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

↩ module page · 3762 lines · 183343 B
1// nx_claude_harvest.nx -- CLAUDE TRANSCRIPT HARVESTER + OUTSIDE-GAUGE (miner-sota lane F964/F973, 2026-07-23).
2// PORTABLE organ (gen-image pattern: runs where the transcripts live -- laptop WSL today, NAS, any host):
3// parses Claude Code transcript JSONL into sovereign actlog frames, bulk-ingests staged frames into a
4// journal (validated, marker-idempotent), and derives the outside_permil gauge (nishi vs outside tool
5// split) that MUST FALL as capabilities move inside (MG00 baseline 651, 2026-07-23).
6// Composes nx_sovjson_lib (sj_*) -- no helper dup (D001 discipline). State derived; journals append-only
7// (O_APPEND, conflict-free, ws_sync lineage). No hw writes (Rule 26).
8//   frames <transcript.jsonl> <ws> <outjournal>  -> parse transcript, append actlog frames; HARVEST OK
9//   ingest <framesfile> <journal>                -> validated bulk append, idempotent by marker frame
10//   gauge  <journal> [days]                      -> JSON outside_permil (0 days = all frames)
11//   beat <chbeat.conf>                           -> DM1 session->NAS capture beat (devmgmt rung, 2026-08-20):
12//                                                   walk EVERY transcript under root (all depths, getdents
13//                                                   looped until 0), ch_delta each against a per-transcript
14//                                                   byte HWM, split the fresh frames into ts-day PIECES sized
15//                                                   under the MCP body cliff, ingest each piece (ch_ingest,
16//                                                   marker-idempotent) into per-day journals -- the local twin
17//                                                   always, the NAS landing via the forked wire when push=1.
18//                                                   Pieces are the chunk unit AND the ingest unit, so the
19//                                                   pipeline is resumable at every stage with no append
20//                                                   primitive over the wire. Counters partition and SUM;
21//                                                   unknown head-types bucket UNKNOWN with a named worklist.
22//   selftest <scratch-prefix>                    -> gate T1..T8 + beat teeth (unique per-run scratch names)
23// SSOT for this source is buildroot/runtime/_hdl_build/ on the NAS; the laptop nxc2 tree is a build twin
24// (synced per edit, video-lane pattern) because the beat RUNS WHERE THE TRANSCRIPTS LIVE (laptop WSL).
25// license_tier: ORIGINAL
26import "nx_sovjson_lib.nx"
27import "nx_json.nx"
28import "nx_sha256.nx"
29import "nx_syscalls.nx"
30import "nx_gate_verdict.nx"
31import "nx_tool_run.nx"
32import "nx_mccabe_lib.nx"
33const CH_MAGIC_146097: i64 = 146097
34const CH_MAGIC_719468: i64 = 719468
35const CH_MAGIC_86400: i64 = 86400
36const CH_MAGIC_3600: i64 = 3600
37const CH_MAGIC_1784764900: i64 = 1784764900
38const CH_MAGIC_1784764901: i64 = 1784764901
39const CH_MAGIC_1784764803: i64 = 1784764803
40
41const CH_WIN: i64 = 67108864
42const CH_JWIN: i64 = 4194304
43const CH_OUT: i64 = 65536
44const CH_LINE: i64 = 4096
45const CH_NAME_MAX: i64 = 120
46const CH_NAME_SCAN: i64 = 400
47const CH_MODE_644: i64 = 420
48// ---- CE1 leg 2 (ce_author_health) consts: declared here, above the selftest that reads them (single-pass parser) ----
49const CH_AH_MAXPATHS: i64 = 8192
50const CH_AH_PATHCELL: i64 = 512
51const CH_AH_MAXSESS: i64 = 1024
52const CH_AH_SESSCELL: i64 = 64
53const CH_AH_CTRS: i64 = 32
54const CH_AH_SPINE: *u8 = "knowledge/status/mccabe.spine"
55const CH_AH_STATUS: *u8 = "knowledge/status/author_health.status"
56const CH_AH_TREE: *u8 = "buildroot/runtime/"
57const CH_AH_RC_UNOBS: i64 = 3
58const CH_AH_RC_NOPATH: i64 = 4
59const CH_AH_FRAMES: i64 = 0
60const CH_AH_PATHFRAMES: i64 = 1
61const CH_AH_UNIQUE: i64 = 2
62const CH_AH_INTREE: i64 = 3
63const CH_AH_OUTSIDE: i64 = 4
64const CH_AH_FIRSTTS: i64 = 5
65const CH_AH_SESSIONS: i64 = 6
66const CH_AH_FILES: i64 = 7
67const CH_AH_FUNCS: i64 = 8
68const CH_AH_SUMVG: i64 = 9
69const CH_AH_ABOVE: i64 = 10
70const CH_AH_DFILES: i64 = 11
71const CH_AH_DFUNCS: i64 = 12
72const CH_AH_DABOVE: i64 = 13
73const CH_AH_DTS: i64 = 14
74const CH_AH_UNREAD: i64 = 15
75const CH_AH_OVERFLOW: i64 = 16
76const CH_AH_FIX_TS: i64 = 1788600000
77const CH_AH_FIX_DFILES: i64 = 10
78const CH_AH_FIX_DFUNCS: i64 = 20
79const CH_AH_FIX_DABOVE: i64 = 3
80const CH_CH_D0: i64 = 48
81const CH_CH_D9: i64 = 57
82const CH_DEC: i64 = 10
83// ---- beat consts (DM1 ch_beat; declared here because the module parser is single-pass and the
84//      selftest teeth read them before the beat section) -- each names its derivation ----
85const CH_BT_DIRWIN: i64 = 65536       // getdents64 batch buffer -- LOOPED until 0, never a listing cap
86const CH_BT_PATHMAX: i64 = 512        // one path cell; longest real transcript path measured ~120 B, 4x headroom
87const CH_BT_MAXFILES: i64 = 16384     // walk table capacity (837 files measured 2026-08-20); hitting it REFUSES loudly
88const CH_BT_MAXDIRS: i64 = 4096
89const CH_BT_ARENA: i64 = 8388608      // path arena = CH_BT_MAXFILES * CH_BT_PATHMAX exactly
90const CH_BT_TYPEMAX: i64 = 64         // distinct head-type slots; overflow announces FLOOR-NOT-TOTAL
91const CH_BT_DAYMAX: i64 = 128         // distinct ts-days per run (backfill spans ~60); overflow REFUSES loudly
92const CH_BT_DAYCELL: i64 = 16         // one day-name cell: YYYYMMDD (8) or tszero (6) + NUL, padded
93const CH_MCP_BODY_CLIFF: i64 = 65536  // measured: the MCP write body silently drops beyond ~64 KiB
94const CH_BT_CTRS: i64 = 32            // bcx slot count (map at ch_beat)
95const CH_MODE_755: i64 = 493          // rwxr-xr-x for the beat's own state/spool/journal dirs
96const CH_MAGIC_1460: i64 = 1460       // 4*365 (Hinnant civil-from-days)
97const CH_MAGIC_36524: i64 = 36524     // 100*365 + 24 (Hinnant)
98const CH_MAGIC_146096: i64 = 146096   // CH_MAGIC_146097 - 1 (Hinnant)
99
100func ch_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return -1 }
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 { let r: i64 = sys_read(fd, ((buf as i64)+n) as *u8, cap-n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap { go = 0 } }
  sys_close(fd)
  return n
108}
109// substring search in q[from..endlim) -> position or -1
110func ch_find_from(q: *u8, from: i64, endlim: i64, lit: *u8) -> i64 {
  var i: i64 = from
  while i < endlim {
      var k: i64 = 0
      var ok: i64 = 1
      var go: i64 = 1
      while go == 1 {
          if lit[k] == (0 as u8) { go = 0 } else {
              if i + k >= endlim { ok = 0; go = 0 } else {
                  if q[i+k] != lit[k] { ok = 0; go = 0 } else { k = k + 1 }
              }
          }
      }
      if ok == 1 { return i }
      i = i + 1
  }
  return -1
127}
128func ch_find(q: *u8, n: i64, lit: *u8) -> i64 {
  if ch_find_from(q, 0, n, lit) >= 0 { return 1 }
  return 0
131}
132// span q[s..e) begins with lit?
133func ch_starts(q: *u8, s: i64, e: i64, lit: *u8) -> i64 {
  var k: i64 = 0
  while lit[k] != (0 as u8) {
      if s + k >= e { return 0 }
      if q[s+k] != lit[k] { return 0 }
      k = k + 1
  }
  return 1
141}
142func ch_digits(q: *u8, s: i64, e: i64) -> i64 {
  if e <= s { return 0 }
  var i: i64 = s
  while i < e { let c: i64 = q[i] as i64; if c < 48 { return 0 } if c > 57 { return 0 } i = i + 1 }
  return 1
147}
148// civil date -> unix epoch (Hinnant days-from-civil, integer only; years >= 1970 here)
149func ch_epoch_ymdhms(y: i64, mo: i64, d: i64, h: i64, mi: i64, s: i64) -> i64 {
  var yy: i64 = y
  var mp: i64 = 0
  if mo > 2 { mp = mo - 3 } else { mp = mo + 9; yy = yy - 1 }
  let era: i64 = yy / 400
  let yoe: i64 = yy - era * 400
  let doy: i64 = (153 * mp + 2) / 5 + d - 1
  let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy
  let days: i64 = era * CH_MAGIC_146097 + doe - CH_MAGIC_719468
  return days * CH_MAGIC_86400 + h * CH_MAGIC_3600 + mi * 60 + s
159}
160// parse ISO "YYYY-MM-DDTHH:MM:SS" at q[s..] (lim-bounded) -> epoch, 0 if malformed
161func ch_iso_epoch(q: *u8, s: i64, lim: i64) -> i64 {
  if s + 19 > lim { return 0 }
  if ch_digits(q, s, s+4) == 0 { return 0 }
  if q[s+4] != (45 as u8) { return 0 }
  if ch_digits(q, s+5, s+7) == 0 { return 0 }
  if q[s+7] != (45 as u8) { return 0 }
  if ch_digits(q, s+8, s+10) == 0 { return 0 }
  if q[s+10] != (84 as u8) { return 0 }
  if ch_digits(q, s+11, s+13) == 0 { return 0 }
  if q[s+13] != (58 as u8) { return 0 }
  if ch_digits(q, s+14, s+16) == 0 { return 0 }
  if q[s+16] != (58 as u8) { return 0 }
  if ch_digits(q, s+17, s+19) == 0 { return 0 }
  let y: i64 = sj_atoi_span(q, s, s+4)
  let mo: i64 = sj_atoi_span(q, s+5, s+7)
  let d: i64 = sj_atoi_span(q, s+8, s+10)
  let h: i64 = sj_atoi_span(q, s+11, s+13)
  let mi: i64 = sj_atoi_span(q, s+14, s+16)
  let se: i64 = sj_atoi_span(q, s+17, s+19)
  if mo < 1 { return 0 }
  if mo > 12 { return 0 }
  if d < 1 { return 0 }
  if d > 31 { return 0 }
  return ch_epoch_ymdhms(y, mo, d, h, mi, se)
185}
186// write one actlog frame line to an open fd: <ts>TAB<ws>TAB<tool>TAB<verb>TAB<outcome>TAB<note>NL
187func ch_frame_write(fd: i64, ln: *u8, ts: i64, ws: *u8, tool: *u8, verb: *u8, outcome: *u8, note: *u8) -> i64 {
  var o: i64 = 0
  o = sj_catn(ln, o, ts)
  ln[o] = 9 as u8; o = o + 1
  o = sj_cat(ln, o, ws)
  ln[o] = 9 as u8; o = o + 1
  o = sj_cat(ln, o, tool)
  ln[o] = 9 as u8; o = o + 1
  o = sj_cat(ln, o, verb)
  ln[o] = 9 as u8; o = o + 1
  o = sj_cat(ln, o, outcome)
  ln[o] = 9 as u8; o = o + 1
  o = sj_cat(ln, o, note)
  ln[o] = 10 as u8; o = o + 1
  sys_write(fd, ln, o)
  return 0
203}
204func ch_frame_append(path: *u8, ts: i64, ws: *u8, tool: *u8, verb: *u8, outcome: *u8, note: *u8) -> i64 {
  let fd: i64 = sys_openat_append(path, CH_MODE_644)
  if fd < 0 { return -1 }
  let ln: *u8 = sys_mmap(CH_LINE)
  ch_frame_write(fd, ln, ts, ws, tool, verb, outcome, note)
  sys_close(fd)
  return 0
211}
212// ---------- CE1 leg 2 (codeeffectiveness, 2026-09-05): the PATH a write tool touched ----------
213// Every frame used to carry `tool use - <verb>` and nothing else, so WHICH FILE a seat wrote was not in the
214// NAS record at all (735 nx_fs_write frames on 2026-09-05, none with a path). The path lives in the tool_use's
215// own input: nx_fs_write carries it as argv[1] (argv[0] is the verb), Write and Edit as file_path. It is read
216// from a BOUNDED window after the tool's name (the input keys come before any content string, so the FIRST
217// match is the input's own key, never a content byte). ADDITIVE: the note gains one space-separated token
218// `path=<p>`; no column moves, every existing reader sees one more token. A non-writer frame is unchanged.
219const CH_PATH_SCAN: i64 = 4096   // one transcript line can carry the write's CONTENT before its path key; the frame line is CH_LINE anyway
220const CH_PATH_MAX: i64 = 512
221const CH_CH_BSL: i64 = 92
222const CH_WK_NONE: i64 = 0
223const CH_WK_ARGV: i64 = 1
224const CH_WK_FILEPATH: i64 = 2
225func ch_tool_writer_kind(nm: *u8) -> i64 {
  let nl: i64 = sj_vlen(nm)
  if sj_lit_eq(nm, 0, nl, "mcp__nishi__nx_fs_write" as *u8) == 1 { return CH_WK_ARGV }
  if sj_lit_eq(nm, 0, nl, "Write" as *u8) == 1 { return CH_WK_FILEPATH }
  if sj_lit_eq(nm, 0, nl, "Edit" as *u8) == 1 { return CH_WK_FILEPATH }
  return CH_WK_NONE
231}
232// copy a JSON string body that starts at k0 (just past the opening quote) up to its closing unescaped quote
233func ch_json_str_copy(buf: *u8, k0: i64, le: i64, pb: *u8, cap: i64) -> i64 {
  var k: i64 = k0
  var o: i64 = 0
  var g: i64 = 1
  while g == 1 {
      if k >= le { g = 0 } else {
          if buf[k] == (34 as u8) { g = 0 } else {
              if buf[k] == (CH_CH_BSL as u8) { k = k + 1 }
              if k < le { if o < cap { pb[o] = buf[k]; o = o + 1 } }
              k = k + 1
          }
      }
  }
  pb[o] = 0 as u8
  return o
248}
249// the path for a writer frame: np is the offset of the tool's name key, le the line end. 0 = no path.
250func ch_tool_path(buf: *u8, np: i64, le: i64, kind: i64, pb: *u8) -> i64 {
  pb[0] = 0 as u8
  if kind == CH_WK_NONE { return 0 }
  var scanend: i64 = np + CH_PATH_SCAN
  if scanend > le { scanend = le }
  if kind == CH_WK_ARGV {
      let akey: *u8 = "\"argv\":[\"" as *u8
      let ap: i64 = ch_find_from(buf, np, scanend, akey)
      if ap < 0 { return 0 }
      var k: i64 = ap + sj_vlen(akey)
      var g: i64 = 1
      while g == 1 { if k >= scanend { g = 0 } else { if buf[k] == (34 as u8) { g = 0 } else { if buf[k] == (CH_CH_BSL as u8) { k = k + 1 } k = k + 1 } } }
      let q2: i64 = ch_find_from(buf, k + 1, scanend, "\"" as *u8)
      if q2 < 0 { return 0 }
      return ch_json_str_copy(buf, q2 + 1, scanend, pb, CH_PATH_MAX)
  }
  let fkey: *u8 = "\"file_path\":\"" as *u8
  let fp: i64 = ch_find_from(buf, np, scanend, fkey)
  if fp < 0 { return 0 }
  return ch_json_str_copy(buf, fp + sj_vlen(fkey), scanend, pb, CH_PATH_MAX)
270}
271// the note for one frame: the verb literal, plus ` path=<p>` when the tool is a writer whose path was read
272func ch_frame_note(buf: *u8, np: i64, le: i64, nm: *u8, verb: *u8, pb: *u8, nb: *u8) -> *u8 {
  let wk: i64 = ch_tool_writer_kind(nm)
  if wk == CH_WK_NONE { return verb }
  if ch_tool_path(buf, np, le, wk, pb) <= 0 { return verb }
  var no: i64 = sj_cat(nb, 0, verb)
  no = sj_cat(nb, no, " path=" as *u8)
  no = sj_cat(nb, no, pb)
  nb[no] = 0 as u8
  return nb
281}
282// ---------- frames: transcript JSONL -> actlog frames ----------
283// returns frames harvested, -1 missing/empty transcript, -3 cannot open out journal.
284// tcx[0] receives truncated flag.
285func ch_frames(tpath: *u8, ws: *u8, outj: *u8, tcx: *i64) -> i64 {
  let buf: *u8 = sys_mmap(CH_WIN)
  let cap: i64 = CH_WIN - 8
  let n: i64 = ch_read(tpath, buf, cap)
  tcx[0] = 0
  if n <= 0 { return -1 }
  if n >= cap { tcx[0] = 1 }
  let fd: i64 = sys_openat_append(outj, CH_MODE_644)
  if fd < 0 { return -3 }
  let ln: *u8 = sys_mmap(CH_LINE)
  let nm: *u8 = sys_mmap(256)
  let pb: *u8 = sys_mmap(CH_PATH_MAX + 8)
  let nb: *u8 = sys_mmap(CH_PATH_MAX + 64)
  var frames: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(buf, i, n)
      var ts: i64 = 0
      let tp: i64 = ch_find_from(buf, i, le, "\"timestamp\":\"" as *u8)
      if tp >= 0 { ts = ch_iso_epoch(buf, tp + 13, le) }
      var j: i64 = i
      var go: i64 = 1
      while go == 1 {
          let tu: i64 = ch_find_from(buf, j, le, "\"type\":\"tool_use\"" as *u8)
          if tu < 0 { go = 0 } else {
              var scanend: i64 = tu + CH_NAME_SCAN
              if scanend > le { scanend = le }
              let np: i64 = ch_find_from(buf, tu, scanend, "\"name\":\"" as *u8)
              if np >= 0 {
                  var k: i64 = np + 8
                  var o: i64 = 0
                  var g2: i64 = 1
                  while g2 == 1 {
                      if k >= le { g2 = 0 } else {
                          if buf[k] == (34 as u8) { g2 = 0 } else {
                              if o < CH_NAME_MAX { nm[o] = buf[k]; o = o + 1 }
                              k = k + 1
                          }
                      }
                  }
                  nm[o] = 0 as u8
                  if o > 0 {
                      ch_frame_write(fd, ln, ts, ws, nm, "use" as *u8, "-" as *u8, ch_frame_note(buf, np, le, nm, "harvest" as *u8, pb, nb))
                      frames = frames + 1
                  }
              }
              j = tu + 17
          }
      }
      i = le + 1
  }
  sys_close(fd)
  return frames
338}
339// ---------- delta: HIGH-WATER-MARK harvest, the F973 self-sufficiency half ----------
340// The ongoing-harvest loop lived in a laptop PowerShell parser (MG03: Claude hand-writes miners).
341// This puts the byte-offset high-water mark INSIDE the organ, so the harvester is self-sufficient on
342// ANY host that holds transcripts: run the ELF, it consumes only what grew since last time.
343// EXACTLY-ONCE BY CONSTRUCTION: only COMPLETE lines are consumed (a partial trailing line stays below
344// the mark for the next run), and the mark advances only over what was actually parsed. A re-run on an
345// unchanged transcript yields 0 frames -- idempotent without needing a marker.
346// hcx[0]=frames hcx[1]=new_hwm hcx[2]=old_hwm hcx[3]=truncated
347func ch_hwm_read(path: *u8) -> i64 {
  let b: *u8 = sys_mmap(CH_LINE)
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  let r: i64 = sys_read(fd, b, CH_LINE - 8)
  sys_close(fd)
  if r <= 0 { return 0 }
  var v: i64 = 0
  var i: i64 = 0
  while i < r { let c: i64 = b[i] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } i = i + 1 }
  return v
358}
359func ch_hwm_write(path: *u8, v: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, CH_MODE_644)
  if fd < 0 { return -1 }
  let b: *u8 = sys_mmap(CH_LINE)
  var o: i64 = sj_catn(b, 0, v)
  b[o] = 10 as u8
  sys_write(fd, b, o + 1)
  sys_close(fd)
  return 0
368}
369func ch_delta(tpath: *u8, ws: *u8, outj: *u8, hwmpath: *u8, hcx: *i64) -> i64 {
  hcx[0] = 0
  hcx[1] = 0
  hcx[2] = 0
  hcx[3] = 0
  // read sized-by-file (2026-08-20): the old fixed CH_WIN window silently stopped harvesting past
  // 64 MiB (largest real transcript measured 55.8 MB the same day -- the cliff was DAYS away).
  // sys_map_file is read-only/zero-copy and every parse below is span-bounded, never NUL-reliant.
  // hcx[3] (truncated) is structurally 0 now; the slot stays for contract stability.
  let nn: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_map_file(tpath, nn)
  let n: i64 = nn[0]
  if n <= 0 { return -1 }
  var hwm: i64 = ch_hwm_read(hwmpath)
  if hwm < 0 { hwm = 0 }
  if hwm > n { hwm = 0 }
  hcx[2] = hwm
  hcx[1] = hwm
  if hwm >= n { sys_munmap(buf, n); return 0 }
  // consume only up to the LAST newline: a partial trailing line waits for the next run
  var lastnl: i64 = 0 - 1
  var z: i64 = n - 1
  while z >= hwm { if lastnl < 0 { if buf[z] == (10 as u8) { lastnl = z } } z = z - 1 }
  if lastnl < 0 { sys_munmap(buf, n); return 0 }
  let fd: i64 = sys_openat_append(outj, CH_MODE_644)
  if fd < 0 { sys_munmap(buf, n); return -3 }
  let ln: *u8 = sys_mmap(CH_LINE)
  let nm: *u8 = sys_mmap(256)
  let pb: *u8 = sys_mmap(CH_PATH_MAX + 8)
  let nb: *u8 = sys_mmap(CH_PATH_MAX + 64)
  var frames: i64 = 0
  var i: i64 = hwm
  while i <= lastnl {
      let le: i64 = sj_le(buf, i, lastnl + 1)
      var ts: i64 = 0
      let tp: i64 = ch_find_from(buf, i, le, "\"timestamp\":\"" as *u8)
      if tp >= 0 { ts = ch_iso_epoch(buf, tp + 13, le) }
      var j: i64 = i
      var go: i64 = 1
      while go == 1 {
          let tu: i64 = ch_find_from(buf, j, le, "\"type\":\"tool_use\"" as *u8)
          if tu < 0 { go = 0 } else {
              var scanend: i64 = tu + CH_NAME_SCAN
              if scanend > le { scanend = le }
              let np: i64 = ch_find_from(buf, tu, scanend, "\"name\":\"" as *u8)
              if np >= 0 {
                  var k: i64 = np + 8
                  var o: i64 = 0
                  var g2: i64 = 1
                  while g2 == 1 {
                      if k >= le { g2 = 0 } else {
                          if buf[k] == (34 as u8) { g2 = 0 } else {
                              if o < CH_NAME_MAX { nm[o] = buf[k]; o = o + 1 }
                              k = k + 1
                          }
                      }
                  }
                  nm[o] = 0 as u8
                  if o > 0 {
                      ch_frame_write(fd, ln, ts, ws, nm, "use" as *u8, "-" as *u8, ch_frame_note(buf, np, le, nm, "delta" as *u8, pb, nb))
                      frames = frames + 1
                  }
              }
              j = tu + 17
          }
      }
      i = le + 1
  }
  sys_close(fd)
  sys_munmap(buf, n)
  hcx[0] = frames
  hcx[1] = lastnl + 1
  ch_hwm_write(hwmpath, lastnl + 1)
  return 0
443}
444// ---------- ingest: validated bulk append of a staged frames file, marker-idempotent ----------
445// returns >=0 ingested count (mcx[0]=malformed), -1 missing frames file, -2 already ingested,
446// -4 cannot open journal. (-3 window-exceeded was RETIRED 2026-08-20: the marker-verify read is now
447// sized by the journal itself via sys_map_file, so idempotence is verifiable at any journal size.)
448func ch_ingest(fpath: *u8, jpath: *u8, mcx: *i64) -> i64 {
  mcx[0] = 0
  // marker = "harvest-ingest:" + basename(fpath)
  var bs: i64 = 0
  var i: i64 = 0
  while fpath[i] != (0 as u8) { if fpath[i] == (47 as u8) { bs = i + 1 } i = i + 1 }
  let marker: *u8 = sys_mmap(512)
  var mo: i64 = sj_cat(marker, 0, "harvest-ingest:" as *u8)
  mo = sj_cat(marker, mo, ((fpath as i64) + bs) as *u8)
  marker[mo] = 0 as u8
  let jnn: *i64 = sys_mmap(16) as *i64
  let jbuf: *u8 = sys_map_file(jpath, jnn)
  let jn: i64 = jnn[0]
  if jn > 0 {
      if ch_find(jbuf, jn, marker) == 1 { sys_munmap(jbuf, jn); return -2 }
      sys_munmap(jbuf, jn)
  }
  let fbuf: *u8 = sys_mmap(CH_WIN)
  let fcap: i64 = CH_WIN - 8
  let fn: i64 = ch_read(fpath, fbuf, fcap)
  if fn <= 0 { return -1 }
  let fd: i64 = sys_openat_append(jpath, CH_MODE_644)
  if fd < 0 { return -4 }
  let sp: *i64 = sys_mmap(16) as *i64
  let nl: *u8 = sys_mmap(8)
  nl[0] = 10 as u8
  var ing: i64 = 0
  var p: i64 = 0
  while p < fn {
      let le: i64 = sj_le(fbuf, p, fn)
      var ok: i64 = 0
      if le > p {
          if sj_col(fbuf, p, le, 5, sp) == 1 {
              if sj_col(fbuf, p, le, 6, sp) == 0 {
                  if sj_col(fbuf, p, le, 0, sp) == 1 {
                      if ch_digits(fbuf, sp[0], sp[1]) == 1 { ok = 1 }
                  }
              }
          }
      }
      if ok == 1 {
          sys_write(fd, ((fbuf as i64) + p) as *u8, le - p)
          sys_write(fd, nl, 1)
          ing = ing + 1
      } else {
          if le > p { mcx[0] = mcx[0] + 1 }
      }
      p = le + 1
  }
  let ln: *u8 = sys_mmap(CH_LINE)
  ch_frame_write(fd, ln, sys_now_realtime_sec(), "harvest" as *u8, "nx_claude_harvest" as *u8, "ingest" as *u8, "ok" as *u8, marker)
  sys_close(fd)
  return ing
501}
502// ---------- gauge: outside_permil JSON from a frames journal ----------
503func ch_nishi_tool(q: *u8, s: i64, e: i64) -> i64 {
  if ch_starts(q, s, e, "mcp__nishi__" as *u8) == 1 { return 1 }
  if ch_starts(q, s, e, "nx_" as *u8) == 1 { return 1 }
  if ch_starts(q, s, e, "nishi" as *u8) == 1 { return 1 }
  if ch_starts(q, s, e, "vizsla" as *u8) == 1 { return 1 }
  return 0
509}
510func ch_key(d: *u8, o: i64, name: *u8) -> i64 {
  d[o] = 34 as u8
  var p: i64 = o + 1
  p = sj_cat(d, p, name)
  d[p] = 34 as u8
  p = p + 1
  d[p] = 58 as u8
  p = p + 1
  return p
519}
520// ---------- bootgauge: SOTA-FROM-THE-FIRST-BYTE (operator 2026-07-24 'go SOTA from the first byte up') ----------
521// For each session (ws) is the FIRST tool nishi-native? A session that opens with nx_seat boot is SOTA
522// from byte 1; one that opens by reading 40KB of memory / scratchpadding is LEGACY. Measures the
523// SOTA-boot ratio + the softer nishi-within-first-K signal. Sessions interned by ws span (bounded, declared).
524const CH_WS_MAX: i64 = 4096
525func ch_bg_intern(q: *u8, cs: i64, ce: i64, wss: *i64, wse: *i64, np: *i64) -> i64 {
  var i: i64 = 0
  while i < np[0] {
      if ce - cs == wse[i] - wss[i] {
          var m: i64 = 0
          var eq: i64 = 1
          while m < ce - cs { if q[cs+m] != q[wss[i]+m] { eq = 0; m = ce - cs } else { m = m + 1 } }
          if eq == 1 { return i }
      }
      i = i + 1
  }
  if np[0] >= CH_WS_MAX { return -1 }
  wss[np[0]] = cs
  wse[np[0]] = ce
  np[0] = np[0] + 1
  return np[0] - 1
541}
542func ch_bootgauge(journal: *u8, k: i64, d: *u8) -> i64 {
  let q: *u8 = sys_mmap(CH_JWIN)
  let cap: i64 = CH_JWIN - 8
  var n: i64 = ch_read(journal, q, cap)
  if n < 0 { n = 0 }
  var trunc: i64 = 0
  if n >= cap { trunc = 1 }
  let wss: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64
  let wse: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64
  let wfn: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64
  let wnk: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64
  let wc: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64
  let np: *i64 = sys_mmap(16) as *i64
  let sp: *i64 = sys_mmap(16) as *i64
  var frames: i64 = 0
  var malformed: i64 = 0
  var capped: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(q, i, n)
      if le > i {
          if sj_col(q, i, le, 1, sp) == 1 {
              let ws0: i64 = sp[0]
              let ws1: i64 = sp[1]
              if sj_col(q, i, le, 2, sp) == 1 {
                  frames = frames + 1
                  let wi: i64 = ch_bg_intern(q, ws0, ws1, wss, wse, np)
                  if wi < 0 { capped = 1 } else {
                      let isn: i64 = ch_nishi_tool(q, sp[0], sp[1])
                      let c: i64 = wc[wi]
                      wc[wi] = c + 1
                      if c == 0 { wfn[wi] = isn }
                      if c < k { if isn == 1 { wnk[wi] = 1 } }
                  }
              } else { malformed = malformed + 1 }
          } else { malformed = malformed + 1 }
      }
      i = le + 1
  }
  var sota: i64 = 0
  var nishik: i64 = 0
  var kk: i64 = 0
  while kk < np[0] {
      if wfn[kk] == 1 { sota = sota + 1 }
      if wnk[kk] == 1 { nishik = nishik + 1 }
      kk = kk + 1
  }
  let total: i64 = np[0]
  var sotaperm: i64 = 0 - 1
  var nkperm: i64 = 0 - 1
  if total > 0 { sotaperm = sota * 1000 / total; nkperm = nishik * 1000 / total }
  var p: i64 = 0
  d[p] = 123 as u8; p = p + 1
  p = ch_key(d, p, "v" as *u8); p = sj_catn(d, p, 1); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "tool" as *u8); d[p]=34 as u8;p=p+1; p = sj_cat(d,p,"nx_claude_harvest" as *u8); d[p]=34 as u8;p=p+1; d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "averb" as *u8); d[p]=34 as u8;p=p+1; p = sj_cat(d,p,"bootgauge" as *u8); d[p]=34 as u8;p=p+1; d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "journal_bytes" as *u8); p = sj_catn(d,p,n); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "truncated" as *u8); p = sj_catn(d,p,trunc); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "k" as *u8); p = sj_catn(d,p,k); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "frames" as *u8); p = sj_catn(d,p,frames); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "malformed" as *u8); p = sj_catn(d,p,malformed); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "sessions" as *u8); p = sj_catn(d,p,total); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "sota_first" as *u8); p = sj_catn(d,p,sota); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "legacy_first" as *u8); p = sj_catn(d,p,total-sota); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "sota_boot_permil" as *u8); p = sj_catn(d,p,sotaperm); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "nishi_within_k" as *u8); p = sj_catn(d,p,nishik); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "nishi_within_k_permil" as *u8); p = sj_catn(d,p,nkperm); d[p]=44 as u8;p=p+1
  p = ch_key(d, p, "sessions_capped" as *u8); p = sj_catn(d,p,capped)
  d[p] = 125 as u8; p = p + 1
  d[p] = 10 as u8; p = p + 1
  return p
