Affected-set CI scoping: Move C (exclusion model) + Move B (execution corpus)

dsl/gunbc/ci_floor_measurement.dag

@@ -84,6 +84,14 @@ fn gunbc_ci_floor_executor_base_overhead_bytes() -> ByteSize {
   }
 }
 
+fn gunbc_ci_execution_corpus_available_width(each: ByteSize) -> Int {
+  let available = byte_size_saturating_sub(
+    total: gunbc_ci_runner_cgroup_memory_cap,
+    reserved: gunbc_ci_floor_executor_base_overhead_bytes()
+  )
+  byte_size_count(b: available) / byte_size_count(b: each)
+}
+
 fn gunbc_ci_floor_usable_shard_budget(cap: ByteSize) -> ByteSize {
   byte_size_saturating_sub(
     total: measure_scale_fraction_floor(

dsl/gunbc/ci_layer_roots.dag

@@ -4,6 +4,20 @@ data witness_layer_roots: List<String> = ["dsl", "src/v2"]
 
 data witness_discovery_scan_dirs: List<String> = ["dsl/test/claim", "src/v2/test/claim/manual"]
 
+data witness_exclusion_substrings: List<String> = [
+  "impossible_bug",
+  "test/manual/",
+  "glob_discovery.dag",
+  "glob_discovery_law.dag",
+  "host_discovered_owned_data_manifest.dag",
+  "host_source_root_ingest_manifest.dag",
+  "program_assembly/real_ingest_test.dag",
+  "self_host/compiler_closure_emit_from_ingest_test.dag",
+  "unified_test_claim_substrate_equivalence.dag",
+  "ci_exclusion_proof_test.dag",
+  "test/claim/execution/"
+]
+
 fn witness_layer_source_flags(roots: List<String>) -> String {
   fold(roots, init: "", f: (acc, r) => concat(acc, concat(" --source-root ", r)))
 }

dsl/std/realization_schedule.dag

@@ -154,13 +154,13 @@ fn runnable_predicted_space(profile: RunnableResourceProfile) -> ByteSize {
 fn runnable_profile(r: Runnable) -> RunnableResourceProfile {
   match r {
     RunnableSingleClaim { entry: _, function: _, profile: p } => p
-    RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, skip_unaffected_node_frontier: _, profile: p } => p
+    RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, skip_unaffected_node_frontier: _, exclude_substrings: _, discovery_scope_dirs: _, spawn_width_cap: _, profile: p } => p
   }
 }
 
 fn runnable_forbids_corpus_co_residence(r: Runnable) -> Bool {
   match r {
-    RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, skip_unaffected_node_frontier: _, profile: _ } => false
+    RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, skip_unaffected_node_frontier: _, exclude_substrings: _, discovery_scope_dirs: _, spawn_width_cap: _, profile: _ } => false
     RunnableSingleClaim { entry: _, function: _, profile: p } => runnable_excludes_corpus_co_residence(profile: p)
   }
 }
@@ -172,6 +172,9 @@ type Runnable
       scan_dirs: List<String>
       explicit_entries: List<ScheduleWitnessEntry>
       skip_unaffected_node_frontier: Bool
+      exclude_substrings: List<String>
+      discovery_scope_dirs: List<String>
+      spawn_width_cap: Int
       profile: RunnableResourceProfile
     }
 
@@ -188,7 +191,7 @@ type RealizationPlan<S> {
 fn runnable_step_label(r: Runnable) -> String {
   match r {
     RunnableSingleClaim { entry: _, function: f, profile: _ } => f
-    RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, skip_unaffected_node_frontier: _, profile: _ } => "__discovery_corpus__"
+    RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, skip_unaffected_node_frontier: _, exclude_substrings: _, discovery_scope_dirs: _, spawn_width_cap: _, profile: _ } => "__discovery_corpus__"
   }
 }
 
@@ -317,15 +320,18 @@ fn runnable_eq(left: Runnable, right: Runnable) -> Bool {
     RunnableSingleClaim { entry: le, function: lf, profile: lp } => match right {
       RunnableSingleClaim { entry: re, function: rf, profile: rp } =>
         (le == re) && (lf == rf) && runnable_resource_profile_eq(left: lp, right: rp)
-      RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, skip_unaffected_node_frontier: _, profile: _ } => false
+      RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, skip_unaffected_node_frontier: _, exclude_substrings: _, discovery_scope_dirs: _, spawn_width_cap: _, profile: _ } => false
     }
