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

↩ module page · 1309 lines · 47553 B
1// nx_vizsla_plan.nx -- NISHI VIZSLA PLANNER: PMP-grade mechanics, friend-group simple.
2// Operator 2026-07-07: "planning with pmp level but simple for a friend group". Closes the last
3// census-ABSENT planning axes: PA7 PRIORITY (Eisenhower urgency x importance), PA8 DEPENDENCIES
4// (DAG + cycle detection + critical path), PA13 TIME-BLOCKING (place ready tasks into real
5// calendar free windows). All integer, NO-FLOAT, deterministic (today/date are argv, never a clock).
6//
7// Records (load <file> <prefix> [segid], additive + CID-idempotent law 10):
8//   CONF <plan> <u4_days> <u3_days> <u2_days>   -> "cnf:" urgency bands (data, not magic numbers;
9//                                                  absent -> bootstrap defaults 2/7/30)
10//   TASK <plan> <tid> <owner> <due> <effort_min> <imp 1-5> <dep[,dep..]|-> <title> -> "tsk:"
11//   MILE <plan> <mid> <date> <title>            -> "mil:" milestone
12//   DONE <plan> <tid> <date>                    -> "don:" completion marker (additive history)
13// Commands:
14//   board <prefix> <plan> <today>
15//     per task: state READY (deps done) / BLOCKED / DONE; urgency from days-to-due vs the CONF
16//     bands (overdue=5); score = urg*10 + imp*2; late flag. Dependency DAG is Kahn-checked --
17//     a CYCLE or unknown dep names the offenders and fails loud (a plan you cannot execute is a
18//     data error, not a rendering choice). CRITICAL PATH = longest-effort dependency chain
19//     (topo-order DP), named task-by-task. Milestones report done/due_tasks/pct. Verdict rolls up.
20//   timeblock <prefix> <plan> <calprefix> <date> [earliest latest]
21//     READY tasks in priority order first-fit into the calendar's real free windows that day
22//     (composes the R-CAL busy walk: cal: events + rec: occurrences). Too-big tasks are named
23//     UNPLACED -- honesty over silent drop.
24// Loud-fail: bad dates/imp/effort, unknown dep, cycle, unknown plan, bad bounds.
25// spec: knowledge/research/2026-06-22-vizsla-sclass-roadmap.md   license_tier: ORIGINAL
26import "nx_syscalls.nx"
27import "nx_canon_cid.nx"
28import "nx_seg_store.nx"
29const K_MAGIC_1970: i64 = 1970
30const K_MAGIC_146097: i64 = 146097
31const K_MAGIC_719468: i64 = 719468
32const K_MAGIC_146096: i64 = 146096
33const K_MAGIC_1460: i64 = 1460
34const K_MAGIC_36524: i64 = 36524
35const K_MAGIC_2048: i64 = 2048
36const K_MAGIC_4096: i64 = 4096
37const K_MAGIC_262144: i64 = 262144
38const K_MAGIC_1440: i64 = 1440
39const K_MAGIC_65536: i64 = 65536
40
41func vp_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
42func vp_p(s: *u8) -> i64 { sys_write(1, s, vp_slen(s)); return 0 }
43
44func vp_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
53}
54
55func vp_cmp(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let ca: i64 = a[i] as i64
      let cb: i64 = b[i] as i64
      if ca < cb { return 0 - 1 }
      if ca > cb { return 1 }
      if ca == 0 { return 0 }
      i = i + 1
  }
  return 0
67}
68
69func vp_dup(s: *u8) -> *u8 {
  let n: i64 = vp_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 vp_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
88func vp_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
98}
99
100func vp_isws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 13 { return 1 }
  if c == 9 { return 1 }
  return 0
105}
106
107func vp_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 vp_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 vp_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
127}
128
129func vp_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
133}
134
135func vp_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
146}
147
148func vp_hhmm(dst: *u8, off: i64, m: i64) -> i64 {
  var o: i64 = off
  let h: i64 = m / 60
  let mm: i64 = m - h * 60
  if h < 10 { dst[o] = 48 as u8; o = o + 1 }
  o = vp_catn(dst, o, h)
  dst[o] = 58 as u8; o = o + 1
  if mm < 10 { dst[o] = 48 as u8; o = o + 1 }
  o = vp_catn(dst, o, mm)
  return o
158}
159
160func vp_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
  if vp_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
