code wiki / _hdl_build / nx_backlog_feeder.nx
nx_backlog_feeder.nx source
↩ module page · 560 lines · 25803 B
1// nx_backlog_feeder.nx -- F208 AUTONOMOUS BACKLOG FEEDER, evidence->FRONTIER half (ws=auto-f208-feeder, 2026-07-21).
2// nx_feeder (ws-intel8) notices dropped threads and files INTAKE proposals; the router triages them;
3// but NOTHING committed deps-resolved F-rows onto the frontier from measured evidence. This organ is
4// that committer, rung 1 = the DEBT source: every OPEN debt at sev >= minsev becomes ONE frontier row
5// F<auto> "debt <epoch>: <desc>" weight=<sev> prio=1 <owner> T deps=- [FEED:debt:<epoch>.<k>] <lane>
6// HONEST WEIGHTS: the row weight IS the measured debt sev, so nx_seat ready (w-desc) ranks feeder rows
7// truthfully against hand-filed rungs (RANKW1 contract). DEPS-RESOLVED: deps=- (a debt is actionable now).
8// SAFETY BY CONSTRUCTION:
9// - ids are NEVER fixed: F<max+1> batch-assigned under the SAME <prefix>plock nx_frontier_put takes
10// (frontier ids collide across lanes; addauto semantics reused, computed in ONE critical section)
11// - CONTENT-IDEMPOTENT: marker [FEED:debt:<epoch>.<k>] in the extra col; a re-run on unchanged
12// evidence adds ZERO rows. k = the epoch's occurrence ordinal among debt rows, so D025 epoch-id
13// collisions (two debts, same epoch) still yield DISTINCT markers -- never a wrong-row dedupe.
14// - per-run cap: the frontier can never be flooded; capped findings are REPORTED, not lost (next run).
15// - ONE sts_seed per run (one new segment) -- honors the seg-store quadratic lesson; a run that adds
16// nothing commits NOTHING (no segment churn, planeguard-quiet).
17// - fail-closed: unseeded frontier plane -> refuse, commit nothing (mirrors nx_frontier_put).
18// NOTHING IS FABRICATED: every row cites its debt epoch + measured sev; eaten/low-sev debts are skipped.
19// Residual sources (gap queues, atlas maturity-gap, intake-TRIAGED promotion) = FILED follow-on rungs.
20// license_tier: ORIGINAL No hw writes (Rule 26). expect_exit: 0
21// scan <minsev> <maxfile> [debt-prefix] [frontier-prefix] -> JSON (READ-ONLY)
22// run <minsev> <maxfile> <owner> <lane> [debt-prefix] [frontier-prefix] [exportpath] -> commit, JSON
23// selftest <scratch-prefix-base> -> gate T1..T9
24import "nx_store_seed_lib.nx"
25import "nx_seg_store.nx"
26import "nx_syscalls.nx"
27import "nx_gate_verdict.nx"
28
29const BF_CAP: i64 = 1048576
30const BF_TAB: i64 = 9
31const BF_NL: i64 = 10
32const BF_STDERR: i64 = 2
33const BF_LOCK_EX: i64 = 2
34const BF_MODE: i64 = 420
35const BF_SPAN: i64 = 16
36const BF_PATHCAP: i64 = 256
37const BF_HDRCAP: i64 = 512
38const BF_OUTJSON: i64 = 8192
39const BF_MARKCAP: i64 = 128
40const BF_TITLE_MAX: i64 = 140
41const BF_EXIT_USAGE: i64 = 2
42const BF_MAGIC_28: i64 = 28
43
44func bf_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
45func bf_werr(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(BF_STDERR, s, n); return 0 }
46func bf_vlen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
47func bf_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 }
48func bf_catn(d: *u8, o: i64, v: i64) -> i64 { let t: *u8 = sys_mmap(BF_MAGIC_28); var m: i64 = v; var p: i64 = o; if m < 0 { m = 0 } var k: i64 = 0; if m == 0 { t[0] = 48 as u8; k = 1 } while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 } var i: i64 = 0; while i < k { d[p] = t[k-1-i]; p = p + 1; i = i + 1 } return p }
49func bf_atoi_c(s: *u8) -> i64 { var v: i64 = 0; var i: i64 = 0; while s[i] != (0 as u8) { let c: i64 = s[i] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } i = i + 1 } return v }
50func bf_le(q: *u8, i: i64, n: i64) -> i64 { var e: i64 = i; var s: i64 = 1; while s == 1 { if e >= n { s = 0 } else { if q[e] == (BF_NL as u8) { s = 0 } else { e = e + 1 } } } return e }
51func bf_col(q: *u8, ls: i64, le: i64, c: i64, out: *i64) -> i64 {
52 var col: i64 = 0
53 var p: i64 = ls
54 while col < c {
55 var s: i64 = 1
56 while s == 1 { if p >= le { return 0 } if q[p] == (BF_TAB as u8) { s = 0 } else { p = p + 1 } }
57 p = p + 1
58 col = col + 1
59 }
60 var e: i64 = p
61 var s2: i64 = 1
62 while s2 == 1 { if e >= le { s2 = 0 } else { if q[e] == (BF_TAB as u8) { s2 = 0 } else { e = e + 1 } } }
63 out[0] = p
64 out[1] = e
65 return 1
66}
67func bf_lit_eq(q: *u8, s: i64, e: i64, lit: *u8) -> i64 {
68 var i: i64 = 0
69 while s + i < e { if lit[i] == (0 as u8) { return 0 } if q[s+i] != lit[i] { return 0 } i = i + 1 }
70 if lit[i] != (0 as u8) { return 0 }
71 return 1
72}
73func bf_span_eq(q: *u8, s1: i64, e1: i64, s2: i64, e2: i64) -> i64 {
74 if e1 - s1 != e2 - s2 { return 0 }
75 var i: i64 = 0
76 while s1 + i < e1 { if q[s1+i] != q[s2+i] { return 0 } i = i + 1 }
77 return 1
78}
79func bf_atoi_span(q: *u8, s: i64, e: i64) -> i64 {
80 var v: i64 = 0
81 var i: i64 = s
82 while i < e { let c: i64 = q[i] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } i = i + 1 }
83 return v
84}
85// substring search of a NUL-terminated needle inside a buffer
86func bf_find(d: *u8, dn: i64, lit: *u8) -> i64 {
87 let ll: i64 = bf_vlen(lit)
88 if ll == 0 { return 0 }
89 var i: i64 = 0
90 while i + ll <= dn {
91 var k: i64 = 0
92 var ok: i64 = 1
93 while k < ll { if d[i+k] != lit[k] { ok = 0; k = ll } else { k = k + 1 } }
94 if ok == 1 { return 1 }
95 i = i + 1
96 }
97 return 0
98}
99// take the flock: open <prefix>plock append-create, LOCK_EX -- the SAME lock nx_frontier_put takes,
100// so feeder commits serialize with every other frontier writer. returns fd or -1.
101func bf_lock(prefix: *u8) -> i64 {
102 let p: *u8 = sys_mmap(BF_PATHCAP)
103 var o: i64 = bf_cat(p, 0, prefix)
104 o = bf_cat(p, o, "plock" as *u8)
105 p[o] = 0 as u8
106 let fd: i64 = sys_openat_append(p, BF_MODE)
107 if fd < 0 { return 0 - 1 }
108 sys_flock(fd, BF_LOCK_EX)
109 return fd
110}
111// export the generated view (byte-consistent with nx_frontier_put's export contract)
112func bf_export(path: *u8, rows: *u8, n: i64) -> i64 {
113 let fd: i64 = sys_openat_wr(path, BF_MODE)
114 if fd < 0 { return 0 - 1 }
115 let h: *u8 = sys_mmap(BF_HDRCAP)
116 h[0] = 35 as u8
117 var o: i64 = bf_cat(h, 1, " GENERATED VIEW (do not hand-edit): SSOT = the seg-store; edit via nx_frontier_put set/add (MCP). Cron re-seeds the store from this view transitionally, so it stays byte-consistent.\n" as *u8)
118 sys_write(fd, h, o)
119 sys_write(fd, rows, n)
120 sys_close(fd)
121 return 0
122}
123// max numeric F-id in col0 (nx_frontier_put fp_max_fid semantics: suffixed ids like F103a skipped)
124func bf_max_fid(q: *u8, n: i64, letter: i64) -> i64 {
125 let c0: *i64 = sys_mmap(BF_SPAN) as *i64
126 var mx: i64 = 0
127 var i: i64 = 0
128 while i < n {
129 let le: i64 = bf_le(q, i, n)
130 if bf_col(q, i, le, 0, c0) == 1 {
131 let s: i64 = c0[0]
132 let e: i64 = c0[1]
133 if e - s >= 2 { if (q[s] as i64) == letter {
134 var allnum: i64 = 1
135 var v: i64 = 0
136 var j: i64 = s + 1
137 while j < e { let c: i64 = q[j] as i64; if c < 48 { allnum = 0; j = e } else { if c > 57 { allnum = 0; j = e } else { v = v * 10 + (c - 48); j = j + 1 } } }
138 if allnum == 1 { if v > mx { mx = v } }
139 } }
140 }
141 i = le + 1
142 }
143 return mx
144}
145// occurrence ordinal of this row's epoch among debt rows BEFORE it (D025 epoch-collision defense)
146func bf_epoch_ordinal(q: *u8, n: i64, upto: i64, e_s: i64, e_e: i64) -> i64 {
147 let c0: *i64 = sys_mmap(BF_SPAN) as *i64
148 var k: i64 = 0
149 var i: i64 = 0
150 while i < upto {
151 let le: i64 = bf_le(q, i, n)
152 if bf_col(q, i, le, 0, c0) == 1 { if bf_span_eq(q, c0[0], c0[1], e_s, e_e) == 1 { k = k + 1 } }
153 i = le + 1
154 }
155 return k
156}
157// marker builder: [FEED:debt:<epoch>.<ordinal>] (the dedupe key, lives in the row's extra col)
158func bf_marker(mb: *u8, q: *u8, e_s: i64, e_e: i64, ord: i64) -> i64 {
159 var p: i64 = 0
160 p = bf_cat(mb, p, "[FEED:debt:" as *u8)
161 var i: i64 = e_s
162 while i < e_e { mb[p] = q[i]; p = p + 1; i = i + 1 }
163 mb[p] = 46 as u8
164 p = p + 1
165 p = bf_catn(mb, p, ord)
166 mb[p] = 93 as u8
167 p = p + 1
168 mb[p] = 0 as u8
169 return p
170}
171// F-id digits zero-padded to 3 (the plane's F001.. style; >=1000 naturally unpadded)
172func bf_catn3(d: *u8, o: i64, v: i64) -> i64 {
173 var p: i64 = o
174 if v < 100 { d[p] = 48 as u8; p = p + 1 }
175 if v < 10 { d[p] = 48 as u8; p = p + 1 }
176 p = bf_catn(d, p, v)
177 return p
178}
179// append one 9-col frontier row into out at o. desc span may contain tabs/newlines -> sanitized.
180func bf_append_row(out: *u8, o: i64, fid: i64, q: *u8, e_s: i64, e_e: i64, d_s: i64, d_e: i64, sev: i64, owner: *u8, lane: *u8, mb: *u8) -> i64 {
181 var p: i64 = o
182 out[p] = 70 as u8
183 p = p + 1
184 p = bf_catn3(out, p, fid)
185 out[p] = BF_TAB as u8
186 p = p + 1
187 p = bf_cat(out, p, "debt " as *u8)
188 var i: i64 = e_s
189 while i < e_e { out[p] = q[i]; p = p + 1; i = i + 1 }
190 p = bf_cat(out, p, ": " as *u8)
191 var j: i64 = d_s
192 var used: i64 = 0
193 while j < d_e { if used < BF_TITLE_MAX { let c: i64 = q[j] as i64; if c == 9 { out[p] = 32 as u8 } else { if c == 10 { out[p] = 32 as u8 } else { if c == 13 { out[p] = 32 as u8 } else { out[p] = c as u8 } } } p = p + 1; used = used + 1 } j = j + 1 }
194 out[p] = BF_TAB as u8
195 p = p + 1
196 p = bf_catn(out, p, sev)
197 out[p] = BF_TAB as u8
198 p = p + 1
199 out[p] = 49 as u8
200 p = p + 1
201 out[p] = BF_TAB as u8
202 p = p + 1
203 p = bf_cat(out, p, owner)
204 out[p] = BF_TAB as u8
205 p = p + 1
206 out[p] = 84 as u8
207 p = p + 1
208 out[p] = BF_TAB as u8
209 p = p + 1
210 out[p] = 45 as u8
211 p = p + 1
212 out[p] = BF_TAB as u8
213 p = p + 1
214 p = bf_cat(out, p, mb)
215 out[p] = BF_TAB as u8
216 p = p + 1
217 p = bf_cat(out, p, lane)
218 out[p] = BF_NL as u8
219 p = p + 1
220 return p
221}
222// the sweep. mode 0 = count only (no lock, no write); mode 1 = commit under flock.
223// cx: [0]=added [1]=skipped_already_fed [2]=capped [3]=candidates [4]=next_id [5]=debt_bytes [6]=frontier_bytes
224// returns 0 ok / 1 fail-closed
225func bf_sweep(dpfx: *u8, fpfx: *u8, minsev: i64, maxfile: i64, owner: *u8, lane: *u8, expath: *u8, mode: i64, cx: *i64) -> i64 {
226 cx[0] = 0
227 cx[1] = 0
228 cx[2] = 0
229 cx[3] = 0
230 let dq: *u8 = sys_mmap(BF_CAP)
231 let dn: i64 = sts_load(dpfx, dq, BF_CAP)
232 cx[5] = dn
233 var lk: i64 = 0 - 1
234 if mode == 1 { lk = bf_lock(fpfx); if lk < 0 { bf_werr("FEED-FAIL cannot lock frontier plane\n" as *u8); return 1 } }
235 let fq: *u8 = sys_mmap(BF_CAP)
236 let fn: i64 = sts_load(fpfx, fq, BF_CAP)
237 cx[6] = fn
238 if mode == 1 { if fn <= 0 { bf_werr("FEED-FAIL frontier plane empty or unseeded (nothing committed)\n" as *u8); sys_close(lk); return 1 } }
239 let out: *u8 = sys_mmap(BF_CAP)
240 var o: i64 = 0
241 var ci: i64 = 0
242 while ci < fn { out[o] = fq[ci]; o = o + 1; ci = ci + 1 }
243 var nextid: i64 = bf_max_fid(fq, fn, 70) + 1
244 let c0: *i64 = sys_mmap(BF_SPAN) as *i64
245 let c1: *i64 = sys_mmap(BF_SPAN) as *i64
246 let c3: *i64 = sys_mmap(BF_SPAN) as *i64
247 let c4: *i64 = sys_mmap(BF_SPAN) as *i64
248 let mb: *u8 = sys_mmap(BF_MARKCAP)
249 var i: i64 = 0
250 while i < dn {
251 let le: i64 = bf_le(dq, i, dn)
252 var take: i64 = 0
253 var sev: i64 = 0
254 if bf_col(dq, i, le, 3, c3) == 1 { if bf_lit_eq(dq, c3[0], c3[1], "open" as *u8) == 1 {
255 if bf_col(dq, i, le, 1, c1) == 1 {
256 sev = bf_atoi_span(dq, c1[0], c1[1])
257 if sev >= minsev { if sev <= 9 { if bf_col(dq, i, le, 0, c0) == 1 { if bf_col(dq, i, le, 4, c4) == 1 { take = 1 } } } }
258 }
259 } }
260 if take == 1 {
261 cx[3] = cx[3] + 1
262 let ord: i64 = bf_epoch_ordinal(dq, dn, i, c0[0], c0[1])
263 bf_marker(mb, dq, c0[0], c0[1], ord)
264 if bf_find(fq, fn, mb) == 1 { cx[1] = cx[1] + 1 } else {
265 if cx[0] >= maxfile { cx[2] = cx[2] + 1 } else {
266 if mode == 1 { o = bf_append_row(out, o, nextid, dq, c0[0], c0[1], c4[0], le, sev, owner, lane, mb); nextid = nextid + 1 }
267 cx[0] = cx[0] + 1
268 }
269 }
270 }
271 i = le + 1
272 }
273 cx[4] = nextid
274 if mode == 1 { if cx[0] > 0 {
275 let cnt: i64 = sts_seed(fpfx, out, o)
276 if cnt < 0 { bf_werr("FEED-FAIL commit error\n" as *u8); sys_close(lk); return 1 }
277 bf_export(expath, out, o)
278 } }
279 // release the flock (close releases it): a MULTI-SWEEP caller (the gate) would otherwise
280 // deadlock on its OWN lock -- single-shot CLI callers like nx_frontier_put never see this.
281 if mode == 1 { if lk >= 0 { sys_close(lk) } }
282 return 0
283}
284func bf_key(d: *u8, o: i64, name: *u8) -> i64 {
285 d[o] = 34 as u8
286 var p: i64 = o + 1
287 p = bf_cat(d, p, name)
288 d[p] = 34 as u8
289 p = p + 1
290 d[p] = 58 as u8
291 p = p + 1
292 return p
293}
294func bf_qlit(d: *u8, o: i64, s: *u8) -> i64 {
295 var p: i64 = o
296 d[p] = 34 as u8
297 p = p + 1
298 p = bf_cat(d, p, s)
299 d[p] = 34 as u8
300 p = p + 1
301 return p
302}
303func bf_summary(d: *u8, modename: *u8, cx: *i64, minsev: i64, maxfile: i64) -> i64 {
304 var p: i64 = 0
305 d[p] = 123 as u8
306 p = p + 1
307 p = bf_key(d, p, "v" as *u8)
308 p = bf_catn(d, p, 1)
309 d[p] = 44 as u8
310 p = p + 1
311 p = bf_key(d, p, "tool" as *u8)
312 p = bf_qlit(d, p, "nx_backlog_feeder" as *u8)
313 d[p] = 44 as u8
314 p = p + 1
315 p = bf_key(d, p, "mode" as *u8)
316 p = bf_qlit(d, p, modename)
317 d[p] = 44 as u8
318 p = p + 1
319 p = bf_key(d, p, "minsev" as *u8)
320 p = bf_catn(d, p, minsev)
321 d[p] = 44 as u8
322 p = p + 1
323 p = bf_key(d, p, "max_per_run" as *u8)
324 p = bf_catn(d, p, maxfile)
325 d[p] = 44 as u8
326 p = p + 1
327 p = bf_key(d, p, "candidates" as *u8)
328 p = bf_catn(d, p, cx[3])
329 d[p] = 44 as u8
330 p = p + 1
331 p = bf_key(d, p, "added" as *u8)
332 p = bf_catn(d, p, cx[0])
333 d[p] = 44 as u8
334 p = p + 1
335 p = bf_key(d, p, "skipped_already_fed" as *u8)
336 p = bf_catn(d, p, cx[1])
337 d[p] = 44 as u8
338 p = p + 1
339 p = bf_key(d, p, "capped" as *u8)
340 p = bf_catn(d, p, cx[2])
341 d[p] = 44 as u8
342 p = p + 1
343 p = bf_key(d, p, "next_id" as *u8)
344 p = bf_catn(d, p, cx[4])
345 d[p] = 44 as u8
346 p = p + 1
347 p = bf_key(d, p, "debt_bytes" as *u8)
348 p = bf_catn(d, p, cx[5])
349 d[p] = 44 as u8
350 p = p + 1
351 p = bf_key(d, p, "frontier_bytes" as *u8)
352 p = bf_catn(d, p, cx[6])
353 d[p] = 44 as u8
354 p = p + 1
355 p = bf_key(d, p, "window_bytes" as *u8)
356 p = bf_catn(d, p, BF_CAP)
357 d[p] = 44 as u8
358 p = p + 1
359 p = bf_key(d, p, "truncated" as *u8)
360 var tr: i64 = 0
361 if cx[5] >= BF_CAP - 8 { tr = 1 }
362 if cx[6] >= BF_CAP - 8 { tr = 1 }
363 p = bf_catn(d, p, tr)
364 d[p] = 125 as u8
365 p = p + 1
366 d[p] = 10 as u8
367 p = p + 1
368 return p
369}
370func bf_mkpfx(dst: *u8, base: *u8, suf: *u8) -> i64 {
371 var p: i64 = 0
372 p = bf_cat(dst, p, base)
373 p = bf_cat(dst, p, suf)
374 dst[p] = 0 as u8
375 return p
376}
377// count rows whose col0 exactly matches lit (dup-id detector for the gate)
378func bf_count_id(q: *u8, n: i64, lit: *u8) -> i64 {
379 let c0: *i64 = sys_mmap(BF_SPAN) as *i64
380 var k: i64 = 0
381 var i: i64 = 0
382 while i < n {
383 let le: i64 = bf_le(q, i, n)
384 if bf_col(q, i, le, 0, c0) == 1 { if bf_lit_eq(q, c0[0], c0[1], lit) == 1 { k = k + 1 } }
385 i = le + 1
386 }
387 return k
388}
389// tab count of the line containing needle (row-shape tooth)
390func bf_row_tabs(q: *u8, n: i64, needle: *u8) -> i64 {
391 let ll: i64 = bf_vlen(needle)
392 var i: i64 = 0
393 while i < n {
394 let le: i64 = bf_le(q, i, n)
395 var hit: i64 = 0
396 var s: i64 = i
397 while s + ll <= le { var k: i64 = 0; var ok: i64 = 1; while k < ll { if q[s+k] != needle[k] { ok = 0; k = ll } else { k = k + 1 } } if ok == 1 { hit = 1; s = le } else { s = s + 1 } }
398 if hit == 1 {
399 var tabs: i64 = 0
400 var t: i64 = i
401 while t < le { if q[t] == (BF_TAB as u8) { tabs = tabs + 1 } t = t + 1 }
402 return tabs
403 }
404 i = le + 1
405 }
406 return 0 - 1
407}
408// fetch col c of the row containing needle into span out; 1 hit / 0 miss
409func bf_row_col(q: *u8, n: i64, needle: *u8, c: i64, out: *i64) -> i64 {
410 let ll: i64 = bf_vlen(needle)
411 var i: i64 = 0
412 while i < n {
413 let le: i64 = bf_le(q, i, n)
414 var hit: i64 = 0
415 var s: i64 = i
416 while s + ll <= le { var k: i64 = 0; var ok: i64 = 1; while k < ll { if q[s+k] != needle[k] { ok = 0; k = ll } else { k = k + 1 } } if ok == 1 { hit = 1; s = le } else { s = s + 1 } }
417 if hit == 1 { return bf_col(q, i, le, c, out) }
418 i = le + 1
419 }
420 return 0
421}
422
423// ---------- selftest gate (T1..T9, scratch seg-store planes; every tooth re-seeds -> re-runnable) ----------
424func bf_selftest(base: *u8) -> i64 {
425 let ctr: *i64 = gv_ctr()
426 gv_head("nx_backlog_feeder selftest -- evidence->frontier feeder teeth (scratch planes under knowledge/store/)" as *u8)
427 let dp: *u8 = sys_mmap(BF_PATHCAP)
428 let fp: *u8 = sys_mmap(BF_PATHCAP)
429 let up: *u8 = sys_mmap(BF_PATHCAP)
430 let ep: *u8 = sys_mmap(BF_PATHCAP)
431 bf_mkpfx(dp, base, "d-" as *u8)
432 bf_mkpfx(fp, base, "f-" as *u8)
433 bf_mkpfx(up, base, "neverseeded-" as *u8)
434 bf_mkpfx(ep, base, "view.tsv" as *u8)
435 let cx: *i64 = sys_mmap(64) as *i64
436 let fq: *u8 = sys_mmap(BF_CAP)
437 let sp: *i64 = sys_mmap(BF_SPAN) as *i64
438 // seed the debt scratch plane: sev8 open + sev5 open (below) + sev9 eaten + sev7 open w/ TAB in desc + DUP-epoch sev6 open
439 let dbuf: *u8 = sys_mmap(BF_CAP)
440 var dl: i64 = 0
441 dl = bf_cat(dbuf, dl, "1000\t8\tscopeA\topen\thigh sev open A\n" as *u8)
442 dl = bf_cat(dbuf, dl, "1001\t5\tscopeB\topen\tlow sev open B\n" as *u8)
443 dl = bf_cat(dbuf, dl, "1002\t9\tscopeC\teaten\teaten high C\n" as *u8)
444 dl = bf_cat(dbuf, dl, "1003\t7\tscopeD\topen\ttabbed\tdesc D\n" as *u8)
445 dl = bf_cat(dbuf, dl, "1000\t6\tscopeE\topen\tdup epoch E\n" as *u8)
446 let sd: i64 = sts_seed(dp, dbuf, dl)
447 // seed the frontier scratch plane: baseline F001 (D) + F002 (T)
448 let fbuf: *u8 = sys_mmap(BF_CAP)
449 var fl: i64 = 0
450 fl = bf_cat(fbuf, fl, "F001\tbase row\t8\t1\tteam\tD\t-\t-\tday0\n" as *u8)
451 fl = bf_cat(fbuf, fl, "F002\tsecond base\t7\t1\tteam\tT\t-\t-\tauto\n" as *u8)
452 let sf: i64 = sts_seed(fp, fbuf, fl)
453 var ok0: i64 = 0
454 if sd == 5 { if sf == 2 { ok0 = 1 } }
455 gv_check("T1 scratch planes seeded (5 debt rows, 2 frontier rows)" as *u8, ok0, ctr)
456 // T2 scan is read-only and counts exactly the eligible: sev>=6 open = 3 (8, 7-tabbed, 6-dup-epoch)
457 let rc2: i64 = bf_sweep(dp, fp, 6, 5, "team" as *u8, "auto" as *u8, ep, 0, cx)
458 var ok2: i64 = 0
459 if rc2 == 0 { if cx[3] == 3 { if cx[0] == 3 { if cx[1] == 0 { ok2 = 1 } } } }
460 gv_check("T2 scan finds exactly the open sev>=minsev debts (eaten + low-sev excluded)" as *u8, ok2, ctr)
461 // T3 run commits 3 rows with auto ids F003.. and distinct D025-safe markers
462 let rc3: i64 = bf_sweep(dp, fp, 6, 5, "team" as *u8, "auto" as *u8, ep, 1, cx)
463 let fn3: i64 = sts_load(fp, fq, BF_CAP)
464 var ok3: i64 = 0
465 if rc3 == 0 { if cx[0] == 3 { if bf_find(fq, fn3, "[FEED:debt:1000.0]" as *u8) == 1 { if bf_find(fq, fn3, "[FEED:debt:1003.0]" as *u8) == 1 { if bf_find(fq, fn3, "[FEED:debt:1000.1]" as *u8) == 1 { ok3 = 1 } } } } }
466 gv_check("T3 run commits 3 rows; dup-epoch debts get DISTINCT markers (D025 defense)" as *u8, ok3, ctr)
467 // T4 neg-controls: low-sev and eaten debts are NEVER fed
468 var ok4: i64 = 0
469 if bf_find(fq, fn3, "[FEED:debt:1001.0]" as *u8) == 0 { if bf_find(fq, fn3, "[FEED:debt:1002.0]" as *u8) == 0 { ok4 = 1 } }
470 gv_check("T4 neg-control low-sev + eaten debts never fed" as *u8, ok4, ctr)
471 // T5 THE negative tooth: re-run on unchanged evidence adds ZERO rows
472 let rc5: i64 = bf_sweep(dp, fp, 6, 5, "team" as *u8, "auto" as *u8, ep, 1, cx)
473 let fn5: i64 = sts_load(fp, fq, BF_CAP)
474 var ok5: i64 = 0
475 if rc5 == 0 { if cx[0] == 0 { if cx[1] == 3 { if fn5 == fn3 { ok5 = 1 } } } }
476 gv_check("T5 NEG rerun on unchanged evidence adds ZERO rows (plane bytes untouched)" as *u8, ok5, ctr)
477 // T6 honest row shape: weight col == debt sev, status T, deps -, lane arg, auto id F003; tabbed desc sanitized to 8 tabs
478 var ok6: i64 = 0
479 var w6: i64 = 0
480 if bf_row_col(fq, fn5, "[FEED:debt:1000.0]" as *u8, 2, sp) == 1 { if bf_lit_eq(fq, sp[0], sp[1], "8" as *u8) == 1 { w6 = w6 + 1 } }
481 if bf_row_col(fq, fn5, "[FEED:debt:1000.0]" as *u8, 5, sp) == 1 { if bf_lit_eq(fq, sp[0], sp[1], "T" as *u8) == 1 { w6 = w6 + 1 } }
482 if bf_row_col(fq, fn5, "[FEED:debt:1000.0]" as *u8, 6, sp) == 1 { if bf_lit_eq(fq, sp[0], sp[1], "-" as *u8) == 1 { w6 = w6 + 1 } }
483 if bf_row_col(fq, fn5, "[FEED:debt:1000.0]" as *u8, 8, sp) == 1 { if bf_lit_eq(fq, sp[0], sp[1], "auto" as *u8) == 1 { w6 = w6 + 1 } }
484 if bf_row_col(fq, fn5, "[FEED:debt:1000.0]" as *u8, 0, sp) == 1 { if bf_lit_eq(fq, sp[0], sp[1], "F003" as *u8) == 1 { w6 = w6 + 1 } }
485 if bf_row_tabs(fq, fn5, "[FEED:debt:1003.0]" as *u8) == 8 { w6 = w6 + 1 }
486 if w6 == 6 { ok6 = 1 }
487 gv_check("T6 row honesty: weight==sev, status T, deps -, lane, auto id, tab-sanitized 9col" as *u8, ok6, ctr)
488 // T7 per-run cap honored on a fresh baseline (re-seed frontier)
489 let sf7: i64 = sts_seed(fp, fbuf, fl)
490 let rc7: i64 = bf_sweep(dp, fp, 6, 1, "team" as *u8, "auto" as *u8, ep, 1, cx)
491 var ok7: i64 = 0
492 if sf7 == 2 { if rc7 == 0 { if cx[0] == 1 { if cx[2] == 2 { ok7 = 1 } } } }
493 gv_check("T7 per-run cap honored and overflow reported (added 1 capped 2)" as *u8, ok7, ctr)
494 // T8 fail-closed: run against a NEVER-seeded frontier plane refuses, commits nothing
495 let rc8: i64 = bf_sweep(dp, up, 6, 5, "team" as *u8, "auto" as *u8, ep, 1, cx)
496 var ok8: i64 = 0
497 if rc8 == 1 { ok8 = 1 }
498 gv_check("T8 fail-closed on unseeded frontier plane (nothing committed)" as *u8, ok8, ctr)
499 // T9 id monotonicity: after the capped run (F003), the next run adds the remaining 2 as F004+F005, no dup ids
500 let rc9: i64 = bf_sweep(dp, fp, 6, 5, "team" as *u8, "auto" as *u8, ep, 1, cx)
501 let fn9: i64 = sts_load(fp, fq, BF_CAP)
502 var ok9: i64 = 0
503 if rc9 == 0 { if cx[0] == 2 { if bf_count_id(fq, fn9, "F003" as *u8) == 1 { if bf_count_id(fq, fn9, "F004" as *u8) == 1 { if bf_count_id(fq, fn9, "F005" as *u8) == 1 { ok9 = 1 } } } } }
504 gv_check("T9 auto ids stay monotonic + unique across capped runs (no dup id)" as *u8, ok9, ctr)
505 let rc: i64 = gv_verdict("BFEED-GATE" as *u8, ctr, "evidence->frontier feeder teeth green" as *u8)
506 return rc
507}
508
509func main(argc: i64, argv: *i64) -> i64 {
510 if argc < 2 { bf_werr("usage: nx_backlog_feeder {scan <minsev> <maxfile> [dpfx] [fpfx] | run <minsev> <maxfile> <owner> <lane> [dpfx] [fpfx] [expath] | selftest <scratch-base>}\n" as *u8); sys_exit(BF_EXIT_USAGE); return BF_EXIT_USAGE }
511 let verb: *u8 = argv[1] as *u8
512 let vl: i64 = bf_vlen(verb)
513 if bf_lit_eq(verb, 0, vl, "selftest" as *u8) == 1 {
514 if argc < 3 { bf_werr("selftest needs <scratch-base>\n" as *u8); sys_exit(BF_EXIT_USAGE); return BF_EXIT_USAGE }
515 let rc: i64 = bf_selftest(argv[2] as *u8)
516 sys_exit(rc)
517 return rc
518 }
519 var dpfx: *u8 = "knowledge/store/debt-" as *u8
520 var fpfx: *u8 = "knowledge/store/frontier-" as *u8
521 var expath: *u8 = "knowledge/registry/frontier_queue.tsv" as *u8
522 let cx: *i64 = sys_mmap(64) as *i64
523 let d: *u8 = sys_mmap(BF_OUTJSON)
524 if bf_lit_eq(verb, 0, vl, "scan" as *u8) == 1 {
525 if argc < 4 { bf_werr("scan needs <minsev> <maxfile>\n" as *u8); sys_exit(BF_EXIT_USAGE); return BF_EXIT_USAGE }
526 if argc > 4 { dpfx = argv[4] as *u8 }
527 if argc > 5 { fpfx = argv[5] as *u8 }
528 let minsev: i64 = bf_atoi_c(argv[2] as *u8)
529 let maxfile: i64 = bf_atoi_c(argv[3] as *u8)
530 if minsev < 1 { bf_werr("FEED-FAIL minsev must be 1..9\n" as *u8); sys_exit(1); return 1 }
531 if minsev > 9 { bf_werr("FEED-FAIL minsev must be 1..9\n" as *u8); sys_exit(1); return 1 }
532 if maxfile < 1 { bf_werr("FEED-FAIL maxfile must be >=1\n" as *u8); sys_exit(1); return 1 }
533 let rc: i64 = bf_sweep(dpfx, fpfx, minsev, maxfile, "scan" as *u8, "scan" as *u8, expath, 0, cx)
534 if rc != 0 { sys_exit(1); return 1 }
535 let n: i64 = bf_summary(d, "scan" as *u8, cx, minsev, maxfile)
536 sys_write(1, d, n)
537 sys_exit(0)
538 return 0
539 }
540 if bf_lit_eq(verb, 0, vl, "run" as *u8) == 1 {
541 if argc < 6 { bf_werr("run needs <minsev> <maxfile> <owner> <lane>\n" as *u8); sys_exit(BF_EXIT_USAGE); return BF_EXIT_USAGE }
542 if argc > 6 { dpfx = argv[6] as *u8 }
543 if argc > 7 { fpfx = argv[7] as *u8 }
544 if argc > 8 { expath = argv[8] as *u8 }
545 let minsev: i64 = bf_atoi_c(argv[2] as *u8)
546 let maxfile: i64 = bf_atoi_c(argv[3] as *u8)
547 if minsev < 1 { bf_werr("FEED-FAIL minsev must be 1..9\n" as *u8); sys_exit(1); return 1 }
548 if minsev > 9 { bf_werr("FEED-FAIL minsev must be 1..9\n" as *u8); sys_exit(1); return 1 }
549 if maxfile < 1 { bf_werr("FEED-FAIL maxfile must be >=1\n" as *u8); sys_exit(1); return 1 }
550 let rc: i64 = bf_sweep(dpfx, fpfx, minsev, maxfile, argv[4] as *u8, argv[5] as *u8, expath, 1, cx)
551 if rc != 0 { sys_exit(1); return 1 }
552 let n: i64 = bf_summary(d, "run" as *u8, cx, minsev, maxfile)
553 sys_write(1, d, n)
554 sys_exit(0)
555 return 0
556 }
557 bf_werr("usage: nx_backlog_feeder {scan <minsev> <maxfile> [dpfx] [fpfx] | run <minsev> <maxfile> <owner> <lane> [dpfx] [fpfx] [expath] | selftest <scratch-base>}\n" as *u8)
558 sys_exit(BF_EXIT_USAGE)
559 return BF_EXIT_USAGE
560}