code wiki / _hdl_build / nx_gap_to_queue.nx
nx_gap_to_queue.nx source
↩ module page · 151 lines · 7518 B
1// nx_gap_to_queue.nx -- AUTONOMOUS WORK GENERATOR (the Gartner/benchmark
2// pattern: measure -> analyze -> the GAP becomes work, with no human pick).
3// Reads the team's OWN evidence (knowledge/status/rung_grades.log) and turns
4// every RED or ABSENT rung into a deterministic "close this rung" assignment
5// appended to knowledge/registry/assignment_queue.tsv -- IDEMPOTENT (a GEN-
6// CLOSE-RN id already present is skipped, so re-running every beat adds 0
7// dupes; a rung that goes GREEN stops generating). This is how the ecosystem
8// grows itself: the same loop a future bench panel feeds (NishiLang-vs-C row
9// LOSS -> a beat-C assignment) -- the grade IS the backlog.
10// Emits GAPGEN rows to knowledge/status/gap_gen.log; exit 0 (a generator, not
11// a gate). license_tier: ORIGINAL
12import "nx_syscalls.nx"
13const K_MAGIC_524288: i64 = 524288
14const K_MAGIC_1048576: i64 = 1048576
15
16func gq_w(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
17func gq_wn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48;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{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
18
19func gq_read(path: *u8, buf: *u8, cap: i64) -> i64 {
20 let fd: i64 = sys_openat_rd(path)
21 if fd < 0 { return 0 }
22 var n: i64 = 0
23 var r: i64 = sys_read(fd, buf, cap - 1)
24 while r > 0 { n = n + r; if n >= cap - 1 { r = 0 } else { r = sys_read(fd, buf + n, cap - 1 - n) } }
25 sys_close(fd)
26 return n
27}
28
29func gq_at(buf: *u8, n: i64, i: i64, pat: *u8, pl: i64) -> i64 {
30 if i + pl > n { return 0 }
31 var k: i64 = 0
32 while k < pl { if buf[i + k] != pat[k] { return 0 } k = k + 1 }
33 return 1
34}
35
36func gq_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
37
38func gq_contains(buf: *u8, n: i64, pat: *u8) -> i64 {
39 let pl: i64 = gq_len(pat)
40 var i: i64 = 0
41 while i + pl <= n { if gq_at(buf, n, i, pat, pl) == 1 { return 1 } i = i + 1 }
42 return 0
43}
44
45// grade of the LAST RUNGGRADE line for rung name (e.g. "R3"): returns
46// 0=GREEN 1=RED 2=ABSENT -1=not-found. Scans for "rung=<name> " then "grade=".
47func gq_grade(buf: *u8, n: i64, rname: *u8) -> i64 {
48 let rl: i64 = gq_len(rname)
49 var result: i64 = 0 - 1
50 var ls: i64 = 0
51 var i: i64 = 0
52 while i <= n {
53 var eol: i64 = 0
54 if i == n { eol = 1 } else { if buf[i] == (10 as u8) { eol = 1 } }
55 if eol == 1 {
56 // line [ls,i): contains "rung=<name> "?
57 var j: i64 = ls
58 var hit: i64 = 0
59 while j < i {
60 if gq_at(buf, n, j, "rung=" as *u8, 5) == 1 {
61 if gq_at(buf, n, j + 5, rname, rl) == 1 {
62 if buf[j + 5 + rl] == (32 as u8) { hit = 1 }
63 }
64 }
65 j = j + 1
66 }
67 if hit == 1 {
68 // find grade= in the line
69 var q: i64 = ls
70 while q < i {
71 if gq_at(buf, n, q, "grade=" as *u8, 6) == 1 {
72 let g: i64 = q + 6
73 if gq_at(buf, n, g, "GREEN" as *u8, 5) == 1 { result = 0 }
74 if gq_at(buf, n, g, "RED" as *u8, 3) == 1 { result = 1 }
75 if gq_at(buf, n, g, "ABSENT" as *u8, 6) == 1 { result = 2 }
76 q = i
77 }
78 q = q + 1
79 }
80 }
81 ls = i + 1
82 }
83 i = i + 1
84 }
85 return result
86}
87
88func main() -> i64 {
89 let gb: *u8 = sys_mmap(K_MAGIC_524288)
90 let gn: i64 = gq_read("knowledge/status/rung_grades.log" as *u8, gb, K_MAGIC_524288)
91 if gn <= 0 { gq_w(1, "GAPGEN verdict=RED reason=no-grades (run nx_rung_grade first)\n" as *u8); sys_exit(101) }
92 let qb: *u8 = sys_mmap(K_MAGIC_1048576)
93 let qn: i64 = gq_read("knowledge/registry/assignment_queue.tsv" as *u8, qb, K_MAGIC_1048576)
94
95 let qf: i64 = sys_openat_append("knowledge/registry/assignment_queue.tsv" as *u8, 0x1a4)
96 let lf: i64 = sys_openat_append("knowledge/status/gap_gen.log" as *u8, 0x1a4)
97 var generated: i64 = 0
98 var ru: i64 = 0
99 while ru < 9 {
100 let nm: *u8 = sys_mmap(8)
101 nm[0] = 82 as u8 // 'R'
102 nm[1] = (48 + ru) as u8
103 nm[2] = 0 as u8
104 let g: i64 = gq_grade(gb, gn, nm)
105 if g == 1 {
106 // RED: a close-to-green assignment (w8, work exists, drive it green)
107 let idp: *u8 = sys_mmap(32)
108 idp[0]=71 as u8; idp[1]=69 as u8; idp[2]=78 as u8; idp[3]=45 as u8 // "GEN-"
109 idp[4]=67 as u8; idp[5]=76 as u8; idp[6]=79 as u8; idp[7]=83 as u8; idp[8]=69 as u8; idp[9]=45 as u8 // "CLOSE-"
110 idp[10]=82 as u8; idp[11]=(48+ru) as u8; idp[12]=0 as u8
111 if gq_contains(qb, qn, idp) == 0 {
112 // CLOSE row is a concrete TODO with an AUTO-CLOSE marker: the
113 // moment the rung's grade flips GREEN in rung_grades.log,
114 // nx_reconcile flips this assignment DONE -- generate-from-gap
115 // and close-on-fix are the SAME loop, zero session.
116 gq_w(qf, idp); gq_w(qf, "\tR" as *u8); gq_wn(qf, ru)
117 gq_w(qf, "\t8\tM\tPM\tTODO\t-\trung-R" as *u8); gq_wn(qf, ru)
118 gq_w(qf, "-GREEN||MARK=knowledge/status/rung_grades.log::rung=R" as *u8); gq_wn(qf, ru)
119 gq_w(qf, " ::grade=GREEN\tdrive R" as *u8); gq_wn(qf, ru)
120 gq_w(qf, " from RED to GREEN (autogenerated; auto-closes when the grade flips)\n" as *u8)
121 gq_w(lf, "GAPGEN rung=R" as *u8); gq_wn(lf, ru); gq_w(lf, " grade=RED -> GEN-CLOSE row (auto-close marker) appended\n" as *u8)
122 generated = generated + 1
123 }
124 }
125 if g == 2 {
126 // ABSENT: open the ladder (w7, new spec+first gate)
127 let idp: *u8 = sys_mmap(32)
128 idp[0]=71 as u8; idp[1]=69 as u8; idp[2]=78 as u8; idp[3]=45 as u8
129 idp[4]=79 as u8; idp[5]=80 as u8; idp[6]=69 as u8; idp[7]=78 as u8; idp[8]=45 as u8 // "OPEN-"
130 idp[9]=82 as u8; idp[10]=(48+ru) as u8; idp[11]=0 as u8
131 if gq_contains(qb, qn, idp) == 0 {
132 // OPEN row = a multi-step ladder deliverable (spec + first gate);
133 // no single auto-close marker -- it closes when its own gate
134 // ships and a later migration/reconcile marks it (X-Q-003b).
135 gq_w(qf, idp); gq_w(qf, "\tR" as *u8); gq_wn(qf, ru)
136 gq_w(qf, "\t7\tL\tPM\tTODO\t-\trung-R" as *u8); gq_wn(qf, ru)
137 gq_w(qf, "-row-in-rung_gates.tsv\topen R" as *u8); gq_wn(qf, ru)
138 gq_w(qf, " ladder: spec + first gate (was ABSENT; autogenerated)\n" as *u8)
139 gq_w(lf, "GAPGEN rung=R" as *u8); gq_wn(lf, ru); gq_w(lf, " grade=ABSENT -> GEN-OPEN row appended\n" as *u8)
140 generated = generated + 1
141 }
142 }
143 ru = ru + 1
144 }
145 gq_w(lf, "GAPGEN-RUN generated=" as *u8); gq_wn(lf, generated); gq_w(lf, " epoch=" as *u8); gq_wn(lf, sys_now_realtime_sec()); gq_w(lf, " verdict=GREEN\n" as *u8)
146 if lf >= 0 { sys_close(lf) }
147 if qf >= 0 { sys_close(qf) }
148 gq_w(1, "GAPGEN generated=" as *u8); gq_wn(1, generated); gq_w(1, " (idempotent; RED->close ABSENT->open) verdict=GREEN\n" as *u8)
149 sys_exit(0)
150 return 0
151}