code wiki / _hdl_build / nx_ecomat_lib.nx
`nx_ecomat_lib.nx` source

↩ module page · 836 lines · 46743 B
1// nx_ecomat_lib.nx -- shared core for the ECOSYSTEM MATURITY ROLLUP (the unifier), SOVEREIGN edition.
2// Operator: "get away from tsv and other 3rd party formats -- use the nishi ecosystem, get to S-class."
3// So the maturity chart lives in the NATIVE seg_store (knowledge/store/ecomat) as BINARY records (the
4// store's own ss_w32/ss_r32 codec -- no TSV, no delimiter format), and the rollup MEASURES from the
5// store + the live autonomy ledger, enforcing a LIAR-KILL (no S-CLASS claim without evidence).
6// Pairs with nx_seg_store (the sovereign store) + nx_maturity_auditor (the ladder). NO FLOAT.
7// RECORD layout (one value per domain, key "ecomat:dom:N"):
8//   w32@0 axis(0=DEPTH 1=BREADTH 2=META) | @4 layer | @8 cur | @12 bar | @16 weight | @20 ev
9//   @24: domain\0 bench\0 next_rung\0
10// license_tier: ORIGINAL
11import "nx_seg_store.nx"
12import "nx_syscalls.nx"
13// EC2 (2026-09-01): the ONE resolver for compare data split across two trees -- regen.list and every
14// <dom>.plan are buildroot-owned, and this lib's consumers run from BOTH the estate root and buildroot,
15// so a hand-rolled path here would be correct in one caller and a latent defect in the other.
16import "nx_comparetree_lib.nx"
17import "nx_maturity_auditor.nx"
18import "../nx_compare_growth_json.nx"
19
20const ECOMAT_STORE: *u8 = "knowledge/store/ecomat"
21
22// Byte offset where the record's 7 NUL-terminated strings begin (the w32 header occupies 0..31).
23// Named, not magic: it IS the record layout documented above ec_pack.
24const ECOMAT_REC_STRBASE: i64 = 32
25
26// Read-side scratch sizes for ec_str. Named so the ALLOCATION and the BOUND are the same symbol and
27// can never drift apart -- the drift is exactly how an unbounded copy turns into a silent overrun.
28const ECOMAT_DOM_CAP: i64 = 128
29const ECOMAT_NR_CAP: i64 = 160
30const ECOMAT_EVLOG_CAP: i64 = 256
31const ECOMAT_EVPAT_CAP: i64 = 64
32
33func el_len(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
34func _p(s: *u8) -> i64 { let n: i64=el_len(s); sys_write(1,s,n); return 0 }
35func _fp(fd: i64, s: *u8) -> i64 { let n: i64=el_len(s); sys_write(fd,s,n); return 0 }
36func _fn(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 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{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
37func el_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 }
38func el_match(buf: *u8, i: i64, pat: *u8, pl: i64) -> i64 { var k: i64=0; while k<pl { if buf[i+k]!=pat[k] { return 0 } k=k+1 } return 1 }
39
40// value of the LAST integer following pat in buf (e.g. "permil=") -- reads the live ledger, -1 if none.
41func el_last_after(buf: *u8, n: i64, pat: *u8) -> i64 {
  let pl: i64 = el_len(pat)
  var res: i64 = 0 - 1
  var i: i64 = 0
  while i + pl <= n {
      if el_match(buf, i, pat, pl) == 1 {
          var j: i64 = i + pl
          var v: i64 = 0
          var any: i64 = 0
          var go: i64 = 1
          while go == 1 {
              if j >= n { go = 0 } else {
                  let c: i64 = buf[j] as i64
                  var d: i64 = 0
                  if c >= 48 { if c <= 57 { d = 1 } }
                  if d == 1 { v = v*10 + (c-48); j = j + 1; any = 1 } else { go = 0 }
              }
          }
          if any == 1 { res = v }
      }
      i = i + 1
  }
  return res
64}
65
66// gate-liveness: is the LAST occurrence of pat (e.g. "verdict=") followed by "GREEN"? (handles RED-then-GREEN logs)
67func el_last_green(buf: *u8, n: i64, pat: *u8) -> i64 {
  let pl: i64 = el_len(pat)
  var res: i64 = 0
  var i: i64 = 0
  while i + pl <= n {
      if el_match(buf, i, pat, pl) == 1 {
          var ok: i64 = 0
          if el_match(buf, i + pl, "GREEN" as *u8, 5) == 1 { ok = 1 }
          if el_match(buf, i + pl, "PASS" as *u8, 4) == 1 { ok = 1 }
          if el_match(buf, i + pl, "VALID" as *u8, 5) == 1 { ok = 1 }
          res = ok
      }
      i = i + 1
  }
  return res
82}
83
84// ---- native seg_store record codec (no TSV) ----
85func ec_axis_label(a: i64) -> *u8 { if a==0 { return "DEPTH" as *u8 } if a==1 { return "BREADTH" as *u8 } return "META" as *u8 }
86func em_tri_label(t: i64) -> *u8 { if t==2 { return "[triangulated]" as *u8 } if t==3 { return "[CONFLICT]" as *u8 } if t==1 { return "[single-src]" as *u8 } if t==4 { return "[dangling]" as *u8 } return "[stored]" as *u8 }
87
88// key "ecomat:dom:N" into out
89func ec_key(k: i64, out: *u8) -> i64 {
  let p: *u8 = "ecomat:dom:" as *u8
  var o: i64 = 0
  var i: i64 = 0
  while p[i] != (0 as u8) { out[o]=p[i]; o=o+1; i=i+1 }
  if k == 0 { out[o]=48 as u8; o=o+1 } else { let t: *u8=sys_mmap(24); var m: i64=k; var n: i64=0; while m>0 { t[n]=(48+(m%10)) as u8; m=m/10; n=n+1 } var j: i64=0; while j<n { out[o]=t[n-1-j]; o=o+1; j=j+1 } }
  out[o]=0 as u8; return o
96}
97
98// BOUNDED append: returns the new offset, or -1 if the string plus its NUL would pass cap.
99// Fail-closed and PROPAGATING -- a negative offset in feeds a negative offset out, so one refusal
100// aborts the whole ec_pack chain instead of letting a half-written record reach the store.
101func ec_putstr(buf: *u8, cap: i64, off: i64, s: *u8) -> i64 {
  if off < 0 { return 0 - 1 }
  let n: i64 = el_len(s)
  if off + n + 1 > cap { return 0 - 1 }
  var o: i64 = off
  var i: i64 = 0
  while i < n { buf[o]=s[i]; o=o+1; i=i+1 }
  buf[o]=0 as u8
  return o + 1
110}
111
112// EXACT bytes ec_pack will write for these fields. Callers size the allocation from the DATA
113// instead of guessing a fixed cap, so an oversized row is impossible BY CONSTRUCTION rather than
114// rejected after the fact -- this is what let the lab-science domain die on a bogus "record too
115// large" while the seeder's 512-byte buffers were silently overrun.
116func ec_reclen(domain: *u8, bench: *u8, nextrung: *u8, evlog: *u8, evpat: *u8, evlog2: *u8, evpat2: *u8) -> i64 {
  var n: i64 = ECOMAT_REC_STRBASE
  n = n + el_len(domain) + 1
  n = n + el_len(bench) + 1
  n = n + el_len(nextrung) + 1
  n = n + el_len(evlog) + 1
  n = n + el_len(evpat) + 1
  n = n + el_len(evlog2) + 1
  n = n + el_len(evpat2) + 1
  return n
126}
127
128// pack a record into buf; return total byte length.
129// record: w32 @0 axis @4 layer @8 cur @12 bar @16 weight @20 ev @24 evkind @28 evkind2 ; strings @32
130// evkind/evkind2: 0=none 1=permil-derive 2=gate-liveness. TWO INDEPENDENT sources -> TRIANGULATION: a grade is
131// trusted only when its sources CONVERGE (<=1 level apart); divergence = CONFLICT (flagged); one source = SINGLE
132// (un-triangulated, flagged). The consensus is the conservative MIN -- never overclaim past the weaker witness.
133// cap = the writable size of buf. Returns the packed length, or -1 if buf cannot hold the record
134// (no partial write ever lands). Size buf with ec_reclen and this can only fire on a caller bug.
135func ec_pack(buf: *u8, cap: i64, axis: i64, layer: i64, cur: i64, bar: i64, weight: i64, ev: i64, evkind: i64, evkind2: i64, domain: *u8, bench: *u8, nextrung: *u8, evlog: *u8, evpat: *u8, evlog2: *u8, evpat2: *u8) -> i64 {
  if cap < ECOMAT_REC_STRBASE { return 0 - 1 }
  ss_w32(buf, 0, axis); ss_w32(buf, 4, layer); ss_w32(buf, 8, cur); ss_w32(buf, 12, bar); ss_w32(buf, 16, weight); ss_w32(buf, 20, ev); ss_w32(buf, 24, evkind); ss_w32(buf, 28, evkind2)
  var o: i64 = ECOMAT_REC_STRBASE
  o = ec_putstr(buf, cap, o, domain)
  o = ec_putstr(buf, cap, o, bench)
  o = ec_putstr(buf, cap, o, nextrung)
  o = ec_putstr(buf, cap, o, evlog)
  o = ec_putstr(buf, cap, o, evpat)
  o = ec_putstr(buf, cap, o, evlog2)
  o = ec_putstr(buf, cap, o, evpat2)
  return o
147}
148func ec_axis(v: *u8) -> i64 { return ss_r32(v, 0) }
149func ec_layer(v: *u8) -> i64 { return ss_r32(v, 4) }
150func ec_cur(v: *u8) -> i64 { return ss_r32(v, 8) }
151func ec_bar(v: *u8) -> i64 { return ss_r32(v, 12) }
152func ec_weight(v: *u8) -> i64 { return ss_r32(v, 16) }
153func ec_ev(v: *u8) -> i64 { return ss_r32(v, 20) }
154func ec_evkind(v: *u8) -> i64 { return ss_r32(v, 24) }
155func ec_evkind2(v: *u8) -> i64 { return ss_r32(v, 28) }
156// extract string field: which 0=domain 1=bench 2=next_rung 3=evlog 4=evpat 5=evlog2 6=evpat2
157// cap = writable size of out. Returns the field length, or -1 if it will not fit -- and on refusal
158// out is set EMPTY, never partially filled, so a caller that ignores the return reads "" rather than
159// a truncated-but-plausible domain name. Mirrors db_dec_str(g,out,cap); ec_str was the outlier that
160// copied a stored field into a fixed buffer with no idea how big that buffer was.
161func ec_str(v: *u8, which: i64, out: *u8, cap: i64) -> i64 {
  if cap < 1 { return 0 - 1 }
  out[0] = 0 as u8
  var off: i64 = ECOMAT_REC_STRBASE
  var idx: i64 = 0
  while idx < which { while v[off]!=(0 as u8){ off=off+1 } off=off+1; idx=idx+1 }
  var n: i64 = 0
  while v[off+n]!=(0 as u8){ n=n+1 }
  if n + 1 > cap { return 0 - 1 }
  var o: i64 = 0
  while o < n { out[o]=v[off+o]; o=o+1 }
  out[o]=0 as u8; return o
173}
174// STORED mode (no live source) -- used by the gates.
175func ec_seed_one(w: *i64, idx: i64, axis: i64, layer: i64, cur: i64, bar: i64, weight: i64, ev: i64, domain: *u8, bench: *u8, nextrung: *u8) -> i64 {
  let key: *u8 = sys_mmap(64); ec_key(idx, key)
  let cap: i64 = ec_reclen(domain, bench, nextrung, "" as *u8, "" as *u8, "" as *u8, "" as *u8)
  let val: *u8 = sys_mmap(cap); let vlen: i64 = ec_pack(val, cap, axis, layer, cur, bar, weight, ev, 0, 0, domain, bench, nextrung, "" as *u8, "" as *u8, "" as *u8, "" as *u8)
  if vlen < 0 { return 0 - 1 }
  if ss_add(w, 1, key, val, vlen) != 0 { return 0 - 1 }
  return 0
182}
183// SINGLE live source (un-triangulated).
184func ec_seed_one_ev(w: *i64, idx: i64, axis: i64, layer: i64, cur: i64, bar: i64, weight: i64, ev: i64, evkind: i64, domain: *u8, bench: *u8, nextrung: *u8, evlog: *u8, evpat: *u8) -> i64 {
  let key: *u8 = sys_mmap(64); ec_key(idx, key)
  let cap: i64 = ec_reclen(domain, bench, nextrung, evlog, evpat, "" as *u8, "" as *u8)
  let val: *u8 = sys_mmap(cap); let vlen: i64 = ec_pack(val, cap, axis, layer, cur, bar, weight, ev, evkind, 0, domain, bench, nextrung, evlog, evpat, "" as *u8, "" as *u8)
  if vlen < 0 { return 0 - 1 }
  if ss_add(w, 1, key, val, vlen) != 0 { return 0 - 1 }
  return 0
191}
192// TWO independent live sources -> the rollup TRIANGULATES (checks convergence).
193func ec_seed_two(w: *i64, idx: i64, axis: i64, layer: i64, cur: i64, bar: i64, weight: i64, ev: i64, evkind: i64, evkind2: i64, domain: *u8, bench: *u8, nextrung: *u8, evlog: *u8, evpat: *u8, evlog2: *u8, evpat2: *u8) -> i64 {
  let key: *u8 = sys_mmap(64); ec_key(idx, key)
  let cap: i64 = ec_reclen(domain, bench, nextrung, evlog, evpat, evlog2, evpat2)
  let val: *u8 = sys_mmap(cap); let vlen: i64 = ec_pack(val, cap, axis, layer, cur, bar, weight, ev, evkind, evkind2, domain, bench, nextrung, evlog, evpat, evlog2, evpat2)
  if vlen < 0 { return 0 - 1 }
  if ss_add(w, 1, key, val, vlen) != 0 { return 0 - 1 }
  return 0
200}
201
202// permil (0..1000) -> maturity level (0..5): live-derive a grade from a live meter so it can't rot.
203func permil_to_level(p: i64) -> i64 {
  // â›”A COVERAGE PERCENTAGE MUST NEVER REACH A RUNG THAT NAMES AN EVIDENCE PROPERTY.
  // nx_maturity_auditor defines MAT_SCLASS(4) as TRIANGULATED PARITY vs a named best-in-class
  // competitor and MAT_EXCEED(5) as a triangulated WIN. Those are CLAIMS ABOUT A COMPARISON, not
  // capability tiers. This function used to award them from a permil (p>=700 -> 4, p>=900 -> 5),
  // so a domain reporting high COVERAGE was stamped "parity with gcc/llvm" WITH NO COMPARISON
  // HAVING RUN -- the laundering path behind cov=1000 rows sitting in CLAIM-ONLY while
  // nx_sota_status reports PROVEN 0/40. Ceiling is now PRODUCTION(3); 4 and 5 require an explicit
  // comparator row (competitor + method + verdict), never a number.
  // INERT ON ADOPTION: the rollup reported sclass_plus=0, so no domain held 4 or 5 when this
  // landed -- it removes a FUTURE inflation path, it does not restate any current grade.
  if p >= 500 { return 3 }
  if p >= 150 { return 2 }
  return 1
217}
218
219// derive a maturity level from ONE evidence source. THREE distinct outcomes (the split is load-bearing):
220//   0..5  = a real MEASURED level (the source was readable and gave an answer)
221//   -1    = NO source declared (evkind 0) -- fall back to the stored assertion
222//   -2    = source DECLARED but DANGLING (file missing/unreadable, or evkind-1 pattern absent) -- we CANNOT measure
223// The -2 vs (1) distinction is the whole point: a RED gate (file PRESENT, verdict not GREEN) is a real
224// measurement of TOY(1); a MISSING gate is the ABSENCE of measurement (-2). Conflating them (the old bug)
225// let a dead evidence pointer read as a low-but-"measured" grade, and worse, two missing gates "converged"
226// at TOY and got stamped [triangulated] -- a validation claim with zero readable sources behind it.
227// evkind 1 = permil-derive (evlog's evpat reading -> level); 2 = gate-liveness (last evpat verdict GREEN/PASS
228// -> the stored level is live-confirmed, else PRESENT-but-not-GREEN = RED = demote to TOY).
229func em_derive_level(evkind: i64, evlog: *u8, evpat: *u8, stored: i64) -> i64 {
  if evkind == 0 { return 0 - 1 }
  let szp: *i64 = sys_mmap(16) as *i64
  let eb: *u8 = ss_readall(evlog, szp)
  let en: i64 = szp[0]
  // en == 0 is an EMPTY log: the file exists but carries no verdict. That is the ABSENCE of a
  // measurement, not a RED one, so it must be DANGLING like a missing file -- otherwise a gate
  // that opened its log and died before writing scores as a real TOY(1), and two such logs
  // "converge" at TOY and get stamped [triangulated]: a validation claim with zero readable
  // sources, which is the exact bug this split was introduced to kill.
  if en <= 0 { return 0 - 2 }
  if evkind == 1 {
      let p: i64 = el_last_after(eb, en, evpat)
      if p >= 0 { return permil_to_level(p) }
      return 0 - 2
  }
  if evkind == 2 {
      let g: i64 = el_last_green(eb, en, evpat)
      if g == 1 {
          // â›”A GREEN GATE PROVES THE CAPABILITY RUNS. IT SAYS NOTHING ABOUT A COMPETITOR.
          // MAT_SCLASS(4) and MAT_EXCEED(5) are defined as TRIANGULATED PARITY / WIN vs a NAMED
          // best-in-class. Gate-liveness is CAPABILITY evidence, so it can confirm at most
          // PRODUCTION(3). Letting a green gate carry a stored 4/5 through was the LAST path to
          // an unearned comparative rung, after permil_to_level was capped the same day.
          // Comparative rungs require an ADMITTED claim (nx_vsbest_lib: named competitor +
          // re-runnable method + readable evidence containing the declared pattern).
          // INERT ON ADOPTION: the rollup reported sclass_plus=0, so nothing is demoted by this;
          // it closes a FUTURE inflation path rather than restating any current grade.
          if stored > MAT_PRODUCTION { return MAT_PRODUCTION }
          return stored
      }
      return 1
  }
  return 0 - 1
263}
264
265// THE single source of truth for a domain's live grade + validation status -- used by BOTH the rollup
266// AND the page so they can never diverge. tout[0]: 0 stored / 1 single-src / 2 triangulated / 3 CONFLICT /
267// 4 DANGLING (a source was DECLARED but no witness is currently readable -> UNVERIFIED, never [triangulated]).
268// Two REAL measured witnesses -> conservative MIN consensus; convergence (<=1 apart) = triangulated, else conflict.
269// One readable witness -> single-src (the OTHER being absent OR dangling must NOT discard the readable one --
270// the old code fell straight to stored whenever witness-1 was unreadable, throwing away a live witness-2).
271func em_domain_level(v: *u8, tout: *i64) -> i64 {
  let stored: i64 = ec_cur(v)
  let evk1: i64 = ec_evkind(v)
  let evk2: i64 = ec_evkind2(v)
  let elog: *u8 = sys_mmap(ECOMAT_EVLOG_CAP)
  let epat: *u8 = sys_mmap(ECOMAT_EVPAT_CAP)
  let elog2: *u8 = sys_mmap(ECOMAT_EVLOG_CAP)
  let epat2: *u8 = sys_mmap(ECOMAT_EVPAT_CAP)
  ec_str(v, 3, elog, ECOMAT_EVLOG_CAP); ec_str(v, 4, epat, ECOMAT_EVPAT_CAP); ec_str(v, 5, elog2, ECOMAT_EVLOG_CAP); ec_str(v, 6, epat2, ECOMAT_EVPAT_CAP)
  let l1: i64 = em_derive_level(evk1, elog, epat, stored)
  let l2: i64 = em_derive_level(evk2, elog2, epat2, stored)
  let DANG: i64 = 0 - 2
  if l1 >= 0 {
      if l2 >= 0 {
          var diff: i64 = l1 - l2
          if diff < 0 { diff = 0 - diff }
          var lo: i64 = l1
          if l2 < lo { lo = l2 }
          if diff <= 1 { tout[0] = 2 } else { tout[0] = 3 }
          return lo
      }
      tout[0] = 1
      return l1
  }
  if l2 >= 0 {
      tout[0] = 1
      return l2
  }
  // NEITHER witness readable. A DECLARED-but-dangling pointer is UNVERIFIED (show the stored assertion,
  // flagged [dangling], counted apart, and -- via the rollup -- ev=0 so a high claim still liar-kills).
  // No pointer declared at all -> the honest stored baseline.
  if l1 == DANG { tout[0] = 4; return stored }
  if l2 == DANG { tout[0] = 4; return stored }
  tout[0] = 0
  return stored
306}
307
308// A ledger older than this is STALE: the rollup must not present it as "live".  Two days, so a
309// daily meter beat has a full miss of slack before it is called out, and a meter that has silently
310// stopped is named within 48h instead of within 23 days.
311const ECOMAT_AUTO_STALE_S: i64 = 172800
312
313// ---- the measured core: MEASURE from the store + the live autonomy ledger ----
314// out[0]=overall_permil out[1]=liar_kill out[2]=domains out[3]=sclass_plus
315// out[4]=absent out[5]=auto_permil out[6]=sum_cur out[7]=sum_bar ; returns 0 GREEN / 1 RED.
316func em_rollup_store(prefix: *u8, autolog: *u8, out: *i64, verbose: i64) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let abuf: *u8 = ss_readall(autolog, szp)
  var an: i64 = szp[0]
  if an < 0 { an = 0 }
  var auto_permil: i64 = 0 - 1
  if an > 0 { auto_permil = el_last_after(abuf, an, "permil=" as *u8) }
  // ★FIXED 2026-08-07 -- AGE THE LEDGER YOU ARE ABOUT TO CALL "LIVE".
  // This reader took the LAST permil= in the autonomy ledger and the rollup printed it under the
  // label "live autonomy", with NO freshness check of any kind.  MEASURED: the autonomy meter last
  // wrote on 2026-07-15; for 23 DAYS every rollup, page and dashboard published that frozen 328 as
  // a live figure, and the durable ecosystem_maturity.log recorded it hourly.  When the meter was
  // finally run the true value was 705 -- so the estate under-reported its own autonomy by 377
  // permil for three weeks, and nothing anywhere said the number was old.
  // A READER THAT LABELS ITS INPUT "LIVE" WITHOUT CHECKING ITS AGE LAUNDERS A STALE NUMBER INTO A
  // FRESH-LOOKING ONE.  Fixing the writer did not fix this; the reader is a separate defect.
  // out[12]=age_seconds of the newest ledger row (-1 = no epoch found), out[13]=1 if STALE.
  var auto_epoch: i64 = 0 - 1
  if an > 0 { auto_epoch = el_last_after(abuf, an, "epoch=" as *u8) }
  var auto_age: i64 = 0 - 1
  var auto_stale: i64 = 0
  if auto_epoch > 0 {
      auto_age = sys_now_realtime_sec() - auto_epoch
      if auto_age > ECOMAT_AUTO_STALE_S { auto_stale = 1 }
  }
  // No epoch at all is NOT freshness -- an unagedable ledger is treated as stale, fail-closed.
  if auto_epoch <= 0 { if an > 0 { auto_stale = 1 } }
  // DECLARE THE DENOMINATOR YOU AVERAGED OVER (2026-08-22), for exactly the reason the age is declared
  // above. nx_autonomy_meter averages ONLY the axes it could score and publishes `axes_known=N of_4 ...
  // verdict=PARTIAL` so a reader can tell a genuinely low grade from a partly blind one. MEASURED:
  // a3_daemon_runs=-1 with n3=0 (BOTH pulse ledgers ABSENT), so 705 is an average over THREE axes --
  // and every consumer printed it as a whole-system figure. An abstention nobody reads is a lie
  // nobody told. The 4-axis figure is NOT recoverable by rescaling: dividing by 4 treats an UNMEASURED
  // axis as a measured ZERO, the exact error the meter refuses. It is UNKNOWN, and we say so.
  // out[14]=axes_known (-1 = never declared), out[15]=1 when the average is PARTIAL.
  var auto_axes: i64 = 0 - 1
  if an > 0 { auto_axes = el_last_after(abuf, an, "axes_known=" as *u8) }
  var auto_partial: i64 = 0
  if auto_axes > 0 { if auto_axes < 4 { auto_partial = 1 } }
  out[14] = auto_axes
  out[15] = auto_partial
  let h: *i64 = ss_open(prefix)
  var sum_cur: i64 = 0
  var sum_bar: i64 = 0
  var domains: i64 = 0
  var bad: i64 = 0
  var sclass_plus: i64 = 0
  var absent: i64 = 0
  var triangulated: i64 = 0
  var conflict: i64 = 0
  var single: i64 = 0
  var dangling: i64 = 0
  let pq: *i64 = sys_mmap(16) as *i64
  let lq: *i64 = sys_mmap(16) as *i64
  let dom: *u8 = sys_mmap(ECOMAT_DOM_CAP)
  let nr: *u8 = sys_mmap(ECOMAT_NR_CAP)
  let elog: *u8 = sys_mmap(ECOMAT_EVLOG_CAP)
  let epat: *u8 = sys_mmap(ECOMAT_EVPAT_CAP)
  let elog2: *u8 = sys_mmap(ECOMAT_EVLOG_CAP)
  let epat2: *u8 = sys_mmap(ECOMAT_EVPAT_CAP)
  let szp2: *i64 = sys_mmap(16) as *i64
  if (h as i64) != 0 {
      var k: i64 = 0
      var go: i64 = 1
      while go == 1 {
          let key: *u8 = sys_mmap(64)
          ec_key(k, key)
          if ss_hget(h, key, pq, lq) == 1 {
              let v: *u8 = pq[0] as *u8
              ec_str(v, 0, dom, ECOMAT_DOM_CAP)
              var cur: i64 = ec_cur(v)
              let bar: i64 = ec_bar(v)
              var ev: i64 = ec_ev(v)
              // LIVE-DERIVE per the record's own evidence pointer (data-driven, anti-staleness): a grade
              // is only what its live source currently supports. evkind 1 = permil-derive the LEVEL from
              // evlog's evpat reading; 2 = gate-liveness (level holds while the gate is GREEN, else demote).
              // TRIANGULATE via the shared em_domain_level (same logic the page uses, so they can't diverge).
              let tout: *i64 = sys_mmap(16) as *i64
              let dl: i64 = em_domain_level(v, tout)
              let tstat: i64 = tout[0]
              // any derived status overrides the stored LEVEL; the EVIDENCE flag is set only when a witness
              // was actually READABLE (single/tri/conflict). DANGLING keeps ev=0 -> a high claim behind a
              // dead pointer still trips the liar-kill instead of hiding as a silently-demoted TOY.
              if tstat != 0 { cur = dl }
              if tstat == 1 { single = single + 1; ev = 1 }
              if tstat == 2 { triangulated = triangulated + 1; ev = 1 }
              if tstat == 3 { conflict = conflict + 1; ev = 1 }
              if tstat == 4 { dangling = dangling + 1; ev = 0 }
              var viol: i64 = 0
              if cur >= MAT_SCLASS { if ev == 0 { viol = 1 } }
              if viol == 1 { bad = bad + 1 }
              sum_cur = sum_cur + cur
              sum_bar = sum_bar + bar
              domains = domains + 1
              if cur >= MAT_SCLASS { sclass_plus = sclass_plus + 1 }
              if cur == 0 { absent = absent + 1 }
              if verbose == 1 {
                  ec_str(v, 0, dom, ECOMAT_DOM_CAP); ec_str(v, 2, nr, ECOMAT_NR_CAP)
                  let lc: *u8 = mat_label(cur)
                  let lb: *u8 = mat_label(bar)
                  let ax: *u8 = ec_axis_label(ec_axis(v))
                  _p("  " as *u8); _p(ax); _p(" / " as *u8); _p(dom); _p("  [" as *u8); _p(lc); _p(" -> " as *u8); _p(lb); _p("] " as *u8)
                  let tl: *u8 = em_tri_label(tstat); _p(tl); _p(" next: " as *u8); _p(nr)
                  if viol == 1 { _p("   <== LIAR-KILL: S-CLASS claim, no evidence" as *u8) }
                  _p("\n" as *u8)
              }
              k = k + 1
          } else { go = 0 }
      }
  }
  var permil: i64 = 0
  if sum_bar > 0 { permil = (1000 * sum_cur) / sum_bar }
  out[0] = permil; out[1] = bad; out[2] = domains; out[3] = sclass_plus
  out[4] = absent; out[5] = auto_permil; out[6] = sum_cur; out[7] = sum_bar
  out[8] = triangulated; out[9] = conflict; out[10] = single; out[11] = dangling
  out[12] = auto_age; out[13] = auto_stale
  if bad > 0 { return 1 }
  return 0
434}
435
436// ---- TARGET EMIT core (R1): the maturity gaps BECOME ranked work for the loop ----
437func el_contains(buf: *u8, n: i64, pat: *u8) -> i64 {
  let pl: i64 = el_len(pat)
  if pl == 0 { return 0 }
  var i: i64 = 0
  while i + pl <= n { if el_match(buf, i, pat, pl) == 1 { return 1 } i = i + 1 }
  return 0
443}
444// ---- EC2 (ecosystem rung, the roadmap ranker's #1 on 2026-09-01): PLAN COVERAGE AS A PUBLISHED ROW ----
445// MEASURED BY HAND 2026-08-21 and then never again: 70 domains, 63 with a plan, 7 without. A number that
446// lives in a session transcript is folklore by the next session. This emits the partition EVERY BEAT,
447// names every planless and ladderless domain (a count without a worklist is not actionable), asserts
448// planless + with_plan = rankable in the row itself, and attributes a ranking refusal to the MISSING PLAN
449// -- refusing a planless domain is the ranker behaving CORRECTLY and must never read as a ranker fault.
450// A domain with a plan but no ver| ladder is counted and named SEPARATELY: the weaker artifact must never
451// be counted as the stronger one, because a plan with no ladder ranks by value alone and sorts wrong for
452// the wrong reason. UNPROVEN is its own exit: an unreadable regen.list publishes NO counts, because an
453// empty population reading as zero-everything would be the vacuous-green defect wearing a census's name.
454const EPC_MODE_LOG: i64 = 0x1a4
455func em_plan_coverage(logpath: *u8) -> i64 {
  let outn: *i64 = sys_mmap(16) as *i64
  let which: *i64 = sys_mmap(16) as *i64
  let lst: *u8 = ct_compare_readall_published("regen" as *u8, ".list" as *u8, outn, which)
  let ln: i64 = outn[0]
  if ln <= 0 { _p("PLAN-COVERAGE UNPROVEN -- regen.list unreadable from either compare tree; no counts published\n" as *u8); return 3 }
  var rankable: i64 = 0
  var with_plan: i64 = 0
  var with_ladder: i64 = 0
  let pn: *i64 = sys_mmap(16) as *i64
  let pw: *i64 = sys_mmap(16) as *i64
  let lfd: i64 = sys_openat_append(logpath, EPC_MODE_LOG)
  var p: i64 = 0
  while p < ln {
      var e: i64 = p
      while e < ln { if lst[e] == (10 as u8) { break } e = e + 1 }
      var t: i64 = e
      if t > p { if lst[t-1] == (13 as u8) { t = t - 1 } }
      lst[t] = 0 as u8
      let dom: *u8 = ((lst as i64) + p) as *u8
      p = e + 1
      if dom[0] != (0 as u8) { if dom[0] != (35 as u8) {
          rankable = rankable + 1
          pn[0] = 0
          let pb: *u8 = ct_compare_readall_published(dom, ".plan" as *u8, pn, pw)
          if pn[0] > 0 {
              with_plan = with_plan + 1
              if el_contains(pb, pn[0], "\nver|" as *u8) == 1 { with_ladder = with_ladder + 1 } else {
                  _p("  NO-LADDER " as *u8); _p(dom); _p(" -- ranks by value alone; UNBLOCK: add ver| rows to its .plan\n" as *u8)
                  if lfd >= 0 { _fp(lfd, "NO-LADDER " as *u8); _fp(lfd, dom); _fp(lfd, "\n" as *u8) }
              }
              sys_free_file(pb, pn[0])
          } else {
              _p("  PLANLESS " as *u8); _p(dom); _p(" -- the ranker's refusal is CORRECT and attributed HERE, to the missing plan\n" as *u8)
              if lfd >= 0 { _fp(lfd, "PLANLESS " as *u8); _fp(lfd, dom); _fp(lfd, "\n" as *u8) }
          }
      } }
  }
  let planless: i64 = rankable - with_plan
  _p("PLAN-COVERAGE rankable=" as *u8); _fn(1, rankable)
  _p(" with_plan=" as *u8); _fn(1, with_plan)
  _p(" planless=" as *u8); _fn(1, planless)
  _p(" with_ladder=" as *u8); _fn(1, with_ladder)
  _p(" ladderless_planned=" as *u8); _fn(1, with_plan - with_ladder)
  _p(" (partition: with_plan+planless=rankable)\n" as *u8)
  if lfd >= 0 {
      _fp(lfd, "PLAN-COVERAGE epoch=" as *u8); _fn(lfd, sys_now_realtime_sec())
      _fp(lfd, " rankable=" as *u8); _fn(lfd, rankable)
      _fp(lfd, " with_plan=" as *u8); _fn(lfd, with_plan)
      _fp(lfd, " planless=" as *u8); _fn(lfd, planless)
      _fp(lfd, " with_ladder=" as *u8); _fn(lfd, with_ladder)
      _fp(lfd, "\n" as *u8)
      sys_close(lfd)
  }
  return 0
510}
511
512// ---- EC3 (ecosystem rung, ranked #2 on 2026-09-01): CONSUMERS CARRY THE ABSTENTION ----
513// The lib has DECLARED the denominator since 2026-08-22 (out[14]=axes_known, out[15]=partial) and every
514// consumer kept printing the bare permil -- 705 published as a whole-system figure while it averaged 3 of
515// 4 axes; the honest 4-axis reading is UNKNOWN, not 529, because dividing by 4 scores an unmeasured axis
516// as a measured zero. This is the ONE renderer of the autonomy figure: it writes the permil, brands it
517// -PARTIAL inline when the source was partial (so the number cannot be quoted without its caveat riding
518// inside the same token), and appends the machine-readable denominator. A parser taking digits after
519// permil= still reads the same value, so every existing trend reader is untouched -- strictly additive.
520func em_axes_known_guard(fd: i64, permil: i64, axes: i64, partial: i64) -> i64 {
  _fn(fd, permil)
  if partial == 1 { _fp(fd, "-PARTIAL" as *u8) }
  _fp(fd, " autonomy_axes_known=" as *u8); _fn(fd, axes)
  _fp(fd, " autonomy_partial=" as *u8); _fn(fd, partial)
  return partial
526}
527
528func et_mkid(domain: *u8, out: *u8) -> i64 {
  let pre: *u8 = "GEN-MAT-" as *u8
  var o: i64 = 0
  var i: i64 = 0
  while pre[i] != (0 as u8) { out[o]=pre[i]; o=o+1; i=i+1 }
  i = 0
  while domain[i] != (0 as u8) { out[o]=domain[i]; o=o+1; i=i+1 }
  out[o] = 0 as u8
  return o
537}
538func et_should_emit(domain: *u8, cur: i64, bar: i64, qb: *u8, qn: i64) -> i64 {
  if cur >= bar { return 0 }
  let idp: *u8 = sys_mmap(160)
  et_mkid(domain, idp)
  if el_contains(qb, qn, idp) == 1 { return 0 }
  return 1
544}
545// count the targets the emitter WOULD append, reading the STORE (gate proves this without the loop).
546func et_count_targets_store(prefix: *u8, qb: *u8, qn: i64) -> i64 {
  // ss_open_cached (seq905/962 class fix, seq1347 migration, 2026-07-30). SAFE: open -> ss_hget loop
  // against this same handle -> return; nothing re-enters the store while the handle is held.
  let h: *i64 = ss_open_cached(prefix)
  if (h as i64) == 0 { return 0 }
  let pq: *i64 = sys_mmap(16) as *i64
  let lq: *i64 = sys_mmap(16) as *i64
  let dom: *u8 = sys_mmap(ECOMAT_DOM_CAP)
  var cnt: i64 = 0
  var k: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let key: *u8 = sys_mmap(64)
      ec_key(k, key)
      if ss_hget(h, key, pq, lq) == 1 {
          let v: *u8 = pq[0] as *u8
          let cur: i64 = ec_cur(v)
          let bar: i64 = ec_bar(v)
          ec_str(v, 0, dom, ECOMAT_DOM_CAP)
          let se: i64 = et_should_emit(dom, cur, bar, qb, qn)
          if se == 1 { cnt = cnt + 1 }
          k = k + 1
      } else { go = 0 }
  }
  return cnt
571}
572
573// ---- R2 PUBLISH: emit the maturity dashboard as HTML (last-mile render, organ-authored) ----
574func pg_thead(buf: *u8, off: i64) -> i64 {
  return ss_cat(buf, off, "<tr><th>domain</th><th>level</th><th></th><th>target</th><th>next rung</th><th>w</th></tr>\n" as *u8)
576}
577// emit one <tr> per domain whose axis == want, reading the sovereign store.
578func pg_emit_axis(buf: *u8, off: i64, h: *i64, want: i64) -> i64 {
  var o: i64 = off
  let pq: *i64 = sys_mmap(16) as *i64
  let lq: *i64 = sys_mmap(16) as *i64
  let dom: *u8 = sys_mmap(ECOMAT_DOM_CAP)
  let nr: *u8 = sys_mmap(ECOMAT_NR_CAP)
  var k: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let key: *u8 = sys_mmap(64); ec_key(k, key)
      if ss_hget(h, key, pq, lq) == 1 {
          let v: *u8 = pq[0] as *u8
          if ec_axis(v) == want {
              let tout: *i64 = sys_mmap(16) as *i64
              let cur: i64 = em_domain_level(v, tout)
              let bar: i64 = ec_bar(v)
              let w: i64 = ec_weight(v)
              ec_str(v, 0, dom, ECOMAT_DOM_CAP); ec_str(v, 2, nr, ECOMAT_NR_CAP)
              let lc: *u8 = mat_label(cur)
              let lb: *u8 = mat_label(bar)
              let tlab: *u8 = em_tri_label(tout[0])
              o = ss_cat(buf, o, "<tr><td class=dom>" as *u8); o = ss_cat(buf, o, dom)
              o = ss_cat(buf, o, "</td><td><span class='b l" as *u8); o = ss_catn(buf, o, cur)
              o = ss_cat(buf, o, "'>" as *u8); o = ss_cat(buf, o, lc); o = ss_cat(buf, o, "</span> <span class=tri>" as *u8); o = ss_cat(buf, o, tlab); o = ss_cat(buf, o, "</span></td><td class=bar>" as *u8)
              var s: i64 = 0
              while s < 5 { if s < cur { o = ss_cat(buf, o, "&#9608;" as *u8) } else { o = ss_cat(buf, o, "&#9617;" as *u8) } s = s + 1 }
              o = ss_cat(buf, o, "</td><td>&#8594; " as *u8); o = ss_cat(buf, o, lb)
              o = ss_cat(buf, o, "</td><td class=nx>" as *u8); o = ss_cat(buf, o, nr)
              o = ss_cat(buf, o, "</td><td class=w>" as *u8); o = ss_catn(buf, o, w)
              o = ss_cat(buf, o, "</td></tr>\n" as *u8)
          }
          k = k + 1
      } else { go = 0 }
  }
  return o