613}
614// gauge core: g slots 0 total 1 nishi 2 outside 3 permil(legacy,all) 4 malformed 5 trunc 6 bytes
615//   7 beats(verb=run: estate autonomy) 8 claude_actions 9 claude_outside 10 claude_outside_permil
616// FULL journal read via sys_read_file (the 4MB cap SAMPLED THE JULY HEAD -- fixed 2026-09-05).
617// Reliance is measured over CLAUDE-ACTION frames ONLY; estate :run beats are the estate running
618// ITSELF (sovereign) and would dilute the denominator (measured law 2026-09-05).
619func ch_gauge_calc(jpath: *u8, days: i64, g: *i64) -> i64 {
  let nn: *i64 = sys_mmap(16) as *i64
  let q: *u8 = sys_read_file(jpath, nn)
  var n: i64 = nn[0]
  if n < 0 { n = 0 }
  let trunc: i64 = 0
  var cutoff: i64 = 0
  if days > 0 { cutoff = sys_now_realtime_sec() - days * CH_MAGIC_86400 }
  let sp: *i64 = sys_mmap(16) as *i64
  let vp: *i64 = sys_mmap(16) as *i64
  var total: i64 = 0
  var nishi: i64 = 0
  var outside: i64 = 0
  var malformed: i64 = 0
  var beats: i64 = 0
  var cl_total: i64 = 0
  var cl_outside: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(q, i, n)
      if le > i {
          var ok: i64 = 0
          var ts: i64 = 0
          var isnishi: i64 = 0
          var isbeat: i64 = 0
          if sj_col(q, i, le, 0, sp) == 1 {
              if ch_digits(q, sp[0], sp[1]) == 1 {
                  ts = sj_atoi_span(q, sp[0], sp[1])
                  if sj_col(q, i, le, 2, sp) == 1 { ok = 1 }
              }
          }
          if ok == 1 {
              isnishi = ch_nishi_tool(q, sp[0], sp[1])
              if sj_col(q, i, le, 3, vp) == 1 {
                  if (vp[1] - vp[0]) == 3 { if ch_starts(q, vp[0], vp[1], "run" as *u8) == 1 { isbeat = 1 } }
              }
              if ts >= cutoff {
                  total = total + 1
                  if isnishi == 1 { nishi = nishi + 1 } else { outside = outside + 1 }
                  if isbeat == 1 { beats = beats + 1 } else {
                      cl_total = cl_total + 1
                      if isnishi == 0 { cl_outside = cl_outside + 1 }
                  }
              }
          } else { malformed = malformed + 1 }
      }
      i = le + 1
  }
  var permil: i64 = 0 - 1
  if total > 0 { permil = outside * 1000 / total }
  var clperm: i64 = 0 - 1
  if cl_total > 0 { clperm = cl_outside * 1000 / cl_total }
  g[0] = total
  g[1] = nishi
  g[2] = outside
  g[3] = permil
  g[4] = malformed
  g[5] = trunc
  g[6] = n
  g[7] = beats
  g[8] = cl_total
  g[9] = cl_outside
  g[10] = clperm
  g[11] = 0
  if (q as i64) == 0 { g[11] = 1; return -1 }
  return 0
685}
686func ch_gauge_json(jpath: *u8, days: i64, d: *u8) -> i64 {
  let g: *i64 = sys_mmap(128) as *i64
  ch_gauge_calc(jpath, days, g)
  let total: i64 = g[0]
  let nishi: i64 = g[1]
  let outside: i64 = g[2]
  let permil: i64 = g[3]
  let malformed: i64 = g[4]
  let trunc: i64 = g[5]
  let n: i64 = g[6]
  var p: i64 = 0
  d[p] = 123 as u8; p = p + 1
  p = ch_key(d, p, "v" as *u8); p = sj_catn(d, p, 1); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "tool" as *u8)
  d[p] = 34 as u8; p = p + 1
  p = sj_cat(d, p, "nx_claude_harvest" as *u8)
  d[p] = 34 as u8; p = p + 1
  d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "averb" as *u8)
  d[p] = 34 as u8; p = p + 1
  p = sj_cat(d, p, "gauge" as *u8)
  d[p] = 34 as u8; p = p + 1
  d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "journal" as *u8)
  d[p] = 34 as u8; p = p + 1
  p = sj_cat_esc(d, p, jpath, 0, sj_vlen(jpath), 200)
  d[p] = 34 as u8; p = p + 1
  d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "journal_bytes" as *u8); p = sj_catn(d, p, n); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "truncated" as *u8); p = sj_catn(d, p, trunc); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "days" as *u8); p = sj_catn(d, p, days); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "frames_total" as *u8); p = sj_catn(d, p, total); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "malformed" as *u8); p = sj_catn(d, p, malformed); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "nishi" as *u8); p = sj_catn(d, p, nishi); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "outside" as *u8); p = sj_catn(d, p, outside); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "outside_permil" as *u8); p = sj_catn(d, p, permil); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "beats" as *u8); p = sj_catn(d, p, g[7]); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "claude_actions" as *u8); p = sj_catn(d, p, g[8]); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "claude_outside" as *u8); p = sj_catn(d, p, g[9]); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "claude_outside_permil" as *u8); p = sj_catn(d, p, g[10])
  p = sj_cat(d, p, ",\"evidence_state\":\"" as *u8)
  if g[11] == 1 { p = sj_cat(d, p, "source_open_failed" as *u8) } else { p = sj_cat(d, p, "source_opened" as *u8) }
  p = sj_cat(d, p, "\",\"measurement_scope\":\"observed_journal_tool_frames\",\"actor_work_share\":null,\"token_cost\":null,\"verified_delivery_share\":null,\"read_integrity_verified\":false" as *u8)
  d[p] = 125 as u8; p = p + 1
  d[p] = 10 as u8; p = p + 1
  return p
732}
733// ---------- page: the F965 watch-it-fall surface (HTML, minimal; U2/U3 restyle rides ui-debt lane) ----------
734func ch_page(jpath: *u8, outp: *u8, days: i64) -> i64 {
  let g: *i64 = sys_mmap(128) as *i64
  ch_gauge_calc(jpath, days, g)
  let d: *u8 = sys_mmap(CH_OUT)
  var p: i64 = 0
  d[p] = 60 as u8; p = p + 1
  d[p] = 33 as u8; p = p + 1
  p = sj_cat(d, p, "doctype html><html><head><meta charset=\"utf-8\"><title>Outside Gauge</title></head><body>" as *u8)
  p = sj_cat(d, p, "<h1>Outside Gauge</h1><p>share of observed tool actions still OUTSIDE the nishi ecosystem (permil, derived from the sovereign actlog)</p>" as *u8)
  p = sj_cat(d, p, "<p style=\"font-size:64px;margin:8px 0\">" as *u8)
  p = sj_catn(d, p, g[10])
  p = sj_cat(d, p, "&permil;</p>" as *u8)
  p = sj_cat(d, p, "<p>outside_permil=" as *u8)
  p = sj_catn(d, p, g[3])
  p = sj_cat(d, p, " (frames=" as *u8)
  p = sj_catn(d, p, g[0])
  p = sj_cat(d, p, " nishi=" as *u8)
  p = sj_catn(d, p, g[1])
  p = sj_cat(d, p, " outside=" as *u8)
  p = sj_catn(d, p, g[2])
  p = sj_cat(d, p, " malformed=" as *u8)
  p = sj_catn(d, p, g[4])
  p = sj_cat(d, p, " truncated=" as *u8)
  p = sj_catn(d, p, g[5])
  p = sj_cat(d, p, " days=" as *u8)
  p = sj_catn(d, p, days)
  p = sj_cat(d, p, ")</p>" as *u8)
  p = sj_cat(d, p, "<p>claude_outside_permil=" as *u8)
  p = sj_catn(d, p, g[10])
  p = sj_cat(d, p, " (claude_actions=" as *u8)
  p = sj_catn(d, p, g[8])
  p = sj_cat(d, p, " claude_outside=" as *u8)
  p = sj_catn(d, p, g[9])
  p = sj_cat(d, p, " estate_beats_excluded=" as *u8)
  p = sj_catn(d, p, g[7])
  p = sj_cat(d, p, ")</p>" as *u8)
  p = sj_cat(d, p, "<p>Baseline 2026-07-23: laptop 651 / sovereign 643. This number must FALL as capabilities move inside (minergap- MG00-MG11; frontier F964-F973).</p>" as *u8)
  p = sj_cat(d, p, "<p><a href=\"/wsmine\">wsmine</a> <a href=\"/claims\">claims</a> <a href=\"/intake\">intake</a> <a href=\"/frontier\">frontier</a></p>" as *u8)
  p = sj_cat(d, p, "<p>emitted by nx_claude_harvest page (hourly beat); journal " as *u8)
  p = sj_cat(d, p, jpath)
  p = sj_cat(d, p, "</p></body></html>" as *u8)
  let fd: i64 = sys_openat_wr(outp, CH_MODE_644)
  if fd < 0 { return -1 }
  sys_write(fd, d, p)
  sys_close(fd)
  return 0
780}
781// ---------- classes: the residual BY TOOL, whole partition (SV2, 2026-09-05) ----------
782// Over CLAUDE-ACTION frames only (estate :run beats excluded), count outside frames per tool name.
783// The emitted list is the top CH_CLS_SHOW by count plus an OTHER bucket so the partition SUMS to
784// claude_outside; the table cap is named and frames beyond it are COUNTED (classes_unnamed_overflow),
785// never silently dropped. Today (2026-09-05) nx_actlog freq could only show the top 30 of 1,635 tool:verb
786// pairs across ALL frames; this verb answers the residual question directly and feeds the journal row.
787const CH_CLS_MAX: i64 = 512       // distinct outside tool names tracked (transcript tool names measured ~60 distinct)
788const CH_CLS_NAME: i64 = 64       // one name cell; longest builtin tool name measured well under this
789const CH_CLS_SHOW: i64 = 12       // JSON shows this many, the rest fold into other
790const CH_CLS_JSHOW: i64 = 6       // the journal row shows this many, the rest fold into other
791func ch_classes_calc(jpath: *u8, names: *u8, counts: *i64, c: *i64) -> i64 {
  let nn: *i64 = sys_mmap(16) as *i64
  let q: *u8 = sys_read_file(jpath, nn)
  var n: i64 = nn[0]
  if n < 0 { n = 0 }
  let sp: *i64 = sys_mmap(16) as *i64
  let vp: *i64 = sys_mmap(16) as *i64
  var ncls: i64 = 0
  var ovf: i64 = 0
  var outside: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(q, i, n)
      if le > i {
          var ok: i64 = 0
          if sj_col(q, i, le, 0, sp) == 1 { if ch_digits(q, sp[0], sp[1]) == 1 { if sj_col(q, i, le, 2, sp) == 1 { ok = 1 } } }
          if ok == 1 {
              var isbeat: i64 = 0
              if sj_col(q, i, le, 3, vp) == 1 { if (vp[1] - vp[0]) == 3 { if ch_starts(q, vp[0], vp[1], "run" as *u8) == 1 { isbeat = 1 } } }
              if isbeat == 0 { if ch_nishi_tool(q, sp[0], sp[1]) == 0 {
                  outside = outside + 1
                  var tl: i64 = sp[1] - sp[0]
                  if tl > CH_CLS_NAME - 1 { tl = CH_CLS_NAME - 1 }
                  var hit: i64 = 0 - 1
                  var k: i64 = 0
                  while k < ncls {
                      let nm: *u8 = ((names as i64) + k * CH_CLS_NAME) as *u8
                      var m: i64 = 0
                      var same: i64 = 1
                      while m < tl { if nm[m] != q[sp[0] + m] { same = 0; m = tl } else { m = m + 1 } }
                      if same == 1 { if nm[tl] == (0 as u8) { hit = k; k = ncls } }
                      k = k + 1
                  }
                  if hit >= 0 { counts[hit] = counts[hit] + 1 } else {
                      if ncls < CH_CLS_MAX {
                          let nm2: *u8 = ((names as i64) + ncls * CH_CLS_NAME) as *u8
                          var m2: i64 = 0
                          while m2 < tl { nm2[m2] = q[sp[0] + m2]; m2 = m2 + 1 }
                          nm2[tl] = 0 as u8
                          counts[ncls] = 1
                          ncls = ncls + 1
                      } else { ovf = ovf + 1 }
                  }
              } }
          }
      }
      i = le + 1
  }
  c[0] = ncls
  c[1] = ovf
  return outside
842}
843func ch_classes_top(counts: *i64, used: *i64, ncls: i64) -> i64 {
  var best: i64 = 0 - 1
  var k: i64 = 0
  while k < ncls { if used[k] == 0 { if best < 0 { best = k } else { if counts[k] > counts[best] { best = k } } } k = k + 1 }
  return best
848}
849func ch_classes_cat(d: *u8, o0: i64, names: *u8, counts: *i64, ncls: i64, show: i64, outside: i64) -> i64 {
  var o: i64 = o0
  let used: *i64 = sys_mmap(CH_CLS_MAX * 8) as *i64
  var shown: i64 = 0
  var acc: i64 = 0
  var s: i64 = 0
  while s < show {
      let b: i64 = ch_classes_top(counts, used, ncls)
      if b >= 0 {
          used[b] = 1
          if shown > 0 { o = sj_cat(d, o, "," as *u8) }
          o = sj_cat(d, o, ((names as i64) + b * CH_CLS_NAME) as *u8)
          o = sj_cat(d, o, ":" as *u8)
          o = sj_catn(d, o, counts[b])
          acc = acc + counts[b]
          shown = shown + 1
      }
      s = s + 1
  }
  if shown > 0 { o = sj_cat(d, o, "," as *u8) }
  o = sj_cat(d, o, "other:" as *u8)
  o = sj_catn(d, o, outside - acc)
  return o
872}
873func ch_classes_json(jpath: *u8, d: *u8) -> i64 {
  let names: *u8 = sys_mmap(CH_CLS_MAX * CH_CLS_NAME)
  let counts: *i64 = sys_mmap(CH_CLS_MAX * 8) as *i64
  let c: *i64 = sys_mmap(16) as *i64
  let outside: i64 = ch_classes_calc(jpath, names, counts, c)
  var p: i64 = 0
  d[p] = 123 as u8; p = p + 1
  p = ch_key(d, p, "v" as *u8); p = sj_catn(d, p, 1); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "tool" as *u8); d[p] = 34 as u8; p = p + 1; p = sj_cat(d, p, "nx_claude_harvest" as *u8); d[p] = 34 as u8; p = p + 1; d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "averb" as *u8); d[p] = 34 as u8; p = p + 1; p = sj_cat(d, p, "classes" as *u8); d[p] = 34 as u8; p = p + 1; d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "claude_outside" as *u8); p = sj_catn(d, p, outside); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "classes_distinct" as *u8); p = sj_catn(d, p, c[0]); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "classes_table_cap" as *u8); p = sj_catn(d, p, CH_CLS_MAX); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "classes_unnamed_overflow" as *u8); p = sj_catn(d, p, c[1]); d[p] = 44 as u8; p = p + 1
  var show: i64 = CH_CLS_SHOW
  if c[0] < show { show = c[0] }
  p = ch_key(d, p, "classes_shown" as *u8); p = sj_catn(d, p, show); d[p] = 44 as u8; p = p + 1
  p = ch_key(d, p, "top_and_other" as *u8); d[p] = 34 as u8; p = p + 1
  p = ch_classes_cat(d, p, names, counts, c[0], show, outside)
  d[p] = 34 as u8; p = p + 1
  d[p] = 125 as u8; p = p + 1
  d[p] = 10 as u8; p = p + 1
  return p
