Finish #11138: delete the retained grammar_coverage_string_eq clone by making the module's three implicit dependencies explicit

src/v2/lens/complexity_linearity_audit.dag

@@ -3,6 +3,7 @@ module v2.lens.complexity_linearity_audit
 import std.roster_frontier { FrontierRow, frontier_row_path, frontier_units }
 
 import std.dissolution { DissolutionCondition, unbound_dissolution }
+import v2.std.text { string_eq }
 data complexity_linearity_debt_row_reason: String = "closed-coproduct wildcard arm classified migration-debt (not kernel-permanent): the match is over a closed coproduct and the wildcard hides arms a total match would surface"
 
 data complexity_linearity_debt_row_dissolve: DissolutionCondition = unbound_dissolution(description: "the site's wildcard arm migrates to a total match; row deletes (roster-wide, the construction justification dissolves to SubstrateMandatoryTag)")
@@ -48,10 +49,6 @@ type ComplexityLinearityWildcardFact {
   rostered: Bool
 }
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn complexity_linearity_wildcard_facts_live() -> List<ComplexityLinearityWildcardFact> {
   complexity_linearity_wildcard_facts()
 }

src/v2/lens/effect_reach.dag

@@ -61,7 +61,7 @@ import v2.std.node {
   Symbol,
   fold_node
 }
-import v2.std.text { String }
+import v2.std.text { String, string_eq }
 
 // This consumer's subject is DIRECTORY-GRAIN: it names roots and no single modules.
 data no_declared_pool_files: List<String> = []
@@ -77,10 +77,6 @@ data empty_string_list: List<String> = []
 data empty_symbol_list: List<Symbol> = []
 data empty_node_list: List<Node> = []
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn callee_text_is_host_sink(text: String) -> Bool {
   contains(xs: effect_reach_host_sink_callee_symbols_v0, item: text, eq: string_eq)
 }

src/v2/lens/enforcement/grammar_coverage.dag

@@ -1,5 +1,18 @@
 module v2.lens.enforcement.grammar_coverage
 
+import extdeps.filesystem.filesystem_io { Filesystem }
+import v2.compiler.parse { parse_module }
+import v2.compiler.tokenize { tokenize }
+import v2.extdeps.languages.dag { dag_language_model }
+import v2.lens.coverage { dedupe_snoc }
+import v2.std.algebra { fold_list, length, list_append }
+import v2.std.collection { List }
+import v2.std.diagnostic { Accepted, Rejected }
+import v2.std.integer { Int }
+import v2.std.logic { Bool }
+import v2.std.node { Symbol, symbol_identity_digest }
+import v2.std.text { String, string_eq }
+
 
 type GrammarCoverageParseVerdict
   = ParsedClean
@@ -49,10 +62,6 @@ data grammar_coverage_file_anchor: Symbol = ^grammar_coverage_file_anchor
 
 data grammar_coverage_reject_probe: Symbol = ^grammar_coverage_reject_probe
 
-fn grammar_coverage_string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn grammar_coverage_tree_root_for_path(path: String) -> String {
   if path.starts_with(prefix: "dag/") {
     "dag"
@@ -73,7 +82,7 @@ fn grammar_coverage_distinct_rel_paths(facts: List<v2.std.decl_index.DeclFact>)
       dedupe_snoc(
         acc: acc,
         item: fact.rel_path,
-        eq: grammar_coverage_string_eq
+        eq: string_eq
       )
     }
   )
@@ -332,7 +341,7 @@ fn grammar_coverage_roster_contains_path(
     xs: roster,
     empty: false,
     cons: fn(acc, p) {
-      acc || grammar_coverage_string_eq(a: p, b: path)
+      acc || string_eq(a: p, b: path)
     }
   )
 }

src/v2/lens/enforcement/lens_module_gate.dag

@@ -32,7 +32,7 @@ import v2.std.collection { List }
 import v2.std.integer { Int }
 import v2.std.logic { Bool }
 import v2.std.live_tree { LiveTreeDisposition, ReadsLiveTree }
-import v2.std.text { String }
+import v2.std.text { String, string_eq }
 
 data live_tree_disposition: LiveTreeDisposition = ReadsLiveTree
 
@@ -87,12 +87,8 @@ type VerdictRemedyPair {
   remedy: LensInvariantRemedy
 }
 
-fn lens_module_gate_string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn lens_module_gate_string_member(xs: List<String>, x: String) -> Bool {
-  contains(xs: xs, item: x, eq: lens_module_gate_string_eq)
+  contains(xs: xs, item: x, eq: string_eq)
 }
 
 fn lens_module_gate_verdict_authority_eq(a: LensVerdictAuthority, b: LensVerdictAuthority) -> Bool {

src/v2/lens/enforcement/vocab.dag

@@ -1,6 +1,7 @@
 module v2.lens.enforcement.vocab
 
 import v2.std.algebra { contains }
+import v2.std.text { string_eq }
 
 
 type SubjectRoster {
@@ -150,10 +151,6 @@ fn narrowing_reason_same_variant(a: NarrowingReason, b: NarrowingReason) -> Bool
   }
 }
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn qualified_name_eq(a: QualifiedName, b: QualifiedName) -> Bool {
   a == b
 }

