nx_sbr_admission_gate.nx source
↩ module page · 361 lines · 18071 B
1// Executes a supplied candidate runner in fresh fixtures. Never promotes or compiles real code.
2// Usage: nx_sbr_admission_gate <absolute-runner> <absolute-self> <existing-fixture-parent> <timeout-ms>
3// Fixture parent must be an absolute, non-symlink directory. Every run gets a new private subtree.
4// The only executable children are the supplied runner and this fixture ELF.
5import "nx_gate_verdict.nx"
6import "nx_tool_run.nx"
7import "nx_sha256.nx"
8import "nx_build_canon_input_lib.nx"
9const SAG_PATH_CAP: i64 = 4096
10const SAG_CAPTURE_CAP: i64 = 65536
11const SAG_FILE_MODE: i64 = 384
12const SAG_DIR_MODE: i64 = 448
13const SAG_EINVAL: i64 = 0 - 22
14const SAG_SETUP_FAIL: i64 = 90
15const SAG_WITNESS_EXIT: i64 = 91
16const SAG_BYTE_BITS: i64 = 8
17const SAG_PTR_BYTES: i64 = 8
18const SAG_ARG_SLOTS: i64 = 8
19const SAG_DIGEST_BYTES: i64 = 32
20const SAG_HEX_BASE: i64 = 16
21const SAG_SOURCE: *u8 = "func main() -> i64 { return 0 }\n"
22const SAG_GUARD: *u8 = "NISHI-SBR-ADMISSION-FIXTURE\n"
23const SAG_TARGET: *u8 = "bci_target"
24const SAG_SOURCE_PATH: *u8 = "runtime/_hdl_build/bci_target.nx"
25const SAG_CANON: *u8 = "!_hdl_build/bci_target.nx\n"
26const SAG_CASE_OK: i64 = 0
27const SAG_CASE_CONF_MISSING: i64 = 1
28const SAG_CASE_CONF_EMPTY: i64 = 2
29const SAG_CASE_CONF_COMMENTS: i64 = 3
30const SAG_CASE_HASH_MISSING: i64 = 4
31const SAG_CASE_HASH_EMPTY: i64 = 5
32const SAG_CASE_HASH_BAD: i64 = 6
33const SAG_CASE_HASH_DUP: i64 = 7
34const SAG_CASE_HASH_ROW_MISSING: i64 = 8
35const SAG_CASE_SOURCE_EMPTY: i64 = 9
36const SAG_CASE_UNRELATED_ZERO: i64 = 10
37const SAG_CASE_UNRELATED_MALFORMED: i64 = 11
38// Deterministic fixture chronology, not an admission policy or a wall-clock assumption.
39const SAG_FIXTURE_MANIFEST_SEC: i64 = 100
40const SAG_FIXTURE_SOURCE_SEC: i64 = 200
41const SAG_TIMESPEC_PAIR_BYTES: i64 = 32
42
43func sag_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
44func sag_eq(a: *u8, b: *u8) -> i64 {
45 var i: i64 = 0
46 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
47 if b[i] != (0 as u8) { return 0 }
48 return 1
49}
50func sag_decimal(s: *u8) -> i64 {
51 let n: i64 = sag_len(s)
52 if n == 0 { return 0 - 1 }
53 var value: i64 = 0
54 var i: i64 = 0
55 while i < n {
56 let c: i64 = s[i] as i64
57 if c < BCI_ZERO { return 0 - 1 }
58 if c > BCI_NINE { return 0 - 1 }
59 let digit: i64 = c - BCI_ZERO
60 if value > (BCI_I64_MAX-digit)/BCI_DECIMAL_BASE { return 0 - 1 }
61 value = value*BCI_DECIMAL_BASE+digit
62 i = i + 1
63 }
64 return value
65}
66func sag_join(root: *u8, relative: *u8) -> *u8 {
67 let rn: i64 = sag_len(root)
68 let pn: i64 = sag_len(relative)
69 if rn + pn + 2 > SAG_PATH_CAP { return 0 as *u8 }
70 let out: *u8 = sys_mmap(SAG_PATH_CAP)
71 var o: i64 = gv_cat(out, 0, root)
72 out[o] = BCI_SLASH as u8
73 o = gv_cat(out, o+1, relative)
74 out[o] = 0 as u8
75 return out
76}
77func sag_write(path: *u8, bytes: *u8, n: i64) -> i64 {
78 if (path as i64) == 0 { return 0 }
79 let fd: i64 = sys_openat_wr(path, SAG_FILE_MODE)
80 if fd < 0 { return 0 }
81 let written: i64 = sys_write(fd, bytes, n)
82 let closed: i64 = sys_close(fd)
83 if written != n { return 0 }
84 if closed != 0 { return 0 }
85 return 1
86}
87func sag_file(root: *u8, rel: *u8, value: *u8) -> i64 {
88 let path: *u8 = sag_join(root, rel)
89 let rc: i64 = sag_write(path, value, sag_len(value))
90 if (path as i64) != 0 { sys_munmap(path, SAG_PATH_CAP) }
91 return rc
92}
93func sag_dir(root: *u8, rel: *u8) -> i64 {
94 let path: *u8 = sag_join(root, rel)
95 if (path as i64) == 0 { return 0 }
96 let rc: i64 = sys_mkdir(path, SAG_DIR_MODE)
97 sys_munmap(path, SAG_PATH_CAP)
98 if rc != 0 { return 0 }
99 return 1
100}
101func sag_link(root: *u8, rel: *u8, target: *u8) -> i64 {
102 let path: *u8 = sag_join(root, rel)
103 if (path as i64) == 0 { return 0 }
104 let rc: i64 = sys_symlinkat(target, path)
105 sys_munmap(path, SAG_PATH_CAP)
106 if rc != 0 { return 0 }
107 return 1
108}
109func sag_exists(path: *u8) -> i64 {
110 let fd: i64 = sys_openat_rd(path)
111 if fd < 0 { return 0 }
112 sys_close(fd)
113 return 1
114}
115// The supplied root already exists. Requiring readlink EINVAL on each component rejects symlinks
116// and unreadable/missing components. Fresh private descendants are never reused.
117func sag_safe_parent(path: *u8) -> i64 {
118 let n: i64 = sag_len(path)
119 if n <= 1 { return 0 }
120 if n >= SAG_PATH_CAP { return 0 }
121 if path[0] != (BCI_SLASH as u8) { return 0 }
122 if bci_relative_path(path, 1, n-1, SAG_PATH_CAP-2) != 1 { return 0 }
123 let part: *u8 = sys_mmap(SAG_PATH_CAP)
124 let probe: *u8 = sys_mmap(SAG_PATH_CAP)
125 var i: i64 = 0
126 var ok: i64 = 1
127 while i <= n {
128 var edge: i64 = 0
129 if i == n { edge = 1 } else { if path[i] == (BCI_SLASH as u8) { if i > 0 { edge = 1 } } }
130 if edge == 1 {
131 part[i] = 0 as u8
132 if sys_readlinkat(part, probe, SAG_PATH_CAP) != SAG_EINVAL { ok = 0 }
133 }
134 if i < n { part[i] = path[i] }
135 i = i + 1
136 }
137 sys_munmap(part, SAG_PATH_CAP)
138 sys_munmap(probe, SAG_PATH_CAP)
139 return ok
140}
141func sag_guarded() -> i64 {
142 let n: *i64 = sys_mmap(SAG_PTR_BYTES) as *i64
143 n[0] = 0
144 let bytes: *u8 = sys_read_file("fixture-root.guard" as *u8, n)
145 if (bytes as i64) == 0 { return 0 }
146 if n[0] != sag_len(SAG_GUARD) { return 0 }
147 var i: i64 = 0
148 while i < n[0] { if bytes[i] != SAG_GUARD[i] { return 0 } i = i + 1 }
149 return 1
150}
151func sag_admitter(invocation: *u8) -> i64 {
152 if sag_guarded() != 1 { return SAG_SETUP_FAIL }
153 var path: *u8 = "admit.rc" as *u8
154 if invocation[0] == (BCI_DOT as u8) { path = "admit-fallback.rc" as *u8 }
155 let n: *i64 = sys_mmap(SAG_PTR_BYTES) as *i64
156 n[0] = 0
157 let bytes: *u8 = sys_read_file(path, n)
158 if (bytes as i64) == 0 { return SAG_SETUP_FAIL }
159 if n[0] <= 0 { return SAG_SETUP_FAIL }
160 bytes[n[0]] = 0 as u8
161 let rc: i64 = sag_decimal(bytes)
162 if rc < 0 { return SAG_SETUP_FAIL }
163 if rc > 255 { return SAG_SETUP_FAIL }
164 gv_puts("SAG-ADMITTER rc=" as *u8); gv_num(rc); gv_puts("\n" as *u8)
165 return rc
166}
167func sag_compiler() -> i64 {
168 if sag_guarded() != 1 { return SAG_SETUP_FAIL }
169 if sag_write("compiler-witness" as *u8, SAG_GUARD, sag_len(SAG_GUARD)) != 1 { return SAG_SETUP_FAIL }
170 gv_puts("SAG-COMPILER-WITNESS\n" as *u8)
171 return SAG_WITNESS_EXIT
172}
173func sag_manifest() -> *u8 {
174 let dg: *u8 = sys_mmap(SAG_DIGEST_BYTES)
175 sha256_digest(SAG_SOURCE, sag_len(SAG_SOURCE), dg)
176 let out: *u8 = sys_mmap(SAG_PATH_CAP)
177 let hex: *u8 = "0123456789abcdef" as *u8
178 var i: i64 = 0
179 while i < SAG_DIGEST_BYTES {
180 let value: i64 = dg[i] as i64
181 out[i*2] = hex[value/SAG_HEX_BASE]
182 out[i*2+1] = hex[value%SAG_HEX_BASE]
183 i = i + 1
184 }
185 var o: i64 = BCI_SHA_HEX
186 out[o] = BCI_SPACE as u8
187 o = gv_catn(out, o+1, sag_len(SAG_SOURCE))
188 o = gv_cat(out, o, " _hdl_build/bci_target.nx\n" as *u8)
189 out[o] = 0 as u8
190 sys_munmap(dg, SAG_DIGEST_BYTES)
191 return out
192}
193func sag_setup(root: *u8, self: *u8, mode: i64, primary: *u8, fallback: *u8, manifest: *u8) -> i64 {
194 if sag_dir(root, "buildroot" as *u8) != 1 { return 0 }
195 if sag_dir(root, "knowledge" as *u8) != 1 { return 0 }
196 if sag_dir(root, "knowledge/status" as *u8) != 1 { return 0 }
197 if sag_dir(root, "buildroot/runtime" as *u8) != 1 { return 0 }
198 if sag_dir(root, "buildroot/runtime/_hdl_build" as *u8) != 1 { return 0 }
199 if sag_dir(root, "buildroot/_build" as *u8) != 1 { return 0 }
200 if sag_dir(root, "buildroot/_offc" as *u8) != 1 { return 0 }
201 if sag_file(root, "buildroot/runtime/nx_syscalls.nx" as *u8, SAG_SOURCE) != 1 { return 0 }
202 var source: *u8 = SAG_SOURCE
203 if mode == SAG_CASE_SOURCE_EMPTY { source = "" as *u8 }
204 if sag_file(root, "buildroot/runtime/_hdl_build/bci_target.nx" as *u8, source) != 1 { return 0 }
205 if sag_file(root, "buildroot/fixture-root.guard" as *u8, SAG_GUARD) != 1 { return 0 }
206 if sag_file(root, "buildroot/admit.rc" as *u8, primary) != 1 { return 0 }
207 if sag_file(root, "buildroot/admit-fallback.rc" as *u8, fallback) != 1 { return 0 }
208 if sag_len(primary) > 0 {
209 if sag_link(root, "buildroot/_build/nx_build_admit.sov.elf" as *u8, self) != 1 { return 0 }
210 }
211 if sag_len(fallback) > 0 {
212 if sag_link(root, "nx_build_admit.elf" as *u8, self) != 1 { return 0 }
213 }
214 if sag_link(root, "buildroot/_offc/nx_cc_sovereign.elf" as *u8, self) != 1 { return 0 }
215 if sag_link(root, "buildroot/_offc/nxasm_x86_main.elf" as *u8, self) != 1 { return 0 }
216 if mode != SAG_CASE_CONF_MISSING {
217 var conf: *u8 = SAG_CANON
218 if mode == SAG_CASE_CONF_EMPTY { conf = "" as *u8 }
219 if mode == SAG_CASE_CONF_COMMENTS { conf = "# comments only\n" as *u8 }
220 if sag_file(root, "knowledge/tree_canon.conf" as *u8, conf) != 1 { return 0 }
221 }
222 if mode != SAG_CASE_HASH_MISSING {
223 var hash: *u8 = manifest
224 if mode == SAG_CASE_HASH_EMPTY { hash = "" as *u8 }
225 if mode == SAG_CASE_HASH_ROW_MISSING { hash = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef 1 other.nx\n" as *u8 }
226 if mode == SAG_CASE_HASH_BAD { hash = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef x _hdl_build/bci_target.nx\n" as *u8 }
227 if mode == SAG_CASE_HASH_DUP {
228 hash = sys_mmap(SAG_PATH_CAP)
229 var o: i64 = gv_cat(hash, 0, manifest)
230 o = gv_cat(hash, o, manifest)
231 hash[o] = 0 as u8
232 }
233 if mode == SAG_CASE_UNRELATED_ZERO {
234 hash = sys_mmap(SAG_PATH_CAP)
235 var o: i64 = gv_cat(hash, 0, manifest)
236 o = gv_cat(hash, o, "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef 0 unrelated.nx\n" as *u8)
237 hash[o] = 0 as u8
238 }
239 if mode == SAG_CASE_UNRELATED_MALFORMED {
240 hash = sys_mmap(SAG_PATH_CAP)
241 var o: i64 = gv_cat(hash, 0, manifest)
242 o = gv_cat(hash, o, "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef malformed unrelated.nx\n" as *u8)
243 hash[o] = 0 as u8
244 }
245 if sag_file(root, "knowledge/status/treecanon_laptop_hash.mf" as *u8, hash) != 1 { return 0 }
246 let times: *i64 = sys_mmap(SAG_TIMESPEC_PAIR_BYTES) as *i64
247 times[0] = SAG_FIXTURE_MANIFEST_SEC; times[1] = 0
248 times[2] = SAG_FIXTURE_MANIFEST_SEC; times[3] = 0
249 let hashpath: *u8 = sag_join(root, "knowledge/status/treecanon_laptop_hash.mf" as *u8)
250 if sys_utimensat(hashpath, times) != 0 { return 0 }
251 times[0] = SAG_FIXTURE_SOURCE_SEC; times[2] = SAG_FIXTURE_SOURCE_SEC
252 let sourcepath: *u8 = sag_join(root, "buildroot/runtime/_hdl_build/bci_target.nx" as *u8)
253 if sys_utimensat(sourcepath, times) != 0 { return 0 }
254 sys_munmap(times as *u8, SAG_TIMESPEC_PAIR_BYTES)
255 sys_munmap(hashpath, SAG_PATH_CAP)
256 sys_munmap(sourcepath, SAG_PATH_CAP)
257 }
258 return 1
259}
260func sag_case(runroot: *u8, name: *u8, runner: *u8, self: *u8, timeout_text: *u8, mode: i64, primary: *u8, fallback: *u8, expected_rc: i64, expected_witness: i64, ctr: *i64) -> i64 {
261 gv_puts("\nCASE " as *u8); gv_puts(name); gv_puts("\n" as *u8)
262 let root: *u8 = sag_join(runroot, name)
263 if (root as i64) == 0 { gv_check("fixture path fits" as *u8, 0, ctr); return 0 }
264 if sys_mkdir(root, SAG_DIR_MODE) != 0 { gv_check("fresh case directory" as *u8, 0, ctr); return 0 }
265 let manifest: *u8 = sag_manifest()
266 let setup: i64 = sag_setup(root, self, mode, primary, fallback, manifest)
267 gv_check_eq("fixture setup" as *u8, setup, 1, ctr)
268 if setup != 1 { return 0 }
269 let cwd: *u8 = sag_join(root, "buildroot" as *u8)
270 let args: *i64 = sys_mmap(SAG_ARG_SLOTS*SAG_PTR_BYTES) as *i64
271 args[0] = runner as i64
272 args[1] = SAG_TARGET as i64
273 args[2] = "--build-only" as *u8 as i64
274 args[3] = "--no-cache" as *u8 as i64
275 args[4] = "--release" as *u8 as i64
276 args[5] = "--timeout-ms" as *u8 as i64
277 args[6] = timeout_text as i64
278 args[7] = 0
279 let out: *u8 = sys_mmap(SAG_CAPTURE_CAP)
280 let outlen: *i64 = sys_mmap(SAG_PTR_BYTES) as *i64
281 let rc: i64 = tr_run_capture_cwd(runner, args, out, SAG_CAPTURE_CAP, outlen, sag_decimal(timeout_text), cwd)
282 // Keep complete child captures in runner.out; the API response budget carries assertions.
283 gv_check_eq("runner exit" as *u8, rc, expected_rc, ctr)
284 let marker: *u8 = sag_join(cwd, "compiler-witness" as *u8)
285 gv_check_eq("compiler reached" as *u8, sag_exists(marker), expected_witness, ctr)
286 gv_check("capture complete" as *u8, (outlen[0] < SAG_CAPTURE_CAP) as i64, ctr)
287 let log: *u8 = sag_join(root, "runner.out" as *u8)
288 gv_check_eq("capture persisted" as *u8, sag_write(log, out, outlen[0]), 1, ctr)
289 sys_munmap(root, SAG_PATH_CAP)
290 sys_munmap(manifest, SAG_PATH_CAP)
291 sys_munmap(cwd, SAG_PATH_CAP)
292 sys_munmap(marker, SAG_PATH_CAP)
293 sys_munmap(log, SAG_PATH_CAP)
294 sys_munmap(out, SAG_CAPTURE_CAP)
295 sys_munmap(outlen as *u8, SAG_PTR_BYTES)
296 sys_munmap(args as *u8, SAG_ARG_SLOTS*SAG_PTR_BYTES)
297 return 1
298}
299func main(argc: i64, argv: *i64) -> i64 {
300 if argc > 1 {
301 if sag_eq(argv[1] as *u8, "check" as *u8) == 1 { let rc: i64 = sag_admitter(argv[0] as *u8); sys_exit(rc); return rc }
302 if sag_eq(argv[1] as *u8, SAG_SOURCE_PATH) == 1 { let rc: i64 = sag_compiler(); sys_exit(rc); return rc }
303 }
304 if argc != 5 {
305 gv_puts("usage: nx_sbr_admission_gate <absolute-runner> <absolute-self> <existing-fixture-parent> <positive-timeout-ms>\n" as *u8)
306 sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL
307 }
308 let runner: *u8 = argv[1] as *u8
309 let self: *u8 = argv[2] as *u8
310 let parent: *u8 = argv[3] as *u8
311 let timeout_text: *u8 = argv[4] as *u8
312 if runner[0] != (BCI_SLASH as u8) { sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL }
313 if self[0] != (BCI_SLASH as u8) { sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL }
314 if sag_exists(runner) != 1 { sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL }
315 if sag_exists(self) != 1 { sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL }
316 if sag_decimal(timeout_text) <= 0 { sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL }
317 if sag_safe_parent(parent) != 1 {
318 gv_puts("REFUSED fixture parent: absolute existing non-symlink path required\n" as *u8)
319 sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL
320 }
321 let tag: *u8 = sys_mmap(SAG_PATH_CAP)
322 var o: i64 = gv_cat(tag, 0, "sbr-admission-" as *u8)
323 o = gv_catn(tag, o, sys_now_ms())
324 tag[o] = 0 as u8
325 let runroot: *u8 = sag_join(parent, tag)
326 if (runroot as i64) == 0 { sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL }
327 if sys_mkdir(runroot, SAG_DIR_MODE) != 0 {
328 gv_puts("REFUSED fixture directory already exists or cannot be created; no reuse\n" as *u8)
329 sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL
330 }
331 if sys_chdir(runroot) != 0 { sys_exit(SAG_SETUP_FAIL); return SAG_SETUP_FAIL }
332 let ctr: *i64 = gv_ctr()
333 gv_head("actual candidate runner admission integration -- no promotion" as *u8)
334 gv_puts("fixture_root=" as *u8); gv_puts(runroot); gv_puts("\n" as *u8)
335 sag_case(runroot, "healthy" as *u8, runner, self, timeout_text, 0, "0" as *u8, "" as *u8, 3, 1, ctr)
336 sag_case(runroot, "missing-conf" as *u8, runner, self, timeout_text, 1, "0" as *u8, "" as *u8, 7, 0, ctr)
337 sag_case(runroot, "empty-conf" as *u8, runner, self, timeout_text, 2, "0" as *u8, "" as *u8, 7, 0, ctr)
338 sag_case(runroot, "comments-conf" as *u8, runner, self, timeout_text, 3, "0" as *u8, "" as *u8, 7, 0, ctr)
339 sag_case(runroot, "missing-hash" as *u8, runner, self, timeout_text, 4, "0" as *u8, "" as *u8, 7, 0, ctr)
340 sag_case(runroot, "empty-hash" as *u8, runner, self, timeout_text, 5, "0" as *u8, "" as *u8, 7, 0, ctr)
341 sag_case(runroot, "malformed-hash" as *u8, runner, self, timeout_text, 6, "0" as *u8, "" as *u8, 7, 0, ctr)
342 sag_case(runroot, "duplicate-hash" as *u8, runner, self, timeout_text, 7, "0" as *u8, "" as *u8, 7, 0, ctr)
343 sag_case(runroot, "missing-relevant-row" as *u8, runner, self, timeout_text, SAG_CASE_HASH_ROW_MISSING, "0" as *u8, "" as *u8, 7, 0, ctr)
344 sag_case(runroot, "empty-source" as *u8, runner, self, timeout_text, SAG_CASE_SOURCE_EMPTY, "0" as *u8, "" as *u8, 7, 0, ctr)
345 sag_case(runroot, "unrelated-zero-size" as *u8, runner, self, timeout_text, SAG_CASE_UNRELATED_ZERO, "0" as *u8, "" as *u8, 3, 1, ctr)
346 sag_case(runroot, "unrelated-malformed" as *u8, runner, self, timeout_text, SAG_CASE_UNRELATED_MALFORMED, "0" as *u8, "" as *u8, 3, 1, ctr)
347 sag_case(runroot, "deny-memory" as *u8, runner, self, timeout_text, 0, "3" as *u8, "" as *u8, 6, 0, ctr)
348 sag_case(runroot, "queue" as *u8, runner, self, timeout_text, 0, "4" as *u8, "" as *u8, 6, 0, ctr)
349 sag_case(runroot, "cannot-measure" as *u8, runner, self, timeout_text, 0, "5" as *u8, "" as *u8, 6, 0, ctr)
350 sag_case(runroot, "both-absent" as *u8, runner, self, timeout_text, 0, "" as *u8, "" as *u8, 6, 0, ctr)
351 sag_case(runroot, "absent-primary-fallback-grant" as *u8, runner, self, timeout_text, 0, "" as *u8, "0" as *u8, 3, 1, ctr)
352 sag_case(runroot, "absent-primary-fallback-deny" as *u8, runner, self, timeout_text, 0, "" as *u8, "5" as *u8, 6, 0, ctr)
353 sag_case(runroot, "primary127-fallback-grant" as *u8, runner, self, timeout_text, 0, "127" as *u8, "0" as *u8, 3, 1, ctr)
354 sag_case(runroot, "primary127-fallback-deny" as *u8, runner, self, timeout_text, 0, "127" as *u8, "5" as *u8, 6, 0, ctr)
355 sag_case(runroot, "unexpected2" as *u8, runner, self, timeout_text, 0, "2" as *u8, "" as *u8, 6, 0, ctr)
356 sag_case(runroot, "unexpected42" as *u8, runner, self, timeout_text, 0, "42" as *u8, "" as *u8, 6, 0, ctr)
357 sag_case(runroot, "unexpected139" as *u8, runner, self, timeout_text, 0, "139" as *u8, "" as *u8, 6, 0, ctr)
358 let rc: i64 = gv_verdict("SBR-ADMISSION-INTEGRATION", ctr, "candidate ELF executed in fresh fixtures; compiler witness only; no promotion" as *u8)
359 sys_exit(rc)
360 return rc
361}