`nx_minecov.nx` source

↩ module page · 325 lines · 14518 B
1// nx_minecov.nx -- MINER CLASS-COVERAGE CENSUS (miner-sota F969/MS06, 2026-07-23).
2// The operator's "features and bugs and capabilities and harnesses and workflows and agents" clause,
3// MECHANIZED: a data-driven class table (knowledge/status/minecov_classes.conf, hot-read, rule-11
4// tunable) declares every artifact class we want brought inside; the census VERIFIES each row by
5// actually READING its source (journal lines, or a seg-store plane loaded through the ALLOWLIST-
6// RESOLVED loader) and reports TWO gauges: coverage (a reader exists AND evidence exists) and mined
7// (that reader actually mines patterns rather than merely listing/deriving). A class can never be
8// "covered" by declaration alone -- no evidence, no credit; and no reader, no credit. The GAP list
9// IS the build queue. Composes nx_sovjson_lib (sj_*). Read-only. No hw writes (Rule 26).
10//   census <classconf> [loader]  -> JSON per-class rows + coverage_permil/mined_permil + gaps
11//   selftest <scratch-prefix>    -> gate T1..T8 (unique per-run scratch)
12// conf cols: id TAB class TAB kind(jrnl|plane|none) TAB source TAB reader(- = none) TAB mined(0|1) TAB note
13// license_tier: ORIGINAL
14import "nx_sovjson_lib.nx"
15import "nx_syscalls.nx"
16import "nx_gate_verdict.nx"
17import "nx_tool_run.nx"
18
19const MC_CONF: i64 = 65536
20const MC_CAP: i64 = 4194304
21const MC_OUT: i64 = 65536
22const MC_PATH: i64 = 512
23const MC_ROWS: i64 = 64
24const MC_MODE_644: i64 = 420
25const MC_PERMIL: i64 = 1000
26const MC_ALLOW_BUF: i64 = 131072
27const MC_NOTE_MAX: i64 = 160
28
29func mc_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return -1 }
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 { let r: i64 = sys_read(fd, ((buf as i64)+n) as *u8, cap-n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap { go = 0 } }
  sys_close(fd)
  return n
37}
38func mc_find(q: *u8, n: i64, lit: *u8) -> i64 {
  let ll: i64 = sj_vlen(lit)
  if ll == 0 { return 0 }
  var i: i64 = 0
  while i + ll <= n {
      var k: i64 = 0
      var ok: i64 = 1
      while k < ll { if q[i+k] != lit[k] { ok = 0; k = ll } else { k = k + 1 } }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
50}
51// count non-empty, non-comment lines (the honest row count for journals AND plane dumps)
52func mc_count_lines(q: *u8, n: i64) -> i64 {
  var c: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(q, i, n)
      if le > i { if q[i] != (35 as u8) { c = c + 1 } }
      i = le + 1
  }
  return c
61}
62// ⚠rule-15: this allowlist resolver is now the THIRD inline copy (nx_actlog al_allow_path,
63// nx_claude_harvest ch_allow_path). Extraction onto nx_sovjson_lib is filed to the local-maker
64// dedup queue (dedupq-) per the engine-shift doctrine -- NOT hand-migrated mid-round.
65// DELEGATES to the shared base (rule-15 extraction 2026-07-23) -- was the 3rd of 7 inline copies
66func mc_allow_path(name: *u8, outp: *u8) -> i64 { return sj_allow_path(name, outp) }
67func mc_key(d: *u8, o: i64, name: *u8) -> i64 {
  d[o] = 34 as u8
  var p: i64 = o + 1
  p = sj_cat(d, p, name)
  d[p] = 34 as u8
  p = p + 1
  d[p] = 58 as u8
  p = p + 1
  return p
76}
77func mc_qspan(d: *u8, o: i64, q: *u8, s: i64, e: i64, maxb: i64) -> i64 {
  var p: i64 = o
  d[p] = 34 as u8; p = p + 1
  p = sj_cat_esc(d, p, q, s, e, maxb)
  d[p] = 34 as u8; p = p + 1
  return p
83}
84// evaluate one class source -> rows seen. tcx[0]=truncated tcx[1]=kind_ok
85func mc_source_rows(cq: *u8, ks: i64, ke: i64, src: *u8, lp: *u8, lok: i64, tcx: *i64) -> i64 {
  tcx[0] = 0
  tcx[1] = 1
  if sj_lit_eq(cq, ks, ke, "jrnl" as *u8) == 1 {
      let b: *u8 = sys_mmap(MC_CAP)
      let n: i64 = mc_read(src, b, MC_CAP - 8)
      if n <= 0 { return 0 }
      if n >= MC_CAP - 8 { tcx[0] = 1 }
      return mc_count_lines(b, n)
  }
  if sj_lit_eq(cq, ks, ke, "plane" as *u8) == 1 {
      if lok == 0 { tcx[1] = 0; return 0 }
      let av: *i64 = sys_mmap(64) as *i64
      av[0] = lp as i64
      av[1] = src as i64
      av[2] = "load" as *u8 as i64
      av[3] = 0
      let cout: *u8 = sys_mmap(MC_CAP)
      let cl: *i64 = sys_mmap(16) as *i64
      let ex: i64 = tr_run_capture(lp, av, cout, MC_CAP - 8, cl)
      if ex != 0 { return 0 }
      if cl[0] >= MC_CAP - 8 { tcx[0] = 1 }
      return mc_count_lines(cout, cl[0])
  }
  if sj_lit_eq(cq, ks, ke, "none" as *u8) == 1 { return 0 }
  tcx[1] = 0
  return 0
112}
113// the census. returns emitted bytes, or -1 when the class table is missing/empty (fail closed).
114func mc_census(conf: *u8, loader: *u8, d: *u8) -> i64 {
  let cb: *u8 = sys_mmap(MC_CONF)
  let cn: i64 = mc_read(conf, cb, MC_CONF - 8)
  if cn <= 0 { return -1 }
  let lp: *u8 = sys_mmap(MC_PATH)
  let lok: i64 = mc_allow_path(loader, lp)
  let sp: *i64 = sys_mmap(16) as *i64
  let srcb: *u8 = sys_mmap(MC_PATH)
  let tcx: *i64 = sys_mmap(16) as *i64
  var p: i64 = 0
  d[p] = 123 as u8; p = p + 1
  p = mc_key(d, p, "v" as *u8); p = sj_catn(d, p, 1); d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "tool" as *u8)
  d[p] = 34 as u8; p = p + 1
  p = sj_cat(d, p, "nx_minecov" as *u8)
  d[p] = 34 as u8; p = p + 1
  d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "averb" as *u8)
  d[p] = 34 as u8; p = p + 1
  p = sj_cat(d, p, "census" as *u8)
  d[p] = 34 as u8; p = p + 1
  d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "conf" as *u8)
  p = mc_qspan(d, p, conf, 0, sj_vlen(conf), MC_NOTE_MAX)
  d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "loader_resolved" as *u8); p = sj_catn(d, p, lok); d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "classes_rows" as *u8)
  d[p] = 91 as u8; p = p + 1
  var classes: i64 = 0
  var covered: i64 = 0
  var minedn: i64 = 0
  var kunk: i64 = 0
  var shown: i64 = 0
  var rcapped: i64 = 0
  var efirst: i64 = 1
  var i: i64 = 0
  while i < cn {
      let le: i64 = sj_le(cb, i, cn)
      var ok: i64 = 0
      if le > i { if cb[i] != (35 as u8) { if sj_col(cb, i, le, 5, sp) == 1 { ok = 1 } } }
      if ok == 1 {
          classes = classes + 1
          sj_col(cb, i, le, 3, sp)
          var k: i64 = 0
          while sp[0]+k < sp[1] { if k < MC_PATH - 2 { srcb[k] = cb[sp[0]+k] } k = k + 1 }
          srcb[k] = 0 as u8
          let kst: *i64 = sys_mmap(16) as *i64
          sj_col(cb, i, le, 2, kst)
          let rows: i64 = mc_source_rows(cb, kst[0], kst[1], srcb, lp, lok, tcx)
          if tcx[1] == 0 { kunk = kunk + 1 }
          sj_col(cb, i, le, 4, sp)
          var hasreader: i64 = 1
          if sj_lit_eq(cb, sp[0], sp[1], "-" as *u8) == 1 { hasreader = 0 }
          let rs: i64 = sp[0]
          let re: i64 = sp[1]
          var cov: i64 = 0
          if hasreader == 1 { if rows > 0 { cov = 1 } }
          let mst: *i64 = sys_mmap(16) as *i64
          sj_col(cb, i, le, 5, mst)
          let mdecl: i64 = sj_atoi_span(cb, mst[0], mst[1])
          var mnd: i64 = 0
          if cov == 1 { if mdecl == 1 { mnd = 1 } }
          covered = covered + cov
          minedn = minedn + mnd
          if shown >= MC_ROWS { rcapped = 1 } else {
              if efirst == 0 { d[p] = 44 as u8; p = p + 1 }
              efirst = 0
              d[p] = 123 as u8; p = p + 1
              p = mc_key(d, p, "id" as *u8)
              sj_col(cb, i, le, 0, sp)
              p = mc_qspan(d, p, cb, sp[0], sp[1], MC_NOTE_MAX)
              d[p] = 44 as u8; p = p + 1
              p = mc_key(d, p, "covered" as *u8); p = sj_catn(d, p, cov); d[p] = 44 as u8; p = p + 1
              p = mc_key(d, p, "mined" as *u8); p = sj_catn(d, p, mnd); d[p] = 44 as u8; p = p + 1
              p = mc_key(d, p, "rows" as *u8); p = sj_catn(d, p, rows); d[p] = 44 as u8; p = p + 1
              p = mc_key(d, p, "truncated" as *u8); p = sj_catn(d, p, tcx[0]); d[p] = 44 as u8; p = p + 1
              p = mc_key(d, p, "kind_ok" as *u8); p = sj_catn(d, p, tcx[1]); d[p] = 44 as u8; p = p + 1
              p = mc_key(d, p, "class" as *u8)
              sj_col(cb, i, le, 1, sp)
              p = mc_qspan(d, p, cb, sp[0], sp[1], MC_NOTE_MAX)
              d[p] = 44 as u8; p = p + 1
              p = mc_key(d, p, "reader" as *u8)
              p = mc_qspan(d, p, cb, rs, re, MC_NOTE_MAX)
              d[p] = 125 as u8; p = p + 1
              shown = shown + 1
          }
      }
      i = le + 1
  }
  d[p] = 93 as u8; p = p + 1
  d[p] = 44 as u8; p = p + 1
  var cperm: i64 = 0 - 1
  var mperm: i64 = 0 - 1
  if classes > 0 { cperm = covered * MC_PERMIL / classes; mperm = minedn * MC_PERMIL / classes }
  p = mc_key(d, p, "classes" as *u8); p = sj_catn(d, p, classes); d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "covered" as *u8); p = sj_catn(d, p, covered); d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "mined" as *u8); p = sj_catn(d, p, minedn); d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "coverage_permil" as *u8); p = sj_catn(d, p, cperm); d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "mined_permil" as *u8); p = sj_catn(d, p, mperm); d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "kind_unknown" as *u8); p = sj_catn(d, p, kunk); d[p] = 44 as u8; p = p + 1
  p = mc_key(d, p, "rows_capped" as *u8); p = sj_catn(d, p, rcapped)
  d[p] = 125 as u8; p = p + 1
  d[p] = 10 as u8; p = p + 1
  return p