-    RunnableDiscoveryBatch { source_roots: lsr, scan_dirs: lsd, explicit_entries: lex, skip_unaffected_node_frontier: lskip, profile: lp } => match right {
+    RunnableDiscoveryBatch { source_roots: lsr, scan_dirs: lsd, explicit_entries: lex, skip_unaffected_node_frontier: lskip, exclude_substrings: lex2, discovery_scope_dirs: lsc, spawn_width_cap: lwc, profile: lp } => match right {
       RunnableSingleClaim { entry: _, function: _, profile: _ } => false
-      RunnableDiscoveryBatch { source_roots: rsr, scan_dirs: rsd, explicit_entries: rex, skip_unaffected_node_frontier: rskip, profile: rp } =>
+      RunnableDiscoveryBatch { source_roots: rsr, scan_dirs: rsd, explicit_entries: rex, skip_unaffected_node_frontier: rskip, exclude_substrings: rex2, discovery_scope_dirs: rsc, spawn_width_cap: rwc, profile: rp } =>
         string_list_eq(left: lsr, right: rsr)
           && string_list_eq(left: lsd, right: rsd)
           && schedule_witness_entry_list_eq(left: lex, right: rex)
           && (lskip == rskip)
+          && string_list_eq(left: lex2, right: rex2)
+          && string_list_eq(left: lsc, right: rsc)
+          && (lwc == rwc)
           && runnable_resource_profile_eq(left: lp, right: rp)
     }
   }

dsl/test/claim/ci_exclusion_proof_test.dag

@@ -0,0 +1,5 @@
+module test.claim.ci_exclusion_proof
+
+import std.types { Bool }
+
+test fn ci_exclusion_proof_sentinel() -> Bool = false

src/v1/stage0/src/bin/claim_batch.rs

@@ -10,7 +10,7 @@ use v1_compiler::cli_run::{
     build_multi_entry_index, check_floor_filename_hygiene, closure_subject_for_entry,
     discover_floor_corpus_rows, make_eval_context_with_runtime_options, peak_rss_vhwm_bytes,
     precompute_whole_tree_published_mock_keys, resolve_entry_with_index, run_claim_measured,
-    ClaimOutcome, DiscoveryRow, MultiEntryIndex,
+    ClaimOutcome, DiscoveryRow, MultiEntryIndex, FLOOR_DISCOVERY_EXCLUDES,
 };
 use v1_compiler::recorded_fixture::RecordedFixtureStore;
 use v1_compiler::v1_compiler_compile::ResolvedGraph;
@@ -462,7 +462,11 @@ fn run() -> Result<ExitCode, ExitCode> {
             eprintln!("claim_batch: {e}");
             return Err(ExitCode::from(2));
         }
-        let mut rows = match discover_floor_corpus_rows(&source_roots, &disc.scan_dirs) {
+        let excludes: Vec<String> = FLOOR_DISCOVERY_EXCLUDES
+            .iter()
+            .map(|s| s.to_string())
+            .collect();
+        let mut rows = match discover_floor_corpus_rows(&source_roots, &disc.scan_dirs, &excludes) {
             Ok(r) => r,
             Err(e) => {
                 eprintln!("claim_batch: discovery roster failed: {e}");

src/v1/stage0/src/bin/claim_executor.rs

@@ -28,6 +28,9 @@ enum Runnable {
         scan_dirs: Vec<String>,
         explicit_entries: Vec<(String, String)>,
         skip_unaffected_node_frontier: bool,
+        exclude_substrings: Vec<String>,
+        discovery_scope_dirs: Vec<String>,
+        spawn_width_cap: usize,
     },
 }
 
@@ -177,11 +180,28 @@ fn runnable_from_value(value: &Value, ctx: &InterpContext) -> Result<Runnable, S
                     },
                     None => false,
                 };
