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} 57func nr_itoa(v: i64, out: *u8) -> i64 { var m: i64=v; if m<0{m=0-m} 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} while k<nn{out[k]=t[nn-1-k];k=k+1} return nn } 58func nr_set_all(perfect_floor: i64, collision_ceil: i64) -> i64 { 59 let w: *i64=ss_begin() 60 let bp: *u8=sys_mmap(24); let lp: i64=nr_itoa(perfect_floor, bp); ss_add(w, 1, "floor:perfect" as *u8, bp, lp) 61 let bc: *u8=sys_mmap(24); let lc: i64=nr_itoa(collision_ceil, bc); ss_add(w, 1, "ceil:collisions" as *u8, bc, lc) 62 ss_commit(NR_STORE, w, sys_now_realtime_sec()); return 0 63} 64 65// fork the sovereign runner on `gate`; 0 = GREEN. 66func nr_run_gate(gate: *u8) -> i64 { 67 let pid: i64=sys_fork() 68 if pid==0 { 69 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) } 70 let argv: *i64=sys_mmap(64) as *i64; argv[0]=NR_RUNNER as i64; argv[1]=gate as i64; argv[2]=0 71 let envp: *i64=sys_mmap(16) as *i64; envp[0]="PATH=/usr/bin:/bin" as *u8 as i64; envp[1]=0 72 sys_execve(NR_RUNNER, argv, envp); sys_exit(127) 73 } 74 let st: *i64=sys_mmap(16) as *i64; sys_wait4(pid, st, 0); return (st[0]>>8)&0xff 75} 76// the merge-verification gates must stay GREEN = NO functionality lost in any consolidation. 1 = all green. 77func nr_gates_green() -> i64 { 78 if nr_run_gate("nx_cidr_gate\x00" as *u8) != 0 { return 0 } 79 if nr_run_gate("nx_aec\x00" as *u8) != 0 { return 0 } 80 return 1 81} 82 83// THE SAFEGUARD: ratchet perfect (floor) + collisions (ceiling), write back; reg_out bitmask (bit0=perfect-drop 84// bit1=collision-rise). returns 1 = no regression on the counts | 0 = regressed. (gates-green is checked separately.) 85func nr_check(perfect: i64, collisions: i64, reg_out: *i64) -> i64 { 86 let pf: i64=nr_get("floor:perfect" as *u8); let cc: i64=nr_get("ceil:collisions" as *u8) 87 let rp: *i64=sys_mmap(16) as *i64; let rc: *i64=sys_mmap(16) as *i64 88 let np: i64=nr_floor_step(pf, perfect, rp); let nc: i64=nr_ceil_step(cc, collisions, rc) 89 nr_set_all(np, nc) 90 var reg: i64=0; if rp[0]==1 { reg=reg|1 } if rc[0]==1 { reg=reg|2 } 91 reg_out[0]=reg 92 if reg==0 { return 1 } return 0 93}