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

↩ module page · 1056 lines · 39928 B
1// nx_vizsla_relate.nx -- NISHI VIZSLA V4: the relationships / PRM keystone.
2// Operator directive 2026-06-14: "build the project management and PRM ... help
3// us manage our contacts, thank yous".  This is the sovereign home of the old
4// nishi-prm "Tom Hagen consigliere" design: proactive counsel, a BIDIRECTIONAL
5// obligation ledger (debts I owe AND credits owed to me), and thank-you tracking
6// as a managed obligation -- folded onto the VIZSLA substrate (CID records on
7// seg_store, civil-date math, idempotent-by-construction) inherited from V2c.
8//
9// THEORY AS DATA (law 11/25): relationship tiers + their desired touch cadence,
10// and the "coming up soon" window, all live in contacts.txt -- refining the
11// model (a new tier, a tighter cadence) is a data edit, never a recompile.
12//
13// Commands (argv[1]):
14//   load <relate_log> <prefix> [segid]   TOUCH/OBLIGATION/SETTLE/THANKS/SENT
15//                                        rows -> canonical records -> CID keys
16//                                        "rel:nxc1-..." on seg_store = additive,
17//                                        idempotent-by-construction (law 10).
18//   cadence <prefix> <contacts> <today>  per contact: LATEST touch date vs its
19//                                        TIER cadence -> FRESH / DUE(reconnect) /
20//                                        NEW(introduce).  today via argv =
21//                                        deterministic stdout.
22//   ledger  <prefix> <contacts>          bidirectional obligation ledger: open
23//                                        OWE (I owe) + open DUE (owed to me)
24//                                        after applying SETTLE; per-direction
25//                                        counts + cent totals.  Closing is an
26//                                        ADDITIVE settle event, never a delete.
27//   thanks  <prefix> <contacts> <today>  open thank-yous (THANKS with no matching
28//                                        SENT): days owed, PENDING(<=soon_days) /
29//                                        OVERDUE.  Gratitude as a tracked debt.
30//   brief   <prefix> <contacts> <today>  the CONSIGLIERE daily brief: follow-ups
31//                                        due + birthdays within soon_days + open
32//                                        thank-yous + open obligations, composed
33//                                        into one "what to do today".
34//
35// File formats (line records, # comments):
36//   contacts: CONF soon_days <n>
37//             TIER <name> <cadence_days>
38//             CONTACT <id> <display> <tier> <birthday>   (birthday MM-DD or "-")
39//   relate_log:
40//             TOUCH <date> <contact> <note>
41//             OBLIGATION <date> <dir> <contact> <ref> <amount_cents> <desc>
42//                                                         (dir = OWE | DUE)
43//             SETTLE <date> <ref> <note>                  (closes that ref)
44//             THANKS <date> <contact> <occasion>
45//             SENT   <date> <contact> <occasion>          (closes that thanks)
46//   (date YYYY-MM-DD; note/desc/occasion = single hyphenated tokens this rung;
47//    rich-text drafts are V4b / the thankyounotes.com product.)
48//
49// Determinism: stdout has no clocks (today via argv; epoch headers go to logs
50// only).  Loud-fail law: missing files, CONTACT on an undeclared TIER, malformed
51// dates, OBLIGATION dir not OWE/DUE = exit 1.
52// EXCEED (honest, feature-class -- not a throughput claim): no consumer PRM
53// (Clay/Dex/Folk/Monica) models a BIDIRECTIONAL obligation ledger or thank-you-
54// as-managed-obligation, and none keep additive tamper-evident relationship
55// history with as-of time-travel.  Outreach DRAFT prose = V4b.
56//
57// module: nishi-core.vizsla.relate
58// depends: nishi-core.lib.syscalls, nishi-core.lib.canon_cid, nishi-core.lib.seg_store
59// capability: VIZSLA_RELATE_PRM
60// spec: knowledge/specs/2026-06-10-nishi-vizsla-ladder.md   license_tier: ORIGINAL
61import "nx_syscalls.nx"
62import "nx_canon_cid.nx"
63import "nx_seg_store.nx"
64const K_MAGIC_1970: i64 = 1970
65const K_MAGIC_146097: i64 = 146097
66const K_MAGIC_719468: i64 = 719468
67const K_MAGIC_4096: i64 = 4096
68const K_MAGIC_2048: i64 = 2048
69const K_MAGIC_65536: i64 = 65536
70const K_MAGIC_131072: i64 = 131072
71
72func rl_slen(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  return n
76}
77
78func rl_p(s: *u8) -> i64 {
  sys_write(1, s, rl_slen(s))
  return 0
81}
82
83func rl_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
92}
93
94func rl_dup(s: *u8) -> *u8 {
  let n: i64 = rl_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
100}
101
102func rl_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
111}
112
113func rl_isws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 13 { return 1 }
  if c == 9 { return 1 }
  return 0
