code wiki / _hdl_build / nx_gate_mutation_probe.nx
`nx_gate_mutation_probe.nx` source

↩ module page · 540 lines · 22444 B
1// nx_gate_mutation_probe.nx -- SOVEREIGN MUTATION TESTING of gate sensor power (the SOTA ruler).
2//
3// Grounding (fetched live 2026-07-14 via nx_https_get, en.wikipedia.org/wiki/Mutation_testing): "the
4// mutation score is the number of mutants killed / total number of mutants"; goal #1 = "identify weakly
5// tested pieces of code (mutants not killed)". Lineage: Lipton 1971, DeMillo/Lipton/Sayward 1978, Budd
6// 1980. RULER = industry-standard; TOOL = GREENFIELD on NishiLang (PIT=JVM, mutmut=Py, Mull=LLVM -- none
7// run here) => sovereign-built, guarded by internal liar-killers per [[feedback-3rd-party-proving-for-nonnovel]].
8//
9// TWO MODES:
10//   (no args)                      CURATED v1: fixed pair (runtime/nx_handoff_gate.nx x its proof gate),
11//                                  6 hand-designed killable mutants -> GREEN iff 6/6 killed. This is the
12//                                  REGRESSION GATE on the sensor stack's power (baseline-wrapped).
13//   <subject> <gate> [budget]      GENERIC v2: ANY lib x gate pair (naming law nx_X / nx_X_gate).
14//                                  Auto-generates mutants with classic operators (ROR: < > <= >= == != ;
15//                                  AOR: + -) at sites OUTSIDE comments/strings (region mask -- mutating a
16//                                  comment is a guaranteed FALSE survivor), evenly spread over the file.
17//                                  Survivors are reported as FINDINGS (op + line) = the liar-killer
18//                                  worklist; score is DATA (verdict = pipeline soundness, not score).
19//                                  ⚠kills assume the gate is idempotent (re-run-stable).
20//
21// LIAR-KILLERS ON THE PROBE ITSELF (both modes):
22//   * IDENTITY CONTROL -- an unmutated copy MUST stay GREEN (pipeline introduces no fault; models the
23//     equivalent-mutant honesty case). Identity RED => all results VOID.
24//   * NEEDLE/SITE-NOT-FOUND = RED -- never silently skip.
25//   * import needle is BUILT AT RUNTIME as `import "<subject>.nx"` (quote bytes composed) so a comment
26//     mentioning the filename can never eat the splice (the v1 trap, killed generally).
27//   * signal-aware rc decode (128+sig).
28// NEVER-BRICK: originals READ-ONLY; only __mutprobe_* copies written, then ARCHIVED to knowledge/mutprobe/.
29// Sovereign nx_cc->nxasm; CWD=nxc2 root. license_tier: ORIGINAL
30import "syscalls.nx"
31import "runtime.nx"
32import "nx_syscalls.nx"   // nx_setsid, nx_kill, sys_prlimit, sys_sleep_ms, WNOHANG, RLIMIT_*
33
34// Bounds for a DELIBERATELY BROKEN program. Named consts, not inline numbers, because someone will need
35// to raise them for a genuinely slow gate and must be able to find them. A real gate run on this host is
36// seconds; 180s is ~30x headroom, so a mutant that exceeds it is hung, not merely slow.
37const MP_MUTANT_DEADLINE_MS: i64 = 180000     // wall-clock ceiling per mutant run
38const MP_POLL_MS:            i64 = 250        // liveness poll interval (WNOHANG)
39const MP_MUTANT_CPU_S:       i64 = 240        // RLIMIT_CPU: a spinner dies even if wall-clock is generous
40const MP_MUTANT_AS_BYTES:    i64 = 4294967296 // RLIMIT_AS 4GiB: a mutated size allocates, then FAILS -- not the host
41const K_MAGIC_1048576: i64 = 1048576
42
43func mp_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
44
45func mp_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 }
  return off + i
