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

↩ module page · 349 lines · 15008 B
1// nx_capability_ladder.nx -- THE BUILD-UP MAP, hardware rung up (operator 2026-06-13:
2// "we need mapping on how we build from the hardware rung up ... so we never have floating
3// capabilities but each layer below acts as the foundation for the one above").
4//
5// Organ-AUTHORED (not hand-drawn): composes nx_assign_core to read the REAL queue and
6// COMPUTE, from the deps graph + DONE status, a layered map:
7//   layer(row) = 0 if deps "-" ; else 1 + max(layer(dep))   (topological depth, fixpoint)
8//   layer 0 = the foundations with no dependency = the hardware/toolchain rung.
9//   FLOATING  = a DONE capability whose foundation (a dep) is NOT DONE / is unknown
10//               -- a capability standing on nothing.  The no-floating LAW: zero floating.
11// Emits the map to knowledge/registry/capability_ladder.tsv (layer-ascending = bottom-up)
12// and a CAPLADDER evidence line.  Navigation: the lowest ABSENT foundation is what to build
13// next; never build a row whose foundation is ABSENT (that would float).
14//
15// SELF-VALIDATING (no false-green): a baked pos control (DONE row on a DONE foundation ->
16// NOT floating) and neg control (DONE row on a TODO foundation -> floating) run on a
17// synthetic in-memory context BEFORE the real queue; controls wrong -> RED.  Reuses
18// an_deps_done as the grounding primitive (DRY).  license_tier: ORIGINAL
19import "nx_assign_core.nx"
20
21const CL_QUEUE: *u8 = "knowledge/registry/assignment_queue.tsv"
22const CL_MAP:   *u8 = "knowledge/registry/capability_ladder.tsv"
23const CL_LOG:   *u8 = "knowledge/status/capability_ladder.log"
24
25func cl_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
26func cl_wn(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;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 }
27
28func cl_status_str(b: i64) -> *u8 {
  if b == 68 { return "DONE" as *u8 }
  if b == 84 { return "TODO" as *u8 }
  if b == 78 { return "NOVEL" as *u8 }
  if b == 87 { return "WIP" as *u8 }
  if b == 71 { return "GEN" as *u8 }
  if b == 82 { return "RED" as *u8 }
  return "?" as *u8
36}
37
38// a dep token can name a built ORGAN (a capability foundation), not only a queue row.
39// try runtime/_hdl_build/<name>.nx then runtime/<name>.nx; exists -> 1.
40func cl_try_open(prefix: *u8, name: *u8) -> i64 {
  let p: *u8 = sys_mmap(256)
  var k: i64 = 0
  var i: i64 = 0
  while prefix[i] != (0 as u8) { p[k] = prefix[i]; k = k + 1; i = i + 1 }
  i = 0
  while name[i] != (0 as u8) { p[k] = name[i]; k = k + 1; i = i + 1 }
  p[k] = 46 as u8; k = k + 1
  p[k] = 110 as u8; k = k + 1
  p[k] = 120 as u8; k = k + 1
  p[k] = 0 as u8
  let fd: i64 = sys_openat_rd(p)
  if fd >= 0 { sys_close(fd); return 1 }
  return 0
54}
55func cl_organ_exists(name: *u8) -> i64 {
  if cl_try_open("runtime/_hdl_build/" as *u8, name) == 1 { return 1 }
  if cl_try_open("runtime/" as *u8, name) == 1 { return 1 }
  return 0
59}
60
61// all deps satisfied? a dep is satisfied iff it is a DONE queue row OR (not a row but) a built organ.
62// a non-DONE row dep (TODO/NOVEL) or a dep that is neither row nor organ (true dangling) -> NOT satisfied.
63// Grounds legitimate ORGAN foundations (the no-floating law: each built layer below IS a foundation)
64// while keeping genuine dangling/unbuilt deps flagged. LOCAL to the ladder -- does NOT alter the shared
65// an_deps_done (the dispatcher/reconcile sequencing is unchanged); only the FLOATING facet gains organ-awareness.
66func cl_deps_grounded(cx: *i64, r: i64) -> i64 {
  let dd: *u8 = an_deps_at(cx, r)
  if dd[0] == (45 as u8) { if dd[1] == (0 as u8) { return 1 } }
  let st: *i64 = cx[4] as *i64
  let tok: *u8 = sys_mmap(64)
  var i: i64 = 0
  var k: i64 = 0
  var go: i64 = 1
  var allok: i64 = 1
  while go == 1 {
      let ch: i64 = dd[i] as i64
      var fin: i64 = 0
      if ch == 0 { fin = 1 }
      if ch == 44 { fin = 1 }
      if fin == 1 {
          if k > 0 {
              tok[k] = 0 as u8
              let dr: i64 = an_find(cx, tok)
              var sat: i64 = 0
              if dr >= 0 { if st[dr] == 68 { sat = 1 } }
              if dr < 0 { if cl_organ_exists(tok) == 1 { sat = 1 } }
              if sat == 0 { allok = 0 }
              k = 0
          }
          if ch == 0 { go = 0 }
      } else {
          if k < 63 { tok[k] = ch as u8; k = k + 1 }
      }
      i = i + 1
  }
  return allok
97}
98
99// a DONE row whose foundation (deps) is not all grounded is FLOATING; pending rows are not floating.
100func cl_is_floating(cx: *i64, r: i64) -> i64 {
  let st: *i64 = cx[4] as *i64
  if st[r] != 68 { return 0 }
  if cl_deps_grounded(cx, r) == 1 { return 0 }
  return 1
105}
106
107// max layer over row r's deps (-1 = no resolvable deps). tok is a caller-owned scratch buffer.
108func cl_max_dep_layer(cx: *i64, r: i64, lay: *i64, tok: *u8) -> i64 {
  let dd: *u8 = an_deps_at(cx, r)
  if dd[0] == (45 as u8) { if dd[1] == (0 as u8) { return 0 - 1 } }
  var maxl: i64 = 0 - 1
  var i: i64 = 0
  var k: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let ch: i64 = dd[i] as i64
      var fin: i64 = 0
      if ch == 0 { fin = 1 }
      if ch == 44 { fin = 1 }
      if fin == 1 {
          if k > 0 {
              tok[k] = 0 as u8
              let dr: i64 = an_find(cx, tok)
              if dr >= 0 { if lay[dr] > maxl { maxl = lay[dr] } }
              k = 0
          }
          if ch == 0 { go = 0 }
      } else {
          if k < 63 { tok[k] = ch as u8; k = k + 1 }
      }
      i = i + 1
  }
  return maxl