613}
614// build the whole dashboard from the store + autonomy ledger, write to outhtml. Returns the
615// rollup verdict (0 GREEN, 1 RED liar-kill), or -1 if the store is missing. NO TSV, NO JS.
616func em_emit_page(prefix: *u8, autolog: *u8, outhtml: *u8) -> i64 {
  let out: *i64 = sys_mmap(256)
  let verdict: i64 = em_rollup_store(prefix, autolog, out, 0)
  let h: *i64 = ss_open(prefix)
  if (h as i64) == 0 { return 0 - 1 }
  let buf: *u8 = sys_mmap(262144)
  var o: i64 = 0
  o = ss_cat(buf, o, "<!doctype html><html lang=en><head><meta charset=utf-8><meta name=viewport content='width=device-width,initial-scale=1'><title>Nishi Ecosystem Maturity</title><style>" as *u8)
  o = ss_cat(buf, o, "body{margin:0;font:15px/1.5 -apple-system,Segoe UI,Roboto,sans-serif;background:#0e1116;color:#e6edf3}" as *u8)
  o = ss_cat(buf, o, "header{padding:32px 24px;background:linear-gradient(135deg,#161b22,#0e1116);border-bottom:1px solid #30363d}" as *u8)
  o = ss_cat(buf, o, "h1{margin:0 0 8px;font-size:22px}.big{font-size:54px;font-weight:800;color:#3fb950;line-height:1}" as *u8)
  o = ss_cat(buf, o, ".sub{color:#8b949e;font-size:14px;margin-top:6px}.track{height:10px;background:#21262d;border-radius:6px;margin-top:16px;max-width:640px;overflow:hidden}" as *u8)
  o = ss_cat(buf, o, ".fill{height:100%;background:linear-gradient(90deg,#1f6feb,#3fb950)}h2{margin:28px 24px 10px;font-size:13px;text-transform:uppercase;letter-spacing:.08em;color:#8b949e}" as *u8)
  o = ss_cat(buf, o, "table{border-collapse:collapse;margin:0 24px 8px;max-width:980px}td,th{padding:8px 10px;border-bottom:1px solid #21262d;text-align:left;font-size:14px}" as *u8)
  o = ss_cat(buf, o, "th{color:#8b949e;font-size:12px;text-transform:uppercase}.dom{font-weight:650}.bar{font-family:monospace;letter-spacing:2px;color:#3fb950}.nx{color:#8b949e;font-size:13px}.w{text-align:right;color:#d29922}.tri{font-size:11px;color:#6e7681}" as *u8)
  o = ss_cat(buf, o, ".b{display:inline-block;padding:2px 8px;border-radius:10px;font-size:12px;font-weight:600}" as *u8)
  o = ss_cat(buf, o, ".l0{background:#490202;color:#ff7b72}.l1{background:#5a1e02;color:#ffa657}.l2{background:#5c4302;color:#e3b341}.l3{background:#234d0a;color:#a5d65b}.l4{background:#0d4429;color:#3fb950}.l5{background:#0a3d62;color:#58a6ff}" as *u8)
  o = ss_cat(buf, o, "footer{padding:20px 24px;color:#6e7681;font-size:12px;border-top:1px solid #21262d;margin-top:20px}" as *u8)
  o = ss_cat(buf, o, "</style></head><body><header><h1>Nishi Ecosystem Maturity</h1><div class=big>" as *u8)
  o = ss_catn(buf, o, out[0]); o = ss_cat(buf, o, "&#8240;</div><div class=sub>toward S-class across " as *u8)
  o = ss_catn(buf, o, out[2]); o = ss_cat(buf, o, " domains &middot; " as *u8); o = ss_catn(buf, o, out[3])
  o = ss_cat(buf, o, " at S-class &middot; live autonomy " as *u8); o = ss_catn(buf, o, out[5]); o = ss_cat(buf, o, "&#8240; &middot; triangulated " as *u8); o = ss_catn(buf, o, out[8]); o = ss_cat(buf, o, "/" as *u8); o = ss_catn(buf, o, out[2]); o = ss_cat(buf, o, " &middot; conflicts " as *u8); o = ss_catn(buf, o, out[9]); o = ss_cat(buf, o, " &middot; dangling " as *u8); o = ss_catn(buf, o, out[11]); o = ss_cat(buf, o, "</div>" as *u8)
  let pct: i64 = out[0] / 10
  o = ss_cat(buf, o, "<div class=track><div class=fill style='width:" as *u8); o = ss_catn(buf, o, pct); o = ss_cat(buf, o, "%'></div></div></header>" as *u8)
  o = ss_cat(buf, o, "<h2>Depth &mdash; substrate</h2><table>" as *u8); o = pg_thead(buf, o); o = pg_emit_axis(buf, o, h, 0); o = ss_cat(buf, o, "</table>" as *u8)
  o = ss_cat(buf, o, "<h2>Breadth &mdash; products</h2><table>" as *u8); o = pg_thead(buf, o); o = pg_emit_axis(buf, o, h, 1); o = ss_cat(buf, o, "</table>" as *u8)
  o = ss_cat(buf, o, "<h2>Meta</h2><table>" as *u8); o = pg_thead(buf, o); o = pg_emit_axis(buf, o, h, 2); o = ss_cat(buf, o, "</table>" as *u8)
  o = ss_cat(buf, o, "<footer>sourced from the sovereign seg_store (knowledge/store/ecomat) &middot; no TSV &middot; generated epoch " as *u8)
  o = ss_catn(buf, o, sys_now_realtime_sec()); o = ss_cat(buf, o, " &middot; measured, never asserted" as *u8)
  if verdict != 0 { o = ss_cat(buf, o, " &middot; <b style=color:#ff7b72>LIAR-KILL FIRED</b>" as *u8) }
  o = ss_cat(buf, o, "</footer></body></html>\n" as *u8)
  ss_writefile(outhtml, buf, o)
  return verdict
649}
650
651// ---- shared target-emit loop (used by the emitter CLI AND the flywheel beat) ----
652// Caller holds the lock and supplies open append fds qf (queue) + lf (targets log). Iterates the store,
653// appends one TODO target per below-bar domain (idempotent vs qb), writes an auto-close marker per at-bar
654// domain. out[0]=emitted out[1]=done_marks. Returns 0, or -1 if the store is missing.
655func et_emit_targets_core(store: *u8, qb: *u8, qn: i64, qf: i64, lf: i64, out: *i64) -> i64 {
  let h: *i64 = ss_open(store)
  if (h as i64) == 0 { out[0] = 0; out[1] = 0; return 0 - 1 }
  let pq: *i64 = sys_mmap(16) as *i64
  let lq: *i64 = sys_mmap(16) as *i64
  let idp: *u8 = sys_mmap(160)
  let dom: *u8 = sys_mmap(ECOMAT_DOM_CAP)
  let nr: *u8 = sys_mmap(ECOMAT_NR_CAP)
  let szb: *u8 = sys_mmap(2)
  var emitted: i64 = 0
  var done_marks: i64 = 0
  var k: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let key: *u8 = sys_mmap(64); ec_key(k, key)
      if ss_hget(h, key, pq, lq) == 1 {
          let v: *u8 = pq[0] as *u8
          let cur: i64 = ec_cur(v)
          let bar: i64 = ec_bar(v)
          let w: i64 = ec_weight(v)
          ec_str(v, 0, dom, ECOMAT_DOM_CAP); ec_str(v, 2, nr, ECOMAT_NR_CAP)
          if cur >= bar {
              if lf >= 0 { _fp(lf, "ECOMAT-DONE domain=" as *u8); _fp(lf, dom); _fp(lf, " at-bar epoch=" as *u8); _fn(lf, sys_now_realtime_sec()); _fp(lf, "\n" as *u8) }
              done_marks = done_marks + 1
          } else {
              let se: i64 = et_should_emit(dom, cur, bar, qb, qn)
              if se == 1 {
                  et_mkid(dom, idp)
                  let gap: i64 = bar - cur
                  var sz: i64 = 83
                  if gap == 2 { sz = 77 }
                  if gap >= 3 { sz = 76 }
                  szb[0] = sz as u8; szb[1] = 0 as u8
                  _fp(qf, idp); _fp(qf, "\tMAT\t" as *u8); _fn(qf, w)
                  _fp(qf, "\t" as *u8); _fp(qf, szb)
                  _fp(qf, "\tPM\tTODO\t-\tecomat-" as *u8); _fp(qf, dom)
                  _fp(qf, "-at-bar||MARK=knowledge/status/ecomat_targets.log::ECOMAT-DONE domain=" as *u8); _fp(qf, dom)
                  _fp(qf, "\tmaturity target: raise " as *u8); _fp(qf, dom)
                  _fp(qf, " toward bar -- " as *u8); _fp(qf, nr)
                  _fp(qf, " (autogenerated; w=" as *u8); _fn(qf, w)
                  _fp(qf, "; auto-closes when domain reaches bar)\n" as *u8)
                  if lf >= 0 { _fp(lf, "ECOMAT-TARGET id=" as *u8); _fp(lf, idp); _fp(lf, " w=" as *u8); _fn(lf, w); _fp(lf, " gap=" as *u8); _fn(lf, gap); _fp(lf, "\n" as *u8) }
                  emitted = emitted + 1
              }
          }
          k = k + 1
      } else { go = 0 }
  }
  out[0] = emitted
  out[1] = done_marks
  return 0