896}
897// ch_classes: THE CONTRACT SYMBOL named by the sovereignty board (SV2, watch _ABSENT_:ch_classes). The symbol
898// ruler (nx_symdecl_lib sd_present) applies the DECLARATION rule to a .nx organ and never falls back to a
899// substring for a lowercase identifier, so ch_classes_json alone can never flip the cell: the board named
900// ch_classes, so ch_classes is what ships. One entry point over the verb, declared here AND called by main.
901func ch_classes(jpath: *u8, d: *u8) -> i64 { return ch_classes_json(jpath, d) }
902// ---------- journal: the SELF-UPDATING number on /compare (2026-09-05) ----------
903// Appends ONE `log|<epoch>|<rung>|measure|...` row to a domain .plan per UTC day (idempotent by a day
904// marker carried in the row), so the compare emitter renders the live reliance number beside the rung
905// with ZERO seat tokens. Wired on the plan-wsmine- beat. Codes: 0 written | 1 plan missing or unwritable
906// (a beat NEVER creates a plan) | 4 already journaled today | 5 insufficient data (never journal a -1).
907func ch_journal(jpath: *u8, planpath: *u8, rung: *u8) -> i64 {
  let g: *i64 = sys_mmap(128) as *i64
  ch_gauge_calc(jpath, 0, g)
  if g[8] <= 0 { return 5 }
  let now: i64 = sys_now_realtime_sec()
  let day: i64 = now / CH_MAGIC_86400
  let nn: *i64 = sys_mmap(16) as *i64
  let pb: *u8 = sys_read_file(planpath, nn)
  let pn: i64 = nn[0]
  if pn <= 0 { return 1 }
  let mk: *u8 = sys_mmap(128)
  var mo: i64 = sj_cat(mk, 0, "[HARV:journal:day=" as *u8)
  mo = sj_catn(mk, mo, day)
  mo = sj_cat(mk, mo, "]" as *u8)
  mk[mo] = 0 as u8
  if ch_find(pb, pn, mk) == 1 { return 4 }
  let row: *u8 = sys_mmap(CH_LINE)
  var o: i64 = sj_cat(row, 0, "log|" as *u8)
  o = sj_catn(row, o, now)
  o = sj_cat(row, o, "|" as *u8)
  o = sj_cat(row, o, rung)
  o = sj_cat(row, o, "|measure|" as *u8)
  o = sj_cat(row, o, mk)
  o = sj_cat(row, o, " claude_outside_permil=" as *u8)
  o = sj_catn(row, o, g[10])
  o = sj_cat(row, o, " claude_actions=" as *u8)
  o = sj_catn(row, o, g[8])
  o = sj_cat(row, o, " claude_outside=" as *u8)
  o = sj_catn(row, o, g[9])
  o = sj_cat(row, o, " estate_beats_excluded=" as *u8)
  o = sj_catn(row, o, g[7])
  o = sj_cat(row, o, " frames_total=" as *u8)
  o = sj_catn(row, o, g[0])
  o = sj_cat(row, o, " journal_bytes=" as *u8)
  o = sj_catn(row, o, g[6])
  let cn: *u8 = sys_mmap(CH_CLS_MAX * CH_CLS_NAME)
  let cc: *i64 = sys_mmap(CH_CLS_MAX * 8) as *i64
  let cx: *i64 = sys_mmap(16) as *i64
  let cout2: i64 = ch_classes_calc(jpath, cn, cc, cx)
  o = sj_cat(row, o, " outside_by_tool=" as *u8)
  var jshow: i64 = CH_CLS_JSHOW
  if cx[0] < jshow { jshow = cx[0] }
  o = ch_classes_cat(row, o, cn, cc, cx[0], jshow, cout2)
  o = sj_cat(row, o, " (nx_claude_harvest journal: full read, estate beats excluded, one row per UTC day)" as *u8)
  row[o] = 10 as u8
  o = o + 1
  let fd: i64 = sys_openat_append(planpath, CH_MODE_644)
  if fd < 0 { return 1 }
  sys_write(fd, row, o)
  sys_close(fd)
  return 0
958}
959// ---------- F971 propose: the gauge FILES its own migration work (feeder pattern) ----------
960// codes: 0 filed | 1 filer-fail | 2 below-threshold | 3 intake-window-exceeded (fail closed) |
961//        4 already-proposed (marker) | 5 insufficient-data. Filer is INJECTABLE (argecho in the
962// gate) and ALLOWLIST-RESOLVED (never a hardcoded sibling path). Marker [HARV:outsidegap:v1]
963// makes re-runs never re-file. NOTE ch_allow_path duplicates nx_actlog al_allow_path -- the
964// shared nx_jrnl_lib extraction is the filed rule-15 residual.
965// DELEGATES to the shared base (rule-15 extraction 2026-07-23)
966func ch_allow_path(name: *u8, outp: *u8) -> i64 { return sj_allow_path(name, outp) }
967func ch_propose(jpath: *u8, ipath: *u8, thr: i64, filer: *u8, cout: *u8, colen: *i64) -> i64 {
  colen[0] = 0
  let g: *i64 = sys_mmap(128) as *i64
  ch_gauge_calc(jpath, 0, g)
  if g[3] < 0 { return 5 }
  if g[3] < thr { return 2 }
  let jb: *u8 = sys_mmap(CH_JWIN)
  let jcap: i64 = CH_JWIN - 8
  let jn: i64 = ch_read(ipath, jb, jcap)
  if jn >= jcap { return 3 }
  if jn > 0 { if ch_find(jb, jn, "[HARV:outsidegap:v1]" as *u8) == 1 { return 4 } }
  let fpath: *u8 = sys_mmap(512)
  if ch_allow_path(filer, fpath) == 0 { return 1 }
  let txt: *u8 = sys_mmap(CH_LINE)
  var o: i64 = sj_cat(txt, 0, "[HARV:outsidegap:v1] outside_permil=" as *u8)
  o = sj_catn(txt, o, g[3])
  o = sj_cat(txt, o, " over threshold " as *u8)
  o = sj_catn(txt, o, thr)
  o = sj_cat(txt, o, " (frames=" as *u8)
  o = sj_catn(txt, o, g[0])
  o = sj_cat(txt, o, " nishi=" as *u8)
  o = sj_catn(txt, o, g[1])
  o = sj_cat(txt, o, " outside=" as *u8)
  o = sj_catn(txt, o, g[2])
  o = sj_cat(txt, o, ") - drive capability-migration from the minergap- catalog MG01-MG11 / frontier F964-F973; auto-filed by nx_claude_harvest propose" as *u8)
  txt[o] = 0 as u8
  let av: *i64 = sys_mmap(64) as *i64
  av[0] = fpath as i64
  av[1] = "ask" as *u8 as i64
  av[2] = ipath as i64
  av[3] = "nx_claude_harvest" as *u8 as i64
  av[4] = txt as i64
  av[5] = 0
  let ex: i64 = tr_run_capture(fpath, av, cout, CH_LINE - 8, colen)
  if ex != 0 { return 1 }
  return 0
1003}
1004// ---------- selftest ----------
1005func ch_selftest(prefix: *u8) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_claude_harvest selftest -- transcript parse + ingest + gauge teeth (unique scratch per run)" as *u8)
  // MICROSECOND stamp (2026-09-05): a second-resolution scratch name collided when nx_behaveprobe ran the live and the
  // staged selftest inside one second -- the second run found the first run's T15 marker already seeded and T14 refused.
  // The beat fixed this exact class on its piece names; the selftest now stamps the same way.
  let now: i64 = sys_now_realtime_us()
  let tj: *u8 = sys_mmap(512)
  var o: i64 = sj_cat(tj, 0, prefix)
  o = sj_catn(tj, o, now)
  o = sj_cat(tj, o, ".jsonl" as *u8)
  tj[o] = 0 as u8
  let fr: *u8 = sys_mmap(512)
  o = sj_cat(fr, 0, prefix)
  o = sj_catn(fr, o, now)
  o = sj_cat(fr, o, ".frames" as *u8)
  fr[o] = 0 as u8
  let st: *u8 = sys_mmap(512)
  o = sj_cat(st, 0, prefix)
  o = sj_catn(st, o, now)
  o = sj_cat(st, o, ".staged" as *u8)
  st[o] = 0 as u8
  let jr: *u8 = sys_mmap(512)
  o = sj_cat(jr, 0, prefix)
  o = sj_catn(jr, o, now)
  o = sj_cat(jr, o, ".jrnl" as *u8)
  jr[o] = 0 as u8
  // fixture transcript: decoy name outside tool_use + 2 tool_use on one line + 1 on another
  let tfd: i64 = sys_openat_append(tj, CH_MODE_644)
  let lb: *u8 = sys_mmap(CH_LINE)
  var lo: i64 = sj_cat(lb, 0, "{\"type\":\"user\",\"name\":\"decoy1\",\"timestamp\":\"2026-07-23T00:00:00Z\"}" as *u8)
  lb[lo] = 10 as u8
  sys_write(tfd, lb, lo + 1)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:01Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"a\",\"name\":\"Edit\"},{\"type\":\"tool_use\",\"id\":\"b\",\"name\":\"PowerShell\"}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(tfd, lb, lo + 1)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:02Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"c\",\"name\":\"mcp__nishi__nx_fs\"}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(tfd, lb, lo + 1)
  sys_close(tfd)
  // T1 harvest exact: 3 frames, decoy never harvested
  let tcx: *i64 = sys_mmap(16) as *i64
  let got: i64 = ch_frames(tj, "wtest" as *u8, fr, tcx)
  let fb: *u8 = sys_mmap(CH_JWIN)
  let fn: i64 = ch_read(fr, fb, CH_JWIN - 8)
  var ok1: i64 = 0
  if got == 3 { if fn > 0 { if ch_find(fb, fn, "Edit" as *u8) == 1 { if ch_find(fb, fn, "PowerShell" as *u8) == 1 { if ch_find(fb, fn, "decoy1" as *u8) == 0 { ok1 = 1 } } } } }
  gv_check("T1 harvest exactly the 3 tool_use names, decoy name never fabricated" as *u8, ok1, ctr)
  // T2 iso timestamp -> epoch propagated (2026-07-23T00:00:01Z = 1784764801)
  var ok2: i64 = 0
  if ch_find(fb, fn, "1784764801" as *u8) == 1 { if ch_find(fb, fn, "1784764802" as *u8) == 1 { ok2 = 1 } }
  gv_check("T2 iso timestamps parsed to exact epochs" as *u8, ok2, ctr)
  // T3 gauge exact split: Edit+PowerShell outside, nx_fs nishi -> 666 permil
  let d: *u8 = sys_mmap(CH_OUT)
  var dl: i64 = ch_gauge_json(fr, 0, d)
  var ok3: i64 = 0
  if dl > 0 { if ch_find(d, dl, "\"frames_total\":3" as *u8) == 1 { if ch_find(d, dl, "\"outside_permil\":666" as *u8) == 1 { ok3 = 1 } } }
  gv_check("T3 gauge exact: 2 outside 1 nishi = 666 permil" as *u8, ok3, ctr)
  // T4 gauge on missing journal refuses a number (-1, insufficient data honesty)
  let miss: *u8 = sys_mmap(512)
  o = sj_cat(miss, 0, prefix)
  o = sj_catn(miss, o, now)
  o = sj_cat(miss, o, ".absent" as *u8)
  miss[o] = 0 as u8
  dl = ch_gauge_json(miss, 0, d)
  var ok4: i64 = 0
  if dl > 0 { if ch_find(d, dl, "\"frames_total\":0" as *u8) == 1 { if ch_find(d, dl, "\"outside_permil\":-1" as *u8) == 1 { ok4 = 1 } } }
  gv_check("T4 empty journal refuses permil (-1) never fabricates" as *u8, ok4, ctr)
  gv_check("T4a missing source is explicitly unavailable", ch_find(d, dl, "\"evidence_state\":\"source_open_failed\"" as *u8), ctr)
  let empty45: *u8 = sys_mmap(CH_PATH_MAX)
  var e45: i64 = sj_cat(empty45, 0, miss)
  e45 = sj_cat(empty45, e45, ".empty" as *u8)
  empty45[e45] = 0 as u8
  let emptyfd45: i64 = sys_openat_wr(empty45, CH_MODE_644)
  var emptyok45: i64 = 0
  if emptyfd45 >= 0 {
      sys_close(emptyfd45)
      dl = ch_gauge_json(empty45, 0, d)
      emptyok45 = ch_find(d, dl, "\"evidence_state\":\"source_opened\"" as *u8)
  }
  gv_check("T4b readable empty source differs from missing source", emptyok45, ctr)
  gv_check("T4c activity is not presented as delivery or cost", ch_find(d, dl, "\"verified_delivery_share\":null" as *u8), ctr)
  // T5 ingest: 2 valid + 1 malformed staged line -> journal gains exactly the 2 + marker
  ch_frame_append(st, CH_MAGIC_1784764900, "w2" as *u8, "Read" as *u8, "use" as *u8, "-" as *u8, "harvest" as *u8)
  ch_frame_append(st, CH_MAGIC_1784764901, "w2" as *u8, "nx_fs_write" as *u8, "use" as *u8, "-" as *u8, "harvest" as *u8)
  let sfd: i64 = sys_openat_append(st, CH_MODE_644)
  var go2: i64 = sj_cat(lb, 0, "garbage-no-tabs" as *u8)
  lb[go2] = 10 as u8
  sys_write(sfd, lb, go2 + 1)
  sys_close(sfd)
  let mcx: *i64 = sys_mmap(16) as *i64
  let r5: i64 = ch_ingest(st, jr, mcx)
  let jb: *u8 = sys_mmap(CH_JWIN)
  var jn: i64 = ch_read(jr, jb, CH_JWIN - 8)
  var ok5: i64 = 0
  if r5 == 2 { if mcx[0] == 1 { if ch_find(jb, jn, "Read" as *u8) == 1 { if ch_find(jb, jn, "harvest-ingest:" as *u8) == 1 { if ch_find(jb, jn, "garbage-no-tabs" as *u8) == 0 { ok5 = 1 } } } } }
  gv_check("T5 ingest validates: 2 in, malformed counted out, marker banked" as *u8, ok5, ctr)
  // T6 idempotent: second ingest refuses, journal bytes unchanged
  let r6: i64 = ch_ingest(st, jr, mcx)
  let jn2: i64 = ch_read(jr, jb, CH_JWIN - 8)
  var ok6: i64 = 0
  if r6 == (0 - 2) { if jn2 == jn { ok6 = 1 } }
  gv_check("T6 re-ingest ALREADY, journal byte-identical" as *u8, ok6, ctr)
  // T7 missing transcript fails closed
  let r7: i64 = ch_frames(miss, "w" as *u8, fr, tcx)
  var ok7: i64 = 0
  if r7 == (0 - 1) { ok7 = 1 }
  gv_check("T7 missing transcript refused (-1) fail closed" as *u8, ok7, ctr)
  // T8 sovereign-organ frames (nx_ prefix) classify as nishi: add one -> 2 outside / 2 nishi = 500
  ch_frame_append(fr, CH_MAGIC_1784764803, "wtest" as *u8, "nx_shelltool" as *u8, "use" as *u8, "-" as *u8, "harvest" as *u8)
  dl = ch_gauge_json(fr, 0, d)
  var ok8: i64 = 0
  if dl > 0 { if ch_find(d, dl, "\"frames_total\":4" as *u8) == 1 { if ch_find(d, dl, "\"outside_permil\":500" as *u8) == 1 { ok8 = 1 } } }
  gv_check("T8 nx_-prefixed frames count as nishi (500 permil exact)" as *u8, ok8, ctr)
  // T9 page emits the exact gauge + title (from the T8 journal: permil 500)
  let pg: *u8 = sys_mmap(512)
  o = sj_cat(pg, 0, prefix)
  o = sj_catn(pg, o, now)
  o = sj_cat(pg, o, ".html" as *u8)
  pg[o] = 0 as u8
  let r9: i64 = ch_page(fr, pg, 0)
  let pb: *u8 = sys_mmap(CH_OUT)
  let pn: i64 = ch_read(pg, pb, CH_OUT - 8)
  var ok9: i64 = 0
  if r9 == 0 { if pn > 0 { if ch_find(pb, pn, "outside_permil=500" as *u8) == 1 { if ch_find(pb, pn, "Outside Gauge" as *u8) == 1 { ok9 = 1 } } } }
  gv_check("T9 page emits the exact gauge + title" as *u8, ok9, ctr)
  // T13-T16 propose (F971): threshold honesty, injectable filer, marker idempotence, insufficient refuse
  let ijr: *u8 = sys_mmap(512)
  o = sj_cat(ijr, 0, prefix)
  o = sj_catn(ijr, o, now)
  o = sj_cat(ijr, o, ".ijr" as *u8)
  ijr[o] = 0 as u8
  let pcl: *i64 = sys_mmap(16) as *i64
  let r13: i64 = ch_propose(fr, ijr, 600, "argecho" as *u8, d, pcl)
  var ok13: i64 = 0
  if r13 == 2 { ok13 = 1 }
  gv_check("T13 below threshold never files (code 2)" as *u8, ok13, ctr)
  // T14 needs a RESOLVABLE filer, and resolution runs through sj_allow_path, which opens
  // "tool_allowlist.conf" as a BARE path -- i.e. relative to the CWD. On any host/CWD without one
  // (every WSL run of this gate) the filer cannot be resolved, and this tooth then reported the
  // ORGAN as broken when only its environment was absent: the same binary reads 39/40 RED from /tmp
  // and 40/40 GREEN from a CWD holding one row. MEASURED 2026-08-20.
  //   ***** AN AXIS THAT CANNOT SEE MUST ABSTAIN, NOT CONVICT -- and a gate that goes RED on its own
  //   environment is the permanently-red detector everyone learns to ignore.
  let t14p: *u8 = sys_mmap(CH_BT_PATHMAX)
  if gv_need("propose filer resolvable via a CWD-relative tool_allowlist.conf" as *u8, ch_allow_path("argecho" as *u8, t14p), ctr) == 1 {
      let r14: i64 = ch_propose(fr, ijr, 400, "argecho" as *u8, d, pcl)
      var ok14: i64 = 0
      if r14 == 0 { if pcl[0] > 0 { if ch_find(d, pcl[0], "[HARV:outsidegap:v1] outside_permil=500" as *u8) == 1 { ok14 = 1 } } }
      gv_check("T14 above threshold files through the injected filer w/ exact marker+permil" as *u8, ok14, ctr)
  }
  let mfd: i64 = sys_openat_append(ijr, CH_MODE_644)
  let mln: *u8 = sys_mmap(256)
  var mo2: i64 = sj_cat(mln, 0, "1 seeded [HARV:outsidegap:v1] marker" as *u8)
  mln[mo2] = 10 as u8
  sys_write(mfd, mln, mo2 + 1)
  sys_close(mfd)
  let r15: i64 = ch_propose(fr, ijr, 400, "argecho" as *u8, d, pcl)
  var ok15: i64 = 0
  if r15 == 4 { ok15 = 1 }
  gv_check("T15 marker present refuses re-file (code 4, idempotent)" as *u8, ok15, ctr)
  let r16: i64 = ch_propose(miss, ijr, 400, "argecho" as *u8, d, pcl)
  var ok16: i64 = 0
  if r16 == 5 { ok16 = 1 }
  gv_check("T16 insufficient data refuses to propose (code 5)" as *u8, ok16, ctr)
  // T17-T20 DELTA (F973): exactly-once harvest by byte high-water mark
  let dj: *u8 = sys_mmap(512)
  o = sj_cat(dj, 0, prefix)
  o = sj_catn(dj, o, now)
  o = sj_cat(dj, o, ".dj" as *u8)
  dj[o] = 0 as u8
  let hw: *u8 = sys_mmap(512)
  o = sj_cat(hw, 0, prefix)
  o = sj_catn(hw, o, now)
  o = sj_cat(hw, o, ".hwm" as *u8)
  hw[o] = 0 as u8
  let hcx: *i64 = sys_mmap(64) as *i64
  // tj holds 3 lines / 3 tool_use frames from T1
  let rd1: i64 = ch_delta(tj, "wd" as *u8, dj, hw, hcx)
  var ok17: i64 = 0
  if rd1 == 0 { if hcx[0] == 3 { if hcx[2] == 0 { if hcx[1] > 0 { ok17 = 1 } } } }
  gv_check("T17 first delta harvests all 3 frames and banks a high-water mark" as *u8, ok17, ctr)
  let firsthwm: i64 = hcx[1]
  let rd2: i64 = ch_delta(tj, "wd" as *u8, dj, hw, hcx)
  var ok18: i64 = 0
  if rd2 == 0 { if hcx[0] == 0 { if hcx[1] == firsthwm { ok18 = 1 } } }
  gv_check("T18 re-run on an unchanged transcript harvests ZERO (exactly-once, no marker needed)" as *u8, ok18, ctr)
  // grow the transcript by ONE complete line (1 tool_use) + a PARTIAL trailing line
  let gfd: i64 = sys_openat_append(tj, CH_MODE_644)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:03Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"g\",\"name\":\"Grep\"}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(gfd, lb, lo + 1)
  lo = sj_cat(lb, 0, "{\"type\":\"tool_use\",\"name\":\"PartialNeverCounted\"" as *u8)
  sys_write(gfd, lb, lo)
  sys_close(gfd)
  let rd3: i64 = ch_delta(tj, "wd" as *u8, dj, hw, hcx)
  var ok19: i64 = 0
  if rd3 == 0 { if hcx[0] == 1 { if hcx[2] == firsthwm { ok19 = 1 } } }
  gv_check("T19 growth harvests ONLY the new line (1 frame), resuming from the banked mark" as *u8, ok19, ctr)
  let db: *u8 = sys_mmap(CH_JWIN)
  let dn: i64 = ch_read(dj, db, CH_JWIN - 8)
  var ok20: i64 = 0
  if dn > 0 { if ch_find(db, dn, "Grep" as *u8) == 1 { if ch_find(db, dn, "PartialNeverCounted" as *u8) == 0 { ok20 = 1 } } }
  gv_check("T20 a PARTIAL trailing line is never consumed (waits below the mark)" as *u8, ok20, ctr)
  // T21-T23 PARTITION (2026-09-05): estate :run beats excluded from the reliance denominator.
  // Fixture: 1 outside claude action + 1 nishi claude action + 3 nishi estate beats (verb run).
  // Legacy outside_permil counts all 5 (nishi beats dilute -> 200); claude_outside_permil counts
  // ONLY the 2 claude actions -> 500 (beats=3). 500 != 200 proves the partition actually fired.
  let pj: *u8 = sys_mmap(512)
  var po: i64 = sj_cat(pj, 0, prefix)
  po = sj_catn(pj, po, now)
  po = sj_cat(pj, po, ".pj" as *u8)
  pj[po] = 0 as u8
  ch_frame_append(pj, CH_MAGIC_1784764900, "wp" as *u8, "PowerShell" as *u8, "use" as *u8, "-" as *u8, "act" as *u8)
  ch_frame_append(pj, CH_MAGIC_1784764901, "wp" as *u8, "nx_fs" as *u8, "call" as *u8, "-" as *u8, "act" as *u8)
  ch_frame_append(pj, CH_MAGIC_1784764803, "wp" as *u8, "nx_netobs.elf" as *u8, "run" as *u8, "-" as *u8, "beat" as *u8)
  ch_frame_append(pj, CH_MAGIC_1784764803, "wp" as *u8, "nx_resmon.elf" as *u8, "run" as *u8, "-" as *u8, "beat" as *u8)
  ch_frame_append(pj, CH_MAGIC_1784764803, "wp" as *u8, "nx_memvel.elf" as *u8, "run" as *u8, "-" as *u8, "beat" as *u8)
  dl = ch_gauge_json(pj, 0, d)
  var ok21: i64 = 0
  if dl > 0 { if ch_find(d, dl, "\"frames_total\":5" as *u8) == 1 { if ch_find(d, dl, "\"beats\":3" as *u8) == 1 { if ch_find(d, dl, "\"claude_actions\":2" as *u8) == 1 { ok21 = 1 } } } }
  gv_check("T21 estate :run beats partitioned out: 5 frames, 3 beats, 2 claude actions" as *u8, ok21, ctr)
  var ok22: i64 = 0
  if dl > 0 { if ch_find(d, dl, "\"claude_outside_permil\":500" as *u8) == 1 { if ch_find(d, dl, "\"outside_permil\":200" as *u8) == 1 { ok22 = 1 } } }
  gv_check("T22 reliance over claude actions (500) NOT diluted by nishi beats (legacy 200)" as *u8, ok22, ctr)
  var ok23: i64 = 0
  if dl > 0 { if ch_find(d, dl, "\"claude_outside_permil\":200" as *u8) == 0 { ok23 = 1 } }
  gv_check("T23 non-vacuity: claude_outside_permil 500 != legacy diluted 200 (partition fired)" as *u8, ok23, ctr)
  // J1-J3 JOURNAL (2026-09-05): one measure row per UTC day on a .plan, idempotent, never a -1.
  let pl: *u8 = sys_mmap(512)
  var plo: i64 = sj_cat(pl, 0, prefix)
  plo = sj_catn(pl, plo, now)
  plo = sj_cat(pl, plo, ".plan" as *u8)
  pl[plo] = 0 as u8
  let pfd: i64 = sys_openat_wr(pl, CH_MODE_644)
  var seedo: i64 = sj_cat(lb, 0, "pos|seed plan for the journal teeth" as *u8)
  lb[seedo] = 10 as u8
  sys_write(pfd, lb, seedo + 1)
  sys_close(pfd)
  let rj1: i64 = ch_journal(pj, pl, "SV0" as *u8)
  let jb2: *u8 = sys_mmap(CH_JWIN)
  let jn3: i64 = ch_read(pl, jb2, CH_JWIN - 8)
  var okj1: i64 = 0
  if rj1 == 0 { if ch_find(jb2, jn3, "|SV0|measure|" as *u8) == 1 { if ch_find(jb2, jn3, "claude_outside_permil=500" as *u8) == 1 { okj1 = 1 } } }
  gv_check("J1 journal appends one measure row carrying the exact honest permil (500, partition fixture)" as *u8, okj1, ctr)
  let rj2: i64 = ch_journal(pj, pl, "SV0" as *u8)
  let jn4: i64 = ch_read(pl, jb2, CH_JWIN - 8)
  var okj2: i64 = 0
  if rj2 == 4 { if jn4 == jn3 { okj2 = 1 } }
  gv_check("J2 second journal the same day refused (4), plan byte-identical (idempotent)" as *u8, okj2, ctr)
  let rj3: i64 = ch_journal(miss, pl, "SV0" as *u8)
  let jn5: i64 = ch_read(pl, jb2, CH_JWIN - 8)
  var okj3: i64 = 0
  if rj3 == 5 { if jn5 == jn4 { okj3 = 1 } }
  gv_check("J3 neg-control-insufficient: a missing journal refuses (5) and writes nothing, never a -1 row" as *u8, okj3, ctr)
  // C1-C3 CLASSES (SV2, 2026-09-05): the residual by tool over claude actions; the partition sums; beats
  // and nishi tools are never a class; the list is sorted by count descending.
  dl = ch_classes_json(pj, d)
  var okc1: i64 = 0
  if dl > 0 { if ch_find(d, dl, "\"claude_outside\":1" as *u8) == 1 { if ch_find(d, dl, "\"classes_distinct\":1" as *u8) == 1 { if ch_find(d, dl, "PowerShell:1,other:0" as *u8) == 1 { okc1 = 1 } } } }
  gv_check("C1 classes on the partition fixture: one outside tool (PowerShell:1) and the partition sums (other:0)" as *u8, okc1, ctr)
  var okc2: i64 = 0
  if dl > 0 { if ch_find(d, dl, "nx_netobs" as *u8) == 0 { if ch_find(d, dl, "nx_fs" as *u8) == 0 { okc2 = 1 } } }
  gv_check("C2 neg-control: estate beats and nishi tools are never a residual class" as *u8, okc2, ctr)
  let cj3: *u8 = sys_mmap(512)
  var co3: i64 = sj_cat(cj3, 0, prefix)
  co3 = sj_catn(cj3, co3, now)
  co3 = sj_cat(cj3, co3, ".cls" as *u8)
  cj3[co3] = 0 as u8
  ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Edit" as *u8, "use" as *u8, "-" as *u8, "a" as *u8)
  ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Bash" as *u8, "use" as *u8, "-" as *u8, "a" as *u8)
  ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Grep" as *u8, "use" as *u8, "-" as *u8, "a" as *u8)
  ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Bash" as *u8, "use" as *u8, "-" as *u8, "a" as *u8)
  ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Edit" as *u8, "use" as *u8, "-" as *u8, "a" as *u8)
  ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Bash" as *u8, "use" as *u8, "-" as *u8, "a" as *u8)
  dl = ch_classes_json(cj3, d)
  var okc3: i64 = 0
  if dl > 0 { if ch_find(d, dl, "\"top_and_other\":\"Bash:3,Edit:2,Grep:1,other:0\"" as *u8) == 1 { if ch_find(d, dl, "\"claude_outside\":6" as *u8) == 1 { okc3 = 1 } } }
  gv_check("C3 classes sorted by count descending with an exact sum: Bash:3,Edit:2,Grep:1,other:0 of 6" as *u8, okc3, ctr)
  // T21/T22 BOOTGAUGE (SOTA-from-the-first-byte): s1 opens nishi-native (nx_seat), s2 opens legacy
  // (Read) but touches nishi within K, s3 stays outside => sota_first 1/3=333, nishi_within_k 2/3=666.
  let bj: *u8 = sys_mmap(512)
  o = sj_cat(bj, 0, prefix)
  o = sj_catn(bj, o, now)
  o = sj_cat(bj, o, ".bj" as *u8)
  bj[o] = 0 as u8
  ch_frame_append(bj, CH_MAGIC_1784764900, "s1" as *u8, "nx_seat" as *u8, "boot" as *u8, "-" as *u8, "-" as *u8)
  ch_frame_append(bj, CH_MAGIC_1784764900, "s1" as *u8, "mcp__nishi__nx_fs" as *u8, "lines" as *u8, "-" as *u8, "-" as *u8)
  ch_frame_append(bj, CH_MAGIC_1784764900, "s2" as *u8, "Read" as *u8, "use" as *u8, "-" as *u8, "-" as *u8)
  ch_frame_append(bj, CH_MAGIC_1784764900, "s2" as *u8, "mcp__nishi__nx_store_put" as *u8, "put" as *u8, "-" as *u8, "-" as *u8)
  ch_frame_append(bj, CH_MAGIC_1784764900, "s3" as *u8, "PowerShell" as *u8, "use" as *u8, "-" as *u8, "-" as *u8)
  ch_frame_append(bj, CH_MAGIC_1784764900, "s3" as *u8, "Bash" as *u8, "use" as *u8, "-" as *u8, "-" as *u8)
  let bd: i64 = ch_bootgauge(bj, 3, d)
  var ok21: i64 = 0
  if bd > 0 { if ch_find(d, bd, "\"sessions\":3,\"sota_first\":1,\"legacy_first\":2,\"sota_boot_permil\":333" as *u8) == 1 { ok21 = 1 } }
  gv_check("T21 bootgauge: first tool nishi in 1 of 3 sessions = 333 permil SOTA-boot" as *u8, ok21, ctr)
  var ok22: i64 = 0
  if bd > 0 { if ch_find(d, bd, "\"nishi_within_k\":2,\"nishi_within_k_permil\":666" as *u8) == 1 { ok22 = 1 } }
  gv_check("T22 nishi-within-first-K = 2 of 3 = 666 permil (the softer signal)" as *u8, ok22, ctr)
  let lc: *u8 = sys_mmap(512)
  o = sj_cat(lc, 0, prefix)
  o = sj_catn(lc, o, now)
  o = sj_cat(lc, o, ".lconf" as *u8)
  lc[o] = 0 as u8
  let lt: *u8 = sys_mmap(512)
  o = sj_cat(lt, 0, prefix)
  o = sj_catn(lt, o, now)
  o = sj_cat(lt, o, ".ltx" as *u8)
  lt[o] = 0 as u8
  let lo2: *u8 = sys_mmap(512)
  o = sj_cat(lo2, 0, prefix)
  o = sj_catn(lo2, o, now)
  o = sj_cat(lo2, o, ".lout" as *u8)
  lo2[o] = 0 as u8
  let cfd: i64 = sys_openat_append(lc, CH_MODE_644)
  let cb2: *u8 = sys_mmap(CH_LINE)
  var co: i64 = sj_cat(cb2, 0, "marker=LAW:|6\nmarker=ROOT CAUSE|5\nmarker=MEASURED|3\nstar_char=★\nwarn_char=⚠\nwarn_bonus=2\nstar_max=6\nmin_rank_store=3\nmin_len=40\nmax_len=400\n" as *u8)
  sys_write(cfd, cb2, co)
  sys_close(cfd)
  let tfd2: i64 = sys_openat_append(lt, CH_MODE_644)
  let tb2: *u8 = sys_mmap(CH_LINE)
  var to2: i64 = sj_cat(tb2, 0, "{\"timestamp\":\"2026-07-23T00:00:00Z\",\"c\":[{\"type\":\"text\",\"text\":\"LAW: a guard placed after the act it guards is not a guard\"}]}\n" as *u8)
  to2 = sj_cat(tb2, to2, "{\"timestamp\":\"2026-07-23T00:00:01Z\",\"c\":[{\"type\":\"text\",\"text\":\"we then opened the file and looked at it for a while and moved on\"}]}\n" as *u8)
  to2 = sj_cat(tb2, to2, "{\"timestamp\":\"2026-07-23T00:00:02Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"a\",\"name\":\"Edit\"}]}\n" as *u8)
  to2 = sj_cat(tb2, to2, "{\"timestamp\":\"2026-07-23T00:00:03Z\",\"c\":[{\"type\":\"text\",\"text\":\"★★★★ gate on the resource the work actually consumes\"}]}\n" as *u8)
  to2 = sj_cat(tb2, to2, "{\"timestamp\":\"2026-07-23T00:00:04Z\",\"c\":[{\"type\":\"text\",\"text\":\"the axes run 0..1000 and -1 means UNMEASURED for this row\"}]}\n" as *u8)
  to2 = sj_cat(tb2, to2, "{\"timestamp\":\"2026-07-23T00:00:05Z\",\"c\":[{\"type\":\"text\",\"text\":\"LAW: an echoed frame must not become two separate records\"},{\"type\":\"text\",\"text\":\"LAW: an echoed frame must not become two separate records\"}]}\n" as *u8)
  sys_write(tfd2, tb2, to2)
  sys_close(tfd2)
  let lcx2: *i64 = sys_mmap(64) as *i64
  let lgot: i64 = ch_learn(lt, "lw" as *u8, lo2, lc, lcx2)
  let lb2: *u8 = sys_mmap(CH_JWIN)
  let ln2: i64 = ch_read(lo2, lb2, CH_JWIN - 8)
  var ok23: i64 = 0
  if ln2 > 0 { if ch_find(lb2, ln2, "\"rank\":6" as *u8) == 1 { ok23 = 1 } }
  gv_check("T23 learn captures a LAW: PROSE line at rank 6 (the thing frames/delta never could)" as *u8, ok23, ctr)
  var ok24: i64 = 1
  if ln2 > 0 { if ch_find(lb2, ln2, "looked at it for a while" as *u8) == 1 { ok24 = 0 } }
  gv_check("T24 NEG-CONTROL: unmarked prose ABOVE min_len is REJECTED -- the ranker can fail" as *u8, ok24, ctr)
  var ok25: i64 = 1
  if ln2 > 0 { if ch_find(lb2, ln2, "Edit" as *u8) == 1 { ok25 = 0 } }
  gv_check("T25 learn ignores tool_use frames entirely -- learn is not a second frames" as *u8, ok25, ctr)
  var ok26: i64 = 0
  if lcx2[1] >= 2 { ok26 = 1 }
  gv_check("T26 markers/weights come from the conf file, never compiled in (rule 11)" as *u8, ok26, ctr)
  var ok27: i64 = 0
  if ln2 > 0 { if ch_find(lb2, ln2, "\"rank\":4" as *u8) == 1 { ok27 = 1 } }
  gv_check("T27 a 4-star run ranks 4 -- multi-byte glyph run counted as bytes, not chars" as *u8, ok27, ctr)
  var ok28: i64 = 0
  if lgot == 3 { ok28 = 1 }
  gv_check("T28 exactly 3 of 6 transcript lines clear the floor (kept count is not a dump)" as *u8, ok28, ctr)
  var ok29: i64 = 1
  if ln2 > 0 { if ch_find(lb2, ln2, "axes run 0..1000" as *u8) == 1 { ok29 = 0 } }
  gv_check("T29 WORD BOUNDARY: UNMEASURED does not match the marker MEASURED (substring flattery)" as *u8, ok29, ctr)
  var ok30: i64 = 0
  var dcount: i64 = 0
  var dp: i64 = 0
  while dp < ln2 {
      let dq: i64 = ch_find_from(lb2, dp, ln2, "an echoed frame must not become" as *u8)
      if dq < 0 { dp = ln2 } else { dcount = dcount + 1; dp = dq + 20 }
  }
  if dcount == 1 { ok30 = 1 }
  gv_check("T30 an echoed payload emits ONCE, not twice (adjacent-duplicate suppression)" as *u8, ok30, ctr)
  // ================= beat teeth (DM1 ch_beat, 2026-08-20; fixtures assembled at RUNTIME) =================
  let btroot: *u8 = sys_mmap(512)
  o = sj_cat(btroot, 0, prefix)
  o = sj_catn(btroot, o, now)
  o = sj_cat(btroot, o, "btroot" as *u8)
  btroot[o] = 0 as u8
  let btpa: *u8 = sys_mmap(512)
  o = sj_cat(btpa, 0, btroot)
  o = sj_cat(btpa, o, "/pA" as *u8)
  btpa[o] = 0 as u8
  let btsub: *u8 = sys_mmap(512)
  o = sj_cat(btsub, 0, btpa)
  o = sj_cat(btsub, o, "/subagents" as *u8)
  btsub[o] = 0 as u8
  let btstate: *u8 = sys_mmap(512)
  o = sj_cat(btstate, 0, prefix)
  o = sj_catn(btstate, o, now)
  o = sj_cat(btstate, o, "btstate" as *u8)
  btstate[o] = 0 as u8
  let btspool: *u8 = sys_mmap(512)
  o = sj_cat(btspool, 0, prefix)
  o = sj_catn(btspool, o, now)
  o = sj_cat(btspool, o, "btspool" as *u8)
  btspool[o] = 0 as u8
  let btdone: *u8 = sys_mmap(512)
  o = sj_cat(btdone, 0, prefix)
  o = sj_catn(btdone, o, now)
  o = sj_cat(btdone, o, "btdone" as *u8)
  btdone[o] = 0 as u8
  let btjrnl: *u8 = sys_mmap(512)
  o = sj_cat(btjrnl, 0, prefix)
  o = sj_catn(btjrnl, o, now)
  o = sj_cat(btjrnl, o, "btjrnl" as *u8)
  btjrnl[o] = 0 as u8
  let bttwin: *u8 = sys_mmap(512)
  o = sj_cat(bttwin, 0, prefix)
  o = sj_catn(bttwin, o, now)
  o = sj_cat(bttwin, o, "bttwin" as *u8)
  bttwin[o] = 0 as u8
  sys_mkdir(btroot, CH_MODE_755)
  sys_mkdir(btpa, CH_MODE_755)
  sys_mkdir(btsub, CH_MODE_755)
  sys_mkdir(bttwin, CH_MODE_755)
  let bts1: *u8 = sys_mmap(512)
  o = sj_cat(bts1, 0, btpa)
  o = sj_cat(bts1, o, "/s1.jsonl" as *u8)
  bts1[o] = 0 as u8
  let bts2: *u8 = sys_mmap(512)
  o = sj_cat(bts2, 0, btsub)
  o = sj_cat(bts2, o, "/s2.jsonl" as *u8)
  bts2[o] = 0 as u8
  let btfd: i64 = sys_openat_append(bts1, CH_MODE_644)
  lo = sj_cat(lb, 0, "{\"type\":\"zzz-newtype\",\"x\":1}" as *u8)
  lb[lo] = 10 as u8
  sys_write(btfd, lb, lo + 1)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:01Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"a\",\"name\":\"Edit\"},{\"type\":\"tool_use\",\"id\":\"b\",\"name\":\"PowerShell\"}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(btfd, lb, lo + 1)
  lo = sj_cat(lb, 0, "{\"type\":\"user\",\"uuid\":\"u1\"}" as *u8)
  lb[lo] = 10 as u8
  sys_write(btfd, lb, lo + 1)
  sys_close(btfd)
  let btfd2: i64 = sys_openat_append(bts2, CH_MODE_644)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-08-19T10:00:01Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"c\",\"name\":\"mcp__nishi__nx_fs\"}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(btfd2, lb, lo + 1)
  sys_close(btfd2)
  // conf assembled at runtime (rule 11 even in the fixture)
  let btconf: *u8 = sys_mmap(512)
  o = sj_cat(btconf, 0, prefix)
  o = sj_catn(btconf, o, now)
  o = sj_cat(btconf, o, "btconf" as *u8)
  btconf[o] = 0 as u8
  let btcb: *u8 = sys_mmap(4096)
  var bo: i64 = sj_cat(btcb, 0, "root=" as *u8)
  bo = sj_cat(btcb, bo, btroot)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "state=" as *u8)
  bo = sj_cat(btcb, bo, btstate)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "spool=" as *u8)
  bo = sj_cat(btcb, bo, btspool)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "done=" as *u8)
  bo = sj_cat(btcb, bo, btdone)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "journal=" as *u8)
  bo = sj_cat(btcb, bo, btjrnl)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "push=0" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "known_type=user" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "known_type=assistant" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  let btcfd: i64 = sys_openat_wr(btconf, CH_MODE_644)
  sys_write(btcfd, btcb, bo)
  sys_close(btcfd)
  let bcx1: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64
  let brc1: i64 = ch_beat(btconf, bcx1)
  var ok31: i64 = 0
  if brc1 == 0 { if bcx1[0] == 2 { if bcx1[1] == 2 { if bcx1[2] == 0 { if bcx1[3] == 0 { if bcx1[27] == 1 { ok31 = 1 } } } } } }
  gv_check("T31 beat walks every transcript at every depth and the file partition SUMS" as *u8, ok31, ctr)
  var ok32: i64 = 0
  if bcx1[4] == 3 { if bcx1[5] == 3 { ok32 = 1 } }
  gv_check("T32 frames reconcile against the independent tooluse-mark census (two counters, free audit)" as *u8, ok32, ctr)
  var ok33: i64 = 0
  if bcx1[6] == 4 { if bcx1[8] == 1 { if bcx1[9] == 1 { if bcx1[10] == 2 { ok33 = 1 } } } }
  gv_check("T33 head-type census: known/UNKNOWN/headless partition sums; nested types never read as record types" as *u8, ok33, ctr)
  let btj1: *u8 = sys_mmap(512)
  o = sj_cat(btj1, 0, btjrnl)
  o = sj_cat(btj1, o, "/chbeat_20260723.jrnl" as *u8)
  btj1[o] = 0 as u8
  let btj2: *u8 = sys_mmap(512)
  o = sj_cat(btj2, 0, btjrnl)
  o = sj_cat(btj2, o, "/chbeat_20260819.jrnl" as *u8)
  btj2[o] = 0 as u8
  let btb1: *u8 = sys_mmap(CH_JWIN)
  let btn1: i64 = ch_read(btj1, btb1, CH_JWIN - 8)
  let btb2: *u8 = sys_mmap(CH_JWIN)
  var btn2: i64 = ch_read(btj2, btb2, CH_JWIN - 8)
  var ok34: i64 = 0
  if btn1 > 0 { if btn2 > 0 { if ch_find(btb1, btn1, "Edit" as *u8) == 1 { if ch_find(btb1, btn1, "mcp__nishi__nx_fs" as *u8) == 0 { if ch_find(btb2, btn2, "mcp__nishi__nx_fs" as *u8) == 1 { ok34 = 1 } } } } }
  gv_check("T34 ts-day routing: each frame lands in its OWN day journal, never cross-filed" as *u8, ok34, ctr)
  let bcx2: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64
  let brc2: i64 = ch_beat(btconf, bcx2)
  let btn1b: i64 = ch_read(btj1, btb1, CH_JWIN - 8)
  var ok35: i64 = 0
  if brc2 == 0 { if bcx2[2] == 2 { if bcx2[4] == 0 { if bcx2[12] == 0 { if btn1b == btn1 { ok35 = 1 } } } } }
  gv_check("T35 re-run is exactly-once: all files skipped-unchanged, zero frames, journal byte-identical" as *u8, ok35, ctr)
  let btfd3: i64 = sys_openat_append(bts2, CH_MODE_644)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-08-19T11:00:00Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"d\",\"name\":\"Grep\"}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(btfd3, lb, lo + 1)
  lo = sj_cat(lb, 0, "{\"c\":[{\"type\":\"tool_use\",\"id\":\"e\",\"name\":\"NoTsTool\"}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(btfd3, lb, lo + 1)
  sys_close(btfd3)
  let bcx3: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64
  let brc3: i64 = ch_beat(btconf, bcx3)
  var ok36: i64 = 0
  if brc3 == 0 { if bcx3[1] == 1 { if bcx3[2] == 1 { if bcx3[4] == 2 { if bcx3[15] == 1 { ok36 = 1 } } } } }
  gv_check("T36 growth delta-harvests ONLY the new lines from the banked mark" as *u8, ok36, ctr)
  let btjz: *u8 = sys_mmap(512)
  o = sj_cat(btjz, 0, btjrnl)
  o = sj_cat(btjz, o, "/chbeat_tszero.jrnl" as *u8)
  btjz[o] = 0 as u8
  let btnz: i64 = ch_read(btjz, btb1, CH_JWIN - 8)
  btn2 = ch_read(btj2, btb2, CH_JWIN - 8)
  var ok37: i64 = 0
  if btnz > 0 { if ch_find(btb1, btnz, "NoTsTool" as *u8) == 1 { if btn2 > 0 { if ch_find(btb2, btn2, "Grep" as *u8) == 1 { if ch_find(btb2, btn2, "NoTsTool" as *u8) == 0 { ok37 = 1 } } } } }
  gv_check("T37 a frame without a parseable timestamp lands in chbeat_tszero.jrnl -- its OWN bucket, never folded" as *u8, ok37, ctr)
  // twin landing: ingest the SAME pieces into a second journal dir and demand gauge agreement
  let btar: *u8 = sys_mmap(CH_BT_ARENA)
  let btfo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64
  let btwcx: *i64 = sys_mmap(64) as *i64
  let btnp: i64 = ch_bt_walk(btspool, ".frames" as *u8, btar, btfo, btwcx)
  let btmcx: *i64 = sys_mmap(16) as *i64
  let btday: *u8 = sys_mmap(CH_BT_DAYCELL)
  let bttj: *u8 = sys_mmap(512)
  var bpi: i64 = 0
  while bpi < btnp {
      let bpp: *u8 = ((btar as i64) + btfo[bpi]) as *u8
      let bpb: *u8 = ch_bt_base(bpp)
      if ch_starts(bpb, 0, sj_vlen(bpb), "cb" as *u8) == 1 {
          ch_bt_pieceday(bpb, btday)
          var oz: i64 = sj_cat(bttj, 0, bttwin)
          bttj[oz] = 47 as u8
          oz = oz + 1
          oz = sj_cat(bttj, oz, "chbeat_" as *u8)
          oz = sj_cat(bttj, oz, btday)
          oz = sj_cat(bttj, oz, ".jrnl" as *u8)
          bttj[oz] = 0 as u8
          ch_ingest(bpp, bttj, btmcx)
      }
      bpi = bpi + 1
  }
  var oz2: i64 = sj_cat(bttj, 0, bttwin)
  bttj[oz2] = 47 as u8
  oz2 = oz2 + 1
  oz2 = sj_cat(bttj, oz2, "chbeat_20260819.jrnl" as *u8)
  bttj[oz2] = 0 as u8
  var dlA: i64 = ch_gauge_json(btj2, 0, d)
  let gfA: i64 = ch_bt_int_after(d, dlA, "\"frames_total\":" as *u8)
  let goA: i64 = ch_bt_int_after(d, dlA, "\"outside\":" as *u8)
  let gpA: i64 = ch_bt_int_after(d, dlA, "\"outside_permil\":" as *u8)
  var dlB: i64 = ch_gauge_json(bttj, 0, d)
  let gfB: i64 = ch_bt_int_after(d, dlB, "\"frames_total\":" as *u8)
  let goB: i64 = ch_bt_int_after(d, dlB, "\"outside\":" as *u8)
  let gpB: i64 = ch_bt_int_after(d, dlB, "\"outside_permil\":" as *u8)
  var ok38: i64 = 0
  if gfA > 0 { if gfA == gfB { if goA == goB { if gpA == gpB { ok38 = 1 } } } }
  gv_check("T38 gauge over the landing twin agrees EXACTLY with gauge over the local journal (the NAS-vs-laptop instrument agreement, in fixture)" as *u8, ok38, ctr)
  // plant a truncated landing: the reconcile MUST catch it, and the gauges MUST diverge
  let btp1: *u8 = sys_mmap(512)
  var btp1n: i64 = 0
  bpi = 0
  while bpi < btnp {
      let bpp2: *u8 = ((btar as i64) + btfo[bpi]) as *u8
      let bpb2: *u8 = ch_bt_base(bpp2)
      if ch_starts(bpb2, 0, sj_vlen(bpb2), "cb20260723" as *u8) == 1 { btp1n = sj_cat(btp1, 0, bpp2); btp1[btp1n] = 0 as u8 }
      bpi = bpi + 1
  }
  let btpb: *u8 = sys_mmap(CH_JWIN)
  let btpn: i64 = ch_read(btp1, btpb, CH_JWIN - 8)
  let btcut: *u8 = sys_mmap(512)
  o = sj_cat(btcut, 0, prefix)
  o = sj_catn(btcut, o, now)
  o = sj_cat(btcut, o, "cut1.frames" as *u8)
  btcut[o] = 0 as u8
  let btcfd2: i64 = sys_openat_wr(btcut, CH_MODE_644)
  sys_write(btcfd2, btpb, btpn - 10)
  sys_close(btcfd2)
  let bttj2: *u8 = sys_mmap(512)
  o = sj_cat(bttj2, 0, bttwin)
  o = sj_cat(bttj2, o, "/chbeat_cutcase.jrnl" as *u8)
  bttj2[o] = 0 as u8
  let btr9: i64 = ch_ingest(btcut, bttj2, btmcx)
  let btpl: i64 = ch_bt_lines(btp1)
  var ok39: i64 = 0
  if btpl == 2 { if btr9 == 1 { if btmcx[0] == 1 { if btr9 != btpl { ok39 = 1 } } } }
  gv_check("T39 neg-control-truncated-landing: ingested-frames != staged-frames and malformed counted -- the push reconcile catches a cut landing" as *u8, ok39, ctr)
  // conf missing a required key refuses, NAMING it
  let btconf2: *u8 = sys_mmap(512)
  o = sj_cat(btconf2, 0, prefix)
  o = sj_catn(btconf2, o, now)
  o = sj_cat(btconf2, o, "btconf2" as *u8)
  btconf2[o] = 0 as u8
  bo = sj_cat(btcb, 0, "root=" as *u8)
  bo = sj_cat(btcb, bo, btroot)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "state=" as *u8)
  bo = sj_cat(btcb, bo, btstate)
  btcb[bo] = 10 as u8
  bo = bo + 1
  let btcfd3: i64 = sys_openat_wr(btconf2, CH_MODE_644)
  sys_write(btcfd3, btcb, bo)
  sys_close(btcfd3)
  let bcx4: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64
  let brc4: i64 = ch_beat(btconf2, bcx4)
  var ok40: i64 = 0
  if brc4 == 2 { ok40 = 1 }
  gv_check("T40 neg-control-conf-missing-required-key refuses fail-closed (never invents a path)" as *u8, ok40, ctr)
  // push with a DEAD wire: every piece stays spooled -- wrong only toward doing nothing
  let btconf3: *u8 = sys_mmap(512)
  o = sj_cat(btconf3, 0, prefix)
  o = sj_catn(btconf3, o, now)
  o = sj_cat(btconf3, o, "btconf3" as *u8)
  btconf3[o] = 0 as u8
  bo = sj_cat(btcb, 0, "root=" as *u8)
  bo = sj_cat(btcb, bo, btroot)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "state=" as *u8)
  bo = sj_cat(btcb, bo, btstate)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "spool=" as *u8)
  bo = sj_cat(btcb, bo, btspool)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "done=" as *u8)
  bo = sj_cat(btcb, bo, btdone)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "journal=" as *u8)
  bo = sj_cat(btcb, bo, btjrnl)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "push=1" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "push_max=8" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "nas_stage=knowledge/status/chbeat/stage" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "nas_journal=knowledge/status/chbeat" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "wire=" as *u8)
  bo = sj_cat(btcb, bo, prefix)
  bo = sj_catn(btcb, bo, now)
  bo = sj_cat(btcb, bo, "nowire" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "wire_script=x" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "cap_write=x" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "cap_ingest=x" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "cap_read=x" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "hash_elf=" as *u8)
  bo = sj_cat(btcb, bo, prefix)
  bo = sj_catn(btcb, bo, now)
  bo = sj_cat(btcb, bo, "nohash" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  let btcfd4: i64 = sys_openat_wr(btconf3, CH_MODE_644)
  sys_write(btcfd4, btcb, bo)
  sys_close(btcfd4)
  let bcx5: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64
  let brc5: i64 = ch_beat(btconf3, bcx5)
  var ok41: i64 = 0
  if brc5 == 1 { if bcx5[16] > 0 { if bcx5[17] == 0 { if bcx5[18] == bcx5[16] { if bcx5[19] > 0 { ok41 = 1 } } } } }
  gv_check("T41 neg-control-push-wire-dead: every piece stays spooled and every failure is counted -- wrong only toward doing nothing" as *u8, ok41, ctr)
  // journal cliff budget rides the conf and announces
  let btconf4: *u8 = sys_mmap(512)
  o = sj_cat(btconf4, 0, prefix)
  o = sj_catn(btconf4, o, now)
  o = sj_cat(btconf4, o, "btconf4" as *u8)
  btconf4[o] = 0 as u8
  bo = sj_cat(btcb, 0, "root=" as *u8)
  bo = sj_cat(btcb, bo, btroot)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "state=" as *u8)
  bo = sj_cat(btcb, bo, btstate)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "spool=" as *u8)
  bo = sj_cat(btcb, bo, btspool)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "done=" as *u8)
  bo = sj_cat(btcb, bo, btdone)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "journal=" as *u8)
  bo = sj_cat(btcb, bo, btjrnl)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "push=0" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  bo = sj_cat(btcb, bo, "jrnl_cliff=64" as *u8)
  btcb[bo] = 10 as u8
  bo = bo + 1
  let btcfd5: i64 = sys_openat_wr(btconf4, CH_MODE_644)
  sys_write(btcfd5, btcb, bo)
  sys_close(btcfd5)
  let bcx6: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64
  let brc6: i64 = ch_beat(btconf4, bcx6)
  var ok42: i64 = 0
  if brc6 == 0 { if bcx6[28] > 1000 { ok42 = 1 } }
  gv_check("T42 the journal cliff budget rides the conf and the fill announce fires PAST-CLIFF on a tiny budget" as *u8, ok42, ctr)
  // push-parser teeth: each decision parser must be able to FAIL
  let btpp: *u8 = sys_mmap(256)
  var btppn: i64 = sj_cat(btpp, 0, "{\"organ\":\"nx_filehash\",\"sha256\":\"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\",\"bytes\":7}" as *u8)
  let btsha: *u8 = sys_mmap(80)
  var ok43: i64 = 0
  if ch_bt_parse_sha(btpp, btppn, btsha) == 1 {
      btppn = sj_cat(btpp, 0, "{\"sha256\":\"zz\"}" as *u8)
      if ch_bt_parse_sha(btpp, btppn, btsha) == 0 {
          btppn = sj_cat(btpp, 0, "INGEST OK frames=42 malformed=0" as *u8)
          if ch_bt_int_after(btpp, btppn, "INGEST OK frames=" as *u8) == 42 {
              if ch_bt_int_after(btpp, btppn, "bytes=" as *u8) == (0 - 1) { ok43 = 1 }
          }
      }
  }
  gv_check("T43 push decision parsers accept the real shapes and REFUSE malformed ones (a parser that cannot fail is not a parser)" as *u8, ok43, ctr)
  // T44 the push-reason truth table. The defect this replaces answered "fail-verify" for an upload
  // that never landed, so the two ABSENT causes -- which have OPPOSITE remedies (retry the write vs
  // investigate a write that lied) -- shared one name. Walk the whole table, then assert they differ.
  var ok44: i64 = 0
  if ch_bt_zeq(ch_bt_pushreason(0, 0, 0), "fail-write" as *u8) == 1 {
      if ch_bt_zeq(ch_bt_pushreason(1, 0, 0), "fail-verify-absent" as *u8) == 1 {
          if ch_bt_zeq(ch_bt_pushreason(1, 1, 0), "fail-verify-mismatch" as *u8) == 1 {
              if ch_bt_zeq(ch_bt_pushreason(1, 1, 1), "ok" as *u8) == 1 {
                  if ch_bt_zeq(ch_bt_pushreason(0, 0, 0), ch_bt_pushreason(1, 0, 0)) == 0 { ok44 = 1 }
              }
          }
      }
  }
  gv_check("T44 neg-control-push-reason-distinct: a write that never landed and a write that lied get DIFFERENT names (the wrong-stage defect cannot return)" as *u8, ok44, ctr)
  // ---- CE1 leg 2: write frames carry the PATH they touched (additive note token) ----
  let tj2: *u8 = sys_mmap(512)
  o = sj_cat(tj2, 0, prefix)
  o = sj_catn(tj2, o, now)
  o = sj_cat(tj2, o, ".t2" as *u8)
  tj2[o] = 0 as u8
  let fr2: *u8 = sys_mmap(512)
  o = sj_cat(fr2, 0, prefix)
  o = sj_catn(fr2, o, now)
  o = sj_cat(fr2, o, ".frames2" as *u8)
  fr2[o] = 0 as u8
  let t2fd: i64 = sys_openat_append(tj2, CH_MODE_644)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:05Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"w1\",\"name\":\"mcp__nishi__nx_fs_write\",\"input\":{\"argv\":[\"edit\",\"buildroot/runtime/x_fixture.nx\",\"old\",\"new\"],\"_cap\":\"zz\"}}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(t2fd, lb, lo + 1)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:06Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"w2\",\"name\":\"Write\",\"input\":{\"file_path\":\"C:/Users/e/m.md\",\"content\":\"x \\\"file_path\\\":\\\"decoy\\\" y\"}}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(t2fd, lb, lo + 1)
  lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:07Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"r1\",\"name\":\"mcp__nishi__nx_fs\",\"input\":{\"argv\":[\"read\",\"buildroot/runtime/x_fixture.nx\"]}}]}" as *u8)
  lb[lo] = 10 as u8
  sys_write(t2fd, lb, lo + 1)
  sys_close(t2fd)
  let tcx2: *i64 = sys_mmap(16) as *i64
  let got2: i64 = ch_frames(tj2, "wpath" as *u8, fr2, tcx2)
  let fb2: *u8 = sys_mmap(CH_JWIN)
  let fn2: i64 = ch_read(fr2, fb2, CH_JWIN - 8)
  var ok45: i64 = 0
  if got2 == 3 { if fn2 > 0 { if ch_find(fb2, fn2, "path=buildroot/runtime/x_fixture.nx" as *u8) == 1 { ok45 = 1 } } }
  gv_check("T45 an nx_fs_write frame carries path= from argv[1], the verb in argv[0] never mistaken for it" as *u8, ok45, ctr)
  var ok46: i64 = 0
  if fn2 > 0 { if ch_find(fb2, fn2, "path=C:/Users/e/m.md" as *u8) == 1 { if ch_find(fb2, fn2, "path=decoy" as *u8) == 0 { ok46 = 1 } } }
  gv_check("T46 a Write frame carries path= from file_path and a decoy key inside its CONTENT is never read as the path" as *u8, ok46, ctr)
  var pc: i64 = 0
  var px: i64 = 0
  var pg: i64 = 1
  let pkey: *u8 = "path=" as *u8
  while pg == 1 { if fn2 <= 0 { pg = 0 } else { let pf: i64 = ch_find_from(fb2, px, fn2, pkey); if pf < 0 { pg = 0 } else { pc = pc + 1; px = pf + sj_vlen(pkey) } } }
  var ok47: i64 = 0
  if pc == 2 { ok47 = 1 }
  gv_check("T47 NEG-CONTROL: a READER frame (nx_fs) carries no path token -- exactly two of three frames do" as *u8, ok47, ctr)
  // ---- CE1 leg 2: ce_author_health on a PLANTED tree prefix, a planted journal and a planted spine ----
  let ahp: *u8 = sys_mmap(512)
  o = sj_cat(ahp, 0, prefix); o = sj_catn(ahp, o, now); o = sj_cat(ahp, o, "ah_" as *u8); ahp[o] = 0 as u8
  let aha: *u8 = sys_mmap(512); o = sj_cat(aha, 0, ahp); o = sj_cat(aha, o, "a.nx" as *u8); aha[o] = 0 as u8
  let ahb: *u8 = sys_mmap(512); o = sj_cat(ahb, 0, ahp); o = sj_cat(ahb, o, "b.nx" as *u8); ahb[o] = 0 as u8
  let ahc: *u8 = sys_mmap(512); o = sj_cat(ahc, 0, ahp); o = sj_cat(ahc, o, "c.txt" as *u8); ahc[o] = 0 as u8
  let ahj: *u8 = sys_mmap(512); o = sj_cat(ahj, 0, ahp); o = sj_cat(ahj, o, "frames.jrnl" as *u8); ahj[o] = 0 as u8
  let ahs: *u8 = sys_mmap(512); o = sj_cat(ahs, 0, ahp); o = sj_cat(ahs, o, "mccabe.spine" as *u8); ahs[o] = 0 as u8
  let ahn: *u8 = sys_mmap(512); o = sj_cat(ahn, 0, ahp); o = sj_cat(ahn, o, "nope.spine" as *u8); ahn[o] = 0 as u8
  let ahfa: i64 = sys_openat_wr(aha, CH_MODE_644)
  lo = sj_cat(lb, 0, "func t(a: i64) -> i64 {\n    if a>0 { return 1 }\n    return 0\n}\n" as *u8)
  sys_write(ahfa, lb, lo); sys_close(ahfa)
  let ahfb: i64 = sys_openat_wr(ahb, CH_MODE_644)
  lo = sj_cat(lb, 0, "func t() -> i64 {\n    return 0\n}\n" as *u8)
  sys_write(ahfb, lb, lo); sys_close(ahfb)
  let ahfc: i64 = sys_openat_wr(ahc, CH_MODE_644)
  lo = sj_cat(lb, 0, "not nishilang\n" as *u8)
  sys_write(ahfc, lb, lo); sys_close(ahfc)
  let ahfs: i64 = sys_openat_wr(ahs, CH_MODE_644)
  lo = sj_cat(lb, 0, "1788600000|files=10|funcs=20|above_10=3|permille=150|classes=0|UNMARKED:10:20:3\n" as *u8)
  sys_write(ahfs, lb, lo); sys_close(ahfs)
  let ahnb: *u8 = sys_mmap(1024)
  let ahfj: i64 = sys_openat_append(ahj, CH_MODE_644)
  var ano: i64 = sj_cat(ahnb, 0, "delta path=" as *u8); ano = sj_cat(ahnb, ano, aha); ahnb[ano] = 0 as u8
  ch_frame_write(ahfj, lb, CH_AH_FIX_TS, "sessA" as *u8, "mcp__nishi__nx_fs_write" as *u8, "use" as *u8, "-" as *u8, ahnb)
  ch_frame_write(ahfj, lb, CH_AH_FIX_TS + 1, "sessA" as *u8, "mcp__nishi__nx_fs_write" as *u8, "use" as *u8, "-" as *u8, ahnb)
  ano = sj_cat(ahnb, 0, "delta path=" as *u8); ano = sj_cat(ahnb, ano, ahb); ahnb[ano] = 0 as u8
  ch_frame_write(ahfj, lb, CH_AH_FIX_TS + 2, "sessB" as *u8, "Write" as *u8, "use" as *u8, "-" as *u8, ahnb)
  ano = sj_cat(ahnb, 0, "delta path=" as *u8); ano = sj_cat(ahnb, ano, ahc); ahnb[ano] = 0 as u8
  ch_frame_write(ahfj, lb, CH_AH_FIX_TS + 3, "sessB" as *u8, "mcp__nishi__nx_fs_write" as *u8, "use" as *u8, "-" as *u8, ahnb)
  ch_frame_write(ahfj, lb, CH_AH_FIX_TS + 4, "sessB" as *u8, "mcp__nishi__nx_fs" as *u8, "use" as *u8, "-" as *u8, "delta" as *u8)
  sys_close(ahfj)
  let acx: *i64 = sys_mmap(8 * CH_AH_CTRS) as *i64
  let aob: *u8 = sys_mmap(CH_OUT)
  let arc: i64 = ce_author_health(ahj, ahp, ahs, acx, aob)
  var ok48: i64 = 0
  if arc == 0 { if acx[CH_AH_FILES] == 2 { if acx[CH_AH_FUNCS] == 2 { if acx[CH_AH_SUMVG] == 3 { if acx[CH_AH_ABOVE] == 0 { if acx[CH_AH_DFILES] == CH_AH_FIX_DFILES { if acx[CH_AH_DFUNCS] == CH_AH_FIX_DFUNCS { if acx[CH_AH_DABOVE] == CH_AH_FIX_DABOVE { ok48 = 1 } } } } } } } }
  gv_check("T48 author-health: two seat-written .nx files scanned once, vG 2+1 hand-computed, denominator read from the spine's LAST row" as *u8, ok48, ctr)
  var ok49: i64 = 0
  if acx[CH_AH_FRAMES] == 5 { if acx[CH_AH_PATHFRAMES] == 4 { if acx[CH_AH_UNIQUE] == 3 { if acx[CH_AH_INTREE] == 2 { if acx[CH_AH_OUTSIDE] == 1 { if acx[CH_AH_SESSIONS] == 2 { if acx[CH_AH_FIRSTTS] == CH_AH_FIX_TS { ok49 = 1 } } } } } } }
  gv_check("T49 author-health partition: a duplicate write counts ONCE, a non-.nx path is counted apart, sessions and first ts are exact" as *u8, ok49, ctr)
  let arc2: i64 = ce_author_health(ahj, ahp, ahn, acx, aob)
  var ok50: i64 = 0
  if arc2 == CH_AH_RC_UNOBS { if acx[CH_AH_DFILES] == 0 { if acx[CH_AH_FILES] == 2 { ok50 = 1 } } }
  gv_check("T50 NEG-CONTROL: an absent spine reads UNOBSERVABLE-DENOMINATOR (rc 3) with NO fabricated denominator, seat figures still measured" as *u8, ok50, ctr)
  let arc3: i64 = ce_author_health(fr, ahp, ahs, acx, aob)
  var ok51: i64 = 0
  if arc3 == CH_AH_RC_NOPATH { if acx[CH_AH_PATHFRAMES] == 0 { if acx[CH_AH_FILES] == 0 { ok51 = 1 } } }
  gv_check("T51 NEG-CONTROL: a journal whose frames carry no path reads NO-PATH-FRAMES (rc 4), never a zero that looks measured" as *u8, ok51, ctr)
  let rc: i64 = gv_verdict("CLAWHARV-GATE" as *u8, ctr, "transcript parse + delta hwm + ingest + gauge + page + propose + bootgauge + capture-beat teeth green" as *u8)
  return rc
