diff --git a/dag/gunbc/instrument_targets.dag b/dag/gunbc/instrument_targets.dag
index 848dd53f5fe..48f7034b5ef 100644
--- a/dag/gunbc/instrument_targets.dag
+++ b/dag/gunbc/instrument_targets.dag
@@ -189,6 +189,18 @@ fn primitive_egress_census_seed_label() -> Label {
   Label { package: instruments_package() target: TargetName { name: "primitive-egress-census-seed" } }
 }
 
+// THE REQUIRED-LANE RESOLUTION CENSUS: for every module under the source roots, does at least
+// one required lane RESOLVE it -- hand its source to compile_to_resolved under the Strict gate?
+// The unreached population, by identity, is the printed product; the exit says whether it is
+// empty. This is DESIGN section 3's "a product-layer dependent can stop resolving, stay broken,
+// and let every required lane report SUCCESS" measured rather than warned about, after
+// gunbc.site_pxe_edge_converge did exactly that on 2026-09-20 (gunbc#11607). The lane roster it
+// classifies is read from gunbc.compiler_gate_workflow, the authority that emits witnesses.yml.
+// `gunbc test //gunbc/instruments:required-lane-resolution-census`.
+fn required_lane_resolution_census_label() -> Label {
+  Label { package: instruments_package() target: TargetName { name: "required-lane-resolution-census" } }
+}
+
 // THE INSTRUMENT IS A `TestRule` WITH NO DEPENDENCIES, and both halves are measurements rather
 // than placeholders. It answers a test question — does the heads reading read the same grammar as
 // the full reading — so it is not a `BuildRule`; and it depends on no other target in this graph,
@@ -261,6 +273,10 @@ fn primitive_egress_census_seed_target() -> BuildTarget {
   instrument_test_target(label: primitive_egress_census_seed_label())
 }
 
+fn required_lane_resolution_census_target() -> BuildTarget {
+  instrument_test_target(label: required_lane_resolution_census_label())
+}
+
 fn v2_native_cli_binding() -> TargetBinding {
   TargetBinding { target: v2_native_cli_label() producer: V2NativeCliProducer {} }
 }
@@ -319,6 +335,10 @@ fn primitive_egress_census_seed_binding() -> TargetBinding {
   TargetBinding { target: primitive_egress_census_seed_label() producer: PrimitiveEgressCensusSeedProducer {} }
 }
 
+fn required_lane_resolution_census_binding() -> TargetBinding {
+  TargetBinding { target: required_lane_resolution_census_label() producer: RequiredLaneResolutionCensusProducer {} }
+}
+
 // THE SUBJECT IS THE INSTRUMENT'S OWN FACT, NOT AN ARGUMENT THE CALLER SUPPLIES.
 //
 // `gunbc test //gunbc/instruments:heads-reading-differential` takes no source-root option, and
@@ -382,7 +402,8 @@ fn instrument_targets() -> List<Label> {
     compile_clean_diagnostic_census_label(), self_host_label(), v2_native_cli_label(),
     evaluation_store_address_exact_head_label(), primitive_egress_census_label(),
     primitive_egress_census_v2_label(), primitive_egress_census_dag_label(),
-    primitive_egress_census_seed_label(), floor_memory_qualification_label()
+    primitive_egress_census_seed_label(), floor_memory_qualification_label(),
+    required_lane_resolution_census_label()
   ]
 }
 
@@ -393,7 +414,8 @@ fn instrument_bindings() -> List<TargetBinding> {
     compile_clean_diagnostic_census_binding(), self_host_binding(), v2_native_cli_binding(),
     evaluation_store_address_exact_head_binding(), primitive_egress_census_binding(),
     primitive_egress_census_v2_binding(), primitive_egress_census_dag_binding(),
-    primitive_egress_census_seed_binding(), floor_memory_qualification_binding()
+    primitive_egress_census_seed_binding(), floor_memory_qualification_binding(),
+    required_lane_resolution_census_binding()
   ]
 }
 
