code wiki / _hdl_build / nx_root_trace.nx
nx_root_trace.nx source
↩ module page · 329 lines · 13816 B
1// nx_root_trace.nx -- THE ROOT-TRACE INSTRUMENT (Genealogist SIL metric), operator
2// 2026-06-13: "make sure that we can go from spore up emitting all of our shapes that
3// have gotten us to where we are."
4//
5// The no-floating LADDER (nx_capability_ladder) already proves every QUEUE row rests on a
6// DONE foundation. This is its GENEALOGY twin: it walks lineage.tsv's child<-parents edges
7// and proves every ORGAN traces UP, by an unbroken parent chain, to the SPORE -- the genesis
8// node rv64im_min_sim (BOOTSTRAP_MAP "god"). A node that CANNOT reach the spore is the
9// genealogical equivalent of a floating capability:
10// FLOATING-ROOT = parents "-" but the node is NOT the spore (claims no parent, yet isn't god)
11// BROKEN-LINK = a named parent has NO row in the tree (a dangling ancestor)
12// UNROOTED = all parents present but at least one does not itself reach the spore
13// Drives traced -> nodes, broken_links -> 0, floating_roots -> 1 (only the spore).
14//
15// Mechanism mirrors the proven capability-ladder fixpoint, but over the lineage parents
16// column instead of the queue deps column (DRY of idiom, not of code -- the formats differ).
17// SELF-VALIDATING (no false-green): a baked pos control (child of the spore traces) and a
18// neg control (a non-spore "-" root + a child of an absent spore stays untraced) run on a
19// synthetic in-memory tree BEFORE the real lineage.tsv; controls wrong -> RED, exit 1.
20// Sovereign: raw syscalls, no shell/sed/awk, no third-party. license_tier: ORIGINAL
21import "nx_syscalls.nx"
22const RT_MAGIC_1048576: i64 = 1048576
23const RT_MAGIC_1048575: i64 = 1048575
24
25const RT_MAX: i64 = 512
26const RT_IDCAP: i64 = 48
27const RT_PARCAP: i64 = 320
28const RT_LIN: *u8 = "knowledge/registry/lineage.tsv"
29const RT_LOG: *u8 = "knowledge/status/root_trace.log"
30const RT_SPORE: *u8 = "rv64im_min_sim"
31
32func rt_w(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 }
33func rt_wn(fd: i64, v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8 = sys_mmap(28); var k: i64=0; if m==0 {t[0]=48 as u8;k=1}; while m>0 {t[k]=(48+(m%10)) as u8; 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 }
34
35func rt_streq(a: *u8, b: *u8) -> i64 {
36 var i: i64 = 0
37 while i < 64 {
38 if a[i] != b[i] { return 0 }
39 if a[i] == (0 as u8) { return 1 }
40 i = i + 1
41 }
42 return 1
43}
44
45// a parent token containing '.' is a DATA surface (a .tsv/.conf epigenetic input), not a build
46// ancestor -- it does not need to root and is never a broken organ-link.
47func rt_has_dot(s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { if s[i] == (46 as u8) { return 1 } i = i + 1 } return 0 }
48
49func rt_id_at(base: i64, r: i64) -> *u8 { return (base + r * RT_IDCAP) as *u8 }
50func rt_par_at(base: i64, r: i64) -> *u8 { return (base + r * RT_PARCAP) as *u8 }
51
52func rt_set(base: i64, cap: i64, r: i64, s: *u8) -> i64 {
53 let d: *u8 = (base + r * cap) as *u8
54 var i: i64 = 0
55 while s[i] != (0 as u8) { d[i] = s[i]; i = i + 1 }
56 d[i] = 0 as u8
57 return 0
58}
59
60// find a node by id; -1 if absent
61func rt_find(idbase: i64, n: i64, name: *u8) -> i64 {
62 var r: i64 = 0
63 while r < n { if rt_streq(rt_id_at(idbase, r), name) == 1 { return r } r = r + 1 }
64 return 0 - 1
65}
66
67// parse lineage.tsv: capture field 0 (child id) + field 1 (parents). returns row count.
68func rt_load(path: *u8, idbase: i64, parbase: i64) -> i64 {
69 let buf: *u8 = sys_mmap(RT_MAGIC_1048576)
70 let fd: i64 = sys_openat_rd(path)
71 if fd < 0 { return 0 }
72 var n: i64 = 0
73 var r: i64 = sys_read(fd, buf, RT_MAGIC_1048575)
74 while r > 0 { n = n + r; r = sys_read(fd, buf + n, RT_MAGIC_1048575 - n) }
75 sys_close(fd)
76 var rows: i64 = 0
77 var i: i64 = 0
78 while i < n {
79 if buf[i] == (35 as u8) {
80 var sk: i64 = 1
81 while sk == 1 { if i >= n { sk = 0 } else { if buf[i] == (10 as u8) { sk = 0 } i = i + 1 } }
82 } else {
83 var f: i64 = 0
84 var fs: i64 = i
85 var idok: i64 = 0
86 while f < 7 {
87 var fe: i64 = fs
88 var scan: i64 = 1
89 while scan == 1 {
90 if fe >= n { scan = 0 } else {
91 if buf[fe] == (9 as u8) { scan = 0 } else {
92 if buf[fe] == (10 as u8) { scan = 0 } else { fe = fe + 1 }
93 }
94 }
95 }
96 let flen: i64 = fe - fs
97 if f == 0 {
98 if flen > 0 { if flen < RT_IDCAP {
99 let dst: *u8 = rt_id_at(idbase, rows)
100 var k: i64 = 0
101 while k < flen { dst[k] = buf[fs + k]; k = k + 1 }
102 dst[flen] = 0 as u8
103 idok = 1
104 } }
105 }
106 if f == 1 {
107 let pd: *u8 = rt_par_at(parbase, rows)
108 var k2: i64 = 0
109 while k2 < flen { if k2 < RT_PARCAP - 1 { pd[k2] = buf[fs + k2] } k2 = k2 + 1 }
110 var pl: i64 = flen
111 if pl > RT_PARCAP - 1 { pl = RT_PARCAP - 1 }
112 pd[pl] = 0 as u8
113 }
114 fs = fe + 1
115 if fe < n { if buf[fe] == (10 as u8) { f = 7; fs = fe + 1 } }
116 f = f + 1
117 if fs > n { f = 7 }
118 }
119 i = fs
120 if idok == 1 { if rows < RT_MAX - 1 { rows = rows + 1 } }
121 }
122 }
123 return rows
124}
125
126// fixpoint: traced[spore]=1; a node is traced iff all its parents are present AND traced.
127// a "-" parents node is traced ONLY if it IS the spore. returns traced count.
128func rt_trace(idbase: i64, parbase: i64, n: i64, spore: *u8, traced: *i64) -> i64 {
129 var r: i64 = 0
130 while r < n {
131 traced[r] = 0
132 if rt_streq(rt_id_at(idbase, r), spore) == 1 { traced[r] = 1 }
133 r = r + 1
134 }
135 let tok: *u8 = sys_mmap(RT_IDCAP)
136 var pass: i64 = 0
137 var go: i64 = 1
138 while go == 1 {
139 var changed: i64 = 0
140 var r2: i64 = 0
141 while r2 < n {
142 if traced[r2] == 0 {
143 let pd: *u8 = rt_par_at(parbase, r2)
144 if pd[0] == (45 as u8) {
145 // "-": only the spore qualifies (already set); nothing to do
146 } else {
147 var i: i64 = 0
148 var k: i64 = 0
149 var allpres: i64 = 1
150 var alltraced: i64 = 1
151 var gp: i64 = 1
152 while gp == 1 {
153 let ch: i64 = pd[i] as i64
154 var fin: i64 = 0
155 if ch == 0 { fin = 1 }
156 if ch == 44 { fin = 1 }
157 if fin == 1 {
158 if k > 0 {
159 tok[k] = 0 as u8
160 if rt_has_dot(tok) == 0 {
161 let pr: i64 = rt_find(idbase, n, tok)
162 if pr < 0 { allpres = 0 } else { if traced[pr] == 0 { alltraced = 0 } }
163 }
164 k = 0
165 }
166 if ch == 0 { gp = 0 }
167 } else {
168 if k < RT_IDCAP - 1 { tok[k] = ch as u8; k = k + 1 }
169 }
170 i = i + 1
171 }
172 if allpres == 1 { if alltraced == 1 { traced[r2] = 1; changed = 1 } }
173 }
174 }
175 r2 = r2 + 1
176 }
177 pass = pass + 1
178 if changed == 0 { go = 0 }
179 if pass >= 256 { go = 0 }
180 }
181 var tc: i64 = 0
182 var r3: i64 = 0
183 while r3 < n { if traced[r3] == 1 { tc = tc + 1 } r3 = r3 + 1 }
184 return tc
185}
186
187// does node r name any parent that has no row in the tree?
188func rt_has_missing(idbase: i64, parbase: i64, n: i64, r: i64) -> i64 {
189 let pd: *u8 = rt_par_at(parbase, r)
190 if pd[0] == (45 as u8) { return 0 }
191 let tok: *u8 = sys_mmap(RT_IDCAP)
192 var i: i64 = 0
193 var k: i64 = 0
194 var miss: i64 = 0
195 var gp: i64 = 1
196 while gp == 1 {
197 let ch: i64 = pd[i] as i64
198 var fin: i64 = 0
199 if ch == 0 { fin = 1 }
200 if ch == 44 { fin = 1 }
201 if fin == 1 {
202 if k > 0 { tok[k] = 0 as u8; if rt_has_dot(tok) == 0 { if rt_find(idbase, n, tok) < 0 { miss = 1 } } k = 0 }
203 if ch == 0 { gp = 0 }
204 } else { if k < RT_IDCAP - 1 { tok[k] = ch as u8; k = k + 1 } }
205 i = i + 1
206 }
207 return miss
208}
209
210// classify ONE untraced node and print its ROOTGAP line (the genealogist worklist).
211func rt_gap_line(fd: i64, idbase: i64, parbase: i64, n: i64, r: i64, traced: *i64) -> i64 {
212 let pd: *u8 = rt_par_at(parbase, r)
213 rt_w(fd, "ROOTGAP id=" as *u8); rt_w(fd, rt_id_at(idbase, r))
214 if pd[0] == (45 as u8) {
215 rt_w(fd, " reason=FLOATING-ROOT parents=- not-the-spore\n" as *u8)
216 return 0
217 }
218 let tok: *u8 = sys_mmap(RT_IDCAP)
219 var i: i64 = 0
220 var k: i64 = 0
221 var reported: i64 = 0
222 var gp: i64 = 1
223 while gp == 1 {
224 let ch: i64 = pd[i] as i64
225 var fin: i64 = 0
226 if ch == 0 { fin = 1 }
227 if ch == 44 { fin = 1 }
228 if fin == 1 {
229 if k > 0 {
230 tok[k] = 0 as u8
231 if reported == 0 { if rt_has_dot(tok) == 0 {
232 let pr: i64 = rt_find(idbase, n, tok)
233 if pr < 0 {
234 rt_w(fd, " reason=BROKEN-LINK missing-parent=" as *u8); rt_w(fd, tok); rt_w(fd, "\n" as *u8); reported = 1
235 } else { if traced[pr] == 0 {
236 rt_w(fd, " reason=UNROOTED-PARENT=" as *u8); rt_w(fd, tok); rt_w(fd, "\n" as *u8); reported = 1
237 } }
238 } }
239 k = 0
240 }
241 if ch == 0 { gp = 0 }
242 } else { if k < RT_IDCAP - 1 { tok[k] = ch as u8; k = k + 1 } }
243 i = i + 1
244 }
245 if reported == 0 { rt_w(fd, " reason=UNROOTED\n" as *u8) }
246 return 0
247}
248
249func rt_gate(fd: i64, cpos: i64, cneg: i64, present: i64, nodes: i64, traced: i64, broken: i64, froots: i64, epoch: i64, ok: i64) -> i64 {
250 rt_w(fd, "ROOTTRACE authored=organ spore=rv64im_min_sim control_pos=" as *u8); rt_wn(fd, cpos)
251 rt_w(fd, " control_neg=" as *u8); rt_wn(fd, cneg)
252 rt_w(fd, " spore_present=" as *u8); rt_wn(fd, present)
253 rt_w(fd, " nodes=" as *u8); rt_wn(fd, nodes)
254 rt_w(fd, " traced=" as *u8); rt_wn(fd, traced)
255 rt_w(fd, " broken_links=" as *u8); rt_wn(fd, broken)
256 rt_w(fd, " floating_roots=" as *u8); rt_wn(fd, froots)
257 var coh: i64 = 0
258 if traced == nodes { if present == 1 { coh = 1 } }
259 if coh == 1 { rt_w(fd, " all_traced=YES" as *u8) } else { rt_w(fd, " all_traced=NO" as *u8) }
260 rt_w(fd, " epoch=" as *u8); rt_wn(fd, epoch)
261 if ok == 1 { rt_w(fd, " verdict=GREEN\n" as *u8) } else { rt_w(fd, " verdict=RED\n" as *u8) }
262 return 0
263}
264
265func main() -> i64 {
266 // ---- baked self-test on a synthetic tree (no false-green) ----
267 let tib: i64 = sys_mmap(4 * RT_IDCAP) as i64
268 let tpb: i64 = sys_mmap(4 * RT_PARCAP) as i64
269 let ttr: *i64 = sys_mmap(4 * 8) as *i64
270 // pos: spore "S" + child "C"<-"S" -> C must trace, count 2
271 rt_set(tib, RT_IDCAP, 0, "S" as *u8); rt_set(tpb, RT_PARCAP, 0, "-" as *u8)
272 rt_set(tib, RT_IDCAP, 1, "C" as *u8); rt_set(tpb, RT_PARCAP, 1, "S" as *u8)
273 let tcp: i64 = rt_trace(tib, tpb, 2, "S" as *u8, ttr)
274 var cpos: i64 = 0
275 if ttr[1] == 1 { if tcp == 2 { cpos = 1 } }
276 // neg: a non-spore "-" root "A" + child "B"<-"A", spore "Z" absent -> none trace
277 rt_set(tib, RT_IDCAP, 0, "A" as *u8); rt_set(tpb, RT_PARCAP, 0, "-" as *u8)
278 rt_set(tib, RT_IDCAP, 1, "B" as *u8); rt_set(tpb, RT_PARCAP, 1, "A" as *u8)
279 let tcn: i64 = rt_trace(tib, tpb, 2, "Z" as *u8, ttr)
280 var cneg: i64 = 0
281 if tcn == 0 { cneg = 1 }
282 var ok: i64 = 1
283 if cpos != 1 { ok = 0 }
284 if cneg != 1 { ok = 0 }
285 let epoch: i64 = sys_now_realtime_sec()
286
287 if ok == 0 {
288 rt_gate(1, cpos, cneg, 0, 0, 0, 0, 0, epoch, 0)
289 let lf0: i64 = sys_openat_append(RT_LOG, 420)
290 if lf0 >= 0 { rt_gate(lf0, cpos, cneg, 0, 0, 0, 0, 0, epoch, 0); sys_close(lf0) }
291 sys_exit(1); return 1
292 }
293
294 // ---- the real tree ----
295 let idbase: i64 = sys_mmap(RT_MAX * RT_IDCAP) as i64
296 let parbase: i64 = sys_mmap(RT_MAX * RT_PARCAP) as i64
297 let n: i64 = rt_load(RT_LIN, idbase, parbase)
298 if n <= 0 { rt_w(1, "ROOTTRACE verdict=RED reason=lineage-missing\n" as *u8); sys_exit(1); return 1 }
299
300 let traced: *i64 = sys_mmap(RT_MAX * 8) as *i64
301 let tc: i64 = rt_trace(idbase, parbase, n, RT_SPORE, traced)
302 var present: i64 = 0
303 if rt_find(idbase, n, RT_SPORE) >= 0 { present = 1 }
304
305 var broken: i64 = 0
306 var froots: i64 = 0
307 var r: i64 = 0
308 while r < n {
309 if traced[r] == 0 {
310 let pd: *u8 = rt_par_at(parbase, r)
311 if pd[0] == (45 as u8) { froots = froots + 1 }
312 else { if rt_has_missing(idbase, parbase, n, r) == 1 { broken = broken + 1 } }
313 }
314 r = r + 1
315 }
316
317 rt_gate(1, cpos, cneg, present, n, tc, broken, froots, epoch, 1)
318 var rg: i64 = 0
319 while rg < n { if traced[rg] == 0 { rt_gap_line(1, idbase, parbase, n, rg, traced) } rg = rg + 1 }
320
321 let lf: i64 = sys_openat_append(RT_LOG, 420)
322 if lf >= 0 {
323 rt_gate(lf, cpos, cneg, present, n, tc, broken, froots, epoch, 1)
324 rg = 0
325 while rg < n { if traced[rg] == 0 { rt_gap_line(lf, idbase, parbase, n, rg, traced) } rg = rg + 1 }
326 sys_close(lf)
327 }
328 sys_exit(0); return 0
329}