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

↩ module page · 680 lines · 27105 B
1// nx_infomgmt_gate.nx -- THE INFORMATION-MANAGEMENT GATE: one command re-proves
2// the sovereign storage substrate rung-1 claim set (segment store + canonical
3// CID), evidence-driven + durable.  Pure NishiLang, NO SQL, no .sh.
4//
5// Rows (each = a claim; FAIL on any row = RED, never silenced):
6//   canon-determinism   same logical record, two field insertion orders
7//                       => IDENTICAL canonical bytes => IDENTICAL CID
8//   canon-distinct      different record => different CID (no collisions by
9//                       construction of the encoding)
10//   fresh-process-read  records written+committed by a CHILD PROCESS that
11//                       exits; parent reads byte-exact (no shared memory --
12//                       the bytes came off disk)
13//   time-travel         v2 shadows v1 on get(); BOTH versions remain readable
14//                       in history (the additive law as a query surface)
15//   tombstone-additive  delete = tombstone: get() says GONE, history still
16//                       serves the old bytes (nothing is ever destroyed)
17//   crash-invisibility  fault injection: child dies BEFORE the commit point
18//                       (temp written, no rename/manifest) => key absent,
19//                       prior data intact, manifest unchanged
20//   reopen-determinism  all reads repeated from scratch are byte-identical
21//                       and the canonical CID re-derives identically
22//
23// EXCEED rows vs SQL-class stores: time-travel + tombstone-additive +
24// crash-invisibility are capabilities SQLite does not give by default.
25// Durable verdicts: knowledge/status/infomgmt_gate.log.
26// license_tier: ORIGINAL
27
28import "nx_syscalls.nx"
29import "nx_canon_cid.nx"
30import "nx_seg_store.nx"
31import "nx_gate_verdict.nx"
32
33const IG_ROWS: i64 = 15
34
35func ig_p(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  sys_write(1, s, n)
  return 0
40}
41
42func ig_fp(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
47}
48
49func ig_fn(fd: i64, v: i64) -> i64 {
  let bb: *u8 = sys_mmap(28)
  var m: i64 = v
  if m < 0 { m = 0 - m; sys_write(fd, "-" as *u8, 1) }
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(fd, bb, k)
  return 0
61}
62
63func ig_memeq(a: *u8, b: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n {
      if a[i] != b[i] { return 0 }
      i = i + 1
  }
  return 1
70}
71
72func ig_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while 1 == 1 {
      if a[i] != b[i] { return 0 }
      if a[i] == (0 as u8) { return 1 }
      i = i + 1
  }
  return 0
80}
81
82func ig_report(logfd: i64, name: *u8, pass: i64) -> i64 {
  var fdi: i64 = 0
  while fdi < 2 {
      var fd: i64 = 1
      if fdi == 1 { fd = logfd }
      if fd > 0 {
          ig_fp(fd, "INFOMGMT-GATE row=" as *u8)
          ig_fp(fd, name)
          if pass == 1 { ig_fp(fd, " verdict=PASS\n" as *u8) }
          if pass != 1 { ig_fp(fd, " verdict=FAIL\n" as *u8) }
      }
      fdi = fdi + 1
  }
  return 0
96}
97
98// fork a child that writes records into segid then commits (mode 1) or
99// crash-writes only the temp (mode 2); parent waits.  Records are passed as
100// (kind,key,val,vlen) quads in q[], nq of them.
101func ig_child_write(prefix: *u8, segid: i64, mode: i64, q: *i64, nq: i64) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      let w: *i64 = ss_begin()
      var i: i64 = 0
      while i < nq {
          ss_add(w, q[i * 4], (q[i * 4 + 1]) as *u8, (q[i * 4 + 2]) as *u8, q[i * 4 + 3])
          i = i + 1
      }
      var rc: i64 = 0
      if mode == 1 { rc = ss_commit(prefix, w, segid) }
      if mode == 2 { rc = ss_crashwrite(prefix, w, segid) }
      if rc != 0 { sys_exit(9) }
      sys_exit(0)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  return st[0]
