nx_forge_os_readiness.nx source
↩ module page · 137 lines · 5458 B
1// nx_forge_os_readiness.nx -- FORGE-ON-NISHIOS READINESS CENSUS (operator 2026-07-16: "get our
2// nishi os ready for the nishi forge capabilities natively -- use compare/evaluate what we need,
3// workflow to eat debt + build SOTA from the biggest rocks down"). Reads the rock registry from the
4// SOVEREIGN STORE (knowledge/store/forge_os_rocks, no-TSV law), grades each capability rock
5// GAP/PARTIAL/READY, computes an honest readiness score (GAP=0 PARTIAL=1 READY=2 over 2*N), and
6// EMITS the big-rocks-first WORKFLOW (rank-ordered gaps = the queue to eat). Re-run as NishiOS
7// matures; the number moves only when a rock's registry verdict flips (backed by real OS gates).
8// usage: nx_forge_os_readiness exit 0 (measurement; the ranked workflow is the deliverable)
9// license_tier: ORIGINAL expect_exit: 0
10import "nx_sov_ledger.nx"
11import "nx_lib_std.nx"
12const FOR_MAGIC_8192: i64 = 8192
13const FOR_MAGIC_8191: i64 = 8191
14const FOR_MAGIC_1024: i64 = 1024
15
16const FOR_STORE: *u8 = "knowledge/store/forge_os_rocks"
17
18// copy |-field k (0-based) of a NUL-terminated value into out. returns len.
19func for_field(val: *u8, k: i64, out: *u8) -> i64 {
20 var field: i64 = 0
21 var o: i64 = 0
22 var i: i64 = 0
23 while val[i] != (0 as u8) {
24 let c: i64 = val[i] as i64
25 if c == 124 {
26 field = field + 1
27 } else {
28 if field == k { out[o] = c as u8; o = o + 1 }
29 }
30 i = i + 1
31 }
32 out[o] = 0 as u8
33 return o
34}
35
36// verdict word -> weight (READY=2 PARTIAL=1 GAP=0) + validity (-1 if unknown = liar-kill).
37func for_weight(v: *u8) -> i64 {
38 if std_streq(v, "READY" as *u8) == 1 { return 2 }
39 if std_streq(v, "PARTIAL" as *u8) == 1 { return 1 }
40 if std_streq(v, "GAP" as *u8) == 1 { return 0 }
41 return 0 - 1
42}
43
44func for_run() -> i64 {
45 let ids: *u8 = sys_mmap(FOR_MAGIC_8192) as *u8
46 let idn: i64 = sov_get_copy(FOR_STORE, "rocks:ids" as *u8, ids, FOR_MAGIC_8191)
47 if idn <= 0 { std_putln("FORGE-OS: no rock registry (seed knowledge/store/forge_os_rocks)" as *u8); return 0 - 1 }
48 let val: *u8 = sys_mmap(FOR_MAGIC_1024) as *u8
49 let cap: *u8 = sys_mmap(128) as *u8
50 let need: *u8 = sys_mmap(256) as *u8
51 let state: *u8 = sys_mmap(256) as *u8
52 let verd: *u8 = sys_mmap(32) as *u8
53 let note: *u8 = sys_mmap(256) as *u8
54 let rankb: *u8 = sys_mmap(32) as *u8
55 var n: i64 = 0
56 var score: i64 = 0
57 var invalid: i64 = 0
58 var gaps: i64 = 0
59 std_putln("=== FORGE-ON-NISHIOS READINESS (big-rocks-first; rocks from the sovereign store) ===" as *u8)
60 // rocks are rank-ordered in the index (r1..r9) -> emit in registry order (already big-rocks-first)
61 var i: i64 = 0
62 while i < idn {
63 var e: i64 = i
64 var sc: i64 = 1
65 while sc == 1 {
66 if e >= idn { sc = 0 }
67 if sc == 1 { if ids[e] == (10 as u8) { sc = 0 } else { e = e + 1 } }
68 }
69 let kl: i64 = e - i
70 if kl > 0 && kl < 60 {
71 let key: *u8 = sys_mmap(64) as *u8
72 var m: i64 = 0
73 while m < kl { key[m] = ids[i + m]; m = m + 1 }
74 key[kl] = 0 as u8
75 let vn: i64 = sov_get_copy(FOR_STORE, key, val, 1023)
76 if vn > 0 {
77 val[vn] = 0 as u8 // terminate at returned len (seg_store value not NUL-terminated -> stale-tail leak)
78 for_field(val, 0, rankb)
79 for_field(val, 1, cap)
80 for_field(val, 2, need)
81 for_field(val, 3, state)
82 for_field(val, 4, verd)
83 for_field(val, 5, note)
84 let w: i64 = for_weight(verd)
85 n = n + 1
86 if w < 0 { invalid = invalid + 1 }
87 if w >= 0 { score = score + w }
88 std_puts(" [R" as *u8)
89 std_puts(rankb)
90 std_puts("] " as *u8)
91 std_puts(cap)
92 std_puts(" " as *u8)
93 std_puts(verd)
94 std_puts("\n need : " as *u8)
95 std_putln(need)
96 std_puts(" os : " as *u8)
97 std_putln(state)
98 if std_streq(verd, "GAP" as *u8) == 1 {
99 gaps = gaps + 1
100 std_puts(" ROCK : " as *u8)
101 std_putln(note)
102 }
103 }
104 }
105 i = e + 1
106 }
107 let denom: i64 = n * 2
108 var pm: i64 = 0
109 if denom > 0 { pm = score * 1000 / denom }
110 std_puts("READINESS " as *u8)
111 std_pdec(pm)
112 std_puts(" permil (score " as *u8)
113 std_pdec(score)
114 std_puts("/" as *u8)
115 std_pdec(denom)
116 std_puts(") rocks=" as *u8)
117 std_pdec(n)
118 std_puts(" gaps=" as *u8)
119 std_pdec(gaps)
120 std_puts(" invalid=" as *u8)
121 std_pdec(invalid)
122 std_puts("\n" as *u8)
123 std_putln("WORKFLOW (eat the biggest rock first): the GAP rocks above, in rank order --" as *u8)
124 std_putln(" R1 syscall-ABI host is FOUNDATIONAL (unblocks R2/R4/R6 for the DETERMINISTIC core:" as *u8)
125 std_putln(" compiler + byte-exact JUDGE + sovereign store + gates -- no network, no GPU needed)." as *u8)
126 std_putln(" Then R5 flock, R7 network (the serve half), R9 GPU (deferred, hardware-gated)." as *u8)
127 return invalid
128}
129
130func main(argc: i64, argv: *i64) -> i64 {
131 let inv: i64 = for_run()
132 std_puts("FORGE-OS-READINESS done (invalid-verdicts=" as *u8)
133 std_pdec(inv)
134 std_putln(")" as *u8)
135 sys_exit(0)
136 return 0
137}