`nx_verify.nx` source

↩ module page · 462 lines · 29453 B
1// nx_verify.nx -- CONSOLIDATED Nishi-unique verification tool (per NISHI_TOOL_ARCHITECTURE: 50+
2// organs -> 15 verb-based tools; "new capability = a VERB, not a new micro-organ"). This is the
3// nx_verify tool: ONE entry point, verbs, that ABSORBS the session's separate self-analysis organs
4// so they stop sprawling as individual stubs. Imports the canonical nx_capability_triage_core (no
5// reinvention). SUPERSEDES the standalone nx_capability_triage.nx + nx_triage_ground.nx CLIs (their
6// cores stay as libs; these two verbs are now the interface).
7//   nx_verify triage [registry]  -> route/wire/build/measure per capability + operator proposals
8//                                    (anti-navel-gazing: SOTA credited ONLY on 3rd-party bench)
9//   nx_verify ground [registry]  -> cross-check has_organ vs DISK FACTS (gate>organ>absent); flags
10//                                    any claim the disk can't back (DISCREPANCY)
11// Future verify verbs (claim / crossval / census / adversary) fold in HERE, not as new organs.
12// Always exit 0; journals a summary. license_tier: ORIGINAL  expect_exit: 0
13import "nx_syscalls.nx"
14import "nx_capability_triage_core.nx"   // tr_decide / tr_proposal / tr_parse_row / verdict names + ccz_*
15// RESTORED 2026-08-15. The `coverage` verb existed in the DEPLOYED binary and in NO source copy --
16// neither nx_verify.nx nor its .bak-itoa2 twin imported this lib, so every rebuild silently dropped it.
17// Found by nx_artifactdrift (served 51,445 > built 49,085 => AHEAD) and NAMED by nx_contentdiff, which
18// listed the exact lost runs: PARITY / EXCEED / UNIQUE / "=== BENCH-COVERAGE:" / the UNMEASURED banner.
19// ******THE SOURCE DESCRIBED AS FUTURE WORK WHAT THE DEPLOYED BINARY ALREADY DID -- the header below
20// still lists census among "future verify verbs" while the live tool has been answering it. A header
21// that predicts a feature the artifact already ships is indistinguishable from one that never got built.
22// **THE DEFINITION WAS NEVER LOST, ONLY THE CALL SITE: nx_bench_census_lib.nx has always been present
23// and nx_bench_census_gate.nx still calls it. Verify the call site, not the definition.
24import "nx_bench_census_lib.nx"        // bc_census / bc_report -- the BENCH-COVERAGE census engine
25const V_MAGIC_1048576: i64 = 1048576
26const V_MAGIC_1048575: i64 = 1048575
27const V_MAGIC_65536: i64 = 65536
28const V_MAGIC_65535: i64 = 65535
29const V_MAGIC_1024: i64 = 1024
30
31func v_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
32func v_putn(v: i64) -> i64 { nxi_out(v); return 0 }
33func v_streq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 } if b[i] != (0 as u8) { return 0 } return 1 }
34// count occurrences of lit in buf[0,n). Used by the `portability` verb (RESTORED 2026-08-15).
35func v_countlit(buf: *u8, n: i64, lit: *u8) -> i64 {
  var ll: i64 = 0
  while lit[ll] != (0 as u8) { ll = ll + 1 }
  if ll == 0 { return 0 }
  var c: i64 = 0
  var i: i64 = 0
  while i + ll <= n {
      var k: i64 = 0
      var hit: i64 = 1
      while k < ll { if buf[i+k] != lit[k] { hit = 0; k = ll } else { k = k + 1 } }
      if hit == 1 { c = c + 1 }
      i = i + 1
  }
  return c
49}
50// does s contain lit anywhere?  1/0
51func v_hasstr(s: *u8, lit: *u8) -> i64 {
  var sl: i64 = 0
  while s[sl] != (0 as u8) { sl = sl + 1 }
  if v_countlit(s, sl, lit) > 0 { return 1 }
  return 0
56}
57
58// --- shared: read registry + a per-row driver (verb-specific body via mode) ---
59// print the task_class (field 0) of a line
60func v_print_task(buf: *u8, ls: i64, le: i64) -> i64 {
  var i: i64 = ls
  while i < le { if buf[i] == (124 as u8) { i = le } else { sys_write(1, (buf as i64 + i) as *u8, 1); i = i + 1 } }
  return 0
64}
65// copy the idx-th '|' field of buf[ls..le) into out; returns length or -1
66func v_field(buf: *u8, ls: i64, le: i64, idx: i64, out: *u8) -> i64 {
  var f: i64 = 0; var s: i64 = ls; var i: i64 = ls; var go: i64 = 1
  while go == 1 { go = 0
      if i <= le {
          var atend: i64 = 0; if i == le { atend = 1 }
          var atbar: i64 = 0; if i < le { if buf[i] == (124 as u8) { atbar = 1 } }
          if atend == 1 { if f == idx { var o: i64 = 0; var k: i64 = s; while k < i { out[o]=buf[k]; o=o+1; k=k+1 } out[o]=0 as u8; return o } f = f + 1 }
          else { if atbar == 1 { if f == idx { var o2: i64=0; var k2: i64=s; while k2<i { out[o2]=buf[k2]; o2=o2+1; k2=k2+1 } out[o2]=0 as u8; return o2 } f=f+1; s=i+1 } i=i+1; go=1 }
      }
  }
  return 0 - 1
77}
78func v_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
79
80// nth (0-based) space-delimited token of buf[ls..le) parsed as an unsigned int; -1 if absent.
81func v_line_int(buf: *u8, ls: i64, le: i64, tok: i64) -> i64 {
  var t: i64 = 0
  var i: i64 = ls
  // skip leading spaces
  var go: i64 = 1
  while go == 1 { go = 0; if i < le { if buf[i] == (32 as u8) { i = i + 1; go = 1 } } }
  while t < tok {
      // advance past this token
      go = 1
      while go == 1 { go = 0; if i < le { if buf[i] != (32 as u8) { i = i + 1; go = 1 } } }
      go = 1
      while go == 1 { go = 0; if i < le { if buf[i] == (32 as u8) { i = i + 1; go = 1 } } }
      t = t + 1
  }
  if i >= le { return 0 - 1 }
  let ep: *i64 = sys_mmap(16) as *i64
  return ccz_num_at(buf, le, i, ep)
98}
99// does buf[ls..le) start with prefix (after leading ws)?
100func v_starts(buf: *u8, ls: i64, le: i64, pre: *u8) -> i64 {
  var i: i64 = ls
  var go: i64 = 1
  while go == 1 { go = 0; if i < le { if buf[i] == (32 as u8) { i = i + 1; go = 1 } } }
  var k: i64 = 0
  while pre[k] != (0 as u8) { if i + k >= le { return 0 } if buf[i+k] != pre[k] { return 0 } k = k + 1 }
  return 1
107}
108
109// ground helpers (inlined disk-fact grade -- mirrors cc_our_grade: gate>organ>absent)
110func v_exists(path: *u8) -> i64 { let sb: *u8 = sys_mmap(256); if sys_fstatat(path, sb) < 0 { return 0 } return 1 }
111func v_probeable(name: *u8, n: i64) -> i64 {
  if n < 4 { return 0 }
  if name[0] != (110 as u8) { return 0 }
  if name[1] != (120 as u8) { return 0 }
  if name[2] != (95 as u8) { return 0 }
  var i: i64 = 0
  while i < n { let c: i64 = name[i] as i64; var ok: i64 = 0; if c >= 97 { if c <= 122 { ok = 1 } } if c >= 48 { if c <= 57 { ok = 1 } } if c == 95 { ok = 1 } if ok == 0 { return 0 } i = i + 1 }
  return 1
119}
120func v_grade(name: *u8) -> i64 {
  let p: *u8 = sys_mmap(512); var o: i64 = 0
  o = ccz_cat_str(p, 0, "runtime/" as *u8); o = ccz_cat_str(p, o, name); o = ccz_cat_str(p, o, "_gate.nx" as *u8)
  if v_exists(p) == 1 { return 4 }
  o = ccz_cat_str(p, 0, "runtime/" as *u8); o = ccz_cat_str(p, o, name); o = ccz_cat_str(p, o, ".nx" as *u8)
  if v_exists(p) == 1 { return 3 }
  o = ccz_cat_str(p, 0, "runtime/" as *u8); o = ccz_cat_str(p, o, name); o = ccz_cat_str(p, o, "_core.nx" as *u8)
  if v_exists(p) == 1 { return 3 }
  return 0
129}
130
131// --- magic-number detector (rule-11 enforcement). Builds on the team's mask-51 predicate + adds the
132// ALLOWLIST the nx_magicnum_preventer header names as the "next rung": a numeric literal is a MAGIC
133// number unless it is on a const-line, part of an identifier, hex (0x), a cast (`N as T`), or a
134// mmap/syscall argument (buffer size / syscall number). Budget is a NAMED const (no magic threshold).
135const V_MAGIC_BUDGET: i64 = 0     // zero-tolerance default for a checked file/diff
136const V_DATA_DENS_X100: i64 = 80  // >=0.8 magic/line = a data table (bias/mesh/font/KAT), not logic -> EXEMPT
137const V_DATA_MIN_CNT: i64 = 50    // ...AND has many literals: floors out line-packed logic one-liners gaming density
138const V_DENS_SCALE: i64 = 100     // density is reported x100 (fixed-point, no floats)
139const V_RADIX10_LEN: i64 = 2      // "10" is two chars (the radix-extraction allowlist match)
140const V_ASCII_NL: i64 = 10
141const V_ASCII_SP: i64 = 32
142const V_ASCII_LP: i64 = 40        // '('
143const V_ASCII_0: i64 = 48
144const V_ASCII_1: i64 = 49
145const V_ASCII_2: i64 = 50
146const V_ASCII_9: i64 = 57
147const V_ASCII_x: i64 = 120
148const V_ASCII_PCT: i64 = 37       // '%'
149const V_ASCII_SLASH: i64 = 47     // '/'
150const V_ASCII_DQ: i64 = 34        // '"' string delimiter -- numbers inside strings are text, not magic (skip like comments)
151const V_ASCII_BS: i64 = 92        // '\' escape -- an escaped quote does not close the string
152
153func v_isdig(c: u8) -> i64 { if c >= (V_ASCII_0 as u8) { if c <= (V_ASCII_9 as u8) { return 1 } } return 0 }
154func v_isaln(c: u8) -> i64 {
  if c >= (V_ASCII_0 as u8) { if c <= (V_ASCII_9 as u8) { return 1 } }
  if c >= (65 as u8) { if c <= (90 as u8) { return 1 } }
  if c >= (97 as u8) { if c <= (122 as u8) { return 1 } }
  if c == (95 as u8) { return 1 }
  return 0
160}
161func v_matchat(buf: *u8, i: i64, n: i64, lit: *u8) -> i64 { var k: i64 = 0; while lit[k] != (0 as u8) { if i + k >= n { return 0 } if buf[i+k] != lit[k] { return 0 } k = k + 1 } return 1 }
162func v_scan_magic(buf: *u8, n: i64) -> i64 {
  var count: i64 = 0; var i: i64 = 0; var incomm: i64 = 0; var lconst: i64 = 0; var instr: i64 = 0
  // ★★★★★★A COUNT WITHOUT A WORKLIST IS NOT ACTIONABLE. This gate reported `magic_numbers=69` and said
  // "move each to a named const" without ever saying WHICH -- so the owner of a failing file had no
  // place to start, and the offenders stayed. THE ENFORCER'S OWN UNACTIONABILITY IS PART OF WHY THE
  // THING IT FORBIDS PERSISTS. Line tracking costs one counter on a walk that already visits every byte.
  var line: i64 = 1
  while i < n {
      let c: u8 = buf[i]
      if c == (V_ASCII_NL as u8) { incomm = 0; lconst = 0; instr = 0; line = line + 1; i = i + 1 } else {
      if incomm == 1 { i = i + 1 } else {
      if instr == 1 {
          if c == (V_ASCII_DQ as u8) { var esc: i64 = 0; if i > 0 { if buf[i-1] == (V_ASCII_BS as u8) { esc = 1 } } if esc == 0 { instr = 0 } }
          i = i + 1
      } else {
      if c == (V_ASCII_DQ as u8) { instr = 1; i = i + 1 } else {
      if v_matchat(buf, i, n, "//" as *u8) == 1 { incomm = 1; i = i + 2 } else {
      if v_matchat(buf, i, n, "const " as *u8) == 1 { lconst = 1; i = i + 6 } else {
      if v_isdig(c) == 1 {
          var prevaln: i64 = 0
          if i > 0 { if v_isaln(buf[i-1]) == 1 { prevaln = 1 } }
          var ishex: i64 = 0
          if i >= 2 { if buf[i-1] == (V_ASCII_x as u8) { if buf[i-2] == (V_ASCII_0 as u8) { ishex = 1 } } }
          let start: i64 = i
          var go: i64 = 1
          while go == 1 { go = 0; if i < n { if v_isdig(buf[i]) == 1 { i = i + 1; go = 1 } } }
          let runlen: i64 = i - start
          var v2: i64 = 0
          if runlen >= 2 { v2 = 1 } else { if buf[start] >= (V_ASCII_2 as u8) { v2 = 1 } }
          var j: i64 = i
          var g2: i64 = 1
          while g2 == 1 { g2 = 0; if j < n { if buf[j] == (V_ASCII_SP as u8) { j = j + 1; g2 = 1 } } }
          var castnext: i64 = 0
          if v_matchat(buf, j, n, "as " as *u8) == 1 { castnext = 1 }
          var argctx: i64 = 0
          if start >= 1 { if buf[start-1] == (V_ASCII_LP as u8) {
              if start >= 5 { if v_matchat(buf, start-5, n, "mmap(" as *u8) == 1 { argctx = 1 } }
              if start >= 8 { if v_matchat(buf, start-8, n, "syscall(" as *u8) == 1 { argctx = 1 } }
          } }
          // radix-10: `% 10` / `/ 10` is decimal-string conversion (structural radix, not a tunable
          // threshold). allowlisting it keeps the gate from crying wolf on every putn -- a noisy gate
          // gets disabled, which is exactly how the original preventer ended up off.
          var radix10: i64 = 0
          if runlen == V_RADIX10_LEN { if buf[start] == (V_ASCII_1 as u8) { if buf[start+1] == (V_ASCII_0 as u8) {
              var p: i64 = start - 1
              var gp: i64 = 1
              while gp == 1 { gp = 0; if p >= 0 { if buf[p] == (V_ASCII_SP as u8) { p = p - 1; gp = 1 } } }
              if p >= 0 { if buf[p] == (V_ASCII_PCT as u8) { radix10 = 1 } }
              if p >= 0 { if buf[p] == (V_ASCII_SLASH as u8) { radix10 = 1 } }
          } } }
          var magic: i64 = 1
          if lconst == 1 { magic = 0 }
          if prevaln == 1 { magic = 0 }
          if ishex == 1 { magic = 0 }
          if castnext == 1 { magic = 0 }
          if argctx == 1 { magic = 0 }
          if radix10 == 1 { magic = 0 }
          if v2 == 0 { magic = 0 }
          if magic == 1 {
              count = count + 1
              // NAME IT: line + the literal itself, so the remedy is a lookup instead of a hunt. Printed
              // BEFORE the verdict line, which stays LAST -- the estate's readers anchor by position.
              v_puts("  MAGIC line=" as *u8); v_putn(line)
              v_puts(" value=" as *u8); sys_write(1, ((buf as i64) + start) as *u8, runlen)
              v_puts("\n" as *u8)
          }
      } else { i = i + 1 } } } } } } }
  }
  return count
231}
232
233func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { v_puts("usage: nx_verify triage|ground|lap|magic [args]\n" as *u8); return 2 }
  let verb: *u8 = argv[1] as *u8
  var reg: *u8 = "knowledge/capability_triage.reg" as *u8
  // only triage/ground take an optional registry as argv[2]; for `lap`, argv[2] is the TARGET
  if argc >= 3 { if v_streq(verb, "triage" as *u8) == 1 { reg = argv[2] as *u8 } if v_streq(verb, "ground" as *u8) == 1 { reg = argv[2] as *u8 } }
