NAMESPACE-XL integration: XL-4 graph instrument, XL-0 origin roster, XL-3 spelling census, exhaustiveness coverage key, XL-1 live tap (supersedes #11202 #11201 #11210 #11301 #11209)

dag/extdeps/systemd/systemd.dag

@@ -68,7 +68,6 @@ type SystemdUnitProperty
   | SubState
   | Result
   | ExecMainStatus
-  | SubState
   | ExecStartProperty
   | User
   | WorkingDirectoryProperty
@@ -108,7 +107,6 @@ fn systemd_unit_property_wire(property: SystemdUnitProperty) -> NonEmptyStr {
     SubState => "SubState" as NonEmptyStr
     Result => "Result" as NonEmptyStr
     ExecMainStatus => "ExecMainStatus" as NonEmptyStr
-    SubState => "SubState" as NonEmptyStr
     ExecStartProperty => "ExecStart" as NonEmptyStr
     User => "User" as NonEmptyStr
     WorkingDirectoryProperty => "WorkingDirectory" as NonEmptyStr

dag/gunbc/compiler_frontend_program_status.dag

@@ -180,8 +180,8 @@ type MissingInstrument
 fn missing_instrument_label(i: MissingInstrument) -> String {
   match i {
     PhaseCargoExecutionFact => "a per-phase cargo-execution fact on gunbc.required_ci_phase_roster"
-    DeclaringIdentitySpellingCensus => "a census of occurrences not spelled at their declaring identity (XL-3's population)"
-    RepairInputOriginRosterProducer => "a repair-input origin roster producer: source-declaration carriers plus rendered target-vocabulary carriers, separately typed, over one base, before eligibility or repair disposition (XL-0's population)"
+    DeclaringIdentitySpellingCensus => "a declaring-identity spelling census that answers over XL-3's usable population on the production ingest route: QUALIFIED cross-module mentions (every position) and bare type names in FIELD position, joined to their declaring identity - the producer v2.compiler.declaring_identity_spelling_census spelling_census_from_ingest exists and answers over the bare same-module classes only, which is not that population (XL-3's population)"
+    RepairInputOriginRosterProducer => "a repair-input origin roster producer that yields a NON-EMPTY denominator over the tree the production ingest actually yields: source-declaration carriers plus rendered target-vocabulary carriers, separately typed, over one base, before eligibility or repair disposition (XL-0's population)"
     ExactOccurrenceResidualCensus => "the exact occurrence and import-declaration residual an XL-2 rehearsal produces (XL-5's population)"
     PersistedBehavioralReceipt => "a persisted behavioral receipt over a discriminating corpus"
     PersistedPromotionOutcome => "a persisted PromotionOutcome over a named candidate"
@@ -404,7 +404,8 @@ fn stage_subject_outstanding(stage: NamespaceCutStage) -> List<String> {
 // named, observed piece of outstanding work, and reporting it unanswerable hid real known
 // work behind the missing-instrument label. The AVAILABLE arm reads the persist outstanding
 // fold: v2.workflow.legacy_baseline_persisted_observation holds a capture by its own
-// GitObjectId, never a receipts roster, and the live pin is unpinned until ACT-0 names a base.
+// GitObjectId, never a receipts roster. Production pin stays PreCutBaseUnpinned until ACT-0
+// names B; the AVAILABLE arm is outstanding until then. That is not ACT-0's BaselineCaptureReceipt.
 // THE THREE DELETION MILESTONES, DERIVED FROM THE SUBJECT ROSTER SINCE F-0 -- at DECLARED-ROW
 // grain, stated at exactly that strength. gunbc.namespace_cut_subject_roster carries every
 // authority scheduled to disappear as string-identity probes (not authored citations, which
@@ -902,7 +903,7 @@ fn stage_status(s: NamespaceCutStage) -> MilestoneStanding {
       )
     StageXL0Denominator =>
       NotDerivable {
-        why: "XL-0 is the REPAIR-INPUT ORIGIN DENOMINATOR -- source-declaration carriers plus rendered target-vocabulary carriers, separately typed, over one base, before eligibility or repair disposition. XL-0A splits and tags the six producer channels before their compatibility projection, but it deliberately does not claim the source declaration continuity or subject-bound roster that XL-0B-D owe. The arm that used to stand here read gunbc.namespace_cut_subject_roster's unobservable host probes instead, which answered a different question entirely: the subject roster is the cut's ROOT-AUTHORITY denominator, one row per family, and probe observability is a property of the instrument rather than a measure of the denominator's completeness. Deriving XL-0 from it let a join repair read as the denominator being produced. Derivable once the repair-input origin roster producer is complete." as NonEmptyStr,
+        why: "XL-0 is the REPAIR-INPUT ORIGIN DENOMINATOR, and the producer built for it does not yet answer over the tree production yields. THIS ARM BRIEFLY READ CLEAR OFF A DELIVERY RECEIPT AND THAT WAS WRONG: the receipt was earned against HAND-BUILT Node trees, while a substrate-only fixture driving the real ingest -- v2.compiler.program_assembly module_roots_from_source_root_ingest, projected through v2.compiler.normalized_tree normalized_tree_roots_to_nodes -- showed the collector returning NO sites at all for a module that plainly contains them. Independently reproduced by the XL-4 lane over real .dag files. A stage that reads CLEAR off a green-on-fixtures, empty-on-corpus instrument is reporting a denominator that does not exist, which is DESIGN section 5 silent wrongness rather than an incomplete measurement, so the honest standing is NOT DERIVABLE and the instrument stays outstanding. Re-run rather than trust this sentence: v2.test.claim.namespace_xl0.call_argument_mention_survival. THE MISS IS NOT ONE FACT AND ITS TRIGGER IS NOT ONE TRIGGER. Measured over every ingested root, a bare same-module value reference, a parameter reference and a bare type name in PARAMETER position all reach the producer; a QUALIFIED CROSS-MODULE reference, a call argument, a callee name and a bare type name in FIELD position do not. WRITING THAT AS \"a type-position name\" WOULD BE TOO COARSE AND AN EARLIER REVISION OF THIS ARM WROTE IT THAT WAY: the same bare spelling reaches from a parameter and does not reach from a field, so a trigger written against the merged class retires while half of it stays dead. The cross-module row is why there is no denominator, because an import-to-containment denominator is made of references that cross a module boundary and the surviving population is the part XL-0 cannot use. Two causes were mine and are fixed -- a parse-projection exclusion that blacked out the corpus, and a census that folded the roots while discarding its accumulator and so measured only the last one, which manufactured a reported type-position miss that does not exist. The third is open and deliberately unattributed: a dotted reference in a BODY is not a qualified-name production at all, so the collector never reassembles it, and whether resolution itself reads dotted body access is UNANSWERED because the probe built for it fails its own control. A FOURTH is open and also unattributed, and it is not a dotted case because the spelling that misses carries no dot: the bare FIELD-position miss, reproduced on two routes, where the whole record declaration is findable in the ingested tree as neither an atom nor a named edge while a parameter-type control is present. Cause unestablished on purpose -- if the declaration is absent from the tree then no collector-side trigger could ever fire. Producer: v2.test.claim.namespace_xl0.field_type_tree_presence. So the body-lowering repair (XL-2, gunbc#11207) is NOT this stage's trigger: it restores the call classes and leaves the cross-module class missing, and a trigger naming less than the capability it restores is retired while the capability stays dead (DESIGN section 4b(3)). Derivable once the producer answers non-empty over CROSS-MODULE references on the production route. THE CAPABILITY THIS STAGE WAITS ON IS UNOWNED, AND THAT IS STATED HERE RATHER THAN LEFT TO BE INFERRED FROM THE ABSENCE OF A LANE: the call classes have an owner (XL-2, gunbc#11207) and the cross-module dotted-reference capability -- the only one XL-0 actually needs -- has none. DESIGN section 4b(2) admits a stall only when it is declared, and separates cannot-climb from can-climb-after-one-grounding from can-climb-now-but-unbuilt; this is the THIRD, so the honest reading is not that XL-0 is blocked by physics but that nobody is assigned to it. A stage whose trigger points at unowned work will sit here indefinitely while every carrier around it reads as though progress were scheduled." as NonEmptyStr,
         cause: needs(i: RepairInputOriginRosterProducer)
       }
     StageXL1BaselineCapture =>
@@ -921,7 +922,7 @@ fn stage_status(s: NamespaceCutStage) -> MilestoneStanding {
       )
     StageXL3DeclaringIdentitySpelling =>
       NotDerivable {
-        why: "no carrier censuses occurrences not yet spelled at their declaring identity. The wave wall's binding channel keys on leaf segments, deliberately invariant under requalification, so it cannot answer this either. Derivable once the spelling census exists." as NonEmptyStr,
+        why: "the spelling census producer exists (v2.compiler.declaring_identity_spelling_census spelling_census_from_ingest) over the production ingest route. Frontiers are separate capabilities: BARE value outside a call, parameter reference, and BARE type name in PARAMETER position reach; BARE type name in FIELD position does not (not a qualification fact -- measured by v2.test.claim.declaring_identity_spelling.production_ingest field_vs_parameter); names inside calls are missing (body-lowering, eager-raven / #11207); QUALIFIED/dotted references are missing in every position (dotted-reference gap, not lowering). A qualified field type is absent for both independent reasons and cannot discriminate. kernel Int has no corpus declaration. IdentityUnbound on a same-module ingest census row is an index-path probe, not a compiler fact -- enrolled control v2.test.claim.provenance.cross_file_provenance cfp_own_module_site binds on resolve_reference_provenance. Derivable once the producer answers over qualified mentions; restoring dotted will not restore bare field types. The producer landed with #11201 in gunbc#11461; what remains UNBUILT is the capability the instrument label names, not the producer file." as NonEmptyStr,
         cause: needs(i: DeclaringIdentitySpellingCensus)
       }
     StageXL4ReferenceDerivedGraph =>

dag/gunbc/instruments/reference_derived_graph.dag

@@ -0,0 +1,200 @@
+module tools.reference_derived_graph
+
+import std.process { ExitSuccess, ProcessExit, exit_failure }
+import std.types { Bool, List, String }
+import extdeps.filesystem.filesystem_io
+import v2.std.algebra { any, fold_list }
+import v2.std.diagnostic { Accepted, Outcome, Rejected }
+import v2.lens.module_graph {
+  ImportResolutionFact,
+  ModuleDependencyEdge,
+  dependency_edges_from_import_facts,
+  import_resolution_facts_live,
+  reference_derived_resolution_facts,
+}
+
+// XL-4 instrument: the reference-derived graph (swap body of v2.lens.module_graph) and its
+// typed difference against the import-derived graph, over a named source root.
+//
+//   gunbc run --source-root dag --source-root src/v2 \
+//     --entry dag/gunbc/instruments/reference_derived_graph.dag --function main
+//
+// Discriminating run is the fixture root below. Qualified mentions are a declared frontier
+// triggered on the dotted-reference capability, not lowering. Call contents are
+// eager-raven-113. Bare field types have a tree-side census with UNVERIFIED cause. Collector-only.
+// Unused-import-must-not-mint-a-reference-edge still is. It does not swap
+// dependency_resolution_facts_live (NAMESPACE-XL STAGE XL-6).
+
+data instrument_source_roots: List<String> = ["dag/test/fixture/reference_derived_graph"]
+
+data instrument_exclude: List<String> = []
+
+data provider_module: String = "test.fixture.reference_derived_graph.provider"
+
+data consumer_reference_only_path: String = "dag/test/fixture/reference_derived_graph/consumer_reference_only.dag"
+
+data consumer_import_only_path: String = "dag/test/fixture/reference_derived_graph/consumer_import_only.dag"
+
+type ReferenceImportEdgeDiff
+  = SharedEdge { path: String, target_module: String }
+  | ReferenceOnlyEdge { path: String, target_module: String }
+  | ImportOnlyEdge { path: String, target_module: String }
+
+type ReferenceDerivedGraphReport {
+  source_roots: List<String>
+  reference_edges: List<ModuleDependencyEdge>
+  import_edges: List<ModuleDependencyEdge>
+  diffs: List<ReferenceImportEdgeDiff>
+}
+
+fn has_identity(edges: List<ModuleDependencyEdge>, path: String, target_module: String) -> Bool {
+  any(xs: edges, predicate: fn(e) { e.path == path && e.target_module == target_module })
+}
+
+fn diff_against_import(
+  reference_edges: List<ModuleDependencyEdge>,
+  import_edges: List<ModuleDependencyEdge>
+) -> List<ReferenceImportEdgeDiff> {
+  let from_reference = fold_list(
+    xs: reference_edges,
+    empty: [],
+    cons: fn(acc, edge) {
+      concat(acc, [
+        if has_identity(edges: import_edges, path: edge.path, target_module: edge.target_module) {
+          SharedEdge { path: edge.path, target_module: edge.target_module }
+        } else {
+          ReferenceOnlyEdge { path: edge.path, target_module: edge.target_module }
+        }
+      ])
+    }
+  )
+  fold_list(
+    xs: import_edges,
+    empty: from_reference,
+    cons: fn(acc, edge) {
+      if has_identity(edges: reference_edges, path: edge.path, target_module: edge.target_module) {
+        acc
+      } else {
+        concat(acc, [ImportOnlyEdge { path: edge.path, target_module: edge.target_module }])
+      }
+    }
+  )
+}
+
+fn report(source_roots: List<String>) -> Outcome<ReferenceDerivedGraphReport> {
+  match reference_derived_resolution_facts(
+    pool_roots: source_roots,
+    importer_roots: source_roots,
+    exclude_substrings: instrument_exclude
+  ) {
+    Rejected { diagnostics: d } => Rejected { diagnostics: d }
+    Accepted { value: reference_edges, diagnostics: pending } => {
+      let import_edges = dependency_edges_from_import_facts(
+        edges: import_resolution_facts_live(
+          pool_roots: source_roots,
+          importer_roots: source_roots,
+          exclude_substrings: instrument_exclude
+        )
+      )
+      Accepted {
+        value: ReferenceDerivedGraphReport {
+          source_roots: source_roots,
+          reference_edges: reference_edges,
+          import_edges: import_edges,
+          diffs: diff_against_import(
+            reference_edges: reference_edges,
+            import_edges: import_edges
+          )
+        },
+        diagnostics: pending
+      }
+    }
+  }
+}
+
+fn fixture_report() -> Outcome<ReferenceDerivedGraphReport> {
+  report(source_roots: instrument_source_roots)
+}
+
+fn diffs_include_reference_only(diffs: List<ReferenceImportEdgeDiff>, path: String, target: String) -> Bool {
+  any(xs: diffs, predicate: fn(d) {
+    match d {
+      ReferenceOnlyEdge { path: p, target_module: t } => p == path && t == target
+      SharedEdge { path: _, target_module: _ } => false
+      ImportOnlyEdge { path: _, target_module: _ } => false
+    }
+  })
+}
+
+fn diffs_include_import_only(diffs: List<ReferenceImportEdgeDiff>, path: String, target: String) -> Bool {
+  any(xs: diffs, predicate: fn(d) {
+    match d {
+      ImportOnlyEdge { path: p, target_module: t } => p == path && t == target
+      SharedEdge { path: _, target_module: _ } => false
+      ReferenceOnlyEdge { path: _, target_module: _ } => false
+    }
+  })
+}
+
+fn diffs_include_shared(diffs: List<ReferenceImportEdgeDiff>, path: String, target: String) -> Bool {
+  any(xs: diffs, predicate: fn(d) {
+    match d {
+      SharedEdge { path: p, target_module: t } => p == path && t == target
+      ReferenceOnlyEdge { path: _, target_module: _ } => false
+      ImportOnlyEdge { path: _, target_module: _ } => false
+    }
+  })
+}
+
+fn main() -> ProcessExit {
+  match fixture_report() {
+    Rejected { diagnostics: _ } =>
+      exit_failure(
+        reason: "tools.reference_derived_graph.report refused over the fixture source root"
+      )
+    Accepted { value: r, diagnostics: _ } =>
+      if !(diffs_include_reference_only(
+        diffs: r.diffs,
+        path: consumer_reference_only_path,
+        target: provider_module
+      ) || diffs_include_shared(
+        diffs: r.diffs,
+        path: consumer_reference_only_path,
+        target: provider_module
+      )) {
+        exit_failure(
+          reason: "positive control absent: the reference-only fixture produced no reference-derived edge, so every negative check below would pass on an empty edge set"
+        )
+      } else if diffs_include_import_only(
+        diffs: r.diffs,
+        path: consumer_reference_only_path,
+        target: provider_module
+      ) {
+        exit_failure(
+          reason: "the reference-only fixture was classified as import-only, so the instrument is reading import syntax"
+        )
+      } else if !diffs_include_import_only(
+        diffs: r.diffs,
+        path: consumer_import_only_path,
+        target: provider_module
+      ) {
+        exit_failure(
+          reason: "an import with no reference produced a reference-derived edge or dropped the import-only difference"
+        )
+      } else if diffs_include_reference_only(
+        diffs: r.diffs,
+        path: consumer_import_only_path,
+        target: provider_module
+      ) || diffs_include_shared(
+        diffs: r.diffs,
+        path: consumer_import_only_path,
+        target: provider_module
+      ) {
+        exit_failure(
+          reason: "an unused import minted a reference-derived edge"
+        )
+      } else {
+        ExitSuccess
+      }
+  }
+}