1850}
1851
1852// ---------- learn: LEARNING-TEXT harvest (root fix for debt 1785525736) ----------
1853// Every other verb in this organ extracts "type":"tool_use" NAMES. That is tool TELEMETRY, not
1854// learning capture: ch_frame_write puts '-' in the two columns where a lesson would go, and the
1855// 6-hourly beat reported fail=0 for weeks while moving ZERO learnings, over transcripts holding
1856// ~40k LAW:/LESSON/ROOT CAUSE/FINDING: statements. This verb reads the PROSE instead -- the "text"
1857// payloads written by the assistant and the operator -- ranks each line, and keeps only what clears
1858// the floor. Because it CAN reject plain prose, its output is evidence rather than a transcript dump.
1859// Rule 11: every marker, weight and floor is loaded from a conf file. No weight is written in code.
1860const CH_MK_MAX: i64 = 64
1861const CH_CONF_WIN: i64 = 65536
1862const CH_TXTWIN: i64 = 262144
1863
1864// longest run of CONSECUTIVE occurrences of a (possibly multi-byte) glyph in q[s..e)
1865// the star/warn glyphs are 3-byte UTF-8, so this compares byte sequences, never single chars.
1866func ch_run_of(q: *u8, s: i64, e: i64, g: *u8) -> i64 {
  let gl: i64 = sj_vlen(g)
  if gl <= 0 { return 0 }
  var best: i64 = 0
  var i: i64 = s
  while i < e {
      var run: i64 = 0
      var j: i64 = i
      var go: i64 = 1
      while go == 1 {
          if j + gl > e { go = 0 } else {
              var k: i64 = 0
              var same: i64 = 1
              while k < gl {
                  if q[j+k] != g[k] { same = 0; k = gl } else { k = k + 1 }
              }
              if same == 1 { run = run + 1; j = j + gl } else { go = 0 }
          }
      }
      if run > best { best = run }
      if run > 0 { i = j } else { i = i + 1 }
  }
  return best
1889}
1890
1891// conf loader. mk is INTERLEAVED (mk[2k]=literal offset into cbuf, mk[2k+1]=weight) so this stays
1892// at 4 params; sc carries the scalars: 0=warn_bonus 1=min_rank 2=min_len 3=max_len 4=star_off
1893// 5=warn_off 6=star_max 7=marker_count. Returns marker count, or -1 if the conf cannot be read --
1894// FAIL-CLOSED: no conf means no ranking basis, so the verb refuses rather than inventing weights.
1895func ch_conf_load(path: *u8, cbuf: *u8, mk: *i64, sc: *i64) -> i64 {
  let n: i64 = ch_read(path, cbuf, CH_CONF_WIN - 8)
  if n <= 0 { return 0 - 1 }
  sc[0] = 2
  sc[1] = 3
  sc[2] = 40
  sc[3] = 400
  sc[4] = 0 - 1
  sc[5] = 0 - 1
  sc[6] = 6
  var cnt: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(cbuf, i, n)
      if cbuf[i] != (35 as u8) {
          if ch_starts(cbuf, i, le, "marker=" as *u8) == 1 {
              if cnt < CH_MK_MAX {
                  let vs: i64 = i + 7
                  var bar: i64 = 0 - 1
                  var p: i64 = vs
                  while p < le { if cbuf[p] == (124 as u8) { bar = p } p = p + 1 }
                  if bar > vs {
                      cbuf[bar] = 0 as u8
                      cbuf[le] = 0 as u8
                      mk[cnt*2] = vs
                      mk[cnt*2+1] = sj_atoi_z(((cbuf as i64) + bar + 1) as *u8)
                      cnt = cnt + 1
                  }
              }
          }
          if ch_starts(cbuf, i, le, "star_char=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[4] = i + 10 }
          if ch_starts(cbuf, i, le, "warn_char=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[5] = i + 10 }
          if ch_starts(cbuf, i, le, "warn_bonus=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[0] = sj_atoi_z(((cbuf as i64) + i + 11) as *u8) }
          if ch_starts(cbuf, i, le, "min_rank_store=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[1] = sj_atoi_z(((cbuf as i64) + i + 15) as *u8) }
          if ch_starts(cbuf, i, le, "min_len=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[2] = sj_atoi_z(((cbuf as i64) + i + 8) as *u8) }
          if ch_starts(cbuf, i, le, "max_len=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[3] = sj_atoi_z(((cbuf as i64) + i + 8) as *u8) }
          if ch_starts(cbuf, i, le, "star_max=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[6] = sj_atoi_z(((cbuf as i64) + i + 9) as *u8) }
      }
      i = le + 1
  }
  sc[7] = cnt
  return cnt
1937}
1938
1939// a marker must sit on a WORD BOUNDARY. Measured on real prose: the naive substring test scored
1940// "UNMEASURED" as the marker "MEASURED" and promoted a doc line to rank 3 -- a substring needle
1941// flatters silently. Only the left edge needs guarding (markers are prefixes like "LAW:").
1942func ch_isalpha(c: u8) -> i64 {
  if c >= (65 as u8) { if c <= (90 as u8) { return 1 } }
  if c >= (97 as u8) { if c <= (122 as u8) { return 1 } }
  return 0
1946}
1947
1948// rank = the MAX of the signals, never the mean (banked law): a star run is the operator's own
1949// ranking convention, a warn glyph is a callout worth rank+bonus, and marker phrases carry their
1950// configured weight. Capped at star_max so a decorative row of stars cannot outrank a real law.
1951func ch_rank_text(q: *u8, s: i64, e: i64, cbuf: *u8, mk: *i64, sc: *i64) -> i64 {
  var r: i64 = 0
  if sc[4] >= 0 {
      let sr: i64 = ch_run_of(q, s, e, ((cbuf as i64) + sc[4]) as *u8)
      if sr > r { r = sr }
  }
  if sc[5] >= 0 {
      let wr: i64 = ch_run_of(q, s, e, ((cbuf as i64) + sc[5]) as *u8)
      if wr > 0 { let wv: i64 = wr + sc[0]; if wv > r { r = wv } }
  }
  var k: i64 = 0
  while k < sc[7] {
      let lit: *u8 = ((cbuf as i64) + mk[k*2]) as *u8
      var from: i64 = s
      var hit: i64 = 0
      while hit == 0 {
          let hp: i64 = ch_find_from(q, from, e, lit)
          if hp < 0 { hit = 0 - 1 } else {
              var okb: i64 = 1
              if hp > s { if ch_isalpha(q[hp-1]) == 1 { okb = 0 } }
              if okb == 1 { hit = 1 } else { from = hp + 1 }
          }
      }
      if hit == 1 { if mk[k*2+1] > r { r = mk[k*2+1] } }
      k = k + 1
  }
  if r > sc[6] { r = sc[6] }
  return r
1979}
1980
1981func ch_learn(tpath: *u8, ws: *u8, outp: *u8, confp: *u8, cx: *i64) -> i64 {
  let cbuf: *u8 = sys_mmap(CH_CONF_WIN)
  let mk: *i64 = sys_mmap(CH_MK_MAX * 16) as *i64
  let sc: *i64 = sys_mmap(128) as *i64
  let cnt: i64 = ch_conf_load(confp, cbuf, mk, sc)
  if cnt < 0 { return 0 - 4 }
  cx[1] = cnt
  let buf: *u8 = sys_mmap(CH_WIN)
  let cap: i64 = CH_WIN - 8
  let n: i64 = ch_read(tpath, buf, cap)
  cx[0] = 0
  if n <= 0 { return 0 - 1 }
  if n >= cap { cx[0] = 1 }
  let fd: i64 = sys_openat_append(outp, CH_MODE_644)
  if fd < 0 { return 0 - 3 }
  let tb: *u8 = sys_mmap(CH_TXTWIN)
  let ob: *u8 = sys_mmap(CH_TXTWIN)
  // last emitted segment. A real transcript frame carries the same assistant text more than once
  // (the message and its echo), so without this the organ emits provable duplicates -- measured 2
  // identical records from one real line. Adjacent-compare, not a full set: the echo is adjacent.
  let pb: *u8 = sys_mmap(CH_TXTWIN)
  var pl: i64 = 0
  var kept: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(buf, i, n)
      var ts: i64 = 0
      let tp: i64 = ch_find_from(buf, i, le, "\"timestamp\":\"" as *u8)
      if tp >= 0 { ts = ch_iso_epoch(buf, tp + 13, le) }
      var j: i64 = i
      var go: i64 = 1
      while go == 1 {
          let xp: i64 = ch_find_from(buf, j, le, "\"text\":\"" as *u8)
          if xp < 0 { go = 0 } else {
              var p: i64 = xp + 8
              var to: i64 = 0
              var g2: i64 = 1
              while g2 == 1 {
                  if p >= le { g2 = 0 } else {
                      let c: u8 = buf[p]
                      if c == (34 as u8) { g2 = 0 } else {
                          if c == (92 as u8) {
                              let d2: u8 = buf[p+1]
                              var em: u8 = d2
                              if d2 == (110 as u8) { em = 10 as u8 }
                              if d2 == (116 as u8) { em = 32 as u8 }
                              if d2 == (114 as u8) { em = 32 as u8 }
                              if to < CH_TXTWIN - 4 { tb[to] = em; to = to + 1 }
                              p = p + 2
                          } else {
                              if to < CH_TXTWIN - 4 { tb[to] = c; to = to + 1 }
                              p = p + 1
                          }
                      }
                  }
              }
              var q: i64 = 0
              while q < to {
                  let qe: i64 = sj_le(tb, q, to)
                  let seg: i64 = qe - q
                  if seg >= sc[2] {
                      var endq: i64 = qe
                      if seg > sc[3] { endq = q + sc[3] }
                      let r: i64 = ch_rank_text(tb, q, endq, cbuf, mk, sc)
                      var dup: i64 = 0
                      if pl == (endq - q) {
                          var z: i64 = 0
                          var sm: i64 = 1
                          while z < pl { if pb[z] != tb[q+z] { sm = 0; z = pl } else { z = z + 1 } }
                          if sm == 1 { dup = 1 }
                      }
                      if r >= sc[1] { if dup == 0 {
                          var o: i64 = sj_cat(ob, 0, "{\"ts\":" as *u8)
                          o = sj_catn(ob, o, ts)
                          o = sj_cat(ob, o, ",\"ws\":\"" as *u8)
                          o = sj_cat(ob, o, ws)
                          o = sj_cat(ob, o, "\",\"src\":\"transcript\",\"rank\":" as *u8)
                          o = sj_catn(ob, o, r)
                          o = sj_cat(ob, o, ",\"text\":\"" as *u8)
                          var k2: i64 = q
                          while k2 < endq {
                              let c2: u8 = tb[k2]
                              if c2 == (34 as u8) { ob[o] = 92 as u8; o = o + 1; ob[o] = 34 as u8; o = o + 1 } else {
                                  if c2 == (92 as u8) { ob[o] = 92 as u8; o = o + 1; ob[o] = 92 as u8; o = o + 1 } else {
                                      if c2 < (32 as u8) { ob[o] = 32 as u8; o = o + 1 } else { ob[o] = c2; o = o + 1 }
                                  }
                              }
                              k2 = k2 + 1
                          }
                          o = sj_cat(ob, o, "\"}" as *u8)
                          ob[o] = 10 as u8
                          sys_write(fd, ob, o + 1)
                          pl = endq - q
                          var z3: i64 = 0
                          while z3 < pl { pb[z3] = tb[q+z3]; z3 = z3 + 1 }
                          kept = kept + 1
                      } }
                  }
                  q = qe + 1
              }
              j = p + 1
          }
      }
      i = le + 1
  }
  sys_close(fd)
  return kept
2088}
2089
2090// ================= beat: DM1 session->NAS capture (devmgmt /compare rung, 2026-08-20) =================
2091// The dev record is laptop-local (837 transcripts / 2.29 GB measured 2026-08-20 under
2092// ~/.claude/projects, at THREE depths: sessions, subagents/, subagents/workflows/); the NAS clock plane
2093// cannot reach the laptop, so the beat RUNS WHERE THE TRANSCRIPTS LIVE (this organ is portable by
2094// design) and PUSHES. Pipeline: walk -> ch_delta per transcript (per-transcript byte HWM in state/)
2095// -> split fresh frames into ts-day PIECES -> ingest every piece into the LOCAL per-day journal twin
2096// -> when push=1, per piece: upload via the forked MCP wire (nx_fs_write), byte-verify with
2097// nx_filehash on BOTH sides (one ruler), NAS-side ch_ingest into the per-day NAS journal, announce
2098// journal fill. PIECES ARE THE CHUNK UNIT AND THE INGEST UNIT: each stays under the MCP body cliff
2099// and is marker-idempotent via ch_ingest, so the pipeline is resumable at every stage with no append
2100// primitive over the wire. A piece leaves the spool only after the NAS leg confirms; every failure
2101// leaves it spooled -- wrong only toward doing nothing.
2102// DAY PARTITION DERIVATION: heaviest measured day (2026-08-19: 32,122 MCP calls / 836,673 transcript
2103// lines across 7 seats) stages ~2-4 MB of frames -- a day is the largest calendar unit whose worst
2104// measured case still fits the 4 MiB gauge window (CH_JWIN), so per-day journals keep the NAS-side
2105// gauge untruncated. Frames whose timestamp cannot parse route to chbeat_tszero.jrnl -- their own
2106// bucket, never folded.
2107// Rule 11: every path, bound and cadence datum rides chbeat.conf; the beat consts live in the module
2108// const block at the top (single-pass parser: the selftest teeth read them first).
2109
2110func ch_bt_zeq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] == b[i] { if a[i] == (0 as u8) { return 1 } i = i + 1 }
  return 0
2114}
2115func ch_bt_ends(s: *u8, sfx: *u8) -> i64 {
  let n: i64 = sj_vlen(s)
  let m: i64 = sj_vlen(sfx)
  if n < m { return 0 }
  return sj_lit_eq(s, n - m, n, sfx)
2120}
2121func ch_bt_le16(b: *u8, off: i64) -> i64 { return (b[off] as i64) + (b[off+1] as i64) * 256 }
2122func ch_bt_le64(b: *u8, off: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 7
  while i >= 0 { v = v * 256 + (b[off+i] as i64); i = i - 1 }
  return v
2127}
2128// stat: k[0]=file kind as the DT_* value ((st_mode>>12)&0xF equals DT_DIR/DT_REG numerically by Linux
2129// design), k[1]=size. sb = caller scratch >= 160 B (never allocated here -- runs once per dirent).
2130// st_mode u16 at offset 24, st_size i64 at offset 48 (x86_64 struct stat; the same offsets
2131// nx_artifactdrift ps_execbit reads). Arithmetic field extraction, no bitwise ops needed.
2132func ch_bt_stat(path: *u8, sb: *u8, k: *i64) -> i64 {
  k[0] = 0
  k[1] = 0 - 1
  if sys_fstatat(path, sb) != 0 { return 0 - 1 }
  let mode: i64 = ch_bt_le16(sb, 24)
  k[0] = (mode / 4096) % 16
  k[1] = ch_bt_le64(sb, 48)
  return 0
2140}
2141// recursive walk: every file ending <sfx> under root, ANY depth (sessions, subagents/, workflows/).
2142// getdents64 LOOPED until 0 per directory (one call is a prefix -- banked law); d_type on 9p/drvfs is
2143// often DT_UNKNOWN -> fstatat fallback, counted. fo[i] = arena offset of file path i.
2144// Returns file count, or -1 = table/arena overflow (caller REFUSES loudly -- never a silent cap).
2145// wcx: 0=dirs_walked 1=dir_open_errors 2=stat_fallbacks 3=arena_used
2146func ch_bt_walk(root: *u8, sfx: *u8, ar: *u8, fo: *i64, wcx: *i64) -> i64 {
  let dq: *i64 = sys_mmap(8 * CH_BT_MAXDIRS) as *i64
  let db: *u8 = sys_mmap(CH_BT_DIRWIN)
  let sb: *u8 = sys_mmap(256)
  let kk: *i64 = sys_mmap(16) as *i64
  var ap: i64 = 0
  var dh: i64 = 0
  var dt2: i64 = 0
  var nf: i64 = 0
  wcx[0] = 0
  wcx[1] = 0
  wcx[2] = 0
  wcx[3] = 0
  let rl: i64 = sj_vlen(root)
  if rl + 2 > CH_BT_ARENA { return 0 - 1 }
  dq[dt2] = ap
  var o: i64 = sj_cat(ar, ap, root)
  ar[o] = 0 as u8
  ap = o + 1
  dt2 = dt2 + 1
  while dh < dt2 {
      let dpo: i64 = dq[dh]
      dh = dh + 1
      let dpath: *u8 = ((ar as i64) + dpo) as *u8
      let dl: i64 = sj_vlen(dpath)
      let fd: i64 = sys_openat_rd(dpath)
      if fd < 0 { wcx[1] = wcx[1] + 1 } else {
          var more: i64 = 1
          while more == 1 {
              let r: i64 = sys_getdents64(fd, db, CH_BT_DIRWIN)
              if r <= 0 { more = 0 } else {
                  var p: i64 = 0
                  while p < r {
                      let rec: *u8 = ((db as i64) + p) as *u8
                      let rl2: i64 = dirent_reclen(rec)
                      if rl2 <= 0 { p = r; more = 0 } else {
                          var ty: i64 = dirent_type(rec)
                          let nm: *u8 = dirent_name(rec)
                          var dot: i64 = 0
                          if nm[0] == (46 as u8) {
                              if nm[1] == (0 as u8) { dot = 1 }
                              if nm[1] == (46 as u8) { if nm[2] == (0 as u8) { dot = 1 } }
                          }
                          if dot == 0 {
                              let nl: i64 = sj_vlen(nm)
                              if ap + dl + nl + 2 > CH_BT_ARENA { sys_close(fd); return 0 - 1 }
                              let po: i64 = ap
                              var q: i64 = sj_cat(ar, po, dpath)
                              ar[q] = 47 as u8
                              q = q + 1
                              q = sj_cat(ar, q, nm)
                              ar[q] = 0 as u8
                              let full: *u8 = ((ar as i64) + po) as *u8
                              if ty == 0 { wcx[2] = wcx[2] + 1; if ch_bt_stat(full, sb, kk) == 0 { ty = kk[0] } }
                              var keep: i64 = 0
                              if ty == DT_DIR {
                                  if dt2 >= CH_BT_MAXDIRS { sys_close(fd); return 0 - 1 }
                                  dq[dt2] = po
                                  dt2 = dt2 + 1
                                  keep = 1
                              } else {
                                  if ty == DT_REG { if ch_bt_ends(full, sfx) == 1 {
                                      if nf >= CH_BT_MAXFILES { sys_close(fd); return 0 - 1 }
                                      fo[nf] = po
                                      nf = nf + 1
                                      keep = 1
                                  } }
                              }
                              if keep == 1 { ap = q + 1 }
                          }
                          p = p + rl2
                      }
                  }
              }
          }
          sys_close(fd)
          wcx[0] = wcx[0] + 1
      }
  }
  wcx[3] = ap
  return nf
2227}
2228// epoch -> zero-padded YYYYMMDD (Hinnant civil-from-days, the exact inverse of ch_epoch_ymdhms).
2229// ts <= 0 -> "tszero": frames without a parseable timestamp keep their OWN journal bucket.
2230func ch_bt_day(ts: i64, d: *u8) -> i64 {
  if ts <= 0 { let o: i64 = sj_cat(d, 0, "tszero" as *u8); d[o] = 0 as u8; return o }
  let z: i64 = ts / CH_MAGIC_86400 + CH_MAGIC_719468
  let era: i64 = z / CH_MAGIC_146097
  let doe: i64 = z - era * CH_MAGIC_146097
  let yoe: i64 = (doe - doe / CH_MAGIC_1460 + doe / CH_MAGIC_36524 - doe / CH_MAGIC_146096) / 365
  var y: i64 = yoe + era * 400
  let doy: i64 = doe - (365 * yoe + yoe / 4 - yoe / 100)
  let mp: i64 = (5 * doy + 2) / 153
  let dd: i64 = doy - (153 * mp + 2) / 5 + 1
  var m: i64 = 0
  if mp < 10 { m = mp + 3 } else { m = mp - 9 }
  if m <= 2 { y = y + 1 }
  d[0] = (48 + (y / 1000) % 10) as u8
  d[1] = (48 + (y / 100) % 10) as u8
  d[2] = (48 + (y / 10) % 10) as u8
  d[3] = (48 + y % 10) as u8
  d[4] = (48 + (m / 10) % 10) as u8
  d[5] = (48 + m % 10) as u8
  d[6] = (48 + (dd / 10) % 10) as u8
  d[7] = (48 + dd % 10) as u8
  d[8] = 0 as u8
  return 8
2253}
2254// conf: key=value rows; '#' comments. Values zero-terminate IN cbuf; the value offset is DERIVED from
2255// the key literal's own length (sj_vlen) -- never a hand-counted twin beside the literal (banked law).
2256func ch_bt_kv(cbuf: *u8, i: i64, le: i64, key: *u8) -> i64 {
  if ch_starts(cbuf, i, le, key) == 1 { cbuf[le] = 0 as u8; return i + sj_vlen(key) }
  return 0 - 1
2259}
2260// off: 0 root 1 state 2 spool 3 done 4 journal 5 nas_stage 6 nas_journal 7 wire 8 wire_script
2261//      9 cap_write 10 cap_ingest 11 cap_read 12 hash_elf     (-1 = absent)
2262// iv:  0 push 1 push_max 2 piece_raw 3 wire_timeout_ms 4 jrnl_cliff 5 jrnl_warn_permil
2263// kt interleaved known_type rows (offset,count); count in kcx[0]
2264// returns 0, -1 unreadable conf, -2 required key missing (NAMED on stdout) -- fail-closed both ways.
2265func ch_bt_conf(path: *u8, cbuf: *u8, off: *i64, iv: *i64, kt: *i64, kcx: *i64) -> i64 {
  let n: i64 = ch_read(path, cbuf, CH_CONF_WIN - 8)
  if n <= 0 { return 0 - 1 }
  var w: i64 = 0
  while w < 13 { off[w] = 0 - 1; w = w + 1 }
  iv[0] = 0
  iv[1] = 0
  // derived default: ~9% JSON-escape inflation on the 6 control bytes per ~80 B frame plus a ~1 KiB
  // rpc envelope cannot push 3/4 of the measured body cliff across it
  iv[2] = CH_MCP_BODY_CLIFF * 3 / 4
  // derived default: matches the estate MCP client's own 120000 ms call deadline
  iv[3] = 120000
  // derived default: the day-journal cliff IS the gauge/verify window
  iv[4] = CH_JWIN
  // derived default: AMBER from four fifths of the cliff (the sizeguard amber-before-red shape)
  iv[5] = 1000 * 4 / 5
  kcx[0] = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(cbuf, i, n)
      if cbuf[i] != (35 as u8) {
          var v: i64 = ch_bt_kv(cbuf, i, le, "root=" as *u8)
          if v >= 0 { off[0] = v }
          v = ch_bt_kv(cbuf, i, le, "state=" as *u8)
          if v >= 0 { off[1] = v }
          v = ch_bt_kv(cbuf, i, le, "spool=" as *u8)
          if v >= 0 { off[2] = v }
          v = ch_bt_kv(cbuf, i, le, "done=" as *u8)
          if v >= 0 { off[3] = v }
          v = ch_bt_kv(cbuf, i, le, "journal=" as *u8)
          if v >= 0 { off[4] = v }
          v = ch_bt_kv(cbuf, i, le, "nas_stage=" as *u8)
          if v >= 0 { off[5] = v }
          v = ch_bt_kv(cbuf, i, le, "nas_journal=" as *u8)
          if v >= 0 { off[6] = v }
          v = ch_bt_kv(cbuf, i, le, "wire=" as *u8)
          if v >= 0 { off[7] = v }
          v = ch_bt_kv(cbuf, i, le, "wire_script=" as *u8)
          if v >= 0 { off[8] = v }
          v = ch_bt_kv(cbuf, i, le, "cap_write=" as *u8)
          if v >= 0 { off[9] = v }
          v = ch_bt_kv(cbuf, i, le, "cap_ingest=" as *u8)
          if v >= 0 { off[10] = v }
          v = ch_bt_kv(cbuf, i, le, "cap_read=" as *u8)
          if v >= 0 { off[11] = v }
          v = ch_bt_kv(cbuf, i, le, "hash_elf=" as *u8)
          if v >= 0 { off[12] = v }
          v = ch_bt_kv(cbuf, i, le, "push=" as *u8)
          if v >= 0 { iv[0] = sj_atoi_z(((cbuf as i64) + v) as *u8) }
          v = ch_bt_kv(cbuf, i, le, "push_max=" as *u8)
          if v >= 0 { iv[1] = sj_atoi_z(((cbuf as i64) + v) as *u8) }
          v = ch_bt_kv(cbuf, i, le, "piece_raw=" as *u8)
          if v >= 0 { iv[2] = sj_atoi_z(((cbuf as i64) + v) as *u8) }
          v = ch_bt_kv(cbuf, i, le, "wire_timeout_ms=" as *u8)
          if v >= 0 { iv[3] = sj_atoi_z(((cbuf as i64) + v) as *u8) }
          v = ch_bt_kv(cbuf, i, le, "jrnl_cliff=" as *u8)
          if v >= 0 { iv[4] = sj_atoi_z(((cbuf as i64) + v) as *u8) }
          v = ch_bt_kv(cbuf, i, le, "jrnl_warn_permil=" as *u8)
          if v >= 0 { iv[5] = sj_atoi_z(((cbuf as i64) + v) as *u8) }
          v = ch_bt_kv(cbuf, i, le, "known_type=" as *u8)
          if v >= 0 { if kcx[0] < CH_MK_MAX { kt[kcx[0] * 2] = v; kt[kcx[0] * 2 + 1] = 0; kcx[0] = kcx[0] + 1 } }
      }
      i = le + 1
  }
  var miss: i64 = 0 - 1
  if off[0] < 0 { miss = 0 }
  if off[1] < 0 { if miss < 0 { miss = 1 } }
  if off[2] < 0 { if miss < 0 { miss = 2 } }
  if off[3] < 0 { if miss < 0 { miss = 3 } }
  if off[4] < 0 { if miss < 0 { miss = 4 } }
  if miss >= 0 {
      let eb: *u8 = sys_mmap(256)
      var o2: i64 = sj_cat(eb, 0, "CHBEAT CONF-MISSING key=" as *u8)
      if miss == 0 { o2 = sj_cat(eb, o2, "root" as *u8) }
      if miss == 1 { o2 = sj_cat(eb, o2, "state" as *u8) }
      if miss == 2 { o2 = sj_cat(eb, o2, "spool" as *u8) }
      if miss == 3 { o2 = sj_cat(eb, o2, "done" as *u8) }
      if miss == 4 { o2 = sj_cat(eb, o2, "journal" as *u8) }
      eb[o2] = 10 as u8
      sys_write(1, eb, o2 + 1)
      return 0 - 2
  }
  return 0
2348}
2349// head-type census + tool_use marks over the freshly harvested window [from,to) of ONE transcript.
2350// ANCHORED at line position 0 -- a nested "type" deeper in the line can never be read as the record
2351// type (measured 2026-08-20: attachment lines carry a NESTED type FIRST, so a first-occurrence scan
2352// answers the wrong field). Lines whose type is not the first key count HEADLESS -- named for what was
2353// measured; the head census watches the head-shaped population only, and that imprecision is declared
2354// here. Unknown head-types intern into their own worklist (ua/uo/ucx), never folded into a known one.
2355// ccx: 0=lines 1=tooluse_lines 2=tooluse_marks 3=head_known 4=head_unknown 5=headless
2356//      6=census_read_fail 7=type_table_overflow(FLOOR flag)   ucx: 0=distinct_unknown 1=ua_cursor
2357func ch_bt_census(tpath: *u8, from: i64, to: i64, cbuf: *u8, kt: *i64, kn: i64, ua: *u8, uo: *i64, ucx: *i64, ccx: *i64) -> i64 {
  let nn: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_map_file(tpath, nn)
  let n: i64 = nn[0]
  if n <= 0 { ccx[6] = ccx[6] + 1; return 0 - 1 }
  var lim: i64 = to
  if lim > n { lim = n }
  let tul: *u8 = "\"type\":\"tool_use\"" as *u8
  let tuln: i64 = sj_vlen(tul)
  let hl: *u8 = "{\"type\":\"" as *u8
  let hln: i64 = sj_vlen(hl)
  var i: i64 = from
  if i < 0 { i = 0 }
  while i < lim {
      let le: i64 = sj_le(buf, i, lim)
      if le > i {
          ccx[0] = ccx[0] + 1
          var marks: i64 = 0
          var j: i64 = i
          var go: i64 = 1
          while go == 1 {
              let tu: i64 = ch_find_from(buf, j, le, tul)
              if tu < 0 { go = 0 } else { marks = marks + 1; j = tu + tuln }
          }
          if marks > 0 { ccx[1] = ccx[1] + 1; ccx[2] = ccx[2] + marks }
          if ch_starts(buf, i, le, hl) == 1 {
              let vs: i64 = i + hln
              var ve: i64 = vs
              var g2: i64 = 1
              while g2 == 1 {
                  if ve >= le { g2 = 0 } else { if buf[ve] == (34 as u8) { g2 = 0 } else { ve = ve + 1 } }
              }
              var hit: i64 = 0
              var k: i64 = 0
              while k < kn {
                  let lit: *u8 = ((cbuf as i64) + kt[k * 2]) as *u8
                  if sj_lit_eq(buf, vs, ve, lit) == 1 { kt[k * 2 + 1] = kt[k * 2 + 1] + 1; hit = 1; k = kn } else { k = k + 1 }
              }
              if hit == 1 { ccx[3] = ccx[3] + 1 } else {
                  ccx[4] = ccx[4] + 1
                  var f: i64 = 0 - 1
                  var k2: i64 = 0
                  while k2 < ucx[0] {
                      let ul: *u8 = ((ua as i64) + uo[k2 * 2]) as *u8
                      if sj_lit_eq(buf, vs, ve, ul) == 1 { f = k2; k2 = ucx[0] } else { k2 = k2 + 1 }
                  }
                  if f >= 0 { uo[f * 2 + 1] = uo[f * 2 + 1] + 1 } else {
                      if ucx[0] < CH_BT_TYPEMAX {
                          var vl2: i64 = ve - vs
                          if vl2 > CH_NAME_MAX { vl2 = CH_NAME_MAX }
                          uo[ucx[0] * 2] = ucx[1]
                          uo[ucx[0] * 2 + 1] = 1
                          var c2: i64 = 0
                          while c2 < vl2 { ua[ucx[1] + c2] = buf[vs + c2]; c2 = c2 + 1 }
                          ua[ucx[1] + vl2] = 0 as u8
                          ucx[1] = ucx[1] + vl2 + 1
                          ucx[0] = ucx[0] + 1
                      } else { ccx[7] = 1 }
                  }
              }
          } else { ccx[5] = ccx[5] + 1 }
      }
      i = le + 1
  }
  sys_munmap(buf, n)
  return 0
2423}
2424func ch_bt_path2(out: *u8, a: *u8, b: *u8) -> i64 {
  var o: i64 = sj_cat(out, 0, a)
  out[o] = 47 as u8
  o = o + 1
  o = sj_cat(out, o, b)
  out[o] = 0 as u8
  return o
2431}
2432func ch_bt_base(path: *u8) -> *u8 {
  var bs: i64 = 0
  var i: i64 = 0
  while path[i] != (0 as u8) { if path[i] == (47 as u8) { bs = i + 1 } i = i + 1 }
  return ((path as i64) + bs) as *u8
2437}
2438func ch_bt_stem(path: *u8, out: *u8) -> i64 {
  let b: *u8 = ch_bt_base(path)
  let n: i64 = sj_vlen(b)
  var e: i64 = n - sj_vlen(".jsonl" as *u8)
  if e < 0 { e = n }
  var o: i64 = 0
  while o < e { out[o] = b[o]; o = o + 1 }
  out[o] = 0 as u8
  return o
2447}
2448func ch_bt_hwmpath(state: *u8, rel: *u8, out: *u8) -> i64 {
  var o: i64 = sj_cat(out, 0, state)
  out[o] = 47 as u8
  o = o + 1
  var i: i64 = 0
  while rel[i] != (0 as u8) {
      var c: u8 = rel[i]
      if c == (47 as u8) { c = 95 as u8 }
      if c == (92 as u8) { c = 95 as u8 }
      out[o] = c
      o = o + 1
      i = i + 1
  }
  o = sj_cat(out, o, ".hwm" as *u8)
  out[o] = 0 as u8
  return o
2464}
2465// frame count of a piece (pieces are written by ch_bt_split, every line newline-terminated)
2466func ch_bt_lines(path: *u8) -> i64 {
  let nn: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_map_file(path, nn)
  let n: i64 = nn[0]
  if n <= 0 { return 0 }
  var c: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(buf, i, n)
      if le > i { c = c + 1 }
      i = le + 1
  }
  sys_munmap(buf, n)
  return c
2480}
2481// first integer right after <key> in b[0..n) -> value, or -1 when key or digits absent
2482func ch_bt_int_after(b: *u8, n: i64, key: *u8) -> i64 {
  let p: i64 = ch_find_from(b, 0, n, key)
  if p < 0 { return 0 - 1 }
  var i: i64 = p + sj_vlen(key)
  var v: i64 = 0
  var any: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if i >= n { go = 0 } else {
          let c: i64 = b[i] as i64
          var dig: i64 = 0
          if c >= 48 { if c <= 57 { dig = 1 } }
          if dig == 1 { v = v * 10 + (c - 48); any = 1; i = i + 1 } else { go = 0 }
      }
  }
  if any == 0 { return 0 - 1 }
  return v
2499}
2500// sha256 hex right after "sha256":" -> out (65 B incl NUL); 1 ok, 0 absent/short/non-hex
2501func ch_bt_parse_sha(b: *u8, n: i64, out: *u8) -> i64 {
  let key: *u8 = "\"sha256\":\"" as *u8
  let p: i64 = ch_find_from(b, 0, n, key)
  if p < 0 { return 0 }
  let s: i64 = p + sj_vlen(key)
  var i: i64 = 0
  while i < 64 {
      if s + i >= n { return 0 }
      let c: i64 = b[s + i] as i64
      var okc: i64 = 0
      if c >= 48 { if c <= 57 { okc = 1 } }
      if c >= 97 { if c <= 102 { okc = 1 } }
      if okc == 0 { return 0 }
      out[i] = b[s + i]
      i = i + 1
  }
  out[64] = 0 as u8
  return 1
2519}
2520// forked call through the MCP wire: <wire> <script> <tool> <cap> [a1..a4]; captures stdout+stderr.
2521// Returns the child's exit code (127 = wire absent). The wire is TRANSPORT ONLY -- every decision
2522// over its output happens in this organ (shell-is-break-glass discipline; the wire is the sanctioned
2523// MCP client, nxmcp.py, forked with a clean argv, no shell interpretation anywhere).
2524func ch_bt_wire(wire: *u8, script: *u8, tool: *u8, cap: *u8, a1: *u8, a2: *u8, a3: *u8, a4: *u8, tmo: i64, cout: *u8, colen: *i64) -> i64 {
  let av: *i64 = sys_mmap(96) as *i64
  av[0] = wire as i64
  av[1] = script as i64
  av[2] = tool as i64
  av[3] = cap as i64
  var k: i64 = 4
  if (a1 as i64) != 0 { av[k] = a1 as i64; k = k + 1 }
  if (a2 as i64) != 0 { av[k] = a2 as i64; k = k + 1 }
  if (a3 as i64) != 0 { av[k] = a3 as i64; k = k + 1 }
  if (a4 as i64) != 0 { av[k] = a4 as i64; k = k + 1 }
  av[k] = 0
  return tr_run_capture_to(wire, av, cout, CH_OUT - 8, colen, tmo)
2537}
2538func ch_bt_flushp(spool: *u8, day: *u8, stamp: i64, seq: i64, cell: *u8, clen: i64) -> i64 {
  let pp: *u8 = sys_mmap(CH_BT_PATHMAX)
  var o: i64 = sj_cat(pp, 0, spool)
  pp[o] = 47 as u8
  o = o + 1
  o = sj_cat(pp, o, "cb" as *u8)
  o = sj_cat(pp, o, day)
  pp[o] = 95 as u8
  o = o + 1
  o = sj_catn(pp, o, stamp)
  pp[o] = 95 as u8
  o = o + 1
  o = sj_catn(pp, o, seq)
  o = sj_cat(pp, o, ".frames" as *u8)
  pp[o] = 0 as u8
  let fd: i64 = sys_openat_wr(pp, CH_MODE_644)
  if fd < 0 { return 0 - 3 }
  sys_write(fd, cell, clen)
  sys_close(fd)
  return 0
2558}
2559// split a raw delta-frames file into ts-day pieces, each under piece_raw bytes at a FRAME boundary.
2560// Piece names cb<day>_<stamp>_<seq>.frames are DETERMINISTIC from the raw file's stamp, so a re-split
2561// after a crash rewrites identical names and content and every downstream stage stays idempotent by
2562// marker. dcx: 0=pieces 1=bytes 2=days 3=tszero_frames 4=frames
2563// returns 0, -2 day-table overflow (REFUSED loudly), -3 piece write fail
2564func ch_bt_split(rawpath: *u8, spool: *u8, stamp: i64, piece_raw: i64, dcx: *i64) -> i64 {
  dcx[0] = 0
  dcx[1] = 0
  dcx[2] = 0
  dcx[3] = 0
  dcx[4] = 0
  let nn: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_map_file(rawpath, nn)
  let n: i64 = nn[0]
  if n <= 0 { return 0 }
  let cellsz: i64 = piece_raw + CH_LINE
  let dayn: *u8 = sys_mmap(CH_BT_DAYMAX * CH_BT_DAYCELL)
  let dbuf: *u8 = sys_mmap(CH_BT_DAYMAX * cellsz)
  let dlen: *i64 = sys_mmap(8 * CH_BT_DAYMAX) as *i64
  let dseq: *i64 = sys_mmap(8 * CH_BT_DAYMAX) as *i64
  let sp: *i64 = sys_mmap(16) as *i64
  let dstr: *u8 = sys_mmap(CH_BT_DAYCELL)
  var nd: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = sj_le(buf, i, n)
      if le > i {
          var ts: i64 = 0
          if sj_col(buf, i, le, 0, sp) == 1 { if ch_digits(buf, sp[0], sp[1]) == 1 { ts = sj_atoi_span(buf, sp[0], sp[1]) } }
          ch_bt_day(ts, dstr)
          if ts <= 0 { dcx[3] = dcx[3] + 1 }
          var di: i64 = 0 - 1
          var k: i64 = 0
          while k < nd {
              if ch_bt_zeq(((dayn as i64) + k * CH_BT_DAYCELL) as *u8, dstr) == 1 { di = k; k = nd } else { k = k + 1 }
          }
          if di < 0 {
              if nd >= CH_BT_DAYMAX { sys_munmap(buf, n); return 0 - 2 }
              var c3: i64 = 0
              var g3: i64 = 1
              while g3 == 1 {
                  let ch: u8 = dstr[c3]
                  dayn[nd * CH_BT_DAYCELL + c3] = ch
                  if ch == (0 as u8) { g3 = 0 } else { c3 = c3 + 1 }
              }
              dlen[nd] = 0
              dseq[nd] = 0
              di = nd
              nd = nd + 1
          }
          let ll2: i64 = le - i
          if dlen[di] + ll2 + 1 > piece_raw {
              if dlen[di] > 0 {
                  let fr: i64 = ch_bt_flushp(spool, ((dayn as i64) + di * CH_BT_DAYCELL) as *u8, stamp, dseq[di], ((dbuf as i64) + di * cellsz) as *u8, dlen[di])
                  if fr != 0 { sys_munmap(buf, n); return fr }
                  dcx[0] = dcx[0] + 1
                  dseq[di] = dseq[di] + 1
                  dlen[di] = 0
              }
          }
          let cell: *u8 = ((dbuf as i64) + di * cellsz) as *u8
          var c4: i64 = 0
          while c4 < ll2 { cell[dlen[di] + c4] = buf[i + c4]; c4 = c4 + 1 }
          cell[dlen[di] + ll2] = 10 as u8
          dlen[di] = dlen[di] + ll2 + 1
          dcx[1] = dcx[1] + ll2 + 1
          dcx[4] = dcx[4] + 1
      }
      i = le + 1
  }
  var k5: i64 = 0
  while k5 < nd {
      if dlen[k5] > 0 {
          let fr2: i64 = ch_bt_flushp(spool, ((dayn as i64) + k5 * CH_BT_DAYCELL) as *u8, stamp, dseq[k5], ((dbuf as i64) + k5 * cellsz) as *u8, dlen[k5])
          if fr2 != 0 { sys_munmap(buf, n); return fr2 }
          dcx[0] = dcx[0] + 1
      }
      k5 = k5 + 1
  }
  dcx[2] = nd
  sys_munmap(buf, n)
  return 0