239
  // magic: rule-11 gate. dispatched BEFORE the registry read -- it needs no registry and must run from
  // ANY cwd (the pre-commit ratchet / build lane call it on arbitrary files). exit 1 = enforcement.
  if v_streq(verb, "magic" as *u8) == 1 {
      if argc < 3 { v_puts("usage: nx_verify magic <file> [budget]\n" as *u8); return 2 }
      let mfile: *u8 = argv[2] as *u8
      var mbudget: i64 = V_MAGIC_BUDGET
      if argc >= 4 { let ep2: *i64 = sys_mmap(16) as *i64; let b: i64 = ccz_num_at(argv[3] as *u8, v_slen(argv[3] as *u8), 0, ep2); if b >= 0 { mbudget = b } }
      let mbuf: *u8 = sys_mmap(V_MAGIC_1048576)
      let mn: i64 = ccz_read(mfile, mbuf, V_MAGIC_1048575)
      if mn <= 0 { v_puts("nx_verify magic: cannot read " as *u8); v_puts(mfile); v_puts("\n" as *u8); return 0 }
      let cnt: i64 = v_scan_magic(mbuf, mn)
      var lines: i64 = 1
      var li: i64 = 0
      while li < mn { if mbuf[li] == (V_ASCII_NL as u8) { lines = lines + 1 } li = li + 1 }
      var dens: i64 = 0
      if lines > 0 { dens = (cnt * V_DENS_SCALE) / lines }
      var isdata: i64 = 0
      if dens >= V_DATA_DENS_X100 { if cnt >= V_DATA_MIN_CNT { isdata = 1 } }
      v_puts("VERIFY-MAGIC file=" as *u8); v_puts(mfile); v_puts(" magic_numbers=" as *u8); v_putn(cnt); v_puts(" lines=" as *u8); v_putn(lines); v_puts(" dens_x100=" as *u8); v_putn(dens); v_puts(" budget=" as *u8); v_putn(mbudget); v_puts(" -> " as *u8)
      if isdata == 1 { v_puts("EXEMPT (data table, not logic thresholds)\n" as *u8); return 0 }
      if cnt <= mbudget { v_puts("PASS (rule-11 clean)\n" as *u8); return 0 }
      v_puts("FAIL (move each to a named const)\n" as *u8)
      return 1
  }
