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

↩ module page · 455 lines · 15859 B
1// nx_vizsla_profile.nx -- NISHI VIZSLA V0: the archetype gap profiler.
2// The operator's three-archetype theory (architect/author/editor; a household
3// usually covers two; the missing one is THE structural gap) as a measured,
4// re-runnable instrument.  The MODEL IS DATA: archetypes, trait weights,
5// domains and fill capabilities all come from knowledge/vizsla/archetype_matrix.txt
6// (the engine reads N archetypes from the file -- "three" is matrix content,
7// never a constant here).  Household answers come from knowledge/vizsla/household.txt.
8// Output rows (stdout deterministic; epoch header -> log only):
9//   VIZSLA-MEMBER name=<m> primary=<arch> <arch>=<permil>...
10//   VIZSLA-COVERAGE archetypes=<n> covered=<k> gaps=<g> threshold=<thr>
11//   VIZSLA-GAP archetype=<a> nearest=<member> nearest_permil=<p>
12//   VIZSLA-FILL domain=<d> gap=<a> capability=<cap> partner=<member>
13//   VIZSLA-VERDICT coverage=FULL | coverage=GAPPED gaps=<g>
14// argv overrides (gate fixture isolation, site-gate pattern):
15//   argv[1]=matrix path  argv[2]=household path  argv[3]=log path
16// Loud-fail law: missing/empty inputs, unknown archetype/member references = exit 1.
17// spec: knowledge/specs/2026-06-10-nishi-vizsla-ladder.md   license_tier: ORIGINAL
18import "nx_syscalls.nx"
19const K_MAGIC_65536: i64 = 65536
20
21func vz_slen(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  return n
25}
26
27func vz_p(s: *u8) -> i64 {
  sys_write(1, s, vz_slen(s))
  return 0
30}
31
32func vz_eq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if a[i] != b[i] { return 0 }
      if a[i] == (0 as u8) { return 1 }
      i = i + 1
  }
  return 0
41}
42
43func vz_dup(s: *u8) -> *u8 {
  let n: i64 = vz_slen(s)
  let d: *u8 = sys_mmap(n + 2)
  var i: i64 = 0
  while i <= n { d[i] = s[i]; i = i + 1 }
  return d
49}
50
51func vz_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while s[i] != (0 as u8) {
      let d: i64 = (s[i] as i64) - 48
      if d >= 0 { if d <= 9 { v = v * 10 + d } }
      i = i + 1
  }
  return v
60}
61
62func vz_isws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 13 { return 1 }
  if c == 9 { return 1 }
  return 0
67}
68
69// next whitespace-delimited token from b[off..lend) -> dst (NUL-terminated);
70// returns offset after the token; dst[0]=0 means no token left on the line
71func vz_tok(b: *u8, off: i64, lend: i64, dst: *u8, cap: i64) -> i64 {
  var p: i64 = off
  var go: i64 = 1
  while go == 1 {
      if p >= lend { go = 0 } else {
          if vz_isws(b[p] as i64) == 1 { p = p + 1 } else { go = 0 }
      }
  }
  var t: i64 = 0
  go = 1
  while go == 1 {
      if p >= lend { go = 0 } else {
          if vz_isws(b[p] as i64) == 1 { go = 0 } else {
              if t < cap - 1 { dst[t] = b[p]; t = t + 1 }
              p = p + 1
          }
      }
  }
  dst[t] = 0 as u8
  return p
91}
92
93func vz_readall(path: *u8, szout: *i64) -> *u8 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { szout[0] = 0 - 1; return 0 as *u8 }
  let sz: i64 = sys_lseek(fd, 0, 2)
  sys_lseek(fd, 0, 0)
  let buf: *u8 = sys_mmap(sz + 64)
  var got: i64 = 0
  var n: i64 = 1
  while n > 0 {
      n = sys_read(fd, (buf as i64 + got) as *u8, K_MAGIC_65536)
      if n > 0 { got = got + n }
  }
  sys_close(fd)
  szout[0] = got
  return buf