src/v2/lens/fact_cardinality.dag

@@ -1,4 +1,5 @@
 module v2.lens.fact_cardinality
+import v2.std.text { string_eq }
 
 
 type FactCardinalityTree
@@ -15,10 +16,6 @@ data fact_cardinality_cross_tree_coexistence_baseline: Int = 43
 
 data no_coexistence_keys: FreeMonoid<String> = Empty
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn add_unseen_key(acc: FreeMonoid<String>, key: String) -> FreeMonoid<String> {
   if contains(xs: acc, item: key, eq: string_eq) {
     acc

src/v2/lens/fn_index_depth_agreement.dag

@@ -10,7 +10,7 @@ import v2.std.logic { Bool }
 import v2.std.node { Edge, Node, NodeFold, Symbol, fold_node, node_subtree_count }
 import v2.std.node_query { call_callee_target, node_is_call }
 import v2.std.diagnostic { Accepted, Rejected }
-import v2.std.text { String }
+import v2.std.text { String, string_eq }
 import v2.std.fn_index {
   FnArrowDecl,
   atom_identities_in_node,
@@ -102,12 +102,8 @@ fn legacy_atoms(node: Node) -> List<Symbol> {
   }
 }
 
-fn agreement_string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn decl_named(decls: List<FnArrowDecl>, name: String) -> Bool {
-  any(xs: decls, predicate: fn(d) { agreement_string_eq(a: d.name, b: name) })
+  any(xs: decls, predicate: fn(d) { string_eq(a: d.name, b: name) })
 }
 
 fn param_collides_with_a_declaration(

src/v2/lens/live_read_classification.dag

@@ -27,6 +27,7 @@ import v2.lens.module_graph {
   module_declaration_facts_live,
   path_matches_touched
 }
+import v2.std.text { string_eq }
 
 // This consumer's subject is DIRECTORY-GRAIN: it names roots and no single modules.
 data no_declared_pool_files: List<String> = []
@@ -43,10 +44,6 @@ data empty_string_list: List<String> = []
 data empty_symbol_list: List<Symbol> = []
 data empty_node_list: List<Node> = []
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn carrier_home_module(home: LiveReadCarrierHome) -> String {
   home.module
 }

src/v2/lens/manufactured_dependency_census.dag

@@ -8,7 +8,7 @@ import v2.std.algebra { contains, fold_list, length, list_reverse, list_snoc_ite
 import v2.std.collection { List, Map, empty_map, map_insert, map_lookup }
 import v2.std.optional { Absent, Present }
 import v2.std.logic { Bool }
-import v2.std.text { String }
+import v2.std.text { String, string_eq }
 import v2.lens.module_graph {
   ImportResolutionFact,
   import_resolution_facts_live,
@@ -68,10 +68,6 @@ type ManufacturedDependencyTally {
   modules_with_manufactured_edges: Int
 }
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn snoc_unseen(acc: List<String>, item: String) -> List<String> {
   if contains(xs: acc, item: item, eq: string_eq) {
     acc

src/v2/lens/module_graph.dag

@@ -21,7 +21,7 @@ import v2.std.optional {
 }
 import v2.std.diagnostic { Outcome, outcome_accepted }
 import v2.std.logic { Bool }
-import v2.std.text { String }
+import v2.std.text { String, string_eq }
 
 type ModuleDeclarationFact {
   module: String
@@ -197,10 +197,6 @@ fn reference_derived_resolution_facts_flagged_pending_reference_producer(
   )
 }
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 data no_paths: FreeMonoid<String> = Empty
 
 data no_import_facts: List<ImportResolutionFact> = []

src/v2/lens/module_impact_query.dag

@@ -10,7 +10,7 @@ import v2.std.algebra {
 import std.algebra { Cons }
 import v2.std.collection { List, Map, empty_map, map_insert }
 import v2.std.optional { Absent, Optional, Present, optional_present }
-import v2.std.text { String }
+import v2.std.text { String, string_eq }
 import v2.lens.common.construction_justification {
   ConstructionJustification,
   WallAfterGrounding,
@@ -176,10 +176,6 @@ data impact_no_module: Optional<ModuleIdentity> = Absent
 
 data impact_no_trigger: Optional<ReferenceDerivedClosureTrigger> = Absent
 
-fn impact_string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn impact_module_eq(a: ModuleIdentity, b: ModuleIdentity) -> Bool {
   a.name == b.name
 }
@@ -393,7 +389,7 @@ fn impact_append_import_module(
   existing: List<String>,
   module_name: String
 ) -> List<String> {
-  if contains(xs: existing, item: module_name, eq: impact_string_eq) {
+  if contains(xs: existing, item: module_name, eq: string_eq) {
     existing
   } else {
     list_snoc_item(xs: existing, item: module_name)
@@ -436,7 +432,7 @@ fn impact_provenance_of_edge_indexed(
   if contains(
     xs: impact_imports_for_path(import_index: import_index, path: edge.path),
     item: edge.target_module,
-    eq: impact_string_eq
+    eq: string_eq
   ) {
     ImportDerivedEdge
   } else {

src/v2/lens/production_qualification_origin_probe.dag

@@ -44,7 +44,7 @@ import v2.std.node {
   TypeNode,
   fold_node,
 }
-import v2.std.text { String }
+import v2.std.text { String, string_eq }
 
 // Production-qualification origin PROBE (session keen-lark-681, wise-ram-22 recut): NOT a
 // repository-wide census. fn_arrow_decl_facts_live(pool_roots:) now answers over the roots its
@@ -142,10 +142,6 @@ data direct_rust_door_inferred_tree_atom: String = "direct_rust_door_inferred_tr
 // CompilerDerived is declared but UNWRITABLE at skeleton grain: callee identity proves a qualification boundary was called, not that the InferredTree argument came from production infer(assemble(...)). Until call/dataflow evidence connects arguments, non-fixture mint surfaces classify UnknownOrigin and fail admission.
 data ingest_mint_entry_name_suffix: String = "generate_provenanced_rust_candidate_from_ingest"
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn production_qualification_origin_eq(
   left: ProductionQualificationOrigin,
   right: ProductionQualificationOrigin

src/v2/lens/reference_deps.dag

@@ -8,6 +8,7 @@ import v2.lens.module_graph { map_lookup_where_rejected_unreachable, no_paths, m
 import v2.std.algebra { contains, fold_list, list_reverse }
 import std.algebra { Cons, Empty, FreeMonoid }
 import v2.compiler.name_resolve { Admission, Import, ImportVisible, ResolutionSubject, resolve_diagnostics }
+import v2.std.text { string_eq }
 
 
 type ReferenceResolutionFact {
@@ -85,10 +86,6 @@ data empty_reference_facts: List<ReferenceResolutionFact> = []
 
 data empty_reference_refusals: List<ReferenceIngestRefusal> = []
 
-fn string_eq(a: String, b: String) -> Bool {
-  a == b
-}
-
 fn symbol_eq(a: Symbol, b: Symbol) -> Bool {
   a == b
 }

src/v2/std/text.dag

@@ -67,6 +67,42 @@ fn char_eq(a: Char, b: Char) -> Bool {
   a == b
 }
 
+// THE AUTHORITY FOR STRING EQUALITY, AND WHAT IT DOES NOT YET REACH. The byte-identical copies
+// this change reaches across v2.lens collapse here. That is the whole of what this change does,
+// and it is NOT one string_eq corpus-wide: byte-identical forks survive elsewhere, several of
+// them under names that do not spell string_eq exactly.
+//
+// THE CENSUS IS THE INSTRUMENT, NOT A LIST. Re-derive the residue rather than reading a count that
+// rots the moment anyone adds or removes a copy. ONE COMMAND, and it is the SAME ONE the roster
+// header in src/v1/stage0/src/namespace_wave_admission.rs names -- two spellings of one census
+// would be the second authority DESIGN section 3 forbids, and the narrower one UNDER-REPORTS:
+//   grep -rnE '^fn [a-z_]*string_eq[a-z_]*\(' --include=*.dag dag/ src/v2
+// A LIST OR A NUMBER WRITTEN HERE WOULD BE STALE ON THE NEXT MERGE and would be cited as coverage
+// after it stopped being true, which is why neither appears in this annotation.
+//
+// AN EARLIER WORDING OF THIS NOTE NAMED THE NARROW PATTERN '^fn string_eq' AND CALLED
+// grammar_coverage_string_eq THE renamed exception. BOTH WERE FALSE. The narrow pattern misses
+// every renamed fork, and grammar_coverage was not the only one -- the command above finds
+// several. That clone no longer exists: it was retained here on the ground that its module
+// declared no imports, and the retention was rejected because naming that module's own imports is
+// source work this change can express, which is not a dissolution trigger but a task. So
+// v2.lens.enforcement.grammar_coverage now names its import surface and calls this declaration.
+// EVERY FORK THE COMMAND STILL FINDS IS UNDECLARED RESIDUE: no reason recorded, no retention
+// stated, nothing at its declaration saying why it is still there.
+//
+// TRIGGER, per fork rather than for the set: a fork collapses when a change touches its module,
+// or earlier if that module's import closure already reaches v2.std.text. There is no single event
+// that retires the whole residue, which is why this is a per-fork trigger and not a date.
+//
+// WHAT WILL ENCOUNTER IT: the DESIGN section 3 single-authority reviewer, a standing criterion
+// declared in gunbc.design_argument and derived into reviewers by gunbc.roadmap.roadmap_review_criteria,
+// which asks whether a change gives one concept a second name or a second home. It runs on changes
+// to this repository. This annotation exists so that reviewer meets a DECLARED residue with a
+// working census rather than rediscovering an undeclared one with a command that under-reports it.
+fn string_eq(a: String, b: String) -> Bool {
+  a == b
+}
+
 fn string_split_step(state: StringSplitState, delimiter: String) -> StringSplitState {
   if list_starts_with(xs: state.rest, prefix: delimiter, eq: char_eq) {
     StringSplitState {