nx_forge_model_gate.nx source
↩ module page · 154 lines · 6286 B
1// nx_forge_model_gate.nx -- gate for the F3 rung-2 model backend (nx_forge_model.nx). Proves the
2// model-stage mechanics sovereignly, no external model:
3// T1 extract+strip from the canned /gen JSON fixture -> valid program bytes (fences gone)
4// T2 NEG malformed response (no "text") -> fm_extract_text returns -1
5// T3 prompt compose -> contains a pack marker AND the task statement
6// T4 LIVE loopback: fork an in-process stub serve, POST /gen to 127.0.0.1, extract -> program
7// T5 INTEGRATION: the extracted program -> candidate file -> fg_run judges it GREEN byte-exact
8// T6 fence-strip idempotent on unfenced text (no-op)
9// license_tier: ORIGINAL expect_exit: 0
10import "nx_forge_model.nx"
11import "nx_gate_verdict.nx"
12
13const FMG_PORT: i64 = 17719
14
15func fmg_write(path: *u8, src: *u8, n: i64) -> i64 {
16 let fd: i64 = sys_openat_wr(path, 420)
17 if fd < 0 { return 0 - 1 }
18 let w: i64 = fc_wb(fd, src, n)
19 sys_close(fd)
20 return w
21}
22
23func main(argc: i64, argv: *i64) -> i64 {
24 var pass: i64 = 0
25 let resp: *u8 = sys_mmap(65536) as *u8
26 let txt: *u8 = sys_mmap(65536) as *u8
27 let prog: *u8 = sys_mmap(65536) as *u8
28 // T1: extract + strip from the canned fixture, then write the candidate file
29 let rn: i64 = fc_read("knowledge/forge/fix/stub_gen_resp.json" as *u8, resp, 65536)
30 let tl: i64 = fm_extract_text(resp, rn, txt, 65536)
31 var pl: i64 = 0
32 if tl > 0 { pl = fm_strip_fences(txt, tl, prog) }
33 var t1: i64 = 0
34 if pl > 0 {
35 let m1: *u8 = "FORGE-M ok" as *u8
36 let f1: i64 = fc_contains(prog, pl, m1, std_slen(m1))
37 let m2: *u8 = "func main" as *u8
38 let f2: i64 = fc_contains(prog, pl, m2, std_slen(m2))
39 let tick: *u8 = "`" as *u8
40 let f3: i64 = fc_contains(prog, pl, tick, 1)
41 if f1 == 1 && f2 == 1 && f3 == 0 { t1 = 1 }
42 }
43 std_puts("T1 extract+strip len=" as *u8)
44 std_pdec(pl)
45 if t1 == 1 { std_putln(" PASS" as *u8) }
46 if t1 == 0 { std_putln(" FAIL" as *u8) }
47 pass = pass + t1
48 if t1 == 1 { fmg_write("knowledge/forge/fix/cand_model.nx" as *u8, prog, pl) }
49 // T2: malformed response -> -1
50 let bad: *u8 = "{\"n_gen\":3,\"oops\":\"no text field here\"}" as *u8
51 let bl: i64 = std_slen(bad)
52 let r2: i64 = fm_extract_text(bad, bl, txt, 65536)
53 var t2: i64 = 0
54 let neg1: i64 = 0 - 1
55 if r2 == neg1 { t2 = 1 }
56 std_puts("T2 malformed-reject rc=" as *u8)
57 std_pdec(r2)
58 if t2 == 1 { std_putln(" NEGCTL-CAUGHT PASS" as *u8) }
59 if t2 == 0 { std_putln(" FAIL" as *u8) }
60 pass = pass + t2
61 // T3: prompt compose
62 let prm: *u8 = sys_mmap(131072) as *u8
63 let z: *i64 = 0 as *i64
64 let cn: i64 = fm_compose_prompt("knowledge/forge/nishilang_pack_v1.txt" as *u8, "Print the line FORGE-M ok and exit 0." as *u8, z as *u8, prm, 131072)
65 var t3: i64 = 0
66 if cn > 0 {
67 let m1: *u8 = "HARD RULES" as *u8
68 let f1: i64 = fc_contains(prm, cn, m1, std_slen(m1))
69 let m2: *u8 = "Print the line FORGE-M ok" as *u8
70 let f2: i64 = fc_contains(prm, cn, m2, std_slen(m2))
71 if f1 == 1 && f2 == 1 { t3 = 1 }
72 }
73 std_puts("T3 prompt-compose len=" as *u8)
74 std_pdec(cn)
75 if t3 == 1 { std_putln(" PASS" as *u8) }
76 if t3 == 0 { std_putln(" FAIL" as *u8) }
77 pass = pass + t3
78 // T4: LIVE loopback round-trip against a forked in-process stub serve
79 let pid: i64 = sys_fork()
80 if pid == 0 {
81 fm_stub_serve_once(FMG_PORT, "knowledge/forge/fix/stub_gen_resp.json" as *u8)
82 sys_exit(0)
83 return 0
84 }
85 sys_sleep_ms(400)
86 let body: *u8 = sys_mmap(4096) as *u8
87 let bn: i64 = fm_build_gen_body("write a program" as *u8, 15, 64, 0, body)
88 let resp2: *u8 = sys_mmap(65536) as *u8
89 let got: i64 = fm_post_gen(127, 0, 0, 1, FMG_PORT, body, bn, resp2, 65536)
90 let st: *i64 = sys_mmap(16) as *i64
91 sys_wait4(pid, st, 0)
92 var t4: i64 = 0
93 if got > 0 {
94 let key: *u8 = "\"text\":\"" as *u8
95 let fk: i64 = fc_contains(resp2, got, key, std_slen(key))
96 let t2l: i64 = fm_extract_text(resp2, got, txt, 65536)
97 var p2l: i64 = 0
98 if t2l > 0 { p2l = fm_strip_fences(txt, t2l, prog) }
99 var okp: i64 = 0
100 if p2l > 0 {
101 let m1: *u8 = "FORGE-M ok" as *u8
102 okp = fc_contains(prog, p2l, m1, std_slen(m1))
103 }
104 if fk == 1 && okp == 1 { t4 = 1 }
105 }
106 std_puts("T4 live-loopback got=" as *u8)
107 std_pdec(got)
108 if t4 == 1 { std_putln(" PASS" as *u8) }
109 if t4 == 0 { std_putln(" FAIL" as *u8) }
110 pass = pass + t4
111 // T5: integration -- the produced candidate goes through the judge GREEN
112 let r5: i64 = fg_run("knowledge/forge/fix/spec_m.txt" as *u8)
113 var t5: i64 = 0
114 if r5 == 1 { t5 = 1 }
115 std_puts("T5 model->candidate->judge rc=" as *u8)
116 std_pdec(r5)
117 if t5 == 1 { std_putln(" PASS" as *u8) }
118 if t5 == 0 { std_putln(" FAIL" as *u8) }
119 pass = pass + t5
120 // T6: fence-strip idempotent on unfenced text
121 let plain: *u8 = "no fences here\nsecond line\n" as *u8
122 let plen: i64 = std_slen(plain)
123 let out6: *u8 = sys_mmap(4096) as *u8
124 let o6: i64 = fm_strip_fences(plain, plen, out6)
125 var t6: i64 = 0
126 if o6 == plen {
127 var eq: i64 = 1
128 var k: i64 = 0
129 while k < plen {
130 let x: i64 = plain[k] as i64
131 let y: i64 = out6[k] as i64
132 if x != y { eq = 0; k = plen }
133 if x == y { k = k + 1 }
134 }
135 t6 = eq
136 }
137 std_puts("T6 fence-idempotent len=" as *u8)
138 std_pdec(o6)
139 if t6 == 1 { std_putln(" PASS" as *u8) }
140 if t6 == 0 { std_putln(" FAIL" as *u8) }
141 pass = pass + t6
142 // verdict
143 std_puts("FORGE-MODEL-GATE pass=" as *u8)
144 std_pdec(pass)
145 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
146 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
147 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
148 let ctr__dry: *i64 = gv_ctr()
149 ctr__dry[0] = pass
150 ctr__dry[1] = 6
151 let rc__dry: i64 = gv_verdict("FORGE-MODEL-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
152 sys_exit(rc__dry)
153 return rc__dry
154}