nx_coder_swap_gate.nx source
↩ module page · 158 lines · 6341 B
1// nx_coder_swap_gate.nx -- L3 gate: the Qwen2.5-Coder-0.5B q8_0 GGUF staged ADDITIVELY at
2// /home/elderwesto/nx_stage/nx_coder_model.gguf must be REAL and LOADABLE through the SAME
3// sovereign stack before any capability claim (dossier row L3). Teeth:
4// T1 GGUF parses (nx_gguf_parse OK on the full file)
5// T2 named-tensor load+dequant works (blk.0.attn_q.weight -> Q16, >0 values) = the exact
6// pipeline the serve uses, on the CODER file's own quant layout
7// T3 FIM special tokens present in tokenizer metadata (<|fim_prefix|> searched in the head)
8// T4 identity: the metadata head names "coder" (proves this is the Coder file, not a base copy)
9// T5 NEG corrupted-magic head must FAIL the parser (liar-kill: the parser really validates)
10// license_tier: ORIGINAL expect_exit: 0
11import "nx_syscalls.nx"
12import "nx_tier.nx"
13import "nx_le.nx"
14import "nx_tensor.nx"
15import "nx_gguf.nx"
16import "nx_gguf_load.nx"
17import "nx_nofloat_llm.nx"
18import "nx_gate_verdict.nx"
19import "nx_stage_path.nx"
20
21func cs_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
22func cs_num(v: i64) -> i64 { let b: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)} let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 }
23func cs_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
24
25// naive substring in [0,hn)
26func cs_contains(hay: *u8, hn: i64, nd: *u8) -> i64 {
27 let nn: i64 = cs_slen(nd)
28 if nn <= 0 { return 0 }
29 if hn < nn { return 0 }
30 var i: i64 = 0
31 let stop: i64 = hn - nn
32 while i <= stop {
33 var j: i64 = 0
34 var ok: i64 = 1
35 while j < nn {
36 let hidx: i64 = i + j
37 let a: i64 = hay[hidx] as i64
38 let b: i64 = nd[j] as i64
39 if a != b { ok = 0; j = nn }
40 if a == b { j = j + 1 }
41 }
42 if ok == 1 { return 1 }
43 i = i + 1
44 }
45 return 0
46}
47
48func main() -> i64 {
49 var pass: i64 = 0
50 let path: *u8 = sp_path("nx_coder_model.gguf" as *u8, sys_mmap(SP_PATH_MAX))
51 sp_skip_unless("CODER-SWAP-GATE" as *u8, path)
52 let len_out: *i64 = sys_mmap(8) as *i64
53 len_out[0] = 0
54 let buf: *u8 = sys_read_file(path, len_out)
55 let flen: i64 = len_out[0]
56 cs_puts("CODER-SWAP file bytes=" as *u8)
57 cs_num(flen)
58 cs_puts("\n" as *u8)
59 // T1 parse
60 var t1: i64 = 0
61 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
62 if buf != (0 as *u8) {
63 if flen > 1000000 {
64 let pr: i64 = nx_gguf_parse(buf, flen, hdr)
65 if pr == NX_GGUF_OK { t1 = 1 }
66 }
67 }
68 if t1 == 1 { cs_puts("T1 gguf-parse PASS\n" as *u8) }
69 if t1 == 0 { cs_puts("T1 gguf-parse FAIL\n" as *u8) }
70 pass = pass + t1
71 // T2 named tensor load+dequant (the serve's exact path) on the coder file
72 var t2: i64 = 0
73 if t1 == 1 {
74 let ne: i64 = 896
75 let OUT: i64 = 896
76 let Wq: *i64 = sys_mmap(OUT * ne * 8) as *i64
77 let nm: *u8 = "blk.0.attn_q.weight\x00" as *u8
78 let nl: i64 = cs_slen(nm)
79 let lr: i64 = load_named_q16(buf, hdr, nm, nl, Wq, OUT * ne)
80 cs_puts("T2 load_named rc=" as *u8)
81 cs_num(lr)
82 if lr > 0 {
83 var nz: i64 = 0
84 var k: i64 = 0
85 while k < 1000 {
86 if Wq[k] != 0 { nz = nz + 1 }
87 k = k + 1
88 }
89 cs_puts(" nonzero-of-1000=" as *u8)
90 cs_num(nz)
91 if nz > 100 { t2 = 1 }
92 }
93 if t2 == 1 { cs_puts(" PASS\n" as *u8) }
94 if t2 == 0 { cs_puts(" FAIL\n" as *u8) }
95 }
96 if t1 == 0 { cs_puts("T2 skipped FAIL\n" as *u8) }
97 pass = pass + t2
98 // T3 FIM tokens in the metadata head
99 var t3: i64 = 0
100 var headn: i64 = flen
101 if headn > 5000000 { headn = 5000000 }
102 if buf != (0 as *u8) {
103 let f1: i64 = cs_contains(buf, headn, "<|fim_prefix|>" as *u8)
104 let f2: i64 = cs_contains(buf, headn, "<|fim_middle|>" as *u8)
105 let f3: i64 = cs_contains(buf, headn, "<|fim_suffix|>" as *u8)
106 let fsum: i64 = f1 + f2 + f3
107 cs_puts("T3 fim-tokens found=" as *u8)
108 cs_num(fsum)
109 if fsum == 3 { t3 = 1 }
110 if t3 == 1 { cs_puts(" PASS\n" as *u8) }
111 if t3 == 0 { cs_puts(" FAIL\n" as *u8) }
112 }
113 pass = pass + t3
114 // T4 identity: metadata names coder
115 var t4: i64 = 0
116 if buf != (0 as *u8) {
117 var idn: i64 = flen
118 if idn > 200000 { idn = 200000 }
119 let g1: i64 = cs_contains(buf, idn, "Coder" as *u8)
120 let g2: i64 = cs_contains(buf, idn, "coder" as *u8)
121 let gsum: i64 = g1 + g2
122 cs_puts("T4 coder-identity hits=" as *u8)
123 cs_num(gsum)
124 if gsum >= 1 { t4 = 1 }
125 if t4 == 1 { cs_puts(" PASS\n" as *u8) }
126 if t4 == 0 { cs_puts(" FAIL\n" as *u8) }
127 }
128 pass = pass + t4
129 // T5 NEG: corrupted magic must fail the parser
130 var t5: i64 = 0
131 if buf != (0 as *u8) {
132 if flen > 8192 {
133 let cbuf: *u8 = sys_mmap(8192) as *u8
134 var k: i64 = 0
135 while k < 8192 { cbuf[k] = buf[k]; k = k + 1 }
136 cbuf[0] = 88 as u8
137 let hdr2: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
138 let pr2: i64 = nx_gguf_parse(cbuf, 8192, hdr2)
139 cs_puts("T5 corrupt-magic rc=" as *u8)
140 cs_num(pr2)
141 if pr2 != NX_GGUF_OK { t5 = 1 }
142 if t5 == 1 { cs_puts(" NEGCTL-CAUGHT PASS\n" as *u8) }
143 if t5 == 0 { cs_puts(" NEGCTL-NOT-CAUGHT FAIL\n" as *u8) }
144 }
145 }
146 pass = pass + t5
147 cs_puts("CODER-SWAP-GATE pass=" as *u8)
148 cs_num(pass)
149 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
150 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
151 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
152 let ctr__dry: *i64 = gv_ctr()
153 ctr__dry[0] = pass
154 ctr__dry[1] = 5
155 let rc__dry: i64 = gv_verdict("CODER-SWAP-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
156 sys_exit(rc__dry)
157 return rc__dry
158}