nx_forge.nx source
↩ module page · 327 lines · 13125 B
1// nx_forge.nx -- FORGE F3 rung 1: the autonomous-coding DRIVER core (pure lib, no main; CLI =
2// nx_forge_run, gate = nx_forge_gate). Runs one task spec through the full harness loop:
3// spec -> candidate source -> literal-ban check (anti-hardcode, pre-build) -> write
4// runtime/<organ>.nx -> sovereign lane --build-only (fork+execve, verbatim compiler output
5// banked to the repair context on failure) -> run the built elf with stdout captured ->
6// BYTE-EXACT judge vs expected bytes -> bounded repair cycles (ACT cap 7) -> append-only
7// FORGE LEDGER row (knowledge/forge/forge_ledger.txt -- every GREEN = a compile-verified
8// training example, the N7 hook).
9// Rung 1 backend = candidate FILES (the gate's fixture model); rung 2 plugs model calls
10// (:11434 local serve + Claude API) into the same loop -- the judge/repair mechanics are
11// identical and are what this rung proves.
12// Spec row: FTASK|<organ>|<expect-bytes-file>|<ban-csv-or-none>|<cand1,cand2,...>|<maxcycles>
13// fg_run returns: >0 success-at-cycle-N; -2 spec unreadable; -3 no FTASK row; -4 expect
14// unreadable; -20 candidates exhausted; -21 max-cycles hit; -22 bad organ name.
15// license_tier: ORIGINAL
16import "nx_forge_ctx.nx"
17const K_MAGIC_16384: i64 = 16384
18const K_MAGIC_65536: i64 = 65536
19const K_MAGIC_131072: i64 = 131072
20
21static fg_numbuf: *u8
22
23func fg_wdec(fd: i64, v: i64) -> i64 {
24 if (fg_numbuf as i64) == 0 { fg_numbuf = sys_mmap(32) as *u8 }
25 let ln: i64 = std_itoa(v, fg_numbuf)
26 let r: i64 = fc_wb(fd, fg_numbuf, ln)
27 return r
28}
29
30// compose prefix+name+suffix into out (NUL-terminated); returns len
31func fg_mkpath(prefix: *u8, name: *u8, suffix: *u8, out: *u8) -> i64 {
32 var o: i64 = 0
33 var i: i64 = 0
34 while prefix[i] != (0 as u8) { out[o] = prefix[i]; o = o + 1; i = i + 1 }
35 i = 0
36 while name[i] != (0 as u8) { out[o] = name[i]; o = o + 1; i = i + 1 }
37 i = 0
38 while suffix[i] != (0 as u8) { out[o] = suffix[i]; o = o + 1; i = i + 1 }
39 out[o] = 0 as u8
40 return o
41}
42
43// fork+exec av (av[0]=program), child stdout+stderr truncated into outpath; 0 clean / 1 fired
44func fg_spawn(outpath: *u8, av: *i64, envp: *i64, st: *i64) -> i64 {
45 let pid: i64 = sys_fork()
46 if pid == 0 {
47 let ofd: i64 = sys_openat_wr(outpath, 420)
48 if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_dup3(ofd, 2, 0) }
49 let p0: i64 = av[0]
50 let prog: *u8 = p0 as *u8
51 sys_execve(prog, av, envp)
52 sys_exit(127)
53 }
54 st[0] = 0
55 sys_wait4(pid, st, 0)
56 let sv: i64 = st[0]
57 let crashed: i64 = sv % 128
58 let ec: i64 = (sv >> 8) & 255
59 if crashed != 0 { return 1 }
60 if ec != 0 { return 1 }
61 return 0
62}
63
64// append a header + the bytes of file src into open fd (repair-context banking)
65func fg_bank(fd: i64, hdr: *u8, src: *u8, tmp: *u8, cap: i64) -> i64 {
66 fc_ws(fd, hdr)
67 let n: i64 = fc_read(src, tmp, cap)
68 if n > 0 { fc_wb(fd, tmp, n) }
69 fc_ws(fd, "\n" as *u8)
70 return 0
71}
72
73func fg_run(specpath: *u8) -> i64 {
74 let sbuf: *u8 = sys_mmap(K_MAGIC_16384) as *u8
75 let sn: i64 = fc_read(specpath, sbuf, K_MAGIC_16384)
76 if sn <= 0 { return 0 - 2 }
77 // locate the FTASK row
78 var ls: i64 = 0 - 1
79 var le: i64 = 0
80 var i: i64 = 0
81 while i < sn {
82 var e: i64 = i
83 var scan: i64 = 1
84 while scan == 1 {
85 if e >= sn { scan = 0 }
86 if scan == 1 {
87 let c: i64 = sbuf[e] as i64
88 if c == 10 { scan = 0 }
89 if c != 10 { e = e + 1 }
90 }
91 }
92 if ls < 0 {
93 let ll: i64 = e - i
94 if ll > 6 {
95 let c0: i64 = sbuf[i] as i64
96 let i1: i64 = i + 1
97 let c1: i64 = sbuf[i1] as i64
98 let i2: i64 = i + 2
99 let c2: i64 = sbuf[i2] as i64
100 let i3: i64 = i + 3
101 let c3: i64 = sbuf[i3] as i64
102 let i4: i64 = i + 4
103 let c4: i64 = sbuf[i4] as i64
104 let i5: i64 = i + 5
105 let c5: i64 = sbuf[i5] as i64
106 if c0 == 70 && c1 == 84 && c2 == 65 && c3 == 83 && c4 == 75 && c5 == 124 {
107 ls = i
108 le = e
109 }
110 }
111 }
112 i = e + 1
113 }
114 if ls < 0 { return 0 - 3 }
115 let of: i64 = fc_fstart(sbuf, ls, le, 1)
116 let ofe: i64 = fc_fend(sbuf, of, le)
117 let xf: i64 = fc_fstart(sbuf, ls, le, 2)
118 let xfe: i64 = fc_fend(sbuf, xf, le)
119 let bf: i64 = fc_fstart(sbuf, ls, le, 3)
120 let bfe: i64 = fc_fend(sbuf, bf, le)
121 let cf: i64 = fc_fstart(sbuf, ls, le, 4)
122 let cfe: i64 = fc_fend(sbuf, cf, le)
123 let mf: i64 = fc_fstart(sbuf, ls, le, 5)
124 if of < 0 || xf < 0 || bf < 0 || cf < 0 || mf < 0 { return 0 - 3 }
125 let mfe0: i64 = fc_fend(sbuf, mf, le)
126 let mfe: i64 = fc_line_cend(sbuf, mf, mfe0)
127 // organ name
128 let organ: *u8 = sys_mmap(128) as *u8
129 let ol: i64 = ofe - of
130 if ol <= 2 || ol > 100 { return 0 - 22 }
131 let osrc: *u8 = sbuf + of
132 std_memcpy(organ, osrc, ol)
133 organ[ol] = 0 as u8
134 // expected bytes
135 let xpath: *u8 = sys_mmap(512) as *u8
136 let xl: i64 = xfe - xf
137 let xsrc: *u8 = sbuf + xf
138 std_memcpy(xpath, xsrc, xl)
139 xpath[xl] = 0 as u8
140 let ebuf: *u8 = sys_mmap(K_MAGIC_65536) as *u8
141 let en: i64 = fc_read(xpath, ebuf, K_MAGIC_65536)
142 if en <= 0 { return 0 - 4 }
143 // maxcycles (ACT cap 7)
144 let mbuf: *u8 = sys_mmap(32) as *u8
145 let ml: i64 = mfe - mf
146 let msrc: *u8 = sbuf + mf
147 std_memcpy(mbuf, msrc, ml)
148 mbuf[ml] = 0 as u8
149 var maxc: i64 = std_atoi(mbuf)
150 if maxc <= 0 { maxc = 1 }
151 if maxc > 7 { maxc = 7 }
152 // ban present?
153 var hasban: i64 = 1
154 let bl: i64 = bfe - bf
155 if bl == 0 { hasban = 0 }
156 if bl == 4 {
157 let b0: i64 = sbuf[bf] as i64
158 let bi1: i64 = bf + 1
159 let b1: i64 = sbuf[bi1] as i64
160 let bi2: i64 = bf + 2
161 let b2: i64 = sbuf[bi2] as i64
162 let bi3: i64 = bf + 3
163 let b3: i64 = sbuf[bi3] as i64
164 if b0 == 110 && b1 == 111 && b2 == 110 && b3 == 101 { hasban = 0 }
165 }
166 // derived paths
167 let srcpath: *u8 = sys_mmap(256) as *u8
168 fg_mkpath("runtime/" as *u8, organ, ".nx" as *u8, srcpath)
169 let elfpath: *u8 = sys_mmap(256) as *u8
170 fg_mkpath("/tmp/" as *u8, organ, ".sov.elf" as *u8, elfpath)
171 // repair context (truncated per run)
172 let ctxfd: i64 = sys_openat_wr("/tmp/forge_repair_ctx.txt" as *u8, 420)
173 // exec scratch
174 let av: *i64 = sys_mmap(64) as *i64
175 let envp: *i64 = sys_mmap(32) as *i64
176 envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64
177 envp[1] = 0
178 let st: *i64 = sys_mmap(64) as *i64
179 let cbuf: *u8 = sys_mmap(K_MAGIC_131072) as *u8
180 let cpath: *u8 = sys_mmap(512) as *u8
181 let rbuf: *u8 = sys_mmap(K_MAGIC_65536) as *u8
182 let tbuf: *u8 = sys_mmap(K_MAGIC_65536) as *u8
183 // cycle loop
184 var cj: i64 = cf
185 var cycle: i64 = 0
186 var verdict: i64 = 0 - 20
187 var done: i64 = 0
188 while done == 0 {
189 if cycle >= maxc { verdict = 0 - 21; done = 1 }
190 if done == 0 {
191 if cj >= cfe { verdict = 0 - 20; done = 1 }
192 }
193 if done == 0 {
194 var k: i64 = cj
195 var t: i64 = 1
196 while t == 1 {
197 if k >= cfe { t = 0 }
198 if t == 1 {
199 let cch: i64 = sbuf[k] as i64
200 if cch == 44 { t = 0 }
201 if cch != 44 { k = k + 1 }
202 }
203 }
204 let cl: i64 = k - cj
205 let csrc: *u8 = sbuf + cj
206 std_memcpy(cpath, csrc, cl)
207 cpath[cl] = 0 as u8
208 cj = k + 1
209 cycle = cycle + 1
210 std_puts("FORGE cycle=" as *u8)
211 std_pdec(cycle)
212 std_puts(" cand=" as *u8)
213 std_puts(cpath)
214 let cn: i64 = fc_read(cpath, cbuf, K_MAGIC_131072)
215 if cn <= 0 {
216 fc_ws(ctxfd, "CYCLE-FAIL cand-unreadable\n" as *u8)
217 std_putln(" -> cand-unreadable" as *u8)
218 }
219 if cn > 0 {
220 var flagged: i64 = 0
221 if hasban == 1 {
222 var bj: i64 = bf
223 while bj < bfe {
224 var bk: i64 = bj
225 var bt: i64 = 1
226 while bt == 1 {
227 if bk >= bfe { bt = 0 }
228 if bt == 1 {
229 let bch: i64 = sbuf[bk] as i64
230 if bch == 44 { bt = 0 }
231 if bch != 44 { bk = bk + 1 }
232 }
233 }
234 let tl2: i64 = bk - bj
235 if tl2 > 0 {
236 let bp: *u8 = sbuf + bj
237 let hit: i64 = fc_contains(cbuf, cn, bp, tl2)
238 if hit == 1 { flagged = 1 }
239 }
240 bj = bk + 1
241 }
242 }
243 if flagged == 1 {
244 fc_ws(ctxfd, "CYCLE-FAIL banned-literal-in-source (hardcode flag)\n" as *u8)
245 std_putln(" -> HARDCODE-FLAGGED" as *u8)
246 }
247 if flagged == 0 {
248 let sfd: i64 = sys_openat_wr(srcpath, 420)
249 var wrote: i64 = 0
250 if sfd >= 0 {
251 let wr: i64 = fc_wb(sfd, cbuf, cn)
252 sys_close(sfd)
253 if wr == 0 { wrote = 1 }
254 }
255 if wrote == 0 {
256 fc_ws(ctxfd, "CYCLE-FAIL source-write\n" as *u8)
257 std_putln(" -> source-write-fail" as *u8)
258 }
259 if wrote == 1 {
260 av[0] = "_offc/nx_sov_build_run.elf" as *u8 as i64
261 av[1] = organ as i64
262 av[2] = "--build-only" as *u8 as i64
263 av[3] = 0
264 let bfail: i64 = fg_spawn("/tmp/forge_build.out" as *u8, av, envp, st)
265 if bfail == 1 {
266 fg_bank(ctxfd, "CYCLE-FAIL build; verbatim compiler output:\n" as *u8, "/tmp/forge_build.out" as *u8, tbuf, K_MAGIC_65536)
267 std_putln(" -> BUILD-FAIL (stderr banked)" as *u8)
268 }
269 if bfail == 0 {
270 av[0] = elfpath as i64
271 av[1] = 0
272 let rfail: i64 = fg_spawn("/tmp/forge_run.out" as *u8, av, envp, st)
273 if rfail == 1 {
274 fg_bank(ctxfd, "CYCLE-FAIL run-nonzero; output:\n" as *u8, "/tmp/forge_run.out" as *u8, tbuf, K_MAGIC_65536)
275 std_putln(" -> RUN-FAIL" as *u8)
276 }
277 if rfail == 0 {
278 let rn: i64 = fc_read("/tmp/forge_run.out" as *u8, rbuf, K_MAGIC_65536)
279 var ok: i64 = 0
280 if rn == en {
281 var m: i64 = 0
282 var eq: i64 = 1
283 while m < en {
284 let x: i64 = rbuf[m] as i64
285 let y: i64 = ebuf[m] as i64
286 if x != y { eq = 0; m = en }
287 if x == y { m = m + 1 }
288 }
289 ok = eq
290 }
291 if ok == 1 {
292 verdict = cycle
293 done = 1
294 std_putln(" -> GREEN byte-exact" as *u8)
295 }
296 if ok == 0 {
297 fg_bank(ctxfd, "CYCLE-FAIL output-mismatch; got:\n" as *u8, "/tmp/forge_run.out" as *u8, tbuf, K_MAGIC_65536)
298 std_putln(" -> JUDGE-REJECT (bytes differ)" as *u8)
299 }
300 }
301 }
302 }
303 }
304 }
305 }
306 }
307 sys_close(ctxfd)
308 // ledger (append-only; every GREEN row = a compile-verified training example)
309 let lfd: i64 = sys_openat_append("knowledge/forge/forge_ledger.txt" as *u8, 420)
310 if lfd >= 0 {
311 fc_ws(lfd, "FORGE|" as *u8)
312 fc_ws(lfd, organ)
313 fc_ws(lfd, "|cycles=" as *u8)
314 fg_wdec(lfd, cycle)
315 fc_ws(lfd, "|verdict=" as *u8)
316 if verdict > 0 { fc_ws(lfd, "GREEN" as *u8) }
317 if verdict <= 0 { fc_ws(lfd, "RED" as *u8) }
318 fc_ws(lfd, "|rc=" as *u8)
319 fg_wdec(lfd, verdict)
320 fc_ws(lfd, "|us=" as *u8)
321 let now: i64 = sys_now_us()
322 fg_wdec(lfd, now)
323 fc_ws(lfd, "\n" as *u8)
324 sys_close(lfd)
325 }
326 return verdict
327}