49}
50
51func mp_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var total: i64 = 0
  var go: i64 = 1
  while go == 1 {
      go = 0
      let tail: *u8 = ((buf as i64) + total) as *u8
      let n: i64 = sys_read(fd, tail, cap - total)
      if n > 0 { total = total + n; if total < cap { go = 1 } }
  }
  sys_close(fd)
  return total
64}
65
66func mp_write(path: *u8, buf: *u8, len: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, buf, len)
  sys_close(fd)
  return 0
72}
73
74func mp_find(hay: *u8, hlen: i64, needle: *u8) -> i64 {
  let nl: i64 = mp_slen(needle)
  if nl == 0 { return 0 - 1 }
  var i: i64 = 0
  while i + nl <= hlen {
      var j: i64 = 0
      var ok: i64 = 1
      while j < nl {
          if hay[i+j] != needle[j] { ok = 0; j = nl } else { j = j + 1 }
      }
      if ok == 1 { return i }
      i = i + 1
  }
  return 0 - 1
88}
89
90func mp_splice(hay: *u8, hlen: i64, needle: *u8, repl: *u8, out: *u8) -> i64 {
  let at: i64 = mp_find(hay, hlen, needle)
  if at < 0 { return 0 - 1 }
  let nl: i64 = mp_slen(needle)
  let rl: i64 = mp_slen(repl)
  var i: i64 = 0
  while i < at { out[i] = hay[i]; i = i + 1 }
  var j: i64 = 0
  while j < rl { out[at+j] = repl[j]; j = j + 1 }
  var k: i64 = at + nl
  while k < hlen { out[at + rl + (k - at - nl)] = hay[k]; k = k + 1 }
  return hlen - nl + rl
102}
103
104// 1-based line number of byte offset (for survivor findings)
105func mp_line_of(src: *u8, off: i64) -> i64 {
  var ln: i64 = 1
  var i: i64 = 0
  while i < off {
      if src[i] == (10 as u8) { ln = ln + 1 }
      i = i + 1
  }
  return ln
113}
114
115// region mask: mark[i]=1 iff byte i is inside a // comment or a "..." string literal
116func mp_mask(src: *u8, len: i64, mark: *u8) -> i64 {
  var i: i64 = 0
  var st: i64 = 0
  while i < len {
      let c: i64 = src[i] as i64
      var m: i64 = 0
      var done: i64 = 0
      if st == 1 {
          m = 1
          if c == 10 { st = 0 }
          done = 1
      }
      if done == 0 {
          if st == 2 {
              m = 1
              if c == 34 { st = 0 }
              done = 1
          }
      }
      if done == 0 {
          if c == 34 { st = 2; m = 1 }
          if c == 47 { if i + 1 < len { if src[i+1] == (47 as u8) { st = 1; m = 1 } } }
      }
      mark[i] = m as u8
      i = i + 1
  }
  return 0
143}
144
145// token match at position i, fully unmasked
146func mp_tok_at(src: *u8, len: i64, mark: *u8, i: i64, tok: *u8) -> i64 {
  let tl: i64 = mp_slen(tok)
  if i + tl > len { return 0 }
  var j: i64 = 0
  while j < tl {
      if src[i+j] != tok[j] { return 0 }
      if mark[i+j] != (0 as u8) { return 0 }
      j = j + 1
  }
  return 1
156}
157
158// scan all mutation sites (op table order = longest tokens first); returns count (capped at maxs)
159func mp_scan(src: *u8, len: i64, mark: *u8, toks: *i64, nops: i64, sites: *i64, ops: *i64, maxs: i64) -> i64 {
  var count: i64 = 0
  var i: i64 = 0
  while i < len {
      var adv: i64 = 1
      var k: i64 = 0
      while k < nops {
          if mp_tok_at(src, len, mark, i, (toks[k]) as *u8) == 1 {
              if count < maxs {
                  sites[count] = i
                  ops[count] = k
                  count = count + 1
              }
              adv = mp_slen((toks[k]) as *u8)
              k = nops
          } else { k = k + 1 }
      }
      i = i + adv
  }
  return count
179}
180
181// fork the sovereign lane on __mutprobe_gate; both streams -> /tmp capture; signal-aware rc
182func mp_run_lane(envp: *i64) -> i64 {
  let runner: *u8 = "_offc/nx_sov_build_run.elf" as *u8
  let ofd: i64 = sys_openat_wr("/tmp/mutprobe_run.out" as *u8, 0x1a4)
  let av: *i64 = sys_mmap(8 * 4) as *i64
  av[0] = runner as i64
  av[1] = ("__mutprobe_gate" as *u8) as i64
  av[2] = 0
  let pid: i64 = sys_fork()
  if pid == 0 {
      // NEW SESSION so the mutant and everything IT forks share one process group we can kill as a
      // unit. Without this, killing the runner ORPHANS the gate it forked: measured live 2026-08-01,
      // four __mutprobe_gate processes reparented to init and span for 2650s, 3325s and 3411s of CPU
      // each (~2.6 CPU-hours) after I killed their probes. They drove host load past 99.
      nx_setsid()
      // BOUND WHAT A DELIBERATELY-BROKEN PROGRAM MAY CONSUME. Mutation testing exists to produce
      // wrong code; a mutated length or stride can request arbitrary memory, and a mutated loop
      // counter can spin forever. Uncapped, the test rig becomes the outage -- the same shape as the
      // 16.7GB OOM that took this box to 819MB free earlier today.
      // nx_prlimit, NOT sys_prlimit: the compiler bakes some sys_* bodies by name and the nx_ prefix
      // avoids that trap (documented at nx_syscalls.nx:358). Takes *u8 to a rlimit64 {cur, max}.
      let rl: *u8 = sys_mmap(16)
      let rli: *i64 = rl as *i64
      rli[0] = MP_MUTANT_CPU_S; rli[1] = MP_MUTANT_CPU_S
      nx_prlimit(0, RLIMIT_CPU, rl, 0 as *u8)
      let ra: *u8 = sys_mmap(16)
      let rai: *i64 = ra as *i64
      rai[0] = MP_MUTANT_AS_BYTES; rai[1] = MP_MUTANT_AS_BYTES
      nx_prlimit(0, RLIMIT_AS, ra, 0 as *u8)
      if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_dup3(ofd, 2, 0) }
      sys_execve(runner, av, envp)
      sys_exit(127)
  }
  // ---- BOUNDED WAIT (2026-08-01) ----
  // Was `sys_wait4(pid, st, 0)` -- a BLOCKING wait with no deadline. A mutant that hangs (which is a
  // NORMAL outcome: flipping a loop counter's `+` to `-` makes it non-terminating) stalled the probe
  // forever, which stalled the whole sweep, and killing the probe left the spinner orphaned.
  // LAW: A HARNESS THAT DELIBERATELY RUNS BROKEN CODE MUST BOUND BOTH ITS RUNTIME AND ITS RESOURCES --
  // an unbounded wait on a program you MUTATED is a promise that the mutation always terminates, and
  // the whole point of mutation is that it does not.
  // rc=124 on timeout, matching the `timeout(1)` convention this codebase already reads as
  // "the deadline talking, not the subject". A hung mutant is a KILLED mutant: the gate failed to
  // return a verdict, which is exactly the failure the tooth is meant to detect.
  let st: *i64 = sys_mmap(16) as *i64
  var waited: i64 = 0
  var timedout: i64 = 0
  var done: i64 = 0
  while done == 0 {
      let r: i64 = sys_wait4(pid, st, WNOHANG)
      if r == pid { done = 1 }
      if r != pid {
          if waited >= MP_MUTANT_DEADLINE_MS {
              nx_kill(0 - pid, 9)          // negative pid = the whole process GROUP (needs the setsid above)
              nx_kill(pid, 9)              // and the leader itself, in case setsid failed
              sys_wait4(pid, st, 0)        // reap the corpse so we leave no zombie
              timedout = 1
              done = 1
          }
          if waited < MP_MUTANT_DEADLINE_MS {
              sys_sleep_ms(MP_POLL_MS)
              waited = waited + MP_POLL_MS
          }
      }
  }
  if ofd >= 0 { sys_close(ofd) }
  if timedout == 1 { return 124 }
  let sig: i64 = st[0] & 0x7f
  if sig != 0 { return 128 + sig }
  return (st[0] >> 8) & 0xff
