code wiki / _hdl_build / nx_pm_intake.nx
nx_pm_intake.nx source
↩ module page · 636 lines · 25848 B
1// nx_pm_intake.nx -- FEATURE-REQUEST INTAKE -> BACKLOG front door (ws=ws-intel, 2026-07-20).
2// The operator's dual-LLM PM vision mapped sovereign: ANY seat (Claude, K3-mu, role daemon,
3// operator) posts a feature request / observation; the PM tier (human or LLM seat) TRIAGES it;
4// FILING links it to a real backlog row (frontier F-row / work- W-row). State is DERIVED from
5// append-only frames -- never stored, never asserted (the loop's evidence law):
6// REQ w/o TRIAGE = NEW; TRIAGE w/o FILED = TRIAGED; FILED = FILED.
7// Append-only journal = crash-proof + conflict-free (O_APPEND, ws_sync lineage). Composes:
8// nx_ask = agent->OPERATOR question queue (decisions); nx_pm_intake = anyone->PM BACKLOG
9// (requests). The internal-LLM integration = an agent seat driving triage via tools/call.
10// Frame: <ts>\t<VERB>\t<id>\t<actor>\t<text> VERB in {REQ, TRIAGE, FILED}
11// SCALE LAW: windowed reads + declared envelope (window_bytes/truncated/reqs_capped).
12// license_tier: ORIGINAL No hw writes (Rule 26).
13// ask <journal> <from> <text> -> NX-INTAKE id=<epoch-id>
14// triage <journal> <id> <actor> <text> -> fail-closed ABSENT(3) on unknown id
15// file <journal> <id> <actor> <text> -> fail-closed ABSENT(3) on unknown / UNTRIAGED(4)
16// list <journal> [NEW|TRIAGED|FILED|ALL] -> JSON
17// selftest <scratch-journal> -> gate T1..T8 (caller pre-cleans path)
18import "nx_syscalls.nx"
19import "nx_gate_verdict.nx"
20const PI_MAGIC_4096: i64 = 4096
21const PI_MAGIC_2000: i64 = 2000
22const PI_MAGIC_200000: i64 = 200000
23const PI_MAGIC_12345: i64 = 12345
24const PI_MAGIC_7000: i64 = 7000
25const PI_MAGIC_7100: i64 = 7100
26const PI_MAGIC_7200: i64 = 7200
27const PI_MAGIC_8000: i64 = 8000
28const PI_MAGIC_99999: i64 = 99999
29const PI_MAGIC_8100: i64 = 8100
30const PI_MAGIC_8200: i64 = 8200
31
32const PI_WIN: i64 = 4194304
33const PI_OUT: i64 = 262144
34const PI_SOFT: i64 = 49152
35const PI_TEXT_MAX: i64 = 300
36const PI_NAME_MAX: i64 = 120
37
38func pi_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 }
39func pi_catn(d: *u8, o: i64, v: i64) -> i64 {
40 let t: *u8 = sys_mmap(28)
41 var m: i64 = v
42 var p: i64 = o
43 if m < 0 { d[p]=45 as u8; p=p+1; m=0-m }
44 var k: i64 = 0
45 if m == 0 { t[0]=48 as u8; k=1 }
46 while m > 0 { t[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
47 var i: i64 = 0
48 while i < k { d[p]=t[k-1-i]; p=p+1; i=i+1 }
49 return p
50}
51func pi_vlen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
52func pi_read(path: *u8, buf: *u8, cap: i64) -> i64 {
53 let fd: i64 = sys_openat_rd(path)
54 if fd < 0 { return 0 }
55 var n: i64 = 0
56 var go: i64 = 1
57 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 } }
58 sys_close(fd)
59 return n
60}
61// flatten tabs/newlines in text at the boundary (nx_ask discipline) then append one frame
62func pi_append(journal: *u8, ts: i64, verb: *u8, id: i64, actor: *u8, text: *u8) -> i64 {
63 var t: i64 = ts
64 if t < 0 { t = sys_now_realtime_sec() }
65 let ln: *u8 = sys_mmap(PI_MAGIC_4096)
66 var o: i64 = 0
67 o = pi_catn(ln, o, t)
68 ln[o]=9 as u8; o=o+1
69 o = pi_cat(ln, o, verb)
70 ln[o]=9 as u8; o=o+1
71 o = pi_catn(ln, o, id)
72 ln[o]=9 as u8; o=o+1
73 o = pi_cat(ln, o, actor)
74 ln[o]=9 as u8; o=o+1
75 var i: i64 = 0
76 var used: i64 = 0
77 while text[i]!=(0 as u8) {
78 if used < PI_MAGIC_2000 {
79 let c: i64 = text[i] as i64
80 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 } } }
81 used = used + 1
82 }
83 i = i + 1
84 }
85 ln[o]=10 as u8; o=o+1
86 let fd: i64 = sys_openat_append(journal, 0x1a4)
87 if fd < 0 { return -1 }
88 sys_write(fd, ln, o)
89 sys_close(fd)
90 return 0
91}
92func pi_le(q: *u8, i: i64, n: i64) -> i64 {
93 var le: i64 = i
94 var s: i64 = 1
95 while s==1 { if le>=n { s=0 } else { if q[le]==(10 as u8){s=0} else {le=le+1} } }
96 return le
97}
98func pi_col(q: *u8, ls: i64, le: i64, c: i64, out: *i64) -> i64 {
99 var col: i64 = 0
100 var p: i64 = ls
101 while col < c {
102 var s: i64 = 1
103 while s == 1 { if p >= le { return 0 } if q[p]==(9 as u8) { s = 0 } else { p = p+1 } }
104 p = p + 1
105 col = col + 1
106 }
107 var e: i64 = p
108 var s2: i64 = 1
109 while s2 == 1 { if e >= le { s2 = 0 } else { if q[e]==(9 as u8) { s2 = 0 } else { e = e+1 } } }
110 out[0] = p
111 out[1] = e
112 return 1
113}
114func pi_lit_eq(q: *u8, s: i64, e: i64, lit: *u8) -> i64 {
115 var i: i64 = 0
116 while s+i < e { if lit[i]==(0 as u8) { return 0 } if q[s+i]!=lit[i] { return 0 } i=i+1 }
117 if lit[i]!=(0 as u8) { return 0 }
118 return 1
119}
120func pi_atoi(q: *u8, s: i64, e: i64) -> i64 {
121 var v: i64 = 0
122 var i: i64 = s
123 while i < e { let c: i64 = q[i] as i64; if c>=48 { if c<=57 { v = v*10 + (c-48) } } i=i+1 }
124 return v
125}
126// does a frame with verb (literal) and col2 id == idv exist?
127func pi_has_id(q: *u8, n: i64, verb: *u8, idv: i64) -> i64 {
128 let cv: *i64 = sys_mmap(16) as *i64
129 let ci: *i64 = sys_mmap(16) as *i64
130 var i: i64 = 0
131 while i < n {
132 let le: i64 = pi_le(q,i,n)
133 if pi_col(q,i,le,1,cv)==1 { if pi_lit_eq(q,cv[0],cv[1],verb)==1 {
134 if pi_col(q,i,le,2,ci)==1 { let v: i64 = pi_atoi(q,ci[0],ci[1]); if v==idv { return 1 } }
135 } }
136 i = le + 1
137 }
138 return 0
139}
140// derived state of request id: -1 absent / 0 NEW / 1 TRIAGED / 2 FILED
141func pi_state(q: *u8, n: i64, idv: i64) -> i64 {
142 if pi_has_id(q,n,"REQ" as *u8,idv)==0 { return -1 }
143 if pi_has_id(q,n,"FILED" as *u8,idv)==1 { return 2 }
144 if pi_has_id(q,n,"TRIAGE" as *u8,idv)==1 { return 1 }
145 return 0
146}
147func pi_state_name(st: i64) -> *u8 {
148 if st==0 { return "NEW" as *u8 }
149 if st==1 { return "TRIAGED" as *u8 }
150 if st==2 { return "FILED" as *u8 }
151 return "ABSENT" as *u8
152}
153// latest text (col4) of a verb frame for id; returns 1 + span
154func pi_text_span(q: *u8, n: i64, verb: *u8, idv: i64, out: *i64) -> i64 {
155 let cv: *i64 = sys_mmap(16) as *i64
156 let ci: *i64 = sys_mmap(16) as *i64
157 let ct: *i64 = sys_mmap(16) as *i64
158 var ts: i64 = -1
159 var te: i64 = -1
160 var i: i64 = 0
161 while i < n {
162 let le: i64 = pi_le(q,i,n)
163 if pi_col(q,i,le,1,cv)==1 { if pi_lit_eq(q,cv[0],cv[1],verb)==1 {
164 if pi_col(q,i,le,2,ci)==1 { let v: i64 = pi_atoi(q,ci[0],ci[1]); if v==idv {
165 if pi_col(q,i,le,4,ct)==1 { ts=ct[0]; te=ct[1] }
166 } }
167 } }
168 i = le + 1
169 }
170 if ts >= 0 { out[0]=ts; out[1]=te; return 1 }
171 return 0
172}
173// actor (col3) of the REQ frame for id
174func pi_from_span(q: *u8, n: i64, idv: i64, out: *i64) -> i64 {
175 let cv: *i64 = sys_mmap(16) as *i64
176 let ci: *i64 = sys_mmap(16) as *i64
177 let ca: *i64 = sys_mmap(16) as *i64
178 var i: i64 = 0
179 while i < n {
180 let le: i64 = pi_le(q,i,n)
181 if pi_col(q,i,le,1,cv)==1 { if pi_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
182 if pi_col(q,i,le,2,ci)==1 { let v: i64 = pi_atoi(q,ci[0],ci[1]); if v==idv {
183 if pi_col(q,i,le,3,ca)==1 { out[0]=ca[0]; out[1]=ca[1]; return 1 }
184 } }
185 } }
186 i = le + 1
187 }
188 return 0
189}
190func pi_jesc(d: *u8, o: i64, q: *u8, s: i64, e: i64, maxb: i64) -> i64 {
191 var p: i64 = o
192 var i: i64 = s
193 var used: i64 = 0
194 while i < e {
195 if used >= maxb { i = e } else {
196 let c: i64 = q[i] as i64
197 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 } } }
198 used = used + 2
199 i = i + 1
200 }
201 }
202 return p
203}
204func pi_key(d: *u8, o: i64, name: *u8) -> i64 {
205 d[o]=34 as u8
206 var p: i64 = o + 1
207 p = pi_cat(d,p,name)
208 d[p]=34 as u8
209 p = p + 1
210 d[p]=58 as u8
211 p = p + 1
212 return p
213}
214func pi_qlit(d: *u8, o: i64, s: *u8) -> i64 {
215 var p: i64 = o
216 d[p]=34 as u8; p=p+1
217 p = pi_cat(d,p,s)
218 d[p]=34 as u8; p=p+1
219 return p
220}
221// emit one request object {"id":..,"state":..,"from":..,"text":..,"triage":..,"filed":..}
222func pi_emit_req(d: *u8, o: i64, q: *u8, n: i64, idv: i64) -> i64 {
223 var p: i64 = o
224 let sp: *i64 = sys_mmap(16) as *i64
225 d[p]=123 as u8; p=p+1
226 p = pi_key(d,p,"id" as *u8)
227 p = pi_catn(d,p,idv)
228 d[p]=44 as u8; p=p+1
229 p = pi_key(d,p,"state" as *u8)
230 let st: i64 = pi_state(q,n,idv)
231 let sn: *u8 = pi_state_name(st)
232 p = pi_qlit(d,p,sn)
233 d[p]=44 as u8; p=p+1
234 p = pi_key(d,p,"from" as *u8)
235 d[p]=34 as u8; p=p+1
236 if pi_from_span(q,n,idv,sp)==1 { p = pi_jesc(d,p,q,sp[0],sp[1],PI_NAME_MAX) }
237 d[p]=34 as u8; p=p+1
238 d[p]=44 as u8; p=p+1
239 p = pi_key(d,p,"text" as *u8)
240 d[p]=34 as u8; p=p+1
241 if pi_text_span(q,n,"REQ" as *u8,idv,sp)==1 { p = pi_jesc(d,p,q,sp[0],sp[1],PI_TEXT_MAX) }
242 d[p]=34 as u8; p=p+1
243 d[p]=44 as u8; p=p+1
244 p = pi_key(d,p,"triage" as *u8)
245 d[p]=34 as u8; p=p+1
246 if pi_text_span(q,n,"TRIAGE" as *u8,idv,sp)==1 { p = pi_jesc(d,p,q,sp[0],sp[1],PI_TEXT_MAX) }
247 d[p]=34 as u8; p=p+1
248 d[p]=44 as u8; p=p+1
249 p = pi_key(d,p,"filed" as *u8)
250 d[p]=34 as u8; p=p+1
251 if pi_text_span(q,n,"FILED" as *u8,idv,sp)==1 { p = pi_jesc(d,p,q,sp[0],sp[1],PI_TEXT_MAX) }
252 d[p]=34 as u8; p=p+1
253 d[p]=125 as u8; p=p+1
254 return p
255}
256// was this REQ line the FIRST with its id? (dedupe on replayed frames)
257func pi_id_first(q: *u8, upto: i64, idv: i64) -> i64 {
258 let cv: *i64 = sys_mmap(16) as *i64
259 let ci: *i64 = sys_mmap(16) as *i64
260 var i: i64 = 0
261 while i < upto {
262 let le: i64 = pi_le(q,i,upto)
263 if pi_col(q,i,le,1,cv)==1 { if pi_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
264 if pi_col(q,i,le,2,ci)==1 { let v: i64 = pi_atoi(q,ci[0],ci[1]); if v==idv { return 0 } }
265 } }
266 i = le + 1
267 }
268 return 1
269}
270// list: filt -1=ALL else state code; emits JSON doc; returns length
271func pi_list_json(q: *u8, n: i64, jp: *u8, truncated: i64, filt: i64, d: *u8) -> i64 {
272 var p: i64 = 0
273 d[p]=123 as u8; p=p+1
274 p = pi_key(d,p,"v" as *u8)
275 p = pi_catn(d,p,1)
276 d[p]=44 as u8; p=p+1
277 p = pi_key(d,p,"tool" as *u8)
278 p = pi_qlit(d,p,"nx_pm_intake" as *u8)
279 d[p]=44 as u8; p=p+1
280 p = pi_key(d,p,"journal" as *u8)
281 d[p]=34 as u8; p=p+1
282 let jl: i64 = pi_vlen(jp)
283 p = pi_jesc(d,p,jp,0,jl,200)
284 d[p]=34 as u8; p=p+1
285 d[p]=44 as u8; p=p+1
286 p = pi_key(d,p,"journal_bytes" as *u8)
287 p = pi_catn(d,p,n)
288 d[p]=44 as u8; p=p+1
289 p = pi_key(d,p,"window_bytes" as *u8)
290 p = pi_catn(d,p,PI_WIN)
291 d[p]=44 as u8; p=p+1
292 p = pi_key(d,p,"truncated" as *u8)
293 p = pi_catn(d,p,truncated)
294 d[p]=44 as u8; p=p+1
295 // totals pass
296 let cv: *i64 = sys_mmap(16) as *i64
297 let ci: *i64 = sys_mmap(16) as *i64
298 var tnew: i64 = 0
299 var ttri: i64 = 0
300 var tfil: i64 = 0
301 var i: i64 = 0
302 while i < n {
303 let le: i64 = pi_le(q,i,n)
304 if pi_col(q,i,le,1,cv)==1 { if pi_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
305 if pi_col(q,i,le,2,ci)==1 {
306 let idv: i64 = pi_atoi(q,ci[0],ci[1])
307 if pi_id_first(q,i,idv)==1 {
308 let st: i64 = pi_state(q,n,idv)
309 if st==0 { tnew=tnew+1 }
310 if st==1 { ttri=ttri+1 }
311 if st==2 { tfil=tfil+1 }
312 }
313 }
314 } }
315 i = le + 1
316 }
317 p = pi_key(d,p,"totals" as *u8)
318 d[p]=123 as u8; p=p+1
319 p = pi_key(d,p,"new" as *u8)
320 p = pi_catn(d,p,tnew)
321 d[p]=44 as u8; p=p+1
322 p = pi_key(d,p,"triaged" as *u8)
323 p = pi_catn(d,p,ttri)
324 d[p]=44 as u8; p=p+1
325 p = pi_key(d,p,"filed" as *u8)
326 p = pi_catn(d,p,tfil)
327 d[p]=125 as u8; p=p+1
328 d[p]=44 as u8; p=p+1
329 p = pi_key(d,p,"requests" as *u8)
330 d[p]=91 as u8; p=p+1
331 var capped: i64 = 0
332 var first: i64 = 1
333 var j: i64 = 0
334 while j < n {
335 let je: i64 = pi_le(q,j,n)
336 if pi_col(q,j,je,1,cv)==1 { if pi_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
337 if pi_col(q,j,je,2,ci)==1 {
338 let idv2: i64 = pi_atoi(q,ci[0],ci[1])
339 if pi_id_first(q,j,idv2)==1 {
340 let st2: i64 = pi_state(q,n,idv2)
341 var want: i64 = 0
342 if filt < 0 { want = 1 }
343 if st2==filt { want = 1 }
344 if want==1 {
345 if p > PI_SOFT { capped=1 } else {
346 if first==0 { d[p]=44 as u8; p=p+1 }
347 first=0
348 p = pi_emit_req(d,p,q,n,idv2)
349 }
350 }
351 }
352 }
353 } }
354 j = je + 1
355 }
356 d[p]=93 as u8; p=p+1
357 d[p]=44 as u8; p=p+1
358 p = pi_key(d,p,"reqs_capped" as *u8)
359 p = pi_catn(d,p,capped)
360 d[p]=125 as u8; p=p+1
361 d[p]=10 as u8; p=p+1
362 return p
363}
364func pi_hesc(d: *u8, o: i64, q: *u8, s: i64, e: i64, maxb: i64) -> i64 {
365 var p: i64 = o
366 var i: i64 = s
367 var used: i64 = 0
368 while i < e {
369 if used >= maxb { i = e } else {
370 let c: i64 = q[i] as i64
371 if c == 60 { p = pi_cat(d,p,"<" as *u8) } else { if c == 62 { p = pi_cat(d,p,">" as *u8) } else { if c == 38 { p = pi_cat(d,p,"&" as *u8) } else { if c < 32 { d[p]=32 as u8; p=p+1 } else { d[p]=c as u8; p=p+1 } } } }
372 used = used + 5
373 i = i + 1
374 }
375 }
376 return p
377}
378func pi_page_html(q: *u8, n: i64, jp: *u8, truncated: i64, d: *u8) -> i64 {
379 var p: i64 = 0
380 p = pi_cat(d,p,"<" as *u8)
381 d[p]=33 as u8
382 p = p + 1
383 p = pi_cat(d,p,"doctype html><html><head><meta charset=utf-8><title>Nishi Intake</title></head><body>" as *u8)
384 p = pi_cat(d,p,"<h1>Nishi Intake -- feature requests to backlog (states derived, never asserted)</h1>" as *u8)
385 let cv: *i64 = sys_mmap(16) as *i64
386 let ci: *i64 = sys_mmap(16) as *i64
387 let sp: *i64 = sys_mmap(16) as *i64
388 var tnew: i64 = 0
389 var ttri: i64 = 0
390 var tfil: i64 = 0
391 var i: i64 = 0
392 while i < n {
393 let le: i64 = pi_le(q,i,n)
394 if pi_col(q,i,le,1,cv)==1 { if pi_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
395 if pi_col(q,i,le,2,ci)==1 {
396 let idv: i64 = pi_atoi(q,ci[0],ci[1])
397 if pi_id_first(q,i,idv)==1 {
398 let st: i64 = pi_state(q,n,idv)
399 if st==0 { tnew=tnew+1 }
400 if st==1 { ttri=ttri+1 }
401 if st==2 { tfil=tfil+1 }
402 }
403 }
404 } }
405 i = le + 1
406 }
407 p = pi_cat(d,p,"<p>new=" as *u8)
408 p = pi_catn(d,p,tnew)
409 p = pi_cat(d,p," triaged=" as *u8)
410 p = pi_catn(d,p,ttri)
411 p = pi_cat(d,p," filed=" as *u8)
412 p = pi_catn(d,p,tfil)
413 p = pi_cat(d,p,"</p>" as *u8)
414 p = pi_cat(d,p,"<table border=1><tr><th>id</th><th>state</th><th>from</th><th>request</th><th>triage</th><th>filed</th></tr>" as *u8)
415 var truncated_rows: i64 = 0
416 var j: i64 = 0
417 while j < n {
418 let je: i64 = pi_le(q,j,n)
419 if pi_col(q,j,je,1,cv)==1 { if pi_lit_eq(q,cv[0],cv[1],"REQ" as *u8)==1 {
420 if pi_col(q,j,je,2,ci)==1 {
421 let idv2: i64 = pi_atoi(q,ci[0],ci[1])
422 if pi_id_first(q,j,idv2)==1 {
423 if p > PI_MAGIC_200000 { truncated_rows = truncated_rows + 1 } else {
424 p = pi_cat(d,p,"<tr><td>" as *u8)
425 p = pi_catn(d,p,idv2)
426 p = pi_cat(d,p,"</td><td>" as *u8)
427 let st2: i64 = pi_state(q,n,idv2)
428 let sn: *u8 = pi_state_name(st2)
429 p = pi_cat(d,p,sn)
430 p = pi_cat(d,p,"</td><td>" as *u8)
431 if pi_from_span(q,n,idv2,sp)==1 { p = pi_hesc(d,p,q,sp[0],sp[1],PI_NAME_MAX) }
432 p = pi_cat(d,p,"</td><td>" as *u8)
433 if pi_text_span(q,n,"REQ" as *u8,idv2,sp)==1 { p = pi_hesc(d,p,q,sp[0],sp[1],PI_TEXT_MAX) }
434 p = pi_cat(d,p,"</td><td>" as *u8)
435 if pi_text_span(q,n,"TRIAGE" as *u8,idv2,sp)==1 { p = pi_hesc(d,p,q,sp[0],sp[1],PI_TEXT_MAX) }
436 p = pi_cat(d,p,"</td><td>" as *u8)
437 if pi_text_span(q,n,"FILED" as *u8,idv2,sp)==1 { p = pi_hesc(d,p,q,sp[0],sp[1],PI_TEXT_MAX) }
438 p = pi_cat(d,p,"</td></tr>" as *u8)
439 }
440 }
441 }
442 } }
443 j = je + 1
444 }
445 p = pi_cat(d,p,"</table>" as *u8)
446 if truncated_rows > 0 {
447 p = pi_cat(d,p,"<p>ENVELOPE: rows_truncated=" as *u8)
448 p = pi_catn(d,p,truncated_rows)
449 p = pi_cat(d,p,"</p>" as *u8)
450 }
451 p = pi_cat(d,p,"<p>envelope window_bytes=" as *u8)
452 p = pi_catn(d,p,PI_WIN)
453 p = pi_cat(d,p," journal_bytes=" as *u8)
454 p = pi_catn(d,p,n)
455 p = pi_cat(d,p," truncated=" as *u8)
456 p = pi_catn(d,p,truncated)
457 p = pi_cat(d,p," | source=knowledge/status/pm_intake.jrnl | tool=nx_pm_intake (MCP: ask/triage/file/list) | <a href=/standup>standup</a> <a href=/wsmine>wsmine</a> <a href=/claims>claims</a></p>" as *u8)
458 p = pi_cat(d,p,"</body></html>" as *u8)
459 d[p]=10 as u8
460 p = p + 1
461 return p
462}
463func pi_find(d: *u8, dn: i64, lit: *u8) -> i64 {
464 let ll: i64 = pi_vlen(lit)
465 if ll == 0 { return 0 }
466 var i: i64 = 0
467 while i + ll <= dn {
468 var k: i64 = 0
469 var ok: i64 = 1
470 while k < ll { if d[i+k]!=lit[k] { ok=0; k=ll } else { k=k+1 } }
471 if ok==1 { return 1 }
472 i = i + 1
473 }
474 return 0
475}
476
477// ---------- selftest gate ----------
478func pi_selftest(journal: *u8) -> i64 {
479 let ctr: *i64 = gv_ctr()
480 gv_head("nx_pm_intake selftest -- feature-request intake teeth (caller pre-cleans journal)" as *u8)
481 let q: *u8 = sys_mmap(PI_WIN)
482 let rcap: i64 = PI_WIN - 8
483 // T1 empty -> zero requests everywhere
484 var n: i64 = pi_read(journal,q,rcap)
485 var ok1: i64 = 0
486 if n==0 { if pi_state(q,n,PI_MAGIC_12345)==(-1) { ok1=1 } }
487 gv_check("T1 empty journal absent id honestly ABSENT" as *u8, ok1, ctr)
488 // T2 ask -> REQ frame, state NEW
489 pi_append(journal, PI_MAGIC_7000, "REQ" as *u8, PI_MAGIC_7000, "seatA" as *u8, "request-one text" as *u8)
490 n = pi_read(journal,q,rcap)
491 var ok2: i64 = 0
492 if pi_state(q,n,PI_MAGIC_7000)==0 { ok2=1 }
493 gv_check("T2 asked request derives NEW" as *u8, ok2, ctr)
494 // T3 triage -> TRIAGED
495 pi_append(journal, PI_MAGIC_7100, "TRIAGE" as *u8, PI_MAGIC_7000, "pmseat" as *u8, "lane=model sev=6 owner=modelwright" as *u8)
496 n = pi_read(journal,q,rcap)
497 var ok3: i64 = 0
498 if pi_state(q,n,PI_MAGIC_7000)==1 { ok3=1 }
499 gv_check("T3 triaged request derives TRIAGED" as *u8, ok3, ctr)
500 // T4 file -> FILED
501 pi_append(journal, PI_MAGIC_7200, "FILED" as *u8, PI_MAGIC_7000, "pmseat" as *u8, "work-plane W030" as *u8)
502 n = pi_read(journal,q,rcap)
503 var ok4: i64 = 0
504 if pi_state(q,n,PI_MAGIC_7000)==2 { ok4=1 }
505 gv_check("T4 filed request derives FILED" as *u8, ok4, ctr)
506 // T5 second request independent, state NEW while first FILED
507 pi_append(journal, PI_MAGIC_8000, "REQ" as *u8, PI_MAGIC_8000, "seatB" as *u8, "request-two text" as *u8)
508 n = pi_read(journal,q,rcap)
509 var ok5: i64 = 0
510 if pi_state(q,n,PI_MAGIC_8000)==0 { if pi_state(q,n,PI_MAGIC_7000)==2 { ok5=1 } }
511 gv_check("T5 second request independent NEW" as *u8, ok5, ctr)
512 // T6 neg-control: unknown id stays ABSENT (fail-closed triage precondition)
513 var ok6: i64 = 0
514 if pi_state(q,n,PI_MAGIC_99999)==(-1) { ok6=1 }
515 gv_check("T6 neg-control unknown id ABSENT" as *u8, ok6, ctr)
516 // T7 latest-text resolution: re-triage 8000 twice, latest wins
517 pi_append(journal, PI_MAGIC_8100, "TRIAGE" as *u8, PI_MAGIC_8000, "pmseat" as *u8, "first-triage" as *u8)
518 pi_append(journal, PI_MAGIC_8200, "TRIAGE" as *u8, PI_MAGIC_8000, "pmseat" as *u8, "second-triage wins" as *u8)
519 n = pi_read(journal,q,rcap)
520 let sp: *i64 = sys_mmap(16) as *i64
521 var ok7: i64 = 0
522 if pi_text_span(q,n,"TRIAGE" as *u8,PI_MAGIC_8000,sp)==1 {
523 if pi_lit_eq(q,sp[0],sp[1],"second-triage wins" as *u8)==1 { ok7=1 }
524 }
525 gv_check("T7 latest triage text wins" as *u8, ok7, ctr)
526 // T8 JSON list smoke: totals + both requests + envelope
527 let d: *u8 = sys_mmap(PI_OUT)
528 let dl: i64 = pi_list_json(q,n,journal,0,-1,d)
529 var ok8: i64 = 0
530 if dl > 0 { if d[0]==(123 as u8) { if pi_find(d,dl,"triaged" as *u8)==1 { if pi_find(d,dl,"reqs_capped" as *u8)==1 { if pi_find(d,dl,"request-two" as *u8)==1 { ok8=1 } } } } }
531 gv_check("T8 JSON list carries totals and declared envelope" as *u8, ok8, ctr)
532 // T9 page HTML smoke: table + states + envelope
533 let d2: *u8 = sys_mmap(PI_OUT)
534 let dl9: i64 = pi_page_html(q,n,journal,0,d2)
535 var ok9: i64 = 0
536 if dl9 > 0 { if pi_find(d2,dl9,"<table" as *u8)==1 { if pi_find(d2,dl9,"FILED" as *u8)==1 { if pi_find(d2,dl9,"window_bytes" as *u8)==1 { ok9=1 } } } }
537 gv_check("T9 page HTML carries table states envelope" as *u8, ok9, ctr)
538 let rc: i64 = gv_verdict("PM-INTAKE-GATE" as *u8, ctr, "feature-request intake teeth green" as *u8)
539 return rc
540}
541
542func main(argc: i64, argv: *i64) -> i64 {
543 if argc < 3 { gv_puts("usage: nx_pm_intake {ask <journal> <from> <text> | triage <journal> <id> <actor> <text> | file <journal> <id> <actor> <text> | list <journal> [NEW|TRIAGED|FILED|ALL] | selftest <journal>}\n" as *u8); sys_exit(2); return 2 }
544 let verb: *u8 = argv[1] as *u8
545 let journal: *u8 = argv[2] as *u8
546 let vl: i64 = pi_vlen(verb)
547 if pi_lit_eq(verb,0,vl,"selftest" as *u8)==1 { let rc: i64 = pi_selftest(journal); sys_exit(rc); return rc }
548 if pi_lit_eq(verb,0,vl,"ask" as *u8)==1 {
549 if argc < 5 { gv_puts("ask needs <journal> <from> <text>\n" as *u8); sys_exit(2); return 2 }
550 let from: *u8 = argv[3] as *u8
551 let text: *u8 = argv[4] as *u8
552 // collision-aware id: epoch-seconds, bumped past any existing REQ id (two asks in one
553 // second otherwise merge; found live 2026-07-20 when a plan ran two asks in <1s)
554 var idv: i64 = sys_now_realtime_sec()
555 let q3: *u8 = sys_mmap(PI_WIN)
556 let rc3: i64 = PI_WIN - 8
557 let n3: i64 = pi_read(journal,q3,rc3)
558 var bump: i64 = 1
559 while bump == 1 { if pi_has_id(q3,n3,"REQ" as *u8,idv)==1 { idv = idv + 1 } else { bump = 0 } }
560 let rc: i64 = pi_append(journal, idv, "REQ" as *u8, idv, from, text)
561 if rc==0 { gv_puts("NX-INTAKE id=" as *u8); gv_num(idv); gv_puts("\n" as *u8); sys_exit(0); return 0 }
562 gv_puts("append FAILED\n" as *u8)
563 sys_exit(1)
564 return 1
565 }
566 if pi_lit_eq(verb,0,vl,"list" as *u8)==1 {
567 let q: *u8 = sys_mmap(PI_WIN)
568 let rcap: i64 = PI_WIN - 8
569 let n: i64 = pi_read(journal,q,rcap)
570 var truncated: i64 = 0
571 if n >= rcap { truncated=1 }
572 var filt: i64 = -1
573 if argc >= 4 {
574 let f: *u8 = argv[3] as *u8
575 let fl: i64 = pi_vlen(f)
576 if pi_lit_eq(f,0,fl,"NEW" as *u8)==1 { filt=0 }
577 if pi_lit_eq(f,0,fl,"TRIAGED" as *u8)==1 { filt=1 }
578 if pi_lit_eq(f,0,fl,"FILED" as *u8)==1 { filt=2 }
579 }
580 let d: *u8 = sys_mmap(PI_OUT)
581 let dl: i64 = pi_list_json(q,n,journal,truncated,filt,d)
582 sys_write(1,d,dl)
583 sys_exit(0)
584 return 0
585 }
586 if pi_lit_eq(verb,0,vl,"page" as *u8)==1 {
587 if argc < 4 { gv_puts("page needs <journal> <outfile>\n" as *u8); sys_exit(2); return 2 }
588 let q2: *u8 = sys_mmap(PI_WIN)
589 let rcap2: i64 = PI_WIN - 8
590 let n2: i64 = pi_read(journal,q2,rcap2)
591 var trunc2: i64 = 0
592 if n2 >= rcap2 { trunc2=1 }
593 let outfile: *u8 = argv[3] as *u8
594 let d: *u8 = sys_mmap(PI_OUT)
595 let dl: i64 = pi_page_html(q2,n2,journal,trunc2,d)
596 let fd: i64 = sys_openat_wr(outfile, 0x1a4)
597 if fd < 0 { gv_puts("INTAKE-PAGE OPEN-FAIL\n" as *u8); sys_exit(1); return 1 }
598 sys_write(fd,d,dl)
599 sys_close(fd)
600 gv_puts("INTAKE-PAGE bytes=" as *u8)
601 gv_num(dl)
602 gv_puts("\n" as *u8)
603 sys_exit(0)
604 return 0
605 }
606 // triage | file -- fail-closed on unknown id
607 if argc < 6 { gv_puts("triage|file need <journal> <id> <actor> <text>\n" as *u8); sys_exit(2); return 2 }
608 let idz: *u8 = argv[3] as *u8
609 let izl: i64 = pi_vlen(idz)
610 let idv: i64 = pi_atoi(idz,0,izl)
611 let actor: *u8 = argv[4] as *u8
612 let text: *u8 = argv[5] as *u8
613 let q: *u8 = sys_mmap(PI_WIN)
614 let rcap: i64 = PI_WIN - 8
615 let n: i64 = pi_read(journal,q,rcap)
616 let st: i64 = pi_state(q,n,idv)
617 if st < 0 { gv_puts("NX-INTAKE ABSENT id=" as *u8); gv_num(idv); gv_puts("\n" as *u8); sys_exit(3); return 3 }
618 if pi_lit_eq(verb,0,vl,"triage" as *u8)==1 {
619 let rc: i64 = pi_append(journal, -1, "TRIAGE" as *u8, idv, actor, text)
620 if rc==0 { gv_puts("NX-INTAKE TRIAGED id=" as *u8); gv_num(idv); gv_puts("\n" as *u8); sys_exit(0); return 0 }
621 gv_puts("append FAILED\n" as *u8)
622 sys_exit(1)
623 return 1
624 }
625 if pi_lit_eq(verb,0,vl,"file" as *u8)==1 {
626 if st == 0 { gv_puts("NX-INTAKE UNTRIAGED id=" as *u8); gv_num(idv); gv_puts(" (triage first)\n" as *u8); sys_exit(4); return 4 }
627 let rc: i64 = pi_append(journal, -1, "FILED" as *u8, idv, actor, text)
628 if rc==0 { gv_puts("NX-INTAKE FILED id=" as *u8); gv_num(idv); gv_puts("\n" as *u8); sys_exit(0); return 0 }
629 gv_puts("append FAILED\n" as *u8)
630 sys_exit(1)
631 return 1
632 }
633 gv_puts("unknown verb\n" as *u8)
634 sys_exit(2)
635 return 2
636}