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

↩ module page · 665 lines · 24120 B
1// nx_vizsla_jobs.nx -- NISHI VIZSLA V2a: the job-search engine (career domain).
2// Fills career/AUTHOR (job-search-engine) + career/EDITOR (application-tracker)
3// from the V0 gap profile.  V2a = match scoring + tracker + cadence against a
4// FIXTURE-ORACLE corpus; V2b (named follow-on, Market Researcher lane) = live
5// posting census via own-TLS entity-gather feeding the same postings format.
6//
7// Commands (argv[1]):
8//   match  <profile> <postings> [log]    score every posting for every SEEK
9//                                        member: score = sum of that member's
10//                                        SKILL weights whose term appears in
11//                                        the posting's term list.  Rank rows
12//                                        score-desc (file order breaks ties);
13//                                        zero-score postings are PRINTED not
14//                                        dropped (matched= counts score>0).
15//   track  <appfile> <prefix> [segid]    APP rows -> canonical records -> CID
16//                                        keys "app:nxc1-..." on seg_store =
17//                                        IDEMPOTENT additive application
18//                                        history (same law/substrate as V1).
19//   cadence <prefix> <profile>           walk the app history chronologically;
20//                                        LAST status per posting wins; posting
21//                                        whose last status is not in the
22//                                        profile's CLOSED set gets a follow-up
23//                                        row.  Closed apps are suppressed from
24//                                        cadence but stay in history (additive).
25//
26// File formats (line records, # comments; ALL model data in files, law 11/25):
27//   profile:  SEEK <member>
28//             SKILL <member> <weight> <term>
29//             CLOSED <status>              (statuses that need no follow-up)
30//   postings: POST <id> <pay_cents> <term> <term> ...
31//   apps:     APP <date> <post-id> <member> <status> <note>
32//
33// Determinism: stdout has no clocks; epoch headers go to logs only (match log
34// argv-overridable; track/cadence log derived from store prefix = fixture
35// isolation).  Loud-fail law: missing files, SKILL for unknown member,
36// non-digit pay/weight = exit 1 named.
37// EXCEED (V2a): ranking is the FAMILY'S fit function -- data-edited skill
38// weights -- not an ad-funded board's pay-to-play order; cadence is the
39// editor-fill that closes application loops.  Reach EXCEED lands with V2b.
40// spec: knowledge/specs/2026-06-10-nishi-vizsla-ladder.md   license_tier: ORIGINAL
41import "nx_syscalls.nx"
42import "nx_canon_cid.nx"
43import "nx_seg_store.nx"
44const K_MAGIC_4096: i64 = 4096
45const K_MAGIC_131072: i64 = 131072
46const K_MAGIC_2048: i64 = 2048
47const K_MAGIC_65536: i64 = 65536
48
49func vj_slen(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  return n
53}
54
55func vj_p(s: *u8) -> i64 {
  sys_write(1, s, vj_slen(s))
  return 0
58}
59
60func vj_eq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if a[i] != b[i] { return 0 }
      if a[i] == (0 as u8) { return 1 }
      i = i + 1
  }
  return 0
69}
70
71func vj_dup(s: *u8) -> *u8 {
  let n: i64 = vj_slen(s)
  let d: *u8 = sys_mmap(n + 2)
  var i: i64 = 0
  while i <= n { d[i] = s[i]; i = i + 1 }
  return d
77}
78
79func vj_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while s[i] != (0 as u8) {
      let d: i64 = (s[i] as i64) - 48
      if d >= 0 { if d <= 9 { v = v * 10 + d } }
      i = i + 1
  }
  return v
88}
89
90func vj_digits(s: *u8) -> i64 {
  if s[0] == (0 as u8) { return 0 }
  var i: i64 = 0
  while s[i] != (0 as u8) {
      let d: i64 = (s[i] as i64) - 48
      if d < 0 { return 0 }
      if d > 9 { return 0 }
      i = i + 1
  }
  return 1
100}
101
102func vj_isws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 13 { return 1 }
  if c == 9 { return 1 }
  return 0
