nx_coder_swap_gate.nx source
↩ module page · 156 lines · 6262 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"
19
20func 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 }
21func 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 }
22func cs_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
23
24// naive substring in [0,hn)
25func cs_contains(hay: *u8, hn: i64, nd: *u8) -> i64 {
26 let nn: i64 = cs_slen(nd)
27 if nn <= 0 { return 0 }
28 if hn < nn { return 0 }
29 var i: i64 = 0
30 let stop: i64 = hn - nn
31 while i <= stop {
32 var j: i64 = 0
33 var ok: i64 = 1
34 while j < nn {
35 let hidx: i64 = i + j
36 let a: i64 = hay[hidx] as i64
37 let b: i64 = nd[j] as i64
38 if a != b { ok = 0; j = nn }
39 if a == b { j = j + 1 }
40 }
41 if ok == 1 { return 1 }
42 i = i + 1
43 }
44 return 0
45}
46
47func main() -> i64 {
48 var pass: i64 = 0
49 let path: *u8 = "/home/elderwesto/nx_stage/nx_coder_model.gguf\x00" as *u8
50 let len_out: *i64 = sys_mmap(8) as *i64
51 len_out[0] = 0
52 let buf: *u8 = sys_read_file(path, len_out)
53 let flen: i64 = len_out[0]
54 cs_puts("CODER-SWAP file bytes=" as *u8)
55 cs_num(flen)
56 cs_puts("\n" as *u8)
57 // T1 parse
58 var t1: i64 = 0
59 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
60 if buf != (0 as *u8) {
61 if flen > 1000000 {
62 let pr: i64 = nx_gguf_parse(buf, flen, hdr)
63 if pr == NX_GGUF_OK { t1 = 1 }
64 }
65 }
66 if t1 == 1 { cs_puts("T1 gguf-parse PASS\n" as *u8) }
67 if t1 == 0 { cs_puts("T1 gguf-parse FAIL\n" as *u8) }
68 pass = pass + t1
69 // T2 named tensor load+dequant (the serve's exact path) on the coder file
70 var t2: i64 = 0
71 if t1 == 1 {
72 let ne: i64 = 896
73 let OUT: i64 = 896
74 let Wq: *i64 = sys_mmap(OUT * ne * 8) as *i64
75 let nm: *u8 = "blk.0.attn_q.weight\x00" as *u8
76 let nl: i64 = cs_slen(nm)
77 let lr: i64 = load_named_q16(buf, hdr, nm, nl, Wq, OUT * ne)
78 cs_puts("T2 load_named rc=" as *u8)
79 cs_num(lr)
80 if lr > 0 {
81 var nz: i64 = 0
82 var k: i64 = 0
83 while k < 1000 {
84 if Wq[k] != 0 { nz = nz + 1 }
85 k = k + 1
86 }
87 cs_puts(" nonzero-of-1000=" as *u8)
88 cs_num(nz)
89 if nz > 100 { t2 = 1 }
90 }
91 if t2 == 1 { cs_puts(" PASS\n" as *u8) }
92 if t2 == 0 { cs_puts(" FAIL\n" as *u8) }
93 }
94 if t1 == 0 { cs_puts("T2 skipped FAIL\n" as *u8) }
95 pass = pass + t2
96 // T3 FIM tokens in the metadata head
97 var t3: i64 = 0
98 var headn: i64 = flen
99 if headn > 5000000 { headn = 5000000 }
100 if buf != (0 as *u8) {
101 let f1: i64 = cs_contains(buf, headn, "<|fim_prefix|>" as *u8)
102 let f2: i64 = cs_contains(buf, headn, "<|fim_middle|>" as *u8)
103 let f3: i64 = cs_contains(buf, headn, "<|fim_suffix|>" as *u8)
104 let fsum: i64 = f1 + f2 + f3
105 cs_puts("T3 fim-tokens found=" as *u8)
106 cs_num(fsum)
107 if fsum == 3 { t3 = 1 }
108 if t3 == 1 { cs_puts(" PASS\n" as *u8) }
109 if t3 == 0 { cs_puts(" FAIL\n" as *u8) }
110 }
111 pass = pass + t3
112 // T4 identity: metadata names coder
113 var t4: i64 = 0
114 if buf != (0 as *u8) {
115 var idn: i64 = flen
116 if idn > 200000 { idn = 200000 }
117 let g1: i64 = cs_contains(buf, idn, "Coder" as *u8)
118 let g2: i64 = cs_contains(buf, idn, "coder" as *u8)
119 let gsum: i64 = g1 + g2
120 cs_puts("T4 coder-identity hits=" as *u8)
121 cs_num(gsum)
122 if gsum >= 1 { t4 = 1 }
123 if t4 == 1 { cs_puts(" PASS\n" as *u8) }
124 if t4 == 0 { cs_puts(" FAIL\n" as *u8) }
125 }
126 pass = pass + t4
127 // T5 NEG: corrupted magic must fail the parser
128 var t5: i64 = 0
129 if buf != (0 as *u8) {
130 if flen > 8192 {
131 let cbuf: *u8 = sys_mmap(8192) as *u8
132 var k: i64 = 0
133 while k < 8192 { cbuf[k] = buf[k]; k = k + 1 }
134 cbuf[0] = 88 as u8
135 let hdr2: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
136 let pr2: i64 = nx_gguf_parse(cbuf, 8192, hdr2)
137 cs_puts("T5 corrupt-magic rc=" as *u8)
138 cs_num(pr2)
139 if pr2 != NX_GGUF_OK { t5 = 1 }
140 if t5 == 1 { cs_puts(" NEGCTL-CAUGHT PASS\n" as *u8) }
141 if t5 == 0 { cs_puts(" NEGCTL-NOT-CAUGHT FAIL\n" as *u8) }
142 }
143 }
144 pass = pass + t5
145 cs_puts("CODER-SWAP-GATE pass=" as *u8)
146 cs_num(pass)
147 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
148 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
149 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
150 let ctr__dry: *i64 = gv_ctr()
151 ctr__dry[0] = pass
152 ctr__dry[1] = 5
153 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)
154 sys_exit(rc__dry)
155 return rc__dry
156}