code wiki / _hdl_build / nx_genesis_trace.nx
nx_genesis_trace.nx source
↩ module page · 345 lines · 16554 B
1// nx_genesis_trace.nx -- THE GENESIS GENEALOGY TRACER.
2//
3// module: nishi-core.genealogy.genesis_trace
4// capability: CORE_COMPUTE (the god->adam&eve->...->IO-endpoint lineage, made queryable)
5//
6// THE MODEL (operator 2026-06-16):
7// god = the ORIGINATION point -- ANY hardware substrate, not locked to one chip.
8// adam & eve = the conceptual 1 and 0 (binary; quantum = the higher register) god passes down.
9// FRAGMENTATION points = 3rd-party divergence axes (hardware, os, ...) where you can get
10// LOCKED to a vendor/variant.
11// UNIFICATION points = layers that SPAN a fragmentation axis ("runs on all hardware",
12// "one app on all OSes") so you are NOT locked. A fragmentation axis with NO unification
13// node = a lock-in (a BOOTSTRAP_MAP broken link).
14// final endpoint = the APP <-> IO LOOP with a human or machine (OS is NOT the top).
15//
16// This organ READS the lineage straight from DATA (knowledge/registry/genesis_lineage.tsv)
17// and re-derives, FRESH every run (Cardinal 11/25 -- add an axis = add rows, no code change):
18// * traces the endpoint DOWN to god, asserting it bottoms out at the origination (any HW);
19// * flags BROKEN LINKS (a parent_id that names no node) -- loud, never silently traced;
20// * censuses every FRAGMENTATION axis and whether a UNIFICATION spans it (else LOCKED).
21// Sovereign: imports only nx_syscalls (no gcc/sed/awk). license_tier: ORIGINAL
22
23import "nx_syscalls.nx"
24
25const GT_FILE: *u8 = "knowledge/registry/genesis_lineage.tsv"
26
27// node type codes (data-driven label set; no magic ints in logic -- compared by name).
28const NT_NONE: i64 = 0
29const NT_ORIGIN: i64 = 1
30const NT_PRIM: i64 = 2
31const NT_UNI: i64 = 3
32const NT_DESC: i64 = 4
33const NT_FRAG: i64 = 5
34const NT_VAR: i64 = 6
35const NT_ENDPOINT: i64 = 7
36
37// parsed graph (module-global, set by gt_parse; re-parsed per gt_analyze call).
38static GT_N: i64
39static GT_IDS: i64 // *i64 of *u8 (node id)
40static GT_TYPES: i64 // *i64
41static GT_PARENTS: i64 // *i64 of *u8 (parent id)
42static GT_AXES: i64 // *i64 of *u8 (axis)
43static GT_SOVS: i64 // *i64 of *u8 (sovereignty)
44static GT_LABELS: i64 // *i64 of *u8 (label)
45static GT_SAFETY: i64 // *i64 of *u8 (safety: never-brick | -)
46
47func gt_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != 0 as u8 { n = n + 1 } sys_write(1, s, n); return 0 }
48func gt_putn(v: i64) -> i64 {
49 if v == 0 { sys_write(1, "0" as *u8, 1); return 0 }
50 var m: i64 = v
51 if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
52 let d: *u8 = sys_mmap(24); var k: i64 = 0
53 while m > 0 { d[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
54 var j: i64 = k - 1
55 while j >= 0 { sys_write(1, ((d as i64)+j) as *u8, 1); j = j - 1 }
56 return 0
57}
58func gt_streq(a: *u8, b: *u8) -> i64 {
59 var i: i64 = 0
60 while a[i] != 0 as u8 { if a[i] != b[i] { return 0 } i = i + 1 }
61 if b[i] != 0 as u8 { return 0 }
62 return 1
63}
64
65// TAB field f (0-based) of line[ls,le) copied into a FRESH NUL-term mmap; returns ptr.
66func gt_field_dup(b: *u8, ls: i64, le: i64, f: i64) -> *u8 {
67 var cur: i64 = 0
68 var i: i64 = ls
69 while cur < f {
70 if i >= le { let e: *u8 = sys_mmap(2); e[0] = 0 as u8; return e }
71 if b[i] == 9 as u8 { cur = cur + 1 }
72 i = i + 1
73 }
74 let out: *u8 = sys_mmap(256)
75 var o: i64 = 0
76 while i < le {
77 if b[i] == 9 as u8 { i = le } else { if o < 255 { out[o] = b[i]; o = o + 1 } i = i + 1 }
78 }
79 out[o] = 0 as u8
80 return out
81}
82
83func gt_type_code(s: *u8) -> i64 {
84 if gt_streq(s, "origination" as *u8) == 1 { return NT_ORIGIN }
85 if gt_streq(s, "primitive" as *u8) == 1 { return NT_PRIM }
86 if gt_streq(s, "unification" as *u8) == 1 { return NT_UNI }
87 if gt_streq(s, "descent" as *u8) == 1 { return NT_DESC }
88 if gt_streq(s, "fragmentation" as *u8) == 1 { return NT_FRAG }
89 if gt_streq(s, "variant" as *u8) == 1 { return NT_VAR }
90 if gt_streq(s, "endpoint" as *u8) == 1 { return NT_ENDPOINT }
91 return NT_NONE
92}
93func gt_type_name(t: i64) -> *u8 {
94 if t == NT_ORIGIN { return "origination " as *u8 }
95 if t == NT_PRIM { return "primitive " as *u8 }
96 if t == NT_UNI { return "UNIFICATION " as *u8 }
97 if t == NT_DESC { return "descent " as *u8 }
98 if t == NT_FRAG { return "FRAGMENTATION" as *u8 }
99 if t == NT_VAR { return "variant " as *u8 }
100 if t == NT_ENDPOINT { return "ENDPOINT " as *u8 }
101 return "? " as *u8
102}
103
104// parse the lineage file into the module-global arrays. Returns 0 ok, -1 unreadable.
105func gt_parse(file: *u8) -> i64 {
106 let lenbox: *i64 = sys_mmap(16) as *i64; lenbox[0] = 0
107 let data: *u8 = sys_read_file(file, lenbox)
108 if (data as i64) == 0 { return 0 - 1 }
109 let n: i64 = lenbox[0]
110 // pass 1: count non-comment non-empty rows (data-driven size, no magic cap)
111 var rows: i64 = 0; var ls: i64 = 0; var i: i64 = 0
112 while i <= n {
113 var atend: i64 = 0
114 if i == n { atend = 1 }
115 if i < n { if data[i] == 10 as u8 { atend = 1 } }
116 if atend == 1 { if i > ls { if data[ls] != 35 as u8 { rows = rows + 1 } } ls = i + 1 }
117 i = i + 1
118 }
119 let ids: *i64 = sys_mmap(8 * (rows + 1)) as *i64
120 let types: *i64 = sys_mmap(8 * (rows + 1)) as *i64
121 let parents: *i64 = sys_mmap(8 * (rows + 1)) as *i64
122 let axes: *i64 = sys_mmap(8 * (rows + 1)) as *i64
123 let sovs: *i64 = sys_mmap(8 * (rows + 1)) as *i64
124 let labels: *i64 = sys_mmap(8 * (rows + 1)) as *i64
125 let safety: *i64 = sys_mmap(8 * (rows + 1)) as *i64
126 // pass 2: fill
127 var r: i64 = 0
128 ls = 0; i = 0
129 while i <= n {
130 var atend: i64 = 0
131 if i == n { atend = 1 }
132 if i < n { if data[i] == 10 as u8 { atend = 1 } }
133 if atend == 1 {
134 if i > ls { if data[ls] != 35 as u8 {
135 ids[r] = gt_field_dup(data, ls, i, 0) as i64
136 types[r] = gt_type_code(gt_field_dup(data, ls, i, 1))
137 parents[r] = gt_field_dup(data, ls, i, 2) as i64
138 axes[r] = gt_field_dup(data, ls, i, 3) as i64
139 sovs[r] = gt_field_dup(data, ls, i, 4) as i64
140 labels[r] = gt_field_dup(data, ls, i, 5) as i64
141 safety[r] = gt_field_dup(data, ls, i, 6) as i64
142 r = r + 1
143 } }
144 ls = i + 1
145 }
146 i = i + 1
147 }
148 GT_N = r
149 GT_IDS = ids as i64; GT_TYPES = types as i64; GT_PARENTS = parents as i64
150 GT_AXES = axes as i64; GT_SOVS = sovs as i64; GT_LABELS = labels as i64
151 GT_SAFETY = safety as i64
152 return 0
153}
154
155func gt_find(id: *u8) -> i64 {
156 let ids: *i64 = GT_IDS as *i64
157 var i: i64 = 0
158 while i < GT_N { if gt_streq(ids[i] as *u8, id) == 1 { return i } i = i + 1 }
159 return 0 - 1
160}
161
162// does a UNIFICATION node exist that spans `axis`? 1/0.
163func gt_axis_has_uni(axis: *u8) -> i64 {
164 let types: *i64 = GT_TYPES as *i64
165 let axes: *i64 = GT_AXES as *i64
166 var i: i64 = 0
167 while i < GT_N { if types[i] == NT_UNI { if gt_streq(axes[i] as *u8, axis) == 1 { return 1 } } i = i + 1 }
168 return 0
169}
170
171// DOWN: does node idx's parent-chain bottom out at god (an origination, parent="-")? 1/0.
172func gt_node_reaches_god(idx: i64) -> i64 {
173 let types: *i64 = GT_TYPES as *i64
174 let parents: *i64 = GT_PARENTS as *i64
175 var cur: i64 = idx; var steps: i64 = 0; var go: i64 = 1; var ok: i64 = 0
176 while go == 1 {
177 let par: *u8 = parents[cur] as *u8
178 if gt_streq(par, "-" as *u8) == 1 { if types[cur] == NT_ORIGIN { ok = 1 } go = 0 }
179 else { let p: i64 = gt_find(par); if p < 0 { go = 0 } else { cur = p; steps = steps + 1; if steps > GT_N { go = 0 } } }
180 }
181 return ok
182}
183
184// UP: does any node name `id` as its parent (i.e. id has at least one child)? 1/0.
185func gt_has_child(id: *u8) -> i64 {
186 let parents: *i64 = GT_PARENTS as *i64
187 var i: i64 = 0
188 while i < GT_N { if gt_streq(parents[i] as *u8, id) == 1 { return 1 } i = i + 1 }
189 return 0
190}
191
192// ANALYZE: parse + compute the census into outs. Returns 0 ok, -1 unreadable.
193// outs[0]=nnodes outs[1]=endpoint_reaches_god outs[2]=broken_links
194// outs[3]=fragmentation_axes outs[4]=unification_points outs[5]=LOCKED_axes(no uni)
195// outs[6]=hardware_variants outs[7]=endpoint_found
196func gt_analyze(file: *u8, outs: *i64) -> i64 {
197 if gt_parse(file) != 0 { return 0 - 1 }
198 let types: *i64 = GT_TYPES as *i64
199 let parents: *i64 = GT_PARENTS as *i64
200 let axes: *i64 = GT_AXES as *i64
201 var broken: i64 = 0; var nfrag: i64 = 0; var nuni: i64 = 0; var locked: i64 = 0; var hwvar: i64 = 0
202 var i: i64 = 0
203 while i < GT_N {
204 let par: *u8 = parents[i] as *u8
205 if gt_streq(par, "-" as *u8) == 0 { if gt_find(par) < 0 { broken = broken + 1 } }
206 if types[i] == NT_FRAG { nfrag = nfrag + 1; if gt_axis_has_uni(axes[i] as *u8) == 0 { locked = locked + 1 } }
207 if types[i] == NT_UNI { nuni = nuni + 1 }
208 if types[i] == NT_VAR { if gt_streq(axes[i] as *u8, "hardware" as *u8) == 1 { hwvar = hwvar + 1 } }
209 i = i + 1
210 }
211 // trace EACH endpoint down to god; reached=1 only if ALL endpoints bottom out at origination.
212 var endpoint_found: i64 = 0; var reached: i64 = 1
213 var ei: i64 = 0
214 while ei < GT_N {
215 if types[ei] == NT_ENDPOINT {
216 endpoint_found = 1
217 var cur: i64 = ei; var steps: i64 = 0; var go: i64 = 1; var this_ok: i64 = 0
218 while go == 1 {
219 let par: *u8 = parents[cur] as *u8
220 if gt_streq(par, "-" as *u8) == 1 {
221 if types[cur] == NT_ORIGIN { this_ok = 1 }
222 go = 0
223 } else {
224 let p: i64 = gt_find(par)
225 if p < 0 { go = 0 } else { cur = p; steps = steps + 1; if steps > GT_N { go = 0 } }
226 }
227 }
228 if this_ok == 0 { reached = 0 }
229 }
230 ei = ei + 1
231 }
232 if endpoint_found == 0 { reached = 0 }
233 // COMPLETENESS both directions (operator: no orphans down, no floaters up, no purposeless
234 // -- whether current OR future state). Every node must connect to god AND carry a purpose.
235 let ids: *i64 = GT_IDS as *i64
236 let labels: *i64 = GT_LABELS as *i64
237 let sovs: *i64 = GT_SOVS as *i64
238 let safety: *i64 = GT_SAFETY as *i64
239 var orphans: i64 = 0; var floaters: i64 = 0; var purposeless: i64 = 0
240 // sovereignty census (god -> down): which capabilities are sovereign vs a 3rd-party lock worklist.
241 var sv_sov: i64 = 0; var sv_emu: i64 = 0; var sv_tp: i64 = 0
242 var sv_build: i64 = 0; var sv_fut: i64 = 0; var sv_mix: i64 = 0
243 // NEVER-BRICK: a node on a brickable axis (firmware) MUST carry safety=never-brick.
244 var unsafe: i64 = 0
245 var c: i64 = 0
246 while c < GT_N {
247 // DOWN: every node must bottom out at god, else ORPHAN.
248 if gt_node_reaches_god(c) == 0 { orphans = orphans + 1 }
249 // UP: endpoints are tops, variants are instance-leaves, a UNIFICATION is a legit
250 // axis-spanning cap (it need not lead further up); ANY OTHER childless node = FLOATER.
251 if types[c] != NT_ENDPOINT { if types[c] != NT_VAR { if types[c] != NT_UNI {
252 if gt_has_child(ids[c] as *u8) == 0 { floaters = floaters + 1 }
253 } } }
254 // PURPOSE: every node needs a flagged purpose (non-empty label) and a known type.
255 let lab: *u8 = labels[c] as *u8
256 if lab[0] == 0 as u8 { purposeless = purposeless + 1 }
257 else { if types[c] == NT_NONE { purposeless = purposeless + 1 } }
258 // SOVEREIGNTY tally (third-party + future = the lock worklist from god down).
259 let sv: *u8 = sovs[c] as *u8
260 if gt_streq(sv, "sovereign" as *u8) == 1 { sv_sov = sv_sov + 1 }
261 if gt_streq(sv, "sovereign-emu" as *u8) == 1 { sv_emu = sv_emu + 1 }
262 if gt_streq(sv, "third-party" as *u8) == 1 { sv_tp = sv_tp + 1 }
263 if gt_streq(sv, "building" as *u8) == 1 { sv_build = sv_build + 1 }
264 if gt_streq(sv, "future" as *u8) == 1 { sv_fut = sv_fut + 1 }
265 if gt_streq(sv, "mixed" as *u8) == 1 { sv_mix = sv_mix + 1 }
266 // NEVER-BRICK: any firmware-axis node must declare never-brick (read-only/reversible/fail-safe).
267 if gt_streq(axes[c] as *u8, "firmware" as *u8) == 1 {
268 if gt_streq(safety[c] as *u8, "never-brick" as *u8) == 0 { unsafe = unsafe + 1 }
269 }
270 c = c + 1
271 }
272 outs[0] = GT_N; outs[1] = reached; outs[2] = broken; outs[3] = nfrag
273 outs[4] = nuni; outs[5] = locked; outs[6] = hwvar; outs[7] = endpoint_found
274 outs[8] = orphans; outs[9] = floaters; outs[10] = purposeless
275 outs[11] = sv_sov; outs[12] = sv_emu; outs[13] = sv_tp
276 outs[14] = sv_build; outs[15] = sv_fut; outs[16] = sv_mix
277 outs[17] = unsafe
278 return 0
279}
280
281// print the endpoint's chain endpoint -> god (each node id + type + sovereignty + label).
282func gt_print_spine() -> i64 {
283 let ids: *i64 = GT_IDS as *i64
284 let types: *i64 = GT_TYPES as *i64
285 let parents: *i64 = GT_PARENTS as *i64
286 let sovs: *i64 = GT_SOVS as *i64
287 let labels: *i64 = GT_LABELS as *i64
288 // find an endpoint
289 var ei: i64 = 0 - 1
290 var i: i64 = 0
291 while i < GT_N { if types[i] == NT_ENDPOINT { ei = i; i = GT_N } else { i = i + 1 } }
292 if ei < 0 { gt_puts(" (no endpoint node)\n"); return 0 }
293 gt_puts(" SPINE (endpoint -> god):\n")
294 var cur: i64 = ei; var steps: i64 = 0; var go: i64 = 1
295 while go == 1 {
296 gt_puts(" "); gt_puts(gt_type_name(types[cur])); gt_puts(" ")
297 gt_puts(ids[cur] as *u8); gt_puts(" ["); gt_puts(sovs[cur] as *u8); gt_puts("] ")
298 gt_puts(labels[cur] as *u8); gt_puts("\n")
299 let par: *u8 = parents[cur] as *u8
300 if gt_streq(par, "-" as *u8) == 1 { go = 0 } else {
301 let p: i64 = gt_find(par)
302 if p < 0 { gt_puts(" !! BROKEN LINK: parent '"); gt_puts(par); gt_puts("' not found\n"); go = 0 }
303 else { cur = p; steps = steps + 1; if steps > GT_N { go = 0 } }
304 }
305 }
306 return 0
307}
308
309func main() -> i64 {
310 gt_puts("=== NISHI GENESIS GENEALOGY (god -> adam&eve -> ... -> IO endpoint) ===\n")
311 let outs: *i64 = sys_mmap(256) as *i64
312 if gt_analyze(GT_FILE, outs) != 0 {
313 gt_puts("FATAL: "); gt_puts(GT_FILE); gt_puts(" unreadable -- no lineage data\n")
314 sys_exit(1); return 1
315 }
316 gt_print_spine()
317 gt_puts(" CENSUS: nodes="); gt_putn(outs[0])
318 gt_puts(" fragmentation_axes="); gt_putn(outs[3])
319 gt_puts(" unification_points="); gt_putn(outs[4])
320 gt_puts(" hardware_variants="); gt_putn(outs[6]); gt_puts("\n")
321 gt_puts(" endpoint(IO loop) found="); gt_putn(outs[7])
322 gt_puts(" reaches god(origination)="); gt_putn(outs[1])
323 gt_puts(" broken_links="); gt_putn(outs[2])
324 gt_puts(" LOCKED_axes(no unification)="); gt_putn(outs[5]); gt_puts("\n")
325 gt_puts(" COMPLETENESS: orphans(no god down)="); gt_putn(outs[8])
326 gt_puts(" floaters(no purpose up)="); gt_putn(outs[9])
327 gt_puts(" purposeless(no flag)="); gt_putn(outs[10]); gt_puts("\n")
328 gt_puts(" SOVEREIGNTY(god->down): sovereign="); gt_putn(outs[11])
329 gt_puts(" sovereign-emu="); gt_putn(outs[12])
330 gt_puts(" building="); gt_putn(outs[14])
331 gt_puts(" future="); gt_putn(outs[15])
332 gt_puts(" third-party(lock worklist)="); gt_putn(outs[13])
333 gt_puts(" mixed="); gt_putn(outs[16]); gt_puts("\n")
334 gt_puts(" NEVER-BRICK: firmware/CMOS nodes missing a never-brick guarantee="); gt_putn(outs[17]); gt_puts("\n")
335 if outs[17] > 0 { gt_puts(" VERDICT: NEVER-BRICK VIOLATION -- firmware/CMOS node without a never-brick guarantee\n"); sys_exit(1); return 1 }
336 if outs[2] > 0 { gt_puts(" VERDICT: BROKEN CHAIN (dangling parent)\n"); sys_exit(1); return 1 }
337 if outs[1] == 0 { gt_puts(" VERDICT: endpoint does NOT bottom out at god(origination)\n"); sys_exit(1); return 1 }
338 if outs[8] > 0 { gt_puts(" VERDICT: ORPHAN(s) -- node(s) do not connect down to god\n"); sys_exit(1); return 1 }
339 if outs[9] > 0 { gt_puts(" VERDICT: FLOATER(s) -- node(s) with no upward purpose toward the IO endpoint\n"); sys_exit(1); return 1 }
340 if outs[10] > 0 { gt_puts(" VERDICT: PURPOSELESS node(s) -- missing a flagged purpose (current or future)\n"); sys_exit(1); return 1 }
341 gt_puts(" VERDICT: chain whole god->IO-endpoint, no orphans/floaters/purposeless; ")
342 if outs[5] == 0 { gt_puts("every fragmentation axis has a unification (not locked to any 3rd party)\n") }
343 else { gt_puts("but "); gt_putn(outs[5]); gt_puts(" axis(es) still LOCKED (no unification) = the worklist\n") }
344 sys_exit(0); return 0
345}