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

↩ module page · 213 lines · 9314 B
1// nx_gate_triage.nx -- TEAM-OWNED failure LOCALIZER for the game gate
2// (operator: "keep building the team to handle this autonomously").
3// Mechanizes the oracle-differential diagnosis ladder Claude ran by hand on
4// 2026-06-09 (the tictactoe draw-detect hunt): for every gated module, build
5// the SAME compiler-emitted .s twice -- once with the sovereign assembler,
6// once with gcc (ORACLE USE ONLY, per the C-is-for-benchmarking law; gcc
7// never lands on a deploy path here) -- run both, and classify:
8//
9//   PASS                : sovereign build exits 0
10//   ASM-GAP             : nxasm refuses the .s (encoding gap) or crashes
11//   TOOLCHAIN-NXASM     : sovereign build fails BUT gcc build of the SAME .s
12//                         passes -> the assembler mis-encoded something
13//   COMPILER-OR-SOURCE  : BOTH builds fail the same way -> the .s itself is
14//                         wrong (compiler bug) or the module's source is
15//   COMPILE-FAIL        : no usable .s after retries
16//
17// One TRIAGE line per module -> stdout + /tmp/nishi_game_gate_triage.log.
18// The sentinel forks this automatically on REGRESSION, so a red beat arrives
19// pre-localized: the Engineer reads WHERE the bug lives, not just that one
20// exists.  Usage: nx_gate_triage.elf [compiler] (default _offc, repo root).
21//
22// license_tier: ORIGINAL   Reuses the gg_ spine from nx_game_gate.
23import "nx_syscalls.nx"
24const GT_MAGIC_4096: i64 = 4096
25
26const GT_MIN_ASM_BYTES: i64 = 128
27const GT_MAX_RETRIES:   i64 = 12
28
29func gt_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 }
30func gt_cat_n(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64 = off
  var m: i64 = v
  if m < 0 { dst[o] = 45; o = o + 1; m = 0 - m }
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48; k = 1 }
  while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { dst[o+i] = t[k-1-i]; i = i + 1 }
  return o + k
41}
42
43func gt_run(path: *u8, argv: *i64, envp: *i64, redir_out: i64, redir_err: i64) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      if redir_out >= 0 { sys_dup3(redir_out, 1, 0) }
      if redir_err >= 0 { sys_dup3(redir_err, 2, 0) }
      sys_execve(path, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  let sig: i64 = st[0] & 0x7f
  if sig != 0 { return 128 + sig }
  return (st[0] >> 8) & 0xff
56}
57
58func gt_filesize(path: *u8) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  let buf: *u8 = sys_mmap(GT_MAGIC_4096)
  var total: i64 = 0
  var n: i64 = sys_read(fd, buf, GT_MAGIC_4096)
  while n > 0 { total = total + n; n = sys_read(fd, buf, GT_MAGIC_4096) }
  sys_close(fd)
  return total
