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

↩ module page · 262 lines · 11236 B
1// nx_ws_active_board.nx -- the HONEST live workstream board, re-derived from the WORKLOG.
2//
3// WHY: nx_ws_board renders the WMS-R1 registry SSOT, whose per-stream `state` was frozen at
4// populate-time and was never wired to live work -- so it reports active=3 while the real work
5// touched ~70 workstreams in the last days. The registry is also a DIFFERENT id-space (queue ids)
6// than the live project-*.md workstreams, so it cannot see them at all. The LIVE source of truth
7// for "what are we actually working on" is the worklog: every tool action appends one line
8//   <epoch>\t<event>\t<tool>\t<target>
9// where <target> for a workstream edit is .../project-<NAME>.md. This organ derives the active set
10// straight from that log: distinct workstreams, last-touch epoch, edit count, ALIVE within a window.
11//
12// ADDITIVE + SAFE: it READS the worklog and the registry SSOT is NEVER touched (no ws_put, no
13// rewrite) -- this is a new truthful VIEW beside the registry board, not a mutation of it.
14// NEGATIVE CONTROL: a built-in self-test runs the same parser over a synthetic fixture (2 real
15// project lines + a duplicate + 2 non-project lines) and asserts distinct=2 / dedup / non-project
16// ignored -- so GREEN means the parser discriminates, never a rubber stamp.
17// Sovereign: imports only nx_syscalls. license_tier: ORIGINAL
18import "nx_syscalls.nx"
19const WL_MAGIC_4096: i64 = 4096
20
21const WL_PATH:   *u8 = "/mnt/c/Users/elder/.claude/projects/C--Users-elder/memory/worklog/worklog.tsv"
22const WL_FBUF:   i64 = 8388608      // 8MB: read the whole append-only worklog (~1MB today; headroom)
23const AB_MAXW:   i64 = 4096         // max distinct workstreams
24const AB_SLOT:   i64 = 256          // per-name byte slot
25const AB_WINDOW: i64 = 172800       // 2 days: "ALIVE" if touched within this of the latest log epoch
26const AB_TOPN:   i64 = 50           // how many rows to list
27
28func ab_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
29func ab_p(s: *u8) -> i64 { let n: i64 = ab_len(s); sys_write(1, s, n); return 0 }
30func ab_pn(v: i64) -> i64 {
  let bb: *u8 = sys_mmap(28); var m: i64 = v
  if m < 0 { sys_write(1, "-" as *u8, 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 { bb[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(1, bb, k); return 0
38}
39
40// NUL-terminated byte equality.
41func ab_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
  if b[i] != (0 as u8) { return 0 }
  return 1
46}
47
48// append NUL-term s into buf at off; return new off.
49func ab_cat(buf: *u8, off: i64, s: *u8) -> i64 {
  var o: i64 = off; var i: i64 = 0
  while s[i] != (0 as u8) { buf[o] = s[i]; o = o + 1; i = i + 1 }
  return o
53}
54
55// bounded whole-file read into buf -> length (0 if empty, -1 if open fails).
56func ab_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var total: i64 = 0
  var nrd: i64 = sys_read(fd, buf, cap)
  while nrd > 0 {
      total = total + nrd
      if total >= cap { nrd = 0 } else { nrd = sys_read(fd, ((buf as i64) + total) as *u8, cap - total) }
  }
  sys_close(fd)
  return total
67}
68
69// first index of NUL-term pat in buf[from..to), or -1.
70func ab_find(buf: *u8, from: i64, to: i64, pat: *u8) -> i64 {
  let pl: i64 = ab_len(pat)
  if pl == 0 { return 0 - 1 }
  var i: i64 = from
  while i + pl <= to {
      var j: i64 = 0; var ok: i64 = 1
      while j < pl { if buf[i + j] != pat[j] { ok = 0; j = pl } else { j = j + 1 } }
      if ok == 1 { return i }
      i = i + 1
  }
  return 0 - 1
81}
82
83// buf[s..e) == NUL-term str (full equality)?
84func ab_eqrange(buf: *u8, s: i64, e: i64, str: *u8) -> i64 {
  var i: i64 = s; var j: i64 = 0
  while i < e { if str[j] == (0 as u8) { return 0 } if buf[i] != str[j] { return 0 } i = i + 1; j = j + 1 }
  if str[j] != (0 as u8) { return 0 }
  return 1
89}
90
91// SCAN the worklog buffer: for each line, parse epoch (field 0) + target (after the 3rd tab); if the
92// target carries project-<NAME>.md, dedup <NAME> into names[]/epochs[](max)/counts[](++). Tracks the
93// latest epoch into nowp[0]. Returns distinct workstream count.
94func ab_scan(buf: *u8, n: i64, names: *i64, epochs: *i64, counts: *i64, cap: i64, nowp: *i64) -> i64 {
  var cnt: i64 = 0
  var now: i64 = 0
  var i: i64 = 0
  while i < n {
      let ls: i64 = i
      var le: i64 = ls
      var g: i64 = 1
      while g == 1 { if le >= n { g = 0 } else { if buf[le] == (10 as u8) { g = 0 } else { le = le + 1 } } }
      // epoch = leading digits
      var ep: i64 = 0
      var p: i64 = ls
      var g2: i64 = 1
      while g2 == 1 {
          if p >= le { g2 = 0 } else {
              let c: i64 = buf[p] as i64
              if c >= 48 { if c <= 57 { ep = ep * 10 + (c - 48); p = p + 1 } else { g2 = 0 } } else { g2 = 0 }
          }
      }
      // target start = after the 3rd tab
      var tabs: i64 = 0
      var ts: i64 = le
      var q: i64 = ls
      var g3: i64 = 1
      while g3 == 1 {
          if q >= le { g3 = 0 } else {
              if buf[q] == (9 as u8) { tabs = tabs + 1; if tabs == 3 { ts = q + 1; g3 = 0 } else { q = q + 1 } } else { q = q + 1 }
          }
      }
      if ts < le {
          let pf: i64 = ab_find(buf, ts, le, "project-" as *u8)
          if pf >= 0 {
              let ns: i64 = pf + 8
              let mf: i64 = ab_find(buf, ns, le, ".md" as *u8)
              if mf >= ns {
                  var found: i64 = 0 - 1
                  var k: i64 = 0
                  while k < cnt {
                      if ab_eqrange(buf, ns, mf, names[k] as *u8) == 1 { found = k; k = cnt } else { k = k + 1 }
                  }
                  if found >= 0 {
                      counts[found] = counts[found] + 1
                      if ep > epochs[found] { epochs[found] = ep }
                  } else {
                      if cnt < cap {
                          let nb: *u8 = sys_mmap(AB_SLOT)
                          var w: i64 = 0
                          var x: i64 = ns
                          while x < mf { if w < AB_SLOT - 1 { nb[w] = buf[x]; w = w + 1 } x = x + 1 }
                          nb[w] = 0 as u8
                          names[cnt] = nb as i64
                          epochs[cnt] = ep
                          counts[cnt] = 1
                          cnt = cnt + 1
                      }
                  }
              }
          }
      }
      if ep > now { now = ep }
      i = le + 1
  }
  nowp[0] = now
  return cnt
158}
159
160// insertion sort the 3 parallel arrays by epoch DESC (newest workstream first). ~70 items -> trivial.
161func ab_sort(names: *i64, epochs: *i64, counts: *i64, cnt: i64) -> i64 {
  var a: i64 = 1
  while a < cnt {
      let ev: i64 = epochs[a]
      let nv: i64 = names[a]
      let cv: i64 = counts[a]
      var b: i64 = a - 1
      var go: i64 = 1
      while go == 1 {
          if b < 0 { go = 0 } else {
              if epochs[b] < ev { epochs[b + 1] = epochs[b]; names[b + 1] = names[b]; counts[b + 1] = counts[b]; b = b - 1 } else { go = 0 }
          }
      }
      epochs[b + 1] = ev; names[b + 1] = nv; counts[b + 1] = cv
      a = a + 1
  }
  return 0
178}
179
180// NEGATIVE CONTROL: run the real parser over a synthetic fixture with a KNOWN answer.
181// 2 distinct project lines (aaa twice = dedup) + 2 non-project lines (MEMORY.md, an .nx) that MUST
182// be ignored. GREEN iff distinct=2, aaa.count=2, bbb.count=1, latest epoch=500. Returns 1/0.
183func ab_selftest() -> i64 {
  let t: *u8 = sys_mmap(WL_MAGIC_4096)
  var o: i64 = 0
  o = ab_cat(t, o, "100\x09ingest\x09Edit\x09/m/project-aaa-2026.md\n" as *u8)
  o = ab_cat(t, o, "200\x09ingest\x09Read\x09/m/project-bbb-2026.md\n" as *u8)
  o = ab_cat(t, o, "300\x09ingest\x09Edit\x09/m/project-aaa-2026.md\n" as *u8)
  o = ab_cat(t, o, "400\x09ingest\x09Read\x09/m/MEMORY.md\n" as *u8)
  o = ab_cat(t, o, "500\x09ingest\x09Write\x09/m/runtime/nx_foo.nx\n" as *u8)
  t[o] = 0 as u8
  let names: *i64 = sys_mmap(8 * 64) as *i64
  let epochs: *i64 = sys_mmap(8 * 64) as *i64
  let counts: *i64 = sys_mmap(8 * 64) as *i64
  let nowp: *i64 = sys_mmap(16) as *i64
  let cnt: i64 = ab_scan(t, o, names, epochs, counts, 64, nowp)
  var ok: i64 = 1
  if cnt != 2 { ok = 0 }
  if nowp[0] != 500 { ok = 0 }
  var ac: i64 = 0 - 1
  var bc: i64 = 0 - 1
  var k: i64 = 0
  while k < cnt {
      if ab_streq(names[k] as *u8, "aaa-2026" as *u8) == 1 { ac = counts[k] }
      if ab_streq(names[k] as *u8, "bbb-2026" as *u8) == 1 { bc = counts[k] }
      k = k + 1
  }
  if ac != 2 { ok = 0 }
  if bc != 1 { ok = 0 }
  return ok
211}
212
213func main() -> i64 {
  ab_p("=== nx_ws_active_board: HONEST live board, re-derived from the worklog ===\n" as *u8)
  ab_p("  source = worklog.tsv (every tool action appends a line); registry SSOT untouched (additive view)\n" as *u8)
  let st: i64 = ab_selftest()
  if st == 1 {
      ab_p("  SELFTEST(neg-control): GREEN -- parser counts distinct project-*.md, dedups, ignores non-project\n" as *u8)
  } else {
      ab_p("  SELFTEST(neg-control): RED -- parser broken, board NOT trustworthy\n" as *u8)
      sys_exit(1); return 1
  }
223
  let buf: *u8 = sys_mmap(WL_FBUF)
  let n: i64 = ab_read(WL_PATH, buf, WL_FBUF)
  if n <= 0 { ab_p("  ERROR: cannot read worklog at WL_PATH\n" as *u8); sys_exit(2); return 2 }
  if n >= WL_FBUF { ab_p("  WARN: worklog exceeds buffer; recent tail not read (raise WL_FBUF)\n" as *u8) }
228
  let names: *i64 = sys_mmap(8 * AB_MAXW) as *i64
  let epochs: *i64 = sys_mmap(8 * AB_MAXW) as *i64
  let counts: *i64 = sys_mmap(8 * AB_MAXW) as *i64
  let nowp: *i64 = sys_mmap(16) as *i64
  let cnt: i64 = ab_scan(buf, n, names, epochs, counts, AB_MAXW, nowp)
  let now: i64 = nowp[0]
  ab_sort(names, epochs, counts, cnt)
236
  var alive: i64 = 0
  var k: i64 = 0
  while k < cnt { if now - epochs[k] <= AB_WINDOW { alive = alive + 1 } k = k + 1 }
240
  ab_p("  now(latest log epoch)=" as *u8); ab_pn(now)
  ab_p("  window=" as *u8); ab_pn(AB_WINDOW); ab_p("s\n" as *u8)
  ab_p("  DISTINCT workstreams in log=" as *u8); ab_pn(cnt)
  ab_p("   ALIVE(touched within window)=" as *u8); ab_pn(alive)
  ab_p("\n" as *u8)
  ab_p("=== TOP (newest-first; edits = log actions; age in seconds) ===\n" as *u8)
  var i: i64 = 0
  while i < cnt {
      if i < AB_TOPN {
          let age: i64 = now - epochs[i]
          ab_p("  " as *u8)
          if age <= AB_WINDOW { ab_p("[ALIVE] " as *u8) } else { ab_p("[older] " as *u8) }
          ab_p(names[i] as *u8)
          ab_p("  edits=" as *u8); ab_pn(counts[i])
          ab_p(" age=" as *u8); ab_pn(age); ab_p("s\n" as *u8)
      }
      i = i + 1
  }
  ab_p("=== nx_ws_board (registry) reports active=3 = STALE (state frozen at populate-time). TRUTH above. ===\n" as *u8)
  sys_exit(0)
  return 0
262}
nx_ws_active_board.nx source

`nx_ws_active_board.nx` source