108}
109
110func vz_find(list: *i64, n: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < n {
      if vz_eq(list[i] as *u8, s) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
117}
118
119func vz_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { dst[off + i] = s[i]; i = i + 1 }
  return off + i
123}
124
125func vz_catn(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64 = off
  var m: i64 = v
  if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m }
  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 { dst[o + i] = t[k - 1 - i]; i = i + 1 }
  return o + k
136}
137
138// answered value (0/1) for member mi on trait key (last write wins, scan)
139func vz_ans(a_mem: *i64, a_key: *i64, a_val: *i64, nans: i64, mi: i64, key: *u8) -> i64 {
  var v: i64 = 0
  var qi: i64 = 0
  while qi < nans {
      if a_mem[qi] == mi {
          if vz_eq(a_key[qi] as *u8, key) == 1 { v = a_val[qi] }
      }
      qi = qi + 1
  }
  return v
149}
150
151func main(argc: i64, argv: *i64) -> i64 {
  var mpath: *u8 = "knowledge/vizsla/archetype_matrix.txt" as *u8
  var hpath: *u8 = "knowledge/vizsla/household.txt" as *u8
  var lpath: *u8 = "knowledge/status/vizsla_profile.log" as *u8
  if argc > 1 { mpath = argv[1] as *u8 }
  if argc > 2 { hpath = argv[2] as *u8 }
  if argc > 3 { lpath = argv[3] as *u8 }
158
  let szp: *i64 = sys_mmap(16) as *i64
  let mb: *u8 = vz_readall(mpath, szp)
  let msz: i64 = szp[0]
  if msz <= 0 { vz_p("VIZSLA-PROFILE matrix MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
  let hb: *u8 = vz_readall(hpath, szp)
  let hsz: i64 = szp[0]
  if hsz <= 0 { vz_p("VIZSLA-PROFILE household MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
166
  // model tables (all FROM DATA; capacities are buffer sizes, not model shape)
  let archs: *i64 = sys_mmap(8 * 8) as *i64
  let totw: *i64 = sys_mmap(8 * 8) as *i64
  var narch: i64 = 0
  let t_arch: *i64 = sys_mmap(8 * 64) as *i64
  let t_w: *i64 = sys_mmap(8 * 64) as *i64
  let t_key: *i64 = sys_mmap(8 * 64) as *i64
  var ntrait: i64 = 0
  let doms: *i64 = sys_mmap(8 * 16) as *i64
  var ndom: i64 = 0
  let n_dom: *i64 = sys_mmap(8 * 96) as *i64
  let n_arch: *i64 = sys_mmap(8 * 96) as *i64
  let n_cap: *i64 = sys_mmap(8 * 96) as *i64
  var nneed: i64 = 0
  var thr: i64 = 500
182
  let t0: *u8 = sys_mmap(128)
  let t1: *u8 = sys_mmap(128)
  let t2: *u8 = sys_mmap(128)
  let t3: *u8 = sys_mmap(128)
187
  // ---- parse matrix ----
  var i: i64 = 0
  while i < msz {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 {
          if e >= msz { go = 0 } else {
              if mb[e] == (10 as u8) { go = 0 } else { e = e + 1 }
          }
      }
      var p: i64 = vz_tok(mb, i, e, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if t0[0] != (0 as u8) {
          if vz_eq(t0, "CONF" as *u8) == 1 {
              p = vz_tok(mb, p, e, t1, 128)
              p = vz_tok(mb, p, e, t2, 128)
              if vz_eq(t1, "threshold_permil" as *u8) == 1 { thr = vz_atoi(t2) }
          }
          if vz_eq(t0, "ARCH" as *u8) == 1 {
              p = vz_tok(mb, p, e, t1, 128)
              if narch < 8 { archs[narch] = vz_dup(t1) as i64; totw[narch] = 0; narch = narch + 1 }
          }
          if vz_eq(t0, "TRAIT" as *u8) == 1 {
              p = vz_tok(mb, p, e, t1, 128)
              p = vz_tok(mb, p, e, t2, 128)
              p = vz_tok(mb, p, e, t3, 128)
              let ai: i64 = vz_find(archs, narch, t1)
              if ai < 0 { vz_p("VIZSLA-PROFILE TRAIT references unknown archetype -- fail loud\n" as *u8); return 1 }
              if ntrait < 64 {
                  t_arch[ntrait] = ai
                  t_w[ntrait] = vz_atoi(t2)
                  t_key[ntrait] = vz_dup(t3) as i64
                  totw[ai] = totw[ai] + t_w[ntrait]
                  ntrait = ntrait + 1
              }
          }
          if vz_eq(t0, "DOMAIN" as *u8) == 1 {
              p = vz_tok(mb, p, e, t1, 128)
              if ndom < 16 { doms[ndom] = vz_dup(t1) as i64; ndom = ndom + 1 }
          }
          if vz_eq(t0, "NEED" as *u8) == 1 {
              p = vz_tok(mb, p, e, t1, 128)
              p = vz_tok(mb, p, e, t2, 128)
              p = vz_tok(mb, p, e, t3, 128)
              let di: i64 = vz_find(doms, ndom, t1)
              if di < 0 { vz_p("VIZSLA-PROFILE NEED references unknown domain -- fail loud\n" as *u8); return 1 }
              let na: i64 = vz_find(archs, narch, t2)
              if na < 0 { vz_p("VIZSLA-PROFILE NEED references unknown archetype -- fail loud\n" as *u8); return 1 }
              if nneed < 96 {
                  n_dom[nneed] = di
                  n_arch[nneed] = na
                  n_cap[nneed] = vz_dup(t3) as i64
                  nneed = nneed + 1
              }
          }
      }
      i = e + 1
  }
246
  // ---- parse household ----
  let mems: *i64 = sys_mmap(8 * 16) as *i64
  var nmem: i64 = 0
  let a_mem: *i64 = sys_mmap(8 * 512) as *i64
  let a_key: *i64 = sys_mmap(8 * 512) as *i64
  let a_val: *i64 = sys_mmap(8 * 512) as *i64
  var nans: i64 = 0
254
  i = 0
  while i < hsz {
      var e2: i64 = i
      var go2: i64 = 1
      while go2 == 1 {
          if e2 >= hsz { go2 = 0 } else {
              if hb[e2] == (10 as u8) { go2 = 0 } else { e2 = e2 + 1 }
          }
      }
      var p2: i64 = vz_tok(hb, i, e2, t0, 128)
      if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
      if t0[0] != (0 as u8) {
          if vz_eq(t0, "MEMBER" as *u8) == 1 {
              p2 = vz_tok(hb, p2, e2, t1, 128)
              if nmem < 16 { mems[nmem] = vz_dup(t1) as i64; nmem = nmem + 1 }
          }
          if vz_eq(t0, "ANS" as *u8) == 1 {
              p2 = vz_tok(hb, p2, e2, t1, 128)
              p2 = vz_tok(hb, p2, e2, t2, 128)
              p2 = vz_tok(hb, p2, e2, t3, 128)
              let mi0: i64 = vz_find(mems, nmem, t1)
              if mi0 < 0 { vz_p("VIZSLA-PROFILE ANS references unknown member -- fail loud\n" as *u8); return 1 }
              if nans < 512 {
                  a_mem[nans] = mi0
                  a_key[nans] = vz_dup(t2) as i64
                  a_val[nans] = vz_atoi(t3)
                  nans = nans + 1
              }
          }
      }
      i = e2 + 1
  }
287
  if narch < 1 { vz_p("VIZSLA-PROFILE no archetypes in matrix -- fail loud\n" as *u8); return 1 }
  if ntrait < 1 { vz_p("VIZSLA-PROFILE no traits in matrix -- fail loud\n" as *u8); return 1 }
  if nmem < 1 { vz_p("VIZSLA-PROFILE no members in household -- fail loud\n" as *u8); return 1 }
291
  // ---- score: member x archetype permil ----
  let permil: *i64 = sys_mmap(8 * 16 * 8) as *i64
  var mi: i64 = 0
  while mi < nmem {
      var ai2: i64 = 0
      while ai2 < narch {
          var sum: i64 = 0
          var ti: i64 = 0
          while ti < ntrait {
              if t_arch[ti] == ai2 {
                  if vz_ans(a_mem, a_key, a_val, nans, mi, t_key[ti] as *u8) == 1 { sum = sum + t_w[ti] }
              }
              ti = ti + 1
          }
          var pm: i64 = 0
          if totw[ai2] > 0 { pm = (sum * 1000) / totw[ai2] }
          permil[mi * 8 + ai2] = pm
          ai2 = ai2 + 1
      }
      mi = mi + 1
  }
313
  // ---- primary per member (argmax, file order breaks ties; none if all 0) ----
  let prim: *i64 = sys_mmap(8 * 16) as *i64
  mi = 0
  while mi < nmem {
      var best: i64 = 0
      var bi: i64 = 0 - 1
      var ai3: i64 = 0
      while ai3 < narch {
          if permil[mi * 8 + ai3] > best { best = permil[mi * 8 + ai3]; bi = ai3 }
          ai3 = ai3 + 1
      }
      prim[mi] = bi
      mi = mi + 1
  }
328
  // ---- coverage: someone's primary OR anyone >= threshold ----
  let cov: *i64 = sys_mmap(8 * 8) as *i64
  var ai4: i64 = 0
  while ai4 < narch { cov[ai4] = 0; ai4 = ai4 + 1 }
  mi = 0
  while mi < nmem {
      if prim[mi] >= 0 { cov[prim[mi]] = 1 }
      var ai5: i64 = 0
      while ai5 < narch {
          if permil[mi * 8 + ai5] >= thr { cov[ai5] = 1 }
          ai5 = ai5 + 1
      }
      mi = mi + 1
  }
  var covered: i64 = 0
  var ai6: i64 = 0
  while ai6 < narch {
      if cov[ai6] == 1 { covered = covered + 1 }
      ai6 = ai6 + 1
  }
  let gaps: i64 = narch - covered
350
  // ---- compose the report (stdout-deterministic; epoch goes to log only) ----
  let rep: *u8 = sys_mmap(K_MAGIC_65536)
  var o: i64 = 0
  mi = 0
  while mi < nmem {
      o = vz_cat(rep, o, "VIZSLA-MEMBER name=" as *u8)
      o = vz_cat(rep, o, mems[mi] as *u8)
      o = vz_cat(rep, o, " primary=" as *u8)
      if prim[mi] >= 0 { o = vz_cat(rep, o, archs[prim[mi]] as *u8) } else { o = vz_cat(rep, o, "none" as *u8) }
      var ai7: i64 = 0
      while ai7 < narch {
          o = vz_cat(rep, o, " " as *u8)
          o = vz_cat(rep, o, archs[ai7] as *u8)
          o = vz_cat(rep, o, "=" as *u8)
          o = vz_catn(rep, o, permil[mi * 8 + ai7])
          ai7 = ai7 + 1
      }
      o = vz_cat(rep, o, "\n" as *u8)
      mi = mi + 1
  }
  o = vz_cat(rep, o, "VIZSLA-COVERAGE archetypes=" as *u8)
  o = vz_catn(rep, o, narch)
  o = vz_cat(rep, o, " covered=" as *u8)
  o = vz_catn(rep, o, covered)
  o = vz_cat(rep, o, " gaps=" as *u8)
  o = vz_catn(rep, o, gaps)
  o = vz_cat(rep, o, " threshold=" as *u8)
  o = vz_catn(rep, o, thr)
  o = vz_cat(rep, o, "\n" as *u8)
380
  // gap rows: nearest member = highest permil in the gap archetype (partnership)
  var ag: i64 = 0
  while ag < narch {
      if cov[ag] == 0 {
          var nbest: i64 = 0 - 1
          var nbp: i64 = 0 - 1
          var mj: i64 = 0
          while mj < nmem {
              if permil[mj * 8 + ag] > nbp { nbp = permil[mj * 8 + ag]; nbest = mj }
              mj = mj + 1
          }
          if nbest < 0 { nbest = 0; nbp = 0 }
          o = vz_cat(rep, o, "VIZSLA-GAP archetype=" as *u8)
          o = vz_cat(rep, o, archs[ag] as *u8)
          o = vz_cat(rep, o, " nearest=" as *u8)
          o = vz_cat(rep, o, mems[nbest] as *u8)
          o = vz_cat(rep, o, " nearest_permil=" as *u8)
          o = vz_catn(rep, o, nbp)
          o = vz_cat(rep, o, "\n" as *u8)
      }
      ag = ag + 1
  }
403
  // fill plan: every NEED row whose archetype is a gap (needs-file order)
  var ni: i64 = 0
  while ni < nneed {
      if cov[n_arch[ni]] == 0 {
          var pbest: i64 = 0
          var pbp: i64 = 0 - 1
          var mk: i64 = 0
          while mk < nmem {
              if permil[mk * 8 + n_arch[ni]] > pbp { pbp = permil[mk * 8 + n_arch[ni]]; pbest = mk }
              mk = mk + 1
          }
          o = vz_cat(rep, o, "VIZSLA-FILL domain=" as *u8)
          o = vz_cat(rep, o, doms[n_dom[ni]] as *u8)
          o = vz_cat(rep, o, " gap=" as *u8)
          o = vz_cat(rep, o, archs[n_arch[ni]] as *u8)
          o = vz_cat(rep, o, " capability=" as *u8)
          o = vz_cat(rep, o, n_cap[ni] as *u8)
          o = vz_cat(rep, o, " partner=" as *u8)
          o = vz_cat(rep, o, mems[pbest] as *u8)
          o = vz_cat(rep, o, "\n" as *u8)
      }
      ni = ni + 1
  }
427
  if gaps == 0 {
      o = vz_cat(rep, o, "VIZSLA-VERDICT coverage=FULL\n" as *u8)
  } else {
      o = vz_cat(rep, o, "VIZSLA-VERDICT coverage=GAPPED gaps=" as *u8)
      o = vz_catn(rep, o, gaps)
      o = vz_cat(rep, o, "\n" as *u8)
  }
435
  sys_write(1, rep, o)
437
  // log: epoch header + the same report (append-only, additive law)
  let logfd: i64 = sys_openat_append(lpath, 0x1a4)
  if logfd > 0 {
      let hdr: *u8 = sys_mmap(512)
      var ho: i64 = 0
      ho = vz_cat(hdr, ho, "VIZSLA-PROFILE epoch=" as *u8)
      ho = vz_catn(hdr, ho, sys_now_realtime_sec())
      ho = vz_cat(hdr, ho, " matrix=" as *u8)
      ho = vz_cat(hdr, ho, mpath)
      ho = vz_cat(hdr, ho, " household=" as *u8)
      ho = vz_cat(hdr, ho, hpath)
      ho = vz_cat(hdr, ho, "\n" as *u8)
      sys_write(logfd, hdr, ho)
      sys_write(logfd, rep, o)
      sys_close(logfd)
  }
  return 0
455}
nx_vizsla_profile.nx source

`nx_vizsla_profile.nx` source
