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

↩ module page · 751 lines · 27066 B
1// nx_vizsla_recruiter.nx -- NISHI VIZSLA V2c: the recruiter-channel engine.
2// Operator directive 2026-06-10: "having a recruiter is a big deal as AI has
3// broken the standard process."  Cold applications drown in AI-generated
4// slush and AI screeners; the human channel (recruiter, referral, warm intro)
5// is the high-yield path.  That theory lives AS DATA in channels.txt --
6// channel weights, agents, thresholds are all file content (law 11/25), so
7// refining it (new channel, new weight) is a data edit, never a recompile.
8//
9// Commands (argv[1]):
10//   route <channels> <postings> [log]   every posting -> the strongest
11//                                       available relationship: best agent by
12//                                       (channel weight, term overlap, file
13//                                       order).  An agent term "*" matches any
14//                                       posting (the cold portal).  Cold/weak
15//                                       routes (weight < strong_permil) are
16//                                       state=WEAK -- the broken standard
17//                                       process NAMED per posting, not hidden.
18//   touch <touchfile> <prefix> [segid]  TOUCH rows -> canonical records -> CID
19//                                       keys "tch:nxc1-..." on seg_store =
20//                                       additive relationship history,
21//                                       idempotent by construction (law 10).
22//   warm  <prefix> <channels> <today>   keep-warm cadence over STRONG-channel
23//                                       agents only (worth-tending = derived
24//                                       from the same data): LATEST touch date
25//                                       wins; <=stale_days FRESH/none,
26//                                       >stale_days STALE/reconnect, never
27//                                       touched COLD/introduce.  `today` is an
28//                                       argv date = deterministic stdout.
29//
30// File formats (line records, # comments):
31//   channels: CONF stale_days <n> | CONF strong_permil <n>
32//             CHANNEL <name> <weight_permil>
33//             AGENT <channel> <id> <display> <terms...>     ("*" = wildcard)
34//   postings: POST <id> <pay_cents> <term> <term> ...        (same as V2a)
35//   touches:  TOUCH <date> <agent-id> <member> <note>        (date YYYY-MM-DD)
36//
37// Determinism: stdout has no clocks (warm takes today via argv; epoch headers
38// go to logs only; track/warm log derived from store prefix).  Loud-fail law:
39// missing files, AGENT referencing unknown CHANNEL, malformed dates = exit 1.
40// EXCEED: job boards and ATS pipelines do not model the relationship channel
41// at all -- they ARE the broken channel; Vizsla routes around them and tends
42// the relationships before they are needed.  Outreach DRAFTS (human sends,
43// V4 law) land with V4 relationships.
44// spec: knowledge/specs/2026-06-10-nishi-vizsla-ladder.md   license_tier: ORIGINAL
45import "nx_syscalls.nx"
46import "nx_canon_cid.nx"
47import "nx_seg_store.nx"
48const K_MAGIC_1970: i64 = 1970
49const K_MAGIC_146097: i64 = 146097
50const K_MAGIC_719468: i64 = 719468
51const K_MAGIC_1024: i64 = 1024
52const K_MAGIC_131072: i64 = 131072
53const K_MAGIC_2048: i64 = 2048
54const K_MAGIC_4096: i64 = 4096
55const K_MAGIC_65536: i64 = 65536
56
57func vr_slen(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  return n
61}
62
63func vr_p(s: *u8) -> i64 {
  sys_write(1, s, vr_slen(s))
  return 0
66}
67
68func vr_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
77}
78
79func vr_dup(s: *u8) -> *u8 {
  let n: i64 = vr_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
85}
86
87func vr_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
96}
97
98func vr_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
108}
109
110func vr_isws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 13 { return 1 }
  if c == 9 { return 1 }
  return 0