119}
120
121func main() -> i64 {
  let logfd: i64 = sys_openat_append("knowledge/status/infomgmt_gate.log" as *u8, 0x1a4)
  if logfd > 0 {
      ig_fp(logfd, "INFOMGMT-GATE epoch=" as *u8)
      ig_fn(logfd, sys_now_realtime_sec())
      ig_fp(logfd, " run-start rung=1 (segment-store + canonical-cid)\n" as *u8)
  }
128
  // fresh per-run store prefix (flat files; no mkdir needed)
  let prefix: *u8 = sys_mmap(128)
  var po: i64 = 0
  po = ss_cat(prefix, po, "/tmp/im" as *u8)
  po = ss_catn(prefix, po, sys_now_us())
  po = ss_cat(prefix, po, "-" as *u8)
  prefix[po] = 0 as u8
136
  var passed: i64 = 0
138
  // ---- record A: same logical record, two insertion orders ----
  let k1: *i64 = sys_mmap(8 * 4) as *i64
  let v1: *i64 = sys_mmap(8 * 4) as *i64
  k1[0] = "name" as *u8 as i64
  v1[0] = "diora_baird" as *u8 as i64
  k1[1] = "layer" as *u8 as i64
  v1[1] = "L6" as *u8 as i64
  k1[2] = "maturity" as *u8 as i64
  v1[2] = "functional" as *u8 as i64
  let k2: *i64 = sys_mmap(8 * 4) as *i64
  let v2: *i64 = sys_mmap(8 * 4) as *i64
  k2[0] = "maturity" as *u8 as i64
  v2[0] = "functional" as *u8 as i64
  k2[1] = "name" as *u8 as i64
  v2[1] = "diora_baird" as *u8 as i64
  k2[2] = "layer" as *u8 as i64
  v2[2] = "L6" as *u8 as i64
156
  let encA: *u8 = sys_mmap(4096)
  let encA2: *u8 = sys_mmap(4096)
  let lenA: i64 = canon_encode(k1, v1, 3, encA)
  let lenA2: i64 = canon_encode(k2, v2, 3, encA2)
  let cidA: *u8 = sys_mmap(80)
  let cidA2: *u8 = sys_mmap(80)
  cid_of(encA, lenA, cidA)
  cid_of(encA2, lenA2, cidA2)
  var ok: i64 = 0
  if lenA == lenA2 { if ig_memeq(encA, encA2, lenA) == 1 { if ig_streq(cidA, cidA2) == 1 { ok = 1 } } }
  ig_report(logfd, "canon-determinism" as *u8, ok)
  passed = passed + ok
169
  // ---- record B: one value differs => different CID ----
  let v3: *i64 = sys_mmap(8 * 4) as *i64
  v3[0] = "diora_baird" as *u8 as i64
  v3[1] = "L6" as *u8 as i64
  v3[2] = "production" as *u8 as i64
  let encB: *u8 = sys_mmap(4096)
  let lenB: i64 = canon_encode(k1, v3, 3, encB)
  let cidB: *u8 = sys_mmap(80)
  cid_of(encB, lenB, cidB)
  ok = 0
  if ig_streq(cidA, cidB) == 0 { ok = 1 }
  ig_report(logfd, "canon-distinct" as *u8, ok)
  passed = passed + ok
183
  // ---- seg 1 written + committed by a fresh child process ----
  let q1: *i64 = sys_mmap(8 * 8) as *i64
  q1[0] = 1
  q1[1] = "cap:diora" as *u8 as i64
  q1[2] = encA as i64
  q1[3] = lenA
  q1[4] = 1
  q1[5] = "cap:search" as *u8 as i64
  q1[6] = encB as i64
  q1[7] = lenB
  let st1: i64 = ig_child_write(prefix, 1, 1, q1, 2)
  let pp: *i64 = sys_mmap(16) as *i64
  let ll: *i64 = sys_mmap(16) as *i64
  ok = 0
  if st1 == 0 {
      let g1: i64 = ss_get(prefix, "cap:diora" as *u8, pp, ll)
      if g1 == 1 { if ll[0] == lenA { if ig_memeq(pp[0] as *u8, encA, lenA) == 1 {
          let g2: i64 = ss_get(prefix, "cap:search" as *u8, pp, ll)
          if g2 == 1 { if ll[0] == lenB { if ig_memeq(pp[0] as *u8, encB, lenB) == 1 { ok = 1 } } }
      } } }
  }
  ig_report(logfd, "fresh-process-read" as *u8, ok)
  passed = passed + ok
207
  // ---- seg 2: v2 of cap:diora (record B bytes) => shadows v1, history keeps both ----
  let q2: *i64 = sys_mmap(8 * 4) as *i64
  q2[0] = 1
  q2[1] = "cap:diora" as *u8 as i64
  q2[2] = encB as i64
  q2[3] = lenB
  let st2: i64 = ig_child_write(prefix, 2, 1, q2, 1)
  let kinds: *i64 = sys_mmap(8 * 260) as *i64
  let ptrs: *i64 = sys_mmap(8 * 260) as *i64
  let lens: *i64 = sys_mmap(8 * 260) as *i64
  ok = 0
  if st2 == 0 {
      let g3: i64 = ss_get(prefix, "cap:diora" as *u8, pp, ll)
      if g3 == 1 { if ll[0] == lenB { if ig_memeq(pp[0] as *u8, encB, lenB) == 1 {
          let hn: i64 = ss_scan(prefix, "cap:diora" as *u8, kinds, ptrs, lens)
          if hn == 2 { if lens[0] == lenA { if ig_memeq(ptrs[0] as *u8, encA, lenA) == 1 { ok = 1 } } }
      } } }
  }
  ig_report(logfd, "time-travel" as *u8, ok)
  passed = passed + ok
228
  // ---- seg 3: tombstone cap:search => GONE on get, history additive ----
  let q3: *i64 = sys_mmap(8 * 4) as *i64
  q3[0] = 2
  q3[1] = "cap:search" as *u8 as i64
  q3[2] = "" as *u8 as i64
  q3[3] = 0
  let st3: i64 = ig_child_write(prefix, 3, 1, q3, 1)
  ok = 0
  if st3 == 0 {
      let g4: i64 = ss_get(prefix, "cap:search" as *u8, pp, ll)
      if g4 == 0 {
          let hn2: i64 = ss_scan(prefix, "cap:search" as *u8, kinds, ptrs, lens)
          if hn2 == 2 { if lens[0] == lenB { if ig_memeq(ptrs[0] as *u8, encB, lenB) == 1 { ok = 1 } } }
      }
  }
  ig_report(logfd, "tombstone-additive" as *u8, ok)
  passed = passed + ok
246
  // ---- seg 4: FAULT INJECTION -- child dies before the commit point ----
  let q4: *i64 = sys_mmap(8 * 4) as *i64
  q4[0] = 1
  q4[1] = "cap:ghost" as *u8 as i64
  q4[2] = encB as i64
  q4[3] = lenB
  let st4: i64 = ig_child_write(prefix, 4, 2, q4, 1)
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  ok = 0
  if st4 == 0 {
      let g5: i64 = ss_get(prefix, "cap:ghost" as *u8, pp, ll)
      if g5 == (0 - 1) {
          let g6: i64 = ss_get(prefix, "cap:diora" as *u8, pp, ll)
          if g6 == 1 { if ig_memeq(pp[0] as *u8, encB, lenB) == 1 {
              let ms: i64 = ss_manifest(prefix, segs)
              if ms == 3 { ok = 1 }
          } }
      }
  }
  ig_report(logfd, "crash-invisibility" as *u8, ok)
  passed = passed + ok
268
  // ---- reopen-determinism: every read again from scratch + CID re-derives ----
  ok = 0
  let g7: i64 = ss_get(prefix, "cap:diora" as *u8, pp, ll)
  if g7 == 1 { if ig_memeq(pp[0] as *u8, encB, lenB) == 1 {
      let cidR: *u8 = sys_mmap(80)
      cid_of(pp[0] as *u8, ll[0], cidR)
      if ig_streq(cidR, cidB) == 1 {
          let g8: i64 = ss_get(prefix, "cap:search" as *u8, pp, ll)
          if g8 == 0 { ok = 1 }
      }
  } }
  ig_report(logfd, "reopen-determinism" as *u8, ok)
  passed = passed + ok
282
  // ---- fsync-durability (IM3): wrapper discriminates real fds, commit path green ----
  // sys_fsync must return 0 on a valid fd and EBADF on a junk fd (proves the
  // syscall is wired, not a no-op), and a commit through the fsync'd path
  // must still read back byte-exact.
  ok = 0
  let mfp: *u8 = sys_mmap(512)
  var mo: i64 = 0
  mo = ss_cat(mfp, mo, prefix)
  mo = ss_cat(mfp, mo, "manifest.txt" as *u8)
  mfp[mo] = 0 as u8
  let ffd: i64 = sys_openat_rd(mfp)
  if ffd >= 0 {
      let f1: i64 = sys_fsync(ffd)
      sys_close(ffd)
      let f2: i64 = sys_fsync(0 - 1)
      if f1 == 0 { if f2 == (0 - 9) {
          let q5: *i64 = sys_mmap(8 * 4) as *i64
          q5[0] = 1
          q5[1] = "cap:fsync" as *u8 as i64
          q5[2] = encA as i64
          q5[3] = lenA
          let st5: i64 = ig_child_write(prefix, 5, 1, q5, 1)
          if st5 == 0 {
              let g9: i64 = ss_get(prefix, "cap:fsync" as *u8, pp, ll)
              if g9 == 1 { if ig_memeq(pp[0] as *u8, encA, lenA) == 1 { ok = 1 } }
          }
      } }
  }
  ig_report(logfd, "fsync-durability" as *u8, ok)
  passed = passed + ok
313
  // ---- key-index-oracle (IM2): binary-search reads == chronological scan ----
  // The scan path is the ORACLE; the index must agree on verdict AND bytes
  // for every key state: live (cap:diora=v2), tombstoned (cap:search),
  // never-written (cap:ghost), fresh single-segment (cap:fsync).
  ok = 1
  let pp2: *i64 = sys_mmap(16) as *i64
  let ll2: *i64 = sys_mmap(16) as *i64
  let names9: *i64 = sys_mmap(8 * 4) as *i64
  names9[0] = "cap:diora" as *u8 as i64
  names9[1] = "cap:search" as *u8 as i64
  names9[2] = "cap:ghost" as *u8 as i64
  names9[3] = "cap:fsync" as *u8 as i64
  let hh: *i64 = ss_open(prefix)
  let pp3: *i64 = sys_mmap(16) as *i64
  let ll3: *i64 = sys_mmap(16) as *i64
  var ki: i64 = 0
  while ki < 4 {
      let kk: *u8 = names9[ki] as *u8
      let vs: i64 = ss_get(prefix, kk, pp, ll)
      let vi: i64 = ss_get_idx(prefix, kk, pp2, ll2)
      let vh: i64 = ss_hget(hh, kk, pp3, ll3)
      if vs != vi { ok = 0 }
      if vs != vh { ok = 0 }
      if vs == 1 { if vi == 1 {
          if ll[0] != ll2[0] { ok = 0 }
          if ok == 1 { if ig_memeq(pp[0] as *u8, pp2[0] as *u8, ll[0]) == 0 { ok = 0 } }
          if ll[0] != ll3[0] { ok = 0 }
          if ok == 1 { if ig_memeq(pp[0] as *u8, pp3[0] as *u8, ll[0]) == 0 { ok = 0 } }
      } }
      ki = ki + 1
  }
  ig_report(logfd, "key-index-oracle" as *u8, ok)
  passed = passed + ok
347
  // ---- term-postings-oracle (IM2b): postings path == brute-force tokenize ----
  // Expectation computed by the ORACLE path (ss_hget + ss_tok_has per key);
  // ss_term must return the same count AND every returned key's current
  // record must actually contain the term.  Terms chosen to exercise:
  // multi-hit ("diora": 2 records), shadowed-version + tombstone exclusion
  // ("production": only cap:diora's v2 -- cap:search had it but is
  // tombstoned), and the negative ("zzznope": 0).
  ok = 1
  let qterms: *i64 = sys_mmap(8 * 4) as *i64
  qterms[0] = "diora" as *u8 as i64
  qterms[1] = "production" as *u8 as i64
  qterms[2] = "zzznope" as *u8 as i64
  let tkp: *i64 = sys_mmap(8 * 20) as *i64
  let tkl: *i64 = sys_mmap(8 * 20) as *i64
  let kcopy: *u8 = sys_mmap(256)
  var exp_diora: i64 = 0
  var exp_prod: i64 = 0
  var qi: i64 = 0
  while qi < 3 {
      let qt: *u8 = qterms[qi] as *u8
      var exp: i64 = 0
      var oi: i64 = 0
      while oi < 4 {
          let g: i64 = ss_hget(hh, names9[oi] as *u8, pp3, ll3)
          if g == 1 { if ss_tok_has(pp3[0] as *u8, ll3[0], qt) == 1 { exp = exp + 1 } }
          oi = oi + 1
      }
      if qi == 0 { exp_diora = exp }
      if qi == 1 { exp_prod = exp }
      let got: i64 = ss_term(hh, qt, tkp, tkl, 16)
      if got != exp { ok = 0 }
      // membership: every returned key's current record contains the term
      var ri: i64 = 0
      while ri < got {
          var x: i64 = 0
          let ks: *u8 = tkp[ri] as *u8
          while x < tkl[ri] { kcopy[x] = ks[x]; x = x + 1 }
          kcopy[x] = 0 as u8
          let g2: i64 = ss_hget(hh, kcopy, pp3, ll3)
          if g2 != 1 { ok = 0 }
          if g2 == 1 { if ss_tok_has(pp3[0] as *u8, ll3[0], qt) == 0 { ok = 0 } }
          ri = ri + 1
      }
      qi = qi + 1
  }
  // sanity teeth: the multi-hit and single-hit expectations must be real
  if exp_diora != 2 { ok = 0 }
  if exp_prod != 1 { ok = 0 }
  ig_report(logfd, "term-postings-oracle" as *u8, ok)
  passed = passed + ok
398
  // ---- multi-term-and-oracle (IM2c): postings intersection == full-scan AND ----
  // ORACLE = for every known key: current bytes (ss_hget) contain ALL terms
  // (ss_tok_has, the same single tokenizer).  Queries chosen to exercise:
  //   q0 diora+production      -> 1  (cap:search ALSO had both but is
  //                                   tombstoned -- AND must exclude it)
  //   q1 diora+functional      -> 1  (cap:diora's v1 had both; its CURRENT
  //                                   v2 lost "functional" -- the stale
  //                                   version must NOT answer = currency)
  //   q2 diora+zzznope         -> 0  (empty intersection)
  //   q3 diora+layer+production-> 1  (3-term query)
  // Runs PRE-compaction so shadowed versions still sit in live segments.
  ok = 1
  let qn: *i64 = sys_mmap(8 * 8) as *i64
  let qts: *i64 = sys_mmap(8 * 16) as *i64
  qn[0] = 2
  qts[0] = "diora" as *u8 as i64
  qts[1] = "production" as *u8 as i64
  qn[1] = 2
  qts[3] = "diora" as *u8 as i64
  qts[4] = "functional" as *u8 as i64
  qn[2] = 2
  qts[6] = "diora" as *u8 as i64
  qts[7] = "zzznope" as *u8 as i64
  qn[3] = 3
  qts[9] = "diora" as *u8 as i64
  qts[10] = "layer" as *u8 as i64
  qts[11] = "production" as *u8 as i64
  let teeth: *i64 = sys_mmap(8 * 8) as *i64
  teeth[0] = 1
  teeth[1] = 1
  teeth[2] = 0
  teeth[3] = 1
  let akp: *i64 = sys_mmap(8 * 20) as *i64
  let akl: *i64 = sys_mmap(8 * 20) as *i64
  let aterms: *i64 = sys_mmap(8 * 4) as *i64
  var aq: i64 = 0
  while aq < 4 {
      let nt: i64 = qn[aq]
      var ti: i64 = 0
      while ti < nt { aterms[ti] = qts[aq * 3 + ti]; ti = ti + 1 }
      // oracle expectation: full scan of known keys, ALL terms in current bytes
      var exp: i64 = 0
      var oi: i64 = 0
      while oi < 4 {
          let g: i64 = ss_hget(hh, names9[oi] as *u8, pp3, ll3)
          if g == 1 {
              var all: i64 = 1
              ti = 0
              while ti < nt {
                  if ss_tok_has(pp3[0] as *u8, ll3[0], aterms[ti] as *u8) == 0 { all = 0 }
                  ti = ti + 1
              }
              if all == 1 { exp = exp + 1 }
          }
          oi = oi + 1
      }
      if exp != teeth[aq] { ok = 0 }
      let got: i64 = ss_term_and(hh, aterms, nt, akp, akl, 16)
      if got != exp { ok = 0 }
      // membership: every returned key's current record contains EVERY term
      var ri: i64 = 0
      while ri < got {
          var x: i64 = 0
          let ks: *u8 = akp[ri] as *u8
          while x < akl[ri] { kcopy[x] = ks[x]; x = x + 1 }
          kcopy[x] = 0 as u8
          let g2: i64 = ss_hget(hh, kcopy, pp3, ll3)
          if g2 != 1 { ok = 0 }
          if g2 == 1 {
              ti = 0
              while ti < nt {
                  if ss_tok_has(pp3[0] as *u8, ll3[0], aterms[ti] as *u8) == 0 { ok = 0 }
                  ti = ti + 1
              }
          }
          ri = ri + 1
      }
      aq = aq + 1
  }
  // single-term consistency: AND of one term == ss_term exactly
  aterms[0] = "diora" as *u8 as i64
  if ss_term_and(hh, aterms, 1, akp, akl, 16) != exp_diora { ok = 0 }
  ig_report(logfd, "multi-term-and-oracle" as *u8, ok)
  passed = passed + ok
483
  // ---- compaction-equivalence (IM4): get() identical across the fold ----
  // Pre-compaction expectations (proven by earlier rows): cap:diora=encB,
  // cap:search=GONE(0), cap:ghost=ABSENT(-1), cap:fsync=encA.  Compact, then
  // every key must answer IDENTICALLY on BOTH read paths, and the live
  // manifest must hold exactly the one merged segment.
  ok = 0
  let cseg: i64 = ss_compact(prefix, 9000001)
  if cseg == 9000001 {
      ok = 1
      let gd: i64 = ss_get(prefix, "cap:diora" as *u8, pp, ll)
      if gd != 1 { ok = 0 }
      if ok == 1 { if ig_memeq(pp[0] as *u8, encB, lenB) == 0 { ok = 0 } }
      let gdi: i64 = ss_get_idx(prefix, "cap:diora" as *u8, pp2, ll2)
      if gdi != 1 { ok = 0 }
      if ok == 1 { if ig_memeq(pp2[0] as *u8, encB, lenB) == 0 { ok = 0 } }
      if ss_get(prefix, "cap:search" as *u8, pp, ll) != 0 { ok = 0 }
      if ss_get_idx(prefix, "cap:search" as *u8, pp2, ll2) != 0 { ok = 0 }
      if ss_get(prefix, "cap:ghost" as *u8, pp, ll) != (0 - 1) { ok = 0 }
      if ss_get_idx(prefix, "cap:ghost" as *u8, pp2, ll2) != (0 - 1) { ok = 0 }
      let gf: i64 = ss_get(prefix, "cap:fsync" as *u8, pp, ll)
      if gf != 1 { ok = 0 }
      if ok == 1 { if ig_memeq(pp[0] as *u8, encA, lenA) == 0 { ok = 0 } }
      let ms2: i64 = ss_manifest(prefix, segs)
      if ms2 != 1 { ok = 0 }
      // term search survives the fold with identical answers (fresh handle)
      let hc: *i64 = ss_open(prefix)
      let ckp: *i64 = sys_mmap(8 * 20) as *i64
      let ckl: *i64 = sys_mmap(8 * 20) as *i64
      if ss_term(hc, "diora" as *u8, ckp, ckl, 16) != exp_diora { ok = 0 }
      if ss_term(hc, "production" as *u8, ckp, ckl, 16) != exp_prod { ok = 0 }
      if ss_term(hc, "zzznope" as *u8, ckp, ckl, 16) != 0 { ok = 0 }
      // AND queries survive the fold with identical answers
      aterms[0] = "diora" as *u8 as i64
      aterms[1] = "production" as *u8 as i64
      if ss_term_and(hc, aterms, 2, ckp, ckl, 16) != 1 { ok = 0 }
      aterms[1] = "functional" as *u8 as i64
      if ss_term_and(hc, aterms, 2, ckp, ckl, 16) != 1 { ok = 0 }
      aterms[1] = "zzznope" as *u8 as i64
      if ss_term_and(hc, aterms, 2, ckp, ckl, 16) != 0 { ok = 0 }
  }
  ig_report(logfd, "compaction-equivalence" as *u8, ok)
  passed = passed + ok
526
  // ---- compaction-archive (IM4): history files survive, archive names them ----
  ok = 1
  let arcp: *u8 = sys_mmap(512)
  var aro: i64 = 0
  aro = ss_cat(arcp, aro, prefix)
  aro = ss_cat(arcp, aro, "manifest-archive.txt" as *u8)
  arcp[aro] = 0 as u8
  let aszp: *i64 = sys_mmap(16) as *i64
  let ab: *u8 = ss_readall(arcp, aszp)
  if aszp[0] <= 0 { ok = 0 }
  // archive must list 4 retired segments (one line each)
  var alines: i64 = 0
  var ai: i64 = 0
  while ai < aszp[0] {
      if ab[ai] == (10 as u8) { alines = alines + 1 }
      ai = ai + 1
  }
  if alines != 4 { ok = 0 }
  // every retired segment's .docs file is STILL on disk and readable
  var sg: i64 = 1
  while sg < 6 {
      if sg != 4 {
          let sp9: *u8 = sys_mmap(512)
          ss_segname(prefix, sg, 0, sp9)
          let sfd9: i64 = sys_openat_rd(sp9)
          if sfd9 < 0 { ok = 0 }
          if sfd9 >= 0 { sys_close(sfd9) }
      }
      sg = sg + 1
  }
  ig_report(logfd, "compaction-archive" as *u8, ok)
  passed = passed + ok
559
  // ---- archive-time-travel (IM-AR): FULL history readable AFTER the fold ----
  // ss_scan_all = archived segments (srcs=0, chronological) then live (srcs=1).
  // Post-compaction expectations derive from the proven fixture history:
  //   cap:diora  -> 3 rows: archived v1=encA, archived v2=encB, live fold-copy
  //                 =encB (pre-fold history BYTE-EXACT = nothing destroyed)
  //   cap:search -> 3 rows: archived put=encB, archived TOMBSTONE, live
  //                 TOMBSTONE (deletes preserved in history)
  //   cap:fsync  -> 2 rows: archived encA, live encA
  //   cap:ghost  -> 0 rows (crash-written temp never entered ANY manifest)
  ok = 1
  let wsrc: *i64 = sys_mmap(8 * 260) as *i64
  let na1: i64 = ss_scan_all(prefix, "cap:diora" as *u8, kinds, ptrs, lens, wsrc)
  if na1 != 3 { ok = 0 }
  if ok == 1 {
      if kinds[0] != 1 { ok = 0 }
      if lens[0] != lenA { ok = 0 }
      if ok == 1 { if ig_memeq(ptrs[0] as *u8, encA, lenA) == 0 { ok = 0 } }
      if kinds[1] != 1 { ok = 0 }
      if lens[1] != lenB { ok = 0 }
      if ok == 1 { if ig_memeq(ptrs[1] as *u8, encB, lenB) == 0 { ok = 0 } }
      if kinds[2] != 1 { ok = 0 }
      if lens[2] != lenB { ok = 0 }
      if ok == 1 { if ig_memeq(ptrs[2] as *u8, encB, lenB) == 0 { ok = 0 } }
      if wsrc[0] != 0 { ok = 0 }
      if wsrc[1] != 0 { ok = 0 }
      if wsrc[2] != 1 { ok = 0 }
  }
  let na2: i64 = ss_scan_all(prefix, "cap:search" as *u8, kinds, ptrs, lens, wsrc)
  if na2 != 3 { ok = 0 }
  if ok == 1 {
      if kinds[0] != 1 { ok = 0 }
      if lens[0] != lenB { ok = 0 }
      if ok == 1 { if ig_memeq(ptrs[0] as *u8, encB, lenB) == 0 { ok = 0 } }
      if kinds[1] != 2 { ok = 0 }
      if kinds[2] != 2 { ok = 0 }
      if wsrc[1] != 0 { ok = 0 }
      if wsrc[2] != 1 { ok = 0 }
  }
  let na3: i64 = ss_scan_all(prefix, "cap:fsync" as *u8, kinds, ptrs, lens, wsrc)
  if na3 != 2 { ok = 0 }
  if ok == 1 {
      if lens[0] != lenA { ok = 0 }
      if lens[1] != lenA { ok = 0 }
      if ig_memeq(ptrs[0] as *u8, encA, lenA) == 0 { ok = 0 }
      if ig_memeq(ptrs[1] as *u8, encA, lenA) == 0 { ok = 0 }
      if wsrc[0] != 0 { ok = 0 }
      if wsrc[1] != 1 { ok = 0 }
  }
  if ss_scan_all(prefix, "cap:ghost" as *u8, kinds, ptrs, lens, wsrc) != 0 { ok = 0 }
  ig_report(logfd, "archive-time-travel" as *u8, ok)
  passed = passed + ok
611
  // ---- postings-scale-bulk: a 4097-doc segment commits AND is searchable ----
  // 4097 docs exceeds the OLD fixed 4096 docs/segment cap (which silently
  // emitted uninitialized doc offsets and dropped terms/pairs = silent
  // search misses).  Capacities are now DATA-DRIVEN from the writer size:
  // the bulk commit must SUCCEED, term search must count EXACTLY 4097
  // (every doc, none silently dropped), keyed reads of first/last bulk doc
  // and the prior store must answer byte-exact.
  ok = 0
  let wbig: *i64 = ss_begin()
  let kb9: *u8 = sys_mmap(64)
  var bi: i64 = 0
  var addrc: i64 = 0
  while bi < 4097 {
      var ko9: i64 = 0
      ko9 = ss_cat(kb9, ko9, "bulk:" as *u8)
      ko9 = ss_catn(kb9, ko9, bi)
      kb9[ko9] = 0 as u8
      if ss_add(wbig, 1, kb9, "vv bulkdoc" as *u8, 10) != 0 { addrc = 1 }
      bi = bi + 1
  }
  let crc: i64 = ss_commit(prefix, wbig, 7777)
  if addrc == 0 { if crc == 0 {
      let ms9: i64 = ss_manifest(prefix, segs)
      if ms9 == 2 {
          let hb: *i64 = ss_open(prefix)
          let bkp: *i64 = sys_mmap(8 * 4200) as *i64
          let bkl: *i64 = sys_mmap(8 * 4200) as *i64
          let nvv: i64 = ss_term(hb, "bulkdoc" as *u8, bkp, bkl, 4200)
          if nvv == 4097 {
              let gf1: i64 = ss_hget(hb, "bulk:0" as *u8, pp3, ll3)
              let gf2: i64 = ss_hget(hb, "bulk:4096" as *u8, pp3, ll3)
              if gf1 == 1 { if gf2 == 1 { if ll3[0] == 10 {
                  let g10: i64 = ss_get(prefix, "cap:diora" as *u8, pp, ll)
                  if g10 == 1 { if ig_memeq(pp[0] as *u8, encB, lenB) == 1 { ok = 1 } }
              } } }
          }
      }
  } }
  ig_report(logfd, "postings-scale-bulk" as *u8, ok)
  passed = passed + ok
652
  let permil: i64 = (passed * 1000) / IG_ROWS
  var fdi: i64 = 0
  while fdi < 2 {
      var fd: i64 = 1
      if fdi == 1 { fd = logfd }
      if fd > 0 {
          ig_fp(fd, "INFOMGMT-GATE rows=" as *u8)
          ig_fn(fd, IG_ROWS)
          ig_fp(fd, " passed=" as *u8)
          ig_fn(fd, passed)
          ig_fp(fd, " permil=" as *u8)
          ig_fn(fd, permil)
          if passed == IG_ROWS { ig_fp(fd, " verdict=GREEN\n" as *u8) }
          if passed != IG_ROWS { ig_fp(fd, " verdict=RED\n" as *u8) }
      }
      fdi = fdi + 1
  }
  if logfd > 0 { sys_close(logfd) }
  // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
  // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
  // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
  let ctr__dry: *i64 = gv_ctr()
  ctr__dry[0] = passed
  ctr__dry[1] = IG_ROWS
  let rc__dry: i64 = gv_verdict("INFOMGMT-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
680}
nx_infomgmt_gate.nx source

`nx_infomgmt_gate.nx` source
