code wiki / _hdl_build / nx_build_rooted_gate.nx
nx_build_rooted_gate.nx source
↩ module page · 194 lines · 10210 B
1// nx_build_rooted_gate.nx -- ROBUST GENEALOGY: every organ ROOTED to god, NO floating mystery-kid orphans
2// (operator 2026-06-21: "rooted from god so we can rebuild anything = true S-class exceed"). The genesis
3// COMPLETENESS LAW (no orphans) from nx_genesis_trace, now enforced over EVERY built organ. Reads the REAL
4// genesis tree (knowledge/registry/genesis_lineage.tsv) + the build-registry (knowledge/registry/
5// build_registry.log) + the organ tree (runtime/_hdl_build). Two directions, both proven:
6// ANCESTORS (rebuild path): each registered organ's parent= anchor walks UP to ORIGIN(god); reaching
7// god = ROOTED; not reaching = ORPHAN (the chain IS the rebuild order: build god's caps first, up to the organ).
8// DESCENDANTS: organs anchored under a node (e.g. DESC-ORGANS) = its children.
9// FLOATING census: organs on disk NOT in the registry = mystery kids with no anchor = the worklist to root.
10// GATE w/ NEG-CONTROL: GREEN iff EVERY registered organ is rooted (0 registered-orphans) AND a bogus anchor
11// is detected as orphan (-1) AND DESC-ORGANS roots to god. (Floating = reported worklist, shrunk by the
12// R-LIVE-2 ratchet + coordinated migration -- not a hard fail since legacy migration is operator-paced.)
13// Sovereign: imports only nx_syscalls. license_tier: ORIGINAL expect_exit: 0
14import "nx_syscalls.nx"
15
16const GEN: *u8 = "knowledge/registry/genesis_lineage.tsv"
17const REG: *u8 = "knowledge/registry/build_registry.log"
18const ODIR: *u8 = "runtime/_hdl_build"
19const FB: i64 = 262144
20const MAXO: i64 = 8192
21const SLOT: i64 = 160
22
23func rp(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
24func rlen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
25func rpn(v: i64) -> i64 {
26 let bb: *u8 = sys_mmap(28); var m: i64 = v
27 if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
28 let t: *u8 = sys_mmap(28); var k: i64 = 0
29 if m == 0 { t[0] = 48 as u8; k = 1 }
30 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
31 var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
32 sys_write(1, bb, k); return 0
33}
34func rstreq(a: *u8, b: *u8) -> i64 {
35 var i: i64 = 0
36 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
37 if b[i] != (0 as u8) { return 0 }
38 return 1
39}
40func rcpy(dst: *u8, src: *u8) -> i64 { var i: i64 = 0; while src[i] != (0 as u8) { dst[i] = src[i]; i = i + 1 } dst[i] = 0 as u8; return 0 }
41func rread(path: *u8, buf: *u8, cap: i64) -> i64 {
42 let fd: i64 = sys_openat_rd(path)
43 if fd < 0 { return 0 - 1 }
44 var total: i64 = 0
45 var nrd: i64 = sys_read(fd, buf, cap)
46 while nrd > 0 { total = total + nrd; if total >= cap { nrd = 0 } else { nrd = sys_read(fd, ((buf as i64) + total) as *u8, cap - total) } }
47 sys_close(fd)
48 return total
49}
50func rgetdents(fd: i64, buf: *u8, count: i64) -> i64 { return __syscall(217, fd, buf, count, 0, 0, 0) }
51func r_isorgan(name: *u8) -> i64 {
52 if name[0] != (110 as u8) { return 0 }
53 if name[1] != (120 as u8) { return 0 }
54 if name[2] != (95 as u8) { return 0 }
55 let n: i64 = rlen(name)
56 if n < 4 { return 0 }
57 if name[n - 3] != (46 as u8) { return 0 }
58 if name[n - 2] != (110 as u8) { return 0 }
59 if name[n - 1] != (120 as u8) { return 0 }
60 return 1
61}
62// ---- generic field helpers (TSV TAB fields + "key=val" space-delimited) ----
63func g_field(buf: *u8, ls: i64, le: i64, idx: i64, out: *u8) -> i64 {
64 var p: i64 = ls; var f: i64 = 0
65 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 }
66 var o: i64 = 0; var g2: i64 = 1
67 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 } } }
68 out[o] = 0 as u8; return 1
69}
70func kv_find(buf: *u8, from: i64, to: i64, pat: *u8) -> i64 {
71 let pl: i64 = rlen(pat); if pl == 0 { return 0 - 1 }
72 var i: i64 = from
73 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 }
74 return 0 - 1
75}
76func kv_extract(buf: *u8, ls: i64, le: i64, key: *u8, out: *u8) -> i64 {
77 let pos: i64 = kv_find(buf, ls, le, key); if pos < 0 { out[0] = 0 as u8; return 0 }
78 var v: i64 = pos + rlen(key); var o: i64 = 0
79 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 } }
80 out[o] = 0 as u8; return 1
81}
82// ---- genesis walk: node -> parent_id -> ... -> ORIGIN ----
83func gen_parent(buf: *u8, n: i64, node: *u8, parent_out: *u8) -> i64 {
84 let f0: *u8 = sys_mmap(SLOT)
85 var i: i64 = 0
86 while i < n {
87 let ls: i64 = i; var le: i64 = ls; var g: i64 = 1
88 while g == 1 { if le >= n { g = 0 } else { if buf[le] == (10 as u8) { g = 0 } else { le = le + 1 } } }
89 if le > ls { if buf[ls] != (35 as u8) { if g_field(buf, ls, le, 0, f0) == 1 { if rstreq(f0, node) == 1 { g_field(buf, ls, le, 2, parent_out); return 1 } } } }
90 i = le + 1
91 }
92 return 0
93}
94func gen_hops(buf: *u8, n: i64, node: *u8) -> i64 {
95 let cur: *u8 = sys_mmap(SLOT); let par: *u8 = sys_mmap(SLOT)
96 rcpy(cur, node)
97 var hops: i64 = 0; var k: i64 = 0
98 while k < 64 {
99 if gen_parent(buf, n, cur, par) == 0 { return 0 - 1 }
100 if rstreq(par, "-" as *u8) == 1 { return hops }
101 rcpy(cur, par); hops = hops + 1; k = k + 1
102 }
103 return 0 - 1
104}
105// membership: is `name` among the cnt distinct organ names?
106func in_set(name: *u8, names: *i64, cnt: i64) -> i64 {
107 var k: i64 = 0
108 while k < cnt { if rstreq(name, names[k] as *u8) == 1 { return 1 } k = k + 1 }
109 return 0
110}
111
112func main() -> i64 {
113 rp("=== nx_build_rooted_gate: ROBUST GENEALOGY -- every organ rooted to god, no orphans ===\n" as *u8)
114 let gbuf: *u8 = sys_mmap(FB); let gn: i64 = rread(GEN, gbuf, FB)
115 let rbuf: *u8 = sys_mmap(FB); let rn: i64 = rread(REG, rbuf, FB)
116 if gn <= 0 { rp(" ERROR: no genesis tree\n" as *u8); sys_exit(2); return 2 }
117 if rn <= 0 { rp(" ERROR: no build registry\n" as *u8); sys_exit(2); return 2 }
118
119 // parse registry -> distinct organ names[] + latest parent[] (latest-wins)
120 let names: *i64 = sys_mmap(8 * MAXO) as *i64
121 let pars: *i64 = sys_mmap(8 * MAXO) as *i64
122 var cnt: i64 = 0
123 var i: i64 = 0
124 while i < rn {
125 let ls: i64 = i; var le: i64 = ls; var g: i64 = 1
126 while g == 1 { if le >= rn { g = 0 } else { if rbuf[le] == (10 as u8) { g = 0 } else { le = le + 1 } } }
127 let ob: *u8 = sys_mmap(SLOT); let pb: *u8 = sys_mmap(SLOT)
128 if kv_extract(rbuf, ls, le, "organ=" as *u8, ob) == 1 {
129 kv_extract(rbuf, ls, le, "parent=" as *u8, pb)
130 var found: i64 = 0 - 1; var k: i64 = 0
131 while k < cnt { if rstreq(names[k] as *u8, ob) == 1 { found = k; k = cnt } else { k = k + 1 } }
132 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 } }
133 }
134 i = le + 1
135 }
136
137 // ROOTEDNESS (ancestors / rebuild path): each registered organ's anchor must reach god.
138 var rooted: i64 = 0; var orphan: i64 = 0
139 var di: i64 = 0
140 while di < cnt {
141 let h: i64 = gen_hops(gbuf, gn, pars[di] as *u8)
142 if h >= 0 { rooted = rooted + 1 } else {
143 orphan = orphan + 1
144 rp(" ORPHAN (registered, anchor not rooted): " as *u8); rp(names[di] as *u8); rp(" parent=" as *u8); rp(pars[di] as *u8); rp("\n" as *u8)
145 }
146 di = di + 1
147 }
148 rp(" registered organs=" as *u8); rpn(cnt); rp(" ROOTED-to-god=" as *u8); rpn(rooted); rp(" registered-orphans=" as *u8); rpn(orphan); rp("\n" as *u8)
149
150 // DESCENDANTS view: organs anchored directly under DESC-ORGANS.
151 var desc: i64 = 0; var di2: i64 = 0
152 while di2 < cnt { if rstreq(pars[di2] as *u8, "DESC-ORGANS" as *u8) == 1 { desc = desc + 1 } di2 = di2 + 1 }
153 rp(" DESCENDANTS(DESC-ORGANS) = " as *u8); rpn(desc); rp(" organs (the children of the organs node)\n" as *u8)
154
155 // FLOATING mystery-kids census: organs on disk NOT in the registry = no anchor = orphans-to-root.
156 var total: i64 = 0; var floating: i64 = 0
157 let fd: i64 = sys_openat_rd(ODIR)
158 if fd >= 0 {
159 let dbuf: *u8 = sys_mmap(65536)
160 var nread: i64 = rgetdents(fd, dbuf, 65536)
161 while nread > 0 {
162 var off: i64 = 0
163 while off < nread {
164 let reclen: i64 = (dbuf[off + 16] as i64) | ((dbuf[off + 17] as i64) << 8)
165 if reclen <= 0 { off = nread } else {
166 let nm: *u8 = ((dbuf as i64) + off + 19) as *u8
167 if r_isorgan(nm) == 1 { total = total + 1; if in_set(nm, names, cnt) == 0 { floating = floating + 1 } }
168 off = off + reclen
169 }
170 }
171 nread = rgetdents(fd, dbuf, 65536)
172 }
173 sys_close(fd)
174 }
175 rp(" runtime/_hdl_build: total organs=" as *u8); rpn(total); rp(" rooted/registered=" as *u8); rpn(total - floating)
176 rp(" FLOATING(mystery kids, no anchor)=" as *u8); rpn(floating); rp(" <- the worklist to fully root\n" as *u8)
177
178 // NEG-CONTROL: a bogus anchor must be detected as an orphan.
179 let h_bogus: i64 = gen_hops(gbuf, gn, "NX-BOGUS-ORPHAN" as *u8)
180 let h_desc: i64 = gen_hops(gbuf, gn, "DESC-ORGANS" as *u8)
181 rp(" neg-control: hops_to_god(bogus)=" as *u8); rpn(h_bogus); rp(" (expect -1) hops_to_god(DESC-ORGANS)=" as *u8); rpn(h_desc); rp(" (expect >=0)\n" as *u8)
182
183 var ok: i64 = 1
184 if orphan != 0 { ok = 0 } // every registered organ MUST be rooted
185 if h_bogus != (0 - 1) { ok = 0 } // liar-kill must fire
186 if h_desc < 0 { ok = 0 } // the anchor itself must root to god
187 rp(" verdict=" as *u8)
188 if ok == 1 {
189 rp("GREEN (every registered organ roots to god; orphan-anchor rejected; floating=worklist)\n" as *u8)
190 sys_exit(0); return 0
191 }
192 rp("RED (a registered organ is an unrooted orphan, or the liar-kill is disarmed)\n" as *u8)
193 sys_exit(1); return 1
194}