115}
116
117func vr_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 vr_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 vr_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
137}
138
139func vr_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
143}
144
145func vr_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
156}
157
158func vr_find(list: *i64, n: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < n {
      if vr_eq(list[i] as *u8, s) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
165}
166
167func vr_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
  if vr_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
175}
176
177func vr_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 vr_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
202}
203
204// strict-better for route ranking: (channel weight, overlap); file order = no
205func vr_better(w: i64, bw: i64, ov: i64, bo: i64) -> i64 {
  if w > bw { return 1 }
  if w < bw { return 0 }
  if ov > bo { return 1 }
  return 0
210}
211
212func vr_istch(b: *u8, koff: i64, kl: i64) -> i64 {
  if kl <= 4 { return 0 }
  return vr_kmemeq(b, koff, 4, "tch:" as *u8)
215}
216
217func vr_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 = vr_cat(hdr, ho, "VIZSLA-RECRUIT epoch=" as *u8)
  ho = vr_catn(hdr, ho, sys_now_realtime_sec())
  ho = vr_cat(hdr, ho, " cmd=" as *u8)
  ho = vr_cat(hdr, ho, tag)
  ho = vr_cat(hdr, ho, "\n" as *u8)
  sys_write(fd, hdr, ho)
  sys_write(fd, rep, o)
  sys_close(fd)
  return 0
231}
232
233func vr_prefixlog(prefix: *u8, out: *u8) -> i64 {
  var o: i64 = 0
  o = vr_cat(out, o, prefix)
  o = vr_cat(out, o, "recruit.log" as *u8)
  out[o] = 0 as u8
  return o
239}
240
241// civil date "YYYY-MM-DD" -> days since 1970-01-01 (Hinnant days_from_civil);
242// -1 if malformed (needs 3 numbers, plausible ranges -- boundary law 12)
243func vr_datedays(s: *u8) -> i64 {
  let nums: *i64 = sys_mmap(8 * 4) as *i64
  var nn: i64 = 0
  var cur: i64 = 0
  var indig: i64 = 0
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let c: i64 = s[i] as i64
      var isd: i64 = 0
      if c >= 48 { if c <= 57 { isd = 1 } }
      if isd == 1 { cur = cur * 10 + (c - 48); indig = 1 }
      if isd == 0 {
          if indig == 1 {
              if nn < 4 { nums[nn] = cur; nn = nn + 1 }
              cur = 0
              indig = 0
          }
      }
      if c == 0 { go = 0 }
      i = i + 1
  }
  if nn != 3 { return 0 - 1 }
  var y: i64 = nums[0]
  let m: i64 = nums[1]
  let d: i64 = nums[2]
  if y < K_MAGIC_1970 { return 0 - 1 }
  if m < 1 { return 0 - 1 }
  if m > 12 { return 0 - 1 }
  if d < 1 { return 0 - 1 }
  if d > 31 { return 0 - 1 }
  if m <= 2 { y = y - 1 }
  let era: i64 = y / 400
  let yoe: i64 = y - era * 400
  var mp: i64 = m - 3
  if m <= 2 { mp = m + 9 }
  let doy: i64 = (153 * mp + 2) / 5 + d - 1
  let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy
  return era * K_MAGIC_146097 + doe - K_MAGIC_719468
