§5 de-fork Step 1 PR-B: grounded cross-tree admission (delete QN-prefix guess)

src/v2/compiler/03_name_resolve.dag

@@ -55,16 +55,16 @@ import v2.std.passing_candidate_fold {
   PassingCandidateFold
 }
 import v2.std.cross_tree.import_model {
-  CrossTreeAdmitted,
-  CrossTreeDenied,
-  FundamentalityUnknown,
-  SourceRootRef,
-  TreeFundamentalityOrder
+  SourceRootRef
 }
 import v2.std.cross_tree.resolution {
-  cross_tree_import_admitted_qualified,
-  cross_tree_import_is_same_tree,
-  source_root_set_from_module_roots
+  EdgeCrossAdmitted,
+  EdgeCrossAmbiguous,
+  EdgeCrossDenied,
+  EdgeNormalResolution,
+  SourceRootIndex,
+  cross_tree_edge_decision,
+  source_root_index_empty
 }
 import v2.std.qualified_name {
   QualifiedName,
@@ -424,12 +424,28 @@ fn admit_import_root_find(
 }
 
 
+fn admit_import_visible_entry(
+  roots: FreeMonoid<Node>,
+  import_edge: Import,
+  state: AdmissionState
+) -> AdmissionState {
+  admit_import_root_find(
+    found: module_root_find(
+      roots: roots,
+      name: import_edge.target
+    ),
+    origin: import_edge.target,
+    state: state
+  )
+}
+
+
 fn admit_import_entry(
   roots: FreeMonoid<Node>,
   import_edge: Import,
   state: AdmissionState,
   subject_qn: QualifiedName,
-  order: TreeFundamentalityOrder,
+  index: SourceRootIndex,
   active_roots: FreeMonoid<SourceRootRef>
 ) -> AdmissionState {
   match state {
@@ -442,36 +458,24 @@ fn admit_import_entry(
             diagnostics: resolve_diagnostics(reason: ^resolve_import_not_visible)
           }
         ImportVisible =>
-          if cross_tree_import_is_same_tree(from_qn: subject_qn, to_qn: import_edge.target) {
-            admit_import_root_find(
-              found: module_root_find(
-                roots: roots,
-                name: import_edge.target
-              ),
-              origin: import_edge.target,
-              state: state
-            )
-          } else {
-            match cross_tree_import_admitted_qualified(
-              from_qn: subject_qn,
-              to_qn: import_edge.target,
-              roots: active_roots,
-              order: order
-            ) {
-              CrossTreeAdmitted =>
-                admit_import_root_find(
-                  found: module_root_find(
-                    roots: roots,
-                    name: import_edge.target
-                  ),
-                  origin: import_edge.target,
-                  state: state
-                )
-              CrossTreeDenied { reason: _ } =>
-                AdmissionRejected {
-                  diagnostics: resolve_diagnostics(reason: ^resolve_cross_tree_import_denied)
-                }
-            }
+          match cross_tree_edge_decision(
+            index: index,
+            from_qn: subject_qn,
+            to_qn: import_edge.target,
+            active_roots: active_roots
+          ) {
+            EdgeNormalResolution =>
+              admit_import_visible_entry(roots: roots, import_edge: import_edge, state: state)
+            EdgeCrossAdmitted =>
+              admit_import_visible_entry(roots: roots, import_edge: import_edge, state: state)
+            EdgeCrossDenied =>
+              AdmissionRejected {
+                diagnostics: resolve_diagnostics(reason: ^resolve_cross_tree_import_denied)
+              }
+            EdgeCrossAmbiguous =>
+              AdmissionRejected {
+                diagnostics: resolve_diagnostics(reason: ^resolve_cross_tree_import_ambiguous)
+              }
           }
       }
   }
@@ -483,7 +487,7 @@ fn admit_imports(
   imports: FreeMonoid<Import>,
   state: AdmissionState,
   subject_qn: QualifiedName,
-  order: TreeFundamentalityOrder,
+  index: SourceRootIndex,
   active_roots: FreeMonoid<SourceRootRef>
 ) -> AdmissionState {
   fold_list(
@@ -495,7 +499,7 @@ fn admit_imports(
         import_edge: import_edge,
         state: acc,
         subject_qn: subject_qn,
-        order: order,
+        index: index,
         active_roots: active_roots
       )
     }
@@ -523,7 +527,7 @@ fn namespace_for_subject(
   lm: LanguageModel,
   roots: FreeMonoid<Node>,
   admission: Admission,
-  order: TreeFundamentalityOrder,
+  index: SourceRootIndex,
   active_roots: FreeMonoid<SourceRootRef>
 ) -> Outcome<AdmittedSubject> {
   match validate_module_roots(roots: roots) {
@@ -549,7 +553,7 @@ fn namespace_for_subject(
                 state: admission_initial(base: base)
               ),
               subject_qn: admission.subject.name,
-              order: order,
+              index: index,
               active_roots: active_roots
             ) {
               AdmissionAccepted { bindings: b, origins: _ } =>
@@ -585,14 +589,14 @@ fn resolve_with_admission_policy(
   lm: LanguageModel,
   roots: FreeMonoid<Node>,
   admission: Admission,
-  order: TreeFundamentalityOrder,
+  index: SourceRootIndex,
   active_roots: FreeMonoid<SourceRootRef>
 ) -> Outcome<ResolvedTree> {
   match namespace_for_subject(
     lm: lm,
     roots: roots,
     admission: admission,
-    order: order,
+    index: index,
     active_roots: active_roots
   ) {
     Accepted { value: admitted, diagnostics: namespace_diag } =>
@@ -616,32 +620,41 @@ fn resolve_with_admission_policy(
 }
 
 
-// Extract QualifiedNames from raw module root Nodes (SCAFFOLD — dissolves with grounded source_root).
-fn module_root_nodes_to_qns(roots: FreeMonoid<Node>) -> FreeMonoid<QualifiedName> {
-  fold_list(
-    xs: roots,
-    empty: Empty,
-    cons: fn(acc, root) {
-      match qualified_name_from_module_node(root: root) {
-        Accepted { value: qn, diagnostics: _ } => Cons { head: qn, tail: acc }
-        Rejected { diagnostics: _ } => acc
-      }
-    }
+// Index-less single-tree resolution: no source-root provenance is supplied, so every import
+// is resolved by module_root_find within the given roots. Cross-tree admission requires the
+// grounded index (resolve_with_admission_grounded), so this path is correct for single-tree
+// compiles; a genuinely cross-tree import to a module absent from `roots` fails closed as an
+// unresolved import.
+fn resolve_with_admission(
+  lm: LanguageModel,
+  roots: FreeMonoid<Node>,
+  admission: Admission
+) -> Outcome<ResolvedTree> {
+  resolve_with_admission_policy(
+    lm: lm,
+    roots: roots,
+    admission: admission,
+    index: source_root_index_empty(),
+    active_roots: Empty
   )
 }
 
 
-// Fail-closed default: FundamentalityUnknown denies all cross-tree imports.
-fn resolve_with_admission(
+// Grounded cross-tree resolution: the QualifiedName -> SourceRootRef index and active
+// source-root set are derived from the host-tagged ingest (program_assembly). Cross-tree
+// import edges are admitted on grounded provenance + tree-pair fundamentality (§4/§5).
+fn resolve_with_admission_grounded(
   lm: LanguageModel,
   roots: FreeMonoid<Node>,
-  admission: Admission
+  admission: Admission,
+  index: SourceRootIndex,
+  active_roots: FreeMonoid<SourceRootRef>
 ) -> Outcome<ResolvedTree> {
   resolve_with_admission_policy(
     lm: lm,
     roots: roots,
     admission: admission,
-    order: FundamentalityUnknown,
-    active_roots: source_root_set_from_module_roots(qns: module_root_nodes_to_qns(roots: roots))
+    index: index,
+    active_roots: active_roots
   )
 }

src/v2/compiler/name_resolve/admission_fail_closed.dag

@@ -13,12 +13,10 @@ import v2.compiler.name_resolve {
   ImportVisible,
   ResolutionSubject,
   admit_import_entry,
-  module_root_nodes_to_qns,
   resolve_with_admission,
   validate_module_roots
 }
-import v2.std.cross_tree.import_model { FundamentalityUnknown }
-import v2.std.cross_tree.resolution { source_root_set_from_module_roots }
+import v2.std.cross_tree.resolution { source_root_index_empty }
 import v2.extdeps.languages.dag {
   dag_grammar_atom,
   dag_language_model_surface_empty_prelude,
@@ -154,8 +152,8 @@ fn admit_import_missing_module_is_rejected() -> Bool {
     import_edge: fc_import_missing_target(),
     state: fc_initial_admission_state(),
     subject_qn: fc_qn(seg: ^fc_subject_seg),
-    order: FundamentalityUnknown,
-    active_roots: source_root_set_from_module_roots(qns: module_root_nodes_to_qns(roots: roots))
+    index: source_root_index_empty(),
+    active_roots: Empty
   ) {
     AdmissionAccepted { bindings: _, origins: _ } => false
     AdmissionRejected { diagnostics: _ } => true

src/v2/compiler/name_resolve/malformed_imported_root.dag

@@ -10,11 +10,9 @@ import v2.compiler.name_resolve {
   AdmissionState,
   Import,
   ImportVisible,
-  admit_import_entry,
-  module_root_nodes_to_qns
+  admit_import_entry
 }
-import v2.std.cross_tree.import_model { FundamentalityUnknown }
-import v2.std.cross_tree.resolution { source_root_set_from_module_roots }
+import v2.std.cross_tree.resolution { source_root_index_empty }
 import v2.extdeps.languages.dag {
   dag_grammar_atom,
   dag_named_edge
@@ -117,8 +115,8 @@ fn witness_malformed_root_is_rejected_holds() -> Bool {
       import_edge: import_edge_for_malformed(),
       state: initial_admission_state(),
       subject_qn: malformed_entry_name(),
-      order: FundamentalityUnknown,
-      active_roots: source_root_set_from_module_roots(qns: module_root_nodes_to_qns(roots: roots))
+      index: source_root_index_empty(),
+      active_roots: Empty
     )
   )
 }