code wiki / _hdl_build / nx_build_lineage_gate.nx
nx_build_lineage_gate.nx source
↩ module page · 152 lines · 6544 B
1// nx_build_lineage_gate.nx -- GENEALOGY OWNERSHIP for backend organs (operator 2026-06-21: "organs
2// owned like our genealogy setup where it goes from god to that organ"). It walks the REAL genesis tree
3// (knowledge/registry/genesis_lineage.tsv: node_id<TAB>type<TAB>parent_id<...>) from a node up the
4// parent_id chain to ORIGIN (god), exactly like the library's foundationing requires hops_to_god>0.
5// Every backend organ anchors at DESC-ORGANS ("organs + K-rungs (the sovereign stack)"), so an organ's
6// ownership chain is god -> ZERO -> ONE -> UNI-BINARY -> DESC-WORD -> DESC-ISA -> DESC-TOOLCHAIN ->
7// DESC-WOMB -> DESC-ORGANS -> <organ>.
8//
9// GATE w/ NEGATIVE CONTROL (GREEN means the walker actually discriminates):
10// - DESC-ORGANS traces to god with hops>0 (organs are owned, not orphaned)
11// - ORIGIN itself = 0 hops (god is the root)
12// - an ORPHAN node not in the tree = -1 (NO path to god => flagged; can't fake lineage)
13// Sovereign: imports only nx_syscalls. license_tier: ORIGINAL expect_exit: 0
14import "nx_syscalls.nx"
15
16const GL_PATH: *u8 = "knowledge/registry/genesis_lineage.tsv"
17const GL_FBUF: i64 = 262144
18
19func ll_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
20func ll_p(s: *u8) -> i64 { let n: i64 = ll_len(s); sys_write(1, s, n); return 0 }
21func ll_pn(v: i64) -> i64 {
22 let bb: *u8 = sys_mmap(28); var m: i64 = v
23 if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
24 let t: *u8 = sys_mmap(28); var k: i64 = 0
25 if m == 0 { t[0] = 48 as u8; k = 1 }
26 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
27 var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
28 sys_write(1, bb, k); return 0
29}
30func ll_streq(a: *u8, b: *u8) -> i64 {
31 var i: i64 = 0
32 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
33 if b[i] != (0 as u8) { return 0 }
34 return 1
35}
36func ll_cpy(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 }
37func ll_read(path: *u8, buf: *u8, cap: i64) -> i64 {
38 let fd: i64 = sys_openat_rd(path)
39 if fd < 0 { return 0 - 1 }
40 var total: i64 = 0
41 var nrd: i64 = sys_read(fd, buf, cap)
42 while nrd > 0 {
43 total = total + nrd
44 if total >= cap { nrd = 0 } else { nrd = sys_read(fd, ((buf as i64) + total) as *u8, cap - total) }
45 }
46 sys_close(fd)
47 return total
48}
49// extract the idx-th TAB-delimited field of line [ls,le) into out (NUL-term). 1 if the field exists.
50func ll_field(buf: *u8, ls: i64, le: i64, idx: i64, out: *u8) -> i64 {
51 var p: i64 = ls
52 var f: i64 = 0
53 while f < idx {
54 var g: i64 = 1
55 while g == 1 {
56 if p >= le { return 0 }
57 if buf[p] == (9 as u8) { p = p + 1; g = 0 } else { p = p + 1 }
58 }
59 f = f + 1
60 }
61 var o: i64 = 0
62 var g2: i64 = 1
63 while g2 == 1 {
64 if p >= le { g2 = 0 } else {
65 if buf[p] == (9 as u8) { g2 = 0 } else { if o < 127 { out[o] = buf[p]; o = o + 1 } p = p + 1 }
66 }
67 }
68 out[o] = 0 as u8
69 return 1
70}
71// find the row whose field0 == node; put its field2 (parent_id) into parent_out. 1 if found.
72func ll_find(buf: *u8, n: i64, node: *u8, parent_out: *u8) -> i64 {
73 let f0: *u8 = sys_mmap(160)
74 var i: i64 = 0
75 while i < n {
76 let ls: i64 = i
77 var le: i64 = ls
78 var g: i64 = 1
79 while g == 1 { if le >= n { g = 0 } else { if buf[le] == (10 as u8) { g = 0 } else { le = le + 1 } } }
80 if le > ls { if buf[ls] != (35 as u8) { // skip comment lines (#)
81 if ll_field(buf, ls, le, 0, f0) == 1 {
82 if ll_streq(f0, node) == 1 { ll_field(buf, ls, le, 2, parent_out); return 1 }
83 }
84 } }
85 i = le + 1
86 }
87 return 0
88}
89// hops from `node` up the parent chain to ORIGIN (god). -1 if the chain breaks before god (orphan).
90func ll_hops(buf: *u8, n: i64, node: *u8) -> i64 {
91 let cur: *u8 = sys_mmap(160)
92 let par: *u8 = sys_mmap(160)
93 ll_cpy(cur, node)
94 var hops: i64 = 0
95 var k: i64 = 0
96 while k < 64 {
97 if ll_find(buf, n, cur, par) == 0 { return 0 - 1 } // node missing => broken/orphan
98 if ll_streq(par, "-" as *u8) == 1 { return hops } // cur is ORIGIN (god)
99 ll_cpy(cur, par)
100 hops = hops + 1
101 k = k + 1
102 }
103 return 0 - 1
104}
105// print node -> parent -> ... -> ORIGIN (the genealogy from an organ's anchor up to god).
106func ll_chain(buf: *u8, n: i64, node: *u8) -> i64 {
107 let cur: *u8 = sys_mmap(160)
108 let par: *u8 = sys_mmap(160)
109 ll_cpy(cur, node)
110 ll_p(cur)
111 var k: i64 = 0
112 while k < 64 {
113 if ll_find(buf, n, cur, par) == 0 { ll_p(" -> [BROKEN]" as *u8); return 0 }
114 if ll_streq(par, "-" as *u8) == 1 { return 0 }
115 ll_p(" -> " as *u8); ll_p(par)
116 ll_cpy(cur, par)
117 k = k + 1
118 }
119 return 0
120}
121
122func main() -> i64 {
123 ll_p("=== nx_build_lineage_gate: GENEALOGY OWNERSHIP god -> ... -> organ ===\n" as *u8)
124 let buf: *u8 = sys_mmap(GL_FBUF)
125 let n: i64 = ll_read(GL_PATH, buf, GL_FBUF)
126 if n <= 0 { ll_p(" ERROR: cannot read genesis_lineage.tsv\n" as *u8); sys_exit(2); return 2 }
127
128 let anchor: *u8 = "DESC-ORGANS" as *u8 // every backend organ descends from this node
129 let h_org: i64 = ll_hops(buf, n, anchor)
130 let h_god: i64 = ll_hops(buf, n, "ORIGIN" as *u8)
131 let h_orphan: i64 = ll_hops(buf, n, "NX-ORPHAN-NOT-IN-TREE" as *u8)
132
133 ll_p(" organ anchor = DESC-ORGANS; its chain to god:\n " as *u8); ll_chain(buf, n, anchor); ll_p("\n" as *u8)
134 ll_p(" hops_to_god(DESC-ORGANS) = " as *u8); ll_pn(h_org); ll_p(" (expect > 0 = owned)\n" as *u8)
135 ll_p(" => any organ's ownership = god -> ... -> DESC-ORGANS -> <organ>, hops = " as *u8); ll_pn(h_org + 1); ll_p("\n" as *u8)
136 ll_p(" hops_to_god(ORIGIN) = " as *u8); ll_pn(h_god); ll_p(" (expect 0 = god is the root)\n" as *u8)
137 ll_p(" hops_to_god(orphan) = " as *u8); ll_pn(h_orphan); ll_p(" (expect -1 = no path to god, neg-control)\n" as *u8)
138
139 var pass: i64 = 0
140 var ok: i64 = 1
141 if h_org > 0 { pass = pass + 1 } else { ok = 0 }
142 if h_god == 0 { pass = pass + 1 } else { ok = 0 }
143 if h_orphan == (0 - 1) { pass = pass + 1 } else { ok = 0 }
144
145 ll_p(" RESULT pass=" as *u8); ll_pn(pass); ll_p("/3 verdict=" as *u8)
146 if ok == 1 {
147 ll_p("GREEN (organs trace god->organ; god=root; orphan rejected)\n" as *u8)
148 sys_exit(0); return 0
149 }
150 ll_p("RED\n" as *u8)
151 sys_exit(1); return 1
152}