218}
219func mc_selftest(prefix: *u8) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_minecov selftest -- class-coverage census teeth (evidence-or-no-credit)" as *u8)
  let now: i64 = sys_now_realtime_sec()
  let j1: *u8 = sys_mmap(MC_PATH)
  var o: i64 = sj_cat(j1, 0, prefix)
  o = sj_catn(j1, o, now)
  o = sj_cat(j1, o, ".j1" as *u8)
  j1[o] = 0 as u8
  let miss: *u8 = sys_mmap(MC_PATH)
  o = sj_cat(miss, 0, prefix)
  o = sj_catn(miss, o, now)
  o = sj_cat(miss, o, ".absent" as *u8)
  miss[o] = 0 as u8
  let cf: *u8 = sys_mmap(MC_PATH)
  o = sj_cat(cf, 0, prefix)
  o = sj_catn(cf, o, now)
  o = sj_cat(cf, o, ".conf" as *u8)
  cf[o] = 0 as u8
  // j1 = 3 evidence lines
  let jfd: i64 = sys_openat_append(j1, MC_MODE_644)
  let lb: *u8 = sys_mmap(MC_PATH)
  var lo: i64 = sj_cat(lb, 0, "e1\ne2\ne3\n" as *u8)
  sys_write(jfd, lb, lo)
  sys_close(jfd)
  // fixture class table: F1 both / F2 reader-no-evidence / F3 evidence-no-reader / F4 bad kind / F5 covered-not-mined
  let cfd: i64 = sys_openat_wr(cf, MC_MODE_644)
  lo = sj_cat(lb, 0, "# fixture\n" as *u8)
  sys_write(cfd, lb, lo)
  lo = sj_cat(lb, 0, "F1\talpha\tjrnl\t" as *u8)
  lo = sj_cat(lb, lo, j1)
  lo = sj_cat(lb, lo, "\treader:x\t1\tboth\n" as *u8)
  sys_write(cfd, lb, lo)
  lo = sj_cat(lb, 0, "F2\tbeta\tjrnl\t" as *u8)
  lo = sj_cat(lb, lo, miss)
  lo = sj_cat(lb, lo, "\treader:y\t1\tdeclared reader no evidence\n" as *u8)
  sys_write(cfd, lb, lo)
  lo = sj_cat(lb, 0, "F3\tgamma\tjrnl\t" as *u8)
  lo = sj_cat(lb, lo, j1)
  lo = sj_cat(lb, lo, "\t-\t0\tevidence no reader\n" as *u8)
  sys_write(cfd, lb, lo)
  lo = sj_cat(lb, 0, "F4\tdelta\tbogus\t" as *u8)
  lo = sj_cat(lb, lo, j1)
  lo = sj_cat(lb, lo, "\treader:z\t1\tunknown kind\n" as *u8)
  sys_write(cfd, lb, lo)
  lo = sj_cat(lb, 0, "F5\teps\tjrnl\t" as *u8)
  lo = sj_cat(lb, lo, j1)
  lo = sj_cat(lb, lo, "\treader:w\t0\tcovered not mined\n" as *u8)
  sys_write(cfd, lb, lo)
  sys_close(cfd)
  let d: *u8 = sys_mmap(MC_OUT)
  // T1 missing class table fails closed
  let r1: i64 = mc_census(miss, "nx_store_put" as *u8, d)
  var ok1: i64 = 0
  if r1 == (0 - 1) { ok1 = 1 }
  gv_check("T1 missing class table refused (-1) fail closed" as *u8, ok1, ctr)
  let dl: i64 = mc_census(cf, "nx_store_put" as *u8, d)
  var ok2: i64 = 0
  if dl > 0 { if mc_find(d, dl, "\"classes\":5" as *u8) == 1 { ok2 = 1 } }
  gv_check("T2 counts exactly the 5 declared classes (comment skipped)" as *u8, ok2, ctr)
  var ok3: i64 = 0
  if mc_find(d, dl, "\"id\":\"F2\",\"covered\":0,\"mined\":0,\"rows\":0" as *u8) == 1 { ok3 = 1 }
  gv_check("T3 declared reader with NO evidence earns no credit" as *u8, ok3, ctr)
  var ok4: i64 = 0
  if mc_find(d, dl, "\"id\":\"F3\",\"covered\":0,\"mined\":0,\"rows\":3" as *u8) == 1 { ok4 = 1 }
  gv_check("T4 evidence with NO reader is a GAP not silent coverage" as *u8, ok4, ctr)
  var ok5: i64 = 0
  if mc_find(d, dl, "\"id\":\"F1\",\"covered\":1,\"mined\":1,\"rows\":3" as *u8) == 1 { ok5 = 1 }
  gv_check("T5 reader plus evidence counts covered and mined" as *u8, ok5, ctr)
  var ok6: i64 = 0
  if mc_find(d, dl, "\"coverage_permil\":400" as *u8) == 1 { ok6 = 1 }
  gv_check("T6 coverage_permil exact 400 (2 of 5)" as *u8, ok6, ctr)
  var ok7: i64 = 0
  if mc_find(d, dl, "\"mined_permil\":200" as *u8) == 1 { if mc_find(d, dl, "\"id\":\"F5\",\"covered\":1,\"mined\":0" as *u8) == 1 { ok7 = 1 } }
  gv_check("T7 mined is DISTINCT from covered (200 permil; F5 read but not mined)" as *u8, ok7, ctr)
  var ok8: i64 = 0
  if mc_find(d, dl, "\"id\":\"F4\",\"covered\":0,\"mined\":0,\"rows\":0,\"truncated\":0,\"kind_ok\":0" as *u8) == 1 { if mc_find(d, dl, "\"kind_unknown\":1" as *u8) == 1 { ok8 = 1 } }
  gv_check("T8 unknown source kind flagged, never fabricated as covered" as *u8, ok8, ctr)
  let rc: i64 = gv_verdict("MINECOV-GATE" as *u8, ctr, "class-coverage census: evidence-or-no-credit, reader-or-no-credit, mined distinct from covered" as *u8)
  return rc
