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

↩ module page · 257 lines · 11757 B
1// nx_reconcile.nx -- the AUTONOMOUS STATUS-KEEPER (X-Q-005): DONE flips on
2// EVIDENCE, with no session.  For every TODO/WIP queue row whose gate cell
3// carries the machine suffix
4//     ...||MARK=<logpath>::<anchor>::<green-substring>
5// evaluate it exactly like the examiner/rung-grade family (the LAST <anchor>
6// line in <logpath> must contain <green-substring>); if GREEN, rewrite that
7// row's status to DONE in place.  Rows without a MARK suffix are untouched
8// (X-Q-003b migrates them); NOVEL rows are NEVER auto-flipped (tutor work is
9// judged by its own gates after the visit).  Deps untouched -- the sequencer
10// re-derives readiness next beat.  Appends RECONCILE rows to
11// knowledge/status/reconcile.log; rewrite is whole-file (read -> patch in
12// memory -> write), safe at this row count.
13//   argv[1] = queue override (gates use a scratch queue).
14// license_tier: ORIGINAL
15import "nx_registry_lock.nx"   // lib-only (nx_syscalls transitive); rt_lock/rt_unlock for the shared queue lock
16import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
17const K_MAGIC_524288: i64 = 524288
18const K_MAGIC_1048576: i64 = 1048576
19
20func rc_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 }
21// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
22// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
23// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
24// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
25func rc_wn(fd: i64, v: i64) -> i64 { nxi_fd(fd, v); return 0 }
26
27// ARK-GATE-001: when a reconcile pass flips >=1 rung TODO->DONE, a rung was
28// ACHIEVED this beat -> stamp a FRESH ark-gate marker (open-wr truncate, one
29// deterministic line).  nx_ark_push reads epoch=<sec> + verdict=ACHIEVED and
30// pushes ONCE (its own ark_push.state one-shot guard).  flips==0 leaves the
31// marker UNTOUCHED so it goes stale on its own -> un-gated beats HOLD.  Same
32// epoch=<sec> shape ARKPUSH/RECONCILE already emit, so existing readers are happy.
33func rc_stamp_ark_marker(flips: i64) -> i64 {
  let fd: i64 = sys_openat_wr("knowledge/status/ark_gate.marker" as *u8, 0x1a4)
  if fd < 0 { return 0 }
  rc_w(fd, "ARKGATE epoch=" as *u8); rc_wn(fd, sys_now_realtime_sec())
  rc_w(fd, " verdict=ACHIEVED flipped=" as *u8); rc_wn(fd, flips)
  rc_w(fd, " source=reconcile\n" as *u8)
  sys_close(fd)
  return 1
41}
42
43func rc_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
51}
52
53func rc_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
58}
59
60func rc_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
61
62// build "<qp>.lock" into out -- the shared queue lock (live queue => assignment_queue.tsv.lock).
63func rc_lockpath(qp: *u8, out: *u8) -> i64 {
  var i: i64 = 0
  while qp[i] != (0 as u8) { out[i] = qp[i]; i = i + 1 }
  let s: *u8 = ".lock" as *u8
  var k: i64 = 0
  while s[k] != (0 as u8) { out[i] = s[k]; i = i + 1; k = k + 1 }
  out[i] = 0 as u8
  return 0
71}
72
73// last <anchor> line in logpath contains green?  1/0; -1 log-or-anchor absent
74func rc_eval(logpath: *u8, anchor: *u8, green: *u8) -> i64 {
  let buf: *u8 = sys_mmap(K_MAGIC_524288)
  let n: i64 = rc_read(logpath, buf, K_MAGIC_524288)
  if n <= 0 { return 0 - 1 }
  let al: i64 = rc_len(anchor)
  let gl: i64 = rc_len(green)
  var found: i64 = 0
  var ls: i64 = 0
  var fs2: i64 = 0
  var fe2: 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 j: i64 = ls
          while j < i {
              if rc_at(buf, n, j, anchor, al) == 1 { found = 1; fs2 = ls; fe2 = i; j = i } else { j = j + 1 }
          }
          ls = i + 1
      }
      i = i + 1
  }
  if found == 0 { return 0 - 1 }
  var q: i64 = fs2
  while q < fe2 {
      if rc_at(buf, n, q, green, gl) == 1 { return 1 }
      q = q + 1
  }
  return 0