264
  // --- coverage: the BENCH-COVERAGE census (the anti-navel-gazing engine). RESTORED 2026-08-15.
  // Of the LIVE tool surface, how many are graded against an EXTERNAL SOTA oracle? An ungraded tool is
  // PRINTED debt, never silently GREEN. Defaults are the paths the live binary uses, so the verb answers
  // with no args; both stay overridable because the denominator is a DATA choice, not a law.
  // ⚠PLACEMENT IS LOAD-BEARING: this MUST sit ABOVE the capability-registry pre-read below. This verb
  // reads its OWN two files and has nothing to do with that registry, but the pre-read returns early on
  // `no-registry`, so a coverage block placed after it is UNREACHABLE. Measured when I first restored it
  // one block too low: staged output was exactly 22 bytes -- the length of "nx_verify no-registry" plus
  // newline -- while the live binary emitted 38,044. **AN EARLY RETURN IN A SHARED PREAMBLE SILENTLY
  // DISABLES EVERY VERB DECLARED BELOW IT, AND THE SYMPTOM IS A SHORT PLAUSIBLE MESSAGE, NOT AN ERROR.**
  // --- portability: is this organ NishiOS-portable, or is it welded to a host OS? RESTORED 2026-08-15
  // (second verb found missing from source; see the coverage note below). Counts raw OS couplings in
  // LOGIC and names the two legitimate seams instead of flagging them -- ★A PORTABILITY RULE WITHOUT AN
  // EXEMPT SEAM FLAGS THE ONE FILE THAT IS SUPPOSED TO HOLD THE COUPLING, AND THEN EVERYONE IGNORES IT.
  if v_streq(verb, "portability" as *u8) == 1 {
      if argc < 3 { v_puts("usage: nx_verify portability <file.nx>\n" as *u8); return 0 }
      let pf: *u8 = argv[2] as *u8
      v_puts("VERIFY-PORT file=" as *u8); v_puts(pf)
      // SEAM 1: the ABI seam. Every syscall in the estate goes through here BY DESIGN.
      if v_hasstr(pf, "nx_syscalls" as *u8) == 1 { v_puts(" -> EXEMPT (the ABI seam)\n" as *u8); return 0 }
      // SEAM 2: the OS-feature seam -- nx_os_* is the ONE place OS-specifics are allowed to live.
      if v_hasstr(pf, "nx_os_" as *u8) == 1 { v_puts(" -> EXEMPT (OS-feature seam: the ONE place OS-specifics live)\n" as *u8); return 0 }
      // SEAM 3: gate fixtures legitimately touch the build host they run on.
      if v_hasstr(pf, "_gate" as *u8) == 1 { v_puts(" -> EXEMPT (gate fixture, runs on the build host)\n" as *u8); return 0 }
      // SEAM 4: THE SELF-REFERENCE GUARD. The triage core NAMES these patterns in order to hunt them,
      // so a scanner without this exemption reports its own pattern table as the worst offender in the
      // estate. ★★A DETECTOR THAT SCANS SOURCE WILL FIND ITSELF, AND THE FIRST THING IT ACCUSES IS THE
      // LIST OF THINGS IT WAS BUILT TO ACCUSE.
      if v_hasstr(pf, "triage_core" as *u8) == 1 { v_puts(" -> EXEMPT (scanner core: names the coupling patterns it hunts)\n" as *u8); return 0 }
      let plen: *i64 = sys_mmap(16) as *i64
      let pbuf: *u8 = sys_read_file(pf, plen)
      if (pbuf as i64) == 0 { v_puts(" -> cannot read\n" as *u8); return 0 }
      let pn: i64 = plen[0]
      // PATH LITERALS, not prose: the leading quote is part of each pattern, so a COMMENT mentioning
      // /proc does not score. ★A SCANNER THAT DOES NOT SKIP COMMENTS MEASURES THE DOCUMENTATION.
      var coup: i64 = 0
      coup = coup + v_countlit(pbuf, pn, "\"/proc" as *u8)
      coup = coup + v_countlit(pbuf, pn, "\"/sys" as *u8)
      coup = coup + v_countlit(pbuf, pn, "\"/dev" as *u8)
      coup = coup + v_countlit(pbuf, pn, "\"/tmp" as *u8)
      coup = coup + v_countlit(pbuf, pn, "__syscall(" as *u8)
      v_puts(" couplings=" as *u8); v_putn(coup)
      if coup == 0 { v_puts(" -> PASS (OS-agnostic logic; NishiOS-portable)\n" as *u8); return 0 }
      v_puts(" -> FAIL (raw /proc|/sys|/dev|/tmp|__syscall in LOGIC -- move behind an nx_os_* seam)\n" as *u8)
      return 0
  }
  if v_streq(verb, "coverage" as *u8) == 1 {
      // BOTH paths are REQUIRED, matching the deployed contract. I first gave them defaults as a
      // nicety; the live binary's own usage line (recovered from the lost-run list) proves it demands
      // them. ★WHEN A DEPLOYED BINARY IS THE SPEC, FIDELITY BEATS CONVENIENCE -- a silent default would
      // let a caller compute a coverage ratio over a denominator they did not choose.
      if argc < 4 { v_puts("usage: nx_verify coverage <bench_registry.conf> <tool_allowlist.conf>\n" as *u8); return 0 }
      let regp: *u8 = argv[2] as *u8
      let allp: *u8 = argv[3] as *u8
      let rlen: *i64 = sys_mmap(16) as *i64
      let rbuf: *u8 = sys_read_file(regp, rlen)
      if (rbuf as i64) == 0 { v_puts("nx_verify coverage: cannot read registry " as *u8); v_puts(regp); v_puts(" -- REFUSING rather than reporting a coverage number over a denominator I could not load\n" as *u8); return 0 }
      let alen: *i64 = sys_mmap(16) as *i64
      let abuf: *u8 = sys_read_file(allp, alen)
      if (abuf as i64) == 0 { v_puts("nx_verify coverage: cannot read allowlist " as *u8); v_puts(allp); v_puts(" -- REFUSING: the allowlist IS the denominator\n" as *u8); return 0 }
      let counts: *i64 = sys_mmap(8 * 8) as *i64
      bc_census(abuf, alen[0], rbuf, rlen[0], counts)
      bc_report(counts)
      return 0
  }
