nx_dbthyg.nx source
↩ module page · 175 lines · 8381 B
1// nx_dbthyg.nx -- debt-plane hygiene organ v2 (2026-07-19, sess claude_f749ee6c; fresh name to bust /api/build name-cache). VERBS: stats (default) | stale.
2import "nx_store_seed_lib.nx"
3import "nx_syscalls.nx"
4
5// ★★SAME 1MiB TRUNCATION BUG AS nx_debt_hygiene.nx, FIXED HERE TOO (seq1529, 2026-07-30). The debt- plane
6// grew past 1 MiB (1447748 bytes / 1540 rows) and this organ read the first megabyte and PRESENTED WHAT IT
7// SCANNED AS THE TOTAL: 1273 instead of 1540, and s9=2 instead of 23 -- 21 sev-9 debts invisible.
8// ★WHY THIS FILE MATTERS EVEN THOUGH nx_debt_hygiene.nx IS WHAT THE LIVE TOOL BUILDS: this is hygiene v2
9// (extra `stale` verb) under a DIFFERENT BASENAME -- deliberately renamed to bust a build name-cache -- so
10// nx_dup_source_check CANNOT SEE IT. Basename-dup detection is structurally blind to same-function/
11// different-name twins, and fixing only the copy the detector can see would have left the bug live in the
12// superset organ, ready to regress the moment anyone builds THIS one.
13const DH_CAP: i64 = 33554432
14const DH_TAB: i64 = 9
15const DH_NL: i64 = 10
16
17func dh_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
18func dh_cat(d: *u8, o: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { d[o] = s[i]; o = o + 1; i = i + 1 } return o }
19func dh_catn(d: *u8, o: i64, v: i64) -> i64 { let t: *u8 = sys_mmap(28); var m: i64 = v; 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[o] = t[k-1-i]; o = o + 1; i = i + 1 } return o }
20func dh_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] == (DH_NL as u8) { s = 0 } else { e = e + 1 } } } return e }
21func dh_col(q: *u8, ls: i64, le: i64, c: i64, out: *i64) -> i64 {
22 var col: i64 = 0
23 var p: i64 = ls
24 while col < c {
25 var s: i64 = 1
26 while s == 1 { if p >= le { return 0 } if q[p] == (DH_TAB as u8) { s = 0 } else { p = p + 1 } }
27 p = p + 1
28 col = col + 1
29 }
30 var e: i64 = p
31 var s2: i64 = 1
32 while s2 == 1 { if e >= le { s2 = 0 } else { if q[e] == (DH_TAB as u8) { s2 = 0 } else { e = e + 1 } } }
33 out[0] = p
34 out[1] = e
35 return 1
36}
37func dh_span_lit(q: *u8, s: i64, e: i64, lit: *u8) -> i64 {
38 var i: i64 = 0
39 while s + i < e { if lit[i] == (0 as u8) { return 0 } if q[s+i] != lit[i] { return 0 } i = i + 1 }
40 if lit[i] != (0 as u8) { return 0 }
41 return 1
42}
43func dh_streq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 } if b[i] != (0 as u8) { return 0 } return 1 }
44func dh_match_at(q: *u8, p: i64, he: i64, needle: *u8) -> i64 { var j: i64 = 0; while needle[j] != (0 as u8) { if p + j >= he { return 0 } if q[p+j] != needle[j] { return 0 } j = j + 1 } return 1 }
45func dh_find(q: *u8, hs: i64, he: i64, needle: *u8) -> i64 { var p: i64 = hs; while p < he { if dh_match_at(q, p, he, needle) == 1 { return 1 } p = p + 1 } return 0 }
46func dh_legacy(q: *u8, s: i64, e: i64) -> i64 {
47 if e - s < 8 { return 0 }
48 var i: i64 = s
49 while i < e { let c: i64 = q[i] as i64; if c < 48 { return 0 } if c > 57 { return 0 } i = i + 1 }
50 return 1
51}
52func dh_atoi(q: *u8, s: i64, e: i64) -> i64 { var v: i64 = 0; var i: i64 = s; while i < e { let c: i64 = q[i] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } i = i + 1 } return v }
53
54func dh_stale(q: *u8, n: i64) -> i64 {
55 let cs: *i64 = sys_mmap(16) as *i64
56 var idx: i64 = 0
57 var flagged: i64 = 0
58 var i: i64 = 0
59 while i < n {
60 let le: i64 = dh_le(q, i, n)
61 if dh_col(q, i, le, 3, cs) == 1 {
62 if dh_span_lit(q, cs[0], cs[1], "open" as *u8) == 1 {
63 var hit: i64 = 0
64 if dh_find(q, i, le, "MISDIAGNOS" as *u8) == 1 { hit = 1 }
65 if dh_find(q, i, le, "DOES NOT REPRODUCE" as *u8) == 1 { hit = 1 }
66 if dh_find(q, i, le, "verified-stale" as *u8) == 1 { hit = 1 }
67 if dh_find(q, i, le, "CLOSED 2026-07" as *u8) == 1 { hit = 1 }
68 if hit == 1 {
69 let m: *u8 = sys_mmap(256)
70 var o: i64 = dh_cat(m, 0, "idx=" as *u8)
71 o = dh_catn(m, o, idx)
72 o = dh_cat(m, o, " :: " as *u8)
73 var p: i64 = i
74 var cap: i64 = i + 96
75 if cap > le { cap = le }
76 while p < cap { if q[p] == (DH_TAB as u8) { m[o] = 32 as u8 } else { m[o] = q[p] } o = o + 1; p = p + 1 }
77 m[o] = DH_NL as u8
78 o = o + 1
79 sys_write(1, m, o)
80 flagged = flagged + 1
81 }
82 }
83 }
84 idx = idx + 1
85 i = le + 1
86 }
87 let f: *u8 = sys_mmap(64)
88 var fo: i64 = dh_cat(f, 0, "STALE-CANDIDATES flagged=" as *u8)
89 fo = dh_catn(f, fo, flagged)
90 f[fo] = DH_NL as u8
91 fo = fo + 1
92 sys_write(1, f, fo)
93 return 0
94}
95
96func main(argc: i64, argv: *i64) -> i64 {
97 var verb: *u8 = "stats" as *u8
98 var prefix: *u8 = "knowledge/store/debt-" as *u8
99 if argc > 1 { verb = argv[1] as *u8 }
100 if argc > 2 { prefix = argv[2] as *u8 }
101 let q: *u8 = sys_mmap(DH_CAP)
102 // sts_load returns ONLY bytes -- it cannot report what it failed to reach, so this organ was
103 // structurally incapable of noticing its own truncation. sts_load_honest fills flags[0]=declared q:n
104 // and flags[1]=rows found, which is what makes the truncation check below possible at all.
105 let dhf: *i64 = sys_mmap(64) as *i64
106 let n: i64 = sts_load_honest(prefix, q, DH_CAP, dhf)
107 if n <= 0 { dh_puts("DEBT-HYGIENE store empty / unseeded\n" as *u8); sys_exit(1); return 1 }
108 if dh_streq(verb, "stale" as *u8) == 1 { dh_stale(q, n); sys_exit(0); return 0 }
109 let c0: *i64 = sys_mmap(16) as *i64
110 let cs: *i64 = sys_mmap(16) as *i64
111 let cc: *i64 = sys_mmap(16) as *i64
112 let hist: *i64 = sys_mmap(80) as *i64
113 var total: i64 = 0
114 var open: i64 = 0
115 var eaten: i64 = 0
116 var gating: i64 = 0
117 var i: i64 = 0
118 while i < n {
119 let le: i64 = dh_le(q, i, n)
120 if dh_col(q, i, le, 0, c0) == 1 {
121 var sevcol: i64 = 2
122 if dh_legacy(q, c0[0], c0[1]) == 1 { sevcol = 1 }
123 if dh_col(q, i, le, 3, cs) == 1 {
124 total = total + 1
125 if dh_span_lit(q, cs[0], cs[1], "open" as *u8) == 1 {
126 open = open + 1
127 if dh_col(q, i, le, sevcol, cc) == 1 {
128 let sv: i64 = dh_atoi(q, cc[0], cc[1])
129 if sv >= 1 { if sv <= 9 { hist[sv] = hist[sv] + 1 } }
130 if sv >= 6 { gating = gating + 1 }
131 }
132 } else { eaten = eaten + 1 }
133 }
134 }
135 i = le + 1
136 }
137 let m: *u8 = sys_mmap(2048)
138 var o: i64 = 0
139 // ★TRUNCATION IN THE NUMBERS, NOT THE PROSE -- the same law the sibling organ now carries. declared is
140 // what the plane says it holds, scanned is what this run actually parsed; when they differ the verdict
141 // is untrustworthy and must say so where a reader cannot skip it.
142 var rowsinbuf: i64 = 0
143 var rb: i64 = 0
144 while rb < n { if q[rb] == (DH_NL as u8) { rowsinbuf = rowsinbuf + 1 } rb = rb + 1 }
145 var trunc: i64 = 0
146 if rowsinbuf != dhf[1] { trunc = 1 }
147 if total < dhf[0] { trunc = 1 }
148 o = dh_cat(m, o, "DEBT-HYGIENE truncated=" as *u8)
149 o = dh_catn(m, o, trunc)
150 o = dh_cat(m, o, " declared=" as *u8)
151 o = dh_catn(m, o, dhf[0])
152 o = dh_cat(m, o, " scanned=" as *u8)
153 o = dh_catn(m, o, rowsinbuf)
154 o = dh_cat(m, o, " total=" as *u8)
155 o = dh_catn(m, o, total)
156 o = dh_cat(m, o, " open=" as *u8)
157 o = dh_catn(m, o, open)
158 o = dh_cat(m, o, " eaten=" as *u8)
159 o = dh_catn(m, o, eaten)
160 o = dh_cat(m, o, " gating[open,sev>=6]=" as *u8)
161 o = dh_catn(m, o, gating)
162 o = dh_cat(m, o, " open-by-sev" as *u8)
163 var s: i64 = 9
164 while s >= 1 {
165 o = dh_cat(m, o, " s" as *u8)
166 o = dh_catn(m, o, s)
167 o = dh_cat(m, o, "=" as *u8)
168 o = dh_catn(m, o, hist[s])
169 s = s - 1
170 }
171 o = dh_cat(m, o, "\n" as *u8)
172 sys_write(1, m, o)
173 sys_exit(0)
174 return 0
175}