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

↩ module page · 604 lines · 21540 B
1// nx_vizsla_budget.nx -- NISHI VIZSLA V1: the family budget ledger.
2// Fills finance/EDITOR (reconcile) and feeds finance/ARCHITECT (plan) from the
3// V0 gap profile.  Storage = the INFOMGMT seg_store substrate (append-only
4// immutable segments, rename(2) commit point, fsync power-loss closure) with
5// nx_canon_cid content addressing -- NO SQL, additive law: money history is
6// never destroyed.
7//
8// Commands (argv[1]):
9//   load   <txnfile> <prefix> [segid]    parse TXN rows -> canonical records ->
10//                                        CID keys "txn:nxc1-..."; a record whose
11//                                        CID already exists in the store is a
12//                                        DUP not a rewrite = IDEMPOTENT RE-LOAD
13//                                        (law 10) by construction.  segid
14//                                        defaults to sys_now_us(); the gate
15//                                        passes explicit ids for determinism.
16//   report <prefix> <envfile> [asof]     per-category sums vs ENV envelopes.
17//                                        asof = max segment id to read (0 or
18//                                        absent = ALL) = TIME-TRAVEL: the
19//                                        ledger exactly as it stood at that
20//                                        commit, reconstructed from history.
21//   verify <prefix>                      recompute every record's CID and
22//                                        compare to its key = TAMPER-EVIDENCE.
23//                                        Any flipped byte names its segment.
24//   (no args)                            report on the durable family store
25//                                        knowledge/vizsla/ledger- with
26//                                        knowledge/vizsla/envelopes.txt.
27//
28// File formats (line records, # comments):
29//   TXN <date> <amount_cents> <category> <desc>     (amount: digits only --
30//       V1 scope is the expense ledger; credits/income = V1b, flagged not silent)
31//   ENV <category> <budget_cents>
32//
33// Determinism: stdout has no clocks; epoch header goes to "<prefix>budget.log"
34// only (log path derived from the store prefix, so gate fixtures in /tmp can
35// never pollute the family log).  Loud-fail law: missing files, malformed TXN
36// rows, non-digit amounts = exit 1 with a named reason.
37// EXCEED vs consumer budget apps: additive history + as-of-commit time travel
38// + content-address tamper evidence; none of Mint/YNAB-class tools prove any.
39// spec: knowledge/specs/2026-06-10-nishi-vizsla-ladder.md   license_tier: ORIGINAL
40import "nx_syscalls.nx"
41import "nx_canon_cid.nx"
42import "nx_seg_store.nx"
43const K_MAGIC_2048: i64 = 2048
44const K_MAGIC_4096: i64 = 4096
45const K_MAGIC_65536: i64 = 65536
46
47func vb_slen(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  return n
51}
52
53func vb_p(s: *u8) -> i64 {
  sys_write(1, s, vb_slen(s))
  return 0
56}
57
58func vb_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
67}
68
69func vb_dup(s: *u8) -> *u8 {
  let n: i64 = vb_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
75}
76
77func vb_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
86}
87
88// strict: 1 iff non-empty and every char is a digit (boundary validation, law 12)
89func vb_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
99}
100
101func vb_isws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 13 { return 1 }
  if c == 9 { return 1 }
  return 0
