test(claw): kill the real check_state.t27 and merge_lane.t27 mutation survivors

.trinity/seals/claw_ClawCheckState.json

@@ -7,27 +7,27 @@
     },
     {
       "spec": "specs/claw/text.t27",
-      "spec_hash": "sha256:b65da69dff231c61a6d3a48558af9e17af42e1acbe3f4763348f1f0c2f118f21"
+      "spec_hash": "sha256:968755ec1917f766eb2cdd0ab4c0c48aef028a0e7d69e191911695e925b286ad"
     }
   ],
   "config": "gen=c,rust,verilog,zig;tests=zig",
-  "gen_hash_c": "sha256:a12ac6811d377dbe066936d7d83874b6500f8cdb1857f114657b1445842d0b49",
-  "gen_hash_rust": "sha256:bd33e233b20fd2a284adb6c1d4ec4f52a78c7e3dde773cbaffbf01c392e00919",
-  "gen_hash_verilog": "sha256:1aae7f4b971d6bb0c1797a7bedf54a461dd4f705efad6aa1cacb5db973ccd12d",
-  "gen_hash_zig": "sha256:84f004a0e9d83668dbd79f4a0eb7ec6c7f6ecd290a2f482faa27aced8b03037c",
+  "gen_hash_c": "sha256:e4a61dbf1879a0e79f0ded5903ca710761bbeabf8d898d28bee4279e7fbc17ae",
+  "gen_hash_rust": "sha256:92081417741464afd951b1e51ced21199edb1a4365dc03aac395daed47277467",
+  "gen_hash_verilog": "sha256:0de652d676622e312842837dc722d69176107729c64ce2995dee5a0137b1b5cb",
+  "gen_hash_zig": "sha256:ccf7cb6d2c09d05c9bd75193f00bb8fa1fa1c455fa70999e4750685fbd2ead21",
   "module": "ClawCheckState",
   "ring": 12,
   "seal_schema": 2,
-  "sealed_at": "2026-10-18T19:55:01Z",
+  "sealed_at": "2026-10-19T00:08:47Z",
   "sealed_by": "t27c-bootstrap@0.5.2",
-  "spec_hash": "sha256:f5f05cce0d40d19693618461a81702761d27917cc6d1a3dfb53d8c06ba8b4ab4",
+  "spec_hash": "sha256:0a036f9c3e48e9c91b1cdadc806d63db91d5f7638157d26b355bd4db42014d83",
   "spec_path": "specs/claw/check_state.t27",
   "tests": {
     "failed": 0,
     "failing": [],
     "forced": false,
-    "passed": 12,
-    "total": 12,
+    "passed": 17,
+    "total": 17,
     "vacuous": 0
   },
   "toolchain": {

.trinity/seals/claw_ClawMergeLane.json

@@ -7,27 +7,27 @@
     },
     {
       "spec": "specs/claw/text.t27",
-      "spec_hash": "sha256:b65da69dff231c61a6d3a48558af9e17af42e1acbe3f4763348f1f0c2f118f21"
+      "spec_hash": "sha256:968755ec1917f766eb2cdd0ab4c0c48aef028a0e7d69e191911695e925b286ad"
     }
   ],
   "config": "gen=c,rust,verilog,zig;tests=zig",
-  "gen_hash_c": "sha256:2d4e93a910650e9b46d12fcc739be63ad7a240b8c13f835415bcf1ad313645f0",
-  "gen_hash_rust": "sha256:ab91d88ed9f58d800b1d0b8c5d0ae94d21531c5858b04f2aeff59ec552f5e4c3",
-  "gen_hash_verilog": "sha256:c90355854c1fe3836be5b2433b04686c263199de040e73793116228a4fc69178",
-  "gen_hash_zig": "sha256:0d2296bd2fd606c4a215fca1758c9613786ab5865f9ae758288e01a96e0c15b3",
+  "gen_hash_c": "sha256:9e64d9f311afe66e2933493b7a4fb09e64d24acf2527f13ce429738a01f32b27",
+  "gen_hash_rust": "sha256:0649a78a43e68e68d61fcbcba21c738e0a5767f5b60dee1c2214eed7f3165927",
+  "gen_hash_verilog": "sha256:58fca36ac6be6e63f55a9cc268a1695a9a046d858ac100fc84bd00fce5752909",
+  "gen_hash_zig": "sha256:ca374fe84de07ca60506572b960144fbcfc46ffc3da72942e15d4743efa82d37",
   "module": "ClawMergeLane",
   "ring": 12,
   "seal_schema": 2,