diff --git a/dag/gunbc/recurring_failure_mode/a_planted_red_control_positioned_where_it_cannot_fire.dag b/dag/gunbc/recurring_failure_mode/a_planted_red_control_positioned_where_it_cannot_fire.dag
new file mode 100644
index 00000000000..ce398f914e0
--- /dev/null
+++ b/dag/gunbc/recurring_failure_mode/a_planted_red_control_positioned_where_it_cannot_fire.dag
@@ -0,0 +1,26 @@
+module gunbc.recurring_failure_mode.a_planted_red_control_positioned_where_it_cannot_fire
+
+import std.types { NonEmptyStr }
+import gunbc.recurring_failure_mode { RecurringFailureMode }
+
+data a_planted_red_control_positioned_where_it_cannot_fire: RecurringFailureMode = RecurringFailureMode {
+  identity: "a_planted_red_control_positioned_where_it_cannot_fire" as NonEmptyStr,
+
+  receipts: [
+    "**a planted red control positioned where it cannot fire** (an instrument folds a verdict into an accumulator -- `failures=0; for ...; failures=$((failures+1))` -- and the author splices the planted red control ABOVE the line that resets the accumulator, or before the fold's first read, so the control's contribution is discarded before the verdict is taken. The instrument then reports green on the control and on the subject alike, and the control is cited as proof the instrument can go red.",
+
+    "INVALID STATE: a control whose effect on the verdict is unreachable from the position it was planted at -- reset after it, scoped outside the fold, written to a variable the verdict does not read. HARM: the control is the only thing that distinguishes an instrument that measures from one that prints green, so a control that cannot fire converts every later green from that instrument into a decoration cited as coverage (DESIGN section 4b: ask whether the check's RED is authorable before writing the check -- and here it was authored, but could not reach the verdict).",
+
+    "DISCRIMINATOR: trace the data path from the control's plant site to the verdict's read site and find an assignment, reset, `local`, subshell boundary or pipeline stage between them that the control's value does not survive. The positive control ON THE PLANT (the same session's memory carries this as its own rule -- a planted red needs a positive control on the plant): run the instrument with ONLY the control planted and confirm the verdict is red; a control that returns green when it is the only input is not a control.",
+
+    "RECEIPT (2026-09-20, dashboard node adhoc-3bc1b8e0-982): the second of two session evidence instruments that reported green over gunbc.site_pxe_edge_converge not resolving carried a red control spliced above its accumulator reset, so it could only return green; both instruments failed toward green on one defect and the head carried four approvals on that evidence. The drivers were session-authored shell and are not in-tree; no in-tree driver of this shape was found, and the in-tree walls against the sibling shape (a control asserted rather than produced; coverage read per call site rather than per argument) are rostered as their own rows.",
+
+    "REPAIR SHAPE: the control is planted at the subject's own input, downstream of every reset and inside every scope the verdict reads, and the receipt records the red it produced BESIDE the green the subject produced -- two runs, two statuses, or the receipt is one run and one status and establishes nothing about the instrument.",
+
+    "Rung: mitigatable -- the positive control on the plant exposes it when run. Ceiling: mechanically preventable, not structural: a verdict fold whose accumulator is a value threaded through the fold rather than a mutable shell variable has no reset to splice above, and an instrument rendered from a typed fold (gunbc.cli_wire, the claim executor's per-claim outcome rows) cannot be authored in this shape; a session's ad-hoc shell can, and is outside the modeled guarantee.",
+
+    "Next-rung trigger: the manual receipt `gunbc.rung_drop` `required_gate_bankruptcy` obliges every PR to carry while that drop stands names an rc-red control as a required part, and the control is required to be shown red in the same receipt -- a receipt whose control did not print red is refused as a receipt by review, which is the executing consumer of this row until the receipt itself is a typed carrier.",
+  ],
+
+  evidence: [],
+}
diff --git a/dag/gunbc/recurring_failure_mode/exit_status_read_through_a_pipe_reports_the_last_stage.dag b/dag/gunbc/recurring_failure_mode/exit_status_read_through_a_pipe_reports_the_last_stage.dag
new file mode 100644
index 00000000000..cfe34e00c79
--- /dev/null
+++ b/dag/gunbc/recurring_failure_mode/exit_status_read_through_a_pipe_reports_the_last_stage.dag
@@ -0,0 +1,26 @@
+module gunbc.recurring_failure_mode.exit_status_read_through_a_pipe_reports_the_last_stage
+
+import std.types { NonEmptyStr }
+import gunbc.recurring_failure_mode { RecurringFailureMode }
+
+data exit_status_read_through_a_pipe_reports_the_last_stage: RecurringFailureMode = RecurringFailureMode {
+  identity: "exit_status_read_through_a_pipe_reports_the_last_stage" as NonEmptyStr,
+
+  receipts: [
+    "**exit status read through a pipe reports the last stage** (an instrument runs its subject as `subject ... | tail -n 40` or `| grep ...` and then reads `$?`, or lets the pipeline's status be the step's; without `set -o pipefail` a POSIX pipeline's status is the LAST stage's, so a subject that refused with exit 1 or 2 is reported as exit 0 whenever `tail` or `grep` exits 0 -- the instrument fails toward green on the one defect it was run to detect.",
+
+    "INVALID STATE: a shell driver whose verdict is a pipeline status while its subject is not the last stage. HARM: a refusal is read as a pass, so a session posts an exact-head APPROVE, a PR body cites a green receipt, or a lane reports SUCCESS over a subject that refused -- the silent-wrongness column DESIGN section 5 forbids, produced by the evidence instrument itself.",
+
+    "DISCRIMINATOR: the driver's status read (`$?`, `if cmd | filter; then`, a step whose last command is a pipeline) sits AFTER a `|` whose left side is the subject, and no `set -o pipefail` or `PIPESTATUS` read is in scope. The control that must be run before citing such a driver: replace the subject with `false` (or `sh -c 'exit 2'`) and confirm the driver goes red; a driver that stays green over `false | tail` is reading tail's status.",
+
+    "RECEIPT (2026-09-20, dashboard node adhoc-3bc1b8e0-982): one of two session evidence instruments that reported green over gunbc.site_pxe_edge_converge not resolving read its `claim_batch` exit status through `| tail`; the head carried four approvals and reached position 1 in the merge queue on that evidence. The drivers were session-authored shell, not in-tree: a grep of `.githooks`, `tools`, `.github/workflows` and every emitted `run:` line found no in-tree driver reading a subject's status through a filter -- the emitted floor steps set `set -o pipefail` before `| tee` (gunbc.ci_failure_class wrap_command_with_floor_attempt_receipt), and gunbc.live_deploy.intent live_deploy_unit_status_tail_command, the one in-tree `| tail` over a diagnostic subject, is already a marked scaffold whose dissolution trigger names exactly this class (exit code recorded as data, never masked by `| tail`).",
+
+    "REPAIR SHAPE: the subject's status is data, not a side effect of the pipeline -- `set -o pipefail` at minimum; better, run the subject to a file and read its status directly, as the floor wrapper does. A rendered filter that is kept for readability (`tail -40`) is applied to the captured output afterwards, never between the subject and the status read.",
+
+    "Rung: mitigatable -- the class is caught by the red control above when someone runs it. Ceiling: structurally impossible for drivers this repository EMITS, once every emitted step script is rendered from a typed carrier that records the subject's status as data (gunbc.systemctl_status_read is the shape; the floor wrapper is the executing instance). Session-authored shell is outside the modeled guarantee and stays at the red-control rung: the obligation on a manual receipt is that its driver was run against `false` once.",
+
+    "Next-rung trigger: the manual-receipt obligation on `gunbc.rung_drop` `required_gate_bankruptcy` names the rc-red control as a required part of the receipt, so a receipt without it is not a receipt; and the emitted-step carrier gunbc.live_deploy.intent live_deploy_unit_diagnosis_dissolution_trigger names retires the last in-tree instance.",
+  ],
+
+  evidence: [],
+}
diff --git a/dag/gunbc/required_lane_resolution_census.dag b/dag/gunbc/required_lane_resolution_census.dag
new file mode 100644
index 00000000000..67b733b2bec
--- /dev/null
+++ b/dag/gunbc/required_lane_resolution_census.dag
@@ -0,0 +1,135 @@
+module gunbc.required_lane_resolution_census
+
+import std.types { String, Bool, List, Int }
+import v2.std.optional { Optional, Present, Absent }
+
+// FOR EVERY MODULE UNDER THE SOURCE ROOTS, DOES AT LEAST ONE REQUIRED LANE RESOLVE IT?
+//
+// DESIGN section 3 states the hazard as a warning: outside the required gate the substrate still
+// refuses and nothing asks it to, so a product-layer dependent can stop resolving, stay broken,
+// and let every required lane report SUCCESS. On 2026-09-20 it was the live state --
+// gunbc.site_pxe_edge_converge did not resolve on main while all four required lanes were green,
+// with four approvals and a place in the merge queue (gunbc#11607) -- and the question "which
+// modules can do that" had no instrument, only the warning. This module is the instrument's fold:
+// pure, over supplied populations, so its claims discriminate at one interface and its live
+// entry (gunbc.required_lane_resolution_census_live) supplies the populations from the lanes'
+// own producers.
+//
+// "RESOLVE" MEANS ONE THING: the module's source is in the source set the lane's compile
+// transaction hands to compile_to_resolved under the Strict gate. A module named only in a
+// `run:` line's argv is not resolved by that step unless the entry's closure reaches it.
+//
+// NOMINAL, NOT DIFF-SCOPED. The floor also seeds its subject from a run's diff, so a module a PR
+// touches is resolved on THAT run. The population this census reports is the complement of what
+// the lanes resolve when the diff seeds nothing -- exactly the modules a rename elsewhere can
+// break without any lane noticing, which is the incident's shape.
+//
+// IDENTITIES ARE THE PRODUCT. The unreached population is printed by identity and every count in
+// the receipt is rendered from a list the receipt also prints; nothing here is a number to be
+// transcribed into prose (DESIGN section 6: name the instrument).
+
+// One population of module identities as a compiler query answers it, or the typed reason the
+// population could not be established. The live entry's three queries
+// (source_root_ingest_module_identities, required_floor_nominal_subject_module_identities,
+// entry_closure_module_identities) return this; the census refuses on the second arm rather than
+// treating an unestablished population as empty.
+type ModuleIdentityPopulation
+  = ModuleIdentityPopulationObserved { modules: List<String> }
+  | ModuleIdentityPopulationRefused { cause: String }
+
+// WHAT ONE REQUIRED JOB RESOLVES, as a subject kind naming the producer that decides it.
+//   FloorNominalPreparedSubject -- `claim_executor --required-ci --required-lane witnesses`: the
+//     prepared subject over the gate's nominal seeds (v1_compiler.cli_run
+//     required_floor_nominal_subject_seeds, assemble_prepared_subject_closure).
+//   RunEntryClosure -- `gunbc run --entry <path>`: the entry's loader closure
+//     (v1_compiler.cli_run load_sources_for_entry_with_pool, the call resolve_entry_graph makes).
+//   ResolvesNoDagModule -- a job that compiles Rust or aggregates lane results and hands no .dag
+//     source to the compiler; the reason names what it does instead.
+type LaneResolutionSubject
+  = FloorNominalPreparedSubject
+  | RunEntryClosure { entry_path: String }
+  | ResolvesNoDagModule { reason: String }
+
+// One required job and the subjects its steps resolve. A job may carry several (the floor job
+// runs the witness fold AND the drift gate); a job with none is unclassified, which the live
+// entry refuses rather than reading as "resolves nothing".
+type LaneResolutionRow {
+  job_id: String
+  subjects: List<LaneResolutionSubject>
+}
+
+// The resolved population one (job, subject) pair contributed, supplied to the fold.
+type LaneResolvedPopulation {
+  job_id: String
+  subject: LaneResolutionSubject
+  modules: List<String>
+}
+
+type ResolutionCensusInputs {
+  admitted: List<String>
+  resolved: List<LaneResolvedPopulation>
+}
+
+type ResolutionCensus {
+  admitted: List<String>
+  reached: List<String>
+  unreached: List<String>
+  lanes: List<LaneResolvedPopulation>
+}
+
+type ResolutionCensusStanding
+  = ResolutionCensusHeld
+  | ResolutionCensusDidNotHold { unreached: List<String> }
+
+// THE JOIN IS AT IDENTITY GRAIN. Reached is every admitted identity some lane resolved; unreached
+// is the rest, in the admitted order. A resolved identity the ingestion does not admit is not an
+// admitted module and is neither reached nor unreached: the denominator is the ingestion's, not
+// the union's.
+fn resolution_census(inputs: ResolutionCensusInputs) -> ResolutionCensus {
+  let reached_by_any = inputs.resolved |> fold(init: empty_map(), f: fn(acc, lane) {
+    lane.modules |> fold(init: acc, f: fn(m, x) { map_insert(m, x, true) })
+  })
+  let reached = inputs.admitted |> filter(x => map_contains_key(reached_by_any, x))
+  let unreached = inputs.admitted |> filter(x => !map_contains_key(reached_by_any, x))
+  ResolutionCensus { admitted: inputs.admitted, reached: reached, unreached: unreached, lanes: inputs.resolved }
+}
+
+fn resolution_census_standing(c: ResolutionCensus) -> ResolutionCensusStanding {
+  if (c.unreached |> count) == 0 { ResolutionCensusHeld {} } else { ResolutionCensusDidNotHold { unreached: c.unreached } }
+}
+
+fn subject_rendered(s: LaneResolutionSubject) -> String {
+  match s {
+    FloorNominalPreparedSubject => "floor-nominal-prepared-subject"
+    RunEntryClosure { entry_path: p } => concat("run-entry-closure:", p)
+    ResolvesNoDagModule { reason: _ } => "resolves-no-dag-module"
+  }
+}
+
+fn json_string(s: String) -> String {
+  concat(concat("\"", s), "\"")
+}
+
+fn json_string_list(xs: List<String>) -> String {
+  concat(concat("[", xs |> map(x => json_string(s: x)) |> join(separator: ",")), "]")
+}
+
+// THE RECEIPT: one JSON object per line. A summary line whose counts are the lengths of lists
+// printed beneath it; one `lane` line per (job, subject) with the identities it resolved; and one
+// `unreached` line per unreached identity, so the population is greppable by identity and a
+// consumer never has to re-derive it from a count.
+fn census_receipt_lines(c: ResolutionCensus) -> List<String> {
+  let summary = concat(concat(concat(concat(
+    "{\"kind\":\"summary\",\"instrument\":\"required-lane-resolution-census\",\"admitted\":", to_string(c.admitted |> count)),
+    concat(",\"reached\":", to_string(c.reached |> count))),
+    concat(",\"unreached\":", to_string(c.unreached |> count))),
+    concat(",\"lanes\":", concat(to_string(c.lanes |> count), "}")))
+  let lane_lines = c.lanes |> map(l =>
+    concat(concat(concat(concat(concat(concat(
+      "{\"kind\":\"lane\",\"job_id\":", json_string(s: l.job_id)),
+      ",\"subject\":"), json_string(s: subject_rendered(s: l.subject))),
+      ",\"resolved\":"), to_string(l.modules |> count)),
+      concat(",\"modules\":", concat(json_string_list(xs: l.modules), "}"))))
+  let unreached_lines = c.unreached |> map(m => concat(concat("{\"kind\":\"unreached\",\"module\":", json_string(s: m)), "}"))
+  concat(concat([summary], lane_lines), unreached_lines)
+}
diff --git a/dag/gunbc/required_lane_resolution_census_live.dag b/dag/gunbc/required_lane_resolution_census_live.dag
new file mode 100644
index 00000000000..c0c46f78488
--- /dev/null
+++ b/dag/gunbc/required_lane_resolution_census_live.dag
@@ -0,0 +1,175 @@
+module gunbc.required_lane_resolution_census_live
+
+import std.types { String, Bool, List, Int }
+import v2.std.optional { Present, Absent }
+import std.process { ProcessExit, ExitSuccess, ExitFailure }
+import gunbc.cli_wire { CliWireResponse, CliWirePrintable }
+import v2.std.live_tree { LiveTreeDisposition, ReadsLiveTree }
+import extdeps.github.actions { Workflow, Job }
+import gunbc.compiler_gate_workflow {
+  compiler_gate_workflow, compiler_gate_job_id, compiler_gate_clippy_job_id,
+  compiler_gate_floor_job_id, compiler_gate_aggregate_job_id,
+}
+import gunbc.ci_spec { gunbc_ci_heal_verify_target }
+import gunbc.ci_layer_roots { witness_layer_roots }
+import gunbc.required_lane_resolution_census {
+  ModuleIdentityPopulation, ModuleIdentityPopulationObserved, ModuleIdentityPopulationRefused,
+  LaneResolutionSubject, FloorNominalPreparedSubject, RunEntryClosure, ResolvesNoDagModule,
+  LaneResolutionRow, LaneResolvedPopulation, ResolutionCensusInputs, ResolutionCensus,
+  ResolutionCensusStanding, ResolutionCensusHeld, ResolutionCensusDidNotHold,
+  resolution_census, resolution_census_standing, census_receipt_lines,
+}
+
+data live_tree_disposition: LiveTreeDisposition = ReadsLiveTree
+
+// THE LANE ROSTER IS READ FROM THE WORKFLOW THAT EMITS witnesses.yml, AND EVERY JOB THERE MUST
+// CARRY A ROW HERE. The classification is authored -- which producer each job's steps hand
+// sources to is a fact about the step scripts, and reading it out of a rendered `run:` line
+// would be a second parser of a string this repository already generates from typed rows -- but
+// its COVERAGE is checked against the emitted job list: a job the workflow carries and this
+// roster does not is a refusal, never a job read as resolving nothing. The subject rows cite the
+// same declarations the step scripts render from (gunbc.ci.ci_spec gunbc_ci_heal_verify_target
+// for the drift gate's entry; the floor's nominal seeds through the compiler query).
+fn lane_resolution_roster() -> List<LaneResolutionRow> {
+  [
+    LaneResolutionRow {
+      job_id: compiler_gate_job_id,
+      subjects: [ResolvesNoDagModule { reason: "cargo build of the seed's Rust mirrors; no .dag source is handed to the compiler" }]
+    },
+    LaneResolutionRow {
+      job_id: compiler_gate_clippy_job_id,
+      subjects: [ResolvesNoDagModule { reason: "cargo clippy over every Rust target; no .dag source is handed to the compiler" }]
+    },
+    LaneResolutionRow {
+      job_id: compiler_gate_floor_job_id,
+      subjects: [
+        FloorNominalPreparedSubject {},
+        RunEntryClosure { entry_path: gunbc_ci_heal_verify_target.entry }
+      ]
+    },
+    LaneResolutionRow {
+      job_id: compiler_gate_aggregate_job_id,
+      subjects: [ResolvesNoDagModule { reason: "reads the other lanes' conclusions; runs no compiler" }]
+    }
+  ]
+}
+
+fn workflow_job_ids(w: Workflow) -> List<String> {
+  w.jobs |> map(j => j.id)
+}
+
+fn roster_job_ids() -> List<String> {
+  lane_resolution_roster() |> map(r => r.job_id)
+}
+
+// Every emitted job has exactly one roster row; every roster row names an emitted job.
+type RosterCoverage
+  = RosterCovers
+  | RosterMissesJob { job_id: String }
+  | RosterNamesAbsentJob { job_id: String }
+  | RosterDuplicatesJob { job_id: String }
+
+fn count_of(xs: List<String>, x: String) -> Int {
+  xs |> filter(y => y == x) |> count
+}
+
+fn roster_coverage(w: Workflow) -> RosterCoverage {
+  let emitted = workflow_job_ids(w: w)
+  let rostered = roster_job_ids()
+  let missing = emitted |> filter(j => count_of(xs: rostered, x: j) == 0)
+  let absent = rostered |> filter(j => count_of(xs: emitted, x: j) == 0)
+  let duplicated = rostered |> filter(j => count_of(xs: rostered, x: j) > 1)
+  match first(missing) {
+    Present { value: j } => RosterMissesJob { job_id: j }
+    Absent => match first(absent) {
+      Present { value: j } => RosterNamesAbsentJob { job_id: j }
+      Absent => match first(duplicated) {
+        Present { value: j } => RosterDuplicatesJob { job_id: j }
+        Absent => RosterCovers {}
+      }
+    }
+  }
+}
+
+fn roster_coverage_rendered(c: RosterCoverage) -> String {
+  match c {
+    RosterCovers => "covers"
+    RosterMissesJob { job_id: j } => concat("the workflow emits job `", concat(j, "` and the lane resolution roster has no row for it"))
+    RosterNamesAbsentJob { job_id: j } => concat("the lane resolution roster names job `", concat(j, "`, which the workflow does not emit"))
+    RosterDuplicatesJob { job_id: j } => concat("the lane resolution roster names job `", concat(j, "` twice"))
+  }
+}
+
+// THE POPULATION ONE SUBJECT RESOLVES, asked of the lane's own producer through the compiler
+// query that wraps it. A ResolvesNoDagModule subject observes the empty population: that is a
+// true statement about a cargo job, not a refusal.
+fn subject_population(s: LaneResolutionSubject) -> ModuleIdentityPopulation {
+  match s {
+    FloorNominalPreparedSubject => required_floor_nominal_subject_module_identities(witness_layer_roots)
+    RunEntryClosure { entry_path: p } => entry_closure_module_identities(witness_layer_roots, p)
+    ResolvesNoDagModule { reason: _ } => ModuleIdentityPopulationObserved { modules: [] }
+  }
+}
+
+type LivePopulations
+  = LivePopulationsObserved { admitted: List<String>, resolved: List<LaneResolvedPopulation> }
+  | LivePopulationsRefused { cause: String }
+
+// The fold's accumulator is a coproduct rather than rows-plus-optional-cause: a refused subject
+// ends the fold with its cause, and no arm carries a partial row list beside a refusal.
+type ResolvedAcc
+  = ResolvedRows { rows: List<LaneResolvedPopulation> }
+  | ResolvedRefused { cause: String }
+
+fn resolve_subject(acc: ResolvedAcc, job_id: String, s: LaneResolutionSubject) -> ResolvedAcc {
+  match acc {
+    ResolvedRefused { cause: c } => ResolvedRefused { cause: c }
+    ResolvedRows { rows: rows } => match subject_population(s: s) {
+      ModuleIdentityPopulationRefused { cause: c } =>
+        ResolvedRefused { cause: concat(concat(concat("job `", job_id), "`: "), c) }
+      ModuleIdentityPopulationObserved { modules: ms } =>
+        ResolvedRows { rows: list_push(rows, LaneResolvedPopulation { job_id: job_id, subject: s, modules: ms }) }
+    }
+  }
+}
+
+fn resolve_row(acc: ResolvedAcc, row: LaneResolutionRow) -> ResolvedAcc {
+  row.subjects |> fold(init: acc, f: fn(a, s) { resolve_subject(acc: a, job_id: row.job_id, s: s) })
+}
+
+fn live_populations() -> LivePopulations {
+  match roster_coverage(w: compiler_gate_workflow) {
+    RosterCovers => match source_root_ingest_module_identities(witness_layer_roots) {
+      ModuleIdentityPopulationRefused { cause: c } => LivePopulationsRefused { cause: concat("admitted population: ", c) }
+      ModuleIdentityPopulationObserved { modules: admitted } =>
+        match lane_resolution_roster() |> fold(init: ResolvedRows { rows: [] }, f: resolve_row) {
+          ResolvedRefused { cause: c } => LivePopulationsRefused { cause: c }
+          ResolvedRows { rows: rows } => LivePopulationsObserved { admitted: admitted, resolved: rows }
+        }
+    }
+    RosterMissesJob { job_id: j } => LivePopulationsRefused { cause: roster_coverage_rendered(c: RosterMissesJob { job_id: j }) }
+    RosterNamesAbsentJob { job_id: j } => LivePopulationsRefused { cause: roster_coverage_rendered(c: RosterNamesAbsentJob { job_id: j }) }
+    RosterDuplicatesJob { job_id: j } => LivePopulationsRefused { cause: roster_coverage_rendered(c: RosterDuplicatesJob { job_id: j }) }
+  }
+}
+
+// THE INSTRUMENT ENTRY (`gunbc test //gunbc/instruments:required-lane-resolution-census`). Prints
+// the receipt and exits by the census standing: 0 every admitted module is resolved by some
+// required lane; 1 the unreached population is nonempty (printed by identity above the exit);
+// 2 a population could not be established or the roster does not cover the emitted jobs. The
+// receipt is the product on every termination that has one.
+fn required_lane_resolution_census_exit() -> CliWireResponse {
+  match live_populations() {
+    LivePopulationsRefused { cause: c } =>
+      CliWirePrintable { bytes: concat("required-lane-resolution-census: refused: ", concat(c, "\n")), exit: ExitFailure { code: 2, reason: c } }
+    LivePopulationsObserved { admitted: admitted, resolved: resolved } => {
+      let c = resolution_census(inputs: ResolutionCensusInputs { admitted: admitted, resolved: resolved })
+      let bytes = concat(census_receipt_lines(c: c) |> join(separator: "\n"), "\n")
+      match resolution_census_standing(c: c) {
+        ResolutionCensusHeld => CliWirePrintable { bytes: bytes, exit: ExitSuccess }
+        ResolutionCensusDidNotHold { unreached: u } =>
+          CliWirePrintable { bytes: bytes, exit: ExitFailure { code: 1, reason: concat("required-lane-resolution-census: did not hold: ", concat(to_string(u |> count), " admitted modules are resolved by no required lane (listed above by identity)")) } }
+      }
+    }
+  }
+}
diff --git a/dag/gunbc/required_lane_resolution_census_seed_growth.dag b/dag/gunbc/required_lane_resolution_census_seed_growth.dag
new file mode 100644
index 00000000000..4a63078ec1c
--- /dev/null
+++ b/dag/gunbc/required_lane_resolution_census_seed_growth.dag
@@ -0,0 +1,46 @@
+module gunbc.required_lane_resolution_census_seed_growth
+
+import gunbc.roadmap_model { RoadmapNodeId }
+import gunbc.seed_growth { SeedGrowthJustification }
+import std.decl_ref { DeclarationRef, WholeDeclaration }
+
+// FORWARD-FREEZE RECEIPT for the hand Rust that realizes the three compiler queries the
+// required-lane resolution census (gunbc.required_lane_resolution_census_live, `gunbc test
+// //gunbc/instruments:required-lane-resolution-census`) consumes. Same shape and owner as
+// gunbc.primitive_egress_census_seed_growth, whose builtins are this change's precedent.
+//
+// PURPOSE (gunbc.v1_maintenance_standing v1_seed_standing). The census asks, for every module the
+// source-root ingestion admits, whether a required lane hands its source to compile_to_resolved.
+// The three populations are products of the seed's own producers -- the module index, the floor's
+// prepared-subject assembly over its nominal seeds, and the entry loader closure -- and none has a
+// substrate representation a .dag fold could read. A .dag re-derivation of any of them would be a
+// second authority for what the lane prepares, drifting the first time a seed kind or a closure
+// rule changed in the seed and not in the copy (DESIGN section 3); so the census asks the seed.
+//
+// WHAT IS NOT NETTED. The generated dispatch rows in v1_interpreter_dispatch_generated.rs are
+// projections of gunbc.v1.v1_interpreter_primitive_surface; the BuiltinSignature inserts in
+// v1_compiler_infer_method are the mirror of src/v1/04_method.dag; the TargetProducer variant and
+// its registry row in target_invocation_host extend existing rosters. run_cli_wire_census is the
+// generalisation of run_primitive_egress_census (one runner for every instrument whose entry
+// answers a CliWireResponse, parameterised by entry and function) and is enrolled here because
+// this change introduces the name. required_floor_nominal_subject_seeds and
+// required_floor_nominal_closure_module_seeds are EXTRACTED from run_required_floor, not added:
+// the floor now consumes them too, which is what makes the census's reading of the nominal
+// subject the floor's own reading by construction.
+data required_lane_resolution_census_seed_growth_justification: SeedGrowthJustification = SeedGrowthJustification {
+  hand_authored_declarations: [
+    DeclarationRef { module_path: "v1_compiler.cli_run", decl_name: "ModuleIdentityPopulation", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.required_lane_resolution_census", decl_name: "source_root_ingest_module_identities", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.required_lane_resolution_census", decl_name: "required_floor_nominal_subject_module_identities", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.required_lane_resolution_census", decl_name: "entry_closure_module_identities", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.required_floor_runner", decl_name: "RequiredFloorNominalSubjectSeeds", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.required_floor_runner", decl_name: "required_floor_nominal_subject_seeds", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.required_floor_runner", decl_name: "required_floor_nominal_closure_module_seeds", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.v1_interpreter", decl_name: "module_identity_population_value", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.target_invocation_host", decl_name: "run_cli_wire_census", field: WholeDeclaration }
+  ],
+  reason: "The required-lane resolution census asks the seed three population questions it alone can answer: which module identities the source-root ingestion admits (source_root_ingest_module_identities, the producer claim_executor --required-ci prints as admitted-module-identities), which modules the required floor's NOMINAL prepared subject contains (required_floor_nominal_subject_module_identities: the gate's prefix, authored-module, runtime-authority and wet-schedule seeds through assemble_prepared_subject_closure, with no diff seeds, read from the same required_floor_nominal_subject_seeds the floor itself consumes), and which modules a `gunbc run --entry` step's loader closure reaches (entry_closure_module_identities: load_sources_for_entry_with_pool, the call resolve_entry_graph makes). Each answers ModuleIdentityPopulation and refuses with a typed cause rather than an empty list. module_identity_population_value lifts the carrier into interpreter values; run_cli_wire_census is the target_invocation_host runner behind the label. The enrolled instrument is gunbc.required_lane_resolution_census_live required_lane_resolution_census_exit, reached as gunbc test //gunbc/instruments:required-lane-resolution-census.",
+  owning_dissolution_lane: "v1-hand-queue-drain" as RoadmapNodeId,
+  trigger: "Delete these items when the floor exposes its prepared subject and the entry loader its closure as substrate facts a .dag fold can read (the same capability gunbc.primitive_egress_census_seed_growth names for its edge query), or when a required lane resolves every admitted module -- at which point the census's unreached population is empty by construction and the instrument is the regression control that keeps it so.",
+  current_boundary: "Reachable only as .dag free-calls. The queries read the source roots they are given through the process-shared index, assemble the floor's nominal subject read-and-fold only (no strict preparation is paid), load one entry's closure, write nothing, and substitute no value for a refused population."
+}
diff --git a/dag/gunbc/rung_drop/required_lanes_do_not_resolve_product_layer_modules.dag b/dag/gunbc/rung_drop/required_lanes_do_not_resolve_product_layer_modules.dag
new file mode 100644
index 00000000000..c314d36a8e5
--- /dev/null
+++ b/dag/gunbc/rung_drop/required_lanes_do_not_resolve_product_layer_modules.dag
@@ -0,0 +1,60 @@
+module gunbc.rung_drop.required_lanes_do_not_resolve_product_layer_modules
+
+import std.types { NonEmptyStr }
+import gunbc.rung_drop { RungDrop, Standing, TypedDeclaration, LostAsPassenger }
+import gunbc.guarantee_rung { Mitigatable, MechanicallyPreventable }
+
+// WHY THIS IS ITS OWN ROW AND NOT A FOURTH AMENDMENT OF required_gate_bankruptcy. That row's
+// 2026-09-02 amendment named "every module OUTSIDE THE REQUIRED FLOOR GATE CLOSURE" as a member
+// and argued -- correctly, for the state of that day -- that two rows behind one trigger is a
+// fork. What changed on 2026-09-20 is the TRIGGER, not the population. The gate-bankruptcy trigger
+// is a required run whose witness population is derived from the change; a run can satisfy it
+// and still hand no product-layer module's SOURCE to compile_to_resolved, because that trigger is
+// stated over witnesses and this loss is stated over modules. The floor's fourth member was
+// riding on the whole-corpus strict preparation that #11742 and gunbc.compiler_gate_workflow
+// deleted, which is the LostAsPassenger shape: nothing deleted "resolve product-layer modules";
+// the carrier it rode on was cut, and re-adding the witness fold at gate width would not restore
+// it. So this row carries its own trigger, stated at module grain, and the population is
+// enumerated by an instrument rather than transcribed.
+//
+// THE INCIDENT (2026-09-20, dashboard node adhoc-3bc1b8e0-982). gunbc.site_pxe_edge_converge
+// (#11607) did not resolve on main while all four required lanes reported SUCCESS; it carried
+// four approvals and a side-chat exact-head APPROVE and reached position 1 in the merge queue.
+// The same day #11722's witness landed importing names #11675 had renamed,
+// gunbc.fabric_required_build_cell landed passing an Optional from first() into a String
+// parameter, and test.claim.workflow_dispatch_input_witness sat on main not resolving --
+// repaired by #11839 ("two composition breaks the PR gate could not see"). DESIGN section 3's
+// sentence -- a product-layer dependent can stop resolving, stay broken, and let every required
+// lane report SUCCESS -- was the live state, not a warning.
+//
+// THE MANUAL RECEIPT WHILE THIS ROW STANDS. A PR that touches a module in the unreached
+// population, or a declaration such a module consumes, carries in its body: (1) a local
+// claim_batch (or gunbc run) at the EXACT head sha over every unreached module its diff reaches,
+// (2) the sha256 of the binary that produced it, and (3) an rc-red control -- the same driver run
+// over a subject that must refuse (a planted non-resolving fixture or `false`), shown red in the
+// same receipt. A receipt without (3) is a driver that was never shown able to go red; the two
+// instruments that approved #11607's head both lacked it (gunbc.recurring_failure_mode
+// exit_status_read_through_a_pipe_reports_the_last_stage,
+// a_planted_red_control_positioned_where_it_cannot_fire). This obligation is review diligence,
+// not a gate, and the row says so: nothing executes it, which is exactly why it is a drop.
+data required_lanes_do_not_resolve_product_layer_modules: RungDrop = RungDrop {
+  identity: "required_lanes_do_not_resolve_product_layer_modules" as NonEmptyStr,
+
+  subject: "Required lanes do not resolve product-layer modules: a module outside the nominal gate closure and the drift gate's entry closure can stop resolving on main while every required lane reports SUCCESS",
+
+  declared: "2026-09-20",
+
+  standing: Standing,
+
+  declaration: TypedDeclaration {
+    previous: MechanicallyPreventable,
+    temporary: Mitigatable,
+    reason: LostAsPassenger { carrier: "the whole-corpus strict preparation of gunbc.witness_floor_workflow's floor lane, cut by #11742 and replaced by gunbc.compiler_gate_workflow, whose floor job prepares the nominal gate closure (v2.workflow.required_floor required_gate_prefixes plus its seeds) and whose drift gate resolves dag/gunbc/instruments/generated_artifact_gate.dag's entry closure; every other module is reached by no required step" },
+    population: [
+      "every module identity the source-root ingestion admits under dag/ and src/v2/ that is in neither the floor job's nominal prepared subject nor the drift gate's entry closure -- enumerated BY IDENTITY, not by count, by `gunbc test //gunbc/instruments:required-lane-resolution-census` (gunbc.required_lane_resolution_census_live), whose receipt prints one `unreached` line per identity; the snapshot at declaration is docs/rung-drops/required_lanes_do_not_resolve_product_layer_modules_2026-09-20.txt, a receipt of one run and not the authority",
+      "the changed-witness and touched-entry seeds do NOT narrow this population: they resolve a module on the PR that touches it, and the loss is the module nobody touched, broken by a rename in a module it depends on (the #11675 -> #11722 shape)",
+      "the `compiler` and `clippy` jobs hand no .dag source to the compiler and the `witnesses` aggregate runs none; the population is therefore a fact about the `floor` job alone (gunbc.compiler_gate_workflow compiler_gate_floor_job)",
+    ],
+    restoration_trigger: "THE CAPABILITY: on every landing revision, some required lane hands the source of EVERY module the source-root ingestion admits to compile_to_resolved under the Strict gate -- or, equivalently at the grain the incident needs, every module that consumes a declaration the revision changed -- so that a rename or a refusal in any admitted module is a red required lane on the revision that introduces it. The retiring observation is `gunbc test //gunbc/instruments:required-lane-resolution-census` holding (an EMPTY unreached population) against the required workflow as emitted, and the instrument then stays enrolled as the regression control. WHAT DOES NOT RETIRE THIS ROW: widening v2.workflow.required_floor required_gate_prefixes (that moves the population and is priced by the cost receipt); a change-derived WITNESS population on the required path (that retires required_gate_bankruptcy, whose trigger is stated over witnesses, and can fire while this row's population is still nonempty); a job added without operator sign-off (the job roster is closed to growth); or a receipt-only run outside the required path. Adding a required job that resolves every witness root's closure is the construction expected to get here and needs the operator, which is why this drop is declared now rather than that lane being built.",
+  },
+}
diff --git a/dag/gunbc/rung_drop/roster.dag b/dag/gunbc/rung_drop/roster.dag
index d31adde50f9..c7de3750adc 100644
--- a/dag/gunbc/rung_drop/roster.dag
+++ b/dag/gunbc/rung_drop/roster.dag
@@ -42,6 +42,7 @@ import gunbc.rung_drop.text_boundary_identity_wall { text_boundary_identity_wall
 import gunbc.rung_drop.fabric_evidence_gating { fabric_evidence_gating }
 import gunbc.rung_drop.rust_unit_tests_off_the_merge_path { rust_unit_tests_off_the_merge_path }
 import gunbc.rung_drop.witness_floor_off_the_required_gate { witness_floor_off_the_required_gate }
+import gunbc.rung_drop.required_lanes_do_not_resolve_product_layer_modules { required_lanes_do_not_resolve_product_layer_modules }
 import gunbc.rung_drop.emit_copy_qualification_without_a_consumer { emit_copy_qualification_without_a_consumer }
 import gunbc.rung_drop.floor_cost_high_cpu_withheld { floor_cost_high_cpu_withheld }
 import gunbc.rung_drop.spark_role_scoped_retirement_production_root { spark_role_scoped_retirement_production_root }
@@ -114,6 +115,7 @@ data rung_drop_roster: List<RungDrop> = [
   fabric_evidence_gating,
   rust_unit_tests_off_the_merge_path,
   witness_floor_off_the_required_gate,
+  required_lanes_do_not_resolve_product_layer_modules,
   emit_copy_qualification_without_a_consumer,
   floor_cost_high_cpu_withheld,
   spark_role_scoped_retirement_production_root,
diff --git a/dag/gunbc/seed_growth_admission.dag b/dag/gunbc/seed_growth_admission.dag
index ba719992b45..fbc3f171b7a 100644
--- a/dag/gunbc/seed_growth_admission.dag
+++ b/dag/gunbc/seed_growth_admission.dag
@@ -2,6 +2,7 @@ module gunbc.seed_growth_admission
 
 import gunbc.evaluation_store_address_census_seed_growth { evaluation_store_address_census_seed_growth_justification }
 import gunbc.primitive_egress_census_seed_growth { primitive_egress_census_seed_growth_justification }
+import gunbc.required_lane_resolution_census_seed_growth { required_lane_resolution_census_seed_growth_justification }
 import gunbc.persisted_resolved_graph_consumer_test_seed_growth {
   persisted_resolved_graph_format_wall_seed_growth_justification,
   resolved_graph_provider_ctx_reuse_seed_growth_justification
@@ -295,7 +296,8 @@ fn seed_growth_justification_roster() -> List<SeedGrowthJustification> {
     floor_arm_set_consumer_seed_growth_justification,
     scope_rank_view_seed_growth_justification,
     floor_teardown_attribution_seed_growth_justification,
-    primitive_egress_census_seed_growth_justification
+    primitive_egress_census_seed_growth_justification,
+    required_lane_resolution_census_seed_growth_justification
   ]
 }
 
diff --git a/dag/gunbc/target_binding.dag b/dag/gunbc/target_binding.dag
index ac8f74156ad..65ffc59b508 100644
--- a/dag/gunbc/target_binding.dag
+++ b/dag/gunbc/target_binding.dag
@@ -33,6 +33,7 @@ type TargetProducer
   // QUALIFICATION, not a floor verdict, and reusing a differently-named slot for a different fact
   // is the meaning fork DESIGN section 3 forbids.
   | FloorMemoryQualificationProducer
+  | RequiredLaneResolutionCensusProducer
 
 type TargetBinding {
   target: Label
diff --git a/dag/gunbc/v1/v1_interpreter_primitive_surface.dag b/dag/gunbc/v1/v1_interpreter_primitive_surface.dag
index 8b2a1f920e7..cb278a1f32e 100644
--- a/dag/gunbc/v1/v1_interpreter_primitive_surface.dag
+++ b/dag/gunbc/v1/v1_interpreter_primitive_surface.dag
@@ -1316,6 +1316,33 @@ fn v1_interpreter_authored_roster_arms() -> List<InterpreterPrimitiveDispatchArm
       dispatch_emit_site: EvalBuiltinInnerSite,
       enumeration: AuthoredInRoster,
     },
+    InterpreterPrimitiveDispatchArm {
+      arm: InterpreterPrimitiveArmId { identity: "free_call.source_root_ingest_module_identities" },
+      form: FreeCall,
+      authored_spelling: "source_root_ingest_module_identities",
+      realization_module: "v1_interpreter",
+      dispatch_symbol: "eval_builtin_inner",
+      dispatch_emit_site: EvalBuiltinInnerSite,
+      enumeration: AuthoredInRoster,
+    },
+    InterpreterPrimitiveDispatchArm {
+      arm: InterpreterPrimitiveArmId { identity: "free_call.required_floor_nominal_subject_module_identities" },
+      form: FreeCall,
+      authored_spelling: "required_floor_nominal_subject_module_identities",
+      realization_module: "v1_interpreter",
+      dispatch_symbol: "eval_builtin_inner",
+      dispatch_emit_site: EvalBuiltinInnerSite,
+      enumeration: AuthoredInRoster,
+    },
+    InterpreterPrimitiveDispatchArm {
+      arm: InterpreterPrimitiveArmId { identity: "free_call.entry_closure_module_identities" },
+      form: FreeCall,
+      authored_spelling: "entry_closure_module_identities",
+      realization_module: "v1_interpreter",
+      dispatch_symbol: "eval_builtin_inner",
+      dispatch_emit_site: EvalBuiltinInnerSite,
+      enumeration: AuthoredInRoster,
+    },
     InterpreterPrimitiveDispatchArm {
       arm: InterpreterPrimitiveArmId { identity: "free_call.compile_dag_call_form_leaf_guard" },
       form: FreeCall,
diff --git a/dag/std/primitives.dag b/dag/std/primitives.dag
index ec917ef9fcf..f88519027a8 100644
--- a/dag/std/primitives.dag
+++ b/dag/std/primitives.dag
@@ -708,6 +708,9 @@ fn builtin_registry_surface_names() -> List<String> {
     "type_ref_hit_ne_bind_measure_active",
     "builtin_function_registry_keys",
     "compile_dag_primitive_call_edges",
+    "source_root_ingest_module_identities",
+    "required_floor_nominal_subject_module_identities",
+    "entry_closure_module_identities",
   ]
 }
 
diff --git a/dag/test/claim/required_lane_resolution_census_witness_test.dag b/dag/test/claim/required_lane_resolution_census_witness_test.dag
new file mode 100644
index 00000000000..8eca6ed7db2
--- /dev/null
+++ b/dag/test/claim/required_lane_resolution_census_witness_test.dag
@@ -0,0 +1,107 @@
+module test.claim.required_lane_resolution_census_witness
+
+import std.types { String, Bool, List, Int }
+import gunbc.required_lane_resolution_census {
+  ModuleIdentityPopulation, ModuleIdentityPopulationObserved, ModuleIdentityPopulationRefused,
+  LaneResolutionSubject, FloorNominalPreparedSubject, RunEntryClosure, ResolvesNoDagModule,
+  LaneResolvedPopulation, ResolutionCensusInputs, ResolutionCensus,
+  ResolutionCensusStanding, ResolutionCensusHeld, ResolutionCensusDidNotHold,
+  resolution_census, resolution_census_standing, census_receipt_lines,
+}
+
+// THE FOLD DISCRIMINATES AT ONE INTERFACE (DESIGN section 3): admitted and resolved populations
+// are SUPPLIED here, so every claim is about the join and nothing else. The pairing obligation --
+// that the real producers emit these shapes -- is discharged by the two claims at the bottom,
+// which call the compiler queries on a two-module fixture root and on the live workflow's roster.
+
+fn floor_lane(modules: List<String>) -> LaneResolvedPopulation {
+  LaneResolvedPopulation { job_id: "floor", subject: FloorNominalPreparedSubject {}, modules: modules }
+}
+
+fn gate_lane(modules: List<String>) -> LaneResolvedPopulation {
+  LaneResolvedPopulation { job_id: "floor", subject: RunEntryClosure { entry_path: "dag/x.dag" }, modules: modules }
+}
+
+fn cargo_lane() -> LaneResolvedPopulation {
+  LaneResolvedPopulation { job_id: "compiler", subject: ResolvesNoDagModule { reason: "cargo build" }, modules: [] }
+}
+
+fn census_of(admitted: List<String>, resolved: List<LaneResolvedPopulation>) -> ResolutionCensus {
+  resolution_census(inputs: ResolutionCensusInputs { admitted: admitted, resolved: resolved })
+}
+
+fn same_list(a: List<String>, b: List<String>) -> Bool {
+  a == b
+}
+
+// An identity resolved by any lane is reached; the rest are unreached, in admitted order.
+test fn unreached_is_the_admitted_complement_of_the_lane_union() -> Bool {
+  let c = census_of(admitted: ["a", "b", "c", "d"], resolved: [floor_lane(modules: ["a", "b"]), gate_lane(modules: ["b", "c"]), cargo_lane()])
+  same_list(a: c.reached, b: ["a", "b", "c"]) && same_list(a: c.unreached, b: ["d"])
+}
+
+test fn every_admitted_module_resolved_by_some_lane_holds() -> Bool {
+  let c = census_of(admitted: ["a", "b"], resolved: [floor_lane(modules: ["a"]), gate_lane(modules: ["b"])])
+  match resolution_census_standing(c: c) {
+    ResolutionCensusHeld => count(c.unreached) == 0
+    ResolutionCensusDidNotHold { unreached: _ } => false
+  }
+}
+
+// THE RED: lanes that resolve nothing leave every admitted module unreached, and the standing
+// carries the population rather than a count.
+test fn lanes_resolving_nothing_leave_every_admitted_module_unreached() -> Bool {
+  let c = census_of(admitted: ["a", "b", "c"], resolved: [floor_lane(modules: []), cargo_lane()])
+  match resolution_census_standing(c: c) {
+    ResolutionCensusHeld => false
+    ResolutionCensusDidNotHold { unreached: u } => same_list(a: u, b: ["a", "b", "c"])
+  }
+}
+
+// The denominator is the ingestion's: a resolved identity the ingestion does not admit is
+// neither reached nor unreached, and cannot inflate the reached count.
+test fn a_resolved_identity_outside_the_admitted_population_is_not_counted() -> Bool {
+  let c = census_of(admitted: ["a"], resolved: [floor_lane(modules: ["a", "ghost"])])
+  same_list(a: c.reached, b: ["a"]) && count(c.unreached) == 0
+}
+
+// One summary line, one line per lane row, one line per unreached identity -- so the receipt
+// carries the population, not only its size.
+test fn the_receipt_prints_one_line_per_unreached_identity() -> Bool {
+  let c = census_of(admitted: ["a", "b", "c"], resolved: [floor_lane(modules: ["a"]), cargo_lane()])
+  let lines = census_receipt_lines(c: c)
+  count(lines) == 1 + 2 + 2
+    && (lines |> filter(fn(l) { contains(l, "\"kind\":\"unreached\",\"module\":\"b\"") }) |> count) == 1
+    && (lines |> filter(fn(l) { contains(l, "\"kind\":\"unreached\",\"module\":\"c\"") }) |> count) == 1
+    && (lines |> filter(fn(l) { contains(l, "\"kind\":\"unreached\",\"module\":\"a\"") }) |> count) == 0
+    && (lines |> filter(fn(l) { contains(l, "\"kind\":\"summary\"") && contains(l, "\"unreached\":2") }) |> count) == 1
+}
+
+// PAIRING: the entry-closure query on the real producer, over a two-module fixture root whose
+// importer reaches its decoy through an import edge. The closure is exactly those two identities.
+test fn w_entry_closure_query_reaches_the_fixture_importer_and_its_import() -> Bool {
+  match entry_closure_module_identities(["dag/test/fixture/primitive_egress_decoy"], "dag/test/fixture/primitive_egress_decoy/importer.dag") {
+    ModuleIdentityPopulationRefused { cause: _ } => false
+    ModuleIdentityPopulationObserved { modules: ms } =>
+      same_list(a: ms, b: ["test.fixture.primitive_egress_decoy.decoy", "test.fixture.primitive_egress_decoy.importer"])
+  }
+}
+
+// PAIRING, the refusing arm: an entry that does not exist is a typed refusal, never an empty
+// population read as "resolves nothing".
+test fn w_entry_closure_query_refuses_an_absent_entry() -> Bool {
+  match entry_closure_module_identities(["dag/test/fixture/primitive_egress_decoy"], "dag/test/fixture/primitive_egress_decoy/absent.dag") {
+    ModuleIdentityPopulationRefused { cause: _ } => true
+    ModuleIdentityPopulationObserved { modules: _ } => false
+  }
+}
+
+// PAIRING: the admitted-population query over the same fixture root admits exactly its two
+// module identities.
+test fn w_source_root_ingest_query_admits_the_fixture_modules() -> Bool {
+  match source_root_ingest_module_identities(["dag/test/fixture/primitive_egress_decoy"]) {
+    ModuleIdentityPopulationRefused { cause: _ } => false
+    ModuleIdentityPopulationObserved { modules: ms } =>
+      same_list(a: ms, b: ["test.fixture.primitive_egress_decoy.decoy", "test.fixture.primitive_egress_decoy.importer"])
+  }
+}
diff --git a/dag/test/claim/target_invocation_witness_test.dag b/dag/test/claim/target_invocation_witness_test.dag
index 2ddd6d9f231..1025b15e847 100644
--- a/dag/test/claim/target_invocation_witness_test.dag
+++ b/dag/test/claim/target_invocation_witness_test.dag
@@ -18,6 +18,7 @@ import gunbc.target_binding {
   EvaluationStoreAddressExactHeadProducer,
   PrimitiveEgressCensusProducer,
   PrimitiveEgressCensusV2Producer,
+  RequiredLaneResolutionCensusProducer,
   CompileCleanDiagnosticCensusStanding, CompileCleanDiagnosticCensusCompleted,
   CompileCleanDiagnosticCensusRefused, CompileCleanDiagnosticCensusObservation,
   CompileCleanDiagnosticCensusIdentity,
@@ -53,6 +54,7 @@ import gunbc.instrument_targets {
   evaluation_store_address_exact_head_label,
   primitive_egress_census_label,
   primitive_egress_census_v2_label,
+  required_lane_resolution_census_label,
   compile_clean_diagnostic_census_termination,
   compile_clean_diagnostic_census_standing_rendered,
   instrument_targets, instrument_bindings,
@@ -650,3 +652,15 @@ test fn the_canonicality_cause_reaches_the_rendered_refusal() -> Bool {
       }
   }
 }
+
+// The required-lane resolution census is its own label bound to its own producer, on the same
+// seam as its siblings: a regression in it is reported under a name that says which instrument.
+test fn the_required_lane_resolution_census_operand_routes_to_its_own_producer() -> Bool {
+  match invoke_target(operand: "//gunbc/instruments:required-lane-resolution-census") {
+    TargetInvocationRouted { binding: b } =>
+      label_eq(a: b.target, b: required_lane_resolution_census_label())
+        && (b.producer == RequiredLaneResolutionCensusProducer {})
+        && !(b.producer == PrimitiveEgressCensusV2Producer {})
+    TargetInvocationRouteRefused { cause: _ } => false
+  }
+}
diff --git a/docs/design-rung-drops.md b/docs/design-rung-drops.md
index c4a6bfe928d..aaa214df2fa 100644
--- a/docs/design-rung-drops.md
+++ b/docs/design-rung-drops.md
@@ -136,6 +136,10 @@ CORRECTION NOTICE, recorded because the wrong version travelled: an earlier revi
 
 The witness floor as a required merge gate: RUNG DROP, mechanically preventable -> mitigatable (deleted without replacement). Population: the whole enrolled witness population (4185 claims executed on the last measured run 35462055101) rather than a named subset of it, the namespace-wave-admission phase -- the refusal that catches a consumed transition-admission row, the generated-artifact phase -- the refusal that catches a committed projection diverging from its authority, the regen fixed-point phase, the parse sweep over every authored root. Restored when: THE CAPABILITY: the required gate again plans and executes the enrolled witness population on the revision that lands, at a cost the fleet can carry. gunbc.compiler_gate_workflow's header names the construction expected to get there -- the fold's preparation cost cut, by reusing resolved-module and reach-probe results across runs or by scoping preparation to a diff's closure -- and the MEASUREMENT that makes this the right target is that the claims were never the cost: on run 35462055101 the 4185 claims executed in 53 seconds while strict-preparation of 3197 modules took 14.3 minutes, reach probes 11 minutes, and parse, admission and bookkeeping the rest. WHAT DOES NOT RETIRE THIS ROW, stated because each is the likely mistake: re-emitting witnesses.yml from gunbc.witness_floor_workflow without the preparation repair, which restores the cost that caused the cut; a faster floor that still does not run on the merge path; and deleting gunbc.compiler_gate_workflow, which removes the stopgap rather than restoring the gate. The row retires on an OBSERVED required run that planned and executed the population on a landing revision, not on an emission.
 
+### Required lanes do not resolve product-layer modules: a module outside the nominal gate closure and the drift gate's entry closure can stop resolving on main while every required lane reports SUCCESS — declared 2026-09-20
+
+Required lanes do not resolve product-layer modules: a module outside the nominal gate closure and the drift gate's entry closure can stop resolving on main while every required lane reports SUCCESS: RUNG DROP, mechanically preventable -> mitigatable (lost as a passenger of the whole-corpus strict preparation of gunbc.witness_floor_workflow's floor lane, cut by #11742 and replaced by gunbc.compiler_gate_workflow, whose floor job prepares the nominal gate closure (v2.workflow.required_floor required_gate_prefixes plus its seeds) and whose drift gate resolves dag/gunbc/instruments/generated_artifact_gate.dag's entry closure; every other module is reached by no required step). Population: every module identity the source-root ingestion admits under dag/ and src/v2/ that is in neither the floor job's nominal prepared subject nor the drift gate's entry closure -- enumerated BY IDENTITY, not by count, by `gunbc test //gunbc/instruments:required-lane-resolution-census` (gunbc.required_lane_resolution_census_live), whose receipt prints one `unreached` line per identity; the snapshot at declaration is docs/rung-drops/required_lanes_do_not_resolve_product_layer_modules_2026-09-20.txt, a receipt of one run and not the authority, the changed-witness and touched-entry seeds do NOT narrow this population: they resolve a module on the PR that touches it, and the loss is the module nobody touched, broken by a rename in a module it depends on (the #11675 -> #11722 shape), the `compiler` and `clippy` jobs hand no .dag source to the compiler and the `witnesses` aggregate runs none; the population is therefore a fact about the `floor` job alone (gunbc.compiler_gate_workflow compiler_gate_floor_job). Restored when: THE CAPABILITY: on every landing revision, some required lane hands the source of EVERY module the source-root ingestion admits to compile_to_resolved under the Strict gate -- or, equivalently at the grain the incident needs, every module that consumes a declaration the revision changed -- so that a rename or a refusal in any admitted module is a red required lane on the revision that introduces it. The retiring observation is `gunbc test //gunbc/instruments:required-lane-resolution-census` holding (an EMPTY unreached population) against the required workflow as emitted, and the instrument then stays enrolled as the regression control. WHAT DOES NOT RETIRE THIS ROW: widening v2.workflow.required_floor required_gate_prefixes (that moves the population and is priced by the cost receipt); a change-derived WITNESS population on the required path (that retires required_gate_bankruptcy, whose trigger is stated over witnesses, and can fire while this row's population is still nonempty); a job added without operator sign-off (the job roster is closed to growth); or a receipt-only run outside the required path. Adding a required job that resolves every witness root's closure is the construction expected to get here and needs the operator, which is why this drop is declared now rather than that lane being built.
+
 ### The EMIT-COST-QUAL-0 wet battery's only sanctioned executing consumer — declared 2026-09-04
 
 **THE EMIT-COST-QUAL-0 BATTERY LOSES ITS ONLY SANCTIONED CONSUMER (2026-09-04).** `emit-copy-qualification-battery` shipped with `if_condition: "false"` under the ROOT-N division ruling of 2026-08-31, holding one activation token for the #9769 chain. The 2026-09-04 runner-capacity ruling spent that token on DELETION rather than activation: the job is removed from `gunbc.witness_floor_workflow` instead of having its `"false"` lifted. PREVIOUS RUNG: none was held — the job never executed, so the honest previous state is the declared standing that it WOULD execute on activation, with its `claim_batch --functions` line named as `gunbc.emit_copy_qualification_wet_battery`'s only sanctioned consumer. TEMPORARY RUNG: outside the modeled guarantee, which is deliberately not a rung — the battery's wet shards and its five instrument-falsifier mutants are now specification without execution in the sense DESIGN §5 names, and no row in `test.claim.emit_copy_qualification_witness_test` establishes anything about a running system. REASON: the job cost a roster slot and a permanently-skipped entry in the emitted workflow while establishing nothing, and under a runner shortage the cheapest honest disposition of a lane that has never run is to delete it rather than to keep holding a slot for it. Note what this did NOT save, because the opposite would be an inflated claim: the job was skipped, so it consumed no runner time and the deletion buys no capacity. What it buys is a roster that means what it says. BOUNDED POPULATION: `gunbc.emit_copy_qualification_wet_battery` — the six wet carrier shards and six calibration rows named in the deleted argv — plus the three workflow-subject rows removed from its witness file. `gunbc.emit_copy_qualification`, `gunbc.emit_copy_qualification_fixture_gen` and `tools.emit_copy_qualification_transport` keep whatever consumers they had; this row does not speak for them. COUNTABLE: `test.claim.witness_floor_workflow_consolidation_witness_test` `w_RED_the_deleted_lanes_do_not_return` reds if the job returns. RESTORATION TRIGGER, at capability grain: the battery's assertions EXECUTING on the real acceptance path as floor-enrolled `*_test.dag` witnesses — which is the same conversion the deleted job's own dissolution row demanded and never got, now with nothing else holding the module up. The blocker it named is real and unchanged: `v2.workflow.floor_changed_witness` refuses a changed witness identity with no terminal floor verdict, and these wet transactions route-gap hermetically (`IsExecutable`, `NoMockResponse`), so the trigger is the capability to give a hermetically route-gapped wet transaction a terminal floor verdict. RE-ADDING A JOB DOES NOT SATISFY IT and now requires operator sign-off besides; a battery that can only be executed by a lane nobody will fund is the state this row records, not the repair.
diff --git a/docs/rung-drops/required_lanes_do_not_resolve_product_layer_modules_2026-09-20.txt b/docs/rung-drops/required_lanes_do_not_resolve_product_layer_modules_2026-09-20.txt
new file mode 100644
index 00000000000..137a859eb26
--- /dev/null
+++ b/docs/rung-drops/required_lanes_do_not_resolve_product_layer_modules_2026-09-20.txt
@@ -0,0 +1,4282 @@
+# Snapshot receipt of ONE run of the instrument, not the authority. Re-derive with:
+#   gunbc test //gunbc/instruments:required-lane-resolution-census
+# rung drop: gunbc.rung_drop.required_lanes_do_not_resolve_product_layer_modules
+# tree: session/sleek-bat-381 at 3dff8c5a5268b47c6f99c16449c8108c7fb2fa85 (worktree carried the uncommitted census_live accumulator fix committed next; dag/gunbc and src/v2 populations identical), merged with main 5bab0b1c31ff50cd94afb759dad3c2f1f84b3710
+# binary: target/release/gunbc sha256 b7d9ecf8f54629ffc238ca13a67c095e7c4da5a530ef99c8312e7d5fd9911042, exit 1 (did not hold)
+# {"kind":"summary","instrument":"required-lane-resolution-census","admitted":6292,"reached":2022,"unreached":4270,"lanes":5}
+# {"kind":"lane","job_id":"compiler","subject":"resolves-no-dag-module","resolved":0}
+# {"kind":"lane","job_id":"clippy","subject":"resolves-no-dag-module","resolved":0}
+# {"kind":"lane","job_id":"floor","subject":"floor-nominal-prepared-subject","resolved":1900}
+# {"kind":"lane","job_id":"floor","subject":"run-entry-closure:dag/gunbc/instruments/generated_artifact_gate.dag","resolved":1727}
+# {"kind":"lane","job_id":"witnesses","subject":"resolves-no-dag-module","resolved":0}
+# one admitted module identity per line, resolved by no required lane on the required workflow as emitted (gunbc.compiler_gate_workflow):
+bisect.add
+bisect.subject
+ctl.pos_emit
+ctl.pos_emit2
+ctl.pos_service
+dag.test.claim.lifecycle_survivor_corpus_census
+dag.test.claim.lifecycle_survivor_scan_witness
+dag.test.claim.offline_local_recipe_witness
+dag.test.claim.witness_deferral_freeze_witness
+direct_rust_door_ingest_fixture
+examples.blackjack.cards
+examples.blackjack.hand
+examples.blackjack.round
+examples.blackjack.shuffle
+examples.blackjack.simulation
+examples.weather
+extdeps.access.aws_iam
+extdeps.access.rbac
+extdeps.access.zanzibar
+extdeps.advertising.google_ads
+extdeps.advertising.meta_ads
+extdeps.advertising.types
+extdeps.ampere.mt_collins_1u_product_brief.specifications
+extdeps.ampere.mt_collins_1u_product_brief.subject
+extdeps.ampere.mt_collins_2u_user_guide.subject
+extdeps.ampere.mt_collins_product_brief.bmc
+extdeps.ampere.mt_collins_product_brief.platform
+extdeps.ampere.mt_jade_getting_started_guide.chassis
+extdeps.ampere.mt_jade_getting_started_guide.memory_population
+extdeps.ampere.mt_jade_getting_started_guide.subject
+extdeps.ampere.oem_sel
+extdeps.ampere.scp_diagnostic
+extdeps.astronomy.stellar_classification
+extdeps.audit.cloudevents
+extdeps.automation.playwright
+extdeps.backblaze.b2
+extdeps.bazel.bazel
+extdeps.bazel.build_event_stream
+extdeps.bazel.label
+extdeps.bazel.target_pattern
+extdeps.bazel.test_status
+extdeps.bmc.access
+extdeps.bmc.aspeed_ast2500
+extdeps.bmc.mock_corpus
+extdeps.bmc.openbmc_fan_control
+extdeps.bmc.openbmc_operation
+extdeps.bmc.openbmc_password_ssh_transport
+extdeps.bmc.pid_control_decode
+extdeps.bmc.pid_control_program
+extdeps.bmc.pid_control_representability
+extdeps.bmc.pid_control_semantic_identity
+extdeps.bmc.serial_console
+extdeps.boards.gigabyte
+extdeps.boards.supermicro
+extdeps.bonterms.cloud_terms
+extdeps.boot.emit
+extdeps.boot.framebuffer
+extdeps.boot.freestanding_payload
+extdeps.boot.freestanding_witness
+extdeps.boot.linux_x86_boot
+extdeps.bootloader.grub
+extdeps.browser
+extdeps.browser.chromium
+extdeps.browser.google_chrome
+extdeps.cache.key_completeness
+extdeps.cache.pin
+extdeps.cadquery.cadquery
+extdeps.ci_runner.actuated
+extdeps.ci_runner.aws_codebuild
+extdeps.ci_runner.blacksmith
+extdeps.ci_runner.buildjet
+extdeps.ci_runner.buildkite
+extdeps.ci_runner.circleci
+extdeps.ci_runner.cirrus_runners
+extdeps.ci_runner.depot
+extdeps.ci_runner.github_actions
+extdeps.ci_runner.gitlab
+extdeps.ci_runner.google_cloud_build
+extdeps.ci_runner.namespace
+extdeps.ci_runner.runs_on
+extdeps.ci_runner.semaphore
+extdeps.ci_runner.sprinters
+extdeps.ci_runner.warpbuild
+extdeps.climbing_holds.atomik
+extdeps.clock.ti_cdce913
+extdeps.cloud.cloud
+extdeps.cloud.gcp.adc_document
+extdeps.cloud.gcp.iam_admin
+extdeps.cloud.gcp.mock_corpus
+extdeps.cloud.gcp.rate_limits
+extdeps.cloud.gcp.storage
+extdeps.cloud.gcp.sts
+extdeps.cloud.hetzner
+extdeps.cloud_init.cloud_init
+extdeps.colo.centersquare
+extdeps.colo.colocation_america
+extdeps.colo.continuity_centers
+extdeps.colo.coresite
+extdeps.colo.critical_systems_realty
+extdeps.colo.databank
+extdeps.colo.dataverge
+extdeps.colo.digital_fortress
+extdeps.colo.digital_realty
+extdeps.colo.equinix
+extdeps.colo.evocative
+extdeps.colo.five_9s_digital
+extdeps.colo.flexential
+extdeps.colo.h5
+extdeps.colo.halsey_165
+extdeps.colo.hivelocity
+extdeps.colo.interserver
+extdeps.colo.iron_mountain
+extdeps.colo.lightwave_networks
+extdeps.colo.long_island_interconnect
+extdeps.colo.lumen
+extdeps.colo.natcoweb
+extdeps.colo.netrality
+extdeps.colo.njfx
+extdeps.colo.nyi
+extdeps.colo.qts
+extdeps.colo.sabey
+extdeps.colo.stafford_associates
+extdeps.colo.summit
+extdeps.colo.telehouse
+extdeps.colo.three_sixty_five
+extdeps.colo.tierpoint
+extdeps.colo.types
+extdeps.colo.vastnet
+extdeps.common_paper.cloud_service_agreement
+extdeps.communication.numerical_fidelity
+extdeps.connector.samtec_ftsh_105_01_l_dv
+extdeps.container.oci.ctrl_session_witness
+extdeps.container.oci.distribution
+extdeps.container.oci.linux
+extdeps.container.oci.runtime_config
+extdeps.cpu.amd
+extdeps.cpu.ampere_altra_memory_controller
+extdeps.cpu.ampere_altra_package
+extdeps.cpu.ampere_altra_package_contact_map
+extdeps.cpu.ampere_altra_package_contacts
+extdeps.cpu.ampere_altra_package_table4_raw
+extdeps.cpu.ampere_altra_platform_hw_design.platform
+extdeps.cpu.ampere_altra_platform_hw_design.subject
+extdeps.cpu.machine_shape
+extdeps.cpu_attachment.ilm4926
+extdeps.cpu_attachment.lotes_azifa072
+extdeps.crm.hubspot_lifecycle
+extdeps.crm.salesforce_opportunity
+extdeps.cron.mock_corpus
+extdeps.currency.ecb_reference_rate
+extdeps.darwin.rusage
+extdeps.darwin.sysctl
+extdeps.diagnostic.mock_corpus
+extdeps.docker.container_stats
+extdeps.docker.distribution_manifest
+extdeps.docker.hub
+extdeps.dpkg
+extdeps.ebay.browse
+extdeps.ebay.ebay
+extdeps.ebay.ebay_contracts
+extdeps.ebay.errors
+extdeps.ebay.inventory
+extdeps.ebay.marketplace_account_deletion
+extdeps.ebay.mock_corpus
+extdeps.ebay.oauth
+extdeps.ebay.rate_limits
+extdeps.energy.con_edison
+extdeps.energy.nj_electricity
+extdeps.exec.xargs
+extdeps.exec_format
+extdeps.fans.dynatron
+extdeps.fans.noctua
+extdeps.filesystem.mock_corpus
+extdeps.filesystem.ntfs
+extdeps.filesystem.posix
+extdeps.firmware.ipxe
+extdeps.firmware.kernel_cmdline
+extdeps.firmware.megarac.subject
+extdeps.firmware.openbmc.subject
+extdeps.firmware.trusted_firmware_a.subject
+extdeps.firmware.uefi_http_boot
+extdeps.firmware.uefi_shell
+extdeps.fixture.external_authority_file_anchor
+extdeps.fixture.external_authority_missing
+extdeps.formats.dnsmasq
+extdeps.formats.elf.encode
+extdeps.formats.elf.hello_static_witness
+extdeps.formats.elf.primitives
+extdeps.formats.elf.relocation
+extdeps.formats.elf.sections
+extdeps.formats.elf.segments
+extdeps.formats.elf.types
+extdeps.git.mock_corpus
+extdeps.git.versioning
+extdeps.github.actions_jit_runner
+extdeps.github.actions_runs
+extdeps.github.actions_token
+extdeps.github.auth
+extdeps.github.ci
+extdeps.github.code_search
+extdeps.github.gists
+extdeps.github.issues
+extdeps.github.merge_state
+extdeps.github.merge_state_contracts
+extdeps.github.mergeable_state
+extdeps.github.mergeable_state_contracts
+extdeps.github.mock_corpus
+extdeps.github.repository_contents
+extdeps.github.rulesets
+extdeps.github.users
+extdeps.github.workflows
+extdeps.gitignore
+extdeps.go
+extdeps.google.drive
+extdeps.google.sheets_mock_corpus
+extdeps.gpu.apple
+extdeps.gpu.machine_shape
+extdeps.gpu.nvidia
+extdeps.gunb_ai.frontend
+extdeps.iana.time_zone_database
+extdeps.ietf.ftps
+extdeps.ietf.language_tag
+extdeps.instrument.fs_box_v3_v4_v5_faq
+extdeps.instrument.fs_box_v4
+extdeps.instrument.pip_boy_3000
+extdeps.instrument.pip_boy_3000_mk_v
+extdeps.ipc.dpmx
+extdeps.iproute2.ip_neigh
+extdeps.iso.iso_273
+extdeps.iso.iso_286
+extdeps.land_pattern.types
+extdeps.languages.bash.subject
+extdeps.languages.c.emit
+extdeps.languages.c.subject
+extdeps.languages.cpp.subject
+extdeps.languages.css.subject
+extdeps.languages.dag.emit
+extdeps.languages.dag.syntax
+extdeps.languages.dag.types
+extdeps.languages.ecmascript.subject
+extdeps.languages.go.emit
+extdeps.languages.go.module
+extdeps.languages.go.primitives
+extdeps.languages.go.subject
+extdeps.languages.go.syntax
+extdeps.languages.go.types
+extdeps.languages.gpu.wgsl.kernel
+extdeps.languages.html.subject
+extdeps.languages.java.subject
+extdeps.languages.json.member_conservation
+extdeps.languages.json.subject
+extdeps.languages.jsx.subject
+extdeps.languages.kotlin.subject
+extdeps.languages.lean.overflow
+extdeps.languages.lean.subject
+extdeps.languages.llvm_ir.subject
+extdeps.languages.markdown.subject
+extdeps.languages.ptx.subject
+extdeps.languages.python.emit
+extdeps.languages.python.primitives
+extdeps.languages.python.syntax
+extdeps.languages.python.types
+extdeps.languages.react_jsx
+extdeps.languages.riscv.subject
+extdeps.languages.rust.derive_contracts
+extdeps.languages.rust.primitives
+extdeps.languages.rust.representation
+extdeps.languages.rust.subject
+extdeps.languages.rust.types
+extdeps.languages.simd.kernel
+extdeps.languages.spice.subject
+extdeps.languages.swift.subject
+extdeps.languages.typescript.emit
+extdeps.languages.typescript.primitives
+extdeps.languages.typescript.subject
+extdeps.languages.typescript.syntax
+extdeps.languages.typescript.types
+extdeps.languages.verilog.subject
+extdeps.languages.wasm.subject
+extdeps.languages.yaml.subject
+extdeps.linux.cgroup_v2_memory
+extdeps.linux.mlx5_core
+extdeps.linux.mock_corpus
+extdeps.linux.neighbour
+extdeps.linux.proc_meminfo
+extdeps.linux.rusage
+extdeps.linux.usb_gadget
+extdeps.llm.anthropic
+extdeps.llm.anthropic_contracts
+extdeps.llm.anthropic_errors
+extdeps.llm.anthropic_rest
+extdeps.llm.claude_agent_sdk_stream
+extdeps.llm.claude_sdk
+extdeps.llm.claude_setup_token_cli
+extdeps.llm.cursor_sdk
+extdeps.llm.cursor_sdk_errors
+extdeps.llm.cursor_sdk_facts
+extdeps.llm.cursor_stream
+extdeps.llm.llm
+extdeps.llm.mock_corpus
+extdeps.llm.openai_errors
+extdeps.llm.openai_rest
+extdeps.memory.cisco_ucs
+extdeps.memory.jedec
+extdeps.memory.macronix_mx25l25673g
+extdeps.memory.microchip_at24cm02
+extdeps.memory.te_ddr4_dimm_socket
+extdeps.mercurial
+extdeps.moonshot.kimi_code
+extdeps.needrestart
+extdeps.network.arista_7050s_52
+extdeps.network.dell_0r887v
+extdeps.network.ibm_01ft753
+extdeps.network.link_duplex
+extdeps.network.mac
+extdeps.network.mcx4121a_acat
+extdeps.network.mcx4411a_acan
+extdeps.network.mcx4421a_acan
+extdeps.network.mcx4621a_acab
+extdeps.network.mikrotik_crs812
+extdeps.network.ti_dp83867
+extdeps.nftables.ruleset
+extdeps.node
+extdeps.oasis.mqtt
+extdeps.observability
+extdeps.ocp.mt_jade.platform
+extdeps.ocp.mt_mitchell.platform
+extdeps.ocp.mt_mitchell.subject
+extdeps.ollama.capability
+extdeps.ollama.gpu_support
+extdeps.ollama.model_store
+extdeps.ollama.server_env
+extdeps.opencascade.ocp
+extdeps.os.debian
+extdeps.os.ubuntu_kernel_nic_coverage
+extdeps.package_managers.conda_forge
+extdeps.package_managers.pip
+extdeps.payroll.contribution
+extdeps.physics.bach_et_al_2013_double_slit
+extdeps.physics.chapman_et_al_1995_atom_interferometer_which_path
+extdeps.pijul
+extdeps.posix.locale
+extdeps.posix.rusage
+extdeps.posix.signal
+extdeps.power.ti_tps3808
+extdeps.power.ti_tps53688
+extdeps.pricing.aws_ec2
+extdeps.pricing.billing_units
+extdeps.pricing.github_actions
+extdeps.pricing.gitlab_subscription
+extdeps.pricing.hetzner_dedicated
+extdeps.pricing.object_storage
+extdeps.pricing.regional_compute
+extdeps.pricing.ubicloud
+extdeps.printing.bambu_lab_ams_lite
+extdeps.printing.bambu_lab_lan_protocol
+extdeps.printing.bambu_studio
+extdeps.printing.orca_slicer
+extdeps.probes.provider_interface_acquisition
+extdeps.programmable_logic.ice40.configuration
+extdeps.programmable_logic.ice40.subject
+extdeps.programmable_logic.ice40.supply
+extdeps.project_schedule.cpm_pert
+extdeps.provisioning.ubuntu_seeded_install_media_toolchain
+extdeps.realestate.nj_industrial
+extdeps.realization.artifact_store_fs
+extdeps.realization.cache_purity
+extdeps.realization.emit_on_demand_host
+extdeps.realization.eval_memo
+extdeps.realization.frame_boundary_simulated
+extdeps.realization.hermetic_fixture
+extdeps.realization.native_artifact_cache
+extdeps.realization.v1_handler
+extdeps.render.ansi
+extdeps.render.glyph
+extdeps.render.glyphs
+extdeps.render.surface
+extdeps.render.terminal
+extdeps.render.terminal_capability
+extdeps.render.tier_glyphs
+extdeps.runtime.api.darwin
+extdeps.runtime.api.windows
+extdeps.runtime.architecture.aarch64_linux
+extdeps.runtime.local
+extdeps.sec.edgar
+extdeps.sec.edgar_rest
+extdeps.sec.facts
+extdeps.sec.issuer.atlassian
+extdeps.sec.issuer.atlassian_facts
+extdeps.sec.issuer.chemed
+extdeps.sec.issuer.chemed_facts
+extdeps.sec.issuer.gitlab
+extdeps.sec.issuer.gitlab_facts
+extdeps.sec.issuer.microsoft
+extdeps.sec.issuer.microsoft_facts
+extdeps.sec.issuer.rollins
+extdeps.sec.issuer.rollins_facts
+extdeps.sec.mock_corpus
+extdeps.sec.operating_metrics
+extdeps.sec.types
+extdeps.sec.us_gaap
+extdeps.shell.mock_corpus
+extdeps.simulators.icarus_verilog.subject
+extdeps.simulators.ngspice.subject
+extdeps.sql.migration
+extdeps.ssh.mock_corpus
+extdeps.ssh.openssh_port_forwarding
+extdeps.standards.atx_2_2
+extdeps.standards.ieee_754_2019
+extdeps.standards.nic_attachment
+extdeps.standards.ocp_nic_2_0
+extdeps.standards.ocp_nic_3_0
+extdeps.standards.rfc_8118
+extdeps.standards.web_annotation
+extdeps.storage.amphenol_mdt420m01001
+extdeps.storage.nbd
+extdeps.storage.te_m2_ngff_connector
+extdeps.systemd.journalctl
+extdeps.systems.nvidia_dgx_spark_pxe
+extdeps.tailscale.acl
+extdeps.tailscale.acl_api
+extdeps.tax.new_jersey_sales_and_use
+extdeps.tax.new_york_city_sales_and_use
+extdeps.tax.statutory_rate
+extdeps.tax.us_irs_fica
+extdeps.tcgplayer.catalog
+extdeps.tcgplayer.mock_corpus
+extdeps.tcgplayer.pricing
+extdeps.tcgplayer.store
+extdeps.tcgplayer.tcgplayer
+extdeps.test.http_pilot
+extdeps.test.mock_corpus
+extdeps.toolchain.icestorm.subject
+extdeps.tools.busybox
+extdeps.tools.conntrack
+extdeps.tools.diffutils
+extdeps.tools.e2fsprogs
+extdeps.tools.free
+extdeps.tools.gnu_time
+extdeps.tools.make
+extdeps.tools.mosquitto_pub
+extdeps.tools.pin
+extdeps.tools.squashfs_tools
+extdeps.tools.tar
+extdeps.tools.wc
+extdeps.transceiver.fs_145681
+extdeps.transports.fidelity
+extdeps.transports.file
+extdeps.transports.sql
+extdeps.typescript
+extdeps.ucamco.gerber
+extdeps.unicode.blocks
+extdeps.unicode.display
+extdeps.vendor.alphabet
+extdeps.vendor.amphenol
+extdeps.vendor.apple
+extdeps.vendor.arista
+extdeps.vendor.arm
+extdeps.vendor.aspeed
+extdeps.vendor.atlassian
+extdeps.vendor.atomik
+extdeps.vendor.chemed
+extdeps.vendor.cisco
+extdeps.vendor.gigabyte
+extdeps.vendor.gitlab
+extdeps.vendor.hubspot
+extdeps.vendor.intel
+extdeps.vendor.lattice_semiconductor
+extdeps.vendor.lotes
+extdeps.vendor.macronix
+extdeps.vendor.meta_platforms
+extdeps.vendor.microchip_technology
+extdeps.vendor.microsoft
+extdeps.vendor.mikrotik
+extdeps.vendor.noctua
+extdeps.vendor.qualcomm
+extdeps.vendor.rollins
+extdeps.vendor.salesforce
+extdeps.vendor.samtec
+extdeps.vendor.texas_instruments
+extdeps.vendor.the_wand_company
+extdeps.vendor.tyco_electronics
+extdeps.vendor.tyco_electronics_amp_kk
+extdeps.vendor.wiwynn
+extdeps.version.pep440
+extdeps.vllm.batch_defaults
+extdeps.vllm.bench_serve
+extdeps.vllm.memory_profile
+extdeps.vllm.recipe_deepseek_v4_1_flash
+extdeps.vllm.sampling_params
+extdeps.w3c.svg
+extdeps.wiwynn.sv328r.specifications
+extdeps.wiwynn.sv328r.subject
+gunbc.accelerator_demo_eval
+gunbc.accelerator_demo_float_eval
+gunbc.accelerator_demo_gpu
+gunbc.accelerator_demo_plan
+gunbc.accelerator_demo_program
+gunbc.accelerator_demo_realize
+gunbc.accelerator_demo_recognizer
+gunbc.accelerator_demo_render
+gunbc.annotation_parse_instrument_agreement
+gunbc.apply
+gunbc.approve_ios_app
+gunbc.arm_ci_seller_census
+gunbc.assimilate.bmc_bootstrap_provision
+gunbc.auth.approval_keyring_converge
+gunbc.auth.approval_mac_key_provision
+gunbc.auth.approval_ntfy_converge
+gunbc.auth.credentials
+gunbc.auth.fleet_secret_accessor_roster
+gunbc.auth.github_credential
+gunbc.auth.heal_publisher_provision
+gunbc.auth.mosquitto_options_binding
+gunbc.auth.optional_impersonation
+gunbc.auth.patterns
+gunbc.auth.secret_access_admission
+gunbc.bach_double_slit_observation
+gunbc.bach_double_slit_path_additivity_synthetic_fixture
+gunbc.bmc_converge
+gunbc.bmc_fan_alignment_standing_witness
+gunbc.bmc_fan_converge
+gunbc.bmc_fan_monitor
+gunbc.bmc_fan_program_capture
+gunbc.bmc_fan_program_capture_witness
+gunbc.bmc_fan_program_decode_witness
+gunbc.bmc_fan_program_interpretation
+gunbc.bmc_fan_program_observation
+gunbc.bmc_fan_program_observation_witness
+gunbc.bmc_fan_program_representability_witness
+gunbc.bmc_fan_program_syntax_boundary_witness
+gunbc.bmc_firmware_transition
+gunbc.bmc_health_reader
+gunbc.bmc_implementation_dispatch
+gunbc.bmc_netboot_serve
+gunbc.bmc_netboot_shell_boot
+gunbc.bmc_virtual_media
+gunbc.bootstrap
+gunbc.build_cache_endpoint_observation
+gunbc.build_cache_instance_readiness
+gunbc.build_cache_latency_probe
+gunbc.build_target
+gunbc.busybox_bmc_build
+gunbc.capability_binding
+gunbc.cargo_execution_placement
+gunbc.census_closure_frontier
+gunbc.change_realization
+gunbc.chapman_which_path_observation
+gunbc.ci_budget_tree
+gunbc.ci_build_job_v1_compiler_unit_receipt
+gunbc.ci_cost_arc_closeout_receipt
+gunbc.ci_input_envelope
+gunbc.ci_oom_reclassify
+gunbc.ci_render
+gunbc.ci_run_attempt_census
+gunbc.ci_workflow_scan_producer
+gunbc.ci_workflow_source_read
+gunbc.citation.pdf_safe_profile
+gunbc.citation.x86_64_abi_pdf_consumer
+gunbc.claim_evidence_probe_rule
+gunbc.class_b_import_closure_overlay
+gunbc.claude_setup_token_enrollment
+gunbc.cli_dispatch_surface
+gunbc.cli_run_floor_lens_oracle_scaffold
+gunbc.cli_run_hand_rust_area_ledger
+gunbc.cli_run_repo_grant
+gunbc.cli_run_repo_grant_scaffold
+gunbc.cli_run_witness_admission_scaffold
+gunbc.cli_run_witness_deferral_freeze_scaffold
+gunbc.cli_run_workspace_root_scaffold
+gunbc.cli_wire
+gunbc.cloudflare.boot_origin
+gunbc.cloudflare.r2_mint_secret_access
+gunbc.cloudflare.r2_origin_object
+gunbc.cloudflare.r2_s3_netrc
+gunbc.code_change_workflow
+gunbc.codex_app_server_press
+gunbc.codex_runtime_bundle
+gunbc.codex_supervised_turn
+gunbc.codex_supervised_turn_run
+gunbc.colo_census_coverage
+gunbc.compile_permit_scope_observe
+gunbc.compile_source_model
+gunbc.compiler_diagnostic_seed_projection_disposition
+gunbc.compiler_frontend_program_status
+gunbc.compute.test_run
+gunbc.compute.test_selection
+gunbc.compute.work_provider_local
+gunbc.compute.work_request
+gunbc.constructor_binding_channel
+gunbc.container.registry_image_config
+gunbc.credential_argv_exposure
+gunbc.cross_pr_contradiction
+gunbc.cursor_sdk_auth_probe
+gunbc.cursor_sdk_local_binding
+gunbc.cursor_sdk_provider_standing
+gunbc.cursor_sdk_secret_admission
+gunbc.dag_grammar_fork_census
+gunbc.dashboard_provider_readiness
+gunbc.declared_import_closure_binding
+gunbc.declined_live_tree_defect_classification
+gunbc.decoder_execution_identity
+gunbc.deleted_cadence_reference_census
+gunbc.demo.board_artifacts
+gunbc.demo.semantic_system_readout
+gunbc.deploy_transition_bootstrap
+gunbc.deployed_intent_v0
+gunbc.deployed_intent_v1
+gunbc.deployed_tree_remote
+gunbc.design.archetype
+gunbc.design.instrument_audition
+gunbc.design.instrument_bob
+gunbc.design.instrument_physical
+gunbc.design.instrument_projection
+gunbc.design.reference_instrument
+gunbc.design.salience
+gunbc.diff_baseline
+gunbc.digest_render
+gunbc.discovery_census
+gunbc.dissolution_census
+gunbc.dissolution_migration_census
+gunbc.dissolution_observation
+gunbc.doc_graph_roots
+gunbc.econ.acquisition
+gunbc.econ.free_tier_serving
+gunbc.econ.knowable_wedge
+gunbc.econ.llm_attempt_receipt
+gunbc.econ.margin_envelope
+gunbc.econ.regional_compute_premium
+gunbc.econ.scm_serving_model
+gunbc.emit_copy_qualification
+gunbc.emit_copy_qualification_fixture_gen
+gunbc.emit_copy_qualification_wet_battery
+gunbc.emit_stage_blocking_population_census
+gunbc.emit_subject_clean_frontier
+gunbc.emit_summary_map_consumer_partition
+gunbc.emitted_record_deserialize_gap
+gunbc.emitter_shared_layer_producer_census
+gunbc.empty_decl_file_checkpoint_bypass
+gunbc.endpoint_authority_replacement_cut
+gunbc.evaluation_store_address_census
+gunbc.executor_privileged_apply
+gunbc.executor_schedule_retention
+gunbc.expected_value_authority_audit
+gunbc.extdeps_scope_frontier
+gunbc.fabric_capacity_class_gap
+gunbc.fabric_cell_host_root
+gunbc.fabric_ci_program
+gunbc.fabric_m0_job_ending
+gunbc.fabric_m0_origin_commit
+gunbc.fabric_m0_publication
+gunbc.fabric_required_build_cell
+gunbc.fleet.fleet_host_power
+gunbc.fleet.fleet_site_locale
+gunbc.fleet.fleet_work_energy_cost
+gunbc.fleet.printer_credential_migration
+gunbc.fleet.printer_credential_migration_run
+gunbc.fleet.printer_delivery_wet_run
+gunbc.fleet.printer_job_start
+gunbc.fleet.printer_project_delivery
+gunbc.fleet_acquisition_census
+gunbc.fleet_bmc_state
+gunbc.fleet_converge_apply
+gunbc.fleet_converge_cli
+gunbc.fleet_convergence_verdict
+gunbc.fleet_fan_acoustic_evidence
+gunbc.fleet_fan_tach_expectation
+gunbc.fleet_fan_tach_observation
+gunbc.fleet_fan_wiring
+gunbc.fleet_fan_wiring_witness
+gunbc.fleet_host_assembly
+gunbc.fleet_install_transport_observations
+gunbc.fleet_observation_collector_supervision
+gunbc.fleet_printer_access
+gunbc.fleet_probe_identity_observe
+gunbc.fleet_receipt_collector
+gunbc.fleet_show_effective_read
+gunbc.float_add_associativity_observation
+gunbc.floor_cold_build_receipt
+gunbc.floor_discovery_scaffold
+gunbc.floor_memory_demand
+gunbc.floor_non_verdict_classification
+gunbc.frontend_eval.attempt
+gunbc.frontend_eval.attempt_arm
+gunbc.frontend_eval.card
+gunbc.frontend_eval.control
+gunbc.frontend_eval.experiment
+gunbc.frontend_eval.instrument
+gunbc.frontend_eval.serving_identity
+gunbc.frontend_eval.task
+gunbc.gcp_estate_adoption
+gunbc.gcp_estate_dependency
+gunbc.gcp_estate_read_instrument
+gunbc.generic_binder_field_projection_deficit
+gunbc.gha_yaml_fold_pilot
+gunbc.git_use_authority
+gunbc.git_use_census.roadmap_event_git_execution
+gunbc.git_use_census.roadmap_publication_pull_create
+gunbc.git_use_census.roadmap_publication_push
+gunbc.git_use_census.roster
+gunbc.git_use_census.rust_floor_head_observation
+gunbc.git_use_census.rust_process_workspace_root
+gunbc.git_use_census.rust_workspace_root_marker
+gunbc.githooks_pre_push_cli
+gunbc.githooks_pre_push_fmt_transport_scaffold
+gunbc.githooks_pre_push_plan
+gunbc.github_app_acquisition
+gunbc.github_authenticated_user_read
+gunbc.github_observation_record
+gunbc.guarantee_stall.algebra_application_owner_resolution_stall
+gunbc.guarantee_stall.algebra_expansion_positional_argument_stall
+gunbc.guarantee_stall.algebra_operation_associativity_undeclarable_stall
+gunbc.guarantee_stall.argument_shape_undecided_at_a_declared_position_stall
+gunbc.guarantee_stall.authority_target_same_expression_equivalence_stall
+gunbc.guarantee_stall.axis_list_re_enumerates_its_variant_type_stall
+gunbc.guarantee_stall.builtin_parameter_name_forked_across_hand_authored_sites_stall
+gunbc.guarantee_stall.complexity_incomplete_assessment_stall
+gunbc.guarantee_stall.deployed_repository_empty_root_bootstrap_stall
+gunbc.guarantee_stall.doc_graph_dangling_link_population_stall
+gunbc.guarantee_stall.doc_graph_orphan_population_stall
+gunbc.guarantee_stall.emission_apply_generic_r_uninstantiated_stall
+gunbc.guarantee_stall.emission_provenance_missing_consumer
+gunbc.guarantee_stall.emit_returns_medium_not_contribution_stall
+gunbc.guarantee_stall.enforcement_live_closure_gate_stall
+gunbc.guarantee_stall.external_model_scope_live_cover_stall
+gunbc.guarantee_stall.floor_cost_basis_boundedness_stall
+gunbc.guarantee_stall.fn_index_depth_agreement_floor_enrollment_stall
+gunbc.guarantee_stall.generated_artifact_registry_membership_stall
+gunbc.guarantee_stall.generic_lambda_parameter_receiver_evidence_stall
+gunbc.guarantee_stall.gitattributes_committed_emit_drift_stall
+gunbc.guarantee_stall.grounding_extract_closed_set_stall
+gunbc.guarantee_stall.grounding_ledger_residue_uninhabited_stall
+gunbc.guarantee_stall.heterogeneous_child_list_stall
+gunbc.guarantee_stall.import_eligibility_resolution_stall
+gunbc.guarantee_stall.information_retrieval_transport_cannot_report_status_stall
+gunbc.guarantee_stall.joint_claim_join_private_corpus_unindexed_stall
+gunbc.guarantee_stall.mandatory_tag_live_corpus_stall
+gunbc.guarantee_stall.merge_admission_terminal_verdict_stall
+gunbc.guarantee_stall.module_cited_only_in_annotation_prose_stall
+gunbc.guarantee_stall.next_rung_trigger_enforcement_stall
+gunbc.guarantee_stall.non_fold_residue_roster_stall
+gunbc.guarantee_stall.observation_heartbeat_lockstep_stall
+gunbc.guarantee_stall.operation_argv_binding_wall_stall
+gunbc.guarantee_stall.parse_ingest_grammar_relation_stall
+gunbc.guarantee_stall.pci_address_rendering_equivalence_stall
+gunbc.guarantee_stall.pre_resolve_entry_closure_module_identity_stall
+gunbc.guarantee_stall.prose_declared_rung_drop_stall
+gunbc.guarantee_stall.required_regen_host_derivation_stall
+gunbc.guarantee_stall.retained_rust_live_tree_migration_stall
+gunbc.guarantee_stall.roster
+gunbc.guarantee_stall.roster_re_enumerates_its_own_rows_stall
+gunbc.guarantee_stall.runner_microvm_floor_fit_stall
+gunbc.guarantee_stall.self_host_hand_authorized_cargo_toml_stall
+gunbc.guarantee_stall.self_host_hand_authorized_driver_source_stall
+gunbc.guarantee_stall.self_host_spelling_search_stall
+gunbc.guarantee_stall.self_host_wet_route_receipt_lifetime_stall
+gunbc.guarantee_stall.synthesis_established_bound_patch_stall
+gunbc.guarantee_stall.testgen_anchor_generator_totality_stall
+gunbc.guarantee_stall.trigger_capability_referent_free_by_construction_stall
+gunbc.guarantee_stall.two_nat_authorities_stall
+gunbc.guarantee_stall.unit_modeling_carrier_totality_stall
+gunbc.guarantee_stall.variant_owner_identity_stall
+gunbc.guarantee_stall.wall_deadline_shared_fill_attribution_stall
+gunbc.guarantee_stall.wet_route_model_lags_seed_stall
+gunbc.gunbhub_serve
+gunbc.gunbhub_serve_html
+gunbc.hand_lens_host_bridge_scaffold_index
+gunbc.hand_lens_host_bridge_scaffold_watchdog
+gunbc.harness.harness_cli
+gunbc.harness.harness_goal_audit_guidance
+gunbc.harness.harness_guidance
+gunbc.harness.harness_review_guidance
+gunbc.harness.harness_tool
+gunbc.harness.harness_turn
+gunbc.hermetic_mock_fidelity
+gunbc.host_authorized_keys_reconcile
+gunbc.host_boot_supervision
+gunbc.host_build_cache_provision
+gunbc.host_build_environment_seed_disposition
+gunbc.host_codex_runtime_provision
+gunbc.host_compile_pool_provision
+gunbc.host_converge_delta
+gunbc.host_converge_slice1
+gunbc.host_diagnostic_channel
+gunbc.host_disk_reclaim
+gunbc.host_disk_reclaim_units
+gunbc.host_effect_plan
+gunbc.host_hygiene_liveness
+gunbc.host_hygiene_liveness_observe
+gunbc.host_hygiene_reaper
+gunbc.host_hygiene_reaper_observe
+gunbc.host_hygiene_reaper_remediate
+gunbc.host_identity_access
+gunbc.host_identity_adopt
+gunbc.host_identity_assimilation
+gunbc.host_identity_converge
+gunbc.host_identity_knob
+gunbc.host_identity_observation
+gunbc.host_network_diagnosis
+gunbc.host_realization
+gunbc.host_resource
+gunbc.host_runner_memory_cap_plan_emit
+gunbc.host_runner_memory_cap_verify
+gunbc.host_runner_memory_provision
+gunbc.host_swap_backing
+gunbc.host_toolchain_components
+gunbc.host_toolchain_ensure
+gunbc.incremental_floor_authority
+gunbc.information_query
+gunbc.information_retrieval
+gunbc.install_media
+gunbc.instrument_targets
+gunbc.instruments.declaration_fork_census
+gunbc.instruments.fabric_capacity_standing
+gunbc.instruments.fabric_event_log_probe
+gunbc.instruments.fabric_seat_probe
+gunbc.instruments.github_app_acquire
+gunbc.instruments.list_append_concat_paired_timing
+gunbc.instruments.pair_incumbent_identity_standing
+gunbc.instruments.rest_pulls_wire_receipt
+gunbc.instruments.scm_write_spine_canary
+gunbc.interpreter_kernel_model
+gunbc.interpreter_replacement_cut
+gunbc.json_exact_number_witness
+gunbc.json_member_conservation_witness
+gunbc.jurisdiction_drop_accounting
+gunbc.lambda_argument_typing_gate
+gunbc.language_module_home
+gunbc.language_source_scaffold_index
+gunbc.language_target_registry
+gunbc.legacy_binding_tap_coverage
+gunbc.legacy_binding_tap_coverage_census
+gunbc.legacy_test_behavior_disposition
+gunbc.legacy_test_inflow
+gunbc.lifecycle_survivor_scan
+gunbc.list_membership_operation_gap
+gunbc.live_deploy.deployed_tree_report
+gunbc.live_deploy.srv1_residue_rehearsal
+gunbc.live_rust_observation
+gunbc.machine_intake_bmc_first_contact_standing
+gunbc.machine_intake_bmc_rotation_route
+gunbc.machine_intake_disposition
+gunbc.machine_intake_ethernet
+gunbc.machine_intake_megarac_pre_os_channel
+gunbc.machine_intake_mount_establishment
+gunbc.machine_intake_mtcollins1_32dimm_bringup_observation
+gunbc.machine_intake_mtcollins1_connectx4lx_observation
+gunbc.machine_intake_mtcollins1_dimm_connector_observation
+gunbc.machine_intake_mtcollins1_diskless_boot_receipt
+gunbc.machine_intake_mtcollins1_expansion_attachment
+gunbc.machine_intake_mtcollins1_expansion_candidates
+gunbc.machine_intake_mtcollins1_expansion_observation
+gunbc.machine_intake_mtcollins1_handoff_probe
+gunbc.machine_intake_mtcollins1_memory_prediction
+gunbc.machine_intake_mtcollins1_platform_observation
+gunbc.machine_intake_mtcollins1_sixteen_module_restore_observation
+gunbc.machine_intake_mtcollins1_spare_screen_prediction
+gunbc.machine_intake_mtjade1_access_observation
+gunbc.machine_intake_mtjade1_coverage_frontier
+gunbc.machine_intake_mtjade1_fan_standing
+gunbc.machine_intake_mtjade1_first_dpc_population_plan
+gunbc.machine_intake_power_supply
+gunbc.machine_intake_pre_os_bringup_attempt
+gunbc.machine_intake_pre_os_replay
+gunbc.machine_intake_pre_os_timeline
+gunbc.machine_intake_predictive_review_render
+gunbc.machine_intake_staging
+gunbc.materialization_kernel_closing_frontier_audit
+gunbc.materialization_provider_consumer_scaffold
+gunbc.materialization_provider_targets
+gunbc.memory_cgroup_binding
+gunbc.memory_cgroup_binding_seed_growth
+gunbc.memory_per_vcpu_convention
+gunbc.memory_provisioning
+gunbc.merge_lifecycle
+gunbc.merge_queue_admission
+gunbc.model.ollama_choice
+gunbc.model.population
+gunbc.model.publication
+gunbc.model.release_relative_selection
+gunbc.model_artifact
+gunbc.mt_collins_dimm_physical_identity
+gunbc.namespace.transition_admission.gunbc_spark_glm_group_b_relaunch_cli_glm_group_b_subjects_glm_group_b_group
+gunbc.namespace.transition_admission.gunbc_spark_v41_runtime_candidate_v41_runtime_artifact_key_vllm_image_build_key_inputs
+gunbc.namespace.transition_admission.gunbc_spark_vllm_runtime_image_build_converge_vllm_image_keyed_vllm_image_tag_for_key
+gunbc.namespace.transition_admission.gunbc_spark_vllm_runtime_image_build_converge_vllm_image_vllm_image_build_key
+gunbc.namespace.transition_admission.gunbc_spark_vllm_runtime_image_build_vllm_image_build_key_with_observed_tree_vllm_image_build_key_inputs
+gunbc.namespace.transition_admission.gunbc_spark_vllm_runtime_image_build_vllm_image_build_spec_vllm_image_tag
+gunbc.namespace.transition_admission.test_claim_spark_v41_runtime_image_build_witness_the_key_and_tag_move_with_the_arch_list_and_not_with_parallelism_vllm_image_build_key
+gunbc.namespace.transition_admission.test_claim_spark_v41_runtime_image_build_witness_the_key_and_tag_move_with_the_arch_list_and_not_with_parallelism_vllm_image_tag
+gunbc.namespace.transition_admission.test_claim_spark_v41_runtime_image_build_witness_the_key_and_tag_move_with_the_arch_list_and_not_with_parallelism_vllm_image_tag_for_key
+gunbc.namespace.transition_admission.test_claim_spark_v41_runtime_image_build_witness_the_key_moves_with_the_connector_build_argument_vllm_image_build_key
+gunbc.namespace_census_receipt
+gunbc.namespace_cut_landing_order
+gunbc.namespace_step0_canary_v1_history
+gunbc.native_scm_interaction_contract
+gunbc.native_witness_transition_receipt
+gunbc.network_boot_manifest_broker
+gunbc.node_http_server_emit
+gunbc.non_fold_residue
+gunbc.observation_ci_render
+gunbc.observation_emit_census
+gunbc.observation_seed_render
+gunbc.observation_tty_render
+gunbc.occurrence_identity_acceptance_closure
+gunbc.offline_local_recipe
+gunbc.ollama_model_resolution
+gunbc.ollama_runtime_bundle
+gunbc.open_node_partial_evidence
+gunbc.operator_fan_declaration
+gunbc.os_install_claim_evidence
+gunbc.p1_retention_cohort_receipt
+gunbc.path_writer_set
+gunbc.payroll.period_accrual
+gunbc.physics.bach_double_slit_path_additivity
+gunbc.physics.which_path_four_model_comparison
+gunbc.pid_control_curve_decode_witness
+gunbc.plans.affected_set_self_confirmation
+gunbc.plans.branch_merge_admission_model
+gunbc.plans.fleet_subsumption_manual_gaps
+gunbc.plans.host_convergence_circuit_residue
+gunbc.plans.merge_admission_gate_shape_proposal
+gunbc.plans.transport_argv_anemia_dissolution
+gunbc.plans.wave2_prep_design
+gunbc.pr_base_freshness
+gunbc.pr_digests
+gunbc.predicate_cause_aliasing_roster
+gunbc.primitive_egress.census
+gunbc.primitive_egress.census_live
+gunbc.primitive_egress.dispositions
+gunbc.primitive_egress.dispositions_collection
+gunbc.primitive_egress.dispositions_hosts
+gunbc.primitive_egress.dispositions_seed_query
+gunbc.primitive_egress.dispositions_text
+gunbc.primitive_egress.identity
+gunbc.primitive_egress.qualification
+gunbc.primitive_egress.receipt
+gunbc.principal_projection
+gunbc.proactive_verification_ledger
+gunbc.process_algebra
+gunbc.procurement.hetzner_supply_observation
+gunbc.prose_row_frontier
+gunbc.provider_interface_binding
+gunbc.provider_readiness_claim_evidence
+gunbc.provider_standing_probe_bridge
+gunbc.provider_turn_adjudication
+gunbc.provider_wire_evidence
+gunbc.public_projection
+gunbc.public_workload_census
+gunbc.publication_admission_delta
+gunbc.publication_decision
+gunbc.publication_policy
+gunbc.quarantine_probe_disposition
+gunbc.realization_vocab_confinement_census
+gunbc.reference_derived_candidate
+gunbc.reference_realization_policy
+gunbc.regen_affected_set
+gunbc.regen_receipt
+gunbc.replacement_cut
+gunbc.replacement_cut_registry
+gunbc.repo_atlas_projection
+gunbc.repo_local_git_config_clone_bootstrap
+gunbc.repo_ruleset
+gunbc.repository_census_coverage
+gunbc.required_ci_host_verdict_census
+gunbc.required_lane_resolution_census
+gunbc.required_lane_resolution_census_live
+gunbc.required_regen_obligation_disposition
+gunbc.resolved_graph_cache_hand_rust_scaffold
+gunbc.review_sheet_converge_cli
+gunbc.review_sheet_drive_actuator
+gunbc.review_sheet_drive_converge
+gunbc.review_sheet_format_actuator
+gunbc.review_sheet_identity
+gunbc.review_sheet_spreadsheet_actuator
+gunbc.review_sheet_tab_locator
+gunbc.roadmap.roadmap_event_carrier
+gunbc.roadmap.roadmap_event_cli
+gunbc.roadmap_belt_tick_cli
+gunbc.roadmap_closing_contract_authoring
+gunbc.roadmap_dashboard_instance_apply
+gunbc.roadmap_dashboard_instance_observe
+gunbc.roadmap_forecast
+gunbc.roadmap_identity
+gunbc.roadmap_instrument_motion
+gunbc.roadmap_instrument_sandbox
+gunbc.roadmap_instrument_tuner
+gunbc.roadmap_launch_canary
+gunbc.roadmap_launch_canary_sentinel
+gunbc.roadmap_program_view
+gunbc.roadmap_repo_atlas_sandbox
+gunbc.roadmap_sandbox
+gunbc.roadmap_serve
+gunbc.roadmap_served_observation
+gunbc.roadmap_site_healthz_validate
+gunbc.roadmap_site_surface_witness
+gunbc.roadmap_verify
+gunbc.root_demand_measurement
+gunbc.roster_registry
+gunbc.rostered_row_join
+gunbc.run_disposition
+gunbc.rung_drop.shared_capability
+gunbc.runner.runner_artifact_lifecycle
+gunbc.runner.runner_bound_attempt_receipt
+gunbc.runner.runner_canary_evidence_frontier
+gunbc.runner.runner_cgroup_placement_receipt
+gunbc.runner.runner_checkout_receipt
+gunbc.runner.runner_console_authentication_receipt
+gunbc.runner.runner_cpu_bandwidth_receipt
+gunbc.runner.runner_filtered_egress_receipt
+gunbc.runner.runner_first_job_receipt
+gunbc.runner.runner_guest_egress_attempt
+gunbc.runner.runner_guest_network_receipt
+gunbc.runner.runner_harness_refusal_receipt
+gunbc.runner.runner_host_filtered_egress
+gunbc.runner.runner_host_hardware_observation
+gunbc.runner.runner_host_image_placeability
+gunbc.runner.runner_host_image_store
+gunbc.runner.runner_host_jailed_kvm_receipt
+gunbc.runner.runner_host_kernel_config
+gunbc.runner.runner_host_kvm_probe_receipt
+gunbc.runner.runner_host_media_independence_receipt
+gunbc.runner.runner_host_surface
+gunbc.runner.runner_host_tpm_observation
+gunbc.runner.runner_isolation_admission
+gunbc.runner.runner_jit_admission
+gunbc.runner.runner_jit_perform
+gunbc.runner.runner_job_initiator
+gunbc.runner.runner_live_census_receipt
+gunbc.runner.runner_observed_version_check
+gunbc.runner.runner_qualification_receipt
+gunbc.runner.runner_runtime_snapshot
+gunbc.runner.runner_signed_envelope_receipt
+gunbc.runner.runner_teardown_receipt
+gunbc.runner.runner_two_attempt_receipt
+gunbc.runner.runner_usage_receipt
+gunbc.runner_attempt_launch
+gunbc.runner_broker_progress_watchdog
+gunbc.runner_capacity_operator_access
+gunbc.runner_connectivity_recovery
+gunbc.runner_connectivity_repair_plan
+gunbc.runner_disk_reclaim
+gunbc.runner_guest_image
+gunbc.runner_host_file_converge
+gunbc.runner_jit_mint
+gunbc.runner_label_resolution
+gunbc.runner_local_state
+gunbc.runner_microvm
+gunbc.runner_microvm_attempt
+gunbc.runner_microvm_boot_probe
+gunbc.runner_microvm_cell_readiness
+gunbc.runner_microvm_footprint_probe
+gunbc.runner_microvm_host_ready
+gunbc.runner_microvm_lifecycle
+gunbc.runner_microvm_network
+gunbc.runner_password_session_tool_converge
+gunbc.runner_provider_survey
+gunbc.runner_shape_census
+gunbc.runner_slot_enforcement
+gunbc.runner_throughput_qualification_route
+gunbc.runner_throughput_selection
+gunbc.runner_unit_file
+gunbc.runner_unit_live_read
+gunbc.rust_decl_type_overlay
+gunbc.rust_source_type_bindings
+gunbc.scm.ancestry
+gunbc.scm.authoring
+gunbc.scm.checkout
+gunbc.scm.cli
+gunbc.scm.commit_closure
+gunbc.scm.commit_closure_json_v2
+gunbc.scm.init
+gunbc.scm.integration
+gunbc.scm.json_member
+gunbc.scm.load_standing
+gunbc.scm.log
+gunbc.scm.manifest_merge
+gunbc.scm.object_store
+gunbc.scm.object_table_json
+gunbc.scm.ordinary_commit
+gunbc.scm.proposal
+gunbc.scm.read_command
+gunbc.scm.render
+gunbc.scm.repository_envelope
+gunbc.scm.repository_load
+gunbc.scm.repository_save
+gunbc.scm.repository_slot
+gunbc.scm.role_requirement_integration
+gunbc.scm.scm_wet_execution_receipt
+gunbc.scm.squash_merge
+gunbc.scm.staging
+gunbc.scm.status
+gunbc.scm.supersession
+gunbc.scm.target_reference
+gunbc.scm.write_spine
+gunbc.scm.write_spine_ingress
+gunbc.scm_compatibility.git
+gunbc.scm_compatibility.mercurial
+gunbc.scm_compatibility.pijul
+gunbc.scm_compatibility_shape
+gunbc.scope_rank_view
+gunbc.seed_closed_vocabulary_wildcard_census
+gunbc.self_compile_blocking_disposition
+gunbc.self_host_artifact_materialization
+gunbc.self_host_compile_phase_live_gate
+gunbc.self_host_promotion_obligations
+gunbc.semantic_conformance
+gunbc.semantic_conformance_subjects
+gunbc.served_surface_browser_observation
+gunbc.serving.router_realization
+gunbc.sheets_bootstrap_converge
+gunbc.shell_target_conformance
+gunbc.site.accent_study
+gunbc.site.interaction
+gunbc.site.starlight
+gunbc.site_pxe_edge_converge
+gunbc.site_uefi_arm64_pxe_edge
+gunbc.source_admission_selection
+gunbc.source_integration_claim_evidence
+gunbc.source_integration_landing_spine
+gunbc.source_integration_proof_kernel
+gunbc.spark.capability_observation
+gunbc.spark.collective_memory_path_standing
+gunbc.spark.dgx_pxe_boot
+gunbc.spark.fabric_rail_apply
+gunbc.spark.fabric_switch_assessment
+gunbc.spark.fabric_switch_desired
+gunbc.spark.fabric_switch_read
+gunbc.spark.glm_canary_converge
+gunbc.spark.glm_group_b_relaunch_cli
+gunbc.spark.group_b_node_qualification
+gunbc.spark.oobe_execution_placement
+gunbc.spark.oobe_screen_observation
+gunbc.spark.pair_serving_capacity_floor
+gunbc.spark.pinned_base_env_classification
+gunbc.spark.prefill_batch_sweep
+gunbc.spark.pxe_rescue_observation
+gunbc.spark.secret_access_ensure
+gunbc.spark.serving_deployment_decision_pending
+gunbc.spark.serving_fit_projection
+gunbc.spark.serving_load_probe
+gunbc.spark.serving_load_probe_cli
+gunbc.spark.serving_performance_subject
+gunbc.spark.spark_gpu_direct_capability
+gunbc.spark.tensor_parallel_comparison
+gunbc.spark.training_ready
+gunbc.spark.v41_runtime_image_probe
+gunbc.spark.v41_source_patch_converge_wet
+gunbc.spark.vllm_memory_receipt
+gunbc.spark.vllm_rank_population
+gunbc.specification_citation_read_provenance
+gunbc.srv1_tasks_preapply_observation
+gunbc.srv3_host_effect_apply
+gunbc.srv3_install_media_fetch
+gunbc.srv3_os_install_actuate
+gunbc.srv3_os_install_actuator_toolchain_ensure
+gunbc.srv3_seeded_install_media
+gunbc.srv4_uefi_observed
+gunbc.stage0_crate_layout_generated
+gunbc.stage0_rust_honest_frontier_integration
+gunbc.stage0_rust_honest_frontier_projection
+gunbc.stage0_rust_lifecycle_totality
+gunbc.stage0_rust_maintenance_census_report
+gunbc.stage0_rust_product_reachability
+gunbc.structural_realization_bindings
+gunbc.superseded_run_starvation_census
+gunbc.symbol_identity_census
+gunbc.systemctl_list_units
+gunbc.systemctl_set_property
+gunbc.systemd_directive_value_grain
+gunbc.systemd_property_directive_overlap
+gunbc.tailscale_acl_emit
+gunbc.tailscale_acl_phase2_credential
+gunbc.target_binding
+gunbc.target_invocation
+gunbc.test.claim.actions_jit_runner_witness_test
+gunbc.test.claim.body_lowering_refusal_scope_test
+gunbc.test.claim.body_lowering_rejection_propagation_test
+gunbc.test.claim.dag_line_comment_annotation_channel_test
+gunbc.test.claim.normalize_retention_contract_probe_test
+gunbc.test.claim.realization_attempt_keystone_test
+gunbc.test.claim.runner.runner_microvm_attempt_witness_test
+gunbc.test.claim.runner.runner_microvm_footprint_probe_witness_test
+gunbc.test.claim.runner.runner_microvm_lifecycle_witness_test
+gunbc.test.claim.runner.runner_microvm_network_witness_test
+gunbc.test.claim.runner_host_image_placeability_witness_test
+gunbc.test.claim.runner_jit_admission_witness_test
+gunbc.test.claim.witness_execution_class_live_census_test
+gunbc.test.claim.witness_execution_class_test
+gunbc.test_module_hygiene
+gunbc.test_node_wall_clock_ratchet
+gunbc.tool_readiness
+gunbc.toolchain_coherence
+gunbc.toolchain_home_interference_probe
+gunbc.tools.bmc_first_contact
+gunbc.tools.bmc_health_reader_converge
+gunbc.tools.bmc_intake_first_contact
+gunbc.tools.bmc_read_telemetry
+gunbc.tools.body_lowering_population_probe
+gunbc.tools.card_intake
+gunbc.tools.ebay_listing
+gunbc.tools.frontier_ingestion_probe
+gunbc.tools.review
+gunbc.type_ref_hit_ne_bind_measure
+gunbc.typed_module_cache_capacity
+gunbc.uefi_boot_config
+gunbc.uefi_boot_install_decision
+gunbc.uefi_shell_over_sol
+gunbc.untyped_fold_init_accumulator
+gunbc.upstream_document_carriage
+gunbc.v1_complexity_capability_census
+gunbc.v1_complexity_decl_classification
+gunbc.v1_complexity_decl_classification_roster
+gunbc.v1_complexity_decl_classification_types
+gunbc.v1_consumer_census
+gunbc.v1_maintenance_standing
+gunbc.v1_witness_census
+gunbc.v2_compile_obligation_census
+gunbc.web_motion_binding
+gunbc.where_refinement_predicate_vocabulary
+gunbc.witness_execution_class
+gunbc.witness_row_cost
+gunbc.workflow.types
+product.altra_motherboard.attachment_stack
+product.altra_motherboard.minimal_design
+product.altra_motherboard.pcb_world
+product.altra_motherboard.placement
+product.altra_motherboard.realization
+product.altra_motherboard.scene_emission
+product.breakout_leg_programming
+product.build_fulfillment
+product.build_selection
+product.cable_order_admission
+product.compute_board.admission
+product.compute_board.analog
+product.compute_board.article
+product.compute_board.composition
+product.compute_board.contact_population
+product.compute_board.device_binding
+product.compute_board.digital_control
+product.compute_board.emission_entry
+product.compute_board.intent
+product.compute_board.power_distribution
+product.compute_board.simulation_receipt
+product.compute_board.spice_projection
+product.compute_board.truth_table_projection
+product.compute_board.verilog_projection
+product.data_category
+product.data_class
+product.electrical.connectivity
+product.fabric.arbitration
+product.fabric.candidate_field
+product.fabric.contention
+product.fabric.grant_issue
+product.fabric.job_admission
+product.fan_tach
+product.fan_tach_health
+product.fleet_operating_point
+product.fs_box_published_claims
+product.lot_sales_tax
+product.mt_collins_power_policy
+product.node_power_envelope
+product.pcb.copper
+product.pcb.footprint
+product.pcb.physical
+product.pcb.plan_view
+product.pcb.scene
+product.pcb.stackup
+product.pcb.world
+product.printed_chassis.cad_toolchain
+product.printed_chassis.export_profile
+product.printed_chassis.filament_supply
+product.printed_chassis.hole_fit_measurement
+product.printed_chassis.manufacturing_manifest
+product.printed_chassis.measurement
+product.printed_chassis.slicing_toolchain
+product.rack_mount
+product.rack_power
+product.spatial_connectivity
+product.spatial_dimension
+product.spatial_edit
+product.spatial_projection
+product.spatial_world
+product.supplier.cloudflare_r2
+product.supplier.hetzner
+product.supplier.hetzner_path_reading
+product.supplier.ubicloud
+product.training.attempt_graph
+product.training.checkpoint
+product.training.composition
+product.training.execution_control
+product.training.observation_cut
+product.training.readback
+product.training.reconciliation
+product.training.resolution
+product.workload_simulation
+stage0_boundary_add_probe
+std.algebra_law
+std.attribution
+std.coercion
+std.declaring_identity_spelling
+std.effect_axes
+std.emission_provenance
+std.emit_on_demand
+std.hermetic_replay
+std.language_target_identity
+std.literal_elaboration
+std.methods
+std.node
+std.numerical_contract
+std.operator_realization
+std.orthogonal_topology
+std.planar_projection
+std.predictive_claim
+std.rational
+std.realization_cost_fidelity
+std.realize_pack
+std.reference_realization
+std.repair_input_origin
+std.selected_witness_bundle
+std.spatial_knowledge
+std.stack
+std.symbol_semantics
+std.target_representation
+std.verification
+std.witness_purpose
+synthetic.fn_family.planted_family
+synthetic.parse_mechanism.elseif_k16
+synthetic.parse_mechanism.elseif_k32
+synthetic.parse_mechanism.elseif_k4
+synthetic.parse_mechanism.elseif_k8
+synthetic.parse_mechanism.flat_12kb
+synthetic.parse_mechanism.flat_1p5kb
+synthetic.parse_mechanism.flat_3kb
+synthetic.parse_mechanism.flat_6kb
+synthetic.parse_mechanism.nest_d1
+synthetic.parse_mechanism.nest_d2
+synthetic.parse_mechanism.nest_d3
+synthetic.parse_mechanism.nest_d4
+test.claim.accelerator_demo_execution_witness
+test.claim.accelerator_demo_gpu_witness
+test.claim.accelerator_demo_model_witness
+test.claim.access_authorization_profile_witness_test
+test.claim.access_iam_validation
+test.claim.access_layer_extension_witness
+test.claim.access_token_ensure_witness
+test.claim.access_token_source_selection_witness
+test.claim.access_validation
+test.claim.acquisition_mechanism_witness
+test.claim.actions_job_grant_witness
+test.claim.admit_callers_roster_integrity_witness
+test.claim.advertising_interface_witness
+test.claim.affine_space_witness
+test.claim.algebra_carrier_roster_witness_test
+test.claim.algebra_expansion_evidence_witness_test
+test.claim.algebra_receiver_alias_witness_test
+test.claim.algebra_receiver_annotated_witness_test
+test.claim.algebra_receiver_application_witness_test
+test.claim.algebra_receiver_callable_witness_test
+test.claim.algebra_receiver_forwarding_witness_test
+test.claim.algebra_receiver_self_witness_test
+test.claim.alias_identity_across_unwrap_witness
+test.claim.alias_rhs_scalar_leaf_realization_witness
+test.claim.altra_attachment_stack_witness
+test.claim.altra_contact_map_witness
+test.claim.altra_datasheet_supersession_witness_test
+test.claim.altra_memory_controller_witness
+test.claim.altra_minimal_design_witness
+test.claim.altra_pcb_world_svg_witness
+test.claim.altra_placement_witness
+test.claim.altra_platform_and_mt_mitchell_authority_witness
+test.claim.altra_realization_witness
+test.claim.altra_routed_vs_populated_witness_test
+test.claim.ams_lite_feed_path_witness_test
+test.claim.annotation_carrier
+test.claim.annotation_erasure_emission_witness_test
+test.claim.anomaly_evidence_witness
+test.claim.anonymous_record_head_use_line_witness_test
+test.claim.app_control_plane_converge_witness
+test.claim.approval_broker_witness_test
+test.claim.approval_capability_issuance_witness_test
+test.claim.approval_capability_witness_test
+test.claim.approval_decision_store_witness_test
+test.claim.approval_device_redemption_witness_test
+test.claim.approval_device_wire_witness_test
+test.claim.approval_keyring_converge_witness_test
+test.claim.approval_mac_key_provision_witness_test
+test.claim.approval_notification_witness_test
+test.claim.approval_ntfy_converge_witness_test
+test.claim.approval_ntfy_deployment_witness_test
+test.claim.approval_request_client_witness_test
+test.claim.approval_request_submission_witness_test
+test.claim.apt_package_of_witness
+test.claim.argument_shape_at_a_declared_position_probe_test
+test.claim.argv_command_render
+test.claim.arity_zero_import_refusal_witness
+test.claim.arm_ci_seller_census_witness
+test.claim.artifact_store_fs_witness
+test.claim.artifact_store_scratch_grant_witness
+test.claim.artifact_store_witness
+test.claim.aspeed_ast2500_management_paths_witness
+test.claim.asrock_live_probe
+test.claim.asrock_standoff_placement_witness
+test.claim.attempt_admission_subject_witness_test
+test.claim.attribution_span_witness
+test.claim.bach_double_slit_observation_witness_test
+test.claim.bach_double_slit_path_additivity_synthetic_fixture_witness_test
+test.claim.bare_name_ambiguity_wall_witness
+test.claim.bare_name_identity_consumer_census_test
+test.claim.bare_service_derived_demand_witness_test
+test.claim.base16_rfc4648_witness_test
+test.claim.base64_rfc4648_witness
+test.claim.bazel_target_model_witness
+test.claim.behavioral_receipt_standing_witness
+test.claim.belt_pass_outcome_decode_witness
+test.claim.belt_tick_receipt_home_witness
+test.claim.bmc_bootstrap_provision_witness
+test.claim.bmc_capability_solve
+test.claim.bmc_factory_credential
+test.claim.bmc_fan_converge_witness
+test.claim.bmc_firmware_evidence_install_mechanism
+test.claim.bmc_firmware_thermal_witness
+test.claim.bmc_health_reader_witness
+test.claim.bmc_intake_first_contact_witness
+test.claim.bmc_live_receipts_witness
+test.claim.bmc_netboot_serve
+test.claim.bmc_netboot_shell_boot
+test.claim.bmc_onboard_body_witness
+test.claim.bmc_onboarding_lifecycle
+test.claim.bmc_onboarding_quarantine_witness_test
+test.claim.bmc_readback_target_witness
+test.claim.bmc_redfish_grounding
+test.claim.bmc_token_federation_witness
+test.claim.bmc_typed_operations_witness
+test.claim.bmc_virtual_media
+test.claim.bmc_wif_delegation_chain_witness
+test.claim.board_artifacts_demo_witness
+test.claim.board_part_land_pattern_witness
+test.claim.boot_artifact_delivery_witness_test
+test.claim.brand_nominal_identity_witness_test
+test.claim.branded_list_first_optional_witness
+test.claim.breakout_leg_programming_witness
+test.claim.budget_tree_witness
+test.claim.build_artifact_corruption_probe_witness
+test.claim.build_cache_configuration_observation_witness
+test.claim.build_cache_endpoint_observe
+test.claim.build_cache_endpoint_path
+test.claim.build_cache_ensure
+test.claim.build_cache_instance_readiness
+test.claim.build_cache_latency_probe_witness
+test.claim.build_cache_placement_observation
+test.claim.build_fulfillment_witness
+test.claim.build_latency_actions_collect_witness
+test.claim.build_selection_witness
+test.claim.builtin_get_resolver
+test.claim.busybox_bmc_build
+test.claim.cable_leg_coding_witness
+test.claim.cable_order_admission_witness
+test.claim.cable_plant_assessment_witness
+test.claim.cache_key_completeness
+test.claim.cache_layer_planner
+test.claim.cache_purity_verdict
+test.claim.cache_retention_axes_witness_test
+test.claim.call_target_partition_witness_test
+test.claim.callable_candidate_ambiguity_witness
+test.claim.capability_binding_witness
+test.claim.capability_ensure_fixture
+test.claim.capacity_lease_chain_witness
+test.claim.capacity_pool_witness
+test.claim.capacity_quota_witness
+test.claim.card_intake_risk_witness
+test.claim.caret_syntax_witness_test
+test.claim.cargo_artifact_selection_witness
+test.claim.cargo_execution_placement_witness_test
+test.claim.cargo_target_path
+test.claim.cargo_version
+test.claim.carrier_derivation_baseline_witness_test
+test.claim.cause_assertion_census_witness
+test.claim.change_realization_witness
+test.claim.chapman_which_path_observation_witness_test
+test.claim.char_at_unicode_witness
+test.claim.cheap_gate_pool
+test.claim.check_coverage_admission_witness
+test.claim.check_removal_residual_witness
+test.claim.checkpoint_identity_keying_witness
+test.claim.ci_budget_tree_witness
+test.claim.ci_compile_jobs_witness
+test.claim.ci_cost_arc_closeout_receipt_witness
+test.claim.ci_deploy_observed_wet
+test.claim.ci_deploy_target_host_witness
+test.claim.ci_exclusion_proof
+test.claim.ci_failure_class_witness
+test.claim.ci_floor_measurement
+test.claim.ci_floor_on_success_materialization_receipt_hand_rust_witness
+test.claim.ci_oom_reclassify_witness
+test.claim.ci_render_histogram_width
+test.claim.ci_render_slowest_hot_style
+test.claim.ci_runner_target_witness
+test.claim.ci_workflow_scan_producer_witness
+test.claim.ci_workflow_source_read_witness_test
+test.claim.citation_cause_subject_disjointness_witness
+test.claim.citation_cit0_witness
+test.claim.citation_cit1_consumer_witness
+test.claim.citation_cit1_witness
+test.claim.claim_cost_observation_type_wall_witness
+test.claim.claim_entailing_evidence_cause_swap_witness
+test.claim.claim_indexed_evidence_witness
+test.claim.claim_scope_fixture_instrument_witness
+test.claim.class_b_import_closure_binding_refusal_witness
+test.claim.class_b_strip_receipt_witness
+test.claim.claude_sdk_parser_drop_witness
+test.claim.claude_setup_token_enrollment_witness
+test.claim.cli_dispatch_surface
+test.claim.cli_run_floor_lens_oracle_witness
+test.claim.cli_run_hand_rust_area_ledger_witness
+test.claim.cli_run_repo_grant_hand_rust_equivalence_witness
+test.claim.cli_run_repo_grant_witness
+test.claim.cli_run_witness_admission_hand_rust_witness
+test.claim.cli_run_workspace_root_hand_rust_witness
+test.claim.cli_surface_boundary_probe
+test.claim.climbing_hold_catalog_witness
+test.claim.climbing_hold_witness_roster
+test.claim.clock_freshness_witness
+test.claim.clone_bound_callable_field_witness
+test.claim.clone_bound_qualified_head_witness
+test.claim.cloudflare_boot_origin_witness
+test.claim.cloudflare_r2_origin_mint_run
+test.claim.cloudflare_r2_origin_object
+test.claim.cloudflare_r2_token
+test.claim.code_change_workflow_witness_test
+test.claim.codex_app_server_press_wet_witness_test
+test.claim.codex_app_server_press_witness_test
+test.claim.codex_device_prompt_witness
+test.claim.codex_initialize_result_disposition_witness
+test.claim.codex_package_delivery_wet_witness_test
+test.claim.codex_package_lock_parse_witness_test
+test.claim.codex_provider_runtime_receipt_witness
+test.claim.codex_supervised_turn_wet_witness_test
+test.claim.codex_supervised_turn_witness_test
+test.claim.colo_cabinet_density_witness
+test.claim.colo_nj_central_south_census
+test.claim.commit_check_demand_witness
+test.claim.commit_witness_claim_roster_witness
+test.claim.commit_writer_admission_witness
+test.claim.commit_writer_index_selection_witness
+test.claim.compile_accepted_unevaluable_program_control
+test.claim.compile_clean_shard_entry_paths_fast_hand_rust_witness
+test.claim.compile_diagnostic_census_witness
+test.claim.compile_permit_scope_observe_witness
+test.claim.compile_pool_ensure
+test.claim.compile_pool_ensure_wiring_witness
+test.claim.compile_source_model_witness
+test.claim.compiler_diagnostic_seed_projection_witness_test
+test.claim.compiler_frontend_program_status_witness
+test.claim.component_dispatch_button_witness
+test.claim.computation_demand_duplication_witness
+test.claim.compute.test_selection_witness_test
+test.claim.compute.work_request_witness_test
+test.claim.compute_board_admission_witness
+test.claim.compute_board_article_witness
+test.claim.compute_board_emission_entry_witness
+test.claim.compute_board_physical_witness
+test.claim.compute_board_pin_chain_witness
+test.claim.compute_board_power_distribution_witness
+test.claim.compute_board_readiness_witness
+test.claim.compute_board_simulation_receipt_witness
+test.claim.compute_board_spice_projection_witness
+test.claim.compute_board_truth_table_witness
+test.claim.compute_board_verilog_projection_witness
+test.claim.config_record_emit_witness
+test.claim.content_hash_combine_preimage_witness_test
+test.claim.content_hash_family_grounded_witness
+test.claim.contract_identity.required_ci_epoch_observation_test
+test.claim.contracts_placement
+test.claim.contributor_onboarding_path
+test.claim.cooling_qualification_witness
+test.claim.corpus_gate_dag_root_probe
+test.claim.covering_grant_witness_test
+test.claim.cpu_l1_cache_geometry_witness
+test.claim.cpu_l2_l3_cache_geometry_witness
+test.claim.cpu_socket_termination_witness
+test.claim.cr1000a_dhcp_lease_naming
+test.claim.credential_argv_exposure_witness
+test.claim.crm_stage_vocabulary_witness
+test.claim.cron_tag_witness_test
+test.claim.cross_file_binding_assembly_witness_test
+test.claim.cross_pr_contradiction_witness_test
+test.claim.crosstree_probe
+test.claim.css_grain_witness
+test.claim.cursor_cli_invocation_witness_test
+test.claim.cursor_sdk_argv_projection_witness_test
+test.claim.cursor_sdk_auth_standing_witness_test
+test.claim.cursor_sdk_dispatch_bridge_witness_test
+test.claim.cursor_sdk_model_witness_test
+test.claim.cursor_sdk_stream_witness_test
+test.claim.customer_image_admission_witness
+test.claim.dag_collect_fingerprint_witness_test
+test.claim.dag_compile_clean_cli_floor_agreement_witness
+test.claim.dag_compile_clean_perturb_receipts
+test.claim.dag_compile_clean_scope_witness
+test.claim.dag_compile_clean_seam_witness
+test.claim.dag_compile_clean_shard_a_witness
+test.claim.dag_compile_clean_shard_hermetic_witness
+test.claim.dag_compile_clean_shard_totality_witness
+test.claim.dag_parse_continuation_operator_witness_test
+test.claim.data_class_marker_identity_witness_test
+test.claim.data_class_refusal_probe_witness_test
+test.claim.data_reference_kind_from_resolved_node
+test.claim.data_row_shared_layer_authority_witness_test
+test.claim.decision_completeness_witness
+test.claim.decl_fact_value_projection_witness
+test.claim.decl_facts_initializer_projection_witness_test
+test.claim.decl_facts_reflection_witness_support
+test.claim.decl_facts_reflection_witness_test
+test.claim.decl_ref_keyed_read_agreement_witness_test
+test.claim.declaration_fork_census_witness_test
+test.claim.declined_live_tree_defect_classification_witness
+test.claim.deepseek.deepseek_v4_1_flash_authority_witness
+test.claim.deepseek.deepseek_v4_encoder_witness
+test.claim.deleted_cadence_reference_census_witness_test
+test.claim.deploy_access_privilege_witness
+test.claim.deploy_mutation_gate_witness
+test.claim.deploy_transition_bootstrap_witness_test
+test.claim.deploy_transition_witness_test
+test.claim.deploy_workflow_retirement_witness
+test.claim.deployed_tree_remote_witness
+test.claim.descent_evidence_lattice
+test.claim.design_argument_witness
+test.claim.design_palette_witness
+test.claim.design_register_lift_parity_witness
+test.claim.devboot_build_product_witness
+test.claim.devboot_host_tool_spelling_witness
+test.claim.devboot_reuse_seams_witness
+test.claim.devboot_subject_identity_witness
+test.claim.dgx_spark_inventory_witness
+test.claim.dgx_spark_pxe_witness
+test.claim.dgx_spark_witness
+test.claim.dhcp_v4_mac_pinned_witness
+test.claim.diagnostic_redfish_witness
+test.claim.diagnostics_test
+test.claim.diff_baseline_witness
+test.claim.diff_window_cross_seam_witness_test
+test.claim.direct_call_argument_type_witness_test
+test.claim.direct_rust_door_write_compile_witness_test
+test.claim.discovery_census_witness
+test.claim.dispatch_attempts_witness
+test.claim.dispatch_preflight_witness
+test.claim.dispatch_presentation_witness
+test.claim.dispatch_selection_witness
+test.claim.dispatch_stop_witness
+test.claim.dissolution_census_mechanism_witness_test
+test.claim.dissolution_migration_census
+test.claim.diverging_match_arm_join_witness
+test.claim.doc_graph_reference_partition_witness_test
+test.claim.doc_reachability_witness
+test.claim.docker_container_stats_witness
+test.claim.docker_image_digest_command_witness
+test.claim.docs_projection_gate_test
+test.claim.documentary_refs_witness
+test.claim.domain_name_parse
+test.claim.duplicate_declaration_wall_witness
+test.claim.duplicate_definition_binding_probe_test
+test.claim.duplicate_record_field_refusal_witness
+test.claim.durable_cas_file_store_witness
+test.claim.durable_compare_and_set
+test.claim.durable_exclusive_hold_witness
+test.claim.e0308_mechanical_trio_test
+test.claim.e0599_emitter_decision_census_witness_test
+test.claim.e0599_probe_census_witness_test
+test.claim.ebay_browse_witness
+test.claim.ebay_listing_witness
+test.claim.econ_wedge_witness
+test.claim.effect_axes_witness_test
+test.claim.effect_grant_witness_test
+test.claim.effectful_item_kind_collapse_witness_test
+test.claim.effects_rest_transport_parse_witness_test
+test.claim.effects_witness_test
+test.claim.electrical_design_identity_witness
+test.claim.emission_entry_instrument_witness
+test.claim.emission_provenance_test
+test.claim.emit_copy_qualification_witness_test
+test.claim.emit_host_gate_verdicts_test
+test.claim.emit_host_gate_witness
+test.claim.emit_host_reported_comparison_cause_swap_test
+test.claim.emit_host_typed_smoke_test
+test.claim.emit_stage_blocking_population_census_witness_test
+test.claim.emit_subject_clean_frontier_witness
+test.claim.emit_summary_map_consumer_partition_test
+test.claim.emitted_lib_rs_module_declaration_witness_test
+test.claim.emitted_manifest_runtime_features
+test.claim.emitted_symbol_collision_witness
+test.claim.emitter_bare_variant_expected_adoption_witness_test
+test.claim.emitter_callable_field_capture_witness_test
+test.claim.emitter_nested_refinement_cast_witness_test
+test.claim.emitter_optional_payload_cast_witness_test
+test.claim.emitter_optional_present_branded_scalar_witness_test
+test.claim.emitter_qualified_type_shared_wrap_witness
+test.claim.emitter_sole_constructor_seal_witness_test
+test.claim.emitter_unprojectable_construct_refuse_witness_test
+test.claim.emitter_variant_tag_reference_witness_test
+test.claim.empty_list_element_fabrication_witness
+test.claim.endpoint_authority_replacement_cut_witness_test
+test.claim.ensure_witness
+test.claim.entry_authority_witness_test
+test.claim.env_execution_authority_witness
+test.claim.env_freshness_witness
+test.claim.eval_cast_identity
+test.claim.evaluation_budget
+test.claim.evaluation_store_address_census_witness
+test.claim.exact_witness_admission_witness
+test.claim.exec_arg_limit_witness
+test.claim.executor_privileged_operation_witness
+test.claim.executor_schedule_retention
+test.claim.expectation_frontier_witness
+test.claim.extdeps.flashinfer_authority_witness
+test.claim.extdeps_anemia_grounding_witness
+test.claim.extdeps_dpkg_witness
+test.claim.extdeps_git_diff_name_status_witness
+test.claim.extdeps_git_versioning_witness
+test.claim.extdeps_github_errors_url_grounding_witness
+test.claim.extdeps_llm_claude_trust_witness
+test.claim.extdeps_llm_type_grounding_witness
+test.claim.extdeps_provisioning_elevation_witness
+test.claim.extdeps_round2_grounding_witness
+test.claim.extdeps_version_base
+test.claim.extdeps_version_semver
+test.claim.external_model_scope_live_cover_witness
+test.claim.external_model_scope_witness
+test.claim.fabric.common_paper_csa_agreement_witness
+test.claim.fabric.data_class_admission_witness_test
+test.claim.fabric.fabric_ci_fci1_allocation_lifecycle_witness_test
+test.claim.fabric.fabric_ci_program_witness_test
+test.claim.fabric.fabric_db_wire_witness
+test.claim.fabric.fabric_db_witness
+test.claim.fabric.fabric_required_build_work_witness_test
+test.claim.fabric.fci1_bounded_execution_context_emit_witness_test
+test.claim.fabric.fci1_bounded_execution_context_witness_test
+test.claim.fabric.jurisdiction_drop_accounting_witness
+test.claim.fabric.node_qualification_witness
+test.claim.fabric.provider_admission_witness
+test.claim.fabric.provider_use_fixture
+test.claim.fabric.spill_candidate_field_witness
+test.claim.fabric.systemd_run_transient_wait_witness_test
+test.claim.fabric.ubicloud_binding_witness
+test.claim.fabric_allocation_store_substrate_witness
+test.claim.fabric_budget_encumbrance_witness
+test.claim.fabric_capacity_class_gap_witness_test
+test.claim.fabric_capacity_class_witness
+test.claim.fabric_cell_acquire_witness
+test.claim.fabric_cell_converge
+test.claim.fabric_cell_effect_witness
+test.claim.fabric_cell_evidence_algebra_witness
+test.claim.fabric_cell_host_root_witness
+test.claim.fabric_cell_observe_witness
+test.claim.fabric_contention_witness_test
+test.claim.fabric_control_plane_witness
+test.claim.fabric_demand_effect_witness_test
+test.claim.fabric_envelope_witness_test
+test.claim.fabric_floor_dispatch_witness
+test.claim.fabric_grant_authorization_witness
+test.claim.fabric_grant_issuance_witness
+test.claim.fabric_isolation_witness_test
+test.claim.fabric_m0_completion_witness
+test.claim.fabric_m0_job_ending_seal
+test.claim.fabric_m0_job_ending_witness
+test.claim.fabric_m0_origin_commit_witness
+test.claim.fabric_m0_origin_readback_seal
+test.claim.fabric_m0_publication_witness
+test.claim.fabric_output_contract_resolution_witness
+test.claim.fabric_sanitation_witness_test
+test.claim.fabric_selection_witness
+test.claim.fabric_terminal_contract_witness
+test.claim.fabric_witness_run
+test.claim.fan_mount_admission_witness_test
+test.claim.fan_tach_assessment_witness
+test.claim.filament_supply_assessment_witness_test
+test.claim.file_hold_plan_refusal_probe_witness_test
+test.claim.filesystem_entry_kind_witness
+test.claim.filesystem_list_hermetic_witness_test
+test.claim.filesystem_read_hermetic_witness
+test.claim.filesystem_read_outcome_witness
+test.claim.filesystem_write_closure_scale_witness
+test.claim.filesystem_write_witness
+test.claim.firmware_applicability_and_loop_cause_witness_test
+test.claim.firmware_prerequisite_evidence_witness_test
+test.claim.fleet.fleet_printer_access_witness_test
+test.claim.fleet.fleet_site_locale_witness
+test.claim.fleet.printer_project_delivery_witness_test
+test.claim.fleet.site_pxe_edge_converge_witness
+test.claim.fleet_acquisition_census_witness
+test.claim.fleet_bootstrap_principal_session_witness
+test.claim.fleet_cap_observation_witness
+test.claim.fleet_capacity_control_witness_test
+test.claim.fleet_capacity_gate_witness_test
+test.claim.fleet_capacity_panel_witness_test
+test.claim.fleet_container_demand_envelope_witness
+test.claim.fleet_converge_apply_witness
+test.claim.fleet_converge_cli_witness
+test.claim.fleet_converge_launch_environment_scope_witness
+test.claim.fleet_converge_launch_scope_non_interference
+test.claim.fleet_converge_plan_manifest_witness
+test.claim.fleet_converge_plan_witness
+test.claim.fleet_converge_privilege_hold_witness
+test.claim.fleet_converge_receipt_witness
+test.claim.fleet_convergence_verdict_witness
+test.claim.fleet_desired_admission_witness_test
+test.claim.fleet_desired_expectation_witness
+test.claim.fleet_desired_merge_queue_admission_witness_test
+test.claim.fleet_hardware_standing_panel_witness_test
+test.claim.fleet_host_assembly_witness
+test.claim.fleet_host_budget
+test.claim.fleet_host_key_enrollment_witness
+test.claim.fleet_intent_memory
+test.claim.fleet_intent_network
+test.claim.fleet_intent_storage
+test.claim.fleet_known_hosts_anchor_witness_test
+test.claim.fleet_main_revision_witness
+test.claim.fleet_observation_producers_witness
+test.claim.fleet_observation_seal
+test.claim.fleet_observation_supervision_witness
+test.claim.fleet_receipt_collector_witness
+test.claim.fleet_revision_acceptance_witness
+test.claim.fleet_revision_relation_wet_matrix
+test.claim.fleet_runner_connectivity_witness
+test.claim.fleet_show_effective_read_witness
+test.claim.fleet_ssh_credential_verify_witness_test
+test.claim.fleet_work_energy_cost_witness
+test.claim.float_add_associativity_law_witness_test
+test.claim.floor_attempt_standing_witness_test
+test.claim.floor_batch_clamp_authority_witness
+test.claim.floor_cold_build_receipt_witness_test
+test.claim.floor_cost_distribution_witness
+test.claim.floor_demand_witness_test
+test.claim.floor_discovery_exact_subject_witness
+test.claim.floor_discovery_hand_rust_equivalence_witness
+test.claim.floor_discovery_roster_fixture
+test.claim.floor_eval_step_budget_witness_test
+test.claim.floor_eval_step_calibration_specimen_test
+test.claim.floor_expected_red_coherence_witness_test
+test.claim.floor_materialization_witness
+test.claim.floor_memory_demand_witness
+test.claim.floor_non_verdict_classification_witness
+test.claim.floor_non_verdict_enrollment_witness_test
+test.claim.floor_preparation_shared_build
+test.claim.floor_preparation_witness
+test.claim.floor_resolve_realization_witness
+test.claim.fn_arrow_decl_facts_live_subject_witness_test
+test.claim.fn_equality_bound_witness
+test.claim.frame_boundary_simulated_witness_test
+test.claim.frame_boundary_witness_test
+test.claim.free_tier_serving_witness
+test.claim.frontend_eval_witness_test
+test.claim.frontend_literal_and_compile_witness_test
+test.claim.fs_box_published_claims_witness
+test.claim.function_derive_alias_hop_witness
+test.claim.gate_receipt_witness
+test.claim.gcp_estate_census_witness
+test.claim.gcp_oauth_access_token_witness
+test.claim.gcp_secret_access_witness_test
+test.claim.generated_artifact_assessment
+test.claim.generated_artifact_merge_driver_recipe
+test.claim.generated_artifact_producer_coverage_witness_test
+test.claim.generated_projection_merge_rows_witness
+test.claim.generic_effectful_declaration_wall_witness_test
+test.claim.generic_item_clone_bound_witness
+test.claim.generic_item_ord_bound_witness
+test.claim.generic_lambda_parameter_binding_witness
+test.claim.gha_expression_roundtrip
+test.claim.gha_job_projection_witness_test
+test.claim.gigabyte_mp72_board_profile_witness
+test.claim.git_ls_remote_witness_test
+test.claim.git_plumbing_ref_mutation_witness_test
+test.claim.git_ref_set_decoder_witness
+test.claim.git_remote_ref_cas_witness
+test.claim.git_upstream_model_witness
+test.claim.git_worktree_set_decoder_witness
+test.claim.gitattributes_emit_witness
+test.claim.githooks_pre_push_emit
+test.claim.githooks_pre_push_plan
+test.claim.githooks_repo_local_git_config_emit
+test.claim.github_app_manifest_witness
+test.claim.github_app_registry
+test.claim.github_authenticated_user_read
+test.claim.github_checks_witness
+test.claim.github_merge_state_witness
+test.claim.github_mergeable_state_witness
+test.claim.github_workflow_runs_witness
+test.claim.gitignore_gate
+test.claim.gitlab_10k_income_series_witness
+test.claim.go_module_versioning_witness
+test.claim.goal_assessment_witness
+test.claim.gpu_interconnect_and_sm_cache_witness
+test.claim.grounded_principal_witness
+test.claim.grub_cmdline_quoting
+test.claim.guarantee_disposition_witness
+test.claim.guarantee_floor_class_probe_witness
+test.claim.guarantee_measurement_witness_test
+test.claim.guarantee_probe_corpus_witness_test
+test.claim.guarantee_rung_witness_test
+test.claim.guarantee_stall_witness_test
+test.claim.gunb_ai_frontend_mark_witness_test
+test.claim.gunbc_invoke_witness
+test.claim.gunbhub_react_browse_witness
+test.claim.gunbhub_serve_witness
+test.claim.hand_lens_host_bridge_scaffold_watchdog
+test.claim.hand_maintained_map_key_seed_witness
+test.claim.harness_chat_shape
+test.claim.harness_goal_audit_guidance_test
+test.claim.harness_guidance
+test.claim.harness_review_guidance_test
+test.claim.harness_seat_witness
+test.claim.harness_throughput
+test.claim.harness_turn_admission_witness
+test.claim.harness_turn_completion_test
+test.claim.hash_checkpoint_retired_witness
+test.claim.heal_candidate_witness
+test.claim.heal_publication_workflow_witness
+test.claim.heal_publisher_provision_witness
+test.claim.hermetic_fixture_realization
+test.claim.hermetic_mock_fidelity_witness
+test.claim.hetzner_cost_quote_witness
+test.claim.hetzner_listing_witness
+test.claim.hole_fit_measurement_witness_test
+test.claim.homomorphism_trait_derive_emit_witness
+test.claim.host.cap_raise_retirement_order_witness
+test.claim.host_allocation_conservation
+test.claim.host_axis_caps
+test.claim.host_build_cache_provision_design
+test.claim.host_build_cache_provision_real_execution
+test.claim.host_cli_dependency_witness_test
+test.claim.host_codex_runtime_provision_design
+test.claim.host_compile_pool
+test.claim.host_converge_delta_witness
+test.claim.host_converge_slice1_witness
+test.claim.host_convergence_census_witness
+test.claim.host_disk_reclaim_units_witness_test
+test.claim.host_disk_reclaim_witness_test
+test.claim.host_effect_apply_witness
+test.claim.host_effect_plan_real_execution
+test.claim.host_effect_plan_witness
+test.claim.host_hygiene_liveness
+test.claim.host_hygiene_reaper
+test.claim.host_identity_observation_witness
+test.claim.host_memory_qualification_witness_test
+test.claim.host_network_diagnosis
+test.claim.host_phase_status
+test.claim.host_reach_identity_probe_witness
+test.claim.host_reset_return_witness_test
+test.claim.host_run_boundary_admission_witness_test
+test.claim.host_standup_assimilation_deduction
+test.claim.host_standup_spine
+test.claim.host_swap_backing
+test.claim.host_toolchain_components
+test.claim.hostname_allocation_witness
+test.claim.hostname_set_invocation_lowering_witness
+test.claim.html_emit_witness
+test.claim.html_markup_xss_witness
+test.claim.html_roundtrip
+test.claim.http_client_get_real_execution
+test.claim.http_pilot_rest_witness
+test.claim.http_serve_route_witness
+test.claim.huggingface.hub_url_kind_witness
+test.claim.ice40_configuration_witness
+test.claim.ice40_supply_witness
+test.claim.if_join_pool_binding_witness_test
+test.claim.ilm4926_designation_witness
+test.claim.import_admission_closure_membership_witness_test
+test.claim.import_shadowed_by_local_definition_witness_test
+test.claim.incremental_floor_authority_witness_test
+test.claim.information_query_witness
+test.claim.information_retrieval_witness
+test.claim.input_envelope_admission
+test.claim.install_transport_qualification_witness_test
+test.claim.installed_bom_reconcile_witness_test
+test.claim.instrument_bob_witness
+test.claim.instrument_camera_witness
+test.claim.instrument_motion_page_witness
+test.claim.instrument_physical_witness
+test.claim.instrument_sandbox_witness
+test.claim.instrument_tuner_witness
+test.claim.interp_recorded_fixture_witness_test
+test.claim.interpreter_dispatch_bijection_real_roster_witness_test
+test.claim.interpreter_kernel_model_witness
+test.claim.interpreter_replacement_cut_witness_test
+test.claim.inventory_admitted_ledger_seal_livetree_witness_test
+test.claim.inventory_asset_source_lot_witness_test
+test.claim.inventory_ledger_witness
+test.claim.iso_273_clearance_hole_witness_test
+test.claim.jedec_ddr_generation
+test.claim.job_admission_witness
+test.claim.jq_invocation_lowering_witness
+test.claim.json_emit_corpus_witness
+test.claim.json_emit_witness
+test.claim.json_parse_witness
+test.claim.json_protocol_schema_memory_split_wet_witness_test
+test.claim.jwt_oidc_claims_witness_test
+test.claim.keyed_delta_fold_witness
+test.claim.keyed_roster_witness
+test.claim.lambda_capture_clone_required_witness
+test.claim.lambda_receiver_type_witness_test
+test.claim.language_module_home_test
+test.claim.language_source_scaffold_index_test
+test.claim.language_target_identity_witness
+test.claim.language_target_registry_totality
+test.claim.language_target_subject_registration
+test.claim.layout_render_witness
+test.claim.ledger_row_coherence
+test.claim.ledger_tail_liveness_witness
+test.claim.legacy_baseline_capture_witness
+test.claim.legacy_baseline_persisted_observation_witness
+test.claim.legacy_binding_delta_witness
+test.claim.legacy_binding_observation_witness
+test.claim.legacy_binding_projection_witness
+test.claim.legacy_binding_tap_coverage_witness_test
+test.claim.legacy_repair_observation_witness
+test.claim.legacy_repair_tap_live_bridge_witness
+test.claim.legacy_repair_tap_persisted_capture_witness
+test.claim.legacy_test_behavior_disposition_acceptance_test
+test.claim.legacy_test_behavior_disposition_witness_test
+test.claim.legacy_test_inflow_witness_test
+test.claim.lens_verdict_witness
+test.claim.lever_a_local_receipt_witness
+test.claim.linux_edac_topology_authority_witness
+test.claim.live_deploy.apply
+test.claim.live_deploy.apply_emission_projection
+test.claim.live_deploy.apply_receipt_witness
+test.claim.live_deploy.candidate_checkout_witness_test
+test.claim.live_deploy.deploy_release_fixture
+test.claim.live_deploy.deployed_tree_observation_witness
+test.claim.live_deploy.deployed_tree_report_witness
+test.claim.live_deploy.desired_roster
+test.claim.live_deploy.emit
+test.claim.live_deploy.fleet_request_witness_test
+test.claim.live_deploy.intent
+test.claim.live_deploy.member_identity_witness_test
+test.claim.live_deploy.operations_witness
+test.claim.live_deploy.readiness
+test.claim.live_deploy.release_binding_witness
+test.claim.live_deploy.running_release_identity_witness_test
+test.claim.live_deploy.service_ready
+test.claim.live_deploy.unit_standing_witness
+test.claim.live_deploy_unit_emission_oracle_witness
+test.claim.live_rust_observation_contract
+test.claim.llm_attempt_receipt_witness
+test.claim.local_tidy_fmt_outcome
+test.claim.long.carrier_reference_integrity_witness_test
+test.claim.long.commit_witness_claim_roster_witness
+test.claim.long.dag_arrow_lambda_witness_test
+test.claim.long.dag_compile_clean_perturb_corpus
+test.claim.long.dag_compile_clean_scope_disposition_witness
+test.claim.long.decl_ref_resolution_witness_test
+test.claim.long.dissolution_census_witness_test
+test.claim.long.extdeps_scope_placement_gate_loudness_witness
+test.claim.long.g2_data_reference_under_selection_witness_test
+test.claim.long.gauntlet_lane_enrollment_witness
+test.claim.long.host_identity_single_authoring_witness_test
+test.claim.long.import_closure_live
+test.claim.long.instrument_sandbox_live_witness
+test.claim.long.namespace_graft_body_dissolution_witness_test
+test.claim.long.realization_sweep_test
+test.claim.long.reference_closure_equivalence
+test.claim.long.roadmap_page_witness
+test.claim.long.root_d_checkpoint_scalar_declared_arity_witness
+test.claim.long.rust_test_fixtures_import_closure_witness
+test.claim.long.v1_complexity_capability_census_resolution_test
+test.claim.long.v1_complexity_decl_classification_totality_test
+test.claim.long.where_refinement_enforcement_witness
+test.claim.lot_sales_tax_witness
+test.claim.m4_governed_service_witness
+test.claim.m4_universal_corpus_witness
+test.claim.mac_verification_witness_test
+test.claim.machine_intake.megarac_session_release_witness_test
+test.claim.machine_intake.mtcollins1_boot_authorization_witness_test
+test.claim.machine_intake.mtcollins1_boot_run_witness_test
+test.claim.machine_intake.mtcollins1_sixteen_module_restore_witness_test
+test.claim.machine_intake.no_fallback_plan_ineligibility_wall_test
+test.claim.machine_intake.pre_os_bringup_witness_test
+test.claim.machine_intake_bmc_rotation_route_witness_test
+test.claim.machine_intake_bmc_secure_witness_test
+test.claim.machine_intake_disposition_witness_test
+test.claim.machine_intake_ethernet_witness
+test.claim.machine_intake_mount_establishment_witness_test
+test.claim.machine_intake_mtcollins1_bmc_secure_standing_witness_test
+test.claim.machine_intake_predictive_claim_construction_witness_test
+test.claim.machine_intake_predictive_claim_witness_test
+test.claim.machine_intake_subject_witness_test
+test.claim.machine_shape_catalog_integration_witness
+test.claim.machine_shape_witness
+test.claim.managed_directory_witness
+test.claim.map_key_alias_hop_witness
+test.claim.map_key_derive_requirement_witness
+test.claim.map_lookup_dual_dispatch_witness_test
+test.claim.map_lookup_key_generic_realization_witness_test
+test.claim.markdown_inline_render
+test.claim.markdown_markup_xss_witness
+test.claim.markdown_roundtrip
+test.claim.markdown_source_emit
+test.claim.marker_argument_not_consulted_witness_test
+test.claim.markup_medium_convergence
+test.claim.markup_serializer_witness
+test.claim.match_arm_join_disjoint_coproduct_witness_test
+test.claim.match_arm_pattern_identity_emission_witness_test
+test.claim.materialization_kernel_closing_frontier_audit_witness
+test.claim.materialization_ladder_witness
+test.claim.materialization_provider_consumer_hand_rust_witness
+test.claim.materialization_provider_witness
+test.claim.materialization_store_witness
+test.claim.materialized_secret
+test.claim.materialized_ssh_key_file_real_execution_witness
+test.claim.measure_lifted_algebra
+test.claim.measure_magnitude_carrier
+test.claim.measurement_provenance_witness
+test.claim.media_type_witness
+test.claim.medium_fidelity
+test.claim.megarac_operation_surface_witness
+test.claim.membership_reconcile_witness
+test.claim.memory_cgroup_binding_witness
+test.claim.memory_change_evaluation_witness
+test.claim.memory_multiple_findings_witness
+test.claim.memory_per_vcpu_convention_witness_test
+test.claim.memory_provisioning_witness_test
+test.claim.memory_scale_factor_derivation
+test.claim.memory_stall_refusal_witness
+test.claim.mercurial_upstream_model_witness
+test.claim.merge_admission_actuator_witness
+test.claim.merge_admission_attempt_witness
+test.claim.merge_admission_deployed_gate_control
+test.claim.merge_admission_enforcement_witness
+test.claim.merge_admission_producer_witness
+test.claim.merge_admission_witness
+test.claim.merge_lifecycle_interleaving_witness
+test.claim.merge_queue_admission_witness_test
+test.claim.messages_api_conformance_witness_test
+test.claim.method_arg_declared_contract_cross_module_alias_witness_test
+test.claim.method_arg_declared_contract_witness_test
+test.claim.micron_dram_module
+test.claim.model.model_population_narrowing_witness_test
+test.claim.model.release_relative_selection_witness_test
+test.claim.model.serving_choice_witness_test
+test.claim.model_artifact_identity_witness_test
+test.claim.module_filename_collision_witness
+test.claim.module_graph.conformance_imports_only
+test.claim.module_graph_edge_source_witness
+test.claim.module_impact_query_witness_test
+test.claim.moonshot.kimi_code_witness
+test.claim.mt_collins_1u_brief_witness
+test.claim.mt_collins_dimm_physical_identity_witness
+test.claim.mt_collins_document_carriage_witness
+test.claim.mt_collins_population_role_witness
+test.claim.mt_collins_power_policy_witness
+test.claim.mt_jade_getting_started_guide_witness
+test.claim.mt_jade_memory_mixing_witness
+test.claim.mt_jade_platform_witness
+test.claim.mtcollins1_candidate_attachment_witness_test
+test.claim.mtcollins1_connectx4lx_observation_witness_test
+test.claim.mtcollins1_expansion_witness_test
+test.claim.mtcollins1_memory_census_witness_test
+test.claim.mtjade1_access_witness
+test.claim.mtjade1_coverage_frontier_witness
+test.claim.mtjade1_fan_standing_witness
+test.claim.mtjade1_first_dpc_population_plan_witness
+test.claim.multi_module_compile_fixture_witness
+test.claim.native_driver_cost_partition
+test.claim.native_lane_import_refusal
+test.claim.native_scm_interaction_contract_witness
+test.claim.native_scm_interaction_scenario_fixture
+test.claim.native_witness_transition_receipt_witness
+test.claim.nbd_proxy_endpoint
+test.claim.nbd_proxy_serve_transport
+test.claim.nbd_proxy_virtual_media_install
+test.claim.nested_fold_generic_param_emit
+test.claim.network_boot_delivery_join_witness
+test.claim.network_boot_manifest_broker_witness
+test.claim.network_grounding
+test.claim.network_mac_witness_test
+test.claim.network_switch_catalog_witness
+test.claim.nic_red_arm_fail_open_cause_swap_test
+test.claim.no_fake_anomalies_witness
+test.claim.node_hash_protocol_witness
+test.claim.node_http_server_emit
+test.claim.node_power_envelope_witness
+test.claim.non_fold_residue_frontier
+test.claim.non_fold_residue_witness
+test.claim.npm_sri_witness_test
+test.claim.ntfy_publish_outcome_witness_test
+test.claim.ny_colo_census_rows_witness
+test.claim.observability_channel_routing
+test.claim.observation_ci_render_witness_test
+test.claim.observation_crawl_replay_test
+test.claim.observation_emit_census_producer_witness_test
+test.claim.observation_emit_census_witness_test
+test.claim.observation_instant_witness
+test.claim.observation_lockstep_witness_test
+test.claim.observation_model_witness_test
+test.claim.observation_raw_print_retirement_acceptance_test
+test.claim.observation_rollup_witness
+test.claim.observation_seed_heartbeat_witness_test
+test.claim.observation_seed_scoped_run_witness
+test.claim.observation_tty_render_witness_test
+test.claim.occurrence_identity_acceptance_closure_witness_test
+test.claim.occurrence_identity_witness_test
+test.claim.ollama_capability_witness_test
+test.claim.ollama_model_resolution_witness
+test.claim.oomd_install_grounding_witness
+test.claim.opaque_census_declaration_scan_witness
+test.claim.opaque_host_call_reach_control_witness
+test.claim.operation_admit_callers_inert_witness
+test.claim.operation_argv_binding_wall_witness
+test.claim.operation_argv_corpus_witness
+test.claim.optional_at_required_position_witness_test
+test.claim.optional_carrier_signature_test
+test.claim.optional_cast_wall_witness_test
+test.claim.optional_consumer_fail_closed_test
+test.claim.orchestration_if_emit
+test.claim.org_actions_standing_witness
+test.claim.org_admin_credential_witness_test
+test.claim.org_admin_refusal_prelude_derivation_witness_test
+test.claim.organization_runner_roster_read_witness
+test.claim.orthogonal_geometry_witness
+test.claim.orthogonal_topology_witness
+test.claim.os_free_witness
+test.claim.os_install_actuator_selection
+test.claim.os_install_actuator_toolchain_grant
+test.claim.os_install_deduction
+test.claim.os_proc_meminfo_witness
+test.claim.os_systemd_witness
+test.claim.output_policy_witness
+test.claim.package_delivery_codex_integrity_witness_test
+test.claim.package_graph_witness_test
+test.claim.page_fold_witness_test
+test.claim.pareto_dominance
+test.claim.pareto_selection_witness
+test.claim.path_writer_set_witness_test
+test.claim.payload_arm_excess_field_admission
+test.claim.payroll_contribution_band_witness
+test.claim.pcb_capability_established_witness
+test.claim.pcb_copper_witness
+test.claim.pcb_footprint_witness
+test.claim.pcb_stackup_witness
+test.claim.pci_identity_observation_witness
+test.claim.peak_resident_measured_witness
+test.claim.perturbation_kernel
+test.claim.phantom_marker_type_argument_identity_witness
+test.claim.pijul_upstream_model_witness
+test.claim.pipeline_transport_emit_rest_shell_witness
+test.claim.plain_call_result_wrap_roster_test
+test.claim.plan_lens_witness
+test.claim.planar_projection_witness
+test.claim.posix_principal_allocation_witness
+test.claim.power_watt
+test.claim.pr_base_freshness_witness
+test.claim.pr_containment_disposition_witness
+test.claim.pre_os_observer_witness
+test.claim.pre_os_replay_witness
+test.claim.predicate_cause_aliasing_roster_witness_test
+test.claim.preemption_reachability
+test.claim.pricing_surface_witness
+test.claim.primitive_egress_census_witness_test
+test.claim.primitive_identity_join_witness_test
+test.claim.primitive_modeled_cost_witness_test
+test.claim.primitive_projection_authority_witness_test
+test.claim.primitive_signature_grounding_witness_test
+test.claim.principal_projection_witness_test
+test.claim.printed_chassis_admitted_realization_seal_witness_test
+test.claim.printed_chassis_artifact_registration_witness_test
+test.claim.printed_chassis_cadquery_witness_test
+test.claim.printed_chassis_contract_witness
+test.claim.printed_chassis_coupon_witness
+test.claim.printed_chassis_export_profile_witness_test
+test.claim.printed_chassis_manufacturing_manifest_livetree_witness_test
+test.claim.printed_chassis_manufacturing_manifest_witness_test
+test.claim.printed_chassis_measurement_witness
+test.claim.printed_chassis_plate_part_realization_witness_test
+test.claim.printed_chassis_slicing_toolchain_witness_test
+test.claim.printer_credential_migration_witness
+test.claim.printer_job_start_witness_test
+test.claim.probed_at_word_witness_test
+test.claim.proc_self_cgroup_real_execution_witness
+test.claim.proc_self_cgroup_witness
+test.claim.process_lease_plan_is_not_a_refusal_witness
+test.claim.prose_citation_census_witness
+test.claim.prose_row_introduction_witness
+test.claim.provider_account_admission_witness_test
+test.claim.provider_lifecycle_witness
+test.claim.provider_standing_probe_bridge_witness
+test.claim.provider_standing_selection_witness_test
+test.claim.provider_standing_witness
+test.claim.public_workload_census_witness
+test.claim.publication_publisher_witness
+test.claim.push_event_witness
+test.claim.push_event_witness_wet
+test.claim.python_pep440_version_witness
+test.claim.qualified_arm_start_witness_test
+test.claim.qualified_ctor_head_witness_test
+test.claim.qualified_declaration_reference_emit_cross_module_witness
+test.claim.qualified_declaration_reference_emit_witness_test
+test.claim.qualified_leaf_registry_collision_emit_witness_test
+test.claim.qualified_pattern_head_witness_test
+test.claim.qualified_spelling_identity_witness_test
+test.claim.quarantine_probe_disposition_witness_test
+test.claim.r2_mint_secret_access_witness_test
+test.claim.rack_mount_witness
+test.claim.rack_power_witness
+test.claim.random_bytes_csprng_witness
+test.claim.ray_threshold_memory_monitor_witness_test
+test.claim.react_jsx_emit
+test.claim.readback_independence
+test.claim.readiness_algebra_witness
+test.claim.realization_cost_fidelity_witness
+test.claim.realization_measurement_keystone
+test.claim.realization_reconcile_witness
+test.claim.realization_scale_agnostic
+test.claim.realization_schedule_critical_path
+test.claim.realization_selection_witness
+test.claim.realization_vocab_confinement_census_test
+test.claim.realization_width_witness
+test.claim.realization_witness
+test.claim.realize_kernel
+test.claim.realize_pack_witness
+test.claim.reconcile_in_process_cache
+test.claim.reconciled_effect_witness
+test.claim.reconstruction_door_fixture_probe
+test.claim.reconstruction_door_rest_probe
+test.claim.record_construction_census_witness_test
+test.claim.record_decl_spelling_identity_witness_test
+test.claim.record_literal_call_arg_handoff_witness
+test.claim.recorded_observation_envelope_witness
+test.claim.reference_binding_provenance_calibration
+test.claim.reference_derived_authored_source_gate_witness_test
+test.claim.reference_derived_variant_induced_parent_gate_witness_test
+test.claim.reference_instrument_witness
+test.claim.reference_realization_witness
+test.claim.refinement_seam_enforcement_witness
+test.claim.regen_receipt_prior_reference_witness
+test.claim.regional_compute_witness
+test.claim.remote_jq_ssh_migration_witness
+test.claim.remote_shell_command_witness
+test.claim.render_glyphs_ansi_witness
+test.claim.render_repeat_string_witness_test
+test.claim.render_surface_witness
+test.claim.replacement_cut_witness
+test.claim.repo_atlas_projection_witness
+test.claim.repo_local_git_config_clone_bootstrap
+test.claim.repo_local_git_config_real_execution
+test.claim.repo_local_git_config_witness
+test.claim.repo_ruleset_goal_assessment_witness
+test.claim.repo_ruleset_witness_test
+test.claim.repository_bootstrap_wet_witness_test
+test.claim.repository_census_coverage_witness
+test.claim.repository_census_observation_witness
+test.claim.repository_convergence_placement_witness_test
+test.claim.repository_convergence_wet_witness_test
+test.claim.repository_convergence_witness_test
+test.claim.repository_transition_admission_witness_test
+test.claim.required_ci_host_verdict_census_witness
+test.claim.required_expr_newline_continuation_witness_test
+test.claim.required_floor_growth_budget_witness_test
+test.claim.required_lane_claim_agreement_witness_test
+test.claim.required_lane_resolution_census_witness
+test.claim.required_record_field_omission_witness
+test.claim.required_regen_admission_witness
+test.claim.required_regen_obligation_disposition_witness
+test.claim.resolved_call_emission_identity_witness_test
+test.claim.resolved_graph_cache_hand_rust_witness
+test.claim.resolved_rust_fn_projection_witness
+test.claim.resolved_rust_fn_service_chain_consumer_witness
+test.claim.resource_namespace_upsert
+test.claim.rest_exchange_replay_test
+test.claim.rest_transport_axes_emit_witness
+test.claim.retained_shell_script_witness
+test.claim.review_sheet_a1_title_witness
+test.claim.review_sheet_converge_witness
+test.claim.review_sheet_drive_converge_witness
+test.claim.review_sheet_format_target_witness
+test.claim.review_sheet_header_schema_witness
+test.claim.review_sheet_identity_witness
+test.claim.review_sheet_tab_locator_witness
+test.claim.review_sheet_tab_refusal_probe_witness
+test.claim.review_sheet_transport_pin_witness
+test.claim.reviewer_source_witness_test
+test.claim.roadmap.dispatch_worker_confinement_witness_test
+test.claim.roadmap.roadmap_attempt_continuation_witness_test
+test.claim.roadmap.roadmap_belt_commit_witness_test
+test.claim.roadmap.roadmap_closing_contract_task_witness_test
+test.claim.roadmap.roadmap_continuation_turn_label_witness_test
+test.claim.roadmap.roadmap_event_carrier_witness_test
+test.claim.roadmap.roadmap_event_log_witness_test
+test.claim.roadmap.roadmap_launch_admission_fixture
+test.claim.roadmap.roadmap_launch_admission_witness
+test.claim.roadmap.roadmap_launch_deployment_observe_witness
+test.claim.roadmap.roadmap_launch_deployment_receipt_witness
+test.claim.roadmap.roadmap_publish_actuate_witness_test
+test.claim.roadmap.roadmap_publish_admission_witness_test
+test.claim.roadmap.roadmap_review_function_witness_test
+test.claim.roadmap.roadmap_review_role_witness_test
+test.claim.roadmap.roadmap_sandbox_render_witness_test
+test.claim.roadmap.roadmap_worker_alive_witness_test
+test.claim.roadmap_altitude_witness
+test.claim.roadmap_authority
+test.claim.roadmap_belt_actuate_witness
+test.claim.roadmap_belt_witness
+test.claim.roadmap_closing_contract_authoring_witness_test
+test.claim.roadmap_dashboard_instance_apply_witness
+test.claim.roadmap_dashboard_instance_witness
+test.claim.roadmap_dispatch_actuator
+test.claim.roadmap_dispatch_destination_witness_test
+test.claim.roadmap_dispatch_environment_witness_test
+test.claim.roadmap_document
+test.claim.roadmap_emit
+test.claim.roadmap_execution_contract_witness_test
+test.claim.roadmap_focus_witness_test
+test.claim.roadmap_forecast_witness
+test.claim.roadmap_frontier_witness
+test.claim.roadmap_gate
+test.claim.roadmap_identity_witness_test
+test.claim.roadmap_launch_canary_witness
+test.claim.roadmap_model
+test.claim.roadmap_presentation_witness
+test.claim.roadmap_program_view_live_corpus_receipt
+test.claim.roadmap_program_view_witness
+test.claim.roadmap_provider_events_witness_test
+test.claim.roadmap_publication_helper_witness
+test.claim.roadmap_publish_observe_witness_test
+test.claim.roadmap_publish_witness_test
+test.claim.roadmap_receipt_continuity_acceptance
+test.claim.roadmap_receipt_continuity_acceptance_fixture
+test.claim.roadmap_receipt_continuity_live_witness
+test.claim.roadmap_register_witness
+test.claim.roadmap_repo_atlas_sandbox_witness
+test.claim.roadmap_row_witness
+test.claim.roadmap_sandbox_witness
+test.claim.roadmap_serve_witness
+test.claim.roadmap_served_observation_witness
+test.claim.roadmap_site_healthz_json_parse_witness
+test.claim.roadmap_site_surface_readiness
+test.claim.roadmap_sizing_witness
+test.claim.roadmap_spawner
+test.claim.roadmap_static_site_witness
+test.claim.roadmap_status
+test.claim.roadmap_tactile_witness
+test.claim.roadmap_validation_oracle_witness_test
+test.claim.roadmap_verification_receipt_witness_test
+test.claim.roadmap_verify_witness_test
+test.claim.roadmap_workflow_command_witness
+test.claim.roadmap_workflow_progress_witness_test
+test.claim.root4_measure_missing_generics_witness
+test.claim.root_demand_measurement_witness
+test.claim.rt_bridge_registry_witness_test
+test.claim.run_attempt_census_witness
+test.claim.run_disposition_witness_test
+test.claim.run_verdict_exit_status_fixture
+test.claim.run_verdict_exit_status_witness_test
+test.claim.rung_drop_declaration_witness_test
+test.claim.rung_drop_shared_capability_witness_test
+test.claim.rung_drop_standing_partition_witness_test
+test.claim.runnable_resource_profile
+test.claim.runner.runner_canary_receipt_witness_test
+test.claim.runner.runner_host_kernel_config_witness_test
+test.claim.runner.runner_slot_population_census_witness
+test.claim.runner.runner_slot_retirement_witness
+test.claim.runner_activation_wall
+test.claim.runner_attempt_launch_witness
+test.claim.runner_broker_progress_watchdog_witness
+test.claim.runner_capacity_operator_access_witness
+test.claim.runner_connectivity_recovery_witness
+test.claim.runner_connectivity_repair_plan_witness
+test.claim.runner_guest_image_witness
+test.claim.runner_host_deploy
+test.claim.runner_host_file_converge_witness_test
+test.claim.runner_isolation_admission_witness
+test.claim.runner_label_resolution_witness_test
+test.claim.runner_lifecycle
+test.claim.runner_local_state
+test.claim.runner_microvm_boot_probe_witness
+test.claim.runner_microvm_host_ready_witness
+test.claim.runner_microvm_witness_test
+test.claim.runner_password_session_tool_converge_witness
+test.claim.runner_placement_witness
+test.claim.runner_replace_incarnation_seam_witness
+test.claim.runner_service_activation
+test.claim.runner_slot_allocation_witness
+test.claim.runner_slot_enforcement_grounding_witness
+test.claim.runner_slot_installation_state_witness
+test.claim.runner_slot_provision
+test.claim.runner_throughput_qualification_witness
+test.claim.runner_unit_file_witness_test
+test.claim.runner_unit_live_read_witness
+test.claim.runtime_materialization_observation_witness_test
+test.claim.runtime_rust_seed_bootstrap_sync_witness_test
+test.claim.rust_gates_ci_witness
+test.claim.rust_item_host_observation_witness_test
+test.claim.rust_item_identity_witness
+test.claim.rust_item_scan_witness_test
+test.claim.rust_stage0_gates_witness
+test.claim.rust_string_literal_escape_witness_test
+test.claim.salience_witness
+test.claim.samsung_dram_module
+test.claim.scaffold_disposition_census_fixture_witness_test
+test.claim.sccache_local_content_verified_on_read
+test.claim.sccache_pin_witness
+test.claim.scm.scm_cli_witness
+test.claim.scm.scm_wet_execution_receipt_witness
+test.claim.scm_agentic_stress_witness
+test.claim.scm_ancestry_witness
+test.claim.scm_authoring_witness
+test.claim.scm_checkout_verb_witness
+test.claim.scm_commit_closure_json_v2_witness
+test.claim.scm_commit_closure_witness
+test.claim.scm_compatibility_git_witness
+test.claim.scm_compatibility_mercurial_witness
+test.claim.scm_compatibility_pijul_witness
+test.claim.scm_compatibility_shape_witness
+test.claim.scm_issuer_corpus_witness
+test.claim.scm_load_standing_witness
+test.claim.scm_log_witness
+test.claim.scm_manifest_merge_witness
+test.claim.scm_merge_base_witness
+test.claim.scm_object_store_collision_witness
+test.claim.scm_object_store_witness
+test.claim.scm_object_table_json_witness
+test.claim.scm_provider_matrix_witness
+test.claim.scm_read_command_witness
+test.claim.scm_render_witness
+test.claim.scm_repository_envelope_witness
+test.claim.scm_repository_load_witness
+test.claim.scm_repository_save_witness
+test.claim.scm_role_requirement_integration_witness
+test.claim.scm_serving_model_witness
+test.claim.scm_squash_merge_witness
+test.claim.scm_staging_witness
+test.claim.scm_status_witness
+test.claim.scm_supersession_witness
+test.claim.scm_write_spine_witness
+test.claim.scope_rank_view_test
+test.claim.sec_edgar_rollins_chemed_witness
+test.claim.sec_edgar_witness
+test.claim.secret_access_admission_witness_test
+test.claim.secret_manager_access_version_witness
+test.claim.secret_provision_actuator_witness
+test.claim.secret_provision_witness
+test.claim.secret_ref_credential_identity_join_witness
+test.claim.secret_rotation_witness
+test.claim.seed_debt_bundle_item_2_floor_scope
+test.claim.seed_growth_admission_witness
+test.claim.seed_growth_change_population_witness_test
+test.claim.seed_honesty_discharge_unavailable_test
+test.claim.seed_mirror_constant_lens_witness_test
+test.claim.self_compile_blocking_disposition_witness_test
+test.claim.self_host_00_compile_behavioral_witness
+test.claim.self_host_01_tokenize_behavioral_witness
+test.claim.self_host_02_parse_behavioral_witness
+test.claim.self_host_03_ingest_behavioral_witness
+test.claim.self_host_03_normalize_behavioral_witness
+test.claim.self_host_03_resolve_behavioral_witness
+test.claim.self_host_04_infer_behavioral_witness
+test.claim.self_host_artifact_materialization_real_execution_witness
+test.claim.self_host_artifact_materialization_witness
+test.claim.self_host_body_producer_behavioral_witness
+test.claim.self_host_compile_phase_frontier_witness
+test.claim.self_host_compile_phase_live_gate_witness
+test.claim.self_host_discovery_enumeration_behavioral_witness
+test.claim.self_host_emitted_call_target_realization_witness_test
+test.claim.self_host_equality_admission_witness
+test.claim.self_host_expected_value_authority_audit_witness
+test.claim.self_host_generation_identity_witness
+test.claim.self_host_instrument_binding_witness
+test.claim.self_host_materialization_carriers_behavioral_witness
+test.claim.self_host_parse_engine_hooks_behavioral_witness
+test.claim.self_host_peano_literal_operator_realization_witness_test
+test.claim.self_host_program_assembly_behavioral_witness
+test.claim.self_host_program_partition_behavioral_witness
+test.claim.self_host_promotion_admission_witness
+test.claim.self_host_promotion_obligations_witness
+test.claim.self_host_regen_affected_set_witness
+test.claim.self_host_regen_round_cost_witness
+test.claim.self_host_semantic_conformance_subjects_witness
+test.claim.self_host_semantic_conformance_witness
+test.claim.self_host_source_authority_behavioral_witness
+test.claim.self_host_structural_text_witness_test
+test.claim.self_host_symbol_identity_binding_witness
+test.claim.self_host_target_carriers_behavioral_witness
+test.claim.self_host_use_site_verdict_behavioral_witness
+test.claim.self_host_v1_consumer_census_witness_test
+test.claim.self_host_v1_witness_census_witness_test
+test.claim.semantic_system_readout_witness
+test.claim.served_surface_browser_artifact_integrity_witness
+test.claim.served_surface_browser_observation_witness
+test.claim.service_effect_expansion_budget_witness
+test.claim.service_import_dedupe_witness_test
+test.claim.serving.engine_progress_witness
+test.claim.serving.router_realization_witness
+test.claim.serving.serving_availability_witness
+test.claim.serving.turn_admission_witness
+test.claim.serving.turn_demand_witness
+test.claim.serving_routing_witness
+test.claim.session_reservation_policy_witness_test
+test.claim.session_residency_witness
+test.claim.sessions_panel_witness
+test.claim.shared_pool_encoding_control
+test.claim.sheets_bootstrap_converge_witness
+test.claim.shell.shell_typed_invocation_witness_test
+test.claim.shell_bash_runner
+test.claim.shell_dag_census_5a_typed_ops_witness
+test.claim.shell_exec_run_argv_embed_witness
+test.claim.shell_stream_capture
+test.claim.shell_target_conformance_witness
+test.claim.site_accent_study_witness
+test.claim.site_register_witness
+test.claim.site_uefi_arm64_pxe_edge_witness
+test.claim.sk_hynix_dram_module
+test.claim.sole_constructor_completeness_audit_probe_test
+test.claim.sole_constructor_type_head_exposure_witness_test
+test.claim.sorted_map_keys_interpreter_order_witness_test
+test.claim.source_admission_selection_witness
+test.claim.source_annotation_attachment_witness
+test.claim.source_integration_landing_spine_witness
+test.claim.source_integration_proof_kernel_acceptance
+test.claim.source_integration_proof_kernel_model_witness
+test.claim.spark.collective_transport_plan_witness_test
+test.claim.spark.container_inspect_decode_witness_test
+test.claim.spark.engram_materialization_witness_test
+test.claim.spark.fabric_capacity_standing_witness
+test.claim.spark.fabric_switch_assessment_witness
+test.claim.spark.fabric_switch_read_witness
+test.claim.spark.glm53_runtime_image_build_witness
+test.claim.spark.glm_group_b_launch_authority_witness_test
+test.claim.spark.gpu_direct_capability_witness_test
+test.claim.spark.native_serving_roce_transport_witness_test
+test.claim.spark.pair_incumbent_identity_witness
+test.claim.spark.pair_serving_authority_witness
+test.claim.spark.pair_serving_capacity_floor_witness
+test.claim.spark.pair_serving_launch_receipt_witness
+test.claim.spark.prefill_batch_sweep
+test.claim.spark.rank_memory_path_join_witness_test
+test.claim.spark.relaunch_hostconfig_witness_test
+test.claim.spark.relaunch_vertical_witness_test
+test.claim.spark.rendezvous_participation_witness
+test.claim.spark.serving_arm_kv_dtype_witness
+test.claim.spark.serving_arm_launch_witness_test
+test.claim.spark.serving_deployment_selection_witness_test
+test.claim.spark.serving_engine_witness_test
+test.claim.spark.serving_fit_projection_witness_test
+test.claim.spark.serving_incarnation_observe
+test.claim.spark.serving_load_probe_witness
+test.claim.spark.serving_performance_subject_witness_test
+test.claim.spark.serving_runtime_capability_probe_witness
+test.claim.spark.spark_cell_role_witness
+test.claim.spark.spark_declared_unit_digest_seal_probe_test
+test.claim.spark.spark_fabric_rail_witness
+test.claim.spark.spark_fabric_reach_witness
+test.claim.spark.spark_fabric_switch_witness
+test.claim.spark.spark_first_party_serving_witness_test
+test.claim.spark.spark_host_commitment_witness
+test.claim.spark.spark_oobe_execution_placement_witness
+test.claim.spark.spark_oobe_screen_observation_witness
+test.claim.spark.spark_pair_serving_apply_witness
+test.claim.spark.spark_pair_serving_desired_witness
+test.claim.spark.spark_pair_serving_realization_witness
+test.claim.spark.spark_training_ready_witness_test
+test.claim.spark.spark_vllm_observed_witness_test
+test.claim.spark.spark_vllm_rank_population_witness_test
+test.claim.spark.v41_runtime_image_build_witness
+test.claim.spark.vllm_kv_layout_receipt_witness
+test.claim.spark.vllm_serving_launch_witness
+test.claim.spark_bootstrap_password_session_witness
+test.claim.spark_bootstrap_provision_witness
+test.claim.spark_capability_observation_witness_test
+test.claim.spark_credential_workflow_witness
+test.claim.spark_grant_privileged_operation_witness
+test.claim.spark_llama_cpp_rpc_witness
+test.claim.spark_managed_grant_install_witness
+test.claim.spark_managed_grant_reconcile_witness
+test.claim.spark_model_provenance_witness
+test.claim.spark_pinned_base_env_classification_witness
+test.claim.spark_secret_access_ensure_witness_test
+test.claim.spark_snapshot_verify_wrapper
+test.claim.spatial_connectivity_witness
+test.claim.spatial_edit_witness
+test.claim.spatial_frame_scale_witness
+test.claim.spatial_knowledge_witness
+test.claim.spatial_placement
+test.claim.spatial_projection_witness
+test.claim.spatial_units_witness
+test.claim.spatial_world_witness
+test.claim.srv1_residue_rehearsal_witness_test
+test.claim.srv1_tasks_preapply_observation_witness
+test.claim.srv3_bmc_credential_resolve
+test.claim.srv3_boot_once_cd
+test.claim.srv3_host_effect_apply_witness
+test.claim.srv3_host_effect_realize_witness
+test.claim.srv3_install_media_fetch
+test.claim.srv3_network_identity_subsumption
+test.claim.srv3_os_install
+test.claim.srv3_os_install_actuate
+test.claim.srv3_os_install_actuate_scope
+test.claim.srv3_os_install_actuate_workflow
+test.claim.srv3_os_install_actuator_toolchain_ensure
+test.claim.srv3_os_install_diagnostic
+test.claim.srv3_os_install_emit
+test.claim.srv3_path_ownership_witness
+test.claim.srv3_principal_privilege_witness
+test.claim.srv3_runner_memory_cap_plan_verify_witness
+test.claim.srv3_runner_memory_converge_witness
+test.claim.srv3_seeded_install_media
+test.claim.srv3_seeded_install_media_real_execution
+test.claim.srv3_subsumption
+test.claim.srv3_token_subject_witness
+test.claim.srv3_tool_acquisition_witness
+test.claim.srv3_unobservable_probe_refuses_witness
+test.claim.srv3_websocat_sequence_witness
+test.claim.ssh_client_options_witness_test
+test.claim.ssh_transport_witness
+test.claim.stage0_crate_layout_witness
+test.claim.stage0_regen_convergence_real_execution_witness
+test.claim.stage0_rust_honest_frontier_integration_witness
+test.claim.stage0_rust_honest_frontier_projection_witness
+test.claim.stage0_rust_host_observation_live_witness
+test.claim.stage0_rust_lifecycle_totality_witness
+test.claim.stage0_rust_maintenance_census_report_live_witness
+test.claim.stage0_rust_maintenance_census_report_witness
+test.claim.stage0_rust_product_reachability_witness
+test.claim.stage0_rust_source_lifecycle_scaffold_witness
+test.claim.standoff_gauge_admission_witness_test
+test.claim.state_durability_witness
+test.claim.state_response_totality_witness
+test.claim.std_list_keyed_scan_witness
+test.claim.storage_nvme_grounding
+test.claim.string_brace_escape_witness_test
+test.claim.string_family_cast
+test.claim.string_length_char_count_witness
+test.claim.structured_application_mismatch_wall_witness
+test.claim.superseded_run_starvation_census_witness
+test.claim.supplier.cloudflare_r2_route_witness
+test.claim.supplier.hetzner_route_witness
+test.claim.systemctl_status_read_scaffold
+test.claim.systemd_directive_value_grain
+test.claim.systemd_property_directive_overlap
+test.claim.systemd_unit_file_witness_test
+test.claim.tailnet_identity_witness_test
+test.claim.tailscale_acl_phase2_design_witness
+test.claim.tailscale_acl_witness
+test.claim.tailscale_serve_route_key_witness
+test.claim.tailscale_serve_status_witness
+test.claim.target_binding_witness
+test.claim.target_invocation_witness
+test.claim.temporal_effect_spine
+test.claim.terminal_capability_witness
+test.claim.terminal_wire_projection_witness_test
+test.claim.test_module_hygiene_hand_rust_equivalence_witness
+test.claim.test_reference_wall_witness
+test.claim.text_alphabet_membership_witness
+test.claim.text_egress_ambient_builtin_bypass_witness
+test.claim.time_scale_factor_derivation
+test.claim.tmux_session_list_outcome_witness
+test.claim.toml_emission
+test.claim.tool_pin_witness
+test.claim.tool_readiness_witness
+test.claim.toolchain_coherence_witness_test
+test.claim.toolchain_home_standing_witness
+test.claim.training_attempt_graph_witness
+test.claim.training_checkpoint_witness
+test.claim.training_execution_control_witness
+test.claim.training_observation_cut_witness
+test.claim.training_readback_witness
+test.claim.training_reconciliation_witness
+test.claim.training_resolution_witness
+test.claim.trait_bound_witness
+test.claim.transparent_alias_identity_witness_test
+test.claim.transport_emission_not_modeled_witness
+test.claim.transport_fidelity
+test.claim.transport_field_refusal_witness
+test.claim.transport_script_stdin_byte_fidelity_witness
+test.claim.transport_script_wall_compile_red
+test.claim.type_argument_arity_witness
+test.claim.type_ref_hit_ne_bind_measure_witness
+test.claim.typed_argv_exec_realization_witness
+test.claim.typed_module_cache_capacity_witness
+test.claim.typed_remote_file_converge_witness_test
+test.claim.typed_remote_file_write_fleet_ssh_fixture
+test.claim.typed_remote_file_write_witness
+test.claim.typed_witness_invocation
+test.claim.types_arch_collapse
+test.claim.typescript_extdeps_language_witness
+test.claim.typescript_program_serializer
+test.claim.uefi_boot_config
+test.claim.uefi_boot_install_decision
+test.claim.uefi_shell_environment
+test.claim.uefi_shell_over_sol
+test.claim.undeclared_bare_type_reference_class_witness
+test.claim.unicode_ident_xid_grounding
+test.claim.uri_grounding_witness
+test.claim.uri_path_match_witness
+test.claim.uri_path_parse_witness
+test.claim.uri_percent_encode_witness
+test.claim.uri_witness
+test.claim.v1_complexity_capability_census_witness_test
+test.claim.v1_complexity_decl_classification_witness_test
+test.claim.v1_interpreter_primitive_dispatch_authority_acceptance
+test.claim.v1_interpreter_primitive_roster_acceptance
+test.claim.v1_interpreter_primitive_surface_witness_test
+test.claim.v1_source_audit_witness_test
+test.claim.v2_compile_obligation_census_witness_test
+test.claim.verification_evidence_addressing_witness_test
+test.claim.virtual_media_unification
+test.claim.vllm.recipe_deepseek_v4_1_flash_witness
+test.claim.vllm_engine_args_render
+test.claim.vllm_kv_layout_witness
+test.claim.vllm_kv_pool_witness_test
+test.claim.vllm_memory_profile
+test.claim.vllm_memory_receipt
+test.claim.vllm_runtime_defaults
+test.claim.void_element
+test.claim.wc_byte_count_verification_witness
+test.claim.wcag_contrast_witness
+test.claim.web_motion_binding_witness
+test.claim.websocat_install_source
+test.claim.wet_hermetic_equivalence_witness
+test.claim.wet_receipt_route_standing_witness
+test.claim.where_refinement_predicate_vocabulary_witness_test
+test.claim.whole_corpus_compile_admission_witness
+test.claim.whole_corpus_compile_demand_projection_witness
+test.claim.whole_generated_artifact_adjudication_test
+test.claim.witness_floor_workflow_consolidation_witness_test
+test.claim.witness_purpose_taxonomy_witness
+test.claim.witness_row_cost_drift
+test.claim.witness_row_cost_migration_disclosure
+test.claim.witness_row_cost_projection
+test.claim.wiwynn_sv328r_witness
+test.claim.workflow_capability_closure_witness
+test.claim.workflow_dispatch_input_witness
+test.claim.workflow_reconcile_witness_test
+test.claim.workflow_recursive_gate
+test.claim.workflow_recursive_witness
+test.claim.workload_simulation_witness
+test.claim.yaml_ingest_witness
+test.claim.yaml_multiline_block_witness
+test.claim.yaml_quoting_witness
+test.fixture.anonhead_provider
+test.fixture.argv_executable_position_probe
+test.fixture.armstart_provider
+test.fixture.compile_phase_frontier_receipt_fixture
+test.fixture.cross_module_alias_handler.definer
+test.fixture.cross_shard_seam.importee
+test.fixture.cross_shard_seam.importer
+test.fixture.data_handling_map_fixture
+test.fixture.decl_fact_value_projection.specimens
+test.fixture.decl_facts_authored_string_channel.specimens
+test.fixture.decl_facts_reflection.ambiguous_b_specimen
+test.fixture.decl_facts_reflection.ambiguous_shared_a
+test.fixture.decl_facts_reflection.ambiguous_shared_b
+test.fixture.decl_facts_reflection.ambiguous_specimen
+test.fixture.decl_facts_reflection.globally_unique_carrier
+test.fixture.decl_facts_reflection.specimens
+test.fixture.decl_facts_reflection.unimported_globally_unique_user
+test.fixture.decl_facts_reflection.witness_support
+test.fixture.decl_facts_reflection_duplicate_qn.shadowed_module
+test.fixture.dissolution_live_discriminator.subject
+test.fixture.effect_reach_conjunction.host_sink_provider
+test.fixture.effect_reach_conjunction.path_literal_provider
+test.fixture.effect_reach_conjunction.sink_and_path_entry
+test.fixture.effect_reach_conjunction.sink_only_entry
+test.fixture.evaluation_store_address_alias.aliased
+test.fixture.evaluation_store_address_alias.decoy
+test.fixture.evaluation_store_address_alias.home
+test.fixture.evaluation_store_address_alias.mutation_entry
+test.fixture.evaluation_store_address_alias.qualified
+test.fixture.evaluation_store_address_alias.same_leaf
+test.fixture.evaluation_store_address_zero_candidate_plant.digest_call
+test.fixture.evaluation_store_address_zero_candidate_plant_absent.noop
+test.fixture.evaluation_store_address_zero_candidate_plant_home.digest
+test.fixture.floor_expected_red_coherence.severed_chunk_fixture
+test.fixture.fn_index_subject.alpha
+test.fixture.fn_index_subject.beta
+test.fixture.glm_group_b_captures
+test.fixture.import_admission_pool_carrier
+test.fixture.import_admission_provider
+test.fixture.import_binding_probe.open_field
+test.fixture.import_binding_probe.sealed_field
+test.fixture.lambda_receiver_provider
+test.fixture.leaf_key_collision.cross_kind_data_fn.module_a
+test.fixture.leaf_key_collision.cross_kind_data_fn.module_b
+test.fixture.leaf_key_collision.cross_kind_fn_data.module_a
+test.fixture.leaf_key_collision.cross_kind_fn_data.module_b
+test.fixture.leaf_key_collision.module_a
+test.fixture.leaf_key_collision.module_b
+test.fixture.m4_universal_governed_corpus
+test.fixture.m4_universal_governed_probe
+test.fixture.module_graph_edge_source.consumer_bare
+test.fixture.module_graph_edge_source.consumer_imported
+test.fixture.module_graph_edge_source.provider_imported
+test.fixture.module_graph_edge_source.provider_referenced
+test.fixture.nat_qualified_provider
+test.fixture.onboarding_quarantine.machine_intake_probe
+test.fixture.payload_arm_excess_field.carrier
+test.fixture.phantom_marker_identity.marker_consumer
+test.fixture.phantom_marker_identity.non_applied_consumer
+test.fixture.phantom_marker_identity.plain_consumer
+test.fixture.primitive_egress_decoy.decoy
+test.fixture.primitive_egress_decoy.importer
+test.fixture.qualpat_provider
+test.fixture.qualspell_provider
+test.fixture.record_construction_census.homonym
+test.fixture.record_construction_census.qualified
+test.fixture.record_construction_census.specimens
+test.fixture.record_decl_spelling.sealed
+test.fixture.record_decl_spelling.specimens
+test.fixture.record_decl_spelling.witness_support
+test.fixture.reference_derived_graph.consumer_body_value
+test.fixture.reference_derived_graph.consumer_both
+test.fixture.reference_derived_graph.consumer_call_only
+test.fixture.reference_derived_graph.consumer_callee_only
+test.fixture.reference_derived_graph.consumer_field_bare_local
+test.fixture.reference_derived_graph.consumer_import_only
+test.fixture.reference_derived_graph.consumer_reference_only
+test.fixture.reference_derived_graph.consumer_type_bare_local
+test.fixture.reference_derived_graph.consumer_type_imported
+test.fixture.reference_derived_graph.consumer_type_only
+test.fixture.reference_derived_graph.provider
+test.fixture.required_lane_claim.stale_claim_fixture
+test.fixture.rest_exchange_replay_probe
+test.fixture.rostered_row_join.collision_control_roster
+test.fixture.rostered_row_join.collision_control_rostered
+test.fixture.rostered_row_join.collision_control_unrostered
+test.fixture.rostered_row_join.omitted_control
+test.fixture.scaffold_disposition_census.expected_classification
+test.fixture.scaffold_disposition_census.pool.decoy_nullary
+test.fixture.scaffold_disposition_census.pool.decoy_record
+test.fixture.scaffold_disposition_census.pool.specimens
+test.fixture.scaffold_disposition_census.pool_notes
+test.fixture.scm_repository_builder
+test.fixture.serve_seam_probe
+test.fixture.sole_constructor_order_probe.open_variant
+test.fixture.sole_constructor_order_probe.sealed_variant
+test.fixture.sole_constructor_sealed.admitted_caller
+test.fixture.sole_constructor_sealed.definer
+test.fixture.sole_constructor_variant_probe.definer
+test.fixture.v1_consumer_census.specimens
+test.fixture.v1_witness_census.specimens
+test.manual.command_runner_local_argv_receipt
+test.manual.emission_provenance_specimen_red
+test.manual.git_upstream_model_execution
+test.manual.mercurial_upstream_model_execution
+test.manual.pijul_upstream_model_execution
+test.manual.process_argv_expansion_receipt
+test.manual.roadmap_launch_canary_oracle
+test.parsecheck
+test.probe.bare_string_from_boundary_probe
+test.probe.branded_path_segment_forgery_probe
+test.probe.classified_unwrap_helper_probe
+test.probe.data_effect_permit_forged_probe
+test.probe.declaring_identity_spelling_unresolvable_probe
+test.probe.durable_write_takes_the_value_probe
+test.probe.file_hold_plan_forged_probe
+test.probe.path_segment_predicate_admission_probe
+test.probe.personal_identity_to_log_channel_probe
+test.probe.refinement_seam_admission_probe
+test.probe.review_sheet_tab_forged_probe
+test.probe.review_sheet_validated_header_schema_forged_probe
+test.probe.self_authored_map_probe
+test.retirement.model
+tools.approval_store_live_probe
+tools.auth_declared_but_unwired_witness_transport
+tools.bootstrap_witness_transport
+tools.build_step
+tools.build_step_transport
+tools.cas_store_live_probe
+tools.cause_assertion_census
+tools.cause_identifier_cost_probe
+tools.cheap_claim_pool_gate
+tools.cheap_gate_pool
+tools.ci_gates
+tools.compile_phase_frontier_live_gate
+tools.cross_pr_contradiction_instrument
+tools.dag_collect_fingerprint_witness_transport
+tools.dag_compile_clean_cli_floor_agreement
+tools.dag_compile_clean_gate
+tools.dag_compile_clean_partition
+tools.dag_compile_clean_scope
+tools.dag_compile_clean_seam
+tools.dag_compile_clean_seam_transport
+tools.dag_compile_clean_shard_roster
+tools.dag_compile_clean_shard_totality
+tools.dag_compile_clean_shard_totality_transport
+tools.dag_compile_clean_shard_transport
+tools.dag_compile_clean_transport
+tools.diagnostics_witness_transport
+tools.direct_rust_door_transport
+tools.docs_projection_gate
+tools.e0599_emitter_decision_census
+tools.e0599_probe_census
+tools.effects_rest_transport_witness_transport
+tools.emit_copy_qualification_transport
+tools.emit_host_fixtures
+tools.emit_host_gate
+tools.emit_host_transport
+tools.emit_subject_clean_ratchet
+tools.extdeps_external_authority_gate
+tools.extdeps_external_authority_transport
+tools.extdeps_scope_placement_gate
+tools.fabric_ci_evidence
+tools.fabric_ci_evidence_projection_fixture
+tools.fabric_control_plane_live_probe
+tools.fabric_m0_origin_object_probe
+tools.fabric_m0_origin_readback_probe
+tools.floor_cost_distribution_instrument
+tools.floor_effect_gate_witness
+tools.infer_semantics_witness_transport
+tools.interp_recorded_fixture_witness_transport
+tools.interpreter_dispatch_bijection_real_roster_transport
+tools.merge_admission_capture
+tools.merge_admission_capture_transport
+tools.merge_admission_current_context
+tools.merge_admission_walk
+tools.module_impact_query_front_door
+tools.opaque_realization_census
+tools.path_writer_set_instrument
+tools.pr_containment_instrument
+tools.proactive_verification_ledger_transport
+tools.prose_citation_census
+tools.prose_row_introduction_gate
+tools.publication_publisher
+tools.publication_push_shadow
+tools.reference_derived_graph
+tools.roadmap_denominator_probe
+tools.roadmap_dispatch
+tools.rust_gates_ci
+tools.rust_item_census_instrument
+tools.scm_acceptance
+tools.scm_acceptance_binary
+tools.seed_growth_change_population
+tools.self_host_03_normalize_declared_source_refs
+tools.self_host_curated_probe_cargo
+tools.self_host_module_behavioral_transport_roster
+tools.v1_consumer_discovery
+v2.cli.compile_cli
+v2.compiler.body_producer
+v2.compiler.build_transport_admission
+v2.compiler.build_workspace_grant
+v2.compiler.declaring_identity_spelling_census
+v2.compiler.effect_demand
+v2.compiler.effect_demand_floor_join
+v2.compiler.emit_host
+v2.compiler.emit_module
+v2.compiler.emit_produced
+v2.compiler.emit_semantic_decl
+v2.compiler.host_run_boundary_admission
+v2.compiler.ingest
+v2.compiler.ingested_fixture_arrows
+v2.compiler.native_loop
+v2.compiler.native_selected_bundle_process
+v2.compiler.program_partition
+v2.compiler.repair_input_origin_roster
+v2.compiler.self_host.ancestry
+v2.compiler.self_host.candidate_generation
+v2.compiler.self_host.candidate_generation_stage_verdicts
+v2.compiler.self_host.closure_witness_layer_roots
+v2.compiler.self_host.compiler_closure_emit
+v2.compiler.self_host.compiler_closure_emit_driver
+v2.compiler.self_host.direct_rust_door_fixture
+v2.compiler.self_host.direct_rust_door_observation
+v2.compiler.self_host.emit_coverage_frontier
+v2.compiler.self_host.emitter_producer_provenance
+v2.compiler.self_host.fixture_synthetic_emission
+v2.compiler.self_host.frontier_probe
+v2.compiler.self_host.frontier_probe_assemble_detail
+v2.compiler.self_host.frontier_probe_semantic_family_receipt
+v2.compiler.self_host.frontier_probe_types
+v2.compiler.self_host.native_agreement_support
+v2.compiler.self_host.native_routing_frontier
+v2.compiler.self_host.parity_receipts_local
+v2.compiler.self_host.parity_window
+v2.compiler.self_host.stage0_production_target
+v2.compiler.self_host.v2_emitter_direct_rust_door_contract
+v2.compiler.self_host.wet_receipt_route_standing
+v2.compiler.self_host.witness_bulk_routing
+v2.compiler.self_host.witness_entry_eligibility_census
+v2.compiler.staged_front_end
+v2.compiler.test_marker_capture
+v2.compiler.trait_derive_completeness
+v2.compiler.use_site_verdict
+v2.extdeps.bmc.lifecycle_fidelity
+v2.extdeps.cache.key_completeness_verdict
+v2.extdeps.coercion_widening
+v2.extdeps.coordination
+v2.extdeps.cpp_abi
+v2.extdeps.file_system
+v2.extdeps.formats.icestorm_pcf
+v2.extdeps.formats.json
+v2.extdeps.formats.spice
+v2.extdeps.formats.spice_passive_projection
+v2.extdeps.formats.sql
+v2.extdeps.formats.sql_create_table_fold
+v2.extdeps.formats.sql_target
+v2.extdeps.formatters.black
+v2.extdeps.formatters.clang_format
+v2.extdeps.formatters.gofmt
+v2.extdeps.formatters.google_java_format
+v2.extdeps.formatters.ktfmt
+v2.extdeps.formatters.lean4_format
+v2.extdeps.formatters.prettier
+v2.extdeps.formatters.rustfmt
+v2.extdeps.formatters.swift_format
+v2.extdeps.frameworks.react
+v2.extdeps.github.diagnostic_emit
+v2.extdeps.github.expression_fidelity
+v2.extdeps.github.gha_fold_pilot_emit
+v2.extdeps.languages.c
+v2.extdeps.languages.c_bool_literal_emit
+v2.extdeps.languages.c_decl
+v2.extdeps.languages.cpp
+v2.extdeps.languages.ecmascript
+v2.extdeps.languages.english
+v2.extdeps.languages.gha_workflow_yaml_fold
+v2.extdeps.languages.go
+v2.extdeps.languages.java
+v2.extdeps.languages.kotlin
+v2.extdeps.languages.lean
+v2.extdeps.languages.machine_code
+v2.extdeps.languages.ptx
+v2.extdeps.languages.rust
+v2.extdeps.languages.rust_emit_small_test
+v2.extdeps.languages.rust_execution_test
+v2.extdeps.languages.rust_freemonoid_char_test
+v2.extdeps.languages.rust_sg2_mode2_test
+v2.extdeps.languages.rust_sg_rc_layering_test
+v2.extdeps.languages.rust_test
+v2.extdeps.languages.rust_translate_underived_test
+v2.extdeps.languages.rust_wire_serde
+v2.extdeps.languages.rust_wrap_decision_test
+v2.extdeps.languages.swift
+v2.extdeps.languages.verilog
+v2.extdeps.languages.wasm
+v2.extdeps.posix
+v2.extdeps.runtimes.effect_io_host_grant
+v2.extdeps.runtimes.v2_effect_io_host
+v2.lens.affected_set
+v2.lens.affected_set.entry_selection
+v2.lens.affected_set_examples
+v2.lens.application
+v2.lens.application_serializer
+v2.lens.common.algebraic_composition
+v2.lens.common.chain_generalization
+v2.lens.common.graph_invariant
+v2.lens.common.outside_modeled_guarantee_join
+v2.lens.common.source_analysis_standing
+v2.lens.complexity
+v2.lens.complexity_accumulator_copy.corpus_census
+v2.lens.complexity_accumulator_copy.corpus_gate
+v2.lens.complexity_accumulator_copy.roster_gate
+v2.lens.complexity_linearity_audit
+v2.lens.complexity_lowering
+v2.lens.cost.expr
+v2.lens.cost.summary
+v2.lens.cost.valuation
+v2.lens.coverage
+v2.lens.dependency_fidelity
+v2.lens.discrimination
+v2.lens.disposition_redundancy
+v2.lens.doc_reachability
+v2.lens.duplicate_computation
+v2.lens.edit_locus
+v2.lens.effect
+v2.lens.effect_reach
+v2.lens.emitted_binary_effect_confinement
+v2.lens.enforcement.complexity_contract_subject
+v2.lens.enforcement.contract
+v2.lens.enforcement.cost_coverage
+v2.lens.enforcement.gate
+v2.lens.enforcement.grammar_coverage
+v2.lens.enforcement.inventory
+v2.lens.enforcement.lens_module_gate
+v2.lens.enforcement.receipts
+v2.lens.enforcement.standing_intent
+v2.lens.enforcement.vocab
+v2.lens.extdeps_shape_transport_policy
+v2.lens.extdeps_shape_transport_policy.module_refs
+v2.lens.fact_cardinality
+v2.lens.fallback_arm_census
+v2.lens.fn_family
+v2.lens.fn_index_depth_agreement
+v2.lens.grounding
+v2.lens.grounding_ledger
+v2.lens.host_language_transport_script
+v2.lens.idempotency
+v2.lens.identical_variant_payload
+v2.lens.identity_captured_navigation
+v2.lens.identity_captured_navigation.analyze
+v2.lens.identity_captured_navigation.fidelity
+v2.lens.identity_captured_navigation.roster_gate
+v2.lens.inert_carrier
+v2.lens.intent_linearity
+v2.lens.interface_summary
+v2.lens.languages_consumer_census
+v2.lens.leaf_model_verification
+v2.lens.live_read_classification
+v2.lens.mandatory_tag.corpus_scan
+v2.lens.mandatory_tag.corpus_scan_witness_test
+v2.lens.manufactured_dependency_census
+v2.lens.meta_exec_confinement
+v2.lens.mock_totality
+v2.lens.module_impact_query
+v2.lens.mutation_adequacy
+v2.lens.no_dual_representation_test
+v2.lens.no_dual_representation_test.scan
+v2.lens.non_fold_residue
+v2.lens.ownership
+v2.lens.parallelism
+v2.lens.production_qualification_origin_probe
+v2.lens.realization_vocabulary_containment
+v2.lens.reference_deps
+v2.lens.reference_derived_residency_reading
+v2.lens.registry
+v2.lens.registry.completeness
+v2.lens.registry.completeness_test
+v2.lens.roster_registry
+v2.lens.schedule_lens
+v2.lens.simulated_relationship
+v2.lens.structural_resolution
+v2.lens.structural_similarity
+v2.lens.subsumption
+v2.lens.synthesis
+v2.lens.table_decision_tree
+v2.lens.test_migration_debt
+v2.lens.testgen
+v2.lens.unused_parameters
+v2.lens.vacuity
+v2.lens.vacuity_self_application_fixture
+v2.lens.visibility
+v2.lens.wiring_liveness
+v2.lens.wiring_liveness_preflight
+v2.lens.witness_cost_locality
+v2.native_lane_fixture.control
+v2.program
+v2.std.change
+v2.std.compilers.coproduct_variant_shape
+v2.std.compilers.semantic_decl_emission
+v2.std.concept_index
+v2.std.data_index
+v2.std.data_initializer_identity
+v2.std.datetime
+v2.std.declaration_marker
+v2.std.dependents
+v2.std.effect_reach
+v2.std.effects
+v2.std.emit_on_demand
+v2.std.execution_envelope
+v2.std.execution_surface
+v2.std.float
+v2.std.generic_instantiation
+v2.std.inhabitant_neutralization
+v2.std.layer_import_scan
+v2.std.leaf_model_verification
+v2.std.lens_verdict
+v2.std.live_read
+v2.std.materialize
+v2.std.native_agreement
+v2.std.node_minimal
+v2.std.node_reflection
+v2.std.patch
+v2.std.probe_selector
+v2.std.program_segment
+v2.std.projection
+v2.std.report
+v2.std.rust_leaf_model_claim
+v2.std.spine
+v2.std.timeseries_signal
+v2.std.value_carrier
+v2.std.witness_evaluation
+v2.std.witness_execution_routing
+v2.test.algebra_laws.field_patch_monoid
+v2.test.algebra_laws.is_prefix_of_prefix_check
+v2.test.algebra_laws.nat_semiring
+v2.test.boundary.english_ingest_fail_closed
+v2.test.branch_dispatch.rung_0_to_2_three_targets
+v2.test.branch_dispatch.rung_3_4
+v2.test.branch_dispatch.rung_8
+v2.test.claim.affected_set_universe
+v2.test.claim.algebra.freemonoid_first_skip_witness
+v2.test.claim.algebra.generic_alias_coproduct_instantiation
+v2.test.claim.algebra.list_linear_combinators
+v2.test.claim.auth_declared_but_unwired_witness
+v2.test.claim.bash_build_round_trip
+v2.test.claim.bash_command_fold
+v2.test.claim.bash_program_fold
+v2.test.claim.bash_program_fold_support
+v2.test.claim.body_lowering.arrow_body_form_semantic_helpers
+v2.test.claim.body_lowering.arrow_body_form_witness
+v2.test.claim.body_lowering.atom_body_discriminator_helpers
+v2.test.claim.body_lowering.data_initializer_fn_value
+v2.test.claim.body_lowering.declaration_structure_preserved
+v2.test.claim.body_lowering.fn_body_seam_witness_helpers
+v2.test.claim.body_lowering.frontier_three_state
+v2.test.claim.body_lowering.infer_transform_binary_infix_witness_helpers
+v2.test.claim.body_lowering.infer_transform_binary_infix_witness_test
+v2.test.claim.body_lowering.match_as_field_name
+v2.test.claim.body_lowering.normalize_outcome_helpers
+v2.test.claim.body_lowering.single_arm_match
+v2.test.claim.body_lowering.statement_let_bind
+v2.test.claim.body_lowering.wave1_gate1_a1_symbol_index_helpers
+v2.test.claim.body_lowering.wave1_gate1_b1_bare_call_helpers
+v2.test.claim.body_lowering.wave1_gate1_c1_copied_port_helpers
+v2.test.claim.body_lowering.wave1_gate1_d_ingested_fixture_helpers
+v2.test.claim.body_lowering.wave1_gate1_d_table_fixture_helpers
+v2.test.claim.body_lowering.wave1_gate1_normalize_add_helpers
+v2.test.claim.body_lowering_block_body_call
+v2.test.claim.body_lowering_qualified_path
+v2.test.claim.body_lowering_well_formed_wall
+v2.test.claim.body_lowering_wrapper_retained
+v2.test.claim.bootstrap
+v2.test.claim.build_artifact_verification_witness
+v2.test.claim.build_transport_admission_witness
+v2.test.claim.build_workspace_grant_witness
+v2.test.claim.byte_cardinality_grounding
+v2.test.claim.c_compilation_unit_witness
+v2.test.claim.cardinality_fold_propagation
+v2.test.claim.cargo_build_run_argv_witness
+v2.test.claim.ci_placement_witness
+v2.test.claim.compilation_unit_witness
+v2.test.claim.compiler.compile_eval_thesis_proof
+v2.test.claim.compiler.infer_application_argument_inhabitance_witness_test
+v2.test.claim.compiler_materialization_witness
+v2.test.claim.complexity.accumulator_copy_corpus_path_test
+v2.test.claim.complexity.accumulator_copy_roster_gate
+v2.test.claim.complexity.accumulator_copy_roster_gate_lean_bash
+v2.test.claim.complexity.accumulator_copy_roster_gate_std
+v2.test.claim.complexity.accumulator_copy_roster_gate_swift
+v2.test.claim.complexity.accumulator_copy_roster_standing
+v2.test.claim.complexity.accumulator_copy_unreadable_subject
+v2.test.claim.complexity_contract_subject_partition_witness
+v2.test.claim.computation_identity_test
+v2.test.claim.concept_index_enumeration
+v2.test.claim.construction_justification.outside_modeled_guarantee_witness_test
+v2.test.claim.cross_tree_import_model
+v2.test.claim.dag_acceptance
+v2.test.claim.dag_acceptance_rustc_wet
+v2.test.claim.declaring_identity_spelling.production_ingest
+v2.test.claim.declaring_identity_spelling.verdict_fold
+v2.test.claim.determinism_contract_test
+v2.test.claim.diagnostic_sequence_outcome_witness
+v2.test.claim.discovery_enumeration_test
+v2.test.claim.effect_demand.effect_demand_census_test
+v2.test.claim.effect_demand.effect_demand_floor_join_test
+v2.test.claim.effect_io_host_grant_witness
+v2.test.claim.effect_plan_bash_materialize_test
+v2.test.claim.emit.trait_derive_supplemental_generic_bound_contract
+v2.test.claim.emitted_binary_effect_confinement_red_control
+v2.test.claim.enforcement.cost_coverage_witness
+v2.test.claim.enforcement.determinism_transitive_witness
+v2.test.claim.enforcement.grammar_coverage_witness
+v2.test.claim.enforcement.lens_module_gate_witness
+v2.test.claim.enforcement_inventory_witness
+v2.test.claim.enforcement_live_witness
+v2.test.claim.execution.eval_bind_non_bind_interpreter_rejects
+v2.test.claim.fallback_arm_census_planted
+v2.test.claim.floor_discovery_source_authority_test
+v2.test.claim.floor_non_verdict_admission_test
+v2.test.claim.fold_list_generic_instantiation
+v2.test.claim.fold_lowering
+v2.test.claim.generated_conformance_floor
+v2.test.claim.gha_workflow_yaml_fold_serialize
+v2.test.claim.gha_workflow_yaml_fold_structural
+v2.test.claim.gpt_oss_120b_resolution
+v2.test.claim.grammar.formal_productions_for_lhs
+v2.test.claim.grammar.validate_grammar
+v2.test.claim.grounding_lens
+v2.test.claim.host_build_environment_row
+v2.test.claim.identity_captured_navigation_roster_gate
+v2.test.claim.infer_self_grounding_wall
+v2.test.claim.infer_semantics_witness
+v2.test.claim.integer.interval_derivation
+v2.test.claim.integer.value_set_decode_reason
+v2.test.claim.interface_summary.interface_summary_firewall
+v2.test.claim.interface_summary.typed_module_key
+v2.test.claim.layer_transition
+v2.test.claim.lean_bit_width_admissibility_witness
+v2.test.claim.lean_overflow_semantics_witness
+v2.test.claim.live_tree.live_tree_collision
+v2.test.claim.live_tree.live_tree_import_peer
+v2.test.claim.local_binding_shadow
+v2.test.claim.local_binding_shadow_compile
+v2.test.claim.local_binding_shadow_peer
+v2.test.claim.local_repo_wet_terminal_test
+v2.test.claim.locality_affinity_witness
+v2.test.claim.long.body_lowering_atom_body_discriminator_witness
+v2.test.claim.long.effect_reach_test
+v2.test.claim.long.identity_captured_navigation_roster_gate
+v2.test.claim.long.live_read_classification_test
+v2.test.claim.long.native_routing_membership_receipt_test
+v2.test.claim.loop_infer_iteration
+v2.test.claim.loop_multiplicity_measure
+v2.test.claim.machine_shape_construction_wall
+v2.test.claim.manual.cross_tree_constructor_binding_test
+v2.test.claim.map_carrier_shape_gate
+v2.test.claim.module_own_declaration_importer_alpha
+v2.test.claim.module_own_declaration_peer_alpha
+v2.test.claim.module_own_declaration_peer_beta
+v2.test.claim.module_own_declaration_wins
+v2.test.claim.module_resolution_plan_witness
+v2.test.claim.module_storage_binding
+v2.test.claim.name_resolve_cross_tree_resolution
+v2.test.claim.namespace_graft.collapsed_reader_test
+v2.test.claim.namespace_graft.graft_shape_test
+v2.test.claim.namespace_graft.marker_strip_test
+v2.test.claim.namespace_graft.normalize_graft_witness_helpers
+v2.test.claim.namespace_graft.zero_metadata_test
+v2.test.claim.namespace_xl0.call_argument_mention_survival
+v2.test.claim.namespace_xl0.cross_module_reference_resolution
+v2.test.claim.namespace_xl0.field_type_tree_presence
+v2.test.claim.namespace_xl0.qualified_site_enumerator_differential
+v2.test.claim.namespace_xl0.repair_input_origin_denominator
+v2.test.claim.native_cache_fusion_test
+v2.test.claim.native_census.whole_tree_census_resolve
+v2.test.claim.normalized_tree_admission
+v2.test.claim.operand_flow_witness
+v2.test.claim.parse.test_data_decl_parse
+v2.test.claim.parse.test_marker_channel
+v2.test.claim.parse_engine_hooks_test
+v2.test.claim.port_locus_classification
+v2.test.claim.proactive_verification_ledger_witness
+v2.test.claim.product_receipt_evidence_cause_swap_test
+v2.test.claim.provenance.cross_file_provenance
+v2.test.claim.provenance.loaded_carrier_receipts
+v2.test.claim.qualified_name.freemonoid_eq_witness
+v2.test.claim.qualified_name.from_dotted_string
+v2.test.claim.qualified_name.path_algebra_test
+v2.test.claim.rc_probe_wire_decode_call
+v2.test.claim.realization_runner_witness
+v2.test.claim.realize_advisory_soundness_test
+v2.test.claim.reference_derived_graph_call_arg_tree
+v2.test.claim.reference_derived_graph_fixture
+v2.test.claim.reference_derived_graph_production_ingest
+v2.test.claim.reference_derived_graph_witness
+v2.test.claim.reference_derived_residency_reading
+v2.test.claim.regen_convergence_transaction_witness_test
+v2.test.claim.repair_input_origin_split_witness_test
+v2.test.claim.roster_registry_test
+v2.test.claim.rust_crate_partition_witness
+v2.test.claim.self_host.ancestry_witness
+v2.test.claim.self_host.crate_layout_witness
+v2.test.claim.self_host.direct_rust_door_emission_witness_test
+v2.test.claim.self_host.direct_rust_door_fixture_containment_witness_test
+v2.test.claim.self_host.emit_coverage_frontier_test
+v2.test.claim.self_host.emitter_producer_provenance_witness
+v2.test.claim.self_host.frontier_probe_cause_location
+v2.test.claim.self_host.frontier_probe_cause_location_roundtrip
+v2.test.claim.self_host.frontier_probe_empty_ingest
+v2.test.claim.self_host.frontier_probe_semantic_family_receipt
+v2.test.claim.self_host.native_agreement_label_probe_test
+v2.test.claim.self_host.native_agreement_rejected_actual_test
+v2.test.claim.self_host.native_agreement_test
+v2.test.claim.self_host.native_routing_frontier_test
+v2.test.claim.self_host.parity_window_test
+v2.test.claim.self_host.peano_nat_structural_realization_test
+v2.test.claim.self_host.production_qualification_origin_probe_structural_fixture
+v2.test.claim.self_host.production_qualification_origin_probe_witness_test
+v2.test.claim.self_host.rust_module_emission_population
+v2.test.claim.self_host.seed_retention_frontier_test
+v2.test.claim.self_host.stage0_executable_assembly_test
+v2.test.claim.self_host.subject_evidence_cause_swap_witness_test
+v2.test.claim.self_host.v2_emitter_direct_rust_door_contract
+v2.test.claim.self_host.verdict_failure_kind_witness_test
+v2.test.claim.self_host.wave1_gate1_a1_fn_body_seam_witness
+v2.test.claim.self_host.wave1_gate1_a1_symbol_index_body_producer_witness
+v2.test.claim.self_host.wave1_gate1_c1_copied_port_derivation_witness
+v2.test.claim.self_host.wave1_gate1_d_mvp_subsumption_witness
+v2.test.claim.self_host.witness_bulk_routing_test
+v2.test.claim.self_host.witness_entry_eligibility_census_classification_test
+v2.test.claim.shell_emission_authorization_test
+v2.test.claim.source_root_tagging
+v2.test.claim.sql_create_table_fold
+v2.test.claim.stage0_partition_rebuild_scope_witness
+v2.test.claim.stage0_partition_roster_layout_join_witness
+v2.test.claim.staged_front_end
+v2.test.claim.staging
+v2.test.claim.symbol_identity_semantics
+v2.test.claim.symbol_index.containment
+v2.test.claim.target_model_external_authority_decode
+v2.test.claim.target_model_survivor_witness
+v2.test.claim.trait_derive_completeness_predicate
+v2.test.claim.translate_underived_refusal
+v2.test.claim.undecidable_verdict_collapse_wall_test
+v2.test.claim.use_site_verdict_test
+v2.test.claim.vacuity_consumer_witness
+v2.test.claim.verilog_interlock_emission_test
+v2.test.claim.witness_admission_test
+v2.test.claim.witness_cost_locality_test
+v2.test.claim.witness_exclusion_reconciliation_test
+v2.test.claim.wrap_decision_gate_smoke
+v2.test.claim.wrap_decision_predicate
+v2.test.claim_pipeline.infer
+v2.test.claim_pipeline.normalize
+v2.test.claim_pipeline.resolve
+v2.test.cli.v2_native_cli
+v2.test.coercion_fold_int_rust_fixture
+v2.test.compile_door_ledger_ownership
+v2.test.compiler.pipeline.corpus
+v2.test.compiler.pipeline.infer_stage
+v2.test.compiler.pipeline.lower_stage
+v2.test.compiler.pipeline.stage_bridge
+v2.test.compiler.pipeline.tokenize_stage
+v2.test.complexity_gate.budget_roster_completeness
+v2.test.complexity_gate.lens_subject_body_supply
+v2.test.complexity_gate.source_bridged_add_budget
+v2.test.complexity_gate.source_bridged_bind_budget
+v2.test.complexity_gate.source_bridged_branch_budget
+v2.test.complexity_gate.source_bridged_loop_budget
+v2.test.complexity_gate.source_bridged_pipeline_bridge
+v2.test.complexity_gate.subject_complexity_budget_roster
+v2.test.complexity_gate.table_fixture_add_subject_producer
+v2.test.complexity_gate.table_fixture_bind_subject_producer
+v2.test.complexity_gate.table_fixture_branch_subject_producer
+v2.test.complexity_gate.table_fixture_loop_subject_producer
+v2.test.complexity_gate.table_fixture_match_subject_producer
+v2.test.computation_shapes.branch_dispatch
+v2.test.computation_shapes.loop_linear_bound
+v2.test.diagnostic_correction.show_correct_code
+v2.test.discrimination_gate.discrimination_roster
+v2.test.doc_reachability.lens_unit.verdict_flip_test
+v2.test.duplicate_computation.duplicate_computation
+v2.test.duplicate_computation.placement_grain_witness
+v2.test.emit.bool_literal_projection
+v2.test.emit.c_semantic_decl_routing
+v2.test.emit.conditional_delimiting
+v2.test.emit.decl_emit_consolidated
+v2.test.emit.emit_module_contribution
+v2.test.emit.fold_call_closure_fixture
+v2.test.emit.produced_decl_support_preserved
+v2.test.emit.produced_decl_two_target
+v2.test.emit.rust_bind_let_emit
+v2.test.emit.rust_binop_emit
+v2.test.emit.rust_body_add_emit
+v2.test.emit.rust_call_emit
+v2.test.emit.rust_conditional_emit
+v2.test.emit.rust_field_access_emit
+v2.test.emit.rust_fold_call_closure_emit
+v2.test.emit.rust_freemonoid_char_string_grounding
+v2.test.emit.rust_literal_bind_emit
+v2.test.emit.rust_logic_complement_emit
+v2.test.emit.rust_logic_meet_join_emit
+v2.test.emit.rust_loop_emit
+v2.test.emit.rust_match_emit
+v2.test.emit.rust_produced_decl_emit
+v2.test.emit.rust_production_closure_let_emit
+v2.test.emit.rust_record_construct_emit
+v2.test.emit.rust_signature_general_emit
+v2.test.emit.rust_variant_construct_emit
+v2.test.emit.semantic_decl_all_lex_parity
+v2.test.emit.semantic_decl_binding_keys_parity
+v2.test.emit.semantic_decl_decoration_binding_test
+v2.test.emit.semantic_decl_emit_substrings_test
+v2.test.emit.semantic_decl_lex_binding_parity
+v2.test.emit.semantic_decl_lookup_receipt_test
+v2.test.emit.semantic_decl_profile_codec
+v2.test.emit.semantic_decl_profile_path_parity
+v2.test.emit.semantic_decl_routing
+v2.test.emit.semantic_decl_routing_generic
+v2.test.emit.semantic_decl_rules_parity_test
+v2.test.emit.semantic_decl_serialize_parity
+v2.test.emit.semantic_decl_string_codec
+v2.test.emit.semantic_decl_target_refusal
+v2.test.emit.std_logic_selfhost_witness
+v2.test.emit.target_text_carrier
+v2.test.emit.trait_derive_seed_emit_binding_test
+v2.test.emit.type_alias_emit
+v2.test.emit_host_gate.target_coverage_completeness
+v2.test.execution.bind_round_trip
+v2.test.execution.branch_eval_by_execution
+v2.test.execution.branch_if_then_else_round_trip
+v2.test.execution.c_add_emit_host_run
+v2.test.execution.c_type_decl_emit_host_run
+v2.test.execution.dag_add_emit_round_trip
+v2.test.execution.dag_binding_denotation
+v2.test.execution.effect_io_eval_by_execution
+v2.test.execution.emit_host_add_equals_eval
+v2.test.execution.emit_host_complement_equals_eval
+v2.test.execution.emit_host_field_access_equals_eval
+v2.test.execution.emit_host_filesystem_read_equals_eval
+v2.test.execution.emit_host_fold_closure_equals_eval
+v2.test.execution.emit_host_loop_equals_eval
+v2.test.execution.emit_host_match_equals_eval
+v2.test.execution.emit_host_meet_join_equals_eval
+v2.test.execution.emit_host_module_equals_eval
+v2.test.execution.emit_host_shell_exec_run_equals_eval
+v2.test.execution.emit_host_transport_wire
+v2.test.execution.emit_host_variant_construct_equals_eval
+v2.test.execution.emit_ingest_grammar_relation_round_trip
+v2.test.execution.emit_ingest_python_same_language_round_trip
+v2.test.execution.emit_ingest_type_decl_round_trip
+v2.test.execution.emit_ingest_typescript_same_language_round_trip
+v2.test.execution.emit_on_demand_classical_not_ingested_family_witness
+v2.test.execution.emit_on_demand_complement_family_witness
+v2.test.execution.emit_on_demand_family_crate_witness
+v2.test.execution.emit_on_demand_field_access_family_witness
+v2.test.execution.emit_on_demand_kernel_witness
+v2.test.execution.emit_on_demand_match_loop_fold_family_witness
+v2.test.execution.emit_on_demand_meet_join_family_witness
+v2.test.execution.emit_on_demand_variant_construct_family_witness
+v2.test.execution.floor_diff_observe_witness
+v2.test.execution.fold_assembly_round_trip
+v2.test.execution.infer_atom_grounding_rules
+v2.test.execution.infer_product_introduction
+v2.test.execution.loop_round_trip
+v2.test.execution.match_bool_round_trip
+v2.test.execution.native_selected_witness_bundle
+v2.test.execution.native_selected_witness_bundle_production
+v2.test.execution.proactive_verification_ledger_overlap_execution
+v2.test.execution.rust_emit_host_call_equals_eval
+v2.test.execution.rust_record_construct_emit_host_equals_eval
+v2.test.execution.self_host_candidate_generation
+v2.test.execution.self_host_candidate_generation_stage_verdicts
+v2.test.execution.self_host_compiler_closure_emit
+v2.test.execution.self_host_fixed_point
+v2.test.execution.typescript_closure_emit_by_execution
+v2.test.execution.typescript_enum_union_emit_by_execution
+v2.test.execution.typescript_import_emit_by_execution
+v2.test.extdeps.coordination_claims
+v2.test.extdeps.formats.spice_passive_projection
+v2.test.extdeps.spice_element_letter
+v2.test.extdeps.spice_rc_passive_deck_claims
+v2.test.extdeps_react.structural_receipts
+v2.test.extdeps_shape_transport_policy.corpus.cargo_build_policy_leak
+v2.test.extdeps_shape_transport_policy.corpus.cargo_clippy_dead_param
+v2.test.extdeps_shape_transport_policy.corpus.cargo_doc_dead_param
+v2.test.extdeps_shape_transport_policy.corpus.cargo_doc_policy_leak
+v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_dead_param
+v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_policy_leak
+v2.test.extdeps_shape_transport_policy.corpus.cargo_run_dead_param
+v2.test.extdeps_shape_transport_policy.corpus.gcp_login_dead_param
+v2.test.extdeps_shape_transport_policy.corpus.gcp_oauth_fusion_fork
+v2.test.extdeps_shape_transport_policy.corpus.gist_create_policy_leak
+v2.test.extdeps_shape_transport_policy.corpus.git_policy_leak
+v2.test.extdeps_shape_transport_policy.corpus.runtime_local_embedded_policy
+v2.test.extdeps_shape_transport_policy.coverage_domain_equivalence
+v2.test.extdeps_shape_transport_policy.coverage_domain_equivalence_module_refs
+v2.test.extdeps_shape_transport_policy.coverage_domain_equivalence_test
+v2.test.extdeps_shape_transport_policy.lens_unit.clean_gist_create
+v2.test.extdeps_shape_transport_policy.lens_unit.clean_git_diff
+v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_cargo_build
+v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_cargo_clippy
+v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_gcp_login
+v2.test.extdeps_shape_transport_policy.lens_unit.embedded_policy_literal_local
+v2.test.extdeps_shape_transport_policy.lens_unit.module_path_rename
+v2.test.extdeps_shape_transport_policy.lens_unit.module_source_nickname_literal_coverage_domain_green
+v2.test.extdeps_shape_transport_policy.lens_unit.module_source_nickname_literal_green
+v2.test.extdeps_shape_transport_policy.lens_unit.module_source_nickname_literal_local_red
+v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_build
+v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_doc
+v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_fmt
+v2.test.extdeps_shape_transport_policy.lens_unit.transport_fusion_gcp_oauth
+v2.test.fact_cardinality.lens_unit.synthetic_fork_red
+v2.test.fact_cardinality.lens_unit.synthetic_unified_green
+v2.test.filesystem.filesystem_read_dag_file
+v2.test.fixture.compile_clean_scope.scope_importer
+v2.test.fixture.compile_clean_scope.scope_isolated
+v2.test.fixture.compile_clean_scope.scope_shared
+v2.test.fixture.compiler_closure_scope_receipt
+v2.test.fixture.coproduct_reflection_generic_wrapper
+v2.test.fixture.dag_add_fn_round_trip_fixture
+v2.test.fixture.declaring_identity_spelling.call_only
+v2.test.fixture.declaring_identity_spelling.cross_consumer
+v2.test.fixture.declaring_identity_spelling.cross_provider
+v2.test.fixture.declaring_identity_spelling.field_vs_parameter
+v2.test.fixture.declaring_identity_spelling.matched_type_vs_value
+v2.test.fixture.declaring_identity_spelling.shorter
+v2.test.fixture.declaring_identity_spelling.value_outside_call
+v2.test.fixture.derivable_coercion_task_id
+v2.test.fixture.frontier_probe_cause_location_manifest_fixture
+v2.test.fixture.frontier_probe_elision_boundary_overlay
+v2.test.fixture.interface_summary.firewall_body_v1
+v2.test.fixture.interface_summary.firewall_body_v2
+v2.test.fixture.interface_summary.firewall_sig_variant
+v2.test.fixture.meta_exec_confinement_scan.leak_plant
+v2.test.fixture.realization_vocab_scan.leak_plant
+v2.test.fixture.spice_rc_passive_deck
+v2.test.fixture.spice_rc_tran_deck
+v2.test.fixture.task_manager_demo
+v2.test.fixture.transport_script_scan.bare_string_literal_plant
+v2.test.fixture.transport_script_scan.let_bound_literal_plant
+v2.test.floor.bash_command_serialization_cost_model
+v2.test.floor.pure_producer_share_refusal
+v2.test.floor_changed_witness
+v2.test.floor_cost_debt_edit
+v2.test.floor_enrolment_margin
+v2.test.floor_prepared_effect_input_ladder
+v2.test.fn_family.lens_unit.discriminators_test
+v2.test.formats.spice_rc_ngspice_oracle
+v2.test.generated.algebra_law_conformance
+v2.test.generated.coproduct_exhaustiveness
+v2.test.generated.cross_representation_equality
+v2.test.generated.idempotent_operation_conformance
+v2.test.generated.language_behavior_equivalence
+v2.test.generated.lbe_anchor_manifest
+v2.test.generated.refinement_preservation
+v2.test.generated.refinement_preservation_anchor_manifest
+v2.test.generated.testgen_category_wishlist
+v2.test.generated.witness_validity
+v2.test.git_import_authority
+v2.test.graph_invariant.lens_unit.reach_kernel_test
+v2.test.graph_invariant.reach_repair_witness_test
+v2.test.grounding_go.family_receipt
+v2.test.grounding_go.sg_claims
+v2.test.grounding_go.subject_roster
+v2.test.grounding_typescript.sg_claims
+v2.test.host_language_transport_script.corpus.facts_readback_verdict_perturb
+v2.test.host_language_transport_script.corpus.migrated_transports_clean
+v2.test.host_language_transport_script.corpus.wall_residue_live
+v2.test.host_language_transport_script.lens_unit.transport_script_position
+v2.test.host_language_transport_script.scanner.bare_string_literal
+v2.test.host_language_transport_script.scanner.let_bound_literal
+v2.test.impossible_bug.idempotency_contract
+v2.test.impossible_bug.nested_optional_flatten
+v2.test.impossible_bug.release_demos
+v2.test.impossible_bug.suboptimal_complexity
+v2.test.impossible_bug.transport_type_drift
+v2.test.impossible_bug.unenumerated_effects
+v2.test.impossible_bug.unhandled_diagnostic_paths
+v2.test.intent_linearity.lens_unit.discriminators
+v2.test.intent_linearity.lens_unit.runtime_axis
+v2.test.language_model.python_l1_static
+v2.test.language_model.python_r1
+v2.test.language_model.rust
+v2.test.language_model.rust_r1
+v2.test.language_model.rust_r3_internal
+v2.test.languages_consumer_census.corpus.data_decl_ratchet
+v2.test.languages_consumer_census.corpus.per_language_row_ratchet
+v2.test.languages_consumer_census.corpus.rust_language_external_consumer
+v2.test.languages_consumer_census.corpus.rust_spec_external_consumer
+v2.test.languages_consumer_census.corpus.rust_statements_composition_only
+v2.test.lens_application.application_subterm_at_empty_path
+v2.test.lens_application.apply_lens_enforce_uses_projection
+v2.test.lens_application.apply_lens_introspect_rejection_is_advisory
+v2.test.lens_application.empty_required_lenses_skip_gate
+v2.test.lens_application.enforce_rejecting_gate_fires
+v2.test.lens_application.introspect_clean_tree_passes
+v2.test.lens_application.rejecting_lens_blocks_before_compile
+v2.test.lens_application.required_lens_coverage_join
+v2.test.lens_application.serialize_applied_diff_swap_operands
+v2.test.lens_application.sg_claims
+v2.test.lens_application.substitute_at_ambiguous_duplicate_name
+v2.test.lens_application.substitute_at_depth_three
+v2.test.lens_application.substitute_at_depth_two
+v2.test.lens_application.subterm_at_ambiguous_duplicate_name
+v2.test.lens_common.infer_fixture
+v2.test.lens_complexity.algebra_receipts
+v2.test.lens_complexity.map_id
+v2.test.lens_complexity.nested
+v2.test.lens_complexity.typescript_type_alias_task
+v2.test.lens_complexity.while_external_condition
+v2.test.lens_complexity_accumulator_copy
+v2.test.lens_complexity_lowering.catalog_sound
+v2.test.lens_complexity_lowering.loop_invariant_hoist
+v2.test.lens_cost.arrow_body_cost_domain_excluded
+v2.test.lens_cost.atom_zero
+v2.test.lens_cost.bounded_summation
+v2.test.lens_cost.copied_port_derivation
+v2.test.lens_cost.disj_alternative_floor
+v2.test.lens_cost.disj_max
+v2.test.lens_cost.expr_refusal
+v2.test.lens_cost.loop_illegal_named
+v2.test.lens_cost.loop_iteration_floor
+v2.test.lens_cost.loop_linear
+v2.test.lens_cost.loop_unknown
+v2.test.lens_cost.map_linear
+v2.test.lens_cost.nested_product
+v2.test.lens_cost.p9_llvm_instruction_cost_registry_owner
+v2.test.lens_cost.summary_span
+v2.test.lens_cost.valuation
+v2.test.lens_coverage.discriminant_predicate_defect_key
+v2.test.lens_coverage.hollow_type_defect_key
+v2.test.lens_coverage.near_miss_vacuous_not_parallel
+v2.test.lens_coverage.parallel_authority_defect_key
+v2.test.lens_coverage.sibling_degenerate_not_hollow
+v2.test.lens_dependency_fidelity.dependency_fidelity_test
+v2.test.lens_determinism.reach_witness
+v2.test.lens_disposition_redundancy.disposition_redundancy_test
+v2.test.lens_doc_reachability.doc_reachability_test
+v2.test.lens_effect.effect_depends_on
+v2.test.lens_enforcement.gate_test
+v2.test.lens_fact_density.computation_not_type_carrier
+v2.test.lens_fact_density.conj_positional_only_no_fact
+v2.test.lens_fact_density.fact_bundle_compile_lens_passes
+v2.test.lens_fact_density.fact_bundle_named
+v2.test.lens_fact_density.hollow_alias_blocked_in_run_gates
+v2.test.lens_fact_density.hollow_alias_blocked_via_always_required_lenses
+v2.test.lens_fact_density.hollow_alias_compile_lens_rejects
+v2.test.lens_fact_density.hollow_alias_nested_rejected
+v2.test.lens_fact_density.hollow_alias_no_fact
+v2.test.lens_fact_density.hollow_alias_vtc_empty_lenses_rejected
+v2.test.lens_fact_density.kernel_ambient_bool
+v2.test.lens_grounding_ledger.grounding_ledger_test
+v2.test.lens_idempotency.write_effect
+v2.test.lens_identical_variant_payload.sg_claims
+v2.test.lens_identity_captured_navigation
+v2.test.lens_inert_carrier.inert_carrier_test
+v2.test.lens_lifecycle_carrier.raw_prose_field_flagged
+v2.test.lens_mock_totality.cron_mock_totality
+v2.test.lens_mock_totality.diagnostic_mock_totality
+v2.test.lens_mock_totality.filesystem_mock_totality
+v2.test.lens_mock_totality.gcp_mock_totality
+v2.test.lens_mock_totality.git_mock_totality
+v2.test.lens_mock_totality.github_mock_totality
+v2.test.lens_mock_totality.http_pilot_mock_totality
+v2.test.lens_mock_totality.llm_mock_totality
+v2.test.lens_mock_totality.sec_edgar_mock_totality
+v2.test.lens_mock_totality.sheets_mock_totality
+v2.test.lens_mock_totality.shell_mock_totality
+v2.test.lens_mock_totality.witness_template
+v2.test.lens_mutation_adequacy.mutation_adequacy_test
+v2.test.lens_non_fold_residue.non_fold_residue_test
+v2.test.lens_ownership.resource_dependency
+v2.test.lens_ownership.subject_roster
+v2.test.lens_parallelism.data_dependency
+v2.test.lens_registry.sg_claims
+v2.test.lens_structural_resolution.binds_to_resolved
+v2.test.lens_structural_resolution.claim_carrier
+v2.test.lens_structural_resolution.facts_lookup_miss
+v2.test.lens_structural_resolution.module_import_out_of_scope
+v2.test.lens_structural_resolution.unbound_symbol_at_use
+v2.test.lens_structural_resolution.unresolved_infer_witness
+v2.test.lens_synthesis.constant_not_dominated_by_linear
+v2.test.lens_synthesis.exponential_dominates_polynomial
+v2.test.lens_synthesis.factorial_dominates_exponential
+v2.test.lens_synthesis.linear_not_dominated_by_polynomial
+v2.test.lens_synthesis.polynomial_dominates_linear
+v2.test.lens_synthesis.synthesis_gap_information_theoretic
+v2.test.lens_synthesis.synthesis_gap_polynomial
+v2.test.lens_synthesis.synthesis_no_technique_diagnostic
+v2.test.lens_table_decision_tree.sg_claims
+v2.test.lens_test_migration_debt.test_migration_debt_test
+v2.test.lens_testgen.dag_input_surface
+v2.test.lens_testgen.generator_provenance
+v2.test.lens_testgen.shadow_ci_receipt
+v2.test.lens_unit_modeling.bitwidth_flat_scalar_flagged
+v2.test.lens_unit_modeling.bitwidth_modeled_passes
+v2.test.lens_unit_modeling.coordinate_index_not_flagged
+v2.test.lens_unit_modeling.electrical_blocked_pending_flagged
+v2.test.lens_unit_modeling.flat_scalar_unit_leaf_flagged
+v2.test.lens_unit_modeling.label_version_not_flagged
+v2.test.lens_unit_modeling.modeled_unit_field_admitted_via_always_required_lenses
+v2.test.lens_unit_modeling.modeled_unit_field_passes
+v2.test.lens_unit_modeling.novel_unit_flagged
+v2.test.lens_unit_modeling.unit_modeling_blocked_via_always_required_lenses
+v2.test.lens_unused_parameters.binds_to_edge
+v2.test.lens_unused_parameters.non_use_edges
+v2.test.lens_unused_parameters.rollup_unused_declaration
+v2.test.lens_vacuity.vacuity_test
+v2.test.lens_visibility.visibility_test
+v2.test.lens_wiring_liveness.wiring_liveness_corpus_test
+v2.test.lens_wiring_liveness.wiring_liveness_preflight_test
+v2.test.lens_wiring_liveness.wiring_liveness_test
+v2.test.long.a4_opacity
+v2.test.long.accumulator_copy_compile_gate
+v2.test.long.accumulator_copy_fold_analysis
+v2.test.long.add_arrow_eval_by_execution
+v2.test.long.alias_decl_parse_witness
+v2.test.long.bash_program_real_probes_witness
+v2.test.long.bind_eval_by_execution
+v2.test.long.compile_door_ledger
+v2.test.long.compiler_frontier_probe_entry
+v2.test.long.cross_tree_real_ingest_activation
+v2.test.long.cwc_resolution_probe
+v2.test.long.dag_caret_symbol_lex
+v2.test.long.dag_comma_optional_list
+v2.test.long.dag_compile_clean_scope_sigma_test
+v2.test.long.dag_import_block_lexeme_stamp
+v2.test.long.dag_repeat_spine_wellformed
+v2.test.long.decl_index_enumeration
+v2.test.long.direct_rust_door_production_group
+v2.test.long.door_real_module_probe
+v2.test.long.emit_host_classical_not_ingested_equals_eval
+v2.test.long.emit_host_native_only_verdict
+v2.test.long.emit_host_produced_module_equals_eval
+v2.test.long.fallback_arm_census_witness
+v2.test.long.free_monoid_not_diverged_green
+v2.test.long.frontier_probe_closure_matrix_integration
+v2.test.long.gap4_parse_tokens_remain
+v2.test.long.grounding_lens_whole_tree
+v2.test.long.infer_transform_binary_infix_witness
+v2.test.long.inhabitant_neutralization_e2e_witness
+v2.test.long.lattice_coexistence_debt
+v2.test.long.lattice_not_diverged_green
+v2.test.long.loop_eval_by_execution
+v2.test.long.mandatory_tag_extdeps_corpus_test
+v2.test.long.mandatory_tag_gate_witness
+v2.test.long.meta_exec_confinement_clean_tree
+v2.test.long.module_binding_host_consistency
+v2.test.long.module_storage_binding_derivation
+v2.test.long.namespace_graft_normalize_witness
+v2.test.long.parse_binding_fidelity_witness
+v2.test.long.parse_table_memo_amortization
+v2.test.long.parse_table_memo_counter_witness
+v2.test.long.parse_table_memo_governed_witness
+v2.test.long.parser_completeness_frontier
+v2.test.long.pick_ingested_probe
+v2.test.long.pick_ingested_structural_lowering
+v2.test.long.pipeline_stage_add_pick_relationship
+v2.test.long.pipeline_stage_match_corpus
+v2.test.long.production_qualification_origin_probe_witness
+v2.test.long.qualified_record_literal_parse
+v2.test.long.ratchet_baseline
+v2.test.long.realization_sweep_probe_entry
+v2.test.long.realization_vocabulary_containment_witness
+v2.test.long.s1_closure_receipt
+v2.test.long.s1_closure_receipt_support
+v2.test.long.self_host_module_emit_derisk
+v2.test.long.source_bridged_pipeline_bridge_witness
+v2.test.long.string_head_linear_witness
+v2.test.long.symbol_index_scaling_receipt
+v2.test.long.syntactic_audit_witness
+v2.test.long.typescript_descriptor_node_run_witness
+v2.test.long.typescript_import_pipeline
+v2.test.long.vacuity_consumer_witness
+v2.test.long.validate_ingest_staging_stage_bisect
+v2.test.long.variant_visibility
+v2.test.long.wave1_gate1_a1_fn_body_seam_witness
+v2.test.long.wave1_gate1_a1_symbol_index_body_producer_witness
+v2.test.long.wave1_gate1_b1_bare_call_body_producer_witness
+v2.test.long.wave1_gate1_c1_copied_port_derivation_witness
+v2.test.long.wave1_gate1_d_mvp_subsumption_witness
+v2.test.loop_linear_bound.rung_0_to_2_three_targets
+v2.test.loop_linear_bound.rung_3_4
+v2.test.loop_linear_bound.rung_8
+v2.test.manual.add_body_emit_python
+v2.test.manual.add_body_emit_typescript
+v2.test.manual.add_body_producer_claim
+v2.test.manual.add_body_value_expression_fold_typescript
+v2.test.manual.bash_command_fold_runner
+v2.test.manual.bash_emit_command
+v2.test.manual.bind_demand_driven_eval
+v2.test.manual.bind_emit
+v2.test.manual.body_lowering_infix
+v2.test.manual.body_lowering_match
+v2.test.manual.body_lowering_normalize_add
+v2.test.manual.body_lowering_projection_call
+v2.test.manual.body_lowering_variants
+v2.test.manual.bootstrap_footprint_anchor
+v2.test.manual.branch_if_then_else_emit
+v2.test.manual.branch_infer
+v2.test.manual.branch_infer_fail_open_audit
+v2.test.manual.branch_infer_if_then_else
+v2.test.manual.branch_lazy_arm_eval_acceptance
+v2.test.manual.c_add_emit_translate
+v2.test.manual.call_carrier_node_query
+v2.test.manual.caret_sigil_surface
+v2.test.manual.chained_generic_field_access
+v2.test.manual.connective_anchors
+v2.test.manual.content_hash_loop_bound_edge_order
+v2.test.manual.content_hash_named_edge_order
+v2.test.manual.coproduct_reflection_conformance
+v2.test.manual.cpp_abi_lp64_width_anchor
+v2.test.manual.cpp_add_emit_translate
+v2.test.manual.cpp_scalar_grounding_anchor
+v2.test.manual.cross_language_add_python_to_typescript
+v2.test.manual.dependency_recompute_plan
+v2.test.manual.derivable_coercion_nickname_triple
+v2.test.manual.diagnostic_assert_eval
+v2.test.manual.discriminant_intrinsic
+v2.test.manual.dissolution_subsumption_reverification
+v2.test.manual.e0599_phase_a_body_evidence_probe
+v2.test.manual.emit_directive_bash
+v2.test.manual.emit_directive_gha
+v2.test.manual.emit_directive_rust
+v2.test.manual.emit_ingest_same_language_row_fold
+v2.test.manual.emit_source_store
+v2.test.manual.english_emit_add
+v2.test.manual.eval_runtime
+v2.test.manual.fact_density_anchor
+v2.test.manual.field_access_emit
+v2.test.manual.find_witness_distinct_node_zip_fold
+v2.test.manual.find_witness_identity
+v2.test.manual.find_witness_project_to_core_controls
+v2.test.manual.floor_drain_retention
+v2.test.manual.fold_call_closure_emit
+v2.test.manual.fold_node_topdown
+v2.test.manual.fold_source
+v2.test.manual.generic_instantiation_runtime
+v2.test.manual.gha_workflow_yaml_fold_runner
+v2.test.manual.go_add_emit_translate
+v2.test.manual.go_grammar_claim
+v2.test.manual.go_language_model_anchor
+v2.test.manual.grammar_choice_ambiguity_audit
+v2.test.manual.infer_algebra_ref_grounding_anchor
+v2.test.manual.infer_bounded_lattice_completeness_anchor
+v2.test.manual.infer_emit_compile_anchor
+v2.test.manual.infer_ground_add
+v2.test.manual.ingest_bridge
+v2.test.manual.inhabitant_neutralization
+v2.test.manual.int_cross_target_coercion
+v2.test.manual.int_literal_parse_smoke
+v2.test.manual.integer_census_stage_receipt
+v2.test.manual.java_grammar_structure
+v2.test.manual.java_language_model_anchor
+v2.test.manual.json_number_integer_lexeme_anchor
+v2.test.manual.kotlin_grammar_claim
+v2.test.manual.kotlin_language_model_anchor
+v2.test.manual.language_model_dissolution
+v2.test.manual.lean_language_model_anchor
+v2.test.manual.llvm_ir_b2_omni_in_b_probe
+v2.test.manual.llvm_ir_model_core_anchor
+v2.test.manual.loop_demand_driven_eval
+v2.test.manual.loop_emit
+v2.test.manual.machine_code_model_core_anchor
+v2.test.manual.manual_anchor_manifest
+v2.test.manual.map_lookup_miss_witness_violates
+v2.test.manual.map_structural_key_equality
+v2.test.manual.match_bool_emit
+v2.test.manual.match_infer_fail_open_audit
+v2.test.manual.medium_node_instantiation
+v2.test.manual.medium_source_serializer_determinism_fidelity
+v2.test.manual.medium_source_text_instantiation
+v2.test.manual.model_core_anchor
+v2.test.manual.multi_target_emit_verification_gate
+v2.test.manual.nat_law_anchors
+v2.test.manual.node_minimal_representation_test
+v2.test.manual.nodefold_topdown_inline_algebra
+v2.test.manual.nominal_distinctness_cross_call
+v2.test.manual.outcome_diagnostics_eq
+v2.test.manual.ownership_movable
+v2.test.manual.parallel_executor
+v2.test.manual.parse_forensics_scaling_witness
+v2.test.manual.parse_mechanism_probe
+v2.test.manual.parse_table_memo_scale_witness
+v2.test.manual.parse_tree_content_hash_witness
+v2.test.manual.path_y_fidelity_successor
+v2.test.manual.pbp_body_producer_perf_repro
+v2.test.manual.posix_output_capture
+v2.test.manual.process_numeric_refinements
+v2.test.manual.program_assembly_multi_file
+v2.test.manual.program_partition_body_emit
+v2.test.manual.python_add_emit_translate
+v2.test.manual.python_grammar_claim
+v2.test.manual.qualified_pattern_reconcile
+v2.test.manual.recompute_trace_probe
+v2.test.manual.record_construct_emit
+v2.test.manual.refinement_authoritative_constants
+v2.test.manual.refinement_nonempty_list
+v2.test.manual.refinement_ordered_iteration
+v2.test.manual.resolve_compile_anchor
+v2.test.manual.retry_eagain_bash
+v2.test.manual.runtime_run
+v2.test.manual.rust_add_emit_translate
+v2.test.manual.rust_grammar_structure
+v2.test.manual.rust_language_model_anchor
+v2.test.manual.rust_wire_serde_naming_policy_test
+v2.test.manual.s1_parse_harness
+v2.test.manual.s1_stall_probe
+v2.test.manual.scheduler_runnable_frontier
+v2.test.manual.scoped_type_reflection_conformance
+v2.test.manual.sg1b_signature_realization_failclosed
+v2.test.manual.sg2_mode2_non_grammar_emit
+v2.test.manual.sg2_type_expression_projection
+v2.test.manual.sg2_typescript_type_expression_projection
+v2.test.manual.sg5_set_non_ordable_falsification
+v2.test.manual.sg_collection_projection
+v2.test.manual.sg_rc_layering
+v2.test.manual.solve_constraints_add
+v2.test.manual.sql_create_table_fold_runner
+v2.test.manual.structured_body_dispatch
+v2.test.manual.structured_body_subsumption_set
+v2.test.manual.swift_language_model_anchor
+v2.test.manual.tail_construct_parse_probe
+v2.test.manual.target_carriers_fidelity
+v2.test.manual.target_model_atom_lookup_dissolution
+v2.test.manual.target_model_operator_lookup_dissolution
+v2.test.manual.target_operation_grounding_emit_typescript
+v2.test.manual.test_claim_cache_digest_sensitivity
+v2.test.manual.timeseries_passive_map_fold_anchor
+v2.test.manual.tm_probe
+v2.test.manual.token_stream_content_hash_witness
+v2.test.manual.tokenize_linear_receipt
+v2.test.manual.typescript_add_emit_translate
+v2.test.manual.typescript_bind_let_iife_emit
+v2.test.manual.typescript_derive_grammar_relation_row_round_trip
+v2.test.manual.typescript_descriptor_node_run_support
+v2.test.manual.typescript_eager_materialize_dedup_cutover
+v2.test.manual.typescript_eager_materialize_forward_dedup
+v2.test.manual.typescript_eager_materialize_serialize
+v2.test.manual.typescript_effect_io_emit
+v2.test.manual.typescript_field_access_emit
+v2.test.manual.typescript_grammar_claim
+v2.test.manual.typescript_language_model_anchor
+v2.test.manual.typescript_pr3_typed_fn_translate
+v2.test.manual.typescript_program_emit_run
+v2.test.manual.typescript_record_construct_emit
+v2.test.manual.typescript_record_task_translate
+v2.test.manual.v2_evaluator_runtime_anchor
+v2.test.manual.validate_then_compile_public_terminal
+v2.test.manual.value_null_split_witness
+v2.test.manual.verilog_concurrency_anchor
+v2.test.manual.wasm_language_model_anchor
+v2.test.materialize.materialize_witness
+v2.test.meta_exec_confinement.lens_unit.discriminators
+v2.test.meta_exec_confinement.roster_soundness
+v2.test.meta_exec_confinement.scanner.planted_leak
+v2.test.name_resolve.admission_fail_closed
+v2.test.name_resolve.malformed_imported_root
+v2.test.name_resolve.one_member_cost_probe
+v2.test.nat_semiring.rung_0_to_2_three_targets
+v2.test.nat_semiring.rung_3_4
+v2.test.nat_semiring.rung_5
+v2.test.nat_semiring.rung_6
+v2.test.nat_semiring.rung_8
+v2.test.native_decl_selection
+v2.test.native_lane_smoke
+v2.test.no_dual_representation_test.lens_unit.controls
+v2.test.parse.alias_decl_parse
+v2.test.parse.choice_plan
+v2.test.parse.d1_declaration_grammar_parse
+v2.test.parse.d5_expression_grammar_parse
+v2.test.parse.expression_bodied_fn_decl_parse
+v2.test.parse.go
+v2.test.parse.grammar_validation_test
+v2.test.parse.kotlin
+v2.test.parse.lean
+v2.test.parse.parse_binding_fidelity
+v2.test.parse.parse_binding_fidelity_support
+v2.test.parse.parse_table_claims
+v2.test.parse.parse_table_content_key
+v2.test.parse.parse_token_first_empty_semantics
+v2.test.parse.python
+v2.test.parse.rust
+v2.test.parse.swift
+v2.test.parse.token_stream_cursor
+v2.test.parse.type_decl_modifier_g0_parse_probe
+v2.test.parse.typescript
+v2.test.parse.weather_g0_prefix_parse_probe
+v2.test.parse.where_refinement_clause_parse
+v2.test.program_assembly.real_ingest
+v2.test.provenance.occurrence_id_model
+v2.test.provenance.parse_memo_frame_replay
+v2.test.provenance.parse_stamp_span_index
+v2.test.qualified_name.from_module_node
+v2.test.realization_vocabulary_containment.cli_vocabulary.rest_path_reaches_no_cli
+v2.test.realization_vocabulary_containment.lens_unit.discriminators
+v2.test.realization_vocabulary_containment.no_new_debt_gate
+v2.test.realization_vocabulary_containment.roster_soundness
+v2.test.realization_vocabulary_containment.scanner.planted_leak
+v2.test.required_ci_measurement
+v2.test.required_floor_gate_selector
+v2.test.resolve.namespace_only_policy
+v2.test.resolve.qualified_module_projection_g1b_fixture
+v2.test.resolve.qualified_module_projection_provider
+v2.test.resolve.qualified_module_projection_resolve
+v2.test.resolve.qualified_module_projection_stripped_fixture
+v2.test.round_trip.dag_comment_wall_test
+v2.test.round_trip.dag_ingest_round_trip
+v2.test.round_trip.source_authority_contract
+v2.test.round_trip.source_authority_contract_test
+v2.test.rung_3_4_common
+v2.test.rung_5_6_common
+v2.test.runtimes.effect_io_handler_claims
+v2.test.runtimes.effect_io_host_mode
+v2.test.self_host.closure_emit_population_admission
+v2.test.self_host.compiler_closure_emit_from_ingest
+v2.test.self_host.compiler_closure_ingest_boundary_witness
+v2.test.self_host.compiler_frontier_emit_probe
+v2.test.self_host.direct_rust_door_group_algebra
+v2.test.self_host.frontier_probe_overlap_detail
+v2.test.self_host.ref_transport_coverage
+v2.test.self_host.stage0_production_target
+v2.test.simulated_relationship.lens_unit.discriminators
+v2.test.spine.spine_receipt_witness
+v2.test.std.named_child_lookup
+v2.test.std.reducible
+v2.test.std.timeseries_signal_passives
+v2.test.std_dependents.dependents_test
+v2.test.std_grounding.runtime_value_node_projection
+v2.test.std_grounding.terminal_gate
+v2.test.std_grounding.value_carrier_laws
+v2.test.std_model_core.bool_fact_lookup
+v2.test.std_text.carrier_claims
+v2.test.structural_similarity.lens_unit.discriminators
+v2.test.synthesis_gate.optimality_gap_completeness
+v2.test.synthesis_gate.subject_technique_roster
+v2.test.synthesis_gate.synthesis_subject_body_supply
+v2.test.tokenize.annotation_channel
+v2.test.tokenize.lex_match_thunk_claims
+v2.test.tokenize.lex_rule_dispatch
+v2.test.tokenize.source_text_ingress
+v2.test.tokenize.string_literal_raw_newline
+v2.test.v2_native_route
+v2.test.wet_evidence
+v2.test.workflow.body_lowering_retention_census
+v2.test.workflow.frontier_probe_closure_matrix
+v2.test.workflow.frontier_probe_closure_readthrough
+v2.test.workflow.glob_discovery_law
+v2.test.workflow.host_module_binding_manifest
+v2.test.workflow.host_source_root_ingest_manifest
+v2.test.workflow.lens_discrimination_family_eval
+v2.test.workflow.lens_effect_family_eval
+v2.test.workflow.lens_idempotency_family_eval
+v2.test.workflow.lens_leaf_model_verification_family_eval
+v2.test.workflow.lens_ownership_family_eval
+v2.test.workflow.lens_parallelism_family_eval
+v2.test.workflow.lens_subsumption_family_eval
+v2.test.workflow.lens_synthesis_family_eval
+v2.test.workflow.lens_unused_parameters_family_eval
+v2.test.workflow.product_receipt
+v2.test.workflow.source_root_overflow_never_empty_witness
+v2.workflow.bash_emit
+v2.workflow.bmc_lifecycle_roundtrip
+v2.workflow.body_lowering_retention_census
+v2.workflow.bootstrap
+v2.workflow.ci_floor_peak_emit
+v2.workflow.ci_floor_peak_emit_test
+v2.workflow.ci_heal_revalidation_preflight_emit_test
+v2.workflow.ci_materialization_emit_test
+v2.workflow.ci_placement
+v2.workflow.ci_v1_compiler_tests_compile_gate_emit
+v2.workflow.ci_v1_compiler_tests_compile_gate_emit_test
+v2.workflow.claim_cost_observation
+v2.workflow.class_b_import_closure_probe
+v2.workflow.class_b_import_closure_transport
+v2.workflow.commit_witness_claim_roster
+v2.workflow.compile_door_ledger
+v2.workflow.compiler_closure_ingest_transport
+v2.workflow.dag_acceptance
+v2.workflow.dag_acceptance_rustc
+v2.workflow.enforcement_live
+v2.workflow.executor
+v2.workflow.floor_changed_witness
+v2.workflow.floor_compile_clean_predicates
+v2.workflow.floor_cost_debt_edit
+v2.workflow.floor_diff_observe
+v2.workflow.floor_discovery_transport
+v2.workflow.floor_expected_red_coherence
+v2.workflow.floor_non_verdict_admission
+v2.workflow.floor_preparation
+v2.workflow.floor_prepared_effect_input_ladder
+v2.workflow.floor_purpose_standing
+v2.workflow.floor_purpose_standing_test
+v2.workflow.floor_subject_seed
+v2.workflow.floor_subject_seed_test
+v2.workflow.floor_terminal_ledger_test
+v2.workflow.floor_terminal_ledger_wire
+v2.workflow.floor_terminal_ledger_wire_test
+v2.workflow.gha_expression_fidelity
+v2.workflow.legacy_baseline_capture
+v2.workflow.legacy_baseline_persisted_observation
+v2.workflow.legacy_binding_delta
+v2.workflow.legacy_binding_observation
+v2.workflow.legacy_binding_projection
+v2.workflow.legacy_repair_observation
+v2.workflow.legacy_repair_tap
+v2.workflow.legacy_test_inflow_audit
+v2.workflow.locality_affinity
+v2.workflow.module_binding_supply_transport
+v2.workflow.module_resolution_plan
+v2.workflow.native_cache_fusion
+v2.workflow.operand_flow
+v2.workflow.orchestration_bash_test
+v2.workflow.orchestration_emit_test
+v2.workflow.orchestration_retry_emit_test
+v2.workflow.orchestration_tier2_emit_test
+v2.workflow.orchestration_while_emit
+v2.workflow.phase_profile_proof_plan
+v2.workflow.product_receipt
+v2.workflow.product_receipt_stage
+v2.workflow.product_receipt_transport
+v2.workflow.realization_attempt
+v2.workflow.realization_runner
+v2.workflow.realization_sweep
+v2.workflow.realize_advisory_soundness
+v2.workflow.regen_convergence_transaction
+v2.workflow.required_lane_claim_agreement
+v2.workflow.required_regen
+v2.workflow.runtime_run
+v2.workflow.scheduler
+v2.workflow.source_root_ingest_gate
+v2.workflow.source_root_ingest_transport
diff --git a/src/v1/04_method.dag b/src/v1/04_method.dag
index d26220ad5b0..69b8a3ba6f3 100644
--- a/src/v1/04_method.dag
+++ b/src/v1/04_method.dag
@@ -353,6 +353,9 @@ data builtin_function_registry: Map<String, BuiltinSignature> = {
   "compile_dag_callsite_resolved_call_edges": BuiltinSignature { params: [BuiltinParam { name: "import_modules", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "exclude_substrings", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "pool_roots", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "target_leaves", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }], returns: type_variable_node(id: "resolved_call_edge_census_result") },
   "builtin_function_registry_keys": BuiltinSignature { params: [], returns: list_of_element(element: string_type) },
   "compile_dag_primitive_call_edges": BuiltinSignature { params: [BuiltinParam { name: "exclude_substrings", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "pool_roots", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "entry_prefixes", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }], returns: type_variable_node(id: "primitive_call_edge_census_result") },
+  "source_root_ingest_module_identities": BuiltinSignature { params: [BuiltinParam { name: "source_roots", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }], returns: type_variable_node(id: "module_identity_population") },
+  "required_floor_nominal_subject_module_identities": BuiltinSignature { params: [BuiltinParam { name: "source_roots", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }], returns: type_variable_node(id: "module_identity_population") },
+  "entry_closure_module_identities": BuiltinSignature { params: [BuiltinParam { name: "source_roots", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "entry_path", ty: NamedTemplate { name: "String" } }], returns: type_variable_node(id: "module_identity_population") },
   "compile_dag_call_form_leaf_guard": BuiltinSignature { params: [BuiltinParam { name: "exclude_substrings", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "pool_roots", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "target_leaves", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "exact_resolved_roots", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }], returns: type_variable_node(id: "evaluation_store_address_production_coverage_result") },
   "parsed_import_statements": BuiltinSignature { params: [BuiltinParam { name: "file", ty: NamedTemplate { name: "String" } }, BuiltinParam { name: "source", ty: NamedTemplate { name: "String" } }], returns: type_variable_node(id: "parsed_import_statements_result") },
   "observe_declared_import_closure_symbol_binding": BuiltinSignature { params: [BuiltinParam { name: "pool_roots", ty: ContainerOf { source: Named { name: "List" }, element: NamedTemplate { name: "String" } } }, BuiltinParam { name: "entry_path", ty: NamedTemplate { name: "String" } }, BuiltinParam { name: "consumer_module", ty: NamedTemplate { name: "String" } }, BuiltinParam { name: "symbol", ty: NamedTemplate { name: "String" } }], returns: type_variable_node(id: "declared_import_closure_binding_result") },
diff --git a/src/v1/stage0/src/cli_run.rs b/src/v1/stage0/src/cli_run.rs
index 0ad8f9460af..05d8f1e7c1b 100644
--- a/src/v1/stage0/src/cli_run.rs
+++ b/src/v1/stage0/src/cli_run.rs
@@ -105,8 +105,13 @@ pub use required_floor_runner::{
 };
 pub use required_lane_roster::{authority_lane_phase_rows, LanePhaseRow};
 mod entry_resolve;
+mod required_lane_resolution_census;
 pub(crate) use active_workset::*;
 pub(crate) use entry_resolve::*;
+pub use required_lane_resolution_census::{
+    entry_closure_module_identities, required_floor_nominal_subject_module_identities,
+    source_root_ingest_module_identities, ModuleIdentityPopulation,
+};
 
 pub fn required_lane_judged_module_identities_for_ci() -> Vec<String> {
     entry_resolve::required_lane_judged_module_identities()
diff --git a/src/v1/stage0/src/cli_run/required_floor_runner.rs b/src/v1/stage0/src/cli_run/required_floor_runner.rs
index a249a41bc20..3ce70a1259c 100644
--- a/src/v1/stage0/src/cli_run/required_floor_runner.rs
+++ b/src/v1/stage0/src/cli_run/required_floor_runner.rs
@@ -3939,6 +3939,91 @@ pub(crate) fn run_discovery_rows(
     Ok(summary)
 }
 
+/// THE SEEDS OF THE REQUIRED FLOOR'S NOMINAL PREPARED SUBJECT -- what the floor prepares when a
+/// run touches nothing: the gate's prefix roster and authored-module roster, both decoded from
+/// `v2.workflow.required_floor` in a frame over that module's own closure, and the local-repo wet
+/// schedule rows whose entry modules join the module seeds. The diff-derived seeds (changed
+/// witnesses, touched entries, arm-set consumers) are NOT here: they are a fact about one run's
+/// diff, and this is the part of the subject that holds for every run.
+///
+/// ONE PRODUCER, TWO CONSUMERS, and that is the reason it is a function rather than a block in
+/// `run_required_floor`. The floor consumes it to seed preparation; the required-lane resolution
+/// census (`gunbc.required_lane_resolution_census`, `gunbc test
+/// //gunbc/instruments:required-lane-resolution-census`) consumes it to answer, for every module
+/// under the source roots, whether the floor's nominal subject resolves it. A census that
+/// re-derived the seed list from the roster would be a second authority for what the floor
+/// prepares, and it would drift the first time a seed kind was added here and not there.
+pub struct RequiredFloorNominalSubjectSeeds {
+    pub required_gate_prefixes: Vec<String>,
+    pub required_gate_authored_modules: Vec<String>,
+    pub(crate) local_repo_wet_schedule_rows: Vec<LocalRepoWetScheduledRow>,
+}
+
+/// THE LANE'S SCHEDULE IS DECODED HERE, IN THE POLICY CLOSURE, AND NOT LATER -- because its
+/// modules must become SEEDS of the prepared subject. The first CI run of that lane refused
+/// seven times with `EntryModuleOutsidePreparedSubject`: the prepared graph is the required-gate
+/// closure plus the changed set, and the lane's members are on the discovery exclusion
+/// frontier, so nothing pulled them in. A lane that cannot reach its own members cannot support
+/// the route claim `std.witness_admission` makes for its cadence, so the schedule joins the seed
+/// list rather than the executor learning to run outside the subject.
+pub fn required_floor_nominal_subject_seeds(
+    source_roots: &[String],
+    gate_entry_index: &MultiEntryIndex,
+) -> Result<RequiredFloorNominalSubjectSeeds, String> {
+    let policy_seed = [REQUIRED_FLOOR_POLICY_MODULE.to_string()];
+    let (policy_prepared, _) = prepare_repository_closure(
+        source_roots,
+        &floor_prepared_subject_exclusions(),
+        Some((gate_entry_index, &[], &policy_seed)),
+    )?;
+    let policy_scope = claim_scope_for(&policy_prepared, REQUIRED_FLOOR_POLICY_MODULE)?;
+    let policy_frame = evaluation_frame(
+        &policy_scope,
+        v1_interpreter::ExecutionMode::Hermetic,
+        None,
+        None,
+    );
+    let required_gate_prefixes = floor_decode_module_prefix_roster(
+        &policy_frame,
+        "v2.workflow.required_floor.required_gate_prefixes",
+    )?;
+    // THE GATE'S SECOND SELECTOR KIND (`v2.workflow.required_floor`
+    // `required_gate_authored_modules`, `RequiredGateSelector`): authored module NAMES,
+    // matched at segment boundaries -- the module-seed rule, not the prefix rule. They join
+    // the module seeds, so preparation and site disposition admit them under one rule by
+    // construction.
+    let required_gate_authored_modules = floor_decode_module_prefix_roster(
+        &policy_frame,
+        "v2.workflow.required_floor.required_gate_authored_modules",
+    )?;
+    let local_repo_wet_schedule_rows = local_repo_wet_schedule(&policy_frame)?;
+    Ok(RequiredFloorNominalSubjectSeeds {
+        required_gate_prefixes,
+        required_gate_authored_modules,
+        local_repo_wet_schedule_rows,
+    })
+}
+
+/// The nominal MODULE seeds (`v2.workflow.floor_subject_seed` `PreparedSubjectSeedGround`,
+/// matched at segment boundaries): the floor's own runtime authorities, the gate's authored
+/// modules, and the wet schedule's entry modules. The prefix seeds travel separately because
+/// they are matched by a different rule.
+pub(crate) fn required_floor_nominal_closure_module_seeds(
+    required_gate_authored_modules: &[String],
+    local_repo_wet_schedule_rows: &[LocalRepoWetScheduledRow],
+) -> Vec<String> {
+    REQUIRED_FLOOR_RUNTIME_AUTHORITY_MODULES
+        .iter()
+        .map(|m| m.to_string())
+        .chain(required_gate_authored_modules.iter().cloned())
+        .chain(
+            local_repo_wet_schedule_rows
+                .iter()
+                .map(|row| row.entry_module.clone()),
+        )
+        .collect()
+}
+
 pub fn floor_prepared_subject_exclusions() -> Vec<String> {
     vec![
         // MUST-NOT-RESOLVE PROBES. Every module under dag/test/probe/ declares in its header that
@@ -5614,44 +5699,14 @@ pub fn run_required_floor(
                 .to_string()
         })
         .collect();
-    // THE LANE'S SCHEDULE IS DECODED HERE, IN THE POLICY CLOSURE, AND NOT LATER -- because its
-    // modules must become SEEDS of the prepared subject below. The first CI run of this lane
-    // refused seven times with `EntryModuleOutsidePreparedSubject`: the prepared graph is the
-    // required-gate closure plus the changed set, and the lane's members are on the discovery
-    // exclusion frontier, so nothing pulled them in. A lane that cannot reach its own members
-    // cannot support the route claim `std.witness_admission` makes for its cadence, so the
-    // schedule joins the seed list rather than the executor learning to run outside the subject.
-    let (required_gate_prefixes, local_repo_wet_schedule_rows) = {
-        let policy_seed = [REQUIRED_FLOOR_POLICY_MODULE.to_string()];
-        let (policy_prepared, _) = prepare_repository_closure(
-            source_roots,
-            &floor_prepared_subject_exclusions(),
-            Some((&gate_entry_index, &[], &policy_seed)),
-        )?;
-        let policy_scope = claim_scope_for(&policy_prepared, REQUIRED_FLOOR_POLICY_MODULE)?;
-        let policy_frame = evaluation_frame(
-            &policy_scope,
-            v1_interpreter::ExecutionMode::Hermetic,
-            None,
-            None,
-        );
-        let prefixes = floor_decode_module_prefix_roster(
-            &policy_frame,
-            "v2.workflow.required_floor.required_gate_prefixes",
-        )?;
-        // THE GATE'S SECOND SELECTOR KIND (`v2.workflow.required_floor`
-        // `required_gate_authored_modules`, `RequiredGateSelector`): authored module NAMES,
-        // matched at segment boundaries -- the module-seed rule below, not the prefix rule.
-        // They join `closure_module_seeds`, so preparation and site disposition admit them
-        // under one rule by construction.
-        let authored_modules = floor_decode_module_prefix_roster(
-            &policy_frame,
-            "v2.workflow.required_floor.required_gate_authored_modules",
-        )?;
-        let schedule = local_repo_wet_schedule(&policy_frame)?;
-        ((prefixes, authored_modules), schedule)
-    };
-    let (required_gate_prefixes, required_gate_authored_modules) = required_gate_prefixes;
+    // THE NOMINAL SEEDS -- gate prefixes, gate authored modules, the wet schedule -- come from
+    // the one producer the resolution census also reads, so what the floor prepares on a run
+    // that touches nothing and what the census reports as reached are the same fact.
+    let RequiredFloorNominalSubjectSeeds {
+        required_gate_prefixes,
+        required_gate_authored_modules,
+        local_repo_wet_schedule_rows,
+    } = required_floor_nominal_subject_seeds(source_roots, &gate_entry_index)?;
     // THE FLOOR'S OWN AUTHORITIES ARE ALWAYS IN THE SUBJECT: the floor evaluates its rosters
     // (expected red, route gap, cost debt, the gate itself) in a frame over the prepared graph,
     // and a gate roster that happened not to reach `v2.workflow.required_floor` refused with
@@ -5788,23 +5843,19 @@ pub fn run_required_floor(
             }
         }
     }
-    let closure_module_seeds: Vec<String> = REQUIRED_FLOOR_RUNTIME_AUTHORITY_MODULES
-        .iter()
-        .map(|m| m.to_string())
-        .chain(required_gate_authored_modules.iter().cloned())
-        .chain(changed_module_seeds.iter().cloned())
-        .chain(
-            compile_subject
-                .iter()
-                .flat_map(|subject| subject.touched_modules.iter().cloned()),
-        )
-        .chain(arm_set_consumer_seeds.iter().cloned())
-        .chain(
-            local_repo_wet_schedule_rows
-                .iter()
-                .map(|row| row.entry_module.clone()),
-        )
-        .collect();
+    let closure_module_seeds: Vec<String> = required_floor_nominal_closure_module_seeds(
+        &required_gate_authored_modules,
+        &local_repo_wet_schedule_rows,
+    )
+    .into_iter()
+    .chain(changed_module_seeds.iter().cloned())
+    .chain(
+        compile_subject
+            .iter()
+            .flat_map(|subject| subject.touched_modules.iter().cloned()),
+    )
+    .chain(arm_set_consumer_seeds.iter().cloned())
+    .collect();
     let (mut prepared, prepared_sources) = prepare_repository_closure(
         source_roots,
         &floor_prepared_subject_exclusions(),
diff --git a/src/v1/stage0/src/cli_run/required_lane_resolution_census.rs b/src/v1/stage0/src/cli_run/required_lane_resolution_census.rs
new file mode 100644
index 00000000000..5a49f2f8f59
--- /dev/null
+++ b/src/v1/stage0/src/cli_run/required_lane_resolution_census.rs
@@ -0,0 +1,118 @@
+//! THE REQUIRED-LANE RESOLUTION CENSUS'S THREE COMPILER QUERIES.
+//!
+//! The question the census asks is DESIGN section 3's standing warning read as a measurement:
+//! outside the required gate the substrate still refuses and nothing asks it to, so a
+//! product-layer dependent can stop resolving, stay broken, and let every required lane report
+//! SUCCESS. On 2026-09-20 that was the live state -- `gunbc.site_pxe_edge_converge` did not
+//! resolve on main while all four required lanes were green (gunbc#11607) -- and the question
+//! "which modules can do that" had no instrument. This file answers the three population
+//! queries the `.dag` census (`gunbc.required_lane_resolution_census`) folds over; the census,
+//! not this file, decides which lanes exist and what each one resolves, and it reads that roster
+//! from `gunbc.compiler_gate_workflow` so a job the workflow emits cannot go unclassified.
+//!
+//! "RESOLVE" MEANS ONE THING HERE: the module's source is in the source set a lane's compile
+//! transaction hands to `compile_to_resolved` under the Strict gate. For the floor that is the
+//! prepared subject (`assemble_prepared_subject_closure` over the nominal seeds); for a
+//! `gunbc run --entry` step it is the entry's loader closure (`load_sources_for_entry_with_pool`,
+//! the same call `resolve_entry_graph` makes). A module reached only by name in a `run:` line
+//! is NOT resolved by that step unless the entry's closure reaches it, and that is the whole
+//! finding.
+//!
+//! NOMINAL, NOT DIFF-SCOPED, AND DELIBERATELY SO. The floor also seeds its subject from the
+//! run's diff -- changed witnesses, touched entries, arm-set consumers -- so a module a PR
+//! touches is resolved on THAT PR's run. The failure this census exists to expose is the other
+//! case: a module nobody touched, broken by a rename in a module it depends on, on a PR whose
+//! diff never seeds it. The population that can break that way is exactly the complement of
+//! the NOMINAL subject, which is why the census reads the floor's seeds through
+//! `required_floor_nominal_subject_seeds` -- the one producer the floor itself consumes -- and
+//! adds no diff seeds.
+//!
+//! EACH QUERY REFUSES RATHER THAN NARROWS. An index that cannot be built, a seed roster that
+//! cannot be decoded, an entry whose closure cannot be loaded: each is a typed refusal the
+//! `.dag` census must decide on. None returns an empty population as if it had observed one.
+
+use super::*;
+
+/// One population of module identities, or the reason it could not be established.
+pub enum ModuleIdentityPopulation {
+    Observed { modules: Vec<String> },
+    Refused { cause: String },
+}
+
+/// The denominator: every module identity the source-root ingestion admits. This is the SAME
+/// producer `claim_executor --required-ci` prints as `admitted-module-identities`, so the census
+/// and the required run cannot disagree about what "every module under dag/ and src/v2/" means.
+/// A `.dag` file with no `module` header is not an identity and is outside this universe.
+pub fn source_root_ingest_module_identities(source_roots: &[String]) -> ModuleIdentityPopulation {
+    match source_root_ingest_module_identities_for_ci(source_roots) {
+        Ok(modules) => ModuleIdentityPopulation::Observed { modules },
+        Err(cause) => ModuleIdentityPopulation::Refused { cause },
+    }
+}
+
+/// The floor's NOMINAL prepared subject: the gate prefix closure plus the runtime-authority,
+/// authored-module and wet-schedule seeds, assembled by `assemble_prepared_subject_closure`
+/// exactly as `run_required_floor` assembles it before adding a run's diff seeds. Read-and-fold
+/// only -- no strict preparation is paid here, because membership in the subject is the
+/// question, not whether the subject then resolves.
+pub fn required_floor_nominal_subject_module_identities(
+    source_roots: &[String],
+) -> ModuleIdentityPopulation {
+    let index = process_shared_index(source_roots);
+    let seeds = match required_floor_nominal_subject_seeds(source_roots, &index) {
+        Ok(seeds) => seeds,
+        Err(cause) => {
+            return ModuleIdentityPopulation::Refused {
+                cause: format!("nominal subject seeds: {cause}"),
+            }
+        }
+    };
+    let module_seeds = required_floor_nominal_closure_module_seeds(
+        &seeds.required_gate_authored_modules,
+        &seeds.local_repo_wet_schedule_rows,
+    );
+    let subject = match assemble_prepared_subject_closure(
+        source_roots,
+        &floor_prepared_subject_exclusions(),
+        Some((&index, &seeds.required_gate_prefixes, &module_seeds)),
+    ) {
+        Ok(subject) => subject,
+        Err(cause) => {
+            return ModuleIdentityPopulation::Refused {
+                cause: format!("nominal subject assembly: {cause}"),
+            }
+        }
+    };
+    let mut modules: Vec<String> = subject
+        .inventory
+        .iter()
+        .map(|view| view.module_path.clone())
+        .collect();
+    modules.sort();
+    modules.dedup();
+    ModuleIdentityPopulation::Observed { modules }
+}
+
+/// The loader closure of one `--entry` file: what `gunbc run --entry <path>` resolves before it
+/// evaluates anything. `entry_path` is workspace-relative, as the `run:` line spells it.
+pub fn entry_closure_module_identities(
+    source_roots: &[String],
+    entry_path: &str,
+) -> ModuleIdentityPopulation {
+    let index = process_shared_index(source_roots);
+    let sources = match load_sources_for_entry_with_pool(&index, entry_path) {
+        Ok(sources) => sources,
+        Err(cause) => {
+            return ModuleIdentityPopulation::Refused {
+                cause: format!("entry closure of {entry_path}: {cause}"),
+            }
+        }
+    };
+    let mut modules: Vec<String> = sources
+        .iter()
+        .filter_map(|source| extract_module_path(&source.content))
+        .collect();
+    modules.sort();
+    modules.dedup();
+    ModuleIdentityPopulation::Observed { modules }
+}
diff --git a/src/v1/stage0/src/target_invocation_host.rs b/src/v1/stage0/src/target_invocation_host.rs
index a9033606cba..eca246a04e0 100644
--- a/src/v1/stage0/src/target_invocation_host.rs
+++ b/src/v1/stage0/src/target_invocation_host.rs
@@ -160,6 +160,7 @@ pub enum TargetProducer {
     PrimitiveEgressCensusV2,
     PrimitiveEgressCensusDag,
     PrimitiveEgressCensusSeed,
+    RequiredLaneResolutionCensus,
 }
 
 /// `gunbc.instrument_targets` `instrument_targets` / `instrument_bindings`, as the pairs the
@@ -237,6 +238,10 @@ fn instrument_registry() -> Vec<(Label, TargetProducer)> {
             instrument_label("primitive-egress-census-seed"),
             TargetProducer::PrimitiveEgressCensusSeed,
         ),
+        (
+            instrument_label("required-lane-resolution-census"),
+            TargetProducer::RequiredLaneResolutionCensus,
+        ),
     ]
 }
 
@@ -447,6 +452,11 @@ fn run_producer(producer: TargetProducer) -> InvocationOutcome {
             "primitive-egress-census-seed",
             "primitive_egress_census_seed_exit",
         ),
+        TargetProducer::RequiredLaneResolutionCensus => run_cli_wire_census(
+            "required-lane-resolution-census",
+            "dag/gunbc/required_lane_resolution_census_live.dag",
+            "required_lane_resolution_census_exit",
+        ),
     }
 }
 
