code wiki / _hdl_build / nx_build_evidence_gate.nx
nx_build_evidence_gate.nx source
↩ module page · 244 lines · 15236 B
1// nx_build_evidence_gate.nx -- EVIDENCE-CORRELATED GENEALOGY + ORPHAN MAINTENANCE (operator 2026-06-22:
2// "the genealogy needs to help flag and maintain orphans, and orphans need EVIDENCE like how there are
3// social-security correlations in real life"). A lineage claim must be CORROBORATED by multiple independent
4// signals that agree -- like an identity backed by SSN <-> birth-cert <-> name all matching -- not a bare
5// asserted parent=. Per organ we gather 4 evidence signals:
6// E1 EXISTS -- the organ file is real on disk
7// E2 IMPORT-ROOTED -- all its imports resolve (rebuildable from god via the import DAG)
8// E3 REGISTERED -- it has a build-registry record (its SSN-like identity)
9// E4 ANCHORED -- its registry parent= traces to ORIGIN(god) in the genesis tree
10// CORRELATION -> classify: GHOST(record but no file) / ANOMALY(registered yet NOT rebuildable = evidence
11// contradiction = "identity fraud") / CORROBORATED(all agree) / UNREGISTERED(rebuildable but no ID) /
12// FLOATING-ORPHAN(exists but can't rebuild) / WEAK. FLAGGED organs are written to a MAINTAINED watchlist
13// (knowledge/registry/orphan_watchlist.log, refreshed each run) so orphans are tracked over time.
14// GATE w/ NEG-CONTROL: the classifier is tested on synthetic evidence vectors (teeth); GREEN iff every
15// REGISTERED organ's evidence CORRELATES (0 anomalies, 0 ghosts) AND the classifier discriminates.
16// Sovereign: imports only nx_syscalls. license_tier: ORIGINAL expect_exit: 0
17import "nx_syscalls.nx"
18
19const GEN: *u8 = "knowledge/registry/genesis_lineage.tsv"
20const REG: *u8 = "knowledge/registry/build_registry.log"
21const WATCH: *u8 = "knowledge/registry/orphan_watchlist.log"
22const ODIR: *u8 = "runtime/_hdl_build"
23const FB: i64 = 262144
24const MAXO: i64 = 8192
25const SLOT: i64 = 160
26// class codes
27const C_GHOST: i64 = 0
28const C_ANOMALY: i64 = 1
29const C_FLOATING: i64 = 2
30const C_UNREG: i64 = 3
31const C_WEAK: i64 = 4
32const C_CORROB: i64 = 5
33
34func ep(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
35func elen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
36func epn(v: i64) -> i64 {
37 let bb: *u8 = sys_mmap(28); var m: i64 = v
38 if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
39 let t: *u8 = sys_mmap(28); var k: i64 = 0
40 if m == 0 { t[0] = 48 as u8; k = 1 }
41 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
42 var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
43 sys_write(1, bb, k); return 0
44}
45func estreq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 } if b[i] != (0 as u8) { return 0 } return 1 }
46func eread(path: *u8, buf: *u8, cap: i64) -> i64 {
47 let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 - 1 }
48 var total: i64 = 0; var nrd: i64 = sys_read(fd, buf, cap)
49 while nrd > 0 { total = total + nrd; if total >= cap { nrd = 0 } else { nrd = sys_read(fd, ((buf as i64) + total) as *u8, cap - total) } }
50 sys_close(fd); return total
51}
52func eexists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 }
53func ejoin(pfx: *u8, name: *u8, out: *u8) -> i64 { var o: i64 = 0; var i: i64 = 0; while pfx[i] != (0 as u8) { out[o] = pfx[i]; o = o + 1; i = i + 1 } i = 0; while name[i] != (0 as u8) { out[o] = name[i]; o = o + 1; i = i + 1 } out[o] = 0 as u8; return 0 }
54func efind(buf: *u8, from: i64, to: i64, pat: *u8) -> i64 {
55 let pl: i64 = elen(pat); if pl == 0 { return 0 - 1 }
56 var i: i64 = from
57 while i + pl <= to { var j: i64 = 0; var ok: i64 = 1; while j < pl { if buf[i + j] != pat[j] { ok = 0; j = pl } else { j = j + 1 } } if ok == 1 { return i } i = i + 1 }
58 return 0 - 1
59}
60func e_kv(buf: *u8, ls: i64, le: i64, key: *u8, out: *u8) -> i64 {
61 let pos: i64 = efind(buf, ls, le, key); if pos < 0 { out[0] = 0 as u8; return 0 }
62 var v: i64 = pos + elen(key); var o: i64 = 0
63 while v < le { if buf[v] == (32 as u8) { v = le } else { if o < SLOT - 1 { out[o] = buf[v]; o = o + 1 } v = v + 1 } }
64 out[o] = 0 as u8; return 1
65}
66func e_field(buf: *u8, ls: i64, le: i64, idx: i64, out: *u8) -> i64 {
67 var p: i64 = ls; var f: i64 = 0
68 while f < idx { var g: i64 = 1; while g == 1 { if p >= le { return 0 } if buf[p] == (9 as u8) { p = p + 1; g = 0 } else { p = p + 1 } } f = f + 1 }
69 var o: i64 = 0; var g2: i64 = 1
70 while g2 == 1 { if p >= le { g2 = 0 } else { if buf[p] == (9 as u8) { g2 = 0 } else { if o < SLOT - 1 { out[o] = buf[p]; o = o + 1 } p = p + 1 } } }
71 out[o] = 0 as u8; return 1
72}
73func e_genparent(buf: *u8, n: i64, node: *u8, parent_out: *u8) -> i64 {
74 let f0: *u8 = sys_mmap(SLOT); var i: i64 = 0
75 while i < n {
76 let ls: i64 = i; var le: i64 = ls; var g: i64 = 1
77 while g == 1 { if le >= n { g = 0 } else { if buf[le] == (10 as u8) { g = 0 } else { le = le + 1 } } }
78 if le > ls { if buf[ls] != (35 as u8) { if e_field(buf, ls, le, 0, f0) == 1 { if estreq(f0, node) == 1 { e_field(buf, ls, le, 2, parent_out); return 1 } } } }
79 i = le + 1
80 }
81 return 0
82}
83func e_genhops(buf: *u8, n: i64, node: *u8) -> i64 {
84 let cur: *u8 = sys_mmap(SLOT); let par: *u8 = sys_mmap(SLOT)
85 var i: i64 = 0; while node[i] != (0 as u8) { cur[i] = node[i]; i = i + 1 } cur[i] = 0 as u8
86 var hops: i64 = 0; var k: i64 = 0
87 while k < 64 {
88 if e_genparent(buf, n, cur, par) == 0 { return 0 - 1 }
89 if estreq(par, "-" as *u8) == 1 { return hops }
90 var j: i64 = 0; while par[j] != (0 as u8) { cur[j] = par[j]; j = j + 1 } cur[j] = 0 as u8
91 hops = hops + 1; k = k + 1
92 }
93 return 0 - 1
94}
95func e_resolve(name: *u8) -> i64 {
96 let p: *u8 = sys_mmap(512)
97 ejoin("runtime/_hdl_build/" as *u8, name, p); if eexists(p) == 1 { return 1 }
98 ejoin("runtime/" as *u8, name, p); if eexists(p) == 1 { return 1 }
99 ejoin("runtime/wiki/" as *u8, name, p); if eexists(p) == 1 { return 1 }
100 ejoin("nxasm/" as *u8, name, p); if eexists(p) == 1 { return 1 }
101 return 0
102}
103// 1 if every line-start import in the organ file resolves (import-rooted = rebuildable).
104func e_import_rooted(path: *u8) -> i64 {
105 let buf: *u8 = sys_mmap(FB); let n: i64 = eread(path, buf, FB)
106 if n <= 0 { return 0 }
107 var i: i64 = 0
108 while i < n {
109 let pos: i64 = efind(buf, i, n, "import " as *u8)
110 if pos < 0 { i = n } else {
111 var atstart: i64 = 1; var bs: i64 = pos - 1; var gb: i64 = 1
112 while gb == 1 { if bs < 0 { gb = 0 } else { let c: i64 = buf[bs] as i64; if c == 10 { gb = 0 } else { if c == 32 { bs = bs - 1 } else { if c == 9 { bs = bs - 1 } else { atstart = 0; gb = 0 } } } } }
113 var q: i64 = pos + 7; var g: i64 = 1
114 while g == 1 { if q >= n { g = 0 } else { if buf[q] == (34 as u8) { g = 0 } else { q = q + 1 } } }
115 if q < n {
116 var s: i64 = q + 1; var o: i64 = 0; let nb: *u8 = sys_mmap(SLOT); var g2: i64 = 1
117 while g2 == 1 { if s >= n { g2 = 0 } else { if buf[s] == (34 as u8) { g2 = 0 } else { if o < SLOT - 1 { nb[o] = buf[s]; o = o + 1 } s = s + 1 } } }
118 nb[o] = 0 as u8
119 if atstart == 1 { if o > 0 { if e_resolve(nb) == 0 { return 0 } } }
120 i = s + 1
121 } else { i = n }
122 }
123 }
124 return 1
125}
126func e_organ_path(name: *u8, out: *u8) -> i64 {
127 ejoin("runtime/_hdl_build/" as *u8, name, out); if eexists(out) == 1 { return 1 }
128 ejoin("runtime/" as *u8, name, out); if eexists(out) == 1 { return 1 }
129 ejoin("runtime/wiki/" as *u8, name, out); if eexists(out) == 1 { return 1 }
130 return 0
131}
132func e_getdents(fd: i64, buf: *u8, count: i64) -> i64 { return __syscall(217, fd, buf, count, 0, 0, 0) }
133func e_isorgan(name: *u8) -> i64 {
134 if name[0] != (110 as u8) { return 0 } if name[1] != (120 as u8) { return 0 } if name[2] != (95 as u8) { return 0 }
135 let n: i64 = elen(name); if n < 4 { return 0 }
136 if name[n - 3] != (46 as u8) { return 0 } if name[n - 2] != (110 as u8) { return 0 } if name[n - 1] != (120 as u8) { return 0 }
137 return 1
138}
139// the CORRELATION classifier: order matters (most-severe contradiction first).
140func classify(e1: i64, e2: i64, e3: i64, e4: i64) -> i64 {
141 if e1 == 0 { return C_GHOST } // a record/claim with NO real organ
142 if e3 == 1 { if e2 == 0 { return C_ANOMALY } } // claims registration but NOT rebuildable = fraud
143 if e2 == 1 { if e3 == 1 { if e4 == 1 { return C_CORROB } } } // all evidence agrees
144 if e2 == 1 { if e3 == 0 { return C_UNREG } } // rebuildable but no ID record
145 if e2 == 0 { return C_FLOATING } // exists but can't rebuild = orphan needing evidence
146 return C_WEAK
147}
148func class_str(c: i64) -> *u8 {
149 if c == C_GHOST { return "GHOST" as *u8 }
150 if c == C_ANOMALY { return "ANOMALY" as *u8 }
151 if c == C_FLOATING { return "FLOATING-ORPHAN" as *u8 }
152 if c == C_UNREG { return "UNREGISTERED" as *u8 }
153 if c == C_WEAK { return "WEAK" as *u8 }
154 return "CORROBORATED" as *u8
155}
156func e_wwrite(fd: i64, s: *u8) -> i64 { if fd >= 0 { sys_write(fd, s, elen(s)) } return 0 }
157func e_wnum(fd: i64, v: i64) -> i64 { let t: *u8 = sys_mmap(28); var m: i64 = v; var k: i64 = 0; if m == 0 { t[0] = 48 as u8; k = 1 } else { while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 } } let o: *u8 = sys_mmap(28); var i: i64 = 0; while i < k { o[i] = t[k - 1 - i]; i = i + 1 } if fd >= 0 { sys_write(fd, o, k) } return 0 }
158
159func main() -> i64 {
160 ep("=== nx_build_evidence_gate: EVIDENCE-CORRELATED genealogy + orphan maintenance ===\n" as *u8)
161 let gbuf: *u8 = sys_mmap(FB); let gn: i64 = eread(GEN, gbuf, FB)
162 let rbuf: *u8 = sys_mmap(FB); let rn: i64 = eread(REG, rbuf, FB)
163 if gn <= 0 { ep(" ERROR: no genesis tree\n" as *u8); sys_exit(2); return 2 }
164 if rn <= 0 { ep(" ERROR: no registry\n" as *u8); sys_exit(2); return 2 }
165
166 // parse registry -> distinct organ + latest parent
167 let names: *i64 = sys_mmap(8 * MAXO) as *i64
168 let pars: *i64 = sys_mmap(8 * MAXO) as *i64
169 var cnt: i64 = 0; var i: i64 = 0
170 while i < rn {
171 let ls: i64 = i; var le: i64 = ls; var g: i64 = 1
172 while g == 1 { if le >= rn { g = 0 } else { if rbuf[le] == (10 as u8) { g = 0 } else { le = le + 1 } } }
173 let ob: *u8 = sys_mmap(SLOT); let pb: *u8 = sys_mmap(SLOT)
174 if e_kv(rbuf, ls, le, "organ=" as *u8, ob) == 1 {
175 e_kv(rbuf, ls, le, "parent=" as *u8, pb)
176 var found: i64 = 0 - 1; var k: i64 = 0
177 while k < cnt { if estreq(names[k] as *u8, ob) == 1 { found = k; k = cnt } else { k = k + 1 } }
178 if found >= 0 { pars[found] = pb as i64 } else { if cnt < MAXO { names[cnt] = ob as i64; pars[cnt] = pb as i64; cnt = cnt + 1 } }
179 }
180 i = le + 1
181 }
182
183 // MAINTAIN: refresh the watchlist (truncate, then write current flagged state)
184 let wfd0: i64 = sys_openat_wr(WATCH, 420); if wfd0 >= 0 { sys_close(wfd0) }
185 let wfd: i64 = sys_openat_append(WATCH, 0x1a4)
186 e_wwrite(wfd, "# orphan_watchlist -- maintained each nx_build_evidence_gate run; flagged = evidence does not fully correlate\n" as *u8)
187
188 var corrob: i64 = 0; var anomaly: i64 = 0; var ghost: i64 = 0; var unreg: i64 = 0; var floating: i64 = 0; var weak: i64 = 0
189 var di: i64 = 0
190 while di < cnt {
191 let nm: *u8 = names[di] as *u8
192 let op: *u8 = sys_mmap(512)
193 let e1: i64 = e_organ_path(nm, op)
194 var e2: i64 = 0; if e1 == 1 { e2 = e_import_rooted(op) }
195 let e3: i64 = 1
196 var e4: i64 = 0; if e_genhops(gbuf, gn, pars[di] as *u8) >= 0 { e4 = 1 }
197 let cls: i64 = classify(e1, e2, e3, e4)
198 if cls == C_CORROB { corrob = corrob + 1 } else {
199 if cls == C_ANOMALY { anomaly = anomaly + 1 }
200 if cls == C_GHOST { ghost = ghost + 1 }
201 if cls == C_UNREG { unreg = unreg + 1 }
202 if cls == C_FLOATING { floating = floating + 1 }
203 if cls == C_WEAK { weak = weak + 1 }
204 // write the flagged organ + its evidence vector to the maintained watchlist
205 e_wwrite(wfd, "WATCH organ=" as *u8); e_wwrite(wfd, nm); e_wwrite(wfd, " class=" as *u8); e_wwrite(wfd, class_str(cls))
206 e_wwrite(wfd, " e1=" as *u8); e_wnum(wfd, e1); e_wwrite(wfd, " e2=" as *u8); e_wnum(wfd, e2); e_wwrite(wfd, " e3=" as *u8); e_wnum(wfd, e3); e_wwrite(wfd, " e4=" as *u8); e_wnum(wfd, e4); e_wwrite(wfd, " END\n" as *u8)
207 ep(" FLAGGED " as *u8); ep(class_str(cls)); ep(": " as *u8); ep(nm); ep("\n" as *u8)
208 }
209 di = di + 1
210 }
211 ep(" registered organs=" as *u8); epn(cnt); ep(" CORROBORATED=" as *u8); epn(corrob)
212 ep(" anomaly=" as *u8); epn(anomaly); ep(" ghost=" as *u8); epn(ghost); ep(" unreg=" as *u8); epn(unreg); ep(" floating=" as *u8); epn(floating); ep(" weak=" as *u8); epn(weak); ep("\n" as *u8)
213
214 // full-scale: organs on disk lacking an ID record (the SSN-less, evidence-incomplete worklist)
215 var total: i64 = 0
216 let fd: i64 = sys_openat_rd(ODIR)
217 if fd >= 0 {
218 let dbuf: *u8 = sys_mmap(65536); var nread: i64 = e_getdents(fd, dbuf, 65536)
219 while nread > 0 { var off: i64 = 0; while off < nread { let rl: i64 = (dbuf[off + 16] as i64) | ((dbuf[off + 17] as i64) << 8); if rl <= 0 { off = nread } else { let nm2: *u8 = ((dbuf as i64) + off + 19) as *u8; if e_isorgan(nm2) == 1 { total = total + 1 } off = off + rl } } nread = e_getdents(fd, dbuf, 65536) }
220 sys_close(fd)
221 }
222 ep(" full-scale: total organs on disk=" as *u8); epn(total); ep(" with-ID(registered)=" as *u8); epn(cnt); ep(" lacking-ID(needs evidence record)=" as *u8); epn(total - cnt); ep("\n" as *u8)
223 e_wwrite(wfd, "SUMMARY registered=" as *u8); e_wnum(wfd, cnt); e_wwrite(wfd, " corroborated=" as *u8); e_wnum(wfd, corrob); e_wwrite(wfd, " anomaly=" as *u8); e_wnum(wfd, anomaly); e_wwrite(wfd, " lacking_id=" as *u8); e_wnum(wfd, total - cnt); e_wwrite(wfd, " END\n" as *u8)
224 if wfd >= 0 { sys_close(wfd) }
225
226 // NEG-CONTROL: the correlation classifier must DISCRIMINATE on synthetic evidence vectors.
227 var ncok: i64 = 1
228 if classify(1, 1, 1, 1) != C_CORROB { ncok = 0 } // all evidence agrees
229 if classify(1, 0, 1, 1) != C_ANOMALY { ncok = 0 } // registered but not rebuildable = fraud
230 if classify(0, 1, 1, 1) != C_GHOST { ncok = 0 } // record but no organ
231 if classify(1, 0, 0, 0) != C_FLOATING { ncok = 0 } // exists, can't rebuild = orphan
232 if classify(1, 1, 0, 0) != C_UNREG { ncok = 0 } // rebuildable, no ID
233 ep(" neg-control (classifier discriminates 5 evidence vectors): " as *u8); if ncok == 1 { ep("OK\n" as *u8) } else { ep("BROKEN\n" as *u8) }
234 ep(" maintained watchlist -> knowledge/registry/orphan_watchlist.log\n" as *u8)
235
236 var ok: i64 = 1
237 if anomaly != 0 { ok = 0 }
238 if ghost != 0 { ok = 0 }
239 if ncok != 1 { ok = 0 }
240 ep(" verdict=" as *u8)
241 if ok == 1 { ep("GREEN (every registered organ's evidence CORRELATES; classifier has teeth; orphans maintained)\n" as *u8); sys_exit(0); return 0 }
242 ep("RED (an organ claims lineage its evidence contradicts, or the classifier is disarmed)\n" as *u8)
243 sys_exit(1); return 1
244}