first(): construct the Optional std.algebra declares, migrate the field-access population, and declare the parameter coercion

DESIGN.md

@@ -116,6 +116,7 @@ At a service boundary, rung honesty has a commercial consequence: a dimension ma
 
 Every newly discovered error class — incident, review finding, runtime exception, falsifier divergence — files or updates one row: invalid state, harm, distinguishing facts, rung found at, ceiling with reason, next trigger. Declared drops are rostered in full — previous rung, temporary rung, reason, population, restoration trigger — in [docs/design-ledgers.md](docs/design-ledgers.md), authority `gunbc.rung_drop`. A drop is retired BY ITS TRIGGER AND BY NOTHING ELSE, so the trigger is the whole check. The ones standing today:
 
+- **An Optional actual flowing into a parameter declared non-optional, at the call seam, in BOTH the interpreter and the Rust emission arm** — declared 2026-09-01
 - **Emitted-bytes fixture witnesses in a required lane** — declared 2026-09-01
 - **Direct-call argument TYPE-COMPAT judgment inside v2.* modules (one of two arms; inhabitance still runs)** — declared 2026-09-01
 - **CI required-run composition** — declared 2026-08-15
@@ -221,6 +222,9 @@ One row per class, each carrying its recognition rule and its receipts, in [docs
 - `restoration_promise_names_a_route_that_does_not_exist`
 - `restored_bytes_reviewed_as_authorship`
 - `review_summary_inverts_roles_and_affirms_the_join`
+- `coarser_parallel_authority`
+- `mutation_applied_to_the_wrong_artifact_of_a_generated_pair`
+- `entry_scoped_green_over_a_corpus_wide_edit`
 - `accepted_source_emits_uncompilable_target`
 
 ## Building & checks

dag/extdeps/bmc/pid_control_decode.dag

@@ -317,14 +317,18 @@ fn decode_curve_side(container: JsonValue, path: DocumentPath, side: CurveSide)
     }
   } else {
     match hits.first() {
-      JsonObject { members } =>
-        curve_side_fold(
-          path: path_field(parent: path, field: field),
-          side: side,
-          members: members,
-          acc: CurveSideDecoded { entries: [] },
-        )
-      other => CurveSideRefused { refusal: CurveSideNotAnObject { path: path, side: side } }
+      Present { value: hit } =>
+        match hit {
+          JsonObject { members } =>
+            curve_side_fold(
+              path: path_field(parent: path, field: field),
+              side: side,
+              members: members,
+              acc: CurveSideDecoded { entries: [] },
+            )
+          other => CurveSideRefused { refusal: CurveSideNotAnObject { path: path, side: side } }
+        }
+      Absent => CurveSideRefused { refusal: CurveSideMissing { path: path, side: side } }
     }
   }
 }
@@ -351,10 +355,54 @@ fn decode_curve_side(container: JsonValue, path: DocumentPath, side: CurveSide)
 // split between the language-semantics question and the type-conformance half that is below floor
 // regardless of how the first is answered. What is claimed HERE is only the local fact: the rename
 // to `magnitude` is a workaround, and no compiler guarantee is claimed by this module.
