code wiki / _hdl_build / nx_feed.nx
nx_feed.nx source
↩ module page · 210 lines · 9421 B
1// nx_feed.nx -- F208: THE AUTONOMOUS BACKLOG FEEDER (2026-07-20). The "growing" in the
2// growing-from-god-graph: turns MEASURED maturity gaps into PROPOSED backlog rows so the
3// backlog grows from evidence, autonomously, with the PM triaging -- the rollup's own
4// autonomy + maturity-measurement domains both name this organ as their next rung.
5// COMPOSES, never re-derives: input = a captured nx_ecosystem_maturity_rollup output
6// (the blessed gap deriver); coverage = the frontier seg-store; output = the feedq- plane,
7// a DERIVED VIEW re-seeded per run (sts_seed whole-snapshot semantics = idempotent and
8// SELF-CLEARING: when coverage lands, the proposal drops off the next run). It NEVER
9// writes the frontier SSOT -- propose, don't pollute; promotion = PM copies a row.
10// argv: <rollup-capture> <frontier-prefix> <feedq-prefix>
11// Coverage rule (v1, honest): extract F-ids (F+digits, up to 4) from each domain's next-rung
12// slug; covered iff EVERY extracted id exists in the frontier store (any status). No ids
13// extractable -> always propose (PM dedups; over-proposal is cheap in a staging plane).
14// Proposed row = frontier 9-col format so promotion is literally a row copy. Weight derived
15// from the maturity gap: ordinal ranks TOY=1 FUNCTIONAL=2 PRODUCTION=3 EXCEED=4 S-CLASS=5,
16// w = FEED_W_BASE + (bar - cur) (rank map is definitional ordinal data, commented not hidden).
17// Report: NX-FEED domains=N parsed / covered=N / proposed=N + one PROPOSE line per row.
18// exit 0 = ran (proposals are data, not failures); 2 = usage/inputs.
19// license_tier: ORIGINAL No hw writes (Rule 26).
20import "nx_seat_drive_lib.nx"
21import "nx_store_seed_lib.nx"
22import "nx_seg_store.nx"
23import "nx_deploy_lib.nx"
24import "nx_syscalls.nx"
25
26const FD_CAP: i64 = 1048576
27const FD_MAXIDS: i64 = 4
28const FD_W_BASE: i64 = 4
29
30// ordinal maturity rank (definitional): TOY=1 FUNCTIONAL=2 PRODUCTION=3 EXCEED=4 S-CLASS=5
31func fd_rank(buf: *u8, s: i64, e: i64) -> i64 {
32 if e - s >= 3 {
33 if buf[s] == (84 as u8) { return 1 } // TOY
34 if buf[s] == (70 as u8) { return 2 } // FUNCTIONAL
35 if buf[s] == (80 as u8) { return 3 } // PRODUCTION
36 if buf[s] == (69 as u8) { return 4 } // EXCEED
37 if buf[s] == (83 as u8) { return 5 } // S-CLASS
38 }
39 return 0
40}
41
42// does the frontier buffer contain a row whose ID column equals ids[0..idn)? (row start = BOL)
43func fd_has_id(fbuf: *u8, fn: i64, idb: *u8, idn: i64) -> i64 {
44 var i: i64 = 0
45 var bol: i64 = 1
46 while i < fn {
47 if bol == 1 {
48 var k: i64 = 0
49 var hit: i64 = 1
50 var scanning: i64 = 1
51 while scanning == 1 {
52 if k >= idn { scanning = 0 } else {
53 var bc: i64 = 0
54 if i + k < fn { bc = fbuf[i + k] as i64 }
55 if bc == (idb[k] as i64) { k = k + 1 } else { hit = 0; scanning = 0 }
56 }
57 }
58 if hit == 1 { if i + idn < fn { if fbuf[i + idn] == (9 as u8) { return 1 } } }
59 }
60 let c: i64 = fbuf[i] as i64
61 if c == 10 { bol = 1 } else { bol = 0 }
62 i = i + 1
63 }
64 return 0
65}
66
67func main(argc: i64, argv: *i64) -> i64 {
68 if argc < 4 { sd_w("usage: nx_feed <rollup-capture> <frontier-prefix> <feedq-prefix>\n" as *u8); sys_exit(2); return 2 }
69 let rollp: *u8 = argv[1] as *u8
70 let frp: *u8 = argv[2] as *u8
71 let fqp: *u8 = argv[3] as *u8
72 let rb: *u8 = sys_mmap(FD_CAP)
73 let rn: i64 = dp_read(rollp, rb, FD_CAP)
74 if rn <= 0 { sd_w("NX-FEED rollup-capture unreadable\n" as *u8); sys_exit(2); return 2 }
75 let fbuf: *u8 = sys_mmap(FD_CAP)
76 let fn: i64 = sts_load(frp, fbuf, FD_CAP)
77
78 let outq: *u8 = sys_mmap(FD_CAP)
79 var qo: i64 = 0
80 var domains: i64 = 0
81 var covered: i64 = 0
82 var proposed: i64 = 0
83
84 var i: i64 = 0
85 while i < rn {
86 var le: i64 = i
87 var s1: i64 = 1
88 while s1 == 1 { if le >= rn { s1 = 0 } else { if rb[le] == (10 as u8) { s1 = 0 } else { le = le + 1 } } }
89 // a domain row contains " / " AND " next: "
90 var slash: i64 = 0 - 1
91 var nxt: i64 = 0 - 1
92 var p: i64 = i
93 while p + 7 < le {
94 if rb[p] == (32 as u8) { if rb[p+1] == (47 as u8) { if rb[p+2] == (32 as u8) { if slash < 0 { slash = p } } } }
95 if rb[p] == (110 as u8) { if rb[p+1] == (101 as u8) { if rb[p+2] == (120 as u8) { if rb[p+3] == (116 as u8) { if rb[p+4] == (58 as u8) { if rb[p+5] == (32 as u8) { nxt = p + 6; p = le } } } } } }
96 p = p + 1
97 }
98 if slash >= 0 { if nxt >= 0 {
99 domains = domains + 1
100 // domain = after "/ " to the next double-space
101 let ds: i64 = slash + 3
102 var de: i64 = ds
103 var s2: i64 = 1
104 while s2 == 1 { if de + 1 >= le { s2 = 0 } else { if rb[de] == (32 as u8) { if rb[de+1] == (32 as u8) { s2 = 0 } else { de = de + 1 } } else { de = de + 1 } } }
105 // ranks: first "[CUR -> BAR]" span after the domain
106 var cs: i64 = 0 - 1
107 var q: i64 = de
108 while q < le { if rb[q] == (91 as u8) { cs = q + 1; q = le } q = q + 1 }
109 var cur: i64 = 0
110 var bar: i64 = 0
111 if cs >= 0 {
112 var ce: i64 = cs
113 var s3: i64 = 1
114 while s3 == 1 { if ce >= le { s3 = 0 } else { if rb[ce] == (32 as u8) { s3 = 0 } else { ce = ce + 1 } } }
115 cur = fd_rank(rb, cs, ce)
116 var bs: i64 = ce
117 var s4: i64 = 1
118 while s4 == 1 { if bs + 2 >= le { s4 = 0 } else { if rb[bs] == (62 as u8) { bs = bs + 2; s4 = 0 } else { bs = bs + 1 } } }
119 var be: i64 = bs
120 var s5: i64 = 1
121 while s5 == 1 { if be >= le { s5 = 0 } else { if rb[be] == (93 as u8) { s5 = 0 } else { be = be + 1 } } }
122 bar = fd_rank(rb, bs, be)
123 }
124 var gap: i64 = bar - cur
125 if gap < 0 { gap = 0 }
126 // extract up to FD_MAXIDS F-ids from the rung slug [nxt..le)
127 let idbuf: *u8 = sys_mmap(256)
128 let idoff: *i64 = sys_mmap(8 * FD_MAXIDS) as *i64
129 let idlen: *i64 = sys_mmap(8 * FD_MAXIDS) as *i64
130 var nids: i64 = 0
131 var ibo: i64 = 0
132 var r: i64 = nxt
133 while r < le {
134 if rb[r] == (70 as u8) {
135 var re: i64 = r + 1
136 var s6: i64 = 1
137 while s6 == 1 { if re >= le { s6 = 0 } else { let c2: i64 = rb[re] as i64; if c2 >= 48 { if c2 <= 57 { re = re + 1 } else { s6 = 0 } } else { s6 = 0 } } }
138 if re > r + 1 { if nids < FD_MAXIDS {
139 idoff[nids] = ibo
140 idlen[nids] = re - r
141 var w2: i64 = r
142 while w2 < re { idbuf[ibo] = rb[w2]; ibo = ibo + 1; w2 = w2 + 1 }
143 nids = nids + 1
144 } }
145 r = re
146 } else { r = r + 1 }
147 }
148 // covered iff EVERY extracted id exists as a frontier row id
149 var cov: i64 = 0
150 if nids > 0 {
151 cov = 1
152 var ii: i64 = 0
153 while ii < nids {
154 let ip: *u8 = ((idbuf as i64) + idoff[ii]) as *u8
155 if fd_has_id(fbuf, fn, ip, idlen[ii]) == 0 { cov = 0 }
156 ii = ii + 1
157 }
158 }
159 if cov == 1 { covered = covered + 1 } else {
160 proposed = proposed + 1
161 // 9-col frontier-format proposal row into the feedq staging buffer
162 qo = sd_cat(outq, qo, "Q" as *u8)
163 qo = sd_num(outq, qo, proposed)
164 qo = sd_cat(outq, qo, "\t" as *u8)
165 var dcp: i64 = ds
166 while dcp < de { outq[qo] = rb[dcp]; qo = qo + 1; dcp = dcp + 1 }
167 qo = sd_cat(outq, qo, "-gap: " as *u8)
168 var rcp: i64 = nxt
169 while rcp < le { outq[qo] = rb[rcp]; qo = qo + 1; rcp = rcp + 1 }
170 qo = sd_cat(outq, qo, "\t" as *u8)
171 qo = sd_num(outq, qo, FD_W_BASE + gap)
172 qo = sd_cat(outq, qo, "\t0\tpm\tT\t\tfeed\t" as *u8)
173 dcp = ds
174 while dcp < de { outq[qo] = rb[dcp]; qo = qo + 1; dcp = dcp + 1 }
175 qo = sd_cat(outq, qo, "\n" as *u8)
176 sd_w("PROPOSE " as *u8)
177 dcp = ds
178 let nb2: *u8 = sys_mmap(280)
179 var no2: i64 = 0
180 while dcp < de { nb2[no2] = rb[dcp]; no2 = no2 + 1; dcp = dcp + 1 }
181 nb2[no2] = 0 as u8
182 sd_w(nb2)
183 sd_w(" w=" as *u8)
184 let wb: *u8 = sys_mmap(24)
185 sd_num(wb, 0, FD_W_BASE + gap)
186 sd_w(wb)
187 sd_w("\n" as *u8)
188 }
189 } }
190 i = le + 1
191 }
192
193 let seeded: i64 = sts_seed(fqp, outq, qo)
194 sd_w("NX-FEED domains=" as *u8)
195 let nb: *u8 = sys_mmap(64)
196 sd_num(nb, 0, domains)
197 sd_w(nb)
198 sd_w(" covered=" as *u8)
199 sd_num(nb, 0, covered)
200 sd_w(nb)
201 sd_w(" proposed=" as *u8)
202 sd_num(nb, 0, proposed)
203 sd_w(nb)
204 sd_w(" seeded_rows=" as *u8)
205 sd_num(nb, 0, seeded)
206 sd_w(nb)
207 sd_w("\n" as *u8)
208 sys_exit(0)
209 return 0
210}