67}
68
69// Same module list as nx_game_gate (keep in sync; gate owns the canon).
70func gt_module(i: i64) -> *u8 {
  if i == 0 { return "nx_term_kat" as *u8 }
  if i == 1 { return "nx_tictactoe_test" as *u8 }
  if i == 2 { return "nx_checkers_test" as *u8 }
  if i == 3 { return "nx_raycast_voxel_test" as *u8 }
  if i == 4 { return "nx_game_engine_compose_test" as *u8 }
  if i == 5 { return "nx_game_runtime_compose_test" as *u8 }
  if i == 6 { return "nx_fab_slice_test" as *u8 }
  if i == 7 { return "nx_text_render_test" as *u8 }
  if i == 8 { return "nx_html_render_test" as *u8 }
  if i == 9 { return "nx_render_target_match_test" as *u8 }
  if i == 10 { return "nx_perceptual_render_test" as *u8 }
  if i == 11 { return "nx_pitwall_render_test" as *u8 }
  if i == 12 { return "nx_math_games_test" as *u8 }
  if i == 13 { return "nx_actor_role_game_logic_test" as *u8 }
  if i == 14 { return "nx_user_sim_games" as *u8 }
  if i == 15 { return "nx_worldgen_refine" as *u8 }
  if i == 16 { return "nx_visual_novel_test" as *u8 }
  return 0 as *u8
89}
90
91// classification codes
92const GT_PASS: i64 = 0
93const GT_ASM_GAP: i64 = 1
94const GT_TOOLCHAIN_NXASM: i64 = 2
95const GT_COMPILER_OR_SOURCE: i64 = 3
96const GT_COMPILE_FAIL: i64 = 4
97
98func gt_triage_one(name: *u8, compiler: *u8, envp: *i64, devnull: i64, sov_exit: *i64, ora_exit: *i64) -> i64 {
  let src: *u8 = sys_mmap(512)
  var o: i64 = 0
  o = gt_cat(src, o, "runtime/_hdl_build/" as *u8); o = gt_cat(src, o, name); o = gt_cat(src, o, ".nx" as *u8); src[o] = 0 as u8
  let chk: i64 = sys_openat_rd(src)
  if chk < 0 {
      o = 0
      o = gt_cat(src, o, "runtime/" as *u8); o = gt_cat(src, o, name); o = gt_cat(src, o, ".nx" as *u8); src[o] = 0 as u8
  }
  if chk >= 0 { sys_close(chk) }
108
  let spath: *u8 = sys_mmap(256); o = 0
  o = gt_cat(spath, o, "/tmp/" as *u8); o = gt_cat(spath, o, name); o = gt_cat(spath, o, ".tri.s" as *u8); spath[o] = 0 as u8
  let sovelf: *u8 = sys_mmap(256); o = 0
  o = gt_cat(sovelf, o, "/tmp/" as *u8); o = gt_cat(sovelf, o, name); o = gt_cat(sovelf, o, ".tri.sov" as *u8); sovelf[o] = 0 as u8
  let oraelf: *u8 = sys_mmap(256); o = 0
  o = gt_cat(oraelf, o, "/tmp/" as *u8); o = gt_cat(oraelf, o, name); o = gt_cat(oraelf, o, ".tri.ora" as *u8); oraelf[o] = 0 as u8
115
  // compile (retry guard)
  var asmbytes: i64 = 0
  var tries: i64 = 0
  while tries < GT_MAX_RETRIES {
      let sfd: i64 = sys_openat_wr(spath, 0x1a4)
      let cc: *i64 = sys_mmap(8*4) as *i64
      cc[0] = compiler as i64; cc[1] = src as i64; cc[2] = 0
      let rc_c: i64 = gt_run(compiler, cc, envp, sfd, devnull)
      sys_close(sfd)
      asmbytes = gt_filesize(spath)
      if rc_c == 0 { if asmbytes > GT_MIN_ASM_BYTES { tries = GT_MAX_RETRIES } }
      if tries != GT_MAX_RETRIES { tries = tries + 1 }
  }
  if asmbytes <= GT_MIN_ASM_BYTES { return GT_COMPILE_FAIL }
130
  // lane A: sovereign assembler
  let asm_tool: *u8 = "_offc/nxasm_x86_main.elf" as *u8
  let aa: *i64 = sys_mmap(8*4) as *i64
  aa[0] = asm_tool as i64; aa[1] = spath as i64; aa[2] = sovelf as i64; aa[3] = 0
  let rc_a: i64 = gt_run(asm_tool, aa, envp, devnull, devnull)
  if rc_a != 0 { return GT_ASM_GAP }
  let rr: *i64 = sys_mmap(8*4) as *i64
  rr[0] = sovelf as i64; rr[1] = 0
  let rc_sov: i64 = gt_run(sovelf, rr, envp, devnull, devnull)
  sov_exit[0] = rc_sov
  if rc_sov == 0 { return GT_PASS }
142
  // lane B: gcc ORACLE of the SAME .s (diagnosis only, never a deploy path)
  let gcc_path: *u8 = "/usr/bin/gcc" as *u8
  let ga: *i64 = sys_mmap(8*8) as *i64
  ga[0] = gcc_path as i64
  ga[1] = "-no-pie" as *u8 as i64
  ga[2] = "-nostartfiles" as *u8 as i64
  ga[3] = "-o" as *u8 as i64
  ga[4] = oraelf as i64
  ga[5] = spath as i64
  ga[6] = 0
  let rc_g: i64 = gt_run(gcc_path, ga, envp, devnull, devnull)
  if rc_g != 0 { return GT_COMPILER_OR_SOURCE }   // .s gcc won't even assemble -> emitted asm broken
  let rr2: *i64 = sys_mmap(8*4) as *i64
  rr2[0] = oraelf as i64; rr2[1] = 0
  let rc_ora: i64 = gt_run(oraelf, rr2, envp, devnull, devnull)
  ora_exit[0] = rc_ora
  if rc_ora == 0 { return GT_TOOLCHAIN_NXASM }
  return GT_COMPILER_OR_SOURCE
161}
162
163func gt_report(logfd: i64, name: *u8, cls: i64, sov: i64, ora: i64, ts: i64) -> i64 {
  let line: *u8 = sys_mmap(512)
  var o: i64 = 0
  o = gt_cat(line, o, "TRIAGE ts=" as *u8)
  o = gt_cat_n(line, o, ts)
  o = gt_cat(line, o, " module=" as *u8)
  o = gt_cat(line, o, name)
  o = gt_cat(line, o, " class=" as *u8)
  if cls == GT_PASS               { o = gt_cat(line, o, "PASS" as *u8) }
  if cls == GT_ASM_GAP            { o = gt_cat(line, o, "ASM-GAP (nxasm refuses/crashes on the .s)" as *u8) }
  if cls == GT_TOOLCHAIN_NXASM    { o = gt_cat(line, o, "TOOLCHAIN-NXASM (gcc build of SAME .s passes; assembler mis-encodes)" as *u8) }
  if cls == GT_COMPILER_OR_SOURCE { o = gt_cat(line, o, "COMPILER-OR-SOURCE (both lanes fail; the .s itself is wrong)" as *u8) }
  if cls == GT_COMPILE_FAIL       { o = gt_cat(line, o, "COMPILE-FAIL (no usable .s)" as *u8) }
  if cls != GT_PASS {
      o = gt_cat(line, o, " sov-exit=" as *u8)
      o = gt_cat_n(line, o, sov)
      o = gt_cat(line, o, " oracle-exit=" as *u8)
      o = gt_cat_n(line, o, ora)
  }
  o = gt_cat(line, o, "\n" as *u8)
  sys_write(1, line, o)
  if logfd >= 0 { sys_write(logfd, line, o) }
  return 0
186}
187
188func main(argc: i64, argv: *i64) -> i64 {
  var compiler: *u8 = "_offc/nx_cc_sovereign.elf" as *u8
  if argc >= 2 { compiler = argv[1] as *u8 }
  let envp: *i64 = sys_mmap(8*4) as *i64
  envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64; envp[1] = 0
  let devnull: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
  let logfd: i64 = sys_openat_append("/tmp/nishi_game_gate_triage.log" as *u8, 0x1a4)
  let ts: i64 = sys_now_realtime_sec()
196
  var nonpass: i64 = 0
  var i: i64 = 0
  var name: *u8 = gt_module(0)
  while name != (0 as *u8) {
      let sov_exit: *i64 = sys_mmap(8) as *i64
      let ora_exit: *i64 = sys_mmap(8) as *i64
      sov_exit[0] = 0 - 1
      ora_exit[0] = 0 - 1
      let cls: i64 = gt_triage_one(name, compiler, envp, devnull, sov_exit, ora_exit)
      gt_report(logfd, name, cls, sov_exit[0], ora_exit[0], ts)
      if cls != GT_PASS { nonpass = nonpass + 1 }
      i = i + 1
      name = gt_module(i)
  }
  if logfd >= 0 { sys_close(logfd) }
  return nonpass
213}
nx_gate_triage.nx source

`nx_gate_triage.nx` source
