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

↩ module page · 1268 lines · 59546 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//   selftest <scratch-prefix>                    -> gate T1..T8 (unique per-run scratch names)
12// license_tier: ORIGINAL
13import "nx_sovjson_lib.nx"
14import "nx_syscalls.nx"
15import "nx_gate_verdict.nx"
16import "nx_tool_run.nx"
17const CH_MAGIC_146097: i64 = 146097
18const CH_MAGIC_719468: i64 = 719468
19const CH_MAGIC_86400: i64 = 86400
20const CH_MAGIC_3600: i64 = 3600
21const CH_MAGIC_1784764900: i64 = 1784764900
22const CH_MAGIC_1784764901: i64 = 1784764901
23const CH_MAGIC_1784764803: i64 = 1784764803
24
25const CH_WIN: i64 = 67108864
26const CH_JWIN: i64 = 4194304
27const CH_OUT: i64 = 65536
28const CH_LINE: i64 = 4096
29const CH_NAME_MAX: i64 = 120
30const CH_NAME_SCAN: i64 = 400
31const CH_MODE_644: i64 = 420
32
33func 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
41}
42// substring search in q[from..endlim) -> position or -1
43func 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
60}
61func ch_find(q: *u8, n: i64, lit: *u8) -> i64 {
  if ch_find_from(q, 0, n, lit) >= 0 { return 1 }
  return 0
64}
65// span q[s..e) begins with lit?
66func 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
74}
75func 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
80}
81// civil date -> unix epoch (Hinnant days-from-civil, integer only; years >= 1970 here)
82func 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
92}
93// parse ISO "YYYY-MM-DDTHH:MM:SS" at q[s..] (lim-bounded) -> epoch, 0 if malformed
94func 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)
118}
119// write one actlog frame line to an open fd: <ts>TAB<ws>TAB<tool>TAB<verb>TAB<outcome>TAB<note>NL
120func 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
136}
137func 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
144}
145// ---------- frames: transcript JSONL -> actlog frames ----------
146// returns frames harvested, -1 missing/empty transcript, -3 cannot open out journal.
147// tcx[0] receives truncated flag.
148func 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)
  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, "harvest" as *u8)
                      frames = frames + 1
                  }
              }
              j = tu + 17
          }
      }
      i = le + 1
  }
  sys_close(fd)
  return frames
199}
200// ---------- delta: HIGH-WATER-MARK harvest, the F973 self-sufficiency half ----------
201// The ongoing-harvest loop lived in a laptop PowerShell parser (MG03: Claude hand-writes miners).
202// This puts the byte-offset high-water mark INSIDE the organ, so the harvester is self-sufficient on
203// ANY host that holds transcripts: run the ELF, it consumes only what grew since last time.
204// EXACTLY-ONCE BY CONSTRUCTION: only COMPLETE lines are consumed (a partial trailing line stays below
205// the mark for the next run), and the mark advances only over what was actually parsed. A re-run on an
206// unchanged transcript yields 0 frames -- idempotent without needing a marker.
207// hcx[0]=frames hcx[1]=new_hwm hcx[2]=old_hwm hcx[3]=truncated
208func 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
219}
220func 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
229}
230func 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
  let buf: *u8 = sys_mmap(CH_WIN)
  let cap: i64 = CH_WIN - 8
  let n: i64 = ch_read(tpath, buf, cap)
  if n <= 0 { return -1 }
  if n >= cap { hcx[3] = 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 { 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 { return 0 }
  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)
  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, "delta" as *u8)
                      frames = frames + 1
                  }
              }
              j = tu + 17
          }
      }
      i = le + 1
  }
  sys_close(fd)
  hcx[0] = frames
  hcx[1] = lastnl + 1
  ch_hwm_write(hwmpath, lastnl + 1)
  return 0
298}
299// ---------- ingest: validated bulk append of a staged frames file, marker-idempotent ----------
300// returns >=0 ingested count (mcx[0]=malformed), -1 missing frames file, -2 already ingested,
301// -3 journal window exceeded (idempotence unverifiable -> fail closed), -4 cannot open journal.
302func 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 jbuf: *u8 = sys_mmap(CH_JWIN)
  let jcap: i64 = CH_JWIN - 8
  let jn: i64 = ch_read(jpath, jbuf, jcap)
  if jn >= jcap { return -3 }
  if jn > 0 { if ch_find(jbuf, jn, marker) == 1 { return -2 } }
  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
353}
354// ---------- gauge: outside_permil JSON from a frames journal ----------
355func 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
361}
362func 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
371}
372// ---------- bootgauge: SOTA-FROM-THE-FIRST-BYTE (operator 2026-07-24 'go SOTA from the first byte up') ----------
373// For each session (ws) is the FIRST tool nishi-native? A session that opens with nx_seat boot is SOTA
374// from byte 1; one that opens by reading 40KB of memory / scratchpadding is LEGACY. Measures the
375// SOTA-boot ratio + the softer nishi-within-first-K signal. Sessions interned by ws span (bounded, declared).
376const CH_WS_MAX: i64 = 4096
377func 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
393}
394func 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
465}
466// gauge core: g slots 0 total 1 nishi 2 outside 3 permil 4 malformed 5 trunc 6 bytes
467func ch_gauge_calc(jpath: *u8, days: i64, g: *i64) -> i64 {
  let q: *u8 = sys_mmap(CH_JWIN)
  let cap: i64 = CH_JWIN - 8
  var n: i64 = ch_read(jpath, q, cap)
  if n < 0 { n = 0 }
  var trunc: i64 = 0
  if n >= cap { trunc = 1 }
  var cutoff: i64 = 0
  if days > 0 { cutoff = sys_now_realtime_sec() - days * CH_MAGIC_86400 }
  let sp: *i64 = sys_mmap(16) as *i64
  var total: i64 = 0
  var nishi: i64 = 0
  var outside: i64 = 0
  var malformed: 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
          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 {
              if ts >= cutoff {
                  total = total + 1
                  if ch_nishi_tool(q, sp[0], sp[1]) == 1 { nishi = nishi + 1 } else { outside = outside + 1 }
              }
          } else { malformed = malformed + 1 }
      }
      i = le + 1
  }
  var permil: i64 = 0 - 1
  if total > 0 { permil = outside * 1000 / total }
  g[0] = total
  g[1] = nishi
  g[2] = outside
  g[3] = permil
  g[4] = malformed
  g[5] = trunc
  g[6] = n
  return 0
