nx_gen_dispatch_gate.nx source
↩ module page · 355 lines · 18796 B
1// nx_gen_dispatch_gate.nx -- the REFEREE for gen G17 (dispatch honesty) on the CHAT path: a planted SLOW worker (listens,
2// never answers) must make the LIVE daemon answer BUSY-TIMEOUT, and an ABSENT worker must make it answer the health-probe
3// refusal -- and NEITHER may read "all in the registry are down", the false attribution measured 2026-08-29 (a socket watch
4// showed the worker ESTABLISHED and rendering while the caller was told no worker existed).
5// SUBJECT = the LIVE binary at /volume1/ai/gen (what serves, never a build). The daemon is launched on a throwaway port from a
6// scratch cwd, so no swarm SSOT conf is visible and the fixture argv worker is its ONLY candidate; budget=2 (one probe connect,
7// one POST) so it exits by itself and leaves no process behind. The slow fixture LISTENS AND NEVER ACCEPTS: the kernel completes
8// the handshake into the backlog, so the daemon's probe and connect succeed and its read times out -- exactly the connected-and-
9// silent worker the defect misattributed. Against the PRE-FIX binary this gate is RED by construction (the bite is the live
10// history, not a planted mutant). RUNTIME ~4 min (three chat tries at the conf budget): run via nx_job_run, never the FAST
11// gate_run path.
12// G18 ADDED 2026-08-30 (the async lane): a third fixture ANSWERS, but only after DG_ANSWER_DELAY_MS. POST /api/chat_async must
13// return a job id BEFORE that delay can have elapsed (so nothing waited on the worker socket), a poll must read pending first,
14// and the planted reply must then land through GET /api/batch/<job> -- a completion slower than the submit round-trip lands
15// instead of being dropped, which is the whole of G18's done-rule. The nonce in the landed reply is the isolation witness.
16// license_tier: ORIGINAL expect_exit: 0
17import "nx_syscalls.nx"
18import "nx_gate_verdict.nx"
19import "nx_connect.nx"
20
21const DG_DAEMON: *u8 = "/volume1/ai/gen/nx_gen_orchestrator_daemon.elf" as *u8
22const DG_DIR: *u8 = "/tmp/nx_gen_dispatch_gate" as *u8
23const DG_MODE_DIR: i64 = 511
24const DG_PORT: i64 = 18979
25const DG_WPORT_SLOW: i64 = 18978
26const DG_WPORT_ABSENT: i64 = 18977
27const DG_CAP: i64 = 65536
28const DG_CONNECT_MS: i64 = 3000
29const DG_PROBE_MS: i64 = 500
30// three 25 s chat tries plus their pauses, plus slack for a loaded box
31const DG_READ_TMO_S: i64 = 200
32// an ABSENT worker is refused by the probe in milliseconds; a reply slower than this proves a real worker was dispatched
33const DG_ISOLATION_US: i64 = 30000000
34// 50 x 100 ms = 5 s for the daemon to bind its port
35const DG_UP_TRIES: i64 = 50
36const DG_UP_STEP_MS: i64 = 100
37const DG_BODY: *u8 = "{\"message\":\"hello there\"}" as *u8
38const DG_BACKLOG: i64 = 16
39const DG_STATUS_503: *u8 = " 503 " as *u8
40const DG_OLD_LIE: *u8 = "all in the registry are down" as *u8
41const DG_BUSY: *u8 = "BUSY-TIMEOUT" as *u8
42const DG_PROBE_TEXT: *u8 = "health probe" as *u8
43// G18 fixture: the answering worker's port, the delay it holds the completion for, the poll cadence and the request budget the
44// daemon is launched with for that run (1 probe + 1 submit + polls; the daemon is killed by pid after the run regardless)
45const DG_WPORT_ANSWERS: i64 = 18976
46const DG_ANSWER_DELAY_MS: i64 = 6000
47const DG_FIX_READ_TMO_S: i64 = 1
48const DG_FIX_REQ_CAP: i64 = 262144
49const DG_POLL_MS: i64 = 1000
50const DG_POLL_TRIES: i64 = 60
51const DG_BUDGET_ASYNC: *u8 = "64" as *u8
52const DG_NONCE: *u8 = "FIXTURE-REPLY-7f3a9c" as *u8
53const DG_FIX_JSON: *u8 = "{\"choices\":[{\"finish_reason\":\"stop\",\"index\":0,\"message\":{\"role\":\"assistant\",\"content\":\"FIXTURE-REPLY-7f3a9c\"}}]}" as *u8
54const DG_PENDING: *u8 = "\"done\":0" as *u8
55const DG_JOB_KEY: *u8 = "\"job\":\"" as *u8
56const DG_CH_QUOTE: i64 = 34
57const DG_JID_CAP: i64 = 30
58const DG_US_PER_MS: i64 = 1000
59const DG_SIGKILL: i64 = 9
60const DG_PATH_CAP: i64 = 96
61const DG_NONE_CAP: i64 = 8
62const DG_FIX_RESP_CAP: i64 = 4096
63
64func dg_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
65func dg_cat(dst: *u8, off: i64, s: *u8) -> i64 { var o: i64 = off; var i: i64 = 0; while s[i] != (0 as u8) { dst[o] = s[i]; o = o + 1; i = i + 1 } return o }
66func dg_itoa(dst: *u8, off: i64, v: i64) -> i64 {
67 let t: *u8 = sys_mmap(32); var m: i64 = v; var k: i64 = 0
68 if m == 0 { t[0] = 48 as u8; k = 1 }
69 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
70 var o: i64 = off
71 while k > 0 { k = k - 1; dst[o] = t[k]; o = o + 1 }
72 return o
73}
74func dg_str(v: i64) -> *u8 { let b: *u8 = sys_mmap(32); let o: i64 = dg_itoa(b, 0, v); b[o] = 0 as u8; return b }
75func dg_find(buf: *u8, n: i64, needle: *u8) -> i64 {
76 let nl: i64 = dg_len(needle)
77 if nl <= 0 { return 0 - 1 }
78 var i: i64 = 0
79 while i + nl <= n {
80 var j: i64 = 0
81 var same: i64 = 1
82 var scan: i64 = 1
83 while scan == 1 { if j >= nl { scan = 0 } else { if buf[i + j] != needle[j] { same = 0; scan = 0 } else { j = j + 1 } } }
84 if same == 1 { return i }
85 i = i + 1
86 }
87 return 0 - 1
88}
89// sockaddr_in for 127.0.0.1:port
90func dg_addr(a: *u8, port: i64) -> i64 {
91 a[0] = 2 as u8; a[1] = 0 as u8; a[2] = ((port >> 8) & 255) as u8; a[3] = (port & 255) as u8
92 a[4] = 127 as u8; a[5] = 0 as u8; a[6] = 0 as u8; a[7] = 1 as u8
93 var z: i64 = 8
94 while z < 16 { a[z] = 0 as u8; z = z + 1 }
95 return 0
96}
97// bounded connect probe: 1 = something accepts on the port, 0 = refused or silent
98func dg_can_connect(port: i64, budget_ms: i64) -> i64 {
99 let fd: i64 = sys_socket(2, 1, 0)
100 if fd < 0 { return 0 }
101 let a: *u8 = sys_mmap(16)
102 dg_addr(a, port)
103 let rc: i64 = nx_connect_bounded(fd, a, 16, budget_ms)
104 sys_close(fd)
105 if rc == 0 { return 1 }
106 return 0
107}
108// the SLOW fixture: bind + listen, NEVER accept. Returns the listen fd, held open for the gate's lifetime.
109func dg_slow_listen(port: i64) -> i64 {
110 let fd: i64 = sys_socket(2, 1, 0)
111 if fd < 0 { return 0 - 1 }
112 let optv: *u8 = sys_mmap(4); optv[0] = 1 as u8
113 sys_setsockopt(fd, 1, 2, optv, 4)
114 let a: *u8 = sys_mmap(16)
115 dg_addr(a, port)
116 if sys_bind(fd, a, 16) < 0 { sys_close(fd); return 0 - 2 }
117 if sys_listen(fd, DG_BACKLOG) < 0 { sys_close(fd); return 0 - 3 }
118 return fd
119}
120// ISOLATION (learned from the first live run, 2026-08-30): the daemon resolves gpu-image from knowledge/swarm_nodes.conf
121// RELATIVE FIRST, then the nishihost absolute path -- so a scratch cwd without the conf silently fell through to the REAL
122// laptop worker, and the absent-worker run answered BUSY-TIMEOUT from a worker the gate never planted. The fixture now
123// writes its own SSOT row in the scratch cwd (R<TAB>gpu-image<TAB>fixture<TAB>127.0.0.1:<wport><TAB>desc), which the
124// relative read wins, so the planted worker is the daemon's ONLY candidate (argv repeats it and is deduplicated).
125func dg_write_swarm_conf(wport: i64) -> i64 {
126 sys_mkdir("/tmp/nx_gen_dispatch_gate/knowledge" as *u8, DG_MODE_DIR)
127 let fd: i64 = sys_openat_wr("/tmp/nx_gen_dispatch_gate/knowledge/swarm_nodes.conf" as *u8, 420)
128 if fd < 0 { return 0 - 1 }
129 let row: *u8 = sys_mmap(256)
130 var o: i64 = dg_cat(row, 0, "R" as *u8); row[o] = 9 as u8; o = o + 1
131 o = dg_cat(row, o, "gpu-image" as *u8); row[o] = 9 as u8; o = o + 1
132 o = dg_cat(row, o, "fixture" as *u8); row[o] = 9 as u8; o = o + 1
133 o = dg_cat(row, o, "127.0.0.1:" as *u8); o = dg_itoa(row, o, wport); row[o] = 9 as u8; o = o + 1
134 o = dg_cat(row, o, "dispatch-gate fixture worker\n" as *u8)
135 sys_write(fd, row, o)
136 sys_close(fd)
137 return 0
138}
139// launch the LIVE daemon in the scratch cwd with (127.0.0.1:wport) as its only worker. budget is the daemon's request budget:
140// "2" = one probe + one POST so it exits by itself; the async run passes DG_BUDGET_ASYNC and is killed by pid after its polls.
141func dg_start_daemon_budget(wport: i64, budget: *u8) -> i64 {
142 dg_write_swarm_conf(wport)
143 let pid: i64 = sys_fork()
144 if pid == 0 {
145 sys_chdir(DG_DIR)
146 let argv: *i64 = sys_mmap(16 * 8) as *i64
147 argv[0] = DG_DAEMON as i64
148 argv[1] = dg_str(DG_PORT) as i64
149 argv[2] = "127" as *u8 as i64
150 argv[3] = "0" as *u8 as i64
151 argv[4] = "0" as *u8 as i64
152 argv[5] = "1" as *u8 as i64
153 argv[6] = dg_str(wport) as i64
154 argv[7] = "store-" as *u8 as i64
155 argv[8] = "blobs" as *u8 as i64
156 argv[9] = "sidecar.tsv" as *u8 as i64
157 argv[10] = "fixture" as *u8 as i64
158 argv[11] = budget as i64
159 argv[12] = 0
160 let envp: *i64 = sys_mmap(16) as *i64
161 envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64
162 envp[1] = 0
163 sys_execve_clean(DG_DAEMON, argv, envp)
164 sys_exit(127)
165 return 0
166 }
167 return pid
168}
169func dg_start_daemon(wport: i64) -> i64 { return dg_start_daemon_budget(wport, "2" as *u8) }
170// wait for the daemon to bind: the successful probe connect consumes ONE unit of its budget (hence budget=2)
171func dg_wait_up(port: i64) -> i64 {
172 var t: i64 = 0
173 while t < DG_UP_TRIES {
174 if dg_can_connect(port, DG_UP_STEP_MS) == 1 { return 1 }
175 sys_sleep_ms(DG_UP_STEP_MS)
176 t = t + 1
177 }
178 return 0
179}
180// ONE request writer for every probe the gate sends -- POST with a JSON body, or GET with an empty one -- draining the whole
181// reply (status line + headers + body). Returns bytes, or -1 when nothing connected.
182func dg_req(port: i64, method: *u8, path: *u8, body: *u8, out: *u8, cap: i64) -> i64 {
183 let fd: i64 = sys_socket(2, 1, 0)
184 if fd < 0 { return 0 - 1 }
185 let a: *u8 = sys_mmap(16)
186 dg_addr(a, port)
187 if nx_connect_bounded(fd, a, 16, DG_CONNECT_MS) != 0 { sys_close(fd); return 0 - 1 }
188 sys_set_socket_timeout(fd, DG_READ_TMO_S)
189 let rq: *u8 = sys_mmap(4096)
190 var o: i64 = dg_cat(rq, 0, method)
191 o = dg_cat(rq, o, " " as *u8)
192 o = dg_cat(rq, o, path)
193 o = dg_cat(rq, o, " HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n" as *u8)
194 if dg_len(body) > 0 {
195 o = dg_cat(rq, o, "Content-Type: application/json\r\nContent-Length: " as *u8)
196 o = dg_itoa(rq, o, dg_len(body))
197 o = dg_cat(rq, o, "\r\n" as *u8)
198 }
199 o = dg_cat(rq, o, "\r\n" as *u8)
200 o = dg_cat(rq, o, body)
201 sys_write(fd, rq, o)
202 var total: i64 = 0
203 var scan: i64 = 1
204 while scan == 1 {
205 if total >= cap - 1 { scan = 0 } else {
206 let r: i64 = sys_read(fd, ((out as i64) + total) as *u8, cap - 1 - total)
207 if r <= 0 { scan = 0 } else { total = total + r }
208 }
209 }
210 sys_close(fd)
211 out[total] = 0 as u8
212 return total
213}
214func dg_post(port: i64, path: *u8, body: *u8, out: *u8, cap: i64) -> i64 { return dg_req(port, "POST" as *u8, path, body, out, cap) }
215func dg_get(port: i64, path: *u8, out: *u8, cap: i64) -> i64 {
216 let none: *u8 = sys_mmap(DG_NONE_CAP)
217 return dg_req(port, "GET" as *u8, path, none, out, cap)
218}
219// THE ANSWERING FIXTURE (G18): a worker that accepts, reads the request until DG_FIX_READ_TMO_S of silence, WAITS
220// DG_ANSWER_DELAY_MS, then answers one fixed chat completion carrying DG_NONCE. A health probe connects and closes without
221// sending a byte -- it gets no answer. Forked so it serves the daemon's probe and POST in turn while the gate polls; the
222// parent kills it by pid after the run. Returns the child pid, or the negative listen failure.
223func dg_answering_worker(port: i64) -> i64 {
224 let lfd: i64 = dg_slow_listen(port)
225 if lfd < 0 { return lfd }
226 let pid: i64 = sys_fork()
227 if pid == 0 {
228 let rb: *u8 = sys_mmap(DG_FIX_REQ_CAP)
229 let rs: *u8 = sys_mmap(DG_FIX_RESP_CAP)
230 var o: i64 = dg_cat(rs, 0, "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nConnection: close\r\nContent-Length: " as *u8)
231 o = dg_itoa(rs, o, dg_len(DG_FIX_JSON))
232 o = dg_cat(rs, o, "\r\n\r\n" as *u8)
233 o = dg_cat(rs, o, DG_FIX_JSON)
234 var serve: i64 = 1
235 while serve == 1 {
236 let c: i64 = sys_accept(lfd)
237 if c < 0 { serve = 0 } else {
238 sys_set_socket_timeout(c, DG_FIX_READ_TMO_S)
239 var got: i64 = 0
240 var rd: i64 = 1
241 while rd == 1 {
242 let r: i64 = sys_read(c, rb, DG_FIX_REQ_CAP)
243 if r <= 0 { rd = 0 } else { got = got + r }
244 }
245 if got > 0 { sys_sleep_ms(DG_ANSWER_DELAY_MS); sys_write(c, rs, o) }
246 sys_close(c)
247 }
248 }
249 sys_exit(0)
250 return 0
251 }
252 return pid
253}
254
255func main() -> i64 {
256 gv_head("nx_gen_dispatch_gate -- G17 + G18 on the chat path against the LIVE binary: a silent worker reads BUSY-TIMEOUT, an absent worker reads the health-probe refusal, neither reads registry-down, and a completion slower than the submit round-trip lands through the job lane" as *u8)
257 let ctr: *i64 = gv_ctr()
258 sys_mkdir(DG_DIR, DG_MODE_DIR)
259 let cd: i64 = sys_chdir(DG_DIR)
260 gv_check("setup-scratch-cwd-entered" as *u8, cd == 0, ctr)
261
262 // FIXTURES REACH THEIR CONDITIONS before any outcome is read
263 gv_check("fixture-reached-condition-absent-port-refuses" as *u8, dg_can_connect(DG_WPORT_ABSENT, DG_PROBE_MS) == 0, ctr)
264 let lfd: i64 = dg_slow_listen(DG_WPORT_SLOW)
265 gv_check("fixture-slow-worker-listening" as *u8, lfd >= 0, ctr)
266 gv_check("fixture-reached-condition-slow-port-accepts-connects-and-stays-silent" as *u8, dg_can_connect(DG_WPORT_SLOW, DG_PROBE_MS) == 1, ctr)
267
268 // T1 the live daemon against the SILENT worker
269 let out: *u8 = sys_mmap(DG_CAP)
270 let st: *i64 = sys_mmap(16) as *i64
271 let pid1: i64 = dg_start_daemon(DG_WPORT_SLOW)
272 let up1: i64 = dg_wait_up(DG_PORT)
273 gv_check("live-daemon-binds-the-throwaway-port" as *u8, up1 == 1, ctr)
274 var n1: i64 = 0
275 if up1 == 1 { n1 = dg_post(DG_PORT, "/api/chat" as *u8, DG_BODY, out, DG_CAP) }
276 gv_check("silent-worker-daemon-answers-the-post" as *u8, n1 > 0, ctr)
277 gv_check("silent-worker-answer-is-a-503" as *u8, dg_find(out, n1, DG_STATUS_503) >= 0, ctr)
278 gv_check("silent-worker-is-named-BUSY-TIMEOUT" as *u8, dg_find(out, n1, DG_BUSY) >= 0, ctr)
279 gv_check("neg-control-silent-worker-is-never-blamed-as-registry-down" as *u8, dg_find(out, n1, DG_OLD_LIE) < 0, ctr)
280 if pid1 > 0 { sys_wait4(pid1, st, 0) }
281
282 // T2 the live daemon against the ABSENT worker (the same port order, the same body, only the worker differs)
283 let pid2: i64 = dg_start_daemon(DG_WPORT_ABSENT)
284 let up2: i64 = dg_wait_up(DG_PORT)
285 gv_check("live-daemon-rebinds-for-the-absent-worker-run" as *u8, up2 == 1, ctr)
286 var n2: i64 = 0
287 let t2a: i64 = sys_now_us()
288 if up2 == 1 { n2 = dg_post(DG_PORT, "/api/chat" as *u8, DG_BODY, out, DG_CAP) }
289 let t2b: i64 = sys_now_us()
290 gv_check("absent-worker-daemon-answers-the-post" as *u8, n2 > 0, ctr)
291 gv_check("isolation-absent-worker-answers-fast-so-no-real-worker-was-dispatched" as *u8, (n2 > 0) & ((t2b - t2a) < DG_ISOLATION_US), ctr)
292 gv_check("absent-worker-names-the-health-probe" as *u8, dg_find(out, n2, DG_PROBE_TEXT) >= 0, ctr)
293 gv_check("neg-control-absent-worker-is-not-a-timeout" as *u8, dg_find(out, n2, DG_BUSY) < 0, ctr)
294 gv_check("neg-control-absent-worker-is-never-blamed-as-registry-down" as *u8, dg_find(out, n2, DG_OLD_LIE) < 0, ctr)
295 if pid2 > 0 { sys_wait4(pid2, st, 0) }
296 if lfd >= 0 { sys_close(lfd) }
297
298 // T3 (G18) the live daemon against a worker that ANSWERS, but only after the delay: the async submit must not wait for it
299 let wpid: i64 = dg_answering_worker(DG_WPORT_ANSWERS)
300 gv_check("fixture-answering-worker-forked" as *u8, wpid > 0, ctr)
301 gv_check("fixture-reached-condition-answering-port-accepts" as *u8, dg_can_connect(DG_WPORT_ANSWERS, DG_PROBE_MS) == 1, ctr)
302 let pid3: i64 = dg_start_daemon_budget(DG_WPORT_ANSWERS, DG_BUDGET_ASYNC)
303 let up3: i64 = dg_wait_up(DG_PORT)
304 gv_check("live-daemon-rebinds-for-the-async-run" as *u8, up3 == 1, ctr)
305 let t3a: i64 = sys_now_us()
306 var n3: i64 = 0
307 if up3 == 1 { n3 = dg_post(DG_PORT, "/api/chat_async" as *u8, DG_BODY, out, DG_CAP) }
308 let t3b: i64 = sys_now_us()
309 var jpos: i64 = 0 - 1
310 if n3 > 0 { jpos = dg_find(out, n3, DG_JOB_KEY) }
311 gv_check("async-submit-returns-a-job-id" as *u8, jpos >= 0, ctr)
312 gv_check("async-submit-returns-before-the-fixture-can-have-answered-so-no-worker-socket-was-awaited" as *u8, (jpos >= 0) & ((t3b - t3a) < (DG_ANSWER_DELAY_MS * DG_US_PER_MS)), ctr)
313 let jid: *u8 = sys_mmap(DG_JID_CAP + 2)
314 var ji: i64 = 0
315 if jpos >= 0 {
316 var q: i64 = jpos + dg_len(DG_JOB_KEY)
317 var scanj: i64 = 1
318 while scanj == 1 {
319 if q >= n3 { scanj = 0 } else { if out[q] == (DG_CH_QUOTE as u8) { scanj = 0 } else { if ji >= DG_JID_CAP { scanj = 0 } else { jid[ji] = out[q]; ji = ji + 1; q = q + 1 } } }
320 }
321 }
322 jid[ji] = 0 as u8
323 let ppath: *u8 = sys_mmap(DG_PATH_CAP)
324 var po: i64 = dg_cat(ppath, 0, "/api/batch/" as *u8)
325 po = dg_cat(ppath, po, jid)
326 ppath[po] = 0 as u8
327 var pending_seen: i64 = 0
328 var landed: i64 = 0
329 var tland: i64 = 0
330 var tries: i64 = 0
331 var np: i64 = 0
332 while (tries < DG_POLL_TRIES) & (landed == 0) {
333 np = dg_get(DG_PORT, ppath, out, DG_CAP)
334 if np > 0 {
335 if dg_find(out, np, DG_NONCE) >= 0 { landed = 1; tland = sys_now_us() } else { if dg_find(out, np, DG_PENDING) >= 0 { pending_seen = 1 } }
336 }
337 if landed == 0 { sys_sleep_ms(DG_POLL_MS) }
338 tries = tries + 1
339 }
340 gv_check("fixture-reached-condition-a-poll-read-pending-before-the-answer-landed" as *u8, pending_seen == 1, ctr)
341 gv_check("slow-completion-lands-through-the-job-lane-carrying-the-planted-reply" as *u8, landed == 1, ctr)
342 gv_check("isolation-the-reply-landed-no-earlier-than-the-fixture-delay-so-the-planted-worker-answered-it" as *u8, (landed == 1) & ((tland - t3a) >= (DG_ANSWER_DELAY_MS * DG_US_PER_MS)), ctr)
343 gv_check("neg-control-landed-reply-is-not-a-503" as *u8, (landed == 1) & (dg_find(out, np, DG_STATUS_503) < 0), ctr)
344 gv_check("neg-control-async-run-never-blamed-as-registry-down" as *u8, (landed == 1) & (dg_find(out, np, DG_OLD_LIE) < 0), ctr)
345 if pid3 > 0 { nx_kill(pid3, DG_SIGKILL); sys_wait4(pid3, st, 0) }
346 if wpid > 0 { nx_kill(wpid, DG_SIGKILL); sys_wait4(wpid, st, 0) }
347 let jf: *u8 = sys_mmap(DG_PATH_CAP)
348 var jfo: i64 = dg_cat(jf, 0, "batchjob-" as *u8)
349 jfo = dg_cat(jf, jfo, jid)
350 jfo = dg_cat(jf, jfo, ".json" as *u8)
351 jf[jfo] = 0 as u8
352 if ji > 0 { sys_unlinkat(jf) }
353
354 return gv_verdict("GEN-DISPATCH-GATE" as *u8, ctr, "G17 + G18 done-rules on the chat path against the LIVE binary: silent worker reads BUSY-TIMEOUT, absent worker reads the health-probe refusal, neither reads registry-down, and a completion slower than the submit round-trip lands through the job lane" as *u8)
355}