-fn indexed_decimal_value_at(entries: List<IndexedDecimal>, index: Int) -> ExactDecimal {
-  let matched = indexed_decimal_entries_with(entries: entries, index: index)
-  let entry = matched.first()
-  entry.magnitude
+// THE LOOKUP ANSWERS AN OPTIONAL BECAUSE THE LIST MIGHT NOT HOLD THE INDEX, and saying so is what
+// keeps its one caller total. It previously read `matched.first()` into a binding and took
+// `.magnitude` off it, which read the OPTIONAL's own payload rather than the entry's field -- the
+// same confusion the note above this module's decode records, in the module that records it.
+fn indexed_decimal_value_at(entries: List<IndexedDecimal>, index: Int) -> Optional<ExactDecimal> {
+  match indexed_decimal_entries_with(entries: entries, index: index).first() {
+    Present { value: entry } => Present { value: entry.magnitude }
+    Absent => Absent
+  }
+}
+
+// THE POINT SET IS BUILT BY A FOLD THAT CAN REFUSE, not by a map that cannot. A map has no arm for
+// a missing output, so the only ways to write it are to fabricate a magnitude or to let an Optional
+// reach a declared non-optional field -- the first is forbidden outright and the second is the
+// coercion this PR declares as debt. The refusal is DERIVED rather than invented: an indexed
+// reading whose output the join cannot supply is exactly `CurveReadingWithoutOutput`, which the
+// caller already raises for the same condition measured a different way. Accumulating by PREPEND
+// keeps the fold linear, and the caller's `sort_by` over the point index restores the order.
+fn curve_points_fold(
+  path: DocumentPath,
+  readings: List<IndexedDecimal>,
+  outputs: List<IndexedDecimal>,
+) -> CurveDecode {
+  fold(
+    readings,
+    init: CurveDecoded { points: [] },
+    f: fn(acc, r) {
+      match acc {
+        CurveRefused { refusal } => CurveRefused { refusal: refusal }
+        CurveDecoded { points } =>
+          match indexed_decimal_value_at(entries: outputs, index: r.index) {
+            Present { value: magnitude } =>
+              CurveDecoded {
+                points: concat(
+                  [DemandCurvePoint {
+                    index: r.index,
+                    reading: decimal_celsius(value: r.magnitude),
+                    output: zone_demand_value(value: magnitude),
+                  }],
+                  points,
+                ),
+              }
+            Absent =>
+              CurveRefused { refusal: CurveReadingWithoutOutput { path: path, index: r.index } }
+          }
+      }
+    },
+  )
 }
 
 type CurveDecode
@@ -375,23 +423,20 @@ type CurveDecode
 fn curve_join(path: DocumentPath, readings: List<IndexedDecimal>, outputs: List<IndexedDecimal>) -> CurveDecode {
   let unpaired_reading = filter(readings, r => indexed_decimal_entries_with(entries: outputs, index: r.index).length() == 0)
   let unpaired_output = filter(outputs, o => indexed_decimal_entries_with(entries: readings, index: o.index).length() == 0)
-  if unpaired_reading.length() > 0 {
-    CurveRefused { refusal: CurveReadingWithoutOutput { path: path, index: unpaired_reading.first().index } }
-  } else if unpaired_output.length() > 0 {
-    CurveRefused { refusal: CurveOutputWithoutReading { path: path, index: unpaired_output.first().index } }
-  } else {
-    CurveDecoded {
-      points: sort_by(
-        map(readings, r =>
-          DemandCurvePoint {
-            index: r.index,
-            reading: decimal_celsius(value: r.magnitude),
-            output: zone_demand_value(value: indexed_decimal_value_at(entries: outputs, index: r.index)),
-          }
-        ),
-        point => point.index,
-      ),
+  match unpaired_reading.first() {
+    Present { value: stray_reading } =>
+      CurveRefused { refusal: CurveReadingWithoutOutput { path: path, index: stray_reading.index } }
+    Absent =>
+      match unpaired_output.first() {
+        Present { value: stray_output } =>
+          CurveRefused { refusal: CurveOutputWithoutReading { path: path, index: stray_output.index } }
+        Absent =>
+    match curve_points_fold(path: path, readings: readings, outputs: outputs) {
+      CurveRefused { refusal } => CurveRefused { refusal: refusal }
+      CurveDecoded { points } =>
+        CurveDecoded { points: sort_by(points, point => point.index) }
     }
+      }
   }
 }
 

dag/extdeps/bmc/types.dag

@@ -180,7 +180,10 @@ fn bmc_redfish_surface_for(
   if count == 0 {
     SurfaceShapeUncatalogued { firmware: firmware }
   } else if count == 1 {
-    SurfaceShapeKnown { shape: matches.first().shape }
+    match matches.first() {
+      Present { value: only } => SurfaceShapeKnown { shape: only.shape }
+      Absent => SurfaceShapeUncatalogued { firmware: firmware }
+    }
   } else {
     SurfaceShapeAmbiguous { firmware: firmware, matches: count }
   }

dag/extdeps/languages/json/member_conservation.dag

@@ -198,13 +198,14 @@ fn first_path_mismatch(partition_path: NonEmptyStr, occurrences: List<JsonMember
 // object and still report every source member as covered.
 fn conservation_verdict(partition: ObjectMemberPartition) -> ConservationVerdict {
   let stray_source = first_path_mismatch(partition_path: partition.object_path, occurrences: partition.source)
-  if stray_source.length() > 0 {
-    PartitionSourcePathMismatch {
-      partition_path: partition.object_path,
-      occurrence_path: stray_source.first().identity.object_path,
-      ordinal: stray_source.first().identity.ordinal,
-    }
-  } else {
+  match stray_source.first() {
+    Present { value: stray } =>
+      PartitionSourcePathMismatch {
+        partition_path: partition.object_path,
+        occurrence_path: stray.identity.object_path,
+        ordinal: stray.identity.ordinal,
+      }
+    Absent =>
   let lost_or_repeated = fold(
     partition.source,
     init: MembersConserved { member_count: partition.source.length() },
@@ -370,13 +371,14 @@ fn element_conservation_verdict(partition: ArrayElementPartition) -> Conservatio
     array_path: partition.array_path,
     occurrences: partition.source,
   )
-  if stray_source.length() > 0 {
-    PartitionSourcePathMismatch {
-      partition_path: partition.array_path,
-      occurrence_path: stray_source.first().identity.array_path,
-      ordinal: stray_source.first().identity.index,
-    }
-  } else {
+  match stray_source.first() {
+    Present { value: stray } =>
+      PartitionSourcePathMismatch {
+        partition_path: partition.array_path,
+        occurrence_path: stray.identity.array_path,
+        ordinal: stray.identity.index,
+      }
+    Absent =>
     let lost_or_repeated = fold(
       partition.source,
       init: MembersConserved { member_count: partition.source.length() },

dag/extdeps/languages/yaml/ingest.dag

@@ -73,10 +73,14 @@ fn yaml_strip_indent(line: String, indent: Int) -> String {
 fn yaml_lines_from_source(src: String) -> List<String> {
   let raw = split(s: src, delimiter: "\n")
   let n = raw.length()
-  if (n > 0) && (raw.skip(n: n - 1).first() == "") {
-    raw.take(n: n - 1)
-  } else {
-    raw
+  match raw.skip(n: n - 1).first() {
+    Present { value: last_line } =>
+      if last_line == "" {
+        raw.take(n: n - 1)
+      } else {
+        raw
+      }
+    Absent => raw
   }
 }
 

dag/extdeps/sudo/nopasswd_execute_probe_check_op.dag

@@ -38,7 +38,10 @@ fn sudo_nopasswd_grant_list_line_admits_probe(
   if length(xs: parts) != 2 {
     false
   } else {
-    parts.skip(n: 1).first().trim() == probe as String
+    match parts.skip(n: 1).first() {
+      Present { value: tail } => tail.trim() == probe as String
+      Absent => false
+    }
   }
 }
 

dag/extdeps/tailscale/acl.dag

@@ -260,10 +260,14 @@ fn tag_dashboard_admin_plane_holds(policy: TailscaleAclPolicy) -> Bool {
 fn dashboard_cutover_ip_is_transient_in_tag_ci_grant(policy: TailscaleAclPolicy) -> Bool {
   let ci_grants = policy.grants |> filter(g => grant_src_is_tag_ci(g: g))
   (length(ci_grants) == 1)
-    && selector_list_contains(
-      items: ci_grants.first().dst,
-      needle: sel_ipv4(address: dashboard_cutover_mac_ip)
-    )
+    && match ci_grants.first() {
+      Present { value: only } =>
+        selector_list_contains(
+          items: only.dst,
+          needle: sel_ipv4(address: dashboard_cutover_mac_ip)
+        )
+      Absent => false
+    }
 }
 
 fn ssh_rule_matches(

dag/extdeps/transports/rest.dag

@@ -237,10 +237,9 @@ fn rest_fixture_scan(
   invocation: RestBoundOperationInvocation,
   scan: RestFixtureScan,
 ) -> RestFixtureScan {
-  if fixtures.count() == 0 {
-    scan
-  } else {
-    let fixture = fixtures.first()
+  match fixtures.first() {
+    Absent => scan
+    Present { value: fixture } =>
     let matches = fixture.store == store
       && rest_bound_invocation_eq(a: fixture.invocation, b: invocation)
     let next = if matches {

dag/extdeps/version/pep440.dag

@@ -96,16 +96,24 @@ fn pep440_compare_release_rest(a_rest: List<NonNegativeInt>, b_rest: List<NonNeg
   if a_rest.length() == 0 && b_rest.length() == 0 { Equal }
   else if a_rest.length() == 0 {
 
-    if b_rest.first() == 0 {
-      pep440_compare_release_rest(a_rest: a_rest, b_rest: b_rest.skip(n: 1))
-    } else {
-      Less
+    match b_rest.first() {
+      Present { value: b0 } =>
+        if b0 == 0 {
+          pep440_compare_release_rest(a_rest: a_rest, b_rest: b_rest.skip(n: 1))
+        } else {
+          Less
+        }
+      Absent => Equal
     }
   } else if b_rest.length() == 0 {
-    if a_rest.first() == 0 {
-      pep440_compare_release_rest(a_rest: a_rest.skip(n: 1), b_rest: b_rest)
-    } else {
-      Greater
+    match a_rest.first() {
+      Present { value: a0 } =>
+        if a0 == 0 {
+          pep440_compare_release_rest(a_rest: a_rest.skip(n: 1), b_rest: b_rest)
+        } else {
+          Greater
+        }
+      Absent => Equal
     }
   } else {
     match pep440_compare_non_negative_int(a: a_rest.first(), b: b_rest.first()) {

dag/gunbc/accelerator_demo/accelerator_demo_plan.dag

@@ -133,7 +133,9 @@ fn recognize_float_fma_fused_kernel_when_contraction_refused() -> AcceleratorRec
 }
 
 fn demo_plan_fused_op_count(plan: RealizationPlan<Nano>) -> Int {
-  let batch = plan.schedule.first()
+  match plan.schedule.first() {
+    Absent => 0
+    Present { value: batch } =>
   match batch.first() {
     Absent => 0
     Present { value: runnable } => match runnable {
@@ -142,6 +144,7 @@ fn demo_plan_fused_op_count(plan: RealizationPlan<Nano>) -> Int {
       RunnableDiscoveryBatch { source_roots: _, scan_dirs: _, explicit_entries: _, exclude_substrings: _, discovery_scope_dirs: _, profile: _ } => 0
     }
   }
+  }
 }
 
 fn demo_plan_has_three_fused_ops(plan: RealizationPlan<Nano>) -> Bool {

dag/gunbc/bmc/bmc_fan_converge.dag

@@ -531,10 +531,9 @@ type BmcFanTypedMutationResult
 
 fn bmc_fan_observation_value(lines: List<String>, key: String) -> String? {
   let prefix = concat(key, "=")
-  if lines.length() == 0 {
-    none
-  } else {
-    let line = lines.first()
+  match lines.first() {
+    Absent => none
+    Present { value: line } =>
     if starts_with(s: line, prefix: prefix) {
       Present {
         value: substring(

dag/gunbc/bmc/bmc_fan_monitor.dag

@@ -29,7 +29,8 @@ fn bmc_fan_assess_monitoring_samples_rec(
   required_elapsed: Second,
   maximum_sample_gap: Second,
 ) -> BmcFanMonitoringResult {
-  if remaining.length() == 0 {
+  match remaining.first() {
+    Absent =>
     let receipt = BmcFanMonitoringReceipt {
       sample_count: sample_count,
       elapsed: previous_elapsed,
@@ -51,8 +52,7 @@ fn bmc_fan_assess_monitoring_samples_rec(
         receipt: receipt,
       }
     }
-  } else {
-    let sample = remaining.first()
+    Present { value: sample } =>
     let sample_gap_seconds = second_count(sample.elapsed) - second_count(previous_elapsed)
     let receipt = BmcFanMonitoringReceipt {
       sample_count: sample_count + 1,