DEVBOOT-0: gunbc build <program> returns one exact executable to a remote agent (open until the operation exists)

dag/extdeps/git/git.dag

@@ -43,6 +43,14 @@ data git_pathspec_external_authority_anchor: ExternalAuthority = ExternalAuthori
   }
 }
 
+// GIT'S OWN ANSWER FOR ABSENCE, cited here because it is a fact about git rather than about any caller. `git rev-parse --verify --quiet <ref>` exits 0 with the object id when the ref resolves, exits 1 when it does not, and exits 128 when the repository itself could not be used. That third case is the one worth naming: a caller that reads only zero-versus-nonzero cannot tell a ref that is absent from a store it never reached, and those have opposite remedies -- the first means create it, the second means stop.
+//
+// The codes live with git rather than with a consumer for the ordinary single-authority reason. The first consumer to need one declared the integer locally, which made a fact about upstream behaviour a fact about one module; a second consumer would have declared it again, and a change in git would have had two places to reach.
+
+data git_ref_missing_exit_code: Int = 1
+
+data git_repository_unusable_exit_code: Int = 128
+
 type ObjectType = BlobObj | TreeObj | CommitObj | TagObj
 
 type GitAuthor {

dag/extdeps/gnu/libc.dag

@@ -0,0 +1,50 @@
+module extdeps.gnu.libc
+
+import std.types { String, NonEmptyStr }
+import std.decl_ref { DeclarationRef, WholeDeclaration }
+import extdeps.external_authority { ExternalAuthority, ExternalModelScope, ExternalSubjectRef }
+import extdeps.uri { Uri, Https }
+
+// THE GNU C LIBRARY, cited because it is a real upstream dependency of every artifact this repository links dynamically, and because the alternative to citing it was proven wrong by execution rather than argued.
+//
+// THE MEASUREMENT THAT PRODUCED THIS MODULE (2026-08-09, DEVBOOT-0 proof stage): a build service produced an artifact on a host running glibc 2.39 and delivered it to a caller running glibc 2.36. Both hosts are aarch64-unknown-linux-gnu. The Rust target triple was therefore IDENTICAL on both sides, the exact-subject comparison passed, the content digest verified independently at both ends, and the twenty-four megabytes that arrived failed at the dynamic linker with `version GLIBC_2.39 not found`. Every check in the system agreed on an answer that could not run. That is the displaced cost this module exists to remove: the triple names the ABI family and says nothing about the version of the C library an artifact was linked against, so a build environment is not identified by its triple.
+//
+// WHAT UPSTREAM ACTUALLY PUBLISHES. The library reports its own version through ldd, whose first output line ends with the version string on both the Debian and Ubuntu spellings -- the vendor text between them differs, which is why a consumer reads the trailing field positionally rather than matching a distribution's phrasing. The version is upstream's own numbering (2.36, 2.39); it is kept verbatim as the string the library reports rather than being re-encoded into an internal ordering, because a re-encoding would be a second naming scheme for a fact upstream already names.
+//
+// WHY A COPRODUCT AND NOT A BARE STRING. An unobserved C library and a C library observed to be absent are different states with different remedies, and the state that must never exist is a build environment silently identified without one. LibcUnobserved is representable so that a consumer must handle it explicitly; it is never the same value as any observed version, so an environment carrying it can never collide with one that was actually measured.
+data extdeps_external_authority_anchor: ExternalAuthority = ExternalAuthority {
+  uri: Uri {
+    scheme: Https
+    locator: "sourceware.org/glibc/wiki/Glibc%20Timeline"
+  }
+}
+
+data extdeps_model_scope: ExternalModelScope = ExternalModelScope {
+  subject: ExternalSubjectRef {
+    declaration: DeclarationRef {
+      module_path: "extdeps.gnu.libc",
+      decl_name: "PlatformCLibrary",
+      field: WholeDeclaration
+    }
+  },
+  first_citation: extdeps_external_authority_anchor,
+  further_citations: []
+}
+
+type PlatformCLibrary
+  = GnuLibc { version: NonEmptyStr }
+  | LibcUnobserved
+
+fn render_platform_c_library(library: PlatformCLibrary) -> String {
+  match library {
+    GnuLibc { version } => concat("glibc-", version as String)
+    LibcUnobserved => "<unobserved>"
+  }
+}
+
+fn platform_c_library_identity_tag(library: PlatformCLibrary) -> NonEmptyStr {
+  match library {
+    GnuLibc { version } => concat("gnu.libc.v1.", version as String) as NonEmptyStr
+    LibcUnobserved => "gnu.libc.v1.unobserved" as NonEmptyStr
+  }
+}

dag/extdeps/rust/target_triple.dag

@@ -0,0 +1,115 @@
+module extdeps.rust.target_triple
+
+import std.types { String, List, NonEmptyStr }
+import std.decl_ref { DeclarationRef, WholeDeclaration }
+import extdeps.external_authority { ExternalAuthority, ExternalModelScope, ExternalSubjectRef }
+import extdeps.uri { Uri, Https }
+import extdeps.toolchain.types {
+  TargetTriple,
+  Architecture,
+  X86_64,
+  Aarch64,
+  TripleVendor,
+  UnknownVendor,
+  Apple,
+  Pc,
+  Os,
+  Linux,
+  Macos,
+  AbiEnv,
+  Gnu,
+  Musl,
+}
+
+data extdeps_external_authority_anchor: ExternalAuthority = ExternalAuthority {
+  uri: Uri {
+    scheme: Https
+    locator: "doc.rust-lang.org/rustc/platform-support.html"
+  }
+}
+
+data extdeps_model_scope: ExternalModelScope = ExternalModelScope {
+  subject: ExternalSubjectRef {
+    declaration: DeclarationRef {
+      module_path: "extdeps.rust.target_triple",
+      decl_name: "RustTargetTripleRow",
+      field: WholeDeclaration
+    }
+  },
+  first_citation: extdeps_external_authority_anchor,
+  further_citations: []
+}
+
+data rust_target_triple_scope_subject_note: String = "THE SUBJECT IS RUST'S SPELLING OF A TARGET TRIPLE, and nothing else about Rust. Not the toolchain distribution, not cargo's build configuration, not the compiler's own target definitions -- only the platform-support table's rendering of the four axes as a hyphenated name, which is the one fact this repository needs from that upstream and the one it cites.\\n\\nThe axes themselves are NOT this module's subject: they are modeled once in the toolchain types, agnostic of any upstream's spelling, and this module is a partial projection from those axes onto the strings Rust publishes. Claiming the axes here would fork the concept that every other upstream's spelling also builds on."
+
+data rust_target_triple_note: String = "RUST'S OWN SPELLING OF A TARGET TRIPLE, living with the Rust upstream that publishes it rather than with any consumer. The toolchain module's diagnostic-name functions state the rule this module obeys: every upstream spells these axes differently, and each spelling belongs beside its own upstream as a PARTIAL projection that refuses what that upstream does not publish. This is that projection for Rust.\\n\\nIT IS DELIBERATELY PARTIAL AND REFUSING. The table below carries the triples this repository actually builds for; anything else returns absent rather than being assembled from parts. Assembling one would be the failure this shape exists to prevent -- a triple composed by concatenating axis spellings looks plausible for every combination, including the many that Rust does not publish, and the resulting string would be handed to a compiler that rejects it or, worse, to an identity that claims a target nobody can build.\\n\\nGROWING IT IS ADDING A ROW, which is the point: a new supported target is a cited addition here, not an edit to a consumer, and until the row exists every consumer refuses rather than guessing."
+
+type RustTargetTripleRow {
+  spelling: NonEmptyStr
+  triple: TargetTriple
+}
+
+fn rust_target_triple_rows() -> List<RustTargetTripleRow> {
+  [
+    RustTargetTripleRow {
+      spelling: "x86_64-unknown-linux-gnu" as NonEmptyStr,
+      triple: TargetTriple { arch: X86_64, vendor: UnknownVendor, os: Linux, env: Present { value: Gnu } },
+    },
+    RustTargetTripleRow {
+      spelling: "aarch64-unknown-linux-gnu" as NonEmptyStr,
+      triple: TargetTriple { arch: Aarch64, vendor: UnknownVendor, os: Linux, env: Present { value: Gnu } },
+    },
+    RustTargetTripleRow {
+      spelling: "x86_64-unknown-linux-musl" as NonEmptyStr,
+      triple: TargetTriple { arch: X86_64, vendor: UnknownVendor, os: Linux, env: Present { value: Musl } },
+    },
+    RustTargetTripleRow {
+      spelling: "aarch64-unknown-linux-musl" as NonEmptyStr,
+      triple: TargetTriple { arch: Aarch64, vendor: UnknownVendor, os: Linux, env: Present { value: Musl } },
+    },
+    RustTargetTripleRow {
+      spelling: "aarch64-apple-darwin" as NonEmptyStr,
+      triple: TargetTriple { arch: Aarch64, vendor: Apple, os: Macos, env: none },
+    },
+    RustTargetTripleRow {
+      spelling: "x86_64-apple-darwin" as NonEmptyStr,
+      triple: TargetTriple { arch: X86_64, vendor: Apple, os: Macos, env: none },
+    },
+  ]
+}
+
+data rust_target_triple_lookup_note: String = "The lookup is a fold over the rows in both directions, so one table serves parsing an observed triple and rendering a modeled one. Two functions reading one row set is the same structure read forwards and backwards; a second table for the reverse direction would be the fork this module exists to avoid."
+
+fn parse_rust_target_triple(spelling: String) -> TargetTriple? {
+  fold(
+    rust_target_triple_rows(),
+    init: none,
+    f: (acc, row) =>
+      match acc {
+        Present { value: found } => Present { value: found }
+        Absent =>
+          if (row.spelling as String) == spelling {
+            Present { value: row.triple }
+          } else {
+            none
+          }
+      },
+  )
+}
+
+fn render_rust_target_triple(triple: TargetTriple) -> NonEmptyStr? {
+  fold(
+    rust_target_triple_rows(),
+    init: none,
+    f: (acc, row) =>
+      match acc {
+        Present { value: found } => Present { value: found }
+        Absent =>
+          if row.triple == triple {
+            Present { value: row.spelling }
+          } else {
+            none
+          }
+      },
+  )
+}