299}
300
301func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { sj_puts("usage: nx_minecov {census <classconf> [loader] | selftest <scratch-prefix>}\n" as *u8); sys_exit(2); return 2 }
  let verb: *u8 = argv[1] as *u8
  let vl: i64 = sj_vlen(verb)
  if sj_lit_eq(verb, 0, vl, "selftest" as *u8) == 1 {
      let rc: i64 = mc_selftest(argv[2] as *u8)
      sys_exit(rc)
      return rc
  }
  if sj_lit_eq(verb, 0, vl, "census" as *u8) == 1 {
      let loader: *u8 = sys_mmap(128)
      var lo2: i64 = 0
      if argc >= 4 { lo2 = sj_cat(loader, 0, argv[3] as *u8) } else { lo2 = sj_cat(loader, 0, "nx_store_put" as *u8) }
      loader[lo2] = 0 as u8
      let d: *u8 = sys_mmap(MC_OUT)
      let dl: i64 = mc_census(argv[2] as *u8, loader, d)
      if dl < 0 { sj_puts("REFUSED class table missing or empty\n" as *u8); sys_exit(3); return 3 }
      sys_write(1, d, dl)
      sys_exit(0)
      return 0
  }
  sj_puts("unknown verb\n" as *u8)
  sys_exit(2)
  return 2
325}
nx_minecov.nx source

`nx_minecov.nx` source
