nx_workflowmine.nx source

1// nx_workflowmine.nx -- WORKFLOWS-CLASS MINER over the plan-/planrun- planes (miner-sota F1011, 2026-07-23). 2// The census (nx_minecov MC08) measured workflows at ZERO readers: plans EXECUTE via nx_plan_run and 3// nobody ever mines them, so a standing beat can rot silently. This derives, per tracked workflow: 4// DECLARED steps (plan- plane) vs RUN steps (planrun- plane), every step's rc, the FIRST failing 5// step id, and a health verdict that keeps three states DISTINCT: 6// NEVER-RUN (no results -- an honest unknown, NOT a failure) | FAILING (some rc != 0) | 7// PARTIAL (ran fewer steps than declared -- stopped early, or the plan grew) | HEALTHY. 8// Conflating never-run with failing is the exact dishonesty this organ exists to avoid. 9// Sources are declared as DATA (knowledge/status/workflow_plans.conf, hot-read); loader "-" reads them 10// as FILES (deterministic gate fixtures), else forks the ALLOWLIST-RESOLVED loader (nx_store_put load). 11// Composes nx_sovjson_lib (sj_*). Read-only. No hw writes (Rule 26). 12// mine <plansconf> [loader] -> JSON per-workflow + totals (healthy/failing/never_run/health_permil) 13// selftest <scratch-prefix> -> gate T1..T8 14// conf cols: id TAB plan_src TAB run_src TAB note planrun row: seq TAB rc=<n> TAB snippet 15// license_tier: ORIGINAL 16import "nx_sovjson_lib.nx" 17import "nx_syscalls.nx" 18import "nx_gate_verdict.nx" 19import "nx_tool_run.nx" 20const WM_MAGIC_4088: i64 = 4088 21 22const WM_CAP: i64 = 1048576 23const WM_CONF: i64 = 65536 24const WM_OUT: i64 = 65536 25const WM_PATH: i64 = 512 26const WM_ROWS: i64 = 64 27const WM_ALLOW: i64 = 131072 28const WM_PERMIL: i64 = 1000 29const WM_NAME_MAX: i64 = 120 30const WM_MODE_644: i64 = 420 31 32func wm_read(path: *u8, buf: *u8, cap: i64) -> i64 { 33 let fd: i64 = sys_openat_rd(path) 34 if fd < 0 { return -1 } 35 var n: i64 = 0 36 var go: i64 = 1 37 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 } } 38 sys_close(fd) 39 return n 40} 41func wm_find(q: *u8, n: i64, lit: *u8) -> i64 { 42 let ll: i64 = sj_vlen(lit) 43 if ll == 0 { return 0 } 44 var i: i64 = 0 45 while i + ll <= n { 46 var k: i64 = 0 47 var ok: i64 = 1 48 while k < ll { if q[i+k] != lit[k] { ok = 0; k = ll } else { k = k + 1 } } 49 if ok == 1 { return 1 } 50 i = i + 1 51 } 52 return 0 53} 54// DELEGATES to the shared base (rule-15 extraction 2026-07-23) 55func wm_allow_path(name: *u8, outp: *u8) -> i64 { return sj_allow_path(name, outp) } 56func wm_key(d: *u8, o: i64, name: *u8) -> i64 { 57 d[o] = 34 as u8 58 var p: i64 = o + 1 59 p = sj_cat(d, p, name) 60 d[p] = 34 as u8 61 p = p + 1 62 d[p] = 58 as u8 63 p = p + 1 64 return p 65} 66// load one source into buf. lok<0 => file mode. returns bytes, -1 absent/empty. 67func wm_load(src: *u8, lp: *u8, lok: i64, buf: *u8) -> i64 { 68 if lok == 0 { 69 let n: i64 = wm_read(src, buf, WM_CAP - 8) 70 if n <= 0 { return -1 } 71 return n 72 } 73 let av: *i64 = sys_mmap(64) as *i64 74 av[0] = lp as i64 75 av[1] = src as i64 76 av[2] = "load" as *u8 as i64 77 av[3] = 0 78 let cl: *i64 = sys_mmap(16) as *i64 79 let ex: i64 = tr_run_capture(lp, av, buf, WM_CAP - 8, cl) 80 if ex != 0 { return -1 } 81 if cl[0] <= 0 { return -1 } 82 return cl[0] 83} 84func wm_rows(q: *u8, n: i64) -> i64 { 85 var c: i64 = 0 86 var i: i64 = 0 87 while i < n { 88 let le: i64 = sj_le(q, i, n) 89 if le > i { if q[i] != (35 as u8) { c = c + 1 } } 90 i = le + 1 91 } 92 return c 93} 94// walk a planrun dump: rcx[0]=steps rcx[1]=failed rcx[2]=first-failing-seq rcx[3]=malformed 95func wm_scan_run(q: *u8, n: i64, rcx: *i64) -> i64 { 96 rcx[0] = 0 97 rcx[1] = 0 98 rcx[2] = 0 - 1 99 rcx[3] = 0 100 let sp: *i64 = sys_mmap(16) as *i64 101 var i: i64 = 0 102 while i < n { 103 let le: i64 = sj_le(q, i, n) 104 if le > i { if q[i] != (35 as u8) { 105 if sj_col(q, i, le, 1, sp) == 0 { rcx[3] = rcx[3] + 1 } else { 106 var s: i64 = sp[0] 107 var okrc: i64 = 0 108 if s + 3 <= sp[1] { if q[s] == (114 as u8) { if q[s+1] == (99 as u8) { if q[s+2] == (61 as u8) { okrc = 1 } } } } 109 if okrc == 0 { rcx[3] = rcx[3] + 1 } else { 110 rcx[0] = rcx[0] + 1 111 var v: i64 = 0 112 var neg: i64 = 0 113 var k: i64 = s + 3 114 if k < sp[1] { if q[k] == (45 as u8) { neg = 1; k = k + 1 } } 115 while k < sp[1] { let c: i64 = q[k] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } k = k + 1 } 116 if neg == 1 { v = 0 - v } 117 if v != 0 { 118 rcx[1] = rcx[1] + 1 119 if rcx[2] < 0 { if sj_col(q, i, le, 0, sp) == 1 { rcx[2] = sj_atoi_span(q, sp[0], sp[1]) } } 120 } 121 } 122 } 123 } } 124 i = le + 1 125 } 126 return 0 127} 128func wm_mine_json(conf: *u8, loader: *u8, d: *u8) -> i64 { 129 let cb: *u8 = sys_mmap(WM_CONF) 130 let cn: i64 = wm_read(conf, cb, WM_CONF - 8) 131 if cn <= 0 { return -1 } 132 let lp: *u8 = sys_mmap(WM_PATH) 133 var lok: i64 = 0 134 if sj_lit_eq(loader, 0, sj_vlen(loader), "-" as *u8) == 0 { lok = wm_allow_path(loader, lp) } 135 let sp: *i64 = sys_mmap(16) as *i64 136 let srcb: *u8 = sys_mmap(WM_PATH) 137 let runb: *u8 = sys_mmap(WM_PATH) 138 let pbuf: *u8 = sys_mmap(WM_CAP) 139 let rbuf: *u8 = sys_mmap(WM_CAP) 140 let rcx: *i64 = sys_mmap(64) as *i64 141 var p: i64 = 0 142 d[p] = 123 as u8; p = p + 1 143 p = wm_key(d, p, "v" as *u8); p = sj_catn(d, p, 1); d[p] = 44 as u8; p = p + 1 144 p = wm_key(d, p, "tool" as *u8) 145 d[p] = 34 as u8; p = p + 1 146 p = sj_cat(d, p, "nx_workflowmine" as *u8) 147 d[p] = 34 as u8; p = p + 1 148 d[p] = 44 as u8; p = p + 1 149 p = wm_key(d, p, "averb" as *u8) 150 d[p] = 34 as u8; p = p + 1 151 p = sj_cat(d, p, "mine" as *u8) 152 d[p] = 34 as u8; p = p + 1 153 d[p] = 44 as u8; p = p + 1 154 p = wm_key(d, p, "conf" as *u8) 155 d[p] = 34 as u8; p = p + 1 156 p = sj_cat_esc(d, p, conf, 0, sj_vlen(conf), WM_NAME_MAX) 157 d[p] = 34 as u8; p = p + 1 158 d[p] = 44 as u8; p = p + 1 159 p = wm_key(d, p, "loader_resolved" as *u8); p = sj_catn(d, p, lok); d[p] = 44 as u8; p = p + 1 160 p = wm_key(d, p, "workflows" as *u8) 161 d[p] = 91 as u8; p = p + 1 162 var nwf: i64 = 0 163 var healthy: i64 = 0 164 var failing: i64 = 0 165 var never: i64 = 0 166 var partial: i64 = 0 167 var shown: i64 = 0 168 var capped: i64 = 0 169 var efirst: i64 = 1 170 var i: i64 = 0 171 while i < cn { 172 let le: i64 = sj_le(cb, i, cn) 173 var ok: i64 = 0 174 if le > i { if cb[i] != (35 as u8) { if sj_col(cb, i, le, 2, sp) == 1 { ok = 1 } } } 175 if ok == 1 { 176 nwf = nwf + 1 177 sj_col(cb, i, le, 1, sp) 178 var k: i64 = 0 179 while sp[0]+k < sp[1] { if k < WM_PATH - 2 { srcb[k] = cb[sp[0]+k] } k = k + 1 } 180 srcb[k] = 0 as u8 181 sj_col(cb, i, le, 2, sp) 182 var k2: i64 = 0 183 while sp[0]+k2 < sp[1] { if k2 < WM_PATH - 2 { runb[k2] = cb[sp[0]+k2] } k2 = k2 + 1 } 184 runb[k2] = 0 as u8 185 let pn: i64 = wm_load(srcb, lp, lok, pbuf) 186 var declared: i64 = 0 187 if pn > 0 { declared = wm_rows(pbuf, pn) } 188 let rn: i64 = wm_load(runb, lp, lok, rbuf) 189 if rn > 0 { wm_scan_run(rbuf, rn, rcx) } else { rcx[0] = 0; rcx[1] = 0; rcx[2] = 0 - 1; rcx[3] = 0 } 190 // health: NEVER-RUN is an honest unknown, never counted as a failure 191 var health: i64 = 0 192 if rcx[0] == 0 { health = 0; never = never + 1 } else { 193 if rcx[1] > 0 { health = 1; failing = failing + 1 } else { 194 if rcx[0] < declared { health = 2; partial = partial + 1 } else { health = 3; healthy = healthy + 1 } 195 } 196 } 197 if shown >= WM_ROWS { capped = 1 } else { 198 if efirst == 0 { d[p] = 44 as u8; p = p + 1 } 199 efirst = 0 200 d[p] = 123 as u8; p = p + 1 201 p = wm_key(d, p, "id" as *u8) 202 sj_col(cb, i, le, 0, sp) 203 d[p] = 34 as u8; p = p + 1 204 p = sj_cat_esc(d, p, cb, sp[0], sp[1], WM_NAME_MAX) 205 d[p] = 34 as u8; p = p + 1 206 d[p] = 44 as u8; p = p + 1 207 p = wm_key(d, p, "health" as *u8) 208 d[p] = 34 as u8; p = p + 1 209 if health == 0 { p = sj_cat(d, p, "NEVER-RUN" as *u8) } else { 210 if health == 1 { p = sj_cat(d, p, "FAILING" as *u8) } else { 211 if health == 2 { p = sj_cat(d, p, "PARTIAL" as *u8) } else { p = sj_cat(d, p, "HEALTHY" as *u8) } 212 } 213 } 214 d[p] = 34 as u8; p = p + 1 215 d[p] = 44 as u8; p = p + 1 216 p = wm_key(d, p, "declared" as *u8); p = sj_catn(d, p, declared); d[p] = 44 as u8; p = p + 1 217 p = wm_key(d, p, "ran" as *u8); p = sj_catn(d, p, rcx[0]); d[p] = 44 as u8; p = p + 1 218 p = wm_key(d, p, "failed" as *u8); p = sj_catn(d, p, rcx[1]); d[p] = 44 as u8; p = p + 1 219 p = wm_key(d, p, "first_fail_step" as *u8); p = sj_catn(d, p, rcx[2]); d[p] = 44 as u8; p = p + 1 220 p = wm_key(d, p, "malformed" as *u8); p = sj_catn(d, p, rcx[3]) 221 d[p] = 125 as u8; p = p + 1 222 shown = shown + 1 223 } 224 } 225 i = le + 1 226 } 227 d[p] = 93 as u8; p = p + 1 228 d[p] = 44 as u8; p = p + 1 229 p = wm_key(d, p, "count" as *u8); p = sj_catn(d, p, nwf); d[p] = 44 as u8; p = p + 1 230 p = wm_key(d, p, "healthy" as *u8); p = sj_catn(d, p, healthy); d[p] = 44 as u8; p = p + 1 231 p = wm_key(d, p, "partial" as *u8); p = sj_catn(d, p, partial); d[p] = 44 as u8; p = p + 1 232 p = wm_key(d, p, "failing" as *u8); p = sj_catn(d, p, failing); d[p] = 44 as u8; p = p + 1 233 p = wm_key(d, p, "never_run" as *u8); p = sj_catn(d, p, never); d[p] = 44 as u8; p = p + 1 234 var hp: i64 = 0 - 1 235 if nwf > 0 { hp = healthy * WM_PERMIL / nwf } 236 p = wm_key(d, p, "health_permil" as *u8); p = sj_catn(d, p, hp); d[p] = 44 as u8; p = p + 1 237 p = wm_key(d, p, "rows_capped" as *u8); p = sj_catn(d, p, capped) 238 d[p] = 125 as u8; p = p + 1 239 d[p] = 10 as u8; p = p + 1 240 return p 241} 242func wm_selftest(prefix: *u8) -> i64 { 243 let ctr: *i64 = gv_ctr() 244 gv_head("nx_workflowmine selftest -- workflow health teeth (never-run is NOT failing)" as *u8) 245 let base: *u8 = sys_mmap(WM_PATH) 246 var o: i64 = sj_cat(base, 0, prefix) 247 o = sj_catn(base, o, sys_now_realtime_sec()) 248 base[o] = 0 as u8 249 let mk: *u8 = sys_mmap(WM_PATH) 250 let lb: *u8 = sys_mmap(WM_MAGIC_4088) 251 // WA healthy 2/2 ok ; WB failing (step 20 rc=-1) ; WC partial (2 declared, 1 ran ok) ; WD never-run 252 o = sj_cat(mk, 0, base) 253 o = sj_cat(mk, o, ".wa.plan" as *u8) 254 mk[o] = 0 as u8 255 var fd: i64 = sys_openat_wr(mk, WM_MODE_644) 256 var lo: i64 = sj_cat(lb, 0, "10\ttoolA\tverb\n20\ttoolB\tverb\n" as *u8) 257 sys_write(fd, lb, lo) 258 sys_close(fd) 259 o = sj_cat(mk, 0, base) 260 o = sj_cat(mk, o, ".wa.run" as *u8) 261 mk[o] = 0 as u8 262 fd = sys_openat_wr(mk, WM_MODE_644) 263 lo = sj_cat(lb, 0, "10\trc=0\tfine\n20\trc=0\tfine\n" as *u8) 264 sys_write(fd, lb, lo) 265 sys_close(fd) 266 o = sj_cat(mk, 0, base) 267 o = sj_cat(mk, o, ".wb.plan" as *u8) 268 mk[o] = 0 as u8 269 fd = sys_openat_wr(mk, WM_MODE_644) 270 lo = sj_cat(lb, 0, "10\ttoolA\tverb\n20\ttoolB\tverb\n" as *u8) 271 sys_write(fd, lb, lo) 272 sys_close(fd) 273 o = sj_cat(mk, 0, base) 274 o = sj_cat(mk, o, ".wb.run" as *u8) 275 mk[o] = 0 as u8 276 fd = sys_openat_wr(mk, WM_MODE_644) 277 lo = sj_cat(lb, 0, "10\trc=0\tfine\n20\trc=-1\tboom\nnotarow\n" as *u8) 278 sys_write(fd, lb, lo) 279 sys_close(fd) 280 o = sj_cat(mk, 0, base) 281 o = sj_cat(mk, o, ".wc.plan" as *u8) 282 mk[o] = 0 as u8 283 fd = sys_openat_wr(mk, WM_MODE_644) 284 lo = sj_cat(lb, 0, "10\ttoolA\tverb\n20\ttoolB\tverb\n" as *u8) 285 sys_write(fd, lb, lo) 286 sys_close(fd) 287 o = sj_cat(mk, 0, base) 288 o = sj_cat(mk, o, ".wc.run" as *u8) 289 mk[o] = 0 as u8 290 fd = sys_openat_wr(mk, WM_MODE_644) 291 lo = sj_cat(lb, 0, "10\trc=0\tfine\n" as *u8) 292 sys_write(fd, lb, lo) 293 sys_close(fd) 294 o = sj_cat(mk, 0, base) 295 o = sj_cat(mk, o, ".wd.plan" as *u8) 296 mk[o] = 0 as u8 297 fd = sys_openat_wr(mk, WM_MODE_644) 298 lo = sj_cat(lb, 0, "10\ttoolA\tverb\n" as *u8) 299 sys_write(fd, lb, lo) 300 sys_close(fd) 301 // conf 302 let cf: *u8 = sys_mmap(WM_PATH) 303 o = sj_cat(cf, 0, base) 304 o = sj_cat(cf, o, ".conf" as *u8) 305 cf[o] = 0 as u8 306 fd = sys_openat_wr(cf, WM_MODE_644) 307 lo = sj_cat(lb, 0, "# fixture\n" as *u8) 308 sys_write(fd, lb, lo) 309 lo = sj_cat(lb, 0, "WA\t" as *u8) 310 lo = sj_cat(lb, lo, base) 311 lo = sj_cat(lb, lo, ".wa.plan\t" as *u8) 312 lo = sj_cat(lb, lo, base) 313 lo = sj_cat(lb, lo, ".wa.run\thealthy\n" as *u8) 314 sys_write(fd, lb, lo) 315 lo = sj_cat(lb, 0, "WB\t" as *u8) 316 lo = sj_cat(lb, lo, base) 317 lo = sj_cat(lb, lo, ".wb.plan\t" as *u8) 318 lo = sj_cat(lb, lo, base) 319 lo = sj_cat(lb, lo, ".wb.run\tfailing\n" as *u8) 320 sys_write(fd, lb, lo) 321 lo = sj_cat(lb, 0, "WC\t" as *u8) 322 lo = sj_cat(lb, lo, base) 323 lo = sj_cat(lb, lo, ".wc.plan\t" as *u8) 324 lo = sj_cat(lb, lo, base) 325 lo = sj_cat(lb, lo, ".wc.run\tpartial\n" as *u8) 326 sys_write(fd, lb, lo) 327 lo = sj_cat(lb, 0, "WD\t" as *u8) 328 lo = sj_cat(lb, lo, base) 329 lo = sj_cat(lb, lo, ".wd.plan\t" as *u8) 330 lo = sj_cat(lb, lo, base) 331 lo = sj_cat(lb, lo, ".wd.absent\tnever run\n" as *u8) 332 sys_write(fd, lb, lo) 333 sys_close(fd) 334 let d: *u8 = sys_mmap(WM_OUT) 335 let miss: *u8 = sys_mmap(WM_PATH) 336 o = sj_cat(miss, 0, base) 337 o = sj_cat(miss, o, ".absentconf" as *u8) 338 miss[o] = 0 as u8 339 let r1: i64 = wm_mine_json(miss, "-" as *u8, d) 340 var ok1: i64 = 0 341 if r1 < 0 { ok1 = 1 } 342 gv_check("T1 missing plans conf refused fail closed" as *u8, ok1, ctr) 343 let dl: i64 = wm_mine_json(cf, "-" as *u8, d) 344 var ok2: i64 = 0 345 if dl > 0 { if wm_find(d, dl, "\"count\":4" as *u8) == 1 { ok2 = 1 } } 346 gv_check("T2 counts exactly the 4 declared workflows (comment skipped)" as *u8, ok2, ctr) 347 var ok3: i64 = 0 348 if wm_find(d, dl, "\"id\":\"WA\",\"health\":\"HEALTHY\",\"declared\":2,\"ran\":2,\"failed\":0,\"first_fail_step\":-1" as *u8) == 1 { ok3 = 1 } 349 gv_check("T3 all-zero rc plan reads HEALTHY with no fail step" as *u8, ok3, ctr) 350 var ok4: i64 = 0 351 if wm_find(d, dl, "\"id\":\"WB\",\"health\":\"FAILING\",\"declared\":2,\"ran\":2,\"failed\":1,\"first_fail_step\":20,\"malformed\":1" as *u8) == 1 { ok4 = 1 } 352 gv_check("T4 negative rc = FAILING and NAMES the first failing step (20); junk row counted" as *u8, ok4, ctr) 353 var ok5: i64 = 0 354 if wm_find(d, dl, "\"id\":\"WC\",\"health\":\"PARTIAL\",\"declared\":2,\"ran\":1,\"failed\":0" as *u8) == 1 { ok5 = 1 } 355 gv_check("T5 ran fewer steps than declared = PARTIAL, not healthy, not failing" as *u8, ok5, ctr) 356 var ok6: i64 = 0 357 if wm_find(d, dl, "\"id\":\"WD\",\"health\":\"NEVER-RUN\",\"declared\":1,\"ran\":0,\"failed\":0" as *u8) == 1 { ok6 = 1 } 358 gv_check("T6 absent results = NEVER-RUN (an honest unknown, never a failure)" as *u8, ok6, ctr) 359 var ok7: i64 = 0 360 if wm_find(d, dl, "\"healthy\":1,\"partial\":1,\"failing\":1,\"never_run\":1" as *u8) == 1 { ok7 = 1 } 361 gv_check("T7 the four states stay DISTINCT in the totals" as *u8, ok7, ctr) 362 var ok8: i64 = 0 363 if wm_find(d, dl, "\"health_permil\":250" as *u8) == 1 { ok8 = 1 } 364 gv_check("T8 health_permil exact 250 (1 healthy of 4)" as *u8, ok8, ctr) 365 let rc: i64 = gv_verdict("WORKFLOWMINE-GATE" as *u8, ctr, "workflow health: never-run distinguished from failing, partial from healthy, failing step named" as *u8) 366 return rc 367} 368 369func main(argc: i64, argv: *i64) -> i64 { 370 if argc < 3 { sj_puts("usage: nx_workflowmine {mine <plansconf> [loader|-] | selftest <scratch-prefix>}\n" as *u8); sys_exit(2); return 2 } 371 let verb: *u8 = argv[1] as *u8 372 let vl: i64 = sj_vlen(verb) 373 if sj_lit_eq(verb, 0, vl, "selftest" as *u8) == 1 { 374 let rc: i64 = wm_selftest(argv[2] as *u8) 375 sys_exit(rc) 376 return rc 377 } 378 if sj_lit_eq(verb, 0, vl, "mine" as *u8) == 1 { 379 let loader: *u8 = sys_mmap(128) 380 var lo: i64 = 0 381 if argc >= 4 { lo = sj_cat(loader, 0, argv[3] as *u8) } else { lo = sj_cat(loader, 0, "nx_store_put" as *u8) } 382 loader[lo] = 0 as u8 383 let d: *u8 = sys_mmap(WM_OUT) 384 let dl: i64 = wm_mine_json(argv[2] as *u8, loader, d) 385 if dl < 0 { sj_puts("REFUSED plans conf missing or empty\n" as *u8); sys_exit(3); return 3 } 386 sys_write(1, d, dl) 387 sys_exit(0) 388 return 0 389 } 390 sj_puts("unknown verb\n" as *u8) 391 sys_exit(2) 392 return 2 393}