134}
135
136func cl_emit_row(fd: i64, L: i64, cx: *i64, r: i64, stx: *i64, flt: *i64) -> i64 {
  cl_wn(fd, L); cl_w(fd, "\t" as *u8)
  cl_w(fd, an_id_at(cx, r)); cl_w(fd, "\t" as *u8)
  cl_w(fd, cl_status_str(stx[r])); cl_w(fd, "\t" as *u8)
  if flt[r] == 1 { cl_w(fd, "FLOATING" as *u8) } else { cl_w(fd, "grounded" as *u8) }
  cl_w(fd, "\t" as *u8)
  cl_w(fd, an_deps_at(cx, r))
  cl_w(fd, "\n" as *u8)
  return 0
145}
146
147// PHANTOM vs MISSING refinement for a dangling dep (not-row, not-organ): PHANTOM if its arc
148// (token up to its LAST '-') has OTHER real rows = a planned-but-uncreated foundation id
149// (repoint the dep to a real sibling in that arc); else MISSING = truly dangling (typo/deleted
150// arc, no siblings). Deterministic -- compares id prefixes, no heuristic target-guessing.
151func cl_arc_sibling(cx: *i64, tok: *u8) -> i64 {
  var n: i64 = 0
  while tok[n] != (0 as u8) { n = n + 1 }
  var last: i64 = 0 - 1
  var i: i64 = 0
  while i < n { if tok[i] == (45 as u8) { last = i } i = i + 1 }
  if last <= 0 { return 0 }
  var r2: i64 = 0
  while r2 < cx[0] {
      let id2: *u8 = an_id_at(cx, r2)
      var j: i64 = 0
      var pre: i64 = 1
      while j < last {
          if id2[j] != tok[j] { pre = 0; j = last } else { j = j + 1 }
      }
      if pre == 1 { if id2[last] == (45 as u8) { return 1 } }
      r2 = r2 + 1
  }
  return 0
170}
171
172// for each dep of row r, print " <id>=<status|PHANTOM|MISSING>" -- the triage classifier:
173// PHANTOM = planned arc-foundation never created (repoint); MISSING = truly dangling dep (correct it);
174// NOVEL/TODO = real unbuilt foundation (build it); ORGAN = grounded on a built organ (not floating).
175func cl_dep_blockers(fd: i64, cx: *i64, r: i64, tok: *u8) -> i64 {
  let dd: *u8 = an_deps_at(cx, r)
  let st: *i64 = cx[4] as *i64
  var i: i64 = 0
  var k: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let ch: i64 = dd[i] as i64
      var fin: i64 = 0
      if ch == 0 { fin = 1 }
      if ch == 44 { fin = 1 }
      if fin == 1 {
          if k > 0 {
              tok[k] = 0 as u8
              let dr: i64 = an_find(cx, tok)
              cl_w(fd, " " as *u8); cl_w(fd, tok); cl_w(fd, "=" as *u8)
              if dr < 0 { if cl_organ_exists(tok) == 1 { cl_w(fd, "ORGAN" as *u8) } else { if cl_arc_sibling(cx, tok) == 1 { cl_w(fd, "PHANTOM" as *u8) } else { cl_w(fd, "MISSING" as *u8) } } } else { cl_w(fd, cl_status_str(st[dr])) }
              k = 0
          }
          if ch == 0 { go = 0 }
      } else {
          if k < 63 { tok[k] = ch as u8; k = k + 1 }
      }
      i = i + 1
  }
  return 0
