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

↩ module page · 288 lines · 12420 B
1// nx_capaxes_derive.nx -- DERIVES capability axis vectors from a LIVE source and ranks the rocks.
2//
3// WHY (operator 2026-07-30): the census is "gamed on coverage to 1000permil but with below toy quality"
4// and partial capabilities are "treated as completed capabilities not as things that need a full living
5// iteration loop to determine biggest rocks". nx_capaxes_lib made the SHAPE measurable; this closes the
6// loop by feeding it real numbers and emitting the rock order.
7//
8// SOURCE (composition, not reimplementation -- the nx_debt_view pattern): fork nx_sota_status and read its
9// per-domain rows. Every domain it lists carries local .matrix evidence, so GROUNDING is real for these
10// (unlike nx_cap_census, which reports "vs 0 SOTA-src" for every row = an EMPTY comparator, debt 1785465147).
11//
12// AXES SET HERE, and what is HONESTLY NOT YET WIRED:
13//   coverage  <- the row's own cov= figure                       MEASURED
14//   evidence  <- 0, because every row nx_sota_status prints with  MEASURED
15//                a cov= figure sits in its CLAIM-ONLY block
16//                (PROVEN is 0/40, so no row scores above this)
17//   grounding <- CAX_FULL: the domain HAS a .matrix comparator    MEASURED
18//   quality   <- UNMEASURED (-1), needs the ecomat maturity grade
19//   scale     <- UNMEASURED (-1), needs the gate envelope N
20//   adoption  <- UNMEASURED (-1), needs the nx_wirecensus join
21// -1 is NOT a silent 0 and the lib proves it can never become the minimum (nx_capaxes_gate T3).
22// Three axes measured is a FLOOR, declared in the envelope -- never presented as the whole picture.
23//
24// THE POINT: with evidence=0 the headline is 0 no matter how high coverage climbs, so LEVERAGE is what
25// orders the work -- and leverage IS the coverage claim. A domain asserting cov=1000 with zero executable
26// evidence is the BIGGEST rock, not the most finished one. That inverts the gamed ranking exactly.
27//
28// nx_capaxes_derive [topN]     exit 0 ok | 4 capture-fail
29// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
30import "nx_capaxes_lib.nx"
31import "nx_tool_run.nx"
32
33const CD_CAP: i64 = 262144
34const CD_MAXDOM: i64 = 128
35const CD_NAMEW: i64 = 40
36const CD_ELF: *u8 = "/volume1/homes/elderwesto/nishihost/nx_sota_status.elf" as *u8
37// The ADOPTION axis, derived by nx_adopt and stamped so nobody re-runs a 17,559-file scan for one number.
38// Reading a stamp instead of forking the census is what keeps this organ inside the /api/gate_run deadline.
39const CD_STAMP: *u8 = "knowledge/status/adopt_census.stamp" as *u8
40const CD_ADOPT_KEY_LEN: i64 = 16
41
42func cd_match(buf: *u8, at: i64, end: i64, pat: *u8, pl: i64) -> i64 {
  if at + pl > end { return 0 }
  var k: i64 = 0
  while k < pl {
      if buf[at + k] != pat[k] { return 0 }
      k = k + 1
  }
  return 1
50}
51
52func cd_num_at(buf: *u8, at: i64, end: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = at
  var any: i64 = 0
  while i < end {
      let c: i64 = buf[i] as i64
      if c < 48 { i = end }
      else {
          if c > 57 { i = end }
          else {
              v = v * 10 + (c - 48)
              any = 1
              i = i + 1
          }
      }
  }
  if any == 0 { return CAX_UNMEASURED }
  return v
70}
71
72func main(argc: i64, argv: *i64) -> i64 {
  var topn: i64 = 20
  if argc > 1 { topn = cax_atoi(argv[1] as *u8) }
  if topn <= 0 { topn = 20 }
76
  let out: *u8 = sys_mmap(CD_CAP + 16)
  let olen: *i64 = sys_mmap(16) as *i64
  let rc: i64 = tr_run1(CD_ELF, 0 as *u8, out, CD_CAP, olen)
  let n: i64 = olen[0]
  if rc == 127 {
      cax_puts("CAPAXES-DERIVE verdict=CAPTURE-FAIL exec-127\n" as *u8)
      return 4
  }
  if n <= 0 {
      cax_puts("CAPAXES-DERIVE verdict=CAPTURE-FAIL empty\n" as *u8)
      return 4
  }
89
  let names: *u8 = sys_mmap(CD_MAXDOM * CD_NAMEW + 16)
  let covs: *i64 = sys_mmap(CD_MAXDOM * 8 + 16) as *i64
  let rocks: *i64 = sys_mmap(CD_MAXDOM * 8 + 16) as *i64
  var nd: i64 = 0
94
  var ls: i64 = 0
  var i: i64 = 0
  while i <= n {
      var isend: i64 = 0
      if i == n { isend = 1 } else { if out[i] == (10 as u8) { isend = 1 } }
      if isend == 1 {
          var j: i64 = ls
          var covpos: i64 = 0 - 1
          while j < i {
              if cd_match(out, j, i, "cov=" as *u8, 4) == 1 {
                  covpos = j + 4
                  j = i
              } else { j = j + 1 }
          }
          if covpos > 0 {
              if nd < CD_MAXDOM {
                  var s: i64 = ls
                  while s < i {
                      if out[s] == (32 as u8) { s = s + 1 } else { s = i }
                  }
                  s = ls
                  while s < i {
                      if out[s] != (32 as u8) { s = i } else { s = s + 1 }
                  }
                  var t: i64 = ls
                  while t < i {
                      if out[t] == (32 as u8) { t = t + 1 } else { t = i + 1 }
                  }
                  var st: i64 = ls
                  while st < i {
                      if out[st] == (32 as u8) { st = st + 1 }
                      else { st = i + 1 }
                  }
                  var b: i64 = ls
                  while b < i {
                      if out[b] == (32 as u8) { b = b + 1 } else { b = i + 2 }
                  }
                  var p0: i64 = ls
                  while p0 < i {
                      if out[p0] == (32 as u8) { p0 = p0 + 1 } else { p0 = i + 3 }
                  }
                  var start: i64 = ls
                  var scan: i64 = ls
                  var found: i64 = 0
                  while scan < i {
                      if found == 0 {
                          if out[scan] != (32 as u8) {
                              start = scan
                              found = 1
                          }
                      }
                      scan = scan + 1
                  }
                  var w: i64 = 0
                  let slot: i64 = (names as i64) + nd * CD_NAMEW
                  var q: i64 = start
                  while q < i {
                      if out[q] == (32 as u8) { q = i }
                      else {
                          if w < CD_NAMEW - 1 {
                              let dst: *u8 = (slot + w) as *u8
                              dst[0] = out[q]
                              w = w + 1
                          }
                          q = q + 1
                      }
                  }
                  let term: *u8 = (slot + w) as *u8
                  term[0] = 0 as u8
                  if w > 0 {
                      covs[nd] = cd_num_at(out, covpos, i)
                      nd = nd + 1
                  }
              }
          }
          ls = i + 1
      }
      i = i + 1
  }
174
  // ⚠SUPERSEDED-RANKING BANNER (added 2026-07-31 by the capgraph arc). Nothing below is removed --
  // Rule 25, this organ's axis-shape work is still correct and still worth reading. What is WRONG is
  // its ROCK ORDER: with evidence hardcoded 0 every headline is 0, so the rank falls back to leverage,
  // and leverage here IS the coverage claim. Ranking by claim size was MEASURED to be inverted.
  // Leaving two rulers answering the same question with opposite answers is the "the other file keeps
  // answering" hazard; a reader who finds this one first would mine the wrong rock. So it now says so.
  cax_puts("### SUPERSEDED RANKING -- READ THIS BEFORE ACTING ON THE ORDER BELOW ###\n" as *u8)
  cax_puts("  This organ ranks by the COVERAGE CLAIM. That order was MEASURED to be INVERTED:\n" as *u8)
  cax_puts("  workermesh (cov=1000) ranks #1 here and gates NOTHING -- it is #9 on the measured graph,\n" as *u8)
  cax_puts("  where leverage is DOWNSTREAM MASS, not claim size. Use `nx_capgraph_derive` for the rock\n" as *u8)
  cax_puts("  order and `nx_capgraph_derive progress` for movement. The AXIS SHAPE below is still valid.\n" as *u8)
  cax_puts("###\n\n" as *u8)
  cax_puts("=== CAPAXES-DERIVE: axis profiles from nx_sota_status (live) ===\n" as *u8)
  cax_puts("domains_parsed=" as *u8)
  cax_puti(nd)
  cax_puts("\n\n" as *u8)
191
  var v: *i64 = sys_mmap(128) as *i64
  var d: i64 = 0
  while d < nd {
      v[CAX_A_COVER] = covs[d]
      v[CAX_A_QUALITY] = CAX_UNMEASURED
      v[CAX_A_SCALE] = CAX_UNMEASURED
      v[CAX_A_EVIDENCE] = 0
      v[CAX_A_ADOPT] = CAX_UNMEASURED
      v[CAX_A_GROUND] = CAX_FULL
      rocks[d] = cax_rock(v, CAX_N, covs[d])
      d = d + 1
  }
204
  cax_puts("-- BIGGEST ROCKS (rank = (1000 - min_axis) x leverage, leverage = the coverage CLAIM) --\n" as *u8)
  cax_puts("   a domain claiming the MOST coverage with ZERO evidence is the BIGGEST rock, not the most done.\n\n" as *u8)
  var shown: i64 = 0
  while shown < topn {
      var best: i64 = 0 - 1
      var k: i64 = 0
      while k < nd {
          if rocks[k] >= 0 {
              if best < 0 { best = k }
              else { if rocks[k] > rocks[best] { best = k } }
          }
          k = k + 1
      }
      if best < 0 { shown = topn }
      else {
          cax_puti(shown + 1)
          cax_puts(". " as *u8)
          cax_puts(((names as i64) + best * CD_NAMEW) as *u8)
          cax_puts("  " as *u8)
          v[CAX_A_COVER] = covs[best]
          v[CAX_A_QUALITY] = CAX_UNMEASURED
          v[CAX_A_SCALE] = CAX_UNMEASURED
          v[CAX_A_EVIDENCE] = 0
          v[CAX_A_ADOPT] = CAX_UNMEASURED
          v[CAX_A_GROUND] = CAX_FULL
          cax_kv("coverage" as *u8, covs[best])
          cax_kv("evidence" as *u8, 0)
          cax_kv("headline_MIN" as *u8, cax_headline(v, CAX_N))
          cax_kv("skew" as *u8, cax_skew(v, CAX_N))
          cax_puts("starved=" as *u8)
          cax_puts(cax_axis_name(cax_min_idx(v, CAX_N)))
          cax_puts(" " as *u8)
          cax_kv("rock" as *u8, rocks[best])
          cax_kv("mean_would_have_read" as *u8, cax_mean(v, CAX_N))
          cax_puts("\n" as *u8)
          rocks[best] = 0 - 1
          shown = shown + 1
      }
  }
244
  // ---- THE ECOSYSTEM ITSELF, PROFILED AS ONE CAPABILITY ----
  // Every axis below comes from a LIVE source, none is asserted: coverage = the mean of the domain cov=
  // figures parsed above; evidence = 0 because nx_sota_status reports PROVEN 0/40 and every row it prints
  // with a cov= figure sits in CLAIM-ONLY; adoption = nx_adopt's stamped adoption_permil; grounding = FULL
  // because these domains carry .matrix comparators. quality and scale stay -1 UNMEASURED and are excluded
  // from the MIN by construction, so this profile is a FLOOR -- wiring them can only lower it.
  let stamp_len: *i64 = sys_mmap(16) as *i64
  let stamp: *u8 = sys_read_file(CD_STAMP, stamp_len)
  var adoption: i64 = CAX_UNMEASURED
  let sn: i64 = stamp_len[0]
  if sn > 0 {
      var si: i64 = 0
      while si < sn {
          if cd_match(stamp, si, sn, "adoption_permil=" as *u8, CD_ADOPT_KEY_LEN) == 1 {
              adoption = cd_num_at(stamp, si + CD_ADOPT_KEY_LEN, sn)
              si = sn
          } else {
              si = si + 1
          }
      }
  }
  var covsum: i64 = 0
  var d2: i64 = 0
  while d2 < nd {
      covsum = covsum + covs[d2]
      d2 = d2 + 1
  }
  var covmean: i64 = CAX_UNMEASURED
  if nd > 0 { covmean = covsum / nd }
  v[CAX_A_COVER] = covmean
  v[CAX_A_QUALITY] = CAX_UNMEASURED
  v[CAX_A_SCALE] = CAX_UNMEASURED
  v[CAX_A_EVIDENCE] = 0
  v[CAX_A_ADOPT] = adoption
  v[CAX_A_GROUND] = CAX_FULL
  cax_puts("\n-- THE ECOSYSTEM ITSELF, PROFILED AS ONE CAPABILITY (every axis from a live source) --\n" as *u8)
  cax_report(v, CAX_N, 1)
282
  cax_puts("\nenvelope: per-domain rows measure 3of6 (coverage/evidence/grounding); quality+scale+adoption=-1,\n" as *u8)
  cax_puts("  excluded from the MIN by construction (nx_capaxes_gate T3), NEVER counted as 0. This is a\n" as *u8)
  cax_puts("  DECLARED FLOOR, not the whole picture: wiring ecomat quality + wirecensus adoption can only\n" as *u8)
  cax_puts("  LOWER these headlines, never raise them. source=nx_sota_status fork-capture, no reimplementation.\n" as *u8)
  return 0
288}
nx_capaxes_derive.nx source

`nx_capaxes_derive.nx` source