104}
105
106func main(argc: i64, argv: *i64) -> i64 {
  var qp: *u8 = "knowledge/registry/assignment_queue.tsv" as *u8
  // is_live: reconcile is running against the REAL queue (no argv override).
  // Only a LIVE reconcile arms the ark-gate marker; a gate that passes a
  // scratch queue (argv[1]) must NEVER arm a real push (ARK-GATE-001).
  var is_live: i64 = 1
  if argc >= 2 { qp = argv[1] as *u8; is_live = 0 }
  // ACQUIRE the SHARED queue lock around the whole read-modify-write of qp (serializes against
  // nx_novel_close + the other writers); degrade-gracefully on giveup (-1 -> proceed unlocked,
  // never wedge; O_EXCL stale-steal bounds a crashed holder to 30s).
  let lockpath: *u8 = sys_mmap(512)
  rc_lockpath(qp, lockpath)
  let qlk: i64 = rt_lock(lockpath)
  let buf: *u8 = sys_mmap(K_MAGIC_1048576)
  let n: i64 = rc_read(qp, buf, K_MAGIC_1048576)
  if n <= 0 { if qlk >= 0 { rt_unlock(lockpath, qlk) } rc_w(1, "RECONCILE verdict=RED reason=queue-missing\n" as *u8); sys_exit(101) }
  let lf: i64 = sys_openat_append("knowledge/status/reconcile.log" as *u8, 0x1a4)
  let lpath: *u8 = sys_mmap(512)
  let anch: *u8 = sys_mmap(256)
  let grn: *u8 = sys_mmap(256)
  var flips: i64 = 0
  var marked: 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 {
          // line [ls, i): find "\tTODO\t" or "\tWIP\t" position + "||MARK=".
          // ||ASK=result rows are SUBJECTIVE deliverables (executive-sponsor
          // doctrine 2026-06-11): objective evidence green -> flip to VIEW
          // (sponsor viewpoint queue, same 4-byte in-place write), never
          // straight to DONE -- only nx_sponsor_review's APPROVE does that.
          var stp: i64 = 0 - 1
          var iswip: i64 = 0
          var mk: i64 = 0 - 1
          var askr: i64 = 0
          var j: i64 = ls
          while j < i {
              if rc_at(buf, n, j, "\tTODO\t" as *u8, 6) == 1 { if stp < 0 { stp = j } }
              if rc_at(buf, n, j, "\tWIP\t" as *u8, 5) == 1 { if stp < 0 { stp = j; iswip = 1 } }
              if rc_at(buf, n, j, "||MARK=" as *u8, 7) == 1 { mk = j + 7 }
              if rc_at(buf, n, j, "||ASK=result" as *u8, 12) == 1 { askr = 1 }
              j = j + 1
          }
          if stp >= 0 {
              if mk >= 0 {
                  marked = marked + 1
                  // parse <log>::<anchor>::<green> ending at tab or eol
                  var p: i64 = mk
                  var k: i64 = 0
                  var go: i64 = 1
                  while go == 1 {
                      if p >= i { go = 0 } else {
                          if rc_at(buf, n, p, "::" as *u8, 2) == 1 { go = 0 } else {
                              if k < 511 { lpath[k] = buf[p]; k = k + 1 }
                              p = p + 1
                          }
                      }
                  }
                  lpath[k] = 0 as u8
                  if p < i { p = p + 2 }
                  k = 0
                  go = 1
                  while go == 1 {
                      if p >= i { go = 0 } else {
                          if rc_at(buf, n, p, "::" as *u8, 2) == 1 { go = 0 } else {
                              if k < 255 { anch[k] = buf[p]; k = k + 1 }
                              p = p + 1
                          }
                      }
                  }
                  anch[k] = 0 as u8
                  if p < i { p = p + 2 }
                  // green ends at TAB (field end) OR at "||" (the next suffix,
                  // e.g. ||EXEC=) -- without the || stop, an EXEC suffix is
                  // swallowed into green and never matches (caught live:
                  // X-EX-001 marked but flipped=0).
                  k = 0
                  go = 1
                  while go == 1 {
                      if p >= i { go = 0 } else {
                          if buf[p] == (9 as u8) { go = 0 } else {
                              if rc_at(buf, n, p, "||" as *u8, 2) == 1 { go = 0 } else {
                                  if k < 255 { grn[k] = buf[p]; k = k + 1 }
                                  p = p + 1
                              }
                          }
                      }
                  }
                  grn[k] = 0 as u8
                  if rc_eval(lpath, anch, grn) == 1 {
                      // flip in place: TODO->DONE or TODO->VIEW (same length);
                      // WIP->DONE shifts -- handle TODO only v1, WIP said
                      if iswip == 0 {
                          if askr == 0 {
                              buf[stp + 1] = 68 as u8     // D
                              buf[stp + 2] = 79 as u8     // O
                              buf[stp + 3] = 78 as u8     // N
                              buf[stp + 4] = 69 as u8     // E
                          } else {
                              buf[stp + 1] = 86 as u8     // V
                              buf[stp + 2] = 73 as u8     // I
                              buf[stp + 3] = 69 as u8     // E
                              buf[stp + 4] = 87 as u8     // W
                          }
                          flips = flips + 1
                          rc_w(1, "RECONCILE-FLIP line-at=" as *u8); rc_wn(1, ls)
                          if askr == 0 { rc_w(1, " marker-green\n" as *u8) } else { rc_w(1, " marker-green -> VIEW (sponsor viewpoint)\n" as *u8) }
                          if lf >= 0 {
                              rc_w(lf, "RECONCILE-FLIP offset=" as *u8); rc_wn(lf, ls)
                              if askr == 0 { rc_w(lf, " -> DONE\n" as *u8) } else { rc_w(lf, " -> VIEW\n" as *u8) }
                          }
                      } else {
                          rc_w(1, "RECONCILE-WIP-GREEN (flip manually or via v2; WIP len differs)\n" as *u8)
                      }
                  }
              }
          }
          ls = i + 1
      }
      i = i + 1
  }
  if flips > 0 {
      let wf: i64 = sys_openat_wr(qp, 0x1a4)
      if wf >= 0 {
          var off: i64 = 0
          while off < n { let w: i64 = sys_write(wf, buf + off, n - off); if w <= 0 { off = n } else { off = off + w } }
          sys_close(wf)
      }
      // a rung was ACHIEVED this beat -> let the ark push once (ARK-GATE-001).
      // ONLY when reconciling the LIVE queue; a scratch-queue gate run never
      // arms a real push.
      if is_live == 1 { rc_stamp_ark_marker(flips) }
  }
  if qlk >= 0 { rt_unlock(lockpath, qlk) }
  var p2: i64 = 0
  while p2 < 2 {
      var fd: i64 = 1
      if p2 == 1 { fd = lf }
      if fd >= 0 {
          rc_w(fd, "RECONCILE marked=" as *u8); rc_wn(fd, marked)
          rc_w(fd, " flipped=" as *u8); rc_wn(fd, flips)
          rc_w(fd, " epoch=" as *u8); rc_wn(fd, sys_now_realtime_sec())
          rc_w(fd, " verdict=GREEN\n" as *u8)
      }
      p2 = p2 + 1
  }
  if lf >= 0 { sys_close(lf) }
  sys_exit(0)
  return 0
257}
nx_reconcile.nx source

`nx_reconcile.nx` source
