code wiki / _hdl_build / nx_triage.nx
nx_triage.nx source
↩ module page · 927 lines · 37275 B
1// nx_triage.nx -- SOVEREIGN AUTO-TRIAGE ROUTER (ws=ws-intel7, 2026-07-20).
2// The ROUTER TIER of the operator's dual-LLM PM architecture, built sovereign: a fast
3// classifier reads NEW nx_pm_intake requests, scores each against the ecosystem's OWN live
4// lane signals (data-driven routing table -- rule 11, never hardcoded), and either
5// AUTO-ADVANCES a high-confidence request NEW -> TRIAGED (writes a TRIAGE frame), or
6// ESCALATES it (leaves it NEW for the orchestrator tier: an LLM seat or the operator).
7// That escalation gate IS the router->orchestrator handoff from the blueprint. Being
8// DETERMINISTIC is the sovereign exceed over a probabilistic small-LLM router: identical
9// input always yields an identical verdict, gate-proven (T5), and never fabricates a lane
10// it cannot evidence (T3/T4 -- score 0 => escalate, never a guess).
11// The K3-mu / small-LLM classifier is a DROP-IN UPGRADE of the scoring function: same
12// journal, same TRIAGE-frame contract, same confidence gate (W032's remaining half).
13// Routing table row: <lane>\t<owner>\t<kw1,kw2,...> ('#' comment lines skipped)
14// Intake frame (nx_pm_intake contract): <ts>\t<VERB>\t<id>\t<actor>\t<text>
15// SCALE LAW: windowed reads + declared envelope (window_bytes/truncated/routes_capped);
16// scan is O(requests x lanes x keywords x textlen), bounded by the declared window.
17// license_tier: ORIGINAL No hw writes (Rule 26).
18// route <intake_journal> <lanes_config> -> JSON proposals (READ-ONLY)
19// run <intake_journal> <lanes_config> <actor> -> auto-triage HIGH, JSON summary
20// selftest <scratch-journal> -> gate T1..T8 (caller pre-cleans)
21import "nx_syscalls.nx"
22import "nx_gate_verdict.nx"
23const TR_MAGIC_4096: i64 = 4096
24const TR_MAGIC_2000: i64 = 2000
25const TR_MAGIC_4095: i64 = 4095
26const TR_MAGIC_1024: i64 = 1024
27const TR_MAGIC_5001: i64 = 5001
28const TR_MAGIC_5002: i64 = 5002
29const TR_MAGIC_5003: i64 = 5003
30const TR_MAGIC_5004: i64 = 5004
31
32const TR_WIN: i64 = 4194304
33const TR_CFG: i64 = 262144
34const TR_OUT: i64 = 262144
35const TR_SOFT: i64 = 49152
36const TR_LC: i64 = 4096
37const TR_NOTE: i64 = 512
38const TR_TEXT_MAX: i64 = 300
39const TR_NAME_MAX: i64 = 120
40// CONFIDENCE POLICY (router tier). HIGH = auto-advance; anything less escalates.
41// Residual: promote these two to routing-table policy rows so the policy is data too.
42const TR_MIN_SCORE: i64 = 2
43const TR_MARGIN: i64 = 2
44// EVAL policy: refuse to report an accuracy below this many labeled samples, and treat a
45// still-untriaged escalation older than this as ROTTING (nobody looked = a silent dead-end).
46const TR_MIN_SAMPLES: i64 = 5
47const TR_STALE_ESC: i64 = 172800
48
49func tr_cat(d: *u8, o: i64, s: *u8) -> i64 { var p: i64=o; var i: i64=0; while s[i]!=(0 as u8){ d[p]=s[i]; p=p+1; i=i+1 } return p }
50func tr_catn(d: *u8, o: i64, v: i64) -> i64 {
51 let t: *u8 = sys_mmap(28)
52 var m: i64 = v
53 var p: i64 = o
54 if m < 0 { d[p]=45 as u8; p=p+1; m=0-m }
55 var k: i64 = 0
56 if m == 0 { t[0]=48 as u8; k=1 }
57 while m > 0 { t[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
58 var i: i64 = 0
59 while i < k { d[p]=t[k-1-i]; p=p+1; i=i+1 }
60 return p
61}
62func tr_vlen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
63func tr_read(path: *u8, buf: *u8, cap: i64) -> i64 {
64 let fd: i64 = sys_openat_rd(path)
65 if fd < 0 { return 0 }
66 var n: i64 = 0
67 var go: i64 = 1
68 while go == 1 { let r: i64 = sys_read(fd, ((buf as i64)+n) as *u8, cap-n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap { go = 0 } }
69 sys_close(fd)
70 return n
71}
72// append a frame in the nx_pm_intake contract (note flattened at the boundary)
73func tr_append(journal: *u8, ts: i64, verb: *u8, id: i64, actor: *u8, note: *u8) -> i64 {
74 var t: i64 = ts
75 if t < 0 { t = sys_now_realtime_sec() }
76 let ln: *u8 = sys_mmap(TR_MAGIC_4096)
77 var o: i64 = 0
78 o = tr_catn(ln, o, t)
79 ln[o]=9 as u8; o=o+1
80 o = tr_cat(ln, o, verb)
81 ln[o]=9 as u8; o=o+1
82 o = tr_catn(ln, o, id)
83 ln[o]=9 as u8; o=o+1
84 o = tr_cat(ln, o, actor)
85 ln[o]=9 as u8; o=o+1
86 var i: i64 = 0
87 var used: i64 = 0
88 while note[i]!=(0 as u8) {
89 if used < TR_MAGIC_2000 {
90 let c: i64 = note[i] as i64
91 if c==9 { ln[o]=32 as u8; o=o+1 } else { if c==10 { ln[o]=32 as u8; o=o+1 } else { if c==13 { ln[o]=32 as u8; o=o+1 } else { ln[o]=c as u8; o=o+1 } } }
92 used = used + 1
93 }
94 i = i + 1
95 }
96 ln[o]=10 as u8; o=o+1
97 let fd: i64 = sys_openat_append(journal, 0x1a4)
98 if fd < 0 { return -1 }
99 sys_write(fd, ln, o)
100 sys_close(fd)
101 return 0
102}
103func tr_le(q: *u8, i: i64, n: i64) -> i64 {
104 var le: i64 = i
105 var s: i64 = 1
106 while s==1 { if le>=n { s=0 } else { if q[le]==(10 as u8){s=0} else {le=le+1} } }
107 return le
108}
109func tr_col(q: *u8, ls: i64, le: i64, c: i64, out: *i64) -> i64 {
110 var col: i64 = 0
111 var p: i64 = ls
112 while col < c {
113 var s: i64 = 1
114 while s == 1 { if p >= le { return 0 } if q[p]==(9 as u8) { s = 0 } else { p = p+1 } }
115 p = p + 1
116 col = col + 1
117 }
118 var e: i64 = p
119 var s2: i64 = 1
120 while s2 == 1 { if e >= le { s2 = 0 } else { if q[e]==(9 as u8) { s2 = 0 } else { e = e+1 } } }
121 out[0] = p
122 out[1] = e
123 return 1
124}
125func tr_lit_eq(q: *u8, s: i64, e: i64, lit: *u8) -> i64 {
126 var i: i64 = 0
127 while s+i < e { if lit[i]==(0 as u8) { return 0 } if q[s+i]!=lit[i] { return 0 } i=i+1 }
128 if lit[i]!=(0 as u8) { return 0 }
129 return 1
130}
131func tr_atoi(q: *u8, s: i64, e: i64) -> i64 {
132 var v: i64 = 0
133 var i: i64 = s
134 while i < e { let c: i64 = q[i] as i64; if c>=48 { if c<=57 { v = v*10 + (c-48) } } i=i+1 }
135 return v
136}
137// ---------- intake state derivation (nx_pm_intake contract, ported) ----------
138func tr_has_id(q: *u8, n: i64, verb: *u8, idv: i64) -> i64 {
139 let cv: *i64 = sys_mmap(16) as *i64
140 let ci: *i64 = sys_mmap(16) as *i64
141 var i: i64 = 0
142 while i < n {
143 let le: i64 = tr_le(q,i,n)
144 if tr_col(q,i,le,1,cv)==1 { if tr_lit_eq(q,cv[0],cv[1],verb)==1 {
145 if tr_col(q,i,le,2,ci)==1 { let v: i64 = tr_atoi(q,ci[0],ci[1]); if v==idv { return 1 } }
146 } }
147 i = le + 1
148 }
149 return 0
150}
151func tr_is_new(q: *u8, n: i64, idv: i64) -> i64 {
152 if tr_has_id(q,n,"REQ" as *u8,idv)==0 { return 0 }
153 if tr_has_id(q,n,"TRIAGE" as *u8,idv)==1 { return 0 }
154 if tr_has_id(q,n,"FILED" as *u8,idv)==1 { return 0 }
155 return 1
156}
157func tr_id_first(q: *u8, upto: i64, idv: i64) -> i64 {
158 let cv: *i64 = sys_mmap(16) as *i64
159 let ci: *i64 = sys_mmap(16) as *i64
160 var i: i64 = 0
161 while i < upto {
162 let le: i64 = tr_le(q,i,upto)
163 if tr_col(q,i,le,1,cv)==1 { if tr_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
164 if tr_col(q,i,le,2,ci)==1 { let v: i64 = tr_atoi(q,ci[0],ci[1]); if v==idv { return 0 } }
165 } }
166 i = le + 1
167 }
168 return 1
169}
170// ---------- the classifier ----------
171// lowercase-copy a span into lc; returns length
172func tr_lc_copy(q: *u8, s: i64, e: i64, lc: *u8) -> i64 {
173 var i: i64 = s
174 var tl: i64 = 0
175 var go: i64 = 1
176 while go == 1 {
177 if i >= e { go = 0 } else {
178 if tl >= TR_MAGIC_4095 { go = 0 } else {
179 let c: i64 = q[i] as i64
180 if c >= 65 { if c <= 90 { lc[tl] = (c+32) as u8 } else { lc[tl] = c as u8 } } else { lc[tl] = c as u8 }
181 tl = tl + 1
182 i = i + 1
183 }
184 }
185 }
186 return tl
187}
188// is keyword cfg[ks,ke) present as a substring of lc[0,tl)?
189func tr_has_kw(lc: *u8, tl: i64, cfg: *u8, ks: i64, ke: i64) -> i64 {
190 let kl: i64 = ke - ks
191 if kl <= 0 { return 0 }
192 var i: i64 = 0
193 while i + kl <= tl {
194 var miss: i64 = 0
195 var k: i64 = 0
196 while k < kl { if lc[i+k] != cfg[ks+k] { miss=1; k=kl } else { k=k+1 } }
197 if miss == 0 { return 1 }
198 i = i + 1
199 }
200 return 0
201}
202// score one routing-table line = number of its keywords present in the request text
203func tr_score_lane(lc: *u8, tl: i64, cfg: *u8, ls: i64, le: i64) -> i64 {
204 let cc: *i64 = sys_mmap(16) as *i64
205 if tr_col(cfg,ls,le,2,cc)==0 { return 0 }
206 let cs: i64 = cc[0]
207 let ce: i64 = cc[1]
208 var score: i64 = 0
209 var ks: i64 = cs
210 while ks < ce {
211 var ke: i64 = ks
212 var d: i64 = 1
213 while d == 1 { if ke >= ce { d=0 } else { if cfg[ke]==(44 as u8) { d=0 } else { ke=ke+1 } } }
214 if ke > ks { if tr_has_kw(lc,tl,cfg,ks,ke)==1 { score = score + 1 } }
215 ks = ke + 1
216 }
217 return score
218}
219// classify: out[0]=best_score out[1]=second_score out[2]=best_line_start out[3]=best_line_end
220func tr_route_one(cfg: *u8, cn: i64, lc: *u8, tl: i64, out: *i64) -> i64 {
221 out[0]=0
222 out[1]=0
223 out[2]=-1
224 out[3]=-1
225 var i: i64 = 0
226 while i < cn {
227 let le: i64 = tr_le(cfg,i,cn)
228 var skip: i64 = 0
229 if le <= i { skip = 1 }
230 if skip == 0 { if cfg[i]==(35 as u8) { skip = 1 } }
231 if skip == 0 {
232 let sc: i64 = tr_score_lane(lc,tl,cfg,i,le)
233 if sc > out[0] { out[1]=out[0]; out[0]=sc; out[2]=i; out[3]=le } else { if sc > out[1] { out[1]=sc } }
234 }
235 i = le + 1
236 }
237 return out[0]
238}
239// confidence: 2 HIGH (auto-advance) / 1 MEDIUM / 0 ESCALATE
240func tr_conf(best: i64, second: i64) -> i64 {
241 if best >= TR_MIN_SCORE {
242 if best - second >= TR_MARGIN { return 2 }
243 return 1
244 }
245 return 0
246}
247func tr_conf_name(c: i64) -> *u8 {
248 if c==2 { return "high" as *u8 }
249 if c==1 { return "medium" as *u8 }
250 return "escalate" as *u8
251}
252// ---------- EVAL: the router grades ITSELF against downstream ground truth ----------
253// A router that cannot be measured cannot be improved, and cannot be replaced on evidence.
254// GROUND TRUTH = what a human/LLM seat actually FILED the request under. We compare that to
255// what the router PROPOSED. Only AUTO-ROUTED decisions are graded (a human's own triage is
256// not the router's work), and only once a FILED frame exists (unlabeled = not counted).
257// Below TR_MIN_SAMPLES the accuracy is REFUSED (-1 + insufficient_samples) rather than
258// reported from noise -- an honest -1 beats a confident number built on n=2.
259// index of literal lit inside [s,e), or -1
260func tr_find_span(q: *u8, s: i64, e: i64, lit: *u8) -> i64 {
261 let ll: i64 = tr_vlen(lit)
262 if ll <= 0 { return -1 }
263 var i: i64 = s
264 while i + ll <= e {
265 var k: i64 = 0
266 var ok: i64 = 1
267 while k < ll { if q[i+k]!=lit[k] { ok=0; k=ll } else { k=k+1 } }
268 if ok==1 { return i }
269 i = i + 1
270 }
271 return -1
272}
273// does span [aS,aE) occur inside span [bS,bE) of the same buffer?
274func tr_span_in_span(q: *u8, aS: i64, aE: i64, bS: i64, bE: i64) -> i64 {
275 let al: i64 = aE - aS
276 if al <= 0 { return 0 }
277 var i: i64 = bS
278 while i + al <= bE {
279 var k: i64 = 0
280 var ok: i64 = 1
281 while k < al { if q[i+k]!=q[aS+k] { ok=0; k=al } else { k=k+1 } }
282 if ok==1 { return 1 }
283 i = i + 1
284 }
285 return 0
286}
287// the lane the ROUTER proposed for id: parse "lane=<x> " out of an AUTO-ROUTED TRIAGE note.
288// returns 1 + out span; 0 if there is no auto-routed triage for that id.
289func tr_routed_lane(q: *u8, n: i64, idv: i64, out: *i64) -> i64 {
290 let sp: *i64 = sys_mmap(16) as *i64
291 if tr_text_span(q,n,"TRIAGE" as *u8,idv,sp)==0 { return 0 }
292 if tr_find_span(q,sp[0],sp[1],"AUTO-ROUTED" as *u8) < 0 { return 0 }
293 let at: i64 = tr_find_span(q,sp[0],sp[1],"lane=" as *u8)
294 if at < 0 { return 0 }
295 let ls: i64 = at + 5
296 var le: i64 = ls
297 var go: i64 = 1
298 while go == 1 { if le >= sp[1] { go = 0 } else { if q[le]==(32 as u8) { go = 0 } else { le = le + 1 } } }
299 if le <= ls { return 0 }
300 out[0] = ls
301 out[1] = le
302 return 1
303}
304// ex[0]=auto ex[1]=escalated ex[2]=labeled ex[3]=agree ex[4]=disagree
305// ex[5]=stale_escalations ex[6]=accuracy_permille(-1 if refused) ex[7]=insufficient
306func tr_eval(q: *u8, n: i64, now: i64, stale_sec: i64, ex: *i64) -> i64 {
307 var i: i64 = 0
308 while i < 8 { ex[i]=0; i=i+1 }
309 let cv: *i64 = sys_mmap(16) as *i64
310 let ci: *i64 = sys_mmap(16) as *i64
311 let c0: *i64 = sys_mmap(16) as *i64
312 let ln: *i64 = sys_mmap(16) as *i64
313 let fs: *i64 = sys_mmap(16) as *i64
314 var j: i64 = 0
315 while j < n {
316 let le: i64 = tr_le(q,j,n)
317 if tr_col(q,j,le,1,cv)==1 { if tr_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
318 if tr_col(q,j,le,2,ci)==1 {
319 let idv: i64 = tr_atoi(q,ci[0],ci[1])
320 if tr_id_first(q,j,idv)==1 {
321 let routed: i64 = tr_routed_lane(q,n,idv,ln)
322 if routed==1 { ex[0] = ex[0] + 1 }
323 if tr_is_new(q,n,idv)==1 {
324 ex[1] = ex[1] + 1
325 if tr_col(q,j,le,0,c0)==1 {
326 let ts: i64 = tr_atoi(q,c0[0],c0[1])
327 if now - ts > stale_sec { ex[5] = ex[5] + 1 }
328 }
329 }
330 if routed==1 { if tr_text_span(q,n,"FILED" as *u8,idv,fs)==1 {
331 ex[2] = ex[2] + 1
332 if tr_span_in_span(q,ln[0],ln[1],fs[0],fs[1])==1 { ex[3] = ex[3] + 1 } else { ex[4] = ex[4] + 1 }
333 } }
334 }
335 }
336 } }
337 j = le + 1
338 }
339 ex[6] = -1
340 ex[7] = 1
341 if ex[2] >= TR_MIN_SAMPLES { ex[7] = 0; ex[6] = (ex[3] * 1000) / ex[2] }
342 return ex[2]
343}
344
345// ---------- emit ----------
346func tr_jesc(d: *u8, o: i64, q: *u8, s: i64, e: i64, maxb: i64) -> i64 {
347 var p: i64 = o
348 var i: i64 = s
349 var used: i64 = 0
350 while i < e {
351 if used >= maxb { i = e } else {
352 let c: i64 = q[i] as i64
353 if c == 34 { d[p]=92 as u8; p=p+1; d[p]=34 as u8; p=p+1 } else { if c == 92 { d[p]=92 as u8; p=p+1; d[p]=92 as u8; p=p+1 } else { if c < 32 { d[p]=32 as u8; p=p+1 } else { d[p]=c as u8; p=p+1 } } }
354 used = used + 2
355 i = i + 1
356 }
357 }
358 return p
359}
360func tr_key(d: *u8, o: i64, name: *u8) -> i64 {
361 d[o]=34 as u8
362 var p: i64 = o + 1
363 p = tr_cat(d,p,name)
364 d[p]=34 as u8
365 p = p + 1
366 d[p]=58 as u8
367 p = p + 1
368 return p
369}
370func tr_qlit(d: *u8, o: i64, s: *u8) -> i64 {
371 var p: i64 = o
372 d[p]=34 as u8; p=p+1
373 p = tr_cat(d,p,s)
374 d[p]=34 as u8; p=p+1
375 return p
376}
377// latest text of a verb frame for id
378func tr_text_span(q: *u8, n: i64, verb: *u8, idv: i64, out: *i64) -> i64 {
379 let cv: *i64 = sys_mmap(16) as *i64
380 let ci: *i64 = sys_mmap(16) as *i64
381 let ct: *i64 = sys_mmap(16) as *i64
382 var ts: i64 = -1
383 var te: i64 = -1
384 var i: i64 = 0
385 while i < n {
386 let le: i64 = tr_le(q,i,n)
387 if tr_col(q,i,le,1,cv)==1 { if tr_lit_eq(q,cv[0],cv[1],verb)==1 {
388 if tr_col(q,i,le,2,ci)==1 { let v: i64 = tr_atoi(q,ci[0],ci[1]); if v==idv {
389 if tr_col(q,i,le,4,ct)==1 { ts=ct[0]; te=ct[1] }
390 } }
391 } }
392 i = le + 1
393 }
394 if ts >= 0 { out[0]=ts; out[1]=te; return 1 }
395 return 0
396}
397// build the TRIAGE note for an auto-routed request
398func tr_build_note(nb: *u8, cfg: *u8, lane_s: i64, lane_e: i64, own_s: i64, own_e: i64, score: i64) -> i64 {
399 var p: i64 = 0
400 p = tr_cat(nb,p,"AUTO-ROUTED lane=" as *u8)
401 var i: i64 = lane_s
402 while i < lane_e { nb[p]=cfg[i]; p=p+1; i=i+1 }
403 p = tr_cat(nb,p," owner=" as *u8)
404 var j: i64 = own_s
405 while j < own_e { nb[p]=cfg[j]; p=p+1; j=j+1 }
406 p = tr_cat(nb,p," score=" as *u8)
407 p = tr_catn(nb,p,score)
408 p = tr_cat(nb,p," confidence=high (nx_triage router tier, deterministic; confirm or file via seat/operator)" as *u8)
409 nb[p]=0 as u8
410 return p
411}
412// ROUTE (read-only): JSON proposal per NEW request
413func tr_route_json(q: *u8, n: i64, cfg: *u8, cn: i64, jp: *u8, cp: *u8, truncated: i64, d: *u8) -> i64 {
414 var p: i64 = 0
415 d[p]=123 as u8; p=p+1
416 p = tr_key(d,p,"v" as *u8)
417 p = tr_catn(d,p,1)
418 d[p]=44 as u8; p=p+1
419 p = tr_key(d,p,"tool" as *u8)
420 p = tr_qlit(d,p,"nx_triage" as *u8)
421 d[p]=44 as u8; p=p+1
422 p = tr_key(d,p,"tier" as *u8)
423 p = tr_qlit(d,p,"router-deterministic" as *u8)
424 d[p]=44 as u8; p=p+1
425 p = tr_key(d,p,"intake_journal" as *u8)
426 d[p]=34 as u8; p=p+1
427 p = tr_jesc(d,p,jp,0,tr_vlen(jp),200)
428 d[p]=34 as u8; p=p+1
429 d[p]=44 as u8; p=p+1
430 p = tr_key(d,p,"lanes_config" as *u8)
431 d[p]=34 as u8; p=p+1
432 p = tr_jesc(d,p,cp,0,tr_vlen(cp),200)
433 d[p]=34 as u8; p=p+1
434 d[p]=44 as u8; p=p+1
435 p = tr_key(d,p,"journal_bytes" as *u8)
436 p = tr_catn(d,p,n)
437 d[p]=44 as u8; p=p+1
438 p = tr_key(d,p,"config_bytes" as *u8)
439 p = tr_catn(d,p,cn)
440 d[p]=44 as u8; p=p+1
441 p = tr_key(d,p,"window_bytes" as *u8)
442 p = tr_catn(d,p,TR_WIN)
443 d[p]=44 as u8; p=p+1
444 p = tr_key(d,p,"truncated" as *u8)
445 p = tr_catn(d,p,truncated)
446 d[p]=44 as u8; p=p+1
447 p = tr_key(d,p,"min_score" as *u8)
448 p = tr_catn(d,p,TR_MIN_SCORE)
449 d[p]=44 as u8; p=p+1
450 p = tr_key(d,p,"margin" as *u8)
451 p = tr_catn(d,p,TR_MARGIN)
452 d[p]=44 as u8; p=p+1
453 // pass 1: totals
454 let cv: *i64 = sys_mmap(16) as *i64
455 let ci: *i64 = sys_mmap(16) as *i64
456 let sp: *i64 = sys_mmap(16) as *i64
457 let out: *i64 = sys_mmap(64) as *i64
458 let lc: *u8 = sys_mmap(TR_LC)
459 var tnew: i64 = 0
460 var thigh: i64 = 0
461 var tesc: i64 = 0
462 var i: i64 = 0
463 while i < n {
464 let le: i64 = tr_le(q,i,n)
465 if tr_col(q,i,le,1,cv)==1 { if tr_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
466 if tr_col(q,i,le,2,ci)==1 {
467 let idv: i64 = tr_atoi(q,ci[0],ci[1])
468 if tr_id_first(q,i,idv)==1 { if tr_is_new(q,n,idv)==1 {
469 tnew = tnew + 1
470 if tr_text_span(q,n,"REQ" as *u8,idv,sp)==1 {
471 let tl: i64 = tr_lc_copy(q,sp[0],sp[1],lc)
472 tr_route_one(cfg,cn,lc,tl,out)
473 let cf: i64 = tr_conf(out[0],out[1])
474 if cf==2 { thigh = thigh + 1 } else { tesc = tesc + 1 }
475 }
476 } }
477 }
478 } }
479 i = le + 1
480 }
481 p = tr_key(d,p,"totals" as *u8)
482 d[p]=123 as u8; p=p+1
483 p = tr_key(d,p,"new" as *u8)
484 p = tr_catn(d,p,tnew)
485 d[p]=44 as u8; p=p+1
486 p = tr_key(d,p,"high" as *u8)
487 p = tr_catn(d,p,thigh)
488 d[p]=44 as u8; p=p+1
489 p = tr_key(d,p,"escalate" as *u8)
490 p = tr_catn(d,p,tesc)
491 d[p]=125 as u8; p=p+1
492 d[p]=44 as u8; p=p+1
493 // pass 2: the routes
494 p = tr_key(d,p,"routes" as *u8)
495 d[p]=91 as u8; p=p+1
496 let ls: *i64 = sys_mmap(16) as *i64
497 let os: *i64 = sys_mmap(16) as *i64
498 var capped: i64 = 0
499 var first: i64 = 1
500 var j: i64 = 0
501 while j < n {
502 let je: i64 = tr_le(q,j,n)
503 if tr_col(q,j,je,1,cv)==1 { if tr_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
504 if tr_col(q,j,je,2,ci)==1 {
505 let idv2: i64 = tr_atoi(q,ci[0],ci[1])
506 if tr_id_first(q,j,idv2)==1 { if tr_is_new(q,n,idv2)==1 {
507 if p > TR_SOFT { capped=1 } else {
508 if first==0 { d[p]=44 as u8; p=p+1 }
509 first=0
510 d[p]=123 as u8; p=p+1
511 p = tr_key(d,p,"id" as *u8)
512 p = tr_catn(d,p,idv2)
513 d[p]=44 as u8; p=p+1
514 var best: i64 = 0
515 var second: i64 = 0
516 var haslane: i64 = 0
517 if tr_text_span(q,n,"REQ" as *u8,idv2,sp)==1 {
518 let tl2: i64 = tr_lc_copy(q,sp[0],sp[1],lc)
519 tr_route_one(cfg,cn,lc,tl2,out)
520 best = out[0]
521 second = out[1]
522 if out[2] >= 0 { haslane = 1 }
523 }
524 p = tr_key(d,p,"best_lane" as *u8)
525 d[p]=34 as u8; p=p+1
526 if haslane==1 { if tr_col(cfg,out[2],out[3],0,ls)==1 { p = tr_jesc(d,p,cfg,ls[0],ls[1],TR_NAME_MAX) } }
527 d[p]=34 as u8; p=p+1
528 d[p]=44 as u8; p=p+1
529 p = tr_key(d,p,"owner" as *u8)
530 d[p]=34 as u8; p=p+1
531 if haslane==1 { if tr_col(cfg,out[2],out[3],1,os)==1 { p = tr_jesc(d,p,cfg,os[0],os[1],TR_NAME_MAX) } }
532 d[p]=34 as u8; p=p+1
533 d[p]=44 as u8; p=p+1
534 p = tr_key(d,p,"score" as *u8)
535 p = tr_catn(d,p,best)
536 d[p]=44 as u8; p=p+1
537 p = tr_key(d,p,"second" as *u8)
538 p = tr_catn(d,p,second)
539 d[p]=44 as u8; p=p+1
540 let cf2: i64 = tr_conf(best,second)
541 p = tr_key(d,p,"confidence" as *u8)
542 let cn2: *u8 = tr_conf_name(cf2)
543 p = tr_qlit(d,p,cn2)
544 d[p]=44 as u8; p=p+1
545 p = tr_key(d,p,"auto_advance" as *u8)
546 var aa: i64 = 0
547 if cf2==2 { aa = 1 }
548 p = tr_catn(d,p,aa)
549 d[p]=44 as u8; p=p+1
550 p = tr_key(d,p,"request" as *u8)
551 d[p]=34 as u8; p=p+1
552 if tr_text_span(q,n,"REQ" as *u8,idv2,sp)==1 { p = tr_jesc(d,p,q,sp[0],sp[1],TR_TEXT_MAX) }
553 d[p]=34 as u8; p=p+1
554 d[p]=125 as u8; p=p+1
555 }
556 } }
557 }
558 } }
559 j = je + 1
560 }
561 d[p]=93 as u8; p=p+1
562 d[p]=44 as u8; p=p+1
563 p = tr_key(d,p,"routes_capped" as *u8)
564 p = tr_catn(d,p,capped)
565 d[p]=125 as u8; p=p+1
566 d[p]=10 as u8; p=p+1
567 return p
568}
569// RUN: auto-advance every HIGH-confidence NEW request; returns count acted
570func tr_run(journal: *u8, q: *u8, n: i64, cfg: *u8, cn: i64, actor: *u8) -> i64 {
571 let cv: *i64 = sys_mmap(16) as *i64
572 let ci: *i64 = sys_mmap(16) as *i64
573 let sp: *i64 = sys_mmap(16) as *i64
574 let out: *i64 = sys_mmap(64) as *i64
575 let ls: *i64 = sys_mmap(16) as *i64
576 let os: *i64 = sys_mmap(16) as *i64
577 let lc: *u8 = sys_mmap(TR_LC)
578 let nb: *u8 = sys_mmap(TR_NOTE)
579 var acted: i64 = 0
580 var i: i64 = 0
581 while i < n {
582 let le: i64 = tr_le(q,i,n)
583 if tr_col(q,i,le,1,cv)==1 { if tr_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
584 if tr_col(q,i,le,2,ci)==1 {
585 let idv: i64 = tr_atoi(q,ci[0],ci[1])
586 if tr_id_first(q,i,idv)==1 { if tr_is_new(q,n,idv)==1 {
587 if tr_text_span(q,n,"REQ" as *u8,idv,sp)==1 {
588 let tl: i64 = tr_lc_copy(q,sp[0],sp[1],lc)
589 tr_route_one(cfg,cn,lc,tl,out)
590 let cf: i64 = tr_conf(out[0],out[1])
591 if cf == 2 { if out[2] >= 0 {
592 if tr_col(cfg,out[2],out[3],0,ls)==1 { if tr_col(cfg,out[2],out[3],1,os)==1 {
593 tr_build_note(nb,cfg,ls[0],ls[1],os[0],os[1],out[0])
594 let rc: i64 = tr_append(journal,-1,"TRIAGE" as *u8,idv,actor,nb)
595 if rc==0 { acted = acted + 1 }
596 } }
597 } }
598 }
599 } }
600 }
601 } }
602 i = le + 1
603 }
604 return acted
605}
606func tr_find(d: *u8, dn: i64, lit: *u8) -> i64 {
607 let ll: i64 = tr_vlen(lit)
608 if ll == 0 { return 0 }
609 var i: i64 = 0
610 while i + ll <= dn {
611 var k: i64 = 0
612 var ok: i64 = 1
613 while k < ll { if d[i+k]!=lit[k] { ok=0; k=ll } else { k=k+1 } }
614 if ok==1 { return 1 }
615 i = i + 1
616 }
617 return 0
618}
619// build "<journal>.lanes" for the selftest scratch config
620func tr_mkcfgpath(dst: *u8, src: *u8) -> i64 {
621 var p: i64 = 0
622 p = tr_cat(dst,p,src)
623 p = tr_cat(dst,p,".lanes" as *u8)
624 dst[p]=0 as u8
625 return p
626}
627func tr_write_file(path: *u8, body: *u8) -> i64 {
628 let fd: i64 = sys_openat_wr(path, 0x1a4)
629 if fd < 0 { return -1 }
630 let n: i64 = tr_vlen(body)
631 sys_write(fd, body, n)
632 sys_close(fd)
633 return 0
634}
635// count NEW requests in an intake journal
636func tr_count_new(q: *u8, n: i64) -> i64 {
637 let cv: *i64 = sys_mmap(16) as *i64
638 let ci: *i64 = sys_mmap(16) as *i64
639 var c: i64 = 0
640 var i: i64 = 0
641 while i < n {
642 let le: i64 = tr_le(q,i,n)
643 if tr_col(q,i,le,1,cv)==1 { if tr_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
644 if tr_col(q,i,le,2,ci)==1 {
645 let idv: i64 = tr_atoi(q,ci[0],ci[1])
646 if tr_id_first(q,i,idv)==1 { if tr_is_new(q,n,idv)==1 { c = c + 1 } }
647 }
648 } }
649 i = le + 1
650 }
651 return c
652}
653
654// ---------- selftest gate (T1..T8, deterministic) ----------
655func tr_selftest(journal: *u8) -> i64 {
656 let ctr: *i64 = gv_ctr()
657 gv_head("nx_triage selftest -- router-tier classification teeth (caller pre-cleans journal)" as *u8)
658 let q: *u8 = sys_mmap(TR_WIN)
659 let cfgb: *u8 = sys_mmap(TR_CFG)
660 let lc: *u8 = sys_mmap(TR_LC)
661 let out: *i64 = sys_mmap(64) as *i64
662 let out2: *i64 = sys_mmap(64) as *i64
663 let ls: *i64 = sys_mmap(16) as *i64
664 let cfgpath: *u8 = sys_mmap(TR_MAGIC_1024)
665 let rcap: i64 = TR_WIN - 8
666 tr_mkcfgpath(cfgpath, journal)
667 // T1 empty intake -> zero NEW, no fabrication
668 var n: i64 = tr_read(journal,q,rcap)
669 var ok1: i64 = 0
670 if n==0 { if tr_count_new(q,n)==0 { ok1=1 } }
671 gv_check("T1 empty intake zero NEW no fabrication" as *u8, ok1, ctr)
672 // seed the scratch routing table + requests
673 tr_write_file(cfgpath, "# scratch routing table\nreliab\tsuper\tclock,health,silent\ntoolz\tward\tregister,promote,mint\n" as *u8)
674 let cn: i64 = tr_read(cfgpath,cfgb,TR_CFG-8)
675 tr_append(journal, TR_MAGIC_5001, "REQ" as *u8, TR_MAGIC_5001, "seatA" as *u8, "the clock health job is silent and failing every tick" as *u8)
676 tr_append(journal, TR_MAGIC_5002, "REQ" as *u8, TR_MAGIC_5002, "seatB" as *u8, "please register and promote and mint the new tool" as *u8)
677 tr_append(journal, TR_MAGIC_5003, "REQ" as *u8, TR_MAGIC_5003, "seatC" as *u8, "something totally unrelated banana" as *u8)
678 tr_append(journal, TR_MAGIC_5004, "REQ" as *u8, TR_MAGIC_5004, "seatD" as *u8, "clock register" as *u8)
679 n = tr_read(journal,q,rcap)
680 // T2 clear signal routes HIGH to the right lane
681 let sp: *i64 = sys_mmap(16) as *i64
682 var ok2: i64 = 0
683 if tr_text_span(q,n,"REQ" as *u8,TR_MAGIC_5001,sp)==1 {
684 let tl: i64 = tr_lc_copy(q,sp[0],sp[1],lc)
685 tr_route_one(cfgb,cn,lc,tl,out)
686 if out[0]==3 { if tr_conf(out[0],out[1])==2 {
687 if tr_col(cfgb,out[2],out[3],0,ls)==1 { if tr_lit_eq(cfgb,ls[0],ls[1],"reliab" as *u8)==1 { ok2=1 } }
688 } }
689 }
690 gv_check("T2 clear signal routes HIGH to correct lane" as *u8, ok2, ctr)
691 // T3 no signal -> score 0, escalate, NO fabricated lane
692 var ok3: i64 = 0
693 if tr_text_span(q,n,"REQ" as *u8,TR_MAGIC_5003,sp)==1 {
694 let tl3: i64 = tr_lc_copy(q,sp[0],sp[1],lc)
695 tr_route_one(cfgb,cn,lc,tl3,out)
696 if out[0]==0 { if out[2]==(0-1) { if tr_conf(out[0],out[1])==0 { ok3=1 } } }
697 }
698 gv_check("T3 no signal escalates with no fabricated lane" as *u8, ok3, ctr)
699 // T4 ambiguous tie -> below threshold/margin -> escalate (never a coin-flip verdict)
700 var ok4: i64 = 0
701 if tr_text_span(q,n,"REQ" as *u8,TR_MAGIC_5004,sp)==1 {
702 let tl4: i64 = tr_lc_copy(q,sp[0],sp[1],lc)
703 tr_route_one(cfgb,cn,lc,tl4,out)
704 if out[0]==1 { if out[1]==1 { if tr_conf(out[0],out[1])==0 { ok4=1 } } }
705 }
706 gv_check("T4 ambiguous tie escalates never coin-flips" as *u8, ok4, ctr)
707 // T5 DETERMINISM (the sovereign exceed): identical input -> identical verdict
708 var ok5: i64 = 0
709 if tr_text_span(q,n,"REQ" as *u8,TR_MAGIC_5001,sp)==1 {
710 let tl5: i64 = tr_lc_copy(q,sp[0],sp[1],lc)
711 tr_route_one(cfgb,cn,lc,tl5,out)
712 let tl6: i64 = tr_lc_copy(q,sp[0],sp[1],lc)
713 tr_route_one(cfgb,cn,lc,tl6,out2)
714 if out[0]==out2[0] { if out[1]==out2[1] { if out[2]==out2[2] { ok5=1 } } }
715 }
716 gv_check("T5 deterministic identical input identical verdict" as *u8, ok5, ctr)
717 // T6 run auto-advances the two HIGH, leaves escalated ones NEW
718 let acted: i64 = tr_run(journal,q,n,cfgb,cn,"nx_triage_test" as *u8)
719 n = tr_read(journal,q,rcap)
720 var ok6: i64 = 0
721 if acted==2 { if tr_is_new(q,n,TR_MAGIC_5001)==0 { if tr_is_new(q,n,TR_MAGIC_5003)==1 { if tr_is_new(q,n,TR_MAGIC_5004)==1 { ok6=1 } } } }
722 gv_check("T6 run advances HIGH only leaves escalated NEW" as *u8, ok6, ctr)
723 // T7 IDEMPOTENCE neg-control: a second run acts on nothing
724 let acted2: i64 = tr_run(journal,q,n,cfgb,cn,"nx_triage_test" as *u8)
725 var ok7: i64 = 0
726 if acted2==0 { ok7=1 }
727 gv_check("T7 neg-control second run acts on nothing" as *u8, ok7, ctr)
728 // T8 route JSON carries totals + policy + declared envelope
729 let d: *u8 = sys_mmap(TR_OUT)
730 let dl: i64 = tr_route_json(q,n,cfgb,cn,journal,cfgpath,0,d)
731 var ok8: i64 = 0
732 if dl > 0 { if d[0]==(123 as u8) { if tr_find(d,dl,"routes_capped" as *u8)==1 { if tr_find(d,dl,"min_score" as *u8)==1 { if tr_find(d,dl,"escalate" as *u8)==1 { ok8=1 } } } } }
733 gv_check("T8 route JSON carries totals policy envelope" as *u8, ok8, ctr)
734 let rc: i64 = gv_verdict("TRIAGE-GATE" as *u8, ctr, "router tier deterministic classification green" as *u8)
735 return rc
736}
737
738func main(argc: i64, argv: *i64) -> i64 {
739 if argc < 3 { gv_puts("usage: nx_triage {route <intake_journal> <lanes_config> | run <intake_journal> <lanes_config> <actor> | selftest <journal>}\n" as *u8); sys_exit(2); return 2 }
740 let verb: *u8 = argv[1] as *u8
741 let journal: *u8 = argv[2] as *u8
742 let vl: i64 = tr_vlen(verb)
743 if tr_lit_eq(verb,0,vl,"selftest" as *u8)==1 { let rc: i64 = tr_selftest(journal); sys_exit(rc); return rc }
744 // eval needs ONLY the journal (no routing table) -- handled before the route|run arg guard
745 if tr_lit_eq(verb,0,vl,"eval" as *u8)==1 {
746 let qe: *u8 = sys_mmap(TR_WIN)
747 let rcape: i64 = TR_WIN - 8
748 let ne: i64 = tr_read(journal,qe,rcape)
749 var trunce: i64 = 0
750 if ne >= rcape { trunce = 1 }
751 let ex: *i64 = sys_mmap(128) as *i64
752 let nowe: i64 = sys_now_realtime_sec()
753 tr_eval(qe,ne,nowe,TR_STALE_ESC,ex)
754 let de: *u8 = sys_mmap(TR_OUT)
755 var p: i64 = 0
756 de[p]=123 as u8; p=p+1
757 p = tr_key(de,p,"tool" as *u8)
758 p = tr_qlit(de,p,"nx_triage" as *u8)
759 de[p]=44 as u8; p=p+1
760 p = tr_key(de,p,"mode" as *u8)
761 p = tr_qlit(de,p,"eval" as *u8)
762 de[p]=44 as u8; p=p+1
763 p = tr_key(de,p,"auto_routed" as *u8)
764 p = tr_catn(de,p,ex[0])
765 de[p]=44 as u8; p=p+1
766 p = tr_key(de,p,"still_escalated" as *u8)
767 p = tr_catn(de,p,ex[1])
768 de[p]=44 as u8; p=p+1
769 p = tr_key(de,p,"labeled_samples" as *u8)
770 p = tr_catn(de,p,ex[2])
771 de[p]=44 as u8; p=p+1
772 p = tr_key(de,p,"agree" as *u8)
773 p = tr_catn(de,p,ex[3])
774 de[p]=44 as u8; p=p+1
775 p = tr_key(de,p,"disagree" as *u8)
776 p = tr_catn(de,p,ex[4])
777 de[p]=44 as u8; p=p+1
778 p = tr_key(de,p,"accuracy_permille" as *u8)
779 p = tr_catn(de,p,ex[6])
780 de[p]=44 as u8; p=p+1
781 p = tr_key(de,p,"insufficient_samples" as *u8)
782 p = tr_catn(de,p,ex[7])
783 de[p]=44 as u8; p=p+1
784 p = tr_key(de,p,"min_samples" as *u8)
785 p = tr_catn(de,p,TR_MIN_SAMPLES)
786 de[p]=44 as u8; p=p+1
787 p = tr_key(de,p,"stale_escalations" as *u8)
788 p = tr_catn(de,p,ex[5])
789 de[p]=44 as u8; p=p+1
790 p = tr_key(de,p,"stale_after_sec" as *u8)
791 p = tr_catn(de,p,TR_STALE_ESC)
792 de[p]=44 as u8; p=p+1
793 p = tr_key(de,p,"journal_bytes" as *u8)
794 p = tr_catn(de,p,ne)
795 de[p]=44 as u8; p=p+1
796 p = tr_key(de,p,"window_bytes" as *u8)
797 p = tr_catn(de,p,TR_WIN)
798 de[p]=44 as u8; p=p+1
799 p = tr_key(de,p,"truncated" as *u8)
800 p = tr_catn(de,p,trunce)
801 de[p]=44 as u8; p=p+1
802 p = tr_key(de,p,"note" as *u8)
803 p = tr_qlit(de,p,"ground truth = the lane a seat/human actually FILED under; only AUTO-ROUTED decisions are graded; accuracy REFUSED (-1) below min_samples rather than reported from noise; stale_escalations = router escalations nobody triaged = silent dead-ends" as *u8)
804 de[p]=125 as u8; p=p+1
805 de[p]=10 as u8; p=p+1
806 sys_write(1,de,p)
807 sys_exit(0)
808 return 0
809 }
810 if argc < 4 { gv_puts("route|run need <intake_journal> <lanes_config>\n" as *u8); sys_exit(2); return 2 }
811 let cfgpath: *u8 = argv[3] as *u8
812 let q: *u8 = sys_mmap(TR_WIN)
813 let rcap: i64 = TR_WIN - 8
814 let n: i64 = tr_read(journal,q,rcap)
815 var truncated: i64 = 0
816 if n >= rcap { truncated = 1 }
817 let cfgb: *u8 = sys_mmap(TR_CFG)
818 let cn: i64 = tr_read(cfgpath,cfgb,TR_CFG-8)
819 if cn == 0 { gv_puts("NX-TRIAGE NO-ROUTING-TABLE (fail-closed, nothing routed)\n" as *u8); sys_exit(3); return 3 }
820 if tr_lit_eq(verb,0,vl,"route" as *u8)==1 {
821 let d: *u8 = sys_mmap(TR_OUT)
822 let dl: i64 = tr_route_json(q,n,cfgb,cn,journal,cfgpath,truncated,d)
823 sys_write(1,d,dl)
824 sys_exit(0)
825 return 0
826 }
827 if tr_lit_eq(verb,0,vl,"eval" as *u8)==1 {
828 let ex: *i64 = sys_mmap(128) as *i64
829 let nowe: i64 = sys_now_realtime_sec()
830 tr_eval(q,n,nowe,TR_STALE_ESC,ex)
831 let d: *u8 = sys_mmap(TR_OUT)
832 var p: i64 = 0
833 d[p]=123 as u8; p=p+1
834 p = tr_key(d,p,"tool" as *u8)
835 p = tr_qlit(d,p,"nx_triage" as *u8)
836 d[p]=44 as u8; p=p+1
837 p = tr_key(d,p,"mode" as *u8)
838 p = tr_qlit(d,p,"eval" as *u8)
839 d[p]=44 as u8; p=p+1
840 p = tr_key(d,p,"auto_routed" as *u8)
841 p = tr_catn(d,p,ex[0])
842 d[p]=44 as u8; p=p+1
843 p = tr_key(d,p,"still_escalated" as *u8)
844 p = tr_catn(d,p,ex[1])
845 d[p]=44 as u8; p=p+1
846 p = tr_key(d,p,"labeled_samples" as *u8)
847 p = tr_catn(d,p,ex[2])
848 d[p]=44 as u8; p=p+1
849 p = tr_key(d,p,"agree" as *u8)
850 p = tr_catn(d,p,ex[3])
851 d[p]=44 as u8; p=p+1
852 p = tr_key(d,p,"disagree" as *u8)
853 p = tr_catn(d,p,ex[4])
854 d[p]=44 as u8; p=p+1
855 p = tr_key(d,p,"accuracy_permille" as *u8)
856 p = tr_catn(d,p,ex[6])
857 d[p]=44 as u8; p=p+1
858 p = tr_key(d,p,"insufficient_samples" as *u8)
859 p = tr_catn(d,p,ex[7])
860 d[p]=44 as u8; p=p+1
861 p = tr_key(d,p,"min_samples" as *u8)
862 p = tr_catn(d,p,TR_MIN_SAMPLES)
863 d[p]=44 as u8; p=p+1
864 p = tr_key(d,p,"stale_escalations" as *u8)
865 p = tr_catn(d,p,ex[5])
866 d[p]=44 as u8; p=p+1
867 p = tr_key(d,p,"stale_after_sec" as *u8)
868 p = tr_catn(d,p,TR_STALE_ESC)
869 d[p]=44 as u8; p=p+1
870 p = tr_key(d,p,"window_bytes" as *u8)
871 p = tr_catn(d,p,TR_WIN)
872 d[p]=44 as u8; p=p+1
873 p = tr_key(d,p,"truncated" as *u8)
874 p = tr_catn(d,p,truncated)
875 d[p]=44 as u8; p=p+1
876 p = tr_key(d,p,"note" as *u8)
877 p = tr_qlit(d,p,"ground truth = the lane a seat/human actually FILED under; only AUTO-ROUTED decisions are graded; accuracy is REFUSED (-1) below min_samples rather than reported from noise; stale_escalations = router escalations nobody has triaged = silent dead-ends" as *u8)
878 d[p]=125 as u8; p=p+1
879 d[p]=10 as u8; p=p+1
880 sys_write(1,d,p)
881 sys_exit(0)
882 return 0
883 }
884 if tr_lit_eq(verb,0,vl,"run" as *u8)==1 {
885 if argc < 5 { gv_puts("run needs <intake_journal> <lanes_config> <actor>\n" as *u8); sys_exit(2); return 2 }
886 let actor: *u8 = argv[4] as *u8
887 let before: i64 = tr_count_new(q,n)
888 let acted: i64 = tr_run(journal,q,n,cfgb,cn,actor)
889 let d: *u8 = sys_mmap(TR_OUT)
890 var p: i64 = 0
891 d[p]=123 as u8; p=p+1
892 p = tr_key(d,p,"tool" as *u8)
893 p = tr_qlit(d,p,"nx_triage" as *u8)
894 d[p]=44 as u8; p=p+1
895 p = tr_key(d,p,"mode" as *u8)
896 p = tr_qlit(d,p,"run" as *u8)
897 d[p]=44 as u8; p=p+1
898 p = tr_key(d,p,"new_before" as *u8)
899 p = tr_catn(d,p,before)
900 d[p]=44 as u8; p=p+1
901 p = tr_key(d,p,"auto_triaged" as *u8)
902 p = tr_catn(d,p,acted)
903 d[p]=44 as u8; p=p+1
904 p = tr_key(d,p,"escalated" as *u8)
905 p = tr_catn(d,p,before-acted)
906 d[p]=44 as u8; p=p+1
907 p = tr_key(d,p,"min_score" as *u8)
908 p = tr_catn(d,p,TR_MIN_SCORE)
909 d[p]=44 as u8; p=p+1
910 p = tr_key(d,p,"margin" as *u8)
911 p = tr_catn(d,p,TR_MARGIN)
912 d[p]=44 as u8; p=p+1
913 p = tr_key(d,p,"window_bytes" as *u8)
914 p = tr_catn(d,p,TR_WIN)
915 d[p]=44 as u8; p=p+1
916 p = tr_key(d,p,"truncated" as *u8)
917 p = tr_catn(d,p,truncated)
918 d[p]=125 as u8; p=p+1
919 d[p]=10 as u8; p=p+1
920 sys_write(1,d,p)
921 sys_exit(0)
922 return 0
923 }
924 gv_puts("unknown verb\n" as *u8)
925 sys_exit(2)
926 return 2
927}