706}
707
708// Additive requirements-v1: authored investment contract, never a maturity scorer.
709const EM_REQUIREMENT_COUNT:i64=6
710func em_req_id(i:i64)->*u8 {
if i==0 {return "defined" as *u8}
if i==1 {return "callable" as *u8}
if i==2 {return "composable" as *u8}
if i==3 {return "dependable" as *u8}
if i==4 {return "adaptive" as *u8}
if i==5 {return "frontier-qualified" as *u8}
return "" as *u8
718}
719func em_req_label(i:i64)->*u8 {
if i==0 {return "Defined" as *u8}
if i==1 {return "Callable" as *u8}
if i==2 {return "Composable" as *u8}
if i==3 {return "Dependable" as *u8}
if i==4 {return "Adaptive" as *u8}
if i==5 {return "Frontier-qualified" as *u8}
return "" as *u8
727}
728func em_req_is(b:*u8,p:i64,e:i64,col:i64,s:*u8)->i64 {
var o:i64=0;let n:i64=bf_field(b,p,e,col,&o)
return pb_equal(b,o,n,s,0,bf_slen(s))
731}
732func em_req_validate(b:*u8,n:i64)->i64 {
if n<=0 {return -1}
if pb_input_ok(b,n)==0 {return -1}
if b[n-1]!=(10 as u8) {return -1}
var p:i64=0;var r:i64=0;var investments:i64=0
while p<n {
let raw:i64=bf_line_end(b,n,p);let e:i64=pb_trim_cr(b,p,raw)
var fields:i64=0;var scratch:i64=0
let req:i64=bf_line_starts(b,p,e,"maturityrequirement|")
let inv:i64=bf_line_starts(b,p,e,"maturityinvestment|")
if req+inv!=1 {return -2}
if req==1 {fields=8} else {fields=12}
if pb_field_count(b,p,e,&scratch)!=fields {return -2}
var c:i64=1;while c<fields {if bf_field(b,p,e,c,&scratch)<=0 {return -2};c=c+1}
if em_req_is(b,p,e,1,"1")==0 {return -3}
let idn:i64=bf_field(b,p,e,2,&scratch)
if cg_ident(b,scratch,idn)==0 {return -3}
var prev:i64=0
while prev<p {let pe:i64=bf_line_end(b,n,prev);var po:i64=0;let pn:i64=bf_field(b,prev,pe,2,&po);if pb_equal(b,scratch,idn,b,po,pn)==1 {return -4};prev=pe+1}
if req==1 {
 if investments>0||r>=EM_REQUIREMENT_COUNT {return -5}
 if em_req_is(b,p,e,2,em_req_id(r))==0||em_req_is(b,p,e,3,em_req_label(r))==0 {return -5}
 var dep:*u8="-" as *u8;if r>0 {dep=em_req_id(r-1)}
 if em_req_is(b,p,e,4,dep)==0 {return -5}
 r=r+1
} else {
 if r!=EM_REQUIREMENT_COUNT {return -5}
 var io:i64=0;let bn:i64=bf_field(b,p,e,3,&io);if cg_ident(b,io,bn)==0 {return -3}
 let cn:i64=bf_field(b,p,e,4,&io);if cg_ident(b,io,cn)==0 {return -3}
 if em_req_is(b,p,e,11,"pending-acceptance")==0 {return -6}
 investments=investments+1
}
p=raw+1
}
if r!=EM_REQUIREMENT_COUNT||investments==0 {return -5}
return investments
768}
769func em_req_key(col:i64,kind:i64)->*u8 {
if col==2 {return "id" as *u8}
if kind==1 {
if col==3 {return "label" as *u8};if col==4 {return "prerequisite" as *u8}
if col==5 {return "required_evidence" as *u8};if col==6 {return "acceptance_rule" as *u8}
return "workflow_steps" as *u8
}
if col==3 {return "board" as *u8};if col==4 {return "capability_id" as *u8}
if col==5 {return "operator_priority" as *u8};if col==6 {return "dependency_refs_authored" as *u8}
if col==7 {return "evidence_refs_authored" as *u8};if col==8 {return "next_action" as *u8}
if col==9 {return "reusable_reach_authored" as *u8};if col==10 {return "measurement_requirements" as *u8}
return "acceptance_state" as *u8
781}
782func em_req_rows(w:*JsonWriter,b:*u8,n:i64,kind:i64)->i64 {
if json_begin_array(w)<0 {return -1}
var p:i64=0
while p<n {
let raw:i64=bf_line_end(b,n,p);let e:i64=pb_trim_cr(b,p,raw)
var tag:*u8="maturityrequirement|" as *u8;var fields:i64=8
if kind==2 {tag="maturityinvestment|" as *u8;fields=12}
if bf_line_starts(b,p,e,tag)==1 {
 if json_begin_object(w)<0 {return -1}
 var c:i64=2
 while c<fields {var o:i64=0;let len:i64=bf_field(b,p,e,c,&o);if cg_jkey(w,em_req_key(c,kind))<0 {return -1};if json_emit_string(w,((b as i64)+o) as *u8,len)<0 {return -1};c=c+1}
 if cg_jnull(w,"evidence_verified")<0 {return -1}
 if cg_jnull(w,"maturity_achieved")<0 {return -1}
 if cg_jnull(w,"investment_return_measured")<0 {return -1}
 if cg_jkey(w,"reference_resolution")<0 {return -1}
 if cg_jstr(w,"external_evidence_and_capability_refs_unresolved")<0 {return -1}
 if json_end_object(w)<0 {return -1}
}
p=raw+1
}
return json_end_array(w)
803}
804func em_requirements_into(b:*u8,n:i64,out:*u8,cap:i64)->i64 {
let valid:i64=em_req_validate(b,n);if valid<0 {return valid}
if cap<=0||(out as i64)<=0 {return -7}
let w:*JsonWriter=sys_mmap(CG_JSON_WRITER_WORDS*8) as *JsonWriter
if (w as i64)<=0 {return -7}
if json_writer_init(w,out,cap)<0 {return -7}
var ok:i64=json_begin_object(w)
if ok>=0 {ok=cg_jkey(w,"version")};if ok>=0 {ok=json_emit_int(w,1)}
if ok>=0 {ok=cg_jkey(w,"scope")};if ok>=0 {ok=cg_jstr(w,"requirements_and_pending_investment_not_achieved_maturity")}
if ok>=0 {ok=cg_jkey(w,"legacy_grade_conversion")};if ok>=0 {ok=json_emit_null(w)}
if ok>=0 {ok=cg_jkey(w,"requirements")};if ok>=0 {ok=em_req_rows(w,b,n,1)}
if ok>=0 {ok=cg_jkey(w,"investments")};if ok>=0 {ok=em_req_rows(w,b,n,2)}
if ok>=0 {ok=json_end_object(w)}
let length:i64=w.pos
sys_munmap(w.prior,JE_MAX_DEPTH+16);sys_munmap(w as *u8,CG_JSON_WRITER_WORDS*8)
if ok<0 {return -7};return length
820}
821func em_req_capacity(s:*u8)->i64 {
var i:i64=0;var v:i64=0
while s[i]!=(0 as u8) {let d:i64=(s[i] as i64)-48;if d<0||d>9 {return -1};if v>(PB_I64_MAX-d)/10 {return -1};v=v*10+d;i=i+1}
if i==0||v<=0 {return -1};return v
825}
826func em_requirements_run(path:*u8,inputcap:i64,outputcap:i64)->i64 {
if inputcap<=0||outputcap<=0 {return 2}
let b:*u8=sys_mmap(inputcap);let out:*u8=sys_mmap(outputcap);let st:*i64=sys_mmap(24) as *i64
if (b as i64)<=0||(out as i64)<=0||(st as i64)<=0 {return 3}
let n:i64=rc_read_file_into(path,b,inputcap,st)
if rc_complete(st)==0 {sys_munmap(b,inputcap);sys_munmap(out,outputcap);sys_munmap(st as *u8,24);return 3}
let length:i64=em_requirements_into(b,n,out,outputcap)
var rc:i64=4
if length>=0 {if sys_write(1,out,length)==length {sys_write(1,"\n",1);rc=0}}
sys_munmap(b,inputcap);sys_munmap(out,outputcap);sys_munmap(st as *u8,24);return rc
836}
nx_ecomat_lib.nx source

`nx_ecomat_lib.nx` source
