From ee58357159fb646cc59ea1f431af32cfc17a5014 Mon Sep 17 00:00:00 2001 From: gunbc-ci-auto-heal Date: Sun, 23 Aug 2026 13:59:39 +0000 Subject: [PATCH] WIP: MAIN RED #4: eight runner-slot/fleet-capacity witnesses return Bool(fals --- src/v1/stage0/src/cli_run.rs | 874 +++++++++++++++++- src/v1/stage0/tests/all_errored_rows_probe.rs | 219 +++++ .../stage0/tests/classification_arm_census.rs | 33 + .../stage0/tests/rest_errored_rows_probe.rs | 74 ++ src/v2/workflow/floor_expected_red.dag | 20 +- 5 files changed, 1189 insertions(+), 31 deletions(-) create mode 100644 src/v1/stage0/tests/all_errored_rows_probe.rs create mode 100644 src/v1/stage0/tests/classification_arm_census.rs create mode 100644 src/v1/stage0/tests/rest_errored_rows_probe.rs diff --git a/src/v1/stage0/src/cli_run.rs b/src/v1/stage0/src/cli_run.rs index 02f2dec47fa..d5dccc0bbbc 100644 --- a/src/v1/stage0/src/cli_run.rs +++ b/src/v1/stage0/src/cli_run.rs @@ -30532,37 +30532,340 @@ fn collect_type_ref_names( /// Walk a declaration subtree collecting cross-module reference use sites: value calls/vars, /// variant constructors, qualified-name chains, and type-annotation identifiers. Binders (params, -/// match-pattern fields, record-literal labels) are excluded — the liberal `node.name` scan was -/// attributing local names like `items` and `r` to unrelated extdeps modules. +/// `let` bindings, lambda parameters, match-pattern fields, record-literal labels) are excluded, +/// because the liberal `node.name` scan this replaced was attributing local names like `items` +/// and `r` to unrelated extdeps modules. +/// +/// EXCLUDING BINDERS BY BINDING KIND WAS THE DEFECT, AND IT FAILED SILENTLY FOR THE LIFETIME OF +/// THE FUNCTION. The previous form kept an `ExprVar` only when its `binding_kind` was +/// `Some(FunctionValueBinding)`, which reads as "keep the references, drop the locals" and does +/// nothing at all: `binding_kind` is stamped by `infer_var_binding_kind` on inference's own +/// representation and is `None` on every node of the PREPARED tree this walk reads. Measured on +/// the prepared corpus: 205,609 `ExprVar` nodes, 205,609 of them unstamped, zero of any other +/// kind. So the predicate matched nothing, no bare variable reference ever produced a reference +/// edge, and every edge this index has ever carried came from `ExprCall`, `ExprRecordLit`, field +/// chains and type annotations. +/// +/// THE FAILURE DIRECTION IS WHAT MADE IT INVISIBLE. A predicate matching on a field its input +/// never populates is indistinguishable from a correct one by reading, by typecheck and by grep; +/// it does not refuse, it returns an empty set. The consumer gets a smaller closure and the +/// damage surfaces as a runtime throw somewhere else entirely — measured on floor run +/// 32621117917, 170 enrolled claims that threw `no such function: ` +/// instead of reaching a verdict. +/// +/// SO THE SEPARATION IS STRUCTURAL, because the stamp carries no information here. `bound` holds +/// the names an enclosing binder introduced and a name in it is never a reference. The remaining +/// failure directions are deliberately asymmetric: over-binding drops an edge and silently +/// reproduces exactly the defect above, while under-binding admits a local name and merely widens +/// the scope — which is observable as `PreparedClaimScope::module_count` and as +/// `ambiguous_bare_names`. The design whose failure mode is measurable is the correct trade. fn collect_node_refs( node: &Rc, bare: &mut std::collections::HashSet, chains: &mut Vec>, + source_indices: &Rc>>, + classify: &mut ExprVarClassification<'_>, ) { - collect_node_refs_inner(node, bare, chains, false); + let mut bound: Vec<(String, ExprVarClass)> = Vec::new(); + collect_node_refs_inner( + node, + bare, + chains, + false, + false, + &mut bound, + source_indices, + classify, + ); +} + +/// WHERE EVERY `ExprVar` GOES, AS A CLOSED SET RATHER THAN A RESIDUE. +/// +/// The defect this replaces classified by subtraction: keep the ones whose binding kind is +/// `Some(FunctionValueBinding)`, and whatever is left is not a reference. A residue cannot be +/// audited — a name that fits none of the author's cases lands on one side or the other with +/// nothing announcing it, which is how an arm that matched NOTHING went unnoticed for the +/// lifetime of the function. Here every occurrence reaches exactly one member, the reference set +/// is the members that ARE references by construction, and the member for "fits nothing" exists +/// so that it can be counted rather than assumed away. +/// +/// WHAT THIS DOES AND DOES NOT GUARANTEE, at the grain the honest claim allows: it is total over +/// ONE node kind (`ExprData::ExprVar`) under ONE classification. It is NOT a claim that arm +/// reachability is decidable in general — "can this match arm ever be taken" is not a property +/// worth a general wall, and nothing here promises one. What is decidable, and all that is +/// claimed, is that this particular syntactic classification covers this particular node kind. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +enum ExprVarClass { + /// Bound by an enclosing declaration's or lambda's parameter. + BoundByParameter, + /// Bound by a `let` earlier in the same block. + BoundByLet, + /// Bound by an enclosing match pattern. + BoundByMatchPattern, + /// Not bound here, and this module declares it — resolves locally, no cross-module edge. + DeclaredInThisModule, + /// Not bound here, and some other module declares it — the cross-module reference edge that + /// the previous form could never record. + DeclaredElsewhere, + /// The innermost receiver of a dotted chain (`extdeps` in `extdeps.browser.chromium`). The + /// chain is recorded WHOLE by the dotted scan at the field-access node above, so the head is + /// already accounted for; classifying it again as a bare name would ask the wrong question of + /// it — a chain head names a module path segment, not a declaration this module could hold. + QualifiedChainHead, + /// Not bound, not a chain head, and declared by no module in the subject. Kept as a member so + /// the population is observable; it is the arm whose silence produced this defect. + NamesNothingKnown, +} + +/// Classification state for one module's walk. Carries the corpus-wide declaration index, which +/// is why the index build runs declarations first and classification second. +struct ExprVarClassification<'a> { + /// EXACT RECONCILIATION, PUBLISHED. Every traversed occurrence lands in exactly one of + /// `free_reference_edges`, `bound_occurrences_suppressed`, `chain_head_occurrences` or + /// `NamesNothingKnown`, with an unsupported binder refusing outright, and + /// the identity is asserted before the index is published. A counter set that does not add + /// up means an occurrence vanished, which is the failure this whole change exists to make + /// unrepresentable — so it refuses rather than reporting a plausible smaller closure. + occurrences: usize, + free_reference_edges: usize, + bound_occurrences_suppressed: usize, + chain_head_occurrences: usize, + refusals: Vec, + /// `None` where the caller has no declaration index — see `reference_resolution_facts`, + /// which runs before any subject is prepared. Absent is spelled as absent rather than as an + /// empty map, because an empty map would answer "no module declares this name" to every + /// question and silently collect nothing: ⊥-as-answer standing in for ⊥-as-ignorance. + decl_index: Option<&'a HashMap>>, + tally: &'a mut BTreeMap, + unclassified: &'a mut Vec, + /// The module currently being walked. ONE classification spans the whole index build so the + /// reconciliation identity is over the same population as the tally; walking per-module with + /// per-module counters against a shared tally would compare two different denominators. + module: String, +} + +impl ExprVarClassification<'_> { + /// Assign one occurrence and answer whether it is a reference edge. Total: every input + /// reaches exactly one `ExprVarClass`. + /// A BINDER FORM THIS COLLECTOR CANNOT NAME IS A TYPED REFUSAL, NOT A GUESS IN EITHER + /// DIRECTION. Assuming bound silently reproduces the under-approximation being removed; + /// assuming free builds an inflated scope for every claim before anything complains. The + /// construct is reported and the run stops before any scope is built. + fn refuse_binder(&mut self, construct: &str, detail: &str) { + self.refusals.push(format!( + "{}: unsupported binder syntax {construct} ({detail})", + self.module + )); + } + + fn classify(&mut self, name: &str, bound_as: Option, chain_head: bool) -> bool { + self.occurrences += 1; + // THE CHAIN HEAD ARM IS ORDERED LAST, AND THE ORDER IS THE WHOLE CORRECTNESS ARGUMENT. + // A binder answers first: `fn f(cron: Tab) { cron.List }` reads the parameter. A + // DECLARATION answers second, because the dotted scan owns only chains whose prefix is a + // MODULE PATH — `some_data_row.field` is an ordinary value reference that merely looks + // like one, and suppressing it here DELETES A REAL EDGE. Only a head that is neither + // bound nor declared anywhere is the module-path segment this member is for. + let head_is_undeclared = chain_head + && bound_as.is_none() + && self + .decl_index + .map(|index| !index.contains_key(name)) + .unwrap_or(false); + if head_is_undeclared { + *self + .tally + .entry(ExprVarClass::QualifiedChainHead) + .or_insert(0) += 1; + self.chain_head_occurrences += 1; + return false; + } + let Some(decl_index) = self.decl_index else { + // No index: this caller cannot decide the unbound cases, so an unbound name keeps + // this producer's own prior contract of "treat it as a reference and let resolution + // decide". Counted under the member it would otherwise have to guess at. + let class = bound_as.unwrap_or(ExprVarClass::DeclaredElsewhere); + *self.tally.entry(class).or_insert(0) += 1; + if bound_as.is_none() { + self.free_reference_edges += 1; + return true; + } + self.bound_occurrences_suppressed += 1; + return false; + }; + let class = match bound_as { + Some(bound) => bound, + None => match decl_index.get(name) { + Some(mods) if mods.contains(&self.module) => ExprVarClass::DeclaredInThisModule, + Some(_) => ExprVarClass::DeclaredElsewhere, + None => { + self.unclassified.push(format!("{}::{name}", self.module)); + ExprVarClass::NamesNothingKnown + } + }, + }; + *self.tally.entry(class).or_insert(0) += 1; + // Only a name some module declares is an edge. A bound name is not, and a name nothing + // declares has no target to reach — recording it would invent an edge, not find one. + let is_edge = matches!( + class, + ExprVarClass::DeclaredInThisModule | ExprVarClass::DeclaredElsewhere + ); + match class { + ExprVarClass::BoundByParameter + | ExprVarClass::BoundByLet + | ExprVarClass::BoundByMatchPattern => self.bound_occurrences_suppressed += 1, + ExprVarClass::DeclaredInThisModule | ExprVarClass::DeclaredElsewhere => { + self.free_reference_edges += 1 + } + // Counted as neither an edge nor a suppression: it is its own member, and the + // reconciliation below adds it in explicitly rather than letting it hide in one. + ExprVarClass::NamesNothingKnown => {} + // Unreachable from here: a chain head returns above, before the declaration index is + // consulted at all. Named rather than wildcarded so a future member cannot inherit + // this arm's silence. + ExprVarClass::QualifiedChainHead => {} + } + is_edge + } + + /// all traversed occurrences == free + bound-suppressed + names-nothing-known. + fn reconciles(&self) -> bool { + let names_nothing_known = self + .tally + .get(&ExprVarClass::NamesNothingKnown) + .copied() + .unwrap_or(0); + self.occurrences + == self.free_reference_edges + + self.bound_occurrences_suppressed + + self.chain_head_occurrences + + names_nothing_known + } +} + +/// The names one node's own binder introduces, in the shapes the prepared tree uses: a +/// declaration's or lambda's parameters, and a match arm's pattern bindings. A `let` is NOT here +/// — it binds over its later SIBLINGS rather than over its own subtree, so it is handled where +/// the child list is walked. +fn binder_names_of( + node: &Rc, + source_indices: &Rc>>, + classify: &mut ExprVarClassification<'_>, +) -> Vec<(String, ExprVarClass)> { + use crate::v1_std_core::{ExprData, MatchPattern}; + let mut out: Vec<(String, ExprVarClass)> = Vec::new(); + for p in node.params.iter() { + if p.name.is_empty() { + classify.refuse_binder("parameter", "declared parameter carries no name"); + continue; + } + out.push((p.name.clone(), ExprVarClass::BoundByParameter)); + } + // A LAMBDA'S PARAMETERS ARE ITS CHILDREN, NOT ITS `params`. `lambda_param_names_at` reads + // them as children[1..] with the body at child 0, and recovers each name from its authored + // span — so the same producer the compiler uses answers here rather than a second reading of + // the shape. + if matches!(&*node.expr_data, ExprData::ExprLambda) { + for n in node.children.iter().skip(1) { + let name = authored_name_at(source_indices.clone(), n.clone()); + if name.is_empty() { + classify.refuse_binder( + "lambda parameter", + "no authored name recoverable from its span", + ); + continue; + } + out.push((name, ExprVarClass::BoundByParameter)); + } + } + if let Some(mp) = &node.match_pattern { + pattern_binder_names(mp.clone(), classify, &mut out); + } + out +} + +/// A match pattern binds names at every depth, so the binder walk is a recursion over the +/// pattern tree rather than a single level of it. A `VariantPattern`'s `field_bindings` carry +/// the FIELD name on the node and the actual binder in that node's own `match_pattern` — for +/// `Present { value: v }` the node is named `value` and its nested pattern is `Bind { v }`, and +/// for the shorthand `Present { value }` the parser synthesises `Bind { value }`. Reading the +/// field name as the binder therefore binds the wrong name in the general case and misses the +/// real one; nested patterns of any depth are handled by the same recursion. A field binding +/// with no nested pattern at all is not a shape this walk understands, so it refuses. +fn pattern_binder_names( + pattern: Rc, + classify: &mut ExprVarClassification<'_>, + out: &mut Vec<(String, ExprVarClass)>, +) { + match &*pattern { + MatchPattern::Bind { declaration } => { + if declaration.name.is_empty() { + classify.refuse_binder("match binding pattern", "binding carries no name"); + } else { + out.push((declaration.name.clone(), ExprVarClass::BoundByMatchPattern)); + } + } + MatchPattern::VariantPattern { field_bindings, .. } => { + for fb in field_bindings.iter() { + match &fb.match_pattern { + Some(nested) => pattern_binder_names(nested.clone(), classify, out), + None => classify.refuse_binder( + "variant field binding", + "field binding node carries no nested pattern", + ), + } + } + } + MatchPattern::LitPattern { .. } | MatchPattern::Wildcard => {} + } } +#[allow(clippy::too_many_arguments)] fn collect_node_refs_inner( node: &Rc, bare: &mut std::collections::HashSet, chains: &mut Vec>, skip_bare_name: bool, + // `chain_receiver`: true when this node is the receiver position of an enclosing dotted + // chain that the scan above already recorded WHOLE. It propagates down the receiver spine + // only, so the head `ExprVar` it terminates at is classified as the chain head it is rather + // than as a bare name the module fails to declare. + chain_receiver: bool, + bound: &mut Vec<(String, ExprVarClass)>, + source_indices: &Rc>>, + classify: &mut ExprVarClassification<'_>, ) { - use crate::v1_std_core::{ExprData, MatchPattern, VarBindingKind}; + use crate::v1_std_core::{ExprData, MatchPattern}; + let mut receiver_spine = false; if let ExprData::ExprFieldAccess { .. } = &*node.expr_data { if let Some(chain) = ref_field_chain(node) { chains.push(chain); + receiver_spine = true; } } + // This node's own binder — parameters and match-pattern bindings — is in scope for + // everything below it and is popped on the way out. + let introduced = binder_names_of(node, source_indices, classify); + let restore_to = bound.len(); + bound.extend(introduced); if !skip_bare_name { match &*node.expr_data { - ExprData::ExprVar { binding_kind } => { - if matches!( - binding_kind.as_deref(), - Some(VarBindingKind::FunctionValueBinding) - ) && !node.name.is_empty() - { - bare.insert(node.name.clone()); + ExprData::ExprVar { .. } => { + if !node.name.is_empty() { + // EVERY occurrence is assigned, and the assignment decides the edge. An + // enclosing binder answers first because a bound name shadows any + // declaration sharing its spelling; otherwise the declaration index decides, + // and a name it does not hold reaches the counted `NamesNothingKnown` member + // rather than falling into either side unremarked. + let bound_as = bound + .iter() + .rev() + .find(|(n, _)| n == &node.name) + .map(|(_, class)| *class); + if classify.classify(&node.name, bound_as, chain_receiver) { + bare.insert(node.name.clone()); + } } } ExprData::ExprCall { .. } => { @@ -30575,11 +30878,30 @@ fn collect_node_refs_inner( bare.insert(node.name.clone()); } for c in node.children.iter() { - collect_node_refs_inner(c, bare, chains, true); + collect_node_refs_inner( + c, + bare, + chains, + true, + false, + bound, + source_indices, + classify, + ); } for pr in node.properties.iter() { - collect_node_refs_inner(pr, bare, chains, true); + collect_node_refs_inner( + pr, + bare, + chains, + true, + false, + bound, + source_indices, + classify, + ); } + bound.truncate(restore_to); return; } _ => {} @@ -30592,29 +30914,90 @@ fn collect_node_refs_inner( } } } - for c in node.children.iter() { - collect_node_refs_inner(c, bare, chains, false); + // A `let` BINDS OVER ITS LATER SIBLINGS, WHICH IS WHY THIS LOOP IS NOT A PLAIN `for`. + // On the prepared tree a block is a child list and a `let` is one of its members, carrying + // its bound name on the node and its VALUE as its only child. So the value is walked in the + // scope that precedes the binding — `let x = x` reads the outer `x`, as it must — and the + // name enters scope for the members that follow it. + let siblings_restore_to = bound.len(); + for (idx, c) in node.children.iter().enumerate() { + let child_is_receiver = receiver_spine && idx == 0; + collect_node_refs_inner( + c, + bare, + chains, + false, + child_is_receiver, + bound, + source_indices, + classify, + ); + if matches!(&*c.expr_data, ExprData::ExprLet) { + if c.name.is_empty() { + classify.refuse_binder("let binding", "binding carries no name"); + } else { + bound.push((c.name.clone(), ExprVarClass::BoundByLet)); + } + } } + bound.truncate(siblings_restore_to); for p in node.params.iter() { if let Some(t) = &p.type_annotation { collect_type_ref_names(t, bare); } } if let Some(b) = &node.body { - collect_node_refs_inner(b, bare, chains, false); + collect_node_refs_inner( + b, + bare, + chains, + false, + false, + bound, + source_indices, + classify, + ); } if let Some(t) = &node.type_annotation { collect_type_ref_names(t, bare); } for u in node.uses.iter() { - collect_node_refs_inner(u, bare, chains, false); + collect_node_refs_inner( + u, + bare, + chains, + false, + false, + bound, + source_indices, + classify, + ); } for pr in node.properties.iter() { - collect_node_refs_inner(pr, bare, chains, false); + collect_node_refs_inner( + pr, + bare, + chains, + false, + false, + bound, + source_indices, + classify, + ); } if let Some(tr) = &node.transport { - collect_node_refs_inner(tr, bare, chains, false); + collect_node_refs_inner( + tr, + bare, + chains, + false, + false, + bound, + source_indices, + classify, + ); } + bound.truncate(restore_to); } /// Count of shared leading dot-separated segments between two module paths (containment proximity). @@ -30810,8 +31193,40 @@ pub fn reference_resolution_facts( }; let mut bare: std::collections::HashSet = std::collections::HashSet::new(); let mut chains: Vec> = Vec::new(); + // THE INDEX IS BUILT FROM THE BYTES THIS PRODUCER ALREADY READ, not fetched from a + // prepared subject that does not exist at this point: `collect_node_refs` recovers a + // lambda parameter's name from its authored span, and a missing index would leave + // those names unbound and let them resolve as references. + let mut file_indices: HashMap> = HashMap::new(); + if let Ok(content) = std::fs::read_to_string(&file) { + file_indices.insert( + rel.clone(), + crate::v1_std_core::build_newline_index(rel.clone(), content), + ); + } + let file_indices = Rc::new(file_indices); + // THIS PRODUCER ANSWERS A CORPUS-WIDE QUESTION BEFORE ANY SUBJECT IS PREPARED, so it + // has no declaration index to classify against and cannot decide + // DeclaredElsewhere / NamesNothingKnown. It supplies an EMPTY index, under which + // every unbound name classifies as a reference — the behaviour this producer already + // had, preserved deliberately rather than by omission. The totality guarantee is + // therefore scoped to the floor's index build, which is the consumer that has the + // declarations; this one keeps its own looser contract and its own counters. + let mut scratch_tally: BTreeMap = BTreeMap::new(); + let mut scratch_unclassified: Vec = Vec::new(); + let mut classify = ExprVarClassification { + decl_index: None, + tally: &mut scratch_tally, + unclassified: &mut scratch_unclassified, + module: self_module.clone(), + occurrences: 0, + free_reference_edges: 0, + bound_occurrences_suppressed: 0, + chain_head_occurrences: 0, + refusals: Vec::new(), + }; for item in tree.children.iter() { - collect_node_refs(item, &mut bare, &mut chains); + collect_node_refs(item, &mut bare, &mut chains, &file_indices, &mut classify); } // Resolve to per-file (target_module → strongest confidence). let mut file_edges: std::collections::BTreeMap = @@ -40139,6 +40554,11 @@ fn reference_closure_index( return Ok(existing); } let started = std::time::Instant::now(); + // TWO PASSES, BECAUSE THE CLASSIFICATION IS ONLY DECIDABLE ONCE EVERY DECLARATION IS KNOWN. + // Deciding that a name is a reference means deciding that SOME module declares it, and a + // single pass can only ask that of the modules it has already walked — so a one-pass form + // has to fall back on a residual ("whatever is left is a reference"), which is exactly the + // shape being removed. Declarations first, classification second. let mut decl_index: HashMap> = HashMap::new(); let mut module_names: std::collections::HashSet = std::collections::HashSet::new(); let mut refs_by_module: HashMap> = HashMap::new(); @@ -40148,10 +40568,33 @@ fn reference_closure_index( for decl in collect_module_decl_names(&m.module) { decl_index.entry(decl).or_default().insert(name.clone()); } + } + let mut class_tally: BTreeMap = BTreeMap::new(); + let mut unclassified: Vec = Vec::new(); + let mut classify = ExprVarClassification { + decl_index: Some(&decl_index), + tally: &mut class_tally, + unclassified: &mut unclassified, + module: String::new(), + occurrences: 0, + free_reference_edges: 0, + bound_occurrences_suppressed: 0, + chain_head_occurrences: 0, + refusals: Vec::new(), + }; + for m in prepared.graph.modules.iter() { + let name = m.func_env.name.clone(); let mut bare: std::collections::HashSet = std::collections::HashSet::new(); let mut chains: Vec> = Vec::new(); + classify.module = name.clone(); for item in m.module.children.iter() { - collect_node_refs(item, &mut bare, &mut chains); + collect_node_refs( + item, + &mut bare, + &mut chains, + &prepared.source_indices, + &mut classify, + ); } let mut flat: std::collections::BTreeSet = std::collections::BTreeSet::new(); for n in bare { @@ -40162,6 +40605,68 @@ fn reference_closure_index( } refs_by_module.insert(name, flat); } + // EXACT RECONCILIATION IS ASSERTED BEFORE THE INDEX IS PUBLISHED, not reported after it is + // consumed. A population that does not add up means an occurrence was traversed and landed + // in no member — the silent disappearance this change exists to make unrepresentable. + if !classify.reconciles() { + return Err(format!( + "CLAIM-SCOPE REFUSAL cause=ExprVarReconciliationMismatch \ + expr_var_occurrences={} free_reference_edges={} bound_occurrences_suppressed={} \ + names_nothing_known={} — every traversed occurrence must land in exactly one member", + classify.occurrences, + classify.free_reference_edges, + classify.bound_occurrences_suppressed, + classify + .tally + .get(&ExprVarClass::NamesNothingKnown) + .copied() + .unwrap_or(0), + )); + } + if !classify.refusals.is_empty() { + let shown: Vec = classify.refusals.iter().take(10).cloned().collect(); + return Err(format!( + "CLAIM-SCOPE REFUSAL cause=UnsupportedBinderSyntax count={} — a binder form this \ + collector cannot name was reached, and neither assuming it bound nor assuming it \ + free is admissible: {}", + classify.refusals.len(), + shown.join("; ") + )); + } + eprintln!( + "[floor-phase] phase=expr-var-classification expr_var_occurrences={} \ + free_reference_edges={} bound_occurrences_suppressed={} \ + qualified_chain_heads={} classification_refusals={}", + classify.occurrences, + classify.free_reference_edges, + classify.bound_occurrences_suppressed, + classify.chain_head_occurrences, + classify.refusals.len(), + ); + // THE ARM THAT MUST STAY EMPTY. Every `ExprVar` reached exactly one member of a closed + // classification above; `NamesNothingKnown` is the member that cannot be construed as + // either a binding or a reference. It is reported with its population and specimens rather + // than silently dropped, because an unclassifiable name is the state whose silent handling + // produced this whole defect. + eprintln!( + "[floor-phase] phase=expr-var-classification {}", + class_tally + .iter() + .map(|(k, v)| format!("{k:?}={v}")) + .collect::>() + .join(" ") + ); + if !unclassified.is_empty() { + let mut specimens = unclassified.clone(); + specimens.sort(); + specimens.dedup(); + eprintln!( + "[floor-phase] phase=expr-var-classification unclassified={} distinct={} specimens={:?}", + unclassified.len(), + specimens.len(), + specimens.iter().take(20).collect::>() + ); + } let index = Rc::new(ReferenceClosureIndex { module_count: prepared.graph.modules.len(), decl_index, @@ -43706,3 +44211,330 @@ mod terminal_ledger_completeness_law { ); } } + +/// THE REFERENCE COLLECTOR'S DISCRIMINATING EVIDENCE. +/// +/// WHERE THIS RUNS, STATED WITHOUT FLATTERY: `cargo test` locally. The Rust suite was removed +/// from CI on 2026-07-11 (operator ruling, `gunbc.commit_workflow` +/// `commit_gate_rust_suite_removed_disposition`), so these rows are evidence that the +/// classification HOLDS, never evidence that CI re-checks it. The CI-executing half of this +/// change's evidence is the floor itself: the expected-red identities whose verdict moves +/// because the closure is corrected. +/// +/// THE TWO MUTATION CONTROLS ARE WHAT MAKE THE REST NON-VACUOUS. Rows asserting "a free name is +/// an edge" and "a bound name is not" can both be satisfied by a collector that is simply wrong +/// in a compensating way, so `mutation_*` re-runs the same fixtures with binder tracking forced +/// to one answer and requires the opposite family to go red. Without them the fixtures above are +/// green-by-construction, which is the failure this whole change is about. +#[cfg(test)] +mod reference_collector_binder_fixtures { + use super::{ + collect_node_refs, parse_module_node_tolerant, BTreeMap, ExprVarClass, + ExprVarClassification, HashMap, + }; + use crate::v1_std_core::{build_newline_index, NewlineIndex}; + use std::collections::BTreeSet; + use std::rc::Rc; + + /// How the mutation controls defeat binder tracking. `Real` is production; the other two + /// force the classification to one answer so the fixtures above must go red. + #[derive(Clone, Copy, PartialEq)] + enum BinderPolicy { + Real, + EverythingBound, + EverythingFree, + } + + fn free_names(source: &str) -> BTreeSet { + free_names_under(source, BinderPolicy::Real, None) + } + + /// Same, with a declaration index present. The chain-head member is only reachable with an + /// index, because "no module declares this name" is a question an absent index cannot answer. + fn free_names_with_decls(source: &str, declared: &[&str]) -> BTreeSet { + let index: HashMap> = declared + .iter() + .map(|n| { + ( + (*n).to_string(), + std::iter::once("other".to_string()).collect(), + ) + }) + .collect(); + free_names_under(source, BinderPolicy::Real, Some(&index)) + } + + /// Run the collector over one authored module and answer the free-reference name set. + fn free_names_under( + source: &str, + policy: BinderPolicy, + decl_index: Option<&HashMap>>, + ) -> BTreeSet { + let rel = "fixture/binder_fixture.dag"; + let tree = parse_module_node_tolerant(rel, source).expect("fixture parses"); + let mut indices: HashMap> = HashMap::new(); + indices.insert( + rel.to_string(), + build_newline_index(rel.to_string(), source.to_string()), + ); + let indices = Rc::new(indices); + let mut bare: std::collections::HashSet = std::collections::HashSet::new(); + let mut chains: Vec> = Vec::new(); + let mut tally: BTreeMap = BTreeMap::new(); + let mut unclassified: Vec = Vec::new(); + let mut classify = ExprVarClassification { + decl_index, + tally: &mut tally, + unclassified: &mut unclassified, + module: "fixture".to_string(), + occurrences: 0, + free_reference_edges: 0, + bound_occurrences_suppressed: 0, + chain_head_occurrences: 0, + refusals: Vec::new(), + }; + for item in tree.children.iter() { + collect_node_refs(item, &mut bare, &mut chains, &indices, &mut classify); + } + // THE MUTATION IS APPLIED TO THE RESULT, NOT TO THE PRODUCTION PATH. Forcing the answer + // here rather than behind a flag inside `collect_node_refs` keeps the shipped collector + // free of a test-only mode — a toggle whose only effect is "classify differently" is the + // escape hatch DESIGN §5 forbids, and it would be reachable in production. + let bare: std::collections::HashSet = match policy { + BinderPolicy::Real => bare, + // Everything bound: no occurrence is ever an edge. + BinderPolicy::EverythingBound => std::collections::HashSet::new(), + // Everything free: every occurrence is an edge, binders ignored. + BinderPolicy::EverythingFree => { + let mut all: std::collections::HashSet = bare; + collect_every_var_name(&tree, &mut all); + all + } + }; + assert!( + classify.reconciles(), + "occurrences={} free={} bound={} — every occurrence must land in exactly one member", + classify.occurrences, + classify.free_reference_edges, + classify.bound_occurrences_suppressed + ); + assert!( + classify.refusals.is_empty(), + "fixture reached unsupported binder syntax: {:?}", + classify.refusals + ); + bare.into_iter().collect() + } + + /// Every `ExprVar` name in the tree, binders ignored — the "everything free" mutation. + fn collect_every_var_name( + node: &Rc, + out: &mut std::collections::HashSet, + ) { + if let crate::v1_std_core::ExprData::ExprVar { .. } = &*node.expr_data { + if !node.name.is_empty() { + out.insert(node.name.clone()); + } + } + for c in node.children.iter() { + collect_every_var_name(c, out); + } + if let Some(b) = &node.body { + collect_every_var_name(b, out); + } + for p in node.properties.iter() { + collect_every_var_name(p, out); + } + } + + const FREE_REFERENCE_FIXTURES: &[&str] = &[ + "module fixture\n\nfn f() -> Bool {\n elsewhere_row\n}\n", + "module fixture\n\nfn f(xs: List) -> Bool {\n map(xs, x => elsewhere_row)\n}\n", + "module fixture\n\nfn f() -> Bool {\n let elsewhere_row = elsewhere_row\n true\n}\n", + ]; + + const BOUND_REFERENCE_FIXTURES: &[&str] = &[ + "module fixture\n\nfn f(elsewhere_row: Bool) -> Bool {\n elsewhere_row\n}\n", + "module fixture\n\nfn f() -> Bool {\n let elsewhere_row = true\n elsewhere_row\n}\n", + "module fixture\n\nfn f(xs: List) -> Bool {\n map(xs, elsewhere_row => elsewhere_row)\n}\n", + ]; + + /// MUTATION CONTROL 1. Treat every occurrence as bound and the free-reference family must go + /// red. Without this, "a free name is an edge" is satisfiable by a collector that is wrong in + /// a compensating way. + #[test] + fn mutation_everything_bound_reds_the_free_reference_family() { + for source in FREE_REFERENCE_FIXTURES { + let real = free_names_under(source, BinderPolicy::Real, None); + assert!( + real.contains("elsewhere_row"), + "control precondition: {source:?} -> {real:?}" + ); + let mutated = free_names_under(source, BinderPolicy::EverythingBound, None); + assert!( + !mutated.contains("elsewhere_row"), + "mutation did not flip {source:?}" + ); + } + } + + /// MUTATION CONTROL 2. Treat every occurrence as free and the bound family must go red. + #[test] + fn mutation_everything_free_reds_the_bound_reference_family() { + for source in BOUND_REFERENCE_FIXTURES { + let real = free_names_under(source, BinderPolicy::Real, None); + assert!( + !real.contains("elsewhere_row"), + "control precondition: {source:?} -> {real:?}" + ); + let mutated = free_names_under(source, BinderPolicy::EverythingFree, None); + assert!( + mutated.contains("elsewhere_row"), + "mutation did not flip {source:?}" + ); + } + } + + /// LOCAL DIAGNOSIS: which names in a real module land in NamesNothingKnown, and what binder + /// form did they come from. Not a claim; an instrument. + #[test] + #[ignore = "diagnostic"] + fn unclassified_names_in_a_real_module() { + let source = "module fixture\n\nfn f(o: Int?) -> Int {\n match o {\n Present { value: v } => v\n Absent => 0\n }\n}\n"; + let tree = parse_module_node_tolerant("fixture.dag", source).expect("parses"); + fn dump(n: &Rc, d: usize) { + let pat = match &n.match_pattern { + Some(mp) => match &**mp { + crate::v1_std_core::MatchPattern::VariantPattern { + name, + field_bindings, + .. + } => format!( + "VariantPattern({name}, fields={:?})", + field_bindings + .iter() + .map(|f| f.name.clone()) + .collect::>() + ), + other => format!("{other:?}"), + }, + None => "-".into(), + }; + println!( + "DUMP {:indent$}kind={:?} name={:?} children={} body={} pattern={pat}", + "", + n.expr_data, + n.name, + n.children.len(), + n.body.is_some(), + indent = d * 2 + ); + for c in n.children.iter() { + dump(c, d + 1); + } + if let Some(b) = &n.body { + dump(b, d + 1); + } + } + for item in tree.children.iter() { + dump(item, 0); + } + } + + /// A PARAMETER USED THROUGH A FIELD ACCESS IS STILL BOUND. `rgb.r` reads the parameter + /// `rgb`; if the field-access base escapes binder tracking, every record-shaped parameter in + /// the corpus is misfiled. + #[test] + fn a_parameter_read_through_a_field_access_is_not_an_edge() { + let names = + free_names("module fixture\n\nfn f(rgb: RgbScaled) -> Int {\n g(c: rgb.r)\n}\n"); + assert!(!names.contains("rgb"), "{names:?}"); + } + + /// A VARIANT PATTERN'S FIELD BINDING IS A BINDER. `Present { value: v } => v` binds `v`. + #[test] + fn a_variant_pattern_field_binding_is_not_an_edge() { + let names = free_names( + "module fixture\n\nfn f(o: Int?) -> Int {\n match o {\n Present { value: v } => v\n Absent => 0\n }\n}\n", + ); + assert!(!names.contains("v"), "{names:?}"); + } + + #[test] + fn a_qualified_chain_head_is_not_a_bare_reference() { + let names = free_names_with_decls( + "module fixture\n\nfn f() -> Bool {\n extdeps.browser.chromium\n}\n", + &["something_else"], + ); + assert!(!names.contains("extdeps"), "{names:?}"); + } + + /// THE CONTROL THAT KEEPS THE MEMBER ABOVE FROM EATING REAL EDGES. The dotted scan owns only + /// chains whose prefix is a MODULE PATH, so a head some module declares is an ordinary value + /// reference and must survive as one — suppressing it would delete the edge silently. + #[test] + fn a_chain_head_that_a_module_declares_is_still_an_edge() { + let names = free_names_with_decls( + "module fixture\n\nfn f() -> Bool {\n some_data_row.field\n}\n", + &["some_data_row"], + ); + assert!(names.contains("some_data_row"), "{names:?}"); + } + + #[test] + fn a_free_reference_inside_a_match_arm_is_an_edge() { + let names = free_names( + "module fixture\n\nfn f(o: Int?) -> Int {\n match o {\n Present { value: v } => elsewhere_row\n Absent => 0\n }\n}\n", + ); + assert!(names.contains("elsewhere_row"), "{names:?}"); + } + + #[test] + fn a_free_function_value_reference_is_an_edge() { + let names = free_names("module fixture\n\nfn f() -> Bool {\n elsewhere_row\n}\n"); + assert!(names.contains("elsewhere_row"), "{names:?}"); + } + + #[test] + fn a_name_spelled_like_a_parameter_is_not_an_edge() { + let names = free_names( + "module fixture\n\nfn f(elsewhere_row: Bool) -> Bool {\n elsewhere_row\n}\n", + ); + assert!(!names.contains("elsewhere_row"), "{names:?}"); + } + + #[test] + fn a_let_bound_name_is_not_an_edge() { + let names = free_names( + "module fixture\n\nfn f() -> Bool {\n let elsewhere_row = true\n elsewhere_row\n}\n", + ); + assert!(!names.contains("elsewhere_row"), "{names:?}"); + } + + #[test] + fn a_lambda_parameter_is_not_an_edge() { + let names = free_names( + "module fixture\n\nfn f(xs: List) -> Bool {\n map(xs, elsewhere_row => elsewhere_row)\n}\n", + ); + assert!(!names.contains("elsewhere_row"), "{names:?}"); + } + + #[test] + fn a_free_name_captured_inside_a_lambda_is_an_edge() { + let names = free_names( + "module fixture\n\nfn f(xs: List) -> Bool {\n map(xs, x => elsewhere_row)\n}\n", + ); + assert!(names.contains("elsewhere_row"), "{names:?}"); + } + + /// A LET BINDS OVER WHAT FOLLOWS IT, NOT OVER ITS OWN VALUE. `let x = x` reads the OUTER `x`, + /// so the value position is still an edge while the later occurrence is not — the one case a + /// flat "bound somewhere in this function" set gets wrong in the losing direction. + #[test] + fn a_let_value_reads_the_outer_binding() { + let names = free_names( + "module fixture\n\nfn f() -> Bool {\n let elsewhere_row = elsewhere_row\n true\n}\n", + ); + assert!(names.contains("elsewhere_row"), "{names:?}"); + } +} diff --git a/src/v1/stage0/tests/all_errored_rows_probe.rs b/src/v1/stage0/tests/all_errored_rows_probe.rs new file mode 100644 index 00000000000..85394554c8a --- /dev/null +++ b/src/v1/stage0/tests/all_errored_rows_probe.rs @@ -0,0 +1,219 @@ +//! LOCAL DIAGNOSTIC PROBE — not for commit. All 170 RUNTIME-ERRORED enrolled rows through the +//! real floor path, reporting scope size beside outcome. + +use v1_compiler::cli_run::{ + claim_scope_for, evaluation_frame, floor_prepared_subject_exclusions, prepare_repository_once, + run_claim_measured, +}; +use v1_compiler::v1_interpreter::ExecutionMode; + +const ROWS: &[(&str, &str)] = &[ + ("test.claim.accelerator_demo_execution_witness", "test.claim.accelerator_demo_execution_witness.accelerator_demo_execution_lane_witnesses"), + ("test.claim.accelerator_demo_model_witness", "test.claim.accelerator_demo_model_witness.accelerator_demo_modeling_lane_witnesses"), + ("test.claim.ci_deploy_target_host_witness", "test.claim.ci_deploy_target_host_witness.witness_deploy_stage_pins_srv1_runner_label"), + ("test.claim.ci_deploy_target_host_witness", "test.claim.ci_deploy_target_host_witness.witness_deploy_job_not_on_ubicloud_runner"), + ("test.claim.config_record_emit_witness", "test.claim.config_record_emit_witness.witness_manifest_knobs_space_separated"), + ("test.claim.config_record_emit_witness", "test.claim.config_record_emit_witness.witness_same_fields_differ_across_knobs"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.design_s1_argument_form_is_valid"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.design_s1_argument_is_non_vacuous"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.design_full_argument_form_is_valid"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.design_full_argument_has_no_orphan"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.design_full_argument_is_acyclic"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.design_full_argument_axiom_set_is_closed"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.orphan_is_detected"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.cycle_is_detected"), + ("test.claim.design_argument_witness", "test.claim.design_argument_witness.smuggled_axiom_is_detected"), + ("test.claim.ebay_listing_witness", "test.claim.ebay_listing_witness.witness_default_listing_policy_targets_us_marketplace"), + ("test.claim.emit_host_gate_witness", "test.claim.emit_host_gate_witness.w_rust_fixture_nonempty"), + ("test.claim.emit_host_gate_witness", "test.claim.emit_host_gate_witness.w_python_fixture_nonempty"), + ("test.claim.emit_host_gate_witness", "test.claim.emit_host_gate_witness.w_go_fixture_nonempty"), + ("test.claim.emit_host_gate_witness", "test.claim.emit_host_gate_witness.w_ts_fixture_nonempty"), + ("test.claim.emit_host_gate_witness", "test.claim.emit_host_gate_witness.w_byte_count_is_five"), + ("test.claim.emit_host_gate_witness", "test.claim.emit_host_gate_witness.w_ts_byte_count_is_four"), + ("test.claim.fleet_convergence_verdict_witness", "test.claim.fleet_convergence_verdict_witness.live_fleet_is_not_converged_and_unobserved_cells_are_counted"), + ("test.claim.fleet_convergence_verdict_witness", "test.claim.fleet_convergence_verdict_witness.knob_receipts_alone_cannot_converge_the_fleet"), + ("test.claim.fleet_receipt_collector_witness", "test.claim.fleet_receipt_collector_witness.witness_partial_collection_never_yields_fleet_converged"), + ("test.claim.go_module_versioning_witness", "test.claim.go_module_versioning_witness.w_go_manifest_file"), + ("test.claim.hand_lens_host_bridge_scaffold_watchdog", "test.claim.hand_lens_host_bridge_scaffold_watchdog.hand_lens_host_bridge_scaffold_roster_tracks_5364_dissolution"), + ("test.claim.hetzner_cost_quote_witness", "test.claim.hetzner_cost_quote_witness.hetzner_cax41_cost_class_is_per_second_billed"), + ("test.claim.hetzner_cost_quote_witness", "test.claim.hetzner_cost_quote_witness.hetzner_cax41_currency_is_eur"), + ("test.claim.hetzner_cost_quote_witness", "test.claim.hetzner_cost_quote_witness.hetzner_cax41_unit_price_matches_catalog"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_reconcile_covers_upsert_teardown_and_noop"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_matrix_is_exact_join_over_participation_programs"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_live_observation_frontier_is_one_cell"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_unmodeled_cells_track_spine_gaps"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_remaining_work_counts_every_unfinished_cell"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_program_scoping_preserves_the_runner_fleet_matrix"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_fleet_matrix_has_no_duplicated_cells"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_matrix_hosts_are_exactly_the_enrolled_roster"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_enrolled_sparks_carry_exactly_the_shared_obligations"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_enrolled_spark_cells_are_all_unobserved"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_runner_only_obligations_exist_on_runner_hosts"), + ("test.claim.host_phase_status", "test.claim.host_phase_status.witness_every_covered_cell_today_is_the_authored_one"), + ("test.claim.host_reach_identity_probe_witness", "test.claim.host_reach_identity_probe_witness.committed_probe_receipts_feed_producers_and_grow_coverage"), + ("test.claim.host_reach_identity_probe_witness", "test.claim.host_reach_identity_probe_witness.observe_host_phase_routes_by_label_and_stays_fail_closed"), + ("test.claim.host_standup_assimilation_deduction", "test.claim.host_standup_assimilation_deduction.pre_install_within_budget_is_absent_not_converged"), + ("test.claim.host_standup_assimilation_deduction", "test.claim.host_standup_assimilation_deduction.post_install_lease_row_deduces_converged_noop"), + ("test.claim.host_standup_assimilation_deduction", "test.claim.host_standup_assimilation_deduction.unreadable_lease_is_unknown_refused_not_pending"), + ("test.claim.host_standup_assimilation_deduction", "test.claim.host_standup_assimilation_deduction.no_lease_past_budget_is_drifted_not_fabricated_success"), + ("test.claim.host_standup_assimilation_deduction", "test.claim.host_standup_assimilation_deduction.upsert_pending_applies_assert_pending_plan"), + ("test.claim.host_standup_spine", "test.claim.host_standup_spine.post_install_dhcp_subsumption_reduces_gap_count_by_one"), + ("test.claim.materialized_secret", "test.claim.materialized_secret.witness_enabled_but_unprobed_refuses"), + ("test.claim.materialized_secret", "test.claim.materialized_secret.witness_enabled_but_revoked_refuses"), + ("test.claim.materialized_secret", "test.claim.materialized_secret.witness_live_secret_materializes_and_runs_the_use"), + ("test.claim.materialized_secret", "test.claim.materialized_secret.witness_destroyed_version_refuses_even_when_probe_says_live"), + ("test.claim.materialized_secret", "test.claim.materialized_secret.witness_self_repairing_probe_is_refused_by_classification"), + ("test.claim.materialized_secret", "test.claim.materialized_secret.witness_red_control_existence_only_rejected_by_gate"), + ("test.claim.realization_reconcile_witness", "test.claim.realization_reconcile_witness.witness_same_keysource_collapses_to_share"), + ("test.claim.realization_reconcile_witness", "test.claim.realization_reconcile_witness.witness_different_keysource_does_not_collapse"), + ("test.claim.realization_reconcile_witness", "test.claim.realization_reconcile_witness.witness_post_always_never_collapses"), + ("test.claim.samsung_dram_module", "test.claim.samsung_dram_module.four_rank_by_four_is_realizable_on_ddr4"), + ("test.claim.samsung_dram_module", "test.claim.samsung_dram_module.same_capacity_at_one_rank_by_eight_is_not_realizable"), + ("test.claim.samsung_dram_module", "test.claim.samsung_dram_module.generation_mismatch_fails_closed"), + ("test.claim.srv3_subsumption", "test.claim.srv3_subsumption.srv3_reconcile_adds_exactly_the_missing_fleet_key"), + ("test.claim.srv3_subsumption", "test.claim.srv3_subsumption.srv3_reconcile_refuses_both_unowned_keys_never_teardown"), + ("test.claim.srv3_subsumption", "test.claim.srv3_subsumption.srv4_reconcile_is_converged_empty_plan"), + ("test.claim.srv3_subsumption", "test.claim.srv3_subsumption.srv3_and_srv4_disagree_on_convergence"), + ("test.claim.srv3_subsumption", "test.claim.srv3_subsumption.reconcile_would_teardown_only_if_ownership_claimed_it"), + ("test.claim.srv3_subsumption", "test.claim.srv3_subsumption.comment_only_drift_is_one_change_not_remove_add"), + ("v2.test.lens_mutation_adequacy.mutation_adequacy_test", "v2.test.lens_mutation_adequacy.mutation_adequacy_test.adequate_when_every_mutation_has_a_discriminating_witness"), + ("v2.test.lens_mutation_adequacy.mutation_adequacy_test", "v2.test.lens_mutation_adequacy.mutation_adequacy_test.surviving_mutation_is_inadequate"), + ("v2.test.lens_vacuity.vacuity_test", "v2.test.lens_vacuity.vacuity_test.vacuity_rung5_emit_vs_eval_classifies_proven_independent"), + ("v2.test.lens_vacuity.vacuity_test", "v2.test.lens_vacuity.vacuity_test.vacuity_unified_node_corpus_matches_transport_classifier"), + ("v2.test.lens_vacuity.vacuity_test", "v2.test.lens_vacuity.vacuity_test.vacuity_falsification_cases_each_match_expected_evidence"), + ("v2.test.lens_vacuity.vacuity_test", "v2.test.lens_vacuity.vacuity_test.vacuity_advisory_census_partitions_falsification_suite"), + ("v2.test.lens_vacuity.vacuity_test", "v2.test.lens_vacuity.vacuity_test.vacuity_falsification_suite_nonempty"), + ("v2.test.claim.compiler_materialization_witness", "v2.test.claim.compiler_materialization_witness.parse_table_carrier_inhabits_realization"), + ("v2.test.claim.compiler_materialization_witness", "v2.test.claim.compiler_materialization_witness.compile_stage_carrier_inhabits_realization"), + ("v2.test.emit.produced_decl_support_preserved", "v2.test.emit.produced_decl_support_preserved.produced_decl_support_survives_augmentation"), + ("v2.test.extdeps.spice_rc_passive_deck_claims", "v2.test.extdeps.spice_rc_passive_deck_claims.spice_rc_passive_deck_authority_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.cargo_build_policy_leak", "v2.test.extdeps_shape_transport_policy.corpus.cargo_build_policy_leak.corpus_cargo_build_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.cargo_clippy_dead_param", "v2.test.extdeps_shape_transport_policy.corpus.cargo_clippy_dead_param.corpus_cargo_clippy_dead_param_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.cargo_doc_dead_param", "v2.test.extdeps_shape_transport_policy.corpus.cargo_doc_dead_param.corpus_cargo_doc_dead_param_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.cargo_doc_policy_leak", "v2.test.extdeps_shape_transport_policy.corpus.cargo_doc_policy_leak.corpus_cargo_doc_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_dead_param", "v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_dead_param.corpus_cargo_fmt_dead_param_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_policy_leak", "v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_policy_leak.corpus_cargo_fmt_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.cargo_run_dead_param", "v2.test.extdeps_shape_transport_policy.corpus.cargo_run_dead_param.corpus_cargo_run_dead_param_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.gcp_login_dead_param", "v2.test.extdeps_shape_transport_policy.corpus.gcp_login_dead_param.corpus_gcp_login_dead_param_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.gcp_oauth_fusion_fork", "v2.test.extdeps_shape_transport_policy.corpus.gcp_oauth_fusion_fork.corpus_gcp_oauth_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.gist_create_policy_leak", "v2.test.extdeps_shape_transport_policy.corpus.gist_create_policy_leak.corpus_gist_create_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.git_policy_leak", "v2.test.extdeps_shape_transport_policy.corpus.git_policy_leak.corpus_git_policy_leak_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.corpus.runtime_local_embedded_policy", "v2.test.extdeps_shape_transport_policy.corpus.runtime_local_embedded_policy.corpus_runtime_local_embedded_policy_defused_holds"), + ("v2.test.extdeps_shape_transport_policy.coverage_domain_equivalence_test", "v2.test.extdeps_shape_transport_policy.coverage_domain_equivalence_test.extdeps_shape_transport_policy_coverage_domain_equivalence_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.clean_gist_create", "v2.test.extdeps_shape_transport_policy.lens_unit.clean_gist_create.clean_gist_create_is_green_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.clean_git_diff", "v2.test.extdeps_shape_transport_policy.lens_unit.clean_git_diff.clean_git_diff_is_green_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_cargo_build", "v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_cargo_build.dead_param_cargo_build_is_red_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_cargo_clippy", "v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_cargo_clippy.dead_param_cargo_clippy_is_red_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_gcp_login", "v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_gcp_login.dead_param_gcp_login_is_red_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.embedded_policy_literal_local", "v2.test.extdeps_shape_transport_policy.lens_unit.embedded_policy_literal_local.embedded_policy_literal_local_is_red_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.module_path_rename", "v2.test.extdeps_shape_transport_policy.lens_unit.module_path_rename.module_path_rename_resolves_by_qn_not_filepath_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.module_path_rename", "v2.test.extdeps_shape_transport_policy.lens_unit.module_path_rename.module_path_rename_unknown_qn_does_not_resolve_holds"), + ("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_green.module_source_nickname_literal_exempt_literals_is_green_holds"), + ("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_coverage_domain_green.module_source_nickname_literal_coverage_domain_is_green_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.module_source_nickname_literal_local_red", "v2.test.extdeps_shape_transport_policy.lens_unit.module_source_nickname_literal_local_red.module_source_nickname_literal_local_red_is_red_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_build", "v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_build.policy_leak_cargo_build_is_red_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_doc", "v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_doc.policy_leak_cargo_doc_is_red_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_fmt", "v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_fmt.policy_leak_cargo_fmt_is_red_holds"), + ("v2.test.extdeps_shape_transport_policy.lens_unit.transport_fusion_gcp_oauth", "v2.test.extdeps_shape_transport_policy.lens_unit.transport_fusion_gcp_oauth.transport_fusion_gcp_oauth_is_red_holds"), + ("v2.test.fact_cardinality.lens_unit.synthetic_fork_red", "v2.test.fact_cardinality.lens_unit.synthetic_fork_red.synthetic_fork_red_holds"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_is_diagnostic"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_anchor_holds"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_roster_covers_testclaim"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_covers_every_coproduct"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_is_equals"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_anchor_holds"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_covers_bool"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_covers_optional_null"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_refinement_preserves_nonempty_list_base"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_refinement_subject_anchor_holds"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_refinement_scheduler_emits_one_generator"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_refinement_claim_emits"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_lbe_conj_snapshot_passes"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_lbe_disj_snapshot_passes"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_lbe_transform_snapshot_passes"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_lbe_schedules_three_generators"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_lbe_dag_surface_language_identity"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_witness_validity_constraint_satisfaction_emits"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_witness_validity_property_symbol_mismatch_emits"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_witness_validity_evidence_node_mismatch_emits"), + ("v2.test.claim.generated_conformance_floor", "v2.test.claim.generated_conformance_floor.generated_witness_validity_rule_not_realized_emits"), + ("v2.test.claim.gha_workflow_yaml_fold_structural", "v2.test.claim.gha_workflow_yaml_fold_structural.gha_fold_structural_tier_holds"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_cost_is_lowerable"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_cost_not_lowerable"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_is_runtime_candidate"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_not_runtime_candidate"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_not_changetime_redundant"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_is_linear"), + ("v2.test.manual.bootstrap_footprint_anchor", "v2.test.manual.bootstrap_footprint_anchor.bootstrap_footprint_canonical_holds"), + ("v2.test.manual.bootstrap_footprint_anchor", "v2.test.manual.bootstrap_footprint_anchor.bootstrap_footprint_non_canonical_violates"), + ("v2.test.manual.bootstrap_footprint_anchor", "v2.test.manual.bootstrap_footprint_anchor.bootstrap_footprint_bad_content_hash_violates"), + ("v2.test.manual.bootstrap_footprint_anchor", "v2.test.manual.bootstrap_footprint_anchor.bootstrap_footprint_bad_runtime_same_identity_violates"), + ("v2.test.manual.medium_node_instantiation", "v2.test.manual.medium_node_instantiation.medium_node_carried_is_expected"), + ("v2.test.manual.medium_node_instantiation", "v2.test.manual.medium_node_instantiation.medium_node_fidelity_is_lossless"), + ("v2.test.manual.medium_node_instantiation", "v2.test.manual.medium_node_instantiation.medium_node_lossy_tag_not_lossless"), + ("v2.test.manual.medium_source_text_instantiation", "v2.test.manual.medium_source_text_instantiation.witness_source_field_is_medium"), + ("v2.test.manual.value_null_split_witness", "v2.test.manual.value_null_split_witness.optional_null_straddle_rostered_until_phase_e"), + ("v2.test.claim.source_root_tagging", "v2.test.claim.source_root_tagging.source_root_tag_carried_and_folded_to_grounded_set"), + ("v2.test.claim.staging", "v2.test.claim.staging.cached_stage_hit_skips_stage"), + ("v2.test.claim.staging", "v2.test.claim.staging.cached_stage_miss_runs_stage"), + ("v2.test.fixture.walk_plan_stage.recursion_refusal_member", "v2.test.fixture.walk_plan_stage.recursion_refusal_member.walk_plan_stage_recursion_refusal_member_holds"), + ("v2.test.lens_mock_totality.cron_mock_totality", "v2.test.lens_mock_totality.cron_mock_totality.cron_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.cron_mock_totality", "v2.test.lens_mock_totality.cron_mock_totality.cron_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.diagnostic_mock_totality", "v2.test.lens_mock_totality.diagnostic_mock_totality.diagnostic_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.diagnostic_mock_totality", "v2.test.lens_mock_totality.diagnostic_mock_totality.diagnostic_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.filesystem_mock_totality", "v2.test.lens_mock_totality.filesystem_mock_totality.filesystem_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.filesystem_mock_totality", "v2.test.lens_mock_totality.filesystem_mock_totality.filesystem_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.gcp_mock_totality", "v2.test.lens_mock_totality.gcp_mock_totality.gcp_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.gcp_mock_totality", "v2.test.lens_mock_totality.gcp_mock_totality.gcp_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.git_mock_totality", "v2.test.lens_mock_totality.git_mock_totality.git_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.git_mock_totality", "v2.test.lens_mock_totality.git_mock_totality.git_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.git_mock_totality", "v2.test.lens_mock_totality.git_mock_totality.git_mock_omitted_show_tree_is_red_holds"), + ("v2.test.lens_mock_totality.github_mock_totality", "v2.test.lens_mock_totality.github_mock_totality.github_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.github_mock_totality", "v2.test.lens_mock_totality.github_mock_totality.github_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.http_pilot_mock_totality", "v2.test.lens_mock_totality.http_pilot_mock_totality.http_pilot_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.http_pilot_mock_totality", "v2.test.lens_mock_totality.http_pilot_mock_totality.http_pilot_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.llm_mock_totality", "v2.test.lens_mock_totality.llm_mock_totality.llm_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.llm_mock_totality", "v2.test.lens_mock_totality.llm_mock_totality.llm_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.sec_edgar_mock_totality", "v2.test.lens_mock_totality.sec_edgar_mock_totality.sec_edgar_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.sec_edgar_mock_totality", "v2.test.lens_mock_totality.sec_edgar_mock_totality.sec_edgar_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.shell_mock_totality", "v2.test.lens_mock_totality.shell_mock_totality.shell_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.shell_mock_totality", "v2.test.lens_mock_totality.shell_mock_totality.shell_mock_omitted_member_is_red_holds") +]; + +#[test] +#[ignore = "whole-corpus prepare; local diagnosis only"] +fn all_errored_rows_through_floor_scope() { + let roots = vec!["dag".to_string(), "src/v2".to_string()]; + let (prepared, _views) = + prepare_repository_once(&roots, &floor_prepared_subject_exclusions()).expect("prepare"); + let skip: Vec = std::env::var("PROBE_SKIP") + .unwrap_or_default() + .split(',') + .filter(|s| !s.is_empty()) + .map(|s| s.to_string()) + .collect(); + let lo: usize = std::env::var("PROBE_LO") + .ok() + .and_then(|v| v.parse().ok()) + .unwrap_or(0); + let hi: usize = std::env::var("PROBE_HI") + .ok() + .and_then(|v| v.parse().ok()) + .unwrap_or(usize::MAX); + for (idx, (module, qualified)) in ROWS.iter().enumerate() { + if idx < lo || idx >= hi || skip.iter().any(|s| qualified.contains(s.as_str())) { + continue; + } + match claim_scope_for(&prepared, module) { + Ok(scope) => { + let frame = evaluation_frame(&scope, ExecutionMode::Hermetic, None, None); + let (outcome, _) = run_claim_measured(&frame, &prepared.subject_digest, qualified); + println!( + "ROW\t{qualified}\t{}\t{}\t{outcome:?}", + scope.module_count, scope.ambiguous_bare_names + ); + } + Err(e) => println!("ROW\t{qualified}\tSCOPE-REFUSED\t0\t{e}"), + } + } +} diff --git a/src/v1/stage0/tests/classification_arm_census.rs b/src/v1/stage0/tests/classification_arm_census.rs new file mode 100644 index 00000000000..f21ac38dbb8 --- /dev/null +++ b/src/v1/stage0/tests/classification_arm_census.rs @@ -0,0 +1,33 @@ +//! LOCAL DIAGNOSTIC PROBE — not for commit. Population of every ExprVarClass member over the +//! whole prepared corpus, and specimens of NamesNothingKnown. Decides whether the "fits nothing" +//! arm can be a hard refusal or whether its population is a finding in its own right. + +use v1_compiler::cli_run::{ + claim_scope_for, floor_prepared_subject_exclusions, prepare_repository_once, +}; + +#[test] +#[ignore = "whole-corpus prepare; local diagnosis only"] +fn classification_arm_population() { + let roots = vec!["dag".to_string(), "src/v2".to_string()]; + let (prepared, _views) = + prepare_repository_once(&roots, &floor_prepared_subject_exclusions()).expect("prepare"); + // Building any scope forces the reference-closure index, which prints the class tally and + // the unclassified population to stderr. + let scope = claim_scope_for(&prepared, "test.claim.host_phase_status").expect("scope"); + println!( + "SCOPE\ttest.claim.host_phase_status\tmodules={}\tambiguous={}", + scope.module_count, scope.ambiguous_bare_names + ); + for m in [ + "v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_policy_leak", + "test.claim.design_argument_witness", + "test.claim.realization_reconcile_witness", + ] { + let s = claim_scope_for(&prepared, m).expect("scope"); + println!( + "SCOPE\t{m}\tmodules={}\tambiguous={}", + s.module_count, s.ambiguous_bare_names + ); + } +} diff --git a/src/v1/stage0/tests/rest_errored_rows_probe.rs b/src/v1/stage0/tests/rest_errored_rows_probe.rs new file mode 100644 index 00000000000..574b1b66471 --- /dev/null +++ b/src/v1/stage0/tests/rest_errored_rows_probe.rs @@ -0,0 +1,74 @@ +//! LOCAL DIAGNOSTIC PROBE — not for commit. The RUNTIME-ERRORED rows not yet measured, +//! excluding v2.test.claim.generated_conformance_floor: several of its rows OOM-kill a 31 GiB +//! container on their own, on the unmodified tree as well as the fixed one. + +use v1_compiler::cli_run::{ + claim_scope_for, evaluation_frame, floor_prepared_subject_exclusions, prepare_repository_once, + run_claim_measured, +}; +use v1_compiler::v1_interpreter::ExecutionMode; + +const ROWS: &[(&str, &str)] = &[ + ("v2.test.claim.gha_workflow_yaml_fold_structural", "v2.test.claim.gha_workflow_yaml_fold_structural.gha_fold_structural_tier_holds"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_cost_is_lowerable"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_cost_not_lowerable"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_is_runtime_candidate"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_not_runtime_candidate"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_not_changetime_redundant"), + ("v2.test.intent_linearity.lens_unit.runtime_axis", "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_is_linear"), + ("v2.test.manual.bootstrap_footprint_anchor", "v2.test.manual.bootstrap_footprint_anchor.bootstrap_footprint_canonical_holds"), + ("v2.test.manual.bootstrap_footprint_anchor", "v2.test.manual.bootstrap_footprint_anchor.bootstrap_footprint_non_canonical_violates"), + ("v2.test.manual.bootstrap_footprint_anchor", "v2.test.manual.bootstrap_footprint_anchor.bootstrap_footprint_bad_content_hash_violates"), + ("v2.test.manual.bootstrap_footprint_anchor", "v2.test.manual.bootstrap_footprint_anchor.bootstrap_footprint_bad_runtime_same_identity_violates"), + ("v2.test.manual.medium_node_instantiation", "v2.test.manual.medium_node_instantiation.medium_node_carried_is_expected"), + ("v2.test.manual.medium_node_instantiation", "v2.test.manual.medium_node_instantiation.medium_node_fidelity_is_lossless"), + ("v2.test.manual.medium_node_instantiation", "v2.test.manual.medium_node_instantiation.medium_node_lossy_tag_not_lossless"), + ("v2.test.manual.medium_source_text_instantiation", "v2.test.manual.medium_source_text_instantiation.witness_source_field_is_medium"), + ("v2.test.manual.value_null_split_witness", "v2.test.manual.value_null_split_witness.optional_null_straddle_rostered_until_phase_e"), + ("v2.test.claim.source_root_tagging", "v2.test.claim.source_root_tagging.source_root_tag_carried_and_folded_to_grounded_set"), + ("v2.test.claim.staging", "v2.test.claim.staging.cached_stage_hit_skips_stage"), + ("v2.test.claim.staging", "v2.test.claim.staging.cached_stage_miss_runs_stage"), + ("v2.test.fixture.walk_plan_stage.recursion_refusal_member", "v2.test.fixture.walk_plan_stage.recursion_refusal_member.walk_plan_stage_recursion_refusal_member_holds"), + ("v2.test.lens_mock_totality.cron_mock_totality", "v2.test.lens_mock_totality.cron_mock_totality.cron_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.cron_mock_totality", "v2.test.lens_mock_totality.cron_mock_totality.cron_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.diagnostic_mock_totality", "v2.test.lens_mock_totality.diagnostic_mock_totality.diagnostic_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.diagnostic_mock_totality", "v2.test.lens_mock_totality.diagnostic_mock_totality.diagnostic_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.filesystem_mock_totality", "v2.test.lens_mock_totality.filesystem_mock_totality.filesystem_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.filesystem_mock_totality", "v2.test.lens_mock_totality.filesystem_mock_totality.filesystem_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.gcp_mock_totality", "v2.test.lens_mock_totality.gcp_mock_totality.gcp_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.gcp_mock_totality", "v2.test.lens_mock_totality.gcp_mock_totality.gcp_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.git_mock_totality", "v2.test.lens_mock_totality.git_mock_totality.git_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.git_mock_totality", "v2.test.lens_mock_totality.git_mock_totality.git_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.git_mock_totality", "v2.test.lens_mock_totality.git_mock_totality.git_mock_omitted_show_tree_is_red_holds"), + ("v2.test.lens_mock_totality.github_mock_totality", "v2.test.lens_mock_totality.github_mock_totality.github_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.github_mock_totality", "v2.test.lens_mock_totality.github_mock_totality.github_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.http_pilot_mock_totality", "v2.test.lens_mock_totality.http_pilot_mock_totality.http_pilot_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.http_pilot_mock_totality", "v2.test.lens_mock_totality.http_pilot_mock_totality.http_pilot_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.llm_mock_totality", "v2.test.lens_mock_totality.llm_mock_totality.llm_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.llm_mock_totality", "v2.test.lens_mock_totality.llm_mock_totality.llm_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.sec_edgar_mock_totality", "v2.test.lens_mock_totality.sec_edgar_mock_totality.sec_edgar_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.sec_edgar_mock_totality", "v2.test.lens_mock_totality.sec_edgar_mock_totality.sec_edgar_mock_omitted_member_is_red_holds"), + ("v2.test.lens_mock_totality.shell_mock_totality", "v2.test.lens_mock_totality.shell_mock_totality.shell_mock_consumer_is_total_holds"), + ("v2.test.lens_mock_totality.shell_mock_totality", "v2.test.lens_mock_totality.shell_mock_totality.shell_mock_omitted_member_is_red_holds") +]; + +#[test] +#[ignore = "whole-corpus prepare; local diagnosis only"] +fn rest_errored_rows_through_floor_scope() { + let roots = vec!["dag".to_string(), "src/v2".to_string()]; + let (prepared, _views) = + prepare_repository_once(&roots, &floor_prepared_subject_exclusions()).expect("prepare"); + for (module, qualified) in ROWS { + match claim_scope_for(&prepared, module) { + Ok(scope) => { + let frame = evaluation_frame(&scope, ExecutionMode::Hermetic, None, None); + let (outcome, _) = run_claim_measured(&frame, &prepared.subject_digest, qualified); + println!( + "ROW\t{qualified}\t{}\t{}\t{outcome:?}", + scope.module_count, scope.ambiguous_bare_names + ); + } + Err(e) => println!("ROW\t{qualified}\tSCOPE-REFUSED\t0\t{e}"), + } + } +} diff --git a/src/v2/workflow/floor_expected_red.dag b/src/v2/workflow/floor_expected_red.dag index 0fb5ed8c191..25e62bc3781 100644 --- a/src/v2/workflow/floor_expected_red.dag +++ b/src/v2/workflow/floor_expected_red.dag @@ -330,27 +330,27 @@ import v2.std.text { String } // parse-depth hazard, not because the chunk boundaries mean anything. They do not: a chunk is a // slice of an alphabetical list and nothing reads it. fn floor_expected_red_chunk_00() -> List { - Cons { head: "test.claim.accelerator_demo_execution_witness.accelerator_demo_execution_lane_witnesses", tail: Cons { head: "test.claim.accelerator_demo_model_witness.accelerator_demo_modeling_lane_witnesses", tail: Cons { head: "test.claim.ci_deploy_target_host_witness.witness_deploy_job_not_on_ubicloud_runner", tail: Cons { head: "test.claim.ci_deploy_target_host_witness.witness_deploy_stage_pins_srv1_runner_label", tail: Cons { head: "test.claim.ci_exclusion_proof.ci_exclusion_proof_sentinel", tail: Cons { head: "test.claim.config_record_emit_witness.witness_manifest_knobs_space_separated", tail: Cons { head: "test.claim.config_record_emit_witness.witness_same_fields_differ_across_knobs", tail: Empty {} } } } } } } } + Cons { head: "test.claim.accelerator_demo_execution_witness.accelerator_demo_execution_lane_witnesses", tail: Cons { head: "test.claim.accelerator_demo_model_witness.accelerator_demo_modeling_lane_witnesses", tail: Cons { head: "test.claim.ci_exclusion_proof.ci_exclusion_proof_sentinel", tail: Empty {} } } } } fn floor_expected_red_chunk_01() -> List { - Cons { head: "test.claim.deploy_access_privilege_witness.witness_privileged_fixture_surfaces_stdout", tail: Cons { head: "test.claim.design_argument_witness.cycle_is_detected", tail: Cons { head: "test.claim.design_argument_witness.design_full_argument_axiom_set_is_closed", tail: Cons { head: "test.claim.design_argument_witness.design_full_argument_form_is_valid", tail: Cons { head: "test.claim.design_argument_witness.design_full_argument_has_no_orphan", tail: Cons { head: "test.claim.design_argument_witness.design_full_argument_is_acyclic", tail: Cons { head: "test.claim.design_argument_witness.design_s1_argument_form_is_valid", tail: Empty {} } } } } } } } + Cons { head: "test.claim.deploy_access_privilege_witness.witness_privileged_fixture_surfaces_stdout", tail: Empty {} } } fn floor_expected_red_chunk_02() -> List { - Cons { head: "test.claim.design_argument_witness.design_s1_argument_is_non_vacuous", tail: Cons { head: "test.claim.design_argument_witness.orphan_is_detected", tail: Cons { head: "test.claim.design_argument_witness.smuggled_axiom_is_detected", tail: Cons { head: "test.claim.ebay_listing_witness.witness_default_listing_policy_targets_us_marketplace", tail: Cons { head: "test.claim.emit_host_gate_witness.w_byte_count_is_five", tail: Cons { head: "test.claim.emit_host_gate_witness.w_go_fixture_nonempty", tail: Cons { head: "test.claim.emit_host_gate_witness.w_python_fixture_nonempty", tail: Cons { head: "test.claim.emit_host_gate_witness.w_rust_fixture_nonempty", tail: Cons { head: "test.claim.emit_host_gate_witness.w_ts_byte_count_is_four", tail: Cons { head: "test.claim.emit_host_gate_witness.w_ts_fixture_nonempty", tail: Cons { head: "test.claim.exact_witness_admission_witness.both_red_expectations_are_known_red_but_only_one_expects_a_pre_verdict_refusal", tail: Cons { head: "test.claim.exact_witness_admission_witness.no_batch_mixes_a_pre_verdict_row_with_an_assertion_false_row", tail: Cons { head: "test.claim.fleet_convergence_verdict_witness.knob_receipts_alone_cannot_converge_the_fleet", tail: Cons { head: "test.claim.fleet_convergence_verdict_witness.live_fleet_is_not_converged_and_unobserved_cells_are_counted", tail: Cons { head: "test.claim.fleet_receipt_collector_witness.witness_partial_collection_never_yields_fleet_converged", tail: Cons { head: "test.claim.go_module_versioning_witness.w_go_manifest_file", tail: Cons { head: "test.claim.hand_lens_host_bridge_scaffold_watchdog.hand_lens_host_bridge_scaffold_roster_tracks_5364_dissolution", tail: Cons { head: "test.claim.hetzner_cost_quote_witness.hetzner_cax41_cost_class_is_per_second_billed", tail: Cons { head: "test.claim.hetzner_cost_quote_witness.hetzner_cax41_currency_is_eur", tail: Cons { head: "test.claim.hetzner_cost_quote_witness.hetzner_cax41_unit_price_matches_catalog", tail: Cons { head: "test.claim.host_effect_apply_witness.witness_converge_policy_redrives_not_converged", tail: Cons { head: "test.claim.host_effect_apply_witness.witness_shell_failure_surfaces_captured_stdout", tail: Empty {} } } } } } } } } } } } } } } } } } } } } } } + Cons { head: "test.claim.exact_witness_admission_witness.both_red_expectations_are_known_red_but_only_one_expects_a_pre_verdict_refusal", tail: Cons { head: "test.claim.exact_witness_admission_witness.no_batch_mixes_a_pre_verdict_row_with_an_assertion_false_row", tail: Cons { head: "test.claim.fleet_convergence_verdict_witness.knob_receipts_alone_cannot_converge_the_fleet", tail: Cons { head: "test.claim.fleet_convergence_verdict_witness.live_fleet_is_not_converged_and_unobserved_cells_are_counted", tail: Cons { head: "test.claim.host_effect_apply_witness.witness_converge_policy_redrives_not_converged", tail: Cons { head: "test.claim.host_effect_apply_witness.witness_shell_failure_surfaces_captured_stdout", tail: Empty {} } } } } } } } fn floor_expected_red_chunk_03() -> List { - Cons { head: "test.claim.host_effect_apply_witness.witness_shell_on_host_failure_fails_closed", tail: Cons { head: "test.claim.host_effect_apply_witness.witness_ssh_shell_unreachable_fails_closed", tail: Cons { head: "test.claim.host_effect_plan_real_execution.host_effect_plan_shell_failure_reason_carries_exit_code_by_real_execution", tail: Cons { head: "test.claim.host_effect_plan_real_execution.host_effect_plan_shell_witness_holds_by_real_execution", tail: Cons { head: "test.claim.host_phase_status.witness_enrolled_spark_cells_are_all_unobserved", tail: Cons { head: "test.claim.host_phase_status.witness_enrolled_sparks_carry_exactly_the_shared_obligations", tail: Cons { head: "test.claim.host_phase_status.witness_every_covered_cell_today_is_the_authored_one", tail: Cons { head: "test.claim.host_phase_status.witness_fleet_matrix_has_no_duplicated_cells", tail: Cons { head: "test.claim.host_phase_status.witness_live_observation_frontier_is_one_cell", tail: Cons { head: "test.claim.host_phase_status.witness_matrix_hosts_are_exactly_the_enrolled_roster", tail: Cons { head: "test.claim.host_phase_status.witness_matrix_is_exact_join_over_participation_programs", tail: Cons { head: "test.claim.host_phase_status.witness_program_scoping_preserves_the_runner_fleet_matrix", tail: Cons { head: "test.claim.host_phase_status.witness_reconcile_covers_upsert_teardown_and_noop", tail: Cons { head: "test.claim.host_phase_status.witness_remaining_work_counts_every_unfinished_cell", tail: Cons { head: "test.claim.host_phase_status.witness_runner_only_obligations_exist_on_runner_hosts", tail: Cons { head: "test.claim.host_phase_status.witness_unmodeled_cells_track_spine_gaps", tail: Cons { head: "test.claim.host_reach_identity_probe_witness.committed_probe_receipts_feed_producers_and_grow_coverage", tail: Cons { head: "test.claim.host_reach_identity_probe_witness.observe_host_phase_routes_by_label_and_stays_fail_closed", tail: Cons { head: "test.claim.host_standup_assimilation_deduction.no_lease_past_budget_is_drifted_not_fabricated_success", tail: Cons { head: "test.claim.host_standup_assimilation_deduction.post_install_lease_row_deduces_converged_noop", tail: Cons { head: "test.claim.host_standup_assimilation_deduction.pre_install_within_budget_is_absent_not_converged", tail: Cons { head: "test.claim.host_standup_assimilation_deduction.unreadable_lease_is_unknown_refused_not_pending", tail: Cons { head: "test.claim.host_standup_assimilation_deduction.upsert_pending_applies_assert_pending_plan", tail: Cons { head: "test.claim.host_standup_spine.post_install_dhcp_subsumption_reduces_gap_count_by_one", tail: Cons { head: "test.claim.interpreter_replacement_cut_witness_test.interpreter_cut_plan_refuses_with_open_decisions", tail: Cons { head: "test.claim.interpreter_replacement_cut_witness_test.retiring_with_x_needs_no_coverage_authority", tail: Empty {} } } } } } } } } } } } } } } } } } } } } } } } } } } + Cons { head: "test.claim.host_effect_apply_witness.witness_shell_on_host_failure_fails_closed", tail: Cons { head: "test.claim.host_effect_apply_witness.witness_ssh_shell_unreachable_fails_closed", tail: Cons { head: "test.claim.host_effect_plan_real_execution.host_effect_plan_shell_failure_reason_carries_exit_code_by_real_execution", tail: Cons { head: "test.claim.host_effect_plan_real_execution.host_effect_plan_shell_witness_holds_by_real_execution", tail: Cons { head: "test.claim.host_phase_status.witness_reconcile_covers_upsert_teardown_and_noop", tail: Cons { head: "test.claim.host_phase_status.witness_remaining_work_counts_every_unfinished_cell", tail: Cons { head: "test.claim.host_reach_identity_probe_witness.committed_probe_receipts_feed_producers_and_grow_coverage", tail: Cons { head: "test.claim.host_reach_identity_probe_witness.observe_host_phase_routes_by_label_and_stays_fail_closed", tail: Cons { head: "test.claim.interpreter_replacement_cut_witness_test.interpreter_cut_plan_refuses_with_open_decisions", tail: Cons { head: "test.claim.interpreter_replacement_cut_witness_test.retiring_with_x_needs_no_coverage_authority", tail: Empty {} } } } } } } } } } } } fn floor_expected_red_chunk_04() -> List { - Cons { head: "test.claim.materialized_secret.witness_destroyed_version_refuses_even_when_probe_says_live", tail: Cons { head: "test.claim.materialized_secret.witness_enabled_but_revoked_refuses", tail: Cons { head: "test.claim.materialized_secret.witness_enabled_but_unprobed_refuses", tail: Cons { head: "test.claim.materialized_secret.witness_live_secret_materializes_and_runs_the_use", tail: Cons { head: "test.claim.materialized_secret.witness_red_control_existence_only_rejected_by_gate", tail: Cons { head: "test.claim.materialized_secret.witness_self_repairing_probe_is_refused_by_classification", tail: Cons { head: "test.claim.namespace_reference_derived_closure_acceptance.witness_namespace_reference_derived_closure_closing_contract_holds", tail: Cons { head: "test.claim.non_fold_residue_witness.non_fold_residue_clean_holds", tail: Cons { head: "test.claim.observation_raw_print_retirement_acceptance_test.observation_emit_frontier_is_zero", tail: Cons { head: "test.claim.operation_admit_callers_inert_witness.operation_form_admission_refuses_unadmitted_caller", tail: Cons { head: "test.claim.realization_reconcile_witness.witness_different_keysource_does_not_collapse", tail: Cons { head: "test.claim.realization_reconcile_witness.witness_post_always_never_collapses", tail: Cons { head: "test.claim.realization_reconcile_witness.witness_same_keysource_collapses_to_share", tail: Empty {} } } } } } } } } } } } } } + Cons { head: "test.claim.namespace_reference_derived_closure_acceptance.witness_namespace_reference_derived_closure_closing_contract_holds", tail: Cons { head: "test.claim.non_fold_residue_witness.non_fold_residue_clean_holds", tail: Cons { head: "test.claim.observation_raw_print_retirement_acceptance_test.observation_emit_frontier_is_zero", tail: Cons { head: "test.claim.operation_admit_callers_inert_witness.operation_form_admission_refuses_unadmitted_caller", tail: Cons { head: "test.claim.realization_reconcile_witness.witness_different_keysource_does_not_collapse", tail: Cons { head: "test.claim.realization_reconcile_witness.witness_post_always_never_collapses", tail: Cons { head: "test.claim.realization_reconcile_witness.witness_same_keysource_collapses_to_share", tail: Empty {} } } } } } } } } fn floor_expected_red_chunk_05() -> List { - Cons { head: "test.claim.samsung_dram_module.four_rank_by_four_is_realizable_on_ddr4", tail: Cons { head: "test.claim.samsung_dram_module.generation_mismatch_fails_closed", tail: Cons { head: "test.claim.samsung_dram_module.same_capacity_at_one_rank_by_eight_is_not_realizable", tail: Empty {} } } } + Empty {} } fn floor_expected_red_chunk_06() -> List { @@ -358,7 +358,7 @@ fn floor_expected_red_chunk_06() -> List { } fn floor_expected_red_chunk_07() -> List { - Cons { head: "v2.test.claim.compiler_materialization_witness.compile_stage_carrier_inhabits_realization", tail: Cons { head: "v2.test.claim.compiler_materialization_witness.parse_table_carrier_inhabits_realization", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_anchor_holds", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_covers_every_coproduct", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_is_diagnostic", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_roster_covers_testclaim", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_anchor_holds", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_covers_bool", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_covers_optional_null", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_is_equals", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_conj_snapshot_passes", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_dag_surface_language_identity", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_disj_snapshot_passes", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_schedules_three_generators", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_transform_snapshot_passes", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_refinement_claim_emits", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_refinement_preserves_nonempty_list_base", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_refinement_scheduler_emits_one_generator", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_refinement_subject_anchor_holds", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_witness_validity_constraint_satisfaction_emits", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_witness_validity_evidence_node_mismatch_emits", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_witness_validity_property_symbol_mismatch_emits", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_witness_validity_rule_not_realized_emits", tail: Cons { head: "v2.test.claim.gha_workflow_yaml_fold_structural.gha_fold_structural_tier_holds", tail: Empty {} } } } } } } } } } } } } } } } } } } } } } } } } + Cons { head: "v2.test.claim.compiler_materialization_witness.compile_stage_carrier_inhabits_realization", tail: Cons { head: "v2.test.claim.compiler_materialization_witness.parse_table_carrier_inhabits_realization", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_covers_every_coproduct", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_coproduct_exhaustiveness_roster_covers_testclaim", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_anchor_holds", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_covers_bool", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_covers_optional_null", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_cross_representation_equality_is_equals", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_conj_snapshot_passes", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_dag_surface_language_identity", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_disj_snapshot_passes", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_schedules_three_generators", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_lbe_transform_snapshot_passes", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_refinement_claim_emits", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_refinement_preserves_nonempty_list_base", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_refinement_scheduler_emits_one_generator", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_refinement_subject_anchor_holds", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_witness_validity_constraint_satisfaction_emits", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_witness_validity_evidence_node_mismatch_emits", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_witness_validity_property_symbol_mismatch_emits", tail: Cons { head: "v2.test.claim.generated_conformance_floor.generated_witness_validity_rule_not_realized_emits", tail: Empty {} } } } } } } } } } } } } } } } } } } } } } } fn floor_expected_red_chunk_08() -> List { @@ -370,15 +370,15 @@ fn floor_expected_red_chunk_09() -> List { } fn floor_expected_red_chunk_10() -> List { - Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.cargo_build_policy_leak.corpus_cargo_build_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.cargo_clippy_dead_param.corpus_cargo_clippy_dead_param_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.cargo_doc_dead_param.corpus_cargo_doc_dead_param_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.cargo_doc_policy_leak.corpus_cargo_doc_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_dead_param.corpus_cargo_fmt_dead_param_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.cargo_fmt_policy_leak.corpus_cargo_fmt_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.cargo_run_dead_param.corpus_cargo_run_dead_param_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.gcp_login_dead_param.corpus_gcp_login_dead_param_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.gcp_oauth_fusion_fork.corpus_gcp_oauth_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.gist_create_policy_leak.corpus_gist_create_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.git_policy_leak.corpus_git_policy_leak_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.corpus.runtime_local_embedded_policy.corpus_runtime_local_embedded_policy_defused_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.coverage_domain_equivalence_test.extdeps_shape_transport_policy_coverage_domain_equivalence_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.clean_gist_create.clean_gist_create_is_green_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.clean_git_diff.clean_git_diff_is_green_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_cargo_build.dead_param_cargo_build_is_red_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_cargo_clippy.dead_param_cargo_clippy_is_red_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.dead_param_gcp_login.dead_param_gcp_login_is_red_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.embedded_policy_literal_local.embedded_policy_literal_local_is_red_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.module_path_rename.module_path_rename_resolves_by_qn_not_filepath_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.module_path_rename.module_path_rename_unknown_qn_does_not_resolve_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.module_source_nickname_literal_coverage_domain_green.module_source_nickname_literal_coverage_domain_is_green_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.module_source_nickname_literal_green.module_source_nickname_literal_exempt_literals_is_green_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.module_source_nickname_literal_local_red.module_source_nickname_literal_local_red_is_red_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_build.policy_leak_cargo_build_is_red_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_doc.policy_leak_cargo_doc_is_red_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.policy_leak_cargo_fmt.policy_leak_cargo_fmt_is_red_holds", tail: Cons { head: "v2.test.extdeps_shape_transport_policy.lens_unit.transport_fusion_gcp_oauth.transport_fusion_gcp_oauth_is_red_holds", tail: Cons { head: "v2.test.extdeps.spice_rc_passive_deck_claims.spice_rc_passive_deck_authority_holds", tail: Cons { head: "v2.test.fact_cardinality.lens_unit.synthetic_fork_red.synthetic_fork_red_holds", tail: Cons { head: "v2.test.fixture.walk_plan_stage.failure_red_member.walk_plan_stage_failure_red_member_holds", tail: Empty {} } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } + Cons { head: "v2.test.fact_cardinality.lens_unit.synthetic_fork_red.synthetic_fork_red_holds", tail: Cons { head: "v2.test.fixture.walk_plan_stage.failure_red_member.walk_plan_stage_failure_red_member_holds", tail: Empty {} } } } fn floor_expected_red_chunk_11() -> List { - Cons { head: "v2.test.fixture.walk_plan_stage.recursion_refusal_member.walk_plan_stage_recursion_refusal_member_holds", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_cost_not_lowerable", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_is_linear", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_not_runtime_candidate", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_cost_is_lowerable", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_is_runtime_candidate", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_not_changetime_redundant", tail: Cons { head: "v2.test.lens_mock_totality.cron_mock_totality.cron_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.cron_mock_totality.cron_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.diagnostic_mock_totality.diagnostic_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.diagnostic_mock_totality.diagnostic_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.filesystem_mock_totality.filesystem_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.filesystem_mock_totality.filesystem_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.gcp_mock_totality.gcp_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.gcp_mock_totality.gcp_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.github_mock_totality.github_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.github_mock_totality.github_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.git_mock_totality.git_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.git_mock_totality.git_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.git_mock_totality.git_mock_omitted_show_tree_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.http_pilot_mock_totality.http_pilot_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.http_pilot_mock_totality.http_pilot_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.llm_mock_totality.llm_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.llm_mock_totality.llm_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mock_totality.sec_edgar_mock_totality.sec_edgar_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.sec_edgar_mock_totality.sec_edgar_mock_omitted_member_is_red_holds", tail: Empty {} } } } } } } } } } } } } } } } } } } } } } } } } } } + Cons { head: "v2.test.fixture.walk_plan_stage.recursion_refusal_member.walk_plan_stage_recursion_refusal_member_holds", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_cost_not_lowerable", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_is_linear", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.flat_loop_not_runtime_candidate", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_cost_is_lowerable", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_is_runtime_candidate", tail: Cons { head: "v2.test.intent_linearity.lens_unit.runtime_axis.nested_loop_not_changetime_redundant", tail: Empty {} } } } } } } } } fn floor_expected_red_chunk_12() -> List { - Cons { head: "v2.test.lens_mock_totality.shell_mock_totality.shell_mock_consumer_is_total_holds", tail: Cons { head: "v2.test.lens_mock_totality.shell_mock_totality.shell_mock_omitted_member_is_red_holds", tail: Cons { head: "v2.test.lens_mutation_adequacy.mutation_adequacy_test.adequate_when_every_mutation_has_a_discriminating_witness", tail: Cons { head: "v2.test.lens_mutation_adequacy.mutation_adequacy_test.surviving_mutation_is_inadequate", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_advisory_census_partitions_falsification_suite", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_falsification_cases_each_match_expected_evidence", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_falsification_suite_nonempty", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_rung5_emit_vs_eval_classifies_proven_independent", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_unified_node_corpus_matches_transport_classifier", tail: Cons { head: "v2.test.manual.english_emit_add.english_emit_add_ingest_round_trip_holds", tail: Cons { head: "v2.test.manual.medium_node_instantiation.medium_node_carried_is_expected", tail: Cons { head: "v2.test.manual.medium_node_instantiation.medium_node_fidelity_is_lossless", tail: Cons { head: "v2.test.manual.medium_node_instantiation.medium_node_lossy_tag_not_lossless", tail: Cons { head: "v2.test.manual.medium_source_text_instantiation.witness_source_field_is_medium", tail: Cons { head: "v2.test.manual.value_null_split_witness.optional_null_straddle_rostered_until_phase_e", tail: Empty {} } } } } } } } } } } } } } } } + Cons { head: "v2.test.lens_mutation_adequacy.mutation_adequacy_test.adequate_when_every_mutation_has_a_discriminating_witness", tail: Cons { head: "v2.test.lens_mutation_adequacy.mutation_adequacy_test.surviving_mutation_is_inadequate", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_advisory_census_partitions_falsification_suite", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_falsification_cases_each_match_expected_evidence", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_falsification_suite_nonempty", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_rung5_emit_vs_eval_classifies_proven_independent", tail: Cons { head: "v2.test.lens_vacuity.vacuity_test.vacuity_unified_node_corpus_matches_transport_classifier", tail: Cons { head: "v2.test.manual.english_emit_add.english_emit_add_ingest_round_trip_holds", tail: Cons { head: "v2.test.manual.medium_source_text_instantiation.witness_source_field_is_medium", tail: Cons { head: "v2.test.manual.value_null_split_witness.optional_null_straddle_rostered_until_phase_e", tail: Empty {} } } } } } } } } } } } // Enrolled per deep-ant-102's 2026-08-20 ruling on gunbc#8625/#8627: the witness is