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

↩ module page · 508 lines · 16730 B
1// nx_capgraph_derive_lib.nx -- pure core for nx_capgraph_derive: level thresholds, row parsing,
2// the progress-rail snapshot compare, and the history reader.
3//
4// SPLIT OUT 2026-07-31 for the SAME reason as nx_capgraph_edges_lib: these helpers sat beside a main()
5// and were therefore unreachable from any gate, which pinned the progress rail at level 2 (WORKS) on
6// this system's own ladder. Gating the edges organ but not this one would have been applying the
7// standard selectively -- exactly the kind of convenient inconsistency this arc exists to catch.
8// license_tier: ORIGINAL   No hw writes (Rule 26).
9import "nx_capgraph_lib.nx"
10import "nx_tool_run.nx"
11
12const CD2_CAP: i64 = 262144
13const CD2_ELF: *u8 = "/volume1/homes/elderwesto/nishihost/nx_sota_status.elf" as *u8
14const CD2_EDGES: *u8 = "knowledge/status/capgraph_edges.conf" as *u8
15
16const CD2_HIST: *u8 = "knowledge/status/capgraph_history.jrnl" as *u8
17const CD2_SBMAX: i64 = 16384
18const CD2_AX_COVER: i64 = 0
19const CD2_AX_EVID: i64 = 1
20const CD2_AX_FRONTIER: i64 = 2
21
22func cd2_match(buf: *u8, at: i64, end: i64, pat: *u8) -> i64 {
  var k: i64 = 0
  var ok: i64 = 1
  var done: i64 = 0
  while done == 0 {
      let pc: i64 = pat[k] as i64
      if pc == 0 { done = 1 }
      else {
          if at + k >= end { ok = 0 }
          else { if buf[at + k] as i64 != pc { ok = 0 } }
          if ok == 0 { done = 1 }
          else { k = k + 1 }
      }
  }
  return ok
37}
38
39func cd2_find(buf: *u8, ls: i64, le: i64, pat: *u8) -> i64 {
  var j: i64 = ls
  var hit: i64 = 0 - 1
  while j < le {
      if cd2_match(buf, j, le, pat) == 1 {
          hit = j
          j = le
      } else { j = j + 1 }
  }
  return hit
49}
50
51func cd2_num(buf: *u8, at: i64, end: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = at
  var any: i64 = 0
  var done: i64 = 0
  while done == 0 {
      if i >= end { done = 1 }
      else {
          let c: i64 = buf[i] as i64
          if c < 48 { done = 1 }
          else {
              if c > 57 { done = 1 }
              else {
                  v = v * 10 + (c - 48)
                  any = 1
                  i = i + 1
              }
          }
      }
  }
  if any == 0 { return CG_UNMEASURED }
  return v
73}
74
75// The flat permil becomes an ORDINAL level. Thresholds are declared here as named boundaries so the
76// conversion is auditable; the level is then capped by evidence (L6) at cg_set, which is what actually
77// stops a big coverage claim from reading as progress.
78func cd2_cov_level(permil: i64) -> i64 {
  if permil == CG_UNMEASURED { return CG_UNMEASURED }
  if permil < 200 { return 0 }
  if permil < 400 { return 1 }
  if permil < 600 { return 2 }
  if permil < 800 { return 3 }
  if permil < 950 { return 4 }
  return 5
86}
87
88func cd2_gap_level(gaps: i64) -> i64 {
  if gaps == CG_UNMEASURED { return CG_UNMEASURED }
  if gaps <= 0 { return 5 }
  var d: i64 = gaps / 3
  if d > 5 { d = 5 }
  return 5 - d
94}
95
96// ---- THE PROGRESS RAIL ----
97// Ordinal levels make a level-up COUNTABLE, but counting requires a record. Without a time series the
98// graph can only ever answer "where are we", never "did we move" -- and the operator asked for the
99// second. This appends ONE row per ACTUAL CHANGE (content-idempotent, the nx_debt pattern): re-running
100// on an unchanged graph appends nothing, so the journal is a history of MOVEMENT, not of invocations.
101// A rail that grows on every run would drown the signal it exists to carry.
102static cd2_sb: *u8
103static cd2_sn: i64
104
105func cd2_sput(s: *u8) {
  var i: i64 = 0
  while s[i] != (0 as u8) {
      if cd2_sn < CD2_SBMAX - 2 {
          cd2_sb[cd2_sn] = s[i]
          cd2_sn = cd2_sn + 1
      }
      i = i + 1
  }
  cd2_sb[cd2_sn] = 0 as u8
115}
116
117func cd2_sputi(x: i64) {
  let b: *u8 = sys_mmap(64) as *u8
  var v: i64 = x
  var neg: i64 = 0
  if v < 0 {
      neg = 1
      v = 0 - v
  }
  var i: i64 = 40
  if v == 0 {
      i = i - 1
      b[i] = 48 as u8
  }
  while v > 0 {
      let d: i64 = v - (v / 10) * 10
      i = i - 1
      b[i] = (d + 48) as u8
      v = v / 10
  }
  if neg == 1 {
      i = i - 1
      b[i] = 45 as u8
  }
  b[40] = 0 as u8
  cd2_sput(((b as i64) + i) as *u8)
142}
143
144func cd2_is_infra(s: *u8) -> i64 {
  if s[0] != (105 as u8) { return 0 }
  if s[1] != (110 as u8) { return 0 }
  if s[2] != (102 as u8) { return 0 }
  if s[3] != (114 as u8) { return 0 }
  if s[4] != (97 as u8) { return 0 }
  if s[5] != (58 as u8) { return 0 }
  return 1
152}
153
154func cd2_name_of(buf: *u8, ls: i64, le: i64, dst: *u8) -> i64 {
  var start: i64 = ls
  var found: i64 = 0
  var scan: i64 = ls
  while scan < le {
      if found == 0 {
          if buf[scan] != (32 as u8) {
              start = scan
              found = 1
          }
      }
      scan = scan + 1
  }
  if found == 0 { return 0 }
  var w: i64 = 0
  var q: i64 = start
  var done: i64 = 0
  while done == 0 {
      if q >= le { done = 1 }
      else {
          if buf[q] == (32 as u8) { done = 1 }
          else {
              if w < CG_NAMEW - 1 {
                  dst[w] = buf[q]
                  w = w + 1
              }
              q = q + 1
          }
      }
  }
  dst[w] = 0 as u8
  return w
186}
187
188// ---- READING the rail. Recording movement is only half a progress system; a journal nobody can read
189// is a log, not an instrument. This diffs the last two rows and names what MOVED, in both directions --
190// a level going DOWN is the more important signal, because it means something that used to hold no
191// longer does, and a report that only ever shows gains is a cheerleader, not a ruler.
192const CD2_MAXPAIR: i64 = 512
193const CD2_PW: i64 = 48
194static cd2_pn: *u8
195static cd2_pv: *i64
196static cd2_np: i64
197static cd2_cn: *u8
198static cd2_cv: *i64
199static cd2_nc: i64
200
201func cd2_parse_row(buf: *u8, s: i64, e: i64) {
  cd2_np = 0
  var i: i64 = s
  while i < e {
      let c: i64 = buf[i] as i64
      var adv: i64 = 1
      if c == 32 { adv = 1 }
      else {
          if c == 9 { adv = 1 }
          else {
              var j: i64 = i
              var eqp: i64 = 0 - 1
              var done: i64 = 0
              while done == 0 {
                  if j >= e { done = 1 }
                  else {
                      let cj: i64 = buf[j] as i64
                      if cj == 32 { done = 1 }
                      else {
                          if cj == 9 { done = 1 }
                          else {
                              if cj == 61 {
                                  if eqp < 0 { eqp = j }
                              }
                              j = j + 1
                          }
                      }
                  }
              }
              if eqp > 0 {
                  if cd2_np < CD2_MAXPAIR {
                      var w: i64 = 0
                      var k: i64 = i
                      while k < eqp {
                          if w < CD2_PW - 1 {
                              let dst: *u8 = ((cd2_pn as i64) + cd2_np * CD2_PW + w) as *u8
                              dst[0] = buf[k]
                              w = w + 1
                          }
                          k = k + 1
                      }
                      let term: *u8 = ((cd2_pn as i64) + cd2_np * CD2_PW + w) as *u8
                      term[0] = 0 as u8
                      var v: i64 = 0
                      var neg: i64 = 0
                      var m: i64 = eqp + 1
                      if m < j {
                          if buf[m] == (45 as u8) {
                              neg = 1
                              m = m + 1
                          }
                      }
                      while m < j {
                          let cm: i64 = buf[m] as i64
                          if cm >= 48 {
                              if cm <= 57 { v = v * 10 + (cm - 48) }
                          }
                          m = m + 1
                      }
                      if neg == 1 { v = 0 - v }
                      cd2_pv[cd2_np] = v
                      cd2_np = cd2_np + 1
                  }
              }
              if j > i { adv = j - i }
          }
      }
      i = i + adv
  }
270}
271
272func cd2_prev_lookup(nm: *u8) -> i64 {
  var i: i64 = 0
  var hit: i64 = 0 - 999
  while i < cd2_np {
      if cg_streq(((cd2_pn as i64) + i * CD2_PW) as *u8, nm) == 1 {
          hit = cd2_pv[i]
          i = cd2_np
      } else { i = i + 1 }
  }
  return hit
282}
283
284func cd2_progress() -> i64 {
  cd2_pn = sys_mmap(CD2_MAXPAIR * CD2_PW + 64) as *u8
  cd2_pv = sys_mmap(CD2_MAXPAIR * 8 + 64) as *i64
  cd2_cn = sys_mmap(CD2_MAXPAIR * CD2_PW + 64) as *u8
  cd2_cv = sys_mmap(CD2_MAXPAIR * 8 + 64) as *i64
  let hl: *i64 = sys_mmap(16) as *i64
  let hb: *u8 = sys_read_file(CD2_HIST, hl)
  let hn: i64 = hl[0]
  cax_puts("=== NX-CAPGRAPH PROGRESS: what MOVED between the last two recorded states ===\n" as *u8)
  if hn <= 0 {
      cax_puts("no history yet -- run nx_capgraph_derive once to record a baseline.\n" as *u8)
      return 0
  }
  let l2: i64 = cd2_last_row_start(hb, hn)
  let l1: i64 = cd2_prev_row_start(hb, hn)
  if l1 < 0 {
      cax_puts("only ONE recorded state -- a baseline, no movement to report yet.\n" as *u8)
      cax_puts("This is the honest answer: progress needs two points, and there is one.\n" as *u8)
      return 0
  }
  var e1: i64 = l2 - 1
  var e2: i64 = hn
  cd2_parse_row(hb, l2, e2)
  cd2_nc = cd2_np
  var c: i64 = 0
  while c < cd2_nc {
      var w: i64 = 0
      let src: *u8 = ((cd2_pn as i64) + c * CD2_PW) as *u8
      while src[w] != (0 as u8) {
          let d: *u8 = ((cd2_cn as i64) + c * CD2_PW + w) as *u8
          d[0] = src[w]
          w = w + 1
      }
      let t: *u8 = ((cd2_cn as i64) + c * CD2_PW + w) as *u8
      t[0] = 0 as u8
      cd2_cv[c] = cd2_pv[c]
      c = c + 1
  }
  cd2_parse_row(hb, l1, e1)
323
  var up: i64 = 0
  var down: i64 = 0
  var newn: i64 = 0
  var i: i64 = 0
  while i < cd2_nc {
      let nm: *u8 = ((cd2_cn as i64) + i * CD2_PW) as *u8
      let now: i64 = cd2_cv[i]
      let was: i64 = cd2_prev_lookup(nm)
      if was == (0 - 999) {
          cax_puts("  NEW    " as *u8)
          cax_puts(nm)
          cax_puts(" = " as *u8)
          cax_puti(now)
          cax_puts("\n" as *u8)
          newn = newn + 1
      } else {
          if now > was {
              cax_puts("  UP     " as *u8)
              cax_puts(nm)
              cax_puts("  " as *u8)
              cax_puti(was)
              cax_puts(" -> " as *u8)
              cax_puti(now)
              cax_puts("\n" as *u8)
              up = up + 1
          }
          if now < was {
              cax_puts("  DOWN   " as *u8)
              cax_puts(nm)
              cax_puts("  " as *u8)
              cax_puti(was)
              cax_puts(" -> " as *u8)
              cax_puti(now)
              cax_puts("   <- REGRESSION\n" as *u8)
              down = down + 1
          }
      }
      i = i + 1
  }
  cax_puts("\n" as *u8)
  cax_kv("advanced" as *u8, up)
  cax_kv("REGRESSED" as *u8, down)
  cax_kv("new_nodes" as *u8, newn)
  cax_puts("\n" as *u8)
  if up == 0 {
      if down == 0 {
          if newn == 0 { cax_puts("no level changed between the last two states (structure moved, levels did not).\n" as *u8) }
      }
  }
  if down > 0 {
      cax_puts("⚠a DOWN is the signal that matters: something that used to hold no longer does.\n" as *u8)
  }
  return 0
377}
378
379// ROW-BOUNDARY DECISIONS, extracted for the same reason as cd2_last_row_matches: `progress` diffs the
380// LAST TWO rows, so if these pick the wrong pair it silently reports the wrong movement -- and an
381// off-by-one here is invisible in a live run, which only ever exercises whatever shape the journal
382// happens to have that day. Trailing-newline handling is the trap: a file ending in \n must NOT be read
383// as having an extra empty final row.
384// cd2_last_row_start: byte offset where the final non-empty row begins, or -1 if there is none.
385func cd2_last_row_start(hb: *u8, hn: i64) -> i64 {
  if hn <= 0 { return 0 - 1 }
  var lstart: i64 = 0
  var k: i64 = 0
  while k < hn {
      if hb[k] == (10 as u8) {
          if k + 1 < hn { lstart = k + 1 }
      }
      k = k + 1
  }
  return lstart
396}
397
398// cd2_prev_row_start: offset of the row BEFORE the last one, or -1 when fewer than two rows exist.
399func cd2_prev_row_start(hb: *u8, hn: i64) -> i64 {
  let last: i64 = cd2_last_row_start(hb, hn)
  if last <= 0 { return 0 - 1 }
  var prev: i64 = 0
  var k: i64 = 0
  while k < last - 1 {
      if hb[k] == (10 as u8) {
          if k + 1 < last { prev = k + 1 }
      }
      k = k + 1
  }
  return prev
411}
412
413// THE DECISION THE WHOLE RAIL TURNS ON: does the LAST journal row already carry exactly this state?
414// If this says yes when it should say no, real movement is silently DROPPED. If it says no when it
415// should say yes, the journal fills with duplicate rows and progress reports phantom changes. It was
416// the one piece of the rail with no standing tooth, so it is now a PURE function -- extracted solely
417// to make it gate-reachable. Compares the state field (after the epoch TAB) of the final line.
418// Returns 1 = identical (do not append) · 0 = differs, or unreadable.
419func cd2_last_row_matches(hb: *u8, hn: i64, st: *u8, stn: i64) -> i64 {
  if hn <= 0 { return 0 }
  let lstart: i64 = cd2_last_row_start(hb, hn)
  if lstart < 0 { return 0 }
  var tab: i64 = lstart
  var found: i64 = 0
  var t: i64 = lstart
  while t < hn {
      if found == 0 {
          if hb[t] == (9 as u8) {
              tab = t + 1
              found = 1
          }
      }
      t = t + 1
  }
  if found == 0 { return 0 }
  var m: i64 = 1
  var q: i64 = 0
  while q < stn {
      if tab + q >= hn { m = 0 }
      else { if hb[tab + q] != st[q] { m = 0 } }
      q = q + 1
  }
  // A stored PREFIX must not read as equal: the byte after the compared span has to END the line.
  // Without this, a shorter recorded state would swallow every longer one and the rail would go deaf.
  if tab + stn < hn {
      if hb[tab + stn] != (10 as u8) { m = 0 }
  }
  return m
449}
450
451// Append one row IFF the graph state differs from the last recorded row.
452// returns 1 = movement recorded · 0 = unchanged (nothing appended) · -1 = write failed
453func cd2_snapshot(edges: i64) -> i64 {
  cd2_sn = 0
  cd2_sput("nodes=" as *u8)
  cd2_sputi(cg_nn)
  cd2_sput(" edges=" as *u8)
  cd2_sputi(edges)
  // Record BOTH the effective level and the node's OWN level.
  // Measured 2026-08-01: `instrument` earned executable evidence (own 0->3 GATED) and the rail showed
  // NOTHING, because L4 correctly capped its EFFECTIVE level at 0 behind an unevidenced prerequisite.
  // A rail that records only the capped figure tells a lane that did real work that nothing happened --
  // ★★★UNDER A WEAKEST-PATH RULE, PROGRESS AND ITS VISIBILITY ARE DIFFERENT THINGS, so record both:
  // `<name>` is what the graph can currently deliver, `<name>#own` is what that node itself earned.
  var i: i64 = 0
  while i < cg_nn {
      cd2_sput(" " as *u8)
      cd2_sput(cg_node_name(i))
      cd2_sput("=" as *u8)
      cd2_sputi(cg_effective(i))
      cd2_sput(" " as *u8)
      cd2_sput(cg_node_name(i))
      cd2_sput("#own=" as *u8)
      cd2_sputi(cg_own[i])
      i = i + 1
  }
477
  let hl: *i64 = sys_mmap(16) as *i64
  let hb: *u8 = sys_read_file(CD2_HIST, hl)
  let hn: i64 = hl[0]
  let same: i64 = cd2_last_row_matches(hb, hn, cd2_sb, cd2_sn)
  if same == 1 { return 0 }
483
  let ts: *i64 = sys_mmap(32) as *i64
  sys_clock_gettime_real(ts)
  let fd: i64 = sys_openat_append(CD2_HIST, 0x1A4)
  if fd < 0 { return 0 - 1 }
  let eb: *u8 = sys_mmap(64) as *u8
  var v: i64 = ts[0]
  var bi: i64 = 40
  if v == 0 {
      bi = bi - 1
      eb[bi] = 48 as u8
  }
  while v > 0 {
      let d: i64 = v - (v / 10) * 10
      bi = bi - 1
      eb[bi] = (d + 48) as u8
      v = v / 10
  }
  sys_write(fd, ((eb as i64) + bi) as *u8, 40 - bi)
  sys_write(fd, "\t" as *u8, 1)
  sys_write(fd, cd2_sb, cd2_sn)
  sys_write(fd, "\n" as *u8, 1)
  sys_close(fd)
  return 1
507}
508
nx_capgraph_derive_lib.nx source

`nx_capgraph_derive_lib.nx` source
