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

↩ module page · 1237 lines · 62910 B
1// nx_wfcost.nx -- WORKFLOW-EPISODE TOKEN COST (Lane I, common-task hardening loop, 2026-08-20).
2// Operator: "grow our capabilities into repeatable high value little to no token capabilities".
3// Ranking hardening candidates needs the REAL cost of what we already do repeatedly. The estate had
4// the three halves and never joined them: nx_actlog mines recurring tool:verb support, nx_eff_lib
5// measures transcript tokens PER DAY, and nx_tokroi's uses_per_day is a DECLARED assumption. This
6// organ joins them: per-INVOCATION-PAIR measured token cost over the FULL transcript population.
7//
8// THE CORRECTION THIS ORGAN CARRIES (measured 2026-08-20, and it is why the join could not be trusted
9// before): one assistant MESSAGE is written to the transcript as SEVERAL JSONL LINES -- one per content
10// block (thinking, tool_use, text) -- and EVERY one of those lines repeats the SAME usage object
11// verbatim. nx_eff_lib::es_tr_tokens dedups the two usage copies WITHIN a line (message.usage and the
12// iterations[] echo -- that half is correct and gated by its T20) but counts once PER LINE, so a
13// message with N content blocks is counted N times. Measured over the 12 largest transcripts:
14// 43,372 assistant lines carry only 22,234 distinct message ids => the per-line method overstates by
15// ~1.95x. This organ dedups by message.id through a real hash set and PRINTS BOTH TOTALS side by side
16// so the correction is proven by the run, never asserted (two counters of one population = free audit).
17// Dedup is a SET, not a previous-id compare: 12 of 22,234 ids reappear NON-consecutively, so the cheap
18// compare would silently overcount those.
19//
20//   gauge [trdir]            -> corrected(msgid-deduped) vs perline totals + overcount permil + envelope
21//   mine  [trdir] [minsup]   -> recurring invocation PAIRS >= minsup with exact total measured tokens
22//   selftest                 -> gv_verdict gate, named neg-controls, runtime fixtures
23//
24// RANKING QUANTITY IS THE EXACT TOTAL, NOT A MEDIAN: total = the sum of every episode's measured cost,
25// carried exactly. A median would need a second pass plus per-episode retention; mean and max are
26// printed and LABELLED as such, and no median is claimed. license_tier: ORIGINAL  No hw writes (Rule 26).
27import "nx_syscalls.nx"
28import "nx_gate_verdict.nx"
29
30const WF_TR_DEF: *u8 = "/mnt/c/Users/elder/.claude/projects/C--Users-elder"
31// ---- byte constants (named; a raw literal byte is a magic number) ----
32const WF_NL: i64 = 10
33const WF_QUOTE: i64 = 34
34const WF_SLASH: i64 = 47
35const WF_ZERO: i64 = 48
36const WF_NINE: i64 = 57
37// ---- token weights: the published Anthropic pricing SHAPE at x10 integer scale, the SAME declared
38// multipliers nx_eff_lib converts with (uncached in 1x, out 5x, cache-read 0.1x, cache-write 1.25x).
39// Weighted units are printed with their divisor so the reader can recover raw token counts.
40const WF_W_IN: i64 = 10
41const WF_W_OUT: i64 = 50
42const WF_W_CR: i64 = 1
43const WF_W_CW: i64 = 12
44const WF_W_DIV: i64 = 10
45// ---- message-id hash set ----
46const WF_MID_SLOTS: i64 = 4194304
47const WF_MID_MASK: i64 = 4194303
48// ---- tool:verb interning ----
49const WF_ID_SLOTS: i64 = 262144
50const WF_ID_MASK: i64 = 262143
51const WF_IDS_MAX: i64 = 32768
52const WF_ARENA: i64 = 8388608
53const WF_LABEL_MAX: i64 = 96
54// ---- pair table ----
55const WF_BG_SLOTS: i64 = 1048576
56const WF_BG_MASK: i64 = 1048575
57// ---- per-file arrays ----
58const WF_MSG_MAX: i64 = 262144
59const WF_INV_MAX: i64 = 262144
60// ---- envelope slots ----
61const WF_E_FILES: i64 = 0
62const WF_E_BYTES: i64 = 1
63const WF_E_LINES: i64 = 2
64const WF_E_MSGS: i64 = 3
65const WF_E_DUPLINES: i64 = 4
66const WF_E_INVS: i64 = 5
67const WF_E_UNREAD: i64 = 6
68const WF_E_MSGCAP: i64 = 7
69const WF_E_INVCAP: i64 = 8
70const WF_E_IDCAP: i64 = 9
71const WF_E_BGCAP: i64 = 10
72const WF_E_PAIRS: i64 = 11
73const WF_E_SLOTS: i64 = 16
74// ---- corrected token accumulators ----
75const WF_T_IN: i64 = 0
76const WF_T_OUT: i64 = 1
77const WF_T_CR: i64 = 2
78const WF_T_CW: i64 = 3
79const WF_T_PIN: i64 = 4
80const WF_T_POUT: i64 = 5
81const WF_T_PCR: i64 = 6
82const WF_T_PCW: i64 = 7
83const WF_T_SLOTS: i64 = 8
84const WF_STAT_BUF: i64 = 256
85const WF_DIRENT_BUF: i64 = 65536
86const WF_PATH_BUF: i64 = 4096
87const WF_GETDENTS: i64 = 217
88const WF_RECLEN_OFF: i64 = 16
89const WF_NAME_OFF: i64 = 19
90const WF_TOP_DEF: i64 = 40
91const WF_PERMIL: i64 = 1000
92const WF_MODE_755: i64 = 493
93const WF_MODE_644: i64 = 420
94const WF_TSV_TAB: i64 = 9
95const WF_DAYSEC: i64 = 86400
96const WF_E_MINTS: i64 = 12
97const WF_E_MAXTS: i64 = 13
98const WF_E_FRAMES: i64 = 14
99const WF_CHBEAT_DEF: *u8 = "knowledge/status/chbeat"
100
101func wf_len(s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { i = i + 1 }
  return i
105}
106func wf_eq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while 1 == 1 {
      let ca: u8 = a[i]
      let cb: u8 = b[i]
      if ca != cb { return 0 }
      if ca == (0 as u8) { return 1 }
      i = i + 1
  }
  return 0
116}
117func wf_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while s[i] != (0 as u8) {
      let c: i64 = s[i] as i64
      if c >= WF_ZERO { if c <= WF_NINE { v = v * 10 + (c - WF_ZERO) } }
      i = i + 1
  }
  return v
