code wiki / _hdl_build / nx_capgraph_derive.nx
nx_capgraph_derive.nx source
↩ module page · 480 lines · 23861 B
1// nx_capgraph_derive.nx -- builds the LIVE ecosystem capability GRAPH from real sources and ranks rocks.
2//
3// THIS IS THE PRODUCTION CALLER. nx_capgraph_lib is gate-proven (27/27) but a gated library with no live
4// caller is, by this ecosystem's own measured law, still the baseline. This organ is what makes the graph
5// ADOPTED rather than merely GATED.
6//
7// WHAT IT REPLACES. nx_sota_status emits one FLAT PERMIL per domain (cov=764) and nx_capaxes_derive turns
8// that into a 6-vector whose evidence axis is hardcoded 0 -- so every domain headlines 0, forever, and the
9// ranking silently falls back to the coverage claim: the flat percent again. Here the permil is converted
10// into an ORDINAL LEVEL and then CAPPED BY ITS EVIDENCE CLASS (L6), so a domain claiming cov=1000 out of
11// the CLAIM-ONLY block lands at TOY, not SOTA -- and when a real gate lands, the level MOVES. That movement
12// is the forward progress the flat percent could never show.
13//
14// EVIDENCE CLASS IS READ FROM THE BLOCK THE DOMAIN APPEARS IN, never asserted:
15// CLAIM-ONLY -> demo evidence (asserts coverage, no executable evidence)
16// MECH-OK -> gate-nonvacuous (quorum+provenance+freshness hold)
17// PROVEN -> external-battery (executed gate GREEN + triangulated)
18// CLAIMED-BUT-RED-> none => UNGROUNDED (doctrine: a dissenting method is WORSE than claim-only,
19// so it refuses to carry a level at all)
20//
21// EDGES ARE DECLARED, NEVER INVENTED. Prerequisite edges load from knowledge/status/capgraph_edges.conf
22// (rows "prereq>dependent"). If that file is absent the graph is reported EDGE-FREE and says so in the
23// envelope -- it does NOT guess a dependency structure, because an invented edge would fabricate exactly
24// the kind of authority this organ exists to remove.
25//
26// nx_capgraph_derive [topN] exit 0 ok | 4 capture-fail
27// license_tier: ORIGINAL No hw writes (Rule 26). expect_exit: 0
28import "nx_capgraph_derive_lib.nx"
29
30func main(argc: i64, argv: *i64) -> i64 {
31 var topn: i64 = 20
32 var chokepoint_mode: i64 = 0
33 var predict_mode: i64 = 0
34 var roots_mode: i64 = 0
35 if argc > 1 {
36 if cg_streq(argv[1] as *u8, "progress" as *u8) == 1 { return cd2_progress() }
37 if cg_streq(argv[1] as *u8, "chokepoint" as *u8) == 1 { chokepoint_mode = 1 }
38 if cg_streq(argv[1] as *u8, "predict" as *u8) == 1 { predict_mode = 1 }
39 if cg_streq(argv[1] as *u8, "roots" as *u8) == 1 { roots_mode = 1 }
40 topn = cax_atoi(argv[1] as *u8)
41 }
42 if topn <= 0 { topn = 20 }
43
44 let out: *u8 = sys_mmap(CD2_CAP + 16)
45 let olen: *i64 = sys_mmap(16) as *i64
46 let rc: i64 = tr_run1(CD2_ELF, 0 as *u8, out, CD2_CAP, olen)
47 let n: i64 = olen[0]
48 if rc == 127 {
49 cax_puts("CAPGRAPH-DERIVE verdict=CAPTURE-FAIL exec-127\n" as *u8)
50 return 4
51 }
52 if n <= 0 {
53 cax_puts("CAPGRAPH-DERIVE verdict=CAPTURE-FAIL empty\n" as *u8)
54 return 4
55 }
56
57 cg_init(3)
58 cg_axis_set(CD2_AX_COVER, "coverage" as *u8)
59 cg_axis_set(CD2_AX_EVID, "evidence" as *u8)
60 cg_axis_set(CD2_AX_FRONTIER, "frontier" as *u8)
61
62 let nm: *u8 = sys_mmap(CG_NAMEW + 16)
63 let rawcov: *i64 = sys_mmap(CG_MAXN * 8 + 16) as *i64
64 var mode: i64 = 0
65 var claim_only: i64 = 0
66 var red: i64 = 0
67 var proven: i64 = 0
68 var mechok: i64 = 0
69
70 var ls: i64 = 0
71 var i: i64 = 0
72 while i <= n {
73 var isend: i64 = 0
74 if i == n { isend = 1 }
75 else { if out[i] == (10 as u8) { isend = 1 } }
76 if isend == 1 {
77 if cd2_find(out, ls, i, "CLAIM-ONLY domains" as *u8) >= 0 { mode = 1 }
78 if cd2_find(out, ls, i, "PROVEN domains" as *u8) >= 0 { mode = 2 }
79 if cd2_find(out, ls, i, "CLAIMED-BUT-RED" as *u8) >= 0 { mode = 3 }
80 // MECH-OK = executed evidence GREEN, second method class still missing. Added 2026-08-01
81 // after this graph DROPPED the `instrument` node the moment that domain earned evidence and
82 // reported the improvement as a REGRESSION -- because upstream emitted MECH-OK as a bare
83 // COUNT with no names. Both halves were fixed: sota_status now LISTS them, and this reads it.
84 if cd2_find(out, ls, i, "MECH-OK domains" as *u8) >= 0 { mode = 4 }
85 let covp: i64 = cd2_find(out, ls, i, "cov=" as *u8)
86 if covp >= 0 {
87 if mode > 0 {
88 let w: i64 = cd2_name_of(out, ls, i, nm)
89 if w > 0 {
90 var evclass: i64 = CG_EV_DEMO
91 var evlevel: i64 = 0
92 if mode == 2 {
93 evclass = CG_EV_EXT
94 evlevel = 5
95 proven = proven + 1
96 }
97 if mode == 3 {
98 evclass = CG_EV_NONE
99 evlevel = 0
100 red = red + 1
101 }
102 // A gate that RAN and passed with provenance+freshness is L5 level 3 GATED --
103 // not 4 (no proven production caller) and not 5 (no external battery, and the
104 // second method class is exactly what MECH-OK says is still missing).
105 if mode == 4 {
106 evclass = CG_EV_GATE
107 evlevel = 3
108 mechok = mechok + 1
109 }
110 if mode == 1 { claim_only = claim_only + 1 }
111 let id: i64 = cg_addnode(nm, evclass)
112 if id >= 0 {
113 let cov: i64 = cd2_num(out, covp + 4, i)
114 rawcov[id] = cov
115 cg_set(id, CD2_AX_COVER, cd2_cov_level(cov))
116 cg_set(id, CD2_AX_EVID, evlevel)
117 let gp: i64 = cd2_find(out, ls, i, "gaps=" as *u8)
118 if gp >= 0 {
119 let gv: i64 = cd2_num(out, gp + 5, i)
120 cg_set(id, CD2_AX_FRONTIER, cd2_gap_level(gv))
121 }
122 }
123 }
124 }
125 }
126 ls = i + 1
127 }
128 i = i + 1
129 }
130
131 let elen: *i64 = sys_mmap(16) as *i64
132 let ebuf: *u8 = sys_read_file(CD2_EDGES, elen)
133 let en: i64 = elen[0]
134 var edges_declared: i64 = 0
135 var infra_nodes: i64 = 0
136 if en > 0 {
137 var els: i64 = 0
138 var k: i64 = 0
139 while k <= en {
140 var e2: i64 = 0
141 if k == en { e2 = 1 }
142 else { if ebuf[k] == (10 as u8) { e2 = 1 } }
143 if e2 == 1 {
144 let sep: i64 = cd2_find(ebuf, els, k, ">" as *u8)
145 if sep > 0 {
146 if ebuf[els] != (35 as u8) {
147 let an: *u8 = sys_mmap(CG_NAMEW + 16)
148 let bn: *u8 = sys_mmap(CG_NAMEW + 16)
149 cd2_name_of(ebuf, els, sep, an)
150 cd2_name_of(ebuf, sep + 1, k, bn)
151 var ai: i64 = 0 - 1
152 var bi: i64 = 0 - 1
153 var z: i64 = 0
154 while z < cg_nn {
155 if cg_streq(cg_node_name(z), an) == 1 { ai = z }
156 if cg_streq(cg_node_name(z), bn) == 1 { bi = z }
157 z = z + 1
158 }
159 // An `infra:<module>` prerequisite is a SHARED module promoted to a first-class
160 // node. It is created on sight with NO measured axes: L3 guarantees UNMEASURED
161 // never drags a dependent down, so adding infra structure can only ever ADD
162 // information -- it cannot silently deflate a domain that stands on it.
163 if ai < 0 {
164 if cd2_is_infra(an) == 1 {
165 ai = cg_addnode(an, CG_EV_REAL)
166 infra_nodes = infra_nodes + 1
167 }
168 }
169 if ai >= 0 {
170 if bi >= 0 {
171 if cg_addedge(ai, bi) == 0 { edges_declared = edges_declared + 1 }
172 }
173 }
174 }
175 }
176 els = k + 1
177 }
178 k = k + 1
179 }
180 }
181
182 cg_relax()
183
184 // ---- THE SOTA WORK ORDER: WHERE DOES EVIDENCE ACTUALLY PAY OFF? ----
185 // Measured 2026-08-01, and it INVERTS naive prioritisation. I landed real evidence on `instrument`
186 // (own 0->3 GATED) and its EFFECTIVE level did not move at all, because L4 caps it behind
187 // `deepresearch`. So I evidenced deepresearch too (own 0->3) -- and instrument STILL did not move,
188 // because deepresearch is itself capped behind browser + coding + two infra nodes.
189 // ★★★★★★UNDER A WEAKEST-PATH RULE, EVIDENCE ON A LEAF BUYS NOTHING UNTIL ITS WHOLE CHAIN IS LIFTED.
190 // Rock-ranking by leverage tells you which node BLOCKS the most; this tells you where work CONVERTS
191 // into delivered capability today. They are different questions and both are needed.
192 if roots_mode == 1 {
193 cax_puts("=== NX-CAPGRAPH SOTA WORK ORDER: where does evidence CONVERT today? ===\n" as *u8)
194 cax_puts(" UNBLOCKED = every prerequisite already carries evidence (or it has none), so raising\n" as *u8)
195 cax_puts(" this domain raises its EFFECTIVE level immediately. BLOCKED = the work is real but the\n" as *u8)
196 cax_puts(" delivered level cannot move until the chain beneath it lifts.\n\n" as *u8)
197 var unb_done: i64 = 0
198 var unb_todo: i64 = 0
199 var blocked: i64 = 0
200 cax_puts("-- UNBLOCKED, NOT YET EVIDENCED <<< START HERE, THIS IS THE QUEUE >>> --\n" as *u8)
201 var t: i64 = 0
202 while t < cg_nn {
203 if cd2_is_infra(cg_node_name(t)) == 0 {
204 var blockedby: i64 = 0
205 var e: i64 = 0
206 while e < cg_ne {
207 if cg_et[e] == t {
208 let pv: i64 = cg_effective(cg_ef[e])
209 if pv != CG_UNMEASURED {
210 if pv <= 0 { blockedby = blockedby + 1 }
211 }
212 }
213 e = e + 1
214 }
215 if blockedby == 0 {
216 // TEST THE EVIDENCE AXIS, NOT THE HEADLINE. cg_own is the MIN across all measured
217 // axes (the min-not-mean rule that stops coverage-gaming), so a domain with GREEN
218 // executable evidence but a large frontier gap still headlines 0. Asking cg_own
219 // "is this evidenced?" therefore answered "no" for `media`, which nx_sota_status
220 // lists as MECH-OK with gates_green=1/1 -- my queue contradicted the evidence organ
221 // and would have sent someone to re-do work that was already done.
222 // ★★★★★A HEADLINE AND A SINGLE AXIS ANSWER DIFFERENT QUESTIONS; ASKING THE HEADLINE
223 // AN AXIS QUESTION SILENTLY RETURNS THE WRONG ONE. "Has it earned evidence" is the
224 // EVIDENCE axis; "how strong is it overall" is the headline. Both are right answers
225 // to their own question and neither substitutes for the other.
226 if cg_get(t, CD2_AX_EVID) > 0 { unb_done = unb_done + 1 }
227 else {
228 unb_todo = unb_todo + 1
229 cax_puts(" " as *u8)
230 cax_puts(cg_node_name(t))
231 cax_puts("\n" as *u8)
232 }
233 } else { blocked = blocked + 1 }
234 }
235 t = t + 1
236 }
237 cax_puts("\n" as *u8)
238 cax_kv("unblocked_not_evidenced" as *u8, unb_todo)
239 cax_kv("unblocked_already_evidenced" as *u8, unb_done)
240 cax_kv("BLOCKED_by_an_unevidenced_prereq" as *u8, blocked)
241 cax_puts("\n\n" as *u8)
242 cax_puts(" A BLOCKED domain is NOT a bad place to work -- the evidence still lands and the rail\n" as *u8)
243 cax_puts(" records it as <name>#own. It simply does not raise DELIVERED capability yet, and\n" as *u8)
244 cax_puts(" saying otherwise would be the same overclaim the flat percent used to make.\n" as *u8)
245 return 0
246 }
247
248 // ---- FALSIFIABLE PREDICTIONS ----
249 // ADeLe's whole point is PREDICTIVE VALIDITY: a capability profile must predict something checkable,
250 // or it is only a description wearing a measurement's clothes. I grounded this design in that paper
251 // and then shipped only the descriptive half. This verb makes the instrument COMMIT: each line states
252 // what must happen next AND what observation would prove the instrument WRONG.
253 // ★AN INSTRUMENT THAT CANNOT BE WRONG CANNOT BE RIGHT EITHER.
254 if predict_mode == 1 {
255 cax_puts("=== NX-CAPGRAPH FALSIFIABLE PREDICTIONS ===\n" as *u8)
256 cax_puts(" Each line commits the instrument. If the stated refutation is observed, the graph is\n" as *u8)
257 cax_puts(" WRONG and must be corrected -- not explained away.\n\n" as *u8)
258
259 cax_puts("P1 EVIDENCE MOVES THE LEVEL.\n" as *u8)
260 cax_puts(" If any domain lands a gate that is PROVEN ABLE TO FAIL, its evidence axis goes 0->3\n" as *u8)
261 cax_puts(" and `nx_capgraph_derive progress` prints UP <domain> 0 -> 3 on the next run.\n" as *u8)
262 cax_puts(" REFUTED IF: such a gate lands and the rail records no movement for that domain.\n\n" as *u8)
263
264 cax_puts("P2 COVERAGE ALONE MOVES NOTHING.\n" as *u8)
265 cax_puts(" If a domain's cov= rises with no new evidence, its effective level does NOT change.\n" as *u8)
266 cax_puts(" REFUTED IF: a pure coverage rise moves a headline. (Tooth T10c guards this offline;\n" as *u8)
267 cax_puts(" this is the LIVE form of the same claim.)\n\n" as *u8)
268
269 cax_puts("P3 THE CHOKEPOINT LIFTS EXACTLY ITS LISTED DEPENDENTS.\n" as *u8)
270 cax_puts(" Raising a shared-infra node lifts the domains `chokepoint` names under it, and no\n" as *u8)
271 cax_puts(" others. REFUTED IF: raising it lifts a domain NOT listed => the edge set is\n" as *u8)
272 cax_puts(" INCOMPLETE, which is the failure mode I already flagged at 85permil ownership.\n\n" as *u8)
273
274 cax_puts("P4 A CYCLE RISES TOGETHER OR NOT AT ALL.\n" as *u8)
275 cax_puts(" Co-dependent members share a floor, so raising ONE of them alone must NOT raise its\n" as *u8)
276 cax_puts(" effective level. REFUTED IF: one member's effective level rises while a peer stays.\n\n" as *u8)
277
278 // The honest part: say plainly whether ANY of this is testable right now.
279 var measured: i64 = 0
280 var i2: i64 = 0
281 while i2 < cg_nn {
282 if cg_effective(i2) != CG_UNMEASURED {
283 if cg_effective(i2) > 0 { measured = measured + 1 }
284 }
285 i2 = i2 + 1
286 }
287 cax_puts("-- FALSIFIABILITY STATUS RIGHT NOW --\n" as *u8)
288 cax_kv("nodes_above_level_0" as *u8, measured)
289 cax_puts("\n" as *u8)
290 if measured == 0 {
291 cax_puts(" ZERO. Every node sits at effective level 0 because nx_sota_status reports PROVEN 0/40,\n" as *u8)
292 cax_puts(" so no DOMAIN-LEVEL prediction above is testable TODAY. That is a real limitation of\n" as *u8)
293 cax_puts(" this instrument and it is stated here rather than left for a reader to discover:\n" as *u8)
294 cax_puts(" the graph currently RANKS well and PREDICTS nothing checkable, and it stays that way\n" as *u8)
295 cax_puts(" until the first non-vacuous gate is wired as executable evidence for any domain.\n" as *u8)
296 cax_puts(" ⚠Do not read the rankings as validated. They are DERIVED, not yet CONFIRMED.\n" as *u8)
297 } else {
298 cax_puts(" Some nodes carry a nonzero level, so P1/P4 are now testable against the rail history.\n" as *u8)
299 }
300 return 0
301 }
302
303 // ---- CHOKEPOINT WORK ORDER ----
304 // "nx_seg_store.nx carries 19 of 28 domains" is a slogan, not a work order: it does not say WHICH
305 // domains, so nobody can scope the migration or tell afterwards whether it helped. This names them.
306 if chokepoint_mode == 1 {
307 cax_puts("=== NX-CAPGRAPH CHOKEPOINT WORK ORDER ===\n" as *u8)
308 cax_puts(" Shared-infra modules ranked by how many domains stand on them, WITH THE NAMES --\n" as *u8)
309 cax_puts(" raising one of these lifts exactly the domains listed under it, and nothing else.\n\n" as *u8)
310 let cpick: *i64 = sys_mmap(CG_MAXN * 8 + 16) as *i64
311 var ci: i64 = 0
312 while ci < cg_nn {
313 cpick[ci] = 0
314 ci = ci + 1
315 }
316 var shown3: i64 = 0
317 while shown3 < 12 {
318 var b3: i64 = 0 - 1
319 var t3: i64 = 0
320 while t3 < cg_nn {
321 if cpick[t3] == 0 {
322 if cd2_is_infra(cg_node_name(t3)) == 1 {
323 if b3 < 0 { b3 = t3 }
324 else { if cg_descendants(t3) > cg_descendants(b3) { b3 = t3 } }
325 }
326 }
327 t3 = t3 + 1
328 }
329 if b3 < 0 { shown3 = 12 }
330 else {
331 cpick[b3] = 1
332 cax_puti(shown3 + 1)
333 cax_puts(". " as *u8)
334 cax_puts(cg_node_name(b3))
335 cax_puts(" " as *u8)
336 cax_kv("domains" as *u8, cg_descendants(b3))
337 cax_puts("\n " as *u8)
338 var e3: i64 = 0
339 var listed: i64 = 0
340 while e3 < cg_ne {
341 if cg_ef[e3] == b3 {
342 cax_puts(cg_node_name(cg_et[e3]))
343 cax_puts(" " as *u8)
344 listed = listed + 1
345 }
346 e3 = e3 + 1
347 }
348 if listed == 0 { cax_puts("(no DIRECT importers -- reached only transitively)" as *u8) }
349 cax_puts("\n\n" as *u8)
350 shown3 = shown3 + 1
351 }
352 }
353 cax_puts("envelope: names are DIRECT importers from the measured import closure. The `domains`\n" as *u8)
354 cax_puts(" count is TRANSITIVE (includes those reached through other nodes), so it can exceed the\n" as *u8)
355 cax_puts(" listed names -- the two numbers answer different questions and are both shown on purpose.\n" as *u8)
356 return 0
357 }
358
359 cax_puts("=== NX-CAPGRAPH: live capability GRAPH (ordinal levels, measured digraph, evidence-capped) ===\n" as *u8)
360 cax_kv("nodes" as *u8, cg_nn)
361 cax_kv("edges" as *u8, edges_declared)
362 cax_kv("infra_nodes" as *u8, infra_nodes)
363 cax_kv("claim_only" as *u8, claim_only)
364 cax_kv("mech_ok" as *u8, mechok)
365 cax_kv("proven" as *u8, proven)
366 cax_kv("red_ungrounded" as *u8, red)
367 cax_puts("\n\n" as *u8)
368 cax_puts("ladder: 0 ABSENT 1 TOY 2 WORKS 3 GATED 4 ADOPTED 5 SOTA\n" as *u8)
369 cax_puts("a level is what it TAKES TO PASS, so breadth cannot buy one -- and a level-up is countable.\n\n" as *u8)
370
371 cax_puts("-- BIGGEST ROCKS (rank = level deficit x downstream mass) --\n\n" as *u8)
372 let used: *i64 = sys_mmap(CG_MAXN * 8 + 16) as *i64
373 let rocks: *i64 = sys_mmap(CG_MAXN * 8 + 16) as *i64
374 var u: i64 = 0
375 while u < cg_nn {
376 used[u] = 0
377 var lev: i64 = 1 + rawcov[u] / 100
378 if rawcov[u] == CG_UNMEASURED { lev = 1 }
379 rocks[u] = cg_rock_lev(u, lev)
380 u = u + 1
381 }
382 var shown: i64 = 0
383 while shown < topn {
384 var best: i64 = 0 - 1
385 var t: i64 = 0
386 while t < cg_nn {
387 if used[t] == 0 {
388 if cg_grounded(t) == 1 {
389 if cg_effective(t) != CG_UNMEASURED {
390 if best < 0 { best = t }
391 else { if rocks[t] > rocks[best] { best = t } }
392 }
393 }
394 }
395 t = t + 1
396 }
397 if best < 0 { shown = topn }
398 else {
399 used[best] = 1
400 cax_puti(shown + 1)
401 cax_puts(". " as *u8)
402 cg_row(best)
403 cax_puts(" stake: " as *u8)
404 cax_kv("claim_permil" as *u8, rawcov[best])
405 cax_kv("rock_leveraged" as *u8, rocks[best])
406 cax_puts("\n" as *u8)
407 shown = shown + 1
408 }
409 }
410
411 cax_puts("\n-- UNGROUNDED (a dissenting method is worse than claim-only: refuses to carry a level) --\n" as *u8)
412 var r2: i64 = 0
413 while r2 < cg_nn {
414 if cg_grounded(r2) == 0 {
415 cax_puts(" " as *u8)
416 cg_row(r2)
417 }
418 r2 = r2 + 1
419 }
420
421 cax_puts("\n-- SHARED INFRASTRUCTURE CHOKEPOINTS (modules many domains stand on) --\n" as *u8)
422 cax_puts(" MIGRATE THE CHOKEPOINT, NOT THE LEAF: these carry no measured level yet, and the moment\n" as *u8)
423 cax_puts(" one IS measured it caps every domain above it. Ranked by domains standing on them.\n\n" as *u8)
424 let iused: *i64 = sys_mmap(CG_MAXN * 8 + 16) as *i64
425 var w3: i64 = 0
426 while w3 < cg_nn {
427 iused[w3] = 0
428 w3 = w3 + 1
429 }
430 var shown2: i64 = 0
431 while shown2 < 10 {
432 var b2: i64 = 0 - 1
433 var t2: i64 = 0
434 while t2 < cg_nn {
435 if iused[t2] == 0 {
436 if cd2_is_infra(cg_node_name(t2)) == 1 {
437 if b2 < 0 { b2 = t2 }
438 else { if cg_descendants(t2) > cg_descendants(b2) { b2 = t2 } }
439 }
440 }
441 t2 = t2 + 1
442 }
443 if b2 < 0 { shown2 = 10 }
444 else {
445 iused[b2] = 1
446 cax_puts(" " as *u8)
447 cax_puts(cg_node_name(b2))
448 cax_puts(" " as *u8)
449 cax_kv("domains_standing_on_it" as *u8, cg_descendants(b2))
450 cax_puts("\n" as *u8)
451 shown2 = shown2 + 1
452 }
453 }
454
455 cd2_sb = sys_mmap(CD2_SBMAX + 64) as *u8
456 let snap: i64 = cd2_snapshot(edges_declared)
457 cax_puts("\n-- PROGRESS RAIL --\n" as *u8)
458 if snap == 1 {
459 cax_puts(" MOVEMENT RECORDED -> knowledge/status/capgraph_history.jrnl (state differs from the last row)\n" as *u8)
460 }
461 if snap == 0 {
462 cax_puts(" unchanged since the last recorded row -- nothing appended (a rail that grows on every\n" as *u8)
463 cax_puts(" run would drown the signal it exists to carry; this journal records MOVEMENT, not runs).\n" as *u8)
464 }
465 if snap < 0 {
466 cax_puts(" WARN: history append FAILED -- progress is NOT being recorded, treat levels as un-tracked\n" as *u8)
467 }
468
469 cax_puts("\nenvelope: axes=3 (coverage/evidence/frontier) levels=0..5 ordinal; evidence class read from the\n" as *u8)
470 cax_puts(" nx_sota_status BLOCK, never asserted; L6 caps every claim by its evidence; L4 weakest-path is\n" as *u8)
471 if edges_declared == 0 {
472 cax_puts(" EDGE-FREE THIS RUN -- knowledge/status/capgraph_edges.conf absent or empty. Prerequisite\n" as *u8)
473 cax_puts(" structure is DECLARED, never guessed, so rollup is per-node only until edges are declared.\n" as *u8)
474 } else {
475 cax_puts(" active over the edge set in capgraph_edges.conf (MEASURED by nx_capgraph_edges from\n" as *u8)
476 cax_puts(" the import closure; NOT acyclic -- a cycle names a co-dependent cluster sharing a floor).\n" as *u8)
477 }
478 cax_puts(" source=nx_sota_status fork-capture, no reimplementation. gate=nx_capgraph_gate 32/32.\n" as *u8)
479 return 0
480}