@@ -465,7 +475,23 @@ fn run_producer(producer: TargetProducer) -> InvocationOutcome {
 /// names (`gunbc.primitive_egress.census_live` `census_wire(scope:)` decides what it walks), so a
 /// bounded projection is a label of its own and not a flag on the full one.
 fn run_primitive_egress_census(label: &'static str, function: &'static str) -> InvocationOutcome {
-    const ENTRY: &str = "dag/gunbc/primitive_egress/census_live.dag";
+    run_cli_wire_census(
+        label,
+        "dag/gunbc/primitive_egress/census_live.dag",
+        function,
+    )
+}
+
+/// ONE RUNNER FOR EVERY INSTRUMENT WHOSE `.dag` ENTRY ANSWERS A `CliWireResponse`: resolve the
+/// entry, evaluate the named function, print the wire bytes on every termination, and map the
+/// wire exit to a Termination through the one classifier in `cli_run`. The primitive egress
+/// census labels and the required-lane resolution census share it; a new instrument of that
+/// shape is a label row plus one arm naming its entry and function, never a second runner.
+fn run_cli_wire_census(
+    label: &'static str,
+    entry: &'static str,
+    function: &'static str,
+) -> InvocationOutcome {
     let label_name = label;
     let function_name = function;
     if let Err(e) = std::env::set_current_dir(cli_run::workspace_root()) {
@@ -475,12 +501,12 @@ fn run_primitive_egress_census(label: &'static str, function: &'static str) -> I
         };
     }
     let roots = cli_run::default_source_roots();
-    let (graph, source_indices) = match cli_run::resolve_entry_graph(&roots, ENTRY) {
+    let (graph, source_indices) = match cli_run::resolve_entry_graph(&roots, entry) {
         Ok(resolved) => resolved,
         Err(cause) => {
             return InvocationOutcome {
                 termination: Termination::SubjectUnreached,
-                message: format!("{label_name}: resolve failed for {ENTRY}: {cause}"),
+                message: format!("{label_name}: resolve failed for {entry}: {cause}"),
             };
         }
     };
@@ -491,7 +517,7 @@ fn run_primitive_egress_census(label: &'static str, function: &'static str) -> I
         return InvocationOutcome {
             termination: Termination::Refused,
             message: format!(
-                "{label_name}: {ENTRY} has blocking diagnostics: {}",
+                "{label_name}: {entry} has blocking diagnostics: {}",
                 blocking.iter().cloned().collect::<Vec<_>>().join("; ")
             ),
         };
diff --git a/src/v1/stage0/src/v1_compiler_infer_method.rs b/src/v1/stage0/src/v1_compiler_infer_method.rs
index 59d9334e75f..0d8d64caa6f 100644
--- a/src/v1/stage0/src/v1_compiler_infer_method.rs
+++ b/src/v1/stage0/src/v1_compiler_infer_method.rs
@@ -1319,6 +1319,53 @@ pub fn builtin_function_registry() -> Rc<HashMap<String, Rc<BuiltinSignature>>>
     }),
     })]),
         returns: type_variable_node("primitive_call_edge_census_result".to_string()),