126}
127// find needle within [a,e); return offset AFTER the needle, or -1
128func wf_find_in(b: *u8, a: i64, e: i64, needle: *u8) -> i64 {
  let nl: i64 = wf_len(needle)
  if nl == 0 { return 0 - 1 }
  var i: i64 = a
  while i + nl <= e {
      var k: i64 = 0
      var ok: i64 = 1
      while k < nl { if b[i+k] != needle[k] { ok = 0; k = nl } else { k = k + 1 } }
      if ok == 1 { return i + nl }
      i = i + 1
  }
  return 0 - 1
140}
141// parse a non-negative integer starting at p, bounded by e
142func wf_num_at(b: *u8, e: i64, p: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = p
  var go: i64 = 1
  while go == 1 {
      if i >= e { go = 0 } else {
          let c: i64 = b[i] as i64
          if c < WF_ZERO { go = 0 } else {
              if c > WF_NINE { go = 0 } else { v = v * 10 + (c - WF_ZERO); i = i + 1 }
          }
      }
  }
  return v
155}
156// FNV-1a-shaped hash over slice [a,e); never returns 0 (0 marks an empty slot)
157func wf_hash(b: *u8, a: i64, e: i64) -> i64 {
  var h: i64 = 1469598103934665603
  var i: i64 = a
  while i < e {
      h = h ^ (b[i] as i64)
      h = h * 1099511628211
      i = i + 1
  }
  if h < 0 { h = 0 - h }
  if h == 0 { h = 1 }
  return h
168}
169// hash-set insert; returns 1 if the key was ALREADY present, 0 if freshly inserted.
170// cap slot: caller counts inserts; a full table must ANNOUNCE, never silently stop deduping.
171func wf_set_add(tab: *i64, h: i64) -> i64 {
  var s: i64 = h & WF_MID_MASK
  var guard: i64 = 0
  while guard < WF_MID_SLOTS {
      let cur: i64 = tab[s]
      if cur == 0 { tab[s] = h; return 0 }
      if cur == h { return 1 }
      s = (s + 1) & WF_MID_MASK
      guard = guard + 1
  }
  return 1
182}
183// intern slice [a,e) as a tool:verb label -> stable small id, or -1 if the id space is full
184func wf_intern(tab: *i64, offs: *i64, arena: *u8, st: *i64, b: *u8, a: i64, e: i64) -> i64 {
  var n: i64 = e - a
  if n <= 0 { return 0 - 1 }
  if n > WF_LABEL_MAX { n = WF_LABEL_MAX }
  let h: i64 = wf_hash(b, a, a + n)
  var s: i64 = h & WF_ID_MASK
  var guard: i64 = 0
  while guard < WF_ID_SLOTS {
      let cur: i64 = tab[s*2]
      if cur == 0 {
          if st[0] >= WF_IDS_MAX { return 0 - 1 }
          if st[1] + n + 1 >= WF_ARENA { return 0 - 1 }
          let id: i64 = st[0]
          let off: i64 = st[1]
          var k: i64 = 0
          while k < n { arena[off+k] = b[a+k]; k = k + 1 }
          arena[off+n] = 0 as u8
          offs[id] = off
          tab[s*2] = h
          tab[s*2+1] = id
          st[0] = id + 1
          st[1] = off + n + 1
          return id
      }
      if cur == h { return tab[s*2+1] }
      s = (s + 1) & WF_ID_MASK
      guard = guard + 1
  }
  return 0 - 1
213}
214// pair table: key = id1 * WF_IDS_MAX + id2 ; slots hold key, count, tokensum, tokenmax
215func wf_pair_add(bg: *i64, key: i64, tok: i64, env: *i64) -> i64 {
  var h: i64 = key * 2654435761
  if h < 0 { h = 0 - h }
  var s: i64 = h & WF_BG_MASK
  var guard: i64 = 0
  while guard < WF_BG_SLOTS {
      let cur: i64 = bg[s*4]
      if cur == 0 {
          bg[s*4] = key + 1
          bg[s*4+1] = 1
          bg[s*4+2] = tok
          bg[s*4+3] = tok
          env[WF_E_PAIRS] = env[WF_E_PAIRS] + 1
          return 0
      }
      if cur == key + 1 {
          bg[s*4+1] = bg[s*4+1] + 1
          bg[s*4+2] = bg[s*4+2] + tok
          if tok > bg[s*4+3] { bg[s*4+3] = tok }
          return 0
      }
      s = (s + 1) & WF_BG_MASK
      guard = guard + 1
  }
  env[WF_E_BGCAP] = env[WF_E_BGCAP] + 1
  return 0 - 1
241}
242func wf_is_jsonl(name: *u8) -> i64 {
  let n: i64 = wf_len(name)
  if n < 6 { return 0 }
  if name[n-6] != (46 as u8) { return 0 }
  if name[n-5] != (106 as u8) { return 0 }
  if name[n-4] != (115 as u8) { return 0 }
  if name[n-3] != (111 as u8) { return 0 }
  if name[n-2] != (110 as u8) { return 0 }
  if name[n-1] != (108 as u8) { return 0 }
  return 1
252}
253// ---- per-file pass: dedup usage by message.id, record invocation sequence, accumulate pairs ----
254func wf_scan_file(path: *u8, mids: *i64, idtab: *i64, idoffs: *i64, arena: *u8, ist: *i64, bg: *i64, msgtok: *i64, invid: *i64, invmsg: *i64, env: *i64, tok: *i64) -> i64 {
  var flen: i64 = 0
  let lp: *i64 = (&flen) as *i64
  let buf: *u8 = sys_read_file(path, lp)
  if (buf as i64) == 0 { env[WF_E_UNREAD] = env[WF_E_UNREAD] + 1; return 0 - 1 }
  if flen <= 0 { return 0 }
  env[WF_E_FILES] = env[WF_E_FILES] + 1
  env[WF_E_BYTES] = env[WF_E_BYTES] + flen
  var nmsg: i64 = 0
  var ninv: i64 = 0
  var i: i64 = 0
  while i < flen {
      var le: i64 = i
      var s: i64 = 1
      while s == 1 { if le >= flen { s = 0 } else { if buf[le] == (WF_NL as u8) { s = 0 } else { le = le + 1 } } }
      if le > i {
          env[WF_E_LINES] = env[WF_E_LINES] + 1
          let pu: i64 = wf_find_in(buf, i, le, "\x22usage\x22:{" as *u8)
          var curmsg: i64 = 0 - 1
          if pu >= 0 {
              // per-line (incumbent method) accumulation -- the audit counter
              let q1: i64 = wf_find_in(buf, i, le, "\x22input_tokens\x22:" as *u8)
              if q1 >= 0 { tok[WF_T_PIN] = tok[WF_T_PIN] + wf_num_at(buf, le, q1) }
              let q2: i64 = wf_find_in(buf, i, le, "\x22output_tokens\x22:" as *u8)
              if q2 >= 0 { tok[WF_T_POUT] = tok[WF_T_POUT] + wf_num_at(buf, le, q2) }
              let q3: i64 = wf_find_in(buf, i, le, "\x22cache_read_input_tokens\x22:" as *u8)
              if q3 >= 0 { tok[WF_T_PCR] = tok[WF_T_PCR] + wf_num_at(buf, le, q3) }
              let q4: i64 = wf_find_in(buf, i, le, "\x22cache_creation_input_tokens\x22:" as *u8)
              if q4 >= 0 { tok[WF_T_PCW] = tok[WF_T_PCW] + wf_num_at(buf, le, q4) }
              // corrected: dedup by message.id
              let pm: i64 = wf_find_in(buf, i, le, "\x22id\x22:\x22msg_" as *u8)
              var dup: i64 = 1
              if pm >= 0 {
                  var real_end: i64 = pm
                  var g: i64 = 1
                  while g == 1 { if real_end >= le { g = 0 } else { if buf[real_end] == (WF_QUOTE as u8) { g = 0 } else { real_end = real_end + 1 } } }
                  let h: i64 = wf_hash(buf, pm, real_end)
                  dup = wf_set_add(mids, h)
              }
              if dup == 0 {
                  var vin: i64 = 0
                  var vout: i64 = 0
                  var vcr: i64 = 0
                  var vcw: i64 = 0
                  if q1 >= 0 { vin = wf_num_at(buf, le, q1) }
                  if q2 >= 0 { vout = wf_num_at(buf, le, q2) }
                  if q3 >= 0 { vcr = wf_num_at(buf, le, q3) }
                  if q4 >= 0 { vcw = wf_num_at(buf, le, q4) }
                  tok[WF_T_IN] = tok[WF_T_IN] + vin
                  tok[WF_T_OUT] = tok[WF_T_OUT] + vout
                  tok[WF_T_CR] = tok[WF_T_CR] + vcr
                  tok[WF_T_CW] = tok[WF_T_CW] + vcw
                  env[WF_E_MSGS] = env[WF_E_MSGS] + 1
                  if nmsg < WF_MSG_MAX {
                      msgtok[nmsg] = vin*WF_W_IN + vout*WF_W_OUT + vcr*WF_W_CR + vcw*WF_W_CW
                      nmsg = nmsg + 1
                  } else { env[WF_E_MSGCAP] = env[WF_E_MSGCAP] + 1 }
              } else { env[WF_E_DUPLINES] = env[WF_E_DUPLINES] + 1 }
          }
          curmsg = nmsg - 1
          // tool invocation on this line
          let pt: i64 = wf_find_in(buf, i, le, "\x22type\x22:\x22tool_use\x22" as *u8)
          if pt >= 0 {
              let pn: i64 = wf_find_in(buf, pt, le, "\x22name\x22:\x22" as *u8)
              if pn >= 0 {
                  var ne: i64 = pn
                  var g2: i64 = 1
                  while g2 == 1 { if ne >= le { g2 = 0 } else { if buf[ne] == (WF_QUOTE as u8) { g2 = 0 } else { ne = ne + 1 } } }
                  // verb = first argv element when the tool takes one, else the bare tool name
                  var lab: i64 = 0
                  let pv: i64 = wf_find_in(buf, pn, le, "\x22argv\x22:[\x22" as *u8)
                  var lend: i64 = ne
                  if pv >= 0 {
                      var ve: i64 = pv
                      var g3: i64 = 1
                      while g3 == 1 { if ve >= le { g3 = 0 } else { if buf[ve] == (WF_QUOTE as u8) { g3 = 0 } else { ve = ve + 1 } } }
                      lab = 1
                      // label = name + ":" + verb, assembled in the arena tail scratch
                      let sc: *u8 = (( arena as i64) + WF_ARENA - WF_LABEL_MAX - 2) as *u8
                      var w: i64 = 0
                      var k2: i64 = pn
                      while k2 < ne { if w < WF_LABEL_MAX - 2 { sc[w] = buf[k2]; w = w + 1 }; k2 = k2 + 1 }
                      sc[w] = 58 as u8
                      w = w + 1
                      var k3: i64 = pv
                      while k3 < ve { if w < WF_LABEL_MAX { sc[w] = buf[k3]; w = w + 1 }; k3 = k3 + 1 }
                      let idv: i64 = wf_intern(idtab, idoffs, arena, ist, sc, 0, w)
                      if idv >= 0 { if ninv < WF_INV_MAX { invid[ninv] = idv; invmsg[ninv] = curmsg; ninv = ninv + 1; env[WF_E_INVS] = env[WF_E_INVS] + 1 } else { env[WF_E_INVCAP] = env[WF_E_INVCAP] + 1 } } else { env[WF_E_IDCAP] = env[WF_E_IDCAP] + 1 }
                  } else {
                      let idn: i64 = wf_intern(idtab, idoffs, arena, ist, buf, pn, ne)
                      if idn >= 0 { if ninv < WF_INV_MAX { invid[ninv] = idn; invmsg[ninv] = curmsg; ninv = ninv + 1; env[WF_E_INVS] = env[WF_E_INVS] + 1 } else { env[WF_E_INVCAP] = env[WF_E_INVCAP] + 1 } } else { env[WF_E_IDCAP] = env[WF_E_IDCAP] + 1 }
                  }
              }
          }
      }
      i = le + 1
  }
  // pairs: consecutive invocations; cost = the measured tokens of the messages they span
  var k: i64 = 0
  while k + 1 < ninv {
      let a1: i64 = invid[k]
      let a2: i64 = invid[k+1]
      var m1: i64 = invmsg[k]
      var m2: i64 = invmsg[k+1]
      if m1 < 0 { m1 = 0 }
      if m2 < m1 { m2 = m1 }
      var cost: i64 = 0
      var m: i64 = m1
      while m <= m2 { if m >= 0 { if m < nmsg { cost = cost + msgtok[m] } }; m = m + 1 }
      wf_pair_add(bg, a1 * WF_IDS_MAX + a2, cost, env)
      k = k + 1
  }
  // free the file map before the next file: 309 transcripts x up to 55 MB would otherwise fault
  // ~2 GB resident for a single census. A measurement that hammers the box is a bug (rule: resource
  // excellence is a shipping criterion), and the peak here is now ONE transcript, not the corpus.
  sys_free_file(buf, flen)
  return 0
371}
372func wf_walk(dir: *u8, mids: *i64, idtab: *i64, idoffs: *i64, arena: *u8, ist: *i64, bg: *i64, msgtok: *i64, invid: *i64, invmsg: *i64, env: *i64, tok: *i64) -> i64 {
  let fd: i64 = sys_openat_rd(dir)
  if fd < 0 { return 0 - 1 }
  let gbuf: *u8 = sys_mmap(WF_DIRENT_BUF)
  let child: *u8 = sys_mmap(WF_PATH_BUF)
  var nread: i64 = __syscall(WF_GETDENTS, fd, gbuf, WF_DIRENT_BUF, 0, 0, 0)
  while nread > 0 {
      var off: i64 = 0
      while off < nread {
          let reclen: i64 = (gbuf[off + WF_RECLEN_OFF] as i64) | ((gbuf[off + WF_RECLEN_OFF + 1] as i64) << 8)
          if reclen <= 0 { off = nread } else {
              let name: *u8 = ((gbuf as i64) + off + WF_NAME_OFF) as *u8
              if wf_is_jsonl(name) == 1 {
                  var co: i64 = 0
                  var di: i64 = 0
                  while dir[di] != (0 as u8) { child[co] = dir[di]; co = co + 1; di = di + 1 }
                  child[co] = WF_SLASH as u8
                  co = co + 1
                  var ci: i64 = 0
                  while name[ci] != (0 as u8) { child[co] = name[ci]; co = co + 1; ci = ci + 1 }
                  child[co] = 0 as u8
                  wf_scan_file(child, mids, idtab, idoffs, arena, ist, bg, msgtok, invid, invmsg, env, tok)
              }
              off = off + reclen
          }
      }
      nread = __syscall(WF_GETDENTS, fd, gbuf, WF_DIRENT_BUF, 0, 0, 0)
  }
  sys_close(fd)
  return 0
402}
403func wf_emit_env(env: *i64, tok: *i64) -> i64 {
  gv_puts("ENV files=" as *u8)
  gv_num(env[WF_E_FILES])
  gv_puts(" bytes=" as *u8)
  gv_num(env[WF_E_BYTES])
  gv_puts(" lines=" as *u8)
  gv_num(env[WF_E_LINES])
  gv_puts(" messages=" as *u8)
  gv_num(env[WF_E_MSGS])
  gv_puts(" duplicate_usage_lines=" as *u8)
  gv_num(env[WF_E_DUPLINES])
  gv_puts(" invocations=" as *u8)
  gv_num(env[WF_E_INVS])
  gv_puts(" distinct_pairs=" as *u8)
  gv_num(env[WF_E_PAIRS])
  gv_puts(" unreadable=" as *u8)
  gv_num(env[WF_E_UNREAD])
  gv_puts("\nCAPS msg_overflow=" as *u8)
  gv_num(env[WF_E_MSGCAP])
  gv_puts(" inv_overflow=" as *u8)
  gv_num(env[WF_E_INVCAP])
  gv_puts(" label_overflow=" as *u8)
  gv_num(env[WF_E_IDCAP])
  gv_puts(" pair_overflow=" as *u8)
  gv_num(env[WF_E_BGCAP])
  gv_puts(" (any non-zero => the run below is a FLOOR, not a total)\n" as *u8)
  return 0
430}
431func wf_gauge(dir: *u8) -> i64 {
  let env: *i64 = sys_mmap(WF_E_SLOTS * 8) as *i64
  let tok: *i64 = sys_mmap(WF_T_SLOTS * 8) as *i64
  let mids: *i64 = sys_mmap(WF_MID_SLOTS * 8) as *i64
  let idtab: *i64 = sys_mmap(WF_ID_SLOTS * 2 * 8) as *i64
  let idoffs: *i64 = sys_mmap(WF_IDS_MAX * 8) as *i64
  let arena: *u8 = sys_mmap(WF_ARENA)
  let ist: *i64 = sys_mmap(4 * 8) as *i64
  let bg: *i64 = sys_mmap(WF_BG_SLOTS * 4 * 8) as *i64
  let msgtok: *i64 = sys_mmap(WF_MSG_MAX * 8) as *i64
  let invid: *i64 = sys_mmap(WF_INV_MAX * 8) as *i64
  let invmsg: *i64 = sys_mmap(WF_INV_MAX * 8) as *i64
  wf_walk(dir, mids, idtab, idoffs, arena, ist, bg, msgtok, invid, invmsg, env, tok)
  gv_puts("WFCOST-GAUGE v1 (full population, no sampling)\n" as *u8)
  wf_emit_env(env, tok)
  gv_puts("CORRECTED msgid_deduped in=" as *u8)
  gv_num(tok[WF_T_IN])
  gv_puts(" out=" as *u8)
  gv_num(tok[WF_T_OUT])
  gv_puts(" cache_read=" as *u8)
  gv_num(tok[WF_T_CR])
  gv_puts(" cache_write=" as *u8)
  gv_num(tok[WF_T_CW])
  gv_puts("\nPERLINE incumbent_method in=" as *u8)
  gv_num(tok[WF_T_PIN])
  gv_puts(" out=" as *u8)
  gv_num(tok[WF_T_POUT])
  gv_puts(" cache_read=" as *u8)
  gv_num(tok[WF_T_PCR])
  gv_puts(" cache_write=" as *u8)
  gv_num(tok[WF_T_PCW])
  let ct: i64 = tok[WF_T_IN] + tok[WF_T_OUT] + tok[WF_T_CR] + tok[WF_T_CW]
  let pt: i64 = tok[WF_T_PIN] + tok[WF_T_POUT] + tok[WF_T_PCR] + tok[WF_T_PCW]
  gv_puts("\nTOTALS corrected=" as *u8)
  gv_num(ct)
  gv_puts(" perline=" as *u8)
  gv_num(pt)
  gv_puts(" overstatement_permil=" as *u8)
  if ct > 0 { gv_num((pt * WF_PERMIL) / ct) } else { gv_num(0) }
  gv_puts(" (1000 = the two agree; >1000 = the per-line method overstates)\n" as *u8)
  return 0
472}
473func wf_mine(dir: *u8, minsup: i64, top: i64) -> i64 {
  let env: *i64 = sys_mmap(WF_E_SLOTS * 8) as *i64
  let tok: *i64 = sys_mmap(WF_T_SLOTS * 8) as *i64
  let mids: *i64 = sys_mmap(WF_MID_SLOTS * 8) as *i64
  let idtab: *i64 = sys_mmap(WF_ID_SLOTS * 2 * 8) as *i64
  let idoffs: *i64 = sys_mmap(WF_IDS_MAX * 8) as *i64
  let arena: *u8 = sys_mmap(WF_ARENA)
  let ist: *i64 = sys_mmap(4 * 8) as *i64
  let bg: *i64 = sys_mmap(WF_BG_SLOTS * 4 * 8) as *i64
  let msgtok: *i64 = sys_mmap(WF_MSG_MAX * 8) as *i64
  let invid: *i64 = sys_mmap(WF_INV_MAX * 8) as *i64
  let invmsg: *i64 = sys_mmap(WF_INV_MAX * 8) as *i64
  wf_walk(dir, mids, idtab, idoffs, arena, ist, bg, msgtok, invid, invmsg, env, tok)
  gv_puts("WFCOST-MINE v1 (full population, no sampling) minsup=" as *u8)
  gv_num(minsup)
  gv_puts("\n" as *u8)
  wf_emit_env(env, tok)
  gv_puts("ROW support total_weighted mean_weighted max_weighted pair  (weighted = in*1 out*5 cacheread*0.1 cachewrite*1.25, x" as *u8)
  gv_num(WF_W_DIV)
  gv_puts(" integer scale; TOTAL is exact, MEAN and MAX are labelled as such, NO median is claimed)\n" as *u8)
  // selection sort over the qualifying rows only, by total weighted tokens DESC
  var shown: i64 = 0
  var qual: i64 = 0
  var s: i64 = 0
  while s < WF_BG_SLOTS { if bg[s*4] != 0 { if bg[s*4+1] >= minsup { qual = qual + 1 } }; s = s + 1 }
  // `go` is a SEPARATE loop-control flag: writing `shown = top` to leave the loop would destroy the
  // very count the footer reports (it printed shown=30 having shown nothing).
  var go: i64 = 1
  while go == 1 { if shown >= top { go = 0 } else {
      var best: i64 = 0 - 1
      var bestv: i64 = 0 - 1
      var t: i64 = 0
      while t < WF_BG_SLOTS {
          if bg[t*4] != 0 {
              if bg[t*4+1] >= minsup {
                  if bg[t*4+2] > bestv { bestv = bg[t*4+2]; best = t }
              }
          }
          t = t + 1
      }
      if best < 0 { go = 0 } else {
          let key: i64 = bg[best*4] - 1
          let id1: i64 = key / WF_IDS_MAX
          let id2: i64 = key - id1 * WF_IDS_MAX
          gv_puts("ROW " as *u8)
          gv_num(bg[best*4+1])
          gv_puts(" " as *u8)
          gv_num(bg[best*4+2])
          gv_puts(" " as *u8)
          gv_num(bg[best*4+2] / bg[best*4+1])
          gv_puts(" " as *u8)
          gv_num(bg[best*4+3])
          gv_puts(" " as *u8)
          let p1: *u8 = ((arena as i64) + idoffs[id1]) as *u8
          let p2: *u8 = ((arena as i64) + idoffs[id2]) as *u8
          gv_puts(p1)
          gv_puts(" >> " as *u8)
          gv_puts(p2)
          gv_puts("\n" as *u8)
          bg[best*4+2] = 0 - 1
          shown = shown + 1
      }
  } }
  gv_puts("QUALIFYING pairs_at_or_above_minsup=" as *u8)
  gv_num(qual)
  gv_puts(" shown=" as *u8)
  gv_num(shown)
  gv_puts(" (shown is a PREFIX of qualifying when shown < qualifying)\n" as *u8)
  return 0
542}
543// ---- FRAMES MODE: mine the NAS-side chbeat journals (DM1's ch_beat, live 2026-08-20) ----
544// ⚠ THESE ARE NOT TRANSCRIPTS AND THE DIFFERENCE IS LOAD-BEARING. A chbeat frame is TSV
545// `ts <TAB> session <TAB> tool <TAB> verb <TAB> outcome <TAB> note`, and MEASURED on the landed
546// corpus: (a) it carries NO token usage at all -- `nx_absent input_tokens knowledge/status/chbeat
547// jrnl` returned matches=0 with corpus_complete=1, ABSENT-PROVEN; (b) the verb column is the
548// CONSTANT string "use" for every row, so `nx_fs:read` and `nx_fs:lines` both collapse to `nx_fs`.
549// ⇒ THIS VERB PUBLISHES SUPPORT AND REFUSES TO PUBLISH COST. That refusal is the point: a cost
550// column derived from frames that contain no cost would be a constant wearing the shape of a
551// measurement. It is sound to rank on support alone because this lane MEASURED that per-episode
552// cost does not discriminate (1.63x spread) while support does (15.1x) -- support IS the ranking
553// quantity, and frames carry exactly that.
554// ⚠ COVERAGE IS A BACKFILL AND IS THEREFORE PARTIAL BY CONSTRUCTION: it drains OLDEST-FIRST, so the
555// landed subset is the PAST, not the present. The window is printed with every run and the verdict
556// line says PARTIAL-WINDOW -- never let a drained prefix read as the corpus.
557func wf_is_jrnl(name: *u8) -> i64 {
  let n: i64 = wf_len(name)
  if n < 6 { return 0 }
  if name[n-5] != (46 as u8) { return 0 }
  if name[n-4] != (106 as u8) { return 0 }
  if name[n-3] != (114 as u8) { return 0 }
  if name[n-2] != (110 as u8) { return 0 }
  if name[n-1] != (108 as u8) { return 0 }
  return 1
566}
567func wf_frames_file(path: *u8, idtab: *i64, idoffs: *i64, arena: *u8, ist: *i64, bg: *i64, env: *i64) -> i64 {
  var flen: i64 = 0
  let lp: *i64 = (&flen) as *i64
  let buf: *u8 = sys_read_file(path, lp)
  if (buf as i64) == 0 { env[WF_E_UNREAD] = env[WF_E_UNREAD] + 1; return 0 - 1 }
  if flen <= 0 { return 0 }
  env[WF_E_FILES] = env[WF_E_FILES] + 1
  env[WF_E_BYTES] = env[WF_E_BYTES] + flen
  var prev_tool: i64 = 0 - 1
  var prev_sess: i64 = 0
  var i: i64 = 0
  while i < flen {
      var le: i64 = i
      var s: i64 = 1
      while s == 1 { if le >= flen { s = 0 } else { if buf[le] == (WF_NL as u8) { s = 0 } else { le = le + 1 } } }
      if le > i {
          env[WF_E_LINES] = env[WF_E_LINES] + 1
          // field 0: ts
          var p: i64 = i
          var g: i64 = 1
          while g == 1 { if p >= le { g = 0 } else { if buf[p] == (WF_TSV_TAB as u8) { g = 0 } else { p = p + 1 } } }
          if p < le {
              let ts: i64 = wf_num_at(buf, le, i)
              if ts > 0 {
                  if env[WF_E_MINTS] == 0 { env[WF_E_MINTS] = ts }
                  if ts < env[WF_E_MINTS] { env[WF_E_MINTS] = ts }
                  if ts > env[WF_E_MAXTS] { env[WF_E_MAXTS] = ts }
              }
              // field 1: session
              let s1: i64 = p + 1
              var q: i64 = s1
              var g2: i64 = 1
              while g2 == 1 { if q >= le { g2 = 0 } else { if buf[q] == (WF_TSV_TAB as u8) { g2 = 0 } else { q = q + 1 } } }
              if q < le {
                  let sess: i64 = wf_hash(buf, s1, q)
                  // field 2: tool
                  let s2: i64 = q + 1
                  var r: i64 = s2
                  var g3: i64 = 1
                  while g3 == 1 { if r >= le { g3 = 0 } else { if buf[r] == (WF_TSV_TAB as u8) { g3 = 0 } else { r = r + 1 } } }
                  if r > s2 {
                      let tid: i64 = wf_intern(idtab, idoffs, arena, ist, buf, s2, r)
                      if tid >= 0 {
                          env[WF_E_FRAMES] = env[WF_E_FRAMES] + 1
                          // pair ONLY within one session: a pair spanning two sessions is an
                          // artifact of file layout, not a thing anybody did.
                          if prev_tool >= 0 { if sess == prev_sess { wf_pair_add(bg, prev_tool * WF_IDS_MAX + tid, 0, env) } }
                          prev_tool = tid
                          prev_sess = sess
                      } else { env[WF_E_IDCAP] = env[WF_E_IDCAP] + 1 }
                  }
              }
          }
      }
      i = le + 1
  }
  sys_free_file(buf, flen)
  return 0
625}
626func wf_frames(dir: *u8, minsup: i64, top: i64) -> i64 {
  let env: *i64 = sys_mmap(WF_E_SLOTS * 8) as *i64
  let idtab: *i64 = sys_mmap(WF_ID_SLOTS * 2 * 8) as *i64
  let idoffs: *i64 = sys_mmap(WF_IDS_MAX * 8) as *i64
  let arena: *u8 = sys_mmap(WF_ARENA)
  let ist: *i64 = sys_mmap(4 * 8) as *i64
  let bg: *i64 = sys_mmap(WF_BG_SLOTS * 4 * 8) as *i64
  let fd: i64 = sys_openat_rd(dir)
  if fd < 0 { gv_puts("WFCOST-FRAMES UNREADABLE dir\n" as *u8); return 0 - 1 }
  let gbuf: *u8 = sys_mmap(WF_DIRENT_BUF)
  let child: *u8 = sys_mmap(WF_PATH_BUF)
  var nread: i64 = __syscall(WF_GETDENTS, fd, gbuf, WF_DIRENT_BUF, 0, 0, 0)
  while nread > 0 {
      var off: i64 = 0
      while off < nread {
          let reclen: i64 = (gbuf[off + WF_RECLEN_OFF] as i64) | ((gbuf[off + WF_RECLEN_OFF + 1] as i64) << 8)
          if reclen <= 0 { off = nread } else {
              let name: *u8 = ((gbuf as i64) + off + WF_NAME_OFF) as *u8
              if wf_is_jrnl(name) == 1 {
                  var co: i64 = 0
                  var di: i64 = 0
                  while dir[di] != (0 as u8) { child[co] = dir[di]; co = co + 1; di = di + 1 }
                  child[co] = WF_SLASH as u8
                  co = co + 1
                  var ci: i64 = 0
                  while name[ci] != (0 as u8) { child[co] = name[ci]; co = co + 1; ci = ci + 1 }
                  child[co] = 0 as u8
                  wf_frames_file(child, idtab, idoffs, arena, ist, bg, env)
              }
              off = off + reclen
          }
      }
      nread = __syscall(WF_GETDENTS, fd, gbuf, WF_DIRENT_BUF, 0, 0, 0)
  }
  sys_close(fd)
  gv_puts("WFCOST-FRAMES v1 SOURCE=chbeat-frames minsup=" as *u8)
  gv_num(minsup)
  gv_puts("\nENV files=" as *u8)
  gv_num(env[WF_E_FILES])
  gv_puts(" bytes=" as *u8)
  gv_num(env[WF_E_BYTES])
  gv_puts(" lines=" as *u8)
  gv_num(env[WF_E_LINES])
  gv_puts(" frames=" as *u8)
  gv_num(env[WF_E_FRAMES])
  gv_puts(" distinct_pairs=" as *u8)
  gv_num(env[WF_E_PAIRS])
  gv_puts(" unreadable=" as *u8)
  gv_num(env[WF_E_UNREAD])
  gv_puts("\nWINDOW min_ts=" as *u8)
  gv_num(env[WF_E_MINTS])
  gv_puts(" max_ts=" as *u8)
  gv_num(env[WF_E_MAXTS])
  gv_puts(" span_days=" as *u8)
  if env[WF_E_MAXTS] > env[WF_E_MINTS] { gv_num((env[WF_E_MAXTS] - env[WF_E_MINTS]) / WF_DAYSEC) } else { gv_num(0) }
  gv_puts("\nTOKENS available=0 -- chbeat frames carry NO usage fields (ABSENT-PROVEN, corpus_complete=1).\n" as *u8)
  gv_puts("  This verb therefore publishes SUPPORT ONLY and REFUSES to print a cost column; a cost\n" as *u8)
  gv_puts("  derived from frames with no cost in them would be a constant wearing the shape of a\n" as *u8)
  gv_puts("  measurement. Run `gauge`/`mine` where the transcripts live for measured tokens.\n" as *u8)
  gv_puts("VERBS collapsed=1 -- the frame verb column is the constant \x22use\x22, so nx_fs:read and\n" as *u8)
  gv_puts("  nx_fs:lines are INDISTINGUISHABLE here; pairs are TOOL-level, not tool:verb-level.\n" as *u8)
  gv_puts("ROW support pair (support only; no cost column by construction)\n" as *u8)
  var shown: i64 = 0
  var qual: i64 = 0
  var s2: i64 = 0
  while s2 < WF_BG_SLOTS { if bg[s2*4] != 0 { if bg[s2*4+1] >= minsup { qual = qual + 1 } }; s2 = s2 + 1 }
  var go: i64 = 1
  while go == 1 { if shown >= top { go = 0 } else {
      var best: i64 = 0 - 1
      var bestv: i64 = 0 - 1
      var t: i64 = 0
      while t < WF_BG_SLOTS {
          if bg[t*4] != 0 { if bg[t*4+1] >= minsup { if bg[t*4+1] > bestv { bestv = bg[t*4+1]; best = t } } }
          t = t + 1
      }
      if best < 0 { go = 0 } else {
          let key: i64 = bg[best*4] - 1
          let id1: i64 = key / WF_IDS_MAX
          let id2: i64 = key - id1 * WF_IDS_MAX
          gv_puts("ROW " as *u8)
          gv_num(bg[best*4+1])
          gv_puts(" " as *u8)
          gv_puts(((arena as i64) + idoffs[id1]) as *u8)
          gv_puts(" >> " as *u8)
          gv_puts(((arena as i64) + idoffs[id2]) as *u8)
          gv_puts("\n" as *u8)
          bg[best*4+1] = 0 - 1
          shown = shown + 1
      }
  } }
  gv_puts("QUALIFYING pairs=" as *u8)
  gv_num(qual)
  gv_puts(" shown=" as *u8)
  gv_num(shown)
  gv_puts("\nverdict=PARTIAL-WINDOW -- this is the LANDED subset of a backfill that drains OLDEST-FIRST,\n" as *u8)
  gv_puts("  so it is a BOUND on the past, not the corpus and not the present. Re-run as it drains.\n" as *u8)
  return 0
723}
724func wf_selftest() -> i64 {
  let ctr: *i64 = sys_mmap(64) as *i64
  // fixture: ONE message id written across THREE content-block lines, usage repeated verbatim --
  // the exact shape that makes the per-line method overcount. Built at RUNTIME (never a source
  // literal a scanner could mistake for real data, and never shared with a production beat).
  let env: *i64 = sys_mmap(WF_E_SLOTS * 8) as *i64
  let tok: *i64 = sys_mmap(WF_T_SLOTS * 8) as *i64
  let mids: *i64 = sys_mmap(WF_MID_SLOTS * 8) as *i64
  let idtab: *i64 = sys_mmap(WF_ID_SLOTS * 2 * 8) as *i64
  let idoffs: *i64 = sys_mmap(WF_IDS_MAX * 8) as *i64
  let arena: *u8 = sys_mmap(WF_ARENA)
  let ist: *i64 = sys_mmap(4 * 8) as *i64
  let bg: *i64 = sys_mmap(WF_BG_SLOTS * 4 * 8) as *i64
  let msgtok: *i64 = sys_mmap(WF_MSG_MAX * 8) as *i64
  let invid: *i64 = sys_mmap(WF_INV_MAX * 8) as *i64
  let invmsg: *i64 = sys_mmap(WF_INV_MAX * 8) as *i64
  let dir: *u8 = sys_mmap(WF_PATH_BUF)
  let path: *u8 = sys_mmap(WF_PATH_BUF)
  var dn: i64 = 0
  let dsrc: *u8 = "/tmp/nx_wfcost_gate" as *u8
  while dsrc[dn] != (0 as u8) { dir[dn] = dsrc[dn]; dn = dn + 1 }
  dir[dn] = 0 as u8
  sys_mkdir(dir, WF_MODE_755)
  var pn: i64 = 0
  let psrc: *u8 = "/tmp/nx_wfcost_gate/fx.jsonl" as *u8
  while psrc[pn] != (0 as u8) { path[pn] = psrc[pn]; pn = pn + 1 }
  path[pn] = 0 as u8
  let fx: *u8 = sys_mmap(WF_ARENA)
  var w: i64 = 0
  let l1: *u8 = "{\x22message\x22:{\x22id\x22:\x22msg_AAA\x22,\x22content\x22:[{\x22type\x22:\x22thinking\x22}],\x22usage\x22:{\x22input_tokens\x22:10,\x22cache_creation_input_tokens\x22:0,\x22cache_read_input_tokens\x22:0,\x22output_tokens\x22:0}}}\n" as *u8
  var k: i64 = 0
  while l1[k] != (0 as u8) { fx[w] = l1[k]; w = w + 1; k = k + 1 }
  let l2: *u8 = "{\x22message\x22:{\x22id\x22:\x22msg_AAA\x22,\x22content\x22:[{\x22type\x22:\x22tool_use\x22,\x22name\x22:\x22Alpha\x22,\x22input\x22:{\x22argv\x22:[\x22one\x22]}}],\x22usage\x22:{\x22input_tokens\x22:10,\x22cache_creation_input_tokens\x22:0,\x22cache_read_input_tokens\x22:0,\x22output_tokens\x22:0}}}\n" as *u8
  k = 0
  while l2[k] != (0 as u8) { fx[w] = l2[k]; w = w + 1; k = k + 1 }
  let l3: *u8 = "{\x22message\x22:{\x22id\x22:\x22msg_BBB\x22,\x22content\x22:[{\x22type\x22:\x22tool_use\x22,\x22name\x22:\x22Beta\x22,\x22input\x22:{\x22argv\x22:[\x22two\x22]}}],\x22usage\x22:{\x22input_tokens\x22:5,\x22cache_creation_input_tokens\x22:0,\x22cache_read_input_tokens\x22:0,\x22output_tokens\x22:0}}}\n" as *u8
  k = 0
  while l3[k] != (0 as u8) { fx[w] = l3[k]; w = w + 1; k = k + 1 }
  let fd: i64 = sys_openat_wr(path, WF_MODE_644)
  sys_write(fd, fx, w)
  sys_close(fd)
  wf_scan_file(path, mids, idtab, idoffs, arena, ist, bg, msgtok, invid, invmsg, env, tok)
  var c1: i64 = 0
  if env[WF_E_MSGS] == 2 { c1 = 1 }
  gv_check("T1 three usage-lines over two message ids counted as TWO messages" as *u8, c1, ctr)
  var c2: i64 = 0
  if env[WF_E_DUPLINES] == 1 { c2 = 1 }
  gv_check("T2 the repeated message-id line is COUNTED as a duplicate, not dropped silently" as *u8, c2, ctr)
  var c3: i64 = 0
  if tok[WF_T_IN] == 15 { c3 = 1 }
  gv_check("T3 corrected input tokens 10+5=15 (msgid-deduped)" as *u8, c3, ctr)
  var c4: i64 = 0
  if tok[WF_T_PIN] == 25 { c4 = 1 }
  gv_check("neg-control-perline-method-MUST-overcount-to-25 (proves the fixture can fail)" as *u8, c4, ctr)
  var c5: i64 = 0
  if env[WF_E_INVS] == 2 { c5 = 1 }
  gv_check("T5 two tool invocations recorded in sequence" as *u8, c5, ctr)
  var c6: i64 = 0
  if env[WF_E_PAIRS] == 1 { c6 = 1 }
  gv_check("T6 exactly ONE consecutive pair formed from two invocations" as *u8, c6, ctr)
  // neg-control: a hash set must report a repeat as a repeat, and a fresh key as fresh
  let t2: *i64 = sys_mmap(WF_MID_SLOTS * 8) as *i64
  var c7: i64 = 0
  if wf_set_add(t2, 12345) == 0 { if wf_set_add(t2, 12345) == 1 { c7 = 1 } }
  gv_check("T7 set: first insert fresh, second insert reports ALREADY-PRESENT" as *u8, c7, ctr)
  var c8: i64 = 0
  if wf_set_add(t2, 999) == 0 { c8 = 1 }
  gv_check("neg-control-a-DIFFERENT-key-must-NOT-read-as-present" as *u8, c8, ctr)
  // anti-vacuity: a one-off sequence must NOT reach a support-2 bar (a detector that fires on
  // everything discriminates nothing -- the POSITIVE control for "not every sequence is common")
  var c9: i64 = 0
  var sq: i64 = 0
  var found: i64 = 0
  while sq < WF_BG_SLOTS { if bg[sq*4] != 0 { if bg[sq*4+1] >= 2 { found = found + 1 } }; sq = sq + 1 }
  if found == 0 { c9 = 1 }
  gv_check("neg-control-one-off-pair-must-NOT-qualify-at-minsup-2 (anti-vacuity)" as *u8, c9, ctr)
  let rc: i64 = gv_verdict("NX-WFCOST-GATE" as *u8, ctr, "msgid dedup + per-line audit counter + pair formation + set semantics" as *u8)
  return rc
802}
803func main(argc: i64, argv: *i64) -> i64 {
  if argc>1 {if wf_eq(argv[1] as *u8,"evaluate")==1{return wfj_command(argc,argv)};if wf_eq(argv[1] as *u8,"evaluate-config")==1{return wfj_config_command(argc,argv)}}
  if argc < 2 {
      gv_puts("nx_wfcost v1 -- workflow-episode token cost (Lane I common-task hardening)\n" as *u8)
      gv_puts("  gauge [trdir]           corrected(msgid-deduped) vs perline totals + overcount permil\n" as *u8)
      gv_puts("  mine  [trdir] [minsup] [top]  recurring invocation pairs with exact measured tokens\n" as *u8)
      gv_puts("  selftest                gv verdict gate (runtime fixtures, named neg-controls)\n" as *u8)
      sys_exit(0)
      return 0
  }
  let a1: *u8 = argv[1] as *u8
  if wf_eq(a1, "selftest" as *u8) == 1 { let rc: i64 = wf_selftest(); sys_exit(rc); return rc }
  var dir: *u8 = WF_TR_DEF
  if wf_eq(a1, "gauge" as *u8) == 1 {
      if argc >= 3 { dir = argv[2] as *u8 }
      wf_gauge(dir)
      sys_exit(0)
      return 0
  }
  if wf_eq(a1, "frames" as *u8) == 1 {
      var fd2: *u8 = WF_CHBEAT_DEF
      if argc >= 3 { fd2 = argv[2] as *u8 }
      var fms: i64 = 2
      var ftop: i64 = WF_TOP_DEF
      if argc >= 4 { fms = wf_atoi(argv[3] as *u8) }
      if argc >= 5 { ftop = wf_atoi(argv[4] as *u8) }
      if fms < 1 { fms = 1 }
      if ftop < 1 { ftop = 1 }
      wf_frames(fd2, fms, ftop)
      sys_exit(0)
      return 0
  }
  if wf_eq(a1, "mine" as *u8) == 1 {
      if argc >= 3 { dir = argv[2] as *u8 }
      var ms: i64 = 2
      var top: i64 = WF_TOP_DEF
      if argc >= 4 { ms = wf_atoi(argv[3] as *u8) }
      if argc >= 5 { top = wf_atoi(argv[4] as *u8) }
      if ms < 1 { ms = 1 }
      if top < 1 { top = 1 }
      wf_mine(dir, ms, top)
      sys_exit(0)
      return 0
  }
  gv_puts("unknown verb (use: gauge | mine | selftest)\n" as *u8)
  sys_exit(2)
  return 2
850}
851
852
853// Explicit attribution joins over the canonical reconciled request table. This
854// does not infer task/model/provider identity or acceptance from temporal proximity.
855// Binding plane v1 has 16 columns: id,scan_sha256,thread,response,workflow,task,
856// attempt,role,provider,actual_model,phase,elapsed_ms,evidence_path,evidence_sha256,
857// acceptance,reviewer. '-' means unknown. Acceptance remains a reviewer assertion.
858import "nx_usage_artifact_t173.nx"
859import "nx_comparestale_lib.nx"
860const WFJ_COLS:i64=16
861const WFJ_STATS:i64=25
862// stats: eligible,bound,unknown,rows,other_snapshot,unmatched,retained,missing,
863// unreadable,drift,accept_assertions,accepted_with_retained,elapsed_known,
864// elapsed_unknown,elapsed_sum,roles_unknown; work/retry/review/unknown phase
865// requests at16..19; assigned request counts by role at20..24. Usage buckets: root,dispatcher,
866// provider,reviewer,unknown; each preserves all six provider-reported counters.
867func wfj_span_eq(a:*u8,s:i64,n:i64,b:*u8,t:i64,m:i64)->i64 {
if n!=m{return 0};var i:i64=0;while i<n{if a[s+i]!=b[t+i]{return 0};i=i+1};return 1
869}
870func wfj_lit(q:*u8,f:*i64,col:i64,s:*u8)->i64{return wfj_span_eq(q,f[col*2],f[col*2+1],s,0,cd_len(s))}
871func wfj_fields_n(q:*u8,s:i64,e:i64,f:*i64,cols:i64)->i64 {
var col:i64=0;var start:i64=s;var i:i64=s
while i<=e {
var end:i64=0;if i==e{end=1}else{if q[i]==(9 as u8){end=1}}
if end==1 {
 if col>=cols||i==start{return -1}
 if utf8_validate((q as i64+start) as *u8,i-start)!=i-start{return -1}
 f[col*2]=start;f[col*2+1]=i-start;col=col+1;start=i+1
}else{if q[i]<(32 as u8){return -1}}
i=i+1
}
if col!=cols{return -1};return 0
883}
884func wfj_fields(q:*u8,s:i64,e:i64,f:*i64)->i64{return wfj_fields_n(q,s,e,f,WFJ_COLS)}
885func wfj_hash(q:*u8,f:*i64,col:i64)->i64 {
if f[col*2+1]!=CD_HASH_CHARS{return 0};var i:i64=0
while i<CD_HASH_CHARS{let c:i64=q[f[col*2]+i] as i64;if (c<48||c>57)&&(c<97||c>102){return 0};i=i+1};return 1
888}
889func wfj_copy(q:*u8,f:*i64,col:i64,out:*u8)->i64 {
let n:i64=f[col*2+1];var i:i64=0;while i<n{out[i]=q[f[col*2]+i];i=i+1};out[n]=0;return n
891}
892func wfj_role(q:*u8,f:*i64)->i64 {
if wfj_lit(q,f,7,"root")==1{return 0};if wfj_lit(q,f,7,"dispatcher")==1{return 1}
if wfj_lit(q,f,7,"provider")==1{return 2};if wfj_lit(q,f,7,"reviewer")==1{return 3}
if wfj_lit(q,f,7,"-")==1{return 4};return -1
896}
897func wfj_validate(q:*u8,f:*i64)->i64 {
if wfj_hash(q,f,1)==0{return -1};if wfj_role(q,f)<0{return -1}
if wfj_lit(q,f,10,"work")!=1&&wfj_lit(q,f,10,"retry")!=1&&wfj_lit(q,f,10,"review")!=1&&wfj_lit(q,f,10,"-")!=1{return -1}
if wfj_lit(q,f,11,"-")!=1{if chu_uint(q,f[22],f[23])<0{return -1}}
let path_unknown:i64=wfj_lit(q,f,12,"-");let hash_unknown:i64=wfj_lit(q,f,13,"-")
if path_unknown!=hash_unknown{return -1};if hash_unknown==0&&wfj_hash(q,f,13)==0{return -1}
if wfj_lit(q,f,14,"unknown")!=1&&wfj_lit(q,f,14,"accepted-deployed")!=1&&wfj_lit(q,f,14,"rejected")!=1{return -1}
if wfj_lit(q,f,14,"unknown")!=1{if wfj_lit(q,f,15,"-")==1{return -1}}
// Request/task/attempt linkage cannot be partial under a bound row.
var i:i64=0;while i<7{if wfj_lit(q,f,i,"-")==1{return -1};i=i+1}
return 0
908}
909// A matching evidence hash proves retained bytes, not the semantic correctness of
910// a reviewer assertion, a live URL, or a causal improvement. Missing is observed
911// failure; unreadable remains unknown. Evidence is read through the shared owner.
912func wfj_evidence(q:*u8,f:*i64)->i64 {
if wfj_lit(q,f,12,"-")==1{return 0}
let pn:i64=f[25]+1
if pn<=0{return -1}
let path:*u8=sys_mmap_shared(pn);let want:*u8=sys_mmap_shared(CD_HASH_CHARS+1)
let got:*u8=sys_mmap_shared(CD_HASH_CHARS+1)
let obs:*CsDependencyFile=sys_mmap_shared(CD_FILE_BYTES) as *CsDependencyFile
var result:i64=3
if (path as i64)>0&&(want as i64)>0&&(got as i64)>0&&(obs as i64)>0{
wfj_copy(q,f,12,path);wfj_copy(q,f,13,want);obs.hash=got
let rc:i64=cd_scan(path,"",obs)
if rc==0{result=4;if cd_equal(got,want)==1{result=1}}else{if rc==(0-2)&&cd_equal(obs.stage,"open")==1{result=2}}
}
if (path as i64)>0{if sys_munmap(path,pn)!=0{result=3}}
if (want as i64)>0{if sys_munmap(want,CD_HASH_CHARS+1)!=0{result=3}}
if (got as i64)>0{if sys_munmap(got,CD_HASH_CHARS+1)!=0{result=3}}
if (obs as i64)>0{if sys_munmap(obs as *u8,CD_FILE_BYTES)!=0{result=3}}
return result
930}
931func wfj_join(raw:*u8,table:*i64,count:i64,from:i64,to:i64,digest:*u8,bindings:*u8,n:i64,stats:*i64,usage:*i64)->i64 {
var i:i64=0;while i<WFJ_STATS{stats[i]=0;i=i+1};i=0;while i<30{usage[i]=0;i=i+1}
if count<0||count>CH_AH_MAXPATHS||n<0||cd_hash_valid(digest)==0{return 2}
let seen:*i64=sys_mmap_shared((count+1)*8) as *i64
let f:*i64=sys_mmap_shared(WFJ_COLS*2*8) as *i64
let prior:*i64=sys_mmap_shared(WFJ_COLS*2*8) as *i64
if (seen as i64)<=0||(f as i64)<=0||(prior as i64)<=0{
if (seen as i64)>0{sys_munmap(seen as *u8,(count+1)*8)}
if (f as i64)>0{sys_munmap(f as *u8,WFJ_COLS*2*8)}
if (prior as i64)>0{sys_munmap(prior as *u8,WFJ_COLS*2*8)};return 3
}
var rc:i64=0;var pos:i64=0
// Validate all rows and duplicate IDs before consuming evidence; no partial pass.
while pos<n&&rc==0{
let end:i64=sj_le(bindings,pos,n)
if end==n||wfj_fields(bindings,pos,end,f)!=0{rc=2;break}
if wfj_validate(bindings,f)!=0{rc=2;break}
var p:i64=0
while p<pos{
 let pe:i64=sj_le(bindings,p,n);wfj_fields(bindings,p,pe,prior)
 if wfj_span_eq(bindings,f[0],f[1],bindings,prior[0],prior[1])==1{rc=2;break};p=pe+1
}
stats[3]=stats[3]+1;pos=end+1
}
pos=0
while pos<n&&rc==0{
let end:i64=sj_le(bindings,pos,n);wfj_fields(bindings,pos,end,f)
if wfj_span_eq(bindings,f[2],f[3],digest,0,CD_HASH_CHARS)==0{stats[4]=stats[4]+1}else{
 var matched_index:i64=-1;i=0
 while i<count{
  let r:*i64=(table as i64+i*CHU_ROW*8) as *i64
  if wfj_span_eq(bindings,f[4],f[5],raw,r[4],r[5])==1&&wfj_span_eq(bindings,f[6],f[7],raw,r[6],r[7])==1{matched_index=i;break};i=i+1
 }
 if matched_index<0{stats[5]=stats[5]+1}else{
  if seen[matched_index]!=0{rc=2;break};seen[matched_index]=1
  let r:*i64=(table as i64+matched_index*CHU_ROW*8) as *i64
  if r[20]>=from&&r[20]<to{
   stats[1]=stats[1]+1;let role:i64=wfj_role(bindings,f);stats[20+role]=stats[20+role]+1;var k:i64=0
   var phase:i64=19;if wfj_lit(bindings,f,10,"work")==1{phase=16};if wfj_lit(bindings,f,10,"retry")==1{phase=17};if wfj_lit(bindings,f,10,"review")==1{phase=18};stats[phase]=stats[phase]+1
   while k<6{if usage[role*6+k]>CHU_SAFE-r[14+k]{rc=2;break};usage[role*6+k]=usage[role*6+k]+r[14+k];k=k+1}
   if role==4{stats[15]=stats[15]+1}
   if wfj_lit(bindings,f,11,"-")==1{stats[13]=stats[13]+1}else{
    let elapsed:i64=chu_uint(bindings,f[22],f[23]);if stats[14]>CHU_SAFE-elapsed{rc=2;break}
    stats[12]=stats[12]+1;stats[14]=stats[14]+elapsed
   }
   let evidence:i64=wfj_evidence(bindings,f)
   if evidence==1{stats[6]=stats[6]+1};if evidence==2{stats[7]=stats[7]+1};if evidence==3{stats[8]=stats[8]+1};if evidence==4{stats[9]=stats[9]+1}
   if wfj_lit(bindings,f,14,"accepted-deployed")==1{stats[10]=stats[10]+1;if evidence==1{stats[11]=stats[11]+1}}
  }
 }
};pos=end+1
}
i=0
while i<count&&rc==0{
let r:*i64=(table as i64+i*CHU_ROW*8) as *i64
if r[20]>=from&&r[20]<to{
 stats[0]=stats[0]+1
 if seen[i]==0{
  stats[2]=stats[2]+1;stats[13]=stats[13]+1;stats[15]=stats[15]+1;stats[19]=stats[19]+1;stats[24]=stats[24]+1
  var k:i64=0;while k<6{if usage[24+k]>CHU_SAFE-r[14+k]{rc=2;break};usage[24+k]=usage[24+k]+r[14+k];k=k+1}
 }
};i=i+1
}
if sys_munmap(seen as *u8,(count+1)*8)!=0{rc=3}
if sys_munmap(f as *u8,WFJ_COLS*2*8)!=0{rc=3}
if sys_munmap(prior as *u8,WFJ_COLS*2*8)!=0{rc=3}
return rc
998}
999
1000// Reads one exact file extent. Existing CH_WIN governs request-window admission;
1001// no total history is loaded. Callers own and release the returned mapping.
1002func wfj_read(path:*u8,limit:i64,result:*i64)->*u8 {
result[0]=0;result[1]=0
let r:*NxFileReadRegion=sys_mmap_shared(CD_REGION_BYTES) as *NxFileReadRegion
if (r as i64)<=0{result[1]=3;return 0 as *u8}
fio_region_init(r);var rc:i64=fio_region_open(path,r);var out:*u8=0 as *u8
if rc==0{
if r.total<0||r.total>=CD_I64_MAX||limit>0&&r.total>limit{rc=2}else{
 result[0]=r.total;out=sys_mmap_shared(r.total+1)
 if (out as i64)<=0{rc=3}else{
  if r.total>0{if fio_region_next(r,out,r.total)!=r.total{rc=3}}
  if rc==0{out[r.total]=0}
 }
}
}
if fio_region_close(r)!=0{rc=3};if sys_munmap(r as *u8,CD_REGION_BYTES)!=0{rc=3}
if rc!=0{if (out as i64)>0{sys_munmap(out,result[0]+1)};out=0 as *u8}
result[1]=rc;return out
1019}
1020func wfj_digest(raw:*u8,n:i64,hex:*u8)->i64 {
let b:*u8=sys_mmap_shared(SHA256_DIGEST_BYTES);if (b as i64)<=0{return 3}
var rc:i64=sha256_digest_checked_native(raw,n,b)
if rc==0{let digits:*u8="0123456789abcdef";var i:i64=0;while i<SHA256_DIGEST_BYTES{let x:i64=b[i] as i64;hex[i*2]=digits[x/16];hex[i*2+1]=digits[x%16];i=i+1};hex[CD_HASH_CHARS]=0}
if sys_munmap(b,SHA256_DIGEST_BYTES)!=0{rc=3};return rc
1025}
1026
1027import "nx_store_seed_lib.nx"
1028// Current declared rows only. The retained handle supplies a physical key-table
1029// bound; stale generations beyond q:n are not resurrected as current bindings.
1030// meta: decoded bytes,status,declared rows,observed rows,allocated bytes.
1031func wfj_plane_range(prefix:*u8,cols:i64,extra:i64,meta:*i64)->*u8 {
var z:i64=0;while z<5{meta[z]=0;z=z+1}
let h:*i64=ss_open_incr(prefix,1,0 as *i64)
if (h as i64)==0{meta[1]=3;return 0 as *u8}
let pr:*i64=sys_mmap_shared(16) as *i64;let ln:*i64=sys_mmap_shared(16) as *i64
let inv:*i64=sys_mmap_shared(32) as *i64;let key:*u8=sys_mmap_shared(STS_KEYCAP)
var rc:i64=0;var result:*u8=0 as *u8;var cap:i64=1
if (pr as i64)<=0||(ln as i64)<=0||(inv as i64)<=0||(key as i64)<=0{rc=3}
if rc==0{
if ss_hget(h,"q:n",pr,ln)!=1{rc=3}else{
 let count:i64=chu_uint(pr[0] as *u8,0,ln[0]);meta[2]=count
 if count<0||ss_open_table(h,inv)!=1{rc=3}else{if count>inv[3]{rc=3}}
}
}
var i:i64=0
while rc==0&&i<meta[2]{
sts_rowkey(i,key)
if ss_hget(h,key,pr,ln)!=1{rc=3;break}
if ln[0]<0||ln[0]>CD_I64_MAX-(cols+extra)*RTV_NUMBUF-1-cap{rc=3;break}
cap=cap+ln[0]+(cols+extra)*RTV_NUMBUF+1;i=i+1
}
if rc==0{result=sys_mmap_shared(cap);if (result as i64)<=0{rc=3}else{meta[4]=cap}}
i=0;var o:i64=0
while rc==0&&i<meta[2]{
sts_rowkey(i,key)
if ss_hget(h,key,pr,ln)!=1{rc=3;break}
let src:*u8=pr[0] as *u8;let n:i64=ln[0];var rown:i64=n
if n>=STS_NXR_HDR&&src[0]==(78 as u8)&&src[1]==(88 as u8)&&src[2]==(82 as u8)&&src[3]==(49 as u8){
 let actual_cols:i64=nxr_count(src)
 if actual_cols!=cols&&actual_cols!=cols+extra{rc=2;break}
 rown=rtv_to_tsv(src,n,actual_cols,(result as i64+o) as *u8,cap-o-2)
 if rown<0{rc=2;break}
}else{
 if n>cap-o-1{rc=3;break};var j:i64=0;while j<n{result[o+j]=src[j];j=j+1}
}
o=o+rown;result[o]=10 as u8;o=o+1;meta[3]=meta[3]+1;i=i+1
}
if rc==0{result[o]=0;meta[0]=o}
ss_close(h)
if (pr as i64)>0{if sys_munmap(pr as *u8,16)!=0{rc=3}}
if (ln as i64)>0{if sys_munmap(ln as *u8,16)!=0{rc=3}}
if (inv as i64)>0{if sys_munmap(inv as *u8,32)!=0{rc=3}}
if (key as i64)>0{if sys_munmap(key,STS_KEYCAP)!=0{rc=3}}
if rc!=0{if (result as i64)>0{sys_munmap(result,cap)};result=0 as *u8}
meta[1]=rc;return result
1076}
1077
1078func wfj_plane(prefix:*u8,cols:i64,meta:*i64)->*u8{return wfj_plane_range(prefix,cols,0,meta)}
1079
1080// Caller-selected immutable evidence artifact; existing files are never overwritten.
1081// Exact decoded bytes are retained, not a later reread of the mutable plane.
1082func wfj_retain_bindings(path:*u8,rows:*u8,n:i64)->i64 {
if cd_len(path)<1||cd_len(path)>CH_AH_PATHCELL{return 2}
let out:*NxFileWriteResult=sys_mmap_shared(__size_of(NxFileWriteResult)) as *NxFileWriteResult
if (out as i64)<=0{return 3}
var rc:i64=0
let fd:i64=sys_openat_exclusive(path,CHU_SNAPSHOT_MODE)
if fd<0{rc=fd}else{
rc=fio_write_sync_fd(fd,rows,n,out)
if rc==0{rc=fio_sync_parent(path,out)}
}
if sys_munmap(out as *u8,__size_of(NxFileWriteResult))!=0&&rc==0{rc=3}
return rc
1094}
1095
1096func wfj_null(j:*JsonWriter,key:*u8)->i64 {let rc:i64=json_emit_key(j,key,cd_len(key));return rc|json_emit_null(j)}
1097func wfj_report(stage:*u8,code:i64,digest:*u8,from:i64,to:i64,plane:*u8,pm:*i64,s:*i64,u:*i64,c:*i64,config_id:*u8,config_sha:*u8,binding_sha:*u8,snapshot:*u8,snapshot_rc:i64,upstream:*u8)->i64 {
let b:*u8=sys_mmap_shared(CH_OUT);let j:*JsonWriter=sys_mmap_shared(CD_WRITER_BYTES) as *JsonWriter
let prior:*u8=sys_mmap_shared(JE_MAX_DEPTH);var rc:i64=0
if (b as i64)<=0||(j as i64)<=0||(prior as i64)<=0{rc=3}else{
j.buf=b;j.pos=0;j.cap=CH_OUT;j.depth=0;j.prior=prior
rc=json_begin_object(j);rc=rc|cd_pair(j,"schema","nishi.workflow-request-attribution.v1")
var state:*u8="PARTIAL_OBSERVATION";if code!=0{state="REFUSED"}
rc=rc|cd_pair(j,"state",state);rc=rc|cd_pair(j,"stage",stage);rc=rc|cd_num(j,"code",code)
rc=rc|cd_num(j,"observed_unix",sys_now_realtime_sec());rc=rc|cd_pair(j,"scan_sha256",digest)
if code==0&&(upstream as i64)>0&&upstream[0]!=(0 as u8){rc=rc|cd_pair(j,"input_format","nishi.context-request-artifact.v1");rc=rc|cd_pair(j,"upstream_scan_sha256",upstream)}else{rc=rc|wfj_null(j,"upstream_scan_sha256");if code==0{rc=rc|cd_pair(j,"input_format","token_usage_record")}else{rc=rc|wfj_null(j,"input_format")}}
rc=rc|cd_pair(j,"binding_identity_scope","scan_sha256 identifies original supplied bytes; upstream identity is declared linkage, not independently fetched provenance")
if (binding_sha as i64)>0&&binding_sha[0]!=(0 as u8){rc=rc|cd_pair(j,"binding_snapshot_sha256",binding_sha)}else{rc=rc|wfj_null(j,"binding_snapshot_sha256")}
if (snapshot as i64)>0{
 rc=rc|cd_pair(j,"binding_snapshot_path",snapshot)
 if snapshot_rc==1{rc=rc|wfj_null(j,"binding_snapshot_retention_code")}else{rc=rc|cd_num(j,"binding_snapshot_retention_code",snapshot_rc)}
 var retention:*u8="failed";if snapshot_rc==1{retention="not-attempted"};if snapshot_rc==0{retention="retained-exclusive-file-and-directory-synced"};rc=rc|cd_pair(j,"binding_snapshot_retention",retention)
}else{rc=rc|wfj_null(j,"binding_snapshot_path");rc=rc|wfj_null(j,"binding_snapshot_retention_code");rc=rc|cd_pair(j,"binding_snapshot_retention","not-requested; reconstruction unavailable unless exact inputs are retained elsewhere")}
if code==0{
 if (config_id as i64)>0{rc=rc|cd_pair(j,"configuration_id",config_id);rc=rc|cd_pair(j,"configuration_snapshot_sha256",config_sha)}else{rc=rc|wfj_null(j,"configuration_id");rc=rc|wfj_null(j,"configuration_snapshot_sha256")}
 rc=rc|cd_num(j,"start_inclusive_epoch",from);rc=rc|cd_num(j,"end_exclusive_epoch",to)
 rc=rc|cd_pair(j,"binding_plane",plane);rc=rc|cd_num(j,"declared_binding_rows",pm[2]);rc=rc|cd_num(j,"observed_binding_rows",pm[3])
 var binding_scope:*u8="selected current declared rows; stale generations and full estate coverage unknown"
 if cd_equal(plane,"-")==1{binding_scope="caller-selected no bindings; zero-byte snapshot; not proof of estate-wide absence"}
 rc=rc|cd_pair(j,"binding_scope",binding_scope)
 rc=rc|cd_num(j,"eligible_requests",s[0]);rc=rc|cd_num(j,"bound_requests",s[1]);rc=rc|cd_num(j,"unbound_requests",s[2])
 rc=rc|cd_num(j,"other_snapshot_bindings",s[4]);rc=rc|cd_num(j,"unmatched_request_bindings",s[5])
 rc=rc|cd_num(j,"requests_with_retained_evidence_identity",s[6]);rc=rc|cd_num(j,"requests_with_missing_evidence",s[7])
 rc=rc|cd_num(j,"requests_with_unreadable_evidence",s[8]);rc=rc|cd_num(j,"requests_with_changed_evidence",s[9])
 rc=rc|cd_num(j,"reviewer_asserted_accepted_requests",s[10]);rc=rc|cd_num(j,"asserted_accepted_requests_with_retained_evidence",s[11])
 rc=rc|cd_num(j,"request_elapsed_known",s[12]);rc=rc|cd_num(j,"request_elapsed_unknown",s[13]);rc=rc|cd_num(j,"request_elapsed_ms_sum",s[14])
 rc=rc|cd_pair(j,"elapsed_semantics","per-request declared duration sum; concurrency prevents treating it as workflow wall time")
 rc=rc|cd_num(j,"role_unknown_requests",s[15])
 rc=rc|cd_num(j,"asserted_work_requests",s[16]);rc=rc|cd_num(j,"asserted_retry_requests",s[17]);rc=rc|cd_num(j,"asserted_review_requests",s[18]);rc=rc|cd_num(j,"phase_unknown_requests",s[19])
 rc=rc|json_emit_key(j,"usage_by_asserted_role",22);rc=rc|json_begin_array(j)
 var role:i64=0
 while role<5{
  var label:*u8="unknown";if role==0{label="root"};if role==1{label="dispatcher"};if role==2{label="provider"};if role==3{label="reviewer"}
  rc=rc|json_begin_object(j);rc=rc|cd_pair(j,"role",label)
  rc=rc|cd_num(j,"assigned_requests",s[20+role]);rc=rc|cd_pair(j,"counter_scope","known assigned subtotal only; zero is not total role cost");rc=rc|wfj_null(j,"unattributed_remainder")
  rc=rc|cd_num(j,"input_tokens",u[role*6]);rc=rc|cd_num(j,"cached_input_tokens",u[role*6+1]);rc=rc|cd_num(j,"cache_write_input_tokens",u[role*6+2])
  rc=rc|cd_num(j,"output_tokens",u[role*6+3]);rc=rc|cd_num(j,"reasoning_output_tokens",u[role*6+4]);rc=rc|cd_num(j,"total_tokens",u[role*6+5])
  rc=rc|json_end_object(j);role=role+1
 }
 rc=rc|json_end_array(j)
 rc=rc|cd_pair(j,"usage_semantics","canonical normalized input includes cached input; reasoning is subset of output; no double-addition or provider billing inference")
 rc=rc|cd_pair(j,"attribution_authority","explicit binding rows are assertions; matching evidence hash proves retained bytes only")
 rc=rc|wfj_null(j,"verified_accepted_deployed_outcomes");rc=rc|wfj_null(j,"provider_identity_verified")
 rc=rc|wfj_null(j,"workflow_wall_elapsed_ms");rc=rc|wfj_null(j,"billed_spend");rc=rc|wfj_null(j,"quality_adjusted_savings");rc=rc|wfj_null(j,"estate_coverage")
 rc=rc|cd_pair(j,"next_action","resolve unbound requests and missing or changed evidence; adjudicate typed deployment acceptance before ROI comparison")
}
rc=rc|json_end_object(j)
if rc==0{rc=chu_write_all(1,b,j.pos);if rc==0{rc=chu_write_all(1,"\n",1)}}
}
if (b as i64)>0{if sys_munmap(b,CH_OUT)!=0{rc=3}}
if (j as i64)>0{if sys_munmap(j as *u8,CD_WRITER_BYTES)!=0{rc=3}}
if (prior as i64)>0{if sys_munmap(prior,JE_MAX_DEPTH)!=0{rc=3}}
if rc!=0{return 3};return code
1154}
1155func wfj_command_context(argc:i64,argv:*i64,config_id:*u8,config_sha:*u8)->i64 {
if argc<7||argc>8{gv_puts("evaluate <usage-jsonl> <expected-snapshot-sha256> <from-inclusive> <to-exclusive> <binding-plane|-> [exclusive-binding-snapshot]\n");return 2}
let path:*u8=argv[2] as *u8;let digest:*u8=argv[3] as *u8;let a:*u8=argv[4] as *u8;let b:*u8=argv[5] as *u8;let plane:*u8=argv[6] as *u8
var snapshot:*u8=0 as *u8;if argc==8{snapshot=argv[7] as *u8}
let from:i64=chu_uint(a,0,cd_len(a));let to:i64=chu_uint(b,0,cd_len(b))
if from<0||to<=from||cd_hash_valid(digest)==0{return 2}
let rm:*i64=sys_mmap_shared(16) as *i64;let pm:*i64=sys_mmap_shared(40) as *i64
let c:*i64=sys_mmap_shared(80) as *i64;let s:*i64=sys_mmap_shared(WFJ_STATS*8) as *i64;let u:*i64=sys_mmap_shared(30*8) as *i64
let table:*i64=sys_mmap_shared(CH_AH_MAXPATHS*CHU_ROW*8) as *i64;let row:*i64=sys_mmap_shared(CHU_ROW*8) as *i64
let binding_sha:*u8=sys_mmap_shared(CD_HASH_CHARS+1);var snapshot_rc:i64=1
let upstream:*u8=sys_mmap_shared(CD_HASH_CHARS+1)
let hex:*u8=sys_mmap_shared(CD_HASH_CHARS+1);var raw:*u8=0 as *u8;var bindings:*u8=0 as *u8;var t:*NxJsonTok=0 as *NxJsonTok
var rc:i64=0;var stage:*u8="allocation"
if (rm as i64)<=0||(pm as i64)<=0||(c as i64)<=0||(s as i64)<=0||(u as i64)<=0||(table as i64)<=0||(row as i64)<=0||(hex as i64)<=0||(binding_sha as i64)<=0||(upstream as i64)<=0{rc=3}
if rc==0{stage="request-read";raw=wfj_read(path,CH_WIN,rm);if (raw as i64)<=0{rc=3}}
if rc==0{stage="request-identity";if wfj_digest(raw,rm[0],hex)!=0||cd_equal(hex,digest)!=1{rc=3}}
if rc==0{stage="request-reconciliation";t=nx_json_new(raw,rm[0]);if (t as i64)<=0{rc=3}else{rc=chu_artifact_totals(raw,rm[0],from,to,table,t,row,c,upstream)}}
if rc==0{
stage="binding-plane"
if cd_equal(plane,"-")==1{bindings=""}else{bindings=wfj_plane(plane,WFJ_COLS,pm);if (bindings as i64)<=0{rc=3}}
}
if rc==0{stage="binding-identity";rc=wfj_digest(bindings,pm[0],binding_sha)}
if rc==0{stage="attribution-join";rc=wfj_join(raw,table,c[0],from,to,digest,bindings,pm[0],s,u)}
if rc==0&&(snapshot as i64)>0{stage="binding-snapshot-retention";snapshot_rc=wfj_retain_bindings(snapshot,bindings,pm[0]);if snapshot_rc!=0{rc=3}}
if rc==0{stage="complete"}
let output:i64=wfj_report(stage,rc,digest,from,to,plane,pm,s,u,c,config_id,config_sha,binding_sha,snapshot,snapshot_rc,upstream)
if (raw as i64)>0{if sys_munmap(raw,rm[0]+1)!=0{rc=3}}
if (bindings as i64)>0&&cd_equal(plane,"-")!=1{if sys_munmap(bindings,pm[4])!=0{rc=3}}
if (t as i64)>0{if sys_munmap(t as *u8,NX_JSONTOK_BYTES)!=0{rc=3}}
if (rm as i64)>0{if sys_munmap(rm as *u8,16)!=0{rc=3}};if (pm as i64)>0{if sys_munmap(pm as *u8,40)!=0{rc=3}}
if (c as i64)>0{if sys_munmap(c as *u8,80)!=0{rc=3}};if (s as i64)>0{if sys_munmap(s as *u8,WFJ_STATS*8)!=0{rc=3}}
if (u as i64)>0{if sys_munmap(u as *u8,30*8)!=0{rc=3}};if (table as i64)>0{if sys_munmap(table as *u8,CH_AH_MAXPATHS*CHU_ROW*8)!=0{rc=3}}
if (row as i64)>0{if sys_munmap(row as *u8,CHU_ROW*8)!=0{rc=3}};if (hex as i64)>0{if sys_munmap(hex,CD_HASH_CHARS+1)!=0{rc=3}}
if (binding_sha as i64)>0{if sys_munmap(binding_sha,CD_HASH_CHARS+1)!=0{rc=3}}
if (upstream as i64)>0{if sys_munmap(upstream,CD_HASH_CHARS+1)!=0{rc=3}}
if output!=0{return output};return rc
1191}
1192
1193func wfj_command(argc:i64,argv:*i64)->i64{return wfj_command_context(argc,argv,0 as *u8,0 as *u8)}
1194
1195// Existing sovereign plane, seven columns: id,raw_path,expected_raw_sha256,
1196// from_inclusive,to_exclusive,binding_plane,enabled|paused; optional eighth
1197// column selects an exclusive decoded-binding snapshot path. No provider call.
1198const WFJ_CONFIG_COLS:i64=7
1199const WFJ_CONFIG_PREFIX:*u8="knowledge/store/wfcost-evaluations-"
1200func wfj_config_command(argc:i64,argv:*i64)->i64 {
if argc<3||argc>4{gv_puts("evaluate-config <id> [configuration-plane]\n");return 2}
let id:*u8=argv[2] as *u8;var prefix:*u8=WFJ_CONFIG_PREFIX;if argc==4{prefix=argv[3] as *u8}
let pm:*i64=sys_mmap_shared(40) as *i64;let f:*i64=sys_mmap_shared((WFJ_CONFIG_COLS+1)*2*8) as *i64
let selected:*i64=sys_mmap_shared((WFJ_CONFIG_COLS+1)*2*8) as *i64;let digest:*u8=sys_mmap_shared(CD_HASH_CHARS+1)
let args:*i64=sys_mmap_shared(9*8) as *i64;var rows:*u8=0 as *u8;var rc:i64=0
if (pm as i64)<=0||(f as i64)<=0||(selected as i64)<=0||(digest as i64)<=0||(args as i64)<=0{rc=3}
if rc==0{rows=wfj_plane_range(prefix,WFJ_CONFIG_COLS,1,pm);if (rows as i64)<=0{rc=3}}
var found:i64=0;var pos:i64=0;var selected_cols:i64=0
while rc==0&&pos<pm[0]{
let end:i64=sj_le(rows,pos,pm[0]);if end==pm[0]{rc=2;break}
var cols:i64=WFJ_CONFIG_COLS
if wfj_fields_n(rows,pos,end,f,cols)!=0{cols=cols+1;if wfj_fields_n(rows,pos,end,f,cols)!=0{rc=2;break}}
if wfj_span_eq(rows,f[0],f[1],id,0,cd_len(id))==1{
 found=found+1;if found>1{rc=2;break};selected_cols=cols;var k:i64=0;while k<cols*2{selected[k]=f[k];k=k+1}
};pos=end+1
}
if rc==0&&found!=1{rc=3}
if rc==0{
if wfj_lit(rows,selected,6,"enabled")!=1{rc=4}
if wfj_hash(rows,selected,2)!=1{rc=2}
}
if rc==0{
rc=wfj_digest(rows,pm[0],digest)
if rc==0{
 args[0]="nx_wfcost" as *u8 as i64;args[1]="evaluate" as *u8 as i64
 var k:i64=1;while k<=5{let start:i64=selected[k*2];let n:i64=selected[k*2+1];rows[start+n]=0;args[k+1]=(rows as i64+start);k=k+1};args[7]=0
 var ac:i64=7
 if selected_cols==WFJ_CONFIG_COLS+1{let start:i64=selected[14];let n:i64=selected[15];rows[start+n]=0;args[7]=rows as i64+start;args[8]=0;ac=8}
 rc=wfj_command_context(ac,args,id,digest)
}
}else{gv_puts("WF-EVALUATE-CONFIG refused: missing, malformed, duplicate or paused configuration; no evaluation ran\n")}
if (rows as i64)>0{if sys_munmap(rows,pm[4])!=0{rc=3}}
if (pm as i64)>0{if sys_munmap(pm as *u8,40)!=0{rc=3}};if (f as i64)>0{if sys_munmap(f as *u8,(WFJ_CONFIG_COLS+1)*2*8)!=0{rc=3}}
if (selected as i64)>0{if sys_munmap(selected as *u8,(WFJ_CONFIG_COLS+1)*2*8)!=0{rc=3}}
if (digest as i64)>0{if sys_munmap(digest,CD_HASH_CHARS+1)!=0{rc=3}};if (args as i64)>0{if sys_munmap(args as *u8,9*8)!=0{rc=3}}
return rc
1237}
nx_wfcost_artifact_t173.nx source

`nx_wfcost_artifact_t173.nx` source