330
  let buf: *u8 = sys_mmap(V_MAGIC_65536)
  let n: i64 = ccz_read(reg, buf, V_MAGIC_65535)
  if n <= 0 { v_puts("nx_verify no-registry\n" as *u8); return 0 }
334
  let out5: *i64 = sys_mmap(64) as *i64
  let organ: *u8 = sys_mmap(128)
  let hstr: *u8 = sys_mmap(32)
  let ep: *i64 = sys_mmap(16) as *i64
339
  if v_streq(verb, "triage" as *u8) == 1 {
      let cnt: *i64 = sys_mmap(80) as *i64
      var k: i64 = 0; while k < 7 { cnt[k] = 0; k = k + 1 }
      var rows: i64 = 0; var raises: i64 = 0
      var ls: i64 = 0
      while ls < n {
          var le: i64 = ls; var go: i64 = 1
          while go == 1 { go = 0; if le < n { if buf[le] != (10 as u8) { le = le + 1; go = 1 } } }
          var i: i64 = ls; go = 1
          while go == 1 { go = 0; if i < le { let c: i64 = buf[i] as i64; if c == 32 { i = i + 1; go = 1 } else { if c == 9 { i = i + 1; go = 1 } } } }
          var skip: i64 = 0; if i >= le { skip = 1 } if skip == 0 { if buf[i] == (35 as u8) { skip = 1 } }
          if skip == 0 { if tr_parse_row(buf, ls, le, out5) == 1 {
              let v: i64 = tr_decide(out5[0], out5[1], out5[2], out5[3])
              let prop: i64 = tr_proposal(v, out5[4])
              cnt[v] = cnt[v] + 1; rows = rows + 1; if prop == 1 { raises = raises + 1 }
              v_puts("VERIFY-TRIAGE " as *u8); v_print_task(buf, ls, le); v_puts(" -> " as *u8); v_puts(tr_verdict_name(v))
              if tr_routes_to_nishi(v) == 1 { v_puts("  [Nishi handles]" as *u8) } else { v_puts("  [GAP]" as *u8) }
              if prop == 1 { v_puts("  ***PROPOSE-INVESTMENT***" as *u8) }
              v_puts("\n" as *u8)
          } }
          ls = le + 1
      }
      v_puts("VERIFY-TRIAGE-SUM rows=" as *u8); v_putn(rows)
      v_puts(" ROUTE=" as *u8); v_putn(cnt[5]); v_puts(" USE_IMPROVE=" as *u8); v_putn(cnt[4])
      v_puts(" MEASURE=" as *u8); v_putn(cnt[3]); v_puts(" WIRE=" as *u8); v_putn(cnt[2])
      v_puts(" BUILD=" as *u8); v_putn(cnt[1]); v_puts(" SUSPECT=" as *u8); v_putn(cnt[6])
      v_puts(" PROPOSALS=" as *u8); v_putn(raises); v_puts("\n" as *u8)
      return 0
  }
  if v_streq(verb, "ground" as *u8) == 1 {
      var rows: i64 = 0; var grounded: i64 = 0; var discrep: i64 = 0; var unprob: i64 = 0
      var ls: i64 = 0
      while ls < n {
          var le: i64 = ls; var go: i64 = 1
          while go == 1 { go = 0; if le < n { if buf[le] != (10 as u8) { le = le + 1; go = 1 } } }
          var i: i64 = ls; go = 1
          while go == 1 { go = 0; if i < le { let c: i64 = buf[i] as i64; if c == 32 { i = i + 1; go = 1 } else { if c == 9 { i = i + 1; go = 1 } } } }
          var skip: i64 = 0; if i >= le { skip = 1 } if skip == 0 { if buf[i] == (35 as u8) { skip = 1 } }
          if skip == 0 { if v_field(buf, ls, le, 1, organ) >= 0 { if v_field(buf, ls, le, 2, hstr) >= 0 {
              let claimed: i64 = ccz_num_at(hstr, v_slen(hstr), 0, ep)
              let prob: i64 = v_probeable(organ, v_slen(organ))
              var grade: i64 = 0; if prob == 1 { grade = v_grade(organ) }
              var present: i64 = 0; if grade >= 3 { present = 1 }
              rows = rows + 1
              var verd: *u8 = "GROUNDED" as *u8
              if prob == 0 { verd = "UNPROBEABLE" as *u8; unprob = unprob + 1 } else {
                  if claimed == 1 { if present == 1 { grounded = grounded + 1 } else { verd = "DISCREPANCY(claim>disk)" as *u8; discrep = discrep + 1 } } else { grounded = grounded + 1 }
              }
              v_puts("VERIFY-GROUND " as *u8); v_puts(organ); v_puts(" claim=" as *u8); v_putn(claimed); v_puts(" disk=" as *u8); v_putn(grade); v_puts(" -> " as *u8); v_puts(verd); v_puts("\n" as *u8)
          } } }
          ls = le + 1
      }
      v_puts("VERIFY-GROUND-SUM rows=" as *u8); v_putn(rows); v_puts(" grounded=" as *u8); v_putn(grounded); v_puts(" DISCREPANCY=" as *u8); v_putn(discrep); v_puts(" unprobeable=" as *u8); v_putn(unprob); v_puts("\n" as *u8)
      return 0
  }
  // --- lap: the RACING-CREW loop. grade a target's progress toward SOTA across deploy laps ---
  // ledger knowledge/lap-<target>.ledger: "SOTA <val> <dir 0=lower-better|1=higher-better>" + "LAP <val> <note>".
  // nx_verify lap <target>                 -> where-was / where-is / where-to-go + verdict
  // nx_verify lap <target> record <val> .. -> append a lap after a deploy
  if v_streq(verb, "lap" as *u8) == 1 {
      if argc < 3 { v_puts("usage: nx_verify lap <target> [record <val> <note>]\n" as *u8); return 2 }
      let target: *u8 = argv[2] as *u8
      let lp: *u8 = sys_mmap(V_MAGIC_1024); var lo: i64 = 0
      lo = ccz_cat_str(lp, 0, "knowledge/lap-" as *u8); lo = ccz_cat_str(lp, lo, target); lo = ccz_cat_str(lp, lo, ".ledger" as *u8)
      // NOTE: reg buf `n` above was for the triage registry; re-read the ledger here.
      let lbuf: *u8 = sys_mmap(V_MAGIC_65536)
      let ln: i64 = ccz_read(lp, lbuf, V_MAGIC_65535)
      if argc >= 5 { if v_streq(argv[3] as *u8, "record" as *u8) == 1 {
          let rec: *u8 = sys_mmap(V_MAGIC_1024); var ro: i64 = 0
          ro = ccz_cat_str(rec, 0, "LAP " as *u8); ro = ccz_cat_str(rec, ro, argv[4] as *u8)
          var a: i64 = 5; while a < argc { ro = ccz_cat_str(rec, ro, " " as *u8); ro = ccz_cat_str(rec, ro, argv[a] as *u8); a = a + 1 }
          ro = ccz_cat_str(rec, ro, "\n" as *u8)
          let fd: i64 = sys_openat_append(lp, 420)
          if fd < 0 { v_puts("lap: cannot open ledger\n" as *u8); return 1 }
          sys_write(fd, rec, ro); sys_close(fd)
          v_puts("nx_verify lap: recorded -> " as *u8); v_puts(target); v_puts(" = " as *u8); v_puts(argv[4] as *u8); v_puts("\n" as *u8)
          return 0
      } }
      if ln <= 0 { v_puts("nx_verify lap: no ledger for " as *u8); v_puts(target); v_puts(" (record the first lap)\n" as *u8); return 0 }
      // parse SOTA + laps
      var sota: i64 = 0 - 1; var dir: i64 = 0
      let vals: *i64 = sys_mmap(8*512) as *i64
      var nl: i64 = 0
      var ls: i64 = 0
      while ls < ln {
          var le: i64 = ls; var go: i64 = 1
          while go == 1 { go = 0; if le < ln { if lbuf[le] != (10 as u8) { le = le + 1; go = 1 } } }
          if v_starts(lbuf, ls, le, "SOTA" as *u8) == 1 { sota = v_line_int(lbuf, ls, le, 1); let d: i64 = v_line_int(lbuf, ls, le, 2); if d >= 0 { dir = d } }
          else { if v_starts(lbuf, ls, le, "LAP" as *u8) == 1 { let vv: i64 = v_line_int(lbuf, ls, le, 1); if vv >= 0 { if nl < 512 { vals[nl] = vv; nl = nl + 1 } } } }
          ls = le + 1
      }
      if nl == 0 { v_puts("nx_verify lap: ledger has no LAP rows\n" as *u8); return 0 }
      let first: i64 = vals[0]
      let last: i64 = vals[nl-1]
      var prev: i64 = last; if nl >= 2 { prev = vals[nl-2] }
      v_puts("=== RACING-CREW LAP REPORT: " as *u8); v_puts(target); v_puts(" (laps=" as *u8); v_putn(nl)
      if dir == 0 { v_puts(", lower=better" as *u8) } else { v_puts(", higher=better" as *u8) }
      v_puts(") ===\n" as *u8)
      v_puts("  WHERE-IT-WAS (lap " as *u8); v_putn(nl-1); v_puts("): " as *u8); v_putn(prev); v_puts("\n" as *u8)
      v_puts("  WHERE-IT-IS  (lap " as *u8); v_putn(nl); v_puts("): " as *u8); v_putn(last)
      let delta: i64 = last - prev
      var improving: i64 = 0
      if dir == 0 { if delta < 0 { improving = 1 } } else { if delta > 0 { improving = 1 } }
      v_puts("   [delta " as *u8); v_putn(delta); if improving == 1 { v_puts(" IMPROVING]" as *u8) } else { if delta == 0 { v_puts(" HELD]" as *u8) } else { v_puts(" REGRESSED]" as *u8) } }
      v_puts("\n" as *u8)
      v_puts("  WHERE-TO-GO  (SOTA): " as *u8); v_putn(sota)
      var gap: i64 = last - sota; if dir == 1 { gap = sota - last }
      v_puts("   [gap " as *u8); v_putn(gap)
      var atsota: i64 = 0
      if dir == 0 { if last <= sota { atsota = 1 } } else { if last >= sota { atsota = 1 } }
      v_puts("]\n" as *u8)
      // progress permille of the original gap closed
      var span: i64 = first - sota; if dir == 1 { span = sota - first }
      if span > 0 { var closed: i64 = span - gap; if closed < 0 { closed = 0 }
          v_puts("  PROGRESS: " as *u8); v_putn(closed * 1000 / span); v_puts("/1000 of the original gap closed since lap 1\n" as *u8) }
      v_puts("  VERDICT: " as *u8)
      if atsota == 1 { v_puts("AT-OR-BEYOND-SOTA (podium)\n" as *u8) } else { if improving == 1 { v_puts("APPROACHING-SOTA (converging -- attack the largest remaining gap next lap)\n" as *u8) } else { v_puts("STALLED/REGRESSED (change the lever -- re-run census+adversary for new information)\n" as *u8) } }
      return 0
  }
459
  v_puts("usage: nx_verify triage|ground|lap|magic [args]\n" as *u8)
  return 2
462}
nx_verify.nx source

`nx_verify.nx` source
