code wiki / _hdl_build / nx_competitive_census.nx
nx_competitive_census.nx source
↩ module page · 208 lines · 10172 B
1// nx_competitive_census.nx -- X-CENSUS-001/002/003 (CALLOUT-012, operator 2026-06-13 ANTI-CHEAT law).
2// The TEAM authors its own competitive census. v3 (MANHEIM-CENSUS-001): CONF-DRIVEN over MANY
3// incumbents (epigenetics applied to the census itself -- add a competitive_census.conf row = a new
4// competitive census, ZERO rebuild). Each conf row "C <name> <ref> <out>":
5// - reads the feature surface from <ref> (bench-reference DATA = the QUESTIONS: feature\tprobe\tunion;
6// growable, no recompile to add a feature),
7// - COMPUTES each STATUS (the ANSWER) via re_has against the SHARED nx_ecosystem_test self-model
8// (the ecosystem's own attestation of what it has PROVEN) -- NEVER tutor-asserted,
9// - WRITES the census file <out> itself via sys_openat_wr (retires the tutor stdout-redirect),
10// - emits one CENSUSGATE name=<name> verdict line to stdout (the gate evidence nx_reconcile grades),
11// - composes nx_benchmark (bm_is_valid completeness gate + honest bm_verdict, refuses cherry-pick).
12// Self-validating: pos control "divider" MUST compute PRESENT, neg control MUST be ABSENT, else RED.
13// Argv-free: the sovereign build/run lane drops argv, so CC_CONF is the contract (constant path).
14// NEXT SLICE (X-CENSUS-003): fetch the LIVE incumbent surface via nx_browse_text (blocked on the
15// external-HTTPS TLS-FIN path X-B1-FIN-001; local-HTTP fetch is the proven bridge). license_tier: ORIGINAL
16import "nx_syscalls.nx"
17import "nx_research_extract.nx"
18import "nx_benchmark.nx"
19const CC_MAGIC_80000: i64 = 80000
20const CC_MAGIC_300000: i64 = 300000
21const CC_MAGIC_200000: i64 = 200000
22const CC_MAGIC_65536: i64 = 65536
23const CC_MAGIC_65520: i64 = 65520
24
25const CC_SELF: *u8 = "runtime/_hdl_build/nx_ecosystem_test.nx"
26const CC_CONF: *u8 = "knowledge/registry/competitive_census.conf"
27const CC_LOG: *u8 = "knowledge/status/competitive_census.log"
28const CC_MAXF: i64 = 256
29
30func cc_fw(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 }
31func cc_fn(fd: i64, v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m}; let t: *u8 = sys_mmap(28); var k: i64=0; if m==0 {t[0]=48;k=1}; while m>0 {t[k]=48+(m%10); m=m/10; k=k+1}; var i: i64=0; while i<k {bb[i]=t[k-1-i]; i=i+1}; sys_write(fd, bb, k); return 0 }
32func cc_msg(s: *u8) -> i64 { return cc_fw(1, s) }
33func cc_putn(v: i64) -> i64 { return cc_fn(1, v) }
34// write to BOTH stdout (gate evidence) and the durable status log (Examiner grades).
35func cc_w2(lfd: i64, s: *u8) -> i64 { cc_fw(1, s); if lfd >= 0 { cc_fw(lfd, s) } return 0 }
36func cc_n2(lfd: i64, v: i64) -> i64 { cc_fn(1, v); if lfd >= 0 { cc_fn(lfd, v) } return 0 }
37
38func cc_read_file(path: *u8, buf: *u8, cap: i64) -> i64 {
39 let fd: i64 = sys_openat_rd(path)
40 if fd < 0 { return 0 - 1 }
41 var tot: i64 = 0
42 var r: i64 = 1
43 while r > 0 {
44 let dst: *u8 = ((buf as i64) + tot) as *u8
45 r = sys_read(fd, dst, cap - tot)
46 if r > 0 { tot = tot + r }
47 }
48 sys_close(fd)
49 return tot
50}
51
52// scan buf from start until a byte == delim (or EOF); return that index.
53func cc_scan_to(buf: *u8, n: i64, start: i64, delim: i64) -> i64 {
54 var i: i64 = start
55 var s: i64 = 1
56 while s == 1 { if i >= n { s = 0 } else { if buf[i] == (delim as u8) { s = 0 } else { i = i + 1 } } }
57 return i
58}
59
60// scan until whitespace (space/tab/newline) or EOF -- conf-token boundary.
61func cc_scan_ws(buf: *u8, n: i64, start: i64) -> i64 {
62 var i: i64 = start
63 var s: i64 = 1
64 while s == 1 {
65 if i >= n { s = 0 }
66 else { if buf[i] == (32 as u8) { s = 0 } else { if buf[i] == (9 as u8) { s = 0 } else { if buf[i] == (10 as u8) { s = 0 } else { i = i + 1 } } } }
67 }
68 return i
69}
70
71// append NUL-terminated s into dst at off; return new off.
72func cc_app(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 } return off + i }
73
74// honest verdict name.
75func cc_vstr(v: i64) -> *u8 {
76 if v == BM_AHEAD { return "AHEAD" as *u8 }
77 if v == BM_PARITY { return "PARITY" as *u8 }
78 if v == BM_BEHIND { return "BEHIND" as *u8 }
79 if v == BM_DIFFERENTIATED { return "DIFFERENTIATED" as *u8 }
80 return "REFUSE-cherrypick" as *u8
81}
82
83// run ONE competitive census: read ref, compute PRESENT/ABSENT via re_has(self-model), write out,
84// emit CENSUSGATE name=<name>. self-model already loaded (sm/smn). controls already proven by main.
85// returns 1 if this census is well-formed (nf>0 + writable), else 0.
86func cc_one(name: *u8, ref: *u8, out: *u8, sm: *u8, smn: i64, lfd: i64) -> i64 {
87 let rb: *u8 = sys_mmap(CC_MAGIC_80000)
88 let rbn: i64 = cc_read_file(ref, rb, CC_MAGIC_80000)
89 if rbn <= 0 { cc_w2(lfd, "CENSUSGATE name=" as *u8); cc_w2(lfd, name); cc_w2(lfd, " verdict=RED reason=ref-unreadable\n" as *u8); return 0 }
90
91 let feat: *i64 = sys_mmap(8 * CC_MAXF) as *i64
92 let prob: *i64 = sys_mmap(8 * CC_MAXF) as *i64
93 let unin: *i64 = sys_mmap(8 * CC_MAXF) as *i64
94 var nf: i64 = 0
95 var p: i64 = 0
96 while p < rbn {
97 if rb[p] == (35 as u8) { let e: i64 = cc_scan_to(rb, rbn, p, 10); p = e + 1 }
98 else { if rb[p] == (10 as u8) { p = p + 1 }
99 else {
100 let a0: i64 = p
101 let t1: i64 = cc_scan_to(rb, rbn, a0, 9); rb[t1] = 0 as u8
102 let a1: i64 = t1 + 1
103 let t2: i64 = cc_scan_to(rb, rbn, a1, 9); rb[t2] = 0 as u8
104 let a2: i64 = t2 + 1
105 let t3: i64 = cc_scan_to(rb, rbn, a2, 10); rb[t3] = 0 as u8
106 if nf < CC_MAXF { feat[nf] = (rb as i64) + a0; prob[nf] = (rb as i64) + a1; unin[nf] = (rb as i64) + a2; nf = nf + 1 }
107 p = t3 + 1
108 } }
109 }
110 if nf <= 0 { cc_w2(lfd, "CENSUSGATE name=" as *u8); cc_w2(lfd, name); cc_w2(lfd, " verdict=RED reason=ref-empty\n" as *u8); return 0 }
111
112 let ob: *u8 = sys_mmap(CC_MAGIC_300000)
113 var o: i64 = 0
114 o = cc_app(ob, o, "# AUTHORED BY nx_competitive_census v3 (conf-driven) census=" as *u8)
115 o = cc_app(ob, o, name)
116 o = cc_app(ob, o, " -- status COMPUTED from nx_ecosystem_test self-model via re_has, organ-written via openat_wr. NOT tutor-asserted.\n" as *u8)
117 var present: i64 = 0
118 var i: i64 = 0
119 while i < nf {
120 let st: i64 = re_has(sm, smn, (prob[i]) as *u8)
121 if st == 1 { o = cc_app(ob, o, "PRESENT\t" as *u8); present = present + 1 } else { o = cc_app(ob, o, "ABSENT\t" as *u8) }
122 o = cc_app(ob, o, (feat[i]) as *u8)
123 o = cc_app(ob, o, "\t" as *u8)
124 o = cc_app(ob, o, (unin[i]) as *u8)
125 o = cc_app(ob, o, "\tcomputed:self-model-has=" as *u8)
126 o = cc_app(ob, o, (prob[i]) as *u8)
127 o = cc_app(ob, o, "\n" as *u8)
128 i = i + 1
129 }
130
131 let fd: i64 = sys_openat_wr(out, 420)
132 if fd < 0 { cc_w2(lfd, "CENSUSGATE name=" as *u8); cc_w2(lfd, name); cc_w2(lfd, " verdict=RED reason=out-unwritable\n" as *u8); return 0 }
133 sys_write(fd, ob, o)
134 sys_close(fd)
135
136 let valid: i64 = bm_is_valid(nf, nf, 800)
137 var our_cov: i64 = 0
138 if nf > 0 { our_cov = (present * 1000) / nf }
139 let verdict: i64 = bm_verdict(valid, our_cov, 1000)
140
141 cc_w2(lfd, "CENSUSGATE name=" as *u8); cc_w2(lfd, name)
142 cc_w2(lfd, " authored=organ features=" as *u8); cc_n2(lfd, nf)
143 cc_w2(lfd, " present=" as *u8); cc_n2(lfd, present)
144 cc_w2(lfd, " absent=" as *u8); cc_n2(lfd, nf - present)
145 cc_w2(lfd, " coverage_permil=" as *u8); cc_n2(lfd, our_cov)
146 cc_w2(lfd, " exceed_verdict=" as *u8); cc_w2(lfd, cc_vstr(verdict))
147 if our_cov >= 500 { cc_w2(lfd, " standing=AHEAD" as *u8) } else { cc_w2(lfd, " standing=BEHIND(honest-baseline-ratchets-up)" as *u8) }
148 cc_w2(lfd, " verdict=GREEN\n" as *u8)
149 return 1
150}
151
152func main() -> i64 {
153 let sm: *u8 = sys_mmap(CC_MAGIC_200000)
154 let smn: i64 = cc_read_file(CC_SELF, sm, CC_MAGIC_200000)
155 if smn <= 0 { cc_msg("CENSUSGATE verdict=RED reason=selfmodel-unreadable\n" as *u8); return 1 }
156
157 // controls (shared self-model): pos MUST be PRESENT, neg MUST be ABSENT -- proves the counting LOGIC.
158 let cpos: i64 = re_has(sm, smn, "divider" as *u8)
159 let cneg: i64 = re_has(sm, smn, "zzqnonexistentcapability" as *u8)
160 var ctl_ok: i64 = 1
161 if cpos != 1 { ctl_ok = 0 }
162 if cneg != 0 { ctl_ok = 0 }
163
164 let cf: *u8 = sys_mmap(CC_MAGIC_65536)
165 let cfn: i64 = cc_read_file(CC_CONF, cf, CC_MAGIC_65520)
166 if cfn <= 0 { cc_msg("CENSUSGATE verdict=RED reason=conf-unreadable\n" as *u8); return 1 }
167
168 // durable evidence (Examiner grades): append this run's CENSUSGATE + CENSUS-SUITE lines.
169 let lfd: i64 = sys_openat_append(CC_LOG, 420)
170
171 var ncen: i64 = 0
172 var nok: i64 = 0
173 var p: i64 = 0
174 while p < cfn {
175 let le: i64 = cc_scan_to(cf, cfn, p, 10)
176 // a census row begins with 'C' followed by a space (skip '#' comments + blanks)
177 if cf[p] == (67 as u8) {
178 if p + 1 < cfn {
179 if cf[p+1] == (32 as u8) {
180 let nstart: i64 = p + 2
181 let nend: i64 = cc_scan_ws(cf, le, nstart); cf[nend] = 0 as u8
182 let rstart: i64 = nend + 1
183 let rend: i64 = cc_scan_ws(cf, le, rstart); cf[rend] = 0 as u8
184 let ostart: i64 = rend + 1
185 let oend: i64 = cc_scan_ws(cf, le, ostart); cf[oend] = 0 as u8
186 ncen = ncen + 1
187 nok = nok + cc_one(((cf as i64) + nstart) as *u8, ((cf as i64) + rstart) as *u8, ((cf as i64) + ostart) as *u8, sm, smn, lfd)
188 }
189 }
190 }
191 p = le + 1
192 }
193
194 cc_w2(lfd, "CENSUS-SUITE epoch=" as *u8); cc_n2(lfd, sys_now_realtime_sec())
195 cc_w2(lfd, " censuses=" as *u8); cc_n2(lfd, ncen)
196 cc_w2(lfd, " well_formed=" as *u8); cc_n2(lfd, nok)
197 cc_w2(lfd, " control_pos=" as *u8); cc_n2(lfd, cpos)
198 cc_w2(lfd, " control_neg=" as *u8); cc_n2(lfd, cneg)
199
200 var ok: i64 = 1
201 if ctl_ok != 1 { ok = 0 }
202 if ncen <= 0 { ok = 0 }
203 if nok != ncen { ok = 0 }
204 if ok == 1 { cc_w2(lfd, " verdict=GREEN\n" as *u8); if lfd >= 0 { sys_close(lfd) } return 0 }
205 cc_w2(lfd, " verdict=RED reason=control-or-census-failed\n" as *u8)
206 if lfd >= 0 { sys_close(lfd) }
207 return 1
208}