nx_claude_harvest_evidence_t45.nx source

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_syscalls.nx" 28import "nx_gate_verdict.nx" 29import "nx_tool_run.nx" 30import "nx_mccabe_lib.nx" 31const CH_MAGIC_146097: i64 = 146097 32const CH_MAGIC_719468: i64 = 719468 33const CH_MAGIC_86400: i64 = 86400 34const CH_MAGIC_3600: i64 = 3600 35const CH_MAGIC_1784764900: i64 = 1784764900 36const CH_MAGIC_1784764901: i64 = 1784764901 37const CH_MAGIC_1784764803: i64 = 1784764803 38 39const CH_WIN: i64 = 67108864 40const CH_JWIN: i64 = 4194304 41const CH_OUT: i64 = 65536 42const CH_LINE: i64 = 4096 43const CH_NAME_MAX: i64 = 120 44const CH_NAME_SCAN: i64 = 400 45const CH_MODE_644: i64 = 420 46// ---- CE1 leg 2 (ce_author_health) consts: declared here, above the selftest that reads them (single-pass parser) ---- 47const CH_AH_MAXPATHS: i64 = 8192 48const CH_AH_PATHCELL: i64 = 512 49const CH_AH_MAXSESS: i64 = 1024 50const CH_AH_SESSCELL: i64 = 64 51const CH_AH_CTRS: i64 = 32 52const CH_AH_SPINE: *u8 = "knowledge/status/mccabe.spine" 53const CH_AH_STATUS: *u8 = "knowledge/status/author_health.status" 54const CH_AH_TREE: *u8 = "buildroot/runtime/" 55const CH_AH_RC_UNOBS: i64 = 3 56const CH_AH_RC_NOPATH: i64 = 4 57const CH_AH_FRAMES: i64 = 0 58const CH_AH_PATHFRAMES: i64 = 1 59const CH_AH_UNIQUE: i64 = 2 60const CH_AH_INTREE: i64 = 3 61const CH_AH_OUTSIDE: i64 = 4 62const CH_AH_FIRSTTS: i64 = 5 63const CH_AH_SESSIONS: i64 = 6 64const CH_AH_FILES: i64 = 7 65const CH_AH_FUNCS: i64 = 8 66const CH_AH_SUMVG: i64 = 9 67const CH_AH_ABOVE: i64 = 10 68const CH_AH_DFILES: i64 = 11 69const CH_AH_DFUNCS: i64 = 12 70const CH_AH_DABOVE: i64 = 13 71const CH_AH_DTS: i64 = 14 72const CH_AH_UNREAD: i64 = 15 73const CH_AH_OVERFLOW: i64 = 16 74const CH_AH_FIX_TS: i64 = 1788600000 75const CH_AH_FIX_DFILES: i64 = 10 76const CH_AH_FIX_DFUNCS: i64 = 20 77const CH_AH_FIX_DABOVE: i64 = 3 78const CH_CH_D0: i64 = 48 79const CH_CH_D9: i64 = 57 80const CH_DEC: i64 = 10 81// ---- beat consts (DM1 ch_beat; declared here because the module parser is single-pass and the 82// selftest teeth read them before the beat section) -- each names its derivation ---- 83const CH_BT_DIRWIN: i64 = 65536 // getdents64 batch buffer -- LOOPED until 0, never a listing cap 84const CH_BT_PATHMAX: i64 = 512 // one path cell; longest real transcript path measured ~120 B, 4x headroom 85const CH_BT_MAXFILES: i64 = 16384 // walk table capacity (837 files measured 2026-08-20); hitting it REFUSES loudly 86const CH_BT_MAXDIRS: i64 = 4096 87const CH_BT_ARENA: i64 = 8388608 // path arena = CH_BT_MAXFILES * CH_BT_PATHMAX exactly 88const CH_BT_TYPEMAX: i64 = 64 // distinct head-type slots; overflow announces FLOOR-NOT-TOTAL 89const CH_BT_DAYMAX: i64 = 128 // distinct ts-days per run (backfill spans ~60); overflow REFUSES loudly 90const CH_BT_DAYCELL: i64 = 16 // one day-name cell: YYYYMMDD (8) or tszero (6) + NUL, padded 91const CH_MCP_BODY_CLIFF: i64 = 65536 // measured: the MCP write body silently drops beyond ~64 KiB 92const CH_BT_CTRS: i64 = 32 // bcx slot count (map at ch_beat) 93const CH_MODE_755: i64 = 493 // rwxr-xr-x for the beat's own state/spool/journal dirs 94const CH_MAGIC_1460: i64 = 1460 // 4*365 (Hinnant civil-from-days) 95const CH_MAGIC_36524: i64 = 36524 // 100*365 + 24 (Hinnant) 96const CH_MAGIC_146096: i64 = 146096 // CH_MAGIC_146097 - 1 (Hinnant) 97 98func ch_read(path: *u8, buf: *u8, cap: i64) -> i64 { 99 let fd: i64 = sys_openat_rd(path) 100 if fd < 0 { return -1 } 101 var n: i64 = 0 102 var go: i64 = 1 103 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 } } 104 sys_close(fd) 105 return n 106} 107// substring search in q[from..endlim) -> position or -1 108func ch_find_from(q: *u8, from: i64, endlim: i64, lit: *u8) -> i64 { 109 var i: i64 = from 110 while i < endlim { 111 var k: i64 = 0 112 var ok: i64 = 1 113 var go: i64 = 1 114 while go == 1 { 115 if lit[k] == (0 as u8) { go = 0 } else { 116 if i + k >= endlim { ok = 0; go = 0 } else { 117 if q[i+k] != lit[k] { ok = 0; go = 0 } else { k = k + 1 } 118 } 119 } 120 } 121 if ok == 1 { return i } 122 i = i + 1 123 } 124 return -1 125} 126func ch_find(q: *u8, n: i64, lit: *u8) -> i64 { 127 if ch_find_from(q, 0, n, lit) >= 0 { return 1 } 128 return 0 129} 130// span q[s..e) begins with lit? 131func ch_starts(q: *u8, s: i64, e: i64, lit: *u8) -> i64 { 132 var k: i64 = 0 133 while lit[k] != (0 as u8) { 134 if s + k >= e { return 0 } 135 if q[s+k] != lit[k] { return 0 } 136 k = k + 1 137 } 138 return 1 139} 140func ch_digits(q: *u8, s: i64, e: i64) -> i64 { 141 if e <= s { return 0 } 142 var i: i64 = s 143 while i < e { let c: i64 = q[i] as i64; if c < 48 { return 0 } if c > 57 { return 0 } i = i + 1 } 144 return 1 145} 146// civil date -> unix epoch (Hinnant days-from-civil, integer only; years >= 1970 here) 147func ch_epoch_ymdhms(y: i64, mo: i64, d: i64, h: i64, mi: i64, s: i64) -> i64 { 148 var yy: i64 = y 149 var mp: i64 = 0 150 if mo > 2 { mp = mo - 3 } else { mp = mo + 9; yy = yy - 1 } 151 let era: i64 = yy / 400 152 let yoe: i64 = yy - era * 400 153 let doy: i64 = (153 * mp + 2) / 5 + d - 1 154 let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy 155 let days: i64 = era * CH_MAGIC_146097 + doe - CH_MAGIC_719468 156 return days * CH_MAGIC_86400 + h * CH_MAGIC_3600 + mi * 60 + s 157} 158// parse ISO "YYYY-MM-DDTHH:MM:SS" at q[s..] (lim-bounded) -> epoch, 0 if malformed 159func ch_iso_epoch(q: *u8, s: i64, lim: i64) -> i64 { 160 if s + 19 > lim { return 0 } 161 if ch_digits(q, s, s+4) == 0 { return 0 } 162 if q[s+4] != (45 as u8) { return 0 } 163 if ch_digits(q, s+5, s+7) == 0 { return 0 } 164 if q[s+7] != (45 as u8) { return 0 } 165 if ch_digits(q, s+8, s+10) == 0 { return 0 } 166 if q[s+10] != (84 as u8) { return 0 } 167 if ch_digits(q, s+11, s+13) == 0 { return 0 } 168 if q[s+13] != (58 as u8) { return 0 } 169 if ch_digits(q, s+14, s+16) == 0 { return 0 } 170 if q[s+16] != (58 as u8) { return 0 } 171 if ch_digits(q, s+17, s+19) == 0 { return 0 } 172 let y: i64 = sj_atoi_span(q, s, s+4) 173 let mo: i64 = sj_atoi_span(q, s+5, s+7) 174 let d: i64 = sj_atoi_span(q, s+8, s+10) 175 let h: i64 = sj_atoi_span(q, s+11, s+13) 176 let mi: i64 = sj_atoi_span(q, s+14, s+16) 177 let se: i64 = sj_atoi_span(q, s+17, s+19) 178 if mo < 1 { return 0 } 179 if mo > 12 { return 0 } 180 if d < 1 { return 0 } 181 if d > 31 { return 0 } 182 return ch_epoch_ymdhms(y, mo, d, h, mi, se) 183} 184// write one actlog frame line to an open fd: <ts>TAB<ws>TAB<tool>TAB<verb>TAB<outcome>TAB<note>NL 185func ch_frame_write(fd: i64, ln: *u8, ts: i64, ws: *u8, tool: *u8, verb: *u8, outcome: *u8, note: *u8) -> i64 { 186 var o: i64 = 0 187 o = sj_catn(ln, o, ts) 188 ln[o] = 9 as u8; o = o + 1 189 o = sj_cat(ln, o, ws) 190 ln[o] = 9 as u8; o = o + 1 191 o = sj_cat(ln, o, tool) 192 ln[o] = 9 as u8; o = o + 1 193 o = sj_cat(ln, o, verb) 194 ln[o] = 9 as u8; o = o + 1 195 o = sj_cat(ln, o, outcome) 196 ln[o] = 9 as u8; o = o + 1 197 o = sj_cat(ln, o, note) 198 ln[o] = 10 as u8; o = o + 1 199 sys_write(fd, ln, o) 200 return 0 201} 202func ch_frame_append(path: *u8, ts: i64, ws: *u8, tool: *u8, verb: *u8, outcome: *u8, note: *u8) -> i64 { 203 let fd: i64 = sys_openat_append(path, CH_MODE_644) 204 if fd < 0 { return -1 } 205 let ln: *u8 = sys_mmap(CH_LINE) 206 ch_frame_write(fd, ln, ts, ws, tool, verb, outcome, note) 207 sys_close(fd) 208 return 0 209} 210// ---------- CE1 leg 2 (codeeffectiveness, 2026-09-05): the PATH a write tool touched ---------- 211// Every frame used to carry `tool use - <verb>` and nothing else, so WHICH FILE a seat wrote was not in the 212// 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 213// own input: nx_fs_write carries it as argv[1] (argv[0] is the verb), Write and Edit as file_path. It is read 214// from a BOUNDED window after the tool's name (the input keys come before any content string, so the FIRST 215// match is the input's own key, never a content byte). ADDITIVE: the note gains one space-separated token 216// `path=<p>`; no column moves, every existing reader sees one more token. A non-writer frame is unchanged. 217const 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 218const CH_PATH_MAX: i64 = 512 219const CH_CH_BSL: i64 = 92 220const CH_WK_NONE: i64 = 0 221const CH_WK_ARGV: i64 = 1 222const CH_WK_FILEPATH: i64 = 2 223func ch_tool_writer_kind(nm: *u8) -> i64 { 224 let nl: i64 = sj_vlen(nm) 225 if sj_lit_eq(nm, 0, nl, "mcp__nishi__nx_fs_write" as *u8) == 1 { return CH_WK_ARGV } 226 if sj_lit_eq(nm, 0, nl, "Write" as *u8) == 1 { return CH_WK_FILEPATH } 227 if sj_lit_eq(nm, 0, nl, "Edit" as *u8) == 1 { return CH_WK_FILEPATH } 228 return CH_WK_NONE 229} 230// copy a JSON string body that starts at k0 (just past the opening quote) up to its closing unescaped quote 231func ch_json_str_copy(buf: *u8, k0: i64, le: i64, pb: *u8, cap: i64) -> i64 { 232 var k: i64 = k0 233 var o: i64 = 0 234 var g: i64 = 1 235 while g == 1 { 236 if k >= le { g = 0 } else { 237 if buf[k] == (34 as u8) { g = 0 } else { 238 if buf[k] == (CH_CH_BSL as u8) { k = k + 1 } 239 if k < le { if o < cap { pb[o] = buf[k]; o = o + 1 } } 240 k = k + 1 241 } 242 } 243 } 244 pb[o] = 0 as u8 245 return o 246} 247// the path for a writer frame: np is the offset of the tool's name key, le the line end. 0 = no path. 248func ch_tool_path(buf: *u8, np: i64, le: i64, kind: i64, pb: *u8) -> i64 { 249 pb[0] = 0 as u8 250 if kind == CH_WK_NONE { return 0 } 251 var scanend: i64 = np + CH_PATH_SCAN 252 if scanend > le { scanend = le } 253 if kind == CH_WK_ARGV { 254 let akey: *u8 = "\"argv\":[\"" as *u8 255 let ap: i64 = ch_find_from(buf, np, scanend, akey) 256 if ap < 0 { return 0 } 257 var k: i64 = ap + sj_vlen(akey) 258 var g: i64 = 1 259 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 } } } 260 let q2: i64 = ch_find_from(buf, k + 1, scanend, "\"" as *u8) 261 if q2 < 0 { return 0 } 262 return ch_json_str_copy(buf, q2 + 1, scanend, pb, CH_PATH_MAX) 263 } 264 let fkey: *u8 = "\"file_path\":\"" as *u8 265 let fp: i64 = ch_find_from(buf, np, scanend, fkey) 266 if fp < 0 { return 0 } 267 return ch_json_str_copy(buf, fp + sj_vlen(fkey), scanend, pb, CH_PATH_MAX) 268} 269// the note for one frame: the verb literal, plus ` path=<p>` when the tool is a writer whose path was read 270func ch_frame_note(buf: *u8, np: i64, le: i64, nm: *u8, verb: *u8, pb: *u8, nb: *u8) -> *u8 { 271 let wk: i64 = ch_tool_writer_kind(nm) 272 if wk == CH_WK_NONE { return verb } 273 if ch_tool_path(buf, np, le, wk, pb) <= 0 { return verb } 274 var no: i64 = sj_cat(nb, 0, verb) 275 no = sj_cat(nb, no, " path=" as *u8) 276 no = sj_cat(nb, no, pb) 277 nb[no] = 0 as u8 278 return nb 279} 280// ---------- frames: transcript JSONL -> actlog frames ---------- 281// returns frames harvested, -1 missing/empty transcript, -3 cannot open out journal. 282// tcx[0] receives truncated flag. 283func ch_frames(tpath: *u8, ws: *u8, outj: *u8, tcx: *i64) -> i64 { 284 let buf: *u8 = sys_mmap(CH_WIN) 285 let cap: i64 = CH_WIN - 8 286 let n: i64 = ch_read(tpath, buf, cap) 287 tcx[0] = 0 288 if n <= 0 { return -1 } 289 if n >= cap { tcx[0] = 1 } 290 let fd: i64 = sys_openat_append(outj, CH_MODE_644) 291 if fd < 0 { return -3 } 292 let ln: *u8 = sys_mmap(CH_LINE) 293 let nm: *u8 = sys_mmap(256) 294 let pb: *u8 = sys_mmap(CH_PATH_MAX + 8) 295 let nb: *u8 = sys_mmap(CH_PATH_MAX + 64) 296 var frames: i64 = 0 297 var i: i64 = 0 298 while i < n { 299 let le: i64 = sj_le(buf, i, n) 300 var ts: i64 = 0 301 let tp: i64 = ch_find_from(buf, i, le, "\"timestamp\":\"" as *u8) 302 if tp >= 0 { ts = ch_iso_epoch(buf, tp + 13, le) } 303 var j: i64 = i 304 var go: i64 = 1 305 while go == 1 { 306 let tu: i64 = ch_find_from(buf, j, le, "\"type\":\"tool_use\"" as *u8) 307 if tu < 0 { go = 0 } else { 308 var scanend: i64 = tu + CH_NAME_SCAN 309 if scanend > le { scanend = le } 310 let np: i64 = ch_find_from(buf, tu, scanend, "\"name\":\"" as *u8) 311 if np >= 0 { 312 var k: i64 = np + 8 313 var o: i64 = 0 314 var g2: i64 = 1 315 while g2 == 1 { 316 if k >= le { g2 = 0 } else { 317 if buf[k] == (34 as u8) { g2 = 0 } else { 318 if o < CH_NAME_MAX { nm[o] = buf[k]; o = o + 1 } 319 k = k + 1 320 } 321 } 322 } 323 nm[o] = 0 as u8 324 if o > 0 { 325 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)) 326 frames = frames + 1 327 } 328 } 329 j = tu + 17 330 } 331 } 332 i = le + 1 333 } 334 sys_close(fd) 335 return frames 336} 337// ---------- delta: HIGH-WATER-MARK harvest, the F973 self-sufficiency half ---------- 338// The ongoing-harvest loop lived in a laptop PowerShell parser (MG03: Claude hand-writes miners). 339// This puts the byte-offset high-water mark INSIDE the organ, so the harvester is self-sufficient on 340// ANY host that holds transcripts: run the ELF, it consumes only what grew since last time. 341// EXACTLY-ONCE BY CONSTRUCTION: only COMPLETE lines are consumed (a partial trailing line stays below 342// the mark for the next run), and the mark advances only over what was actually parsed. A re-run on an 343// unchanged transcript yields 0 frames -- idempotent without needing a marker. 344// hcx[0]=frames hcx[1]=new_hwm hcx[2]=old_hwm hcx[3]=truncated 345func ch_hwm_read(path: *u8) -> i64 { 346 let b: *u8 = sys_mmap(CH_LINE) 347 let fd: i64 = sys_openat_rd(path) 348 if fd < 0 { return 0 } 349 let r: i64 = sys_read(fd, b, CH_LINE - 8) 350 sys_close(fd) 351 if r <= 0 { return 0 } 352 var v: i64 = 0 353 var i: i64 = 0 354 while i < r { let c: i64 = b[i] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } i = i + 1 } 355 return v 356} 357func ch_hwm_write(path: *u8, v: i64) -> i64 { 358 let fd: i64 = sys_openat_wr(path, CH_MODE_644) 359 if fd < 0 { return -1 } 360 let b: *u8 = sys_mmap(CH_LINE) 361 var o: i64 = sj_catn(b, 0, v) 362 b[o] = 10 as u8 363 sys_write(fd, b, o + 1) 364 sys_close(fd) 365 return 0 366} 367func ch_delta(tpath: *u8, ws: *u8, outj: *u8, hwmpath: *u8, hcx: *i64) -> i64 { 368 hcx[0] = 0 369 hcx[1] = 0 370 hcx[2] = 0 371 hcx[3] = 0 372 // read sized-by-file (2026-08-20): the old fixed CH_WIN window silently stopped harvesting past 373 // 64 MiB (largest real transcript measured 55.8 MB the same day -- the cliff was DAYS away). 374 // sys_map_file is read-only/zero-copy and every parse below is span-bounded, never NUL-reliant. 375 // hcx[3] (truncated) is structurally 0 now; the slot stays for contract stability. 376 let nn: *i64 = sys_mmap(16) as *i64 377 let buf: *u8 = sys_map_file(tpath, nn) 378 let n: i64 = nn[0] 379 if n <= 0 { return -1 } 380 var hwm: i64 = ch_hwm_read(hwmpath) 381 if hwm < 0 { hwm = 0 } 382 if hwm > n { hwm = 0 } 383 hcx[2] = hwm 384 hcx[1] = hwm 385 if hwm >= n { sys_munmap(buf, n); return 0 } 386 // consume only up to the LAST newline: a partial trailing line waits for the next run 387 var lastnl: i64 = 0 - 1 388 var z: i64 = n - 1 389 while z >= hwm { if lastnl < 0 { if buf[z] == (10 as u8) { lastnl = z } } z = z - 1 } 390 if lastnl < 0 { sys_munmap(buf, n); return 0 } 391 let fd: i64 = sys_openat_append(outj, CH_MODE_644) 392 if fd < 0 { sys_munmap(buf, n); return -3 } 393 let ln: *u8 = sys_mmap(CH_LINE) 394 let nm: *u8 = sys_mmap(256) 395 let pb: *u8 = sys_mmap(CH_PATH_MAX + 8) 396 let nb: *u8 = sys_mmap(CH_PATH_MAX + 64) 397 var frames: i64 = 0 398 var i: i64 = hwm 399 while i <= lastnl { 400 let le: i64 = sj_le(buf, i, lastnl + 1) 401 var ts: i64 = 0 402 let tp: i64 = ch_find_from(buf, i, le, "\"timestamp\":\"" as *u8) 403 if tp >= 0 { ts = ch_iso_epoch(buf, tp + 13, le) } 404 var j: i64 = i 405 var go: i64 = 1 406 while go == 1 { 407 let tu: i64 = ch_find_from(buf, j, le, "\"type\":\"tool_use\"" as *u8) 408 if tu < 0 { go = 0 } else { 409 var scanend: i64 = tu + CH_NAME_SCAN 410 if scanend > le { scanend = le } 411 let np: i64 = ch_find_from(buf, tu, scanend, "\"name\":\"" as *u8) 412 if np >= 0 { 413 var k: i64 = np + 8 414 var o: i64 = 0 415 var g2: i64 = 1 416 while g2 == 1 { 417 if k >= le { g2 = 0 } else { 418 if buf[k] == (34 as u8) { g2 = 0 } else { 419 if o < CH_NAME_MAX { nm[o] = buf[k]; o = o + 1 } 420 k = k + 1 421 } 422 } 423 } 424 nm[o] = 0 as u8 425 if o > 0 { 426 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)) 427 frames = frames + 1 428 } 429 } 430 j = tu + 17 431 } 432 } 433 i = le + 1 434 } 435 sys_close(fd) 436 sys_munmap(buf, n) 437 hcx[0] = frames 438 hcx[1] = lastnl + 1 439 ch_hwm_write(hwmpath, lastnl + 1) 440 return 0 441} 442// ---------- ingest: validated bulk append of a staged frames file, marker-idempotent ---------- 443// returns >=0 ingested count (mcx[0]=malformed), -1 missing frames file, -2 already ingested, 444// -4 cannot open journal. (-3 window-exceeded was RETIRED 2026-08-20: the marker-verify read is now 445// sized by the journal itself via sys_map_file, so idempotence is verifiable at any journal size.) 446func ch_ingest(fpath: *u8, jpath: *u8, mcx: *i64) -> i64 { 447 mcx[0] = 0 448 // marker = "harvest-ingest:" + basename(fpath) 449 var bs: i64 = 0 450 var i: i64 = 0 451 while fpath[i] != (0 as u8) { if fpath[i] == (47 as u8) { bs = i + 1 } i = i + 1 } 452 let marker: *u8 = sys_mmap(512) 453 var mo: i64 = sj_cat(marker, 0, "harvest-ingest:" as *u8) 454 mo = sj_cat(marker, mo, ((fpath as i64) + bs) as *u8) 455 marker[mo] = 0 as u8 456 let jnn: *i64 = sys_mmap(16) as *i64 457 let jbuf: *u8 = sys_map_file(jpath, jnn) 458 let jn: i64 = jnn[0] 459 if jn > 0 { 460 if ch_find(jbuf, jn, marker) == 1 { sys_munmap(jbuf, jn); return -2 } 461 sys_munmap(jbuf, jn) 462 } 463 let fbuf: *u8 = sys_mmap(CH_WIN) 464 let fcap: i64 = CH_WIN - 8 465 let fn: i64 = ch_read(fpath, fbuf, fcap) 466 if fn <= 0 { return -1 } 467 let fd: i64 = sys_openat_append(jpath, CH_MODE_644) 468 if fd < 0 { return -4 } 469 let sp: *i64 = sys_mmap(16) as *i64 470 let nl: *u8 = sys_mmap(8) 471 nl[0] = 10 as u8 472 var ing: i64 = 0 473 var p: i64 = 0 474 while p < fn { 475 let le: i64 = sj_le(fbuf, p, fn) 476 var ok: i64 = 0 477 if le > p { 478 if sj_col(fbuf, p, le, 5, sp) == 1 { 479 if sj_col(fbuf, p, le, 6, sp) == 0 { 480 if sj_col(fbuf, p, le, 0, sp) == 1 { 481 if ch_digits(fbuf, sp[0], sp[1]) == 1 { ok = 1 } 482 } 483 } 484 } 485 } 486 if ok == 1 { 487 sys_write(fd, ((fbuf as i64) + p) as *u8, le - p) 488 sys_write(fd, nl, 1) 489 ing = ing + 1 490 } else { 491 if le > p { mcx[0] = mcx[0] + 1 } 492 } 493 p = le + 1 494 } 495 let ln: *u8 = sys_mmap(CH_LINE) 496 ch_frame_write(fd, ln, sys_now_realtime_sec(), "harvest" as *u8, "nx_claude_harvest" as *u8, "ingest" as *u8, "ok" as *u8, marker) 497 sys_close(fd) 498 return ing 499} 500// ---------- gauge: outside_permil JSON from a frames journal ---------- 501func ch_nishi_tool(q: *u8, s: i64, e: i64) -> i64 { 502 if ch_starts(q, s, e, "mcp__nishi__" as *u8) == 1 { return 1 } 503 if ch_starts(q, s, e, "nx_" as *u8) == 1 { return 1 } 504 if ch_starts(q, s, e, "nishi" as *u8) == 1 { return 1 } 505 if ch_starts(q, s, e, "vizsla" as *u8) == 1 { return 1 } 506 return 0 507} 508func ch_key(d: *u8, o: i64, name: *u8) -> i64 { 509 d[o] = 34 as u8 510 var p: i64 = o + 1 511 p = sj_cat(d, p, name) 512 d[p] = 34 as u8 513 p = p + 1 514 d[p] = 58 as u8 515 p = p + 1 516 return p 517} 518// ---------- bootgauge: SOTA-FROM-THE-FIRST-BYTE (operator 2026-07-24 'go SOTA from the first byte up') ---------- 519// For each session (ws) is the FIRST tool nishi-native? A session that opens with nx_seat boot is SOTA 520// from byte 1; one that opens by reading 40KB of memory / scratchpadding is LEGACY. Measures the 521// SOTA-boot ratio + the softer nishi-within-first-K signal. Sessions interned by ws span (bounded, declared). 522const CH_WS_MAX: i64 = 4096 523func ch_bg_intern(q: *u8, cs: i64, ce: i64, wss: *i64, wse: *i64, np: *i64) -> i64 { 524 var i: i64 = 0 525 while i < np[0] { 526 if ce - cs == wse[i] - wss[i] { 527 var m: i64 = 0 528 var eq: i64 = 1 529 while m < ce - cs { if q[cs+m] != q[wss[i]+m] { eq = 0; m = ce - cs } else { m = m + 1 } } 530 if eq == 1 { return i } 531 } 532 i = i + 1 533 } 534 if np[0] >= CH_WS_MAX { return -1 } 535 wss[np[0]] = cs 536 wse[np[0]] = ce 537 np[0] = np[0] + 1 538 return np[0] - 1 539} 540func ch_bootgauge(journal: *u8, k: i64, d: *u8) -> i64 { 541 let q: *u8 = sys_mmap(CH_JWIN) 542 let cap: i64 = CH_JWIN - 8 543 var n: i64 = ch_read(journal, q, cap) 544 if n < 0 { n = 0 } 545 var trunc: i64 = 0 546 if n >= cap { trunc = 1 } 547 let wss: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64 548 let wse: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64 549 let wfn: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64 550 let wnk: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64 551 let wc: *i64 = sys_mmap(8 * CH_WS_MAX) as *i64 552 let np: *i64 = sys_mmap(16) as *i64 553 let sp: *i64 = sys_mmap(16) as *i64 554 var frames: i64 = 0 555 var malformed: i64 = 0 556 var capped: i64 = 0 557 var i: i64 = 0 558 while i < n { 559 let le: i64 = sj_le(q, i, n) 560 if le > i { 561 if sj_col(q, i, le, 1, sp) == 1 { 562 let ws0: i64 = sp[0] 563 let ws1: i64 = sp[1] 564 if sj_col(q, i, le, 2, sp) == 1 { 565 frames = frames + 1 566 let wi: i64 = ch_bg_intern(q, ws0, ws1, wss, wse, np) 567 if wi < 0 { capped = 1 } else { 568 let isn: i64 = ch_nishi_tool(q, sp[0], sp[1]) 569 let c: i64 = wc[wi] 570 wc[wi] = c + 1 571 if c == 0 { wfn[wi] = isn } 572 if c < k { if isn == 1 { wnk[wi] = 1 } } 573 } 574 } else { malformed = malformed + 1 } 575 } else { malformed = malformed + 1 } 576 } 577 i = le + 1 578 } 579 var sota: i64 = 0 580 var nishik: i64 = 0 581 var kk: i64 = 0 582 while kk < np[0] { 583 if wfn[kk] == 1 { sota = sota + 1 } 584 if wnk[kk] == 1 { nishik = nishik + 1 } 585 kk = kk + 1 586 } 587 let total: i64 = np[0] 588 var sotaperm: i64 = 0 - 1 589 var nkperm: i64 = 0 - 1 590 if total > 0 { sotaperm = sota * 1000 / total; nkperm = nishik * 1000 / total } 591 var p: i64 = 0 592 d[p] = 123 as u8; p = p + 1 593 p = ch_key(d, p, "v" as *u8); p = sj_catn(d, p, 1); d[p] = 44 as u8; p = p + 1 594 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 595 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 596 p = ch_key(d, p, "journal_bytes" as *u8); p = sj_catn(d,p,n); d[p]=44 as u8;p=p+1 597 p = ch_key(d, p, "truncated" as *u8); p = sj_catn(d,p,trunc); d[p]=44 as u8;p=p+1 598 p = ch_key(d, p, "k" as *u8); p = sj_catn(d,p,k); d[p]=44 as u8;p=p+1 599 p = ch_key(d, p, "frames" as *u8); p = sj_catn(d,p,frames); d[p]=44 as u8;p=p+1 600 p = ch_key(d, p, "malformed" as *u8); p = sj_catn(d,p,malformed); d[p]=44 as u8;p=p+1 601 p = ch_key(d, p, "sessions" as *u8); p = sj_catn(d,p,total); d[p]=44 as u8;p=p+1 602 p = ch_key(d, p, "sota_first" as *u8); p = sj_catn(d,p,sota); d[p]=44 as u8;p=p+1 603 p = ch_key(d, p, "legacy_first" as *u8); p = sj_catn(d,p,total-sota); d[p]=44 as u8;p=p+1 604 p = ch_key(d, p, "sota_boot_permil" as *u8); p = sj_catn(d,p,sotaperm); d[p]=44 as u8;p=p+1 605 p = ch_key(d, p, "nishi_within_k" as *u8); p = sj_catn(d,p,nishik); d[p]=44 as u8;p=p+1 606 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 607 p = ch_key(d, p, "sessions_capped" as *u8); p = sj_catn(d,p,capped) 608 d[p] = 125 as u8; p = p + 1 609 d[p] = 10 as u8; p = p + 1 610 return p 611} 612// gauge core: g slots 0 total 1 nishi 2 outside 3 permil(legacy,all) 4 malformed 5 trunc 6 bytes 613// 7 beats(verb=run: estate autonomy) 8 claude_actions 9 claude_outside 10 claude_outside_permil 614// FULL journal read via sys_read_file (the 4MB cap SAMPLED THE JULY HEAD -- fixed 2026-09-05). 615// Reliance is measured over CLAUDE-ACTION frames ONLY; estate :run beats are the estate running 616// ITSELF (sovereign) and would dilute the denominator (measured law 2026-09-05). 617func ch_gauge_calc(jpath: *u8, days: i64, g: *i64) -> i64 { 618 let nn: *i64 = sys_mmap(16) as *i64 619 let q: *u8 = sys_read_file(jpath, nn) 620 var n: i64 = nn[0] 621 if n < 0 { n = 0 } 622 let trunc: i64 = 0 623 var cutoff: i64 = 0 624 if days > 0 { cutoff = sys_now_realtime_sec() - days * CH_MAGIC_86400 } 625 let sp: *i64 = sys_mmap(16) as *i64 626 let vp: *i64 = sys_mmap(16) as *i64 627 var total: i64 = 0 628 var nishi: i64 = 0 629 var outside: i64 = 0 630 var malformed: i64 = 0 631 var beats: i64 = 0 632 var cl_total: i64 = 0 633 var cl_outside: i64 = 0 634 var i: i64 = 0 635 while i < n { 636 let le: i64 = sj_le(q, i, n) 637 if le > i { 638 var ok: i64 = 0 639 var ts: i64 = 0 640 var isnishi: i64 = 0 641 var isbeat: i64 = 0 642 if sj_col(q, i, le, 0, sp) == 1 { 643 if ch_digits(q, sp[0], sp[1]) == 1 { 644 ts = sj_atoi_span(q, sp[0], sp[1]) 645 if sj_col(q, i, le, 2, sp) == 1 { ok = 1 } 646 } 647 } 648 if ok == 1 { 649 isnishi = ch_nishi_tool(q, sp[0], sp[1]) 650 if sj_col(q, i, le, 3, vp) == 1 { 651 if (vp[1] - vp[0]) == 3 { if ch_starts(q, vp[0], vp[1], "run" as *u8) == 1 { isbeat = 1 } } 652 } 653 if ts >= cutoff { 654 total = total + 1 655 if isnishi == 1 { nishi = nishi + 1 } else { outside = outside + 1 } 656 if isbeat == 1 { beats = beats + 1 } else { 657 cl_total = cl_total + 1 658 if isnishi == 0 { cl_outside = cl_outside + 1 } 659 } 660 } 661 } else { malformed = malformed + 1 } 662 } 663 i = le + 1 664 } 665 var permil: i64 = 0 - 1 666 if total > 0 { permil = outside * 1000 / total } 667 var clperm: i64 = 0 - 1 668 if cl_total > 0 { clperm = cl_outside * 1000 / cl_total } 669 g[0] = total 670 g[1] = nishi 671 g[2] = outside 672 g[3] = permil 673 g[4] = malformed 674 g[5] = trunc 675 g[6] = n 676 g[7] = beats 677 g[8] = cl_total 678 g[9] = cl_outside 679 g[10] = clperm 680 g[11] = 0 681 if (q as i64) == 0 { g[11] = 1; return -1 } 682 return 0 683} 684func ch_gauge_json(jpath: *u8, days: i64, d: *u8) -> i64 { 685 let g: *i64 = sys_mmap(128) as *i64 686 ch_gauge_calc(jpath, days, g) 687 let total: i64 = g[0] 688 let nishi: i64 = g[1] 689 let outside: i64 = g[2] 690 let permil: i64 = g[3] 691 let malformed: i64 = g[4] 692 let trunc: i64 = g[5] 693 let n: i64 = g[6] 694 var p: i64 = 0 695 d[p] = 123 as u8; p = p + 1 696 p = ch_key(d, p, "v" as *u8); p = sj_catn(d, p, 1); d[p] = 44 as u8; p = p + 1 697 p = ch_key(d, p, "tool" as *u8) 698 d[p] = 34 as u8; p = p + 1 699 p = sj_cat(d, p, "nx_claude_harvest" as *u8) 700 d[p] = 34 as u8; p = p + 1 701 d[p] = 44 as u8; p = p + 1 702 p = ch_key(d, p, "averb" as *u8) 703 d[p] = 34 as u8; p = p + 1 704 p = sj_cat(d, p, "gauge" as *u8) 705 d[p] = 34 as u8; p = p + 1 706 d[p] = 44 as u8; p = p + 1 707 p = ch_key(d, p, "journal" as *u8) 708 d[p] = 34 as u8; p = p + 1 709 p = sj_cat_esc(d, p, jpath, 0, sj_vlen(jpath), 200) 710 d[p] = 34 as u8; p = p + 1 711 d[p] = 44 as u8; p = p + 1 712 p = ch_key(d, p, "journal_bytes" as *u8); p = sj_catn(d, p, n); d[p] = 44 as u8; p = p + 1 713 p = ch_key(d, p, "truncated" as *u8); p = sj_catn(d, p, trunc); d[p] = 44 as u8; p = p + 1 714 p = ch_key(d, p, "days" as *u8); p = sj_catn(d, p, days); d[p] = 44 as u8; p = p + 1 715 p = ch_key(d, p, "frames_total" as *u8); p = sj_catn(d, p, total); d[p] = 44 as u8; p = p + 1 716 p = ch_key(d, p, "malformed" as *u8); p = sj_catn(d, p, malformed); d[p] = 44 as u8; p = p + 1 717 p = ch_key(d, p, "nishi" as *u8); p = sj_catn(d, p, nishi); d[p] = 44 as u8; p = p + 1 718 p = ch_key(d, p, "outside" as *u8); p = sj_catn(d, p, outside); d[p] = 44 as u8; p = p + 1 719 p = ch_key(d, p, "outside_permil" as *u8); p = sj_catn(d, p, permil); d[p] = 44 as u8; p = p + 1 720 p = ch_key(d, p, "beats" as *u8); p = sj_catn(d, p, g[7]); d[p] = 44 as u8; p = p + 1 721 p = ch_key(d, p, "claude_actions" as *u8); p = sj_catn(d, p, g[8]); d[p] = 44 as u8; p = p + 1 722 p = ch_key(d, p, "claude_outside" as *u8); p = sj_catn(d, p, g[9]); d[p] = 44 as u8; p = p + 1 723 p = ch_key(d, p, "claude_outside_permil" as *u8); p = sj_catn(d, p, g[10]) 724 p = sj_cat(d, p, ",\"evidence_state\":\"" as *u8) 725 if g[11] == 1 { p = sj_cat(d, p, "source_open_failed" as *u8) } else { p = sj_cat(d, p, "source_opened" as *u8) } 726 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) 727 d[p] = 125 as u8; p = p + 1 728 d[p] = 10 as u8; p = p + 1 729 return p 730} 731// ---------- page: the F965 watch-it-fall surface (HTML, minimal; U2/U3 restyle rides ui-debt lane) ---------- 732func ch_page(jpath: *u8, outp: *u8, days: i64) -> i64 { 733 let g: *i64 = sys_mmap(128) as *i64 734 ch_gauge_calc(jpath, days, g) 735 let d: *u8 = sys_mmap(CH_OUT) 736 var p: i64 = 0 737 d[p] = 60 as u8; p = p + 1 738 d[p] = 33 as u8; p = p + 1 739 p = sj_cat(d, p, "doctype html><html><head><meta charset=\"utf-8\"><title>Outside Gauge</title></head><body>" as *u8) 740 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) 741 p = sj_cat(d, p, "<p style=\"font-size:64px;margin:8px 0\">" as *u8) 742 p = sj_catn(d, p, g[10]) 743 p = sj_cat(d, p, "&permil;</p>" as *u8) 744 p = sj_cat(d, p, "<p>outside_permil=" as *u8) 745 p = sj_catn(d, p, g[3]) 746 p = sj_cat(d, p, " (frames=" as *u8) 747 p = sj_catn(d, p, g[0]) 748 p = sj_cat(d, p, " nishi=" as *u8) 749 p = sj_catn(d, p, g[1]) 750 p = sj_cat(d, p, " outside=" as *u8) 751 p = sj_catn(d, p, g[2]) 752 p = sj_cat(d, p, " malformed=" as *u8) 753 p = sj_catn(d, p, g[4]) 754 p = sj_cat(d, p, " truncated=" as *u8) 755 p = sj_catn(d, p, g[5]) 756 p = sj_cat(d, p, " days=" as *u8) 757 p = sj_catn(d, p, days) 758 p = sj_cat(d, p, ")</p>" as *u8) 759 p = sj_cat(d, p, "<p>claude_outside_permil=" as *u8) 760 p = sj_catn(d, p, g[10]) 761 p = sj_cat(d, p, " (claude_actions=" as *u8) 762 p = sj_catn(d, p, g[8]) 763 p = sj_cat(d, p, " claude_outside=" as *u8) 764 p = sj_catn(d, p, g[9]) 765 p = sj_cat(d, p, " estate_beats_excluded=" as *u8) 766 p = sj_catn(d, p, g[7]) 767 p = sj_cat(d, p, ")</p>" as *u8) 768 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) 769 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) 770 p = sj_cat(d, p, "<p>emitted by nx_claude_harvest page (hourly beat); journal " as *u8) 771 p = sj_cat(d, p, jpath) 772 p = sj_cat(d, p, "</p></body></html>" as *u8) 773 let fd: i64 = sys_openat_wr(outp, CH_MODE_644) 774 if fd < 0 { return -1 } 775 sys_write(fd, d, p) 776 sys_close(fd) 777 return 0 778} 779// ---------- classes: the residual BY TOOL, whole partition (SV2, 2026-09-05) ---------- 780// Over CLAUDE-ACTION frames only (estate :run beats excluded), count outside frames per tool name. 781// The emitted list is the top CH_CLS_SHOW by count plus an OTHER bucket so the partition SUMS to 782// claude_outside; the table cap is named and frames beyond it are COUNTED (classes_unnamed_overflow), 783// never silently dropped. Today (2026-09-05) nx_actlog freq could only show the top 30 of 1,635 tool:verb 784// pairs across ALL frames; this verb answers the residual question directly and feeds the journal row. 785const CH_CLS_MAX: i64 = 512 // distinct outside tool names tracked (transcript tool names measured ~60 distinct) 786const CH_CLS_NAME: i64 = 64 // one name cell; longest builtin tool name measured well under this 787const CH_CLS_SHOW: i64 = 12 // JSON shows this many, the rest fold into other 788const CH_CLS_JSHOW: i64 = 6 // the journal row shows this many, the rest fold into other 789func ch_classes_calc(jpath: *u8, names: *u8, counts: *i64, c: *i64) -> i64 { 790 let nn: *i64 = sys_mmap(16) as *i64 791 let q: *u8 = sys_read_file(jpath, nn) 792 var n: i64 = nn[0] 793 if n < 0 { n = 0 } 794 let sp: *i64 = sys_mmap(16) as *i64 795 let vp: *i64 = sys_mmap(16) as *i64 796 var ncls: i64 = 0 797 var ovf: i64 = 0 798 var outside: i64 = 0 799 var i: i64 = 0 800 while i < n { 801 let le: i64 = sj_le(q, i, n) 802 if le > i { 803 var ok: i64 = 0 804 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 } } } 805 if ok == 1 { 806 var isbeat: i64 = 0 807 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 } } } 808 if isbeat == 0 { if ch_nishi_tool(q, sp[0], sp[1]) == 0 { 809 outside = outside + 1 810 var tl: i64 = sp[1] - sp[0] 811 if tl > CH_CLS_NAME - 1 { tl = CH_CLS_NAME - 1 } 812 var hit: i64 = 0 - 1 813 var k: i64 = 0 814 while k < ncls { 815 let nm: *u8 = ((names as i64) + k * CH_CLS_NAME) as *u8 816 var m: i64 = 0 817 var same: i64 = 1 818 while m < tl { if nm[m] != q[sp[0] + m] { same = 0; m = tl } else { m = m + 1 } } 819 if same == 1 { if nm[tl] == (0 as u8) { hit = k; k = ncls } } 820 k = k + 1 821 } 822 if hit >= 0 { counts[hit] = counts[hit] + 1 } else { 823 if ncls < CH_CLS_MAX { 824 let nm2: *u8 = ((names as i64) + ncls * CH_CLS_NAME) as *u8 825 var m2: i64 = 0 826 while m2 < tl { nm2[m2] = q[sp[0] + m2]; m2 = m2 + 1 } 827 nm2[tl] = 0 as u8 828 counts[ncls] = 1 829 ncls = ncls + 1 830 } else { ovf = ovf + 1 } 831 } 832 } } 833 } 834 } 835 i = le + 1 836 } 837 c[0] = ncls 838 c[1] = ovf 839 return outside 840} 841func ch_classes_top(counts: *i64, used: *i64, ncls: i64) -> i64 { 842 var best: i64 = 0 - 1 843 var k: i64 = 0 844 while k < ncls { if used[k] == 0 { if best < 0 { best = k } else { if counts[k] > counts[best] { best = k } } } k = k + 1 } 845 return best 846} 847func ch_classes_cat(d: *u8, o0: i64, names: *u8, counts: *i64, ncls: i64, show: i64, outside: i64) -> i64 { 848 var o: i64 = o0 849 let used: *i64 = sys_mmap(CH_CLS_MAX * 8) as *i64 850 var shown: i64 = 0 851 var acc: i64 = 0 852 var s: i64 = 0 853 while s < show { 854 let b: i64 = ch_classes_top(counts, used, ncls) 855 if b >= 0 { 856 used[b] = 1 857 if shown > 0 { o = sj_cat(d, o, "," as *u8) } 858 o = sj_cat(d, o, ((names as i64) + b * CH_CLS_NAME) as *u8) 859 o = sj_cat(d, o, ":" as *u8) 860 o = sj_catn(d, o, counts[b]) 861 acc = acc + counts[b] 862 shown = shown + 1 863 } 864 s = s + 1 865 } 866 if shown > 0 { o = sj_cat(d, o, "," as *u8) } 867 o = sj_cat(d, o, "other:" as *u8) 868 o = sj_catn(d, o, outside - acc) 869 return o 870} 871func ch_classes_json(jpath: *u8, d: *u8) -> i64 { 872 let names: *u8 = sys_mmap(CH_CLS_MAX * CH_CLS_NAME) 873 let counts: *i64 = sys_mmap(CH_CLS_MAX * 8) as *i64 874 let c: *i64 = sys_mmap(16) as *i64 875 let outside: i64 = ch_classes_calc(jpath, names, counts, c) 876 var p: i64 = 0 877 d[p] = 123 as u8; p = p + 1 878 p = ch_key(d, p, "v" as *u8); p = sj_catn(d, p, 1); d[p] = 44 as u8; p = p + 1 879 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 880 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 881 p = ch_key(d, p, "claude_outside" as *u8); p = sj_catn(d, p, outside); d[p] = 44 as u8; p = p + 1 882 p = ch_key(d, p, "classes_distinct" as *u8); p = sj_catn(d, p, c[0]); d[p] = 44 as u8; p = p + 1 883 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 884 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 885 var show: i64 = CH_CLS_SHOW 886 if c[0] < show { show = c[0] } 887 p = ch_key(d, p, "classes_shown" as *u8); p = sj_catn(d, p, show); d[p] = 44 as u8; p = p + 1 888 p = ch_key(d, p, "top_and_other" as *u8); d[p] = 34 as u8; p = p + 1 889 p = ch_classes_cat(d, p, names, counts, c[0], show, outside) 890 d[p] = 34 as u8; p = p + 1 891 d[p] = 125 as u8; p = p + 1 892 d[p] = 10 as u8; p = p + 1 893 return p 894} 895// ch_classes: THE CONTRACT SYMBOL named by the sovereignty board (SV2, watch _ABSENT_:ch_classes). The symbol 896// ruler (nx_symdecl_lib sd_present) applies the DECLARATION rule to a .nx organ and never falls back to a 897// substring for a lowercase identifier, so ch_classes_json alone can never flip the cell: the board named 898// ch_classes, so ch_classes is what ships. One entry point over the verb, declared here AND called by main. 899func ch_classes(jpath: *u8, d: *u8) -> i64 { return ch_classes_json(jpath, d) } 900// ---------- journal: the SELF-UPDATING number on /compare (2026-09-05) ---------- 901// Appends ONE `log|<epoch>|<rung>|measure|...` row to a domain .plan per UTC day (idempotent by a day 902// marker carried in the row), so the compare emitter renders the live reliance number beside the rung 903// with ZERO seat tokens. Wired on the plan-wsmine- beat. Codes: 0 written | 1 plan missing or unwritable 904// (a beat NEVER creates a plan) | 4 already journaled today | 5 insufficient data (never journal a -1). 905func ch_journal(jpath: *u8, planpath: *u8, rung: *u8) -> i64 { 906 let g: *i64 = sys_mmap(128) as *i64 907 ch_gauge_calc(jpath, 0, g) 908 if g[8] <= 0 { return 5 } 909 let now: i64 = sys_now_realtime_sec() 910 let day: i64 = now / CH_MAGIC_86400 911 let nn: *i64 = sys_mmap(16) as *i64 912 let pb: *u8 = sys_read_file(planpath, nn) 913 let pn: i64 = nn[0] 914 if pn <= 0 { return 1 } 915 let mk: *u8 = sys_mmap(128) 916 var mo: i64 = sj_cat(mk, 0, "[HARV:journal:day=" as *u8) 917 mo = sj_catn(mk, mo, day) 918 mo = sj_cat(mk, mo, "]" as *u8) 919 mk[mo] = 0 as u8 920 if ch_find(pb, pn, mk) == 1 { return 4 } 921 let row: *u8 = sys_mmap(CH_LINE) 922 var o: i64 = sj_cat(row, 0, "log|" as *u8) 923 o = sj_catn(row, o, now) 924 o = sj_cat(row, o, "|" as *u8) 925 o = sj_cat(row, o, rung) 926 o = sj_cat(row, o, "|measure|" as *u8) 927 o = sj_cat(row, o, mk) 928 o = sj_cat(row, o, " claude_outside_permil=" as *u8) 929 o = sj_catn(row, o, g[10]) 930 o = sj_cat(row, o, " claude_actions=" as *u8) 931 o = sj_catn(row, o, g[8]) 932 o = sj_cat(row, o, " claude_outside=" as *u8) 933 o = sj_catn(row, o, g[9]) 934 o = sj_cat(row, o, " estate_beats_excluded=" as *u8) 935 o = sj_catn(row, o, g[7]) 936 o = sj_cat(row, o, " frames_total=" as *u8) 937 o = sj_catn(row, o, g[0]) 938 o = sj_cat(row, o, " journal_bytes=" as *u8) 939 o = sj_catn(row, o, g[6]) 940 let cn: *u8 = sys_mmap(CH_CLS_MAX * CH_CLS_NAME) 941 let cc: *i64 = sys_mmap(CH_CLS_MAX * 8) as *i64 942 let cx: *i64 = sys_mmap(16) as *i64 943 let cout2: i64 = ch_classes_calc(jpath, cn, cc, cx) 944 o = sj_cat(row, o, " outside_by_tool=" as *u8) 945 var jshow: i64 = CH_CLS_JSHOW 946 if cx[0] < jshow { jshow = cx[0] } 947 o = ch_classes_cat(row, o, cn, cc, cx[0], jshow, cout2) 948 o = sj_cat(row, o, " (nx_claude_harvest journal: full read, estate beats excluded, one row per UTC day)" as *u8) 949 row[o] = 10 as u8 950 o = o + 1 951 let fd: i64 = sys_openat_append(planpath, CH_MODE_644) 952 if fd < 0 { return 1 } 953 sys_write(fd, row, o) 954 sys_close(fd) 955 return 0 956} 957// ---------- F971 propose: the gauge FILES its own migration work (feeder pattern) ---------- 958// codes: 0 filed | 1 filer-fail | 2 below-threshold | 3 intake-window-exceeded (fail closed) | 959// 4 already-proposed (marker) | 5 insufficient-data. Filer is INJECTABLE (argecho in the 960// gate) and ALLOWLIST-RESOLVED (never a hardcoded sibling path). Marker [HARV:outsidegap:v1] 961// makes re-runs never re-file. NOTE ch_allow_path duplicates nx_actlog al_allow_path -- the 962// shared nx_jrnl_lib extraction is the filed rule-15 residual. 963// DELEGATES to the shared base (rule-15 extraction 2026-07-23) 964func ch_allow_path(name: *u8, outp: *u8) -> i64 { return sj_allow_path(name, outp) } 965func ch_propose(jpath: *u8, ipath: *u8, thr: i64, filer: *u8, cout: *u8, colen: *i64) -> i64 { 966 colen[0] = 0 967 let g: *i64 = sys_mmap(128) as *i64 968 ch_gauge_calc(jpath, 0, g) 969 if g[3] < 0 { return 5 } 970 if g[3] < thr { return 2 } 971 let jb: *u8 = sys_mmap(CH_JWIN) 972 let jcap: i64 = CH_JWIN - 8 973 let jn: i64 = ch_read(ipath, jb, jcap) 974 if jn >= jcap { return 3 } 975 if jn > 0 { if ch_find(jb, jn, "[HARV:outsidegap:v1]" as *u8) == 1 { return 4 } } 976 let fpath: *u8 = sys_mmap(512) 977 if ch_allow_path(filer, fpath) == 0 { return 1 } 978 let txt: *u8 = sys_mmap(CH_LINE) 979 var o: i64 = sj_cat(txt, 0, "[HARV:outsidegap:v1] outside_permil=" as *u8) 980 o = sj_catn(txt, o, g[3]) 981 o = sj_cat(txt, o, " over threshold " as *u8) 982 o = sj_catn(txt, o, thr) 983 o = sj_cat(txt, o, " (frames=" as *u8) 984 o = sj_catn(txt, o, g[0]) 985 o = sj_cat(txt, o, " nishi=" as *u8) 986 o = sj_catn(txt, o, g[1]) 987 o = sj_cat(txt, o, " outside=" as *u8) 988 o = sj_catn(txt, o, g[2]) 989 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) 990 txt[o] = 0 as u8 991 let av: *i64 = sys_mmap(64) as *i64 992 av[0] = fpath as i64 993 av[1] = "ask" as *u8 as i64 994 av[2] = ipath as i64 995 av[3] = "nx_claude_harvest" as *u8 as i64 996 av[4] = txt as i64 997 av[5] = 0 998 let ex: i64 = tr_run_capture(fpath, av, cout, CH_LINE - 8, colen) 999 if ex != 0 { return 1 } 1000 return 0 1001} 1002// ---------- selftest ---------- 1003func ch_selftest(prefix: *u8) -> i64 { 1004 let ctr: *i64 = gv_ctr() 1005 gv_head("nx_claude_harvest selftest -- transcript parse + ingest + gauge teeth (unique scratch per run)" as *u8) 1006 // MICROSECOND stamp (2026-09-05): a second-resolution scratch name collided when nx_behaveprobe ran the live and the 1007 // staged selftest inside one second -- the second run found the first run's T15 marker already seeded and T14 refused. 1008 // The beat fixed this exact class on its piece names; the selftest now stamps the same way. 1009 let now: i64 = sys_now_realtime_us() 1010 let tj: *u8 = sys_mmap(512) 1011 var o: i64 = sj_cat(tj, 0, prefix) 1012 o = sj_catn(tj, o, now) 1013 o = sj_cat(tj, o, ".jsonl" as *u8) 1014 tj[o] = 0 as u8 1015 let fr: *u8 = sys_mmap(512) 1016 o = sj_cat(fr, 0, prefix) 1017 o = sj_catn(fr, o, now) 1018 o = sj_cat(fr, o, ".frames" as *u8) 1019 fr[o] = 0 as u8 1020 let st: *u8 = sys_mmap(512) 1021 o = sj_cat(st, 0, prefix) 1022 o = sj_catn(st, o, now) 1023 o = sj_cat(st, o, ".staged" as *u8) 1024 st[o] = 0 as u8 1025 let jr: *u8 = sys_mmap(512) 1026 o = sj_cat(jr, 0, prefix) 1027 o = sj_catn(jr, o, now) 1028 o = sj_cat(jr, o, ".jrnl" as *u8) 1029 jr[o] = 0 as u8 1030 // fixture transcript: decoy name outside tool_use + 2 tool_use on one line + 1 on another 1031 let tfd: i64 = sys_openat_append(tj, CH_MODE_644) 1032 let lb: *u8 = sys_mmap(CH_LINE) 1033 var lo: i64 = sj_cat(lb, 0, "{\"type\":\"user\",\"name\":\"decoy1\",\"timestamp\":\"2026-07-23T00:00:00Z\"}" as *u8) 1034 lb[lo] = 10 as u8 1035 sys_write(tfd, lb, lo + 1) 1036 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) 1037 lb[lo] = 10 as u8 1038 sys_write(tfd, lb, lo + 1) 1039 lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:02Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"c\",\"name\":\"mcp__nishi__nx_fs\"}]}" as *u8) 1040 lb[lo] = 10 as u8 1041 sys_write(tfd, lb, lo + 1) 1042 sys_close(tfd) 1043 // T1 harvest exact: 3 frames, decoy never harvested 1044 let tcx: *i64 = sys_mmap(16) as *i64 1045 let got: i64 = ch_frames(tj, "wtest" as *u8, fr, tcx) 1046 let fb: *u8 = sys_mmap(CH_JWIN) 1047 let fn: i64 = ch_read(fr, fb, CH_JWIN - 8) 1048 var ok1: i64 = 0 1049 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 } } } } } 1050 gv_check("T1 harvest exactly the 3 tool_use names, decoy name never fabricated" as *u8, ok1, ctr) 1051 // T2 iso timestamp -> epoch propagated (2026-07-23T00:00:01Z = 1784764801) 1052 var ok2: i64 = 0 1053 if ch_find(fb, fn, "1784764801" as *u8) == 1 { if ch_find(fb, fn, "1784764802" as *u8) == 1 { ok2 = 1 } } 1054 gv_check("T2 iso timestamps parsed to exact epochs" as *u8, ok2, ctr) 1055 // T3 gauge exact split: Edit+PowerShell outside, nx_fs nishi -> 666 permil 1056 let d: *u8 = sys_mmap(CH_OUT) 1057 var dl: i64 = ch_gauge_json(fr, 0, d) 1058 var ok3: i64 = 0 1059 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 } } } 1060 gv_check("T3 gauge exact: 2 outside 1 nishi = 666 permil" as *u8, ok3, ctr) 1061 // T4 gauge on missing journal refuses a number (-1, insufficient data honesty) 1062 let miss: *u8 = sys_mmap(512) 1063 o = sj_cat(miss, 0, prefix) 1064 o = sj_catn(miss, o, now) 1065 o = sj_cat(miss, o, ".absent" as *u8) 1066 miss[o] = 0 as u8 1067 dl = ch_gauge_json(miss, 0, d) 1068 var ok4: i64 = 0 1069 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 } } } 1070 gv_check("T4 empty journal refuses permil (-1) never fabricates" as *u8, ok4, ctr) 1071 gv_check("T4a missing source is explicitly unavailable", ch_find(d, dl, "\"evidence_state\":\"source_open_failed\"" as *u8), ctr) 1072 let empty45: *u8 = sys_mmap(CH_PATH_MAX) 1073 var e45: i64 = sj_cat(empty45, 0, miss) 1074 e45 = sj_cat(empty45, e45, ".empty" as *u8) 1075 empty45[e45] = 0 as u8 1076 let emptyfd45: i64 = sys_openat_wr(empty45, CH_MODE_644) 1077 var emptyok45: i64 = 0 1078 if emptyfd45 >= 0 { 1079 sys_close(emptyfd45) 1080 dl = ch_gauge_json(empty45, 0, d) 1081 emptyok45 = ch_find(d, dl, "\"evidence_state\":\"source_opened\"" as *u8) 1082 } 1083 gv_check("T4b readable empty source differs from missing source", emptyok45, ctr) 1084 gv_check("T4c activity is not presented as delivery or cost", ch_find(d, dl, "\"verified_delivery_share\":null" as *u8), ctr) 1085 // T5 ingest: 2 valid + 1 malformed staged line -> journal gains exactly the 2 + marker 1086 ch_frame_append(st, CH_MAGIC_1784764900, "w2" as *u8, "Read" as *u8, "use" as *u8, "-" as *u8, "harvest" as *u8) 1087 ch_frame_append(st, CH_MAGIC_1784764901, "w2" as *u8, "nx_fs_write" as *u8, "use" as *u8, "-" as *u8, "harvest" as *u8) 1088 let sfd: i64 = sys_openat_append(st, CH_MODE_644) 1089 var go2: i64 = sj_cat(lb, 0, "garbage-no-tabs" as *u8) 1090 lb[go2] = 10 as u8 1091 sys_write(sfd, lb, go2 + 1) 1092 sys_close(sfd) 1093 let mcx: *i64 = sys_mmap(16) as *i64 1094 let r5: i64 = ch_ingest(st, jr, mcx) 1095 let jb: *u8 = sys_mmap(CH_JWIN) 1096 var jn: i64 = ch_read(jr, jb, CH_JWIN - 8) 1097 var ok5: i64 = 0 1098 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 } } } } } 1099 gv_check("T5 ingest validates: 2 in, malformed counted out, marker banked" as *u8, ok5, ctr) 1100 // T6 idempotent: second ingest refuses, journal bytes unchanged 1101 let r6: i64 = ch_ingest(st, jr, mcx) 1102 let jn2: i64 = ch_read(jr, jb, CH_JWIN - 8) 1103 var ok6: i64 = 0 1104 if r6 == (0 - 2) { if jn2 == jn { ok6 = 1 } } 1105 gv_check("T6 re-ingest ALREADY, journal byte-identical" as *u8, ok6, ctr) 1106 // T7 missing transcript fails closed 1107 let r7: i64 = ch_frames(miss, "w" as *u8, fr, tcx) 1108 var ok7: i64 = 0 1109 if r7 == (0 - 1) { ok7 = 1 } 1110 gv_check("T7 missing transcript refused (-1) fail closed" as *u8, ok7, ctr) 1111 // T8 sovereign-organ frames (nx_ prefix) classify as nishi: add one -> 2 outside / 2 nishi = 500 1112 ch_frame_append(fr, CH_MAGIC_1784764803, "wtest" as *u8, "nx_shelltool" as *u8, "use" as *u8, "-" as *u8, "harvest" as *u8) 1113 dl = ch_gauge_json(fr, 0, d) 1114 var ok8: i64 = 0 1115 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 } } } 1116 gv_check("T8 nx_-prefixed frames count as nishi (500 permil exact)" as *u8, ok8, ctr) 1117 // T9 page emits the exact gauge + title (from the T8 journal: permil 500) 1118 let pg: *u8 = sys_mmap(512) 1119 o = sj_cat(pg, 0, prefix) 1120 o = sj_catn(pg, o, now) 1121 o = sj_cat(pg, o, ".html" as *u8) 1122 pg[o] = 0 as u8 1123 let r9: i64 = ch_page(fr, pg, 0) 1124 let pb: *u8 = sys_mmap(CH_OUT) 1125 let pn: i64 = ch_read(pg, pb, CH_OUT - 8) 1126 var ok9: i64 = 0 1127 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 } } } } 1128 gv_check("T9 page emits the exact gauge + title" as *u8, ok9, ctr) 1129 // T13-T16 propose (F971): threshold honesty, injectable filer, marker idempotence, insufficient refuse 1130 let ijr: *u8 = sys_mmap(512) 1131 o = sj_cat(ijr, 0, prefix) 1132 o = sj_catn(ijr, o, now) 1133 o = sj_cat(ijr, o, ".ijr" as *u8) 1134 ijr[o] = 0 as u8 1135 let pcl: *i64 = sys_mmap(16) as *i64 1136 let r13: i64 = ch_propose(fr, ijr, 600, "argecho" as *u8, d, pcl) 1137 var ok13: i64 = 0 1138 if r13 == 2 { ok13 = 1 } 1139 gv_check("T13 below threshold never files (code 2)" as *u8, ok13, ctr) 1140 // T14 needs a RESOLVABLE filer, and resolution runs through sj_allow_path, which opens 1141 // "tool_allowlist.conf" as a BARE path -- i.e. relative to the CWD. On any host/CWD without one 1142 // (every WSL run of this gate) the filer cannot be resolved, and this tooth then reported the 1143 // ORGAN as broken when only its environment was absent: the same binary reads 39/40 RED from /tmp 1144 // and 40/40 GREEN from a CWD holding one row. MEASURED 2026-08-20. 1145 // ***** AN AXIS THAT CANNOT SEE MUST ABSTAIN, NOT CONVICT -- and a gate that goes RED on its own 1146 // environment is the permanently-red detector everyone learns to ignore. 1147 let t14p: *u8 = sys_mmap(CH_BT_PATHMAX) 1148 if gv_need("propose filer resolvable via a CWD-relative tool_allowlist.conf" as *u8, ch_allow_path("argecho" as *u8, t14p), ctr) == 1 { 1149 let r14: i64 = ch_propose(fr, ijr, 400, "argecho" as *u8, d, pcl) 1150 var ok14: i64 = 0 1151 if r14 == 0 { if pcl[0] > 0 { if ch_find(d, pcl[0], "[HARV:outsidegap:v1] outside_permil=500" as *u8) == 1 { ok14 = 1 } } } 1152 gv_check("T14 above threshold files through the injected filer w/ exact marker+permil" as *u8, ok14, ctr) 1153 } 1154 let mfd: i64 = sys_openat_append(ijr, CH_MODE_644) 1155 let mln: *u8 = sys_mmap(256) 1156 var mo2: i64 = sj_cat(mln, 0, "1 seeded [HARV:outsidegap:v1] marker" as *u8) 1157 mln[mo2] = 10 as u8 1158 sys_write(mfd, mln, mo2 + 1) 1159 sys_close(mfd) 1160 let r15: i64 = ch_propose(fr, ijr, 400, "argecho" as *u8, d, pcl) 1161 var ok15: i64 = 0 1162 if r15 == 4 { ok15 = 1 } 1163 gv_check("T15 marker present refuses re-file (code 4, idempotent)" as *u8, ok15, ctr) 1164 let r16: i64 = ch_propose(miss, ijr, 400, "argecho" as *u8, d, pcl) 1165 var ok16: i64 = 0 1166 if r16 == 5 { ok16 = 1 } 1167 gv_check("T16 insufficient data refuses to propose (code 5)" as *u8, ok16, ctr) 1168 // T17-T20 DELTA (F973): exactly-once harvest by byte high-water mark 1169 let dj: *u8 = sys_mmap(512) 1170 o = sj_cat(dj, 0, prefix) 1171 o = sj_catn(dj, o, now) 1172 o = sj_cat(dj, o, ".dj" as *u8) 1173 dj[o] = 0 as u8 1174 let hw: *u8 = sys_mmap(512) 1175 o = sj_cat(hw, 0, prefix) 1176 o = sj_catn(hw, o, now) 1177 o = sj_cat(hw, o, ".hwm" as *u8) 1178 hw[o] = 0 as u8 1179 let hcx: *i64 = sys_mmap(64) as *i64 1180 // tj holds 3 lines / 3 tool_use frames from T1 1181 let rd1: i64 = ch_delta(tj, "wd" as *u8, dj, hw, hcx) 1182 var ok17: i64 = 0 1183 if rd1 == 0 { if hcx[0] == 3 { if hcx[2] == 0 { if hcx[1] > 0 { ok17 = 1 } } } } 1184 gv_check("T17 first delta harvests all 3 frames and banks a high-water mark" as *u8, ok17, ctr) 1185 let firsthwm: i64 = hcx[1] 1186 let rd2: i64 = ch_delta(tj, "wd" as *u8, dj, hw, hcx) 1187 var ok18: i64 = 0 1188 if rd2 == 0 { if hcx[0] == 0 { if hcx[1] == firsthwm { ok18 = 1 } } } 1189 gv_check("T18 re-run on an unchanged transcript harvests ZERO (exactly-once, no marker needed)" as *u8, ok18, ctr) 1190 // grow the transcript by ONE complete line (1 tool_use) + a PARTIAL trailing line 1191 let gfd: i64 = sys_openat_append(tj, CH_MODE_644) 1192 lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-07-23T00:00:03Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"g\",\"name\":\"Grep\"}]}" as *u8) 1193 lb[lo] = 10 as u8 1194 sys_write(gfd, lb, lo + 1) 1195 lo = sj_cat(lb, 0, "{\"type\":\"tool_use\",\"name\":\"PartialNeverCounted\"" as *u8) 1196 sys_write(gfd, lb, lo) 1197 sys_close(gfd) 1198 let rd3: i64 = ch_delta(tj, "wd" as *u8, dj, hw, hcx) 1199 var ok19: i64 = 0 1200 if rd3 == 0 { if hcx[0] == 1 { if hcx[2] == firsthwm { ok19 = 1 } } } 1201 gv_check("T19 growth harvests ONLY the new line (1 frame), resuming from the banked mark" as *u8, ok19, ctr) 1202 let db: *u8 = sys_mmap(CH_JWIN) 1203 let dn: i64 = ch_read(dj, db, CH_JWIN - 8) 1204 var ok20: i64 = 0 1205 if dn > 0 { if ch_find(db, dn, "Grep" as *u8) == 1 { if ch_find(db, dn, "PartialNeverCounted" as *u8) == 0 { ok20 = 1 } } } 1206 gv_check("T20 a PARTIAL trailing line is never consumed (waits below the mark)" as *u8, ok20, ctr) 1207 // T21-T23 PARTITION (2026-09-05): estate :run beats excluded from the reliance denominator. 1208 // Fixture: 1 outside claude action + 1 nishi claude action + 3 nishi estate beats (verb run). 1209 // Legacy outside_permil counts all 5 (nishi beats dilute -> 200); claude_outside_permil counts 1210 // ONLY the 2 claude actions -> 500 (beats=3). 500 != 200 proves the partition actually fired. 1211 let pj: *u8 = sys_mmap(512) 1212 var po: i64 = sj_cat(pj, 0, prefix) 1213 po = sj_catn(pj, po, now) 1214 po = sj_cat(pj, po, ".pj" as *u8) 1215 pj[po] = 0 as u8 1216 ch_frame_append(pj, CH_MAGIC_1784764900, "wp" as *u8, "PowerShell" as *u8, "use" as *u8, "-" as *u8, "act" as *u8) 1217 ch_frame_append(pj, CH_MAGIC_1784764901, "wp" as *u8, "nx_fs" as *u8, "call" as *u8, "-" as *u8, "act" as *u8) 1218 ch_frame_append(pj, CH_MAGIC_1784764803, "wp" as *u8, "nx_netobs.elf" as *u8, "run" as *u8, "-" as *u8, "beat" as *u8) 1219 ch_frame_append(pj, CH_MAGIC_1784764803, "wp" as *u8, "nx_resmon.elf" as *u8, "run" as *u8, "-" as *u8, "beat" as *u8) 1220 ch_frame_append(pj, CH_MAGIC_1784764803, "wp" as *u8, "nx_memvel.elf" as *u8, "run" as *u8, "-" as *u8, "beat" as *u8) 1221 dl = ch_gauge_json(pj, 0, d) 1222 var ok21: i64 = 0 1223 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 } } } } 1224 gv_check("T21 estate :run beats partitioned out: 5 frames, 3 beats, 2 claude actions" as *u8, ok21, ctr) 1225 var ok22: i64 = 0 1226 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 } } } 1227 gv_check("T22 reliance over claude actions (500) NOT diluted by nishi beats (legacy 200)" as *u8, ok22, ctr) 1228 var ok23: i64 = 0 1229 if dl > 0 { if ch_find(d, dl, "\"claude_outside_permil\":200" as *u8) == 0 { ok23 = 1 } } 1230 gv_check("T23 non-vacuity: claude_outside_permil 500 != legacy diluted 200 (partition fired)" as *u8, ok23, ctr) 1231 // J1-J3 JOURNAL (2026-09-05): one measure row per UTC day on a .plan, idempotent, never a -1. 1232 let pl: *u8 = sys_mmap(512) 1233 var plo: i64 = sj_cat(pl, 0, prefix) 1234 plo = sj_catn(pl, plo, now) 1235 plo = sj_cat(pl, plo, ".plan" as *u8) 1236 pl[plo] = 0 as u8 1237 let pfd: i64 = sys_openat_wr(pl, CH_MODE_644) 1238 var seedo: i64 = sj_cat(lb, 0, "pos|seed plan for the journal teeth" as *u8) 1239 lb[seedo] = 10 as u8 1240 sys_write(pfd, lb, seedo + 1) 1241 sys_close(pfd) 1242 let rj1: i64 = ch_journal(pj, pl, "SV0" as *u8) 1243 let jb2: *u8 = sys_mmap(CH_JWIN) 1244 let jn3: i64 = ch_read(pl, jb2, CH_JWIN - 8) 1245 var okj1: i64 = 0 1246 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 } } } 1247 gv_check("J1 journal appends one measure row carrying the exact honest permil (500, partition fixture)" as *u8, okj1, ctr) 1248 let rj2: i64 = ch_journal(pj, pl, "SV0" as *u8) 1249 let jn4: i64 = ch_read(pl, jb2, CH_JWIN - 8) 1250 var okj2: i64 = 0 1251 if rj2 == 4 { if jn4 == jn3 { okj2 = 1 } } 1252 gv_check("J2 second journal the same day refused (4), plan byte-identical (idempotent)" as *u8, okj2, ctr) 1253 let rj3: i64 = ch_journal(miss, pl, "SV0" as *u8) 1254 let jn5: i64 = ch_read(pl, jb2, CH_JWIN - 8) 1255 var okj3: i64 = 0 1256 if rj3 == 5 { if jn5 == jn4 { okj3 = 1 } } 1257 gv_check("J3 neg-control-insufficient: a missing journal refuses (5) and writes nothing, never a -1 row" as *u8, okj3, ctr) 1258 // C1-C3 CLASSES (SV2, 2026-09-05): the residual by tool over claude actions; the partition sums; beats 1259 // and nishi tools are never a class; the list is sorted by count descending. 1260 dl = ch_classes_json(pj, d) 1261 var okc1: i64 = 0 1262 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 } } } } 1263 gv_check("C1 classes on the partition fixture: one outside tool (PowerShell:1) and the partition sums (other:0)" as *u8, okc1, ctr) 1264 var okc2: i64 = 0 1265 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 } } } 1266 gv_check("C2 neg-control: estate beats and nishi tools are never a residual class" as *u8, okc2, ctr) 1267 let cj3: *u8 = sys_mmap(512) 1268 var co3: i64 = sj_cat(cj3, 0, prefix) 1269 co3 = sj_catn(cj3, co3, now) 1270 co3 = sj_cat(cj3, co3, ".cls" as *u8) 1271 cj3[co3] = 0 as u8 1272 ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Edit" as *u8, "use" as *u8, "-" as *u8, "a" as *u8) 1273 ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Bash" as *u8, "use" as *u8, "-" as *u8, "a" as *u8) 1274 ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Grep" as *u8, "use" as *u8, "-" as *u8, "a" as *u8) 1275 ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Bash" as *u8, "use" as *u8, "-" as *u8, "a" as *u8) 1276 ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Edit" as *u8, "use" as *u8, "-" as *u8, "a" as *u8) 1277 ch_frame_append(cj3, CH_MAGIC_1784764900, "wc" as *u8, "Bash" as *u8, "use" as *u8, "-" as *u8, "a" as *u8) 1278 dl = ch_classes_json(cj3, d) 1279 var okc3: i64 = 0 1280 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 } } } 1281 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) 1282 // T21/T22 BOOTGAUGE (SOTA-from-the-first-byte): s1 opens nishi-native (nx_seat), s2 opens legacy 1283 // (Read) but touches nishi within K, s3 stays outside => sota_first 1/3=333, nishi_within_k 2/3=666. 1284 let bj: *u8 = sys_mmap(512) 1285 o = sj_cat(bj, 0, prefix) 1286 o = sj_catn(bj, o, now) 1287 o = sj_cat(bj, o, ".bj" as *u8) 1288 bj[o] = 0 as u8 1289 ch_frame_append(bj, CH_MAGIC_1784764900, "s1" as *u8, "nx_seat" as *u8, "boot" as *u8, "-" as *u8, "-" as *u8) 1290 ch_frame_append(bj, CH_MAGIC_1784764900, "s1" as *u8, "mcp__nishi__nx_fs" as *u8, "lines" as *u8, "-" as *u8, "-" as *u8) 1291 ch_frame_append(bj, CH_MAGIC_1784764900, "s2" as *u8, "Read" as *u8, "use" as *u8, "-" as *u8, "-" as *u8) 1292 ch_frame_append(bj, CH_MAGIC_1784764900, "s2" as *u8, "mcp__nishi__nx_store_put" as *u8, "put" as *u8, "-" as *u8, "-" as *u8) 1293 ch_frame_append(bj, CH_MAGIC_1784764900, "s3" as *u8, "PowerShell" as *u8, "use" as *u8, "-" as *u8, "-" as *u8) 1294 ch_frame_append(bj, CH_MAGIC_1784764900, "s3" as *u8, "Bash" as *u8, "use" as *u8, "-" as *u8, "-" as *u8) 1295 let bd: i64 = ch_bootgauge(bj, 3, d) 1296 var ok21: i64 = 0 1297 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 } } 1298 gv_check("T21 bootgauge: first tool nishi in 1 of 3 sessions = 333 permil SOTA-boot" as *u8, ok21, ctr) 1299 var ok22: i64 = 0 1300 if bd > 0 { if ch_find(d, bd, "\"nishi_within_k\":2,\"nishi_within_k_permil\":666" as *u8) == 1 { ok22 = 1 } } 1301 gv_check("T22 nishi-within-first-K = 2 of 3 = 666 permil (the softer signal)" as *u8, ok22, ctr) 1302 let lc: *u8 = sys_mmap(512) 1303 o = sj_cat(lc, 0, prefix) 1304 o = sj_catn(lc, o, now) 1305 o = sj_cat(lc, o, ".lconf" as *u8) 1306 lc[o] = 0 as u8 1307 let lt: *u8 = sys_mmap(512) 1308 o = sj_cat(lt, 0, prefix) 1309 o = sj_catn(lt, o, now) 1310 o = sj_cat(lt, o, ".ltx" as *u8) 1311 lt[o] = 0 as u8 1312 let lo2: *u8 = sys_mmap(512) 1313 o = sj_cat(lo2, 0, prefix) 1314 o = sj_catn(lo2, o, now) 1315 o = sj_cat(lo2, o, ".lout" as *u8) 1316 lo2[o] = 0 as u8 1317 let cfd: i64 = sys_openat_append(lc, CH_MODE_644) 1318 let cb2: *u8 = sys_mmap(CH_LINE) 1319 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) 1320 sys_write(cfd, cb2, co) 1321 sys_close(cfd) 1322 let tfd2: i64 = sys_openat_append(lt, CH_MODE_644) 1323 let tb2: *u8 = sys_mmap(CH_LINE) 1324 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) 1325 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) 1326 to2 = sj_cat(tb2, to2, "{\"timestamp\":\"2026-07-23T00:00:02Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"a\",\"name\":\"Edit\"}]}\n" as *u8) 1327 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) 1328 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) 1329 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) 1330 sys_write(tfd2, tb2, to2) 1331 sys_close(tfd2) 1332 let lcx2: *i64 = sys_mmap(64) as *i64 1333 let lgot: i64 = ch_learn(lt, "lw" as *u8, lo2, lc, lcx2) 1334 let lb2: *u8 = sys_mmap(CH_JWIN) 1335 let ln2: i64 = ch_read(lo2, lb2, CH_JWIN - 8) 1336 var ok23: i64 = 0 1337 if ln2 > 0 { if ch_find(lb2, ln2, "\"rank\":6" as *u8) == 1 { ok23 = 1 } } 1338 gv_check("T23 learn captures a LAW: PROSE line at rank 6 (the thing frames/delta never could)" as *u8, ok23, ctr) 1339 var ok24: i64 = 1 1340 if ln2 > 0 { if ch_find(lb2, ln2, "looked at it for a while" as *u8) == 1 { ok24 = 0 } } 1341 gv_check("T24 NEG-CONTROL: unmarked prose ABOVE min_len is REJECTED -- the ranker can fail" as *u8, ok24, ctr) 1342 var ok25: i64 = 1 1343 if ln2 > 0 { if ch_find(lb2, ln2, "Edit" as *u8) == 1 { ok25 = 0 } } 1344 gv_check("T25 learn ignores tool_use frames entirely -- learn is not a second frames" as *u8, ok25, ctr) 1345 var ok26: i64 = 0 1346 if lcx2[1] >= 2 { ok26 = 1 } 1347 gv_check("T26 markers/weights come from the conf file, never compiled in (rule 11)" as *u8, ok26, ctr) 1348 var ok27: i64 = 0 1349 if ln2 > 0 { if ch_find(lb2, ln2, "\"rank\":4" as *u8) == 1 { ok27 = 1 } } 1350 gv_check("T27 a 4-star run ranks 4 -- multi-byte glyph run counted as bytes, not chars" as *u8, ok27, ctr) 1351 var ok28: i64 = 0 1352 if lgot == 3 { ok28 = 1 } 1353 gv_check("T28 exactly 3 of 6 transcript lines clear the floor (kept count is not a dump)" as *u8, ok28, ctr) 1354 var ok29: i64 = 1 1355 if ln2 > 0 { if ch_find(lb2, ln2, "axes run 0..1000" as *u8) == 1 { ok29 = 0 } } 1356 gv_check("T29 WORD BOUNDARY: UNMEASURED does not match the marker MEASURED (substring flattery)" as *u8, ok29, ctr) 1357 var ok30: i64 = 0 1358 var dcount: i64 = 0 1359 var dp: i64 = 0 1360 while dp < ln2 { 1361 let dq: i64 = ch_find_from(lb2, dp, ln2, "an echoed frame must not become" as *u8) 1362 if dq < 0 { dp = ln2 } else { dcount = dcount + 1; dp = dq + 20 } 1363 } 1364 if dcount == 1 { ok30 = 1 } 1365 gv_check("T30 an echoed payload emits ONCE, not twice (adjacent-duplicate suppression)" as *u8, ok30, ctr) 1366 // ================= beat teeth (DM1 ch_beat, 2026-08-20; fixtures assembled at RUNTIME) ================= 1367 let btroot: *u8 = sys_mmap(512) 1368 o = sj_cat(btroot, 0, prefix) 1369 o = sj_catn(btroot, o, now) 1370 o = sj_cat(btroot, o, "btroot" as *u8) 1371 btroot[o] = 0 as u8 1372 let btpa: *u8 = sys_mmap(512) 1373 o = sj_cat(btpa, 0, btroot) 1374 o = sj_cat(btpa, o, "/pA" as *u8) 1375 btpa[o] = 0 as u8 1376 let btsub: *u8 = sys_mmap(512) 1377 o = sj_cat(btsub, 0, btpa) 1378 o = sj_cat(btsub, o, "/subagents" as *u8) 1379 btsub[o] = 0 as u8 1380 let btstate: *u8 = sys_mmap(512) 1381 o = sj_cat(btstate, 0, prefix) 1382 o = sj_catn(btstate, o, now) 1383 o = sj_cat(btstate, o, "btstate" as *u8) 1384 btstate[o] = 0 as u8 1385 let btspool: *u8 = sys_mmap(512) 1386 o = sj_cat(btspool, 0, prefix) 1387 o = sj_catn(btspool, o, now) 1388 o = sj_cat(btspool, o, "btspool" as *u8) 1389 btspool[o] = 0 as u8 1390 let btdone: *u8 = sys_mmap(512) 1391 o = sj_cat(btdone, 0, prefix) 1392 o = sj_catn(btdone, o, now) 1393 o = sj_cat(btdone, o, "btdone" as *u8) 1394 btdone[o] = 0 as u8 1395 let btjrnl: *u8 = sys_mmap(512) 1396 o = sj_cat(btjrnl, 0, prefix) 1397 o = sj_catn(btjrnl, o, now) 1398 o = sj_cat(btjrnl, o, "btjrnl" as *u8) 1399 btjrnl[o] = 0 as u8 1400 let bttwin: *u8 = sys_mmap(512) 1401 o = sj_cat(bttwin, 0, prefix) 1402 o = sj_catn(bttwin, o, now) 1403 o = sj_cat(bttwin, o, "bttwin" as *u8) 1404 bttwin[o] = 0 as u8 1405 sys_mkdir(btroot, CH_MODE_755) 1406 sys_mkdir(btpa, CH_MODE_755) 1407 sys_mkdir(btsub, CH_MODE_755) 1408 sys_mkdir(bttwin, CH_MODE_755) 1409 let bts1: *u8 = sys_mmap(512) 1410 o = sj_cat(bts1, 0, btpa) 1411 o = sj_cat(bts1, o, "/s1.jsonl" as *u8) 1412 bts1[o] = 0 as u8 1413 let bts2: *u8 = sys_mmap(512) 1414 o = sj_cat(bts2, 0, btsub) 1415 o = sj_cat(bts2, o, "/s2.jsonl" as *u8) 1416 bts2[o] = 0 as u8 1417 let btfd: i64 = sys_openat_append(bts1, CH_MODE_644) 1418 lo = sj_cat(lb, 0, "{\"type\":\"zzz-newtype\",\"x\":1}" as *u8) 1419 lb[lo] = 10 as u8 1420 sys_write(btfd, lb, lo + 1) 1421 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) 1422 lb[lo] = 10 as u8 1423 sys_write(btfd, lb, lo + 1) 1424 lo = sj_cat(lb, 0, "{\"type\":\"user\",\"uuid\":\"u1\"}" as *u8) 1425 lb[lo] = 10 as u8 1426 sys_write(btfd, lb, lo + 1) 1427 sys_close(btfd) 1428 let btfd2: i64 = sys_openat_append(bts2, CH_MODE_644) 1429 lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-08-19T10:00:01Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"c\",\"name\":\"mcp__nishi__nx_fs\"}]}" as *u8) 1430 lb[lo] = 10 as u8 1431 sys_write(btfd2, lb, lo + 1) 1432 sys_close(btfd2) 1433 // conf assembled at runtime (rule 11 even in the fixture) 1434 let btconf: *u8 = sys_mmap(512) 1435 o = sj_cat(btconf, 0, prefix) 1436 o = sj_catn(btconf, o, now) 1437 o = sj_cat(btconf, o, "btconf" as *u8) 1438 btconf[o] = 0 as u8 1439 let btcb: *u8 = sys_mmap(4096) 1440 var bo: i64 = sj_cat(btcb, 0, "root=" as *u8) 1441 bo = sj_cat(btcb, bo, btroot) 1442 btcb[bo] = 10 as u8 1443 bo = bo + 1 1444 bo = sj_cat(btcb, bo, "state=" as *u8) 1445 bo = sj_cat(btcb, bo, btstate) 1446 btcb[bo] = 10 as u8 1447 bo = bo + 1 1448 bo = sj_cat(btcb, bo, "spool=" as *u8) 1449 bo = sj_cat(btcb, bo, btspool) 1450 btcb[bo] = 10 as u8 1451 bo = bo + 1 1452 bo = sj_cat(btcb, bo, "done=" as *u8) 1453 bo = sj_cat(btcb, bo, btdone) 1454 btcb[bo] = 10 as u8 1455 bo = bo + 1 1456 bo = sj_cat(btcb, bo, "journal=" as *u8) 1457 bo = sj_cat(btcb, bo, btjrnl) 1458 btcb[bo] = 10 as u8 1459 bo = bo + 1 1460 bo = sj_cat(btcb, bo, "push=0" as *u8) 1461 btcb[bo] = 10 as u8 1462 bo = bo + 1 1463 bo = sj_cat(btcb, bo, "known_type=user" as *u8) 1464 btcb[bo] = 10 as u8 1465 bo = bo + 1 1466 bo = sj_cat(btcb, bo, "known_type=assistant" as *u8) 1467 btcb[bo] = 10 as u8 1468 bo = bo + 1 1469 let btcfd: i64 = sys_openat_wr(btconf, CH_MODE_644) 1470 sys_write(btcfd, btcb, bo) 1471 sys_close(btcfd) 1472 let bcx1: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64 1473 let brc1: i64 = ch_beat(btconf, bcx1) 1474 var ok31: i64 = 0 1475 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 } } } } } } 1476 gv_check("T31 beat walks every transcript at every depth and the file partition SUMS" as *u8, ok31, ctr) 1477 var ok32: i64 = 0 1478 if bcx1[4] == 3 { if bcx1[5] == 3 { ok32 = 1 } } 1479 gv_check("T32 frames reconcile against the independent tooluse-mark census (two counters, free audit)" as *u8, ok32, ctr) 1480 var ok33: i64 = 0 1481 if bcx1[6] == 4 { if bcx1[8] == 1 { if bcx1[9] == 1 { if bcx1[10] == 2 { ok33 = 1 } } } } 1482 gv_check("T33 head-type census: known/UNKNOWN/headless partition sums; nested types never read as record types" as *u8, ok33, ctr) 1483 let btj1: *u8 = sys_mmap(512) 1484 o = sj_cat(btj1, 0, btjrnl) 1485 o = sj_cat(btj1, o, "/chbeat_20260723.jrnl" as *u8) 1486 btj1[o] = 0 as u8 1487 let btj2: *u8 = sys_mmap(512) 1488 o = sj_cat(btj2, 0, btjrnl) 1489 o = sj_cat(btj2, o, "/chbeat_20260819.jrnl" as *u8) 1490 btj2[o] = 0 as u8 1491 let btb1: *u8 = sys_mmap(CH_JWIN) 1492 let btn1: i64 = ch_read(btj1, btb1, CH_JWIN - 8) 1493 let btb2: *u8 = sys_mmap(CH_JWIN) 1494 var btn2: i64 = ch_read(btj2, btb2, CH_JWIN - 8) 1495 var ok34: i64 = 0 1496 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 } } } } } 1497 gv_check("T34 ts-day routing: each frame lands in its OWN day journal, never cross-filed" as *u8, ok34, ctr) 1498 let bcx2: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64 1499 let brc2: i64 = ch_beat(btconf, bcx2) 1500 let btn1b: i64 = ch_read(btj1, btb1, CH_JWIN - 8) 1501 var ok35: i64 = 0 1502 if brc2 == 0 { if bcx2[2] == 2 { if bcx2[4] == 0 { if bcx2[12] == 0 { if btn1b == btn1 { ok35 = 1 } } } } } 1503 gv_check("T35 re-run is exactly-once: all files skipped-unchanged, zero frames, journal byte-identical" as *u8, ok35, ctr) 1504 let btfd3: i64 = sys_openat_append(bts2, CH_MODE_644) 1505 lo = sj_cat(lb, 0, "{\"timestamp\":\"2026-08-19T11:00:00Z\",\"c\":[{\"type\":\"tool_use\",\"id\":\"d\",\"name\":\"Grep\"}]}" as *u8) 1506 lb[lo] = 10 as u8 1507 sys_write(btfd3, lb, lo + 1) 1508 lo = sj_cat(lb, 0, "{\"c\":[{\"type\":\"tool_use\",\"id\":\"e\",\"name\":\"NoTsTool\"}]}" as *u8) 1509 lb[lo] = 10 as u8 1510 sys_write(btfd3, lb, lo + 1) 1511 sys_close(btfd3) 1512 let bcx3: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64 1513 let brc3: i64 = ch_beat(btconf, bcx3) 1514 var ok36: i64 = 0 1515 if brc3 == 0 { if bcx3[1] == 1 { if bcx3[2] == 1 { if bcx3[4] == 2 { if bcx3[15] == 1 { ok36 = 1 } } } } } 1516 gv_check("T36 growth delta-harvests ONLY the new lines from the banked mark" as *u8, ok36, ctr) 1517 let btjz: *u8 = sys_mmap(512) 1518 o = sj_cat(btjz, 0, btjrnl) 1519 o = sj_cat(btjz, o, "/chbeat_tszero.jrnl" as *u8) 1520 btjz[o] = 0 as u8 1521 let btnz: i64 = ch_read(btjz, btb1, CH_JWIN - 8) 1522 btn2 = ch_read(btj2, btb2, CH_JWIN - 8) 1523 var ok37: i64 = 0 1524 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 } } } } } 1525 gv_check("T37 a frame without a parseable timestamp lands in chbeat_tszero.jrnl -- its OWN bucket, never folded" as *u8, ok37, ctr) 1526 // twin landing: ingest the SAME pieces into a second journal dir and demand gauge agreement 1527 let btar: *u8 = sys_mmap(CH_BT_ARENA) 1528 let btfo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64 1529 let btwcx: *i64 = sys_mmap(64) as *i64 1530 let btnp: i64 = ch_bt_walk(btspool, ".frames" as *u8, btar, btfo, btwcx) 1531 let btmcx: *i64 = sys_mmap(16) as *i64 1532 let btday: *u8 = sys_mmap(CH_BT_DAYCELL) 1533 let bttj: *u8 = sys_mmap(512) 1534 var bpi: i64 = 0 1535 while bpi < btnp { 1536 let bpp: *u8 = ((btar as i64) + btfo[bpi]) as *u8 1537 let bpb: *u8 = ch_bt_base(bpp) 1538 if ch_starts(bpb, 0, sj_vlen(bpb), "cb" as *u8) == 1 { 1539 ch_bt_pieceday(bpb, btday) 1540 var oz: i64 = sj_cat(bttj, 0, bttwin) 1541 bttj[oz] = 47 as u8 1542 oz = oz + 1 1543 oz = sj_cat(bttj, oz, "chbeat_" as *u8) 1544 oz = sj_cat(bttj, oz, btday) 1545 oz = sj_cat(bttj, oz, ".jrnl" as *u8) 1546 bttj[oz] = 0 as u8 1547 ch_ingest(bpp, bttj, btmcx) 1548 } 1549 bpi = bpi + 1 1550 } 1551 var oz2: i64 = sj_cat(bttj, 0, bttwin) 1552 bttj[oz2] = 47 as u8 1553 oz2 = oz2 + 1 1554 oz2 = sj_cat(bttj, oz2, "chbeat_20260819.jrnl" as *u8) 1555 bttj[oz2] = 0 as u8 1556 var dlA: i64 = ch_gauge_json(btj2, 0, d) 1557 let gfA: i64 = ch_bt_int_after(d, dlA, "\"frames_total\":" as *u8) 1558 let goA: i64 = ch_bt_int_after(d, dlA, "\"outside\":" as *u8) 1559 let gpA: i64 = ch_bt_int_after(d, dlA, "\"outside_permil\":" as *u8) 1560 var dlB: i64 = ch_gauge_json(bttj, 0, d) 1561 let gfB: i64 = ch_bt_int_after(d, dlB, "\"frames_total\":" as *u8) 1562 let goB: i64 = ch_bt_int_after(d, dlB, "\"outside\":" as *u8) 1563 let gpB: i64 = ch_bt_int_after(d, dlB, "\"outside_permil\":" as *u8) 1564 var ok38: i64 = 0 1565 if gfA > 0 { if gfA == gfB { if goA == goB { if gpA == gpB { ok38 = 1 } } } } 1566 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) 1567 // plant a truncated landing: the reconcile MUST catch it, and the gauges MUST diverge 1568 let btp1: *u8 = sys_mmap(512) 1569 var btp1n: i64 = 0 1570 bpi = 0 1571 while bpi < btnp { 1572 let bpp2: *u8 = ((btar as i64) + btfo[bpi]) as *u8 1573 let bpb2: *u8 = ch_bt_base(bpp2) 1574 if ch_starts(bpb2, 0, sj_vlen(bpb2), "cb20260723" as *u8) == 1 { btp1n = sj_cat(btp1, 0, bpp2); btp1[btp1n] = 0 as u8 } 1575 bpi = bpi + 1 1576 } 1577 let btpb: *u8 = sys_mmap(CH_JWIN) 1578 let btpn: i64 = ch_read(btp1, btpb, CH_JWIN - 8) 1579 let btcut: *u8 = sys_mmap(512) 1580 o = sj_cat(btcut, 0, prefix) 1581 o = sj_catn(btcut, o, now) 1582 o = sj_cat(btcut, o, "cut1.frames" as *u8) 1583 btcut[o] = 0 as u8 1584 let btcfd2: i64 = sys_openat_wr(btcut, CH_MODE_644) 1585 sys_write(btcfd2, btpb, btpn - 10) 1586 sys_close(btcfd2) 1587 let bttj2: *u8 = sys_mmap(512) 1588 o = sj_cat(bttj2, 0, bttwin) 1589 o = sj_cat(bttj2, o, "/chbeat_cutcase.jrnl" as *u8) 1590 bttj2[o] = 0 as u8 1591 let btr9: i64 = ch_ingest(btcut, bttj2, btmcx) 1592 let btpl: i64 = ch_bt_lines(btp1) 1593 var ok39: i64 = 0 1594 if btpl == 2 { if btr9 == 1 { if btmcx[0] == 1 { if btr9 != btpl { ok39 = 1 } } } } 1595 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) 1596 // conf missing a required key refuses, NAMING it 1597 let btconf2: *u8 = sys_mmap(512) 1598 o = sj_cat(btconf2, 0, prefix) 1599 o = sj_catn(btconf2, o, now) 1600 o = sj_cat(btconf2, o, "btconf2" as *u8) 1601 btconf2[o] = 0 as u8 1602 bo = sj_cat(btcb, 0, "root=" as *u8) 1603 bo = sj_cat(btcb, bo, btroot) 1604 btcb[bo] = 10 as u8 1605 bo = bo + 1 1606 bo = sj_cat(btcb, bo, "state=" as *u8) 1607 bo = sj_cat(btcb, bo, btstate) 1608 btcb[bo] = 10 as u8 1609 bo = bo + 1 1610 let btcfd3: i64 = sys_openat_wr(btconf2, CH_MODE_644) 1611 sys_write(btcfd3, btcb, bo) 1612 sys_close(btcfd3) 1613 let bcx4: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64 1614 let brc4: i64 = ch_beat(btconf2, bcx4) 1615 var ok40: i64 = 0 1616 if brc4 == 2 { ok40 = 1 } 1617 gv_check("T40 neg-control-conf-missing-required-key refuses fail-closed (never invents a path)" as *u8, ok40, ctr) 1618 // push with a DEAD wire: every piece stays spooled -- wrong only toward doing nothing 1619 let btconf3: *u8 = sys_mmap(512) 1620 o = sj_cat(btconf3, 0, prefix) 1621 o = sj_catn(btconf3, o, now) 1622 o = sj_cat(btconf3, o, "btconf3" as *u8) 1623 btconf3[o] = 0 as u8 1624 bo = sj_cat(btcb, 0, "root=" as *u8) 1625 bo = sj_cat(btcb, bo, btroot) 1626 btcb[bo] = 10 as u8 1627 bo = bo + 1 1628 bo = sj_cat(btcb, bo, "state=" as *u8) 1629 bo = sj_cat(btcb, bo, btstate) 1630 btcb[bo] = 10 as u8 1631 bo = bo + 1 1632 bo = sj_cat(btcb, bo, "spool=" as *u8) 1633 bo = sj_cat(btcb, bo, btspool) 1634 btcb[bo] = 10 as u8 1635 bo = bo + 1 1636 bo = sj_cat(btcb, bo, "done=" as *u8) 1637 bo = sj_cat(btcb, bo, btdone) 1638 btcb[bo] = 10 as u8 1639 bo = bo + 1 1640 bo = sj_cat(btcb, bo, "journal=" as *u8) 1641 bo = sj_cat(btcb, bo, btjrnl) 1642 btcb[bo] = 10 as u8 1643 bo = bo + 1 1644 bo = sj_cat(btcb, bo, "push=1" as *u8) 1645 btcb[bo] = 10 as u8 1646 bo = bo + 1 1647 bo = sj_cat(btcb, bo, "push_max=8" as *u8) 1648 btcb[bo] = 10 as u8 1649 bo = bo + 1 1650 bo = sj_cat(btcb, bo, "nas_stage=knowledge/status/chbeat/stage" as *u8) 1651 btcb[bo] = 10 as u8 1652 bo = bo + 1 1653 bo = sj_cat(btcb, bo, "nas_journal=knowledge/status/chbeat" as *u8) 1654 btcb[bo] = 10 as u8 1655 bo = bo + 1 1656 bo = sj_cat(btcb, bo, "wire=" as *u8) 1657 bo = sj_cat(btcb, bo, prefix) 1658 bo = sj_catn(btcb, bo, now) 1659 bo = sj_cat(btcb, bo, "nowire" as *u8) 1660 btcb[bo] = 10 as u8 1661 bo = bo + 1 1662 bo = sj_cat(btcb, bo, "wire_script=x" as *u8) 1663 btcb[bo] = 10 as u8 1664 bo = bo + 1 1665 bo = sj_cat(btcb, bo, "cap_write=x" as *u8) 1666 btcb[bo] = 10 as u8 1667 bo = bo + 1 1668 bo = sj_cat(btcb, bo, "cap_ingest=x" as *u8) 1669 btcb[bo] = 10 as u8 1670 bo = bo + 1 1671 bo = sj_cat(btcb, bo, "cap_read=x" as *u8) 1672 btcb[bo] = 10 as u8 1673 bo = bo + 1 1674 bo = sj_cat(btcb, bo, "hash_elf=" as *u8) 1675 bo = sj_cat(btcb, bo, prefix) 1676 bo = sj_catn(btcb, bo, now) 1677 bo = sj_cat(btcb, bo, "nohash" as *u8) 1678 btcb[bo] = 10 as u8 1679 bo = bo + 1 1680 let btcfd4: i64 = sys_openat_wr(btconf3, CH_MODE_644) 1681 sys_write(btcfd4, btcb, bo) 1682 sys_close(btcfd4) 1683 let bcx5: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64 1684 let brc5: i64 = ch_beat(btconf3, bcx5) 1685 var ok41: i64 = 0 1686 if brc5 == 1 { if bcx5[16] > 0 { if bcx5[17] == 0 { if bcx5[18] == bcx5[16] { if bcx5[19] > 0 { ok41 = 1 } } } } } 1687 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) 1688 // journal cliff budget rides the conf and announces 1689 let btconf4: *u8 = sys_mmap(512) 1690 o = sj_cat(btconf4, 0, prefix) 1691 o = sj_catn(btconf4, o, now) 1692 o = sj_cat(btconf4, o, "btconf4" as *u8) 1693 btconf4[o] = 0 as u8 1694 bo = sj_cat(btcb, 0, "root=" as *u8) 1695 bo = sj_cat(btcb, bo, btroot) 1696 btcb[bo] = 10 as u8 1697 bo = bo + 1 1698 bo = sj_cat(btcb, bo, "state=" as *u8) 1699 bo = sj_cat(btcb, bo, btstate) 1700 btcb[bo] = 10 as u8 1701 bo = bo + 1 1702 bo = sj_cat(btcb, bo, "spool=" as *u8) 1703 bo = sj_cat(btcb, bo, btspool) 1704 btcb[bo] = 10 as u8 1705 bo = bo + 1 1706 bo = sj_cat(btcb, bo, "done=" as *u8) 1707 bo = sj_cat(btcb, bo, btdone) 1708 btcb[bo] = 10 as u8 1709 bo = bo + 1 1710 bo = sj_cat(btcb, bo, "journal=" as *u8) 1711 bo = sj_cat(btcb, bo, btjrnl) 1712 btcb[bo] = 10 as u8 1713 bo = bo + 1 1714 bo = sj_cat(btcb, bo, "push=0" as *u8) 1715 btcb[bo] = 10 as u8 1716 bo = bo + 1 1717 bo = sj_cat(btcb, bo, "jrnl_cliff=64" as *u8) 1718 btcb[bo] = 10 as u8 1719 bo = bo + 1 1720 let btcfd5: i64 = sys_openat_wr(btconf4, CH_MODE_644) 1721 sys_write(btcfd5, btcb, bo) 1722 sys_close(btcfd5) 1723 let bcx6: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64 1724 let brc6: i64 = ch_beat(btconf4, bcx6) 1725 var ok42: i64 = 0 1726 if brc6 == 0 { if bcx6[28] > 1000 { ok42 = 1 } } 1727 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) 1728 // push-parser teeth: each decision parser must be able to FAIL 1729 let btpp: *u8 = sys_mmap(256) 1730 var btppn: i64 = sj_cat(btpp, 0, "{\"organ\":\"nx_filehash\",\"sha256\":\"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\",\"bytes\":7}" as *u8) 1731 let btsha: *u8 = sys_mmap(80) 1732 var ok43: i64 = 0 1733 if ch_bt_parse_sha(btpp, btppn, btsha) == 1 { 1734 btppn = sj_cat(btpp, 0, "{\"sha256\":\"zz\"}" as *u8) 1735 if ch_bt_parse_sha(btpp, btppn, btsha) == 0 { 1736 btppn = sj_cat(btpp, 0, "INGEST OK frames=42 malformed=0" as *u8) 1737 if ch_bt_int_after(btpp, btppn, "INGEST OK frames=" as *u8) == 42 { 1738 if ch_bt_int_after(btpp, btppn, "bytes=" as *u8) == (0 - 1) { ok43 = 1 } 1739 } 1740 } 1741 } 1742 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) 1743 // T44 the push-reason truth table. The defect this replaces answered "fail-verify" for an upload 1744 // that never landed, so the two ABSENT causes -- which have OPPOSITE remedies (retry the write vs 1745 // investigate a write that lied) -- shared one name. Walk the whole table, then assert they differ. 1746 var ok44: i64 = 0 1747 if ch_bt_zeq(ch_bt_pushreason(0, 0, 0), "fail-write" as *u8) == 1 { 1748 if ch_bt_zeq(ch_bt_pushreason(1, 0, 0), "fail-verify-absent" as *u8) == 1 { 1749 if ch_bt_zeq(ch_bt_pushreason(1, 1, 0), "fail-verify-mismatch" as *u8) == 1 { 1750 if ch_bt_zeq(ch_bt_pushreason(1, 1, 1), "ok" as *u8) == 1 { 1751 if ch_bt_zeq(ch_bt_pushreason(0, 0, 0), ch_bt_pushreason(1, 0, 0)) == 0 { ok44 = 1 } 1752 } 1753 } 1754 } 1755 } 1756 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) 1757 // ---- CE1 leg 2: write frames carry the PATH they touched (additive note token) ---- 1758 let tj2: *u8 = sys_mmap(512) 1759 o = sj_cat(tj2, 0, prefix) 1760 o = sj_catn(tj2, o, now) 1761 o = sj_cat(tj2, o, ".t2" as *u8) 1762 tj2[o] = 0 as u8 1763 let fr2: *u8 = sys_mmap(512) 1764 o = sj_cat(fr2, 0, prefix) 1765 o = sj_catn(fr2, o, now) 1766 o = sj_cat(fr2, o, ".frames2" as *u8) 1767 fr2[o] = 0 as u8 1768 let t2fd: i64 = sys_openat_append(tj2, CH_MODE_644) 1769 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) 1770 lb[lo] = 10 as u8 1771 sys_write(t2fd, lb, lo + 1) 1772 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) 1773 lb[lo] = 10 as u8 1774 sys_write(t2fd, lb, lo + 1) 1775 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) 1776 lb[lo] = 10 as u8 1777 sys_write(t2fd, lb, lo + 1) 1778 sys_close(t2fd) 1779 let tcx2: *i64 = sys_mmap(16) as *i64 1780 let got2: i64 = ch_frames(tj2, "wpath" as *u8, fr2, tcx2) 1781 let fb2: *u8 = sys_mmap(CH_JWIN) 1782 let fn2: i64 = ch_read(fr2, fb2, CH_JWIN - 8) 1783 var ok45: i64 = 0 1784 if got2 == 3 { if fn2 > 0 { if ch_find(fb2, fn2, "path=buildroot/runtime/x_fixture.nx" as *u8) == 1 { ok45 = 1 } } } 1785 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) 1786 var ok46: i64 = 0 1787 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 } } } 1788 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) 1789 var pc: i64 = 0 1790 var px: i64 = 0 1791 var pg: i64 = 1 1792 let pkey: *u8 = "path=" as *u8 1793 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) } } } 1794 var ok47: i64 = 0 1795 if pc == 2 { ok47 = 1 } 1796 gv_check("T47 NEG-CONTROL: a READER frame (nx_fs) carries no path token -- exactly two of three frames do" as *u8, ok47, ctr) 1797 // ---- CE1 leg 2: ce_author_health on a PLANTED tree prefix, a planted journal and a planted spine ---- 1798 let ahp: *u8 = sys_mmap(512) 1799 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 1800 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 1801 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 1802 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 1803 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 1804 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 1805 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 1806 let ahfa: i64 = sys_openat_wr(aha, CH_MODE_644) 1807 lo = sj_cat(lb, 0, "func t(a: i64) -> i64 {\n if a>0 { return 1 }\n return 0\n}\n" as *u8) 1808 sys_write(ahfa, lb, lo); sys_close(ahfa) 1809 let ahfb: i64 = sys_openat_wr(ahb, CH_MODE_644) 1810 lo = sj_cat(lb, 0, "func t() -> i64 {\n return 0\n}\n" as *u8) 1811 sys_write(ahfb, lb, lo); sys_close(ahfb) 1812 let ahfc: i64 = sys_openat_wr(ahc, CH_MODE_644) 1813 lo = sj_cat(lb, 0, "not nishilang\n" as *u8) 1814 sys_write(ahfc, lb, lo); sys_close(ahfc) 1815 let ahfs: i64 = sys_openat_wr(ahs, CH_MODE_644) 1816 lo = sj_cat(lb, 0, "1788600000|files=10|funcs=20|above_10=3|permille=150|classes=0|UNMARKED:10:20:3\n" as *u8) 1817 sys_write(ahfs, lb, lo); sys_close(ahfs) 1818 let ahnb: *u8 = sys_mmap(1024) 1819 let ahfj: i64 = sys_openat_append(ahj, CH_MODE_644) 1820 var ano: i64 = sj_cat(ahnb, 0, "delta path=" as *u8); ano = sj_cat(ahnb, ano, aha); ahnb[ano] = 0 as u8 1821 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) 1822 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) 1823 ano = sj_cat(ahnb, 0, "delta path=" as *u8); ano = sj_cat(ahnb, ano, ahb); ahnb[ano] = 0 as u8 1824 ch_frame_write(ahfj, lb, CH_AH_FIX_TS + 2, "sessB" as *u8, "Write" as *u8, "use" as *u8, "-" as *u8, ahnb) 1825 ano = sj_cat(ahnb, 0, "delta path=" as *u8); ano = sj_cat(ahnb, ano, ahc); ahnb[ano] = 0 as u8 1826 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) 1827 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) 1828 sys_close(ahfj) 1829 let acx: *i64 = sys_mmap(8 * CH_AH_CTRS) as *i64 1830 let aob: *u8 = sys_mmap(CH_OUT) 1831 let arc: i64 = ce_author_health(ahj, ahp, ahs, acx, aob) 1832 var ok48: i64 = 0 1833 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 } } } } } } } } 1834 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) 1835 var ok49: i64 = 0 1836 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 } } } } } } } 1837 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) 1838 let arc2: i64 = ce_author_health(ahj, ahp, ahn, acx, aob) 1839 var ok50: i64 = 0 1840 if arc2 == CH_AH_RC_UNOBS { if acx[CH_AH_DFILES] == 0 { if acx[CH_AH_FILES] == 2 { ok50 = 1 } } } 1841 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) 1842 let arc3: i64 = ce_author_health(fr, ahp, ahs, acx, aob) 1843 var ok51: i64 = 0 1844 if arc3 == CH_AH_RC_NOPATH { if acx[CH_AH_PATHFRAMES] == 0 { if acx[CH_AH_FILES] == 0 { ok51 = 1 } } } 1845 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) 1846 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) 1847 return rc 1848} 1849 1850// ---------- learn: LEARNING-TEXT harvest (root fix for debt 1785525736) ---------- 1851// Every other verb in this organ extracts "type":"tool_use" NAMES. That is tool TELEMETRY, not 1852// learning capture: ch_frame_write puts '-' in the two columns where a lesson would go, and the 1853// 6-hourly beat reported fail=0 for weeks while moving ZERO learnings, over transcripts holding 1854// ~40k LAW:/LESSON/ROOT CAUSE/FINDING: statements. This verb reads the PROSE instead -- the "text" 1855// payloads written by the assistant and the operator -- ranks each line, and keeps only what clears 1856// the floor. Because it CAN reject plain prose, its output is evidence rather than a transcript dump. 1857// Rule 11: every marker, weight and floor is loaded from a conf file. No weight is written in code. 1858const CH_MK_MAX: i64 = 64 1859const CH_CONF_WIN: i64 = 65536 1860const CH_TXTWIN: i64 = 262144 1861 1862// longest run of CONSECUTIVE occurrences of a (possibly multi-byte) glyph in q[s..e) 1863// the star/warn glyphs are 3-byte UTF-8, so this compares byte sequences, never single chars. 1864func ch_run_of(q: *u8, s: i64, e: i64, g: *u8) -> i64 { 1865 let gl: i64 = sj_vlen(g) 1866 if gl <= 0 { return 0 } 1867 var best: i64 = 0 1868 var i: i64 = s 1869 while i < e { 1870 var run: i64 = 0 1871 var j: i64 = i 1872 var go: i64 = 1 1873 while go == 1 { 1874 if j + gl > e { go = 0 } else { 1875 var k: i64 = 0 1876 var same: i64 = 1 1877 while k < gl { 1878 if q[j+k] != g[k] { same = 0; k = gl } else { k = k + 1 } 1879 } 1880 if same == 1 { run = run + 1; j = j + gl } else { go = 0 } 1881 } 1882 } 1883 if run > best { best = run } 1884 if run > 0 { i = j } else { i = i + 1 } 1885 } 1886 return best 1887} 1888 1889// conf loader. mk is INTERLEAVED (mk[2k]=literal offset into cbuf, mk[2k+1]=weight) so this stays 1890// at 4 params; sc carries the scalars: 0=warn_bonus 1=min_rank 2=min_len 3=max_len 4=star_off 1891// 5=warn_off 6=star_max 7=marker_count. Returns marker count, or -1 if the conf cannot be read -- 1892// FAIL-CLOSED: no conf means no ranking basis, so the verb refuses rather than inventing weights. 1893func ch_conf_load(path: *u8, cbuf: *u8, mk: *i64, sc: *i64) -> i64 { 1894 let n: i64 = ch_read(path, cbuf, CH_CONF_WIN - 8) 1895 if n <= 0 { return 0 - 1 } 1896 sc[0] = 2 1897 sc[1] = 3 1898 sc[2] = 40 1899 sc[3] = 400 1900 sc[4] = 0 - 1 1901 sc[5] = 0 - 1 1902 sc[6] = 6 1903 var cnt: i64 = 0 1904 var i: i64 = 0 1905 while i < n { 1906 let le: i64 = sj_le(cbuf, i, n) 1907 if cbuf[i] != (35 as u8) { 1908 if ch_starts(cbuf, i, le, "marker=" as *u8) == 1 { 1909 if cnt < CH_MK_MAX { 1910 let vs: i64 = i + 7 1911 var bar: i64 = 0 - 1 1912 var p: i64 = vs 1913 while p < le { if cbuf[p] == (124 as u8) { bar = p } p = p + 1 } 1914 if bar > vs { 1915 cbuf[bar] = 0 as u8 1916 cbuf[le] = 0 as u8 1917 mk[cnt*2] = vs 1918 mk[cnt*2+1] = sj_atoi_z(((cbuf as i64) + bar + 1) as *u8) 1919 cnt = cnt + 1 1920 } 1921 } 1922 } 1923 if ch_starts(cbuf, i, le, "star_char=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[4] = i + 10 } 1924 if ch_starts(cbuf, i, le, "warn_char=" as *u8) == 1 { cbuf[le] = 0 as u8; sc[5] = i + 10 } 1925 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) } 1926 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) } 1927 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) } 1928 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) } 1929 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) } 1930 } 1931 i = le + 1 1932 } 1933 sc[7] = cnt 1934 return cnt 1935} 1936 1937// a marker must sit on a WORD BOUNDARY. Measured on real prose: the naive substring test scored 1938// "UNMEASURED" as the marker "MEASURED" and promoted a doc line to rank 3 -- a substring needle 1939// flatters silently. Only the left edge needs guarding (markers are prefixes like "LAW:"). 1940func ch_isalpha(c: u8) -> i64 { 1941 if c >= (65 as u8) { if c <= (90 as u8) { return 1 } } 1942 if c >= (97 as u8) { if c <= (122 as u8) { return 1 } } 1943 return 0 1944} 1945 1946// rank = the MAX of the signals, never the mean (banked law): a star run is the operator's own 1947// ranking convention, a warn glyph is a callout worth rank+bonus, and marker phrases carry their 1948// configured weight. Capped at star_max so a decorative row of stars cannot outrank a real law. 1949func ch_rank_text(q: *u8, s: i64, e: i64, cbuf: *u8, mk: *i64, sc: *i64) -> i64 { 1950 var r: i64 = 0 1951 if sc[4] >= 0 { 1952 let sr: i64 = ch_run_of(q, s, e, ((cbuf as i64) + sc[4]) as *u8) 1953 if sr > r { r = sr } 1954 } 1955 if sc[5] >= 0 { 1956 let wr: i64 = ch_run_of(q, s, e, ((cbuf as i64) + sc[5]) as *u8) 1957 if wr > 0 { let wv: i64 = wr + sc[0]; if wv > r { r = wv } } 1958 } 1959 var k: i64 = 0 1960 while k < sc[7] { 1961 let lit: *u8 = ((cbuf as i64) + mk[k*2]) as *u8 1962 var from: i64 = s 1963 var hit: i64 = 0 1964 while hit == 0 { 1965 let hp: i64 = ch_find_from(q, from, e, lit) 1966 if hp < 0 { hit = 0 - 1 } else { 1967 var okb: i64 = 1 1968 if hp > s { if ch_isalpha(q[hp-1]) == 1 { okb = 0 } } 1969 if okb == 1 { hit = 1 } else { from = hp + 1 } 1970 } 1971 } 1972 if hit == 1 { if mk[k*2+1] > r { r = mk[k*2+1] } } 1973 k = k + 1 1974 } 1975 if r > sc[6] { r = sc[6] } 1976 return r 1977} 1978 1979func ch_learn(tpath: *u8, ws: *u8, outp: *u8, confp: *u8, cx: *i64) -> i64 { 1980 let cbuf: *u8 = sys_mmap(CH_CONF_WIN) 1981 let mk: *i64 = sys_mmap(CH_MK_MAX * 16) as *i64 1982 let sc: *i64 = sys_mmap(128) as *i64 1983 let cnt: i64 = ch_conf_load(confp, cbuf, mk, sc) 1984 if cnt < 0 { return 0 - 4 } 1985 cx[1] = cnt 1986 let buf: *u8 = sys_mmap(CH_WIN) 1987 let cap: i64 = CH_WIN - 8 1988 let n: i64 = ch_read(tpath, buf, cap) 1989 cx[0] = 0 1990 if n <= 0 { return 0 - 1 } 1991 if n >= cap { cx[0] = 1 } 1992 let fd: i64 = sys_openat_append(outp, CH_MODE_644) 1993 if fd < 0 { return 0 - 3 } 1994 let tb: *u8 = sys_mmap(CH_TXTWIN) 1995 let ob: *u8 = sys_mmap(CH_TXTWIN) 1996 // last emitted segment. A real transcript frame carries the same assistant text more than once 1997 // (the message and its echo), so without this the organ emits provable duplicates -- measured 2 1998 // identical records from one real line. Adjacent-compare, not a full set: the echo is adjacent. 1999 let pb: *u8 = sys_mmap(CH_TXTWIN) 2000 var pl: i64 = 0 2001 var kept: i64 = 0 2002 var i: i64 = 0 2003 while i < n { 2004 let le: i64 = sj_le(buf, i, n) 2005 var ts: i64 = 0 2006 let tp: i64 = ch_find_from(buf, i, le, "\"timestamp\":\"" as *u8) 2007 if tp >= 0 { ts = ch_iso_epoch(buf, tp + 13, le) } 2008 var j: i64 = i 2009 var go: i64 = 1 2010 while go == 1 { 2011 let xp: i64 = ch_find_from(buf, j, le, "\"text\":\"" as *u8) 2012 if xp < 0 { go = 0 } else { 2013 var p: i64 = xp + 8 2014 var to: i64 = 0 2015 var g2: i64 = 1 2016 while g2 == 1 { 2017 if p >= le { g2 = 0 } else { 2018 let c: u8 = buf[p] 2019 if c == (34 as u8) { g2 = 0 } else { 2020 if c == (92 as u8) { 2021 let d2: u8 = buf[p+1] 2022 var em: u8 = d2 2023 if d2 == (110 as u8) { em = 10 as u8 } 2024 if d2 == (116 as u8) { em = 32 as u8 } 2025 if d2 == (114 as u8) { em = 32 as u8 } 2026 if to < CH_TXTWIN - 4 { tb[to] = em; to = to + 1 } 2027 p = p + 2 2028 } else { 2029 if to < CH_TXTWIN - 4 { tb[to] = c; to = to + 1 } 2030 p = p + 1 2031 } 2032 } 2033 } 2034 } 2035 var q: i64 = 0 2036 while q < to { 2037 let qe: i64 = sj_le(tb, q, to) 2038 let seg: i64 = qe - q 2039 if seg >= sc[2] { 2040 var endq: i64 = qe 2041 if seg > sc[3] { endq = q + sc[3] } 2042 let r: i64 = ch_rank_text(tb, q, endq, cbuf, mk, sc) 2043 var dup: i64 = 0 2044 if pl == (endq - q) { 2045 var z: i64 = 0 2046 var sm: i64 = 1 2047 while z < pl { if pb[z] != tb[q+z] { sm = 0; z = pl } else { z = z + 1 } } 2048 if sm == 1 { dup = 1 } 2049 } 2050 if r >= sc[1] { if dup == 0 { 2051 var o: i64 = sj_cat(ob, 0, "{\"ts\":" as *u8) 2052 o = sj_catn(ob, o, ts) 2053 o = sj_cat(ob, o, ",\"ws\":\"" as *u8) 2054 o = sj_cat(ob, o, ws) 2055 o = sj_cat(ob, o, "\",\"src\":\"transcript\",\"rank\":" as *u8) 2056 o = sj_catn(ob, o, r) 2057 o = sj_cat(ob, o, ",\"text\":\"" as *u8) 2058 var k2: i64 = q 2059 while k2 < endq { 2060 let c2: u8 = tb[k2] 2061 if c2 == (34 as u8) { ob[o] = 92 as u8; o = o + 1; ob[o] = 34 as u8; o = o + 1 } else { 2062 if c2 == (92 as u8) { ob[o] = 92 as u8; o = o + 1; ob[o] = 92 as u8; o = o + 1 } else { 2063 if c2 < (32 as u8) { ob[o] = 32 as u8; o = o + 1 } else { ob[o] = c2; o = o + 1 } 2064 } 2065 } 2066 k2 = k2 + 1 2067 } 2068 o = sj_cat(ob, o, "\"}" as *u8) 2069 ob[o] = 10 as u8 2070 sys_write(fd, ob, o + 1) 2071 pl = endq - q 2072 var z3: i64 = 0 2073 while z3 < pl { pb[z3] = tb[q+z3]; z3 = z3 + 1 } 2074 kept = kept + 1 2075 } } 2076 } 2077 q = qe + 1 2078 } 2079 j = p + 1 2080 } 2081 } 2082 i = le + 1 2083 } 2084 sys_close(fd) 2085 return kept 2086} 2087 2088// ================= beat: DM1 session->NAS capture (devmgmt /compare rung, 2026-08-20) ================= 2089// The dev record is laptop-local (837 transcripts / 2.29 GB measured 2026-08-20 under 2090// ~/.claude/projects, at THREE depths: sessions, subagents/, subagents/workflows/); the NAS clock plane 2091// cannot reach the laptop, so the beat RUNS WHERE THE TRANSCRIPTS LIVE (this organ is portable by 2092// design) and PUSHES. Pipeline: walk -> ch_delta per transcript (per-transcript byte HWM in state/) 2093// -> split fresh frames into ts-day PIECES -> ingest every piece into the LOCAL per-day journal twin 2094// -> when push=1, per piece: upload via the forked MCP wire (nx_fs_write), byte-verify with 2095// nx_filehash on BOTH sides (one ruler), NAS-side ch_ingest into the per-day NAS journal, announce 2096// journal fill. PIECES ARE THE CHUNK UNIT AND THE INGEST UNIT: each stays under the MCP body cliff 2097// and is marker-idempotent via ch_ingest, so the pipeline is resumable at every stage with no append 2098// primitive over the wire. A piece leaves the spool only after the NAS leg confirms; every failure 2099// leaves it spooled -- wrong only toward doing nothing. 2100// DAY PARTITION DERIVATION: heaviest measured day (2026-08-19: 32,122 MCP calls / 836,673 transcript 2101// lines across 7 seats) stages ~2-4 MB of frames -- a day is the largest calendar unit whose worst 2102// measured case still fits the 4 MiB gauge window (CH_JWIN), so per-day journals keep the NAS-side 2103// gauge untruncated. Frames whose timestamp cannot parse route to chbeat_tszero.jrnl -- their own 2104// bucket, never folded. 2105// Rule 11: every path, bound and cadence datum rides chbeat.conf; the beat consts live in the module 2106// const block at the top (single-pass parser: the selftest teeth read them first). 2107 2108func ch_bt_zeq(a: *u8, b: *u8) -> i64 { 2109 var i: i64 = 0 2110 while a[i] == b[i] { if a[i] == (0 as u8) { return 1 } i = i + 1 } 2111 return 0 2112} 2113func ch_bt_ends(s: *u8, sfx: *u8) -> i64 { 2114 let n: i64 = sj_vlen(s) 2115 let m: i64 = sj_vlen(sfx) 2116 if n < m { return 0 } 2117 return sj_lit_eq(s, n - m, n, sfx) 2118} 2119func ch_bt_le16(b: *u8, off: i64) -> i64 { return (b[off] as i64) + (b[off+1] as i64) * 256 } 2120func ch_bt_le64(b: *u8, off: i64) -> i64 { 2121 var v: i64 = 0 2122 var i: i64 = 7 2123 while i >= 0 { v = v * 256 + (b[off+i] as i64); i = i - 1 } 2124 return v 2125} 2126// stat: k[0]=file kind as the DT_* value ((st_mode>>12)&0xF equals DT_DIR/DT_REG numerically by Linux 2127// design), k[1]=size. sb = caller scratch >= 160 B (never allocated here -- runs once per dirent). 2128// st_mode u16 at offset 24, st_size i64 at offset 48 (x86_64 struct stat; the same offsets 2129// nx_artifactdrift ps_execbit reads). Arithmetic field extraction, no bitwise ops needed. 2130func ch_bt_stat(path: *u8, sb: *u8, k: *i64) -> i64 { 2131 k[0] = 0 2132 k[1] = 0 - 1 2133 if sys_fstatat(path, sb) != 0 { return 0 - 1 } 2134 let mode: i64 = ch_bt_le16(sb, 24) 2135 k[0] = (mode / 4096) % 16 2136 k[1] = ch_bt_le64(sb, 48) 2137 return 0 2138} 2139// recursive walk: every file ending <sfx> under root, ANY depth (sessions, subagents/, workflows/). 2140// getdents64 LOOPED until 0 per directory (one call is a prefix -- banked law); d_type on 9p/drvfs is 2141// often DT_UNKNOWN -> fstatat fallback, counted. fo[i] = arena offset of file path i. 2142// Returns file count, or -1 = table/arena overflow (caller REFUSES loudly -- never a silent cap). 2143// wcx: 0=dirs_walked 1=dir_open_errors 2=stat_fallbacks 3=arena_used 2144func ch_bt_walk(root: *u8, sfx: *u8, ar: *u8, fo: *i64, wcx: *i64) -> i64 { 2145 let dq: *i64 = sys_mmap(8 * CH_BT_MAXDIRS) as *i64 2146 let db: *u8 = sys_mmap(CH_BT_DIRWIN) 2147 let sb: *u8 = sys_mmap(256) 2148 let kk: *i64 = sys_mmap(16) as *i64 2149 var ap: i64 = 0 2150 var dh: i64 = 0 2151 var dt2: i64 = 0 2152 var nf: i64 = 0 2153 wcx[0] = 0 2154 wcx[1] = 0 2155 wcx[2] = 0 2156 wcx[3] = 0 2157 let rl: i64 = sj_vlen(root) 2158 if rl + 2 > CH_BT_ARENA { return 0 - 1 } 2159 dq[dt2] = ap 2160 var o: i64 = sj_cat(ar, ap, root) 2161 ar[o] = 0 as u8 2162 ap = o + 1 2163 dt2 = dt2 + 1 2164 while dh < dt2 { 2165 let dpo: i64 = dq[dh] 2166 dh = dh + 1 2167 let dpath: *u8 = ((ar as i64) + dpo) as *u8 2168 let dl: i64 = sj_vlen(dpath) 2169 let fd: i64 = sys_openat_rd(dpath) 2170 if fd < 0 { wcx[1] = wcx[1] + 1 } else { 2171 var more: i64 = 1 2172 while more == 1 { 2173 let r: i64 = sys_getdents64(fd, db, CH_BT_DIRWIN) 2174 if r <= 0 { more = 0 } else { 2175 var p: i64 = 0 2176 while p < r { 2177 let rec: *u8 = ((db as i64) + p) as *u8 2178 let rl2: i64 = dirent_reclen(rec) 2179 if rl2 <= 0 { p = r; more = 0 } else { 2180 var ty: i64 = dirent_type(rec) 2181 let nm: *u8 = dirent_name(rec) 2182 var dot: i64 = 0 2183 if nm[0] == (46 as u8) { 2184 if nm[1] == (0 as u8) { dot = 1 } 2185 if nm[1] == (46 as u8) { if nm[2] == (0 as u8) { dot = 1 } } 2186 } 2187 if dot == 0 { 2188 let nl: i64 = sj_vlen(nm) 2189 if ap + dl + nl + 2 > CH_BT_ARENA { sys_close(fd); return 0 - 1 } 2190 let po: i64 = ap 2191 var q: i64 = sj_cat(ar, po, dpath) 2192 ar[q] = 47 as u8 2193 q = q + 1 2194 q = sj_cat(ar, q, nm) 2195 ar[q] = 0 as u8 2196 let full: *u8 = ((ar as i64) + po) as *u8 2197 if ty == 0 { wcx[2] = wcx[2] + 1; if ch_bt_stat(full, sb, kk) == 0 { ty = kk[0] } } 2198 var keep: i64 = 0 2199 if ty == DT_DIR { 2200 if dt2 >= CH_BT_MAXDIRS { sys_close(fd); return 0 - 1 } 2201 dq[dt2] = po 2202 dt2 = dt2 + 1 2203 keep = 1 2204 } else { 2205 if ty == DT_REG { if ch_bt_ends(full, sfx) == 1 { 2206 if nf >= CH_BT_MAXFILES { sys_close(fd); return 0 - 1 } 2207 fo[nf] = po 2208 nf = nf + 1 2209 keep = 1 2210 } } 2211 } 2212 if keep == 1 { ap = q + 1 } 2213 } 2214 p = p + rl2 2215 } 2216 } 2217 } 2218 } 2219 sys_close(fd) 2220 wcx[0] = wcx[0] + 1 2221 } 2222 } 2223 wcx[3] = ap 2224 return nf 2225} 2226// epoch -> zero-padded YYYYMMDD (Hinnant civil-from-days, the exact inverse of ch_epoch_ymdhms). 2227// ts <= 0 -> "tszero": frames without a parseable timestamp keep their OWN journal bucket. 2228func ch_bt_day(ts: i64, d: *u8) -> i64 { 2229 if ts <= 0 { let o: i64 = sj_cat(d, 0, "tszero" as *u8); d[o] = 0 as u8; return o } 2230 let z: i64 = ts / CH_MAGIC_86400 + CH_MAGIC_719468 2231 let era: i64 = z / CH_MAGIC_146097 2232 let doe: i64 = z - era * CH_MAGIC_146097 2233 let yoe: i64 = (doe - doe / CH_MAGIC_1460 + doe / CH_MAGIC_36524 - doe / CH_MAGIC_146096) / 365 2234 var y: i64 = yoe + era * 400 2235 let doy: i64 = doe - (365 * yoe + yoe / 4 - yoe / 100) 2236 let mp: i64 = (5 * doy + 2) / 153 2237 let dd: i64 = doy - (153 * mp + 2) / 5 + 1 2238 var m: i64 = 0 2239 if mp < 10 { m = mp + 3 } else { m = mp - 9 } 2240 if m <= 2 { y = y + 1 } 2241 d[0] = (48 + (y / 1000) % 10) as u8 2242 d[1] = (48 + (y / 100) % 10) as u8 2243 d[2] = (48 + (y / 10) % 10) as u8 2244 d[3] = (48 + y % 10) as u8 2245 d[4] = (48 + (m / 10) % 10) as u8 2246 d[5] = (48 + m % 10) as u8 2247 d[6] = (48 + (dd / 10) % 10) as u8 2248 d[7] = (48 + dd % 10) as u8 2249 d[8] = 0 as u8 2250 return 8 2251} 2252// conf: key=value rows; '#' comments. Values zero-terminate IN cbuf; the value offset is DERIVED from 2253// the key literal's own length (sj_vlen) -- never a hand-counted twin beside the literal (banked law). 2254func ch_bt_kv(cbuf: *u8, i: i64, le: i64, key: *u8) -> i64 { 2255 if ch_starts(cbuf, i, le, key) == 1 { cbuf[le] = 0 as u8; return i + sj_vlen(key) } 2256 return 0 - 1 2257} 2258// off: 0 root 1 state 2 spool 3 done 4 journal 5 nas_stage 6 nas_journal 7 wire 8 wire_script 2259// 9 cap_write 10 cap_ingest 11 cap_read 12 hash_elf (-1 = absent) 2260// iv: 0 push 1 push_max 2 piece_raw 3 wire_timeout_ms 4 jrnl_cliff 5 jrnl_warn_permil 2261// kt interleaved known_type rows (offset,count); count in kcx[0] 2262// returns 0, -1 unreadable conf, -2 required key missing (NAMED on stdout) -- fail-closed both ways. 2263func ch_bt_conf(path: *u8, cbuf: *u8, off: *i64, iv: *i64, kt: *i64, kcx: *i64) -> i64 { 2264 let n: i64 = ch_read(path, cbuf, CH_CONF_WIN - 8) 2265 if n <= 0 { return 0 - 1 } 2266 var w: i64 = 0 2267 while w < 13 { off[w] = 0 - 1; w = w + 1 } 2268 iv[0] = 0 2269 iv[1] = 0 2270 // derived default: ~9% JSON-escape inflation on the 6 control bytes per ~80 B frame plus a ~1 KiB 2271 // rpc envelope cannot push 3/4 of the measured body cliff across it 2272 iv[2] = CH_MCP_BODY_CLIFF * 3 / 4 2273 // derived default: matches the estate MCP client's own 120000 ms call deadline 2274 iv[3] = 120000 2275 // derived default: the day-journal cliff IS the gauge/verify window 2276 iv[4] = CH_JWIN 2277 // derived default: AMBER from four fifths of the cliff (the sizeguard amber-before-red shape) 2278 iv[5] = 1000 * 4 / 5 2279 kcx[0] = 0 2280 var i: i64 = 0 2281 while i < n { 2282 let le: i64 = sj_le(cbuf, i, n) 2283 if cbuf[i] != (35 as u8) { 2284 var v: i64 = ch_bt_kv(cbuf, i, le, "root=" as *u8) 2285 if v >= 0 { off[0] = v } 2286 v = ch_bt_kv(cbuf, i, le, "state=" as *u8) 2287 if v >= 0 { off[1] = v } 2288 v = ch_bt_kv(cbuf, i, le, "spool=" as *u8) 2289 if v >= 0 { off[2] = v } 2290 v = ch_bt_kv(cbuf, i, le, "done=" as *u8) 2291 if v >= 0 { off[3] = v } 2292 v = ch_bt_kv(cbuf, i, le, "journal=" as *u8) 2293 if v >= 0 { off[4] = v } 2294 v = ch_bt_kv(cbuf, i, le, "nas_stage=" as *u8) 2295 if v >= 0 { off[5] = v } 2296 v = ch_bt_kv(cbuf, i, le, "nas_journal=" as *u8) 2297 if v >= 0 { off[6] = v } 2298 v = ch_bt_kv(cbuf, i, le, "wire=" as *u8) 2299 if v >= 0 { off[7] = v } 2300 v = ch_bt_kv(cbuf, i, le, "wire_script=" as *u8) 2301 if v >= 0 { off[8] = v } 2302 v = ch_bt_kv(cbuf, i, le, "cap_write=" as *u8) 2303 if v >= 0 { off[9] = v } 2304 v = ch_bt_kv(cbuf, i, le, "cap_ingest=" as *u8) 2305 if v >= 0 { off[10] = v } 2306 v = ch_bt_kv(cbuf, i, le, "cap_read=" as *u8) 2307 if v >= 0 { off[11] = v } 2308 v = ch_bt_kv(cbuf, i, le, "hash_elf=" as *u8) 2309 if v >= 0 { off[12] = v } 2310 v = ch_bt_kv(cbuf, i, le, "push=" as *u8) 2311 if v >= 0 { iv[0] = sj_atoi_z(((cbuf as i64) + v) as *u8) } 2312 v = ch_bt_kv(cbuf, i, le, "push_max=" as *u8) 2313 if v >= 0 { iv[1] = sj_atoi_z(((cbuf as i64) + v) as *u8) } 2314 v = ch_bt_kv(cbuf, i, le, "piece_raw=" as *u8) 2315 if v >= 0 { iv[2] = sj_atoi_z(((cbuf as i64) + v) as *u8) } 2316 v = ch_bt_kv(cbuf, i, le, "wire_timeout_ms=" as *u8) 2317 if v >= 0 { iv[3] = sj_atoi_z(((cbuf as i64) + v) as *u8) } 2318 v = ch_bt_kv(cbuf, i, le, "jrnl_cliff=" as *u8) 2319 if v >= 0 { iv[4] = sj_atoi_z(((cbuf as i64) + v) as *u8) } 2320 v = ch_bt_kv(cbuf, i, le, "jrnl_warn_permil=" as *u8) 2321 if v >= 0 { iv[5] = sj_atoi_z(((cbuf as i64) + v) as *u8) } 2322 v = ch_bt_kv(cbuf, i, le, "known_type=" as *u8) 2323 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 } } 2324 } 2325 i = le + 1 2326 } 2327 var miss: i64 = 0 - 1 2328 if off[0] < 0 { miss = 0 } 2329 if off[1] < 0 { if miss < 0 { miss = 1 } } 2330 if off[2] < 0 { if miss < 0 { miss = 2 } } 2331 if off[3] < 0 { if miss < 0 { miss = 3 } } 2332 if off[4] < 0 { if miss < 0 { miss = 4 } } 2333 if miss >= 0 { 2334 let eb: *u8 = sys_mmap(256) 2335 var o2: i64 = sj_cat(eb, 0, "CHBEAT CONF-MISSING key=" as *u8) 2336 if miss == 0 { o2 = sj_cat(eb, o2, "root" as *u8) } 2337 if miss == 1 { o2 = sj_cat(eb, o2, "state" as *u8) } 2338 if miss == 2 { o2 = sj_cat(eb, o2, "spool" as *u8) } 2339 if miss == 3 { o2 = sj_cat(eb, o2, "done" as *u8) } 2340 if miss == 4 { o2 = sj_cat(eb, o2, "journal" as *u8) } 2341 eb[o2] = 10 as u8 2342 sys_write(1, eb, o2 + 1) 2343 return 0 - 2 2344 } 2345 return 0 2346} 2347// head-type census + tool_use marks over the freshly harvested window [from,to) of ONE transcript. 2348// ANCHORED at line position 0 -- a nested "type" deeper in the line can never be read as the record 2349// type (measured 2026-08-20: attachment lines carry a NESTED type FIRST, so a first-occurrence scan 2350// answers the wrong field). Lines whose type is not the first key count HEADLESS -- named for what was 2351// measured; the head census watches the head-shaped population only, and that imprecision is declared 2352// here. Unknown head-types intern into their own worklist (ua/uo/ucx), never folded into a known one. 2353// ccx: 0=lines 1=tooluse_lines 2=tooluse_marks 3=head_known 4=head_unknown 5=headless 2354// 6=census_read_fail 7=type_table_overflow(FLOOR flag) ucx: 0=distinct_unknown 1=ua_cursor 2355func ch_bt_census(tpath: *u8, from: i64, to: i64, cbuf: *u8, kt: *i64, kn: i64, ua: *u8, uo: *i64, ucx: *i64, ccx: *i64) -> i64 { 2356 let nn: *i64 = sys_mmap(16) as *i64 2357 let buf: *u8 = sys_map_file(tpath, nn) 2358 let n: i64 = nn[0] 2359 if n <= 0 { ccx[6] = ccx[6] + 1; return 0 - 1 } 2360 var lim: i64 = to 2361 if lim > n { lim = n } 2362 let tul: *u8 = "\"type\":\"tool_use\"" as *u8 2363 let tuln: i64 = sj_vlen(tul) 2364 let hl: *u8 = "{\"type\":\"" as *u8 2365 let hln: i64 = sj_vlen(hl) 2366 var i: i64 = from 2367 if i < 0 { i = 0 } 2368 while i < lim { 2369 let le: i64 = sj_le(buf, i, lim) 2370 if le > i { 2371 ccx[0] = ccx[0] + 1 2372 var marks: i64 = 0 2373 var j: i64 = i 2374 var go: i64 = 1 2375 while go == 1 { 2376 let tu: i64 = ch_find_from(buf, j, le, tul) 2377 if tu < 0 { go = 0 } else { marks = marks + 1; j = tu + tuln } 2378 } 2379 if marks > 0 { ccx[1] = ccx[1] + 1; ccx[2] = ccx[2] + marks } 2380 if ch_starts(buf, i, le, hl) == 1 { 2381 let vs: i64 = i + hln 2382 var ve: i64 = vs 2383 var g2: i64 = 1 2384 while g2 == 1 { 2385 if ve >= le { g2 = 0 } else { if buf[ve] == (34 as u8) { g2 = 0 } else { ve = ve + 1 } } 2386 } 2387 var hit: i64 = 0 2388 var k: i64 = 0 2389 while k < kn { 2390 let lit: *u8 = ((cbuf as i64) + kt[k * 2]) as *u8 2391 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 } 2392 } 2393 if hit == 1 { ccx[3] = ccx[3] + 1 } else { 2394 ccx[4] = ccx[4] + 1 2395 var f: i64 = 0 - 1 2396 var k2: i64 = 0 2397 while k2 < ucx[0] { 2398 let ul: *u8 = ((ua as i64) + uo[k2 * 2]) as *u8 2399 if sj_lit_eq(buf, vs, ve, ul) == 1 { f = k2; k2 = ucx[0] } else { k2 = k2 + 1 } 2400 } 2401 if f >= 0 { uo[f * 2 + 1] = uo[f * 2 + 1] + 1 } else { 2402 if ucx[0] < CH_BT_TYPEMAX { 2403 var vl2: i64 = ve - vs 2404 if vl2 > CH_NAME_MAX { vl2 = CH_NAME_MAX } 2405 uo[ucx[0] * 2] = ucx[1] 2406 uo[ucx[0] * 2 + 1] = 1 2407 var c2: i64 = 0 2408 while c2 < vl2 { ua[ucx[1] + c2] = buf[vs + c2]; c2 = c2 + 1 } 2409 ua[ucx[1] + vl2] = 0 as u8 2410 ucx[1] = ucx[1] + vl2 + 1 2411 ucx[0] = ucx[0] + 1 2412 } else { ccx[7] = 1 } 2413 } 2414 } 2415 } else { ccx[5] = ccx[5] + 1 } 2416 } 2417 i = le + 1 2418 } 2419 sys_munmap(buf, n) 2420 return 0 2421} 2422func ch_bt_path2(out: *u8, a: *u8, b: *u8) -> i64 { 2423 var o: i64 = sj_cat(out, 0, a) 2424 out[o] = 47 as u8 2425 o = o + 1 2426 o = sj_cat(out, o, b) 2427 out[o] = 0 as u8 2428 return o 2429} 2430func ch_bt_base(path: *u8) -> *u8 { 2431 var bs: i64 = 0 2432 var i: i64 = 0 2433 while path[i] != (0 as u8) { if path[i] == (47 as u8) { bs = i + 1 } i = i + 1 } 2434 return ((path as i64) + bs) as *u8 2435} 2436func ch_bt_stem(path: *u8, out: *u8) -> i64 { 2437 let b: *u8 = ch_bt_base(path) 2438 let n: i64 = sj_vlen(b) 2439 var e: i64 = n - sj_vlen(".jsonl" as *u8) 2440 if e < 0 { e = n } 2441 var o: i64 = 0 2442 while o < e { out[o] = b[o]; o = o + 1 } 2443 out[o] = 0 as u8 2444 return o 2445} 2446func ch_bt_hwmpath(state: *u8, rel: *u8, out: *u8) -> i64 { 2447 var o: i64 = sj_cat(out, 0, state) 2448 out[o] = 47 as u8 2449 o = o + 1 2450 var i: i64 = 0 2451 while rel[i] != (0 as u8) { 2452 var c: u8 = rel[i] 2453 if c == (47 as u8) { c = 95 as u8 } 2454 if c == (92 as u8) { c = 95 as u8 } 2455 out[o] = c 2456 o = o + 1 2457 i = i + 1 2458 } 2459 o = sj_cat(out, o, ".hwm" as *u8) 2460 out[o] = 0 as u8 2461 return o 2462} 2463// frame count of a piece (pieces are written by ch_bt_split, every line newline-terminated) 2464func ch_bt_lines(path: *u8) -> i64 { 2465 let nn: *i64 = sys_mmap(16) as *i64 2466 let buf: *u8 = sys_map_file(path, nn) 2467 let n: i64 = nn[0] 2468 if n <= 0 { return 0 } 2469 var c: i64 = 0 2470 var i: i64 = 0 2471 while i < n { 2472 let le: i64 = sj_le(buf, i, n) 2473 if le > i { c = c + 1 } 2474 i = le + 1 2475 } 2476 sys_munmap(buf, n) 2477 return c 2478} 2479// first integer right after <key> in b[0..n) -> value, or -1 when key or digits absent 2480func ch_bt_int_after(b: *u8, n: i64, key: *u8) -> i64 { 2481 let p: i64 = ch_find_from(b, 0, n, key) 2482 if p < 0 { return 0 - 1 } 2483 var i: i64 = p + sj_vlen(key) 2484 var v: i64 = 0 2485 var any: i64 = 0 2486 var go: i64 = 1 2487 while go == 1 { 2488 if i >= n { go = 0 } else { 2489 let c: i64 = b[i] as i64 2490 var dig: i64 = 0 2491 if c >= 48 { if c <= 57 { dig = 1 } } 2492 if dig == 1 { v = v * 10 + (c - 48); any = 1; i = i + 1 } else { go = 0 } 2493 } 2494 } 2495 if any == 0 { return 0 - 1 } 2496 return v 2497} 2498// sha256 hex right after "sha256":" -> out (65 B incl NUL); 1 ok, 0 absent/short/non-hex 2499func ch_bt_parse_sha(b: *u8, n: i64, out: *u8) -> i64 { 2500 let key: *u8 = "\"sha256\":\"" as *u8 2501 let p: i64 = ch_find_from(b, 0, n, key) 2502 if p < 0 { return 0 } 2503 let s: i64 = p + sj_vlen(key) 2504 var i: i64 = 0 2505 while i < 64 { 2506 if s + i >= n { return 0 } 2507 let c: i64 = b[s + i] as i64 2508 var okc: i64 = 0 2509 if c >= 48 { if c <= 57 { okc = 1 } } 2510 if c >= 97 { if c <= 102 { okc = 1 } } 2511 if okc == 0 { return 0 } 2512 out[i] = b[s + i] 2513 i = i + 1 2514 } 2515 out[64] = 0 as u8 2516 return 1 2517} 2518// forked call through the MCP wire: <wire> <script> <tool> <cap> [a1..a4]; captures stdout+stderr. 2519// Returns the child's exit code (127 = wire absent). The wire is TRANSPORT ONLY -- every decision 2520// over its output happens in this organ (shell-is-break-glass discipline; the wire is the sanctioned 2521// MCP client, nxmcp.py, forked with a clean argv, no shell interpretation anywhere). 2522func 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 { 2523 let av: *i64 = sys_mmap(96) as *i64 2524 av[0] = wire as i64 2525 av[1] = script as i64 2526 av[2] = tool as i64 2527 av[3] = cap as i64 2528 var k: i64 = 4 2529 if (a1 as i64) != 0 { av[k] = a1 as i64; k = k + 1 } 2530 if (a2 as i64) != 0 { av[k] = a2 as i64; k = k + 1 } 2531 if (a3 as i64) != 0 { av[k] = a3 as i64; k = k + 1 } 2532 if (a4 as i64) != 0 { av[k] = a4 as i64; k = k + 1 } 2533 av[k] = 0 2534 return tr_run_capture_to(wire, av, cout, CH_OUT - 8, colen, tmo) 2535} 2536func ch_bt_flushp(spool: *u8, day: *u8, stamp: i64, seq: i64, cell: *u8, clen: i64) -> i64 { 2537 let pp: *u8 = sys_mmap(CH_BT_PATHMAX) 2538 var o: i64 = sj_cat(pp, 0, spool) 2539 pp[o] = 47 as u8 2540 o = o + 1 2541 o = sj_cat(pp, o, "cb" as *u8) 2542 o = sj_cat(pp, o, day) 2543 pp[o] = 95 as u8 2544 o = o + 1 2545 o = sj_catn(pp, o, stamp) 2546 pp[o] = 95 as u8 2547 o = o + 1 2548 o = sj_catn(pp, o, seq) 2549 o = sj_cat(pp, o, ".frames" as *u8) 2550 pp[o] = 0 as u8 2551 let fd: i64 = sys_openat_wr(pp, CH_MODE_644) 2552 if fd < 0 { return 0 - 3 } 2553 sys_write(fd, cell, clen) 2554 sys_close(fd) 2555 return 0 2556} 2557// split a raw delta-frames file into ts-day pieces, each under piece_raw bytes at a FRAME boundary. 2558// Piece names cb<day>_<stamp>_<seq>.frames are DETERMINISTIC from the raw file's stamp, so a re-split 2559// after a crash rewrites identical names and content and every downstream stage stays idempotent by 2560// marker. dcx: 0=pieces 1=bytes 2=days 3=tszero_frames 4=frames 2561// returns 0, -2 day-table overflow (REFUSED loudly), -3 piece write fail 2562func ch_bt_split(rawpath: *u8, spool: *u8, stamp: i64, piece_raw: i64, dcx: *i64) -> i64 { 2563 dcx[0] = 0 2564 dcx[1] = 0 2565 dcx[2] = 0 2566 dcx[3] = 0 2567 dcx[4] = 0 2568 let nn: *i64 = sys_mmap(16) as *i64 2569 let buf: *u8 = sys_map_file(rawpath, nn) 2570 let n: i64 = nn[0] 2571 if n <= 0 { return 0 } 2572 let cellsz: i64 = piece_raw + CH_LINE 2573 let dayn: *u8 = sys_mmap(CH_BT_DAYMAX * CH_BT_DAYCELL) 2574 let dbuf: *u8 = sys_mmap(CH_BT_DAYMAX * cellsz) 2575 let dlen: *i64 = sys_mmap(8 * CH_BT_DAYMAX) as *i64 2576 let dseq: *i64 = sys_mmap(8 * CH_BT_DAYMAX) as *i64 2577 let sp: *i64 = sys_mmap(16) as *i64 2578 let dstr: *u8 = sys_mmap(CH_BT_DAYCELL) 2579 var nd: i64 = 0 2580 var i: i64 = 0 2581 while i < n { 2582 let le: i64 = sj_le(buf, i, n) 2583 if le > i { 2584 var ts: i64 = 0 2585 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]) } } 2586 ch_bt_day(ts, dstr) 2587 if ts <= 0 { dcx[3] = dcx[3] + 1 } 2588 var di: i64 = 0 - 1 2589 var k: i64 = 0 2590 while k < nd { 2591 if ch_bt_zeq(((dayn as i64) + k * CH_BT_DAYCELL) as *u8, dstr) == 1 { di = k; k = nd } else { k = k + 1 } 2592 } 2593 if di < 0 { 2594 if nd >= CH_BT_DAYMAX { sys_munmap(buf, n); return 0 - 2 } 2595 var c3: i64 = 0 2596 var g3: i64 = 1 2597 while g3 == 1 { 2598 let ch: u8 = dstr[c3] 2599 dayn[nd * CH_BT_DAYCELL + c3] = ch 2600 if ch == (0 as u8) { g3 = 0 } else { c3 = c3 + 1 } 2601 } 2602 dlen[nd] = 0 2603 dseq[nd] = 0 2604 di = nd 2605 nd = nd + 1 2606 } 2607 let ll2: i64 = le - i 2608 if dlen[di] + ll2 + 1 > piece_raw { 2609 if dlen[di] > 0 { 2610 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]) 2611 if fr != 0 { sys_munmap(buf, n); return fr } 2612 dcx[0] = dcx[0] + 1 2613 dseq[di] = dseq[di] + 1 2614 dlen[di] = 0 2615 } 2616 } 2617 let cell: *u8 = ((dbuf as i64) + di * cellsz) as *u8 2618 var c4: i64 = 0 2619 while c4 < ll2 { cell[dlen[di] + c4] = buf[i + c4]; c4 = c4 + 1 } 2620 cell[dlen[di] + ll2] = 10 as u8 2621 dlen[di] = dlen[di] + ll2 + 1 2622 dcx[1] = dcx[1] + ll2 + 1 2623 dcx[4] = dcx[4] + 1 2624 } 2625 i = le + 1 2626 } 2627 var k5: i64 = 0 2628 while k5 < nd { 2629 if dlen[k5] > 0 { 2630 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]) 2631 if fr2 != 0 { sys_munmap(buf, n); return fr2 } 2632 dcx[0] = dcx[0] + 1 2633 } 2634 k5 = k5 + 1 2635 } 2636 dcx[2] = nd 2637 sys_munmap(buf, n) 2638 return 0 2639} 2640// copy the day span out of a piece basename cb<day>_... into db (NUL-terminated) 2641func ch_bt_pieceday(pbase: *u8, db: *u8) -> i64 { 2642 var di: i64 = sj_vlen("cb" as *u8) 2643 var o: i64 = 0 2644 var g: i64 = 1 2645 while g == 1 { 2646 let c: u8 = pbase[di] 2647 if c == (95 as u8) { g = 0 } else { 2648 if c == (0 as u8) { g = 0 } else { 2649 if o < CH_BT_DAYCELL - 2 { db[o] = c; o = o + 1 } 2650 di = di + 1 2651 } 2652 } 2653 } 2654 db[o] = 0 as u8 2655 return o 2656} 2657// WHICH STAGE OWNS A FAILED PUSH? Three causes with three DIFFERENT remedies, so three names -- 2658// never one bucket. Until 2026-08-20 an upload that never landed was journalled as "fail-verify", 2659// blaming the verifier for the writer's failure; it cost a real investigation (the artifact was simply 2660// ABSENT and the journal pointed at the wrong leg). 2661// * A MESSAGE THAT NAMES THE WRONG STAGE COSTS THE READER THE INVESTIGATION IT WAS WRITTEN TO SAVE 2662// THEM, and two causes with opposite remedies must never share one counter. 2663// This is a TEXT read, not an rc read, and that is measured, not assumed: nx_fs_write returns rc=0 2664// EVEN WHEN IT REFUSES (`REFUSED would-clobber ... (file unchanged)`), so a guard branching on rc 2665// would never have fired. A would-clobber refusal is ALSO not a failure here -- it is the idempotent 2666// re-push of a piece that already landed, and the hash verify is what adjudicates it, which is why 2667// this function decides from the VERIFY's findings and uses the write's own line only to attribute 2668// the ABSENT case. Pure and total so the gate can walk the whole truth table. 2669// wrote_ok the upload leg printed its own OK line 2670// okr the remote artifact could be hashed at all (0 = nothing is there) 2671// same remote bytes == local bytes 2672func ch_bt_pushreason(wrote_ok: i64, okr: i64, same: i64) -> *u8 { 2673 if okr == 0 { 2674 if wrote_ok == 1 { return "fail-verify-absent" as *u8 } 2675 return "fail-write" as *u8 2676 } 2677 if same == 0 { return "fail-verify-mismatch" as *u8 } 2678 return "ok" as *u8 2679} 2680// push one piece: local-hash -> upload -> remote-hash-verify -> NAS ingest -> journal-fill announce. 2681// Returns 0 = NAS leg confirmed (piece may leave the spool), 1 = left spooled (stage named in the 2682// push journal). Every stage is idempotent: re-upload of a landed piece is refused-then-verified 2683// equal by hash, re-ingest answers ALREADY. Wrong only toward doing nothing. 2684func ch_bt_push1(ppath: *u8, cbuf: *u8, off: *i64, iv: *i64, pjr: *u8, bcx: *i64) -> i64 { 2685 let pbase: *u8 = ch_bt_base(ppath) 2686 let cout: *u8 = sys_mmap(CH_OUT) 2687 let colen: *i64 = sys_mmap(16) as *i64 2688 let lsha: *u8 = sys_mmap(80) 2689 let rsha: *u8 = sys_mmap(80) 2690 let napath: *u8 = sys_mmap(CH_BT_PATHMAX) 2691 let njpath: *u8 = sys_mmap(CH_BT_PATHMAX) 2692 let ob: *u8 = sys_mmap(CH_LINE) 2693 let wire: *u8 = ((cbuf as i64) + off[7]) as *u8 2694 let script: *u8 = ((cbuf as i64) + off[8]) as *u8 2695 let capw: *u8 = ((cbuf as i64) + off[9]) as *u8 2696 let capi: *u8 = ((cbuf as i64) + off[10]) as *u8 2697 let capr: *u8 = ((cbuf as i64) + off[11]) as *u8 2698 let helf: *u8 = ((cbuf as i64) + off[12]) as *u8 2699 let tmo: i64 = iv[3] 2700 let plines: i64 = ch_bt_lines(ppath) 2701 let db2: *u8 = sys_mmap(CH_BT_DAYCELL) 2702 ch_bt_pieceday(pbase, db2) 2703 var o3: i64 = sj_cat(napath, 0, ((cbuf as i64) + off[5]) as *u8) 2704 napath[o3] = 47 as u8 2705 o3 = o3 + 1 2706 o3 = sj_cat(napath, o3, pbase) 2707 napath[o3] = 0 as u8 2708 var o4: i64 = sj_cat(njpath, 0, ((cbuf as i64) + off[6]) as *u8) 2709 njpath[o4] = 47 as u8 2710 o4 = o4 + 1 2711 o4 = sj_cat(njpath, o4, "chbeat_" as *u8) 2712 o4 = sj_cat(njpath, o4, db2) 2713 o4 = sj_cat(njpath, o4, ".jrnl" as *u8) 2714 njpath[o4] = 0 as u8 2715 // 1) local sha -- ONE ruler, nx_filehash, forked on both sides 2716 let hav: *i64 = sys_mmap(32) as *i64 2717 hav[0] = helf as i64 2718 hav[1] = ppath as i64 2719 hav[2] = 0 2720 let hrc: i64 = tr_run_capture_to(helf, hav, cout, CH_OUT - 8, colen, tmo) 2721 var okl: i64 = 0 2722 if hrc == 0 { okl = ch_bt_parse_sha(cout, colen[0], lsha) } 2723 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 } 2724 // 2) upload (@@FILE: substitution puts the piece CONTENT into the write argv); a refusal 2725 // (already-landed / CAS) is decided by the hash verify below -- only a DEAD wire is fatal here 2726 let atf: *u8 = sys_mmap(CH_BT_PATHMAX) 2727 var o5: i64 = sj_cat(atf, 0, "@@FILE:" as *u8) 2728 o5 = sj_cat(atf, o5, ppath) 2729 atf[o5] = 0 as u8 2730 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) 2731 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 } 2732 // the write's OWN verdict, read BEFORE the verify overwrites the shared capture buffer 2733 let wrote_ok: i64 = ch_find(cout, colen[0], "NX-FS-WRITE OK" as *u8) 2734 // 3) remote hash verify -- the artifact, never the receipt 2735 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) 2736 var okr: i64 = 0 2737 if vrc == 0 { okr = ch_bt_parse_sha(cout, colen[0], rsha) } 2738 var same: i64 = 0 2739 if okr == 1 { same = ch_bt_zeq(lsha, rsha) } 2740 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 } 2741 // 4) NAS ingest (ch_ingest server-side: validated, marker-idempotent) 2742 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) 2743 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 } 2744 var infr: i64 = 0 - 1 2745 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) } 2746 let mal: i64 = ch_bt_int_after(cout, colen[0], " malformed=" as *u8) 2747 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 } 2748 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 } 2749 // 5) journal fill announce from the NAS's own size read; an unreadable size is ANNOUNCED, not skipped 2750 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) 2751 var jb2: i64 = 0 - 1 2752 if src2 == 0 { jb2 = ch_bt_int_after(cout, colen[0], "bytes=" as *u8) } 2753 if jb2 >= 0 { 2754 let fill: i64 = jb2 * 1000 / iv[4] 2755 if fill > bcx[28] { bcx[28] = fill } 2756 var o6: i64 = sj_cat(ob, 0, "CHBEAT JOURNAL day=" as *u8) 2757 o6 = sj_cat(ob, o6, db2) 2758 o6 = sj_cat(ob, o6, " nas_bytes=" as *u8) 2759 o6 = sj_catn(ob, o6, jb2) 2760 o6 = sj_cat(ob, o6, " fill_permil=" as *u8) 2761 o6 = sj_catn(ob, o6, fill) 2762 if fill >= 1000 { o6 = sj_cat(ob, o6, " RED-PAST-CLIFF (gauge window truncates: partition finer than a day)" as *u8) } else { 2763 if fill >= iv[5] { o6 = sj_cat(ob, o6, " AMBER-NEAR-CLIFF" as *u8) } 2764 } 2765 ob[o6] = 10 as u8 2766 sys_write(1, ob, o6 + 1) 2767 } else { 2768 var o7: i64 = sj_cat(ob, 0, "CHBEAT JOURNAL day=" as *u8) 2769 o7 = sj_cat(ob, o7, db2) 2770 o7 = sj_cat(ob, o7, " nas_bytes=UNREAD (size call failed; fill unobserved this beat)" as *u8) 2771 ob[o7] = 10 as u8 2772 sys_write(1, ob, o7 + 1) 2773 } 2774 ch_frame_append(pjr, sys_now_realtime_sec(), pbase, "nx_claude_harvest" as *u8, "push" as *u8, "ok" as *u8, njpath) 2775 bcx[21] = bcx[21] + plines 2776 return 0 2777} 2778// ---------- the beat orchestrator ---------- 2779// bcx map (CH_BT_CTRS slots): 2780// 0 files_seen 1 harvested 2 skipped_unchanged 3 errors 4 frames 5 tooluse_marks 6 lines 2781// 7 tooluse_lines 8 head_known 9 head_unknown 10 headless 11 truncated_files 12 pieces_spooled 2782// 13 bytes_staged 14 days_touched 15 tszero_frames 16 push_attempted 17 push_done 18 push_left 2783// 19 spool_remaining 20 local_ingested_frames 21 nas_confirmed_frames 22 local_malformed 2784// 23 census_read_fail 24 walk_dirs 25 walk_direrrs 26 stat_fallbacks 27 partition_ok 2785// 28 worst_journal_fill_permil 29 type_table_overflow 30 raws_recovered 2786func ch_beat(confpath: *u8, bcx: *i64) -> i64 { 2787 var w0: i64 = 0 2788 while w0 < CH_BT_CTRS { bcx[w0] = 0; w0 = w0 + 1 } 2789 let cbuf: *u8 = sys_mmap(CH_CONF_WIN) 2790 let off: *i64 = sys_mmap(128) as *i64 2791 let iv: *i64 = sys_mmap(64) as *i64 2792 let kt: *i64 = sys_mmap(CH_MK_MAX * 16) as *i64 2793 let kcx: *i64 = sys_mmap(16) as *i64 2794 let crc: i64 = ch_bt_conf(confpath, cbuf, off, iv, kt, kcx) 2795 if crc == (0 - 1) { sj_puts("CHBEAT CONF-UNREADABLE (fail closed)\n" as *u8); return 2 } 2796 if crc == (0 - 2) { return 2 } 2797 let root: *u8 = ((cbuf as i64) + off[0]) as *u8 2798 let state: *u8 = ((cbuf as i64) + off[1]) as *u8 2799 let spool: *u8 = ((cbuf as i64) + off[2]) as *u8 2800 let done: *u8 = ((cbuf as i64) + off[3]) as *u8 2801 let jdir: *u8 = ((cbuf as i64) + off[4]) as *u8 2802 sys_mkdir(state, CH_MODE_755) 2803 sys_mkdir(spool, CH_MODE_755) 2804 sys_mkdir(done, CH_MODE_755) 2805 sys_mkdir(jdir, CH_MODE_755) 2806 if iv[0] == 1 { 2807 var pm: i64 = 0 - 1 2808 if off[5] < 0 { pm = 5 } 2809 if off[6] < 0 { if pm < 0 { pm = 6 } } 2810 if off[7] < 0 { if pm < 0 { pm = 7 } } 2811 if off[8] < 0 { if pm < 0 { pm = 8 } } 2812 if off[9] < 0 { if pm < 0 { pm = 9 } } 2813 if off[10] < 0 { if pm < 0 { pm = 10 } } 2814 if off[11] < 0 { if pm < 0 { pm = 11 } } 2815 if off[12] < 0 { if pm < 0 { pm = 12 } } 2816 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 } 2817 } 2818 // MICROSECOND stamp: piece and raw names must be unique ACROSS beats -- a second-resolution stamp 2819 // collided two beats in one second, the truncating rewrite replaced a piece, and the ingest marker 2820 // (keyed on the basename) then silently dropped the replaced frames. Caught by teeth T37/T38. 2821 // Re-split of the SAME raw still reproduces identical names (stamp parsed from the raw's own name). 2822 let now: i64 = sys_now_realtime_us() 2823 let ob: *u8 = sys_mmap(CH_OUT) 2824 let p2: *u8 = sys_mmap(CH_BT_PATHMAX) 2825 let dcx: *i64 = sys_mmap(64) as *i64 2826 // ---- recover: split any crashed raw files left in the spool (deterministic piece names) ---- 2827 let sar: *u8 = sys_mmap(CH_BT_ARENA) 2828 let sfo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64 2829 let swcx: *i64 = sys_mmap(64) as *i64 2830 let ns: i64 = ch_bt_walk(spool, ".frames" as *u8, sar, sfo, swcx) 2831 if ns < 0 { sj_puts("CHBEAT REFUSED spool walk overflow\n" as *u8); return 2 } 2832 var si: i64 = 0 2833 while si < ns { 2834 let sp2: *u8 = ((sar as i64) + sfo[si]) as *u8 2835 let sb2: *u8 = ch_bt_base(sp2) 2836 if ch_starts(sb2, 0, sj_vlen(sb2), "raw_" as *u8) == 1 { 2837 let stamp2: i64 = sj_atoi_z(((sb2 as i64) + sj_vlen("raw_" as *u8)) as *u8) 2838 let rr: i64 = ch_bt_split(sp2, spool, stamp2, iv[2], dcx) 2839 if rr == 0 { 2840 bcx[30] = bcx[30] + 1 2841 ch_bt_path2(p2, done, sb2) 2842 sys_renameat(sp2, p2) 2843 } 2844 } 2845 si = si + 1 2846 } 2847 // ---- walk + delta-harvest EVERY transcript (full population, never a sample) ---- 2848 let ar: *u8 = sys_mmap(CH_BT_ARENA) 2849 let fo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64 2850 let wcx: *i64 = sys_mmap(64) as *i64 2851 let nf: i64 = ch_bt_walk(root, ".jsonl" as *u8, ar, fo, wcx) 2852 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 } 2853 bcx[0] = nf 2854 bcx[24] = wcx[0] 2855 bcx[25] = wcx[1] 2856 bcx[26] = wcx[2] 2857 let rootl: i64 = sj_vlen(root) 2858 let raw: *u8 = sys_mmap(CH_BT_PATHMAX) 2859 var o7: i64 = sj_cat(raw, 0, spool) 2860 raw[o7] = 47 as u8 2861 o7 = o7 + 1 2862 o7 = sj_cat(raw, o7, "raw_" as *u8) 2863 o7 = sj_catn(raw, o7, now) 2864 o7 = sj_cat(raw, o7, ".frames" as *u8) 2865 raw[o7] = 0 as u8 2866 let sbuf: *u8 = sys_mmap(256) 2867 let kk2: *i64 = sys_mmap(16) as *i64 2868 let hcx: *i64 = sys_mmap(64) as *i64 2869 let ccx: *i64 = sys_mmap(64) as *i64 2870 let ua: *u8 = sys_mmap(CH_BT_TYPEMAX * (CH_NAME_MAX + 8)) 2871 let uo: *i64 = sys_mmap(16 * CH_BT_TYPEMAX) as *i64 2872 let ucx: *i64 = sys_mmap(16) as *i64 2873 let hwmp: *u8 = sys_mmap(CH_BT_PATHMAX * 2) 2874 let stem: *u8 = sys_mmap(CH_BT_PATHMAX) 2875 var fi: i64 = 0 2876 while fi < nf { 2877 let tp: *u8 = ((ar as i64) + fo[fi]) as *u8 2878 let rel: *u8 = ((tp as i64) + rootl + 1) as *u8 2879 ch_bt_hwmpath(state, rel, hwmp) 2880 ch_bt_stat(tp, sbuf, kk2) 2881 let hwm0: i64 = ch_hwm_read(hwmp) 2882 var did: i64 = 0 2883 if kk2[1] >= 0 { if kk2[1] == hwm0 { bcx[2] = bcx[2] + 1; did = 1 } } 2884 if did == 0 { 2885 ch_bt_stem(tp, stem) 2886 let dr: i64 = ch_delta(tp, stem, raw, hwmp, hcx) 2887 if dr < 0 { 2888 bcx[3] = bcx[3] + 1 2889 var oe: i64 = sj_cat(ob, 0, "CHBEAT ERR delta rc=" as *u8) 2890 oe = sj_catn(ob, oe, dr) 2891 oe = sj_cat(ob, oe, " file=" as *u8) 2892 oe = sj_cat(ob, oe, tp) 2893 ob[oe] = 10 as u8 2894 sys_write(1, ob, oe + 1) 2895 } else { 2896 bcx[1] = bcx[1] + 1 2897 bcx[4] = bcx[4] + hcx[0] 2898 if hcx[3] == 1 { 2899 bcx[11] = bcx[11] + 1 2900 var ot: i64 = sj_cat(ob, 0, "CHBEAT TRUNC file=" as *u8) 2901 ot = sj_cat(ob, ot, tp) 2902 ob[ot] = 10 as u8 2903 sys_write(1, ob, ot + 1) 2904 } 2905 if hcx[1] > hcx[2] { ch_bt_census(tp, hcx[2], hcx[1], cbuf, kt, kcx[0], ua, uo, ucx, ccx) } 2906 } 2907 } 2908 fi = fi + 1 2909 } 2910 bcx[5] = ccx[2] 2911 bcx[6] = ccx[0] 2912 bcx[7] = ccx[1] 2913 bcx[8] = ccx[3] 2914 bcx[9] = ccx[4] 2915 bcx[10] = ccx[5] 2916 bcx[23] = ccx[6] 2917 bcx[29] = ccx[7] 2918 // ---- split this run's raw into ts-day pieces (the split re-counts what ch_delta emitted: 2919 // two counters over one population = a free audit) ---- 2920 let src: i64 = ch_bt_split(raw, spool, now, iv[2], dcx) 2921 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 } 2922 if src == (0 - 3) { sj_puts("CHBEAT ERR piece write failed\n" as *u8); return 1 } 2923 bcx[12] = dcx[0] 2924 bcx[13] = dcx[1] 2925 bcx[14] = dcx[2] 2926 bcx[15] = dcx[3] 2927 var recon_ok: i64 = 1 2928 if dcx[4] != bcx[4] { recon_ok = 0 } 2929 ch_bt_path2(p2, done, ch_bt_base(raw)) 2930 sys_renameat(raw, p2) 2931 // ---- ingest every spooled piece locally; push up to push_max to the NAS ---- 2932 let par: *u8 = sys_mmap(CH_BT_ARENA) 2933 let pfo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64 2934 let pwcx: *i64 = sys_mmap(64) as *i64 2935 let np: i64 = ch_bt_walk(spool, ".frames" as *u8, par, pfo, pwcx) 2936 if np < 0 { sj_puts("CHBEAT REFUSED spool walk overflow\n" as *u8); return 2 } 2937 let mcx: *i64 = sys_mmap(16) as *i64 2938 let ljp: *u8 = sys_mmap(CH_BT_PATHMAX) 2939 let db3: *u8 = sys_mmap(CH_BT_DAYCELL) 2940 let pjr: *u8 = sys_mmap(CH_BT_PATHMAX) 2941 ch_bt_path2(pjr, state, "push.jrnl" as *u8) 2942 var pi: i64 = 0 2943 while pi < np { 2944 let pp: *u8 = ((par as i64) + pfo[pi]) as *u8 2945 let pb: *u8 = ch_bt_base(pp) 2946 if ch_starts(pb, 0, sj_vlen(pb), "cb" as *u8) == 1 { 2947 ch_bt_pieceday(pb, db3) 2948 var o9: i64 = sj_cat(ljp, 0, jdir) 2949 ljp[o9] = 47 as u8 2950 o9 = o9 + 1 2951 o9 = sj_cat(ljp, o9, "chbeat_" as *u8) 2952 o9 = sj_cat(ljp, o9, db3) 2953 o9 = sj_cat(ljp, o9, ".jrnl" as *u8) 2954 ljp[o9] = 0 as u8 2955 let lr: i64 = ch_ingest(pp, ljp, mcx) 2956 if lr >= 0 { bcx[20] = bcx[20] + lr; bcx[22] = bcx[22] + mcx[0] } 2957 var moved: i64 = 0 2958 if iv[0] == 1 { 2959 if bcx[16] < iv[1] { 2960 bcx[16] = bcx[16] + 1 2961 let prc: i64 = ch_bt_push1(pp, cbuf, off, iv, pjr, bcx) 2962 if prc == 0 { 2963 bcx[17] = bcx[17] + 1 2964 ch_bt_path2(p2, done, pb) 2965 sys_renameat(pp, p2) 2966 moved = 1 2967 } else { bcx[18] = bcx[18] + 1 } 2968 } 2969 } 2970 if moved == 0 { bcx[19] = bcx[19] + 1 } 2971 } 2972 pi = pi + 1 2973 } 2974 // ---- local journal fill (every day journal present, from its own stat; budget rides the conf) ---- 2975 let jar: *u8 = sys_mmap(CH_BT_ARENA) 2976 let jfo: *i64 = sys_mmap(8 * CH_BT_MAXFILES) as *i64 2977 let jwcx: *i64 = sys_mmap(64) as *i64 2978 let nj: i64 = ch_bt_walk(jdir, ".jrnl" as *u8, jar, jfo, jwcx) 2979 var ji: i64 = 0 2980 while ji < nj { 2981 let jp2: *u8 = ((jar as i64) + jfo[ji]) as *u8 2982 ch_bt_stat(jp2, sbuf, kk2) 2983 if kk2[1] >= 0 { 2984 let fill2: i64 = kk2[1] * 1000 / iv[4] 2985 if fill2 > bcx[28] { bcx[28] = fill2 } 2986 if fill2 >= iv[5] { 2987 var oa: i64 = sj_cat(ob, 0, "CHBEAT JOURNAL local=" as *u8) 2988 oa = sj_cat(ob, oa, jp2) 2989 oa = sj_cat(ob, oa, " bytes=" as *u8) 2990 oa = sj_catn(ob, oa, kk2[1]) 2991 oa = sj_cat(ob, oa, " fill_permil=" as *u8) 2992 oa = sj_catn(ob, oa, fill2) 2993 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) } 2994 ob[oa] = 10 as u8 2995 sys_write(1, ob, oa + 1) 2996 } 2997 } 2998 ji = ji + 1 2999 } 3000 // ---- worklists: the reason travels with the count ---- 3001 var ui: i64 = 0 3002 while ui < ucx[0] { 3003 var ou: i64 = sj_cat(ob, 0, "CHBEAT UNKNOWN-TYPE name=" as *u8) 3004 ou = sj_cat(ob, ou, ((ua as i64) + uo[ui * 2]) as *u8) 3005 ou = sj_cat(ob, ou, " count=" as *u8) 3006 ou = sj_catn(ob, ou, uo[ui * 2 + 1]) 3007 ob[ou] = 10 as u8 3008 sys_write(1, ob, ou + 1) 3009 ui = ui + 1 3010 } 3011 if bcx[29] == 1 { sj_puts("CHBEAT UNKNOWN-TYPE table full -- the distinct list above is a FLOOR, not a total\n" as *u8) } 3012 // ---- partitions: print the sums, not just a verdict ---- 3013 var pok: i64 = 1 3014 if bcx[0] != bcx[1] + bcx[2] + bcx[3] { pok = 0 } 3015 if bcx[5] < bcx[4] { pok = 0 } 3016 if bcx[6] != bcx[8] + bcx[9] + bcx[10] { pok = 0 } 3017 if recon_ok == 0 { pok = 0 } 3018 bcx[27] = pok 3019 var op: i64 = sj_cat(ob, 0, "CHBEAT files seen=" as *u8) 3020 op = sj_catn(ob, op, bcx[0]) 3021 op = sj_cat(ob, op, " = harvested=" as *u8) 3022 op = sj_catn(ob, op, bcx[1]) 3023 op = sj_cat(ob, op, " + skipped_unchanged=" as *u8) 3024 op = sj_catn(ob, op, bcx[2]) 3025 op = sj_cat(ob, op, " + errors=" as *u8) 3026 op = sj_catn(ob, op, bcx[3]) 3027 op = sj_cat(ob, op, " (dirs=" as *u8) 3028 op = sj_catn(ob, op, bcx[24]) 3029 op = sj_cat(ob, op, " direrrs=" as *u8) 3030 op = sj_catn(ob, op, bcx[25]) 3031 op = sj_cat(ob, op, " statfb=" as *u8) 3032 op = sj_catn(ob, op, bcx[26]) 3033 op = sj_cat(ob, op, ")" as *u8) 3034 ob[op] = 10 as u8 3035 sys_write(1, ob, op + 1) 3036 op = sj_cat(ob, 0, "CHBEAT frames harvested=" as *u8) 3037 op = sj_catn(ob, op, bcx[4]) 3038 op = sj_cat(ob, op, " split_recount=" as *u8) 3039 op = sj_catn(ob, op, dcx[4]) 3040 op = sj_cat(ob, op, " tooluse_marks=" as *u8) 3041 op = sj_catn(ob, op, bcx[5]) 3042 op = sj_cat(ob, op, " unnamed_tooluse=" as *u8) 3043 op = sj_catn(ob, op, bcx[5] - bcx[4]) 3044 op = sj_cat(ob, op, " tszero=" as *u8) 3045 op = sj_catn(ob, op, bcx[15]) 3046 op = sj_cat(ob, op, " truncated_files=" as *u8) 3047 op = sj_catn(ob, op, bcx[11]) 3048 ob[op] = 10 as u8 3049 sys_write(1, ob, op + 1) 3050 op = sj_cat(ob, 0, "CHBEAT lines=" as *u8) 3051 op = sj_catn(ob, op, bcx[6]) 3052 op = sj_cat(ob, op, " = head_known=" as *u8) 3053 op = sj_catn(ob, op, bcx[8]) 3054 op = sj_cat(ob, op, " + head_unknown=" as *u8) 3055 op = sj_catn(ob, op, bcx[9]) 3056 op = sj_cat(ob, op, " + headless=" as *u8) 3057 op = sj_catn(ob, op, bcx[10]) 3058 op = sj_cat(ob, op, " (tooluse_lines=" as *u8) 3059 op = sj_catn(ob, op, bcx[7]) 3060 op = sj_cat(ob, op, " census_read_fail=" as *u8) 3061 op = sj_catn(ob, op, bcx[23]) 3062 op = sj_cat(ob, op, ")" as *u8) 3063 ob[op] = 10 as u8 3064 sys_write(1, ob, op + 1) 3065 op = sj_cat(ob, 0, "CHBEAT staged pieces=" as *u8) 3066 op = sj_catn(ob, op, bcx[12]) 3067 op = sj_cat(ob, op, " bytes=" as *u8) 3068 op = sj_catn(ob, op, bcx[13]) 3069 op = sj_cat(ob, op, " days=" as *u8) 3070 op = sj_catn(ob, op, bcx[14]) 3071 op = sj_cat(ob, op, " raws_recovered=" as *u8) 3072 op = sj_catn(ob, op, bcx[30]) 3073 op = sj_cat(ob, op, " local_ingested_frames=" as *u8) 3074 op = sj_catn(ob, op, bcx[20]) 3075 op = sj_cat(ob, op, " local_malformed=" as *u8) 3076 op = sj_catn(ob, op, bcx[22]) 3077 ob[op] = 10 as u8 3078 sys_write(1, ob, op + 1) 3079 op = sj_cat(ob, 0, "CHBEAT push attempted=" as *u8) 3080 op = sj_catn(ob, op, bcx[16]) 3081 op = sj_cat(ob, op, " done=" as *u8) 3082 op = sj_catn(ob, op, bcx[17]) 3083 op = sj_cat(ob, op, " left=" as *u8) 3084 op = sj_catn(ob, op, bcx[18]) 3085 op = sj_cat(ob, op, " nas_confirmed_frames=" as *u8) 3086 op = sj_catn(ob, op, bcx[21]) 3087 op = sj_cat(ob, op, " spool_remaining=" as *u8) 3088 op = sj_catn(ob, op, bcx[19]) 3089 if iv[0] == 0 { op = sj_cat(ob, op, " (push=0 staging mode declared)" as *u8) } 3090 ob[op] = 10 as u8 3091 sys_write(1, ob, op + 1) 3092 // LAST LINE (positional readers). A failed push is a PARTIAL beat, never an OK one -- 3093 // the pieces are safe in the spool, but the NAS record is behind and the verdict says so. 3094 var ov: i64 = 0 3095 if pok == 1 { if bcx[3] == 0 { if bcx[18] == 0 { ov = 1 } } } 3096 var ol: i64 = 0 3097 if ov == 1 { ol = sj_cat(ob, 0, "CHBEAT OK" as *u8) } else { ol = sj_cat(ob, 0, "CHBEAT PARTIAL" as *u8) } 3098 ol = sj_cat(ob, ol, " files=" as *u8) 3099 ol = sj_catn(ob, ol, bcx[0]) 3100 ol = sj_cat(ob, ol, " frames=" as *u8) 3101 ol = sj_catn(ob, ol, bcx[4]) 3102 ol = sj_cat(ob, ol, " pieces=" as *u8) 3103 ol = sj_catn(ob, ol, bcx[12]) 3104 ol = sj_cat(ob, ol, " pushed=" as *u8) 3105 ol = sj_catn(ob, ol, bcx[17]) 3106 ol = sj_cat(ob, ol, " spool=" as *u8) 3107 ol = sj_catn(ob, ol, bcx[19]) 3108 ol = sj_cat(ob, ol, " worst_fill_permil=" as *u8) 3109 ol = sj_catn(ob, ol, bcx[28]) 3110 ob[ol] = 10 as u8 3111 sys_write(1, ob, ol + 1) 3112 if ov == 1 { return 0 } 3113 return 1 3114} 3115 3116// ---------- CE1 leg 2: ce_author_health -- seat-written NishiLang joined to its complexity (2026-09-05) ---------- 3117// Frames carry `path=<p>` for writes since ch_frame_note landed. Every UNIQUE .nx path under the tree prefix that a seat 3118// session wrote is scanned ONCE with the complexity ruler (mc_scan_file -- the one ruler nx_mccabe and its gate share), 3119// and the figures are set against the census's LAST spine row so the board can say what share of the estate's 3120// complexity is seat-written. The complement is NOT "human": it is everything the frames cannot attribute -- human- 3121// authored files AND every write before the first path-bearing frame -- and it is named so, never guessed. A seat is 3122// AI at a seat by definition of the transcript. Counters partition and SUM; a path outside the tree or not .nx is 3123// counted apart; an unreadable path is counted apart; an absent spine makes the denominator UNOBSERVABLE (rc 3), a 3124// journal with no path frames is NO-PATH-FRAMES (rc 4) -- neither ever fabricates a number. 3125// (the CH_AH_* consts sit at the top of the file beside the beat consts: the module parser is single-pass and the 3126// selftest teeth read them before this section) 3127func ch_ah_prefix(p: *u8, pre: *u8) -> i64 { 3128 var i: i64 = 0 3129 while pre[i] != (0 as u8) { if p[i] != pre[i] { return 0 } i = i + 1 } 3130 return 1 3131} 3132// n-th TAB-separated field of line [i,le) -> out (NUL-terminated); returns its length, 0 if absent 3133func ch_ah_field_n(buf: *u8, i: i64, le: i64, want: i64, out: *u8, cap: i64) -> i64 { 3134 var f: i64 = 0 3135 var s: i64 = i 3136 var k: i64 = i 3137 var o: i64 = 0 3138 while k <= le { 3139 var endf: i64 = 0 3140 if k == le { endf = 1 } else { if buf[k] == (9 as u8) { endf = 1 } } 3141 if endf == 1 { 3142 if f == want { 3143 var q: i64 = s 3144 while q < k { if o < cap - 1 { out[o] = buf[q]; o = o + 1 } q = q + 1 } 3145 out[o] = 0 as u8 3146 return o 3147 } 3148 f = f + 1 3149 s = k + 1 3150 } 3151 k = k + 1 3152 } 3153 out[0] = 0 as u8 3154 return 0 3155} 3156// linear lookup in a table of NUL-terminated cells; small tables, no second ruler 3157func ch_ah_find(tab: *u8, n: i64, cell: i64, p: *u8) -> i64 { 3158 var k: i64 = 0 3159 while k < n { 3160 let q: *u8 = ((tab as i64) + k*cell) as *u8 3161 if sj_lit_eq(q, 0, sj_vlen(q), p) == 1 { return k } 3162 k = k + 1 3163 } 3164 return 0 - 1 3165} 3166func ch_ah_lastline(buf: *u8, n: i64) -> i64 { 3167 var i: i64 = 0 3168 var last: i64 = 0 - 1 3169 while i < n { let le: i64 = sj_le(buf, i, n); if le > i { last = i } i = le + 1 } 3170 return last 3171} 3172// a BOUNDED digit run: stops at the first non-digit or at `to` (sj_atoi_z concatenates every digit up to the NUL, 3173// so on a `k=10|j=20` row it would read 1020 -- measured, not assumed) 3174func ch_ah_num(buf: *u8, p0: i64, to: i64) -> i64 { 3175 var v: i64 = 0 3176 var p: i64 = p0 3177 var g: i64 = 1 3178 while g == 1 { 3179 if p >= to { g = 0 } else { 3180 let c: i64 = buf[p] as i64 3181 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 } } 3182 } 3183 } 3184 return v 3185} 3186func ch_ah_field(buf: *u8, from: i64, to: i64, key: *u8) -> i64 { 3187 let p: i64 = ch_find_from(buf, from, to, key) 3188 if p < 0 { return 0 - 1 } 3189 return ch_ah_num(buf, p + sj_vlen(key), to) 3190} 3191func ce_author_health(jpath: *u8, pre: *u8, spine: *u8, cx: *i64, ob: *u8) -> i64 { 3192 var z: i64 = 0 3193 while z < CH_AH_CTRS { cx[z] = 0; z = z + 1 } 3194 cx[CH_AH_FIRSTTS] = 0 - 1 3195 let lp: *i64 = sys_mmap(16) as *i64 3196 lp[0] = 0 3197 let jb: *u8 = sys_read_file(jpath, lp) 3198 var jn: i64 = lp[0] 3199 if jn < 0 { jn = 0 } 3200 let tab: *u8 = sys_mmap(CH_AH_MAXPATHS * CH_AH_PATHCELL) 3201 var nt: i64 = 0 3202 let stab: *u8 = sys_mmap(CH_AH_MAXSESS * CH_AH_SESSCELL) 3203 var ns: i64 = 0 3204 let pkey: *u8 = "path=" as *u8 3205 let pkl: i64 = sj_vlen(pkey) 3206 let pc: *u8 = sys_mmap(CH_AH_PATHCELL + 8) 3207 let sc: *u8 = sys_mmap(CH_AH_SESSCELL + 8) 3208 var i: i64 = 0 3209 while i < jn { 3210 let le: i64 = sj_le(jb, i, jn) 3211 if le > i { 3212 cx[CH_AH_FRAMES] = cx[CH_AH_FRAMES] + 1 3213 let pp: i64 = ch_find_from(jb, i, le, pkey) 3214 if pp >= 0 { 3215 cx[CH_AH_PATHFRAMES] = cx[CH_AH_PATHFRAMES] + 1 3216 let ts: i64 = ch_ah_num(jb, i, le) 3217 if cx[CH_AH_FIRSTTS] < 0 { cx[CH_AH_FIRSTTS] = ts } else { if ts < cx[CH_AH_FIRSTTS] { cx[CH_AH_FIRSTTS] = ts } } 3218 let sl: i64 = ch_ah_field_n(jb, i, le, 1, sc, CH_AH_SESSCELL) 3219 if sl > 0 { if ch_ah_find(stab, ns, CH_AH_SESSCELL, sc) < 0 { if ns < CH_AH_MAXSESS { 3220 let scell: *u8 = ((stab as i64) + ns*CH_AH_SESSCELL) as *u8 3221 let scl: i64 = sj_cat(scell, 0, sc) 3222 scell[scl] = 0 as u8 3223 ns = ns + 1 3224 } } } 3225 var pl: i64 = le - (pp + pkl) 3226 if pl > CH_AH_PATHCELL - 1 { pl = CH_AH_PATHCELL - 1 } 3227 var q: i64 = 0 3228 while q < pl { pc[q] = jb[pp + pkl + q]; q = q + 1 } 3229 if pl > 0 { if pc[pl-1] == (13 as u8) { pl = pl - 1 } } 3230 pc[pl] = 0 as u8 3231 if pl > 0 { if ch_ah_find(tab, nt, CH_AH_PATHCELL, pc) < 0 { 3232 if nt < CH_AH_MAXPATHS { 3233 let pcell: *u8 = ((tab as i64) + nt*CH_AH_PATHCELL) as *u8 3234 let pcl: i64 = sj_cat(pcell, 0, pc) 3235 pcell[pcl] = 0 as u8 3236 nt = nt + 1 3237 } else { cx[CH_AH_OVERFLOW] = cx[CH_AH_OVERFLOW] + 1 } 3238 } } 3239 } 3240 } 3241 i = le + 1 3242 } 3243 cx[CH_AH_UNIQUE] = nt 3244 cx[CH_AH_SESSIONS] = ns 3245 let hist: *i64 = sys_mmap(MC_HIST_MAX*8 + 64) as *i64 3246 let mc: *i64 = sys_mmap(MC_C_SLOTS*8) as *i64 3247 let work: *u8 = sys_mmap(MC_WORKCAP) 3248 let wo: *i64 = sys_mmap(16) as *i64 3249 wo[0] = 0 3250 var k: i64 = 0 3251 while k < nt { 3252 let p: *u8 = ((tab as i64) + k*CH_AH_PATHCELL) as *u8 3253 var intree: i64 = 0 3254 if ch_ah_prefix(p, pre) == 1 { if mc_ends_nx(p, sj_vlen(p)) == 1 { intree = 1 } } 3255 if intree == 1 { 3256 cx[CH_AH_INTREE] = cx[CH_AH_INTREE] + 1 3257 let f0: i64 = mc[MC_C_FILES] 3258 let n0: i64 = mc[MC_C_FUNCS] 3259 let s0: i64 = mc[MC_C_SUMVG] 3260 let a0: i64 = mc[MC_C_ABOVE] 3261 mc_scan_file(p, hist, mc, work, wo) 3262 if mc[MC_C_FILES] > f0 { 3263 cx[CH_AH_FILES] = cx[CH_AH_FILES] + 1 3264 cx[CH_AH_FUNCS] = cx[CH_AH_FUNCS] + (mc[MC_C_FUNCS] - n0) 3265 cx[CH_AH_SUMVG] = cx[CH_AH_SUMVG] + (mc[MC_C_SUMVG] - s0) 3266 cx[CH_AH_ABOVE] = cx[CH_AH_ABOVE] + (mc[MC_C_ABOVE] - a0) 3267 } else { cx[CH_AH_UNREAD] = cx[CH_AH_UNREAD] + 1 } 3268 } else { cx[CH_AH_OUTSIDE] = cx[CH_AH_OUTSIDE] + 1 } 3269 k = k + 1 3270 } 3271 let sp: *i64 = sys_mmap(16) as *i64 3272 sp[0] = 0 3273 let sb: *u8 = sys_read_file(spine, sp) 3274 let sn: i64 = sp[0] 3275 var den: i64 = 0 3276 if sn > 0 { 3277 let ls: i64 = ch_ah_lastline(sb, sn) 3278 if ls >= 0 { 3279 let lse: i64 = sj_le(sb, ls, sn) 3280 cx[CH_AH_DTS] = ch_ah_num(sb, ls, lse) 3281 cx[CH_AH_DFILES] = ch_ah_field(sb, ls, lse, "files=" as *u8) 3282 cx[CH_AH_DFUNCS] = ch_ah_field(sb, ls, lse, "funcs=" as *u8) 3283 cx[CH_AH_DABOVE] = ch_ah_field(sb, ls, lse, "above_10=" as *u8) 3284 if cx[CH_AH_DFILES] > 0 { den = 1 } 3285 } 3286 } 3287 if den == 0 { cx[CH_AH_DFILES] = 0; cx[CH_AH_DFUNCS] = 0; cx[CH_AH_DABOVE] = 0 } 3288 var rc: i64 = 0 3289 if cx[CH_AH_PATHFRAMES] == 0 { rc = CH_AH_RC_NOPATH } else { if den == 0 { rc = CH_AH_RC_UNOBS } } 3290 var o: i64 = 0 3291 o = sj_cat(ob, o, "=== NX-AUTHOR-HEALTH -- seat-written NishiLang joined to its complexity (codeeffectiveness CE1 leg 2) ===\n" as *u8) 3292 o = sj_cat(ob, o, " journal=" as *u8); o = sj_cat(ob, o, jpath) 3293 o = sj_cat(ob, o, " frames=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FRAMES]) 3294 o = sj_cat(ob, o, " path_frames=" as *u8); o = sj_catn(ob, o, cx[CH_AH_PATHFRAMES]) 3295 o = sj_cat(ob, o, " unique_paths=" as *u8); o = sj_catn(ob, o, cx[CH_AH_UNIQUE]) 3296 o = sj_cat(ob, o, " nx_in_tree=" as *u8); o = sj_catn(ob, o, cx[CH_AH_INTREE]) 3297 o = sj_cat(ob, o, " outside_tree_or_not_nx=" as *u8); o = sj_catn(ob, o, cx[CH_AH_OUTSIDE]) 3298 o = sj_cat(ob, o, " unreadable=" as *u8); o = sj_catn(ob, o, cx[CH_AH_UNREAD]) 3299 o = sj_cat(ob, o, " overflow=" as *u8); o = sj_catn(ob, o, cx[CH_AH_OVERFLOW]) 3300 o = sj_cat(ob, o, " sessions=" as *u8); o = sj_catn(ob, o, cx[CH_AH_SESSIONS]) 3301 o = sj_cat(ob, o, " first_path_frame_ts=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FIRSTTS]) 3302 o = sj_cat(ob, o, "\n tree=" as *u8); o = sj_cat(ob, o, pre) 3303 o = sj_cat(ob, o, "\n seat_written: files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FILES]) 3304 o = sj_cat(ob, o, " funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FUNCS]) 3305 o = sj_cat(ob, o, " sum_vG=" as *u8); o = sj_catn(ob, o, cx[CH_AH_SUMVG]) 3306 o = sj_cat(ob, o, " above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_ABOVE]) 3307 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]) } 3308 if den == 1 { 3309 o = sj_cat(ob, o, "\n denominator (mccabe spine row ts=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DTS]) 3310 o = sj_cat(ob, o, "): files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFILES]) 3311 o = sj_cat(ob, o, " funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFUNCS]) 3312 o = sj_cat(ob, o, " above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DABOVE]) 3313 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]) 3314 o = sj_cat(ob, o, " funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFUNCS] - cx[CH_AH_FUNCS]) 3315 o = sj_cat(ob, o, " above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DABOVE] - cx[CH_AH_ABOVE]) 3316 o = sj_cat(ob, o, " (human-authored PLUS every write before ts=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FIRSTTS]) 3317 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) 3318 } else { 3319 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) 3320 } 3321 o = sj_cat(ob, o, "NX-AUTHOR-HEALTH frames=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FRAMES]) 3322 o = sj_cat(ob, o, " path_frames=" as *u8); o = sj_catn(ob, o, cx[CH_AH_PATHFRAMES]) 3323 o = sj_cat(ob, o, " unique_paths=" as *u8); o = sj_catn(ob, o, cx[CH_AH_UNIQUE]) 3324 o = sj_cat(ob, o, " seat_files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FILES]) 3325 o = sj_cat(ob, o, " seat_funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_FUNCS]) 3326 o = sj_cat(ob, o, " seat_above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_ABOVE]) 3327 o = sj_cat(ob, o, " den_files=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFILES]) 3328 o = sj_cat(ob, o, " den_funcs=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DFUNCS]) 3329 o = sj_cat(ob, o, " den_above_10=" as *u8); o = sj_catn(ob, o, cx[CH_AH_DABOVE]) 3330 o = sj_cat(ob, o, " verdict=" as *u8) 3331 if rc == 0 { o = sj_cat(ob, o, "MEASURED" as *u8) } 3332 if rc == CH_AH_RC_UNOBS { o = sj_cat(ob, o, "UNOBSERVABLE-DENOMINATOR" as *u8) } 3333 if rc == CH_AH_RC_NOPATH { o = sj_cat(ob, o, "NO-PATH-FRAMES" as *u8) } 3334 o = sj_cat(ob, o, "\n" as *u8) 3335 ob[o] = 0 as u8 3336 return rc 3337} 3338 3339func main(argc: i64, argv: *i64) -> i64 { 3340 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 } 3341 let verb: *u8 = argv[1] as *u8 3342 let vl: i64 = sj_vlen(verb) 3343 if sj_lit_eq(verb, 0, vl, "selftest" as *u8) == 1 { 3344 let rc: i64 = ch_selftest(argv[2] as *u8) 3345 sys_exit(rc) 3346 return rc 3347 } 3348 if sj_lit_eq(verb, 0, vl, "authorhealth" as *u8) == 1 { 3349 if argc < 3 { sj_puts("authorhealth needs <journal> [treeprefix] [spine]\n" as *u8); sys_exit(2); return 2 } 3350 var ahpre: *u8 = CH_AH_TREE as *u8 3351 if argc >= 4 { ahpre = argv[3] as *u8 } 3352 var ahspn: *u8 = CH_AH_SPINE as *u8 3353 if argc >= 5 { ahspn = argv[4] as *u8 } 3354 let acx: *i64 = sys_mmap(8 * CH_AH_CTRS) as *i64 3355 let aob: *u8 = sys_mmap(CH_OUT) 3356 let arc: i64 = ce_author_health(argv[2] as *u8, ahpre, ahspn, acx, aob) 3357 sys_write(1, aob, sj_vlen(aob)) 3358 let ahfd: i64 = sys_openat_wr(CH_AH_STATUS as *u8, CH_MODE_644) 3359 if ahfd >= 0 { sys_write(ahfd, aob, sj_vlen(aob)); sys_close(ahfd) } 3360 sys_exit(arc) 3361 return arc 3362 } 3363 if sj_lit_eq(verb, 0, vl, "classes" as *u8) == 1 { 3364 let dc: *u8 = sys_mmap(CH_OUT) 3365 let dcl: i64 = ch_classes(argv[2] as *u8, dc) 3366 sys_write(1, dc, dcl) 3367 sys_exit(0) 3368 return 0 3369 } 3370 if sj_lit_eq(verb, 0, vl, "journal" as *u8) == 1 { 3371 if argc < 5 { sj_puts("journal needs <journal> <planpath> <rung>\n" as *u8); sys_exit(2); return 2 } 3372 let rj: i64 = ch_journal(argv[2] as *u8, argv[3] as *u8, argv[4] as *u8) 3373 if rj == 0 { sj_puts("JOURNAL OK one measure row appended\n" as *u8) } 3374 if rj == 4 { sj_puts("JOURNAL ALREADY today (idempotent, plan unchanged)\n" as *u8) } 3375 if rj == 5 { sj_puts("JOURNAL REFUSED insufficient data (no claude actions) -- nothing written\n" as *u8) } 3376 if rj == 1 { sj_puts("JOURNAL FAIL plan missing or unwritable (a beat never creates a plan)\n" as *u8) } 3377 sys_exit(rj) 3378 return rj 3379 } 3380 if sj_lit_eq(verb, 0, vl, "beat" as *u8) == 1 { 3381 let bcx: *i64 = sys_mmap(8 * CH_BT_CTRS) as *i64 3382 let rc: i64 = ch_beat(argv[2] as *u8, bcx) 3383 sys_exit(rc) 3384 return rc 3385 } 3386 if sj_lit_eq(verb, 0, vl, "bootgauge" as *u8) == 1 { 3387 var k: i64 = 3 3388 if argc >= 4 { let kz: i64 = sj_atoi_z(argv[3] as *u8); if kz > 0 { k = kz } } 3389 let d: *u8 = sys_mmap(CH_OUT) 3390 let dl: i64 = ch_bootgauge(argv[2] as *u8, k, d) 3391 sys_write(1, d, dl) 3392 sys_exit(0) 3393 return 0 3394 } 3395 if sj_lit_eq(verb, 0, vl, "learn" as *u8) == 1 { 3396 if argc < 6 { sj_puts("learn needs <transcript.jsonl> <ws> <outfile> <markersconf>\n" as *u8); sys_exit(2); return 2 } 3397 let lcx: *i64 = sys_mmap(64) as *i64 3398 let lg: i64 = ch_learn(argv[2] as *u8, argv[3] as *u8, argv[4] as *u8, argv[5] as *u8, lcx) 3399 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 } 3400 let ob4: *u8 = sys_mmap(256) 3401 var o4: i64 = sj_cat(ob4, 0, "LEARN OK kept=" as *u8) 3402 o4 = sj_catn(ob4, o4, lg) 3403 o4 = sj_cat(ob4, o4, " markers=" as *u8) 3404 o4 = sj_catn(ob4, o4, lcx[1]) 3405 o4 = sj_cat(ob4, o4, " truncated=" as *u8) 3406 o4 = sj_catn(ob4, o4, lcx[0]) 3407 ob4[o4] = 10 as u8 3408 sys_write(1, ob4, o4 + 1) 3409 sys_exit(0) 3410 return 0 3411 } 3412 if sj_lit_eq(verb, 0, vl, "frames" as *u8) == 1 { 3413 if argc < 5 { sj_puts("frames needs <transcript.jsonl> <ws> <outjournal>\n" as *u8); sys_exit(2); return 2 } 3414 let tcx: *i64 = sys_mmap(16) as *i64 3415 let got: i64 = ch_frames(argv[2] as *u8, argv[3] as *u8, argv[4] as *u8, tcx) 3416 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 } 3417 let ob: *u8 = sys_mmap(256) 3418 var oo: i64 = sj_cat(ob, 0, "HARVEST OK frames=" as *u8) 3419 oo = sj_catn(ob, oo, got) 3420 oo = sj_cat(ob, oo, " truncated=" as *u8) 3421 oo = sj_catn(ob, oo, tcx[0]) 3422 ob[oo] = 10 as u8 3423 sys_write(1, ob, oo + 1) 3424 sys_exit(0) 3425 return 0 3426 } 3427 if sj_lit_eq(verb, 0, vl, "ingest" as *u8) == 1 { 3428 if argc < 4 { sj_puts("ingest needs <framesfile> <journal>\n" as *u8); sys_exit(2); return 2 } 3429 let mcx: *i64 = sys_mmap(16) as *i64 3430 let r: i64 = ch_ingest(argv[2] as *u8, argv[3] as *u8, mcx) 3431 if r == (0 - 2) { sj_puts("ALREADY-INGESTED (marker present, journal untouched)\n" as *u8); sys_exit(0); return 0 } 3432 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 } 3433 let ob2: *u8 = sys_mmap(256) 3434 var o2: i64 = sj_cat(ob2, 0, "INGEST OK frames=" as *u8) 3435 o2 = sj_catn(ob2, o2, r) 3436 o2 = sj_cat(ob2, o2, " malformed=" as *u8) 3437 o2 = sj_catn(ob2, o2, mcx[0]) 3438 ob2[o2] = 10 as u8 3439 sys_write(1, ob2, o2 + 1) 3440 sys_exit(0) 3441 return 0 3442 } 3443 if sj_lit_eq(verb, 0, vl, "gauge" as *u8) == 1 { 3444 var days: i64 = 0 3445 if argc >= 4 { days = sj_atoi_z(argv[3] as *u8) } 3446 let d: *u8 = sys_mmap(CH_OUT) 3447 let dl: i64 = ch_gauge_json(argv[2] as *u8, days, d) 3448 sys_write(1, d, dl) 3449 if ch_find(d, dl, "\"evidence_state\":\"source_open_failed\"" as *u8) == 1 { sys_exit(CH_AH_RC_UNOBS); return CH_AH_RC_UNOBS } 3450 sys_exit(0) 3451 return 0 3452 } 3453 if sj_lit_eq(verb, 0, vl, "page" as *u8) == 1 { 3454 if argc < 4 { sj_puts("page needs <journal> <outfile> [days]\n" as *u8); sys_exit(2); return 2 } 3455 var days2: i64 = 0 3456 if argc >= 5 { days2 = sj_atoi_z(argv[4] as *u8) } 3457 let rp: i64 = ch_page(argv[2] as *u8, argv[3] as *u8, days2) 3458 if rp != 0 { sj_puts("PAGE FAIL\n" as *u8); sys_exit(1); return 1 } 3459 sj_puts("PAGE OK\n" as *u8) 3460 sys_exit(0) 3461 return 0 3462 } 3463 if sj_lit_eq(verb, 0, vl, "delta" as *u8) == 1 { 3464 if argc < 6 { sj_puts("delta needs <transcript.jsonl> <ws> <outjournal> <hwmfile>\n" as *u8); sys_exit(2); return 2 } 3465 let hcx: *i64 = sys_mmap(64) as *i64 3466 let r: i64 = ch_delta(argv[2] as *u8, argv[3] as *u8, argv[4] as *u8, argv[5] as *u8, hcx) 3467 if r < 0 { sj_puts("DELTA FAIL (missing transcript or unwritable journal)\n" as *u8); sys_exit(1); return 1 } 3468 let ob: *u8 = sys_mmap(256) 3469 var oo: i64 = sj_cat(ob, 0, "DELTA OK frames=" as *u8) 3470 oo = sj_catn(ob, oo, hcx[0]) 3471 oo = sj_cat(ob, oo, " from_hwm=" as *u8) 3472 oo = sj_catn(ob, oo, hcx[2]) 3473 oo = sj_cat(ob, oo, " new_hwm=" as *u8) 3474 oo = sj_catn(ob, oo, hcx[1]) 3475 oo = sj_cat(ob, oo, " truncated=" as *u8) 3476 oo = sj_catn(ob, oo, hcx[3]) 3477 ob[oo] = 10 as u8 3478 sys_write(1, ob, oo + 1) 3479 sys_exit(0) 3480 return 0 3481 } 3482 if sj_lit_eq(verb, 0, vl, "propose" as *u8) == 1 { 3483 if argc < 5 { sj_puts("propose needs <journal> <intake_jrnl> <threshold_permil> [filer]\n" as *u8); sys_exit(2); return 2 } 3484 let thr: i64 = sj_atoi_z(argv[4] as *u8) 3485 let filer: *u8 = sys_mmap(128) 3486 var fo: i64 = 0 3487 if argc >= 6 { fo = sj_cat(filer, 0, argv[5] as *u8) } else { fo = sj_cat(filer, 0, "nx_pm_intake" as *u8) } 3488 filer[fo] = 0 as u8 3489 let co: *u8 = sys_mmap(CH_OUT) 3490 let cl: *i64 = sys_mmap(16) as *i64 3491 let r: i64 = ch_propose(argv[2] as *u8, argv[3] as *u8, thr, filer, co, cl) 3492 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 } 3493 if r == 2 { sj_puts("BELOW-THRESHOLD\n" as *u8); sys_exit(0); return 0 } 3494 if r == 4 { sj_puts("ALREADY-PROPOSED (marker present)\n" as *u8); sys_exit(0); return 0 } 3495 if r == 5 { sj_puts("SKIP-INSUFFICIENT (no frames)\n" as *u8); sys_exit(0); return 0 } 3496 if r == 3 { sj_puts("REFUSED intake window exceeded\n" as *u8); sys_exit(3); return 3 } 3497 sj_puts("PROPOSE FAIL (filer)\n" as *u8) 3498 sys_exit(1) 3499 return 1 3500 } 3501 sj_puts("unknown verb\n" as *u8) 3502 sys_exit(2) 3503 return 2 3504}