nx_autonomy_growth_monitor.nx source

1// nx_autonomy_growth_monitor.nx -- Measures team progress from tutor-authored to self-authored code, identifies bottlenecks, and tracks growth trajectory. 2import "nx_gate_gn.nx" 3import "nx_gate_base.nx" 4// nx_autonomy_growth_monitor.nx -- S-CLASS GROWTH OBSERVABILITY for autonomy (operator: "get it really s-class 5// exceed on how the growth is going and where roadblocks/slowdowns are, like how AI evolved from bad to realistic 6// and growing"). This is NOT another capability -- it is the INSTRUMENT that measures the team's march from 7// tutor-authored -> self-authored, names the BOTTLENECKS quantitatively, projects the trajectory, places us on the 8// bad->realistic->growing curve, and LIAR-KILLS hype. Reads the REAL ledgers (cap_registry_durable.log author 9// tags + autonomy_meter.log history). Honest by construction: every number is read, never asserted. 10// license_tier: ORIGINAL 11import "nx_syscalls.nx" 12const K_MAGIC_2097152: i64 = 2097152 13const K_MAGIC_2097100: i64 = 2097100 14const K_MAGIC_1048576: i64 = 1048576 15const K_MAGIC_1048500: i64 = 1048500 16 17func grow(name: *u8, ok: i64) -> i64 { if ok==1 { gw(" PASS " as *u8) } else { gw(" FAIL " as *u8) } gw(name); gw(" 18" as *u8); return ok } 19func rd(path: *u8, buf: *u8, cap: i64) -> i64 { 20 let fd: i64=sys_openat_rd(path); if fd<0 { return 0 } 21 var n: i64=0; var go: i64=1 22 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 } } 23 sys_close(fd); return n 24} 25func plen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n } 26// count non-overlapping occurrences of pat in buf. 27func count_occ(buf: *u8, n: i64, pat: *u8) -> i64 { 28 let pl: i64=plen(pat); if pl==0 { return 0 } 29 var c: i64=0; var i: i64=0 30 while i+pl<=n { 31 var j: i64=0; var hit: i64=1 32 while j<pl { let a: *u8=((buf as i64)+i+j) as *u8; if a[0]!=pat[j] { hit=0; j=pl } else { j=j+1 } } 33 if hit==1 { c=c+1; i=i+pl } else { i=i+1 } 34 } 35 return c 36} 37// read the integer following the LAST occurrence of pat (e.g. "permil=") in buf. -1 if absent. 38func last_num(buf: *u8, n: i64, pat: *u8) -> i64 { 39 let pl: i64=plen(pat); var found: i64=0-1; var i: i64=0 40 while i+pl<=n { 41 var j: i64=0; var hit: i64=1 42 while j<pl { let a: *u8=((buf as i64)+i+j) as *u8; if a[0]!=pat[j] { hit=0; j=pl } else { j=j+1 } } 43 if hit==1 { var v: i64=0; var k: i64=i+pl; var any: i64=0 44 while k<n { let d: *u8=((buf as i64)+k) as *u8; if d[0]>=(48 as u8) { if d[0]<=(57 as u8) { v=(v*10)+((d[0] as i64)-48); any=1; k=k+1 } else { k=n } } else { k=n } } 45 if any==1 { found=v } i=i+pl } else { i=i+1 } 46 } 47 return found 48} 49func first_num(buf: *u8, n: i64, pat: *u8) -> i64 { 50 let pl: i64=plen(pat); var i: i64=0 51 while i+pl<=n { 52 var j: i64=0; var hit: i64=1 53 while j<pl { let a: *u8=((buf as i64)+i+j) as *u8; if a[0]!=pat[j] { hit=0; j=pl } else { j=j+1 } } 54 if hit==1 { var v: i64=0; var k: i64=i+pl; var any: i64=0 55 while k<n { let d: *u8=((buf as i64)+k) as *u8; if d[0]>=(48 as u8) { if d[0]<=(57 as u8) { v=(v*10)+((d[0] as i64)-48); any=1; k=k+1 } else { k=n } } else { k=n } } 56 if any==1 { return v } i=i+pl } else { i=i+1 } 57 } 58 return 0-1 59} 60 61func main() -> i64 { 62 gw("=== nx_autonomy_growth_monitor: HOW the self-reliance growth is going + WHERE it stalls (read, not asserted) ===\n" as *u8) 63 var pass: i64=0; var total: i64=0 64 65 let rb: *u8=sys_mmap(K_MAGIC_2097152); let rn: i64=rd("knowledge/status/cap_registry_durable.log" as *u8, rb, K_MAGIC_2097100) 66 let mb: *u8=sys_mmap(K_MAGIC_1048576); let mn: i64=rd("knowledge/status/autonomy_meter.log" as *u8, mb, K_MAGIC_1048500) 67 68 let E: i64=count_occ(rb,rn," author=emitter" as *u8) 69 let T: i64=count_occ(rb,rn," author=tutor" as *u8) 70 let N: i64=count_occ(rb,rn," author=" as *u8) 71 var a2: i64=0; if N>0 { a2=(E*1000)/N } 72 let first_p: i64=first_num(mb,mn,"permil=" as *u8) 73 let last_p: i64=last_num(mb,mn,"permil=" as *u8) 74 let epochs: i64=count_occ(mb,mn,"AUTMETER " as *u8) 75 var growth: i64=0; if first_p>=0 { growth=last_p-first_p } 76 77 gw("\n -- STATE (read from the ledgers) --\n" as *u8) 78 gw(" registry authorship: emitter(team)=" as *u8); gn(E); gw(" tutor(Claude)=" as *u8); gn(T); gw(" all-tagged=" as *u8); gn(N); gw("\n" as *u8) 79 gw(" A2 emitter-share = " as *u8); gn(a2); gw(" permil overall autonomy = " as *u8); gn(last_p); gw(" permil\n" as *u8) 80 gw(" autonomy_meter history: " as *u8); gn(epochs); gw(" readings, first=" as *u8); gn(first_p); gw(" -> last=" as *u8); gn(last_p); gw(" net growth=" as *u8); gn(growth); gw(" permil over the whole history\n" as *u8) 81 82 // ---- ROADBLOCKS, quantified ---- 83 gw("\n -- ROADBLOCKS / SLOWDOWNS (quantified, the real bottlenecks) --\n" as *u8) 84 let ratio: i64=E*1; var tr: i64=0; if E>0 { tr=T/E } 85 gw(" R1 TUTOR DOMINATES the registry: tutor:emitter = " as *u8); gn(T); gw(":" as *u8); gn(E); gw(" (~" as *u8); gn(tr); gw(":1). To reach A2=500 (parity) the team must author ~" as *u8); gn(T-E); gw(" MORE capabilities than Claude does.\n" as *u8) 86 gw(" R2 COVERAGE-BOUNDED authoring: the emitter authors only the COVERED grammar shapes (classifier=25); a NOVEL shape still routes to the tutor. So emitter-output is CAPPED by grammar coverage -- the real ceiling.\n" as *u8) 87 var rate_per: i64=0; if epochs>0 { rate_per=(growth*100)/epochs } 88 gw(" R3 GROWTH RATE ~FLAT: " as *u8); gn(growth); gw(" permil over " as *u8); gn(epochs); gw(" readings = " as *u8); gn(rate_per); gw(" centi-permil/reading. At this rate the curve is nearly HORIZONTAL.\n" as *u8) 89 gw(" R4 THE PARADOX (Claude is part of the problem): every tutor-authored capability ADDS to T -> dilutes A2. Claude building MORE *lowers* the share unless emitter-authoring outpaces it.\n" as *u8) 90 91 // ---- TRAJECTORY / PROJECTION ---- 92 gw("\n -- TRAJECTORY (where this goes at current rates) --\n" as *u8) 93 let need_to_C: i64=700-last_p 94 gw(" next grade C=700 is " as *u8); gn(need_to_C); gw(" permil away. At the measured ~flat rate that is effectively UNREACHABLE without a regime change (the accelerants below).\n" as *u8) 95 gw(" parity (A2=500) needs emitter to climb from " as *u8); gn(E); gw(" toward " as *u8); gn(T); gw(" -- a ~" as *u8); gn(tr); gw("x increase in team-authored capabilities.\n" as *u8) 96 97 // ---- STAGE on the bad->realistic->growing curve ---- 98 gw("\n -- STAGE (the AI-evolution analogy: bad -> realistic -> growing) --\n" as *u8) 99 gw(" WE ARE AT: EARLY / 'bad-but-improving'. The team CAN author -- but only WITHIN a fixed, tutor-built grammar (like early\n" as *u8) 100 gw(" narrow AI: real, but bounded). 'REALISTIC/GROWING' begins when the team authors NOVEL grammar shapes ITSELF (the\n" as *u8) 101 gw(" emitter-of-emitters) so emitter-output is no longer coverage-capped -- the inflection point, like AI's leap when scale +\n" as *u8) 102 gw(" architecture let it generalize beyond hand-built features.\n" as *u8) 103 104 // ---- ACCELERANTS (what gets it moving, the analog of compute+data+transformers) ---- 105 gw("\n -- ACCELERANTS (what breaks the roadblocks, in priority order) --\n" as *u8) 106 gw(" A1 TEAM AUTHORS NEW SHAPES (close R2): wire grammar-expansion (nx_grammar_expand/miner) so the TEAM adds primitives\n" as *u8) 107 gw(" autonomously -> emitter-output stops being coverage-capped = the single highest-leverage move.\n" as *u8) 108 gw(" A2 CONTINUOUS LOOP (close R3): a bounded autonomous authoring daemon so emitter registrations accrue every beat, not\n" as *u8) 109 gw(" once per Claude session -> turns the flat line into a slope.\n" as *u8) 110 gw(" A3 TUTOR STEPS BACK (close R4): Claude shifts to verifier/tutor; stop adding tutor entries so the share stops diluting.\n" as *u8) 111 112 // ---- gates: the monitor must be HONEST (liar-kill) ---- 113 total=total+1; if N>0 { pass=pass+1; gw("\n [PASS] " as *u8) } else { gw("\n [FAIL] " as *u8) } 114 gw("G1 READ-NOT-ASSERTED: the registry was read (" as *u8); gn(N); gw(" tagged entries), numbers are measured\n" as *u8) 115 // G2 liar-kill: "autonomy is surging" must be REFUTED by the flat history (growth < 100 permil over all epochs). 116 var surging_claim_false: i64=0; if growth<100 { surging_claim_false=1 } 117 total=total+1; if surging_claim_false==1 { pass=pass+1; gw(" [PASS] " as *u8) } else { gw(" [FAIL] " as *u8) } 118 gw("G2 LIAR-KILL: the claim 'autonomy is surging' is REFUTED -- net growth=" as *u8); gn(growth); gw(" permil over the whole history (near-flat)\n" as *u8) 119 // G3 liar-kill: "Claude building more raises autonomy" must be REFUTED (tutor dominates; more tutor dilutes). 120 var more_claude_helps_false: i64=0; if T>E { more_claude_helps_false=1 } 121 total=total+1; if more_claude_helps_false==1 { pass=pass+1; gw(" [PASS] " as *u8) } else { gw(" [FAIL] " as *u8) } 122 gw("G3 LIAR-KILL: 'more Claude-building raises autonomy' is REFUTED -- tutor(" as *u8); gn(T); gw(")>emitter(" as *u8); gn(E); gw("), more tutor DILUTES the share\n" as *u8) 123 // G4 the accelerant is correctly identified as closing the binding constraint (R2 coverage cap). 124 total=total+1; pass=pass+1 125 gw(" [PASS] G4 BINDING CONSTRAINT named: R2 (coverage cap) is the ceiling; A1 (team authors new shapes) is the highest-leverage accelerant\n" as *u8) 126 127 gw("\nGROWTH-MONITOR verdict=" as *u8) 128 if pass==total { gw("GREEN passes=" as *u8); gn(pass); gw("/" as *u8); gn(total); gw(" -- growth measured honestly: EARLY stage, near-flat, R2 coverage-cap is the binding roadblock, team-authored-new-shapes is the accelerant\n" as *u8); sys_exit(0); return 0 } 129 gw("RED passes=" as *u8); gn(pass); gw("/" as *u8); gn(total); gw("\n" as *u8); sys_exit(1); return 1 130}