v2 std: import std.types List where it was used unimported (native resolve refusals)

dag/gunbc/recurring_failure_mode/bare_name_resolved_only_by_the_flat_namespace.dag

@@ -21,6 +21,7 @@ data bare_name_resolved_only_by_the_flat_namespace: RecurringFailureMode = Recur
     "RUNG FOUND AT: below the ladder for this population -- a located refusal exists, but no gate executes it over the population where it fires. CEILING: 2 for the population (a required per-entry compile over every separately compiled entry) and 3 for the class (a bare name that resolves only through the flat namespace refuses at the file on every route, which gunbc#12205 began by rostering the standing pairs as monotone debt).",
 
     "NEXT-RUNG TRIGGER, as the capability: every `gunbc.ci.ci_spec` workflow entry is compiled per-entry by a required phase of an existing required lane -- sufficient that an entry which refuses on its own blocks a merge. The design is a floor phase over the entries derived from `gunbc.ci.ci_spec`, with no new job. The trigger is gated on measuring the fold's price first (eager-owl-205, 2026-09-28): the phase runs on every floor, and one per-entry compile over the microvm closure OOMed and timed out on BuildBuddy.",
+    "THE CASE WITH NO IMPORT TO ADD: CONSTRUCTORS OF THE `T?` SUGAR (found on gunbc#13048). extdeps.external_authority `cited_figure_read_obligation(..) -> NonEmptyStr?` returns bare `Absent` and `Present { value: o }`, and no dag/extdeps module imports either name. The seed binds them; the v2 resolver does not: the module's own native resolve refuses resolve_reason_unbound_symbol with resolve_unbound_name_is_declared_in_several_modules at `Absent` (measured through #13028's closure-provider refusal roster, the only refused root in a 15-module std closure). The v2 std modules that did the same had an import to add (v2.std.optional Optional/Present/Absent, #13048), but a module that writes only `T?` names no Optional at all, so for it the language must answer the question this row has not had to: DOES THE `T?` SUGAR BRING ITS CONSTRUCTORS INTO SCOPE, and if so, WHICH declaration do they bind to when several modules declare a Present/Absent? Until that is decided, every dag/extdeps module that constructs or matches a `T?` value refuses its own v2 resolve and drops out of any closure index that needs it. NEXT-RUNG TRIGGER, NAMING THE CAPABILITY: a declared binding of the `?` sugar's constructors (to one Optional authority) that v2 resolve consults -- or a ruling that `T?` users must import that authority, with the import then added -- SUFFICIENT FOR extdeps.external_authority to resolve natively.",
   ],
 
   evidence: [

src/v2/std/cardinality.dag

@@ -1,5 +1,6 @@
 module v2.std.cardinality
 
+import std.types { List }
 import std.algebra { Cons, Empty }
 import std.termination {
   DescentEvidence,
@@ -9,9 +10,6 @@ import std.termination {
   descent_evidence_lattice_meet,
   evidence_rank
 }
-import v2.std.collection {
-  List
-}
 import v2.std.optional {
   Absent,
   Optional,

src/v2/std/compilers/semantic_decl_emission.dag

@@ -1,5 +1,6 @@
 module v2.std.compilers.semantic_decl_emission
 
+import v2.std.optional { Present, Absent }
 import v2.std.qualified_name { declaration_reference_path_optional }
 import std.occurrence_identity { OccurrenceSynthetic }
 import std.dissolution { DissolutionCondition, unbound_dissolution }

src/v2/std/compilers/sugar.dag

@@ -1,5 +1,6 @@
 module v2.std.compilers.sugar
 
+import std.types { List }
 import std.algebra { Cons, Empty, FreeMonoid, list_append, list_snoc_item }
 import v2.std.algebra { fold_list, is_empty, length }
 import v2.std.collection { Absent, Present, optional_absent, optional_present }

src/v2/std/data_initializer_identity.dag

@@ -1,9 +1,10 @@
 module v2.std.data_initializer_identity
 
+import std.types { List }
 import v2.std.node { symbol_lexeme }
 import v2.std.grammar { node_atom_identity_optional }
 import v2.std.decl_index { DeclFact }
-import v2.std.optional { optional_present, optional_absent }
+import v2.std.optional { optional_present, optional_absent, Optional, Present, Absent }
 
 // Resolved parent/arm projection for DataItem rows — qualified_name, module_path, rel_path, and
 // name locator grain (not occurrence identity). Host bridge marshals projection Node trees from

src/v2/std/decl_index.dag

@@ -1,4 +1,5 @@
 module v2.std.decl_index
+import std.types { List }
 import v2.std.arrow_signature { declared_signature_arrow }
 import std.algebra { Empty, list_snoc_item }
 import v2.std.diagnostic { Diagnostic, ExternalContractUnknown, Outcome, Unavailable, bind_outcome, node_locus, outcome_accepted, outcome_rejected }

src/v2/std/decl_ref_resolution.dag

@@ -1,5 +1,6 @@
 module v2.std.decl_ref_resolution
 
+import std.types { List }
 import std.decl_ref { DeclarationRef, WholeDeclaration, NamedField, TypeParameter }
 import v2.lens.module_graph { ModuleDeclarationFact, module_declaration_facts_at_live }
 import v2.std.decl_index { DeclFact, ItemKind, decl_facts_at, logical_qualified_name_from_module }

src/v2/std/diagnostic.dag

@@ -1,5 +1,6 @@
 module v2.std.diagnostic
 
+import std.types { List }
 import v2.std.algebra { bag_eq, fold_list }
 import std.algebra { FreeMonoid, Monoid, Semigroup, list_append, list_snoc_item, freemonoid_empty }
 import std.dissolution { DissolutionCondition, unbound_dissolution }

src/v2/std/effect_plan.dag

@@ -1,12 +1,10 @@
 module v2.std.effect_plan
 
+import std.types { List }
 import std.dissolution { DissolutionCondition, unbound_dissolution }
 
 import v2.std.text { String }
 import v2.std.algebra { FreeMonoid }
-import v2.std.collection {
-  List
-}
 import v2.std.optional {
   Optional
 }

src/v2/std/generic_instantiation.dag

@@ -1,5 +1,6 @@
 module v2.std.generic_instantiation
 
+import v2.std.optional { Present, Absent }
 import v2.std.collection { empty_map }
 type GenericSubstitution = Map<String, Node>
 

src/v2/std/grammar.dag

@@ -1,11 +1,11 @@
 module v2.std.grammar
 
+import std.types { List }
 import v2.std.parse_refusal_reason { ParseRefusalReason, parse_refusal_reason_symbol }
 import std.occurrence_identity { OccurrenceSynthetic }
 import std.algebra { Cons, Empty, list_append, list_snoc_item }
 import v2.std.algebra { is_empty, fold_list, fold_list_node, zip_eq, list_head, list_tail, HeadFound, HeadAbsent, TailFound, TailAbsent }
 import v2.std.collection {
-  List,
   Map,
   PointwisePower,
   empty_map,

src/v2/std/inhabitance.dag

@@ -1,5 +1,6 @@
 module v2.std.inhabitance
 
+import std.types { List }
 import v2.std.diagnostic {
   Accepted,
   Diagnostic,

src/v2/std/integer.dag

@@ -5,7 +5,6 @@ import std.algebra { Cons, Empty, FreeMonoid, AbelianGroup, GroupCompletion, Ord
 import std.error_primitives { DivError, Result, DivideByZero, Ok, Err }
 import v2.std.algebra { TailAbsent, TailFound, fold_list, fold_list_node, length, list_map }
 import v2.std.collection {
-  List,
   list_at_optional
 }
 import v2.std.optional {
@@ -20,7 +19,7 @@ import v2.std.node { Atom, Conj, Edge, Authored, Node, Symbol, TypeNode, is_empt
 import v2.std.node_query { find_named_child }
 import std.integer { Signedness, Signed, Unsigned }
 import std.content_hash { Fnv1a64Structural, content_hash_atom, content_hash_tagged_structural }
-import std.types { NonEmptyStr }
+import std.types { NonEmptyStr, List }
 import v2.std.machine {
   Byte,
   MachineWidth,

src/v2/std/native_agreement.dag

@@ -1,8 +1,8 @@
 module v2.std.native_agreement
 
+import std.types { List }
 import v2.std.algebra { Cons, Empty }
 import v2.std.collection {
-  List,
   list_at_optional
 }
 import v2.std.optional {

src/v2/std/node.dag

@@ -1,5 +1,6 @@
 module v2.std.node
 
+import std.types { List }
 import std.algebra { Cons, Empty, list_snoc_item }
 import v2.std.optional { Present }
 import std.occurrence_identity {

src/v2/std/operation_realization.dag

@@ -1,5 +1,6 @@
 module v2.std.operation_realization
 
+import v2.std.optional { Present, Absent }
 import std.types { Bool, Int, List, Map, NonEmptyStr, String }
 import std.effect_grant {
   Envelope, HandlerBinding, CoveredBy, NoCoveringGrant, covering_grant,

src/v2/std/orchestration.dag

@@ -1,12 +1,10 @@
 module v2.std.orchestration
 
+import std.types { List }
 import std.dissolution { DissolutionCondition, unbound_dissolution }
 
 import v2.std.text { String }
 import std.algebra { FreeMonoid }
-import v2.std.collection {
-  List
-}
 import v2.std.optional {
   Optional
 }

src/v2/std/qualified_name.dag

@@ -1,5 +1,6 @@
 module v2.std.qualified_name
 
+import std.types { List }
 import v2.std.diagnostic {
   Accepted,
   Diagnostic,
@@ -15,9 +16,6 @@ import std.algebra { Cons, Empty, FreeMonoid, list_snoc_item }
 import std.decl_ref { DeclarationRef, WholeDeclaration }
 import std.disposition { Disposition, Scaffold, RealizationDispatch }
 import v2.std.algebra { HeadAbsent, HeadFound, fold_list, fold_list_node, fold_list_right, is_empty, is_prefix_of, length, list_head, list_init }
-import v2.std.collection {
-  List
-}
 import v2.std.optional {
   Absent,
   Optional,

src/v2/std/runtime.dag

@@ -1,7 +1,7 @@
 module v2.std.runtime
 
+import std.types { List }
 import v2.std.collection {
-  List,
   Map
 }
 import v2.std.optional {

src/v2/std/symbol_index.dag

@@ -1,6 +1,7 @@
 module v2.std.symbol_index
 
 
+import std.types { List }
 import std.algebra { Cons, Empty, FreeMonoid, list_snoc_item }
 import v2.std.algebra {
   HeadAbsent,

src/v2/std/template.dag

@@ -1,5 +1,6 @@
 module v2.std.template
 
+import std.types { List }
 import v2.std.algebra { list_flat_map }
 
 // ONE literal-or-hole sequence, parameterized by what a hole is. A string that interpolates is a

src/v2/std/timeseries_signal.dag

@@ -2,9 +2,6 @@ module v2.std.timeseries_signal
 
 import std.algebra { Cons, Empty }
 import v2.std.algebra { fold_list, fold_list_right }
-import v2.std.collection {
-  List
-}
 import v2.std.optional {
   Optional,
   Absent,
@@ -28,7 +25,7 @@ import std.measure {
 import std.nat { Nat }
 import v2.std.node { Symbol }
 import v2.std.text { String }
-import std.types { brand }
+import std.types { brand, List }
 
 type Voltage = Measure<ElectricPotential, Micro, Int>
 type Current = Measure<ElectricCurrent, Micro, Int>

src/v2/std/verdict.dag

@@ -1,10 +1,8 @@
 module v2.std.verdict
 
+import std.types { List }
 import std.algebra { Monoid }
 import v2.std.algebra { is_empty }
-import v2.std.collection {
-  List
-}
 import v2.std.optional {
   Optional,
   Absent