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

1// nx_govern_sweep.nx -- gov lane (F750). Governance sweep: reads a supervisor log TAIL and counts
2// respawn events = the CRASH-LOOP signature (a job dying instantly and respawned forever with NO
3// backoff) -- the anti-pattern vs the SOTA Kubernetes reconciliation loop (observe->compare-to-desired
4// ->correct with EXPONENTIAL BACKOFF; requeue on repeated failure). Detect-and-report, fail-closed on
5// ungoverned churn. Declares its window (scale-law). No hardware writes (Rule 26).
6//   nx_govern_sweep respawns <logpath> [threshold]
7// exit: 0 GOVERNED | 3 UNGOVERNED (crash-loop: respawns>threshold) | 4 ABSENT | 2 usage.
8// license_tier: ORIGINAL   expect_exit: 0
9import "nx_syscalls.nx"
10import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
11const K_MAGIC_262144: i64 = 262144
12
13func gv_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
14// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
15// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
16// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
17// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
18func gv_wn(fd: i64, v: i64) -> i64 { nxi_fd(fd, v); return 0 }
19func gv_atoi(s: *u8) -> i64 { var v: i64 = 0; var i: i64 = 0; while s[i] != (0 as u8) { let c: i64 = s[i]; if c < 48 { i = i + 1 } else { if c > 57 { i = i + 1 } else { v = v * 10 + (c - 48); i = i + 1 } } } return v }
20func gv_tail(path: *u8, buf: *u8, win: i64) -> i64 {
21    let fd: i64 = sys_openat_rd(path)
22    if fd < 0 { return 0 - 1 }
23    let sz: i64 = sys_lseek(fd, 0, 2)
24    var start: i64 = 0
25    if sz > win { start = sz - win }
26    sys_lseek(fd, start, 0)
27    var n: i64 = 0
28    var go: i64 = 1
29    while go == 1 { let r: i64 = sys_read(fd, (buf as i64 + n) as *u8, win - n); if r <= 0 { go = 0 } else { n = n + r } if n >= win { go = 0 } }
30    sys_close(fd)
31    return n
32}
33func gv_count(buf: *u8, n: i64, pat: *u8) -> i64 {
34    var pl: i64 = 0
35    while pat[pl] != (0 as u8) { pl = pl + 1 }
36    if pl == 0 { return 0 }
37    var c: i64 = 0
38    var i: i64 = 0
39    while i + pl <= n {
40        var k: i64 = 0
41        var m: i64 = 1
42        while k < pl { if buf[i + k] != pat[k] { m = 0; k = pl } else { k = k + 1 } }
43        if m == 1 { c = c + 1; i = i + pl } else { i = i + 1 }
44    }
45    return c
46}
47func main(argc: i64, argv: *i64) -> i64 {
48    if argc < 3 { gv_w(2, "usage: nx_govern_sweep respawns <logpath> [threshold]\n" as *u8); sys_exit(2); return 2 }
49    let logpath: *u8 = argv[2] as *u8
50    var thr: i64 = 20
51    if argc >= 4 { thr = gv_atoi(argv[3] as *u8) }
52    let win: i64 = K_MAGIC_262144
53    let buf: *u8 = sys_mmap(win + 16)
54    let n: i64 = gv_tail(logpath, buf, win)
55    if n < 0 { gv_w(1, "GOVERN-SWEEP verdict=ABSENT path=" as *u8); gv_w(1, logpath); gv_w(1, "\n" as *u8); sys_exit(4); return 4 }
56    let cnt: i64 = gv_count(buf, n, "-> respawn" as *u8)
57    gv_w(1, "GOVERN-SWEEP respawns=" as *u8); gv_wn(1, cnt)
58    gv_w(1, " threshold=" as *u8); gv_wn(1, thr)
59    gv_w(1, " window_bytes=" as *u8); gv_wn(1, n)
60    if cnt > thr {
61        gv_w(1, " verdict=UNGOVERNED (crash-loop: respawn WITHOUT backoff -- vs K8s reconcile exp-backoff SOTA; add circuit-breaker/quarantine)\n" as *u8)
62        sys_exit(3)
63        return 3
64    }
65    gv_w(1, " verdict=GOVERNED\n" as *u8)
66    sys_exit(0)
67    return 0
68}
nx_govern_sweep.nx source

`nx_govern_sweep.nx` source