107}
108
109func vj_tok(b: *u8, off: i64, lend: i64, dst: *u8, cap: i64) -> i64 {
  var p: i64 = off
  var go: i64 = 1
  while go == 1 {
      if p >= lend { go = 0 } else {
          if vj_isws(b[p] as i64) == 1 { p = p + 1 } else { go = 0 }
      }
  }
  var t: i64 = 0
  go = 1
  while go == 1 {
      if p >= lend { go = 0 } else {
          if vj_isws(b[p] as i64) == 1 { go = 0 } else {
              if t < cap - 1 { dst[t] = b[p]; t = t + 1 }
              p = p + 1
          }
      }
  }
  dst[t] = 0 as u8
  return p
129}
130
131func vj_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
135}
136
137func vj_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
148}
149
150func vj_find(list: *i64, n: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < n {
      if vj_eq(list[i] as *u8, s) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
157}
158
159func vj_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
  if vj_slen(s) != n { return 0 }
  var i: i64 = 0
  while i < n {
      if b[off + i] != s[i] { return 0 }
      i = i + 1
  }
  return 1
167}
168
169func vj_field(rec: *u8, rl: i64, want: *u8, out: *u8, cap: i64) -> i64 {
  if rl < 8 { return 0 }
  let nf: i64 = ss_r32(rec, 4)
  var off: i64 = 8
  var fi: i64 = 0
  while fi < nf {
      if off + 8 > rl { return 0 }
      let kl: i64 = ss_r32(rec, off)
      let koff: i64 = off + 4
      let vl: i64 = ss_r32(rec, koff + kl)
      let voff: i64 = koff + kl + 4
      if vj_kmemeq(rec, koff, kl, want) == 1 {
          var t: i64 = 0
          while t < vl {
              if t < cap - 1 { out[t] = rec[voff + t] }
              t = t + 1
          }
          if t > cap - 1 { t = cap - 1 }
          out[t] = 0 as u8
          return 1
      }
      off = voff + vl
      fi = fi + 1
  }
  return 0
194}
195
196func vj_isapp(b: *u8, koff: i64, kl: i64) -> i64 {
  if kl <= 4 { return 0 }
  return vj_kmemeq(b, koff, 4, "app:" as *u8)
199}
200
201func vj_log(lpath: *u8, tag: *u8, rep: *u8, o: i64) -> i64 {
  let fd: i64 = sys_openat_append(lpath, 0x1a4)
  if fd <= 0 { return 0 }
  let hdr: *u8 = sys_mmap(256)
  var ho: i64 = 0
  ho = vj_cat(hdr, ho, "VIZSLA-JOBS epoch=" as *u8)
  ho = vj_catn(hdr, ho, sys_now_realtime_sec())
  ho = vj_cat(hdr, ho, " cmd=" as *u8)
  ho = vj_cat(hdr, ho, tag)
  ho = vj_cat(hdr, ho, "\n" as *u8)
  sys_write(fd, hdr, ho)
  sys_write(fd, rep, o)
  sys_close(fd)
  return 0
215}
216
217func vj_prefixlog(prefix: *u8, out: *u8) -> i64 {
  var o: i64 = 0
  o = vj_cat(out, o, prefix)
  o = vj_cat(out, o, "jobs.log" as *u8)
  out[o] = 0 as u8
  return o
223}
224
225// score one member's skills against a posting's term slice
226// sk: [0]=sk_mem [1]=sk_w [2]=sk_term [3]=nskill ; terms = ptr-list slice
227func vj_score(sk: *i64, mi: i64, terms: *i64, nterm: i64) -> i64 {
  let sk_mem: *i64 = sk[0] as *i64
  let sk_w: *i64 = sk[1] as *i64
  let sk_term: *i64 = sk[2] as *i64
  var sum: i64 = 0
  var si: i64 = 0
  while si < sk[3] {
      if sk_mem[si] == mi {
          if vj_find(terms, nterm, sk_term[si] as *u8) >= 0 { sum = sum + sk_w[si] }
      }
      si = si + 1
  }
  return sum
240}
241
242// ---------------- MATCH ----------------
243func vj_cmd_match(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vj_p("VIZSLA-JOBS match needs <profile> <postings> -- fail loud\n" as *u8); return 1 }
  let ppath: *u8 = argv[2] as *u8
  let opath: *u8 = argv[3] as *u8
  var lpath: *u8 = "knowledge/status/vizsla_jobs.log" as *u8
  if argc > 4 { lpath = argv[4] as *u8 }
