code wiki / _hdl_build / nx_fixflywheel.nx
nx_fixflywheel.nx source
↩ module page · 314 lines · 13394 B
1// nx_fixflywheel.nx -- THE HEREDITY RATCHET (bugforge-swe-scale, 2026-07-24). Evolution needs the
2// genome to GROW across generations: every machine-verified green becomes teaching data for the next.
3// This organ harvests verified (buggy->fixed) pairs and folds them into bf_fixcorpus ADDITIVELY,
4// de-duped, so generation N+1 always inherits from a LARGER survivor pool than generation N.
5//
6// SOURCE = a MINED manifest (name|path rows) whose instances the maker resolved GREEN. For each row
7// it reads the emitted candidate's header (// src=<origpath> op=<label>), recovers the buggy fn (the
8// candidate's own mutant, under its real name) and the ORACLE fixed fn (the original at src), and
9// appends `buggy TAB fixed` (multi-line via the 0x01 sentinel, matching nx_fixshot_lib). CONTRACT:
10// only append a pair that fsl_shots would accept (fixed != buggy) AND that is not already present
11// (exact-row de-dup) -- the ratchet is monotone + idempotent (re-run adds nothing new). This is the
12// same additive+preload+dedup discipline the seq756 wipe taught (never REPLACE a live genome).
13//
14// verbs: harvest <manifest> <ledger> | selftest
15// license_tier: ORIGINAL No hw writes (Rule 26).
16import "nx_tool_run.nx"
17import "nx_syscalls.nx"
18
19const FW_FCAP: i64 = 262144
20const FW_CORCAP: i64 = 524288
21const FW_TCAP: i64 = 4096
22const FW_ZERO: i64 = 48
23const FW_MODE: i64 = 420
24
25func w(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
26func wn(v: i64) -> i64 {
27 var m: i64 = v
28 if m < 0 { w("-" as *u8); m = 0 - m }
29 let t: *u8 = sys_mmap(24)
30 var k: i64 = 0
31 if m == 0 { t[0] = FW_ZERO as u8; k = 1 }
32 while m > 0 { t[k] = (FW_ZERO + (m % 10)) as u8; m = m / 10; k = k + 1 }
33 let o: *u8 = sys_mmap(24)
34 var i: i64 = 0
35 while i < k { o[i] = t[k - 1 - i]; i = i + 1 }
36 sys_write(1, o, k)
37 return 0
38}
39func slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
40func sfind(hay: *u8, hn: i64, needle: *u8, from: i64) -> i64 {
41 let m: i64 = slen(needle)
42 if m == 0 { return 0 - 1 }
43 var i: i64 = from
44 while i + m <= hn {
45 var j: i64 = 0
46 var ok: i64 = 1
47 while j < m { if hay[i + j] != needle[j] { ok = 0; j = m } else { j = j + 1 } }
48 if ok == 1 { return i }
49 i = i + 1
50 }
51 return 0 - 1
52}
53func fw_read(path: *u8, buf: *u8, cap: i64) -> i64 {
54 let fd: i64 = sys_openat_rd(path)
55 if fd < 0 { return 0 - 1 }
56 var n: i64 = 0
57 var go: i64 = 1
58 while go == 1 {
59 if n >= cap { sys_close(fd); return 0 - 2 }
60 let r: i64 = sys_read(fd, ((buf as i64) + n) as *u8, cap - n)
61 if r <= 0 { go = 0 } else { n = n + r }
62 }
63 sys_close(fd)
64 return n
65}
66func fw_write(path: *u8, buf: *u8, n: i64) -> i64 {
67 let fd: i64 = sys_openat_wr(path, FW_MODE)
68 if fd < 0 { return 0 - 1 }
69 sys_write(fd, buf, n)
70 sys_close(fd)
71 return n
72}
73// extract fn "func <name>(" ... through brace depth 0 into dst (0x01 for interior newlines); ret len
74func fw_extract(src: *u8, n: i64, name: *u8, dst: *u8) -> i64 {
75 let needle: *u8 = sys_mmap(96)
76 var no: i64 = 0
77 let pfx: *u8 = "func " as *u8
78 while pfx[no] != (0 as u8) { needle[no] = pfx[no]; no = no + 1 }
79 var k: i64 = 0
80 while name[k] != (0 as u8) { needle[no] = name[k]; no = no + 1; k = k + 1 }
81 needle[no] = 40 as u8
82 needle[no + 1] = 0 as u8
83 let fs: i64 = sfind(src, n, needle, 0)
84 if fs < 0 { return 0 }
85 var fe: i64 = fs
86 var depth: i64 = 0
87 var seen: i64 = 0
88 var go: i64 = 1
89 while go == 1 {
90 if fe >= n { go = 0 }
91 else {
92 let c: i64 = src[fe] as i64
93 if c == 123 { depth = depth + 1; seen = 1 }
94 if c == 125 { depth = depth - 1 }
95 fe = fe + 1
96 if seen == 1 { if depth == 0 { go = 0 } }
97 }
98 }
99 if seen == 0 { return 0 }
100 var o: i64 = 0
101 var z: i64 = fs
102 while z < fe { var c2: u8 = src[z]; if c2 == (10 as u8) { c2 = 1 as u8 } dst[o] = c2; o = o + 1; z = z + 1 }
103 dst[o] = 0 as u8
104 return o
105}
106// is `cand` (a bugforge instance name) GREEN in ledger[0,ln)? (AUTOFIX-AUTO ... cand=<c> ... maker=GREEN)
107func fw_green(led: *u8, ln: i64, cand: *u8) -> i64 {
108 let key: *u8 = sys_mmap(160)
109 var ko: i64 = 0
110 let kp: *u8 = "cand=" as *u8
111 while kp[ko] != (0 as u8) { key[ko] = kp[ko]; ko = ko + 1 }
112 var z: i64 = 0
113 while cand[z] != (0 as u8) { key[ko] = cand[z]; ko = ko + 1; z = z + 1 }
114 key[ko] = 32 as u8
115 key[ko + 1] = 0 as u8
116 var p: i64 = 0
117 var found: i64 = 0
118 var go: i64 = 1
119 while go == 1 {
120 let at: i64 = sfind(led, ln, key, p)
121 if at < 0 { go = 0 }
122 else {
123 // scan to end of this line; GREEN if "maker=GREEN" appears before newline
124 var e: i64 = at
125 var f: i64 = 0
126 while f == 0 { if e >= ln { f = 1 } else { if led[e] == (10 as u8) { f = 1 } else { e = e + 1 } } }
127 if sfind(led, e, "maker=GREEN" as *u8, at) >= 0 { found = 1; go = 0 }
128 p = e + 1
129 }
130 }
131 return found
132}
133// fn NAME recovery from a bugforge instance bf_i<N>_<fn>_<op>: done INLINE in fw_one (strip the
134// "bf_i<N>_" prefix via a flag-exit underscore scan, then the fixed-set "_<op>" suffix via fw_oplen).
135// Robust to fn names WITH underscores (nx_ac_subcool_mC) because op labels are a closed set.
136func fw_oplen(inst: *u8, n: i64) -> i64 {
137 // return byte length of the trailing "_<oplabel>" (including the underscore) for the known set
138 if n >= 7 { if sfind(inst, n, "_addsub" as *u8, n - 7) == n - 7 { return 7 } }
139 if n >= 7 { if sfind(inst, n, "_subadd" as *u8, n - 7) == n - 7 { return 7 } }
140 if n >= 5 { if sfind(inst, n, "_ltgt" as *u8, n - 5) == n - 5 { return 5 } }
141 if n >= 5 { if sfind(inst, n, "_gtlt" as *u8, n - 5) == n - 5 { return 5 } }
142 if n >= 7 { if sfind(inst, n, "_muladd" as *u8, n - 7) == n - 7 { return 7 } }
143 return 0
144}
145
146// copy the (buggy,fixed) pair for instance at manifest offsets into out if green + novel; ret 1 added
147static g_cor: *u8
148static g_cor_o: i64
149static g_fbuf: *u8
150static g_led: *u8
151static g_ledn: i64
152static g_added: i64
153static g_skipdup: i64
154static g_skipred: i64
155
156func fw_one(iname: *u8, ipath: *u8) -> i64 {
157 if fw_green(g_led, g_ledn, iname) == 0 { g_skipred = g_skipred + 1; return 0 }
158 // fn name = iname minus "bf_i<N>_" prefix and "_<op>" suffix
159 let inl: i64 = slen(iname)
160 var ps: i64 = 4
161 var uf: i64 = 0
162 while uf == 0 { if ps >= inl { uf = 1 } else { if iname[ps] == (95 as u8) { uf = 1 } else { ps = ps + 1 } } }
163 ps = ps + 1
164 let opl: i64 = fw_oplen(iname, inl)
165 let fnl: i64 = inl - ps - opl
166 if fnl <= 0 { g_skipred = g_skipred + 1; return 0 }
167 let fname: *u8 = sys_mmap(96)
168 var z: i64 = 0
169 while z < fnl { fname[z] = iname[ps + z]; z = z + 1 }
170 fname[fnl] = 0 as u8
171 // read the candidate (buggy = the mutant under its real name)
172 let cn: i64 = fw_read(ipath, g_fbuf, FW_FCAP)
173 if cn <= 0 { g_skipred = g_skipred + 1; return 0 }
174 // recover original src path from header: // src=<path> op=
175 let sat: i64 = sfind(g_fbuf, cn, "src=" as *u8, 0)
176 if sat < 0 { g_skipred = g_skipred + 1; return 0 }
177 var sp: i64 = sat + 4
178 let spath: *u8 = sys_mmap(200)
179 var so: i64 = 0
180 var sg: i64 = 1
181 while sg == 1 { if sp >= cn { sg = 0 } else { let c: i64 = g_fbuf[sp] as i64; if c == 32 { sg = 0 } else { if c == 10 { sg = 0 } else { spath[so] = g_fbuf[sp]; so = so + 1; sp = sp + 1 } } } }
182 spath[so] = 0 as u8
183 let buggy: *u8 = sys_mmap(FW_TCAP)
184 let bl: i64 = fw_extract(g_fbuf, cn, fname, buggy)
185 if bl <= 0 { g_skipred = g_skipred + 1; return 0 }
186 // read original source, extract the ORACLE fixed fn
187 let obuf: *u8 = sys_mmap(FW_FCAP)
188 let on: i64 = fw_read(spath, obuf, FW_FCAP)
189 if on <= 0 { g_skipred = g_skipred + 1; return 0 }
190 let fixed: *u8 = sys_mmap(FW_TCAP)
191 let fxl: i64 = fw_extract(obuf, on, fname, fixed)
192 if fxl <= 0 { g_skipred = g_skipred + 1; return 0 }
193 // reject degenerate (fixed==buggy)
194 if fxl == bl { var eq: i64 = 1; var q: i64 = 0; while q < fxl { if fixed[q] != buggy[q] { eq = 0; q = fxl } else { q = q + 1 } } if eq == 1 { g_skipred = g_skipred + 1; return 0 } }
195 // build the row: buggy TAB fixed NEWLINE (already 0x01-escaped by fw_extract)
196 let row: *u8 = sys_mmap(FW_TCAP * 2)
197 var ro: i64 = 0
198 var a: i64 = 0
199 while a < bl { row[ro] = buggy[a]; ro = ro + 1; a = a + 1 }
200 row[ro] = 9 as u8
201 ro = ro + 1
202 var b: i64 = 0
203 while b < fxl { row[ro] = fixed[b]; ro = ro + 1; b = b + 1 }
204 // de-dup: exact row already in corpus?
205 if g_cor_o > 0 { if sfind(g_cor, g_cor_o, row, 0) >= 0 { g_skipdup = g_skipdup + 1; return 0 } }
206 // append
207 var c2: i64 = 0
208 while c2 < ro { g_cor[g_cor_o] = row[c2]; g_cor_o = g_cor_o + 1; c2 = c2 + 1 }
209 g_cor[g_cor_o] = 10 as u8
210 g_cor_o = g_cor_o + 1
211 g_added = g_added + 1
212 return 1
213}
214
215func fw_harvest(manp: *u8, ledp: *u8) -> i64 {
216 g_cor = sys_mmap(FW_CORCAP)
217 g_fbuf = sys_mmap(FW_FCAP)
218 g_led = sys_mmap(FW_FCAP)
219 g_cor_o = 0
220 g_added = 0
221 g_skipdup = 0
222 g_skipred = 0
223 // PRELOAD existing genome (additive, never replace)
224 let pre: i64 = fw_read("bf_fixcorpus.txt" as *u8, g_cor, FW_CORCAP)
225 if pre > 0 { g_cor_o = pre }
226 let start: i64 = g_cor_o
227 g_ledn = fw_read(ledp, g_led, FW_FCAP)
228 if g_ledn <= 0 { w("cannot read ledger " as *u8); w(ledp); w("\n" as *u8); return 1 }
229 let man: *u8 = sys_mmap(FW_FCAP)
230 let mn: i64 = fw_read(manp, man, FW_FCAP)
231 if mn <= 0 { w("cannot read manifest\n" as *u8); return 1 }
232 var rows: i64 = 0
233 var p: i64 = 0
234 while p < mn {
235 var e: i64 = p
236 var f: i64 = 0
237 while f == 0 { if e >= mn { f = 1 } else { if man[e] == (10 as u8) { f = 1 } else { e = e + 1 } } }
238 if e > p { if man[p] != (35 as u8) {
239 var pipe: i64 = 0 - 1
240 var b: i64 = p
241 var bd: i64 = 0
242 while bd == 0 { if b >= e { bd = 1 } else { if man[b] == (124 as u8) { pipe = b; bd = 1 } else { b = b + 1 } } }
243 if pipe > p {
244 let iname: *u8 = sys_mmap(128)
245 let ipath: *u8 = sys_mmap(200)
246 var x: i64 = p
247 var io: i64 = 0
248 while x < pipe { iname[io] = man[x]; io = io + 1; x = x + 1 }
249 iname[io] = 0 as u8
250 var y: i64 = pipe + 1
251 var jo: i64 = 0
252 while y < e { ipath[jo] = man[y]; jo = jo + 1; y = y + 1 }
253 ipath[jo] = 0 as u8
254 rows = rows + 1
255 fw_one(iname, ipath)
256 }
257 } }
258 p = e + 1
259 }
260 // write back only if we grew (monotone)
261 if g_cor_o > start { fw_write("bf_fixcorpus.txt" as *u8, g_cor, g_cor_o) }
262 w("NX-FIXFLYWHEEL harvest manifest_rows=" as *u8)
263 wn(rows)
264 w(" genome_before=" as *u8)
265 wn(start)
266 w("B added=" as *u8)
267 wn(g_added)
268 w(" skip_dup=" as *u8)
269 wn(g_skipdup)
270 w(" skip_notgreen_or_bad=" as *u8)
271 wn(g_skipred)
272 w(" genome_after=" as *u8)
273 wn(g_cor_o)
274 w("B (ADDITIVE + de-duped -- monotone genome ratchet)\n" as *u8)
275 return 0
276}
277
278func fw_selftest() -> i64 {
279 var passn: i64 = 0
280 // T1 fw_oplen recognizes the known op suffixes
281 let a1: *u8 = "bf_i16_nx_ac_subcool_mC_subadd" as *u8
282 if fw_oplen(a1, slen(a1)) == 7 { passn = passn + 1; w("T1 oplen-subadd PASS\n" as *u8) } else { w("T1 FAIL\n" as *u8) }
283 let a2: *u8 = "bf_i2_ms_iabs_ltgt" as *u8
284 if fw_oplen(a2, slen(a2)) == 5 { passn = passn + 1; w("T2 oplen-ltgt PASS\n" as *u8) } else { w("T2 FAIL\n" as *u8) }
285 // T3 fw_extract pulls a multi-line fn with 0x01 newlines
286 let src: *u8 = "func foo(a: i64) -> i64 {\n if a < 0 { return 0 }\n return a\n}\n" as *u8
287 let dst: *u8 = sys_mmap(512)
288 let el: i64 = fw_extract(src, slen(src), "foo" as *u8, dst)
289 var ok3: i64 = 0
290 if el > 20 { if dst[0] == (102 as u8) { var hasesc: i64 = 0; var z: i64 = 0; while z < el { if dst[z] == (1 as u8) { hasesc = 1 } z = z + 1 } if hasesc == 1 { ok3 = 1 } } }
291 if ok3 == 1 { passn = passn + 1; w("T3 extract-multiline PASS\n" as *u8) } else { w("T3 FAIL len=" as *u8); wn(el); w("\n" as *u8) }
292 // T4 fw_green parses a GREEN ledger row and rejects a MISS
293 let led: *u8 = "AUTOFIX-AUTO ts=1 cand=bf_i5_fx_add_addsub located=fx_add attempts=1 maker=GREEN revert=1\nAUTOFIX-AUTO ts=1 cand=bf_i1_pad16_len_subadd located=pad16_len attempts=6 maker=MISS revert=1\n" as *u8
294 let ln: i64 = slen(led)
295 var ok4: i64 = 0
296 if fw_green(led, ln, "bf_i5_fx_add_addsub" as *u8) == 1 { if fw_green(led, ln, "bf_i1_pad16_len_subadd" as *u8) == 0 { ok4 = 1 } }
297 if ok4 == 1 { passn = passn + 1; w("T4 green-parse PASS\n" as *u8) } else { w("T4 FAIL\n" as *u8) }
298 w("NX-FIXFLYWHEEL selftest " as *u8)
299 wn(passn)
300 w("/4 " as *u8)
301 if passn == 4 { w("VERDICT=GREEN\n" as *u8); return 0 }
302 w("VERDICT=RED\n" as *u8)
303 return 1
304}
305
306func main(argc: i64, argv: *i64) -> i64 {
307 var verb: *u8 = "selftest" as *u8
308 if argc > 1 { verb = argv[1] as *u8 }
309 if verb[0] == (104 as u8) {
310 if argc < 4 { w("usage: nx_fixflywheel harvest <manifest> <ledger>\n" as *u8); return 2 }
311 return fw_harvest(argv[2] as *u8, argv[3] as *u8)
312 }
313 return fw_selftest()
314}