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

↩ module page · 293 lines · 12203 B
1// nx_vizsla_jobs_gate.nx -- VIZSLA V2a gate: the job-search engine is gate-proven
2// against a FIXTURE CORPUS with hand-computed best-match order (the oracle is
3// arithmetic in this header, not the module under test).
4//
5// profile: ada SKILL nishilang=300 compilers=200 writing=100;
6//          bea SKILL editing=400 writing=100; CLOSED rejected/accepted/withdrawn
7// postings: j1 9000000 [compilers rust writing]   j2 12000000 [nishilang compilers systems]
8//           j3 7500000 [sales travel]             j4 8000000 [editing writing remote]
9// hand scores: ada j1=300 j2=500 j3=0 j4=100 -> rank j2,j1,j4,j3 matched=3
10//              bea j1=100 j2=0  j3=0 j4=500 -> rank j4,j1,(j2,j3 file order) matched=2
11// apps: j2 applied -> j1 applied -> j2 interview -> j1 rejected
12//   => cadence: j2 last=interview OPEN follow-up; j1 last=rejected CLOSED suppressed
13//   => VERDICT apps=4 posts=2 open=1 closed=1
14//
15// Rows:
16//   1 loud-fail        missing profile => exit 1
17//   2 best-match-order ada rank1=j2 score=500 + rank2=j1 score=300 exact
18//   3 zero-score-named j3 printed at rank4 score=0 AND verdict matched=3 (never dropped)
19//   4 multi-member     bea rank1=j4 score=500 (data-driven per-member ranking)
20//   5 match-determinism twice => byte-identical
21//   6 track-load       4 apps -> new=4 committed seg-2001
22//   7 idempotent       re-track => new=0 dup_instore=4 segment=none (law 10)
23//   8 cadence-last     j2 last=interview action=follow-up (last status wins)
24//   9 closed-honest    NO j1 cadence row BUT verdict apps=4 posts=2 open=1 closed=1
25//                      (suppressed from cadence, kept in history)
26//  10 cadence-determinism twice => byte-identical
27// Evidence: VIZSLA-JOBS-GATE line -> stdout + knowledge/status/vizsla_gate.log;
28// exit 0 iff 10/10.
29// spec: knowledge/specs/2026-06-10-nishi-vizsla-ladder.md   license_tier: ORIGINAL
30import "nx_syscalls.nx"
31import "nx_gate_verdict.nx"
32
33func jg_slen(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  return n
37}
38
39func jg_p(s: *u8) -> i64 {
  sys_write(1, s, jg_slen(s))
  return 0
42}
43
44func jg_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { dst[off + i] = s[i]; i = i + 1 }
  return off + i
48}
49
50func jg_catn(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64 = off
  var m: i64 = v
  if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m }
  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 { dst[o + i] = t[k - 1 - i]; i = i + 1 }
  return o + k
61}
62
63func jg_write(path: *u8, content: *u8) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, content, jg_slen(content))
  sys_close(fd)
  return 0
69}
70
71func jg_readall(path: *u8, szout: *i64) -> *u8 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { szout[0] = 0 - 1; return 0 as *u8 }
  let sz: i64 = sys_lseek(fd, 0, 2)
  sys_lseek(fd, 0, 0)
  let buf: *u8 = sys_mmap(sz + 64)
  var got: i64 = 0
  var n: i64 = 1
  while n > 0 {
      n = sys_read(fd, (buf as i64 + got) as *u8, 65536)
      if n > 0 { got = got + n }
  }
  sys_close(fd)
  szout[0] = got
  return buf