168}
169
170func vp_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 vp_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
195}
196
197func vp_iskind(b: *u8, koff: i64, kl: i64, pfx: *u8) -> i64 {
  if kl <= 4 { return 0 }
  return vp_kmemeq(b, koff, 4, pfx)
200}
201
202func vp_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
241}
242
243func vp_ymd2days(y0: i64, m: i64, d: i64) -> i64 {
  var y: i64 = y0
  if m <= 2 { y = y0 - 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
255func vp_civil(z0: i64, out: *i64) -> i64 {
  var z: i64 = z0 + K_MAGIC_719468
  var era: i64 = z / K_MAGIC_146097
  if z < 0 { era = (z - K_MAGIC_146096) / K_MAGIC_146097 }
  let doe: i64 = z - era * K_MAGIC_146097
  let yoe: i64 = (doe - doe / K_MAGIC_1460 + doe / K_MAGIC_36524 - doe / K_MAGIC_146096) / 365
  let y0: i64 = yoe + era * 400
  let doy: i64 = doe - (365 * yoe + yoe / 4 - yoe / 100)
  let mp: i64 = (5 * doy + 2) / 153
  let d: i64 = doy - (153 * mp + 2) / 5 + 1
  var m: i64 = mp + 3
  if mp >= 10 { m = mp - 9 }
  var y: i64 = y0
  if m <= 2 { y = y0 + 1 }
  out[0] = y; out[1] = m; out[2] = d
  return 0
271}
272
273func vp_dim(y: i64, m: i64) -> i64 {
  if m == 2 {
      var leap: i64 = 0
      if y % 4 == 0 { leap = 1 }
      if y % 100 == 0 { leap = 0 }
      if y % 400 == 0 { leap = 1 }
      if leap == 1 { return 29 }
      return 28
  }
  if m == 4 { return 30 }
  if m == 6 { return 30 }
  if m == 9 { return 30 }
  if m == 11 { return 30 }
  return 31
287}
288
289func vp_occ(freq: *u8, sd0: i64, sy: i64, sm: i64, sd: i64, interval: i64, k: i64) -> i64 {
  if vp_eq(freq, "DAILY" as *u8) == 1 { return sd0 + k * interval }
  if vp_eq(freq, "WEEKLY" as *u8) == 1 { return sd0 + k * interval * 7 }
  var mstep: i64 = interval
  if vp_eq(freq, "YEARLY" as *u8) == 1 { mstep = interval * 12 }
  let tot: i64 = (sm - 1) + k * mstep
  let y2: i64 = sy + tot / 12
  let m2: i64 = tot - (tot / 12) * 12 + 1
  var d2: i64 = sd
  let dim: i64 = vp_dim(y2, m2)
  if d2 > dim { d2 = dim }
  return vp_ymd2days(y2, m2, d2)
301}
302
303func vp_find(list: *i64, n: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < n {
      if vp_eq(list[i] as *u8, s) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
310}
311
312func vp_put(keys: *i64, vals: *i64, nf: i64, kp: *u8, st: *i64) -> i64 {
  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 = vp_cat(kbuf, ko, kp)
  ko = vp_cat(kbuf, ko, cid)
  kbuf[ko] = 0 as u8
  let seen: *i64 = st[1] as *i64
  var fresh: i64 = 1
  if vp_find(seen, st[2], kbuf) >= 0 { fresh = 0; st[4] = st[4] + 1 }
  if fresh == 1 {
      if st[2] < K_MAGIC_2048 {
          let dk: *u8 = vp_dup(kbuf)
          seen[st[2]] = dk as i64
          st[2] = st[2] + 1
      }
  }
  if fresh == 1 {
      let pp: *i64 = sys_mmap(16) as *i64
      let ll: *i64 = sys_mmap(16) as *i64
      if ss_get_idx(st[6] as *u8, kbuf, pp, ll) == 1 { fresh = 0; st[5] = st[5] + 1 }
  }
  if fresh == 1 {
      if ss_add(st[0] as *i64, 1, kbuf, enc, el) != 0 { return 0 - 1 }
      st[3] = st[3] + 1
  }
  return 0
342}
343
344// ---------------- LOAD ----------------
345func vp_cmd_load(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vp_p("VIZSLA-PLAN load needs <file> <prefix> -- fail loud\n" as *u8); return 1 }
  let efile: *u8 = argv[2] as *u8
  let prefix: *u8 = argv[3] as *u8
  var segid: i64 = 0
  if argc > 4 { segid = vp_atoi(argv[4] as *u8) }
  if segid == 0 { segid = sys_now_us() }
352
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = ss_readall(efile, szp)
  let sz: i64 = szp[0]
  if sz <= 0 { vp_p("VIZSLA-PLAN file MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
357
  let ckeys: *i64 = sys_mmap(8 * 8) as *i64
  let cvals: *i64 = sys_mmap(8 * 8) as *i64
  ckeys[0] = "kind" as *u8 as i64
  ckeys[1] = "plan" as *u8 as i64
  ckeys[2] = "u4" as *u8 as i64
  ckeys[3] = "u3" as *u8 as i64
  ckeys[4] = "u2" as *u8 as i64
  cvals[0] = "cnf" as *u8 as i64
  let tkeys: *i64 = sys_mmap(8 * 12) as *i64
  let tvals: *i64 = sys_mmap(8 * 12) as *i64
  tkeys[0] = "kind" as *u8 as i64
  tkeys[1] = "plan" as *u8 as i64
  tkeys[2] = "tid" as *u8 as i64
  tkeys[3] = "owner" as *u8 as i64
  tkeys[4] = "due" as *u8 as i64
  tkeys[5] = "effort" as *u8 as i64
  tkeys[6] = "imp" as *u8 as i64
  tkeys[7] = "dep" as *u8 as i64
  tkeys[8] = "title" as *u8 as i64
  tvals[0] = "tsk" as *u8 as i64
  let mkeys: *i64 = sys_mmap(8 * 8) as *i64
  let mvals: *i64 = sys_mmap(8 * 8) as *i64
  mkeys[0] = "kind" as *u8 as i64
  mkeys[1] = "plan" as *u8 as i64
  mkeys[2] = "mid" as *u8 as i64
  mkeys[3] = "date" as *u8 as i64
  mkeys[4] = "title" as *u8 as i64
  mvals[0] = "mil" as *u8 as i64
  let dkeys: *i64 = sys_mmap(8 * 8) as *i64
  let dvals: *i64 = sys_mmap(8 * 8) as *i64
  dkeys[0] = "kind" as *u8 as i64
  dkeys[1] = "plan" as *u8 as i64
  dkeys[2] = "tid" as *u8 as i64
  dkeys[3] = "date" as *u8 as i64
  dvals[0] = "don" as *u8 as i64
393
  let st: *i64 = sys_mmap(8 * 8) as *i64
  st[0] = ss_begin() as i64
  st[1] = sys_mmap(8 * K_MAGIC_2048)
  st[2] = 0
  st[3] = 0
  st[4] = 0
  st[5] = 0
  st[6] = prefix as i64
402
  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 f7: *u8 = sys_mmap(256)
  let fdep: *u8 = sys_mmap(256)
  let ftl: *u8 = sys_mmap(256)
  var scanned: i64 = 0
414
  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 = vp_tok(b, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if vp_eq(t0, "CONF" as *u8) == 1 {
          scanned = scanned + 1
          p = vp_tok(b, p, e, f1, 128)
          p = vp_tok(b, p, e, f2, 128)
          p = vp_tok(b, p, e, f3, 128)
          p = vp_tok(b, p, e, f4, 128)
          if f1[0] == (0 as u8) { vp_p("VIZSLA-PLAN CONF missing plan -- fail loud\n" as *u8); return 1 }
          if vp_digits(f2) == 0 { vp_p("VIZSLA-PLAN CONF u4 not digits -- fail loud\n" as *u8); return 1 }
          if vp_digits(f3) == 0 { vp_p("VIZSLA-PLAN CONF u3 not digits -- fail loud\n" as *u8); return 1 }
          if vp_digits(f4) == 0 { vp_p("VIZSLA-PLAN CONF u2 not digits -- fail loud\n" as *u8); return 1 }
          cvals[1] = f1 as i64
          cvals[2] = f2 as i64
          cvals[3] = f3 as i64
          cvals[4] = f4 as i64
          if vp_put(ckeys, cvals, 5, "cnf:" as *u8, st) != 0 { vp_p("VIZSLA-PLAN writer full -- fail loud\n" as *u8); return 1 }
      }
      if vp_eq(t0, "TASK" as *u8) == 1 {
          scanned = scanned + 1
          p = vp_tok(b, p, e, f1, 128)
          p = vp_tok(b, p, e, f2, 128)
          p = vp_tok(b, p, e, f3, 128)
          p = vp_tok(b, p, e, f4, 128)
          p = vp_tok(b, p, e, f5, 128)
          p = vp_tok(b, p, e, f6, 256)
          let fimp: *u8 = f6
          // TASK <plan> <tid> <owner> <due> <effort> <imp> <dep> <title>
          p = vp_tok(b, p, e, fdep, 256)
          p = vp_tok(b, p, e, ftl, 256)
          if f1[0] == (0 as u8) { vp_p("VIZSLA-PLAN TASK missing plan -- fail loud\n" as *u8); return 1 }
          if f2[0] == (0 as u8) { vp_p("VIZSLA-PLAN TASK missing tid -- fail loud\n" as *u8); return 1 }
          if f3[0] == (0 as u8) { vp_p("VIZSLA-PLAN TASK missing owner -- fail loud\n" as *u8); return 1 }
          if vp_datedays(f4) < 0 { vp_p("VIZSLA-PLAN TASK bad due date -- fail loud\n" as *u8); return 1 }
          if vp_digits(f5) == 0 { vp_p("VIZSLA-PLAN TASK effort not digits -- fail loud\n" as *u8); return 1 }
          if vp_atoi(f5) < 1 { vp_p("VIZSLA-PLAN TASK effort < 1 -- fail loud\n" as *u8); return 1 }
          if vp_digits(fimp) == 0 { vp_p("VIZSLA-PLAN TASK imp not digits -- fail loud\n" as *u8); return 1 }
          let iv: i64 = vp_atoi(fimp)
          if iv < 1 { vp_p("VIZSLA-PLAN TASK imp out of 1..5 -- fail loud\n" as *u8); return 1 }
          if iv > 5 { vp_p("VIZSLA-PLAN TASK imp out of 1..5 -- fail loud\n" as *u8); return 1 }
          if fdep[0] == (0 as u8) { vp_p("VIZSLA-PLAN TASK missing dep -- fail loud\n" as *u8); return 1 }
          if ftl[0] == (0 as u8) { vp_p("VIZSLA-PLAN TASK missing title -- fail loud\n" as *u8); return 1 }
          tvals[1] = f1 as i64
          tvals[2] = f2 as i64
          tvals[3] = f3 as i64
          tvals[4] = f4 as i64
          tvals[5] = f5 as i64
          tvals[6] = fimp as i64
          tvals[7] = fdep as i64
          tvals[8] = ftl as i64
          if vp_put(tkeys, tvals, 9, "tsk:" as *u8, st) != 0 { vp_p("VIZSLA-PLAN writer full -- fail loud\n" as *u8); return 1 }
      }
      if vp_eq(t0, "MILE" as *u8) == 1 {
          scanned = scanned + 1
          p = vp_tok(b, p, e, f1, 128)
          p = vp_tok(b, p, e, f2, 128)
          p = vp_tok(b, p, e, f3, 128)
          p = vp_tok(b, p, e, f7, 256)
          if f1[0] == (0 as u8) { vp_p("VIZSLA-PLAN MILE missing plan -- fail loud\n" as *u8); return 1 }
          if f2[0] == (0 as u8) { vp_p("VIZSLA-PLAN MILE missing mid -- fail loud\n" as *u8); return 1 }
          if vp_datedays(f3) < 0 { vp_p("VIZSLA-PLAN MILE bad date -- fail loud\n" as *u8); return 1 }
          if f7[0] == (0 as u8) { vp_p("VIZSLA-PLAN MILE missing title -- fail loud\n" as *u8); return 1 }
          mvals[1] = f1 as i64
          mvals[2] = f2 as i64
          mvals[3] = f3 as i64
          mvals[4] = f7 as i64
          if vp_put(mkeys, mvals, 5, "mil:" as *u8, st) != 0 { vp_p("VIZSLA-PLAN writer full -- fail loud\n" as *u8); return 1 }
      }
      if vp_eq(t0, "DONE" as *u8) == 1 {
          scanned = scanned + 1
          p = vp_tok(b, p, e, f1, 128)
          p = vp_tok(b, p, e, f2, 128)
          p = vp_tok(b, p, e, f3, 128)
          if f1[0] == (0 as u8) { vp_p("VIZSLA-PLAN DONE missing plan -- fail loud\n" as *u8); return 1 }
          if f2[0] == (0 as u8) { vp_p("VIZSLA-PLAN DONE missing tid -- fail loud\n" as *u8); return 1 }
          if vp_datedays(f3) < 0 { vp_p("VIZSLA-PLAN DONE bad date -- fail loud\n" as *u8); return 1 }
          dvals[1] = f1 as i64
          dvals[2] = f2 as i64
          dvals[3] = f3 as i64
          if vp_put(dkeys, dvals, 4, "don:" as *u8, st) != 0 { vp_p("VIZSLA-PLAN writer full -- fail loud\n" as *u8); return 1 }
      }
      i = e + 1
  }
507
  var committed: i64 = 0
  if st[3] > 0 {
      if ss_commit(prefix, st[0] as *i64, segid) != 0 { vp_p("VIZSLA-PLAN commit FAILED -- fail loud\n" as *u8); return 1 }
      committed = 1
  }
513
  let rep: *u8 = sys_mmap(K_MAGIC_4096)
  var o: i64 = 0
  o = vp_cat(rep, o, "VIZSLA-PLAN-LOAD scanned=" as *u8)
  o = vp_catn(rep, o, scanned)
  o = vp_cat(rep, o, " new=" as *u8)
  o = vp_catn(rep, o, st[3])
  o = vp_cat(rep, o, " dup_infile=" as *u8)
  o = vp_catn(rep, o, st[4])
  o = vp_cat(rep, o, " dup_instore=" as *u8)
  o = vp_catn(rep, o, st[5])
  o = vp_cat(rep, o, " segment=" as *u8)
  if committed == 1 {
      o = vp_cat(rep, o, "seg-" as *u8)
      o = vp_catn(rep, o, segid)
  } else {
      o = vp_cat(rep, o, "none" as *u8)
  }
  o = vp_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
534}
535
536// gather plan state from the store. st slots:
537// 0=n 1=tid[] 2=owner[] 3=due[] 4=duedays[] 5=effort[] 6=imp[] 7=dep[] 8=title[] 9=doneflag[]
538// 10=nmile 11=mid[] 12=mdate[] 13=mdays[] 14=u4 15=u3 16=u2
539func vp_gather(prefix: *u8, plan: *u8, st: *i64) -> i64 {
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  let fp: *u8 = sys_mmap(128)
  let fa: *u8 = sys_mmap(256)
  let fb: *u8 = sys_mmap(256)
  let fc: *u8 = sys_mmap(256)
  let fd2: *u8 = sys_mmap(256)
  let fe: *u8 = sys_mmap(256)
  let ff: *u8 = sys_mmap(256)
  let dtids: *i64 = sys_mmap(8 * 256) as *i64
  var ndt: i64 = 0
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = vp_cat(path, po, prefix)
      po = vp_cat(path, po, segs[s] as *u8)
      po = vp_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
          let rec: *u8 = (b as i64 + voff) as *u8
          var istsk: i64 = 0
          var ismil: i64 = 0
          var isdon: i64 = 0
          var iscnf: i64 = 0
          if kind == 1 { istsk = vp_iskind(b, koff, kl, "tsk:" as *u8) }
          if kind == 1 { ismil = vp_iskind(b, koff, kl, "mil:" as *u8) }
          if kind == 1 { isdon = vp_iskind(b, koff, kl, "don:" as *u8) }
          if kind == 1 { iscnf = vp_iskind(b, koff, kl, "cnf:" as *u8) }
          if istsk == 1 {
              if vp_field(rec, vl, "plan" as *u8, fp, 128) == 1 { if vp_eq(fp, plan) == 1 {
                  let n: i64 = st[0]
                  if n < 128 {
                      vp_field(rec, vl, "tid" as *u8, fa, 256)
                      vp_field(rec, vl, "owner" as *u8, fb, 256)
                      vp_field(rec, vl, "due" as *u8, fc, 256)
                      vp_field(rec, vl, "effort" as *u8, fd2, 256)
                      vp_field(rec, vl, "imp" as *u8, fe, 256)
                      vp_field(rec, vl, "dep" as *u8, ff, 256)
                      let tids: *i64 = st[1] as *i64
                      let owners: *i64 = st[2] as *i64
                      let dues: *i64 = st[3] as *i64
                      let duedays: *i64 = st[4] as *i64
                      let efforts: *i64 = st[5] as *i64
                      let imps: *i64 = st[6] as *i64
                      let deps: *i64 = st[7] as *i64
                      let titles: *i64 = st[8] as *i64
                      // dedup by tid (CID makes exact dups impossible, but a re-defined task
                      // with different fields would double -- first wins, honest count)
                      if vp_find(tids, n, fa) < 0 {
                          let d1: *u8 = vp_dup(fa)
                          let d2: *u8 = vp_dup(fb)
                          let d3: *u8 = vp_dup(fc)
                          let d4: *u8 = vp_dup(ff)
                          tids[n] = d1 as i64
                          owners[n] = d2 as i64
                          dues[n] = d3 as i64
                          duedays[n] = vp_datedays(fc)
                          efforts[n] = vp_atoi(fd2)
                          imps[n] = vp_atoi(fe)
                          deps[n] = d4 as i64
                          vp_field(rec, vl, "title" as *u8, fe, 256)
                          let d5: *u8 = vp_dup(fe)
                          titles[n] = d5 as i64
                          st[0] = n + 1
                      }
                  }
              } }
          }
          if ismil == 1 {
              if vp_field(rec, vl, "plan" as *u8, fp, 128) == 1 { if vp_eq(fp, plan) == 1 {
                  let nm: i64 = st[10]
                  if nm < 32 {
                      vp_field(rec, vl, "mid" as *u8, fa, 256)
                      vp_field(rec, vl, "date" as *u8, fb, 256)
                      let mids: *i64 = st[11] as *i64
                      let mdates: *i64 = st[12] as *i64
                      let mdays: *i64 = st[13] as *i64
                      let d1: *u8 = vp_dup(fa)
                      let d2: *u8 = vp_dup(fb)
                      mids[nm] = d1 as i64
                      mdates[nm] = d2 as i64
                      mdays[nm] = vp_datedays(fb)
                      st[10] = nm + 1
                  }
              } }
          }
          if isdon == 1 {
              if vp_field(rec, vl, "plan" as *u8, fp, 128) == 1 { if vp_eq(fp, plan) == 1 {
                  if ndt < 256 {
                      vp_field(rec, vl, "tid" as *u8, fa, 256)
                      if vp_find(dtids, ndt, fa) < 0 {
                          let d1: *u8 = vp_dup(fa)
                          dtids[ndt] = d1 as i64
                          ndt = ndt + 1
                      }
                  }
              } }
          }
          if iscnf == 1 {
              if vp_field(rec, vl, "plan" as *u8, fp, 128) == 1 { if vp_eq(fp, plan) == 1 {
                  vp_field(rec, vl, "u4" as *u8, fa, 256)
                  vp_field(rec, vl, "u3" as *u8, fb, 256)
                  vp_field(rec, vl, "u2" as *u8, fc, 256)
                  st[14] = vp_atoi(fa)
                  st[15] = vp_atoi(fb)
                  st[16] = vp_atoi(fc)
              } }
          }
          j = voff + vl
      }
      s = s + 1
  }
  // apply done markers to flags
  let tids: *i64 = st[1] as *i64
  let flags: *i64 = st[9] as *i64
  var t: i64 = 0
  while t < st[0] {
      flags[t] = 0
      if vp_find(dtids, ndt, tids[t] as *u8) >= 0 { flags[t] = 1 }
      t = t + 1
  }
  return 0
672}
673
674func vp_urgency(duedays: i64, today: i64, u4: i64, u3: i64, u2: i64) -> i64 {
  if duedays < today { return 5 }
  let d: i64 = duedays - today
  if d <= u4 { return 4 }
  if d <= u3 { return 3 }
  if d <= u2 { return 2 }
  return 1
681}
682
683// parse comma-separated dep list of task ids into indices; -1 terminated; returns count or -1 on unknown
684func vp_depidx(depstr: *u8, tids: *i64, n: i64, out: *i64) -> i64 {
  if vp_eq(depstr, "-" as *u8) == 1 { out[0] = 0 - 1; return 0 }
  let tokb: *u8 = sys_mmap(256)
  var cnt: i64 = 0
  var i: i64 = 0
  var t: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let c: i64 = depstr[i] as i64
      var flush: i64 = 0
      if c == 44 { flush = 1 }
      if c == 0 { flush = 1 }
      if flush == 1 {
          tokb[t] = 0 as u8
          if t > 0 {
              let idx: i64 = vp_find(tids, n, tokb)
              if idx < 0 { return 0 - 1 }
              if cnt < 8 { out[cnt] = idx; cnt = cnt + 1 }
          }
          t = 0
      } else {
          if t < 255 { tokb[t] = c as u8; t = t + 1 }
      }
      if c == 0 { go = 0 }
      i = i + 1
  }
  out[cnt] = 0 - 1
  return cnt
712}
713
714func vp_alloc_state() -> *i64 {
  let st: *i64 = sys_mmap(8 * 24) as *i64
  st[0] = 0
  st[1] = sys_mmap(8 * 128)
  st[2] = sys_mmap(8 * 128)
  st[3] = sys_mmap(8 * 128)
  st[4] = sys_mmap(8 * 128)
  st[5] = sys_mmap(8 * 128)
  st[6] = sys_mmap(8 * 128)
  st[7] = sys_mmap(8 * 128)
  st[8] = sys_mmap(8 * 128)
  st[9] = sys_mmap(8 * 128)
  st[10] = 0
  st[11] = sys_mmap(8 * 32)
  st[12] = sys_mmap(8 * 32)
  st[13] = sys_mmap(8 * 32)
  st[14] = 2
  st[15] = 7
  st[16] = 30
  return st
734}
735
736// ---------------- BOARD ----------------
737func vp_cmd_board(argc: i64, argv: *i64) -> i64 {
  if argc < 5 { vp_p("VIZSLA-PLAN board needs <prefix> <plan> <today> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let plan: *u8 = argv[3] as *u8
  let today: i64 = vp_datedays(argv[4] as *u8)
  if today < 0 { vp_p("VIZSLA-PLAN board bad today date -- fail loud\n" as *u8); return 1 }
743
  let st: *i64 = vp_alloc_state()
  vp_gather(prefix, plan, st)
  let n: i64 = st[0]
  if n == 0 { vp_p("VIZSLA-PLAN board plan has NO tasks -- fail loud\n" as *u8); return 1 }
  let tids: *i64 = st[1] as *i64
  let owners: *i64 = st[2] as *i64
  let dues: *i64 = st[3] as *i64
  let duedays: *i64 = st[4] as *i64
  let efforts: *i64 = st[5] as *i64
  let imps: *i64 = st[6] as *i64
  let depstrs: *i64 = st[7] as *i64
  let titles: *i64 = st[8] as *i64
  let done: *i64 = st[9] as *i64
757
  // dep indices (flat n x 8) + unknown-dep loud-fail
  let dmat: *i64 = sys_mmap(8 * 128 * 9) as *i64
  let dcnt: *i64 = sys_mmap(8 * 128) as *i64
  var i: i64 = 0
  while i < n {
      let row: *i64 = (dmat as i64 + i * 9 * 8) as *i64
      let c: i64 = vp_depidx(depstrs[i] as *u8, tids, n, row)
      if c < 0 {
          vp_p("VIZSLA-PLAN-BAD-DEP task=" as *u8)
          vp_p(tids[i] as *u8)
          vp_p(" names an unknown dependency -- fail loud\n" as *u8)
          return 1
      }
      dcnt[i] = c
      i = i + 1
  }
774
  // Kahn topological order over ALL tasks (cycle = data error, loud)
  let processed: *i64 = sys_mmap(8 * 128) as *i64
  let order: *i64 = sys_mmap(8 * 128) as *i64
  var norder: i64 = 0
  i = 0
  while i < n { processed[i] = 0; i = i + 1 }
  var progress: i64 = 1
  while progress == 1 {
      progress = 0
      var t: i64 = 0
      while t < n {
          if processed[t] == 0 {
              var ok: i64 = 1
              let row: *i64 = (dmat as i64 + t * 9 * 8) as *i64
              var k: i64 = 0
              while k < dcnt[t] {
                  if processed[row[k]] == 0 { ok = 0 }
                  k = k + 1
              }
              if ok == 1 {
                  processed[t] = 1
                  order[norder] = t
                  norder = norder + 1
                  progress = 1
              }
          }
          t = t + 1
      }
  }
  if norder < n {
      vp_p("VIZSLA-PLAN-CYCLE plan=" as *u8)
      vp_p(plan)
      vp_p(" stuck=" as *u8)
      var t: i64 = 0
      var first: i64 = 1
      while t < n {
          if processed[t] == 0 {
              if first == 0 { vp_p("," as *u8) }
              vp_p(tids[t] as *u8)
              first = 0
          }
          t = t + 1
      }
      vp_p(" -- dependency cycle, fail loud\n" as *u8)
      return 1
  }
821
  // critical path: longest effort chain (DP in topo order)
  let longest: *i64 = sys_mmap(8 * 128) as *i64
  let from: *i64 = sys_mmap(8 * 128) as *i64
  var oi: i64 = 0
  while oi < n {
      let t: i64 = order[oi]
      var best: i64 = 0
      var bfrom: i64 = 0 - 1
      let row: *i64 = (dmat as i64 + t * 9 * 8) as *i64
      var k: i64 = 0
      while k < dcnt[t] {
          if longest[row[k]] > best { best = longest[row[k]]; bfrom = row[k] }
          k = k + 1
      }
      longest[t] = best + efforts[t]
      from[t] = bfrom
      oi = oi + 1
  }
  var cpend: i64 = 0
  i = 1
  while i < n {
      if longest[i] > longest[cpend] { cpend = i }
      i = i + 1
  }
  // reconstruct chain indices (reversed walk)
  let chain: *i64 = sys_mmap(8 * 128) as *i64
  var clen: i64 = 0
  var cur: i64 = cpend
  var go: i64 = 1
  while go == 1 {
      chain[clen] = cur
      clen = clen + 1
      if from[cur] < 0 { go = 0 } else { cur = from[cur] }
  }
856
  let rep: *u8 = sys_mmap(K_MAGIC_262144)
  var o: i64 = 0
859
  // task lines: not-done sorted by score desc / due asc / tid lex, then done by tid
  let idxs: *i64 = sys_mmap(8 * 128) as *i64
  var nn: i64 = 0
  i = 0
  while i < n { if done[i] == 0 { idxs[nn] = i; nn = nn + 1 } i = i + 1 }
  let scores: *i64 = sys_mmap(8 * 128) as *i64
  i = 0
  while i < n {
      let u: i64 = vp_urgency(duedays[i], today, st[14], st[15], st[16])
      scores[i] = u * 10 + imps[i] * 2
      i = i + 1
  }
  var a: i64 = 0
  while a < nn {
      var mn: i64 = a
      var c: i64 = a + 1
      while c < nn {
          var better: i64 = 0
          let ic: i64 = idxs[c]
          let im: i64 = idxs[mn]
          if scores[ic] > scores[im] { better = 1 }
          if scores[ic] == scores[im] {
              if duedays[ic] < duedays[im] { better = 1 }
              if duedays[ic] == duedays[im] {
                  if vp_cmp(tids[ic] as *u8, tids[im] as *u8) < 0 { better = 1 }
              }
          }
          if better == 1 { mn = c }
          c = c + 1
      }
      if mn != a { let t1: i64 = idxs[a]; idxs[a] = idxs[mn]; idxs[mn] = t1 }
      a = a + 1
  }
893
  var ready: i64 = 0
  var blocked: i64 = 0
  var late: i64 = 0
  var ndone: i64 = 0
  var ti: i64 = 0
  while ti < nn {
      let t: i64 = idxs[ti]
      var isready: i64 = 1
      let row: *i64 = (dmat as i64 + t * 9 * 8) as *i64
      var k: i64 = 0
      while k < dcnt[t] {
          if done[row[k]] == 0 { isready = 0 }
          k = k + 1
      }
      var islate: i64 = 0
      if duedays[t] < today { islate = 1; late = late + 1 }
      if isready == 1 { ready = ready + 1 } else { blocked = blocked + 1 }
      let u: i64 = vp_urgency(duedays[t], today, st[14], st[15], st[16])
      o = vp_cat(rep, o, "VIZSLA-PLAN-TASK plan=" as *u8)
      o = vp_cat(rep, o, plan)
      o = vp_cat(rep, o, " id=" as *u8)
      o = vp_cat(rep, o, tids[t] as *u8)
      o = vp_cat(rep, o, " owner=" as *u8)
      o = vp_cat(rep, o, owners[t] as *u8)
      o = vp_cat(rep, o, " due=" as *u8)
      o = vp_cat(rep, o, dues[t] as *u8)
      o = vp_cat(rep, o, " state=" as *u8)
      if isready == 1 { o = vp_cat(rep, o, "READY" as *u8) } else { o = vp_cat(rep, o, "BLOCKED" as *u8) }
      o = vp_cat(rep, o, " urg=" as *u8)
      o = vp_catn(rep, o, u)
      o = vp_cat(rep, o, " imp=" as *u8)
      o = vp_catn(rep, o, imps[t])
      o = vp_cat(rep, o, " score=" as *u8)
      o = vp_catn(rep, o, scores[t])
      o = vp_cat(rep, o, " late=" as *u8)
      o = vp_catn(rep, o, islate)
      o = vp_cat(rep, o, " title=" as *u8)
      o = vp_cat(rep, o, titles[t] as *u8)
      o = vp_cat(rep, o, "\n" as *u8)
      ti = ti + 1
  }
  i = 0
  while i < n {
      if done[i] == 1 {
          ndone = ndone + 1
          o = vp_cat(rep, o, "VIZSLA-PLAN-TASK plan=" as *u8)
          o = vp_cat(rep, o, plan)
          o = vp_cat(rep, o, " id=" as *u8)
          o = vp_cat(rep, o, tids[i] as *u8)
          o = vp_cat(rep, o, " owner=" as *u8)
          o = vp_cat(rep, o, owners[i] as *u8)
          o = vp_cat(rep, o, " due=" as *u8)
          o = vp_cat(rep, o, dues[i] as *u8)
          o = vp_cat(rep, o, " state=DONE title=" as *u8)
          o = vp_cat(rep, o, titles[i] as *u8)
          o = vp_cat(rep, o, "\n" as *u8)
      }
      i = i + 1
  }
953
  // milestones
  var mi: i64 = 0
  let mids: *i64 = st[11] as *i64
  let mdates: *i64 = st[12] as *i64
  let mdays: *i64 = st[13] as *i64
  while mi < st[10] {
      var duet: i64 = 0
      var dunet: i64 = 0
      i = 0
      while i < n {
          if duedays[i] <= mdays[mi] {
              duet = duet + 1
              if done[i] == 1 { dunet = dunet + 1 }
          }
          i = i + 1
      }
      var mpct: i64 = 0
      if duet > 0 { mpct = (dunet * 100) / duet }
      o = vp_cat(rep, o, "VIZSLA-PLAN-MILE plan=" as *u8)
      o = vp_cat(rep, o, plan)
      o = vp_cat(rep, o, " id=" as *u8)
      o = vp_cat(rep, o, mids[mi] as *u8)
      o = vp_cat(rep, o, " date=" as *u8)
      o = vp_cat(rep, o, mdates[mi] as *u8)
      o = vp_cat(rep, o, " due_tasks=" as *u8)
      o = vp_catn(rep, o, duet)
      o = vp_cat(rep, o, " done=" as *u8)
      o = vp_catn(rep, o, dunet)
      o = vp_cat(rep, o, " pct=" as *u8)
      o = vp_catn(rep, o, mpct)
      o = vp_cat(rep, o, "\n" as *u8)
      mi = mi + 1
  }
987
  // critical path line (chain reversed: chain[clen-1] is the head)
  o = vp_cat(rep, o, "VIZSLA-PLAN-CRITICAL plan=" as *u8)
  o = vp_cat(rep, o, plan)
  o = vp_cat(rep, o, " effort_min=" as *u8)
  o = vp_catn(rep, o, longest[cpend])
  o = vp_cat(rep, o, " path=" as *u8)
  var ci: i64 = clen - 1
  var firstc: i64 = 1
  while ci >= 0 {
      if firstc == 0 { o = vp_cat(rep, o, ">" as *u8) }
      o = vp_cat(rep, o, tids[chain[ci]] as *u8)
      firstc = 0
      ci = ci - 1
  }
  o = vp_cat(rep, o, "\n" as *u8)
1003
  let pct: i64 = (ndone * 100) / n
  o = vp_cat(rep, o, "VIZSLA-PLAN-VERDICT plan=" as *u8)
  o = vp_cat(rep, o, plan)
  o = vp_cat(rep, o, " tasks=" as *u8)
  o = vp_catn(rep, o, n)
  o = vp_cat(rep, o, " done=" as *u8)
  o = vp_catn(rep, o, ndone)
  o = vp_cat(rep, o, " ready=" as *u8)
  o = vp_catn(rep, o, ready)
  o = vp_cat(rep, o, " blocked=" as *u8)
  o = vp_catn(rep, o, blocked)
  o = vp_cat(rep, o, " late=" as *u8)
  o = vp_catn(rep, o, late)
  o = vp_cat(rep, o, " pct=" as *u8)
  o = vp_catn(rep, o, pct)
  o = vp_cat(rep, o, " critical_min=" as *u8)
  o = vp_catn(rep, o, longest[cpend])
  o = vp_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
1024}
1025
1026// collect busy intervals for calprefix on day qd (cal: + rec:)
1027func vp_busy_day(calpfx: *u8, qd: i64, bs: *i64, be: *i64, np: *i64) -> i64 {
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(calpfx, segs)
  let fdt: *u8 = sys_mmap(128)
  let fst: *u8 = sys_mmap(128)
  let fdu: *u8 = sys_mmap(128)
  let ffr: *u8 = sys_mmap(64)
  let fiv: *u8 = sys_mmap(64)
  let fct: *u8 = sys_mmap(64)
  let ymd: *i64 = sys_mmap(8 * 4) as *i64
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = vp_cat(path, po, calpfx)
      po = vp_cat(path, po, segs[s] as *u8)
      po = vp_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
          let rec: *u8 = (b as i64 + voff) as *u8
          var iscal: i64 = 0
          var isrec: i64 = 0
          if kind == 1 { iscal = vp_iskind(b, koff, kl, "cal:" as *u8) }
          if kind == 1 { isrec = vp_iskind(b, koff, kl, "rec:" as *u8) }
          if iscal == 1 {
              var dd: i64 = 0 - 1
              if vp_field(rec, vl, "date" as *u8, fdt, 128) == 1 { dd = vp_datedays(fdt) }
              if dd == qd {
                  vp_field(rec, vl, "start" as *u8, fst, 128)
                  vp_field(rec, vl, "dur" as *u8, fdu, 128)
                  if np[0] < 512 {
                      let sv: i64 = vp_atoi(fst)
                      let ev: i64 = sv + vp_atoi(fdu)
                      bs[np[0]] = sv
                      be[np[0]] = ev
                      np[0] = np[0] + 1
                  }
              }
          }
          if isrec == 1 {
              vp_field(rec, vl, "sdate" as *u8, fdt, 128)
              vp_field(rec, vl, "start" as *u8, fst, 128)
              vp_field(rec, vl, "dur" as *u8, fdu, 128)
              vp_field(rec, vl, "freq" as *u8, ffr, 64)
              vp_field(rec, vl, "interval" as *u8, fiv, 64)
              vp_field(rec, vl, "count" as *u8, fct, 64)
              let sd0: i64 = vp_datedays(fdt)
              vp_civil(sd0, ymd)
              let iv: i64 = vp_atoi(fiv)
              let ct: i64 = vp_atoi(fct)
              var k: i64 = 0
              while k < ct {
                  let occ: i64 = vp_occ(ffr, sd0, ymd[0], ymd[1], ymd[2], iv, k)
                  if occ == qd { if np[0] < 512 {
                      let sv: i64 = vp_atoi(fst)
                      let ev: i64 = sv + vp_atoi(fdu)
                      bs[np[0]] = sv
                      be[np[0]] = ev
                      np[0] = np[0] + 1
                  } }
                  if occ > qd { k = ct }
                  k = k + 1
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
  return 0
1105}
1106
1107// ---------------- TIMEBLOCK ----------------
1108func vp_cmd_timeblock(argc: i64, argv: *i64) -> i64 {
  if argc < 6 { vp_p("VIZSLA-PLAN timeblock needs <prefix> <plan> <calprefix> <date> [earliest latest] -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let plan: *u8 = argv[3] as *u8
  let calpfx: *u8 = argv[4] as *u8
  let qd: i64 = vp_datedays(argv[5] as *u8)
  if qd < 0 { vp_p("VIZSLA-PLAN timeblock bad date -- fail loud\n" as *u8); return 1 }
  var emin: i64 = 0
  var emax: i64 = K_MAGIC_1440
  if argc > 7 {
      if vp_digits(argv[6] as *u8) == 0 { vp_p("VIZSLA-PLAN timeblock earliest not digits -- fail loud\n" as *u8); return 1 }
      if vp_digits(argv[7] as *u8) == 0 { vp_p("VIZSLA-PLAN timeblock latest not digits -- fail loud\n" as *u8); return 1 }
      emin = vp_atoi(argv[6] as *u8)
      emax = vp_atoi(argv[7] as *u8)
  }
  if emin >= emax { vp_p("VIZSLA-PLAN timeblock earliest >= latest -- fail loud\n" as *u8); return 1 }
  if emax > K_MAGIC_1440 { vp_p("VIZSLA-PLAN timeblock latest > 1440 -- fail loud\n" as *u8); return 1 }
1125
  let st: *i64 = vp_alloc_state()
  vp_gather(prefix, plan, st)
  let n: i64 = st[0]
  if n == 0 { vp_p("VIZSLA-PLAN timeblock plan has NO tasks -- fail loud\n" as *u8); return 1 }
  let tids: *i64 = st[1] as *i64
  let duedays: *i64 = st[4] as *i64
  let efforts: *i64 = st[5] as *i64
  let imps: *i64 = st[6] as *i64
  let depstrs: *i64 = st[7] as *i64
  let done: *i64 = st[9] as *i64
1136
  // READY not-done tasks (all deps done); unknown dep -> loud
  let dmat: *i64 = sys_mmap(8 * 128 * 9) as *i64
  let dcnt: *i64 = sys_mmap(8 * 128) as *i64
  var i: i64 = 0
  while i < n {
      let row: *i64 = (dmat as i64 + i * 9 * 8) as *i64
      let c: i64 = vp_depidx(depstrs[i] as *u8, tids, n, row)
      if c < 0 { vp_p("VIZSLA-PLAN-BAD-DEP -- fail loud\n" as *u8); return 1 }
      dcnt[i] = c
      i = i + 1
  }
  let cand: *i64 = sys_mmap(8 * 128) as *i64
  var nc: i64 = 0
  i = 0
  while i < n {
      if done[i] == 0 {
          var isready: i64 = 1
          let row: *i64 = (dmat as i64 + i * 9 * 8) as *i64
          var k: i64 = 0
          while k < dcnt[i] {
              if done[row[k]] == 0 { isready = 0 }
              k = k + 1
          }
          if isready == 1 { cand[nc] = i; nc = nc + 1 }
      }
      i = i + 1
  }
  // priority order (score desc / due asc / tid lex), today := the block date
  let scores: *i64 = sys_mmap(8 * 128) as *i64
  i = 0
  while i < n {
      let u: i64 = vp_urgency(duedays[i], qd, st[14], st[15], st[16])
      scores[i] = u * 10 + imps[i] * 2
      i = i + 1
  }
  var a: i64 = 0
  while a < nc {
      var mn: i64 = a
      var c: i64 = a + 1
      while c < nc {
          var better: i64 = 0
          let ic: i64 = cand[c]
          let im: i64 = cand[mn]
          if scores[ic] > scores[im] { better = 1 }
          if scores[ic] == scores[im] {
              if duedays[ic] < duedays[im] { better = 1 }
              if duedays[ic] == duedays[im] {
                  if vp_cmp(tids[ic] as *u8, tids[im] as *u8) < 0 { better = 1 }
              }
          }
          if better == 1 { mn = c }
          c = c + 1
      }
      if mn != a { let t1: i64 = cand[a]; cand[a] = cand[mn]; cand[mn] = t1 }
      a = a + 1
  }
1193
  // free windows of the calendar day within [emin,emax)
  let bs: *i64 = sys_mmap(8 * 512) as *i64
  let be: *i64 = sys_mmap(8 * 512) as *i64
  let np: *i64 = sys_mmap(16) as *i64
  np[0] = 0
  vp_busy_day(calpfx, qd, bs, be, np)
  let nb: i64 = np[0]
  a = 0
  while a < nb {
      var mn: i64 = a
      var c: i64 = a + 1
      while c < nb {
          if bs[c] < bs[mn] { mn = c }
          c = c + 1
      }
      if mn != a {
          let t1: i64 = bs[a]; bs[a] = bs[mn]; bs[mn] = t1
          let t2: i64 = be[a]; be[a] = be[mn]; be[mn] = t2
      }
      a = a + 1
  }
  let ws: *i64 = sys_mmap(8 * 64) as *i64
  let we: *i64 = sys_mmap(8 * 64) as *i64
  var nw: i64 = 0
  var prev: i64 = emin
  var bi: i64 = 0
  while bi < nb {
      var s0: i64 = prev
      var e0: i64 = bs[bi]
      if e0 > emax { e0 = emax }
      if e0 > s0 { if nw < 64 { ws[nw] = s0; we[nw] = e0; nw = nw + 1 } }
      if be[bi] > prev { prev = be[bi] }
      if prev >= emax { bi = nb }
      bi = bi + 1
  }
  if prev < emax { if nw < 64 { ws[nw] = prev; we[nw] = emax; nw = nw + 1 } }
  var free_min: i64 = 0
  i = 0
  while i < nw { free_min = free_min + (we[i] - ws[i]); i = i + 1 }
1233
  // first-fit placement in priority order
  let cursor: *i64 = sys_mmap(8 * 64) as *i64
  i = 0
  while i < nw { cursor[i] = ws[i]; i = i + 1 }
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  var placed: i64 = 0
  var unplaced: i64 = 0
  var used: i64 = 0
  var ci: i64 = 0
  while ci < nc {
      let t: i64 = cand[ci]
      var put: i64 = 0
      var wi: i64 = 0
      while wi < nw {
          if put == 0 {
              let rem: i64 = we[wi] - cursor[wi]
              if efforts[t] <= rem {
                  o = vp_cat(rep, o, "VIZSLA-PLAN-BLOCK plan=" as *u8)
                  o = vp_cat(rep, o, plan)
                  o = vp_cat(rep, o, " date=" as *u8)
                  o = vp_cat(rep, o, argv[5] as *u8)
                  o = vp_cat(rep, o, " start=" as *u8)
                  o = vp_hhmm(rep, o, cursor[wi])
                  o = vp_cat(rep, o, " end=" as *u8)
                  o = vp_hhmm(rep, o, cursor[wi] + efforts[t])
                  o = vp_cat(rep, o, " task=" as *u8)
                  o = vp_cat(rep, o, tids[t] as *u8)
                  o = vp_cat(rep, o, "\n" as *u8)
                  cursor[wi] = cursor[wi] + efforts[t]
                  used = used + efforts[t]
                  placed = placed + 1
                  put = 1
              }
          }
          wi = wi + 1
      }
      if put == 0 {
          o = vp_cat(rep, o, "VIZSLA-PLAN-UNPLACED plan=" as *u8)
          o = vp_cat(rep, o, plan)
          o = vp_cat(rep, o, " task=" as *u8)
          o = vp_cat(rep, o, tids[t] as *u8)
          o = vp_cat(rep, o, " effort_min=" as *u8)
          o = vp_catn(rep, o, efforts[t])
          o = vp_cat(rep, o, " reason=no-free-window-fits\n" as *u8)
          unplaced = unplaced + 1
      }
      ci = ci + 1
  }
1283
  o = vp_cat(rep, o, "VIZSLA-PLAN-TIMEBLOCK plan=" as *u8)
  o = vp_cat(rep, o, plan)
  o = vp_cat(rep, o, " date=" as *u8)
  o = vp_cat(rep, o, argv[5] as *u8)
  o = vp_cat(rep, o, " placed=" as *u8)
  o = vp_catn(rep, o, placed)
  o = vp_cat(rep, o, " unplaced=" as *u8)
  o = vp_catn(rep, o, unplaced)
  o = vp_cat(rep, o, " used_min=" as *u8)
  o = vp_catn(rep, o, used)
  o = vp_cat(rep, o, " free_min=" as *u8)
  o = vp_catn(rep, o, free_min)
  o = vp_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
1299}
1300
1301func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { vp_p("VIZSLA-PLAN usage: load|board|timeblock -- fail loud\n" as *u8); return 1 }
  let cmd: *u8 = argv[1] as *u8
  if vp_eq(cmd, "load" as *u8) == 1 { return vp_cmd_load(argc, argv) }
  if vp_eq(cmd, "board" as *u8) == 1 { return vp_cmd_board(argc, argv) }
  if vp_eq(cmd, "timeblock" as *u8) == 1 { return vp_cmd_timeblock(argc, argv) }
  vp_p("VIZSLA-PLAN unknown command (load|board|timeblock) -- fail loud\n" as *u8)
  return 1
1309}
nx_vizsla_plan.nx source

`nx_vizsla_plan.nx` source
