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

↩ module page · 748 lines · 35495 B
1// nx_novel_close.nx -- the INDEPENDENT REFEREE that CLOSES genuinely-built NOVEL
2// queue rows that nx_reconcile refuses to touch (NOVEL is never auto-flipped by
3// design: novel work is judged after the visit).  A NOVEL row whose deliverable is
4// really built+gated cannot otherwise close, so its dependents stay FLOATING in
5// nx_capability_ladder.
6//
7// This organ adjudicates each candidate MECHANICALLY -- it does NOT trust the row's
8// stored ||MARK.  Referee check per candidate (an auto_builder-emitted deliverable):
9//   DELETE the deliverable .nx + _test.nx  ->  re-run nx_auto_builder from its
10//   build-spec  ->  assert ALL of: (a) BOTH files RE-EMITTED, (b) builder exit==0
11//   AND stdout carries the candidate's green marker "AUTO-BUILD GREEN: <name>
12//   shape=<N> KAT green", (c) line 1 of the re-emitted primary .nx carries
13//   "AUTHORED BY THE NISHI BUILDER" (proves author=organ, not a hand-written
14//   false-green).  Only ALL-PASS closes the row.  A stale/hand-written deliverable
15//   cannot survive deletion -> strongest no-false-green probe.  The organ is NOT the
16//   builder, so there is NO self-grade: it re-runs the team's own auto_builder and
17//   reads the verdict.
18//
19// NOVEL is 5 bytes, DONE is 4 -> closing SHRINKS the line by 1 byte, so this is a
20// LENGTH-CHANGING line REWRITE (reconcile only does same-length 4-byte in-place
21// patches).  We read the whole file, and for a referee-PASSED candidate row scoped
22// by (field1==id AND field6=="NOVEL") emit the prefix, write "DONE", then the rest
23// from after "NOVEL" (skip 5 src bytes, write 4).  NEVER global-replace "NOVEL"
24// (other rows' descriptions contain it); field6 is located by tab position.
25//
26// BAKED SELF-TEST runs FIRST on a SCRATCH scenario (control_pos via the proven erf
27// pipeline MUST close; control_neg via a non-existent spec MUST NOT close); any
28// mismatch -> print RED + nonzero exit, real queue UNTOUCHED.  Proves it cannot
29// false-close (sibling of nx_capability_ladder / nx_epic_rollup baked controls).
30//
31//   argv[1] = queue-path override (scratch queue for dry-run; no side effects
32//             beyond that named file -- like reconcile's is_live guard).  No-arg =>
33//             LIVE: operates on knowledge/registry/assignment_queue.tsv (the only
34//             run that writes the real queue) and writes a .bak first.
35//
36// SOVEREIGN ONLY (nx_cc->nxasm, no gcc/python/qemu).  Additive/history-sacred: the
37// log is append-only; referee deletions are repaired by the re-emit (verified) or
38// restored from backup on FAIL.  The referee execs /tmp/nx_auto_builder.sov.elf, so
39// the wrapper must build nx_auto_builder into /tmp in the SAME shell session.
40// license_tier: ORIGINAL
41//
42// module: nishi-core.autonomy.novel_close
43// depends: nishi-core.sys.syscalls
44// capability: NO_FLOAT_NOVEL_CLOSE_REFEREE
45import "nx_registry_lock.nx"   // lib-only (pulls nx_syscalls transitively); gives rt_lock/rt_unlock + the SHARED queue lock
46import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
47const Q_MAGIC_262144: i64 = 262144
48const Q_MAGIC_65536: i64 = 65536
49const Q_MAGIC_4096: i64 = 4096
50
51const Q_CAP: i64 = 1048576
52const MAXCAND: i64 = 64
53
54func nc_w(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
55// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
56// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
57// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
58// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
59func nc_wn(fd: i64, v: i64) -> i64 { nxi_fd(fd, v); return 0 }
60func nc_len(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
61
62// unlinkat(AT_FDCWD, path, 0) -- x86_64 raw 263 passes through (fsync/74 precedent).
63func nc_unlink(path: *u8) -> i64 { return __syscall(263, AT_FDCWD, path, 0, 0, 0, 0) }
64
65func nc_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  var n: i64 = 0
  var r: i64 = sys_read(fd, buf, cap - 1)
  while r > 0 { n = n + r; if n >= cap - 1 { r = 0 } else { r = sys_read(fd, buf + n, cap - 1 - n) } }
  sys_close(fd)
  return n
73}
74
75func nc_exists(path: *u8) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  sys_close(fd)
  return 1
80}
81
82func nc_write_all(fd: i64, buf: *u8, len: i64) -> i64 {
  var off: i64 = 0
  while off < len { let w: i64 = sys_write(fd, buf + off, len - off); if w <= 0 { off = len } else { off = off + w } }
  return 0
86}
87
88// copy src -> dst (whole file). 1 ok / 0 fail.
89func nc_copy(src: *u8, dst: *u8) -> i64 {
  let buf: *u8 = sys_mmap(Q_CAP)
  let rf: i64 = sys_openat_rd(src)
  if rf < 0 { return 0 }
  var n: i64 = 0
  var r: i64 = sys_read(rf, buf, Q_CAP - 1)
  while r > 0 { n = n + r; if n >= Q_CAP - 1 { r = 0 } else { r = sys_read(rf, buf + n, Q_CAP - 1 - n) } }
  sys_close(rf)
  let wf: i64 = sys_openat_wr(dst, 0x1a4)
  if wf < 0 { return 0 }
  nc_write_all(wf, buf, n)
  sys_close(wf)
  return 1
102}
103
104// substring search in buf[0,n)
105func nc_contains(buf: *u8, n: i64, needle: *u8) -> i64 {
  let nl: i64 = nc_len(needle)
  if nl == 0 { return 1 }
  var i: i64 = 0
  while i + nl <= n {
      var k: i64 = 0
      var ok: i64 = 1
      while k < nl { if buf[i+k] != needle[k] { ok = 0; k = nl } else { k = k + 1 } }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
117}
118
119// exact byte-match of pat (len pl) at buf+i
120func nc_at(buf: *u8, n: i64, i: i64, pat: *u8, pl: i64) -> i64 {
  if i + pl > n { return 0 }
  var k: i64 = 0
  while k < pl { if buf[i+k] != pat[k] { return 0 } k = k + 1 }
  return 1
125}
126
127// concat s into dst at off (null-terminates); returns new off
128func nc_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var o: i64 = off; var i: i64 = 0
  while s[i] != (0 as u8) { dst[o] = s[i]; o = o + 1; i = i + 1 }
  dst[o] = 0 as u8
  return o
133}
134func nc_path_d(dst: *u8, name: *u8) -> i64 {
  var o: i64 = nc_cat(dst, 0, "runtime/_hdl_build/" as *u8); o = nc_cat(dst, o, name); o = nc_cat(dst, o, ".nx" as *u8); return o
136}
137func nc_path_t(dst: *u8, name: *u8) -> i64 {
  var o: i64 = nc_cat(dst, 0, "runtime/_hdl_build/" as *u8); o = nc_cat(dst, o, name); o = nc_cat(dst, o, "_test.nx" as *u8); return o
139}
140
141// REFEREE RE-VERIFY: delete D+T -> exec /tmp/nx_auto_builder.sov.elf <spec>
142// (stdout -> /tmp/_nc_ab_out.log, stderr silenced) -> assert (a) BOTH re-emitted,
143// (b) exit==0 AND green marker in stdout, (c) AUTHORED-BY header on D line1.
144// Returns 1 PASS / 0 FAIL.  On FAIL restores D+T from backup so a transient builder
145// failure never leaves a real capability deleted (additive / history-sacred).
146func nc_referee(name: *u8, spec: *u8, green: *u8) -> i64 {
  let dpath: *u8 = sys_mmap(512); nc_path_d(dpath, name)
  let tpath: *u8 = sys_mmap(512); nc_path_t(tpath, name)
  let dbak: *u8 = "/tmp/_nc_d.bak" as *u8
  let tbak: *u8 = "/tmp/_nc_t.bak" as *u8
  let had_d: i64 = nc_exists(dpath); if had_d == 1 { nc_copy(dpath, dbak) }
  let had_t: i64 = nc_exists(tpath); if had_t == 1 { nc_copy(tpath, tbak) }
  // no-false-green probe: DELETE both deliverables
  nc_unlink(dpath)
  nc_unlink(tpath)
  // re-run the team's auto_builder, stdout -> outlog, stderr -> /dev/null
  let outlog: *u8 = "/tmp/_nc_ab_out.log" as *u8
  let pid: i64 = sys_fork()
  if pid == 0 {
      let of: i64 = sys_openat_wr(outlog, 0x1a4)
      if of >= 0 { sys_dup3(of, 1, 0) }
      let dn: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
      if dn >= 0 { sys_dup3(dn, 2, 0) }
      let lane: *u8 = "/tmp/nx_auto_builder.sov.elf" as *u8
      let argv: *i64 = sys_mmap(32) as *i64
      argv[0] = lane as i64
      argv[1] = spec as i64
      argv[2] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve(lane, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  let ec: i64 = wait_exit_code(st[0])
  // (a) BOTH re-emitted
  let re_d: i64 = nc_exists(dpath)
  let re_t: i64 = nc_exists(tpath)
  // (b) green marker in builder stdout
  let outbuf: *u8 = sys_mmap(Q_MAGIC_262144)
  let on: i64 = nc_read(outlog, outbuf, Q_MAGIC_262144)
  let has_green: i64 = nc_contains(outbuf, on, green)
  // (c) AUTHORED-BY header on line 1 of re-emitted D
  var has_hdr: i64 = 0
  if re_d == 1 {
      let dbuf: *u8 = sys_mmap(Q_MAGIC_262144)
      let dn2: i64 = nc_read(dpath, dbuf, Q_MAGIC_262144)
      // line-1 length = bytes up to the first '\n' (the header must be on line 1).
      var l1: i64 = 0
      var nl: i64 = dn2
      var s: i64 = 0
      while s < dn2 { if dbuf[s] == (10 as u8) { nl = s; s = dn2 } else { s = s + 1 } }
      l1 = nl
      has_hdr = nc_contains(dbuf, l1, "AUTHORED BY THE NISHI BUILDER" as *u8)
  }
  var pass: i64 = 0
  if re_d == 1 { if re_t == 1 { if ec == 0 { if has_green == 1 { if has_hdr == 1 { pass = 1 } } } } }
  if pass == 0 {
      if had_d == 1 { nc_copy(dbak, dpath) }
      if had_t == 1 { nc_copy(tbak, tpath) }
  }
  return pass
204}
205
206// RUN-referee (for a NOVEL row whose deliverable is NOT auto_builder-emitted -- e.g. a
207// re-instrumented measurement organ like nx_cms_wp_scorecard). REBUILD+RUN the organ via
208// ./_offc/nx_sov_build_run.elf (independent: the closer is not the organ's author, and it
209// rebuilds from source + runs fresh -- no trust of stored state), capture stdout, and assert
210// BOTH the candidate's green substring AND "run-exit=0" appear. Returns 1 PASS / 0 FAIL.
211// No deletion/restore needed (it does not mutate the deliverable; it rebuilds it).
212func nc_referee_run(organ: *u8, green: *u8) -> i64 {
  let outlog: *u8 = "/tmp/_nc_run_out.log" as *u8
  let pid: i64 = sys_fork()
  if pid == 0 {
      let of: i64 = sys_openat_wr(outlog, 0x1a4)
      if of >= 0 { sys_dup3(of, 1, 0) }
      let dn: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
      if dn >= 0 { sys_dup3(dn, 2, 0) }
      let lane: *u8 = "./_offc/nx_sov_build_run.elf" as *u8
      let argv: *i64 = sys_mmap(32) as *i64
      argv[0] = lane as i64
      argv[1] = organ as i64
      argv[2] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve(lane, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  let outbuf: *u8 = sys_mmap(Q_MAGIC_262144)
  let on: i64 = nc_read(outlog, outbuf, Q_MAGIC_262144)
  var pass: i64 = 0
  if nc_contains(outbuf, on, green) == 1 {
      if nc_contains(outbuf, on, "run-exit=0" as *u8) == 1 { pass = 1 }
  }
  return pass
239}
240
241// ---- helpers for the DEPS-DONE referee ----
242// exact equality of the field starting at fstart (bounded by next tab or line_end) to s[0,sl).
243func nc_field_eq(buf: *u8, fstart: i64, line_end: i64, s: *u8, sl: i64) -> i64 {
  var fend: i64 = fstart
  var d: i64 = 0
  while d == 0 {
      if fend >= line_end { d = 1 } else { if buf[fend] == (9 as u8) { d = 1 } else { fend = fend + 1 } }
  }
  if fend - fstart != sl { return 0 }
  var k: i64 = 0
  while k < sl { if buf[fstart+k] != s[k] { return 0 } k = k + 1 }
  return 1
253}
254
255// does the dep field [dep_off, next-tab-or-line_end) contain id as a whole SPACE-separated
256// token?  Handles single-dep (token == whole field) AND multi-dep ("A B C"); token-bounded so
257// "R4-H2-001" never substring-matches "R4-H2-0011" (the no-false-close guard for this referee).
258func nc_dep_has_token(buf: *u8, dep_off: i64, line_end: i64, id: *u8, idl: i64) -> i64 {
  var dep_end: i64 = dep_off
  var d: i64 = 0
  while d == 0 {
      if dep_end >= line_end { d = 1 } else { if buf[dep_end] == (9 as u8) { d = 1 } else { dep_end = dep_end + 1 } }
  }
  var ts: i64 = dep_off
  var p: i64 = dep_off
  var found: i64 = 0
  while p <= dep_end {
      var sep: i64 = 0
      if p == dep_end { sep = 1 } else { if buf[p] == (32 as u8) { sep = 1 } }
      if sep == 1 {
          if p - ts == idl {
              var k: i64 = 0
              var eq: i64 = 1
              while k < idl { if buf[ts+k] != id[k] { eq = 0; k = idl } else { k = k + 1 } }
              if eq == 1 { found = 1 }
          }
          ts = p + 1
      }
      p = p + 1
  }
  return found
282}
283
284// DEPS-DONE referee: for a SPEC/umbrella NOVEL row with NO code deliverable (e.g. the HTTP/2
285// ladder spec R4-H2-001).  The spec is "realized" exactly when EVERY queue row that names it
286// as a dep (field7) is DONE (field6).  Mechanical: the closer SCANS the live queue and runs
287// NOTHING -- no organ, no self-grade.  Requires >=1 child (never vacuously closes a childless
288// row).  Returns 1 PASS (>=1 child, ALL DONE) / 0 FAIL.  Reusable rule-11 for any umbrella/spec
289// row -> serves the no-float + anti-Frankenstein (X-GEN-005) law.
290func nc_referee_deps(id: *u8, qpath: *u8) -> i64 {
  let buf: *u8 = sys_mmap(Q_CAP)
  let n: i64 = nc_read(qpath, buf, Q_CAP)
  if n <= 0 { return 0 }
  let idl: i64 = nc_len(id)
  var children: i64 = 0
  var not_done: i64 = 0
  var ls: i64 = 0
  var i: i64 = 0
  while i <= n {
      var eol: i64 = 0
      if i == n { eol = 1 } else { if buf[i] == (10 as u8) { eol = 1 } }
      if eol == 1 {
          if i > ls {
              var tabs: i64 = 0
              var p: i64 = ls
              var st_off: i64 = 0 - 1
              var dep_off: i64 = 0 - 1
              while p < i {
                  if buf[p] == (9 as u8) {
                      tabs = tabs + 1
                      if tabs == 5 { st_off = p + 1 }
                      if tabs == 6 { dep_off = p + 1 }
                  }
                  p = p + 1
              }
              if dep_off >= 0 { if st_off >= 0 {
                  if nc_dep_has_token(buf, dep_off, i, id, idl) == 1 {
                      children = children + 1
                      if nc_field_eq(buf, st_off, i, "DONE" as *u8, 4) != 1 { not_done = not_done + 1 }
                  }
              } }
          }
          ls = i + 1
      }
      i = i + 1
  }
  if children >= 1 { if not_done == 0 { return 1 } }
  return 0
329}
330
331// FILECHECK referee (for a NOVEL row whose deliverable is a FETCHED/GENERATED FILE carrying a
332// content marker -- e.g. a research-substrate doc fetched by _dlr_fetch_one).  Reads the file at
333// <path> (field3) and asserts it contains <anchor> (field4) -- the NOVEL-row twin of reconcile's
334// ||MARK file-content check (reconcile refuses NOVEL).  A failed/blocked fetch writes no anchor
335// (error/empty page lacks the distinctive anchor) -> cannot false-close.  Returns 1 PASS / 0 FAIL.
336func nc_referee_file(path: *u8, anchor: *u8) -> i64 {
  let buf: *u8 = sys_mmap(Q_CAP)
  let n: i64 = nc_read(path, buf, Q_CAP)
  if n <= 0 { return 0 }
  if nc_contains(buf, n, anchor) == 1 { return 1 }
  return 0
342}
343
344// In queue buf, locate a line where field1==id AND field6=="NOVEL".  On hit sets
345// *line_start to that line offset and returns 1; else 0.  Exact full-field equality
346// (bounded by tabs), never prefix; field6 = char after the 5th tab.
347func nc_find_novel(buf: *u8, n: i64, id: *u8, line_start: *i64) -> i64 {
  let idl: i64 = nc_len(id)
  var ls: i64 = 0
  var i: i64 = 0
  while i <= n {
      var eol: i64 = 0
      if i == n { eol = 1 } else { if buf[i] == (10 as u8) { eol = 1 } }
      if eol == 1 {
          var f1ok: i64 = 0
          if ls + idl < i {
              if nc_at(buf, n, ls, id, idl) == 1 { if buf[ls+idl] == (9 as u8) { f1ok = 1 } }
          }
          if f1ok == 1 {
              var tabs: i64 = 0
              var p: i64 = ls
              var fs: i64 = 0 - 1
              while p < i {
                  if buf[p] == (9 as u8) { tabs = tabs + 1; if tabs == 5 { fs = p + 1; p = i } }
                  p = p + 1
              }
              if fs >= 0 {
                  if nc_at(buf, n, fs, "NOVEL\t" as *u8, 6) == 1 { *line_start = ls; return 1 }
              }
          }
          ls = i + 1
      }
      i = i + 1
  }
  return 0
376}
377
378// Locate the field6 status start offset for the line at line_start (5th tab + 1).
379func nc_status_off(buf: *u8, n: i64, line_start: i64) -> i64 {
  var p: i64 = line_start
  var tabs: i64 = 0
  while p < n {
      if buf[p] == (10 as u8) { return 0 - 1 }
      if buf[p] == (9 as u8) { tabs = tabs + 1; if tabs == 5 { return p + 1 } }
      p = p + 1
  }
  return 0 - 1
388}
389
390// Close the candidate id in queue file qpath IFF currently NOVEL.  Assumes referee
391// already PASSED.  Whole-file rewrite: [0,sstart) + "DONE" + [sstart+5, n).
392// Returns 1 if a line was rewritten, else 0.
393func nc_write_close(qpath: *u8, id: *u8) -> i64 {
  let buf: *u8 = sys_mmap(Q_CAP)
  let n: i64 = nc_read(qpath, buf, Q_CAP)
  if n <= 0 { return 0 }
  let lsp: *i64 = sys_mmap(16) as *i64
  lsp[0] = 0 - 1
  if nc_find_novel(buf, n, id, lsp) != 1 { return 0 }
  let sstart: i64 = nc_status_off(buf, n, lsp[0])
  if sstart < 0 { return 0 }
  if nc_at(buf, n, sstart, "NOVEL" as *u8, 5) != 1 { return 0 }
  let wf: i64 = sys_openat_wr(qpath, 0x1a4)
  if wf < 0 { return 0 }
  nc_write_all(wf, buf, sstart)
  nc_write_all(wf, "DONE" as *u8, 4)
  nc_write_all(wf, buf + sstart + 5, n - sstart - 5)
  sys_close(wf)
  return 1
410}
411
412// Process the queue against a candidate set.  For each candidate found NOVEL, run
413// the referee; on PASS, rewrite NOVEL->DONE and log.  Re-reads the file fresh per
414// candidate (lengths shift after a close).  Returns flips, or -1 if queue missing.
415func nc_process(qpath: *u8, ids: *i64, specs: *i64, names: *i64, greens: *i64,
              ncand: i64, do_log: i64, lfd: i64) -> i64 {
  let buf: *u8 = sys_mmap(Q_CAP)
  let n0: i64 = nc_read(qpath, buf, Q_CAP)
  if n0 <= 0 { return 0 - 1 }
  var flips: i64 = 0
  var c: i64 = 0
  while c < ncand {
      let id: *u8 = ids[c] as *u8
      // fresh read each candidate
      let qn: i64 = nc_read(qpath, buf, Q_CAP)
      let lsp: *i64 = sys_mmap(16) as *i64
      lsp[0] = 0 - 1
      if nc_find_novel(buf, qn, id, lsp) == 1 {
          let name: *u8 = names[c] as *u8
          let spec: *u8 = specs[c] as *u8
          let green: *u8 = greens[c] as *u8
          // referee type (DATA-driven by spec field): "RUN" -> RUN-referee (rebuild+run
          // organ=name); "DEPSDONE" -> DEPS-DONE referee (spec row closes when every row that
          // deps on it is DONE); else REEMIT-referee (delete+re-emit auto_builder deliverable).
          var is_run: i64 = 0
          if nc_len(spec) == 3 { if spec[0] == (82 as u8) { if spec[1] == (85 as u8) { if spec[2] == (78 as u8) { is_run = 1 } } } }
          var is_deps: i64 = 0
          if nc_len(spec) == 8 { if spec[0] == (68 as u8) { if spec[1] == (69 as u8) { if spec[2] == (80 as u8) { if spec[3] == (83 as u8) { if spec[4] == (68 as u8) { if spec[5] == (79 as u8) { if spec[6] == (78 as u8) { if spec[7] == (69 as u8) { is_deps = 1 } } } } } } } } }
          var is_file: i64 = 0
          if nc_len(spec) == 9 { if spec[0] == (70 as u8) { if spec[1] == (73 as u8) { if spec[2] == (76 as u8) { if spec[3] == (69 as u8) { if spec[4] == (67 as u8) { if spec[5] == (72 as u8) { if spec[6] == (69 as u8) { if spec[7] == (67 as u8) { if spec[8] == (75 as u8) { is_file = 1 } } } } } } } } } }
          var passr: i64 = 0
          if is_run == 1 { passr = nc_referee_run(name, green) } else { if is_deps == 1 { passr = nc_referee_deps(id, qpath) } else { if is_file == 1 { passr = nc_referee_file(name, green) } else { passr = nc_referee(name, spec, green) } } }
          if passr == 1 {
              // serialize the live-queue RMW against the beat + other side-organs via the SHARED
              // queue lock (qpath + ".lock"); degrade-gracefully on giveup (-1) so the close never
              // wedges (O_EXCL stale-steal bounds a crashed holder to 30s). [nx_registry_lock]
              let nclkp: *u8 = sys_mmap(512)
              nc_cat(nclkp, nc_cat(nclkp, 0, qpath), ".lock" as *u8)
              let nclkfd: i64 = rt_lock(nclkp)
              if nc_write_close(qpath, id) == 1 {
                  flips = flips + 1
                  nc_w(1, "NOVELCLOSE-FLIP row=" as *u8); nc_w(1, id)
                  if is_run == 1 { nc_w(1, " referee=RUN-GREEN verdict=CLOSED\n" as *u8) } else { if is_deps == 1 { nc_w(1, " referee=DEPSDONE-GREEN verdict=CLOSED\n" as *u8) } else { if is_file == 1 { nc_w(1, " referee=FILECHECK-GREEN verdict=CLOSED\n" as *u8) } else { nc_w(1, " referee=REEMIT-GREEN verdict=CLOSED\n" as *u8) } } }
                  if do_log == 1 { if lfd >= 0 {
                      nc_w(lfd, "NOVELCLOSE row=" as *u8); nc_w(lfd, id)
                      if is_run == 1 { nc_w(lfd, " referee=RUN-GREEN verdict=CLOSED\n" as *u8) } else { if is_deps == 1 { nc_w(lfd, " referee=DEPSDONE-GREEN verdict=CLOSED\n" as *u8) } else { if is_file == 1 { nc_w(lfd, " referee=FILECHECK-GREEN verdict=CLOSED\n" as *u8) } else { nc_w(lfd, " referee=REEMIT-GREEN verdict=CLOSED\n" as *u8) } } }
                  } }
              }
              if nclkfd >= 0 { rt_unlock(nclkp, nclkfd) }
          } else {
              nc_w(1, "NOVELCLOSE-SKIP row=" as *u8); nc_w(1, id)
              nc_w(1, " referee=FAIL (not closed, deliverable intact)\n" as *u8)
          }
      }
      c = c + 1
  }
  return flips
468}
469
470// Load knowledge/registry/novel_close.tsv: lines "id<TAB>spec<TAB>name<TAB>green";
471// '#'-prefixed lines skipped.  Fills parallel id/spec/name/green pools; returns count.
472func nc_load_candidates(ids: *i64, specs: *i64, names: *i64, greens: *i64) -> i64 {
  let buf: *u8 = sys_mmap(Q_MAGIC_65536)
  let n: i64 = nc_read("knowledge/registry/novel_close.tsv" as *u8, buf, Q_MAGIC_65536)
  if n <= 0 { return 0 }
  var cnt: i64 = 0
  var ls: i64 = 0
  var i: i64 = 0
  while i <= n {
      var eol: i64 = 0
      if i == n { eol = 1 } else { if buf[i] == (10 as u8) { eol = 1 } }
      if eol == 1 {
          if i > ls { if buf[ls] != (35 as u8) {
              if cnt < MAXCAND {
                  let fid: *u8 = sys_mmap(256)
                  let fsp: *u8 = sys_mmap(512)
                  let fnm: *u8 = sys_mmap(256)
                  let fgr: *u8 = sys_mmap(512)
                  var field: i64 = 0
                  var k: i64 = 0
                  var p: i64 = ls
                  while p < i {
                      if buf[p] == (9 as u8) { field = field + 1; k = 0 } else {
                          if field == 0 { fid[k] = buf[p]; fid[k+1] = 0 as u8 }
                          if field == 1 { fsp[k] = buf[p]; fsp[k+1] = 0 as u8 }
                          if field == 2 { fnm[k] = buf[p]; fnm[k+1] = 0 as u8 }
                          if field == 3 { fgr[k] = buf[p]; fgr[k+1] = 0 as u8 }
                          k = k + 1
                      }
                      p = p + 1
                  }
                  if field >= 3 {
                      ids[cnt] = fid as i64; specs[cnt] = fsp as i64
                      names[cnt] = fnm as i64; greens[cnt] = fgr as i64
                      cnt = cnt + 1
                  }
              }
          } }
          ls = i + 1
      }
      i = i + 1
  }
  return cnt
514}
515
516// ===================== BAKED SELF-TEST =====================
517// control_pos: scratch queue NOVEL row SELFTEST-POS mapped to the PROVEN erf
518// pipeline (real spec/deliverable) -> referee GREEN -> MUST close (closed==1).
519// control_neg: scratch NOVEL row SELFTEST-NEG mapped to a NON-EXISTENT spec ->
520// auto_builder REFUSED (exit!=0, no green) -> MUST NOT close (closed==0).
521// Runs on /tmp scratch queues; the real erf deliverable is backed up + restored.
522func nc_write_scratch_queue(path: *u8, status_line: *u8) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 }
  nc_w(fd, status_line)
  sys_close(fd)
  return 1
528}
529
530// self-sufficiency: the REEMIT referee/control execs the PREBUILT /tmp/nx_auto_builder.sov.elf
531// (the now-gone autorun daemon used to keep it fresh). Build it if absent (the tp_run "heal"
532// pattern) so nx_novel_close never refuses-live just because that artifact is missing. 1 if present.
533func nc_ensure_auto_builder() -> i64 {
  if nc_exists("/tmp/nx_auto_builder.sov.elf" as *u8) == 1 { return 1 }
  let pid: i64 = sys_fork()
  if pid == 0 {
      let dn: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
      if dn >= 0 { sys_dup3(dn, 1, 0); sys_dup3(dn, 2, 0) }
      let lane: *u8 = "./_offc/nx_sov_build_run.elf" as *u8
      let argv: *i64 = sys_mmap(32) as *i64
      argv[0] = lane as i64; argv[1] = "nx_auto_builder" as *u8 as i64; argv[2] = 0
      let envp: *i64 = sys_mmap(16) as *i64; envp[0] = 0
      sys_execve(lane, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  return nc_exists("/tmp/nx_auto_builder.sov.elf" as *u8)
549}
550
551func nc_selftest() -> i64 {
  nc_ensure_auto_builder()   // ensure the REEMIT control's prebuilt elf exists -> self-sufficient
  let erf_d: *u8 = "runtime/_hdl_build/_ab_mk_erf.nx" as *u8
  let erf_t: *u8 = "runtime/_hdl_build/_ab_mk_erf_test.nx" as *u8
  let erf_d_bak: *u8 = "/tmp/_nc_st_erf_d.bak" as *u8
  let erf_t_bak: *u8 = "/tmp/_nc_st_erf_t.bak" as *u8
  let had_d: i64 = nc_exists(erf_d); if had_d == 1 { nc_copy(erf_d, erf_d_bak) }
  let had_t: i64 = nc_exists(erf_t); if had_t == 1 { nc_copy(erf_t, erf_t_bak) }
559
  let ids: *i64 = sys_mmap(8 * 4) as *i64
  let specs: *i64 = sys_mmap(8 * 4) as *i64
  let names: *i64 = sys_mmap(8 * 4) as *i64
  let greens: *i64 = sys_mmap(8 * 4) as *i64
564
  // ---- control_pos ----
  let qp: *u8 = "/tmp/_nc_st_pos.tsv" as *u8
  nc_write_scratch_queue(qp, "SELFTEST-POS\tX\t9\tM\tBuilder\tNOVEL\tnone\tgate\tselftest pos row\n" as *u8)
  ids[0] = "SELFTEST-POS" as *u8 as i64
  specs[0] = "runtime/_hdl_build/_ab_mk_erf.spec" as *u8 as i64
  names[0] = "_ab_mk_erf" as *u8 as i64
  greens[0] = "AUTO-BUILD GREEN: _ab_mk_erf shape=11 KAT green" as *u8 as i64
  nc_process(qp, ids, specs, names, greens, 1, 0, 0 - 1)
  let pbuf: *u8 = sys_mmap(Q_MAGIC_4096)
  let pn: i64 = nc_read(qp, pbuf, Q_MAGIC_4096)
  var pos_closed: i64 = 0
  if nc_contains(pbuf, pn, "\tDONE\t" as *u8) == 1 { pos_closed = 1 }
577
  // ---- control_neg ----  (non-existent spec -> referee FAIL -> no close)
  let qn: *u8 = "/tmp/_nc_st_neg.tsv" as *u8
  nc_write_scratch_queue(qn, "SELFTEST-NEG\tX\t9\tM\tBuilder\tNOVEL\tnone\tgate\tselftest neg row\n" as *u8)
  ids[0] = "SELFTEST-NEG" as *u8 as i64
  specs[0] = "knowledge/specs/_NO_SUCH_SPEC_selftest.spec" as *u8 as i64
  names[0] = "_nc_selftest_neg" as *u8 as i64
  greens[0] = "AUTO-BUILD GREEN: _nc_selftest_neg" as *u8 as i64
  nc_process(qn, ids, specs, names, greens, 1, 0, 0 - 1)
  let nbuf: *u8 = sys_mmap(Q_MAGIC_4096)
  let nn: i64 = nc_read(qn, nbuf, Q_MAGIC_4096)
  var neg_closed: i64 = 1
  if nc_contains(nbuf, nn, "\tNOVEL\t" as *u8) == 1 { neg_closed = 0 }
  if nc_contains(nbuf, nn, "\tDONE\t" as *u8) == 1 { neg_closed = 1 }
591
  // ---- control_run_pos ---- (RUN-referee: organ emits the green -> MUST close)
  let qrp: *u8 = "/tmp/_nc_st_runpos.tsv" as *u8
  nc_write_scratch_queue(qrp, "SELFTEST-RUNPOS\tX\t9\tM\tBuilder\tNOVEL\tnone\tgate\tselftest run pos\n" as *u8)
  ids[0] = "SELFTEST-RUNPOS" as *u8 as i64
  specs[0] = "RUN" as *u8 as i64
  names[0] = "nx_cms_wp_scorecard" as *u8 as i64
  greens[0] = "verdict=MEASURED" as *u8 as i64
  nc_process(qrp, ids, specs, names, greens, 1, 0, 0 - 1)
  let rpbuf: *u8 = sys_mmap(Q_MAGIC_4096)
  let rpn: i64 = nc_read(qrp, rpbuf, Q_MAGIC_4096)
  var runpos_closed: i64 = 0
  if nc_contains(rpbuf, rpn, "\tDONE\t" as *u8) == 1 { runpos_closed = 1 }
604
  // ---- control_run_neg ---- (RUN-referee: green absent -> MUST NOT close)
  let qrn: *u8 = "/tmp/_nc_st_runneg.tsv" as *u8
  nc_write_scratch_queue(qrn, "SELFTEST-RUNNEG\tX\t9\tM\tBuilder\tNOVEL\tnone\tgate\tselftest run neg\n" as *u8)
  ids[0] = "SELFTEST-RUNNEG" as *u8 as i64
  specs[0] = "RUN" as *u8 as i64
  names[0] = "nx_cms_wp_scorecard" as *u8 as i64
  greens[0] = "ZZ_NEVER_APPEARS_RUNNEG" as *u8 as i64
  nc_process(qrn, ids, specs, names, greens, 1, 0, 0 - 1)
  let rnbuf: *u8 = sys_mmap(Q_MAGIC_4096)
  let rnn: i64 = nc_read(qrn, rnbuf, Q_MAGIC_4096)
  var runneg_closed: i64 = 1
  if nc_contains(rnbuf, rnn, "\tNOVEL\t" as *u8) == 1 { runneg_closed = 0 }
  if nc_contains(rnbuf, rnn, "\tDONE\t" as *u8) == 1 { runneg_closed = 1 }
618
  // ---- control_deps_pos ---- (DEPS-DONE: spec row whose only child is DONE -> MUST close)
  let qdp: *u8 = "/tmp/_nc_st_depspos.tsv" as *u8
  nc_write_scratch_queue(qdp, "SPECPOS\tX\t9\tM\tPM\tNOVEL\t-\tspec\tumbrella spec row\nCHILDPOS\tX\t9\tM\tBuilder\tDONE\tSPECPOS\tgate\tchild built\n" as *u8)
  ids[0] = "SPECPOS" as *u8 as i64
  specs[0] = "DEPSDONE" as *u8 as i64
  names[0] = "-" as *u8 as i64
  greens[0] = "-" as *u8 as i64
  nc_process(qdp, ids, specs, names, greens, 1, 0, 0 - 1)
  let dpbuf: *u8 = sys_mmap(Q_MAGIC_4096)
  let dpn: i64 = nc_read(qdp, dpbuf, Q_MAGIC_4096)
  let dplsp: *i64 = sys_mmap(16) as *i64
  dplsp[0] = 0 - 1
  var deps_pos_closed: i64 = 0
  if nc_find_novel(dpbuf, dpn, "SPECPOS" as *u8, dplsp) == 0 { deps_pos_closed = 1 }
633
  // ---- control_deps_neg ---- (DEPS-DONE: spec row whose child is still NOVEL -> MUST NOT close)
  let qdn2: *u8 = "/tmp/_nc_st_depsneg.tsv" as *u8
  nc_write_scratch_queue(qdn2, "SPECNEG\tX\t9\tM\tPM\tNOVEL\t-\tspec\tumbrella spec row\nCHILDNEG\tX\t9\tM\tBuilder\tNOVEL\tSPECNEG\tgate\tchild not built\n" as *u8)
  ids[0] = "SPECNEG" as *u8 as i64
  specs[0] = "DEPSDONE" as *u8 as i64
  names[0] = "-" as *u8 as i64
  greens[0] = "-" as *u8 as i64
  nc_process(qdn2, ids, specs, names, greens, 1, 0, 0 - 1)
  let dnbuf: *u8 = sys_mmap(Q_MAGIC_4096)
  let dnn2: i64 = nc_read(qdn2, dnbuf, Q_MAGIC_4096)
  let dnlsp: *i64 = sys_mmap(16) as *i64
  dnlsp[0] = 0 - 1
  var deps_neg_closed: i64 = 0
  if nc_find_novel(dnbuf, dnn2, "SPECNEG" as *u8, dnlsp) == 0 { deps_neg_closed = 1 }
648
  // ---- control_file_pos ---- (FILECHECK: deliverable file carries anchor -> MUST close)
  let qfp: *u8 = "/tmp/_nc_st_filepos.tsv" as *u8
  nc_write_scratch_queue(qfp, "FILEPOS\tX\t9\tM\tResearcher\tNOVEL\t-\tgate\tfile pos row\n" as *u8)
  nc_write_scratch_queue("/tmp/_nc_st_file_pos.txt" as *u8, "header line\nWhen MARKER appears here exactly\nfooter line\n" as *u8)
  ids[0] = "FILEPOS" as *u8 as i64
  specs[0] = "FILECHECK" as *u8 as i64
  names[0] = "/tmp/_nc_st_file_pos.txt" as *u8 as i64
  greens[0] = "When MARKER appears here exactly" as *u8 as i64
  nc_process(qfp, ids, specs, names, greens, 1, 0, 0 - 1)
  let fpbuf: *u8 = sys_mmap(Q_MAGIC_4096)
  let fpn: i64 = nc_read(qfp, fpbuf, Q_MAGIC_4096)
  var file_pos_closed: i64 = 0
  if nc_contains(fpbuf, fpn, "\tDONE\t" as *u8) == 1 { file_pos_closed = 1 }
662
  // ---- control_file_neg ---- (FILECHECK: anchor absent in file -> MUST NOT close)
  let qfn2: *u8 = "/tmp/_nc_st_fileneg.tsv" as *u8
  nc_write_scratch_queue(qfn2, "FILENEG\tX\t9\tM\tResearcher\tNOVEL\t-\tgate\tfile neg row\n" as *u8)
  nc_write_scratch_queue("/tmp/_nc_st_file_neg.txt" as *u8, "header line\nno marker present at all here\nfooter line\n" as *u8)
  ids[0] = "FILENEG" as *u8 as i64
  specs[0] = "FILECHECK" as *u8 as i64
  names[0] = "/tmp/_nc_st_file_neg.txt" as *u8 as i64
  greens[0] = "ZZ_NEVER_IN_FILE_NEG" as *u8 as i64
  nc_process(qfn2, ids, specs, names, greens, 1, 0, 0 - 1)
  let fnbuf: *u8 = sys_mmap(Q_MAGIC_4096)
  let fnn2: i64 = nc_read(qfn2, fnbuf, Q_MAGIC_4096)
  var file_neg_closed: i64 = 1
  if nc_contains(fnbuf, fnn2, "\tNOVEL\t" as *u8) == 1 { file_neg_closed = 0 }
  if nc_contains(fnbuf, fnn2, "\tDONE\t" as *u8) == 1 { file_neg_closed = 1 }
677
  // restore the real erf deliverable regardless (history sacred)
  if had_d == 1 { nc_copy(erf_d_bak, erf_d) }
  if had_t == 1 { nc_copy(erf_t_bak, erf_t) }
681
  nc_w(1, "SELFTEST control_pos=" as *u8); nc_wn(1, pos_closed)
  nc_w(1, " control_neg=" as *u8); nc_wn(1, neg_closed)
  nc_w(1, " control_run_pos=" as *u8); nc_wn(1, runpos_closed)
  nc_w(1, " control_run_neg=" as *u8); nc_wn(1, runneg_closed)
  nc_w(1, " control_deps_pos=" as *u8); nc_wn(1, deps_pos_closed)
  nc_w(1, " control_deps_neg=" as *u8); nc_wn(1, deps_neg_closed)
  nc_w(1, " control_file_pos=" as *u8); nc_wn(1, file_pos_closed)
  nc_w(1, " control_file_neg=" as *u8); nc_wn(1, file_neg_closed)
  var allok: i64 = 0
  if pos_closed == 1 { if neg_closed == 0 { if runpos_closed == 1 { if runneg_closed == 0 { if deps_pos_closed == 1 { if deps_neg_closed == 0 { if file_pos_closed == 1 { if file_neg_closed == 0 { allok = 1 } } } } } } } }
  if allok == 1 { nc_w(1, " verdict=GREEN\n" as *u8); return 1 }
  nc_w(1, " verdict=RED\n" as *u8)
  return 0
695}
696
697func main(argc: i64, argv: *i64) -> i64 {
  // 1) BAKED SELF-TEST FIRST -- abort (no real-queue write) on any control mismatch.
  if nc_selftest() == 0 {
      nc_w(1, "NOVELCLOSE verdict=RED reason=selftest-failed (real queue UNTOUCHED)\n" as *u8)
      sys_exit(7); return 7
  }
703
  // 2) target queue + live-ness
  var qp: *u8 = "knowledge/registry/assignment_queue.tsv" as *u8
  var is_live: i64 = 1
  if argc >= 2 { qp = argv[1] as *u8; is_live = 0 }
708
  // 3) LIVE run: write .bak of the real queue BEFORE any mutation
  if is_live == 1 {
      nc_copy("knowledge/registry/assignment_queue.tsv" as *u8,
              "knowledge/registry/assignment_queue.tsv.bak" as *u8)
  }
714
  // 4) load DATA candidate table
  let ids: *i64 = sys_mmap(8 * MAXCAND) as *i64
  let specs: *i64 = sys_mmap(8 * MAXCAND) as *i64
  let names: *i64 = sys_mmap(8 * MAXCAND) as *i64
  let greens: *i64 = sys_mmap(8 * MAXCAND) as *i64
  let ncand: i64 = nc_load_candidates(ids, specs, names, greens)
  nc_w(1, "NOVELCLOSE candidates=" as *u8); nc_wn(1, ncand)
  nc_w(1, " queue=" as *u8); nc_w(1, qp)
  if is_live == 1 { nc_w(1, " mode=LIVE\n" as *u8) } else { nc_w(1, " mode=DRYRUN\n" as *u8) }
724
  // 5) durable log (append-only) -- only LIVE runs append durable history
  var lfd: i64 = 0 - 1
  var do_log: i64 = 0
  if is_live == 1 {
      lfd = sys_openat_append("knowledge/status/novel_close.log" as *u8, 0x1a4)
      do_log = 1
  }
732
  let flips: i64 = nc_process(qp, ids, specs, names, greens, ncand, do_log, lfd)
  if flips < 0 {
      nc_w(1, "NOVELCLOSE verdict=RED reason=queue-missing\n" as *u8)
      sys_exit(101); return 101
  }
738
  nc_w(1, "NOVELCLOSE closed=" as *u8); nc_wn(1, flips)
  nc_w(1, " verdict=GREEN epoch=" as *u8); nc_wn(1, sys_now_realtime_sec()); nc_w(1, "\n" as *u8)
  if do_log == 1 { if lfd >= 0 {
      nc_w(lfd, "NOVELCLOSE closed=" as *u8); nc_wn(lfd, flips)
      nc_w(lfd, " verdict=GREEN epoch=" as *u8); nc_wn(lfd, sys_now_realtime_sec()); nc_w(lfd, "\n" as *u8)
      sys_close(lfd)
  } }
  sys_exit(0)
  return 0
748}
nx_novel_close.nx source

`nx_novel_close.nx` source
