nx_rank_refresh_integration_gate_v3.nx source
↩ module page · 431 lines · 26966 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_PM_FAILED: i64 = 5
21const RIG_PM_EMPTY: i64 = 6
22const RIG_PM_FULL: i64 = 7
23const RIG_PLANE_FAILED: i64 = 8
24const RIG_PLANE_EMPTY: i64 = 9
25const RIG_PLANE_FULL: i64 = 10
26const RIG_SOURCE_CHANGE: i64 = 11
27// Exact structural receipt boundary in pinned rank candidate: RANK_FORK_CAP=4096, capture=cap-1.
28const RIG_SUBJECT_RECEIPT_CAP: i64 = 4096
29const RIG_SUBJECT_RECEIPT_FULL: i64 = RIG_SUBJECT_RECEIPT_CAP - 1
30const RIG_RECEIPT_FAILED: i64 = 1
31const RIG_RECEIPT_EMPTY: i64 = 2
32const RIG_RECEIPT_FULL: i64 = 3
33const RIG_SOURCE_APPEND: *u8 = "# changed by native scorer fixture before return\n"
34const RIG_GUARD: *u8 = "NISHI-RANK-REFRESH-FIXTURE\n"
35const RIG_OLD: *u8 = "# retained old rank fixture\n"
36const 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"
37const RIG_MATRIX: *u8 = "@cols Reference\nFixture|runtime/rig_missing.nx|_ABSENT_:rig_missing|0|2|Fixture only\n"
38const RIG_ZERO_MATRIX: *u8 = "@cols Reference\nFixture|runtime/rig_missing.nx|rig_missing|0|2|Fixture all-present spelling exercises zero-open branch\n"
39
40func rig_len(p: *u8) -> i64 { var n: i64 = 0; while p[n] != (0 as u8) { n = n + 1 } return n }
41func rig_eq(a: *u8, b: *u8) -> i64 {
42 var i: i64 = 0
43 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
44 if b[i] != (0 as u8) { return 0 }
45 return 1
46}
47func rig_num(p: *u8) -> i64 {
48 let n: i64 = rig_len(p)
49 if n == 0 { return 0 - 1 }
50 var i: i64 = 0; var v: i64 = 0
51 while i < n {
52 let c: i64 = p[i] as i64
53 if c < BCI_ZERO { return 0 - 1 }
54 if c > BCI_NINE { return 0 - 1 }
55 let d: i64 = c - BCI_ZERO
56 if v > (BCI_I64_MAX-d)/BCI_DECIMAL_BASE { return 0 - 1 }
57 v = v*BCI_DECIMAL_BASE+d; i = i + 1
58 }
59 return v
60}
61func rig_join(root: *u8, rel: *u8) -> *u8 {
62 if rig_len(root)+rig_len(rel)+2 > RIG_PATH { return 0 as *u8 }
63 let p: *u8 = sys_mmap(RIG_PATH)
64 var o: i64 = gv_cat(p, 0, root)
65 o = gv_cat(p, o, "/" as *u8); o = gv_cat(p, o, rel); p[o] = 0 as u8
66 return p
67}
68func rig_exists(path: *u8) -> i64 {
69 if (path as i64) == 0 { return 0 }
70 let f: i64 = sys_openat_rd(path)
71 if f < 0 { return 0 }
72 sys_close(f); return 1
73}
74// Reject symlinks in every supplied parent component. No descendant is reused.
75func rig_parent(path: *u8) -> i64 {
76 let n: i64 = rig_len(path)
77 if n <= 1 { return 0 }
78 if n >= RIG_PATH { return 0 }
79 if path[0] != (BCI_SLASH as u8) { return 0 }
80 if bci_relative_path(path, 1, n-1, RIG_PATH-2) != 1 { return 0 }
81 let part: *u8 = sys_mmap(RIG_PATH)
82 let probe: *u8 = sys_mmap(RIG_PATH)
83 var i: i64 = 0
84 while i <= n {
85 var edge: i64 = 0
86 if i == n { edge = 1 } else { if i > 0 { if path[i] == (BCI_SLASH as u8) { edge = 1 } } }
87 if edge == 1 {
88 part[i] = 0 as u8
89 if sys_readlinkat(part, probe, RIG_PATH) != RIG_EINVAL { return 0 }
90 }
91 if i < n { part[i] = path[i] }
92 i = i + 1
93 }
94 return 1
95}
96func rig_write(path: *u8, buf: *u8, n: i64) -> i64 {
97 if (path as i64) == 0 { return 0 }
98 let fd: i64 = sys_openat_wr(path, RIG_FILE_MODE)
99 if fd < 0 { return 0 }
100 var w: i64 = 0
101 while w < n {
102 let got: i64 = sys_write(fd, (buf as i64+w) as *u8, n-w)
103 if got <= 0 { sys_close(fd); return 0 }
104 w = w + got
105 }
106 // Fixture visibility check only; persistence barriers belong to the subject under test.
107 let close: i64 = sys_close(fd)
108 if close != 0 { return 0 }
109 return rrf_file_equal(path, buf, n)
110}
111func rig_file(root: *u8, rel: *u8, val: *u8) -> i64 { return rig_write(rig_join(root,rel),val,rig_len(val)) }
112func rig_dir(root: *u8, rel: *u8) -> i64 {
113 let p: *u8 = rig_join(root, rel)
114 if (p as i64) == 0 { return 0 }
115 if sys_mkdir(p,RIG_DIR_MODE) != 0 { return 0 }
116 return 1
117}
118func rig_link(root: *u8, rel: *u8, target: *u8) -> i64 {
119 let p: *u8 = rig_join(root,rel)
120 if (p as i64) == 0 { return 0 }
121 if sys_symlinkat(target,p) != 0 { return 0 }
122 return 1
123}
124func rig_guard() -> i64 { return rrf_file_equal("fixture-root.guard" as *u8,RIG_GUARD,rig_len(RIG_GUARD)) }
125func rig_read_num(path: *u8) -> i64 {
126 let ln: *i64 = sys_mmap(RIG_PTR) as *i64
127 let b: *u8 = sys_read_file(path,ln)
128 if (b as i64) == 0 { return 0 - 1 }
129 if ln[0] <= 0 { return 0 - 1 }
130 b[ln[0]] = 0 as u8
131 return rig_num(b)
132}
133func rig_write_stdout(buf: *u8, n: i64) -> i64 {
134 var off: i64 = 0
135 while off < n {
136 let w: i64 = sys_write(1,(buf as i64+off) as *u8,n-off)
137 if w <= 0 { return RIG_SETUP }
138 off = off + w
139 }
140 return 0
141}
142func rig_bad_receipt(role: *u8, kind: i64) -> i64 {
143 let marker: *u8 = sys_mmap(RIG_PATH)
144 var o: i64 = gv_cat(marker,0,role); o = gv_cat(marker,o,"-receipt.witness" as *u8)
145 var value: *u8 = "failed exit=42 nonempty-output\n" as *u8
146 if kind == RIG_RECEIPT_EMPTY { value = "empty exit=0\n" as *u8 }
147 if kind == RIG_RECEIPT_FULL { value = "full exit=0 bytes=4095\n" as *u8 }
148 if rig_file("." as *u8,marker,value) != 1 { return RIG_SETUP }
149 if kind == RIG_RECEIPT_FAILED { gv_puts("fixture apparent success receipt with failing exit\n" as *u8); return RIG_SCORER_FAIL }
150 if kind == RIG_RECEIPT_EMPTY { return 0 }
151 let bytes: *u8 = sys_mmap(RIG_SUBJECT_RECEIPT_FULL)
152 var i: i64 = 0
153 while i < RIG_SUBJECT_RECEIPT_FULL { bytes[i] = 120 as u8; i = i + 1 }
154 return rig_write_stdout(bytes,RIG_SUBJECT_RECEIPT_FULL)
155}
156func rig_mutating_scorer(argv: *i64) -> i64 {
157 let cap: i64 = rig_read_num("fixture-capture-bytes" as *u8)
158 let timeout: i64 = rig_read_num("fixture-timeout-ms" as *u8)
159 if cap <= 0 { return RIG_SETUP }
160 if timeout <= 0 { return RIG_SETUP }
161 let out: *u8 = sys_mmap(cap)
162 let ln: *i64 = sys_mmap(RIG_PTR) as *i64
163 argv[0] = "./real-scorer.elf" as *u8 as i64
164 let rc: i64 = tr_run_capture_to("./real-scorer.elf" as *u8,argv,out,cap,ln,timeout)
165 if rig_write("scorer.out" as *u8,out,ln[0]) != 1 { return RIG_SETUP }
166 if rc != 0 { return RIG_SETUP }
167 if ln[0] <= 0 { return RIG_SETUP }
168 if ln[0] >= cap { return RIG_SETUP }
169 let pn: *i64 = sys_mmap(RIG_PTR) as *i64
170 let path: *u8 = "buildroot/knowledge/compare/deploy.plan" as *u8
171 let plan: *u8 = sys_read_file(path,pn)
172 if (plan as i64) == 0 { return RIG_SETUP }
173 if pn[0] <= 0 { return RIG_SETUP }
174 let sn: i64 = rig_len(RIG_SOURCE_APPEND)
175 let changed: *u8 = sys_mmap(pn[0]+sn+1)
176 var i: i64 = 0
177 while i < pn[0] { changed[i] = plan[i]; i = i + 1 }
178 var j: i64 = 0
179 while j < sn { changed[i+j] = RIG_SOURCE_APPEND[j]; j = j + 1 }
180 if rig_write(path,changed,pn[0]+sn) != 1 { return RIG_SETUP }
181 if rig_file("." as *u8,"source-change.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
182 return rig_write_stdout(out,ln[0])
183}
184func rig_witness(argc: i64, argv: *i64) -> i64 {
185 if rig_guard() != 1 { return RIG_SETUP }
186 let mode: i64 = rig_read_num("fixture-mode" as *u8)
187 if mode < RIG_OK { return RIG_SETUP }
188 if mode > RIG_SOURCE_CHANGE { return RIG_SETUP }
189 let invocation: *u8 = argv[0] as *u8
190 if tr_contains(invocation,rig_len(invocation),"nx_store_put.elf" as *u8) == 1 {
191 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 {
192 if rig_file("." as *u8,"store-load.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
193 return 0
194 } } }
195 if rig_file("." as *u8,"plane-put.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
196 if mode == RIG_PLANE_FAILED { return rig_bad_receipt("plane" as *u8,RIG_RECEIPT_FAILED) }
197 if mode == RIG_PLANE_EMPTY { return rig_bad_receipt("plane" as *u8,RIG_RECEIPT_EMPTY) }
198 if mode == RIG_PLANE_FULL { return rig_bad_receipt("plane" as *u8,RIG_RECEIPT_FULL) }
199 gv_puts("RIG fixture plane put witnessed\n" as *u8); return 0
200 }
201 if tr_contains(invocation,rig_len(invocation),"nx_pm_intake.elf" as *u8) == 1 {
202 if rig_file("." as *u8,"pm-ask.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
203 if mode == RIG_PM_FAILED { return rig_bad_receipt("pm" as *u8,RIG_RECEIPT_FAILED) }
204 if mode == RIG_PM_EMPTY { return rig_bad_receipt("pm" as *u8,RIG_RECEIPT_EMPTY) }
205 if mode == RIG_PM_FULL { return rig_bad_receipt("pm" as *u8,RIG_RECEIPT_FULL) }
206 gv_puts("RIG fixture PM ask witnessed\n" as *u8); return 0
207 }
208 if mode == RIG_SOURCE_CHANGE { return rig_mutating_scorer(argv) }
209 if rig_file("." as *u8,"scorer-fail.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
210 gv_puts("{\"order\":[0],\"priorities\":[1]}\n" as *u8)
211 return RIG_SCORER_FAIL
212}
213func rig_dispatch_mode(mode: i64) -> i64 {
214 if mode == RIG_DISPATCH { return 1 }
215 if mode >= RIG_PM_FAILED { if mode <= RIG_PLANE_FULL { return 1 } }
216 return 0
217}
218func rig_setup(root: *u8, self: *u8, scorer: *u8, plan: *u8, pn: i64, matrix: *u8, mn: i64, mode: i64) -> i64 {
219 if sys_mkdir(root,RIG_DIR_MODE) != 0 { return 0 }
220 if rig_dir(root,"buildroot" as *u8) != 1 { return 0 }
221 if rig_dir(root,"buildroot/knowledge" as *u8) != 1 { return 0 }
222 if rig_dir(root,"buildroot/knowledge/compare" as *u8) != 1 { return 0 }
223 if rig_dir(root,"buildroot/runtime" as *u8) != 1 { return 0 }
224 if rig_dir(root,"knowledge" as *u8) != 1 { return 0 }
225 if rig_dir(root,"knowledge/status" as *u8) != 1 { return 0 }
226 if rig_file(root,"fixture-root.guard" as *u8,RIG_GUARD) != 1 { return 0 }
227 let modebuf: *u8 = sys_mmap(RIG_PATH)
228 gv_catn(modebuf,0,mode)
229 if rig_file(root,"fixture-mode" as *u8,modebuf) != 1 { return 0 }
230 // cl_estate_path uses this marker before considering production EP_ROOT.
231 if rig_file(root,"daemons.reg" as *u8,"" as *u8) != 1 { return 0 }
232 if rig_file(root,"tool_allowlist.conf" as *u8,"" as *u8) != 1 { return 0 }
233 if rig_file(root,"cap_consent.log" as *u8,"" as *u8) != 1 { return 0 }
234 if rig_file(root,"knowledge/status/organ_kind.conf" as *u8,"" as *u8) != 1 { return 0 }
235 if rig_file(root,"knowledge/status/actlog.jrnl" as *u8,"" as *u8) != 1 { return 0 }
236 if rig_file(root,"knowledge/status/importers.tsv" as *u8,"" as *u8) != 1 { return 0 }
237 if rig_file(root,"knowledge/status/gateadjudicate.rows" as *u8,"" as *u8) != 1 { return 0 }
238 if rig_file(root,"knowledge/status/gateadjudicate.log" as *u8,"" as *u8) != 1 { return 0 }
239 if rig_file(root,"knowledge/status/execsurface.tsv" as *u8,"" as *u8) != 1 { return 0 }
240 if rig_file(root,"knowledge/status/selfsuff.ledger" as *u8,"" as *u8) != 1 { return 0 }
241 if rig_write(rig_join(root,"buildroot/knowledge/compare/deploy.plan" as *u8),plan,pn) != 1 { return 0 }
242 if rig_write(rig_join(root,"buildroot/knowledge/compare/deploy.matrix" as *u8),matrix,mn) != 1 { return 0 }
243 if rig_link(root,"nx_store_put.elf" as *u8,self) != 1 { return 0 }
244 if rig_link(root,"nx_pm_intake.elf" as *u8,self) != 1 { return 0 }
245 var sc: *u8 = scorer
246 if mode == RIG_BAD_SCORER { sc = self }
247 if mode == RIG_SOURCE_CHANGE { sc = self; if rig_link(root,"real-scorer.elf" as *u8,scorer) != 1 { return 0 } }
248 if rig_link(root,"nx_dr_ocm_cli.elf" as *u8,sc) != 1 { return 0 }
249 if mode == RIG_DEST_DIR { if rig_dir(root,"buildroot/knowledge/compare/deploy.rank" as *u8) != 1 { return 0 } }
250 else { if rig_file(root,"buildroot/knowledge/compare/deploy.rank" as *u8,RIG_OLD) != 1 { return 0 } }
251 return 1
252}
253func 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 {
254 gv_puts("CASE " as *u8); gv_puts(name); gv_puts("\n" as *u8)
255 let root: *u8 = rig_join(runroot,name)
256 let case_start: i64 = sys_now_ms()
257 let setup: i64 = rig_setup(root,self,scorer,plan,pn,matrix,mn,mode)
258 gv_check_eq("setup" as *u8,setup,1,ctr)
259 if setup != 1 { return 0 }
260 let config: *u8 = sys_mmap(RIG_PATH)
261 gv_catn(config,0,cap)
262 let cap_ok: i64 = rig_file(root,"fixture-capture-bytes" as *u8,config)
263 gv_catn(config,0,timeout)
264 let time_ok: i64 = rig_file(root,"fixture-timeout-ms" as *u8,config)
265 gv_check_eq("witness config persisted" as *u8,cap_ok*time_ok,1,ctr)
266 if cap_ok*time_ok != 1 { return 0 }
267 var lockfd: i64 = 0 - 1
268 if mode == RIG_LOCK {
269 lockfd = sys_openat_rdwr(rig_join(root,"buildroot/knowledge/compare/deploy.rank.lock" as *u8),RIG_FILE_MODE)
270 if lockfd < 0 { gv_check_eq("parent lock open" as *u8,0,1,ctr); return 0 }
271 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 }
272 }
273 let av: *i64 = sys_mmap(RIG_ARG_SLOTS*RIG_PTR) as *i64
274 av[0] = runner as i64; av[1] = "deploy" as *u8 as i64; av[2] = budget as i64
275 av[3] = "--artifact-only" as *u8 as i64; av[4] = 0
276 if rig_dispatch_mode(mode) == 1 { av[3] = 0 }
277 let out: *u8 = sys_mmap(cap)
278 let ln: *i64 = sys_mmap(RIG_PTR) as *i64
279 let child_start: i64 = sys_now_ms()
280 let rc: i64 = tr_run_capture_cwd(runner,av,out,cap,ln,timeout,root)
281 let child_end: i64 = sys_now_ms()
282 let timing: *u8 = sys_mmap(RIG_PATH)
283 var to: i64 = gv_cat(timing,0,"case=" as *u8); to = gv_cat(timing,to,name)
284 to = gv_cat(timing,to," setup_ms=" as *u8); to = gv_catn(timing,to,child_start-case_start)
285 to = gv_cat(timing,to," child_ms=" as *u8); to = gv_catn(timing,to,child_end-child_start)
286 to = gv_cat(timing,to," observed_through_child_ms=" as *u8); to = gv_catn(timing,to,child_end-case_start)
287 to = gv_cat(timing,to,"\n" as *u8)
288 gv_puts(timing)
289 gv_check_eq("case timing persisted" as *u8,rig_write(rig_join(root,"timing.txt" as *u8),timing,to),1,ctr)
290 if lockfd >= 0 { sys_close(lockfd) }
291 gv_check_eq("ranker exit" as *u8,rc,expected,ctr)
292 var zero: i64 = 0
293 if (matrix as i64) == (RIG_ZERO_MATRIX as i64) { zero = 1 }
294 gv_check_eq("zero-open branch selection" as *u8,tr_contains(out,ln[0],"RANK: nothing open --" as *u8),zero,ctr)
295 gv_check("capture complete" as *u8,(ln[0]<cap) as i64,ctr)
296 gv_check_eq("capture persisted" as *u8,rig_write(rig_join(root,"ranker.out" as *u8),out,ln[0]),1,ctr)
297 gv_check_eq("sponsor load witnessed" as *u8,rig_exists(rig_join(root,"store-load.witness" as *u8)),1,ctr)
298 let pm_expected: i64 = rig_dispatch_mode(mode)
299 var plane_expected: i64 = pm_expected
300 if mode >= RIG_PM_FAILED { if mode <= RIG_PM_FULL { plane_expected = 0 } }
301 gv_check_eq("PM ask witness" as *u8,rig_exists(rig_join(root,"pm-ask.witness" as *u8)),pm_expected,ctr)
302 gv_check_eq("plane put witness" as *u8,rig_exists(rig_join(root,"plane-put.witness" as *u8)),plane_expected,ctr)
303 let rankpath: *u8 = rig_join(root,"buildroot/knowledge/compare/deploy.rank" as *u8)
304 if expected == 0 {
305 gv_check_eq("successful write diagnostic" as *u8,tr_contains(out,ln[0],"RANK artefact wrote=" as *u8),1,ctr)
306 let rn: *i64 = sys_mmap(RIG_PTR) as *i64
307 let rb: *u8 = sys_read_file(rankpath,rn)
308 gv_check("rank file readable" as *u8,((rb as i64)!=0) as i64,ctr)
309 if (rb as i64) != 0 {
310 let ph: *u8 = sys_mmap(RRF_HEX_BYTES+1); let mh: *u8 = sys_mmap(RRF_HEX_BYTES+1)
311 rrf_hash(plan,pn,ph); rrf_hash(matrix,mn,mh)
312 let metadata: *u8 = sys_mmap(RIG_PATH)
313 var o: i64 = gv_cat(metadata,0,"# inputs_v=1 plan_sha256=" as *u8); o = gv_cat(metadata,o,ph)
314 o = gv_cat(metadata,o," plan_bytes=" as *u8); o = gv_catn(metadata,o,pn)
315 o = gv_cat(metadata,o," matrix_sha256=" as *u8); o = gv_cat(metadata,o,mh)
316 o = gv_cat(metadata,o," matrix_bytes=" as *u8); o = gv_catn(metadata,o,mn)
317 o = gv_cat(metadata,o,"\n" as *u8)
318 gv_check_eq("exact input metadata" as *u8,tr_contains(rb,rn[0],metadata),1,ctr)
319 gv_check_eq("stamp domain" as *u8,tr_contains(rb,rn[0]," domain=deploy " as *u8),1,ctr)
320 gv_check_eq("open rank row emitted" as *u8,tr_contains(rb,rn[0],"\nrank|" as *u8),1-zero,ctr)
321 }
322 } else {
323 gv_check_eq("no successful write diagnostic" as *u8,tr_contains(out,ln[0],"RANK artefact wrote=" as *u8),0,ctr)
324 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) }
325 }
326 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) }
327 if mode == RIG_LOCK { gv_check_eq("actual contention refusal" as *u8,tr_contains(out,ln[0],"writer lock unavailable" as *u8),1,ctr) }
328 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) }
329 var reason: *u8 = "" as *u8
330 var role: *u8 = "" as *u8
331 var receipt: *u8 = "" as *u8
332 if mode == RIG_PM_FAILED { reason = "RANK DISPATCH-UNCERTAIN: PM child failed;" as *u8; role = "pm" as *u8; receipt = "failed exit=42 nonempty-output\n" as *u8 }
333 if mode == RIG_PM_EMPTY { reason = "RANK DISPATCH-UNCERTAIN: PM receipt empty" as *u8; role = "pm" as *u8; receipt = "empty exit=0\n" as *u8 }
334 if mode == RIG_PM_FULL { reason = "RANK DISPATCH-UNCERTAIN: PM receipt truncated" as *u8; role = "pm" as *u8; receipt = "full exit=0 bytes=4095\n" as *u8 }
335 if mode == RIG_PLANE_FAILED { reason = "RANK DISPATCH-UNCERTAIN: plane child failed;" as *u8; role = "plane" as *u8; receipt = "failed exit=42 nonempty-output\n" as *u8 }
336 if mode == RIG_PLANE_EMPTY { reason = "RANK DISPATCH-UNCERTAIN: plane receipt empty" as *u8; role = "plane" as *u8; receipt = "empty exit=0\n" as *u8 }
337 if mode == RIG_PLANE_FULL { reason = "RANK DISPATCH-UNCERTAIN: plane receipt truncated" as *u8; role = "plane" as *u8; receipt = "full exit=0 bytes=4095\n" as *u8 }
338 if rig_len(reason) > 0 {
339 gv_check_eq("exact uncertain branch reached" as *u8,tr_contains(out,ln[0],reason),1,ctr)
340 let marker: *u8 = sys_mmap(RIG_PATH)
341 var mo: i64 = gv_cat(marker,0,role); mo = gv_cat(marker,mo,"-receipt.witness" as *u8)
342 gv_check_eq("native receipt variant witnessed" as *u8,rrf_file_equal(rig_join(root,marker),receipt,rig_len(receipt)),1,ctr)
343 }
344 if mode == RIG_SOURCE_CHANGE {
345 gv_check_eq("source changed before scorer returned" as *u8,rrf_file_equal(rig_join(root,"source-change.witness" as *u8),RIG_GUARD,rig_len(RIG_GUARD)),1,ctr)
346 gv_check_eq("source hash refusal reached" as *u8,tr_contains(out,ln[0],"RANK REFUSED: plan changed during computation" as *u8),1,ctr)
347 let appended: *u8 = sys_mmap(pn+rig_len(RIG_SOURCE_APPEND)+1)
348 var p: i64 = 0
349 while p < pn { appended[p] = plan[p]; p = p + 1 }
350 var j: i64 = 0
351 while j < rig_len(RIG_SOURCE_APPEND) { appended[p+j] = RIG_SOURCE_APPEND[j]; j = j + 1 }
352 gv_check_eq("exact fixture source mutation" as *u8,rrf_file_equal(rig_join(root,"buildroot/knowledge/compare/deploy.plan" as *u8),appended,pn+j),1,ctr)
353 gv_check_eq("matrix unchanged" as *u8,rrf_file_equal(rig_join(root,"buildroot/knowledge/compare/deploy.matrix" as *u8),matrix,mn),1,ctr)
354 }
355 return 1
356}
357func rig_selected(selector: *u8, name: *u8) -> i64 {
358 if rig_eq(selector,"all" as *u8) == 1 { return 1 }
359 return rig_eq(selector,name)
360}
361func rig_selector_valid(selector: *u8) -> i64 {
362 if rig_eq(selector,"all" as *u8) == 1 { return 1 }
363 if rig_eq(selector,"real-success" as *u8) == 1 { return 1 }
364 if rig_eq(selector,"real-write-failure" as *u8) == 1 { return 1 }
365 if rig_eq(selector,"zero-open-success" as *u8) == 1 { return 1 }
366 if rig_eq(selector,"zero-open-write-failure" as *u8) == 1 { return 1 }
367 if rig_eq(selector,"scorer-failure" as *u8) == 1 { return 1 }
368 if rig_eq(selector,"lock-contention" as *u8) == 1 { return 1 }
369 if rig_eq(selector,"dispatch-positive-control" as *u8) == 1 { return 1 }
370 if rig_eq(selector,"pm-failed" as *u8) == 1 { return 1 }
371 if rig_eq(selector,"pm-empty" as *u8) == 1 { return 1 }
372 if rig_eq(selector,"pm-full" as *u8) == 1 { return 1 }
373 if rig_eq(selector,"plane-failed" as *u8) == 1 { return 1 }
374 if rig_eq(selector,"plane-empty" as *u8) == 1 { return 1 }
375 if rig_eq(selector,"plane-full" as *u8) == 1 { return 1 }
376 if rig_eq(selector,"source-change" as *u8) == 1 { return 1 }
377 return 0
378}
379func main(argc: i64, argv: *i64) -> i64 {
380 let inv: *u8 = argv[0] as *u8
381 var witness: i64 = tr_contains(inv,rig_len(inv),"nx_store_put.elf" as *u8)
382 witness = witness + tr_contains(inv,rig_len(inv),"nx_pm_intake.elf" as *u8)
383 witness = witness + tr_contains(inv,rig_len(inv),"nx_dr_ocm_cli.elf" as *u8)
384 if witness > 0 { let rc: i64 = rig_witness(argc,argv); sys_exit(rc); return rc }
385 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 }
386 let selector: *u8 = argv[10] as *u8
387 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 }
388 let runner: *u8 = argv[1] as *u8; let self: *u8 = argv[2] as *u8; let parent: *u8 = argv[3] as *u8
389 let scorer: *u8 = argv[4] as *u8; let planpath: *u8 = argv[5] as *u8; let matrixpath: *u8 = argv[6] as *u8
390 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
391 if timeout <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
392 if cap <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
393 if rig_num(budget) <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
394 if rig_parent(parent) != 1 { sys_exit(RIG_SETUP); return RIG_SETUP }
395 var ai: i64 = 1
396 while ai <= 6 {
397 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 } }
398 ai = ai + 1
399 }
400 let pn: *i64 = sys_mmap(RIG_PTR) as *i64; let mn: *i64 = sys_mmap(RIG_PTR) as *i64
401 let plan: *u8 = sys_read_file(planpath,pn); let matrix: *u8 = sys_read_file(matrixpath,mn)
402 if (plan as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
403 if (matrix as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
404 if pn[0] <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
405 if mn[0] <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
406 let tag: *u8 = sys_mmap(RIG_PATH)
407 var o: i64 = gv_cat(tag,0,"rank-refresh-v3-" as *u8); o = gv_catn(tag,o,sys_now_ms())
408 let root: *u8 = rig_join(parent,tag)
409 if (root as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
410 if sys_mkdir(root,RIG_DIR_MODE) != 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
411 let ctr: *i64 = gv_ctr()
412 gv_head("RANK REFRESH ACTUAL PROCESS INTEGRATION V3" as *u8)
413 gv_puts("selected_case=" as *u8); gv_puts(selector); gv_puts("\n" as *u8)
414 gv_puts("fixture_root=" as *u8); gv_puts(root); gv_puts("\n" as *u8)
415 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) }
416 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) }
417 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) }
418 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) }
419 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) }
420 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) }
421 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) }
422 if rig_selected(selector,"pm-failed" as *u8) == 1 { rig_case(root,"pm-failed" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_PM_FAILED,8,timeout,cap,budget,ctr) }
423 if rig_selected(selector,"pm-empty" as *u8) == 1 { rig_case(root,"pm-empty" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_PM_EMPTY,8,timeout,cap,budget,ctr) }
424 if rig_selected(selector,"pm-full" as *u8) == 1 { rig_case(root,"pm-full" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_PM_FULL,8,timeout,cap,budget,ctr) }
425 if rig_selected(selector,"plane-failed" as *u8) == 1 { rig_case(root,"plane-failed" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_PLANE_FAILED,8,timeout,cap,budget,ctr) }
426 if rig_selected(selector,"plane-empty" as *u8) == 1 { rig_case(root,"plane-empty" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_PLANE_EMPTY,8,timeout,cap,budget,ctr) }
427 if rig_selected(selector,"plane-full" as *u8) == 1 { rig_case(root,"plane-full" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_PLANE_FULL,8,timeout,cap,budget,ctr) }
428 if rig_selected(selector,"source-change" as *u8) == 1 { rig_case(root,"source-change" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_SOURCE_CHANGE,7,timeout,cap,budget,ctr) }
429 let rc: i64 = gv_verdict("RANK-REFRESH-INTEGRATION",ctr,"actual candidate + real scorer; captured deploy input; isolated PM/plane witnesses; no promotion" as *u8)
430 sys_exit(rc); return rc
431}