118}
119
120func rl_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 rl_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 rl_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
140}
141
142func rl_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
146}
147
148func rl_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
159}
160
161func rl_find(list: *i64, n: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < n {
      if rl_eq(list[i] as *u8, s) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
168}
169
170func rl_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
  if rl_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
178}
179
180// decode a named field out of a canonical NXR1 value record (mirror of V2c)
181func rl_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 rl_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
206}
207
208func rl_isrel(b: *u8, koff: i64, kl: i64) -> i64 {
  if kl <= 4 { return 0 }
  return rl_kmemeq(b, koff, 4, "rel:" as *u8)
211}
212
213// civil date "YYYY-MM-DD" -> days since 1970-01-01 (Hinnant); -1 if malformed
214func rl_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
253}
254
255// leading integer (the year) out of a "YYYY-..." token
256func rl_yearof(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let c: i64 = s[i] as i64
      if c >= 48 { if c <= 57 { v = v * 10 + (c - 48); i = i + 1; go = 2 } }
      if go == 1 { go = 0 }
      if go == 2 { go = 1 }
  }
  return v
267}
268
269// days until the next occurrence of a "MM-DD" birthday from today; -1 if "-"
270func rl_bday_until(today: *u8, today_days: i64, mmdd: *u8) -> i64 {
  if mmdd[0] == (45 as u8) { if mmdd[1] == (0 as u8) { return 0 - 1 } }
  let yr: i64 = rl_yearof(today)
  if yr < K_MAGIC_1970 { return 0 - 1 }
  let cand: *u8 = sys_mmap(32)
  var co: i64 = 0
  co = rl_catn(cand, co, yr)
  cand[co] = 45 as u8; co = co + 1
  co = rl_cat(cand, co, mmdd)
  cand[co] = 0 as u8
  var bdd: i64 = rl_datedays(cand)
  if bdd < 0 { return 0 - 1 }
  if bdd < today_days {
      var c2: i64 = 0
      c2 = rl_catn(cand, c2, yr + 1)
      cand[c2] = 45 as u8; c2 = c2 + 1
      c2 = rl_cat(cand, c2, mmdd)
      cand[c2] = 0 as u8
      bdd = rl_datedays(cand)
      if bdd < 0 { return 0 - 1 }
  }
  return bdd - today_days
292}
293
294func rl_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 = rl_cat(hdr, ho, "VIZSLA-RELATE epoch=" as *u8)
  ho = rl_catn(hdr, ho, sys_now_realtime_sec())
  ho = rl_cat(hdr, ho, " cmd=" as *u8)
  ho = rl_cat(hdr, ho, tag)
  ho = rl_cat(hdr, ho, "\n" as *u8)
  sys_write(fd, hdr, ho)
  sys_write(fd, rep, o)
  sys_close(fd)
  return 0
308}
309
310func rl_prefixlog(prefix: *u8, out: *u8) -> i64 {
  var o: i64 = 0
  o = rl_cat(out, o, prefix)
  o = rl_cat(out, o, "relate.log" as *u8)
  out[o] = 0 as u8
  return o
316}
317
318// contacts table packed in one heap-mmap state block:
319// cf[0]=ct_id cf[1]=ct_disp cf[2]=ct_tier(idx) cf[3]=ct_bday cf[4]=nct
320// cf[5]=tr_name cf[6]=tr_days cf[7]=ntr cf[8]=(reserved) cf[9]=soon_days
321func rl_load_contacts(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 * 256)
  cf[1] = sys_mmap(8 * 256)
  cf[2] = sys_mmap(8 * 256)
  cf[3] = sys_mmap(8 * 256)
  cf[4] = 0
  cf[5] = sys_mmap(8 * 16)
  cf[6] = sys_mmap(8 * 16)
  cf[7] = 0
  cf[8] = 0
  cf[9] = 14
  let ct_id: *i64 = cf[0] as *i64
  let ct_disp: *i64 = cf[1] as *i64
  let ct_tier: *i64 = cf[2] as *i64
  let ct_bday: *i64 = cf[3] as *i64
  let tr_name: *i64 = cf[5] as *i64
  let tr_days: *i64 = cf[6] 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 = rl_tok(cb, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if rl_eq(t0, "CONF" as *u8) == 1 {
          p = rl_tok(cb, p, e, t1, 128)
          p = rl_tok(cb, p, e, t2, 128)
          if rl_eq(t1, "soon_days" as *u8) == 1 { cf[9] = rl_atoi(t2) }
      }
      if rl_eq(t0, "TIER" as *u8) == 1 {
          p = rl_tok(cb, p, e, t1, 128)
          p = rl_tok(cb, p, e, t2, 128)
          if cf[7] < 16 { tr_name[cf[7]] = rl_dup(t1) as i64; tr_days[cf[7]] = rl_atoi(t2); cf[7] = cf[7] + 1 }
      }
      if rl_eq(t0, "CONTACT" as *u8) == 1 {
          p = rl_tok(cb, p, e, t1, 128)
          p = rl_tok(cb, p, e, t2, 128)
          p = rl_tok(cb, p, e, t3, 128)
          let ti: i64 = rl_find(tr_name, cf[7], t3)
          if ti < 0 { return 0 as *i64 }
          let bd: *u8 = sys_mmap(16)
          rl_tok(cb, p, e, bd, 16)
          if bd[0] == (0 as u8) { bd[0] = 45 as u8; bd[1] = 0 as u8 }
          if cf[4] < 256 {
              ct_id[cf[4]] = rl_dup(t1) as i64
              ct_disp[cf[4]] = rl_dup(t2) as i64
              ct_tier[cf[4]] = ti
              ct_bday[cf[4]] = rl_dup(bd) as i64
              cf[4] = cf[4] + 1
          }
      }
      i = e + 1
  }
  if cf[7] < 1 { return 0 as *i64 }
  if cf[4] < 1 { return 0 as *i64 }
  return cf
