From 8ed16af39df310800d10d47997fe29e29234ab0a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 21 Jun 2026 23:21:15 +0000 Subject: [PATCH 1/5] WIP: Re-staff Section 5 de-fork lane: FIRST fix the source-root absolute-vs-r --- src/v1/stage0/src/cli_run.rs | 60 ++++++++++++++++++++++++++++++++++-- 1 file changed, 57 insertions(+), 3 deletions(-) diff --git a/src/v1/stage0/src/cli_run.rs b/src/v1/stage0/src/cli_run.rs index 128be01d59c..cacdabf713a 100644 --- a/src/v1/stage0/src/cli_run.rs +++ b/src/v1/stage0/src/cli_run.rs @@ -3616,20 +3616,30 @@ fn source_root_ref_variant_for_root(root: &str) -> Result { /// Attribute a host-read file to the `--source-root` it came from (grounded in the actual /// filesystem path, NOT the module's self-declared QN prefix), then map to its /// `SourceRootRef` variant. Fail-closed: a path matching zero or 2+ roots is an error. +/// +/// Both the file path and the roots are first normalized to repo-relative form +/// (`repo_relative_dag_path`, the same workspace-anchored authority the import-closure keying +/// uses) so admission is invocation-independent: an ABSOLUTE `--source-root` +/// (`/src/v2`, as host tests pass) and a RELATIVE one (`src/v2`, as `claim_batch` passes) +/// both ground to the same `src/v2`/`dsl` and map to the same `SourceRootRef`. Without this, +/// an absolute root reached the variant map verbatim and fail-closed as `unknown --source-root`. fn source_root_ref_token_for_path( file_path: &str, source_roots: &[String], ) -> Result { - let matched: Vec<&String> = source_roots + let rel_path = repo_relative_dag_path(file_path); + let matched: Vec = source_roots .iter() + .map(|r| repo_relative_dag_path(r)) .filter(|r| { let r = r.trim_end_matches('/'); - file_path == r || file_path.starts_with(&format!("{r}/")) + rel_path == r || rel_path.starts_with(&format!("{r}/")) }) .collect(); match matched.as_slice() { [] => Err(format!( - "source_root tagging: file '{file_path}' matches no --source-root {source_roots:?}" + "source_root tagging: file '{file_path}' (repo-relative '{rel_path}') matches no \ + --source-root {source_roots:?}" )), [one] => source_root_ref_variant_for_root(one), _ => Err(format!( @@ -3797,6 +3807,50 @@ mod manifest_emit_tests { // boundary: a sibling dir sharing a prefix must not match (src/v20 ≠ src/v2). assert!(source_root_ref_token_for_path("src/v20/x.dag", &roots).is_err()); } + + // Discriminating regression for the abs-vs-rel admission bug: ABSOLUTE roots + an absolute + // file path (exactly how the host manifest tests invoke discover_source_root_reads_for_entry) + // must ground to the same SourceRootRef as the repo-relative form. Before the + // repo_relative_dag_path normalization, an absolute root reached the variant map verbatim and + // fail-closed as `unknown --source-root`. Goes RED on revert of that normalization. + #[test] + fn source_root_token_admits_absolute_roots() { + let ws = super::workspace_root(); + let abs_roots = vec![ + ws.join("src/v2").to_string_lossy().into_owned(), + ws.join("dsl").to_string_lossy().into_owned(), + ]; + // absolute file under an absolute root + assert_eq!( + source_root_ref_token_for_path( + ws.join("src/v2/std/algebra.dag").to_str().unwrap(), + &abs_roots + ) + .unwrap(), + "V2Tree" + ); + assert_eq!( + source_root_ref_token_for_path( + ws.join("dsl/std/algebra.dag").to_str().unwrap(), + &abs_roots + ) + .unwrap(), + "DslTree" + ); + // mixed: repo-relative file path against absolute roots also grounds correctly. + assert_eq!( + source_root_ref_token_for_path("dsl/std/algebra.dag", &abs_roots).unwrap(), + "DslTree" + ); + // fail-closed survives normalization: a file under no root is still rejected. + assert!( + source_root_ref_token_for_path( + ws.join("src/v1/stage0/x.dag").to_str().unwrap(), + &abs_roots + ) + .is_err() + ); + } } fn emit_import_admission_list(imports: &[Vec]) -> String { From 543c0720bad61907a2b01f152c39df983fa2ce2a Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 21 Jun 2026 23:24:59 +0000 Subject: [PATCH 2/5] =?UTF-8?q?=C2=A75=20de-fork=20Step=201:=20fix=20sourc?= =?UTF-8?q?e-root=20abs-vs-rel=20admission=20(un-block=20rust=20gate)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit source_root_ref_token_for_path matched/mapped --source-root paths verbatim, so an ABSOLUTE root (/src/v2, as the host manifest tests pass) never equaled src/v2/dsl and fail-closed as 'unknown --source-root'; a relative root admitted fine. Ground both the file path and the roots through repo_relative_dag_path (the same workspace-anchored authority the import-closure keying already uses) before matching and variant-mapping, so admission is invocation-independent (abs or rel). Reproduced RED by execution: source_root_ingest_manifest_host_test:: manifest_entry_admission_qualified_name_is_well_formed panicked with 'unknown --source-root /home/.../src/v2'; green after the fix. Added source_root_token_admits_absolute_roots as the discriminating unit regression (RED on revert of the normalization). fmt+clippy clean. Co-Authored-By: Claude Opus 4.8 (1M context) --- src/v1/stage0/src/cli_run.rs | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/v1/stage0/src/cli_run.rs b/src/v1/stage0/src/cli_run.rs index cacdabf713a..251e9113f4c 100644 --- a/src/v1/stage0/src/cli_run.rs +++ b/src/v1/stage0/src/cli_run.rs @@ -3843,13 +3843,11 @@ mod manifest_emit_tests { "DslTree" ); // fail-closed survives normalization: a file under no root is still rejected. - assert!( - source_root_ref_token_for_path( - ws.join("src/v1/stage0/x.dag").to_str().unwrap(), - &abs_roots - ) - .is_err() - ); + assert!(source_root_ref_token_for_path( + ws.join("src/v1/stage0/x.dag").to_str().unwrap(), + &abs_roots + ) + .is_err()); } } From 5d017243b94e6bd2bbfc57cb13e5c0126f097352 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 21 Jun 2026 23:43:52 +0000 Subject: [PATCH 3/5] WIP: Re-staff Section 5 de-fork lane: FIRST fix the source-root absolute-vs-r --- ...cross_tree_real_ingest_activation_test.dag | 163 ++++++++++++++++++ 1 file changed, 163 insertions(+) create mode 100644 src/v2/test/claim/cross_tree_real_ingest_activation_test.dag diff --git a/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag b/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag new file mode 100644 index 00000000000..e61a54184d0 --- /dev/null +++ b/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag @@ -0,0 +1,163 @@ +// Scope: §5 de-fork ACTIVATION arbiter — real-compile-path cross-tree resolution. +// +// The existing name_resolve_cross_tree_resolution_test proves resolve_with_admission_grounded +// admits v2→dsl GIVEN a HAND-BUILT grounded index (source_root_index_insert). This witness +// closes the remaining leg: it drives the REAL grounded compile entry +// assemble_program_from_ingest with a HOST-TAGGED SourceRootIngest and supplies NOTHING about +// fundamentality — the QualifiedName→SourceRootRef index and the active source-root set are +// both DERIVED from each DagSourceReadWitness.source_root tag (program_assembly fold + +// source_root_set_from_ingest), and the MoreFundamental/LessFundamental order is derived from +// tree_fundamentality_order. No explicit MoreFundamental anywhere (that is the illusion the +// audit doc names: the explicit-supply test only passes because it hands the order in). +// +// GREEN: a V2Tree-tagged subject importing a DslTree-tagged target resolves end-to-end — +// tree_fundamentality_order(V2,Dsl)=MoreFundamental + layer direction (compiler→std) +// admits it. This is the by-execution proof that cross-tree import is LIVE on the real +// compile path (carrier consumed, not merely carried). +// RED: reverse the tags (DslTree subject importing a V2Tree target) and the SAME real path +// denies it fail-closed (LessFundamental). Flip either source_root tag and the witness +// goes the wrong way — the discriminating oracle. +// +// Enrolled in CI via _test.dag naming convention (floor discovery auto-enroll). + +module v2.test.claim.cross_tree_real_ingest_activation + +import extdeps.communication.medium { Lossless, Medium } +import v2.compiler.name_resolve { + Admission, + Import, + ImportVisible, + ResolutionSubject +} +import v2.compiler.program_assembly { assemble_program_from_ingest } +import v2.compiler.source_authority { DagSourceReadWitness, SourceRootIngest } +import v2.extdeps.languages.dag { dag_language_model_wave1 } +import v2.std.algebra { Cons, Empty } +import v2.std.artifact { Artifact, SourceFile } +import v2.std.cross_tree.import_model { DslTree, V2Tree } +import v2.std.diagnostic { Accepted, Rejected } +import v2.std.logic { Bool } +import v2.std.qualified_name { QnCons, QnEmpty } + + +// ── Real module source text (parsed by the wave1 LM, the real-compile language model) ── + +// V2Tree subject: a v2.* module (layer ordinal compiler). Bare module — the import edge it +// is admitted on is carried by the Admission below, exactly as the host parses it from the +// entry's import list. The cross-tree admit/deny decision is index-driven, not body-driven. +data ct_real_v2_subject_source: Medium = Medium { + carried: "module v2.ct_real_subject\n", + fidelity: Lossless +} + +// DslTree target: a single-segment (dsl, std-layer) module exporting one type. +data ct_real_dsl_target_source: Medium = Medium { + carried: "module ct_real_target\n\ntype CtRealExport = CtRealExportValue\n", + fidelity: Lossless +} + + +// ── Artifacts (filesystem provenance the host would attach at ingest) ── + +data ct_real_v2_subject_artifact: Artifact = Artifact { + kind: SourceFile, + id: ^ct_real_v2_subject_artifact, + file_path: "src/v2/ct_real_subject.dag" +} + +data ct_real_dsl_target_artifact: Artifact = Artifact { + kind: SourceFile, + id: ^ct_real_dsl_target_artifact, + file_path: "dsl/ct_real_target.dag" +} + + +// ── GREEN ingest: V2Tree subject + DslTree target (host filesystem truth) ── +// source_root tags are the ONLY grounding input; index + active_roots derive from them. + +data ct_real_v2_to_dsl_subject_read: DagSourceReadWitness = DagSourceReadWitness { + source: ct_real_v2_subject_source, + artifact: ct_real_v2_subject_artifact, + compilation_unit: ^ct_real_subject_cu, + source_root: V2Tree +} + +data ct_real_v2_to_dsl_target_read: DagSourceReadWitness = DagSourceReadWitness { + source: ct_real_dsl_target_source, + artifact: ct_real_dsl_target_artifact, + compilation_unit: ^ct_real_target_cu, + source_root: DslTree +} + +data ct_real_v2_to_dsl_ingest: SourceRootIngest = Cons { + head: ct_real_v2_to_dsl_subject_read, + tail: Cons { head: ct_real_v2_to_dsl_target_read, tail: Empty } +} + +data ct_real_v2_to_dsl_admission: Admission = Admission { + subject: ResolutionSubject { + name: QnCons { head: ^v2, tail: QnCons { head: ^ct_real_subject, tail: QnEmpty } } + }, + imports: Cons { + head: Import { + target: QnCons { head: ^ct_real_target, tail: QnEmpty }, + visibility: ImportVisible + }, + tail: Empty + } +} + + +// ── RED ingest: tags reversed — DslTree subject + V2Tree target ── +// Same source modules, only the source_root tags swap. Importing toward a LESS fundamental +// tree (dsl→v2) must be denied fail-closed by the same real path. + +data ct_real_dsl_to_v2_subject_read: DagSourceReadWitness = DagSourceReadWitness { + source: ct_real_v2_subject_source, + artifact: ct_real_v2_subject_artifact, + compilation_unit: ^ct_real_subject_cu, + source_root: DslTree +} + +data ct_real_dsl_to_v2_target_read: DagSourceReadWitness = DagSourceReadWitness { + source: ct_real_dsl_target_source, + artifact: ct_real_dsl_target_artifact, + compilation_unit: ^ct_real_target_cu, + source_root: V2Tree +} + +data ct_real_dsl_to_v2_ingest: SourceRootIngest = Cons { + head: ct_real_dsl_to_v2_subject_read, + tail: Cons { head: ct_real_dsl_to_v2_target_read, tail: Empty } +} + + +// ── Witnesses ── + +fn cross_tree_real_ingest_v2_to_dsl_resolves_holds() -> Bool { + match assemble_program_from_ingest( + ingest: ct_real_v2_to_dsl_ingest, + admission: ct_real_v2_to_dsl_admission, + lm: dag_language_model_wave1() + ) { + Accepted { value: _, diagnostics: _ } => true + Rejected { diagnostics: _ } => false + } +} + +fn cross_tree_real_ingest_dsl_to_v2_denied_holds() -> Bool { + match assemble_program_from_ingest( + ingest: ct_real_dsl_to_v2_ingest, + admission: ct_real_v2_to_dsl_admission, + lm: dag_language_model_wave1() + ) { + Accepted { value: _, diagnostics: _ } => false + Rejected { diagnostics: _ } => true + } +} + + +test fn cross_tree_real_ingest_activation_witnesses() -> Bool { + cross_tree_real_ingest_v2_to_dsl_resolves_holds() + && cross_tree_real_ingest_dsl_to_v2_denied_holds() +} From 00e6ee39752358525d3d55e3dbac14bb66177484 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 21 Jun 2026 23:54:24 +0000 Subject: [PATCH 4/5] WIP: Re-staff Section 5 de-fork lane: FIRST fix the source-root absolute-vs-r --- ...cross_tree_real_ingest_activation_test.dag | 20 ++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag b/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag index e61a54184d0..074564dcb3a 100644 --- a/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag +++ b/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag @@ -31,12 +31,13 @@ import v2.compiler.name_resolve { } import v2.compiler.program_assembly { assemble_program_from_ingest } import v2.compiler.source_authority { DagSourceReadWitness, SourceRootIngest } -import v2.extdeps.languages.dag { dag_language_model_wave1 } +import v2.extdeps.languages.dag { dag_language_model_surface_empty_prelude } import v2.std.algebra { Cons, Empty } import v2.std.artifact { Artifact, SourceFile } import v2.std.cross_tree.import_model { DslTree, V2Tree } import v2.std.diagnostic { Accepted, Rejected } import v2.std.logic { Bool } +import v2.std.node { Symbol } import v2.std.qualified_name { QnCons, QnEmpty } @@ -138,7 +139,7 @@ fn cross_tree_real_ingest_v2_to_dsl_resolves_holds() -> Bool { match assemble_program_from_ingest( ingest: ct_real_v2_to_dsl_ingest, admission: ct_real_v2_to_dsl_admission, - lm: dag_language_model_wave1() + lm: dag_language_model_surface_empty_prelude() ) { Accepted { value: _, diagnostics: _ } => true Rejected { diagnostics: _ } => false @@ -149,7 +150,7 @@ fn cross_tree_real_ingest_dsl_to_v2_denied_holds() -> Bool { match assemble_program_from_ingest( ingest: ct_real_dsl_to_v2_ingest, admission: ct_real_v2_to_dsl_admission, - lm: dag_language_model_wave1() + lm: dag_language_model_surface_empty_prelude() ) { Accepted { value: _, diagnostics: _ } => false Rejected { diagnostics: _ } => true @@ -161,3 +162,16 @@ test fn cross_tree_real_ingest_activation_witnesses() -> Bool { cross_tree_real_ingest_v2_to_dsl_resolves_holds() && cross_tree_real_ingest_dsl_to_v2_denied_holds() } + + +// TEMP DEBUG — surface the rejection reason of the GREEN case (remove before commit). +fn ct_real_debug_v2_to_dsl_reason() -> Symbol { + match assemble_program_from_ingest( + ingest: ct_real_v2_to_dsl_ingest, + admission: ct_real_v2_to_dsl_admission, + lm: dag_language_model_surface_empty_prelude() + ) { + Accepted { value: _, diagnostics: _ } => ^accepted_no_rejection + Rejected { diagnostics: d } => d.head.reason + } +} From 2f43b965549ecb82b7008f22e0eac77eb649d407 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sun, 21 Jun 2026 23:54:33 +0000 Subject: [PATCH 5/5] Scope #5504 to the RED1 admission fix: move activation witness to its own PR The cross-tree real-ingest activation witness was an in-progress lane artifact the auto-committer swept onto this branch; it is currently failing for witness-construction reasons (parse/export-shape), not a cross-tree verdict, and is out of scope for the RED1 fix. Removing it keeps this PR the clean, green source-root abs-vs-rel admission fix. The witness lands separately once it is a valid green/red arbiter. Co-Authored-By: Claude Opus 4.8 (1M context) --- ...cross_tree_real_ingest_activation_test.dag | 177 ------------------ 1 file changed, 177 deletions(-) delete mode 100644 src/v2/test/claim/cross_tree_real_ingest_activation_test.dag diff --git a/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag b/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag deleted file mode 100644 index 074564dcb3a..00000000000 --- a/src/v2/test/claim/cross_tree_real_ingest_activation_test.dag +++ /dev/null @@ -1,177 +0,0 @@ -// Scope: §5 de-fork ACTIVATION arbiter — real-compile-path cross-tree resolution. -// -// The existing name_resolve_cross_tree_resolution_test proves resolve_with_admission_grounded -// admits v2→dsl GIVEN a HAND-BUILT grounded index (source_root_index_insert). This witness -// closes the remaining leg: it drives the REAL grounded compile entry -// assemble_program_from_ingest with a HOST-TAGGED SourceRootIngest and supplies NOTHING about -// fundamentality — the QualifiedName→SourceRootRef index and the active source-root set are -// both DERIVED from each DagSourceReadWitness.source_root tag (program_assembly fold + -// source_root_set_from_ingest), and the MoreFundamental/LessFundamental order is derived from -// tree_fundamentality_order. No explicit MoreFundamental anywhere (that is the illusion the -// audit doc names: the explicit-supply test only passes because it hands the order in). -// -// GREEN: a V2Tree-tagged subject importing a DslTree-tagged target resolves end-to-end — -// tree_fundamentality_order(V2,Dsl)=MoreFundamental + layer direction (compiler→std) -// admits it. This is the by-execution proof that cross-tree import is LIVE on the real -// compile path (carrier consumed, not merely carried). -// RED: reverse the tags (DslTree subject importing a V2Tree target) and the SAME real path -// denies it fail-closed (LessFundamental). Flip either source_root tag and the witness -// goes the wrong way — the discriminating oracle. -// -// Enrolled in CI via _test.dag naming convention (floor discovery auto-enroll). - -module v2.test.claim.cross_tree_real_ingest_activation - -import extdeps.communication.medium { Lossless, Medium } -import v2.compiler.name_resolve { - Admission, - Import, - ImportVisible, - ResolutionSubject -} -import v2.compiler.program_assembly { assemble_program_from_ingest } -import v2.compiler.source_authority { DagSourceReadWitness, SourceRootIngest } -import v2.extdeps.languages.dag { dag_language_model_surface_empty_prelude } -import v2.std.algebra { Cons, Empty } -import v2.std.artifact { Artifact, SourceFile } -import v2.std.cross_tree.import_model { DslTree, V2Tree } -import v2.std.diagnostic { Accepted, Rejected } -import v2.std.logic { Bool } -import v2.std.node { Symbol } -import v2.std.qualified_name { QnCons, QnEmpty } - - -// ── Real module source text (parsed by the wave1 LM, the real-compile language model) ── - -// V2Tree subject: a v2.* module (layer ordinal compiler). Bare module — the import edge it -// is admitted on is carried by the Admission below, exactly as the host parses it from the -// entry's import list. The cross-tree admit/deny decision is index-driven, not body-driven. -data ct_real_v2_subject_source: Medium = Medium { - carried: "module v2.ct_real_subject\n", - fidelity: Lossless -} - -// DslTree target: a single-segment (dsl, std-layer) module exporting one type. -data ct_real_dsl_target_source: Medium = Medium { - carried: "module ct_real_target\n\ntype CtRealExport = CtRealExportValue\n", - fidelity: Lossless -} - - -// ── Artifacts (filesystem provenance the host would attach at ingest) ── - -data ct_real_v2_subject_artifact: Artifact = Artifact { - kind: SourceFile, - id: ^ct_real_v2_subject_artifact, - file_path: "src/v2/ct_real_subject.dag" -} - -data ct_real_dsl_target_artifact: Artifact = Artifact { - kind: SourceFile, - id: ^ct_real_dsl_target_artifact, - file_path: "dsl/ct_real_target.dag" -} - - -// ── GREEN ingest: V2Tree subject + DslTree target (host filesystem truth) ── -// source_root tags are the ONLY grounding input; index + active_roots derive from them. - -data ct_real_v2_to_dsl_subject_read: DagSourceReadWitness = DagSourceReadWitness { - source: ct_real_v2_subject_source, - artifact: ct_real_v2_subject_artifact, - compilation_unit: ^ct_real_subject_cu, - source_root: V2Tree -} - -data ct_real_v2_to_dsl_target_read: DagSourceReadWitness = DagSourceReadWitness { - source: ct_real_dsl_target_source, - artifact: ct_real_dsl_target_artifact, - compilation_unit: ^ct_real_target_cu, - source_root: DslTree -} - -data ct_real_v2_to_dsl_ingest: SourceRootIngest = Cons { - head: ct_real_v2_to_dsl_subject_read, - tail: Cons { head: ct_real_v2_to_dsl_target_read, tail: Empty } -} - -data ct_real_v2_to_dsl_admission: Admission = Admission { - subject: ResolutionSubject { - name: QnCons { head: ^v2, tail: QnCons { head: ^ct_real_subject, tail: QnEmpty } } - }, - imports: Cons { - head: Import { - target: QnCons { head: ^ct_real_target, tail: QnEmpty }, - visibility: ImportVisible - }, - tail: Empty - } -} - - -// ── RED ingest: tags reversed — DslTree subject + V2Tree target ── -// Same source modules, only the source_root tags swap. Importing toward a LESS fundamental -// tree (dsl→v2) must be denied fail-closed by the same real path. - -data ct_real_dsl_to_v2_subject_read: DagSourceReadWitness = DagSourceReadWitness { - source: ct_real_v2_subject_source, - artifact: ct_real_v2_subject_artifact, - compilation_unit: ^ct_real_subject_cu, - source_root: DslTree -} - -data ct_real_dsl_to_v2_target_read: DagSourceReadWitness = DagSourceReadWitness { - source: ct_real_dsl_target_source, - artifact: ct_real_dsl_target_artifact, - compilation_unit: ^ct_real_target_cu, - source_root: V2Tree -} - -data ct_real_dsl_to_v2_ingest: SourceRootIngest = Cons { - head: ct_real_dsl_to_v2_subject_read, - tail: Cons { head: ct_real_dsl_to_v2_target_read, tail: Empty } -} - - -// ── Witnesses ── - -fn cross_tree_real_ingest_v2_to_dsl_resolves_holds() -> Bool { - match assemble_program_from_ingest( - ingest: ct_real_v2_to_dsl_ingest, - admission: ct_real_v2_to_dsl_admission, - lm: dag_language_model_surface_empty_prelude() - ) { - Accepted { value: _, diagnostics: _ } => true - Rejected { diagnostics: _ } => false - } -} - -fn cross_tree_real_ingest_dsl_to_v2_denied_holds() -> Bool { - match assemble_program_from_ingest( - ingest: ct_real_dsl_to_v2_ingest, - admission: ct_real_v2_to_dsl_admission, - lm: dag_language_model_surface_empty_prelude() - ) { - Accepted { value: _, diagnostics: _ } => false - Rejected { diagnostics: _ } => true - } -} - - -test fn cross_tree_real_ingest_activation_witnesses() -> Bool { - cross_tree_real_ingest_v2_to_dsl_resolves_holds() - && cross_tree_real_ingest_dsl_to_v2_denied_holds() -} - - -// TEMP DEBUG — surface the rejection reason of the GREEN case (remove before commit). -fn ct_real_debug_v2_to_dsl_reason() -> Symbol { - match assemble_program_from_ingest( - ingest: ct_real_v2_to_dsl_ingest, - admission: ct_real_v2_to_dsl_admission, - lm: dag_language_model_surface_empty_prelude() - ) { - Accepted { value: _, diagnostics: _ } => ^accepted_no_rejection - Rejected { diagnostics: d } => d.head.reason - } -}