282}
283
284// channels-file tables packed in one state block (heap-mmap idiom):
285// cf[0]=ch_name cf[1]=ch_w cf[2]=nch
286// cf[3]=ag_ch cf[4]=ag_id cf[5]=ag_disp cf[6]=ag_ts cf[7]=ag_tn cf[8]=nag
287// cf[9]=terms flat ptr-list cf[10]=nterm cf[11]=stale_days cf[12]=strong_permil
288func vr_load_channels(cpath: *u8) -> *i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let cb: *u8 = ss_readall(cpath, szp)
  let csz: i64 = szp[0]
  if csz <= 0 { return 0 as *i64 }
  let cf: *i64 = sys_mmap(8 * 16) as *i64
  cf[0] = sys_mmap(8 * 16)
  cf[1] = sys_mmap(8 * 16)
  cf[2] = 0
  cf[3] = sys_mmap(8 * 64)
  cf[4] = sys_mmap(8 * 64)
  cf[5] = sys_mmap(8 * 64)
  cf[6] = sys_mmap(8 * 64)
  cf[7] = sys_mmap(8 * 64)
  cf[8] = 0
  cf[9] = sys_mmap(8 * K_MAGIC_1024)
  cf[10] = 0
  cf[11] = 30
  cf[12] = 500
  let ch_name: *i64 = cf[0] as *i64
  let ch_w: *i64 = cf[1] as *i64
  let ag_ch: *i64 = cf[3] as *i64
  let ag_id: *i64 = cf[4] as *i64
  let ag_disp: *i64 = cf[5] as *i64
  let ag_ts: *i64 = cf[6] as *i64
  let ag_tn: *i64 = cf[7] as *i64
  let terms: *i64 = cf[9] as *i64
  let t0: *u8 = sys_mmap(128)
  let t1: *u8 = sys_mmap(128)
  let t2: *u8 = sys_mmap(128)
  let t3: *u8 = sys_mmap(128)
  var i: i64 = 0
  while i < csz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 {
          if e >= csz { go = 0 } else {
              if cb[e] == (10 as u8) { go = 0 } else { e = e + 1 }
          }
      }
      var p: i64 = vr_tok(cb, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vr_eq(t0, "CONF" as *u8) == 1 {
          p = vr_tok(cb, p, e, t1, 128)
          p = vr_tok(cb, p, e, t2, 128)
          if vr_eq(t1, "stale_days" as *u8) == 1 { cf[11] = vr_atoi(t2) }
          if vr_eq(t1, "strong_permil" as *u8) == 1 { cf[12] = vr_atoi(t2) }
      }
      if vr_eq(t0, "CHANNEL" as *u8) == 1 {
          p = vr_tok(cb, p, e, t1, 128)
          p = vr_tok(cb, p, e, t2, 128)
          if vr_digits(t2) == 0 { return 0 as *i64 }
          if cf[2] < 16 { ch_name[cf[2]] = vr_dup(t1) as i64; ch_w[cf[2]] = vr_atoi(t2); cf[2] = cf[2] + 1 }
      }
      if vr_eq(t0, "AGENT" as *u8) == 1 {
          p = vr_tok(cb, p, e, t1, 128)
          p = vr_tok(cb, p, e, t2, 128)
          p = vr_tok(cb, p, e, t3, 128)
          let ci: i64 = vr_find(ch_name, cf[2], t1)
          if ci < 0 { return 0 as *i64 }
          if cf[8] < 64 {
              ag_ch[cf[8]] = ci
              ag_id[cf[8]] = vr_dup(t2) as i64
              ag_disp[cf[8]] = vr_dup(t3) as i64
              ag_ts[cf[8]] = cf[10]
              var tn: i64 = 0
              var more: i64 = 1
              while more == 1 {
                  p = vr_tok(cb, p, e, t3, 128)
                  if t3[0] == (0 as u8) { more = 0 } else {
                      if cf[10] < K_MAGIC_1024 { terms[cf[10]] = vr_dup(t3) as i64; cf[10] = cf[10] + 1; tn = tn + 1 }
                  }
              }
              ag_tn[cf[8]] = tn
              cf[8] = cf[8] + 1
          }
      }
      i = e + 1
  }
  if cf[2] < 1 { return 0 as *i64 }
  if cf[8] < 1 { return 0 as *i64 }
  return cf