+            let exclude_substrings = match ctx.field(fields, "exclude_substrings") {
+                Some(v) => str_list_from_value(v, ctx)?,
+                // Field absent means the plan author specified no exclusions — default is empty,
+                // not the Rust constant (the model is the sole authority on the plan path).
+                None => Vec::new(),
+            };
+            let discovery_scope_dirs = match ctx.field(fields, "discovery_scope_dirs") {
+                Some(v) => str_list_from_value(v, ctx)?,
+                None => Vec::new(),
+            };
+            let spawn_width_cap = match ctx.field(fields, "spawn_width_cap") {
+                Some(Value::Int(n)) => (*n).max(0) as usize,
+                Some(_) | None => 0,
+            };
             Ok(Runnable::DiscoveryBatch {
                 source_roots,
                 scan_dirs,
                 explicit_entries,
                 skip_unaffected_node_frontier,
+                exclude_substrings,
+                discovery_scope_dirs,
+                spawn_width_cap,
             })
         }
         other => Err(format!(
@@ -243,6 +263,9 @@ enum BatchUnit {
         scan_dirs: Vec<String>,
         explicit_entries: Vec<(String, String)>,
         skip_unaffected_node_frontier: bool,
+        exclude_substrings: Vec<String>,
+        discovery_scope_dirs: Vec<String>,
+        spawn_width_cap: usize,
     },
 }
 
@@ -278,11 +301,17 @@ fn group_batch_units(batch: &[Runnable]) -> Vec<BatchUnit> {
                 scan_dirs,
                 explicit_entries,
                 skip_unaffected_node_frontier,
+                exclude_substrings,
+                discovery_scope_dirs,
+                spawn_width_cap,
             } => units.push(BatchUnit::Discovery {
                 source_roots: source_roots.clone(),
                 scan_dirs: scan_dirs.clone(),
                 explicit_entries: explicit_entries.clone(),
                 skip_unaffected_node_frontier: *skip_unaffected_node_frontier,
+                exclude_substrings: exclude_substrings.clone(),
+                discovery_scope_dirs: discovery_scope_dirs.clone(),
+                spawn_width_cap: *spawn_width_cap,
             }),
         }
     }
@@ -361,12 +390,18 @@ fn run_batch_unit(
             scan_dirs,
             explicit_entries,
             skip_unaffected_node_frontier,
+            exclude_substrings,
+            discovery_scope_dirs,
+            spawn_width_cap,
         } => vec![run_discovery_batch_node(
             roots,
             scan_dirs,
             explicit_entries,
             skip_unaffected_node_frontier,
+            exclude_substrings,
+            discovery_scope_dirs,
             spawn_width,
+            spawn_width_cap,
         )],
         BatchUnit::SharedClaims { entry, functions } => {
             run_shared_entry_claims(&source_roots, &entry, &functions)
@@ -622,12 +657,16 @@ fn emit_slowest_witness_attribution(source_roots: &[String], summary: &Discovery
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn run_discovery_batch_node(
     source_roots: Vec<String>,
     scan_dirs: Vec<String>,
     explicit_entries: Vec<(String, String)>,
     skip_unaffected_node_frontier: bool,
+    exclude_substrings: Vec<String>,
+    discovery_scope_dirs: Vec<String>,
     spawn_width: usize,
+    spawn_width_cap: usize,
 ) -> ClaimResult {
     let label = format!(
         "discovery-corpus[{} root(s)+{} explicit, width={}]",
@@ -644,6 +683,9 @@ fn run_discovery_batch_node(
         DiscoveryCorpusOptions {
             skip_unaffected_node_frontier,
             explicit_roster_only: false,
+            exclude_substrings,
+            discovery_scope_dirs,
+            spawn_width_cap,
         },
     ) {
         Ok(summary) if summary.failures.is_empty() => {
@@ -1412,11 +1454,17 @@ fn run_perturb_check(
                         scan_dirs,
                         explicit_entries,
                         skip_unaffected_node_frontier,
+                        exclude_substrings,
+                        discovery_scope_dirs,
+                        spawn_width_cap,
                     } => Runnable::DiscoveryBatch {
                         source_roots: roots.iter().map(|r| remap_root(r)).collect(),
                         scan_dirs: scan_dirs.iter().map(|d| remap_root(d)).collect(),
                         explicit_entries: explicit_entries.clone(),
                         skip_unaffected_node_frontier: *skip_unaffected_node_frontier,
+                        exclude_substrings: exclude_substrings.clone(),
+                        discovery_scope_dirs: discovery_scope_dirs.clone(),
+                        spawn_width_cap: *spawn_width_cap,
                     },
                 })
                 .collect()
@@ -1633,6 +1681,9 @@ mod tests {
             scan_dirs: vec![],
             explicit_entries: vec![],
             skip_unaffected_node_frontier: true,
+            exclude_substrings: vec![],
+            discovery_scope_dirs: vec![],
+            spawn_width_cap: 0,
         }
     }