86}
87
88func jg_run(elf: *u8, a1: *u8, a2: *u8, a3: *u8, a4: *u8, outpath: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      if (outpath as i64) != 0 {
          let ofd: i64 = sys_openat_wr(outpath, 0x1a4)
          if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_dup3(ofd, 2, 0) }
      }
      let argv: *i64 = sys_mmap(64) as *i64
      argv[0] = elf as i64
      var i: i64 = 1
      if (a1 as i64) != 0 { argv[i] = a1 as i64; i = i + 1 }
      if (a2 as i64) != 0 { argv[i] = a2 as i64; i = i + 1 }
      if (a3 as i64) != 0 { argv[i] = a3 as i64; i = i + 1 }
      if (a4 as i64) != 0 { argv[i] = a4 as i64; i = i + 1 }
      argv[i] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve(elf, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  let sig: i64 = st[0] & 0x7f
  if sig != 0 { return 128 + sig }
  return (st[0] >> 8) & 0xff
113}
114
115func jg_has(path: *u8, needle: *u8) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = jg_readall(path, szp)
  let sz: i64 = szp[0]
  let n: i64 = jg_slen(needle)
  if sz < n { return 0 }
  var i: i64 = 0
  while i + n <= sz {
      var ok: i64 = 1
      var j: i64 = 0
      while j < n {
          if b[i + j] != needle[j] { ok = 0; j = n } else { j = j + 1 }
      }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
132}
133
134func jg_fileeq(p1: *u8, p2: *u8) -> i64 {
  let s1: *i64 = sys_mmap(16) as *i64
  let s2: *i64 = sys_mmap(16) as *i64
  let b1: *u8 = jg_readall(p1, s1)
  let b2: *u8 = jg_readall(p2, s2)
  if s1[0] != s2[0] { return 0 }
  if s1[0] <= 0 { return 0 }
  var i: i64 = 0
  while i < s1[0] {
      if b1[i] != b2[i] { return 0 }
      i = i + 1
  }
  return 1
147}
148
149func jg_row(name: *u8, pass: i64) -> i64 {
  jg_p("ROW " as *u8)
  jg_p(name)
  if pass == 1 { jg_p(" PASS\n" as *u8) } else { jg_p(" FAIL\n" as *u8) }
  return pass
154}
155
156func main(argc: i64, argv: *i64) -> i64 {
  jg_p("=== VIZSLA JOBS GATE: fixture-corpus best-match KATs (hand-computed order) ===\n" as *u8)
  var jb: *u8 = "buildroot/_build/nx_vizsla_jobs.sov.elf" as *u8
  if argc > 1 { jb = argv[1] as *u8 }
  let pr: i64 = sys_openat_rd(jb)
  if pr >= 0 { sys_close(pr) }
  else {
      jg_p(" instrument missing -> rebuilding via durable runner\n" as *u8)
      jg_run("_offc/nx_sov_build_run.elf" as *u8, "nx_vizsla_jobs" as *u8, 0 as *u8, 0 as *u8, 0 as *u8, "/tmp/vzj_rebuild.out" as *u8)
  }
166
  // epoch-unique virgin store prefix for the tracker
  let pfx: *u8 = sys_mmap(128)
  var po: i64 = 0
  po = jg_cat(pfx, po, "/tmp/vzjG" as *u8)
  po = jg_catn(pfx, po, sys_now_us())
  po = jg_cat(pfx, po, "-" as *u8)
  pfx[po] = 0 as u8
174
  let prof: *u8 = "SEEK ada\nSKILL ada 300 nishilang\nSKILL ada 200 compilers\nSKILL ada 100 writing\nSEEK bea\nSKILL bea 400 editing\nSKILL bea 100 writing\nCLOSED rejected\nCLOSED accepted\nCLOSED withdrawn\n" as *u8
  jg_write("/tmp/vzj_prof.txt" as *u8, prof)
  let posts: *u8 = "POST j1 9000000 compilers rust writing\nPOST j2 12000000 nishilang compilers systems\nPOST j3 7500000 sales travel\nPOST j4 8000000 editing writing remote\n" as *u8
  jg_write("/tmp/vzj_posts.txt" as *u8, posts)
  let apps: *u8 = "APP 2026-06-01 j2 ada applied first-pass\nAPP 2026-06-03 j1 ada applied backup\nAPP 2026-06-05 j2 ada interview phone-screen\nAPP 2026-06-06 j1 ada rejected form-letter\n" as *u8
  jg_write("/tmp/vzj_apps.txt" as *u8, apps)
181
  let fp: *u8 = "/tmp/vzj_prof.txt" as *u8
  let fo: *u8 = "/tmp/vzj_posts.txt" as *u8
  let flog: *u8 = "/tmp/vzj_fix.log" as *u8
  var pass: i64 = 0
  var r: i64 = 0
187
  // row 1: loud-fail on missing profile
  let rc1: i64 = jg_run(jb, "match" as *u8, "/tmp/vzj_prof_NOPE.txt" as *u8, fo, flog, "/tmp/vzj_out1.txt" as *u8)
  r = 0
  if rc1 == 1 { r = 1 }
  pass = pass + jg_row("loud-fail-missing-profile" as *u8, r)
193
  // row 2: hand-computed best-match order for ada
  let rc2: i64 = jg_run(jb, "match" as *u8, fp, fo, flog, "/tmp/vzj_out2.txt" as *u8)
  r = 0
  if rc2 == 0 {
      if jg_has("/tmp/vzj_out2.txt" as *u8, "VIZSLA-JOBS-MATCH member=ada rank=1 post=j2 score=500 pay=12000000" as *u8) == 1 {
          if jg_has("/tmp/vzj_out2.txt" as *u8, "VIZSLA-JOBS-MATCH member=ada rank=2 post=j1 score=300 pay=9000000" as *u8) == 1 { r = 1 }
      }
  }
  pass = pass + jg_row("best-match-order" as *u8, r)
203
  // row 3: zero-score posting PRINTED + matched counts only score>0
  r = 0
  if jg_has("/tmp/vzj_out2.txt" as *u8, "VIZSLA-JOBS-MATCH member=ada rank=4 post=j3 score=0" as *u8) == 1 {
      if jg_has("/tmp/vzj_out2.txt" as *u8, "VIZSLA-JOBS-VERDICT member=ada postings=4 matched=3" as *u8) == 1 { r = 1 }
  }
  pass = pass + jg_row("zero-score-named-not-dropped" as *u8, r)
210
  // row 4: second member ranks differently from the SAME corpus (model is data)
  r = 0
  if jg_has("/tmp/vzj_out2.txt" as *u8, "VIZSLA-JOBS-MATCH member=bea rank=1 post=j4 score=500 pay=8000000" as *u8) == 1 {
      if jg_has("/tmp/vzj_out2.txt" as *u8, "VIZSLA-JOBS-VERDICT member=bea postings=4 matched=2" as *u8) == 1 { r = 1 }
  }
  pass = pass + jg_row("multi-member-data-driven" as *u8, r)
217
  // row 5: match determinism
  jg_run(jb, "match" as *u8, fp, fo, flog, "/tmp/vzj_out5.txt" as *u8)
  r = jg_fileeq("/tmp/vzj_out2.txt" as *u8, "/tmp/vzj_out5.txt" as *u8)
  pass = pass + jg_row("match-determinism" as *u8, r)
222
  // row 6: track 4 applications into seg-2001
  let rc6: i64 = jg_run(jb, "track" as *u8, "/tmp/vzj_apps.txt" as *u8, pfx, "2001" as *u8, "/tmp/vzj_out6.txt" as *u8)
  r = 0
  if rc6 == 0 {
      if jg_has("/tmp/vzj_out6.txt" as *u8, "VIZSLA-JOBS-TRACK scanned=4 new=4 dup_infile=0 dup_instore=0 segment=seg-2001" as *u8) == 1 { r = 1 }
  }
  pass = pass + jg_row("track-load" as *u8, r)
230
  // row 7: idempotent re-track (law 10)
  let rc7: i64 = jg_run(jb, "track" as *u8, "/tmp/vzj_apps.txt" as *u8, pfx, "2009" as *u8, "/tmp/vzj_out7.txt" as *u8)
  r = 0
  if rc7 == 0 {
      if jg_has("/tmp/vzj_out7.txt" as *u8, "VIZSLA-JOBS-TRACK scanned=4 new=0 dup_infile=0 dup_instore=4 segment=none" as *u8) == 1 { r = 1 }
  }
  pass = pass + jg_row("idempotent-retrack" as *u8, r)
238
  // row 8: cadence -- last status wins (j2 applied then interview => interview)
  let rc8: i64 = jg_run(jb, "cadence" as *u8, pfx, fp, 0 as *u8, "/tmp/vzj_out8.txt" as *u8)
  r = 0
  if rc8 == 0 {
      if jg_has("/tmp/vzj_out8.txt" as *u8, "VIZSLA-JOBS-CADENCE post=j2 member=ada last=interview action=follow-up" as *u8) == 1 { r = 1 }
  }
  pass = pass + jg_row("cadence-last-status-wins" as *u8, r)
246
  // row 9: closed app suppressed from cadence, still counted in history
  r = 0
  if jg_has("/tmp/vzj_out8.txt" as *u8, "VIZSLA-JOBS-CADENCE post=j1" as *u8) == 0 {
      if jg_has("/tmp/vzj_out8.txt" as *u8, "VIZSLA-JOBS-CADENCE-VERDICT apps=4 posts=2 open=1 closed=1" as *u8) == 1 { r = 1 }
  }
  pass = pass + jg_row("closed-suppressed-history-kept" as *u8, r)
253
  // row 10: cadence determinism
  jg_run(jb, "cadence" as *u8, pfx, fp, 0 as *u8, "/tmp/vzj_out10.txt" as *u8)
  r = jg_fileeq("/tmp/vzj_out8.txt" as *u8, "/tmp/vzj_out10.txt" as *u8)
  pass = pass + jg_row("cadence-determinism" as *u8, r)
258
  let permil: i64 = (pass * 1000) / 10
  let logfd: i64 = sys_openat_append("knowledge/status/vizsla_gate.log" as *u8, 0x1a4)
  var fdi: i64 = 0
  while fdi < 2 {
      var fd: i64 = 1
      if fdi == 1 { fd = logfd }
      if fd > 0 {
          let line: *u8 = sys_mmap(256)
          var o: i64 = 0
          o = jg_cat(line, o, "VIZSLA-JOBS-GATE epoch=" as *u8)
          o = jg_catn(line, o, sys_now_realtime_sec())
          o = jg_cat(line, o, " rows=10 pass=" as *u8)
          o = jg_catn(line, o, pass)
          o = jg_cat(line, o, " permil=" as *u8)
          o = jg_catn(line, o, permil)
          if pass == 10 {
              o = jg_cat(line, o, " verdict=GREEN\n" as *u8)
          } else {
              o = jg_cat(line, o, " verdict=RED\n" as *u8)
          }
          sys_write(fd, line, o)
      }
      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] = pass
  ctr__dry[1] = 10
  let rc__dry: i64 = gv_verdict("VIZSLA-JOBS-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
293}
nx_vizsla_jobs_gate.nx source

`nx_vizsla_jobs_gate.nx` source