370}
371
372// agent availability vs a posting's term slice: -1 unavailable, else overlap
373// count ("*" wildcard term = available at overlap 0 + never counts)
374func vr_overlap(cf: *i64, ai: i64, pterms: *i64, pn: i64) -> i64 {
  let ag_ts: *i64 = cf[6] as *i64
  let ag_tn: *i64 = cf[7] as *i64
  let terms: *i64 = cf[9] as *i64
  var ov: i64 = 0
  var wild: i64 = 0
  var t: i64 = 0
  while t < ag_tn[ai] {
      let term: *u8 = terms[ag_ts[ai] + t] as *u8
      if vr_eq(term, "*" as *u8) == 1 { wild = 1 } else {
          if vr_find(pterms, pn, term) >= 0 { ov = ov + 1 }
      }
      t = t + 1
  }
  if ov > 0 { return ov }
  if wild == 1 { return 0 }
  return 0 - 1
391}
392
393// ---------------- ROUTE ----------------
394func vr_cmd_route(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vr_p("VIZSLA-RECRUIT route needs <channels> <postings> -- fail loud\n" as *u8); return 1 }
  let cf: *i64 = vr_load_channels(argv[2] as *u8)
  if (cf as i64) == 0 { vr_p("VIZSLA-RECRUIT channels MISSING/MALFORMED -- fail loud\n" as *u8); return 1 }
  var lpath: *u8 = "knowledge/status/vizsla_recruit.log" as *u8
  if argc > 4 { lpath = argv[4] as *u8 }
