`nx_percept.nx` source

↩ module page · 653 lines · 29246 B
1// nx_percept.nx -- AL2: THE PERCEPTUAL JUDGE (operator 2026-08-09: EXCEED needs a human-confirmed
2// perceptual win; the composite critic is CONVICTED as quality -- random squares score 628 on it).
3// This organ does NOT claim absolute quality. It claims RELATIVE PERCEPTUAL POSITION: a candidate's
4// multi-scale structure statistics compared against TWO banked anchor sets --
5//   GOOD  = the 10 commercial reference frames (the estate's benchmark artifacts, gate-floored)
6//   JUNK  = the caricature controls (flat colour, random-squares mosaic)
7// score = sim(candidate, GOOD centroid) - sim(candidate, JUNK centroid), permil cosine, integer.
8// ADMISSION IS EARNED, NEVER ASSUMED: the `ladder` verb replays the HUMAN-CONFIRMED ordering from
9// 2026-08-09 (flat < squares < m2d frame < craft frame; every reference above squares, LEAVE-ONE-OUT
10// so an anchor never scores against a centroid containing itself). If the ladder does not reproduce
11// the human ordering, the judge REFUSES ITSELF -- numbers published either way, all values printed.
12// Features (integer, per NXFH1 400x240 frame): 7-bin hue-order histogram + 3-scale block-delta
13// histograms (2/8/32 px, 8 bins each) + edge-direction distribution (H/V/diag + density) + horizontal
14// same-run length histogram (8 log bins). Each family permil-normalized => 43 dims, cosine compared.
15// license_tier: ORIGINAL  expect_exit: 0
16import "nx_syscalls.nx"
17const PJ_MAGIC_500000: i64 = 500000
18const PJ_MAGIC_1000000000: i64 = 1000000000
19
20const PJ_W: i64 = 400
21const PJ_H: i64 = 240
22const PJ_ND: i64 = 43
23const PJ_NANCH: i64 = 12
24const PJ_FCAP: i64 = 1048576
25
26func pw2(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
27func pn2(v: i64) -> i64 {
  if v==0 { sys_write(1,"0" as *u8,1); return 0 }
  var m: i64=v
  if m<0 { sys_write(1,"-" as *u8,1); m=0-m }
  let t: *u8=sys_mmap(32); var k: i64=0
  while m>0 { t[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  let o: *u8=sys_mmap(32); var q: i64=k-1; var i: i64=0
  while q>=0 { o[i]=t[q]; i=i+1; q=q-1 }
  sys_write(1,o,i); return 0
36}
37func pj_abs(v: i64) -> i64 { if v<0 { return 0-v } return v }
38func pj_isq(v: i64) -> i64 {
  if v <= 0 { return 0 }
  var x: i64 = v
  var y: i64 = (x+1)/2
  while y < x { x = y; y = (x + v/x)/2 }
  return x
44}
45func pj_hex1(c: i64) -> i64 {
  if c >= 48 { if c <= 57 { return c-48 } }
  if c >= 97 { if c <= 102 { return c-87 } }
  return 0-1
49}
50
51const PJ_MAGIC_LEN: i64 = 6            // the six bytes of "NXFH1 " including its separating space
52const PJ_ASCII_0: i64 = 48
53const PJ_ASCII_9: i64 = 57
54const PJ_DEC_BASE: i64 = 10
55const PJ_WH_BYTES: i64 = 16             // two i64 out-slots, page-rounded by mmap
56const PJ_HDR_READ: i64 = 64             // the header line settles the question; never read the body for it
57const PJ_HDR_MIN: i64 = 10              // shortest possible "NXFH1 w h" + newline
58const PJ_EXIT_UNJUDGED: i64 = 4         // NOT a low score and NOT a failure: NO score
59
60// ★THE HEADER DECLARES THE SIZE AND THIS ORGAN USED TO IGNORE IT ENTIRELY.
61// pj_load skips line 1 and then reads EXACTLY PJ_W*PJ_H hex triplets out of the body. For a frame
62// LARGER than 400x240 that is a silent PREFIX -- for a 1920x1200 capture, the top 50 rows -- scored
63// against 400x240 anchors and published as a confident number about the whole image. Its only guard
64// was a BYTE-COUNT floor, which a larger frame passes trivially.
65// MEASURED 2026-08-28: nothing in the estate checked the declared dimensions on this path.
66// ★A JUDGE THAT REPORTS A CONFIDENT NUMBER ABOUT A WINDOW OF ITS INPUT IS WORSE THAN ONE THAT
67// REFUSES, BECAUSE THE NUMBER IS AUTHORITATIVE AND WRONG -- and it makes every quality improvement
68// above the ceiling unmeasurable and every regression there invisible.
69// ⚠THIS IS A CEILING, NOT A BUFFER TO WIDEN. The banked GOOD/JUNK anchor sets are themselves 400x240
70// (verified: all twelve anchors plus both ladder frames declare "NXFH1 400 240"), so a candidate at
71// another extent would be compared against anchors of a different subject. Raising PJ_W/PJ_H means
72// re-banking every anchor, which is a deliberate project, not a constant edit.
73// SAFE BY CONSTRUCTION for every existing caller: each shipped anchor already declares 400x240, so
74// this check refuses only frames that were previously being read as prefixes.
75// out[0]=w out[1]=h are written EITHER WAY, so a caller can NAME the mismatch instead of emitting a
76// bare refusal that reads like an unreadable file.
77func pj_hdr_wh(b: *u8, n: i64, out: *i64) -> i64 {
  out[0] = 0
  out[1] = 0
  if n < PJ_HDR_MIN { return 0 }
  let mg: *u8 = "NXFH1 " as *u8
  var k: i64 = 0
  var m: i64 = 1
  while k < PJ_MAGIC_LEN {
      if b[k] != mg[k] { m = 0 }
      k = k + 1
  }
  if m == 0 { return 0 }
  var p: i64 = PJ_MAGIC_LEN
  var w: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if p >= n { go = 0 }
      if go == 1 {
          let c: i64 = b[p] as i64
          var dg: i64 = 0
          if c >= PJ_ASCII_0 { if c <= PJ_ASCII_9 { dg = 1 } }
          if dg == 1 { w = w*PJ_DEC_BASE + (c - PJ_ASCII_0); p = p + 1 }
          if dg == 0 { go = 0 }
      }
  }
  p = p + 1
  var h: i64 = 0
  var go2: i64 = 1
  while go2 == 1 {
      if p >= n { go2 = 0 }
      if go2 == 1 {
          let c2: i64 = b[p] as i64
          var dg2: i64 = 0
          if c2 >= PJ_ASCII_0 { if c2 <= PJ_ASCII_9 { dg2 = 1 } }
          if dg2 == 1 { h = h*PJ_DEC_BASE + (c2 - PJ_ASCII_0); p = p + 1 }
          if dg2 == 0 { go2 = 0 }
      }
  }
  out[0] = w
  out[1] = h
  if w != PJ_W { return 0 }
  if h != PJ_H { return 0 }
  return 1
120}
121
122// Read ONLY the header line of a capture. Sizing a buffer from the file would pull a multi-megabyte
123// frame into memory to answer a question its first line settles.
124func pj_hdr_of_file(path: *u8, out: *i64) -> i64 {
  out[0] = 0
  out[1] = 0
  let b: *u8 = sys_mmap(PJ_HDR_READ)
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { sys_munmap(b, PJ_HDR_READ); return 0 }
  let got: i64 = sys_read(fd, b, PJ_HDR_READ)
  sys_close(fd)
  var r: i64 = 0
  if got > 0 { r = pj_hdr_wh(b, got, out) }
  sys_munmap(b, PJ_HDR_READ)
  return r
136}
137
138// load an NXFH1 400x240 frame into rgb arrays. returns 1 ok / 0 refuse.
139func pj_load(path: *u8, rr: *i64, gg: *i64, bb: *i64) -> i64 {
  let lp: *i64 = sys_mmap(8) as *i64
  lp[0]=0
  let b: *u8 = sys_read_file(path, lp)
  if (b as i64)==0 { return 0 }
  let n: i64 = lp[0]
  if n < PJ_MAGIC_500000 { return 0 }
  // ★DEFENCE IN DEPTH: refuse a frame whose DECLARED extent is not this judge's. The byte-count floor
  // above only catches frames that are too SMALL; a larger one sails past it and is then read as a
  // prefix. Callers that need to NAME the mismatch call pj_hdr_of_file first (the judge verb does);
  // this guard exists so no future caller can reintroduce the silent-prefix path by forgetting to.
  let hw: *i64 = sys_mmap(PJ_WH_BYTES) as *i64
  let dimok: i64 = pj_hdr_wh(b, n, hw)
  sys_munmap(hw as *u8, PJ_WH_BYTES)
  if dimok == 0 { return 0 }
  var i: i64 = 0
  while i < n { if b[i]==(10 as u8) { i = i + 1 } else { i = i + PJ_MAGIC_1000000000 } }
  var p: i64 = 0
  while b[p]!=(10 as u8) { p=p+1 }
  p = p + 1
  var px: i64 = 0
  while px < PJ_W*PJ_H {
      if b[p]==(10 as u8) { p=p+1 }
      let h0: i64 = pj_hex1(b[p] as i64)
      let h1: i64 = pj_hex1(b[p+1] as i64)
      let h2: i64 = pj_hex1(b[p+2] as i64)
      let h3: i64 = pj_hex1(b[p+3] as i64)
      let h4: i64 = pj_hex1(b[p+4] as i64)
      let h5: i64 = pj_hex1(b[p+5] as i64)
      if h0 < 0 { return 0 }
      if h1 < 0 { return 0 }
      if h2 < 0 { return 0 }
      if h3 < 0 { return 0 }
      if h4 < 0 { return 0 }
      if h5 < 0 { return 0 }
      rr[px] = h0*16+h1
      gg[px] = h2*16+h3
      bb[px] = h4*16+h5
      p = p + 6
      px = px + 1
  }
  return 1
181}
182
183func pj_norm(f: *i64, from: i64, cnt: i64) -> i64 {
  var s: i64 = 0
  var i: i64 = from
  while i < from+cnt { s = s + f[i]; i = i + 1 }
  if s <= 0 { return 0 }
  i = from
  while i < from+cnt { f[i] = f[i]*1000/s; i = i + 1 }
  return 0
191}
192
193// extract the 43-dim feature vector
194func pj_feat(rr: *i64, gg: *i64, bb: *i64, f: *i64) -> i64 {
  var i: i64 = 0
  while i < PJ_ND { f[i]=0; i=i+1 }
  let lum: *i64 = sys_mmap(PJ_W*PJ_H*8) as *i64
  i = 0
  while i < PJ_W*PJ_H { lum[i] = (rr[i]*3 + gg[i]*6 + bb[i]) / 10; i = i + 1 }
  // F1 hue-order histogram: dims 0..6 (6 channel orderings + gray)
  i = 0
  while i < PJ_W*PJ_H {
      let r: i64 = rr[i]
      let g: i64 = gg[i]
      let b: i64 = bb[i]
      var mx: i64 = r
      if g > mx { mx = g }
      if b > mx { mx = b }
      var mn: i64 = r
      if g < mn { mn = g }
      if b < mn { mn = b }
      var bin: i64 = 6
      if mx - mn >= 24 {
          bin = 0
          if r >= g { if g >= b { bin = 0 } }
          if r >= b { if b > g { bin = 1 } }
          if g > r { if r >= b { bin = 2 } }
          if g >= b { if b > r { bin = 3 } }
          if b > g { if g >= r { bin = 4 } }
          if b > r { if r > g { bin = 5 } }
      }
      f[bin] = f[bin] + 1
      i = i + 1
  }
  pj_norm(f, 0, 7)
  // F2 block-delta histograms at 2/8/32 px: dims 7..14, 15..22, 23..30
  var sc: i64 = 0
  while sc < 3 {
      var bs: i64 = 2
      if sc == 1 { bs = 8 }
      if sc == 2 { bs = 32 }
      let bw: i64 = PJ_W/bs
      let bh: i64 = PJ_H/bs
      let bm: *i64 = sys_mmap(bw*bh*8) as *i64
      var by: i64 = 0
      while by < bh {
          var bx: i64 = 0
          while bx < bw {
              var s2: i64 = 0
              var yy: i64 = 0
              while yy < bs {
                  var xx: i64 = 0
                  while xx < bs { s2 = s2 + lum[(by*bs+yy)*PJ_W + bx*bs+xx]; xx = xx + 1 }
                  yy = yy + 1
              }
              bm[by*bw+bx] = s2/(bs*bs)
              bx = bx + 1
          }
          by = by + 1
      }
      let base: i64 = 7 + sc*8
      by = 0
      while by < bh {
          var bx2: i64 = 0
          while bx2 < bw {
              if bx2+1 < bw {
                  var d: i64 = pj_abs(bm[by*bw+bx2+1]-bm[by*bw+bx2]) / 8
                  if d > 7 { d = 7 }
                  f[base+d] = f[base+d] + 1
              }
              if by+1 < bh {
                  var d2: i64 = pj_abs(bm[(by+1)*bw+bx2]-bm[by*bw+bx2]) / 8
                  if d2 > 7 { d2 = 7 }
                  f[base+d2] = f[base+d2] + 1
              }
              bx2 = bx2 + 1
          }
          by = by + 1
      }
      pj_norm(f, base, 8)
      sc = sc + 1
  }
  // F3 edge directions: dims 31..33 (H/V/diag) + 34 edge density permil
  var ne: i64 = 0
  var y3: i64 = 0
  while y3 < PJ_H-1 {
      var x3: i64 = 0
      while x3 < PJ_W-1 {
          let dx3: i64 = pj_abs(lum[y3*PJ_W+x3+1]-lum[y3*PJ_W+x3])
          let dy3: i64 = pj_abs(lum[(y3+1)*PJ_W+x3]-lum[y3*PJ_W+x3])
          if dx3+dy3 > 60 {
              ne = ne + 1
              var db: i64 = 33
              if dx3 > 2*dy3 { db = 31 }
              if dy3 > 2*dx3 { db = 32 }
              f[db] = f[db] + 1
          }
          x3 = x3 + 1
      }
      y3 = y3 + 1
  }
  pj_norm(f, 31, 3)
  f[34] = ne*1000/(PJ_W*PJ_H)
  // F4 horizontal same-run lengths: dims 35..42 (log2 bins)
  var y4: i64 = 0
  while y4 < PJ_H {
      var run: i64 = 1
      var x4: i64 = 1
      while x4 < PJ_W {
          let i0: i64 = y4*PJ_W+x4-1
          let i1: i64 = y4*PJ_W+x4
          var same: i64 = 1
          if pj_abs(rr[i1]-rr[i0]) > 12 { same = 0 }
          if pj_abs(gg[i1]-gg[i0]) > 12 { same = 0 }
          if pj_abs(bb[i1]-bb[i0]) > 12 { same = 0 }
          if same == 1 { run = run + 1 }
          if same == 0 {
              var lb: i64 = 0
              var rv: i64 = run
              while rv > 1 { rv = rv/2; lb = lb + 1 }
              if lb > 7 { lb = 7 }
              f[35+lb] = f[35+lb] + 1
              run = 1
          }
          x4 = x4 + 1
      }
      var lb2: i64 = 0
      var rv2: i64 = run
      while rv2 > 1 { rv2 = rv2/2; lb2 = lb2 + 1 }
      if lb2 > 7 { lb2 = 7 }
      f[35+lb2] = f[35+lb2] + 1
      y4 = y4 + 1
  }
  pj_norm(f, 35, 8)
  return 0
326}
327
328// permil cosine similarity between two 43-dim vectors
329func pj_cos(a: *i64, b: *i64) -> i64 {
  var dot: i64 = 0
  var na: i64 = 0
  var nb: i64 = 0
  var i: i64 = 0
  while i < PJ_ND {
      dot = dot + a[i]*b[i]
      na = na + a[i]*a[i]
      nb = nb + b[i]*b[i]
      i = i + 1
  }
  let d: i64 = pj_isq(na) * pj_isq(nb)
  if d <= 0 { return 0 }
  return dot*1000/d
343}
344
345func pj_featfile(path: *u8, f: *i64) -> i64 {
  let rr: *i64 = sys_mmap(PJ_W*PJ_H*8) as *i64
  let gg: *i64 = sys_mmap(PJ_W*PJ_H*8) as *i64
  let bb: *i64 = sys_mmap(PJ_W*PJ_H*8) as *i64
  if pj_load(path, rr, gg, bb) == 0 { return 0 }
  pj_feat(rr, gg, bb, f)
  return 1
352}
353
354// CENTROIDS, EXTRACTED so the scorer and the family decomposition below cannot disagree about what the
355// GOOD and JUNK centroids ARE. Byte-for-byte the arithmetic that used to sit inside pj_score, and the
356// neutrality is CHECKABLE ON REAL DATA rather than asserted: `ladder` must still print exactly
357// flat=-342 squares=-167 m2d=283 craft=196 after this extraction.
358func pj_centroids(av: *i64, skip: i64, gc: *i64, jc: *i64) -> i64 {
  var d2: i64 = 0
  while d2 < PJ_ND {
      var sg: i64 = 0
      var ng: i64 = 0
      var ai: i64 = 0
      while ai < 10 {
          if ai != skip { sg = sg + av[ai*PJ_ND+d2]; ng = ng + 1 }
          ai = ai + 1
      }
      gc[d2] = sg/ng
      jc[d2] = (av[10*PJ_ND+d2] + av[11*PJ_ND+d2])/2
      d2 = d2 + 1
  }
  return 0
373}
374
375// FAMILY-SCOPED COSINE: pj_cos restricted to one contiguous dim range, so a disagreement can be
376// ATTRIBUTED to a feature family instead of asserted about all 43 dims at once. The ladder could say
377// the judge contradicts the human and nothing could say WHICH PART OF THE JUDGE did it.
378func pj_cos_range(a: *i64, b: *i64, lo: i64, hi: i64) -> i64 {
  var dot: i64 = 0
  var na: i64 = 0
  var nb: i64 = 0
  var i: i64 = lo
  while i < hi {
      dot = dot + a[i]*b[i]
      na = na + a[i]*a[i]
      nb = nb + b[i]*b[i]
      i = i + 1
  }
  let d: i64 = pj_isq(na) * pj_isq(nb)
  if d <= 0 { return 0 }
  return dot*1000/d
392}
393
394// FAMILY-MASKED COSINE: pj_cos over every dim OUTSIDE [lo, hi). The complement of pj_cos_range, and the
395// arithmetic ladderx needs to ask what the judge would say if one family were not in the vector at all.
396func pj_cos_excl(a: *i64, b: *i64, lo: i64, hi: i64) -> i64 {
  var dot: i64 = 0
  var na: i64 = 0
  var nb: i64 = 0
  var i: i64 = 0
  while i < PJ_ND {
      var use: i64 = 0
      if i < lo { use = 1 }
      if i >= hi { use = 1 }
      if use == 1 {
          dot = dot + a[i]*b[i]
          na = na + a[i]*a[i]
          nb = nb + b[i]*b[i]
      }
      i = i + 1
  }
  let d: i64 = pj_isq(na) * pj_isq(nb)
  if d <= 0 { return 0 }
  return dot*1000/d
415}
416
417// the judge's own score with one family masked out. lo==hi==0 masks NOTHING and must therefore reproduce
418// pj_score exactly -- that identity is ladderx's control row and is the reason the control is printed.
419func pj_score_excl(f: *i64, av: *i64, lo: i64, hi: i64) -> i64 {
  let gc: *i64 = sys_mmap(PJ_ND*8) as *i64
  let jc: *i64 = sys_mmap(PJ_ND*8) as *i64
  pj_centroids(av, 0-1, gc, jc)
  return pj_cos_excl(f, gc, lo, hi) - pj_cos_excl(f, jc, lo, hi)
424}
425
426// judge score of vector f against GOOD centroid (skip index `skip` for leave-one-out; -1 = none)
427func pj_score(f: *i64, av: *i64, skip: i64) -> i64 {
  let gc: *i64 = sys_mmap(PJ_ND*8) as *i64
  let jc: *i64 = sys_mmap(PJ_ND*8) as *i64
  pj_centroids(av, skip, gc, jc)
  return pj_cos(f, gc) - pj_cos(f, jc)
432}
433
434func pj_anchor_path(i: i64) -> *u8 {
  if i == 0 { return "knowledge/breeders1.nxfh" as *u8 }
  if i == 1 { return "knowledge/veloren1.nxfh" as *u8 }
  if i == 2 { return "knowledge/ref_madisland.nxfh" as *u8 }
  if i == 3 { return "knowledge/ref_carnal.nxfh" as *u8 }
  if i == 4 { return "knowledge/ref_dik.nxfh" as *u8 }
  if i == 5 { return "knowledge/ref_vrhot.nxfh" as *u8 }
  if i == 6 { return "knowledge/mgi1.nxfh" as *u8 }
  if i == 7 { return "knowledge/oplc1.nxfh" as *u8 }
  if i == 8 { return "knowledge/cm3d21.nxfh" as *u8 }
  if i == 9 { return "knowledge/vam1.nxfh" as *u8 }
  if i == 10 { return "knowledge/flat_control.nxfh" as *u8 }
  return "knowledge/squares_control.nxfh" as *u8
447}
448
449func main(argc: i64, argv: *i64) -> i64 {
  let av: *i64 = sys_mmap(PJ_NANCH*PJ_ND*8) as *i64
  var ai: i64 = 0
  while ai < PJ_NANCH {
      if pj_featfile(pj_anchor_path(ai), ((av as i64) + ai*PJ_ND*8) as *i64) == 0 {
          pw2("PERCEPT RED: anchor unreadable: " as *u8)
          pw2(pj_anchor_path(ai))
          pw2("\x0averdict=RED\x0a" as *u8)
          return 1
      }
      ai = ai + 1
  }
  // LADDERX: THE LADDER RE-RUN WITH ONE FEATURE FAMILY MASKED OUT, FOUR TIMES, PLUS THE UNMASKED CONTROL.
  // This changes NO score the judge publishes -- it is an instrument that asks WHICH FAMILY the L3
  // disagreement lives in, by measurement instead of by argument. ALL FIVE ROWS PRINT, ALWAYS: handing a
  // reader only the mask that produces the desired ordering would be choosing the experiment after seeing
  // the result, and if SEVERAL masks flip L3 then the evidence for any one of them is correspondingly
  // weaker and the output must show that rather than hide it.
  // * A MASK THAT FLIPS THE VERDICT IS A HYPOTHESIS ABOUT A CONFOUND, NEVER A LICENCE TO DROP THE FAMILY:
  //   dropping a family because it disagrees is loosening the gate to flatter the number.
  if argc >= 2 {
      let a0: *u8 = argv[1] as *u8
      if a0[0]==(120 as u8) {
          let fmx: *i64 = sys_mmap(PJ_ND*8) as *i64
          let fcx: *i64 = sys_mmap(PJ_ND*8) as *i64
          if pj_featfile("knowledge/nx_m2d_frame.nxfh" as *u8, fmx) == 0 { pw2("PERCEPT RED: m2d frame unreadable\x0averdict=RED\x0a" as *u8); return 1 }
          if pj_featfile("knowledge/craft1.nxfh" as *u8, fcx) == 0 { pw2("PERCEPT RED: craft frame unreadable\x0averdict=RED\x0a" as *u8); return 1 }
          pw2("=== nx_percept ladderx: L3 (m2d < craft) with ONE FAMILY MASKED OUT, all five rows printed ===\x0a" as *u8)
          var mi: i64 = 0
          var flips: i64 = 0
          while mi < 5 {
              var lo: i64 = 0
              var hi: i64 = 0
              if mi == 1 { lo = 0;  hi = 7 }
              if mi == 2 { lo = 7;  hi = 31 }
              if mi == 3 { lo = 31; hi = 35 }
              if mi == 4 { lo = 35; hi = 43 }
              let sm: i64 = pj_score_excl(fmx, av, lo, hi)
              let sc: i64 = pj_score_excl(fcx, av, lo, hi)
              pw2("  masked=" as *u8)
              if mi == 0 { pw2("none(control)" as *u8) }
              if mi == 1 { pw2("hue" as *u8) }
              if mi == 2 { pw2("blockdelta" as *u8) }
              if mi == 3 { pw2("edge" as *u8) }
              if mi == 4 { pw2("runlength" as *u8) }
              pw2(" m2d=" as *u8); pn2(sm)
              pw2(" craft=" as *u8); pn2(sc)
              pw2(" L3=" as *u8)
              if sm < sc { pw2("GREEN" as *u8) if mi > 0 { flips = flips + 1 } } else { pw2("RED" as *u8) }
              pw2("\x0a" as *u8)
              mi = mi + 1
          }
          pw2("  masks_that_flip_L3=" as *u8); pn2(flips)
          pw2(" of 4 -- ONE is a located confound, SEVERAL is a weak signal, ZERO means no single family explains it\x0a" as *u8)
          return 0
      }
  }
  // judge <path>
  if argc >= 3 {
      let a1: *u8 = argv[1] as *u8
      // ANCHORS: THE PER-ANCHOR DECOMPOSITION. A SCORE THAT CANNOT BE DECOMPOSED CANNOT BE ARGUED WITH.
      // `ladder` can say the judge contradicts the human ordering and NOTHING could say why, so L3 has
      // stood RED as a bare verdict. This prints the cosine to EVERY banked anchor with its class, which
      // is what separates the two candidate explanations: a SUBJECT MISMATCH (the GOOD centroid is 9/10
      // commercial CHARACTER renders, so a world/terrain frame is far from it for a reason that is not
      // quality) from a genuine quality disagreement. Those two have opposite remedies, and guessing
      // between them is how a gate gets loosened to flatter a number.
      // Read-only and strictly additive: no existing verb, path or number changes.
      // FAMILIES: the same decomposition ONE LEVEL DEEPER -- per FEATURE FAMILY, cosine to the GOOD and
      // JUNK centroids and their difference. `anchors` says WHICH ANCHOR pulls a frame; this says WHICH
      // PART OF THE 43-DIM VECTOR does the pulling, and that is exactly the difference between two
      // remedies that look identical from a score: RE-BANK AN ANCHOR, versus THE FEATURE SET CANNOT SEE
      // WHAT THE HUMAN SEES. Layout is fixed by pj_feat and read from its own comments rather than
      // guessed: hue 0..6, block-delta 7..30 (three scales x 8 bins), edge 31..34, runlength 35..42.
      if a1[0]==(102 as u8) {
          let cff: *i64 = sys_mmap(PJ_ND*8) as *i64
          if pj_featfile(argv[2] as *u8, cff) == 0 {
              pw2("PERCEPT RED: candidate unreadable\x0averdict=RED\x0a" as *u8)
              return 1
          }
          let gcf: *i64 = sys_mmap(PJ_ND*8) as *i64
          let jcf: *i64 = sys_mmap(PJ_ND*8) as *i64
          pj_centroids(av, 0-1, gcf, jcf)
          pw2("{\x22organ\x22:\x22nx_percept\x22,\x22verb\x22:\x22families\x22,\x22families\x22:[" as *u8)
          var fi: i64 = 0
          while fi < 4 {
              var lo: i64 = 0
              var hi: i64 = 7
              if fi == 1 { lo = 7; hi = 31 }
              if fi == 2 { lo = 31; hi = 35 }
              if fi == 3 { lo = 35; hi = 43 }
              if fi > 0 { pw2("," as *u8) }
              pw2("{\x22family\x22:\x22" as *u8)
              if fi == 0 { pw2("hue" as *u8) }
              if fi == 1 { pw2("blockdelta" as *u8) }
              if fi == 2 { pw2("edge" as *u8) }
              if fi == 3 { pw2("runlength" as *u8) }
              pw2("\x22,\x22dims\x22:" as *u8); pn2(hi - lo)
              let cg: i64 = pj_cos_range(cff, gcf, lo, hi)
              let cj: i64 = pj_cos_range(cff, jcf, lo, hi)
              pw2(",\x22cos_good\x22:" as *u8); pn2(cg)
              pw2(",\x22cos_junk\x22:" as *u8); pn2(cj)
              pw2(",\x22diff\x22:" as *u8); pn2(cg - cj)
              pw2("}" as *u8)
              fi = fi + 1
          }
          pw2("]}\x0a" as *u8)
          return 0
      }
      if a1[0]==(97 as u8) {
          let caf: *i64 = sys_mmap(PJ_ND*8) as *i64
          if pj_featfile(argv[2] as *u8, caf) == 0 {
              pw2("PERCEPT RED: candidate unreadable\x0averdict=RED\x0a" as *u8)
              return 1
          }
          pw2("{\x22organ\x22:\x22nx_percept\x22,\x22verb\x22:\x22anchors\x22,\x22sims\x22:[" as *u8)
          var qi: i64 = 0
          while qi < PJ_NANCH {
              if qi > 0 { pw2("," as *u8) }
              pw2("{\x22anchor\x22:\x22" as *u8); pw2(pj_anchor_path(qi))
              pw2("\x22,\x22class\x22:\x22" as *u8)
              if qi < 10 { pw2("GOOD" as *u8) } else { pw2("JUNK" as *u8) }
              pw2("\x22,\x22cos\x22:" as *u8)
              pn2(pj_cos(caf, ((av as i64) + qi*PJ_ND*8) as *i64))
              pw2("}" as *u8)
              qi = qi + 1
          }
          pw2("]}\x0a" as *u8)
          return 0
      }
      if a1[0]==(106 as u8) {
          // ★DECLARE THE CEILING BEFORE SCORING, AND NAME A MISMATCH INSTEAD OF ABSORBING IT.
          // A frame that parses but is not this judge's extent is UNJUDGED, not RED and not a low
          // score: the ruler cannot see it, and "the ruler is blind here" and "the image is bad"
          // are different findings with different remedies. Before 2026-08-28 this path silently
          // scored the first 400x240 pixels of whatever it was handed.
          let hw2: *i64 = sys_mmap(PJ_WH_BYTES) as *i64
          let hdrok: i64 = pj_hdr_of_file(argv[2] as *u8, hw2)
          if hdrok == 0 { if hw2[0] > 0 {
              pw2("{\x22organ\x22:\x22nx_percept\x22,\x22verb\x22:\x22judge\x22,\x22verdict\x22:\x22UNJUDGED-AT-RESOLUTION\x22,\x22frame_w\x22:" as *u8); pn2(hw2[0])
              pw2(",\x22frame_h\x22:" as *u8); pn2(hw2[1])
              pw2(",\x22ceiling_w\x22:" as *u8); pn2(PJ_W)
              pw2(",\x22ceiling_h\x22:" as *u8); pn2(PJ_H)
              pw2(",\x22why\x22:\x22this judge's banked GOOD and JUNK anchors are ceiling_w x ceiling_h, so a frame of any other extent would be compared against anchors of a different subject; it was previously read as a PREFIX of that size and scored anyway\x22" as *u8)
              pw2(",\x22fix\x22:\x22fit the capture to the ceiling deliberately and say so in the caller, or raise the ceiling by re-banking every anchor -- this is a CEILING, not a buffer to widen\x22}\x0a" as *u8)
              return PJ_EXIT_UNJUDGED
          } }
          let cf: *i64 = sys_mmap(PJ_ND*8) as *i64
          if pj_featfile(argv[2] as *u8, cf) == 0 {
              pw2("PERCEPT RED: candidate unreadable\x0averdict=RED\x0a" as *u8)
              return 1
          }
          let sc: i64 = pj_score(cf, av, 0-1)
          pw2("{\x22organ\x22:\x22nx_percept\x22,\x22verb\x22:\x22judge\x22,\x22score\x22:" as *u8)
          pn2(sc)
          // ★EVERY SCORE CARRIES THE RESOLUTION IT WAS TAKEN AT AND THE RULER'S OWN REACH. A reader
          // cannot otherwise tell a quality verdict from a resolution ceiling, and those two have
          // opposite remedies. Printed on the SUCCESS path deliberately: a ceiling that only shows
          // up in refusals is invisible exactly when someone is acting on a number.
          pw2(",\x22judged_w\x22:" as *u8); pn2(PJ_W)
          pw2(",\x22judged_h\x22:" as *u8); pn2(PJ_H)
          pw2(",\x22ceiling_w\x22:" as *u8); pn2(PJ_W)
          pw2(",\x22ceiling_h\x22:" as *u8); pn2(PJ_H)
          pw2(",\x22meaning\x22:\x22permil(sim-to-commercial-band minus sim-to-junk-band); RELATIVE position, never absolute quality; admitted only while `ladder` reproduces the human ordering\x22}\x0a" as *u8)
          return 0
      }
  }
  // ladder -- the admission oracle (default verb)
  let fm: *i64 = sys_mmap(PJ_ND*8) as *i64
  let fc: *i64 = sys_mmap(PJ_ND*8) as *i64
  if pj_featfile("knowledge/nx_m2d_frame.nxfh" as *u8, fm) == 0 { pw2("PERCEPT RED: m2d frame unreadable\x0averdict=RED\x0a" as *u8); return 1 }
  if pj_featfile("knowledge/craft1.nxfh" as *u8, fc) == 0 { pw2("PERCEPT RED: craft frame unreadable\x0averdict=RED\x0a" as *u8); return 1 }
  let sflat: i64 = pj_score(((av as i64) + 10*PJ_ND*8) as *i64, av, 0-1)
  let ssq: i64 = pj_score(((av as i64) + 11*PJ_ND*8) as *i64, av, 0-1)
  let sm2d: i64 = pj_score(fm, av, 0-1)
  let scraft: i64 = pj_score(fc, av, 0-1)
  pw2("=== nx_percept ladder: does the judge reproduce the HUMAN ordering? ===\x0a" as *u8)
  pw2("  flat=" as *u8); pn2(sflat)
  pw2(" squares=" as *u8); pn2(ssq)
  pw2(" m2d=" as *u8); pn2(sm2d)
  pw2(" craft=" as *u8); pn2(scraft)
  pw2("\x0a" as *u8)
  var passn: i64 = 0
  var totn: i64 = 0
  totn = totn + 1
  if sflat < ssq { passn = passn + 1; pw2("  L1 flat < squares GREEN\x0a" as *u8) } else { pw2("  L1 flat < squares RED\x0a" as *u8) }
  totn = totn + 1
  if ssq < sm2d { passn = passn + 1; pw2("  L2 squares < m2d GREEN\x0a" as *u8) } else { pw2("  L2 squares < m2d RED\x0a" as *u8) }
  totn = totn + 1
  if sm2d < scraft { passn = passn + 1; pw2("  L3 m2d < craft (the operator ordering) GREEN\x0a" as *u8) } else { pw2("  L3 m2d < craft (the operator ordering) RED\x0a" as *u8) }
  var ri: i64 = 0
  while ri < 10 {
      totn = totn + 1
      let sr: i64 = pj_score(((av as i64) + ri*PJ_ND*8) as *i64, av, ri)
      pw2("  ref[" as *u8); pn2(ri)
      pw2("] loo=" as *u8); pn2(sr)
      if sr > ssq { passn = passn + 1; pw2(" > squares GREEN\x0a" as *u8) } else { pw2(" NOT > squares RED\x0a" as *u8) }
      ri = ri + 1
  }
  pw2("=== nx_percept ladder " as *u8); pn2(passn)
  pw2("/" as *u8); pn2(totn)
  if passn == totn { pw2(" ADMITTED (judge reproduces the human ordering; advisory pick instrument, human override stands)\x0averdict=GREEN\x0a" as *u8); return 0 }
  pw2(" REFUSED (the judge does NOT reproduce the human ordering -- numbers above are published, the verdict is about the JUDGE)\x0averdict=RED\x0a" as *u8)
  return 1
653}
nx_percept.nx source

`nx_percept.nx` source
