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

↩ module page · 988 lines · 53534 B
1// nx_codewiki_gate.nx -- teeth for the code-wiki generator (nx_codewiki_lib).
2//
3// Fixture lives under ./_gatework/ -- a name-spaced dir the gate owns inside
4// its CWD. NOT /tmp (operator ban 2026-07-27: WSL wipes it mid-session, NAS
5// /tmp is noexec + shared) and NOT loose files in the prod CWD (the seq282
6// lesson: a gate that scatters writes where siblings work cannot run safely).
7//
8// What each tooth would catch:
9//   T1  silent page loss (the C:-full incident produced exactly this live)
10//   T2  functions missing from a module page, or line numbers detached
11//   T3  import links that do not resolve to the imported module's page
12//   T4  the reverse index (imported-by) silently empty
13//   T5  a dead href emitted for an import that has no page (unresolved must
14//       render as text, and be COUNTED)
15//   T6  nondeterministic bytes (same tree -> different pages)
16//   T7  unescaped source text corrupting the HTML
17//   T8  silent truncation (the banner mechanism itself)
18//   T9  a stale stamp -- content changed but the stamp did not (freshness)
19//   T10 directory pages losing descriptions or member links
20//
21// license_tier: ORIGINAL   No hw writes (Rule 26).
22import "nx_syscalls.nx"
23import "nx_gate_verdict.nx"
24import "nx_gatelib.nx"
25import "nx_codewiki_lib.nx"
26
27const CG_BUF: i64 = 4194304
28const CG_SCRATCH: i64 = 4096
29
30func cg_write(path: *u8, s: *u8) -> i64 {
  let fd: i64 = sys_openat_wr(path, 420)
  if fd < 0 { return 0 - 1 }
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  var off: i64 = 0
  while off < n {
      let w: i64 = sys_write(fd, ((s as i64) + off) as *u8, n - off)
      if w <= 0 { sys_close(fd); return 0 - 1 }
      off = off + w
  }
  sys_close(fd)
  return 0
43}
44
45// plain substring search (NOT token-bounded -- these are HTML fragments)
46func cg_has(hay: *u8, hn: i64, needle: *u8) -> i64 {
  var nl: i64 = 0
  while needle[nl] != (0 as u8) { nl = nl + 1 }
  if nl == 0 { return 0 }
  var i: i64 = 0
  while i + nl <= hn {
      var m: i64 = 0
      var ok: i64 = 1
      while m < nl { if hay[i + m] != needle[m] { ok = 0; m = nl } else { m = m + 1 } }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
59}
60
61func cg_eqbytes(a: *u8, an: i64, b: *u8, bn: i64) -> i64 {
  if an != bn { return 0 }
  var i: i64 = 0
  while i < an { if a[i] != b[i] { return 0 } i = i + 1 }
  return 1
66}
67
68func main() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_codewiki_gate -- the code wiki must measure, link, escape, and stay honest" as *u8)
71
  // ----- fixture -----
  sys_mkdir("_gatework" as *u8, 493)
  sys_mkdir("_gatework/cwg_fix" as *u8, 493)
  sys_mkdir("_gatework/cwg_fix/sub" as *u8, 493)
  // markers folded into line 1 (keeps alpha_one on line 5 for T2/T20/T21)
  // so the debt-taxonomy scan has real categories to detect (T40).
  cg_write("_gatework/cwg_fix/a.nx" as *u8,
      "// a.nx -- alpha module for the gate. WORKAROUND hack around a dual-copy landmine gotcha, TODO, third-party foreign, deprecated\nimport \"b.nx\"\nimport \"zz_missing.nx\"\n\nfunc alpha_one(x: i64) -> i64 { return bee_two() + x }\n" as *u8)
  // b carries ONLY a todo marker (no landmine) -- the discriminating fixture
  // that catches the &-vs-!= precedence bug: if every category wrongly read
  // bit 0, b (no landmine bit) would appear under NO category (T40b).
  cg_write("_gatework/cwg_fix/b.nx" as *u8,
      "// b.nx -- has <angle> & amp TODO\nfunc bee_two() -> i64 { return 2 }\n" as *u8)
  // c mentions bee_two() in a COMMENT and a STRING -- neither may become a
  // call edge (comment-strip + string-skip immunity, checked by T23)
  cg_write("_gatework/cwg_fix/sub/c.nx" as *u8,
      "// c.nx -- child in subdir\n// bee_two() in a comment must not count\nimport \"a.nx\"\nfunc cee_three() -> i64 { let z: *u8 = \"bee_two() quoted\" as *u8; return alpha_one(1) }\nfunc main() -> i64 { return cee_three() }\n" as *u8)
89
  // the qq_* family (4 members = exactly the CW_FAMMIN threshold)
  // qq_alpha carries a PROVENANCED cap (exempt), qq_beta a NAKED one
  // (flagged) -- the T50 discriminating pair per the taxonomy-tooth law.
  cg_write("_gatework/cwg_fix/qq_alpha.nx" as *u8, "// qq_alpha.nx -- family member one\nconst QA_MAX: i64 = 128 // sized from measured qq corpus\nfunc qq_a() -> i64 { return 1 }\n" as *u8)
  cg_write("_gatework/cwg_fix/qq_beta.nx" as *u8, "// qq_beta.nx -- family member two\nimport \"qq_alpha.nx\"\nconst QQ_CAP: i64 = 64\nfunc qq_b() -> i64 { return qq_a() }\n" as *u8)
  // qq_gamma declares a [N]T fixed array, qq_delta uses the []T slice form --
  // the T44 language-adoption fixtures (single-line bodies so no line-number
  // tooth moves; the generator only SCANS these, it never compiles them).
  cg_write("_gatework/cwg_fix/qq_gamma.nx" as *u8, "// qq_gamma.nx -- family member three\nfunc qq_c() -> i64 { var t: [4]i64; t[0] = 3; return t[0] }\n" as *u8)
  cg_write("_gatework/cwg_fix/qq_delta.nx" as *u8, "// qq_delta.nx -- family member four\nfunc qq_d(p: *i64) -> i64 { let s: []i64 = __slice(p, 4); return 4 }\n" as *u8)
100
  // ----- run 1 -----
  let st: *i64 = sys_mmap(24 * 8) as *i64
  var z: i64 = 0
  while z < 24 { st[z] = 0; z = z + 1 }
  // capability-join fixtures land BEFORE the first generate: the retrieval
  // corpus must be fixture-deterministic (a prod-CWD conf leaking in warps
  // df ranking and the on-disk counts -- the rung-23 RED taught this).
  cg_write("_gatework/cwg_allow.conf" as *u8, "ctool\t/somewhere/c.elf\tGREEN\targ1\n" as *u8)
  cg_write("_gatework/cwg_schemas.conf" as *u8, "ctool\tVerifies live pages end to end\tx\tx\tx\tx\tx\t<https-url> browser-grade verify\n" as *u8)
  cg_write("_gatework/cwg_atlas.conf" as *u8, "qq\tgames\nzz\tvideo\n" as *u8)
  let rc: i64 = cw_generate2("_gatework/cwg_fix" as *u8, "_gatework/cwg_out" as *u8, 0, st, "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_schemas.conf" as *u8, "_gatework/cwg_atlas.conf" as *u8)
112
  // T1: 7 modules + 7 sources + 2 dirs + 2 topic pages + 19 emissions = 37
  // (19th standing emission = sotaplan.html -- the sidebar had promised this
  //  link since rung 23 with NO emission behind it; T1 is the tooth that
  //  makes the promise enforceable, because a missing emission drops the
  //  count to 36 and turns this RED.)
  var t1: i64 = 0
  if rc == 0 { if st[0] == 7 { if st[10] == 2 { if st[15] == 2 { if st[7] == 37 { t1 = 1 } } } } }
  gv_check("T1 all pages written (7+7 modules/sources + 2 dirs + 2 topics + 19 = 37)" as *u8, t1, ctr)
121
  let pa: *u8 = sys_mmap(CG_BUF)
  let pb: *u8 = sys_mmap(CG_BUF)
  let pan: i64 = gl_read("_gatework/cwg_out/a.html" as *u8, pa, CG_BUF)
  let pbn: i64 = gl_read("_gatework/cwg_out/b.html" as *u8, pb, CG_BUF)
126
  // T2: function on the page WITH its line number attached (a.nx line 5)
  var t2: i64 = 0
  if pan > 0 { if cg_has(pa, pan, ">5</a></td><td class='sig'>func alpha_one(x: i64) -&gt; i64" as *u8) == 1 { t2 = 1 } }
  gv_check("T2 alpha_one signature + line 5 on a.html" as *u8, t2, ctr)
131
  // T3: import link resolves to the imported module's page
  var t3: i64 = 0
  if pan > 0 { if cg_has(pa, pan, "href='b.html'" as *u8) == 1 { t3 = 1 } }
  gv_check("T3 a.html links its import to b.html" as *u8, t3, ctr)
136
  // T4: reverse index -- b.html names a as an importer
  var t4: i64 = 0
  if pbn > 0 { if cg_has(pb, pbn, "href='a.html'" as *u8) == 1 { t4 = 1 } }
  gv_check("T4 b.html lists a.nx under imported-by" as *u8, t4, ctr)
141
  // T5: unresolved import is counted, rendered, and NOT a dead link
  var t5: i64 = 0
  if st[6] >= 1 { if pan > 0 {
      if cg_has(pa, pan, "zz_missing.nx (unresolved)" as *u8) == 1 {
          if cg_has(pa, pan, "href='zz_missing" as *u8) == 0 { t5 = 1 }
      }
  } }
  gv_check("T5 zz_missing counted + text-rendered, no dead href" as *u8, t5, ctr)
150
  // T6: determinism -- second run, byte-identical pages
  let st2: *i64 = sys_mmap(24 * 8) as *i64
  var z2: i64 = 0
  while z2 < 24 { st2[z2] = 0; z2 = z2 + 1 }
  cw_generate2("_gatework/cwg_fix" as *u8, "_gatework/cwg_out2" as *u8, 0, st2, "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_schemas.conf" as *u8, "_gatework/cwg_atlas.conf" as *u8)
  let qa: *u8 = sys_mmap(CG_BUF)
  let qan: i64 = gl_read("_gatework/cwg_out2/a.html" as *u8, qa, CG_BUF)
  let ia: *u8 = sys_mmap(CG_BUF)
  let ib: *u8 = sys_mmap(CG_BUF)
  let ian: i64 = gl_read("_gatework/cwg_out/index.html" as *u8, ia, CG_BUF)
  let ibn: i64 = gl_read("_gatework/cwg_out2/index.html" as *u8, ib, CG_BUF)
  var t6: i64 = 0
  if cg_eqbytes(pa, pan, qa, qan) == 1 { if cg_eqbytes(ia, ian, ib, ibn) == 1 { if st2[8] == st[8] { t6 = 1 } } }
  gv_check("T6 re-run byte-identical (a.html + index) + same stamp" as *u8, t6, ctr)
165
  // T7: source text is escaped in both the doc block and the dir listing
  var t7: i64 = 0
  if pbn > 0 { if cg_has(pb, pbn, "has &lt;angle&gt; &amp; amp" as *u8) == 1 { t7 = 1 } }
  gv_check("T7 <angle> & amp escaped on b.html" as *u8, t7, ctr)
170
  // T8: the truncation banner mechanism fires and lands in the file
  let tb: *u8 = sys_mmap(CG_SCRATCH)
  let tp: *i64 = sys_mmap(32) as *i64
  tp[0] = 0
  tp[1] = 0
  var f8: i64 = 0
  while f8 < 40 { cw_apps(tb, tp, 400, "0123456789" as *u8); f8 = f8 + 1 }
  cw_flush("_gatework/cwg_trunc.html" as *u8, tb, tp, 400)
  let tr: *u8 = sys_mmap(CG_SCRATCH)
  let trn: i64 = gl_read("_gatework/cwg_trunc.html" as *u8, tr, CG_SCRATCH)
  var t8: i64 = 0
  if tp[1] == 1 { if cg_has(tr, trn, "PAGE-TRUNCATED" as *u8) == 1 { t8 = 1 } }
  gv_check("T8 overflow sets the flag + banner lands in the bytes" as *u8, t8, ctr)
184
  // T9: content change -> stamp change (freshness is content-derived)
  cg_write("_gatework/cwg_fix/b.nx" as *u8,
      "// b.nx -- has <angle> & amp\nfunc bee_two() -> i64 { return 2 }\nfunc bee_extra() -> i64 { return 9 }\n" as *u8)
  let st3: *i64 = sys_mmap(24 * 8) as *i64
  var z3: i64 = 0
  while z3 < 24 { st3[z3] = 0; z3 = z3 + 1 }
  cw_generate2("_gatework/cwg_fix" as *u8, "_gatework/cwg_out3" as *u8, 0, st3, "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_schemas.conf" as *u8, "_gatework/cwg_atlas.conf" as *u8)
  var t9: i64 = 0
  if st3[8] != st[8] { if st3[3] == st[3] + 1 { t9 = 1 } }
  gv_check("T9 edited fixture -> new stamp + one more func measured" as *u8, t9, ctr)
195
  // T10: directory pages carry descriptions + member links
  let da: *u8 = sys_mmap(CG_BUF)
  let dan: i64 = gl_read("_gatework/cwg_out/d_root.html" as *u8, da, CG_BUF)
  let ds: *u8 = sys_mmap(CG_BUF)
  let dsn: i64 = gl_read("_gatework/cwg_out/d_sub.html" as *u8, ds, CG_BUF)
  var t10: i64 = 0
  if dan > 0 { if cg_has(da, dan, "alpha module for the gate" as *u8) == 1 {
      if dsn > 0 { if cg_has(ds, dsn, "href='c.html'" as *u8) == 1 { t10 = 1 } }
  } }
  gv_check("T10 d_root desc + d_sub member link present" as *u8, t10, ctr)
206
  // T11: empty root refused LOUDLY (seq1107) -- no green nothing.
  // Self-cleaning: a STALE index.html from a prior run must not fake a write.
  sys_unlinkat("_gatework/cwg_outx/index.html" as *u8)
  let stx: *i64 = sys_mmap(24 * 8) as *i64
  var zx: i64 = 0
  while zx < 24 { stx[zx] = 0; zx = zx + 1 }
  let rcx: i64 = cw_generate2("_gatework/cwg_nothere" as *u8, "_gatework/cwg_outx" as *u8, 0, stx, "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_schemas.conf" as *u8, "_gatework/cwg_atlas.conf" as *u8)
  let xi: *u8 = sys_mmap(CG_SCRATCH)
  let xin: i64 = gl_read("_gatework/cwg_outx/index.html" as *u8, xi, CG_SCRATCH)
  var t11: i64 = 0
  if rcx == 2 { if xin == 0 { t11 = 1 } }
  gv_check("T11 empty root -> rc=2 and NO index written" as *u8, t11, ctr)
219
  // T12: per-function anchors on module pages
  var t12: i64 = 0
  if cg_has(pa, pan, "id='fn_alpha_one'" as *u8) == 1 { t12 = 1 }
  gv_check("T12 a.html carries id='fn_alpha_one' anchor" as *u8, t12, ctr)
224
  // T13: search page + both index files, with the exact function row
  let sp: *u8 = sys_mmap(CG_BUF)
  let spn: i64 = gl_read("_gatework/cwg_out/search.html" as *u8, sp, CG_BUF)
  let fx: *u8 = sys_mmap(CG_BUF)
  let fxn: i64 = gl_read("_gatework/cwg_out/fnindex.js" as *u8, fx, CG_BUF)
  let mx: *u8 = sys_mmap(CG_BUF)
  let mxn: i64 = gl_read("_gatework/cwg_out/modindex.js" as *u8, mx, CG_BUF)
  var t13: i64 = 0
  if spn > 0 { if fxn > 0 { if mxn > 0 {
      if cg_has(fx, fxn, "[\"alpha_one\",\"a\",5]" as *u8) == 1 {
          if cg_has(mx, mxn, "[\"b\",\"" as *u8) == 1 { t13 = 1 }
      }
  } } }
  gv_check("T13 search.html + fnindex row [alpha_one,a,5] + modindex row" as *u8, t13, ctr)
239
  // T14: noext build emits extensionless hrefs while disk files stay .html
  let st4: *i64 = sys_mmap(24 * 8) as *i64
  var z4: i64 = 0
  while z4 < 24 { st4[z4] = 0; z4 = z4 + 1 }
  cw_generate2("_gatework/cwg_fix" as *u8, "_gatework/cwg_out4" as *u8, 1, st4, "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_schemas.conf" as *u8, "_gatework/cwg_atlas.conf" as *u8)
  let na: *u8 = sys_mmap(CG_BUF)
  let nan: i64 = gl_read("_gatework/cwg_out4/a.html" as *u8, na, CG_BUF)
  var t14: i64 = 0
  if nan > 0 {
      if cg_has(na, nan, "href='b'" as *u8) == 1 {
          if cg_has(na, nan, "href='b.html'" as *u8) == 0 { t14 = 1 }
      }
  }
  gv_check("T14 noext: href='b' emitted, href='b.html' absent, file still a.html" as *u8, t14, ctr)
254
  // T15: architecture page with layer table + native SVG
  let ap: *u8 = sys_mmap(CG_BUF)
  let apn: i64 = gl_read("_gatework/cwg_out/arch.html" as *u8, ap, CG_BUF)
  var t15: i64 = 0
  if apn > 0 { if cg_has(ap, apn, "<svg" as *u8) == 1 { if cg_has(ap, apn, "layers (longest import chain" as *u8) == 1 { t15 = 1 } } }
  gv_check("T15 arch.html has the layer table + generated SVG" as *u8, t15, ctr)
261
  // T16: transitive impact numbers (c->a->b + unresolved zz from a):
  // a pulls in {b, zz} = 2; b reaches {a, c} = 2 importers
  var t16: i64 = 0
  if cg_has(pa, pan, "pulls <b>2</b> transitive" as *u8) == 1 {
      if cg_has(pb, pbn, "reach <b>2</b> importers" as *u8) == 1 { t16 = 1 }
  }
  gv_check("T16 transitive: a pulls 2, b reaches 2 importers" as *u8, t16, ctr)
269
  // T17: the app shell -- sidebar with directories + load-bearing on module pages
  var t17: i64 = 0
  if cg_has(pa, pan, "<nav class='sb'" as *u8) == 1 { if cg_has(pa, pan, "load-bearing" as *u8) == 1 { t17 = 1 } }
  gv_check("T17 sidebar (nav.sb + load-bearing) present on a.html" as *u8, t17, ctr)
274
  // T18: neighborhood diagram on module pages with dependencies
  var t18: i64 = 0
  if cg_has(pa, pan, "class='nbr'" as *u8) == 1 { t18 = 1 }
  gv_check("T18 neighborhood SVG on a.html" as *u8, t18, ctr)
279
  // T19: narrative sidecar -- a fragment dropped in _narrative/ appears on the
  // dir page after regeneration (the LLM-narration include mechanism)
  sys_mkdir("_gatework/cwg_out/_narrative" as *u8, 493)
  cg_write("_gatework/cwg_out/_narrative/d_root.html" as *u8,
      "<p>NARRATIVE-FRAGMENT-MARKER: this directory holds the gate fixture modules.</p>" as *u8)
  let st5: *i64 = sys_mmap(24 * 8) as *i64
  var z5: i64 = 0
  while z5 < 24 { st5[z5] = 0; z5 = z5 + 1 }
  cw_generate2("_gatework/cwg_fix" as *u8, "_gatework/cwg_out" as *u8, 0, st5, "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_schemas.conf" as *u8, "_gatework/cwg_atlas.conf" as *u8)
  let dn2: *u8 = sys_mmap(CG_BUF)
  let dnn: i64 = gl_read("_gatework/cwg_out/d_root.html" as *u8, dn2, CG_BUF)
  var t19: i64 = 0
  if dnn > 0 { if cg_has(dn2, dnn, "NARRATIVE-FRAGMENT-MARKER" as *u8) == 1 { if cg_has(dn2, dnn, "class='nar'" as *u8) == 1 { t19 = 1 } } }
  gv_check("T19 narrative sidecar included on the dir page" as *u8, t19, ctr)
294
  // T20: line-anchored source page, escaped, with the anchor at the right line
  let sa: *u8 = sys_mmap(CG_BUF)
  let san: i64 = gl_read("_gatework/cwg_out/src_a.html" as *u8, sa, CG_BUF)
  var t20: i64 = 0
  if san > 0 { if cg_has(sa, san, "id='L5'" as *u8) == 1 {
      if cg_has(sa, san, "func alpha_one(x: i64) -&gt; i64" as *u8) == 1 { t20 = 1 }
  } }
  gv_check("T20 src_a.html: L5 anchor + escaped source line" as *u8, t20, ctr)
303
  // T21: the module page's line number links INTO the source page
  var t21: i64 = 0
  if cg_has(pa, pan, "href='src_a.html#L5'" as *u8) == 1 { t21 = 1 }
  gv_check("T21 a.html line number links to src_a.html#L5" as *u8, t21, ctr)
308
  // T22: call graph forward -- alpha_one calls bee_two (cross-module via import)
  // and is called by cee_three; both rendered as def links on a.html
  var t22: i64 = 0
  if cg_has(pa, pan, "calls 1:" as *u8) == 1 {
      if cg_has(pa, pan, "href='b.html#fn_bee_two'" as *u8) == 1 {
          if cg_has(pa, pan, "href='c.html#fn_cee_three'" as *u8) == 1 { t22 = 1 }
      }
  }
  gv_check("T22 a.html: alpha_one calls bee_two + called by cee_three" as *u8, t22, ctr)
318
  // T23: reverse edge EXACT -- bee_two has exactly ONE caller (the comment
  // and string mentions in c.nx must NOT have counted)
  var t23: i64 = 0
  if cg_has(pb, pbn, "called by 1:" as *u8) == 1 {
      if cg_has(pb, pbn, "href='a.html#fn_alpha_one'" as *u8) == 1 { t23 = 1 }
  }
  gv_check("T23 b.html: bee_two called by EXACTLY alpha_one (comment+string immune)" as *u8, t23, ctr)
326
  // T25: call-flow diagram -- c has a main, its tree must reach bee_two
  // (main -> cee_three -> alpha_one -> bee_two, three modules deep)
  let cp: *u8 = sys_mmap(CG_BUF)
  let cpn: i64 = gl_read("_gatework/cwg_out/c.html" as *u8, cp, CG_BUF)
  var t25: i64 = 0
  if cpn > 0 { if cg_has(cp, cpn, "call flow from main" as *u8) == 1 {
      if cg_has(cp, cpn, "class='cflow'" as *u8) == 1 {
          if cg_has(cp, cpn, "href='b.html#fn_bee_two'" as *u8) == 1 { t25 = 1 }
      }
  } }
  gv_check("T25 c.html call-flow SVG reaches bee_two (3 modules deep)" as *u8, t25, ctr)
338
  // T26: topic page for the qq family lists all 4 members; sidebar has topics
  let tq: *u8 = sys_mmap(CG_BUF)
  let tqn: i64 = gl_read("_gatework/cwg_out/t_qq.html" as *u8, tq, CG_BUF)
  var t26: i64 = 0
  if tqn > 0 { if cg_has(tq, tqn, "href='qq_alpha.html'" as *u8) == 1 { if cg_has(tq, tqn, "href='qq_delta.html'" as *u8) == 1 {
      if cg_has(pa, pan, ">topics</div>" as *u8) == 1 { t26 = 1 }
  } } }
  gv_check("T26 t_qq.html lists all 4 members + sidebar topics section" as *u8, t26, ctr)
347
  // T27: threshold honesty -- the 1-member 'a' family gets NO topic page
  let ta2: *u8 = sys_mmap(CG_SCRATCH)
  let tan2: i64 = gl_read("_gatework/cwg_out/t_a.html" as *u8, ta2, CG_SCRATCH)
  var t27: i64 = 0
  if tan2 == 0 { t27 = 1 }
  gv_check("T27 below-threshold family emits no page (t_a absent)" as *u8, t27, ctr)
354
  // T28-T30: RETRIEVAL. A hit must be found for a real term, NOTHING must be
  // returned for a term the corpus does not contain (an honest miss beats a
  // confident wrong answer), and the index must carry both record kinds.
  let qt: *u8 = sys_mmap(256)
  let qo: *i64 = sys_mmap(8 * 8) as *i64
  let ql: *i64 = sys_mmap(8 * 8) as *i64
  cg_write("_gatework/qtok.txt" as *u8, "x" as *u8)
  qo[0] = 0
  ql[0] = 9
  // ⚠nx_cc: index a literal through a BOUND POINTER -- ("lit" as *u8)[i]
  // inline compiles clean and reads garbage (the banked CONST[i] trap).
  let q1s: *u8 = "alpha_one" as *u8
  var qc: i64 = 0
  while qc < 9 { qt[qc] = q1s[qc]; qc = qc + 1 }
  let topn: *u8 = sys_mmap(128)
  let hits1: i64 = cw_ask("_gatework/cwg_out/askindex.tsv" as *u8, qt, qo, ql, 1, "https://x/" as *u8, topn)
  var t28: i64 = 0
  if hits1 >= 1 { t28 = 1 }
  gv_check("T28 ask 'alpha_one' finds >=1 cited hit" as *u8, t28, ctr)
374
  qo[0] = 0
  ql[0] = 11
  let q2s: *u8 = "zqxjnobodyy" as *u8
  var qd: i64 = 0
  while qd < 11 { qt[qd] = q2s[qd]; qd = qd + 1 }
  let hits2: i64 = cw_ask("_gatework/cwg_out/askindex.tsv" as *u8, qt, qo, ql, 1, "https://x/" as *u8, 0 as *u8)
  var t29: i64 = 0
  if hits2 == 0 { t29 = 1 }
  gv_check("T29 ask for an absent term returns NO-MATCH (0 hits, no guess)" as *u8, t29, ctr)
384
  let ax: *u8 = sys_mmap(CG_BUF)
  let axn: i64 = gl_read("_gatework/cwg_out/askindex.tsv" as *u8, ax, CG_BUF)
  var t30: i64 = 0
  if axn > 0 { if cg_has(ax, axn, "M\ta\t\t" as *u8) == 1 { if cg_has(ax, axn, "F\talpha_one\ta\t5" as *u8) == 1 { t30 = 1 } } }
  gv_check("T30 askindex.tsv carries both record kinds with real fields" as *u8, t30, ctr)
390
  // T31: RARITY WEIGHTING. Query "gate member": 'gate' appears in 1 record
  // (a.nx's description), 'member' in 4 (the qq family). Flat scoring ties
  // them and returns whichever was scanned first; rarity weighting must put
  // the 'gate' record on top. This is the tooth that caught the real defect
  // where "function" drowned "duplicate" on a live question.
  let g1s: *u8 = "gate" as *u8
  let g2s: *u8 = "member" as *u8
  qo[0] = 0
  ql[0] = 4
  var qe: i64 = 0
  while qe < 4 { qt[qe] = g1s[qe]; qe = qe + 1 }
  qo[1] = 8
  ql[1] = 6
  var qf: i64 = 0
  while qf < 6 { qt[8 + qf] = g2s[qf]; qf = qf + 1 }
  let topn2: *u8 = sys_mmap(128)
  let hits3: i64 = cw_ask("_gatework/cwg_out/askindex.tsv" as *u8, qt, qo, ql, 2, "https://x/" as *u8, topn2)
  var t31: i64 = 0
  if hits3 >= 2 { if topn2[0] == (97 as u8) { if topn2[1] == (0 as u8) { t31 = 1 } } }
  gv_check("T31 rare token outranks common one (top hit = a, not a qq member)" as *u8, t31, ctr)
411
  // T32: WORD-BOUNDARY. 'ember' occurs inside 'member' four times in the
  // fixture; a mid-word occurrence must score NOTHING (this is the exact
  // class that made a live question rank nx_chem_mORGANn for "organ").
  let g3s: *u8 = "ember" as *u8
  qo[0] = 0
  ql[0] = 5
  var qg: i64 = 0
  while qg < 5 { qt[qg] = g3s[qg]; qg = qg + 1 }
  let hits4: i64 = cw_ask("_gatework/cwg_out/askindex.tsv" as *u8, qt, qo, ql, 1, "https://x/" as *u8, 0 as *u8)
  var t32: i64 = 0
  if hits4 == 0 { t32 = 1 }
  gv_check("T32 mid-word occurrence scores nothing ('ember' in 'member')" as *u8, t32, ctr)
424
  // T33: THE RETRIEVAL CORPUS IS COMPLETE. It shared the 4 MiB page buffer
  // for a whole evening and silently held 10% of the tree -- answers came
  // from a fraction of the corpus and looked exactly like healthy ones.
  // Records must equal modules + measured functions, with truncation off.
  // (rung 23: the corpus also carries T capability rows joined from the
  // build CWD's live allowlist, whose row count varies by host -- so count
  // KINDS from the landed file itself: every record is one of M/F/T, the
  // M and F counts match the fixture exactly, and the generator's record
  // count equals what is actually on disk. Environment-agnostic AND it
  // still catches the truncation class T33 was born from.)
  var t33: i64 = 0
  var axm: i64 = 0
  var axf: i64 = 0
  var axt: i64 = 0
  var axp: i64 = 0
  while axp < axn {
      var axe: i64 = axp
      var axg: i64 = 1
      while axg == 1 { if axe >= axn { axg = 0 } else { if ax[axe] == (10 as u8) { axg = 0 } else { axe = axe + 1 } } }
      if axe > axp + 1 {
          if ax[axp] == (77 as u8) { axm = axm + 1 }
          if ax[axp] == (70 as u8) { axf = axf + 1 }
          if ax[axp] == (84 as u8) { axt = axt + 1 }
      }
      axp = axe + 1
  }
  // compare against st5 -- the run that actually WROTE the on-disk file
  // (the T9 freshness edit mutates the fixture between run-1 and the
  // restore regen, so run-1 counters describe a different tree).
  if st5[17] == 0 { if axm == st5[0] { if axf == st5[3] { if st5[16] == axm + axf + axt { t33 = 1 } } } }
  gv_check("T33 askindex complete (M==modules, F==funcs, records==M+F+T on disk, not truncated)" as *u8, t33, ctr)
456
  // T34-T35: KINDS. c owns a main -> tool; b is imported -> library;
  // qq_delta has no main and no importers -> orphan library (the honesty
  // bucket that surfaces dead-code candidates instead of hiding them).
  let kc: *u8 = sys_mmap(CG_BUF)
  let kcn: i64 = gl_read("_gatework/cwg_out/c.html" as *u8, kc, CG_BUF)
  let kq: *u8 = sys_mmap(CG_BUF)
  let kqn: i64 = gl_read("_gatework/cwg_out/qq_delta.html" as *u8, kq, CG_BUF)
  var t34: i64 = 0
  if kcn > 0 { if cg_has(kc, kcn, "<b>tool</b>" as *u8) == 1 {
      if cg_has(pb, pbn, "<b>library</b>" as *u8) == 1 {
          if kqn > 0 { if cg_has(kq, kqn, "<b>orphan library</b>" as *u8) == 1 { t34 = 1 } }
      }
  } }
  gv_check("T34 kinds: c=tool, b=library, qq_delta=orphan library" as *u8, t34, ctr)
471
  let kp: *u8 = sys_mmap(CG_BUF)
  let kpn: i64 = gl_read("_gatework/cwg_out/kinds.html" as *u8, kp, CG_BUF)
  var t35: i64 = 0
  if kpn > 0 { if cg_has(kp, kpn, "candidate dead code" as *u8) == 1 {
      if cg_has(kp, kpn, "href='qq_delta.html'" as *u8) == 1 { t35 = 1 }
  } }
  gv_check("T35 census page: rules declared + orphan listed" as *u8, t35, ctr)
479
  // T36: the EXPOSURE JOIN, fixtured. An allowlist row whose elf basename
  // matches module c must link c.html; an elf with no row must land in the
  // dark list. Inputs are parameters precisely so this tooth can exist
  // without touching the prod CWD.
  sys_mkdir("_gatework/cwg_elfs" as *u8, 493)
  cg_write("_gatework/cwg_elfs/c.elf" as *u8, "fake" as *u8)
  cg_write("_gatework/cwg_elfs/b.elf" as *u8, "fake" as *u8)
  // T53 fixture (promote-sprawl discrimination): c_new2/c_v2 share the base
  // c.elf that IS deployed => genuine promote ambiguity, must be FLAGGED.
  // solo_v2 has NO solo.elf => the version is the organ's own name, must NOT
  // be flagged. Distinct single-property fixtures per the taxonomy law.
  cg_write("_gatework/cwg_elfs/c_new2.elf" as *u8, "fake" as *u8)
  cg_write("_gatework/cwg_elfs/c_v2.elf" as *u8, "fake" as *u8)
  cg_write("_gatework/cwg_elfs/solo_v2.elf" as *u8, "fake" as *u8)
  cg_write("_gatework/cwg_allow.conf" as *u8, "ctool\t/somewhere/c.elf\tGREEN\targ1\n" as *u8)
  // NOTE: the capability-title join reads knowledge/tool_schemas.conf from
  // the CWD. The gate deliberately does NOT create that path -- writing into
  // the prod CWD is the seq282 violation this gate's whole fixture design
  // avoids. Absent schema => "capability undocumented", which is the honest
  // rendering and is what this fixture exercises.
  let xp: *u8 = sys_mmap(CG_BUF)
  let xpos: *i64 = sys_mmap(32) as *i64
  xpos[0] = 0
  xpos[1] = 0
  let dkb: *i64 = sys_mmap(16)
  dkb[0] = 0
  // rebuild the graph context cheaply: reuse the LIVE generate2 state is not
  // possible from outside, so drive cw_exposure through a tiny re-generate:
  // instead, read the emitted exposure.html from run 1 (inputs were absent
  // there -> honest-absent note) and separately prove the JOIN path here.
  // ⚠nx_cc LEXER TRAP: an identifier ending in a DIGIT followed by '.' lexes as
  // a float ('g2.' -> '2.') and desyncs the parser. Name it gfx, never g2.
  let gfx: *EcoGraph = eg_new(64, 64, 65536, 1024)
  let pa2: *u8 = sys_mmap(65536)
  let po2: *i64 = sys_mmap(64 * 8) as *i64
  let us2: *i64 = sys_mmap(16)
  let ws2: *i64 = sys_mmap(16)
  us2[0] = 0
  ws2[0] = 0
  var zz2: i64 = 0
  while zz2 < 64 { po2[zz2] = 0; zz2 = zz2 + 1 }
  let pth2: *u8 = sys_mmap(4096)
  let rt2: *u8 = "_gatework/cwg_fix" as *u8
  var rn2: i64 = 0
  while rt2[rn2] != (0 as u8) { pth2[rn2] = rt2[rn2]; rn2 = rn2 + 1 }
  gl_walk(gfx, pth2, rn2, 0 as *u8, 0 as *i64, 0 as *i64, ws2, 0, pa2, po2, us2, 65536)
  eg_finalize(gfx)
  let sx2: *i64 = sys_mmap(64 * 8) as *i64
  var nsx2: i64 = 0
  var sv2: i64 = 0
  while sv2 < gfx.node_count { if po2[sv2] > 0 { sx2[nsx2] = sv2; nsx2 = nsx2 + 1 } sv2 = sv2 + 1 }
  let kv2: *i64 = sys_mmap(64 * 8) as *i64
  var kz2: i64 = 0
  while kz2 < gfx.node_count { kv2[kz2] = CW_K_LIB; kz2 = kz2 + 1 }
  let fxb: *u8 = sys_mmap(CG_BUF)
  let fxp: *i64 = sys_mmap(32) as *i64
  fxp[0] = 0
  fxp[1] = 0
  // T57 fixture: source mtimes for the drift join. All zero = "unknown",
  // which the gauge treats as NOT comparable -- an absent input must never
  // read as "no drift" (the honest-absent law).
  let smt2: *i64 = sys_mmap(4096) as *i64
  var smz: i64 = 0
  while smz < 64 { smt2[smz] = 0; smz = smz + 1 }
  let nx2: i64 = cw_exposure(xp, xpos, CG_BUF, gfx, po2, kv2, sx2, nsx2, 0,
                             "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_elfs" as *u8, dkb, fxb, fxp, smt2)
  // dark = b + c_new2 + c_v2 + solo_v2 = 4 (the T53 fixture elfs are dark by
  // construction: only ctool->c.elf carries an allowlist row). This count
  // moved 1->4 when T53's fixtures landed -- a shared fixture dir is shared
  // state, so every tooth reading it owns the update.
  var t36: i64 = 0
  if nx2 == 1 { if dkb[0] == 4 {
      if cg_has(xp, xpos[0], "href='c.html'" as *u8) == 1 {
          if cg_has(xp, xpos[0], "href='b.html'" as *u8) == 1 { t36 = 1 }
      }
  } }
  gv_check("T36 exposure join: c exposed+linked, b deployed-dark+linked" as *u8, t36, ctr)
557
  // T53: PROMOTE-SPRAWL DISCRIMINATION. The rule used to substring-match
  // _new/_v<n>, so it flagged organs whose NAME carries a version (the edge
  // SSOT is literally nx_sites_daemon_v2) alongside real stale-promote
  // copies -- and a gauge that cries wolf teaches its reader to ignore the
  // rows that matter. A versioned name is a hazard ONLY when its base is
  // deployed too. c_new2/c_v2 (base c.elf present) must appear; solo_v2
  // (no solo.elf) must NOT -- absence here is a valid discriminator because
  // these pills carry the elf basename, which nothing else on the page emits.
  // EXACT COUNT is the discriminator: solo_v2.elf DOES appear on this page
  // (the dark-capability list prints every deployed elf), so its absence can
  // never be asserted. data-sprawl='2' says c_new2 + c_v2 and nothing else;
  // before the base-sibling rule this read 3.
  var t53: i64 = 0
  if cg_has(xp, xpos[0], "data-sprawl='2'" as *u8) == 1 {
      if cg_has(xp, xpos[0], "c_new2.elf" as *u8) == 1 {
          if cg_has(xp, xpos[0], "c_v2.elf" as *u8) == 1 { t53 = 1 }
      }
  }
  gv_check("T53 promote-sprawl: versioned WITH deployed base flagged, versioned-as-identity not" as *u8, t53, ctr)
577
  // T54: SECURITY MARKER = HAZARD or DECLARED MITIGATION. Driven DIRECTLY on
  // two buffers rather than through the module fixture: the shared fixture
  // tree is shared state (adding a module there moves T1/T33 counts -- the
  // lesson T36 just taught), and a unit pair is the sharper instrument here.
  // Distinct single-property fixtures per the taxonomy law: one line is a
  // documented prevention, the other an unqualified hazard note.
  cg_write("_gatework/cwg_secmit.txt" as *u8, "// CSRF prevention (rank-4 CWE-352): structural prevention via route flags\n" as *u8)
  cg_write("_gatework/cwg_sechaz.txt" as *u8, "// input here is not checked -- CWE-79 reflected XSS reachable from the edge\n" as *u8)
  let sb1: *u8 = sys_mmap(CG_SCRATCH)
  let sn1: i64 = gl_read("_gatework/cwg_secmit.txt" as *u8, sb1, CG_SCRATCH)
  let sb2: *u8 = sys_mmap(CG_SCRATCH)
  let sn2: i64 = gl_read("_gatework/cwg_sechaz.txt" as *u8, sb2, CG_SCRATCH)
  var t54: i64 = 0
  if sn1 > 0 { if sn2 > 0 {
      if cw_secscan(sb1, sn1) == 0 { if cw_secscan(sb2, sn2) == 1 { t54 = 1 } }
  } }
  gv_check("T54 security markers: a documented prevention is NOT a hazard, an unqualified CWE line IS" as *u8, t54, ctr)
595
  // T55: the same rule over the LANDMINE family, plus the tooth that keeps it
  // honest -- an IMPERATIVE must still count. "landmine avoided" is handled;
  // "fix this landmine" is work OWED and must stay flagged, which is exactly
  // what stops this rule from being used to silence the board.
  cg_write("_gatework/cwg_lmok.txt" as *u8, "// no mkdir needed (sys_mkdir landmine avoided); durable stores use a prefix\n" as *u8)
  cg_write("_gatework/cwg_lmhaz.txt" as *u8, "// this scratch buffer is reused across calls -- a landmine for any caller\n" as *u8)
  cg_write("_gatework/cwg_lmtodo.txt" as *u8, "// fix this landmine before the next release\n" as *u8)
  let lb1: *u8 = sys_mmap(CG_SCRATCH)
  let ln1: i64 = gl_read("_gatework/cwg_lmok.txt" as *u8, lb1, CG_SCRATCH)
  let lb2: *u8 = sys_mmap(CG_SCRATCH)
  let ln2: i64 = gl_read("_gatework/cwg_lmhaz.txt" as *u8, lb2, CG_SCRATCH)
  let lb3: *u8 = sys_mmap(CG_SCRATCH)
  let ln3: i64 = gl_read("_gatework/cwg_lmtodo.txt" as *u8, lb3, CG_SCRATCH)
  var t55: i64 = 0
  if ln1 > 0 { if ln2 > 0 { if ln3 > 0 {
      if cw_lmscan(lb1, ln1) == 0 { if cw_lmscan(lb2, ln2) == 1 { if cw_lmscan(lb3, ln3) == 1 { t55 = 1 } } }
  } } }
  gv_check("T55 landmine markers: 'avoided' handled, live hazard flagged, IMPERATIVE 'fix this' still flagged" as *u8, t55, ctr)
614
  // T56: the SUBSTRING-CLASSIFIER gauge -- the class that produced four
  // defects in one day. The discriminating pair is the whole point: a line
  // that DECIDES on a substring is the smell; a line that merely LOCATES one
  // and hands the offset onward is legitimate and must NOT be counted, or the
  // gauge becomes noise and gets ignored (the lesson from the hazard scans).
  cg_write("_gatework/cwg_sc_bad.txt" as *u8, "    if md_contains(nm, \"torrent\" as *u8) == 1 { return 1 }\n" as *u8)
  cg_write("_gatework/cwg_sc_ok.txt" as *u8, "    let at: i64 = cw_nameidx(snm, \"_v2\" as *u8)\n" as *u8)
  let scb: *u8 = sys_mmap(CG_SCRATCH)
  let scbn: i64 = gl_read("_gatework/cwg_sc_bad.txt" as *u8, scb, CG_SCRATCH)
  let sco: *u8 = sys_mmap(CG_SCRATCH)
  let scon: i64 = gl_read("_gatework/cwg_sc_ok.txt" as *u8, sco, CG_SCRATCH)
  var t56: i64 = 0
  if scbn > 0 { if scon > 0 {
      if cw_substrclass(scb, scbn) == 1 { if cw_substrclass(sco, scon) == 0 { t56 = 1 } }
  } }
  gv_check("T56 substring-classifier: a line that DECIDES on a substring counts, one that only LOCATES does not" as *u8, t56, ctr)
631
  // T57: DRIFT MUST SEE THROUGH THE IMPORT CLOSURE (seq1721). The first
  // version compared an elf against its module's OWN source only, which
  // misses the COMMON case: the fix landed in a shared lib and the consumer
  // was never rebuilt. Driven directly on the fixture graph -- a unit pair,
  // not the shared fixture tree, per the lesson T36 taught about shared state.
  // a imports b (edge a->b in the fixture): a's closure max must pick up b's
  // NEWER source, and b alone must report only its own.
  // u26a0the gate's fixture graph is walked with EDGE MODE OFF (a deliberate
  // rung-1 decision: gl_walk interns subdir import paths verbatim, so the real
  // generator builds its own basename edges). It has nodes but NO edges and
  // cannot exercise a closure -- build a 2-node graph here, a genuine unit.
  let cg: *EcoGraph = eg_new(16, 16, 4096, 64)
  let ia: i64 = eg_intern(cg, "importer" as *u8, 8)
  let ib: i64 = eg_intern(cg, "dep" as *u8, 3)
  eg_add_edge(cg, ia, ib)
  eg_finalize(cg)
  let cstamp: *i64 = sys_mmap(4096) as *i64
  let cstack: *i64 = sys_mmap(4096) as *i64
  let cmt: *i64 = sys_mmap(4096) as *i64
  var cz: i64 = 0
  while cz < 16 { cstamp[cz] = 0; cmt[cz] = 0; cz = cz + 1 }
  var t57: i64 = 0
  cmt[ia] = 100
  cmt[ib] = 900
  let amax: i64 = cw_reach_maxmt(cg, ia, cstamp, 1, cstack, cmt)
  let bmax: i64 = cw_reach_maxmt(cg, ib, cstamp, 2, cstack, cmt)
  // importer inherits the dependency's NEWER source (900) so a stale consumer
  // is caught; the dependency sees only its own, so a leaf is never slandered
  // by something that merely imports IT.
  if amax == 900 { if bmax == 900 { t57 = 1 } }
  gv_check("T57 drift sees the CLOSURE: a newer dependency makes its importer stale, not just its own file" as *u8, t57, ctr)
663
  // T37: THE CLOSED LOOP. findings.tsv IS the backlog feed -- exactly the
  // nx_debt-grammar rows the bridge files. It must exist, be non-empty for
  // the fixture (which has an orphan library), and every row must parse as
  // sev<TAB>scope<TAB>desc with a numeric leading sev. The dark-capability
  // finding from the exposure detector proves the JOIN feeds the loop too.
  let fv: *u8 = sys_mmap(CG_BUF)
  let fvn: i64 = gl_read("_gatework/cwg_out/findings.tsv" as *u8, fv, CG_BUF)
  var frows: i64 = 0
  var badrow: i64 = 0
  var fi: i64 = 0
  var lstart: i64 = 0
  while fi < fvn {
      if fv[fi] == (10 as u8) {
          frows = frows + 1
          // first byte of each row must be a digit (the severity)
          if fv[lstart] < (48 as u8) { badrow = 1 }
          if fv[lstart] > (57 as u8) { badrow = 1 }
          lstart = fi + 1
      }
      fi = fi + 1
  }
  var t37: i64 = 0
  if fvn > 0 { if frows >= 1 { if badrow == 0 {
      if cg_has(fv, fvn, "Orphan libraries exist" as *u8) == 1 { t37 = 1 }
  } } }
  gv_check("T37 findings.tsv: valid nx_debt rows, orphan finding present (the loop)" as *u8, t37, ctr)
690
  // T38: the sovereignty ladder page exists with the hardware rung first
  let sp: *u8 = sys_mmap(CG_BUF)
  let spn: i64 = gl_read("_gatework/cwg_out/sovereignty.html" as *u8, sp, CG_BUF)
  var t38: i64 = 0
  if spn > 0 { if cg_has(sp, spn, "the sovereignty ladder" as *u8) == 1 {
      if cg_has(sp, spn, "hardware / firmware" as *u8) == 1 { t38 = 1 }
  } }
  gv_check("T38 sovereignty ladder: hardware rung present, first-byte-up" as *u8, t38, ctr)
699
  // T39: findings.html renders the same feed for humans
  let fh: *u8 = sys_mmap(CG_BUF)
  let fhn: i64 = gl_read("_gatework/cwg_out/findings.html" as *u8, fh, CG_BUF)
  var t39: i64 = 0
  if fhn > 0 { if cg_has(fh, fhn, "the wiki's own work backlog" as *u8) == 1 {
      if cg_has(fh, fhn, "idempotent" as *u8) == 1 { t39 = 1 }
  } }
  gv_check("T39 findings.html: the loop is explained + rendered" as *u8, t39, ctr)
708
  // T40: the DEBT TAXONOMY covers all categories. a.nx carries workaround +
  // landmine + todo markers -> its page must list under those categories and
  // the feed must carry the category findings (operator: cover ALL categories).
  let dbp: *u8 = sys_mmap(CG_BUF)
  let dbpn: i64 = gl_read("_gatework/cwg_out/debt.html" as *u8, dbp, CG_BUF)
  var t40: i64 = 0
  if dbpn > 0 {
      if cg_has(dbp, dbpn, "landmine" as *u8) == 1 { if cg_has(dbp, dbpn, "workaround / hack" as *u8) == 1 {
          if cg_has(dbp, dbpn, "gotcha / trap" as *u8) == 1 { if cg_has(dbp, dbpn, "third-party" as *u8) == 1 {
              if cg_has(dbp, dbpn, "href='a.html'" as *u8) == 1 {
                  // b has ONLY a todo marker -- it must appear (under todo).
                  // With the precedence bug it would appear under no category.
                  if cg_has(dbp, dbpn, "href='b.html'" as *u8) == 1 {
                      if cg_has(fv, fvn, "Workaround/hack markers present" as *u8) == 1 { t40 = 1 }
                  }
              }
          } }
      } }
  }
  gv_check("T40 debt taxonomy: all 8 categories rendered, a listed, findings filed" as *u8, t40, ctr)
729
  // T41: TARGETED findings name individual modules for the severe categories,
  // and carry NO COUNTS (a drifting number would refile as a new debt every
  // regen and turn the board into noise). a.nx has landmine markers and is
  // imported by c, so it must be named in a per-module row.
  var t41: i64 = 0
  if fvn > 0 { if cg_has(fv, fvn, "landmine in a (high blast radius" as *u8) == 1 {
      // the row must cite the module page and carry no digits after the sev
      if cg_has(fv, fvn, "https://nishifamily.com/code/a\n" as *u8) == 1 { t41 = 1 }
  } }
  gv_check("T41 targeted finding names the module, cites its page, no counts" as *u8, t41, ctr)
740
  // T42: the ASK surface (rung 15) -- the grounded-chat page exists and
  // carries all four disciplines as CONTRACT strings (not markup, per the
  // T2 lesson): the loopback engine URL, the refusal-before-model literal,
  // the hallucination-guard rejection literal, and grounding in the wiki's
  // own index (modindex.js). Any regression in a discipline breaks its
  // pinned literal.
  let akp: *u8 = sys_mmap(CG_BUF)
  let akn: i64 = gl_read("_gatework/cwg_out/ask.html" as *u8, akp, CG_BUF)
  var t42: i64 = 0
  if akn > 0 { if cg_has(akp, akn, "http://127.0.0.1:7862" as *u8) == 1 {
      if cg_has(akp, akn, "NO EVIDENCE IN THE WIKI" as *u8) == 1 {
          if cg_has(akp, akn, "ANSWER REJECTED" as *u8) == 1 {
              if cg_has(akp, akn, "modindex.js" as *u8) == 1 { t42 = 1 }
          }
      }
  } }
  gv_check("T42 ask.html: engine contract + refusal-before-model + guard + index-grounded" as *u8, t42, ctr)
758
  // T43: ask is reachable from every page's sidebar, and the noext build
  // emits the extensionless href (per-click 301s stay dead).
  var t43: i64 = 0
  if cg_has(pa, pan, "href='ask.html'>" as *u8) == 1 {
      if cg_has(na, nan, "href='ask'>" as *u8) == 1 { t43 = 1 }
  }
  gv_check("T43 sidebar Ask link on module pages, extensionless under noext" as *u8, t43, ctr)
766
  // T44: the LANGUAGE page (rung 16) -- the nishilang lane's adoption axes
  // measured from the fixture: qq_gamma declares [N]T -> listed under fixed;
  // qq_delta uses []T/__slice -> listed under slice; the page cross-links
  // the published rankings at /nishilang. A miscounting scan or a dropped
  // axis breaks its pinned adopter link.
  let lgp: *u8 = sys_mmap(CG_BUF)
  let lgn: i64 = gl_read("_gatework/cwg_out/lang.html" as *u8, lgp, CG_BUF)
  var t44: i64 = 0
  if lgn > 0 { if cg_has(lgp, lgn, "spatial-safety adoption" as *u8) == 1 {
      if cg_has(lgp, lgn, "href='qq_gamma.html'" as *u8) == 1 {
          if cg_has(lgp, lgn, "href='qq_delta.html'" as *u8) == 1 {
              if cg_has(lgp, lgn, "href='/nishilang'" as *u8) == 1 { t44 = 1 }
          }
      }
  } }
  gv_check("T44 lang.html: adoption axes measured, adopters linked, /nishilang cross-link" as *u8, t44, ctr)
783
  // T45: the sidebar reaches the language page from every page, extensionless
  // under noext (mirror of T43).
  var t45: i64 = 0
  if cg_has(pa, pan, "href='lang.html'>" as *u8) == 1 {
      if cg_has(na, nan, "href='lang'>" as *u8) == 1 { t45 = 1 }
  }
  gv_check("T45 sidebar Language link on module pages, extensionless under noext" as *u8, t45, ctr)
791
  // T46: the CAPABILITY CATALOG join (rung 19 -- discoverability). Driven
  // with fixture inputs (T36 pattern: never write into the prod CWD): the
  // ctool allowlist row joined to a fixture schema row must yield the
  // anchored catalog row with title + grammar, and the TOOLS js row.
  cg_write("_gatework/cwg_schemas.conf" as *u8,
      "ctool\tVerifies live pages end to end\tx\tx\tx\tx\tx\t<https-url> browser-grade verify\n" as *u8)
  let tcp: *u8 = sys_mmap(CG_BUF)
  let tcpos: *i64 = sys_mmap(32) as *i64
  tcpos[0] = 0
  tcpos[1] = 0
  let tjx: *u8 = sys_mmap(CG_BUF)
  let tjxp: *i64 = sys_mmap(32) as *i64
  tjxp[0] = 0
  tjxp[1] = 0
  let ntl: i64 = cw_tools(tcp, tcpos, CG_BUF, tjx, tjxp,
                          "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_schemas.conf" as *u8)
  var t46: i64 = 0
  if ntl == 1 { if cg_has(tcp, tcpos[0], "id='t_ctool'" as *u8) == 1 {
      if cg_has(tcp, tcpos[0], "Verifies live pages end to end" as *u8) == 1 {
          if cg_has(tcp, tcpos[0], "browser-grade verify" as *u8) == 1 {
              if cg_has(tjx, tjxp[0], "[\"ctool\",\"Verifies live pages end to end\"" as *u8) == 1 { t46 = 1 }
          }
      }
  } }
  gv_check("T46 capability catalog: allowlist x schemas join, anchor + title + grammar + js row" as *u8, t46, ctr)
817
  // T47: capabilities are retrievable everywhere -- search and ask load
  // toolindex.js and carry the capability sections; the sidebar reaches the
  // catalog from every page (extensionless under noext).
  let sq: *u8 = sys_mmap(CG_BUF)
  let sqn: i64 = gl_read("_gatework/cwg_out/search.html" as *u8, sq, CG_BUF)
  let aq: *u8 = sys_mmap(CG_BUF)
  let aqn: i64 = gl_read("_gatework/cwg_out/ask.html" as *u8, aq, CG_BUF)
  var t47: i64 = 0
  if sqn > 0 { if cg_has(sq, sqn, "toolindex.js" as *u8) == 1 { if cg_has(sq, sqn, "capabilities (" as *u8) == 1 {
      if aqn > 0 { if cg_has(aq, aqn, "toolindex.js" as *u8) == 1 { if cg_has(aq, aqn, "CAPABILITY " as *u8) == 1 {
          if cg_has(pa, pan, "href='tools.html'>" as *u8) == 1 {
              if cg_has(na, nan, "href='tools'>" as *u8) == 1 { t47 = 1 }
          }
      } } }
  } } }
  gv_check("T47 capabilities retrievable: search section + ask records + sidebar link" as *u8, t47, ctr)
834
  // T48: the PULSE instrument (rung 20) -- fixture journal + meter drive the
  // gauges: 3 DONE frames across 2 days, ONE by a non-claude actor (the
  // making-plane shift gauge must count exactly it), one foreign mention
  // (ssh) and one sovereign (nx_) in the notes, meter row rendered as a
  // TABLE row (missing days absent, never zero-barred).
  cg_write("_gatework/cwg_pulse.jrnl" as *u8,
      "8640000\tKICKOFF\twsA\tclaude-x\tstart\n8640010\tDONE\twsA\tclaude-x\tshipped via ssh lane\n8726400\tDONE\twsB\tmaker-local\tclosed with nx_tool zero API\n8726500\tDONE\twsC\tclaude-y\tplain note\n" as *u8)
  cg_write("_gatework/cwg_pulse.meter" as *u8,
      "8726400\tclaude-daily\t3\t1000000\t2000000000\t5\tnote\n" as *u8)
  let pup: *u8 = sys_mmap(CG_BUF)
  let pupos: *i64 = sys_mmap(32) as *i64
  pupos[0] = 0
  pupos[1] = 0
  let pdone: i64 = cw_pulse(pup, pupos, CG_BUF, "_gatework/cwg_pulse.jrnl" as *u8, "_gatework/cwg_pulse.meter" as *u8, 0)
  // contract = data-* attributes, NOT markup (the T2 lesson: design may
  // evolve; the numbers may not)
  var t48: i64 = 0
  if pdone == 3 { if cg_has(pup, pupos[0], "<svg" as *u8) == 1 {
      if cg_has(pup, pupos[0], "data-nc='333'" as *u8) == 1 {
          if cg_has(pup, pupos[0], "data-fo='500'" as *u8) == 1 {
              if cg_has(pup, pupos[0], "<td><code>claude-daily</code></td>" as *u8) == 1 { t48 = 1 }
          }
      }
  } }
  gv_check("T48 pulse gauges: data-nc=333, data-fo=500 (contract attrs), SVG + meter table" as *u8, t48, ctr)
860
  // T49: pulse reachable from every page (extensionless under noext); the
  // honest-absent rendering proven DIRECTLY with a nonexistent journal path
  // (environment-agnostic: the build host may or may not carry real logs,
  // so the run-1 page only needs to exist and be one of the two honest
  // states -- gauges or declared absence).
  let pw: *u8 = sys_mmap(CG_BUF)
  let pwn: i64 = gl_read("_gatework/cwg_out/pulse.html" as *u8, pw, CG_BUF)
  let pab: *u8 = sys_mmap(CG_SCRATCH)
  let pabp: *i64 = sys_mmap(32) as *i64
  pabp[0] = 0
  pabp[1] = 0
  cw_pulse(pab, pabp, CG_SCRATCH, "_gatework/cwg_nofile.jrnl" as *u8, "_gatework/cwg_nofile.meter" as *u8, 0)
  var t49: i64 = 0
  if pwn > 0 {
      var pok: i64 = 0
      if cg_has(pw, pwn, "not present in this build environment" as *u8) == 1 { pok = 1 }
      if cg_has(pw, pwn, "data-nc='" as *u8) == 1 { pok = 1 }
      if pok == 1 { if cg_has(pab, pabp[0], "not present in this build environment" as *u8) == 1 {
          if cg_has(pa, pan, "href='pulse.html'>" as *u8) == 1 {
              if cg_has(na, nan, "href='pulse'>" as *u8) == 1 { t49 = 1 }
          }
      } }
  }
  gv_check("T49 pulse: sidebar link + honest-absent proven on a missing journal" as *u8, t49, ctr)
885
  // T50: the TASTE-BOUND gauge (bounds law, seq1242): qq_beta's naked
  // QQ_CAP=64 must be flagged; qq_alpha's QA_MAX=128 carries 'sized from
  // measured' and must be EXEMPT -- distinct single-property fixtures, per
  // the taxonomy-tooth law (one module with both would hide a read-the-
  // wrong-bit defect). The auto-filed finding must be in the loop feed.
  // (the sidebar's load-bearing list links qq_alpha on EVERY page -- fan-in
  // 1 -- so absence-of-link is NOT a valid discriminator; the exact count
  // "1 caps in 1 modules" is: were QA_MAX wrongly counted it would read 2/2.)
  var t50: i64 = 0
  if dbpn > 0 { if cg_has(dbp, dbpn, "taste-bound consts" as *u8) == 1 {
      if cg_has(dbp, dbpn, "1 caps in 1 modules" as *u8) == 1 {
          if cg_has(dbp, dbpn, "href='qq_beta.html'" as *u8) == 1 {
              if cg_has(fv, fvn, "Taste-bound consts present" as *u8) == 1 { t50 = 1 }
          }
      }
  } }
  gv_check("T50 taste-bound gauge: exactly 1/1 flagged (QQ_CAP naked, QA_MAX exempt), finding filed" as *u8, t50, ctr)
903
  // T51: CAPABILITY RETRIEVAL, organ side (rung 23). Fixture-driven via the
  // T46 conf inputs. The ask must find the capability from its TITLE words
  // alone -- the discovery-failure class this rung eats: the seeker knows
  // the NEED ("verifies pages"), never the NAME (ctool). Without T-field
  // scoring this is NO-MATCH; without T-row emission nt51 is 0; the row
  // bytes pin name+title+grammar so the join cannot silently degrade.
  let tb51: *u8 = sys_mmap(CG_SCRATCH)
  let tb51p: *i64 = sys_mmap(32) as *i64
  tb51p[0] = 0
  tb51p[1] = 0
  let nt51: i64 = cw_asktools(tb51, tb51p, CG_SCRATCH, "_gatework/cwg_allow.conf" as *u8, "_gatework/cwg_schemas.conf" as *u8)
  let hd51: *u8 = sys_mmap(CG_SCRATCH)
  let hd51p: *i64 = sys_mmap(32) as *i64
  hd51p[0] = 0
  hd51p[1] = 0
  cw_apps(hd51, hd51p, CG_SCRATCH, "M\tzz_mod\tdirx\t5\t1\tplain rec\tplain rec\n" as *u8)
  cw_apps(hd51, hd51p, CG_SCRATCH, "F\tzz_fn\tzz_mod\t3\n" as *u8)
  cw_app(hd51, hd51p, CG_SCRATCH, tb51, tb51p[0])
  hd51[hd51p[0]] = 0 as u8
  cg_write("_gatework/cwg_askt.tsv" as *u8, hd51)
  let q51: *u8 = "verifies" as *u8
  qo[0] = 0
  ql[0] = 8
  var q5c: i64 = 0
  while q5c < 8 { qt[q5c] = q51[q5c]; q5c = q5c + 1 }
  let top51: *u8 = sys_mmap(128)
  let hits51: i64 = cw_ask("_gatework/cwg_askt.tsv" as *u8, qt, qo, ql, 1, "https://x/" as *u8, top51)
  var t51: i64 = 0
  if nt51 == 1 { if cg_has(tb51, tb51p[0], "T\tctool\tVerifies live pages end to end\t<https-url> browser-grade verify" as *u8) == 1 {
      if hits51 >= 1 { if top51[0] == (99 as u8) { if top51[4] == (108 as u8) { if top51[5] == (0 as u8) { t51 = 1 } } } }
  } }
  gv_check("T51 capability retrieval: T-row joined (name+title+grammar) and found by TITLE words, top hit = the tool" as *u8, t51, ctr)
936
  // T52: THE ATLAS RULER (seq1220). qq is the fixture's only eligible
  // family and the conf maps it (qq->games), so conformance is EXACTLY
  // 1000 permil (data-conf contract attr, T48 law); zz names no current
  // family and must surface as a STALE row, never vanish. The absent-conf
  // branch is driven DIRECTLY on a synthetic 1-family table: conformance 0,
  // qq lands in the unmapped work list, absence declared in-band.
  let at52: *u8 = sys_mmap(CG_BUF)
  let at52n: i64 = gl_read("_gatework/cwg_out/atlas.html" as *u8, at52, CG_BUF)
  let ab52: *u8 = sys_mmap(CG_SCRATCH)
  let ab52p: *i64 = sys_mmap(32) as *i64
  ab52p[0] = 0
  ab52p[1] = 0
  let af52: *u8 = sys_mmap(CG_SCRATCH)
  let af52p: *i64 = sys_mmap(32) as *i64
  af52p[0] = 0
  af52p[1] = 0
  let fa52: *u8 = sys_mmap(64)
  let fo52: *i64 = sys_mmap(16) as *i64
  let fl52: *i64 = sys_mmap(16) as *i64
  let fcx52: *i64 = sys_mmap(16) as *i64
  let flo52: *i64 = sys_mmap(16) as *i64
  fa52[0] = 113 as u8
  fa52[1] = 113 as u8
  fa52[2] = 0 as u8
  fo52[0] = 0
  fl52[0] = 2
  fcx52[0] = CW_FAMMIN
  flo52[0] = 77
  cw_atlas(ab52, ab52p, CG_SCRATCH, fa52, fo52, fl52, fcx52, flo52, 1, "_gatework/cwg_atlas_absent.conf" as *u8, 0, af52, af52p)
  var t52: i64 = 0
  if at52n > 0 { if cg_has(at52, at52n, "data-conf='1000'" as *u8) == 1 {
      if cg_has(at52, at52n, ">games</td>" as *u8) == 1 {
          if cg_has(at52, at52n, "stale mapping rows" as *u8) == 1 { if cg_has(at52, at52n, "<code>zz</code>" as *u8) == 1 {
              if cg_has(ab52, ab52p[0], "data-conf='0'" as *u8) == 1 { if cg_has(ab52, ab52p[0], ">qq</a>" as *u8) == 1 {
                  if cg_has(ab52, ab52p[0], "not present in this build environment" as *u8) == 1 { t52 = 1 }
              } }
          } }
      }
  } }
  gv_check("T52 atlas ruler: qq->games conformance exactly 1000, zz stale declared; absent conf -> 0 + unmapped work list" as *u8, t52, ctr)
977
  // T24: arch page carries the call-graph headline
  let aa: *u8 = sys_mmap(CG_BUF)
  let aan: i64 = gl_read("_gatework/cwg_out/arch.html" as *u8, aa, CG_BUF)
  var t24: i64 = 0
  if aan > 0 { if cg_has(aa, aan, "most-called functions" as *u8) == 1 { if cg_has(aa, aan, "resolved call edges" as *u8) == 1 { t24 = 1 } } }
  gv_check("T24 arch.html: most-called table + edge counts" as *u8, t24, ctr)
984
  let rc2: i64 = gv_verdict("CODEWIKI-GATE" as *u8, ctr, "code wiki measures, links, escapes, searches, stays honest" as *u8)
  sys_exit(rc2)
  return rc2
988}
nx_codewiki_gate.nx source

`nx_codewiki_gate.nx` source