512}
513func ch_gauge_json(jpath: *u8, days: i64, d: *u8) -> i64 {
  let g: *i64 = sys_mmap(64) 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] = 125 as u8; p = p + 1
  d[p] = 10 as u8; p = p + 1
  return p
552}
553// ---------- page: the F965 watch-it-fall surface (HTML, minimal; U2/U3 restyle rides ui-debt lane) ----------
554func ch_page(jpath: *u8, outp: *u8, days: i64) -> i64 {
  let g: *i64 = sys_mmap(64) 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[3])
  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>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
591}
592// ---------- F971 propose: the gauge FILES its own migration work (feeder pattern) ----------
593// codes: 0 filed | 1 filer-fail | 2 below-threshold | 3 intake-window-exceeded (fail closed) |
594//        4 already-proposed (marker) | 5 insufficient-data. Filer is INJECTABLE (argecho in the
595// gate) and ALLOWLIST-RESOLVED (never a hardcoded sibling path). Marker [HARV:outsidegap:v1]
596// makes re-runs never re-file. NOTE ch_allow_path duplicates nx_actlog al_allow_path -- the
597// shared nx_jrnl_lib extraction is the filed rule-15 residual.
598// DELEGATES to the shared base (rule-15 extraction 2026-07-23)
599func ch_allow_path(name: *u8, outp: *u8) -> i64 { return sj_allow_path(name, outp) }
600func ch_propose(jpath: *u8, ipath: *u8, thr: i64, filer: *u8, cout: *u8, colen: *i64) -> i64 {
  colen[0] = 0
  let g: *i64 = sys_mmap(64) 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
636}
637// ---------- selftest ----------
638func 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)
  let now: i64 = sys_now_realtime_sec()
  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)
  // 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)
  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/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)
  let rc: i64 = gv_verdict("CLAWHARV-GATE" as *u8, ctr, "transcript parse + delta hwm + ingest + gauge + page + propose + bootgauge teeth green" as *u8)
  return rc
901}
902
903// ---------- learn: LEARNING-TEXT harvest (root fix for debt 1785525736) ----------
904// Every other verb in this organ extracts "type":"tool_use" NAMES. That is tool TELEMETRY, not
905// learning capture: ch_frame_write puts '-' in the two columns where a lesson would go, and the
906// 6-hourly beat reported fail=0 for weeks while moving ZERO learnings, over transcripts holding
907// ~40k LAW:/LESSON/ROOT CAUSE/FINDING: statements. This verb reads the PROSE instead -- the "text"
908// payloads written by the assistant and the operator -- ranks each line, and keeps only what clears
909// the floor. Because it CAN reject plain prose, its output is evidence rather than a transcript dump.
910// Rule 11: every marker, weight and floor is loaded from a conf file. No weight is written in code.
911const CH_MK_MAX: i64 = 64
912const CH_CONF_WIN: i64 = 65536
913const CH_TXTWIN: i64 = 262144
914
915// longest run of CONSECUTIVE occurrences of a (possibly multi-byte) glyph in q[s..e)
916// the star/warn glyphs are 3-byte UTF-8, so this compares byte sequences, never single chars.
917func 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
940}
941
942// conf loader. mk is INTERLEAVED (mk[2k]=literal offset into cbuf, mk[2k+1]=weight) so this stays
943// at 4 params; sc carries the scalars: 0=warn_bonus 1=min_rank 2=min_len 3=max_len 4=star_off
944// 5=warn_off 6=star_max 7=marker_count. Returns marker count, or -1 if the conf cannot be read --
945// FAIL-CLOSED: no conf means no ranking basis, so the verb refuses rather than inventing weights.
946func 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
988}
989
990// a marker must sit on a WORD BOUNDARY. Measured on real prose: the naive substring test scored
991// "UNMEASURED" as the marker "MEASURED" and promoted a doc line to rank 3 -- a substring needle
992// flatters silently. Only the left edge needs guarding (markers are prefixes like "LAW:").
993func 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
997}
998
999// rank = the MAX of the signals, never the mean (banked law): a star run is the operator's own
1000// ranking convention, a warn glyph is a callout worth rank+bonus, and marker phrases carry their
1001// configured weight. Capped at star_max so a decorative row of stars cannot outrank a real law.
1002func 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
1030}
1031
1032func 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
1139}
1140
1141func main(argc: i64, argv: *i64) -> i64 {
  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> | 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, "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 - 3) { sj_puts("REFUSED journal window exceeded, idempotence unverifiable\n" as *u8); sys_exit(3); return 3 }
      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)
      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
1268}
nx_claude_harvest.nx source

`nx_claude_harvest.nx` source