400
  let szp: *i64 = sys_mmap(16) as *i64
  let ob: *u8 = ss_readall(argv[3] as *u8, szp)
  let osz: i64 = szp[0]
  if osz <= 0 { vr_p("VIZSLA-RECRUIT postings MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
405
  let ch_name: *i64 = cf[0] as *i64
  let ch_w: *i64 = cf[1] as *i64
  let ag_ch: *i64 = cf[3] as *i64
  let ag_id: *i64 = cf[4] as *i64
  let strong: i64 = cf[12]
411
  let rep: *u8 = sys_mmap(K_MAGIC_131072)
  var o: i64 = 0
  var nposts: i64 = 0
  var nstrong: i64 = 0
  var nweak: i64 = 0
  var nunr: i64 = 0
  let t0: *u8 = sys_mmap(128)
  let t1: *u8 = sys_mmap(128)
  let t2: *u8 = sys_mmap(128)
  let t3: *u8 = sys_mmap(128)
  let pterms: *i64 = sys_mmap(8 * 64) as *i64
423
  var i: i64 = 0
  while i < osz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 {
          if e >= osz { go = 0 } else {
              if ob[e] == (10 as u8) { go = 0 } else { e = e + 1 }
          }
      }
      var p: i64 = vr_tok(ob, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vr_eq(t0, "POST" as *u8) == 1 {
          p = vr_tok(ob, p, e, t1, 128)
          p = vr_tok(ob, p, e, t2, 128)
          if t1[0] == (0 as u8) { vr_p("VIZSLA-RECRUIT POST missing id -- fail loud\n" as *u8); return 1 }
          var pn: i64 = 0
          var more: i64 = 1
          while more == 1 {
              p = vr_tok(ob, p, e, t3, 128)
              if t3[0] == (0 as u8) { more = 0 } else {
                  if pn < 64 { pterms[pn] = vr_dup(t3) as i64; pn = pn + 1 }
              }
          }
          nposts = nposts + 1
          // best agent: (channel weight, overlap, file order)
          var bi: i64 = 0 - 1
          var bw: i64 = 0 - 1
          var bo: i64 = 0 - 1
          var ai: i64 = 0
          while ai < cf[8] {
              let ov: i64 = vr_overlap(cf, ai, pterms, pn)
              if ov >= 0 {
                  let w: i64 = ch_w[ag_ch[ai]]
                  if vr_better(w, bw, ov, bo) == 1 { bi = ai; bw = w; bo = ov }
              }
              ai = ai + 1
          }
          o = vr_cat(rep, o, "VIZSLA-RECRUIT-ROUTE post=" as *u8)
          o = vr_cat(rep, o, t1)
          if bi < 0 {
              nunr = nunr + 1
              o = vr_cat(rep, o, " channel=none via=none strength=0 overlap=0 state=UNROUTED\n" as *u8)
          } else {
              o = vr_cat(rep, o, " channel=" as *u8)
              o = vr_cat(rep, o, ch_name[ag_ch[bi]] as *u8)
              o = vr_cat(rep, o, " via=" as *u8)
              o = vr_cat(rep, o, ag_id[bi] as *u8)
              o = vr_cat(rep, o, " strength=" as *u8)
              o = vr_catn(rep, o, bw)
              o = vr_cat(rep, o, " overlap=" as *u8)
              o = vr_catn(rep, o, bo)
              if bw >= strong {
                  nstrong = nstrong + 1
                  o = vr_cat(rep, o, " state=STRONG\n" as *u8)
              } else {
                  nweak = nweak + 1
                  o = vr_cat(rep, o, " state=WEAK\n" as *u8)
              }
          }
      }
      i = e + 1
  }
  if nposts < 1 { vr_p("VIZSLA-RECRUIT no POST rows -- fail loud\n" as *u8); return 1 }
  o = vr_cat(rep, o, "VIZSLA-RECRUIT-ROUTE-VERDICT posts=" as *u8)
  o = vr_catn(rep, o, nposts)
  o = vr_cat(rep, o, " strong=" as *u8)
  o = vr_catn(rep, o, nstrong)
  o = vr_cat(rep, o, " weak=" as *u8)
  o = vr_catn(rep, o, nweak)
  o = vr_cat(rep, o, " unrouted=" as *u8)
  o = vr_catn(rep, o, nunr)
  o = vr_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  vr_log(lpath, "route" as *u8, rep, o)
  return 0
499}
500
501// ---------------- TOUCH (additive relationship history) ----------------
502func vr_cmd_touch(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vr_p("VIZSLA-RECRUIT touch needs <touchfile> <prefix> -- fail loud\n" as *u8); return 1 }
  let tpath: *u8 = argv[2] as *u8
  let prefix: *u8 = argv[3] as *u8
  var segid: i64 = 0
  if argc > 4 { segid = vr_atoi(argv[4] as *u8) }
  if segid == 0 { segid = sys_now_us() }
509
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = ss_readall(tpath, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { vr_p("VIZSLA-RECRUIT touchfile MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
514
  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] = "agent" as *u8 as i64
  keys[3] = "member" as *u8 as i64
  keys[4] = "note" as *u8 as i64
  vals[0] = "touch" as *u8 as i64
523
  let t0: *u8 = sys_mmap(128)
  let dt: *u8 = sys_mmap(128)
  let ag: *u8 = sys_mmap(128)
  let me: *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
531
  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
539
  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 = vr_tok(b, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vr_eq(t0, "TOUCH" as *u8) == 1 {
          scanned = scanned + 1
          p = vr_tok(b, p, e, dt, 128)
          p = vr_tok(b, p, e, ag, 128)
          p = vr_tok(b, p, e, me, 128)
          p = vr_tok(b, p, e, nt, 256)
          if vr_datedays(dt) < 0 { vr_p("VIZSLA-RECRUIT TOUCH bad date (YYYY-MM-DD) -- fail loud\n" as *u8); return 1 }
          if ag[0] == (0 as u8) { vr_p("VIZSLA-RECRUIT TOUCH missing agent -- fail loud\n" as *u8); return 1 }
          if me[0] == (0 as u8) { vr_p("VIZSLA-RECRUIT TOUCH missing member -- fail loud\n" as *u8); return 1 }
          if nt[0] == (0 as u8) { vr_p("VIZSLA-RECRUIT TOUCH missing note -- fail loud\n" as *u8); return 1 }
          vals[1] = dt as i64
          vals[2] = ag as i64
          vals[3] = me as i64
          vals[4] = nt as i64
          let enc: *u8 = sys_mmap(K_MAGIC_2048)
          let el: i64 = canon_encode(keys, vals, 5, enc)
          let cid: *u8 = sys_mmap(96)
          cid_of(enc, el, cid)
          let kbuf: *u8 = sys_mmap(128)
          var ko: i64 = 0
          ko = vr_cat(kbuf, ko, "tch:" as *u8)
          ko = vr_cat(kbuf, ko, cid)
          kbuf[ko] = 0 as u8
          var fresh: i64 = 1
          if vr_find(seen, nseen, kbuf) >= 0 { fresh = 0; dup_infile = dup_infile + 1 }
          if fresh == 1 {
              if nseen < K_MAGIC_2048 { seen[nseen] = vr_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 { vr_p("VIZSLA-RECRUIT writer full -- fail loud\n" as *u8); return 1 }
              added = added + 1
          }
      }
      i = e + 1
  }
589
  var committed: i64 = 0
  if added > 0 {
      if ss_commit(prefix, w, segid) != 0 { vr_p("VIZSLA-RECRUIT commit FAILED -- fail loud\n" as *u8); return 1 }
      committed = 1
  }
595
  let rep: *u8 = sys_mmap(K_MAGIC_4096)
  var o: i64 = 0
  o = vr_cat(rep, o, "VIZSLA-RECRUIT-TOUCH scanned=" as *u8)
  o = vr_catn(rep, o, scanned)
  o = vr_cat(rep, o, " new=" as *u8)
  o = vr_catn(rep, o, added)
  o = vr_cat(rep, o, " dup_infile=" as *u8)
  o = vr_catn(rep, o, dup_infile)
  o = vr_cat(rep, o, " dup_instore=" as *u8)
  o = vr_catn(rep, o, dup_instore)
  o = vr_cat(rep, o, " segment=" as *u8)
  if committed == 1 {
      o = vr_cat(rep, o, "seg-" as *u8)
      o = vr_catn(rep, o, segid)
  } else {
      o = vr_cat(rep, o, "none" as *u8)
  }
  o = vr_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  vr_prefixlog(prefix, lp)
  vr_log(lp, "touch" as *u8, rep, o)
  return 0
619}
620
621// ---------------- WARM (keep-warm cadence; LATEST date wins) ----------------
622func vr_cmd_warm(argc: i64, argv: *i64) -> i64 {
  if argc < 5 { vr_p("VIZSLA-RECRUIT warm needs <prefix> <channels> <today> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let cf: *i64 = vr_load_channels(argv[3] as *u8)
  if (cf as i64) == 0 { vr_p("VIZSLA-RECRUIT channels MISSING/MALFORMED -- fail loud\n" as *u8); return 1 }
  let today: i64 = vr_datedays(argv[4] as *u8)
  if today < 0 { vr_p("VIZSLA-RECRUIT bad today date (YYYY-MM-DD) -- fail loud\n" as *u8); return 1 }
629
  let ch_name: *i64 = cf[0] as *i64
  let ch_w: *i64 = cf[1] as *i64
  let ag_ch: *i64 = cf[3] as *i64
  let ag_id: *i64 = cf[4] as *i64
  let stale: i64 = cf[11]
  let strong: i64 = cf[12]
636
  // last (latest-date) touch per agent; empty store = everyone COLD (bootstrap)
  let a_days: *i64 = sys_mmap(8 * 64) as *i64
  let a_date: *i64 = sys_mmap(8 * 64) as *i64
  var ai0: i64 = 0
  while ai0 < cf[8] { a_days[ai0] = 0 - 1; a_date[ai0] = "never" as *u8 as i64; ai0 = ai0 + 1 }
  var unknown: i64 = 0
  var touches: i64 = 0
644
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  let fag: *u8 = sys_mmap(128)
  let fdt: *u8 = sys_mmap(128)
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = vr_cat(path, po, prefix)
      po = vr_cat(path, po, segs[s] as *u8)
      po = vr_cat(path, po, ".docs" as *u8)
      path[po] = 0 as u8
      let szp: *i64 = sys_mmap(16) as *i64
      let b: *u8 = ss_readall(path, szp)
      let sz: i64 = szp[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 = vr_istch(b, koff, kl) }
          if take == 1 {
              let rec: *u8 = (b as i64 + voff) as *u8
              var okf: i64 = vr_field(rec, vl, "agent" as *u8, fag, 128)
              okf = okf + vr_field(rec, vl, "date" as *u8, fdt, 128)
              if okf == 2 {
                  touches = touches + 1
                  let aix: i64 = vr_find(ag_id, cf[8], fag)
                  if aix < 0 { unknown = unknown + 1 }
                  if aix >= 0 {
                      let dd: i64 = vr_datedays(fdt)
                      if dd > a_days[aix] { a_days[aix] = dd; a_date[aix] = vr_dup(fdt) as i64 }
                  }
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
687
  // strong-channel agents only = relationships worth tending (from the data)
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  var nag: i64 = 0
  var nfresh: i64 = 0
  var nstale: i64 = 0
  var ncold: i64 = 0
  var ai: i64 = 0
  while ai < cf[8] {
      if ch_w[ag_ch[ai]] >= strong {
          nag = nag + 1
          o = vr_cat(rep, o, "VIZSLA-RECRUIT-WARM agent=" as *u8)
          o = vr_cat(rep, o, ag_id[ai] as *u8)
          o = vr_cat(rep, o, " channel=" as *u8)
          o = vr_cat(rep, o, ch_name[ag_ch[ai]] as *u8)
          o = vr_cat(rep, o, " last=" as *u8)
          o = vr_cat(rep, o, a_date[ai] as *u8)
          o = vr_cat(rep, o, " days=" as *u8)
          if a_days[ai] < 0 { o = vr_catn(rep, o, 0 - 1) } else { o = vr_catn(rep, o, today - a_days[ai]) }
          if a_days[ai] < 0 {
              ncold = ncold + 1
              o = vr_cat(rep, o, " state=COLD action=introduce\n" as *u8)
          } else {
              if today - a_days[ai] <= stale {
                  nfresh = nfresh + 1
                  o = vr_cat(rep, o, " state=FRESH action=none\n" as *u8)
              } else {
                  nstale = nstale + 1
                  o = vr_cat(rep, o, " state=STALE action=reconnect\n" as *u8)
              }
          }
      }
      ai = ai + 1
  }
  o = vr_cat(rep, o, "VIZSLA-RECRUIT-WARM-VERDICT agents=" as *u8)
  o = vr_catn(rep, o, nag)
  o = vr_cat(rep, o, " fresh=" as *u8)
  o = vr_catn(rep, o, nfresh)
  o = vr_cat(rep, o, " stale=" as *u8)
  o = vr_catn(rep, o, nstale)
  o = vr_cat(rep, o, " cold=" as *u8)
  o = vr_catn(rep, o, ncold)
  o = vr_cat(rep, o, "\n" as *u8)
  if unknown > 0 {
      o = vr_cat(rep, o, "VIZSLA-RECRUIT-WARM-UNKNOWN touches=" as *u8)
      o = vr_catn(rep, o, unknown)
      o = vr_cat(rep, o, "\n" as *u8)
  }
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  vr_prefixlog(prefix, lp)
  vr_log(lp, "warm" as *u8, rep, o)
  return 0
741}
742
743func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { vr_p("VIZSLA-RECRUIT usage: route|touch|warm -- fail loud\n" as *u8); return 1 }
  let cmd: *u8 = argv[1] as *u8
  if vr_eq(cmd, "route" as *u8) == 1 { return vr_cmd_route(argc, argv) }
  if vr_eq(cmd, "touch" as *u8) == 1 { return vr_cmd_touch(argc, argv) }
  if vr_eq(cmd, "warm" as *u8) == 1 { return vr_cmd_warm(argc, argv) }
  vr_p("VIZSLA-RECRUIT unknown command (route|touch|warm) -- fail loud\n" as *u8)
  return 1
751}
nx_vizsla_recruiter.nx source

`nx_vizsla_recruiter.nx` source