390}
391
392// ---------------- LOAD (additive event journal -> CID records) ----------------
393func rl_cmd_load(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { rl_p("VIZSLA-RELATE load needs <relate_log> <prefix> -- fail loud\n" as *u8); return 1 }
  let lpath: *u8 = argv[2] as *u8
  let prefix: *u8 = argv[3] as *u8
  var segid: i64 = 0
  if argc > 4 { segid = rl_atoi(argv[4] as *u8) }
  if segid == 0 { segid = sys_now_us() }
400
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = ss_readall(lpath, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { rl_p("VIZSLA-RELATE relate_log MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
405
  let keys: *i64 = sys_mmap(8 * 8) as *i64
  let vals: *i64 = sys_mmap(8 * 8) as *i64
  keys[0] = "k" as *u8 as i64
  keys[1] = "date" as *u8 as i64
  keys[2] = "a" as *u8 as i64
  keys[3] = "b" as *u8 as i64
  keys[4] = "c" as *u8 as i64
  keys[5] = "d" as *u8 as i64
  keys[6] = "e" as *u8 as i64
415
  let t0: *u8 = sys_mmap(128)
  let f1: *u8 = sys_mmap(128)
  let f2: *u8 = sys_mmap(128)
  let f3: *u8 = sys_mmap(128)
  let f4: *u8 = sys_mmap(128)
  let f5: *u8 = sys_mmap(128)
  let f6: *u8 = sys_mmap(256)
  let pp: *i64 = sys_mmap(16) as *i64
  let ll: *i64 = sys_mmap(16) as *i64
425
  let w: *i64 = ss_begin()
  let seen: *i64 = sys_mmap(8 * K_MAGIC_4096) as *i64
  var nseen: i64 = 0
  var scanned: i64 = 0
  var added: i64 = 0
  var dup_infile: i64 = 0
  var dup_instore: i64 = 0
433
  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 = rl_tok(b, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      var nf: i64 = 0
      if rl_eq(t0, "TOUCH" as *u8) == 1 {
          p = rl_tok(b, p, e, f1, 128); p = rl_tok(b, p, e, f2, 128); p = rl_tok(b, p, e, f3, 256)
          vals[0] = "touch" as *u8 as i64; vals[1] = f1 as i64; vals[2] = f2 as i64; vals[3] = f3 as i64
          nf = 4
      }
      if rl_eq(t0, "OBLIGATION" as *u8) == 1 {
          p = rl_tok(b, p, e, f1, 128); p = rl_tok(b, p, e, f2, 128); p = rl_tok(b, p, e, f3, 128)
          p = rl_tok(b, p, e, f4, 128); p = rl_tok(b, p, e, f5, 128); p = rl_tok(b, p, e, f6, 256)
          if rl_eq(f2, "OWE" as *u8) == 0 { if rl_eq(f2, "DUE" as *u8) == 0 { rl_p("VIZSLA-RELATE OBLIGATION dir not OWE/DUE -- fail loud\n" as *u8); return 1 } }
          vals[0] = "oblig" as *u8 as i64; vals[1] = f1 as i64; vals[2] = f2 as i64; vals[3] = f3 as i64
          vals[4] = f4 as i64; vals[5] = f5 as i64; vals[6] = f6 as i64
          nf = 7
      }
      if rl_eq(t0, "SETTLE" as *u8) == 1 {
          p = rl_tok(b, p, e, f1, 128); p = rl_tok(b, p, e, f2, 128); p = rl_tok(b, p, e, f3, 256)
          vals[0] = "settle" as *u8 as i64; vals[1] = f1 as i64; vals[2] = f2 as i64; vals[3] = f3 as i64
          nf = 4
      }
      if rl_eq(t0, "THANKS" as *u8) == 1 {
          p = rl_tok(b, p, e, f1, 128); p = rl_tok(b, p, e, f2, 128); p = rl_tok(b, p, e, f3, 128)
          vals[0] = "thanks" as *u8 as i64; vals[1] = f1 as i64; vals[2] = f2 as i64; vals[3] = f3 as i64
          nf = 4
      }
      if rl_eq(t0, "SENT" as *u8) == 1 {
          p = rl_tok(b, p, e, f1, 128); p = rl_tok(b, p, e, f2, 128); p = rl_tok(b, p, e, f3, 128)
          vals[0] = "sent" as *u8 as i64; vals[1] = f1 as i64; vals[2] = f2 as i64; vals[3] = f3 as i64
          nf = 4
      }
      if nf > 0 {
          scanned = scanned + 1
          if rl_datedays(f1) < 0 { rl_p("VIZSLA-RELATE bad date (YYYY-MM-DD) -- fail loud\n" as *u8); return 1 }
          let enc: *u8 = sys_mmap(K_MAGIC_2048)
          let el: i64 = canon_encode(keys, vals, nf, enc)
          let cid: *u8 = sys_mmap(96)
          cid_of(enc, el, cid)
          let kbuf: *u8 = sys_mmap(128)
          var ko: i64 = 0
          ko = rl_cat(kbuf, ko, "rel:" as *u8)
          ko = rl_cat(kbuf, ko, cid)
          kbuf[ko] = 0 as u8
          var fresh: i64 = 1
          if rl_find(seen, nseen, kbuf) >= 0 { fresh = 0; dup_infile = dup_infile + 1 }
          if fresh == 1 {
              if nseen < K_MAGIC_4096 { seen[nseen] = rl_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 { rl_p("VIZSLA-RELATE writer full -- fail loud\n" as *u8); return 1 }
              added = added + 1
          }
      }
      i = e + 1
  }
501
  var committed: i64 = 0
  if added > 0 {
      if ss_commit(prefix, w, segid) != 0 { rl_p("VIZSLA-RELATE commit FAILED -- fail loud\n" as *u8); return 1 }
      committed = 1
  }
507
  let rep: *u8 = sys_mmap(K_MAGIC_4096)
  var o: i64 = 0
  o = rl_cat(rep, o, "VIZSLA-RELATE-LOAD scanned=" as *u8)
  o = rl_catn(rep, o, scanned)
  o = rl_cat(rep, o, " new=" as *u8)
  o = rl_catn(rep, o, added)
  o = rl_cat(rep, o, " dup_infile=" as *u8)
  o = rl_catn(rep, o, dup_infile)
  o = rl_cat(rep, o, " dup_instore=" as *u8)
  o = rl_catn(rep, o, dup_instore)
  o = rl_cat(rep, o, " segment=" as *u8)
  if committed == 1 {
      o = rl_cat(rep, o, "seg-" as *u8)
      o = rl_catn(rep, o, segid)
  } else {
      o = rl_cat(rep, o, "none" as *u8)
  }
  o = rl_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  rl_prefixlog(prefix, lp)
  rl_log(lp, "load" as *u8, rep, o)
  return 0
531}
532
533// fill latest-touch (days,date) per contact idx by walking the store
534func rl_latest_touch(prefix: *u8, cf: *i64, a_days: *i64, a_date: *i64) -> i64 {
  let ct_id: *i64 = cf[0] as *i64
  var i0: i64 = 0
  while i0 < cf[4] { a_days[i0] = 0 - 1; a_date[i0] = "never" as *u8 as i64; i0 = i0 + 1 }
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  let fk: *u8 = sys_mmap(64)
  let fa: *u8 = sys_mmap(128)
  let fd: *u8 = sys_mmap(128)
  var touches: i64 = 0
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = rl_cat(path, po, prefix); po = rl_cat(path, po, segs[s] as *u8); po = rl_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 = rl_isrel(b, koff, kl) }
          if take == 1 {
              let rec: *u8 = (b as i64 + voff) as *u8
              if rl_field(rec, vl, "k" as *u8, fk, 64) == 1 {
                  if rl_eq(fk, "touch" as *u8) == 1 {
                      if rl_field(rec, vl, "a" as *u8, fa, 128) == 1 {
                          if rl_field(rec, vl, "date" as *u8, fd, 128) == 1 {
                              touches = touches + 1
                              let aix: i64 = rl_find(ct_id, cf[4], fa)
                              if aix >= 0 {
                                  let dd: i64 = rl_datedays(fd)
                                  if dd > a_days[aix] { a_days[aix] = dd; a_date[aix] = rl_dup(fd) as i64 }
                              }
                          }
                      }
                  }
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
  return touches
584}
585
586// ---------------- CADENCE (tier-driven follow-up) ----------------
587func rl_cmd_cadence(argc: i64, argv: *i64) -> i64 {
  if argc < 5 { rl_p("VIZSLA-RELATE cadence needs <prefix> <contacts> <today> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let cf: *i64 = rl_load_contacts(argv[3] as *u8)
  if (cf as i64) == 0 { rl_p("VIZSLA-RELATE contacts MISSING/MALFORMED -- fail loud\n" as *u8); return 1 }
  let today: i64 = rl_datedays(argv[4] as *u8)
  if today < 0 { rl_p("VIZSLA-RELATE bad today date (YYYY-MM-DD) -- fail loud\n" as *u8); return 1 }
594
  let ct_id: *i64 = cf[0] as *i64
  let ct_tier: *i64 = cf[2] as *i64
  let tr_name: *i64 = cf[5] as *i64
  let tr_days: *i64 = cf[6] as *i64
  let a_days: *i64 = sys_mmap(8 * 256) as *i64
  let a_date: *i64 = sys_mmap(8 * 256) as *i64
  rl_latest_touch(prefix, cf, a_days, a_date)
602
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  var nfresh: i64 = 0
  var ndue: i64 = 0
  var nnew: i64 = 0
  var i: i64 = 0
  while i < cf[4] {
      let cad: i64 = tr_days[ct_tier[i]]
      o = rl_cat(rep, o, "VIZSLA-RELATE-CADENCE contact=" as *u8)
      o = rl_cat(rep, o, ct_id[i] as *u8)
      o = rl_cat(rep, o, " tier=" as *u8)
      o = rl_cat(rep, o, tr_name[ct_tier[i]] as *u8)
      o = rl_cat(rep, o, " last=" as *u8)
      o = rl_cat(rep, o, a_date[i] as *u8)
      o = rl_cat(rep, o, " days=" as *u8)
      if a_days[i] < 0 { o = rl_catn(rep, o, 0 - 1) } else { o = rl_catn(rep, o, today - a_days[i]) }
      o = rl_cat(rep, o, " cadence=" as *u8)
      o = rl_catn(rep, o, cad)
      if a_days[i] < 0 {
          nnew = nnew + 1
          o = rl_cat(rep, o, " state=NEW action=introduce\n" as *u8)
      } else {
          if today - a_days[i] <= cad {
              nfresh = nfresh + 1
              o = rl_cat(rep, o, " state=FRESH action=none\n" as *u8)
          } else {
              ndue = ndue + 1
              o = rl_cat(rep, o, " state=DUE action=reconnect\n" as *u8)
          }
      }
      i = i + 1
  }
  o = rl_cat(rep, o, "VIZSLA-RELATE-CADENCE-VERDICT contacts=" as *u8)
  o = rl_catn(rep, o, cf[4])
  o = rl_cat(rep, o, " fresh=" as *u8)
  o = rl_catn(rep, o, nfresh)
  o = rl_cat(rep, o, " due=" as *u8)
  o = rl_catn(rep, o, ndue)
  o = rl_cat(rep, o, " new=" as *u8)
  o = rl_catn(rep, o, nnew)
  o = rl_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  rl_prefixlog(prefix, lp)
  rl_log(lp, "cadence" as *u8, rep, o)
  return 0
649}
650
651// collect OPEN obligations (after SETTLE) into an ob block:
652// ob[0]=ct ob[1]=dir ob[2]=ref ob[3]=amt(str) ob[4]=desc ob[5]=nopen ob[6]=settled
653func rl_collect_obligs(prefix: *u8) -> *i64 {
  let ob: *i64 = sys_mmap(8 * 8) as *i64
  ob[0] = sys_mmap(8 * 256); ob[1] = sys_mmap(8 * 256); ob[2] = sys_mmap(8 * 256)
  ob[3] = sys_mmap(8 * 256); ob[4] = sys_mmap(8 * 256); ob[5] = 0; ob[6] = 0
  let o_ct: *i64 = ob[0] as *i64
  let o_dir: *i64 = ob[1] as *i64
  let o_ref: *i64 = ob[2] as *i64
  let o_amt: *i64 = ob[3] as *i64
  let o_desc: *i64 = ob[4] as *i64
  // temp store of all obligations + the settled-ref set
  let t_ct: *i64 = sys_mmap(8 * 256) as *i64
  let t_dir: *i64 = sys_mmap(8 * 256) as *i64
  let t_ref: *i64 = sys_mmap(8 * 256) as *i64
  let t_amt: *i64 = sys_mmap(8 * 256) as *i64
  let t_desc: *i64 = sys_mmap(8 * 256) as *i64
  var nt: i64 = 0
  let settled: *i64 = sys_mmap(8 * 256) as *i64
  var nset: i64 = 0
671
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  let fk: *u8 = sys_mmap(64)
  let fa: *u8 = sys_mmap(128)
  let fb: *u8 = sys_mmap(128)
  let fc: *u8 = sys_mmap(128)
  let fd: *u8 = sys_mmap(128)
  let fe: *u8 = sys_mmap(256)
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = rl_cat(path, po, prefix); po = rl_cat(path, po, segs[s] as *u8); po = rl_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 = rl_isrel(b, koff, kl) }
          if take == 1 {
              let rec: *u8 = (b as i64 + voff) as *u8
              if rl_field(rec, vl, "k" as *u8, fk, 64) == 1 {
                  if rl_eq(fk, "oblig" as *u8) == 1 {
                      rl_field(rec, vl, "a" as *u8, fb, 128)
                      rl_field(rec, vl, "b" as *u8, fa, 128)
                      rl_field(rec, vl, "c" as *u8, fc, 128)
                      rl_field(rec, vl, "d" as *u8, fd, 128)
                      rl_field(rec, vl, "e" as *u8, fe, 256)
                      if nt < 256 {
                          t_dir[nt] = rl_dup(fb) as i64
                          t_ct[nt] = rl_dup(fa) as i64
                          t_ref[nt] = rl_dup(fc) as i64
                          t_amt[nt] = rl_dup(fd) as i64
                          t_desc[nt] = rl_dup(fe) as i64
                          nt = nt + 1
                      }
                  }
                  if rl_eq(fk, "settle" as *u8) == 1 {
                      rl_field(rec, vl, "a" as *u8, fc, 128)
                      if nset < 256 { settled[nset] = rl_dup(fc) as i64; nset = nset + 1 }
                  }
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
  ob[6] = nset
  var k: i64 = 0
  while k < nt {
      if rl_find(settled, nset, t_ref[k] as *u8) < 0 {
          let n: i64 = ob[5]
          o_ct[n] = t_ct[k]; o_dir[n] = t_dir[k]; o_ref[n] = t_ref[k]; o_amt[n] = t_amt[k]; o_desc[n] = t_desc[k]
          ob[5] = n + 1
      }
      k = k + 1
  }
  return ob
737}
738
739// ---------------- LEDGER (bidirectional obligation ledger) ----------------
740func rl_cmd_ledger(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { rl_p("VIZSLA-RELATE ledger needs <prefix> <contacts> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let cf: *i64 = rl_load_contacts(argv[3] as *u8)
  if (cf as i64) == 0 { rl_p("VIZSLA-RELATE contacts MISSING/MALFORMED -- fail loud\n" as *u8); return 1 }
745
  let ob: *i64 = rl_collect_obligs(prefix)
  let o_ct: *i64 = ob[0] as *i64
  let o_dir: *i64 = ob[1] as *i64
  let o_ref: *i64 = ob[2] as *i64
  let o_amt: *i64 = ob[3] as *i64
  let o_desc: *i64 = ob[4] as *i64
752
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  var nowe: i64 = 0
  var ndue: i64 = 0
  var owe_amt: i64 = 0
  var due_amt: i64 = 0
  var i: i64 = 0
  while i < ob[5] {
      let amt: i64 = rl_atoi(o_amt[i] as *u8)
      o = rl_cat(rep, o, "VIZSLA-RELATE-OBLIG contact=" as *u8)
      o = rl_cat(rep, o, o_ct[i] as *u8)
      o = rl_cat(rep, o, " dir=" as *u8)
      o = rl_cat(rep, o, o_dir[i] as *u8)
      o = rl_cat(rep, o, " ref=" as *u8)
      o = rl_cat(rep, o, o_ref[i] as *u8)
      o = rl_cat(rep, o, " amount=" as *u8)
      o = rl_catn(rep, o, amt)
      o = rl_cat(rep, o, " desc=" as *u8)
      o = rl_cat(rep, o, o_desc[i] as *u8)
      o = rl_cat(rep, o, " state=OPEN\n" as *u8)
      if rl_eq(o_dir[i] as *u8, "OWE" as *u8) == 1 { nowe = nowe + 1; owe_amt = owe_amt + amt } else { ndue = ndue + 1; due_amt = due_amt + amt }
      i = i + 1
  }
  o = rl_cat(rep, o, "VIZSLA-RELATE-OBLIG-VERDICT open=" as *u8)
  o = rl_catn(rep, o, ob[5])
  o = rl_cat(rep, o, " owe=" as *u8)
  o = rl_catn(rep, o, nowe)
  o = rl_cat(rep, o, " due=" as *u8)
  o = rl_catn(rep, o, ndue)
  o = rl_cat(rep, o, " owe_amount=" as *u8)
  o = rl_catn(rep, o, owe_amt)
  o = rl_cat(rep, o, " due_amount=" as *u8)
  o = rl_catn(rep, o, due_amt)
  o = rl_cat(rep, o, " settled=" as *u8)
  o = rl_catn(rep, o, ob[6])
  o = rl_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  rl_prefixlog(prefix, lp)
  rl_log(lp, "ledger" as *u8, rep, o)
  return 0
794}
795
796// collect OPEN thank-yous (THANKS with no matching SENT contact|occasion):
797// th[0]=ct th[1]=occ th[2]=dt th[3]=nopen th[4]=sent
798func rl_collect_thanks(prefix: *u8) -> *i64 {
  let th: *i64 = sys_mmap(8 * 8) as *i64
  th[0] = sys_mmap(8 * 256); th[1] = sys_mmap(8 * 256); th[2] = sys_mmap(8 * 256); th[3] = 0; th[4] = 0
  let h_ct: *i64 = th[0] as *i64
  let h_occ: *i64 = th[1] as *i64
  let h_dt: *i64 = th[2] as *i64
  let t_ct: *i64 = sys_mmap(8 * 256) as *i64
  let t_occ: *i64 = sys_mmap(8 * 256) as *i64
  let t_dt: *i64 = sys_mmap(8 * 256) as *i64
  var nt: i64 = 0
  let sent: *i64 = sys_mmap(8 * 256) as *i64
  var nsent: i64 = 0
810
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  let fk: *u8 = sys_mmap(64)
  let fa: *u8 = sys_mmap(128)
  let fb: *u8 = sys_mmap(128)
  let fd: *u8 = sys_mmap(128)
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = rl_cat(path, po, prefix); po = rl_cat(path, po, segs[s] as *u8); po = rl_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 = rl_isrel(b, koff, kl) }
          if take == 1 {
              let rec: *u8 = (b as i64 + voff) as *u8
              if rl_field(rec, vl, "k" as *u8, fk, 64) == 1 {
                  if rl_eq(fk, "thanks" as *u8) == 1 {
                      rl_field(rec, vl, "a" as *u8, fa, 128)
                      rl_field(rec, vl, "b" as *u8, fb, 128)
                      rl_field(rec, vl, "date" as *u8, fd, 128)
                      if nt < 256 { t_ct[nt] = rl_dup(fa) as i64; t_occ[nt] = rl_dup(fb) as i64; t_dt[nt] = rl_dup(fd) as i64; nt = nt + 1 }
                  }
                  if rl_eq(fk, "sent" as *u8) == 1 {
                      rl_field(rec, vl, "a" as *u8, fa, 128)
                      rl_field(rec, vl, "b" as *u8, fb, 128)
                      let key: *u8 = sys_mmap(256)
                      var ko: i64 = 0
                      ko = rl_cat(key, ko, fa); key[ko] = 124 as u8; ko = ko + 1; ko = rl_cat(key, ko, fb); key[ko] = 0 as u8
                      if nsent < 256 { sent[nsent] = rl_dup(key) as i64; nsent = nsent + 1 }
                  }
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
  th[4] = nsent
  var k: i64 = 0
  while k < nt {
      let key: *u8 = sys_mmap(256)
      var ko: i64 = 0
      ko = rl_cat(key, ko, t_ct[k] as *u8); key[ko] = 124 as u8; ko = ko + 1; ko = rl_cat(key, ko, t_occ[k] as *u8); key[ko] = 0 as u8
      if rl_find(sent, nsent, key) < 0 {
          let n: i64 = th[3]
          h_ct[n] = t_ct[k]; h_occ[n] = t_occ[k]; h_dt[n] = t_dt[k]
          th[3] = n + 1
      }
      k = k + 1
  }
  return th
872}
873
874// ---------------- THANKS (gratitude as a tracked debt) ----------------
875func rl_cmd_thanks(argc: i64, argv: *i64) -> i64 {
  if argc < 5 { rl_p("VIZSLA-RELATE thanks needs <prefix> <contacts> <today> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let cf: *i64 = rl_load_contacts(argv[3] as *u8)
  if (cf as i64) == 0 { rl_p("VIZSLA-RELATE contacts MISSING/MALFORMED -- fail loud\n" as *u8); return 1 }
  let today: i64 = rl_datedays(argv[4] as *u8)
  if today < 0 { rl_p("VIZSLA-RELATE bad today date (YYYY-MM-DD) -- fail loud\n" as *u8); return 1 }
  let soon: i64 = cf[9]
883
  let th: *i64 = rl_collect_thanks(prefix)
  let h_ct: *i64 = th[0] as *i64
  let h_occ: *i64 = th[1] as *i64
  let h_dt: *i64 = th[2] as *i64
888
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  var npend: i64 = 0
  var nover: i64 = 0
  var i: i64 = 0
  while i < th[3] {
      let dd: i64 = rl_datedays(h_dt[i] as *u8)
      let days: i64 = today - dd
      o = rl_cat(rep, o, "VIZSLA-RELATE-THANKS contact=" as *u8)
      o = rl_cat(rep, o, h_ct[i] as *u8)
      o = rl_cat(rep, o, " occasion=" as *u8)
      o = rl_cat(rep, o, h_occ[i] as *u8)
      o = rl_cat(rep, o, " owed=" as *u8)
      o = rl_cat(rep, o, h_dt[i] as *u8)
      o = rl_cat(rep, o, " days=" as *u8)
      o = rl_catn(rep, o, days)
      if days > soon {
          nover = nover + 1
          o = rl_cat(rep, o, " state=OVERDUE\n" as *u8)
      } else {
          npend = npend + 1
          o = rl_cat(rep, o, " state=PENDING\n" as *u8)
      }
      i = i + 1
  }
  o = rl_cat(rep, o, "VIZSLA-RELATE-THANKS-VERDICT open=" as *u8)
  o = rl_catn(rep, o, th[3])
  o = rl_cat(rep, o, " pending=" as *u8)
  o = rl_catn(rep, o, npend)
  o = rl_cat(rep, o, " overdue=" as *u8)
  o = rl_catn(rep, o, nover)
  o = rl_cat(rep, o, " sent=" as *u8)
  o = rl_catn(rep, o, th[4])
  o = rl_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  rl_prefixlog(prefix, lp)
  rl_log(lp, "thanks" as *u8, rep, o)
  return 0
928}
929
930// ---------------- BRIEF (the consigliere daily counsel) ----------------
931func rl_cmd_brief(argc: i64, argv: *i64) -> i64 {
  if argc < 5 { rl_p("VIZSLA-RELATE brief needs <prefix> <contacts> <today> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let cf: *i64 = rl_load_contacts(argv[3] as *u8)
  if (cf as i64) == 0 { rl_p("VIZSLA-RELATE contacts MISSING/MALFORMED -- fail loud\n" as *u8); return 1 }
  let tstr: *u8 = argv[4] as *u8
  let today: i64 = rl_datedays(tstr)
  if today < 0 { rl_p("VIZSLA-RELATE bad today date (YYYY-MM-DD) -- fail loud\n" as *u8); return 1 }
  let soon: i64 = cf[9]
940
  let ct_id: *i64 = cf[0] as *i64
  let ct_tier: *i64 = cf[2] as *i64
  let ct_bday: *i64 = cf[3] as *i64
  let tr_days: *i64 = cf[6] as *i64
  let a_days: *i64 = sys_mmap(8 * 256) as *i64
  let a_date: *i64 = sys_mmap(8 * 256) as *i64
  rl_latest_touch(prefix, cf, a_days, a_date)
948
  let rep: *u8 = sys_mmap(K_MAGIC_131072)
  var o: i64 = 0
  o = rl_cat(rep, o, "VIZSLA-RELATE-BRIEF date=" as *u8)
  o = rl_cat(rep, o, tstr)
  o = rl_cat(rep, o, "\n" as *u8)
954
  // 1) follow-ups due (tier cadence exceeded) or NEW
  var nfollow: i64 = 0
  var i: i64 = 0
  while i < cf[4] {
      let cad: i64 = tr_days[ct_tier[i]]
      var flag: i64 = 0
      if a_days[i] < 0 { flag = 2 } else { if today - a_days[i] > cad { flag = 1 } }
      if flag > 0 {
          nfollow = nfollow + 1
          o = rl_cat(rep, o, "  FOLLOWUP contact=" as *u8)
          o = rl_cat(rep, o, ct_id[i] as *u8)
          if flag == 2 {
              o = rl_cat(rep, o, " (NEW)\n" as *u8)
          } else {
              o = rl_cat(rep, o, " days=" as *u8)
              o = rl_catn(rep, o, today - a_days[i])
              o = rl_cat(rep, o, " (DUE)\n" as *u8)
          }
      }
      i = i + 1
  }
976
  // 2) upcoming birthdays within soon_days
  var nbday: i64 = 0
  var bi: i64 = 0
  while bi < cf[4] {
      let until: i64 = rl_bday_until(tstr, today, ct_bday[bi] as *u8)
      if until >= 0 {
          if until <= soon {
              nbday = nbday + 1
              o = rl_cat(rep, o, "  BIRTHDAY contact=" as *u8)
              o = rl_cat(rep, o, ct_id[bi] as *u8)
              o = rl_cat(rep, o, " on=" as *u8)
              o = rl_cat(rep, o, ct_bday[bi] as *u8)
              o = rl_cat(rep, o, " in=" as *u8)
              o = rl_catn(rep, o, until)
              o = rl_cat(rep, o, "d\n" as *u8)
          }
      }
      bi = bi + 1
  }
996
  // 3) open thank-yous
  let th: *i64 = rl_collect_thanks(prefix)
  let h_ct: *i64 = th[0] as *i64
  let h_occ: *i64 = th[1] as *i64
  let h_dt: *i64 = th[2] as *i64
  var ti: i64 = 0
  while ti < th[3] {
      let dd: i64 = rl_datedays(h_dt[ti] as *u8)
      o = rl_cat(rep, o, "  THANKYOU contact=" as *u8)
      o = rl_cat(rep, o, h_ct[ti] as *u8)
      o = rl_cat(rep, o, " occasion=" as *u8)
      o = rl_cat(rep, o, h_occ[ti] as *u8)
      if today - dd > soon { o = rl_cat(rep, o, " (OVERDUE)\n" as *u8) } else { o = rl_cat(rep, o, " (PENDING)\n" as *u8) }
      ti = ti + 1
  }
1012
  // 4) open obligations
  let ob: *i64 = rl_collect_obligs(prefix)
  let o_ct: *i64 = ob[0] as *i64
  let o_dir: *i64 = ob[1] as *i64
  let o_ref: *i64 = ob[2] as *i64
  var oi: i64 = 0
  while oi < ob[5] {
      o = rl_cat(rep, o, "  OBLIGATION contact=" as *u8)
      o = rl_cat(rep, o, o_ct[oi] as *u8)
      o = rl_cat(rep, o, " dir=" as *u8)
      o = rl_cat(rep, o, o_dir[oi] as *u8)
      o = rl_cat(rep, o, " ref=" as *u8)
      o = rl_cat(rep, o, o_ref[oi] as *u8)
      o = rl_cat(rep, o, "\n" as *u8)
      oi = oi + 1
  }
1029
  o = rl_cat(rep, o, "VIZSLA-RELATE-BRIEF-VERDICT followups=" as *u8)
  o = rl_catn(rep, o, nfollow)
  o = rl_cat(rep, o, " birthdays=" as *u8)
  o = rl_catn(rep, o, nbday)
  o = rl_cat(rep, o, " thankyous=" as *u8)
  o = rl_catn(rep, o, th[3])
  o = rl_cat(rep, o, " obligations=" as *u8)
  o = rl_catn(rep, o, ob[5])
  o = rl_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  let lp: *u8 = sys_mmap(512)
  rl_prefixlog(prefix, lp)
  rl_log(lp, "brief" as *u8, rep, o)
  return 0
1044}
1045
1046func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { rl_p("VIZSLA-RELATE usage: load|cadence|ledger|thanks|brief -- fail loud\n" as *u8); return 1 }
  let cmd: *u8 = argv[1] as *u8
  if rl_eq(cmd, "load" as *u8) == 1 { return rl_cmd_load(argc, argv) }
  if rl_eq(cmd, "cadence" as *u8) == 1 { return rl_cmd_cadence(argc, argv) }
  if rl_eq(cmd, "ledger" as *u8) == 1 { return rl_cmd_ledger(argc, argv) }
  if rl_eq(cmd, "thanks" as *u8) == 1 { return rl_cmd_thanks(argc, argv) }
  if rl_eq(cmd, "brief" as *u8) == 1 { return rl_cmd_brief(argc, argv) }
  rl_p("VIZSLA-RELATE unknown command (load|cadence|ledger|thanks|brief) -- fail loud\n" as *u8)
  return 1
1056}
nx_vizsla_relate.nx source

`nx_vizsla_relate.nx` source