106}
107
108// next whitespace-delimited token from b[off..lend) -> dst; returns new offset
109func vb_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 vb_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 vb_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 vb_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 vb_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
150// find s in a ptr-list; -1 if absent
151func vb_find(list: *i64, n: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < n {
      if vb_eq(list[i] as *u8, s) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
158}
159
160// compare blob bytes b[off..off+n) against null-terminated s of length n
161func vb_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
  if vb_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
169}
170
171// extract field `want` from canonical NXR1 bytes into out; 1 found / 0 absent
172func vb_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 vb_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
197}
198
199// is entry key b[koff..koff+kl) a "txn:" record key? (flag-style, shallow ifs)
200func vb_istxn(b: *u8, koff: i64, kl: i64) -> i64 {
  if kl <= 4 { return 0 }
  return vb_kmemeq(b, koff, 4, "txn:" as *u8)
203}
204
205// "<prefix>budget.log" -- log home derived from the store prefix (fixture isolation)
206func vb_logpath(prefix: *u8, out: *u8) -> i64 {
  var o: i64 = 0
  o = vb_cat(out, o, prefix)
  o = vb_cat(out, o, "budget.log" as *u8)
  out[o] = 0 as u8
  return o
212}
213
214// append `rep` (o bytes) to the prefix log with an epoch header line
215func vb_log(prefix: *u8, tag: *u8, rep: *u8, o: i64) -> i64 {
  let lp: *u8 = sys_mmap(512)
  vb_logpath(prefix, lp)
  let fd: i64 = sys_openat_append(lp, 0x1a4)
  if fd <= 0 { return 0 }
  let hdr: *u8 = sys_mmap(256)
  var ho: i64 = 0
  ho = vb_cat(hdr, ho, "VIZSLA-BUDGET epoch=" as *u8)
  ho = vb_catn(hdr, ho, sys_now_realtime_sec())
  ho = vb_cat(hdr, ho, " cmd=" as *u8)
  ho = vb_cat(hdr, ho, tag)
  ho = vb_cat(hdr, ho, "\n" as *u8)
  sys_write(fd, hdr, ho)
  sys_write(fd, rep, o)
  sys_close(fd)
  return 0
231}
232
233// accumulate one canonical txn record into the category table.
234// st: [0]=cats ptr-list [1]=sums [2]=ncat [3]=txns [4]=total_cents
235func vb_acc(rec: *u8, rl: i64, st: *i64) -> i64 {
  let fcat: *u8 = sys_mmap(128)
  let famt: *u8 = sys_mmap(128)
  if vb_field(rec, rl, "category" as *u8, fcat, 128) == 0 { return 0 }
  if vb_field(rec, rl, "amount" as *u8, famt, 128) == 0 { return 0 }
  let cats: *i64 = st[0] as *i64
  let sums: *i64 = st[1] as *i64
  var ci: i64 = vb_find(cats, st[2], fcat)
  if ci < 0 {
      if st[2] >= 256 { return 0 }
      cats[st[2]] = vb_dup(fcat) as i64
      sums[st[2]] = 0
      ci = st[2]
      st[2] = st[2] + 1
  }
  let amt: i64 = vb_atoi(famt)
  sums[ci] = sums[ci] + amt
  st[3] = st[3] + 1
  st[4] = st[4] + amt
  return 1
255}
256
257// ---------------- LOAD ----------------
258func vb_cmd_load(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vb_p("VIZSLA-BUDGET load needs <txnfile> <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 = vb_atoi(argv[4] as *u8) }
  if segid == 0 { segid = sys_now_us() }
265
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = ss_readall(tpath, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { vb_p("VIZSLA-BUDGET txnfile MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
270
  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] = "amount" as *u8 as i64
  keys[3] = "category" as *u8 as i64
  keys[4] = "desc" as *u8 as i64
  vals[0] = "txn" as *u8 as i64
279
  let t0: *u8 = sys_mmap(128)
  let dt: *u8 = sys_mmap(128)
  let am: *u8 = sys_mmap(128)
  let ct: *u8 = sys_mmap(128)
  let ds: *u8 = sys_mmap(256)
  let pp: *i64 = sys_mmap(16) as *i64
  let ll: *i64 = sys_mmap(16) as *i64
287
  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
295
  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 = vb_tok(b, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vb_eq(t0, "TXN" as *u8) == 1 {
          scanned = scanned + 1
          p = vb_tok(b, p, e, dt, 128)
          p = vb_tok(b, p, e, am, 128)
          p = vb_tok(b, p, e, ct, 128)
          p = vb_tok(b, p, e, ds, 256)
          if dt[0] == (0 as u8) { vb_p("VIZSLA-BUDGET TXN missing date -- fail loud\n" as *u8); return 1 }
          if vb_digits(am) == 0 { vb_p("VIZSLA-BUDGET TXN amount not pure digits (credits=V1b) -- fail loud\n" as *u8); return 1 }
          if ct[0] == (0 as u8) { vb_p("VIZSLA-BUDGET TXN missing category -- fail loud\n" as *u8); return 1 }
          if ds[0] == (0 as u8) { vb_p("VIZSLA-BUDGET TXN missing desc -- fail loud\n" as *u8); return 1 }
          vals[1] = dt as i64
          vals[2] = am as i64
          vals[3] = ct as i64
          vals[4] = ds 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 = vb_cat(kbuf, ko, "txn:" as *u8)
          ko = vb_cat(kbuf, ko, cid)
          kbuf[ko] = 0 as u8
          // flattened dedup ladder (in-file CID repeat, then in-store CID hit)
          var fresh: i64 = 1
          if vb_find(seen, nseen, kbuf) >= 0 { fresh = 0; dup_infile = dup_infile + 1 }
          if fresh == 1 {
              if nseen < K_MAGIC_2048 { seen[nseen] = vb_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 { vb_p("VIZSLA-BUDGET writer full -- fail loud\n" as *u8); return 1 }
              added = added + 1
          }
      }
      i = e + 1
  }
346
  var committed: i64 = 0
  if added > 0 {
      if ss_commit(prefix, w, segid) != 0 { vb_p("VIZSLA-BUDGET commit FAILED -- fail loud\n" as *u8); return 1 }
      committed = 1
  }
352
  let rep: *u8 = sys_mmap(K_MAGIC_4096)
  var o: i64 = 0
  o = vb_cat(rep, o, "VIZSLA-LEDGER-LOAD scanned=" as *u8)
  o = vb_catn(rep, o, scanned)
  o = vb_cat(rep, o, " new=" as *u8)
  o = vb_catn(rep, o, added)
  o = vb_cat(rep, o, " dup_infile=" as *u8)
  o = vb_catn(rep, o, dup_infile)
  o = vb_cat(rep, o, " dup_instore=" as *u8)
  o = vb_catn(rep, o, dup_instore)
  o = vb_cat(rep, o, " segment=" as *u8)
  if committed == 1 {
      o = vb_cat(rep, o, "seg-" as *u8)
      o = vb_catn(rep, o, segid)
  } else {
      o = vb_cat(rep, o, "none" as *u8)
  }
  o = vb_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  vb_log(prefix, "load" as *u8, rep, o)
  return 0
374}
375
376// ---------------- VERIFY (tamper-evidence) ----------------
377func vb_cmd_verify(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { vb_p("VIZSLA-BUDGET verify needs <prefix> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  if ns == 0 { vb_p("VIZSLA-BUDGET verify: no manifest/segments -- fail loud\n" as *u8); return 1 }
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  var entries: i64 = 0
  var bad: i64 = 0
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = vb_cat(path, po, prefix)
      po = vb_cat(path, po, segs[s] as *u8)
      po = vb_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 i: i64 = 0
      while i + 9 <= sz {
          let kl: i64 = ss_r32(b, i + 1)
          let koff: i64 = i + 5
          let vl: i64 = ss_r32(b, koff + kl)
          let voff: i64 = koff + kl + 4
          if vb_istxn(b, koff, kl) == 1 {
              entries = entries + 1
              let cid: *u8 = sys_mmap(96)
              let cl: i64 = cid_of((b as i64 + voff) as *u8, vl, cid)
              var ok: i64 = 1
              if kl - 4 != cl { ok = 0 }
              var t: i64 = 0
              while t < cl {
                  if ok == 1 { if b[koff + 4 + t] != cid[t] { ok = 0 } }
                  t = t + 1
              }
              if ok == 0 {
                  bad = bad + 1
                  o = vb_cat(rep, o, "VIZSLA-LEDGER-TAMPER segment=" as *u8)
                  o = vb_cat(rep, o, segs[s] as *u8)
                  o = vb_cat(rep, o, " entry=" as *u8)
                  o = vb_catn(rep, o, entries)
                  o = vb_cat(rep, o, " cid-mismatch\n" as *u8)
              }
          }
          i = voff + vl
      }
      s = s + 1
  }
  o = vb_cat(rep, o, "VIZSLA-LEDGER-VERIFY entries=" as *u8)
  o = vb_catn(rep, o, entries)
  o = vb_cat(rep, o, " bad=" as *u8)
  o = vb_catn(rep, o, bad)
  if bad == 0 {
      o = vb_cat(rep, o, " verdict=CLEAN\n" as *u8)
  } else {
      o = vb_cat(rep, o, " verdict=TAMPERED\n" as *u8)
  }
  sys_write(1, rep, o)
  vb_log(prefix, "verify" as *u8, rep, o)
  if bad == 0 { return 0 }
  return 1
441}
442
443// ---------------- REPORT (default; time-travel via asof) ----------------
444func vb_cmd_report(prefix: *u8, epath: *u8, asof: i64) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let eb: *u8 = ss_readall(epath, szp)
  let esz: i64 = szp[0]
  if esz <= 0 { vb_p("VIZSLA-BUDGET envelopes MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
449
  // parse envelopes (file order = report order)
  let e_cat: *i64 = sys_mmap(8 * 64) as *i64
  let e_bud: *i64 = sys_mmap(8 * 64) as *i64
  var nenv: i64 = 0
  let t0: *u8 = sys_mmap(128)
  let t1: *u8 = sys_mmap(128)
  let t2: *u8 = sys_mmap(128)
  var i: i64 = 0
  while i < esz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 {
          if e >= esz { go = 0 } else {
              if eb[e] == (10 as u8) { go = 0 } else { e = e + 1 }
          }
      }
      var p: i64 = vb_tok(eb, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vb_eq(t0, "ENV" as *u8) == 1 {
          p = vb_tok(eb, p, e, t1, 128)
          p = vb_tok(eb, p, e, t2, 128)
          if vb_digits(t2) == 0 { vb_p("VIZSLA-BUDGET ENV budget not pure digits -- fail loud\n" as *u8); return 1 }
          if nenv < 64 { e_cat[nenv] = vb_dup(t1) as i64; e_bud[nenv] = vb_atoi(t2); nenv = nenv + 1 }
      }
      i = e + 1
  }
476
  // walk committed segments (chronological; asof bounds the read = time travel)
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  let st: *i64 = sys_mmap(8 * 8) as *i64
  st[0] = sys_mmap(8 * 256)
  st[1] = sys_mmap(8 * 256)
  st[2] = 0
  st[3] = 0
  st[4] = 0
  var segread: i64 = 0
  var s: i64 = 0
  while s < ns {
      var use: i64 = 1
      if asof > 0 { if vb_atoi(segs[s] as *u8) > asof { use = 0 } }
      if use == 1 {
          segread = segread + 1
          let path: *u8 = sys_mmap(512)
          var po: i64 = 0
          po = vb_cat(path, po, prefix)
          po = vb_cat(path, po, segs[s] as *u8)
          po = vb_cat(path, po, ".docs" as *u8)
          path[po] = 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 = vb_istxn(b, koff, kl) }
              if take == 1 { vb_acc((b as i64 + voff) as *u8, vl, st) }
              j = voff + vl
          }
      }
      s = s + 1
  }
  let cats: *i64 = st[0] as *i64
  let sums: *i64 = st[1] as *i64
  let ncat: i64 = st[2]
520
  // compose the report: envelope-order rows, then unbudgeted (honesty: named, not dropped)
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  o = vb_cat(rep, o, "VIZSLA-LEDGER-REPORT asof=" as *u8)
  if asof > 0 { o = vb_catn(rep, o, asof) } else { o = vb_cat(rep, o, "ALL" as *u8) }
  o = vb_cat(rep, o, " segments=" as *u8)
  o = vb_catn(rep, o, segread)
  o = vb_cat(rep, o, "\n" as *u8)
  var over: i64 = 0
  var unb: i64 = 0
  var ei: i64 = 0
  while ei < nenv {
      var spent: i64 = 0
      let ci2: i64 = vb_find(cats, ncat, e_cat[ei] as *u8)
      if ci2 >= 0 { spent = sums[ci2] }
      let delta: i64 = e_bud[ei] - spent
      o = vb_cat(rep, o, "VIZSLA-LEDGER category=" as *u8)
      o = vb_cat(rep, o, e_cat[ei] as *u8)
      o = vb_cat(rep, o, " spent=" as *u8)
      o = vb_catn(rep, o, spent)
      o = vb_cat(rep, o, " budget=" as *u8)
      o = vb_catn(rep, o, e_bud[ei])
      o = vb_cat(rep, o, " delta=" as *u8)
      o = vb_catn(rep, o, delta)
      if delta >= 0 {
          o = vb_cat(rep, o, " state=OK\n" as *u8)
      } else {
          o = vb_cat(rep, o, " state=OVER\n" as *u8)
          over = over + 1
      }
      ei = ei + 1
  }
  var ci3: i64 = 0
  while ci3 < ncat {
      if vb_find(e_cat, nenv, cats[ci3] as *u8) < 0 {
          unb = unb + 1
          o = vb_cat(rep, o, "VIZSLA-LEDGER category=" as *u8)
          o = vb_cat(rep, o, cats[ci3] as *u8)
          o = vb_cat(rep, o, " spent=" as *u8)
          o = vb_catn(rep, o, sums[ci3])
          o = vb_cat(rep, o, " budget=0 delta=" as *u8)
          o = vb_catn(rep, o, 0 - sums[ci3])
          o = vb_cat(rep, o, " state=UNBUDGETED\n" as *u8)
      }
      ci3 = ci3 + 1
  }
  o = vb_cat(rep, o, "VIZSLA-LEDGER-TOTAL txns=" as *u8)
  o = vb_catn(rep, o, st[3])
  o = vb_cat(rep, o, " spent=" as *u8)
  o = vb_catn(rep, o, st[4])
  o = vb_cat(rep, o, "\n" as *u8)
  o = vb_cat(rep, o, "VIZSLA-LEDGER-VERDICT envelopes=" as *u8)
  o = vb_catn(rep, o, nenv)
  o = vb_cat(rep, o, " over=" as *u8)
  o = vb_catn(rep, o, over)
  o = vb_cat(rep, o, " unbudgeted=" as *u8)
  o = vb_catn(rep, o, unb)
  if over == 0 {
      o = vb_cat(rep, o, " state=WITHIN\n" as *u8)
  } else {
      o = vb_cat(rep, o, " state=ATTENTION\n" as *u8)
  }
  sys_write(1, rep, o)
  vb_log(prefix, "report" as *u8, rep, o)
  return 0
586}
587
588func main(argc: i64, argv: *i64) -> i64 {
  var cmd: *u8 = "report" as *u8
  if argc > 1 { cmd = argv[1] as *u8 }
  if vb_eq(cmd, "load" as *u8) == 1 { return vb_cmd_load(argc, argv) }
  if vb_eq(cmd, "verify" as *u8) == 1 { return vb_cmd_verify(argc, argv) }
  if vb_eq(cmd, "report" as *u8) == 0 {
      vb_p("VIZSLA-BUDGET unknown command (load|report|verify) -- fail loud\n" as *u8)
      return 1
  }
  var prefix: *u8 = "knowledge/vizsla/ledger-" as *u8
  var epath: *u8 = "knowledge/vizsla/envelopes.txt" as *u8
  var asof: i64 = 0
  if argc > 2 { prefix = argv[2] as *u8 }
  if argc > 3 { epath = argv[3] as *u8 }
  if argc > 4 { asof = vb_atoi(argv[4] as *u8) }
  return vb_cmd_report(prefix, epath, asof)
604}
nx_vizsla_budget.nx source

`nx_vizsla_budget.nx` source