+    }));
+                __m.insert("source_root_ingest_module_identities".to_string(), Rc::new(BuiltinSignature {
+        params: Rc::new(vec![Rc::new(BuiltinParam {
+        name: "source_roots".to_string(),
+        ty: Rc::new(AlgebraTypeTemplate::ContainerOf {
+        source: Rc::new(ContainerSource::Named {
+        name: "List".to_string(),
+    }),
+        element: Rc::new(AlgebraTypeTemplate::NamedTemplate {
+        name: "String".to_string(),
+    }),
+    }),
+    })]),
+        returns: type_variable_node("module_identity_population".to_string()),
+    }));
+                __m.insert("required_floor_nominal_subject_module_identities".to_string(), Rc::new(BuiltinSignature {
+        params: Rc::new(vec![Rc::new(BuiltinParam {
+        name: "source_roots".to_string(),
+        ty: Rc::new(AlgebraTypeTemplate::ContainerOf {
+        source: Rc::new(ContainerSource::Named {
+        name: "List".to_string(),
+    }),
+        element: Rc::new(AlgebraTypeTemplate::NamedTemplate {
+        name: "String".to_string(),
+    }),
+    }),
+    })]),
+        returns: type_variable_node("module_identity_population".to_string()),
+    }));
+                __m.insert("entry_closure_module_identities".to_string(), Rc::new(BuiltinSignature {
+        params: Rc::new(vec![Rc::new(BuiltinParam {
+        name: "source_roots".to_string(),
+        ty: Rc::new(AlgebraTypeTemplate::ContainerOf {
+        source: Rc::new(ContainerSource::Named {
+        name: "List".to_string(),
+    }),
+        element: Rc::new(AlgebraTypeTemplate::NamedTemplate {
+        name: "String".to_string(),
+    }),
+    }),
+    }), Rc::new(BuiltinParam {
+        name: "entry_path".to_string(),
+        ty: Rc::new(AlgebraTypeTemplate::NamedTemplate {
+        name: "String".to_string(),
+    }),
+    })]),
+        returns: type_variable_node("module_identity_population".to_string()),
     }));
                 __m.insert("compile_dag_call_form_leaf_guard".to_string(), Rc::new(BuiltinSignature {
         params: Rc::new(vec![Rc::new(BuiltinParam {
diff --git a/src/v1/stage0/src/v1_interpreter.rs b/src/v1/stage0/src/v1_interpreter.rs
index 8055f85d1b2..300aa04cf26 100644
--- a/src/v1/stage0/src/v1_interpreter.rs
+++ b/src/v1/stage0/src/v1_interpreter.rs
@@ -13786,6 +13786,30 @@ fn primitive_callee_identity_value(
     }
 }
 
+/// `gunbc.required_lane_resolution_census` `ModuleIdentityPopulation`, lifted from the host's
+/// carrier. Two arms and nothing else: an observed identity list, or the typed cause the
+/// population could not be established -- never an empty list standing for a refusal.
+fn module_identity_population_value(
+    population: crate::cli_run::ModuleIdentityPopulation,
+    ctx: &InterpContext,
+) -> Value {
+    match population {
+        crate::cli_run::ModuleIdentityPopulation::Refused { cause } => Value::Variant {
+            type_name: ctx.sym("ModuleIdentityPopulation"),
+            variant_name: ctx.sym("ModuleIdentityPopulationRefused"),
+            fields: Rc::new(sorted_fields(vec![(ctx.sym("cause"), str_value(cause))])),
+        },
+        crate::cli_run::ModuleIdentityPopulation::Observed { modules } => Value::Variant {
+            type_name: ctx.sym("ModuleIdentityPopulation"),
+            variant_name: ctx.sym("ModuleIdentityPopulationObserved"),
+            fields: Rc::new(sorted_fields(vec![(
+                ctx.sym("modules"),
+                list_value(modules.into_iter().map(str_value).collect::<Vec<_>>()),
+            )])),
+        },
+    }
+}
+
 fn primitive_call_edge_census_value(
     census: crate::cli_run::PrimitiveCallEdgeCensus,
     ctx: &InterpContext,
@@ -21013,6 +21037,31 @@ macro_rules! v1_builtin_arms {
                 )))
             },
 
+            arm "free_call.source_root_ingest_module_identities" { "source_root_ingest_module_identities" } => {
+                let source_roots = expect_str_list($positional.first().copied(), $name)?;
+                Ok(Some(module_identity_population_value(
+                    crate::cli_run::source_root_ingest_module_identities(&source_roots),
+                    $ctx,
+                )))
+            },
+
+            arm "free_call.required_floor_nominal_subject_module_identities" { "required_floor_nominal_subject_module_identities" } => {
+                let source_roots = expect_str_list($positional.first().copied(), $name)?;
+                Ok(Some(module_identity_population_value(
+                    crate::cli_run::required_floor_nominal_subject_module_identities(&source_roots),
+                    $ctx,
+                )))
+            },
+
+            arm "free_call.entry_closure_module_identities" { "entry_closure_module_identities" } => {
+                let source_roots = expect_str_list($positional.first().copied(), $name)?;
+                let entry_path = expect_str($positional.get(1).copied(), $name)?;
+                Ok(Some(module_identity_population_value(
+                    crate::cli_run::entry_closure_module_identities(&source_roots, &entry_path),
+                    $ctx,
+                )))
+            },
+
             arm "free_call.compile_dag_call_form_leaf_guard" { "compile_dag_call_form_leaf_guard" } => {
                 let exclude_substrings = expect_str_list($positional.first().copied(), $name)?;
                 let pool_roots = expect_str_list($positional.get(1).copied(), $name)?;
diff --git a/src/v1/stage0/src/v1_interpreter_dispatch_generated.rs b/src/v1/stage0/src/v1_interpreter_dispatch_generated.rs
index e6ed1063c6a..889f6548589 100644
--- a/src/v1/stage0/src/v1_interpreter_dispatch_generated.rs
+++ b/src/v1/stage0/src/v1_interpreter_dispatch_generated.rs
@@ -110,6 +110,9 @@ pub enum EvalBuiltinArm {
     FreeCallCompileDagCallsiteResolvedCallEdges,
     FreeCallBuiltinFunctionRegistryKeys,
     FreeCallCompileDagPrimitiveCallEdges,
+    FreeCallSourceRootIngestModuleIdentities,
+    FreeCallRequiredFloorNominalSubjectModuleIdentities,
+    FreeCallEntryClosureModuleIdentities,
     FreeCallCompileDagCallFormLeafGuard,
     FreeCallObserveDeclaredImportClosureSymbolBinding,
     FreeCallClassBImportClosureGateNotAffectedSkip,
@@ -258,6 +261,9 @@ pub fn lookup_eval_builtin_inner(spelling: &str) -> Option<EvalBuiltinArm> {
         "compile_dag_callsite_resolved_call_edges" => Some(EvalBuiltinArm::FreeCallCompileDagCallsiteResolvedCallEdges),
         "builtin_function_registry_keys" => Some(EvalBuiltinArm::FreeCallBuiltinFunctionRegistryKeys),
         "compile_dag_primitive_call_edges" => Some(EvalBuiltinArm::FreeCallCompileDagPrimitiveCallEdges),
+        "source_root_ingest_module_identities" => Some(EvalBuiltinArm::FreeCallSourceRootIngestModuleIdentities),
+        "required_floor_nominal_subject_module_identities" => Some(EvalBuiltinArm::FreeCallRequiredFloorNominalSubjectModuleIdentities),
+        "entry_closure_module_identities" => Some(EvalBuiltinArm::FreeCallEntryClosureModuleIdentities),
         "compile_dag_call_form_leaf_guard" => Some(EvalBuiltinArm::FreeCallCompileDagCallFormLeafGuard),
         "observe_declared_import_closure_symbol_binding" => Some(EvalBuiltinArm::FreeCallObserveDeclaredImportClosureSymbolBinding),
         "class_b_import_closure_gate_not_affected_skip" => Some(EvalBuiltinArm::FreeCallClassBImportClosureGateNotAffectedSkip),
@@ -404,6 +410,9 @@ macro_rules! eval_builtin_inner_arm {
     ("free_call.compile_dag_callsite_resolved_call_edges") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallCompileDagCallsiteResolvedCallEdges };
     ("free_call.builtin_function_registry_keys") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallBuiltinFunctionRegistryKeys };
     ("free_call.compile_dag_primitive_call_edges") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallCompileDagPrimitiveCallEdges };
+    ("free_call.source_root_ingest_module_identities") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallSourceRootIngestModuleIdentities };
+    ("free_call.required_floor_nominal_subject_module_identities") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallRequiredFloorNominalSubjectModuleIdentities };
+    ("free_call.entry_closure_module_identities") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallEntryClosureModuleIdentities };
     ("free_call.compile_dag_call_form_leaf_guard") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallCompileDagCallFormLeafGuard };
     ("free_call.observe_declared_import_closure_symbol_binding") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallObserveDeclaredImportClosureSymbolBinding };
     ("free_call.class_b_import_closure_gate_not_affected_skip") => { $crate::v1_interpreter_dispatch_generated::EvalBuiltinArm::FreeCallClassBImportClosureGateNotAffectedSkip };