-  "sealed_at": "2026-10-18T20:55:41Z",
+  "sealed_at": "2026-10-19T00:08:51Z",
   "sealed_by": "t27c-bootstrap@0.5.2",
-  "spec_hash": "sha256:91d755a5c6b463f115856e61765ac8c7915f72ab988b53fcc0241edec08765ca",
+  "spec_hash": "sha256:43b070ab365c203b897b555f2ad2743f4b56049cf8186057743df02b990e0b5a",
   "spec_path": "specs/claw/merge_lane.t27",
   "tests": {
     "failed": 0,
     "failing": [],
     "forced": false,
-    "passed": 23,
-    "total": 23,
+    "passed": 30,
+    "total": 30,
     "vacuous": 0
   },
   "toolchain": {

specs/claw/check_state.t27

@@ -258,7 +258,6 @@ test an_unknown_or_inconsistent_row_is_unreadable {
     assert t_class("COMPLETED\tMAYBE\n", 16) == K_BAD;
     assert t_class("DONE\tSUCCESS\n", 13) == K_BAD;
     assert t_class("COMPLETED\tSUCCESS\textra\n", 24) == K_BAD;
-    assert t_class("COMPLETED\tSUCCESS\r\n", 19) == K_BAD;
     assert t_class("completed\tsuccess\n", 18) == K_BAD;
 }
 
@@ -310,3 +309,66 @@ test a_clipped_plan_still_advances_the_cursor {
     assert out[0] == 'C';
     assert out[1] == '\t';
 }
+
+// `"\r"` in a t27 literal is a backslash and an `r`, so the tests below write the carriage return
+// as the byte 13 and assert that it is there (#10722).
+
+test a_carriage_return_after_the_conclusion_is_unreadable {
+    var row : [24]u8 = undefined;
+    const w : usize = put_str(&row, 24, 0, "COMPLETED\tSUCCESS", 17);
+    row[w] = 13;
+    row[w + 1] = '\n';
+    assert w == 17;
+    assert row[17] == 13;
+    var st : [4]u32 = undefined;
+    assert check_counts(&row, 19, &st) == 1;
+    assert st[K_BAD as usize] == 1;
+    assert st[K_PASS as usize] == 0;
+}
+
+test a_line_that_is_only_a_carriage_return_is_an_unreadable_row {
+    var raw : [24]u8 = undefined;
+    var w : usize = put_str(&raw, 24, 0, "COMPLETED\tSUCCESS\n", 18);
+    raw[w] = 13;
+    raw[w + 1] = '\n';
+    w += 2;
+    assert raw[18] == 13;
+    var st : [4]u32 = undefined;
+    assert check_counts(&raw, w, &st) == 2;
+    assert st[K_PASS as usize] == 1;
+    assert st[K_BAD as usize] == 1;
+    var out : [128]u8 = undefined;
+    const o : usize = check_plan(&raw, w, &out, 128);
+    assert buf_has(&out, o, "V\tpending\n", 10) == true;
+}
+
+// The tests below were written against a mutation sweep of this file (#10724).
+
+test every_wait_status_with_no_conclusion_is_pending {
+    assert t_class("QUEUED\t-\n", 9) == K_WAIT;
+    assert t_class("IN_PROGRESS\t-\n", 14) == K_WAIT;
+    assert t_class("WAITING\t-\n", 10) == K_WAIT;
+    assert t_class("PENDING\t-\n", 10) == K_WAIT;
+    assert t_class("REQUESTED\t-\n", 12) == K_WAIT;
+    assert t_class("REQUESTED\tSUCCESS\n", 18) == K_BAD;
+}
+
+test the_row_cap_reads_1024_rows_and_refuses_the_next {
+    var raw : [9225]u8 = undefined;
+    var st : [4]u32 = undefined;
+    const n : usize = t_rows(&raw, 9225, 0, "QUEUED\t-\n", 9, 1024);
+    assert n == 9216;
+    assert check_counts(&raw, n, &st) == 1024;
+    assert st[K_WAIT as usize] == 1024;
+    assert st[K_BAD as usize] == 0;
+    const m : usize = t_rows(&raw, 9225, n, "QUEUED\t-\n", 9, 1);
+    assert m == 9225;
+    assert check_counts(&raw, m, &st) == 1025;
+    assert st[K_WAIT as usize] == 1024;
+    assert st[K_BAD as usize] == 1;
+}
+
+test the_dashboard_reads_each_row_from_its_first_byte {
+    assert dashboard_failing("COMPLETED\tSUCCESS\nCONTEXT\tFAILURE\n", 34) == 0;
+    assert dashboard_failing("COMPLETED\tSUCCESS\nCOMPLETED\tFAILURE\n", 36) == 1;
+}

specs/claw/merge_lane.t27

@@ -630,8 +630,16 @@ test an_unreadable_row_counts_as_somebody_elses {
 
 test a_carriage_return_or_a_near_name_is_not_the_merger {
     var st : [4]u32 = undefined;
-    assert ms_counts("Auto Merge Ready PRs\tworkflow_run\r\n", 35, &st) == 1;
+    // `"\r"` in a t27 literal is a backslash and an `r`, so the carriage return is the byte 13 (#10722).
+    var cr : [40]u8 = undefined;
+    const w : usize = put_str(&cr, 40, 0, "Auto Merge Ready PRs\tworkflow_run", 33);
+    cr[w] = 13;
+    cr[w + 1] = '\n';
+    assert w == 33;
+    assert cr[33] == 13;
+    assert ms_counts(&cr, 35, &st) == 1;
     assert st[MS_BAD] == 1;
+    assert st[MS_ROWS] == 0;
     assert st[MS_MERGER_ROWS] == 0;
     assert ms_counts("Auto Merge Ready PR\tworkflow_run\n", 33, &st) == 1;
     assert st[MS_ROWS] == 1;
@@ -664,3 +672,103 @@ test the_share_total_counts_unreadable_rows {
     assert buf_has(&out, w, "S\tmerger share: 1 of 2 queued runs are the merger's, 1 of them workflow_run; 1 unreadable\n", 90) == true;
     assert buf_has(&out, w, "F\tmerger-share\thigh\n", 20) == true;
 }
+
+// The tests below were written against a mutation sweep of this file (#10724).
+
+fn t_rep(dst : []u8, cap : usize, w : usize, row : str, row_len : usize, count : u32) -> usize {
+    var x : usize = w;
+    var i : u32 = 0;
+    while (i < count) {
+        x = put_str(dst, cap, x, row, row_len);
+        i += 1;
+    }
+    return x;
+}
+
+test a_blank_line_is_not_a_row_in_any_reader {
+    var st : [8]u32 = undefined;
+    assert ml_counts("queued\t-\t5\n\nqueued\t-\t5\n", 23, &st) == 2;
+    assert st[ML_QUEUED] == 2;
+    assert st[ML_BAD] == 0;
+    assert my_counts("schedule\t1\t0\t0\n\n", 16, &st) == 1;
+    assert st[MY_RUNS] == 1;
+    assert st[MY_BAD] == 0;
+    assert ms_counts("x\tpush\n\n", 8, &st) == 1;
+    assert st[MS_ROWS] == 1;
+    assert st[MS_BAD] == 0;
+}
+
+test an_open_run_of_age_zero_is_read {
+    var st : [8]u32 = undefined;
+    assert ml_counts("queued\t-\t0\n", 11, &st) == 1;
+    assert st[ML_QUEUED] == 1;
+    assert st[ML_BAD] == 0;
+    assert st[ML_OLDEST] == 0;
+}
+
+test the_merger_rows_cap_at_4096_and_refuse_the_next {
+    var raw : [45067]u8 = undefined;
+    var st : [8]u32 = undefined;
+    const n : usize = t_rep(&raw, 45067, 0, "queued\t-\t5\n", 11, 4096);
+    assert n == 45056;
+    assert ml_counts(&raw, n, &st) == 4096;
+    assert st[ML_QUEUED] == 4096;
+    assert st[ML_BAD] == 0;
+    const m : usize = t_rep(&raw, 45067, n, "queued\t-\t5\n", 11, 1);
+    assert m == 45067;
+    assert ml_counts(&raw, m, &st) == 4097;
+    assert st[ML_QUEUED] == 4096;
+    assert st[ML_BAD] == 1;
+}
+
+test the_yield_rows_cap_at_4096_and_refuse_the_next {
+    var raw : [61455]u8 = undefined;
+    var st : [5]u32 = undefined;
+    const n : usize = t_rep(&raw, 61455, 0, "schedule\t1\t0\t0\n", 15, 4096);
+    assert n == 61440;
+    assert my_counts(&raw, n, &st) == 4096;
+    assert st[MY_RUNS] == 4096;
+    assert st[MY_BAD] == 0;
+    const m : usize = t_rep(&raw, 61455, n, "schedule\t1\t0\t0\n", 15, 1);
+    assert m == 61455;
+    assert my_counts(&raw, m, &st) == 4097;
+    assert st[MY_RUNS] == 4096;
+    assert st[MY_BAD] == 1;
+}
+
+test the_share_rows_cap_at_4096_and_refuse_the_next {
+    var raw : [28679]u8 = undefined;
+    var st : [4]u32 = undefined;
+    const n : usize = t_rep(&raw, 28679, 0, "x\tpush\n", 7, 4096);
+    assert n == 28672;
+    assert ms_counts(&raw, n, &st) == 4096;
+    assert st[MS_ROWS] == 4096;
+    assert st[MS_BAD] == 0;
+    const m : usize = t_rep(&raw, 28679, n, "x\tpush\n", 7, 1);
+    assert m == 28679;
+    assert ms_counts(&raw, m, &st) == 4097;
+    assert st[MS_ROWS] == 4096;
+    assert st[MS_BAD] == 1;
+}
+
+test an_empty_run_is_label_only_only_when_a_label_was_missing {
+    var st : [5]u32 = undefined;
+    assert my_counts("schedule\t0\t0\t0\n", 15, &st) == 1;
+    assert st[MY_EMPTY] == 1;
+    assert st[MY_LABEL_ONLY] == 0;
+}
+
+test an_event_name_is_lower_case_letters_from_a_to_z {
+    var st : [4]u32 = undefined;
+    assert ms_counts("x\t\n", 3, &st) == 1;
+    assert st[MS_BAD] == 1;
+    assert st[MS_ROWS] == 0;
+    assert ms_counts("x\tworkflow_dispatch\n", 20, &st) == 1;
+    assert st[MS_ROWS] == 1;
+    assert ms_counts("x\tzz\n", 5, &st) == 1;
+    assert st[MS_ROWS] == 1;
+    assert ms_counts("x\t`\n", 4, &st) == 1;
+    assert st[MS_BAD] == 1;
+    assert ms_counts("x\t{\n", 4, &st) == 1;
+    assert st[MS_BAD] == 1;
+}