`nx_adopt.nx` source

↩ module page · 408 lines · 22529 B
1// nx_adopt.nx -- THE ADOPTION CENSUS. Which capability primitives has nobody adopted? (operator priority)
2//
3// LAW: THE BOTTLENECK IS NOT BUILDING PRIMITIVES, IT IS ADOPTING THEM. Three proofs on 2026-07-30:
4// cpu-feature-detect existed with a KAT, registered nowhere (seq1359) - ss_close: 133 openers, 1 closer
5// (seq1347) - nx_hw_cpu_count: CORRECT (sched_getaffinity, cgroup-safe) with ZERO external callers in
6// 19,823 files while nx_torrent_get hardcodes MAXP=32 (seq1410). A build-only 'done' is the cause.
7// ==> A ZERO-CALLER CAPABILITY PRIMITIVE IS A RED DEFECT, NOT A COMPLETED FEATURE.
8//
9// SCALE: the naive census greps the corpus once per primitive = O(primitives x corpus). This walks the
10// corpus TWICE total -- pass A hashes every definition, pass B counts every identifier against it with
11// O(1) lookups -- so cost is O(corpus) regardless of how many primitives exist.
12//
13// SELF-REFERENCES DO NOT COUNT AS ADOPTION. nx_hw_cpu_count showed FIVE grep matches and looked alive;
14// four were its own file. Definition-file hits are tallied SEPARATELY from external ones -- that is the
15// entire difference between 'used' and 'looks used'.
16//   argv: <defs-dir> [callers-dir]
17// exit 0 = ran, 2 = usage/unreadable. license_tier: ORIGINAL   Read-only. No hw writes (Rule 26).
18import "nx_adopt_lib.nx"
19import "nx_proc_ctl.nx"
20import "nx_resmon_lib.nx"
21
22const AD_CAP: i64 = 65536
23const AD_TBL_BYTES: i64 = 524288
24const AD_NAMEBUF: i64 = 2097152
25const AD_FILECAP: i64 = 2097152
26const AD_DIRBUF: i64 = 262144
27const AD_MAXREPORT: i64 = 30
28const AD_PATHBUF: i64 = 1024
29const AD_PAREN: i64 = 40
30const AD_SLASH: i64 = 47
31const AD_NL: i64 = 10
32const AD_SP: i64 = 32
33const AD_F: i64 = 102
34const AD_U: i64 = 117
35const AD_N: i64 = 110
36const AD_C: i64 = 99
37// Spare fd used to PARK the caller's real stdout while the long report is written to argv[3].
38// 9 is above the 0/1/2 standard trio and below any fd this organ opens, so it cannot collide.
39const AD_SAVEFD: i64 = 9
40// Second spare fd, same trick, used to park stdout while the machine-readable stamp is written.
41const AD_STAMPFD: i64 = 10
42// The ADOPTION axis stamp. A .stamp and NOT a .log ON PURPOSE: nx_gatereg_derive registers ANY anchored
43// *.log in knowledge/status as a gate, and this is a CENSUS, not a verdict -- registering it would
44// manufacture a false RED in nx_gate_rollup (whose pass vocabulary is GREEN|PASS|VALID). Filed as its own
45// defect; this organ declines to feed it.
46const AD_STAMP: *u8 = "knowledge/status/adopt_census.stamp" as *u8
47
48// PROOF-FILE CLASSIFIER (2026-07-30). A caller that is a GATE is not adoption -- it is the receipt for
49// the build. This census scored external>0 as ADOPTED, which made it blind to the class that caused six
50// separate defects in one session: capability BUILT, capability GATED, capability never called in
51// production. ls_signup_allowed scored adopted (two gates call it) while the live register route gated on
52// a single global boolean and public registration sat open to the internet.
53// BOUNDED substring search. The first cut kept scanning after a mismatch and read nm[i+k] PAST the
54// NUL terminator -- an out-of-bounds read that happened to compile and would usually 'work'. Stop at the
55// first mismatch AND at the end of nm, so the scan can never leave the string.
56func ad_has_sub(nm: *u8, sub: *u8) -> i64 {
  var i: i64 = 0
  while nm[i] != (0 as u8) {
      var k: i64 = 0
      var ok: i64 = 1
      var go: i64 = 1
      while go == 1 {
          if sub[k] == (0 as u8) { go = 0 } else {
              if nm[i+k] == (0 as u8) { ok = 0; go = 0 } else {
                  if nm[i+k] != sub[k] { ok = 0; go = 0 } else { k = k + 1 }
              }
          }
      }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
73}
74func ad_is_prooffile(nm: *u8) -> i64 {
  if ad_has_sub(nm, "_gate" as *u8) == 1 { return 1 }
  if ad_has_sub(nm, "_test" as *u8) == 1 { return 1 }
  if ad_has_sub(nm, "_probe" as *u8) == 1 { return 1 }
  if ad_has_sub(nm, "_kat" as *u8) == 1 { return 1 }
  if ad_has_sub(nm, "_smoke" as *u8) == 1 { return 1 }
  return 0
81}
82func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { rm_puts("usage: nx_adopt <defs-dir> [callers-dir]\n" as *u8); return 2 }
  let dirs: *i64 = sys_mmap(32) as *i64
  dirs[0] = argv[1]
  var ndirs: i64 = 1
  if argc >= 3 { dirs[1] = argv[2]; ndirs = 2 }
  // Optional argv[3] = report path. WHY: a census whose findings only reach stdout is capped at the
  // 200-char plan snippet, so the DARK LIST -- the entire point -- is unreadable. Same lesson as
  // nx_procchurn's journal: an instrument that cannot deliver its findings has not delivered them.
  // DELIVERY FIX 2026-07-30. The comment directly above states the law -- 'an instrument that cannot
  // deliver its findings has not delivered them' -- and then this line dup3'd the report file OVER fd 1
  // and never restored it, so EVERY caller received an empty response. It is not conditional in practice:
  // the allowlist row pins argv[3]=knowledge/status/adopt_census.txt, so argc is ALWAYS >=4 over MCP and
  // the census returned nothing to every seat that ever called it -- indistinguishable from a broken tool,
  // which is why nx_adopt sits in the S4 DARK list while working perfectly.
  // NOW: the long DEBT/PROVEN_UNWIRED rows still go to the file (they belong there -- they are unbounded),
  // and the caller's stdout is PARKED on AD_SAVEFD and restored before the summary, so the answer arrives
  // where it was asked for. Fail-safe: if the park fails, ad_savefd stays -1 and behaviour is exactly as before.
  var ad_savefd: i64 = 0 - 1
  if argc >= 4 {
      let ofd: i64 = sys_openat_wr(argv[3] as *u8, 420)
      if ofd >= 0 {
          if sys_dup3(1, AD_SAVEFD, 0) >= 0 { ad_savefd = AD_SAVEFD }
          sys_dup3(ofd, 1, 0)
      }
  }
108
  let h_hash: *i64 = sys_mmap(AD_TBL_BYTES) as *i64
  let h_noff: *i64 = sys_mmap(AD_TBL_BYTES) as *i64
  let h_nlen: *i64 = sys_mmap(AD_TBL_BYTES) as *i64
  let h_fh: *i64 = sys_mmap(AD_TBL_BYTES) as *i64
  let h_ext: *i64 = sys_mmap(AD_TBL_BYTES) as *i64
  let h_self: *i64 = sys_mmap(AD_TBL_BYTES) as *i64
  // callers that are GATES/TESTS, counted SEPARATELY from h_ext (which stays the TOTAL external count so
  // the existing DEBT verdict is byte-for-byte unchanged). production callers = h_ext - h_proof.
  let h_proof: *i64 = sys_mmap(AD_TBL_BYTES) as *i64
  let arena: *u8 = sys_mmap(AD_NAMEBUF)
  let src: *u8 = sys_mmap(AD_FILECAP)
  let dbuf: *u8 = sys_mmap(AD_DIRBUF)
  let p: *u8 = sys_mmap(AD_PATHBUF)
  var ab: i64 = 0
  var ndef: i64 = 0
  var nfiles: i64 = 0
  var truncated: i64 = 0
126
  let d1: *u8 = dirs[0] as *u8
  let fdA: i64 = sys_openat_rd(d1)
  if fdA < 0 { rm_puts("NX-ADOPT defs-dir unreadable\n" as *u8); return 2 }
  var goA: i64 = 1
  while goA == 1 {
      let dn: i64 = sys_getdents64(fdA, dbuf, AD_DIRBUF)
      if dn <= 0 { goA = 0 } else {
          var off: i64 = 0
          while off < dn {
              let rec: *u8 = ((dbuf as i64) + off) as *u8
              let reclen: i64 = dirent_reclen(rec)
              if reclen <= 0 { off = dn } else {
                  let nm: *u8 = dirent_name(rec)
                  var take: i64 = 0
                  if dirent_type(rec) != 4 { if ad_ends_nx(nm) == 1 { take = 1 } }
                  if take == 1 {
                      var po: i64 = 0
                      var di: i64 = 0
                      while d1[di] != (0 as u8) { p[po] = d1[di]; po = po + 1; di = di + 1 }
                      p[po] = AD_SLASH as u8; po = po + 1
                      let nb0: i64 = po
                      var mi: i64 = 0
                      while nm[mi] != (0 as u8) { p[po] = nm[mi]; po = po + 1; mi = mi + 1 }
                      p[po] = 0 as u8
                      let fh: i64 = ad_fnv(p, nb0, po)
                      let fd: i64 = sys_openat_rd(p)
                      if fd >= 0 {
                          var slen: i64 = 0
                          var r: i64 = sys_read(fd, src, AD_FILECAP - 1)
                          while r > 0 {
                              slen = slen + r
                              if slen >= AD_FILECAP - 1 { r = 0; truncated = truncated + 1 } else { r = sys_read(fd, ((src as i64) + slen) as *u8, AD_FILECAP - 1 - slen) }
                          }
                          sys_close(fd)
                          nfiles = nfiles + 1
                          var i: i64 = 0
                          while i + 6 < slen {
                              var bol: i64 = 0
                              if i == 0 { bol = 1 }
                              if i > 0 { if src[i-1] == (AD_NL as u8) { bol = 1 } }
                              var isfunc: i64 = 0
                              if bol == 1 {
                                  if src[i] == (AD_F as u8) { if src[i+1] == (AD_U as u8) { if src[i+2] == (AD_N as u8) { if src[i+3] == (AD_C as u8) { if src[i+4] == (AD_SP as u8) { isfunc = 1 } } } } }
                              }
                              if isfunc == 1 {
                                  let s: i64 = i + 5
                                  var e: i64 = s
                                  var run: i64 = 1
                                  while run == 1 {
                                      if e >= slen { run = 0 } else {
                                          if ad_isid(src[e] as i64) == 1 { e = e + 1 } else { run = 0 }
                                      }
                                  }
                                  if e > s {
                                      let hh: i64 = ad_fnv(src, s, e)
                                      var slot: i64 = ad_slot(hh, AD_CAP)
                                      var placed: i64 = 0
                                      var probes: i64 = 0
                                      while placed == 0 {
                                          if probes > AD_CAP { placed = 1 } else {
                                              if h_hash[slot] == 0 {
                                                  if ab + (e - s) < AD_NAMEBUF {
                                                      h_hash[slot] = hh
                                                      h_noff[slot] = ab
                                                      h_nlen[slot] = e - s
                                                      var k: i64 = 0
                                                      while k < e - s { arena[ab + k] = src[s + k]; k = k + 1 }
                                                      ab = ab + (e - s)
                                                      h_fh[slot] = fh
                                                      h_ext[slot] = 0
                                                      h_self[slot] = 0
                                                      ndef = ndef + 1
                                                  }
                                                  placed = 1
                                              } else {
                                                  if h_hash[slot] == hh { placed = 1 } else { slot = ad_next(slot, AD_CAP); probes = probes + 1 }
                                              }
                                          }
                                      }
                                  }
                                  i = e
                              } else { i = i + 1 }
                          }
                      }
                  }
                  off = off + reclen
              }
          }
      }
  }
  sys_close(fdA)
218
  var dix: i64 = 0
  var scanned: i64 = 0
  while dix < ndirs {
      let dcur: *u8 = dirs[dix] as *u8
      let fdB: i64 = sys_openat_rd(dcur)
      if fdB >= 0 {
          var goB: i64 = 1
          while goB == 1 {
              let dn: i64 = sys_getdents64(fdB, dbuf, AD_DIRBUF)
              if dn <= 0 { goB = 0 } else {
                  var off: i64 = 0
                  while off < dn {
                      let rec: *u8 = ((dbuf as i64) + off) as *u8
                      let reclen: i64 = dirent_reclen(rec)
                      if reclen <= 0 { off = dn } else {
                          let nm: *u8 = dirent_name(rec)
                          var take: i64 = 0
                          if dirent_type(rec) != 4 { if ad_ends_nx(nm) == 1 { take = 1 } }
                          if take == 1 {
                              var po: i64 = 0
                              var di: i64 = 0
                              while dcur[di] != (0 as u8) { p[po] = dcur[di]; po = po + 1; di = di + 1 }
                              p[po] = AD_SLASH as u8; po = po + 1
                              let nb0: i64 = po
                              var mi: i64 = 0
                              while nm[mi] != (0 as u8) { p[po] = nm[mi]; po = po + 1; mi = mi + 1 }
                              p[po] = 0 as u8
                              let fh: i64 = ad_fnv(p, nb0, po)
                              let fd: i64 = sys_openat_rd(p)
                              if fd >= 0 {
                                  var slen: i64 = 0
                                  var r: i64 = sys_read(fd, src, AD_FILECAP - 1)
                                  while r > 0 {
                                      slen = slen + r
                                      if slen >= AD_FILECAP - 1 { r = 0 } else { r = sys_read(fd, ((src as i64) + slen) as *u8, AD_FILECAP - 1 - slen) }
                                  }
                                  sys_close(fd)
                                  scanned = scanned + 1
                                  // is THIS caller file a proof file? computed once per file, not per identifier.
                                  let isproof: i64 = ad_is_prooffile(nm)
                                  var i: i64 = 0
                                  while i < slen {
                                      var isstart: i64 = 0
                                      if ad_id_start(src[i] as i64) == 1 {
                                          if i == 0 { isstart = 1 }
                                          if i > 0 { if ad_isid(src[i-1] as i64) == 0 { isstart = 1 } }
                                      }
                                      if isstart == 1 {
                                          var e: i64 = i
                                          var run: i64 = 1
                                          while run == 1 {
                                              if e >= slen { run = 0 } else {
                                                  if ad_isid(src[e] as i64) == 1 { e = e + 1 } else { run = 0 }
                                              }
                                          }
                                          var iscall: i64 = 0
                                          if e < slen { if src[e] == (AD_PAREN as u8) { iscall = 1 } }
                                          if iscall == 1 {
                                              let hh: i64 = ad_fnv(src, i, e)
                                              var slot: i64 = ad_slot(hh, AD_CAP)
                                              var done: i64 = 0
                                              var probes: i64 = 0
                                              while done == 0 {
                                                  if probes > AD_CAP { done = 1 } else {
                                                      if h_hash[slot] == 0 { done = 1 } else {
                                                          var hit: i64 = 0
                                                          if h_hash[slot] == hh {
                                                              if ad_name_eq(arena, h_noff[slot], h_nlen[slot], src, i, e) == 1 { hit = 1 }
                                                          }
                                                          if hit == 1 {
                                                              if h_fh[slot] == fh { h_self[slot] = h_self[slot] + 1 } else {
                                                                  h_ext[slot] = h_ext[slot] + 1
                                                                  if isproof == 1 { h_proof[slot] = h_proof[slot] + 1 }
                                                              }
                                                              done = 1
                                                          } else { slot = ad_next(slot, AD_CAP); probes = probes + 1 }
                                                      }
                                                  }
                                              }
                                          }
                                          i = e
                                      } else { i = i + 1 }
                                  }
                              }
                          }
                          off = off + reclen
                      }
                  }
              }
          }
          sys_close(fdB)
      }
      dix = dix + 1
  }
313
  var dark: i64 = 0
  var debt: i64 = 0
  var shown: i64 = 0
  rm_puts("=== nx_adopt -- ADOPTION CENSUS: primitives nobody calls (seq1410) ===\n" as *u8)
  var sl: i64 = 0
  while sl < AD_CAP {
      if h_hash[sl] != 0 {
          if ad_is_adopted(h_ext[sl]) == 0 {
              dark = dark + 1
              // Only PUBLIC-surface names are printed: those are the actionable set (seq1436). A dark
              // module-local helper is CORRECT DESIGN, and listing it would drown the real debt.
              if ad_is_debt(h_ext[sl], ad_is_public(arena, h_noff[sl], h_nlen[sl])) == 1 {
                  debt = debt + 1
              if shown < AD_MAXREPORT {
                  rm_puts("  DEBT " as *u8)
                  var k: i64 = 0
                  while k < h_nlen[sl] { sys_write(1, ((arena as i64) + h_noff[sl] + k) as *u8, 1); k = k + 1 }
                  rm_puts(" self_refs=" as *u8); rm_num(h_self[sl])
                  rm_puts(" external=0\n" as *u8)
                  shown = shown + 1
              }
              }
          }
      }
      sl = sl + 1
  }
  // ---- PROVEN_UNWIRED: gates call it, production does not -------------------------------------
  // STRICTLY WORSE THAN AN UNCALLED PRIMITIVE: someone paid to BUILD it AND to PROVE it, and it
  // protects nothing. Invisible to the DEBT verdict above because external>0 (the gate IS external).
  // A GATE PROVES A CAPABILITY WORKS; ONLY A PRODUCTION CALLER PROVES IT RUNS.
  var unwired: i64 = 0
  var ushown: i64 = 0
  rm_puts("--- PROVEN_UNWIRED: gate-proven, ZERO production callers ---\n" as *u8)
  var ul: i64 = 0
  while ul < AD_CAP {
      if h_hash[ul] != 0 {
          if h_proof[ul] > 0 {
              if h_ext[ul] - h_proof[ul] == 0 {
                  if ad_is_public(arena, h_noff[ul], h_nlen[ul]) == 1 {
                      unwired = unwired + 1
                      if ushown < AD_MAXREPORT {
                          rm_puts("  UNWIRED " as *u8)
                          var uk: i64 = 0
                          while uk < h_nlen[ul] { sys_write(1, ((arena as i64) + h_noff[ul] + uk) as *u8, 1); uk = uk + 1 }
                          rm_puts(" proof_callers=" as *u8); rm_num(h_proof[ul])
                          rm_puts(" production_callers=0 self_refs=" as *u8); rm_num(h_self[ul])
                          rm_puts("\n" as *u8)
                          ushown = ushown + 1
                      }
                  }
              }
          }
      }
      ul = ul + 1
  }
  // Restore the caller's stdout so the SUMMARY is delivered to whoever asked, not buried in the report.
  if ad_savefd >= 0 { sys_dup3(ad_savefd, 1, 0) }
  rm_puts("NX-ADOPT defs=" as *u8); rm_num(ndef)
  rm_puts(" def_files=" as *u8); rm_num(nfiles)
  rm_puts(" scanned_files=" as *u8); rm_num(scanned)
  rm_puts(" DARK_total=" as *u8); rm_num(dark)
  rm_puts(" DEBT_public=" as *u8); rm_num(debt)
  rm_puts(" shown=" as *u8); rm_num(shown)
  rm_puts(" PROVEN_UNWIRED=" as *u8); rm_num(unwired)
  rm_puts(" oversize_files=" as *u8); rm_num(truncated)
  rm_puts("\n" as *u8)
  rm_puts("COVERAGE: FLAT dirs only (no recursion); a name defined twice counts once; DARK = ZERO\n" as *u8)
  rm_puts("external callers -- self-references excluded BY DESIGN (that is the nx_hw_cpu_count trap).\n" as *u8)
  // THE ADOPTION AXIS, DERIVED HERE so no consumer has to re-run a 17k-file scan to learn one number.
  // adoption_permil = defs that SOMEONE ELSE calls / all defs. It is the live source for the ADOPTION
  // axis of nx_capaxes, and by construction it can only LOWER a capability headline, never raise it.
  var adopt_permil: i64 = 0
  if ndef > 0 { adopt_permil = (ndef - dark) * 1000 / ndef }
  rm_puts("ADOPTION_PERMIL=" as *u8); rm_num(adopt_permil)
  rm_puts(" = externally-called defs / total defs -- the ADOPTION axis for nx_capaxes.\n" as *u8)
  let sfd: i64 = sys_openat_wr(AD_STAMP, 420)
  if sfd >= 0 {
      var back: i64 = 0 - 1
      if sys_dup3(1, AD_STAMPFD, 0) >= 0 { back = AD_STAMPFD }
      sys_dup3(sfd, 1, 0)
      rm_puts("NX-ADOPT-STAMP defs=" as *u8); rm_num(ndef)
      rm_puts(" dark=" as *u8); rm_num(dark)
      rm_puts(" debt_public=" as *u8); rm_num(debt)
      rm_puts(" proven_unwired=" as *u8); rm_num(unwired)
      rm_puts(" adoption_permil=" as *u8); rm_num(adopt_permil)
      rm_puts("\n" as *u8)
      if back >= 0 { sys_dup3(back, 1, 0) }
  }
  if ad_savefd >= 0 {
      rm_puts("REPORT: the full DEBT + PROVEN_UNWIRED rows went to argv[3] -- read it with nx_fs.\n" as *u8)
      rm_puts("  PROVEN_UNWIRED is the one that matters: gate-proven capability with ZERO production\n" as *u8)
      rm_puts("  callers -- BUILT and GATED and never called, which scores as done and behaves as absent.\n" as *u8)
  }
  return 0
408}
nx_adopt.nx source

`nx_adopt.nx` source