249
  let szp: *i64 = sys_mmap(16) as *i64
  let pb: *u8 = ss_readall(ppath, szp)
  let psz: i64 = szp[0]
  if psz <= 0 { vj_p("VIZSLA-JOBS profile MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
  let ob: *u8 = ss_readall(opath, szp)
  let osz: i64 = szp[0]
  if osz <= 0 { vj_p("VIZSLA-JOBS postings MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
257
  // profile tables (capacities = buffer sizes, model shape = file content)
  let seeks: *i64 = sys_mmap(8 * 16) as *i64
  var nseek: i64 = 0
  let sk: *i64 = sys_mmap(8 * 8) as *i64
  sk[0] = sys_mmap(8 * 128)
  sk[1] = sys_mmap(8 * 128)
  sk[2] = sys_mmap(8 * 128)
  sk[3] = 0
  let sk_mem: *i64 = sk[0] as *i64
  let sk_w: *i64 = sk[1] as *i64
  let sk_term: *i64 = sk[2] as *i64
269
  let t0: *u8 = sys_mmap(128)
  let t1: *u8 = sys_mmap(128)
  let t2: *u8 = sys_mmap(128)
  let t3: *u8 = sys_mmap(128)
274
  var i: i64 = 0
  while i < psz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 {
          if e >= psz { go = 0 } else {
              if pb[e] == (10 as u8) { go = 0 } else { e = e + 1 }
          }
      }
      var p: i64 = vj_tok(pb, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vj_eq(t0, "SEEK" as *u8) == 1 {
          p = vj_tok(pb, p, e, t1, 128)
          if nseek < 16 { seeks[nseek] = vj_dup(t1) as i64; nseek = nseek + 1 }
      }
      if vj_eq(t0, "SKILL" as *u8) == 1 {
          p = vj_tok(pb, p, e, t1, 128)
          p = vj_tok(pb, p, e, t2, 128)
          p = vj_tok(pb, p, e, t3, 128)
          let mi: i64 = vj_find(seeks, nseek, t1)
          if mi < 0 { vj_p("VIZSLA-JOBS SKILL references unknown member -- fail loud\n" as *u8); return 1 }
          if vj_digits(t2) == 0 { vj_p("VIZSLA-JOBS SKILL weight not pure digits -- fail loud\n" as *u8); return 1 }
          if sk[3] < 128 {
              sk_mem[sk[3]] = mi
              sk_w[sk[3]] = vj_atoi(t2)
              sk_term[sk[3]] = vj_dup(t3) as i64
              sk[3] = sk[3] + 1
          }
      }
      i = e + 1
  }
  if nseek < 1 { vj_p("VIZSLA-JOBS no SEEK members in profile -- fail loud\n" as *u8); return 1 }
  if sk[3] < 1 { vj_p("VIZSLA-JOBS no SKILL rows in profile -- fail loud\n" as *u8); return 1 }
308
  // postings: ids, pay, flat term ptr-list with per-post start/count
  let po_id: *i64 = sys_mmap(8 * 256) as *i64
  let po_pay: *i64 = sys_mmap(8 * 256) as *i64
  let po_ts: *i64 = sys_mmap(8 * 256) as *i64
  let po_tn: *i64 = sys_mmap(8 * 256) as *i64
  var npost: i64 = 0
  let terms: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
  var nterm: i64 = 0
317
  i = 0
  while i < osz {
      var e2: i64 = i
      var go2: i64 = 1
      while go2 == 1 {
          if e2 >= osz { go2 = 0 } else {
              if ob[e2] == (10 as u8) { go2 = 0 } else { e2 = e2 + 1 }
          }
      }
      var p2: i64 = vj_tok(ob, i, e2, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vj_eq(t0, "POST" as *u8) == 1 {
          p2 = vj_tok(ob, p2, e2, t1, 128)
          p2 = vj_tok(ob, p2, e2, t2, 128)
          if t1[0] == (0 as u8) { vj_p("VIZSLA-JOBS POST missing id -- fail loud\n" as *u8); return 1 }
          if vj_digits(t2) == 0 { vj_p("VIZSLA-JOBS POST pay not pure digits -- fail loud\n" as *u8); return 1 }
          if npost < 256 {
              po_id[npost] = vj_dup(t1) as i64
              po_pay[npost] = vj_atoi(t2)
              po_ts[npost] = nterm
              var tn: i64 = 0
              var more: i64 = 1
              while more == 1 {
                  p2 = vj_tok(ob, p2, e2, t3, 128)
                  if t3[0] == (0 as u8) { more = 0 } else {
                      if nterm < K_MAGIC_4096 { terms[nterm] = vj_dup(t3) as i64; nterm = nterm + 1; tn = tn + 1 }
                  }
              }
              po_tn[npost] = tn
              npost = npost + 1
          }
      }
      i = e2 + 1
  }
  if npost < 1 { vj_p("VIZSLA-JOBS no POST rows -- fail loud\n" as *u8); return 1 }
353
  // rank per member: selection over score desc, file order breaks ties
  let rep: *u8 = sys_mmap(K_MAGIC_131072)
  var o: i64 = 0
  let score: *i64 = sys_mmap(8 * 256) as *i64
  let used: *i64 = sys_mmap(8 * 256) as *i64
  var mi2: i64 = 0
  while mi2 < nseek {
      var pi: i64 = 0
      var matched: i64 = 0
      while pi < npost {
          let slice: *i64 = ((terms as i64) + po_ts[pi] * 8) as *i64
          score[pi] = vj_score(sk, mi2, slice, po_tn[pi])
          if score[pi] > 0 { matched = matched + 1 }
          used[pi] = 0
          pi = pi + 1
      }
      var rank: i64 = 1
      while rank <= npost {
          var best: i64 = 0 - 1
          var bs: i64 = 0 - 1
          pi = 0
          while pi < npost {
              var take: i64 = 0
              if used[pi] == 0 { if score[pi] > bs { take = 1 } }
              if take == 1 { bs = score[pi]; best = pi }
              pi = pi + 1
          }
          used[best] = 1
          o = vj_cat(rep, o, "VIZSLA-JOBS-MATCH member=" as *u8)
          o = vj_cat(rep, o, seeks[mi2] as *u8)
          o = vj_cat(rep, o, " rank=" as *u8)
          o = vj_catn(rep, o, rank)
          o = vj_cat(rep, o, " post=" as *u8)
          o = vj_cat(rep, o, po_id[best] as *u8)
          o = vj_cat(rep, o, " score=" as *u8)
          o = vj_catn(rep, o, score[best])
          o = vj_cat(rep, o, " pay=" as *u8)
          o = vj_catn(rep, o, po_pay[best])
          o = vj_cat(rep, o, "\n" as *u8)
          rank = rank + 1
      }
      o = vj_cat(rep, o, "VIZSLA-JOBS-VERDICT member=" as *u8)
      o = vj_cat(rep, o, seeks[mi2] as *u8)
      o = vj_cat(rep, o, " postings=" as *u8)
      o = vj_catn(rep, o, npost)
      o = vj_cat(rep, o, " matched=" as *u8)
      o = vj_catn(rep, o, matched)
      o = vj_cat(rep, o, "\n" as *u8)
      mi2 = mi2 + 1
  }
  sys_write(1, rep, o)
  vj_log(lpath, "match" as *u8, rep, o)
  return 0
407}
408
409// ---------------- TRACK (additive application history) ----------------
410func vj_cmd_track(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vj_p("VIZSLA-JOBS track needs <appfile> <prefix> -- fail loud\n" as *u8); return 1 }
  let apath: *u8 = argv[2] as *u8
  let prefix: *u8 = argv[3] as *u8
  var segid: i64 = 0
  if argc > 4 { segid = vj_atoi(argv[4] as *u8) }
  if segid == 0 { segid = sys_now_us() }
417
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = ss_readall(apath, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { vj_p("VIZSLA-JOBS appfile MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
422
  let keys: *i64 = sys_mmap(8 * 8) as *i64
  let vals: *i64 = sys_mmap(8 * 8) as *i64
  keys[0] = "kind" as *u8 as i64
  keys[1] = "date" as *u8 as i64
  keys[2] = "post" as *u8 as i64
  keys[3] = "member" as *u8 as i64
  keys[4] = "status" as *u8 as i64
  keys[5] = "note" as *u8 as i64
  vals[0] = "app" as *u8 as i64
432
  let t0: *u8 = sys_mmap(128)
  let dt: *u8 = sys_mmap(128)
  let po: *u8 = sys_mmap(128)
  let me: *u8 = sys_mmap(128)
  let stt: *u8 = sys_mmap(128)
  let nt: *u8 = sys_mmap(256)
  let pp: *i64 = sys_mmap(16) as *i64
  let ll: *i64 = sys_mmap(16) as *i64
441
  let w: *i64 = ss_begin()
  let seen: *i64 = sys_mmap(8 * K_MAGIC_2048) as *i64
  var nseen: i64 = 0
  var scanned: i64 = 0
  var added: i64 = 0
  var dup_infile: i64 = 0
  var dup_instore: i64 = 0
449
  var i: i64 = 0
  while i < sz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 {
          if e >= sz { go = 0 } else {
              if b[e] == (10 as u8) { go = 0 } else { e = e + 1 }
          }
      }
      var p: i64 = vj_tok(b, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vj_eq(t0, "APP" as *u8) == 1 {
          scanned = scanned + 1
          p = vj_tok(b, p, e, dt, 128)
          p = vj_tok(b, p, e, po, 128)
          p = vj_tok(b, p, e, me, 128)
          p = vj_tok(b, p, e, stt, 128)
          p = vj_tok(b, p, e, nt, 256)
          if dt[0] == (0 as u8) { vj_p("VIZSLA-JOBS APP missing date -- fail loud\n" as *u8); return 1 }
          if po[0] == (0 as u8) { vj_p("VIZSLA-JOBS APP missing post-id -- fail loud\n" as *u8); return 1 }
          if me[0] == (0 as u8) { vj_p("VIZSLA-JOBS APP missing member -- fail loud\n" as *u8); return 1 }
          if stt[0] == (0 as u8) { vj_p("VIZSLA-JOBS APP missing status -- fail loud\n" as *u8); return 1 }
          if nt[0] == (0 as u8) { vj_p("VIZSLA-JOBS APP missing note -- fail loud\n" as *u8); return 1 }
          vals[1] = dt as i64
          vals[2] = po as i64
          vals[3] = me as i64
          vals[4] = stt as i64
          vals[5] = nt as i64
          let enc: *u8 = sys_mmap(K_MAGIC_2048)
          let el: i64 = canon_encode(keys, vals, 6, enc)
          let cid: *u8 = sys_mmap(96)
          cid_of(enc, el, cid)
          let kbuf: *u8 = sys_mmap(128)
          var ko: i64 = 0
          ko = vj_cat(kbuf, ko, "app:" as *u8)
          ko = vj_cat(kbuf, ko, cid)
          kbuf[ko] = 0 as u8
          var fresh: i64 = 1
          if vj_find(seen, nseen, kbuf) >= 0 { fresh = 0; dup_infile = dup_infile + 1 }
          if fresh == 1 {
              if nseen < K_MAGIC_2048 { seen[nseen] = vj_dup(kbuf) as i64; nseen = nseen + 1 }
          }
          if fresh == 1 {
              if ss_get_idx(prefix, kbuf, pp, ll) == 1 { fresh = 0; dup_instore = dup_instore + 1 }
          }
          if fresh == 1 {
              if ss_add(w, 1, kbuf, enc, el) != 0 { vj_p("VIZSLA-JOBS writer full -- fail loud\n" as *u8); return 1 }
              added = added + 1
          }
      }
      i = e + 1
  }
502
  var committed: i64 = 0
  if added > 0 {
      if ss_commit(prefix, w, segid) != 0 { vj_p("VIZSLA-JOBS commit FAILED -- fail loud\n" as *u8); return 1 }
      committed = 1
  }
508
  let rep: *u8 = sys_mmap(K_MAGIC_4096)
  var o: i64 = 0
  o = vj_cat(rep, o, "VIZSLA-JOBS-TRACK scanned=" as *u8)
  o = vj_catn(rep, o, scanned)
  o = vj_cat(rep, o, " new=" as *u8)
  o = vj_catn(rep, o, added)
  o = vj_cat(rep, o, " dup_infile=" as *u8)
  o = vj_catn(rep, o, dup_infile)
  o = vj_cat(rep, o, " dup_instore=" as *u8)
  o = vj_catn(rep, o, dup_instore)
  o = vj_cat(rep, o, " segment=" as *u8)
  if committed == 1 {
      o = vj_cat(rep, o, "seg-" as *u8)
      o = vj_catn(rep, o, segid)
  } else {
      o = vj_cat(rep, o, "none" as *u8)
  }
  o = vj_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  vj_prefixlog(prefix, lp)
  vj_log(lp, "track" as *u8, rep, o)
  return 0
532}
533
534// ---------------- CADENCE (last status wins; CLOSED set from data) ----------------
535func vj_cmd_cadence(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vj_p("VIZSLA-JOBS cadence needs <prefix> <profile> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let ppath: *u8 = argv[3] as *u8
539
  let szp: *i64 = sys_mmap(16) as *i64
  let pb: *u8 = ss_readall(ppath, szp)
  let psz: i64 = szp[0]
  if psz <= 0 { vj_p("VIZSLA-JOBS profile MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
544
  // CLOSED statuses from the profile (data-driven, never code)
  let closed: *i64 = sys_mmap(8 * 16) as *i64
  var nclosed: i64 = 0
  let t0: *u8 = sys_mmap(128)
  let t1: *u8 = sys_mmap(128)
  var i: i64 = 0
  while i < psz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 {
          if e >= psz { go = 0 } else {
              if pb[e] == (10 as u8) { go = 0 } else { e = e + 1 }
          }
      }
      var p: i64 = vj_tok(pb, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vj_eq(t0, "CLOSED" as *u8) == 1 {
          p = vj_tok(pb, p, e, t1, 128)
          if nclosed < 16 { closed[nclosed] = vj_dup(t1) as i64; nclosed = nclosed + 1 }
      }
      i = e + 1
  }
  if nclosed < 1 { vj_p("VIZSLA-JOBS profile has no CLOSED rows -- fail loud\n" as *u8); return 1 }
568
  // chronological walk: last status per post wins (first-seen post order)
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  if ns == 0 { vj_p("VIZSLA-JOBS cadence: no manifest/segments -- fail loud\n" as *u8); return 1 }
  let posts: *i64 = sys_mmap(8 * 256) as *i64
  let lastst: *i64 = sys_mmap(8 * 256) as *i64
  let lastme: *i64 = sys_mmap(8 * 256) as *i64
  var nposts: i64 = 0
  var apps: i64 = 0
  let fpo: *u8 = sys_mmap(128)
  let fme: *u8 = sys_mmap(128)
  let fst: *u8 = sys_mmap(128)
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po2: i64 = 0
      po2 = vj_cat(path, po2, prefix)
      po2 = vj_cat(path, po2, segs[s] as *u8)
      po2 = vj_cat(path, po2, ".docs" as *u8)
      path[po2] = 0 as u8
      let szp2: *i64 = sys_mmap(16) as *i64
      let b: *u8 = ss_readall(path, szp2)
      let sz: i64 = szp2[0]
      var j: i64 = 0
      while j + 9 <= sz {
          let kind: i64 = b[j]
          let kl: i64 = ss_r32(b, j + 1)
          let koff: i64 = j + 5
          let vl: i64 = ss_r32(b, koff + kl)
          let voff: i64 = koff + kl + 4
          var take: i64 = 0
          if kind == 1 { take = vj_isapp(b, koff, kl) }
          if take == 1 {
              let rec: *u8 = (b as i64 + voff) as *u8
              var okf: i64 = vj_field(rec, vl, "post" as *u8, fpo, 128)
              okf = okf + vj_field(rec, vl, "member" as *u8, fme, 128)
              okf = okf + vj_field(rec, vl, "status" as *u8, fst, 128)
              if okf == 3 {
                  apps = apps + 1
                  var ci: i64 = vj_find(posts, nposts, fpo)
                  if ci < 0 {
                      if nposts < 256 { posts[nposts] = vj_dup(fpo) as i64; ci = nposts; nposts = nposts + 1 }
                  }
                  if ci >= 0 { lastst[ci] = vj_dup(fst) as i64; lastme[ci] = vj_dup(fme) as i64 }
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
619
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  var nopen: i64 = 0
  var ncl: i64 = 0
  var pi: i64 = 0
  while pi < nposts {
      var iscl: i64 = 0
      if vj_find(closed, nclosed, lastst[pi] as *u8) >= 0 { iscl = 1 }
      if iscl == 1 { ncl = ncl + 1 }
      if iscl == 0 {
          nopen = nopen + 1
          o = vj_cat(rep, o, "VIZSLA-JOBS-CADENCE post=" as *u8)
          o = vj_cat(rep, o, posts[pi] as *u8)
          o = vj_cat(rep, o, " member=" as *u8)
          o = vj_cat(rep, o, lastme[pi] as *u8)
          o = vj_cat(rep, o, " last=" as *u8)
          o = vj_cat(rep, o, lastst[pi] as *u8)
          o = vj_cat(rep, o, " action=follow-up\n" as *u8)
      }
      pi = pi + 1
  }
  o = vj_cat(rep, o, "VIZSLA-JOBS-CADENCE-VERDICT apps=" as *u8)
  o = vj_catn(rep, o, apps)
  o = vj_cat(rep, o, " posts=" as *u8)
  o = vj_catn(rep, o, nposts)
  o = vj_cat(rep, o, " open=" as *u8)
  o = vj_catn(rep, o, nopen)
  o = vj_cat(rep, o, " closed=" as *u8)
  o = vj_catn(rep, o, ncl)
  o = vj_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  vj_prefixlog(prefix, lp)
  vj_log(lp, "cadence" as *u8, rep, o)
  return 0
655}
656
657func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { vj_p("VIZSLA-JOBS usage: match|track|cadence -- fail loud\n" as *u8); return 1 }
  let cmd: *u8 = argv[1] as *u8
  if vj_eq(cmd, "match" as *u8) == 1 { return vj_cmd_match(argc, argv) }
  if vj_eq(cmd, "track" as *u8) == 1 { return vj_cmd_track(argc, argv) }
  if vj_eq(cmd, "cadence" as *u8) == 1 { return vj_cmd_cadence(argc, argv) }
  vj_p("VIZSLA-JOBS unknown command (match|track|cadence) -- fail loud\n" as *u8)
  return 1
665}
nx_vizsla_jobs.nx source

`nx_vizsla_jobs.nx` source
