nx_rank_refresh_integration_gate_v2.nx source
↩ module page · 291 lines · 17696 B
1// Local unbuilt integration harness. Native ranker/scorer, isolated fixture state.
2// argv: runner self existing-parent real-scorer captured-plan captured-matrix timeout-ms capture-bytes rank-budget case-selector
3import "nx_gate_verdict.nx"
4import "nx_tool_run.nx"
5import "nx_build_canon_input_lib.nx"
6import "nx_rank_refresh_lib.nx"
7const RIG_PATH: i64 = 4096
8const RIG_PTR: i64 = 8
9const RIG_ARG_SLOTS: i64 = 5
10const RIG_FILE_MODE: i64 = 384
11const RIG_DIR_MODE: i64 = 448
12const RIG_EINVAL: i64 = 0 - 22
13const RIG_SETUP: i64 = 90
14const RIG_SCORER_FAIL: i64 = 42
15const RIG_OK: i64 = 0
16const RIG_DEST_DIR: i64 = 1
17const RIG_LOCK: i64 = 2
18const RIG_BAD_SCORER: i64 = 3
19const RIG_DISPATCH: i64 = 4
20const RIG_GUARD: *u8 = "NISHI-RANK-REFRESH-FIXTURE\n"
21const RIG_OLD: *u8 = "# retained old rank fixture\n"
22const RIG_PLAN: *u8 = "rung|R1|Fixture open rung|rig_missing|Fixture only|Organ|1|-\nver|0.1|M1\nms|M1|Fixture milestone|1|R1\n"
23const RIG_MATRIX: *u8 = "@cols Reference\nFixture|runtime/rig_missing.nx|_ABSENT_:rig_missing|0|2|Fixture only\n"
24const RIG_ZERO_MATRIX: *u8 = "@cols Reference\nFixture|runtime/rig_missing.nx|rig_missing|0|2|Fixture all-present spelling exercises zero-open branch\n"
25
26func rig_len(p: *u8) -> i64 { var n: i64 = 0; while p[n] != (0 as u8) { n = n + 1 } return n }
27func rig_eq(a: *u8, b: *u8) -> i64 {
28 var i: i64 = 0
29 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
30 if b[i] != (0 as u8) { return 0 }
31 return 1
32}
33func rig_num(p: *u8) -> i64 {
34 let n: i64 = rig_len(p)
35 if n == 0 { return 0 - 1 }
36 var i: i64 = 0; var v: i64 = 0
37 while i < n {
38 let c: i64 = p[i] as i64
39 if c < BCI_ZERO { return 0 - 1 }
40 if c > BCI_NINE { return 0 - 1 }
41 let d: i64 = c - BCI_ZERO
42 if v > (BCI_I64_MAX-d)/BCI_DECIMAL_BASE { return 0 - 1 }
43 v = v*BCI_DECIMAL_BASE+d; i = i + 1
44 }
45 return v
46}
47func rig_join(root: *u8, rel: *u8) -> *u8 {
48 if rig_len(root)+rig_len(rel)+2 > RIG_PATH { return 0 as *u8 }
49 let p: *u8 = sys_mmap(RIG_PATH)
50 var o: i64 = gv_cat(p, 0, root)
51 o = gv_cat(p, o, "/" as *u8); o = gv_cat(p, o, rel); p[o] = 0 as u8
52 return p
53}
54func rig_exists(path: *u8) -> i64 {
55 if (path as i64) == 0 { return 0 }
56 let f: i64 = sys_openat_rd(path)
57 if f < 0 { return 0 }
58 sys_close(f); return 1
59}
60// Reject symlinks in every supplied parent component. No descendant is reused.
61func rig_parent(path: *u8) -> i64 {
62 let n: i64 = rig_len(path)
63 if n <= 1 { return 0 }
64 if n >= RIG_PATH { return 0 }
65 if path[0] != (BCI_SLASH as u8) { return 0 }
66 if bci_relative_path(path, 1, n-1, RIG_PATH-2) != 1 { return 0 }
67 let part: *u8 = sys_mmap(RIG_PATH)
68 let probe: *u8 = sys_mmap(RIG_PATH)
69 var i: i64 = 0
70 while i <= n {
71 var edge: i64 = 0
72 if i == n { edge = 1 } else { if i > 0 { if path[i] == (BCI_SLASH as u8) { edge = 1 } } }
73 if edge == 1 {
74 part[i] = 0 as u8
75 if sys_readlinkat(part, probe, RIG_PATH) != RIG_EINVAL { return 0 }
76 }
77 if i < n { part[i] = path[i] }
78 i = i + 1
79 }
80 return 1
81}
82func rig_write(path: *u8, buf: *u8, n: i64) -> i64 {
83 if (path as i64) == 0 { return 0 }
84 let fd: i64 = sys_openat_wr(path, RIG_FILE_MODE)
85 if fd < 0 { return 0 }
86 var w: i64 = 0
87 while w < n {
88 let got: i64 = sys_write(fd, (buf as i64+w) as *u8, n-w)
89 if got <= 0 { sys_close(fd); return 0 }
90 w = w + got
91 }
92 // Fixture visibility check only; persistence barriers belong to the subject under test.
93 let close: i64 = sys_close(fd)
94 if close != 0 { return 0 }
95 return rrf_file_equal(path, buf, n)
96}
97func rig_file(root: *u8, rel: *u8, val: *u8) -> i64 { return rig_write(rig_join(root,rel),val,rig_len(val)) }
98func rig_dir(root: *u8, rel: *u8) -> i64 {
99 let p: *u8 = rig_join(root, rel)
100 if (p as i64) == 0 { return 0 }
101 if sys_mkdir(p,RIG_DIR_MODE) != 0 { return 0 }
102 return 1
103}
104func rig_link(root: *u8, rel: *u8, target: *u8) -> i64 {
105 let p: *u8 = rig_join(root,rel)
106 if (p as i64) == 0 { return 0 }
107 if sys_symlinkat(target,p) != 0 { return 0 }
108 return 1
109}
110func rig_guard() -> i64 { return rrf_file_equal("fixture-root.guard" as *u8,RIG_GUARD,rig_len(RIG_GUARD)) }
111func rig_witness(argc: i64, argv: *i64) -> i64 {
112 if rig_guard() != 1 { return RIG_SETUP }
113 let invocation: *u8 = argv[0] as *u8
114 if tr_contains(invocation,rig_len(invocation),"nx_store_put.elf" as *u8) == 1 {
115 if argc == 3 { if rig_eq(argv[1] as *u8,"sponsor-" as *u8) == 1 { if rig_eq(argv[2] as *u8,"load" as *u8) == 1 {
116 if rig_file("." as *u8,"store-load.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
117 return 0
118 } } }
119 if rig_file("." as *u8,"plane-put.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
120 gv_puts("RIG fixture plane put witnessed\n" as *u8); return 0
121 }
122 if tr_contains(invocation,rig_len(invocation),"nx_pm_intake.elf" as *u8) == 1 {
123 if rig_file("." as *u8,"pm-ask.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
124 gv_puts("RIG fixture PM ask witnessed\n" as *u8); return 0
125 }
126 if rig_file("." as *u8,"scorer-fail.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
127 gv_puts("{\"order\":[0],\"priorities\":[1]}\n" as *u8)
128 return RIG_SCORER_FAIL
129}
130func rig_setup(root: *u8, self: *u8, scorer: *u8, plan: *u8, pn: i64, matrix: *u8, mn: i64, mode: i64) -> i64 {
131 if sys_mkdir(root,RIG_DIR_MODE) != 0 { return 0 }
132 if rig_dir(root,"buildroot" as *u8) != 1 { return 0 }
133 if rig_dir(root,"buildroot/knowledge" as *u8) != 1 { return 0 }
134 if rig_dir(root,"buildroot/knowledge/compare" as *u8) != 1 { return 0 }
135 if rig_dir(root,"buildroot/runtime" as *u8) != 1 { return 0 }
136 if rig_dir(root,"knowledge" as *u8) != 1 { return 0 }
137 if rig_dir(root,"knowledge/status" as *u8) != 1 { return 0 }
138 if rig_file(root,"fixture-root.guard" as *u8,RIG_GUARD) != 1 { return 0 }
139 // cl_estate_path uses this marker before considering production EP_ROOT.
140 if rig_file(root,"daemons.reg" as *u8,"" as *u8) != 1 { return 0 }
141 if rig_file(root,"tool_allowlist.conf" as *u8,"" as *u8) != 1 { return 0 }
142 if rig_file(root,"cap_consent.log" as *u8,"" as *u8) != 1 { return 0 }
143 if rig_file(root,"knowledge/status/organ_kind.conf" as *u8,"" as *u8) != 1 { return 0 }
144 if rig_file(root,"knowledge/status/actlog.jrnl" as *u8,"" as *u8) != 1 { return 0 }
145 if rig_file(root,"knowledge/status/importers.tsv" as *u8,"" as *u8) != 1 { return 0 }
146 if rig_file(root,"knowledge/status/gateadjudicate.rows" as *u8,"" as *u8) != 1 { return 0 }
147 if rig_file(root,"knowledge/status/gateadjudicate.log" as *u8,"" as *u8) != 1 { return 0 }
148 if rig_file(root,"knowledge/status/execsurface.tsv" as *u8,"" as *u8) != 1 { return 0 }
149 if rig_file(root,"knowledge/status/selfsuff.ledger" as *u8,"" as *u8) != 1 { return 0 }
150 if rig_write(rig_join(root,"buildroot/knowledge/compare/deploy.plan" as *u8),plan,pn) != 1 { return 0 }
151 if rig_write(rig_join(root,"buildroot/knowledge/compare/deploy.matrix" as *u8),matrix,mn) != 1 { return 0 }
152 if rig_link(root,"nx_store_put.elf" as *u8,self) != 1 { return 0 }
153 if rig_link(root,"nx_pm_intake.elf" as *u8,self) != 1 { return 0 }
154 var sc: *u8 = scorer
155 if mode == RIG_BAD_SCORER { sc = self }
156 if rig_link(root,"nx_dr_ocm_cli.elf" as *u8,sc) != 1 { return 0 }
157 if mode == RIG_DEST_DIR { if rig_dir(root,"buildroot/knowledge/compare/deploy.rank" as *u8) != 1 { return 0 } }
158 else { if rig_file(root,"buildroot/knowledge/compare/deploy.rank" as *u8,RIG_OLD) != 1 { return 0 } }
159 return 1
160}
161func rig_case(runroot: *u8, name: *u8, runner: *u8, self: *u8, scorer: *u8, plan: *u8, pn: i64, matrix: *u8, mn: i64, mode: i64, expected: i64, timeout: i64, cap: i64, budget: *u8, ctr: *i64) -> i64 {
162 gv_puts("CASE " as *u8); gv_puts(name); gv_puts("\n" as *u8)
163 let root: *u8 = rig_join(runroot,name)
164 let case_start: i64 = sys_now_ms()
165 let setup: i64 = rig_setup(root,self,scorer,plan,pn,matrix,mn,mode)
166 gv_check_eq("setup" as *u8,setup,1,ctr)
167 if setup != 1 { return 0 }
168 var lockfd: i64 = 0 - 1
169 if mode == RIG_LOCK {
170 lockfd = sys_openat_rdwr(rig_join(root,"buildroot/knowledge/compare/deploy.rank.lock" as *u8),RIG_FILE_MODE)
171 if lockfd < 0 { gv_check_eq("parent lock open" as *u8,0,1,ctr); return 0 }
172 if sys_flock(lockfd,SYS_LOCK_EX | SYS_LOCK_NB) != 0 { sys_close(lockfd); gv_check_eq("parent lock held" as *u8,0,1,ctr); return 0 }
173 }
174 let av: *i64 = sys_mmap(RIG_ARG_SLOTS*RIG_PTR) as *i64
175 av[0] = runner as i64; av[1] = "deploy" as *u8 as i64; av[2] = budget as i64
176 av[3] = "--artifact-only" as *u8 as i64; av[4] = 0
177 if mode == RIG_DISPATCH { av[3] = 0 }
178 let out: *u8 = sys_mmap(cap)
179 let ln: *i64 = sys_mmap(RIG_PTR) as *i64
180 let child_start: i64 = sys_now_ms()
181 let rc: i64 = tr_run_capture_cwd(runner,av,out,cap,ln,timeout,root)
182 let child_end: i64 = sys_now_ms()
183 let timing: *u8 = sys_mmap(RIG_PATH)
184 var to: i64 = gv_cat(timing,0,"case=" as *u8); to = gv_cat(timing,to,name)
185 to = gv_cat(timing,to," setup_ms=" as *u8); to = gv_catn(timing,to,child_start-case_start)
186 to = gv_cat(timing,to," child_ms=" as *u8); to = gv_catn(timing,to,child_end-child_start)
187 to = gv_cat(timing,to," observed_through_child_ms=" as *u8); to = gv_catn(timing,to,child_end-case_start)
188 to = gv_cat(timing,to,"\n" as *u8)
189 gv_puts(timing)
190 gv_check_eq("case timing persisted" as *u8,rig_write(rig_join(root,"timing.txt" as *u8),timing,to),1,ctr)
191 if lockfd >= 0 { sys_close(lockfd) }
192 gv_check_eq("ranker exit" as *u8,rc,expected,ctr)
193 var zero: i64 = 0
194 if (matrix as i64) == (RIG_ZERO_MATRIX as i64) { zero = 1 }
195 gv_check_eq("zero-open branch selection" as *u8,tr_contains(out,ln[0],"RANK: nothing open --" as *u8),zero,ctr)
196 gv_check("capture complete" as *u8,(ln[0]<cap) as i64,ctr)
197 gv_check_eq("capture persisted" as *u8,rig_write(rig_join(root,"ranker.out" as *u8),out,ln[0]),1,ctr)
198 gv_check_eq("sponsor load witnessed" as *u8,rig_exists(rig_join(root,"store-load.witness" as *u8)),1,ctr)
199 var dispatch: i64 = 0
200 if mode == RIG_DISPATCH { dispatch = 1 }
201 gv_check_eq("PM ask witness" as *u8,rig_exists(rig_join(root,"pm-ask.witness" as *u8)),dispatch,ctr)
202 gv_check_eq("plane put witness" as *u8,rig_exists(rig_join(root,"plane-put.witness" as *u8)),dispatch,ctr)
203 let rankpath: *u8 = rig_join(root,"buildroot/knowledge/compare/deploy.rank" as *u8)
204 if expected == 0 {
205 gv_check_eq("successful write diagnostic" as *u8,tr_contains(out,ln[0],"RANK artefact wrote=" as *u8),1,ctr)
206 let rn: *i64 = sys_mmap(RIG_PTR) as *i64
207 let rb: *u8 = sys_read_file(rankpath,rn)
208 gv_check("rank file readable" as *u8,((rb as i64)!=0) as i64,ctr)
209 if (rb as i64) != 0 {
210 let ph: *u8 = sys_mmap(RRF_HEX_BYTES+1); let mh: *u8 = sys_mmap(RRF_HEX_BYTES+1)
211 rrf_hash(plan,pn,ph); rrf_hash(matrix,mn,mh)
212 let metadata: *u8 = sys_mmap(RIG_PATH)
213 var o: i64 = gv_cat(metadata,0,"# inputs_v=1 plan_sha256=" as *u8); o = gv_cat(metadata,o,ph)
214 o = gv_cat(metadata,o," plan_bytes=" as *u8); o = gv_catn(metadata,o,pn)
215 o = gv_cat(metadata,o," matrix_sha256=" as *u8); o = gv_cat(metadata,o,mh)
216 o = gv_cat(metadata,o," matrix_bytes=" as *u8); o = gv_catn(metadata,o,mn)
217 o = gv_cat(metadata,o,"\n" as *u8)
218 gv_check_eq("exact input metadata" as *u8,tr_contains(rb,rn[0],metadata),1,ctr)
219 gv_check_eq("stamp domain" as *u8,tr_contains(rb,rn[0]," domain=deploy " as *u8),1,ctr)
220 gv_check_eq("open rank row emitted" as *u8,tr_contains(rb,rn[0],"\nrank|" as *u8),1-zero,ctr)
221 }
222 } else {
223 gv_check_eq("no successful write diagnostic" as *u8,tr_contains(out,ln[0],"RANK artefact wrote=" as *u8),0,ctr)
224 if mode != RIG_DEST_DIR { gv_check_eq("old artifact preserved" as *u8,rrf_file_equal(rankpath,RIG_OLD,rig_len(RIG_OLD)),1,ctr) }
225 }
226 if mode == RIG_DEST_DIR { gv_check_eq("actual rename failure reached" as *u8,tr_contains(out,ln[0],"RANK ARTEFACT WRITE-FAILED: rename" as *u8),1,ctr) }
227 if mode == RIG_LOCK { gv_check_eq("actual contention refusal" as *u8,tr_contains(out,ln[0],"writer lock unavailable" as *u8),1,ctr) }
228 if mode == RIG_BAD_SCORER { gv_check_eq("failed scorer executed" as *u8,rig_exists(rig_join(root,"scorer-fail.witness" as *u8)),1,ctr) }
229 return 1
230}
231func rig_selected(selector: *u8, name: *u8) -> i64 {
232 if rig_eq(selector,"all" as *u8) == 1 { return 1 }
233 return rig_eq(selector,name)
234}
235func rig_selector_valid(selector: *u8) -> i64 {
236 if rig_eq(selector,"all" as *u8) == 1 { return 1 }
237 if rig_eq(selector,"real-success" as *u8) == 1 { return 1 }
238 if rig_eq(selector,"real-write-failure" as *u8) == 1 { return 1 }
239 if rig_eq(selector,"zero-open-success" as *u8) == 1 { return 1 }
240 if rig_eq(selector,"zero-open-write-failure" as *u8) == 1 { return 1 }
241 if rig_eq(selector,"scorer-failure" as *u8) == 1 { return 1 }
242 if rig_eq(selector,"lock-contention" as *u8) == 1 { return 1 }
243 if rig_eq(selector,"dispatch-positive-control" as *u8) == 1 { return 1 }
244 return 0
245}
246func main(argc: i64, argv: *i64) -> i64 {
247 let inv: *u8 = argv[0] as *u8
248 var witness: i64 = tr_contains(inv,rig_len(inv),"nx_store_put.elf" as *u8)
249 witness = witness + tr_contains(inv,rig_len(inv),"nx_pm_intake.elf" as *u8)
250 witness = witness + tr_contains(inv,rig_len(inv),"nx_dr_ocm_cli.elf" as *u8)
251 if witness > 0 { let rc: i64 = rig_witness(argc,argv); sys_exit(rc); return rc }
252 if argc != 11 { gv_puts("usage: rank-refresh-gate runner self existing-parent real-scorer captured-plan captured-matrix timeout-ms capture-bytes rank-budget case-selector\n" as *u8); sys_exit(RIG_SETUP); return RIG_SETUP }
253 let selector: *u8 = argv[10] as *u8
254 if rig_selector_valid(selector) != 1 { gv_puts("REFUSED unknown case selector; use all or one named case\n" as *u8); sys_exit(RIG_SETUP); return RIG_SETUP }
255 let runner: *u8 = argv[1] as *u8; let self: *u8 = argv[2] as *u8; let parent: *u8 = argv[3] as *u8
256 let scorer: *u8 = argv[4] as *u8; let planpath: *u8 = argv[5] as *u8; let matrixpath: *u8 = argv[6] as *u8
257 let timeout: i64 = rig_num(argv[7] as *u8); let cap: i64 = rig_num(argv[8] as *u8); let budget: *u8 = argv[9] as *u8
258 if timeout <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
259 if cap <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
260 if rig_num(budget) <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
261 if rig_parent(parent) != 1 { sys_exit(RIG_SETUP); return RIG_SETUP }
262 var ai: i64 = 1
263 while ai <= 6 {
264 if ai != 3 { let arg: *u8 = argv[ai] as *u8; if arg[0] != (BCI_SLASH as u8) { sys_exit(RIG_SETUP); return RIG_SETUP } if rig_exists(arg) != 1 { sys_exit(RIG_SETUP); return RIG_SETUP } }
265 ai = ai + 1
266 }
267 let pn: *i64 = sys_mmap(RIG_PTR) as *i64; let mn: *i64 = sys_mmap(RIG_PTR) as *i64
268 let plan: *u8 = sys_read_file(planpath,pn); let matrix: *u8 = sys_read_file(matrixpath,mn)
269 if (plan as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
270 if (matrix as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
271 if pn[0] <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
272 if mn[0] <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
273 let tag: *u8 = sys_mmap(RIG_PATH)
274 var o: i64 = gv_cat(tag,0,"rank-refresh-v2-" as *u8); o = gv_catn(tag,o,sys_now_ms())
275 let root: *u8 = rig_join(parent,tag)
276 if (root as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
277 if sys_mkdir(root,RIG_DIR_MODE) != 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
278 let ctr: *i64 = gv_ctr()
279 gv_head("RANK REFRESH ACTUAL PROCESS INTEGRATION V2" as *u8)
280 gv_puts("selected_case=" as *u8); gv_puts(selector); gv_puts("\n" as *u8)
281 gv_puts("fixture_root=" as *u8); gv_puts(root); gv_puts("\n" as *u8)
282 if rig_selected(selector,"real-success" as *u8) == 1 { rig_case(root,"real-success" as *u8,runner,self,scorer,plan,pn[0],matrix,mn[0],RIG_OK,0,timeout,cap,budget,ctr) }
283 if rig_selected(selector,"real-write-failure" as *u8) == 1 { rig_case(root,"real-write-failure" as *u8,runner,self,scorer,plan,pn[0],matrix,mn[0],RIG_DEST_DIR,7,timeout,cap,budget,ctr) }
284 if rig_selected(selector,"zero-open-success" as *u8) == 1 { rig_case(root,"zero-open-success" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_ZERO_MATRIX,rig_len(RIG_ZERO_MATRIX),RIG_OK,0,timeout,cap,budget,ctr) }
285 if rig_selected(selector,"zero-open-write-failure" as *u8) == 1 { rig_case(root,"zero-open-write-failure" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_ZERO_MATRIX,rig_len(RIG_ZERO_MATRIX),RIG_DEST_DIR,7,timeout,cap,budget,ctr) }
286 if rig_selected(selector,"scorer-failure" as *u8) == 1 { rig_case(root,"scorer-failure" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_BAD_SCORER,4,timeout,cap,budget,ctr) }
287 if rig_selected(selector,"lock-contention" as *u8) == 1 { rig_case(root,"lock-contention" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_LOCK,7,timeout,cap,budget,ctr) }
288 if rig_selected(selector,"dispatch-positive-control" as *u8) == 1 { rig_case(root,"dispatch-positive-control" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_DISPATCH,0,timeout,cap,budget,ctr) }
289 let rc: i64 = gv_verdict("RANK-REFRESH-INTEGRATION",ctr,"actual candidate + real scorer; captured deploy input; isolated PM/plane witnesses; no promotion" as *u8)
290 sys_exit(rc); return rc
291}