code wiki / _hdl_build / nx_evolution_ladder.nx
nx_evolution_ladder.nx source
↩ module page · 269 lines · 12240 B
1// nx_evolution_ladder.nx -- THE GRACEFUL EVOLUTION LADDER organ.
2//
3// module: nishi-core.doctrine.evolution_ladder
4// capability: CORE_COMPUTE (the honest "where we are" on the god->canopy technology tree)
5//
6// Charter: knowledge/specs/2026-06-16-graceful-evolution-charter.md.
7// Reads knowledge/registry/evolution_ladder.tsv (one row per tree-layer) and, FRESH every run:
8// * VERIFIES each layer's evidence_src file actually exists (does not trust a declared grade);
9// * COMPUTES the verified maturity rung (ABSENT..PHYSICS-OPTIMUM) from (evidence_kind, file-exists);
10// * THE LIAR-KILL: a layer claiming measured/exceed/physics whose evidence file does NOT exist is
11// counted `unproven` -> VERDICT RED. No "S-class exceeds" claim survives without its artifact.
12// * tree-whole: every layer reaches the HW root (no broken parents), and carries a purpose;
13// * NEVER-BRICK (Rule 26, inherited from genesis): a layer doing persistent hardware writes but not
14// proven (safety=brickable) is counted `unsafe` -> RED.
15// Sovereign: imports only nx_syscalls (no gcc/sed/awk). license_tier: ORIGINAL
16
17import "nx_syscalls.nx"
18
19const EL_FILE: *u8 = "knowledge/registry/evolution_ladder.tsv"
20
21// the maturity ladder (the honest "where we are"), as rung codes.
22const RK_ABSENT: i64 = 0
23const RK_SPEC: i64 = 1
24const RK_BUILT: i64 = 2
25const RK_GATED: i64 = 3
26const RK_MEASURED: i64 = 4
27const RK_EXCEEDS: i64 = 5
28const RK_PHYSICS: i64 = 6
29
30// parsed graph (module-global; re-parsed per el_analyze call).
31static EL_N: i64
32static EL_IDS: i64 // *i64 of *u8 (layer id)
33static EL_PARENTS: i64 // *i64 of *u8 (parent id)
34static EL_TELOS: i64 // *i64 of *u8 (telos phrase)
35static EL_KINDS: i64 // *i64 (rung code from evidence_kind)
36static EL_SRCS: i64 // *i64 of *u8 (evidence_src path)
37static EL_SAFETY: i64 // *i64 of *u8 (never-brick | brickable | -)
38static EL_LABELS: i64 // *i64 of *u8 (label)
39
40func el_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != 0 as u8 { n = n + 1 } sys_write(1, s, n); return 0 }
41func el_putn(v: i64) -> i64 {
42 if v == 0 { sys_write(1, "0" as *u8, 1); return 0 }
43 var m: i64 = v
44 if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
45 let d: *u8 = sys_mmap(24); var k: i64 = 0
46 while m > 0 { d[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
47 var j: i64 = k - 1
48 while j >= 0 { sys_write(1, ((d as i64)+j) as *u8, 1); j = j - 1 }
49 return 0
50}
51func el_streq(a: *u8, b: *u8) -> i64 {
52 var i: i64 = 0
53 while a[i] != 0 as u8 { if a[i] != b[i] { return 0 } i = i + 1 }
54 if b[i] != 0 as u8 { return 0 }
55 return 1
56}
57
58// TAB field f (0-based) of line[ls,le) copied into a FRESH NUL-term mmap; returns ptr.
59func el_field_dup(b: *u8, ls: i64, le: i64, f: i64) -> *u8 {
60 var cur: i64 = 0
61 var i: i64 = ls
62 while cur < f {
63 if i >= le { let e: *u8 = sys_mmap(2); e[0] = 0 as u8; return e }
64 if b[i] == 9 as u8 { cur = cur + 1 }
65 i = i + 1
66 }
67 let out: *u8 = sys_mmap(256)
68 var o: i64 = 0
69 while i < le {
70 if b[i] == 9 as u8 { i = le } else { if o < 255 { out[o] = b[i]; o = o + 1 } i = i + 1 }
71 }
72 out[o] = 0 as u8
73 return out
74}
75
76// evidence_kind string -> the rung it CLAIMS (verified later against file-exists).
77func el_kind_code(s: *u8) -> i64 {
78 if el_streq(s, "spec" as *u8) == 1 { return RK_SPEC }
79 if el_streq(s, "build" as *u8) == 1 { return RK_BUILT }
80 if el_streq(s, "gate" as *u8) == 1 { return RK_GATED }
81 if el_streq(s, "measured" as *u8) == 1 { return RK_MEASURED }
82 if el_streq(s, "exceed" as *u8) == 1 { return RK_EXCEEDS }
83 if el_streq(s, "physics" as *u8) == 1 { return RK_PHYSICS }
84 return RK_ABSENT
85}
86func el_rung_name(r: i64) -> *u8 {
87 if r == RK_ABSENT { return "ABSENT " as *u8 }
88 if r == RK_SPEC { return "SPEC'D " as *u8 }
89 if r == RK_BUILT { return "BUILT " as *u8 }
90 if r == RK_GATED { return "GATED " as *u8 }
91 if r == RK_MEASURED { return "MEASURED " as *u8 }
92 if r == RK_EXCEEDS { return "EXCEEDS " as *u8 }
93 if r == RK_PHYSICS { return "PHYSICS-OPT" as *u8 }
94 return "? " as *u8
95}
96
97// does the evidence file exist + read? "-" => no evidence. 1/0.
98func el_exists(path: *u8) -> i64 {
99 if el_streq(path, "-" as *u8) == 1 { return 0 }
100 let lenbox: *i64 = sys_mmap(16) as *i64; lenbox[0] = 0
101 let data: *u8 = sys_read_file(path, lenbox)
102 if (data as i64) == 0 { return 0 }
103 return 1
104}
105
106// parse the ladder file into the module-global arrays. Returns 0 ok, -1 unreadable.
107func el_parse(file: *u8) -> i64 {
108 let lenbox: *i64 = sys_mmap(16) as *i64; lenbox[0] = 0
109 let data: *u8 = sys_read_file(file, lenbox)
110 if (data as i64) == 0 { return 0 - 1 }
111 let n: i64 = lenbox[0]
112 var rows: i64 = 0; var ls: i64 = 0; var i: i64 = 0
113 while i <= n {
114 var atend: i64 = 0
115 if i == n { atend = 1 }
116 if i < n { if data[i] == 10 as u8 { atend = 1 } }
117 if atend == 1 { if i > ls { if data[ls] != 35 as u8 { rows = rows + 1 } } ls = i + 1 }
118 i = i + 1
119 }
120 let ids: *i64 = sys_mmap(8 * (rows + 1)) as *i64
121 let parents: *i64 = sys_mmap(8 * (rows + 1)) as *i64
122 let telos: *i64 = sys_mmap(8 * (rows + 1)) as *i64
123 let kinds: *i64 = sys_mmap(8 * (rows + 1)) as *i64
124 let srcs: *i64 = sys_mmap(8 * (rows + 1)) as *i64
125 let safety: *i64 = sys_mmap(8 * (rows + 1)) as *i64
126 let labels: *i64 = sys_mmap(8 * (rows + 1)) as *i64
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] = el_field_dup(data, ls, i, 0) as i64
136 parents[r] = el_field_dup(data, ls, i, 1) as i64
137 telos[r] = el_field_dup(data, ls, i, 2) as i64
138 kinds[r] = el_kind_code(el_field_dup(data, ls, i, 3))
139 srcs[r] = el_field_dup(data, ls, i, 4) as i64
140 safety[r] = el_field_dup(data, ls, i, 5) as i64
141 labels[r] = el_field_dup(data, ls, i, 6) as i64
142 r = r + 1
143 } }
144 ls = i + 1
145 }
146 i = i + 1
147 }
148 EL_N = r
149 EL_IDS = ids as i64; EL_PARENTS = parents as i64; EL_TELOS = telos as i64
150 EL_KINDS = kinds as i64; EL_SRCS = srcs as i64; EL_SAFETY = safety as i64; EL_LABELS = labels as i64
151 return 0
152}
153
154func el_find(id: *u8) -> i64 {
155 let ids: *i64 = EL_IDS as *i64
156 var i: i64 = 0
157 while i < EL_N { if el_streq(ids[i] as *u8, id) == 1 { return i } i = i + 1 }
158 return 0 - 1
159}
160
161// read accessors (expose the parsed ladder to consumers like the live wiki page generator,
162// so a published article renders the COMPUTED grades, never hand-typed numbers).
163func el_count() -> i64 { return EL_N }
164func el_id(i: i64) -> *u8 { let ids: *i64 = EL_IDS as *i64; return ids[i] as *u8 }
165func el_label(i: i64) -> *u8 { let labels: *i64 = EL_LABELS as *i64; return labels[i] as *u8 }
166
167// verified rung of layer idx: declared rung if its evidence file exists, else ABSENT.
168func el_verified_rung(idx: i64) -> i64 {
169 let kinds: *i64 = EL_KINDS as *i64
170 let srcs: *i64 = EL_SRCS as *i64
171 let k: i64 = kinds[idx]
172 if el_exists(srcs[idx] as *u8) == 0 { return RK_ABSENT }
173 return k
174}
175
176// ANALYZE: parse + compute the census into outs. Returns 0 ok, -1 unreadable.
177// outs[0]=nlayers outs[1]=root_found outs[2]=broken outs[3]=unproven
178// outs[4]=purposeless outs[5]=unsafe outs[6..12]=count by rung (ABSENT..PHYSICS) outs[13]=max_rung
179func el_analyze(file: *u8, outs: *i64) -> i64 {
180 if el_parse(file) != 0 { return 0 - 1 }
181 let parents: *i64 = EL_PARENTS as *i64
182 let kinds: *i64 = EL_KINDS as *i64
183 let srcs: *i64 = EL_SRCS as *i64
184 let telos: *i64 = EL_TELOS as *i64
185 let labels: *i64 = EL_LABELS as *i64
186 let safety: *i64 = EL_SAFETY as *i64
187 let cnt: *i64 = sys_mmap(8 * 8) as *i64
188 var z: i64 = 0; while z < 8 { cnt[z] = 0; z = z + 1 }
189 var root_found: i64 = 0; var broken: i64 = 0; var unproven: i64 = 0
190 var purposeless: i64 = 0; var unsafe: i64 = 0; var maxr: i64 = 0
191 var i: i64 = 0
192 while i < EL_N {
193 // tree: parent "-" is the root; any other parent must resolve.
194 let par: *u8 = parents[i] as *u8
195 if el_streq(par, "-" as *u8) == 1 { root_found = 1 }
196 else { if el_find(par) < 0 { broken = broken + 1 } }
197 // verified rung (computed from artifact existence, not declaration).
198 let k: i64 = kinds[i]
199 let ex: i64 = el_exists(srcs[i] as *u8)
200 var vr: i64 = k
201 if ex == 0 { vr = RK_ABSENT }
202 // LIAR-KILL: a claimed measured/exceed/physics with no artifact = unproven.
203 if k >= RK_MEASURED { if ex == 0 { unproven = unproven + 1 } }
204 cnt[vr] = cnt[vr] + 1
205 if vr > maxr { maxr = vr }
206 // PURPOSE: every layer needs a telos and a label.
207 let tl: *u8 = telos[i] as *u8
208 let lb: *u8 = labels[i] as *u8
209 if tl[0] == 0 as u8 { purposeless = purposeless + 1 }
210 else { if lb[0] == 0 as u8 { purposeless = purposeless + 1 } }
211 // NEVER-BRICK (Rule 26): a hardware-write layer not yet proven safe.
212 if el_streq(safety[i] as *u8, "brickable" as *u8) == 1 { unsafe = unsafe + 1 }
213 i = i + 1
214 }
215 outs[0] = EL_N; outs[1] = root_found; outs[2] = broken; outs[3] = unproven
216 outs[4] = purposeless; outs[5] = unsafe
217 var c: i64 = 0
218 while c < 7 { outs[6 + c] = cnt[c]; c = c + 1 }
219 outs[13] = maxr
220 return 0
221}
222
223// print the ladder root -> canopy (file order), each layer's VERIFIED rung + id + label.
224func el_print_ladder() -> i64 {
225 let ids: *i64 = EL_IDS as *i64
226 let labels: *i64 = EL_LABELS as *i64
227 el_puts(" THE TREE (verified rung layer label):\n")
228 var i: i64 = 0
229 while i < EL_N {
230 let vr: i64 = el_verified_rung(i)
231 el_puts(" "); el_puts(el_rung_name(vr)); el_puts(" ")
232 el_puts(ids[i] as *u8); el_puts(" "); el_puts(labels[i] as *u8); el_puts("\n")
233 i = i + 1
234 }
235 return 0
236}
237
238func main() -> i64 {
239 el_puts("=== NISHI GRACEFUL EVOLUTION LADDER (god/hardware -> research-engine) ===\n")
240 let outs: *i64 = sys_mmap(256) as *i64
241 if el_analyze(EL_FILE, outs) != 0 {
242 el_puts("FATAL: "); el_puts(EL_FILE); el_puts(" unreadable -- no ladder data\n")
243 sys_exit(1); return 1
244 }
245 el_print_ladder()
246 el_puts(" WHERE WE ARE (verified-rung census): ABSENT="); el_putn(outs[6])
247 el_puts(" SPEC'D="); el_putn(outs[7])
248 el_puts(" BUILT="); el_putn(outs[8])
249 el_puts(" GATED="); el_putn(outs[9])
250 el_puts(" MEASURED="); el_putn(outs[10])
251 el_puts(" EXCEEDS="); el_putn(outs[11])
252 el_puts(" PHYSICS-OPT="); el_putn(outs[12]); el_puts("\n")
253 el_puts(" HONEST-ACCOUNTING: layers="); el_putn(outs[0])
254 el_puts(" unproven-exceed-claims="); el_putn(outs[3])
255 el_puts(" highest-verified-rung="); el_puts(el_rung_name(outs[13])); el_puts("\n")
256 el_puts(" COMPLETENESS: HW-root="); el_putn(outs[1])
257 el_puts(" broken-parents="); el_putn(outs[2])
258 el_puts(" purposeless="); el_putn(outs[4])
259 el_puts(" never-brick-unsafe="); el_putn(outs[5]); el_puts("\n")
260 if outs[5] > 0 { el_puts(" VERDICT: NEVER-BRICK VIOLATION -- a hardware-write layer is not proven safe (Rule 26)\n"); sys_exit(1); return 1 }
261 if outs[1] == 0 { el_puts(" VERDICT: NO HW ROOT -- the tree does not bottom out at god/hardware\n"); sys_exit(1); return 1 }
262 if outs[2] > 0 { el_puts(" VERDICT: BROKEN TREE -- a layer's parent names no layer\n"); sys_exit(1); return 1 }
263 if outs[3] > 0 { el_puts(" VERDICT: UNPROVEN -- layer(s) claim a MEASURED/EXCEEDS win with no evidence artifact (the liar-kill)\n"); sys_exit(1); return 1 }
264 if outs[4] > 0 { el_puts(" VERDICT: PURPOSELESS -- layer(s) missing a telos/label\n"); sys_exit(1); return 1 }
265 el_puts(" VERDICT: tree whole god->canopy; no orphans/purposeless; 0 unproven exceed claims; ")
266 if outs[11] == 0 { if outs[12] == 0 { el_puts("0 measured head-to-head wins yet = the honest worklist\n") } else { el_puts("see census\n") } }
267 else { el_puts("see census\n") }
268 sys_exit(0); return 0
269}