nx_capability_no_regression.nx source

1// nx_capability_no_regression.nx -- the NO-REGRESSION SAFEGUARD (operator: "a no regression safeguard"). As we 2// climb the family tree into perfect objects, we must NEVER lose ground. Three guards, ratcheted/verified: 3// (1) PERFECT count is a FLOOR (up-only): the climbed-capability count may rise or hold, never DROP (a 4// frontier object un-climbing = regression). Reads `perfect=` from the capability_audit.log. 5// (2) COLLISIONS is a CEILING (down-only): un-consolidated generations may fall or hold, never RISE (new 6// sprawl = regression). Reads `collisions=`. 7// (3) NO FUNCTIONALITY LOST: the merge-verification gates (nx_cidr_gate, nx_aec) must stay GREEN -- if a 8// consolidation ever drops a capability, its union-gate goes RED and this trips. This is the deepest guard. 9// Floors/ceilings persist in the sovereign seg_store. Run standing (conductor pulse) = the gains can't erode. 10// license_tier: ORIGINAL 11import "nx_seg_store.nx" 12import "nx_syscalls.nx" 13const NR_MAGIC_1048576: i64 = 1048576 14const NR_MAGIC_1048560: i64 = 1048560 15 16const NR_STORE: *u8 = "knowledge/store/cap-no-regress" 17const NR_LOG: *u8 = "knowledge/status/capability_audit.log" 18const NR_RUNNER: *u8 = "_offc/nx_sov_build_run.elf" 19const NR_NONE: i64 = 0 - 2000000000 // sentinel: no baseline yet 20 21// read the LATEST "key<digits>" integer in the audit log (key e.g. "perfect=" / "collisions="). -1 if absent. 22func nr_metric(key: *u8) -> i64 { 23 let fd: i64=sys_openat_rd(NR_LOG); if fd<0 { return 0-1 } 24 let buf: *u8=sys_mmap(NR_MAGIC_1048576); var n: i64=0; var go: i64=1 25 while go==1 { let r: i64=sys_read(fd, (buf as i64 + n) as *u8, NR_MAGIC_1048560-n); if r<=0 {go=0} else {n=n+r} if n>=NR_MAGIC_1048560 {go=0} } 26 sys_close(fd) 27 var kl: i64=0; while key[kl]!=(0 as u8){kl=kl+1} 28 var last: i64=0-1; var i: i64=0 29 while i+kl<=n { 30 var k: i64=0; var hit: i64=1 31 while k<kl { if buf[i+k]!=key[k] {hit=0;k=kl} else {k=k+1} } 32 if hit==1 { var p: i64=i+kl; var v: i64=0; var any: i64=0; while p<n { if buf[p]<(48 as u8){p=n} else { if buf[p]>(57 as u8){p=n} else {v=v*10+((buf[p] as i64)-48);p=p+1;any=1} } } if any==1 {last=v} } 33 i=i+1 34 } 35 return last 36} 37 38// PERFECT is a FLOOR (up-only): reg if current < floor; ratchet floor UP. COLLISIONS is a CEILING (down-only): 39// reg if current > ceil; ratchet ceil DOWN. 40func nr_floor_step(floor: i64, current: i64, reg_out: *i64) -> i64 { 41 if floor == NR_NONE { reg_out[0]=0; return current } 42 if current < floor { reg_out[0]=1; return floor } 43 reg_out[0]=0; if current > floor { return current } return floor 44} 45func nr_ceil_step(ceil: i64, current: i64, reg_out: *i64) -> i64 { 46 if ceil == NR_NONE { reg_out[0]=0; return current } 47 if current > ceil { reg_out[0]=1; return ceil } 48 reg_out[0]=0; if current < ceil { return current } return ceil 49} 50 51func nr_get(axis: *u8) -> i64 { 52 let h: *i64=ss_open(NR_STORE); if (h as i64)==0 { return NR_NONE } 53 let pq: *i64=sys_mmap(16) as *i64; let lq: *i64=sys_mmap(16) as *i64 54 if ss_hget(h, axis, pq, lq)!=1 { return NR_NONE } 55 let cp: *u8=pq[0] as *u8; var v: i64=0; var i: i64=0; while i<lq[0]{v=v*10+((cp[i] as i64)-48);i=i+1} return v 56} 57// ★SIGN FIX 2026-08-07 (estate-wide sweep). Digits are pushed into t[] least-significant-first and 58// copied out REVERSED, so appending '-' as the LAST element of t makes it emerge FIRST -- and every 59// index expression (out[k]=t[nn-1-k], return nn) stays correct with nn incremented. This one uses nn 60// where the other 393 sites use k, which is why it was the residue of the mechanical sweep. 61func nr_itoa(v: i64, out: *u8) -> i64 { var m: i64=v; var neg9: i64=0; if m<0{m=0-m;neg9=1} var k: i64=0; if m==0{out[0]=48 as u8;return 1} let t: *u8=sys_mmap(24); var nn: i64=0; while m>0{t[nn]=(48+(m%10)) as u8;m=m/10;nn=nn+1} if neg9==1{t[nn]=45 as u8;nn=nn+1} while k<nn{out[k]=t[nn-1-k];k=k+1} return nn } 62func nr_set_all(perfect_floor: i64, collision_ceil: i64) -> i64 { 63 let w: *i64=ss_begin() 64 let bp: *u8=sys_mmap(24); let lp: i64=nr_itoa(perfect_floor, bp); ss_add(w, 1, "floor:perfect" as *u8, bp, lp) 65 let bc: *u8=sys_mmap(24); let lc: i64=nr_itoa(collision_ceil, bc); ss_add(w, 1, "ceil:collisions" as *u8, bc, lc) 66 ss_commit(NR_STORE, w, sys_now_realtime_sec()); return 0 67} 68 69// fork the sovereign runner on `gate`; 0 = GREEN. 70func nr_run_gate(gate: *u8) -> i64 { 71 let pid: i64=sys_fork() 72 if pid==0 { 73 let dn: i64=sys_openat_wr("/dev/null\x00" as *u8, 420); if dn>=0 { sys_dup3(dn,1,0); sys_dup3(dn,2,0) } 74 let argv: *i64=sys_mmap(64) as *i64; argv[0]=NR_RUNNER as i64; argv[1]=gate as i64; argv[2]=0 75 let envp: *i64=sys_mmap(16) as *i64; envp[0]="PATH=/usr/bin:/bin" as *u8 as i64; envp[1]=0 76 sys_execve(NR_RUNNER, argv, envp); sys_exit(127) 77 } 78 let st: *i64=sys_mmap(16) as *i64; sys_wait4(pid, st, 0); return (st[0]>>8)&0xff 79} 80// the merge-verification gates must stay GREEN = NO functionality lost in any consolidation. 1 = all green. 81func nr_gates_green() -> i64 { 82 if nr_run_gate("nx_cidr_gate\x00" as *u8) != 0 { return 0 } 83 if nr_run_gate("nx_aec\x00" as *u8) != 0 { return 0 } 84 return 1 85} 86 87// THE SAFEGUARD: ratchet perfect (floor) + collisions (ceiling), write back; reg_out bitmask (bit0=perfect-drop 88// bit1=collision-rise). returns 1 = no regression on the counts | 0 = regressed. (gates-green is checked separately.) 89func nr_check(perfect: i64, collisions: i64, reg_out: *i64) -> i64 { 90 let pf: i64=nr_get("floor:perfect" as *u8); let cc: i64=nr_get("ceil:collisions" as *u8) 91 let rp: *i64=sys_mmap(16) as *i64; let rc: *i64=sys_mmap(16) as *i64 92 let np: i64=nr_floor_step(pf, perfect, rp); let nc: i64=nr_ceil_step(cc, collisions, rc) 93 nr_set_all(np, nc) 94 var reg: i64=0; if rp[0]==1 { reg=reg|1 } if rc[0]==1 { reg=reg|2 } 95 reg_out[0]=reg 96 if reg==0 { return 1 } return 0 97}