2641}
2642// copy the day span out of a piece basename cb<day>_... into db (NUL-terminated)
2643func ch_bt_pieceday(pbase: *u8, db: *u8) -> i64 {
  var di: i64 = sj_vlen("cb" as *u8)
  var o: i64 = 0
  var g: i64 = 1
  while g == 1 {
      let c: u8 = pbase[di]
      if c == (95 as u8) { g = 0 } else {
          if c == (0 as u8) { g = 0 } else {
              if o < CH_BT_DAYCELL - 2 { db[o] = c; o = o + 1 }
              di = di + 1
          }
      }
  }
  db[o] = 0 as u8
  return o
2658}
2659// WHICH STAGE OWNS A FAILED PUSH? Three causes with three DIFFERENT remedies, so three names --
2660// never one bucket. Until 2026-08-20 an upload that never landed was journalled as "fail-verify",
2661// blaming the verifier for the writer's failure; it cost a real investigation (the artifact was simply
2662// ABSENT and the journal pointed at the wrong leg).
2663//   * A MESSAGE THAT NAMES THE WRONG STAGE COSTS THE READER THE INVESTIGATION IT WAS WRITTEN TO SAVE
2664//     THEM, and two causes with opposite remedies must never share one counter.
2665// This is a TEXT read, not an rc read, and that is measured, not assumed: nx_fs_write returns rc=0
2666// EVEN WHEN IT REFUSES (`REFUSED would-clobber ... (file unchanged)`), so a guard branching on rc
2667// would never have fired. A would-clobber refusal is ALSO not a failure here -- it is the idempotent
2668// re-push of a piece that already landed, and the hash verify is what adjudicates it, which is why
2669// this function decides from the VERIFY's findings and uses the write's own line only to attribute
2670// the ABSENT case. Pure and total so the gate can walk the whole truth table.
2671//   wrote_ok  the upload leg printed its own OK line
2672//   okr       the remote artifact could be hashed at all (0 = nothing is there)
2673//   same      remote bytes == local bytes
2674func ch_bt_pushreason(wrote_ok: i64, okr: i64, same: i64) -> *u8 {
  if okr == 0 {
      if wrote_ok == 1 { return "fail-verify-absent" as *u8 }
      return "fail-write" as *u8
  }
  if same == 0 { return "fail-verify-mismatch" as *u8 }
  return "ok" as *u8
2681}
2682// push one piece: local-hash -> upload -> remote-hash-verify -> NAS ingest -> journal-fill announce.
2683// Returns 0 = NAS leg confirmed (piece may leave the spool), 1 = left spooled (stage named in the
2684// push journal). Every stage is idempotent: re-upload of a landed piece is refused-then-verified
2685// equal by hash, re-ingest answers ALREADY. Wrong only toward doing nothing.
2686func ch_bt_push1(ppath: *u8, cbuf: *u8, off: *i64, iv: *i64, pjr: *u8, bcx: *i64) -> i64 {
  let pbase: *u8 = ch_bt_base(ppath)
  let cout: *u8 = sys_mmap(CH_OUT)
  let colen: *i64 = sys_mmap(16) as *i64
  let lsha: *u8 = sys_mmap(80)
  let rsha: *u8 = sys_mmap(80)
  let napath: *u8 = sys_mmap(CH_BT_PATHMAX)
  let njpath: *u8 = sys_mmap(CH_BT_PATHMAX)
  let ob: *u8 = sys_mmap(CH_LINE)
  let wire: *u8 = ((cbuf as i64) + off[7]) as *u8
  let script: *u8 = ((cbuf as i64) + off[8]) as *u8
  let capw: *u8 = ((cbuf as i64) + off[9]) as *u8
  let capi: *u8 = ((cbuf as i64) + off[10]) as *u8
  let capr: *u8 = ((cbuf as i64) + off[11]) as *u8
  let helf: *u8 = ((cbuf as i64) + off[12]) as *u8
  let tmo: i64 = iv[3]
  let plines: i64 = ch_bt_lines(ppath)
  let db2: *u8 = sys_mmap(CH_BT_DAYCELL)
  ch_bt_pieceday(pbase, db2)
  var o3: i64 = sj_cat(napath, 0, ((cbuf as i64) + off[5]) as *u8)
  napath[o3] = 47 as u8
  o3 = o3 + 1
  o3 = sj_cat(napath, o3, pbase)
  napath[o3] = 0 as u8
  var o4: i64 = sj_cat(njpath, 0, ((cbuf as i64) + off[6]) as *u8)
  njpath[o4] = 47 as u8
  o4 = o4 + 1
  o4 = sj_cat(njpath, o4, "chbeat_" as *u8)
  o4 = sj_cat(njpath, o4, db2)
  o4 = sj_cat(njpath, o4, ".jrnl" as *u8)
  njpath[o4] = 0 as u8
  // 1) local sha -- ONE ruler, nx_filehash, forked on both sides
  let hav: *i64 = sys_mmap(32) as *i64
  hav[0] = helf as i64
  hav[1] = ppath as i64
  hav[2] = 0
  let hrc: i64 = tr_run_capture_to(helf, hav, cout, CH_OUT - 8, colen, tmo)
  var okl: i64 = 0
  if hrc == 0 { okl = ch_bt_parse_sha(cout, colen[0], lsha) }
  if okl == 0 { ch_frame_append(pjr, sys_now_realtime_sec(), pbase, "nx_claude_harvest" as *u8, "push" as *u8, "fail-localhash" as *u8, ppath); return 1 }
  // 2) upload (@@FILE: substitution puts the piece CONTENT into the write argv); a refusal
  //    (already-landed / CAS) is decided by the hash verify below -- only a DEAD wire is fatal here
  let atf: *u8 = sys_mmap(CH_BT_PATHMAX)
  var o5: i64 = sj_cat(atf, 0, "@@FILE:" as *u8)
  o5 = sj_cat(atf, o5, ppath)
  atf[o5] = 0 as u8
  let wrc: i64 = ch_bt_wire(wire, script, "nx_fs_write" as *u8, capw, "write" as *u8, napath, atf, 0 as *u8, tmo, cout, colen)
  if wrc == 127 { ch_frame_append(pjr, sys_now_realtime_sec(), pbase, "nx_claude_harvest" as *u8, "push" as *u8, "fail-wire-absent" as *u8, ppath); return 1 }
  // the write's OWN verdict, read BEFORE the verify overwrites the shared capture buffer
  let wrote_ok: i64 = ch_find(cout, colen[0], "NX-FS-WRITE OK" as *u8)
  // 3) remote hash verify -- the artifact, never the receipt
  let vrc: i64 = ch_bt_wire(wire, script, "nx_filehash" as *u8, capr, napath, 0 as *u8, 0 as *u8, 0 as *u8, tmo, cout, colen)
  var okr: i64 = 0
  if vrc == 0 { okr = ch_bt_parse_sha(cout, colen[0], rsha) }
  var same: i64 = 0
  if okr == 1 { same = ch_bt_zeq(lsha, rsha) }
  if same == 0 { ch_frame_append(pjr, sys_now_realtime_sec(), pbase, "nx_claude_harvest" as *u8, "push" as *u8, ch_bt_pushreason(wrote_ok, okr, same), napath); return 1 }
  // 4) NAS ingest (ch_ingest server-side: validated, marker-idempotent)
  let irc: i64 = ch_bt_wire(wire, script, "nx_claude_harvest" as *u8, capi, "ingest" as *u8, napath, njpath, 0 as *u8, tmo, cout, colen)
  if irc != 0 { ch_frame_append(pjr, sys_now_realtime_sec(), pbase, "nx_claude_harvest" as *u8, "push" as *u8, "fail-ingest-wire" as *u8, njpath); return 1 }
  var infr: i64 = 0 - 1
  if ch_find(cout, colen[0], "ALREADY-INGESTED" as *u8) == 1 { infr = plines } else { infr = ch_bt_int_after(cout, colen[0], "INGEST OK frames=" as *u8) }
  let mal: i64 = ch_bt_int_after(cout, colen[0], " malformed=" as *u8)
  if infr != plines { ch_frame_append(pjr, sys_now_realtime_sec(), pbase, "nx_claude_harvest" as *u8, "push" as *u8, "fail-reconcile" as *u8, njpath); return 1 }
  if mal > 0 { ch_frame_append(pjr, sys_now_realtime_sec(), pbase, "nx_claude_harvest" as *u8, "push" as *u8, "fail-malformed" as *u8, njpath); return 1 }
  // 5) journal fill announce from the NAS's own size read; an unreadable size is ANNOUNCED, not skipped
  let src2: i64 = ch_bt_wire(wire, script, "nx_fs" as *u8, capr, "size" as *u8, njpath, 0 as *u8, 0 as *u8, tmo, cout, colen)
  var jb2: i64 = 0 - 1
  if src2 == 0 { jb2 = ch_bt_int_after(cout, colen[0], "bytes=" as *u8) }
  if jb2 >= 0 {
      let fill: i64 = jb2 * 1000 / iv[4]
      if fill > bcx[28] { bcx[28] = fill }
      var o6: i64 = sj_cat(ob, 0, "CHBEAT JOURNAL day=" as *u8)
      o6 = sj_cat(ob, o6, db2)
      o6 = sj_cat(ob, o6, " nas_bytes=" as *u8)
      o6 = sj_catn(ob, o6, jb2)
      o6 = sj_cat(ob, o6, " fill_permil=" as *u8)
      o6 = sj_catn(ob, o6, fill)
      if fill >= 1000 { o6 = sj_cat(ob, o6, " RED-PAST-CLIFF (gauge window truncates: partition finer than a day)" as *u8) } else {
          if fill >= iv[5] { o6 = sj_cat(ob, o6, " AMBER-NEAR-CLIFF" as *u8) }
      }
      ob[o6] = 10 as u8
      sys_write(1, ob, o6 + 1)
  } else {
      var o7: i64 = sj_cat(ob, 0, "CHBEAT JOURNAL day=" as *u8)
      o7 = sj_cat(ob, o7, db2)
      o7 = sj_cat(ob, o7, " nas_bytes=UNREAD (size call failed; fill unobserved this beat)" as *u8)
      ob[o7] = 10 as u8
      sys_write(1, ob, o7 + 1)
  }
  ch_frame_append(pjr, sys_now_realtime_sec(), pbase, "nx_claude_harvest" as *u8, "push" as *u8, "ok" as *u8, njpath)
  bcx[21] = bcx[21] + plines
  return 0
2779}
2780// ---------- the beat orchestrator ----------
2781// bcx map (CH_BT_CTRS slots):
2782//  0 files_seen 1 harvested 2 skipped_unchanged 3 errors 4 frames 5 tooluse_marks 6 lines
2783//  7 tooluse_lines 8 head_known 9 head_unknown 10 headless 11 truncated_files 12 pieces_spooled
2784// 13 bytes_staged 14 days_touched 15 tszero_frames 16 push_attempted 17 push_done 18 push_left
2785// 19 spool_remaining 20 local_ingested_frames 21 nas_confirmed_frames 22 local_malformed
2786// 23 census_read_fail 24 walk_dirs 25 walk_direrrs 26 stat_fallbacks 27 partition_ok
2787// 28 worst_journal_fill_permil 29 type_table_overflow 30 raws_recovered
2788func ch_beat(confpath: *u8, bcx: *i64) -> i64 {
  var w0: i64 = 0
  while w0 < CH_BT_CTRS { bcx[w0] = 0; w0 = w0 + 1 }
  let cbuf: *u8 = sys_mmap(CH_CONF_WIN)
  let off: *i64 = sys_mmap(128) as *i64
  let iv: *i64 = sys_mmap(64) as *i64
  let kt: *i64 = sys_mmap(CH_MK_MAX * 16) as *i64
  let kcx: *i64 = sys_mmap(16) as *i64
  let crc: i64 = ch_bt_conf(confpath, cbuf, off, iv, kt, kcx)
  if crc == (0 - 1) { sj_puts("CHBEAT CONF-UNREADABLE (fail closed)\n" as *u8); return 2 }
  if crc == (0 - 2) { return 2 }
  let root: *u8 = ((cbuf as i64) + off[0]) as *u8
  let state: *u8 = ((cbuf as i64) + off[1]) as *u8
  let spool: *u8 = ((cbuf as i64) + off[2]) as *u8
  let done: *u8 = ((cbuf as i64) + off[3]) as *u8
  let jdir: *u8 = ((cbuf as i64) + off[4]) as *u8
  sys_mkdir(state, CH_MODE_755)
  sys_mkdir(spool, CH_MODE_755)
  sys_mkdir(done, CH_MODE_755)
  sys_mkdir(jdir, CH_MODE_755)
  if iv[0] == 1 {
      var pm: i64 = 0 - 1
      if off[5] < 0 { pm = 5 }
      if off[6] < 0 { if pm < 0 { pm = 6 } }
      if off[7] < 0 { if pm < 0 { pm = 7 } }
      if off[8] < 0 { if pm < 0 { pm = 8 } }
      if off[9] < 0 { if pm < 0 { pm = 9 } }
      if off[10] < 0 { if pm < 0 { pm = 10 } }
      if off[11] < 0 { if pm < 0 { pm = 11 } }
      if off[12] < 0 { if pm < 0 { pm = 12 } }
      if pm >= 0 { sj_puts("CHBEAT CONF-MISSING push=1 needs nas_stage nas_journal wire wire_script cap_write cap_ingest cap_read hash_elf (fail closed)\n" as *u8); return 2 }
  }
  // MICROSECOND stamp: piece and raw names must be unique ACROSS beats -- a second-resolution stamp
  // collided two beats in one second, the truncating rewrite replaced a piece, and the ingest marker
  // (keyed on the basename) then silently dropped the replaced frames. Caught by teeth T37/T38.
  // Re-split of the SAME raw still reproduces identical names (stamp parsed from the raw's own name).
  let now: i64 = sys_now_realtime_us()
  let ob: *u8 = sys_mmap(CH_OUT)
  let p2: *u8 = sys_mmap(CH_BT_PATHMAX)
  let dcx: *i64 = sys_mmap(64) as *i64
  // ---- recover: split any crashed raw files left in the spool (deterministic piece names) ----
  let sar: *u8 = sys_mmap(CH_BT_ARENA)
  let sfo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64
  let swcx: *i64 = sys_mmap(64) as *i64
  let ns: i64 = ch_bt_walk(spool, ".frames" as *u8, sar, sfo, swcx)
  if ns < 0 { sj_puts("CHBEAT REFUSED spool walk overflow\n" as *u8); return 2 }
  var si: i64 = 0
  while si < ns {
      let sp2: *u8 = ((sar as i64) + sfo[si]) as *u8
      let sb2: *u8 = ch_bt_base(sp2)
      if ch_starts(sb2, 0, sj_vlen(sb2), "raw_" as *u8) == 1 {
          let stamp2: i64 = sj_atoi_z(((sb2 as i64) + sj_vlen("raw_" as *u8)) as *u8)
          let rr: i64 = ch_bt_split(sp2, spool, stamp2, iv[2], dcx)
          if rr == 0 {
              bcx[30] = bcx[30] + 1
              ch_bt_path2(p2, done, sb2)
              sys_renameat(sp2, p2)
          }
      }
      si = si + 1
  }
  // ---- walk + delta-harvest EVERY transcript (full population, never a sample) ----
  let ar: *u8 = sys_mmap(CH_BT_ARENA)
  let fo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64
  let wcx: *i64 = sys_mmap(64) as *i64
  let nf: i64 = ch_bt_walk(root, ".jsonl" as *u8, ar, fo, wcx)
  if nf < 0 { sj_puts("CHBEAT REFUSED transcript walk overflow (raise CH_BT_MAXFILES/CH_BT_ARENA -- never harvest a prefix)\n" as *u8); return 2 }
  bcx[0] = nf
  bcx[24] = wcx[0]
  bcx[25] = wcx[1]
  bcx[26] = wcx[2]
  let rootl: i64 = sj_vlen(root)
  let raw: *u8 = sys_mmap(CH_BT_PATHMAX)
  var o7: i64 = sj_cat(raw, 0, spool)
  raw[o7] = 47 as u8
  o7 = o7 + 1
  o7 = sj_cat(raw, o7, "raw_" as *u8)
  o7 = sj_catn(raw, o7, now)
  o7 = sj_cat(raw, o7, ".frames" as *u8)
  raw[o7] = 0 as u8
  let sbuf: *u8 = sys_mmap(256)
  let kk2: *i64 = sys_mmap(16) as *i64
  let hcx: *i64 = sys_mmap(64) as *i64
  let ccx: *i64 = sys_mmap(64) as *i64
  let ua: *u8 = sys_mmap(CH_BT_TYPEMAX * (CH_NAME_MAX + 8))
  let uo: *i64 = sys_mmap(16 * CH_BT_TYPEMAX) as *i64
  let ucx: *i64 = sys_mmap(16) as *i64
  let hwmp: *u8 = sys_mmap(CH_BT_PATHMAX * 2)
  let stem: *u8 = sys_mmap(CH_BT_PATHMAX)
  var fi: i64 = 0
  while fi < nf {
      let tp: *u8 = ((ar as i64) + fo[fi]) as *u8
      let rel: *u8 = ((tp as i64) + rootl + 1) as *u8
      ch_bt_hwmpath(state, rel, hwmp)
      ch_bt_stat(tp, sbuf, kk2)
      let hwm0: i64 = ch_hwm_read(hwmp)
      var did: i64 = 0
      if kk2[1] >= 0 { if kk2[1] == hwm0 { bcx[2] = bcx[2] + 1; did = 1 } }
      if did == 0 {
          ch_bt_stem(tp, stem)
          let dr: i64 = ch_delta(tp, stem, raw, hwmp, hcx)
          if dr < 0 {
              bcx[3] = bcx[3] + 1
              var oe: i64 = sj_cat(ob, 0, "CHBEAT ERR delta rc=" as *u8)
              oe = sj_catn(ob, oe, dr)
              oe = sj_cat(ob, oe, " file=" as *u8)
              oe = sj_cat(ob, oe, tp)
              ob[oe] = 10 as u8
              sys_write(1, ob, oe + 1)
          } else {
              bcx[1] = bcx[1] + 1
              bcx[4] = bcx[4] + hcx[0]
              if hcx[3] == 1 {
                  bcx[11] = bcx[11] + 1
                  var ot: i64 = sj_cat(ob, 0, "CHBEAT TRUNC file=" as *u8)
                  ot = sj_cat(ob, ot, tp)
                  ob[ot] = 10 as u8
                  sys_write(1, ob, ot + 1)
              }
              if hcx[1] > hcx[2] { ch_bt_census(tp, hcx[2], hcx[1], cbuf, kt, kcx[0], ua, uo, ucx, ccx) }
          }
      }
      fi = fi + 1
  }
  bcx[5] = ccx[2]
  bcx[6] = ccx[0]
  bcx[7] = ccx[1]
  bcx[8] = ccx[3]
  bcx[9] = ccx[4]
  bcx[10] = ccx[5]
  bcx[23] = ccx[6]
  bcx[29] = ccx[7]
  // ---- split this run's raw into ts-day pieces (the split re-counts what ch_delta emitted:
  //      two counters over one population = a free audit) ----
  let src: i64 = ch_bt_split(raw, spool, now, iv[2], dcx)
  if src == (0 - 2) { sj_puts("CHBEAT REFUSED day-table overflow (CH_BT_DAYMAX) -- run the backfill in date batches\n" as *u8); return 2 }
  if src == (0 - 3) { sj_puts("CHBEAT ERR piece write failed\n" as *u8); return 1 }
  bcx[12] = dcx[0]
  bcx[13] = dcx[1]
  bcx[14] = dcx[2]
  bcx[15] = dcx[3]
  var recon_ok: i64 = 1
  if dcx[4] != bcx[4] { recon_ok = 0 }
  ch_bt_path2(p2, done, ch_bt_base(raw))
  sys_renameat(raw, p2)
  // ---- ingest every spooled piece locally; push up to push_max to the NAS ----
  let par: *u8 = sys_mmap(CH_BT_ARENA)
  let pfo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64
  let pwcx: *i64 = sys_mmap(64) as *i64
  let np: i64 = ch_bt_walk(spool, ".frames" as *u8, par, pfo, pwcx)
  if np < 0 { sj_puts("CHBEAT REFUSED spool walk overflow\n" as *u8); return 2 }
  let mcx: *i64 = sys_mmap(16) as *i64
  let ljp: *u8 = sys_mmap(CH_BT_PATHMAX)
  let db3: *u8 = sys_mmap(CH_BT_DAYCELL)
  let pjr: *u8 = sys_mmap(CH_BT_PATHMAX)
  ch_bt_path2(pjr, state, "push.jrnl" as *u8)
  var pi: i64 = 0
  while pi < np {
      let pp: *u8 = ((par as i64) + pfo[pi]) as *u8
      let pb: *u8 = ch_bt_base(pp)
      if ch_starts(pb, 0, sj_vlen(pb), "cb" as *u8) == 1 {
          ch_bt_pieceday(pb, db3)
          var o9: i64 = sj_cat(ljp, 0, jdir)
          ljp[o9] = 47 as u8
          o9 = o9 + 1
          o9 = sj_cat(ljp, o9, "chbeat_" as *u8)
          o9 = sj_cat(ljp, o9, db3)
          o9 = sj_cat(ljp, o9, ".jrnl" as *u8)
          ljp[o9] = 0 as u8
          let lr: i64 = ch_ingest(pp, ljp, mcx)
          if lr >= 0 { bcx[20] = bcx[20] + lr; bcx[22] = bcx[22] + mcx[0] }
          var moved: i64 = 0
          if iv[0] == 1 {
              if bcx[16] < iv[1] {
                  bcx[16] = bcx[16] + 1
                  let prc: i64 = ch_bt_push1(pp, cbuf, off, iv, pjr, bcx)
                  if prc == 0 {
                      bcx[17] = bcx[17] + 1
                      ch_bt_path2(p2, done, pb)
                      sys_renameat(pp, p2)
                      moved = 1
                  } else { bcx[18] = bcx[18] + 1 }
              }
          }
          if moved == 0 { bcx[19] = bcx[19] + 1 }
      }
      pi = pi + 1
  }
  // ---- local journal fill (every day journal present, from its own stat; budget rides the conf) ----
  let jar: *u8 = sys_mmap(CH_BT_ARENA)
  let jfo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64
  let jwcx: *i64 = sys_mmap(64) as *i64
  let nj: i64 = ch_bt_walk(jdir, ".jrnl" as *u8, jar, jfo, jwcx)
  var ji: i64 = 0
  while ji < nj {
      let jp2: *u8 = ((jar as i64) + jfo[ji]) as *u8
      ch_bt_stat(jp2, sbuf, kk2)
      if kk2[1] >= 0 {
          let fill2: i64 = kk2[1] * 1000 / iv[4]
          if fill2 > bcx[28] { bcx[28] = fill2 }
          if fill2 >= iv[5] {
              var oa: i64 = sj_cat(ob, 0, "CHBEAT JOURNAL local=" as *u8)
              oa = sj_cat(ob, oa, jp2)
              oa = sj_cat(ob, oa, " bytes=" as *u8)
              oa = sj_catn(ob, oa, kk2[1])
              oa = sj_cat(ob, oa, " fill_permil=" as *u8)
              oa = sj_catn(ob, oa, fill2)
              if fill2 >= 1000 { oa = sj_cat(ob, oa, " RED-PAST-CLIFF (gauge window truncates: partition finer than a day)" as *u8) } else { oa = sj_cat(ob, oa, " AMBER-NEAR-CLIFF" as *u8) }
              ob[oa] = 10 as u8
              sys_write(1, ob, oa + 1)
          }
      }
      ji = ji + 1
  }
  // ---- worklists: the reason travels with the count ----
  var ui: i64 = 0
  while ui < ucx[0] {
      var ou: i64 = sj_cat(ob, 0, "CHBEAT UNKNOWN-TYPE name=" as *u8)
      ou = sj_cat(ob, ou, ((ua as i64) + uo[ui * 2]) as *u8)
      ou = sj_cat(ob, ou, " count=" as *u8)
      ou = sj_catn(ob, ou, uo[ui * 2 + 1])
      ob[ou] = 10 as u8
      sys_write(1, ob, ou + 1)
      ui = ui + 1
  }
  if bcx[29] == 1 { sj_puts("CHBEAT UNKNOWN-TYPE table full -- the distinct list above is a FLOOR, not a total\n" as *u8) }
  // ---- partitions: print the sums, not just a verdict ----
  var pok: i64 = 1
  if bcx[0] != bcx[1] + bcx[2] + bcx[3] { pok = 0 }
  if bcx[5] < bcx[4] { pok = 0 }
  if bcx[6] != bcx[8] + bcx[9] + bcx[10] { pok = 0 }
  if recon_ok == 0 { pok = 0 }
  bcx[27] = pok
  var op: i64 = sj_cat(ob, 0, "CHBEAT files seen=" as *u8)
  op = sj_catn(ob, op, bcx[0])
  op = sj_cat(ob, op, " = harvested=" as *u8)
  op = sj_catn(ob, op, bcx[1])
  op = sj_cat(ob, op, " + skipped_unchanged=" as *u8)
  op = sj_catn(ob, op, bcx[2])
  op = sj_cat(ob, op, " + errors=" as *u8)
  op = sj_catn(ob, op, bcx[3])
  op = sj_cat(ob, op, " (dirs=" as *u8)
  op = sj_catn(ob, op, bcx[24])
  op = sj_cat(ob, op, " direrrs=" as *u8)
  op = sj_catn(ob, op, bcx[25])
  op = sj_cat(ob, op, " statfb=" as *u8)
  op = sj_catn(ob, op, bcx[26])
  op = sj_cat(ob, op, ")" as *u8)
  ob[op] = 10 as u8
  sys_write(1, ob, op + 1)
  op = sj_cat(ob, 0, "CHBEAT frames harvested=" as *u8)
  op = sj_catn(ob, op, bcx[4])
  op = sj_cat(ob, op, " split_recount=" as *u8)
  op = sj_catn(ob, op, dcx[4])
  op = sj_cat(ob, op, " tooluse_marks=" as *u8)
  op = sj_catn(ob, op, bcx[5])
  op = sj_cat(ob, op, " unnamed_tooluse=" as *u8)
  op = sj_catn(ob, op, bcx[5] - bcx[4])
  op = sj_cat(ob, op, " tszero=" as *u8)
  op = sj_catn(ob, op, bcx[15])
  op = sj_cat(ob, op, " truncated_files=" as *u8)
  op = sj_catn(ob, op, bcx[11])
  ob[op] = 10 as u8
  sys_write(1, ob, op + 1)
  op = sj_cat(ob, 0, "CHBEAT lines=" as *u8)
  op = sj_catn(ob, op, bcx[6])
  op = sj_cat(ob, op, " = head_known=" as *u8)
  op = sj_catn(ob, op, bcx[8])
  op = sj_cat(ob, op, " + head_unknown=" as *u8)
  op = sj_catn(ob, op, bcx[9])
  op = sj_cat(ob, op, " + headless=" as *u8)
  op = sj_catn(ob, op, bcx[10])
  op = sj_cat(ob, op, " (tooluse_lines=" as *u8)
  op = sj_catn(ob, op, bcx[7])
  op = sj_cat(ob, op, " census_read_fail=" as *u8)
  op = sj_catn(ob, op, bcx[23])
  op = sj_cat(ob, op, ")" as *u8)
  ob[op] = 10 as u8
  sys_write(1, ob, op + 1)
  op = sj_cat(ob, 0, "CHBEAT staged pieces=" as *u8)
  op = sj_catn(ob, op, bcx[12])
  op = sj_cat(ob, op, " bytes=" as *u8)
  op = sj_catn(ob, op, bcx[13])
  op = sj_cat(ob, op, " days=" as *u8)
  op = sj_catn(ob, op, bcx[14])
  op = sj_cat(ob, op, " raws_recovered=" as *u8)
  op = sj_catn(ob, op, bcx[30])
  op = sj_cat(ob, op, " local_ingested_frames=" as *u8)
  op = sj_catn(ob, op, bcx[20])
  op = sj_cat(ob, op, " local_malformed=" as *u8)
  op = sj_catn(ob, op, bcx[22])
  ob[op] = 10 as u8
  sys_write(1, ob, op + 1)
  op = sj_cat(ob, 0, "CHBEAT push attempted=" as *u8)
  op = sj_catn(ob, op, bcx[16])
  op = sj_cat(ob, op, " done=" as *u8)
  op = sj_catn(ob, op, bcx[17])
  op = sj_cat(ob, op, " left=" as *u8)
  op = sj_catn(ob, op, bcx[18])
  op = sj_cat(ob, op, " nas_confirmed_frames=" as *u8)
  op = sj_catn(ob, op, bcx[21])
  op = sj_cat(ob, op, " spool_remaining=" as *u8)
  op = sj_catn(ob, op, bcx[19])
  if iv[0] == 0 { op = sj_cat(ob, op, " (push=0 staging mode declared)" as *u8) }
  ob[op] = 10 as u8
  sys_write(1, ob, op + 1)
  // LAST LINE (positional readers). A failed push is a PARTIAL beat, never an OK one --
  // the pieces are safe in the spool, but the NAS record is behind and the verdict says so.
  var ov: i64 = 0
  if pok == 1 { if bcx[3] == 0 { if bcx[18] == 0 { ov = 1 } } }
  var ol: i64 = 0
  if ov == 1 { ol = sj_cat(ob, 0, "CHBEAT OK" as *u8) } else { ol = sj_cat(ob, 0, "CHBEAT PARTIAL" as *u8) }
  ol = sj_cat(ob, ol, " files=" as *u8)
  ol = sj_catn(ob, ol, bcx[0])
  ol = sj_cat(ob, ol, " frames=" as *u8)
  ol = sj_catn(ob, ol, bcx[4])
  ol = sj_cat(ob, ol, " pieces=" as *u8)
  ol = sj_catn(ob, ol, bcx[12])
  ol = sj_cat(ob, ol, " pushed=" as *u8)
  ol = sj_catn(ob, ol, bcx[17])
  ol = sj_cat(ob, ol, " spool=" as *u8)
  ol = sj_catn(ob, ol, bcx[19])
  ol = sj_cat(ob, ol, " worst_fill_permil=" as *u8)
  ol = sj_catn(ob, ol, bcx[28])
  ob[ol] = 10 as u8
  sys_write(1, ob, ol + 1)
  if ov == 1 { return 0 }
  return 1
3116}
3117
3118// ---------- CE1 leg 2: ce_author_health -- seat-written NishiLang joined to its complexity (2026-09-05) ----------
3119// Frames carry `path=<p>` for writes since ch_frame_note landed. Every UNIQUE .nx path under the tree prefix that a seat
3120// session wrote is scanned ONCE with the complexity ruler (mc_scan_file -- the one ruler nx_mccabe and its gate share),
3121// and the figures are set against the census's LAST spine row so the board can say what share of the estate's
3122// complexity is seat-written. The complement is NOT "human": it is everything the frames cannot attribute -- human-
3123// authored files AND every write before the first path-bearing frame -- and it is named so, never guessed. A seat is
3124// AI at a seat by definition of the transcript. Counters partition and SUM; a path outside the tree or not .nx is
3125// counted apart; an unreadable path is counted apart; an absent spine makes the denominator UNOBSERVABLE (rc 3), a
3126// journal with no path frames is NO-PATH-FRAMES (rc 4) -- neither ever fabricates a number.
3127// (the CH_AH_* consts sit at the top of the file beside the beat consts: the module parser is single-pass and the
3128//  selftest teeth read them before this section)
3129func ch_ah_prefix(p: *u8, pre: *u8) -> i64 {
  var i: i64 = 0
  while pre[i] != (0 as u8) { if p[i] != pre[i] { return 0 } i = i + 1 }
  return 1
3133}
3134// n-th TAB-separated field of line [i,le) -> out (NUL-terminated); returns its length, 0 if absent
3135func ch_ah_field_n(buf: *u8, i: i64, le: i64, want: i64, out: *u8, cap: i64) -> i64 {
  var f: i64 = 0
  var s: i64 = i
  var k: i64 = i
  var o: i64 = 0
  while k <= le {
      var endf: i64 = 0
      if k == le { endf = 1 } else { if buf[k] == (9 as u8) { endf = 1 } }
      if endf == 1 {
          if f == want {
              var q: i64 = s
              while q < k { if o < cap - 1 { out[o] = buf[q]; o = o + 1 } q = q + 1 }
              out[o] = 0 as u8
              return o
          }
          f = f + 1
          s = k + 1
      }
      k = k + 1
  }
  out[0] = 0 as u8
  return 0
3157}
3158// linear lookup in a table of NUL-terminated cells; small tables, no second ruler
3159func ch_ah_find(tab: *u8, n: i64, cell: i64, p: *u8) -> i64 {
  var k: i64 = 0
  while k < n {
      let q: *u8 = ((tab as i64) + k*cell) as *u8
      if sj_lit_eq(q, 0, sj_vlen(q), p) == 1 { return k }
      k = k + 1
  }
  return 0 - 1
3167}
3168func ch_ah_lastline(buf: *u8, n: i64) -> i64 {
  var i: i64 = 0
  var last: i64 = 0 - 1
  while i < n { let le: i64 = sj_le(buf, i, n); if le > i { last = i } i = le + 1 }
  return last
3173}
3174// a BOUNDED digit run: stops at the first non-digit or at `to` (sj_atoi_z concatenates every digit up to the NUL,
3175// so on a `k=10|j=20` row it would read 1020 -- measured, not assumed)
3176func ch_ah_num(buf: *u8, p0: i64, to: i64) -> i64 {
  var v: i64 = 0
  var p: i64 = p0
  var g: i64 = 1
  while g == 1 {
      if p >= to { g = 0 } else {
          let c: i64 = buf[p] as i64
          if c < CH_CH_D0 { g = 0 } else { if c > CH_CH_D9 { g = 0 } else { v = v*CH_DEC + (c - CH_CH_D0); p = p + 1 } }
      }
  }
  return v
3187}
3188func ch_ah_field(buf: *u8, from: i64, to: i64, key: *u8) -> i64 {
  let p: i64 = ch_find_from(buf, from, to, key)
  if p < 0 { return 0 - 1 }
  return ch_ah_num(buf, p + sj_vlen(key), to)
3192}
3193func ce_author_health(jpath: *u8, pre: *u8, spine: *u8, cx: *i64, ob: *u8) -> i64 {
  var z: i64 = 0
  while z < CH_AH_CTRS { cx[z] = 0; z = z + 1 }
  cx[CH_AH_FIRSTTS] = 0 - 1
  let lp: *i64 = sys_mmap(16) as *i64
  lp[0] = 0
  let jb: *u8 = sys_read_file(jpath, lp)
  var jn: i64 = lp[0]
  if jn < 0 { jn = 0 }
  let tab: *u8 = sys_mmap(CH_AH_MAXPATHS * CH_AH_PATHCELL)
  var nt: i64 = 0
  let stab: *u8 = sys_mmap(CH_AH_MAXSESS * CH_AH_SESSCELL)
  var ns: i64 = 0
  let pkey: *u8 = "path=" as *u8
  let pkl: i64 = sj_vlen(pkey)
  let pc: *u8 = sys_mmap(CH_AH_PATHCELL + 8)
  let sc: *u8 = sys_mmap(CH_AH_SESSCELL + 8)
  var i: i64 = 0
  while i < jn {
      let le: i64 = sj_le(jb, i, jn)
      if le > i {
          cx[CH_AH_FRAMES] = cx[CH_AH_FRAMES] + 1
          let pp: i64 = ch_find_from(jb, i, le, pkey)
          if pp >= 0 {
              cx[CH_AH_PATHFRAMES] = cx[CH_AH_PATHFRAMES] + 1
              let ts: i64 = ch_ah_num(jb, i, le)
              if cx[CH_AH_FIRSTTS] < 0 { cx[CH_AH_FIRSTTS] = ts } else { if ts < cx[CH_AH_FIRSTTS] { cx[CH_AH_FIRSTTS] = ts } }
              let sl: i64 = ch_ah_field_n(jb, i, le, 1, sc, CH_AH_SESSCELL)
              if sl > 0 { if ch_ah_find(stab, ns, CH_AH_SESSCELL, sc) < 0 { if ns < CH_AH_MAXSESS {
                  let scell: *u8 = ((stab as i64) + ns*CH_AH_SESSCELL) as *u8
                  let scl: i64 = sj_cat(scell, 0, sc)
                  scell[scl] = 0 as u8
                  ns = ns + 1
              } } }
              var pl: i64 = le - (pp + pkl)
              if pl > CH_AH_PATHCELL - 1 { pl = CH_AH_PATHCELL - 1 }
              var q: i64 = 0
              while q < pl { pc[q] = jb[pp + pkl + q]; q = q + 1 }
              if pl > 0 { if pc[pl-1] == (13 as u8) { pl = pl - 1 } }
              pc[pl] = 0 as u8
              if pl > 0 { if ch_ah_find(tab, nt, CH_AH_PATHCELL, pc) < 0 {
                  if nt < CH_AH_MAXPATHS {
                      let pcell: *u8 = ((tab as i64) + nt*CH_AH_PATHCELL) as *u8
                      let pcl: i64 = sj_cat(pcell, 0, pc)
                      pcell[pcl] = 0 as u8
                      nt = nt + 1
                  } else { cx[CH_AH_OVERFLOW] = cx[CH_AH_OVERFLOW] + 1 }
              } }
          }
      }
      i = le + 1
  }
  cx[CH_AH_UNIQUE] = nt
  cx[CH_AH_SESSIONS] = ns
  let hist: *i64 = sys_mmap(MC_HIST_MAX*8 + 64) as *i64
  let mc: *i64 = sys_mmap(MC_C_SLOTS*8) as *i64
  let work: *u8 = sys_mmap(MC_WORKCAP)
  let wo: *i64 = sys_mmap(16) as *i64
  wo[0] = 0
  var k: i64 = 0
  while k < nt {
      let p: *u8 = ((tab as i64) + k*CH_AH_PATHCELL) as *u8
      var intree: i64 = 0
      if ch_ah_prefix(p, pre) == 1 { if mc_ends_nx(p, sj_vlen(p)) == 1 { intree = 1 } }
      if intree == 1 {
          cx[CH_AH_INTREE] = cx[CH_AH_INTREE] + 1
          let f0: i64 = mc[MC_C_FILES]
          let n0: i64 = mc[MC_C_FUNCS]
          let s0: i64 = mc[MC_C_SUMVG]
          let a0: i64 = mc[MC_C_ABOVE]
          mc_scan_file(p, hist, mc, work, wo)
          if mc[MC_C_FILES] > f0 {
              cx[CH_AH_FILES] = cx[CH_AH_FILES] + 1
              cx[CH_AH_FUNCS] = cx[CH_AH_FUNCS] + (mc[MC_C_FUNCS] - n0)
              cx[CH_AH_SUMVG] = cx[CH_AH_SUMVG] + (mc[MC_C_SUMVG] - s0)
              cx[CH_AH_ABOVE] = cx[CH_AH_ABOVE] + (mc[MC_C_ABOVE] - a0)
          } else { cx[CH_AH_UNREAD] = cx[CH_AH_UNREAD] + 1 }
      } else { cx[CH_AH_OUTSIDE] = cx[CH_AH_OUTSIDE] + 1 }
      k = k + 1
  }
  let sp: *i64 = sys_mmap(16) as *i64
  sp[0] = 0
  let sb: *u8 = sys_read_file(spine, sp)
  let sn: i64 = sp[0]
  var den: i64 = 0
  if sn > 0 {
      let ls: i64 = ch_ah_lastline(sb, sn)
      if ls >= 0 {
          let lse: i64 = sj_le(sb, ls, sn)
          cx[CH_AH_DTS] = ch_ah_num(sb, ls, lse)
          cx[CH_AH_DFILES] = ch_ah_field(sb, ls, lse, "files=" as *u8)
          cx[CH_AH_DFUNCS] = ch_ah_field(sb, ls, lse, "funcs=" as *u8)
          cx[CH_AH_DABOVE] = ch_ah_field(sb, ls, lse, "above_10=" as *u8)
          if cx[CH_AH_DFILES] > 0 { den = 1 }
      }
  }
  if den == 0 { cx[CH_AH_DFILES] = 0; cx[CH_AH_DFUNCS] = 0; cx[CH_AH_DABOVE] = 0 }
  var rc: i64 = 0
  if cx[CH_AH_PATHFRAMES] == 0 { rc = CH_AH_RC_NOPATH } else { if den == 0 { rc = CH_AH_RC_UNOBS } }
  var o: i64 = 0
  o = sj_cat(ob, o, "=== NX-AUTHOR-HEALTH -- seat-written NishiLang joined to its complexity (codeeffectiveness CE1 leg 2) ===\n" as *u8)
  o = sj_cat(ob, o, "  journal=" as *u8); o = sj_cat(ob, o, jpath)
  o = sj_cat(ob, o, " frames=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FRAMES])
  o = sj_cat(ob, o, " path_frames=" as *u8); o = sj_catn(ob, o, cx[CH_AH_PATHFRAMES])
  o = sj_cat(ob, o, " unique_paths=" as *u8); o = sj_catn(ob, o, cx[CH_AH_UNIQUE])
  o = sj_cat(ob, o, " nx_in_tree=" as *u8); o = sj_catn(ob, o, cx[CH_AH_INTREE])
  o = sj_cat(ob, o, " outside_tree_or_not_nx=" as *u8); o = sj_catn(ob, o, cx[CH_AH_OUTSIDE])
  o = sj_cat(ob, o, " unreadable=" as *u8); o = sj_catn(ob, o, cx[CH_AH_UNREAD])
  o = sj_cat(ob, o, " overflow=" as *u8); o = sj_catn(ob, o, cx[CH_AH_OVERFLOW])
  o = sj_cat(ob, o, " sessions=" as *u8); o = sj_catn(ob, o, cx[CH_AH_SESSIONS])
  o = sj_cat(ob, o, " first_path_frame_ts=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FIRSTTS])
  o = sj_cat(ob, o, "\n  tree=" as *u8); o = sj_cat(ob, o, pre)
  o = sj_cat(ob, o, "\n  seat_written: files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FILES])
  o = sj_cat(ob, o, " funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FUNCS])
  o = sj_cat(ob, o, " sum_vG=" as *u8); o = sj_catn(ob, o, cx[CH_AH_SUMVG])
  o = sj_cat(ob, o, " above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_ABOVE])
  if cx[CH_AH_FUNCS] > 0 { o = sj_cat(ob, o, " permille=" as *u8); o = sj_catn(ob, o, (cx[CH_AH_ABOVE]*MC_PERMILLE)/cx[CH_AH_FUNCS]) }
  if den == 1 {
      o = sj_cat(ob, o, "\n  denominator (mccabe spine row ts=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DTS])
      o = sj_cat(ob, o, "): files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFILES])
      o = sj_cat(ob, o, " funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFUNCS])
      o = sj_cat(ob, o, " above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DABOVE])
      o = sj_cat(ob, o, "\n  not_seat_attributed: files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFILES] - cx[CH_AH_FILES])
      o = sj_cat(ob, o, " funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFUNCS] - cx[CH_AH_FUNCS])
      o = sj_cat(ob, o, " above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DABOVE] - cx[CH_AH_ABOVE])
      o = sj_cat(ob, o, " (human-authored PLUS every write before ts=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FIRSTTS])
      o = sj_cat(ob, o, ", which carried no path -- UNATTRIBUTED, never guessed)\n  partition: seat_written + not_seat_attributed = denominator, by construction\n" as *u8)
  } else {
      o = sj_cat(ob, o, "\n  denominator: UNOBSERVABLE (no mccabe spine row at " as *u8); o = sj_cat(ob, o, spine); o = sj_cat(ob, o, " -- run nx_mccabe first; nothing is fabricated)\n" as *u8)
  }
  o = sj_cat(ob, o, "NX-AUTHOR-HEALTH frames=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FRAMES])
  o = sj_cat(ob, o, " path_frames=" as *u8); o = sj_catn(ob, o, cx[CH_AH_PATHFRAMES])
  o = sj_cat(ob, o, " unique_paths=" as *u8); o = sj_catn(ob, o, cx[CH_AH_UNIQUE])
  o = sj_cat(ob, o, " seat_files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FILES])
  o = sj_cat(ob, o, " seat_funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FUNCS])
  o = sj_cat(ob, o, " seat_above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_ABOVE])
  o = sj_cat(ob, o, " den_files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFILES])
  o = sj_cat(ob, o, " den_funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFUNCS])
  o = sj_cat(ob, o, " den_above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DABOVE])
  o = sj_cat(ob, o, " verdict=" as *u8)
  if rc == 0 { o = sj_cat(ob, o, "MEASURED" as *u8) }
  if rc == CH_AH_RC_UNOBS { o = sj_cat(ob, o, "UNOBSERVABLE-DENOMINATOR" as *u8) }
  if rc == CH_AH_RC_NOPATH { o = sj_cat(ob, o, "NO-PATH-FRAMES" as *u8) }
  o = sj_cat(ob, o, "\n" as *u8)
  ob[o] = 0 as u8
  return rc
3339}
3340
3341
3342// Request accounting reads local observation snapshots only. No provider calls or journal writes.
3343// Existing CH_WIN/CH_AH_MAXPATHS/CH_BT_TYPEMAX bound scan bytes, requests, JSON depth.
3344const CHU_SAFE:i64=9007199254740991 // exact JSON integer interoperability limit
3345const CHU_ROW:i64=21 // mask, kind, six identity spans, six counters, epoch
3346func chu_uint(q:*u8,s:i64,n:i64)->i64 {
if n<1{return -1};var v:i64=0;var i:i64=0
while i<n{let c:i64=q[s+i] as i64;if c<48||c>57{return -1};let d:i64=c-48
if v>(CHU_SAFE-d)/10{return -1};v=v*10+d;i=i+1}
return v
3351}
3352func chu_key(t:*NxJsonTok,ctx:i64)->i64 {
let s:i64=t.tok_off+1;let e:i64=t.tok_off+t.tok_len-1
if ctx==1{
if sj_lit_eq(t.src,s,e,"type")==1{return 0}
if sj_lit_eq(t.src,s,e,"timestamp")==1{return 1}
if sj_lit_eq(t.src,s,e,"payload")==1{return 2}
}
if ctx==2{
if sj_lit_eq(t.src,s,e,"thread_id")==1{return 3}
if sj_lit_eq(t.src,s,e,"response_id")==1{return 4}
if sj_lit_eq(t.src,s,e,"turn_id")==1{return 5}
if sj_lit_eq(t.src,s,e,"session_id")==1{return 6}
if sj_lit_eq(t.src,s,e,"root_turn_id")==1{return 7}
if sj_lit_eq(t.src,s,e,"usage")==1{return 8}
}
if ctx==3{
if sj_lit_eq(t.src,s,e,"input_tokens")==1{return 9}
if sj_lit_eq(t.src,s,e,"cached_input_tokens")==1{return 10}
if sj_lit_eq(t.src,s,e,"cache_write_input_tokens")==1{return 11}
if sj_lit_eq(t.src,s,e,"output_tokens")==1{return 12}
if sj_lit_eq(t.src,s,e,"reasoning_output_tokens")==1{return 13}
if sj_lit_eq(t.src,s,e,"total_tokens")==1{return 14}
}
return -1
3376}
3377func chu_value(t:*NxJsonTok,ctx:i64,r:*i64,depth:i64)->i64 {
if depth>CH_BT_TYPEMAX{return -1}
if t.kind==NX_JSON_LBRACE{
var kind:i64=nx_json_next(t)
if kind==NX_JSON_RBRACE{return 0}
while 1==1{
 if kind!=NX_JSON_STRING{return -1}
 var x:i64=t.tok_off+1
 while x<t.tok_off+t.tok_len-1{if t.src[x]==(92 as u8){return -1};x=x+1}
 let key:i64=chu_key(t,ctx)
 if key>=0{let bit:i64=1<<key;if (r[0]&bit)!=0{return -1};r[0]=r[0]|bit}
 if nx_json_next(t)!=NX_JSON_COLON{return -1}
 kind=nx_json_next(t)
 var child:i64=0
 if key==2{if kind!=NX_JSON_LBRACE{return -1};child=2}
 if key==8{if kind!=NX_JSON_LBRACE{return -1};child=3}
 if key==0{
  if kind!=NX_JSON_STRING{return -1}
  var ki:i64=t.tok_off+1;while ki<t.tok_off+t.tok_len-1{if t.src[ki]==(92 as u8){return -1};ki=ki+1}
  if sj_lit_eq(t.src,t.tok_off+1,t.tok_off+t.tok_len-1,"token_usage_record")==1{r[1]=1}
 }
 if key==1||key>=3&&key<=7{
  if kind!=NX_JSON_STRING{return -1}
  let n:i64=t.tok_len-2;if n<1||n>CH_NAME_SCAN{return -1}
  var j:i64=t.tok_off+1;while j<t.tok_off+t.tok_len-1{if t.src[j]==(92 as u8){return -1};j=j+1}
  var at:i64=2;if key>=3{at=(key-1)*2}
  r[at]=t.tok_off+1;r[at+1]=n
 }
 if key>=9{
  if kind!=NX_JSON_NUMBER{return -1}
  let v:i64=chu_uint(t.src,t.tok_off,t.tok_len);if v<0{return -1};r[14+key-9]=v
 }
 if chu_value(t,child,r,depth+1)!=0{return -1}
 kind=nx_json_next(t)
 if kind==NX_JSON_RBRACE{return 0}
 if kind!=NX_JSON_COMMA{return -1}
 kind=nx_json_next(t)
}
}
if t.kind==NX_JSON_LBRACKET{
var kind:i64=nx_json_next(t);if kind==NX_JSON_RBRACKET{return 0}
while 1==1{
 if chu_value(t,0,r,depth+1)!=0{return -1};kind=nx_json_next(t)
 if kind==NX_JSON_RBRACKET{return 0};if kind!=NX_JSON_COMMA{return -1};kind=nx_json_next(t)
}
}
if t.kind>=NX_JSON_STRING&&t.kind<=NX_JSON_NULL{return 0}
return -1
3425}
3426func chu_row(t:*NxJsonTok,q:*u8,n:i64,r:*i64)->i64 {
var i:i64=0;while i<CHU_ROW{r[i]=0;i=i+1}
t.src=q;t.len=n;t.pos=0;t.kind=0
if nx_json_next(t)!=NX_JSON_LBRACE{return -1}
if chu_value(t,1,r,0)!=0{return -1}
if nx_json_next(t)!=NX_JSON_EOF{return -1}
if (r[0]&1)==0{return -1}
if r[1]==0{return 0}
if r[0]!=32767{return -1}
let s:i64=r[2];if r[3]!=24{return -1}
if q[s+19]!=(46 as u8)||q[s+23]!=(90 as u8){return -1}
if ch_digits(q,s+20,s+23)==0{return -1}
let epoch:i64=ch_iso_epoch(q,s,s+19);if epoch<=0{return -1}
let hh:i64=chu_uint(q,s+11,2);let mm:i64=chu_uint(q,s+14,2);let ss:i64=chu_uint(q,s+17,2)
if hh>23||mm>59||ss>59{return -1}
let mo:i64=chu_uint(q,s+5,2);let day:i64=chu_uint(q,s+8,2);let year:i64=chu_uint(q,s,4)
var days:i64=31
if mo==4||mo==6||mo==9||mo==11{days=30}
if mo==2{days=28;if year%4==0{if year%100!=0||year%400==0{days=29}}}
if day>days{return -1}
r[20]=epoch
if r[15]>r[14]||r[16]>r[14]||r[18]>r[17]{return -1}
if r[14]>CHU_SAFE-r[17]{return -1}
if r[19]!=r[14]+r[17]{return -1}
return 1
3451}
3452func chu_span_same(q:*u8,a:*i64,b:*i64,slot:i64)->i64 {
if a[slot+1]!=b[slot+1]{return 0}
var i:i64=0;while i<a[slot+1]{if q[a[slot]+i]!=q[b[slot]+i]{return 0};i=i+1}
return 1
3456}
3457func chu_totals(q:*u8,n:i64,from:i64,to:i64,table:*i64,t:*NxJsonTok,r:*i64,c:*i64)->i64 {
var i:i64=0;while i<10{c[i]=0;i=i+1}
var pos:i64=0
while pos<n{
let end:i64=sj_le(q,pos,n)
if end==n{return -2}
if end>pos{
 let rowrc:i64=chu_row(t,(q as i64+pos) as *u8,end-pos,r)
 if rowrc<0{return -3}
 if rowrc==1{
  var s:i64=2;while s<14{r[s]=r[s]+pos;s=s+2}
  // Reconcile all requests in this byte snapshot before filtering time. A conflicting
  // repetition outside the requested time window cannot silently change membership.
  var found:i64=-1;var j:i64=0
  while j<c[0]{
   let old:*i64=(table as i64+j*CHU_ROW*8) as *i64
   if chu_span_same(q,r,old,4)==1&&chu_span_same(q,r,old,6)==1{found=j;break};j=j+1
  }
  if found>=0{
   let old:*i64=(table as i64+found*CHU_ROW*8) as *i64
   var same:i64=1;s=2;while s<14{if chu_span_same(q,r,old,s)==0{same=0};s=s+2}
   s=14;while s<CHU_ROW{if r[s]!=old[s]{same=0};s=s+1}
   if same==0{return -4};c[1]=c[1]+1
  }else{
   if c[0]>=CH_AH_MAXPATHS{return -5}
   let dest:*i64=(table as i64+c[0]*CHU_ROW*8) as *i64
   s=0;while s<CHU_ROW{dest[s]=r[s];s=s+1};c[0]=c[0]+1
   if r[20]>=from&&r[20]<to{
    c[2]=c[2]+1;s=0;while s<6{if c[4+s]>CHU_SAFE-r[14+s]{return -6};c[4+s]=c[4+s]+r[14+s];s=s+1}
   }
  }
 }else{c[3]=c[3]+1}
}
pos=end+1
}
return 0
3493}
3494func chu_emit(path:*u8,digest:*u8,state:*u8,rc:i64,extent:i64,start:i64,end:i64,head:i64,tail:i64,from:i64,to:i64,c:*i64)->i64 {
let d:*u8=sys_mmap(CH_OUT);if (d as i64)<=0{return 3}
var o:i64=sj_cat(d,0,"{\"schema\":\"nishi.context-request-window.v1\",\"state\":\"")
o=sj_cat(d,o,state);o=sj_cat(d,o,"\",\"code\":");o=sj_catn(d,o,rc)
o=sj_cat(d,o,",\"source_path_bytes_hex\":")
let hex:*u8="0123456789abcdef"
let pn:i64=sj_vlen(path)
if pn>CH_AH_PATHCELL{o=sj_cat(d,o,"null")}else{
o=sj_cat(d,o,"\"");var pi:i64=0;while pi<pn{let b:i64=path[pi] as i64;d[o]=hex[b>>4];d[o+1]=hex[b&15];o=o+2;pi=pi+1};o=sj_cat(d,o,"\"")
}
o=sj_cat(d,o,",\"scan_sha256\":")
if (digest as i64)==0{o=sj_cat(d,o,"null")}else{o=sj_cat(d,o,"\"");o=sj_cat(d,o,digest);o=sj_cat(d,o,"\"")}
o=sj_cat(d,o,",\"snapshot_extent\":");o=sj_catn(d,o,extent)
o=sj_cat(d,o,",\"scan_start\":");o=sj_catn(d,o,start)
o=sj_cat(d,o,",\"scan_end\":");o=sj_catn(d,o,end)
o=sj_cat(d,o,",\"discarded_head_bytes\":");o=sj_catn(d,o,head)
o=sj_cat(d,o,",\"discarded_tail_bytes\":");o=sj_catn(d,o,tail)
o=sj_cat(d,o,",\"start_inclusive_epoch\":");o=sj_catn(d,o,from)
o=sj_cat(d,o,",\"end_exclusive_epoch\":");o=sj_catn(d,o,to)
o=sj_cat(d,o,",\"observed_at_epoch\":");o=sj_catn(d,o,sys_now_realtime_sec())
o=sj_cat(d,o,",\"window_coverage\":\"scanned-complete-records-only; broader-history-unknown\",\"totals\":")
if rc!=0{o=sj_cat(d,o,"null,\"unique_requests\":null")}else{
o=sj_cat(d,o,"{\"input_tokens\":");o=sj_catn(d,o,c[4])
o=sj_cat(d,o,",\"cached_input_tokens\":");o=sj_catn(d,o,c[5])
o=sj_cat(d,o,",\"cache_write_input_tokens\":");o=sj_catn(d,o,c[6])
o=sj_cat(d,o,",\"output_tokens\":");o=sj_catn(d,o,c[7])
o=sj_cat(d,o,",\"reasoning_output_tokens\":");o=sj_catn(d,o,c[8])
o=sj_cat(d,o,",\"total_tokens\":");o=sj_catn(d,o,c[9])
o=sj_cat(d,o,"},\"unique_requests\":");o=sj_catn(d,o,c[2])
o=sj_cat(d,o,",\"snapshot_unique_requests\":");o=sj_catn(d,o,c[0])
o=sj_cat(d,o,",\"duplicate_records\":");o=sj_catn(d,o,c[1])
o=sj_cat(d,o,",\"ignored_records\":");o=sj_catn(d,o,c[3])
}
o=sj_cat(d,o,",\"cached_input_is_subset\":true,\"reasoning_is_subset\":true,\"cumulative_usage_excluded\":true,\"attribution\":\"mixed-window; temporal overlap is not task causality\",\"billed_spend\":null,\"quota_attribution\":null,\"task_attributable_tokens\":null,\"net_savings\":null}\n")
sys_write(1,d,o);sys_munmap(d,CH_OUT);return rc
3529}
3530func ch_usage_window(path:*u8,from:i64,to:i64,start:i64,end:i64)->i64 {
let c:*i64=sys_mmap(80) as *i64
if (c as i64)<=0{return 3}
if sj_vlen(path)>CH_AH_PATHCELL||from<0||to<=from||start<0||end<start||end-start>CH_WIN{
chu_emit(path,0 as *u8,"invalid-boundary",2,-1,start,end,0,0,from,to,c);sys_munmap(c as *u8,80);return 2}
let fd:i64=sys_openat_rd(path)
if fd<0{chu_emit(path,0 as *u8,"source-open-failed",3,-1,start,end,0,0,from,to,c);sys_munmap(c as *u8,80);return 3}
let extent:i64=sys_lseek(fd,0,2)
if extent<end||extent<0{sys_close(fd);chu_emit(path,0 as *u8,"snapshot-unavailable",3,extent,start,end,0,0,from,to,c);sys_munmap(c as *u8,80);return 3}
let n:i64=end-start;let q:*u8=sys_mmap(n+8)
let table:*i64=sys_mmap(CH_AH_MAXPATHS*CHU_ROW*8) as *i64
let r:*i64=sys_mmap(CHU_ROW*8) as *i64
var t:*NxJsonTok=0 as *NxJsonTok
if (q as i64)>0&&(table as i64)>0&&(r as i64)>0{t=nx_json_new(q,n)}
let dh:*u8=sys_mmap(SHA256_DIGEST_BYTES*2+1)
let db:*u8=sys_mmap(SHA256_DIGEST_BYTES)
var digest:*u8=0 as *u8
var rc:i64=0;var head:i64=0;var tail:i64=0;var partial:i64=0
if (q as i64)<=0||(table as i64)<=0||(r as i64)<=0||(t as i64)<=0||(dh as i64)<=0||(db as i64)<=0{rc=3}else{
if start>0{
 if sys_lseek(fd,start-1,0)!=start-1{rc=3}else{if sys_read(fd,q,1)!=1{rc=3}else{if q[0]!=(10 as u8){partial=1}}}
}
if rc==0{
 if sys_lseek(fd,start,0)!=start{rc=3}else{
  var got:i64=0
  while got<n{let k:i64=sys_read(fd,(q as i64+got) as *u8,n-got);if k<=0{rc=3;break};got=got+k}
 }
}
if rc==0{
 if sha256_digest_checked_native(q,n,db)!=0{rc=3}else{
  let hex:*u8="0123456789abcdef";var di:i64=0
  while di<SHA256_DIGEST_BYTES{let b:i64=db[di] as i64;dh[di*2]=hex[b>>4];dh[di*2+1]=hex[b&15];di=di+1}
  dh[SHA256_DIGEST_BYTES*2]=0 as u8;digest=dh
 }
}
if rc==0{
 if partial==1{while head<n{let b:u8=q[head];head=head+1;if b==(10 as u8){break}}}
 var last:i64=n;while last>head{if q[last-1]==(10 as u8){break};last=last-1}
 tail=n-last
 rc=chu_totals((q as i64+head) as *u8,last-head,from,to,table,t,r,c)
}
}
let after:i64=sys_lseek(fd,0,2)
if after<extent{rc=3}
if sys_close(fd)!=0{rc=3}
var state:*u8="observed"
if rc!=0{state="refused-unreconciled"}
chu_emit(path,digest,state,rc,extent,start,end,head,tail,from,to,c)
if (dh as i64)>0{sys_munmap(dh,SHA256_DIGEST_BYTES*2+1)}
if (db as i64)>0{sys_munmap(db,SHA256_DIGEST_BYTES)}
if (q as i64)>0{sys_munmap(q,n+8)}
if (table as i64)>0{sys_munmap(table as *u8,CH_AH_MAXPATHS*CHU_ROW*8)}
if (r as i64)>0{sys_munmap(r as *u8,CHU_ROW*8)}
if (t as i64)>0{sys_munmap(t as *u8,NX_JSONTOK_BYTES)}
sys_munmap(c as *u8,80)
if rc!=0{return 3};return 0
3586}
3587func main(argc: i64, argv: *i64) -> i64 {
  if argc>=2{
      let uv:*u8=argv[1] as *u8
      if sj_lit_eq(uv,0,sj_vlen(uv),"usage-window")==1{
          if argc!=7{sj_puts("usage-window <jsonl> <start-inclusive-epoch> <end-exclusive-epoch> <scan-start-byte> <scan-end-byte>\n");return 2}
          let a:*u8=argv[3] as *u8;let b:*u8=argv[4] as *u8
          let c:*u8=argv[5] as *u8;let d:*u8=argv[6] as *u8
          return ch_usage_window(argv[2] as *u8,chu_uint(a,0,sj_vlen(a)),chu_uint(b,0,sj_vlen(b)),chu_uint(c,0,sj_vlen(c)),chu_uint(d,0,sj_vlen(d)))
      }
  }
3597
  if argc < 3 { sj_puts("usage: nx_claude_harvest {frames <transcript.jsonl> <ws> <outjournal> | delta <transcript.jsonl> <ws> <outjournal> <hwmfile> | ingest <framesfile> <journal> | gauge <journal> [days] | page <journal> <outfile> [days] | propose <journal> <intake_jrnl> <threshold_permil> [filer] | bootgauge <framesjournal> [k] | learn <transcript.jsonl> <ws> <outfile> <markersconf> | beat <chbeat.conf> | journal <journal> <planpath> <rung> | classes <journal> | selftest <scratch-prefix>}\n" as *u8); sys_exit(2); return 2 }
  let verb: *u8 = argv[1] as *u8
  let vl: i64 = sj_vlen(verb)
  if sj_lit_eq(verb, 0, vl, "selftest" as *u8) == 1 {
      let rc: i64 = ch_selftest(argv[2] as *u8)
      sys_exit(rc)
      return rc
  }
  if sj_lit_eq(verb, 0, vl, "authorhealth" as *u8) == 1 {
      if argc < 3 { sj_puts("authorhealth needs <journal> [treeprefix] [spine]\n" as *u8); sys_exit(2); return 2 }
      var ahpre: *u8 = CH_AH_TREE as *u8
      if argc >= 4 { ahpre = argv[3] as *u8 }
      var ahspn: *u8 = CH_AH_SPINE as *u8
      if argc >= 5 { ahspn = argv[4] as *u8 }
      let acx: *i64 = sys_mmap(8 * CH_AH_CTRS) as *i64
      let aob: *u8 = sys_mmap(CH_OUT)
      let arc: i64 = ce_author_health(argv[2] as *u8, ahpre, ahspn, acx, aob)
      sys_write(1, aob, sj_vlen(aob))
      let ahfd: i64 = sys_openat_wr(CH_AH_STATUS as *u8, CH_MODE_644)
      if ahfd >= 0 { sys_write(ahfd, aob, sj_vlen(aob)); sys_close(ahfd) }
      sys_exit(arc)
      return arc
  }
  if sj_lit_eq(verb, 0, vl, "classes" as *u8) == 1 {
      let dc: *u8 = sys_mmap(CH_OUT)
      let dcl: i64 = ch_classes(argv[2] as *u8, dc)
      sys_write(1, dc, dcl)
      sys_exit(0)
      return 0
  }
  if sj_lit_eq(verb, 0, vl, "journal" as *u8) == 1 {
      if argc < 5 { sj_puts("journal needs <journal> <planpath> <rung>\n" as *u8); sys_exit(2); return 2 }
      let rj: i64 = ch_journal(argv[2] as *u8, argv[3] as *u8, argv[4] as *u8)
      if rj == 0 { sj_puts("JOURNAL OK one measure row appended\n" as *u8) }
      if rj == 4 { sj_puts("JOURNAL ALREADY today (idempotent, plan unchanged)\n" as *u8) }
      if rj == 5 { sj_puts("JOURNAL REFUSED insufficient data (no claude actions) -- nothing written\n" as *u8) }
      if rj == 1 { sj_puts("JOURNAL FAIL plan missing or unwritable (a beat never creates a plan)\n" as *u8) }
      sys_exit(rj)
      return rj
  }
  if sj_lit_eq(verb, 0, vl, "beat" as *u8) == 1 {
      let bcx: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64
      let rc: i64 = ch_beat(argv[2] as *u8, bcx)
      sys_exit(rc)
      return rc
  }
  if sj_lit_eq(verb, 0, vl, "bootgauge" as *u8) == 1 {
      var k: i64 = 3
      if argc >= 4 { let kz: i64 = sj_atoi_z(argv[3] as *u8); if kz > 0 { k = kz } }
      let d: *u8 = sys_mmap(CH_OUT)
      let dl: i64 = ch_bootgauge(argv[2] as *u8, k, d)
      sys_write(1, d, dl)
      sys_exit(0)
      return 0
  }
  if sj_lit_eq(verb, 0, vl, "learn" as *u8) == 1 {
      if argc < 6 { sj_puts("learn needs <transcript.jsonl> <ws> <outfile> <markersconf>\n" as *u8); sys_exit(2); return 2 }
      let lcx: *i64 = sys_mmap(64) as *i64
      let lg: i64 = ch_learn(argv[2] as *u8, argv[3] as *u8, argv[4] as *u8, argv[5] as *u8, lcx)
      if lg < 0 { sj_puts("LEARN FAIL rc=" as *u8); let eb4: *u8 = sys_mmap(32); var e4: i64 = sj_catn(eb4, 0, lg); eb4[e4] = 10 as u8; sys_write(1, eb4, e4 + 1); sys_exit(1); return 1 }
      let ob4: *u8 = sys_mmap(256)
      var o4: i64 = sj_cat(ob4, 0, "LEARN OK kept=" as *u8)
      o4 = sj_catn(ob4, o4, lg)
      o4 = sj_cat(ob4, o4, " markers=" as *u8)
      o4 = sj_catn(ob4, o4, lcx[1])
      o4 = sj_cat(ob4, o4, " truncated=" as *u8)
      o4 = sj_catn(ob4, o4, lcx[0])
      ob4[o4] = 10 as u8
      sys_write(1, ob4, o4 + 1)
      sys_exit(0)
      return 0
  }
  if sj_lit_eq(verb, 0, vl, "frames" as *u8) == 1 {
      if argc < 5 { sj_puts("frames needs <transcript.jsonl> <ws> <outjournal>\n" as *u8); sys_exit(2); return 2 }
      let tcx: *i64 = sys_mmap(16) as *i64
      let got: i64 = ch_frames(argv[2] as *u8, argv[3] as *u8, argv[4] as *u8, tcx)
      if got < 0 { sj_puts("HARVEST FAIL rc=" as *u8); let eb: *u8 = sys_mmap(32); var eo: i64 = sj_catn(eb, 0, got); eb[eo] = 10 as u8; sys_write(1, eb, eo + 1); sys_exit(1); return 1 }
      let ob: *u8 = sys_mmap(256)
      var oo: i64 = sj_cat(ob, 0, "HARVEST OK frames=" as *u8)
      oo = sj_catn(ob, oo, got)
      oo = sj_cat(ob, oo, " truncated=" as *u8)
      oo = sj_catn(ob, oo, tcx[0])
      ob[oo] = 10 as u8
      sys_write(1, ob, oo + 1)
      sys_exit(0)
      return 0
  }
  if sj_lit_eq(verb, 0, vl, "ingest" as *u8) == 1 {
      if argc < 4 { sj_puts("ingest needs <framesfile> <journal>\n" as *u8); sys_exit(2); return 2 }
      let mcx: *i64 = sys_mmap(16) as *i64
      let r: i64 = ch_ingest(argv[2] as *u8, argv[3] as *u8, mcx)
      if r == (0 - 2) { sj_puts("ALREADY-INGESTED (marker present, journal untouched)\n" as *u8); sys_exit(0); return 0 }
      if r < 0 { sj_puts("INGEST FAIL rc=" as *u8); let eb2: *u8 = sys_mmap(32); var e2: i64 = sj_catn(eb2, 0, r); eb2[e2] = 10 as u8; sys_write(1, eb2, e2 + 1); sys_exit(1); return 1 }
      let ob2: *u8 = sys_mmap(256)
      var o2: i64 = sj_cat(ob2, 0, "INGEST OK frames=" as *u8)
      o2 = sj_catn(ob2, o2, r)
      o2 = sj_cat(ob2, o2, " malformed=" as *u8)
      o2 = sj_catn(ob2, o2, mcx[0])
      ob2[o2] = 10 as u8
      sys_write(1, ob2, o2 + 1)
      sys_exit(0)
      return 0
  }
  if sj_lit_eq(verb, 0, vl, "gauge" as *u8) == 1 {
      var days: i64 = 0
      if argc >= 4 { days = sj_atoi_z(argv[3] as *u8) }
      let d: *u8 = sys_mmap(CH_OUT)
      let dl: i64 = ch_gauge_json(argv[2] as *u8, days, d)
      sys_write(1, d, dl)
      if ch_find(d, dl, "\"evidence_state\":\"source_open_failed\"" as *u8) == 1 { sys_exit(CH_AH_RC_UNOBS); return CH_AH_RC_UNOBS }
      sys_exit(0)
      return 0
  }
  if sj_lit_eq(verb, 0, vl, "page" as *u8) == 1 {
      if argc < 4 { sj_puts("page needs <journal> <outfile> [days]\n" as *u8); sys_exit(2); return 2 }
      var days2: i64 = 0
      if argc >= 5 { days2 = sj_atoi_z(argv[4] as *u8) }
      let rp: i64 = ch_page(argv[2] as *u8, argv[3] as *u8, days2)
      if rp != 0 { sj_puts("PAGE FAIL\n" as *u8); sys_exit(1); return 1 }
      sj_puts("PAGE OK\n" as *u8)
      sys_exit(0)
      return 0
  }
  if sj_lit_eq(verb, 0, vl, "delta" as *u8) == 1 {
      if argc < 6 { sj_puts("delta needs <transcript.jsonl> <ws> <outjournal> <hwmfile>\n" as *u8); sys_exit(2); return 2 }
      let hcx: *i64 = sys_mmap(64) as *i64
      let r: i64 = ch_delta(argv[2] as *u8, argv[3] as *u8, argv[4] as *u8, argv[5] as *u8, hcx)
      if r < 0 { sj_puts("DELTA FAIL (missing transcript or unwritable journal)\n" as *u8); sys_exit(1); return 1 }
      let ob: *u8 = sys_mmap(256)
      var oo: i64 = sj_cat(ob, 0, "DELTA OK frames=" as *u8)
      oo = sj_catn(ob, oo, hcx[0])
      oo = sj_cat(ob, oo, " from_hwm=" as *u8)
      oo = sj_catn(ob, oo, hcx[2])
      oo = sj_cat(ob, oo, " new_hwm=" as *u8)
      oo = sj_catn(ob, oo, hcx[1])
      oo = sj_cat(ob, oo, " truncated=" as *u8)
      oo = sj_catn(ob, oo, hcx[3])
      ob[oo] = 10 as u8
      sys_write(1, ob, oo + 1)
      sys_exit(0)
      return 0
  }
  if sj_lit_eq(verb, 0, vl, "propose" as *u8) == 1 {
      if argc < 5 { sj_puts("propose needs <journal> <intake_jrnl> <threshold_permil> [filer]\n" as *u8); sys_exit(2); return 2 }
      let thr: i64 = sj_atoi_z(argv[4] as *u8)
      let filer: *u8 = sys_mmap(128)
      var fo: i64 = 0
      if argc >= 6 { fo = sj_cat(filer, 0, argv[5] as *u8) } else { fo = sj_cat(filer, 0, "nx_pm_intake" as *u8) }
      filer[fo] = 0 as u8
      let co: *u8 = sys_mmap(CH_OUT)
      let cl: *i64 = sys_mmap(16) as *i64
      let r: i64 = ch_propose(argv[2] as *u8, argv[3] as *u8, thr, filer, co, cl)
      if r == 0 { sj_puts("PROPOSED " as *u8); if cl[0] > 0 { sys_write(1, co, cl[0]) } sj_puts("\n" as *u8); sys_exit(0); return 0 }
      if r == 2 { sj_puts("BELOW-THRESHOLD\n" as *u8); sys_exit(0); return 0 }
      if r == 4 { sj_puts("ALREADY-PROPOSED (marker present)\n" as *u8); sys_exit(0); return 0 }
      if r == 5 { sj_puts("SKIP-INSUFFICIENT (no frames)\n" as *u8); sys_exit(0); return 0 }
      if r == 3 { sj_puts("REFUSED intake window exceeded\n" as *u8); sys_exit(3); return 3 }
      sj_puts("PROPOSE FAIL (filer)\n" as *u8)
      sys_exit(1)
      return 1
  }
  sj_puts("unknown verb\n" as *u8)
  sys_exit(2)
  return 2
3762}
nx_claude_harvest_usage_t76.nx source

`nx_claude_harvest_usage_t76.nx` source