250}
251
252func mp_archive() -> i64 {
  sys_mkdir("knowledge/mutprobe" as *u8, 0x1ed)
  sys_renameat("runtime/_hdl_build/__mutprobe_lib.nx" as *u8, "knowledge/mutprobe/__mutprobe_lib.nx" as *u8)
  sys_renameat("runtime/_hdl_build/__mutprobe_gate.nx" as *u8, "knowledge/mutprobe/__mutprobe_gate.nx" as *u8)
  return 0
257}
258
259// ---- GENERIC v2 mode ---------------------------------------------------
260func run_generic(subject: *u8, gatename: *u8, budget: i64) -> i64 {
  print("=== nx_gate_mutation_probe GENERIC: subject=" as *u8)
  print(subject)
  print(" gate=" as *u8)
  print(gatename)
  print(" budget=" as *u8)
  print_i64(budget)
  print(" ===\n" as *u8)
268
  let cap: i64 = K_MAGIC_1048576
  let lib: *u8 = sys_mmap(cap + 16)
  let gate: *u8 = sys_mmap(cap + 16)
  let mut: *u8 = sys_mmap(cap + 16)
  let mgate: *u8 = sys_mmap(cap + 16)
  let mark: *u8 = sys_mmap(cap + 16)
275
  // subject path: _hdl_build first, then runtime/
  let spath: *u8 = sys_mmap(512)
  var o: i64 = 0
  o = mp_cat(spath, o, "runtime/_hdl_build/" as *u8)
  o = mp_cat(spath, o, subject)
  o = mp_cat(spath, o, ".nx" as *u8)
  spath[o] = 0 as u8
  var liblen: i64 = mp_read(spath, lib, cap)
  if liblen < 0 {
      o = 0
      o = mp_cat(spath, o, "runtime/" as *u8)
      o = mp_cat(spath, o, subject)
      o = mp_cat(spath, o, ".nx" as *u8)
      spath[o] = 0 as u8
      liblen = mp_read(spath, lib, cap)
  }
  if liblen <= 0 { print("  [RED] subject not found\n" as *u8); sys_exit(1); return 1 }
293
  let gpath: *u8 = sys_mmap(512)
  o = 0
  o = mp_cat(gpath, o, "runtime/_hdl_build/" as *u8)
  o = mp_cat(gpath, o, gatename)
  o = mp_cat(gpath, o, ".nx" as *u8)
  gpath[o] = 0 as u8
  let gatelen: i64 = mp_read(gpath, gate, cap)
  if gatelen <= 0 { print("  [RED] gate not found\n" as *u8); sys_exit(1); return 1 }
302
  // runtime-built import needle: import "<subject>.nx"   (quote bytes composed -> comment-proof)
  let needle: *u8 = sys_mmap(512)
  o = 0
  o = mp_cat(needle, o, "import " as *u8)
  needle[o] = 34 as u8
  o = o + 1
  o = mp_cat(needle, o, subject)
  o = mp_cat(needle, o, ".nx" as *u8)
  needle[o] = 34 as u8
  o = o + 1
  needle[o] = 0 as u8
  let repl: *u8 = sys_mmap(512)
  o = 0
  o = mp_cat(repl, o, "import " as *u8)
  repl[o] = 34 as u8
  o = o + 1
  o = mp_cat(repl, o, "__mutprobe_lib.nx" as *u8)
  repl[o] = 34 as u8
  o = o + 1
  repl[o] = 0 as u8
323
  let mgatelen: i64 = mp_splice(gate, gatelen, needle, repl, mgate)
  if mgatelen < 0 { print("  [RED] gate does not import the subject (needle absent)\n" as *u8); sys_exit(1); return 1 }
  mp_write("runtime/_hdl_build/__mutprobe_gate.nx" as *u8, mgate, mgatelen)
327
  let envp: *i64 = sys_mmap(8 * 4) as *i64
  envp[0] = ("PATH=/usr/bin:/bin" as *u8) as i64
  envp[1] = 0
331
  // operator table (longest tokens FIRST so ' <= ' wins over ' < ')
  let toks: *i64 = sys_mmap(8 * 16) as *i64
  let rpls: *i64 = sys_mmap(8 * 16) as *i64
  toks[0] = (" <= " as *u8) as i64; rpls[0] = (" >= " as *u8) as i64
  toks[1] = (" >= " as *u8) as i64; rpls[1] = (" <= " as *u8) as i64
  toks[2] = (" == " as *u8) as i64; rpls[2] = (" != " as *u8) as i64
  toks[3] = (" != " as *u8) as i64; rpls[3] = (" == " as *u8) as i64
  toks[4] = (" < " as *u8) as i64;  rpls[4] = (" > " as *u8) as i64
  toks[5] = (" > " as *u8) as i64;  rpls[5] = (" < " as *u8) as i64
  toks[6] = (" + " as *u8) as i64;  rpls[6] = (" - " as *u8) as i64
  let nops: i64 = 7
343
  mp_mask(lib, liblen, mark)
  let sites: *i64 = sys_mmap(8 * 512) as *i64
  let opsat: *i64 = sys_mmap(8 * 512) as *i64
  let nsites: i64 = mp_scan(lib, liblen, mark, toks, nops, sites, opsat, 512)
  print("  mutation sites found (outside comments/strings) = " as *u8)
  print_i64(nsites)
  print("\n" as *u8)
  if nsites == 0 { print("  [RED] nothing to mutate (probe inapplicable)\n" as *u8); mp_archive(); sys_exit(1); return 1 }
352
  // IDENTITY CONTROL
  mp_write("runtime/_hdl_build/__mutprobe_lib.nx" as *u8, lib, liblen)
  let rc0: i64 = mp_run_lane(envp)
  print("  [identity control] rc=" as *u8)
  print_i64(rc0)
  if rc0 != 0 {
      print("  RED -- pipeline unsound for this pair (gate may self-reference; results VOID)\n" as *u8)
      mp_archive()
      sys_exit(1)
      return 1
  }
  print("  GREEN (pipeline sound)\n" as *u8)
365
  var nrun: i64 = budget
  if nsites < nrun { nrun = nsites }
  var killed: i64 = 0
  var survived: i64 = 0
  var m: i64 = 0
  while m < nrun {
      let pick: i64 = (m * nsites) / nrun
      let at: i64 = sites[pick]
      let op: i64 = opsat[pick]
      // copy subject + patch the token bytes in place (same length)
      var ci: i64 = 0
      while ci < liblen { mut[ci] = lib[ci]; ci = ci + 1 }
      let rp: *u8 = (rpls[op]) as *u8
      let tl: i64 = mp_slen((toks[op]) as *u8)
      var pj: i64 = 0
      while pj < tl { mut[at+pj] = rp[pj]; pj = pj + 1 }
      mp_write("runtime/_hdl_build/__mutprobe_lib.nx" as *u8, mut, liblen)
      let rc: i64 = mp_run_lane(envp)
      print("  [mutant " as *u8)
      print_i64(m + 1)
      print("/" as *u8)
      print_i64(nrun)
      print(" op '" as *u8)
      print((toks[op]) as *u8)
      print("'->'" as *u8)
      print(rp)
      print("' line " as *u8)
      print_i64(mp_line_of(lib, at))
      print("] rc=" as *u8)
      print_i64(rc)
      if rc != 0 { killed = killed + 1; print("  KILLED\n" as *u8) }
      if rc == 0 {
          survived = survived + 1
          print("  *** SURVIVED -> gate blind at this site (liar-killer worklist)\n" as *u8)
      }
      m = m + 1
  }
403
  mp_archive()
  print("---- mutation score: " as *u8)
  print_i64(killed)
  print("/" as *u8)
  print_i64(nrun)
  print(" killed, " as *u8)
  print_i64(survived)
  print(" survived (findings; score=data, verdict=pipeline soundness) ----\n" as *u8)
  print("=== verdict: GREEN (identity sound; score measured; survivors above are the retrofit worklist) ===\n" as *u8)
  sys_exit(0)
  return 0
415}
416
417func main(argc: i64, argv: *i64) -> i64 {
  if argc >= 3 {
      var budget: i64 = 5
      if argc >= 4 {
          let b: *u8 = argv[3] as *u8
          var v: i64 = 0
          var bi: i64 = 0
          while b[bi] != (0 as u8) {
              let d: i64 = b[bi] as i64
              if d >= 48 { if d <= 57 { v = v * 10 + (d - 48) } }
              bi = bi + 1
          }
          if v > 0 { budget = v }
      }
      return run_generic(argv[1] as *u8, argv[2] as *u8, budget)
  }
433
  // ---------------- CURATED v1 mode (the baseline-wrapped regression gate) ----------------
  print("=== nx_gate_mutation_probe: sovereign mutation score of the handoff sensor stack ===\n" as *u8)
  print("  ruler: mutation score = killed/total (DeMillo-Lipton-Sayward line, fetched+grounded 2026-07-14)\n" as *u8)
437
  let libp: *u8 = "runtime/nx_handoff_gate.nx" as *u8
  let gatep: *u8 = "runtime/_hdl_build/nx_handoff_gate_proof.nx" as *u8
  let mlibp: *u8 = "runtime/_hdl_build/__mutprobe_lib.nx" as *u8
  let mgatep: *u8 = "runtime/_hdl_build/__mutprobe_gate.nx" as *u8
442
  let cap: i64 = K_MAGIC_1048576
  let lib: *u8 = sys_mmap(cap + 16)
  let gate: *u8 = sys_mmap(cap + 16)
  let mut: *u8 = sys_mmap(cap + 16)
  let mgate: *u8 = sys_mmap(cap + 16)
448
  let liblen: i64 = mp_read(libp, lib, cap)
  let gatelen: i64 = mp_read(gatep, gate, cap)
  if liblen <= 0 { print("  [RED] cannot read subject lib\n" as *u8); sys_exit(1); return 1 }
  if gatelen <= 0 { print("  [RED] cannot read gate\n" as *u8); sys_exit(1); return 1 }
453
  let mgatelen: i64 = mp_splice(gate, gatelen, "nx_handoff_gate.nx" as *u8, "__mutprobe_lib.nx" as *u8, mgate)
  if mgatelen < 0 { print("  [RED] import-splice needle absent in gate\n" as *u8); sys_exit(1); return 1 }
  mp_write(mgatep, mgate, mgatelen)
457
  let envp: *i64 = sys_mmap(8 * 4) as *i64
  envp[0] = ("PATH=/usr/bin:/bin" as *u8) as i64
  envp[1] = 0
461
  let names: *i64 = sys_mmap(8 * 8) as *i64
  let ndl: *i64 = sys_mmap(8 * 8) as *i64
  let rpl: *i64 = sys_mmap(8 * 8) as *i64
  names[0] = ("M1 neg-control flip (<= to >=)" as *u8) as i64
  ndl[0] = ("if wrong_score <= floor" as *u8) as i64
  rpl[0] = ("if wrong_score >= floor" as *u8) as i64
  names[1] = ("M2 monotonic reversal blinded (return 0 to 1)" as *u8) as i64
  ndl[1] = ("if vals[i] < vals[i-1] { return 0 }" as *u8) as i64
  rpl[1] = ("if vals[i] < vals[i-1] { return 1 }" as *u8) as i64
  names[2] = ("M3 invariant_le flip (<= to >=)" as *u8) as i64
  ndl[2] = ("if a <= b { return 1 }" as *u8) as i64
  rpl[2] = ("if a >= b { return 1 }" as *u8) as i64
  names[3] = ("M4 no_backslide flip (< to >)" as *u8) as i64
  ndl[3] = ("if cur[i] < base[i] { return 0 }" as *u8) as i64
  rpl[3] = ("if cur[i] > base[i] { return 0 }" as *u8) as i64
  names[4] = ("M5 parse arithmetic nudge (*10 to *11)" as *u8) as i64
  ndl[4] = ("val = val * 10 + (d - 48)" as *u8) as i64
  rpl[4] = ("val = val * 11 + (d - 48)" as *u8) as i64
  names[5] = ("M6 worst-drop localizer flip (> to <)" as *u8) as i64
  ndl[5] = ("if drop > wdrop { wdrop = drop; worst = i }" as *u8) as i64
  rpl[5] = ("if drop < wdrop { wdrop = drop; worst = i }" as *u8) as i64
  let nmut: i64 = 6
484
  mp_write(mlibp, lib, liblen)
  let rc0: i64 = mp_run_lane(envp)
  print("  [M0 identity control] rc=" as *u8)
  print_i64(rc0)
  var probe_ok: i64 = 1
  if rc0 == 0 { print("  GREEN (pipeline sound: unmutated copy passes)\n" as *u8) }
  if rc0 != 0 { print("  RED -- probe pipeline itself broke the build; ALL results below are VOID\n" as *u8); probe_ok = 0 }
492
  var killed: i64 = 0
  var survived: i64 = 0
  var notfound: i64 = 0
  var m: i64 = 0
  while m < nmut {
      print("  [" as *u8)
      print((names[m]) as *u8)
      print("] " as *u8)
      let mlen: i64 = mp_splice(lib, liblen, (ndl[m]) as *u8, (rpl[m]) as *u8, mut)
      if mlen < 0 {
          notfound = notfound + 1
          print("NEEDLE-NOT-FOUND (probe out of sync with lib) -> RED\n" as *u8)
      }
      if mlen >= 0 {
          mp_write(mlibp, mut, mlen)
          let rc: i64 = mp_run_lane(envp)
          print("rc=" as *u8)
          print_i64(rc)
          if rc != 0 { killed = killed + 1; print("  KILLED (gate caught the injected fault)\n" as *u8) }
          if rc == 0 { survived = survived + 1; print("  *** SURVIVED -> the gate is BLIND to this fault (add a liar-killer here)\n" as *u8) }
      }
      m = m + 1
  }
516
  mp_archive()
518
  print("---- mutation score: " as *u8)
  print_i64(killed)
  print("/" as *u8)
  print_i64(nmut)
  print(" killed, " as *u8)
  print_i64(survived)
  print(" survived, " as *u8)
  print_i64(notfound)
  print(" not-found ----\n" as *u8)
  var green: i64 = 1
  if probe_ok != 1 { green = 0 }
  if notfound != 0 { green = 0 }
  if survived != 0 { green = 0 }
  if green == 1 {
      print("=== verdict: GREEN (identity sound; 6/6 mutants killed = the sensor stack provably catches these fault classes; regression-gates the proof gate's sensor power) ===\n" as *u8)
      sys_exit(0)
      return 0
  }
  print("=== verdict: RED (probe broken, needle drift, or SURVIVORS = measured sensor blindness -- fix with new liar-killers, never by weakening mutants) ===\n" as *u8)
  sys_exit(1)
  return 1
540}
nx_gate_mutation_probe.nx source

`nx_gate_mutation_probe.nx` source