201}
202
203// name one floating capability + classify its blocking foundation (organ-surfaced triage).
204func cl_float_line(fd: i64, cx: *i64, r: i64, lay: *i64, stx: *i64, tok: *u8) -> i64 {
  cl_w(fd, "CAPFLOAT layer=" as *u8); cl_wn(fd, lay[r])
  cl_w(fd, " id=" as *u8); cl_w(fd, an_id_at(cx, r))
  cl_w(fd, " status=" as *u8); cl_w(fd, cl_status_str(stx[r]))
  cl_w(fd, " blocking-foundation:" as *u8)
  cl_dep_blockers(fd, cx, r, tok)
  cl_w(fd, "\n" as *u8)
  return 0
212}
213
214func cl_gate(fd: i64, cpos: i64, cneg: i64, corgpos: i64, corgneg: i64, caps: i64, layers: i64, present: i64, floating: i64, epoch: i64, ok: i64) -> i64 {
  cl_w(fd, "CAPLADDER authored=organ control_pos=" as *u8); cl_wn(fd, cpos)
  cl_w(fd, " control_neg=" as *u8); cl_wn(fd, cneg)
  cl_w(fd, " control_org_pos=" as *u8); cl_wn(fd, corgpos)
  cl_w(fd, " control_org_neg=" as *u8); cl_wn(fd, corgneg)
  cl_w(fd, " capabilities=" as *u8); cl_wn(fd, caps)
  cl_w(fd, " layers=" as *u8); cl_wn(fd, layers)
  cl_w(fd, " present=" as *u8); cl_wn(fd, present)
  cl_w(fd, " floating=" as *u8); cl_wn(fd, floating)
  if floating == 0 { cl_w(fd, " ladder_coherent=YES" as *u8) } else { cl_w(fd, " ladder_coherent=NO" as *u8) }
  cl_w(fd, " epoch=" as *u8); cl_wn(fd, epoch)
  if ok == 1 { cl_w(fd, " verdict=GREEN\n" as *u8) } else { cl_w(fd, " verdict=RED\n" as *u8) }
  return 0
227}
228
229// build a 2-row synthetic context: B (done) depends on A; caller sets A's status to test grounding.
230func cl_make_test(a_status: i64) -> i64 {
  let tcx: *i64 = an_newcx()
  tcx[0] = 2
  let a0: *u8 = an_id_at(tcx, 0); a0[0] = 65 as u8; a0[1] = 0 as u8           // "A"
  let d0: *u8 = an_deps_at(tcx, 0); d0[0] = 45 as u8; d0[1] = 0 as u8         // "-"
  let a1: *u8 = an_id_at(tcx, 1); a1[0] = 66 as u8; a1[1] = 0 as u8           // "B"
  let d1: *u8 = an_deps_at(tcx, 1); d1[0] = 65 as u8; d1[1] = 0 as u8         // "A"
  let st: *i64 = tcx[4] as *i64
  st[0] = a_status
  st[1] = 68                                                                  // B is DONE
  return cl_is_floating(tcx, 1)                                               // does B float?
241}
242
243// organ-foundation control: a 1-row DONE context whose single dep is <dep>. dep names a built organ ->
244// grounded (0); dep names nothing (no row, no organ) -> floating (1). Validates the organ-dep path.
245func cl_make_test_org(dep: *u8) -> i64 {
  let tcx: *i64 = an_newcx()
  tcx[0] = 1
  let a1: *u8 = an_id_at(tcx, 0); a1[0] = 66 as u8; a1[1] = 0 as u8           // "B"
  let d1: *u8 = an_deps_at(tcx, 0)
  var i: i64 = 0
  while dep[i] != (0 as u8) { d1[i] = dep[i]; i = i + 1 }
  d1[i] = 0 as u8
  let st: *i64 = tcx[4] as *i64
  st[0] = 68                                                                  // B is DONE
  return cl_is_floating(tcx, 0)                                               // does B float?
256}
257
258func main() -> i64 {
  // baked self-test: foundation DONE -> B not floating (0); foundation TODO -> B floating (1).
  // organ controls: a dep naming a BUILT organ -> grounded (0); a dep naming nothing -> floating (1).
  let cpos: i64 = cl_make_test(68)   // A DONE  -> expect 0
  let cneg: i64 = cl_make_test(84)   // A TODO  -> expect 1
  let corgpos: i64 = cl_make_test_org("nx_assign_core" as *u8)        // real organ -> expect 0
  let corgneg: i64 = cl_make_test_org("ZZ_NOEXIST_FOUNDATION" as *u8) // nothing    -> expect 1
  var ok: i64 = 1
  if cpos != 0 { ok = 0 }
  if cneg != 1 { ok = 0 }
  if corgpos != 0 { ok = 0 }
  if corgneg != 1 { ok = 0 }
  let epoch: i64 = sys_now_realtime_sec()
271
  if ok == 0 {
      cl_gate(1, cpos, cneg, corgpos, corgneg, 0, 0, 0, 0, epoch, 0)
      let lf0: i64 = sys_openat_append(CL_LOG, 420)
      if lf0 >= 0 { cl_gate(lf0, cpos, cneg, corgpos, corgneg, 0, 0, 0, 0, epoch, 0); sys_close(lf0) }
      return 1
  }
278
  let cx: *i64 = an_newcx()
  let nrows: i64 = an_load(CL_QUEUE, cx)
  if nrows <= 0 { cl_w(1, "CAPLADDER verdict=RED reason=queue-missing\n" as *u8); return 1 }
282
  // layer fixpoint (topological depth from the no-deps foundations)
  let lay: *i64 = sys_mmap(nrows * 8) as *i64
  var r: i64 = 0
  while r < nrows { lay[r] = 0; r = r + 1 }
  let tok: *u8 = sys_mmap(64)
  var pass: i64 = 0
  var go: i64 = 1
  while go == 1 {
      var changed: i64 = 0
      var r2: i64 = 0
      while r2 < nrows {
          let md: i64 = cl_max_dep_layer(cx, r2, lay, tok)
          var nl: i64 = 0
          if md >= 0 { nl = md + 1 }
          if nl > lay[r2] { lay[r2] = nl; changed = 1 }
          r2 = r2 + 1
      }
      pass = pass + 1
      if changed == 0 { go = 0 }
      if pass >= 64 { go = 0 }
  }
304
  // floating + counts
  let flt: *i64 = sys_mmap(nrows * 8) as *i64
  let stx: *i64 = cx[4] as *i64
  var present: i64 = 0
  var floating: i64 = 0
  var maxlayer: i64 = 0
  r = 0
  while r < nrows {
      if stx[r] == 68 { present = present + 1 }
      let fl: i64 = cl_is_floating(cx, r)
      flt[r] = fl
      if fl == 1 { floating = floating + 1 }
      if lay[r] > maxlayer { maxlayer = lay[r] }
      r = r + 1
  }
320
  // emit the map, layer-ascending (hardware rung up)
  let mfd: i64 = sys_openat_wr(CL_MAP, 420)
  if mfd >= 0 {
      cl_w(mfd, "# AUTHORED BY nx_capability_ladder -- build-up map from the hardware rung up (layer 0 = no-deps foundations). Layer + grounding COMPUTED from assignment_queue.tsv deps+DONE status, NOT asserted. FLOATING = a DONE capability resting on a non-DONE foundation (no-floating law).\n" as *u8)
      cl_w(mfd, "# columns: layer\tid\tstatus\tgrounding\tdeps\n" as *u8)
      var L: i64 = 0
      while L <= maxlayer {
          var r3: i64 = 0
          while r3 < nrows {
              if lay[r3] == L { cl_emit_row(mfd, L, cx, r3, stx, flt) }
              r3 = r3 + 1
          }
          L = L + 1
      }
      sys_close(mfd)
  }
337
  cl_gate(1, cpos, cneg, corgpos, corgneg, nrows, maxlayer + 1, present, floating, epoch, 1)
  var rf: i64 = 0
  while rf < nrows { if flt[rf] == 1 { cl_float_line(1, cx, rf, lay, stx, tok) } rf = rf + 1 }
  let lf: i64 = sys_openat_append(CL_LOG, 420)
  if lf >= 0 {
      cl_gate(lf, cpos, cneg, corgpos, corgneg, nrows, maxlayer + 1, present, floating, epoch, 1)
      rf = 0
      while rf < nrows { if flt[rf] == 1 { cl_float_line(lf, cx, rf, lay, stx, tok) } rf = rf + 1 }
      sys_close(lf)
  }
  return 0
349}
nx_capability_ladder.nx source

`nx_capability_ladder.nx` source
