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

↩ module page · 874 lines · 47222 B
1// nx_domain_admit.nx -- THE REFUSING ADMISSION GATE for a /compare domain.
2// Specified but never built: knowledge/compare/ADMISSION_STANDARD.txt ends with an ENFORCEMENT RUNG that
3// says COMPOSE the admission checks from the instruments that already exist and wire it into the authoring
4// lane so a new .matrix cannot publish without passing. Measured 2026-08-06: 0 matches for nx_domain_admit
5// across 50,386 files. The standard existed as prose and nothing refused against it, which is exactly the
6// estate's central defect -- a rule that scores nothing changes nothing.
7//
8// WHAT THIS ENFORCES (the mechanical subset; the rest is reported UNVERIFIED, never faked GREEN):
9//   C1 SYMBOL GROUNDING -- every non-_ABSENT_ row's symbol must occur, ON A WORD BOUNDARY, inside the organ
10//      the row itself declares. This is the liar-kill check: it is what stops a matrix asserting coverage
11//      that no file backs. A prefix or substring hit does NOT count (the standard names 11 prefix rows
12//      repaired in arrears; a bare substring is how they passed in the first place).
13//   C2 RIVAL BARS -- knowledge/barcheck.conf must carry at least one pinned row for the domain, OR the
14//      matrix header must explicitly declare the bars UNPINNED. An unpinned comparison is unfalsifiable;
15//      the standard permits saying so out loud and forbids staying silent.
16//   C3 EXECUTABLE EVIDENCE -- knowledge/compare/<domain>.gates must exist and be non-empty, else the domain
17//      is CLAIM-ONLY and must say so.
18//   C4 FRESH-KILL -- every gate the <domain>.gates map declares, partitioned by its durable bite record:
19//      bite-proven / never-bitten / bitten-but-zero-kill. Reports, does not refuse.
20//   C5 SECOND METHOD CLASS -- the signed experiential row, READ and cryptographically VERIFIED through the
21//      estate's one verifier (at_verify_row), in THREE states that must never collapse into each other:
22//      SIGNED / UNSIGNED-CANDIDATE / ABSENT, plus a separately declared SIGNED-BUT-REFUSED. Reports.
23//   C6 STAMP AND BOARD -- ALWAYS ABSTAINS, and names which conjunct it could not evaluate. The stamp half
24//      is read from knowledge/status/evstamp_<domain>.verdict (forking the producer measured ~25 s per
25//      domain); the board half is structurally unavailable, because nx_sota_status has no `why <domain>`
26//      verb and publishes no per-domain verdict at all. An abstention that names its dead conjunct is a
27//      measurement; a bare UNVERIFIED is not, and a bare UNVERIFIED is what this organ printed for both of
28//      these from the day it was written until 2026-08-25.
29//
30// EXIT: 0 = ADMIT, 1 = REFUSE, 2 = usage, 3 = matrix unreadable.
31// A REFUSE is not a failure of the domain -- the standard says an unproven domain is admitted as HONESTLY
32// UNPROVEN when it declares that. This gate refuses SILENT unprovenness, not unprovenness.
33// 100% sovereign. No hardware writes (Rule 26). license_tier: ORIGINAL  expect_exit: 0
34import "nx_syscalls.nx"
35import "nx_deploy_lib.nx"
36// THE ONE SYMBOL RULER (2026-08-23): cl_symbol_declared -- a top-level `func <sym>` declaration in the organ
37// the row names. Three organs answered "does the symbol exist" three ways (this gate: word boundary; the
38// page: substring; the ranker: declaration) and a rung read LANDED on the page and OPEN in the ranker at
39// once. C1 below MEASURES the disagreement between its word-boundary rule and the declaration rule on
40// every grounded row (printed per row, summed per domain and per sweep) before the verdict switches.
41import "nx_catalog_lib.nx"
42
43// THE PURE DECISION CORE LIVES IN nx_domain_admit_lib.nx, AND THIS ORGAN NOW IMPORTS IT RATHER THAN
44// DEFINING IT. Reason, 2026-08-25: nx_organ_ship reported "PROVE NO-GATE-FOUND -- a NAMED absence, NOT
45// a pass" for this target, and a gate could not be written while the checks lived inside a top-level
46// programme -- nothing can import a main(), and a gate that fork/execs the deployed elf is not
47// mutation-provable (every mutant returns NOT-REACHED, and the GREEN that produces reads exactly like a
48// proof). The functions were MOVED, not copied: da_wfind, da_classify_row, da_symstart, da_tenths,
49// da_count_lines, da_hasline, da_kv, da_c4 and the gates-map resolver now have exactly one definition
50// each, in the library, and nx_domain_admit_gate.nx drives them in-process.
51import "nx_domain_admit_lib.nx"
52
53const DA_MCAP: i64 = 1048576
54const DA_AT:   i64 = 64
55// THE TREE THIS GATE AUDITS -- ONE literal, replacing three former call sites (main, da_c1, da_sweep).
56// MEASURED 2026-08-20: this gate read the bare "knowledge/compare/" (the nishihost twin) while
57// nx_compare_regen PUBLISHES from "buildroot/knowledge/compare/". The two trees are FORKED, not
58// stale, so converging them by copy would destroy real work in one direction or the other: the
59// nishihost twin holds a richer @sub for ecosysdesign (the 2026-08-04 HBS WP 05-016 re-read), and
60// buildroot holds every [@key] citation mark the refs rung landed -- proven by scan, the nishihost
61// tree has matches=0 with corpus_complete=1 over 379 files, so a nishihost->buildroot copy would
62// strip all 981 marks and turn nx_compare_refs_gate's declared-refs-cited-inline tooth RED fleet-wide.
63// ★AN ADMISSION GATE MUST AUDIT THE COPY THAT PUBLISHES, AND REPOINTING THE GATE MOVES NO DATA.
64// ★AND THE OLD TARGET DID NOT MERELY MIS-JUDGE DOMAINS -- IT COULD NOT SEE THE ONES MOST LIKELY TO
65// BE WRONG: knowledge/compare/devmgmt.matrix is ABSENT while buildroot/knowledge/compare/devmgmt.matrix
66// is 10,325 B, published and page-verified GREEN. The newest admitted domain was invisible to its own
67// admission gate, and --all reported domains=45 as if that were the population.
68const DA_CDIR:  *u8 = "buildroot/knowledge/compare\x00"
69// DA_CDIRS (the publishing tree) and DA_GATESDIR (the tree that owns the .gates maps) MOVED to
70// nx_domain_admit_lib.nx, together with da_read_2dir/da_gates_read -- the resolver that uses them. The
71// 2026-08-25 defect was that C3 and C4 each built that path themselves and only one was repointed; a
72// constant and the one resolver that reads it belong in the same file, where they cannot half-move.
73
74// da_slen/da_w/da_wn/da_n/da_cat/da_isword/da_wfind/da_eol/da_sl_eq/da_symstart MOVED to
75// nx_domain_admit_lib.nx so the gate can drive them in-process. da_wfind in particular is the liar-kill
76// mechanism -- the word boundary is why a prefix, a suffix or a substring inside a longer identifier is
77// NOT a grounding -- and it now has teeth on all four of those cases.
78// C1 RULE MEASUREMENT: 1 when the word-boundary rule grounds the row and the declaration rule does NOT
79// (declared=0: the symbol is a mention -- comment, string, tooth name, a token in a log -- not a `func`;
80// declared=-1: the declaration ruler could not read the organ path at all, e.g. a non-source path).
81// Every such row is printed: the switch to one ruler is a measured decision, never a quiet flip.
82func da_rule_disagree(mb: *u8, p1: i64, p2: i64, sym: i64, symend: i64, dom: *u8) -> i64 {
  let org: *u8 = sys_mmap(DA_PATH)
  var o: i64 = 0
  var i: i64 = p1 + 1
  while i < p2 { if o < DA_PATH - 1 { org[o] = mb[i]; o = o + 1 } i = i + 1 }
  org[o] = 0 as u8
  let sy: *u8 = sys_mmap(DA_PATH)
  var q: i64 = 0
  i = sym
  while i < symend { if q < DA_PATH - 1 { sy[q] = mb[i]; q = q + 1 } i = i + 1 }
  sy[q] = 0 as u8
  let d: i64 = cl_symbol_declared(org, sy)
  if d == 1 { return 0 }
  da_w("  C1 rule-disagree dom=" as *u8); da_w(dom); da_w(" sym=" as *u8); da_w(sy); da_w(" organ=" as *u8); da_w(org)
  da_w(" wordboundary=1 declared=" as *u8); da_n(d); da_w("\n" as *u8)
  return 1
98}
99
100// da_try / da_read_organ / da_classify_row MOVED to nx_domain_admit_lib.nx. da_classify_row is the
101// four-way answer the whole admission rests on -- declared-gap, grounded, ungrounded, organ-unreadable --
102// and every one of the four is now bite-proven against in-memory rows and /tmp fixtures.
103
104// C1 for one domain. Returns the FAULT COUNT (ungrounded + unreadable); 0 means every declared symbol is
105// word-boundary-present in the organ its own row names. Extracted so the single-domain path and the sweep
106// run the SAME code -- a sweep that re-implements the check is a second opinion, not a wider one.
107func da_c1(dom: *u8, mb: *u8, sb: *u8, verbose: i64, agg: *i64) -> i64 {
  let path: *u8 = sys_mmap(DA_PATH)
  var p: i64 = da_cat(path, 0, DA_CDIRS)
  p = da_cat(path, p, dom)
  p = da_cat(path, p, ".matrix" as *u8)
  path[p] = 0 as u8
  let mn: i64 = dp_read(path, mb, DA_MCAP - 4)
  if mn <= 0 { da_w("  " as *u8); da_w(dom); da_w("  NO-MATRIX\n" as *u8); return 1 }
115
  var rows: i64 = 0
  var absent: i64 = 0
  var grounded: i64 = 0
  var ungrounded: i64 = 0
  var unreadable: i64 = 0
  var newwatch: i64 = 0
  var disagree: i64 = 0
  var i: i64 = 0
  while i < mn {
      let le: i64 = da_eol(mb, mn, i)
      if le > i {
          let f: i64 = mb[i] as i64
          var skip: i64 = 0
          if f == DA_HASH { skip = 1 }
          if f == DA_AT { skip = 1 }
          if f == DA_NL { skip = 1 }
          if skip == 0 {
              var p1: i64 = 0 - 1
              var p2: i64 = 0 - 1
              var p3: i64 = 0 - 1
              var k: i64 = i
              while k < le {
                  if mb[k] == (DA_PIPE as u8) {
                      if p1 < 0 { p1 = k } else { if p2 < 0 { p2 = k } else { if p3 < 0 { p3 = k; k = le } } }
                  }
                  k = k + 1
              }
              if p3 > 0 {
                  rows = rows + 1
                  let sa: i64 = p2 + 1
                  let cls: i64 = da_classify_row(mb, p1, p2, p3, sb)
                  if cls == 0 { absent = absent + 1 }
                  if cls == 1 { grounded = grounded + 1; disagree = disagree + da_rule_disagree(mb, p1, p2, da_symstart(mb, sa, p3), p3, dom) }
                  if cls == 3 {
                      unreadable = unreadable + 1
                      if verbose == 1 {
                          da_w("  C1 UNREADABLE organ: " as *u8)
                          da_wn(mb, p1 + 1, p2 - (p1 + 1))
                          da_w("   (row: " as *u8); da_wn(mb, i, p1 - i); da_w(")\n" as *u8)
                      }
                  }
                  if cls == 4 {
                      newwatch = newwatch + 1
                      if verbose == 1 {
                          da_w("  C1 WATCH-NEW-ORGAN: " as *u8)
                          da_wn(mb, p1 + 1, p2 - (p1 + 1))
                          da_w("   (row: " as *u8); da_wn(mb, i, p1 - i); da_w(")\n" as *u8)
                      }
                  }
                  if cls == 2 {
                      ungrounded = ungrounded + 1
                      if verbose == 1 {
                          da_w("  C1 UNGROUNDED symbol " as *u8)
                          da_wn(mb, sa, p3 - sa)
                          da_w(" not word-boundary-present in " as *u8)
                          da_wn(mb, p1 + 1, p2 - (p1 + 1))
                          da_w("\n     row: " as *u8); da_wn(mb, i, p1 - i); da_w("\n" as *u8)
                      }
                  }
              }
          }
      }
      i = le + 1
  }
  da_w("  " as *u8); da_w(dom)
  da_w("  rows=" as *u8); da_n(rows)
  da_w(" grounded=" as *u8); da_n(grounded)
  da_w(" absent=" as *u8); da_n(absent)
  da_w(" ungrounded=" as *u8); da_n(ungrounded)
  da_w(" unreadable=" as *u8); da_n(unreadable)
  da_w(" watch_new_organ=" as *u8); da_n(newwatch)
  da_w(" rule_disagree=" as *u8); da_n(disagree)
  agg[0] = agg[0] + disagree
  if ungrounded + unreadable == 0 { da_w("  OK\n" as *u8) } else { da_w("  FAULT\n" as *u8) }
  return ungrounded + unreadable
191}
192
193// Sweep every *.matrix in knowledge/compare. This is what makes the gate a standing instrument instead of
194// a thing someone remembers to run: the denominator is the directory, so a domain cannot dodge the check
195// by never being named.
196func da_sweep(mb: *u8, sb: *u8, nbuf: *u8, ncap: i64, nlen: *i64) -> i64 {
  let fd: i64 = sys_openat_rd(DA_CDIR)
  if fd < 0 { da_w("SWEEP REFUSE: cannot open buildroot/knowledge/compare\n" as *u8); return 0 - 1 }
  let agg: *i64 = sys_mmap(16) as *i64
  agg[0] = 0
  let dbuf: *u8 = sys_mmap(1 << 16)
  let dom: *u8 = sys_mmap(256)
  var domains: i64 = 0
  var faulty: i64 = 0
  var faults: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let nr: i64 = sys_getdents64(fd, dbuf, 1 << 16)
      if nr <= 0 { go = 0 } else {
          var pos: i64 = 0
          while pos < nr {
              let rec: *u8 = ((dbuf as i64) + pos) as *u8
              let reclen: i64 = dirent_reclen(rec)
              let name: *u8 = ((rec as i64) + 19) as *u8
              var ln: i64 = 0
              while name[ln] != (0 as u8) { ln = ln + 1 }
              // THE SUFFIX LENGTH IS DERIVED FROM THE SUFFIX, NEVER HAND-COUNTED BESIDE IT. This block
              // wrote 7 six times as the length of ".matrix"; change that literal and all six still
              // compile and still read a window, just the wrong one, with no diagnostic anywhere.
              let suf: *u8 = ".matrix\x00" as *u8
              let sl: i64 = da_slen(suf)
              if ln > sl {
                  var m: i64 = 1
                  var j: i64 = 0
                  while j < sl { if name[ln-sl+j] != suf[j] { m = 0; j = sl } else { j = j + 1 } }
                  if m == 1 {
                      var c: i64 = 0
                      while c < ln - sl { dom[c] = name[c]; c = c + 1 }
                      dom[ln-sl] = 0 as u8
                      domains = domains + 1
                      let f: i64 = da_c1(dom, mb, sb, 0, agg)
                      if f > 0 {
                          faulty = faulty + 1
                          faults = faults + f
                          // COLLECT THE NAME, not just the count. A count-only ratchet on a tree nine
                          // lanes write reports a regression without saying WHOSE, which makes it
                          // unusable exactly when it fires.
                          var q: i64 = nlen[0]
                          var c2: i64 = 0
                          while dom[c2] != (0 as u8) {
                              if q < ncap - 2 { nbuf[q] = dom[c2]; q = q + 1 }
                              c2 = c2 + 1
                          }
                          if q < ncap - 1 { nbuf[q] = DA_NL as u8; q = q + 1 }
                          nlen[0] = q
                      }
                  }
              }
              if reclen <= 0 { pos = nr } else { pos = pos + reclen }
          }
      }
  }
  sys_close(fd)
  da_w("\nSWEEP domains=" as *u8); da_n(domains)
  da_w("  faulty-domains=" as *u8); da_n(faulty)
  da_w("  total-faults=" as *u8); da_n(faults)
  da_w("  c1-rule-disagree(wordboundary=1,declared!=1)=" as *u8); da_n(agg[0]); da_w("\n" as *u8)
  return faulty
259}
260
261const DA_NAMEBUF:  i64 = 65536
262const DA_MODE_0644: i64 = 420
263const DA_CH_R:     i64 = 114     // 'r' -- distinguishes --ratchet from --all at argv[1][2]
264const DA_BASELINE: *u8 = "knowledge/status/domain_admit.baseline"
265
266// THE RATCHET (2026-08-20). Repointing this gate to the publishing tree took the sweep from
267// domains=45 faulty=3 to domains=61 faulty=54 / faults=342 -- because 16 domains had never been
268// audited at all, not because anything regressed that day. A gate that is permanently RED is one
269// everyone learns to ignore, so the standing 342 are held as a WORKLIST and only NEW offenders fail.
270// ★RATCHET ON A SET OF NAMES, NEVER A COUNT: on a tree nine lanes write, a count-only ratchet reports
271// a regression without saying WHOSE, which makes it useless exactly when it fires.
272// ★SELF-BASELINES ON FIRST SIGHT, so adopting it cannot break a single caller by construction.
273// ★AND THE BAR IS PRINTED IN THE VERDICT: a threshold nobody can see is a threshold nobody can act on
274// (the magic-number chain reported against an invisible bar for weeks).
275// da_count_lines / da_hasline -- the ratchet's set logic -- MOVED to nx_domain_admit_lib.nx.
276func da_write_file(path: *u8, buf: *u8, n: i64) -> i64 {
  let tmp: *u8 = sys_mmap(DA_PATH)
  var o: i64 = da_cat(tmp, 0, path)
  o = da_cat(tmp, o, ".new" as *u8); tmp[o] = 0 as u8
  let fd: i64 = sys_openat_wr(tmp, DA_MODE_0644)
  if fd < 0 { return 0 - 1 }
  var off: i64 = 0
  while off < n {
      let r: i64 = sys_write(fd, ((buf as i64) + off) as *u8, n - off)
      if r <= 0 { sys_close(fd); return 0 - 2 }
      off = off + r
  }
  sys_close(fd)
  if sys_renameat(tmp, path) != 0 { return 0 - 3 }
  return 0
291}
292const DA_LOG:    *u8 = "knowledge/status/domain_admit.log"
293const DA_ZERO:    i64 = 48
294const DA_NUMCAP:  i64 = 28
295func da_catn(dst: *u8, o: i64, v: i64) -> i64 {
  var x: i64 = o
  var m: i64 = v
  if m == 0 { dst[x] = DA_ZERO as u8; return x + 1 }
  let t: *u8 = sys_mmap(DA_NUMCAP)
  var k: i64 = 0
  while m > 0 { t[k] = (DA_ZERO + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { dst[x] = t[k - 1 - i]; x = x + 1; i = i + 1 }
  return x
305}
306// A VERDICT NOBODY COLLECTS IS A VERDICT NOBODY HAS. This organ sat REGISTERED-DARK while it audited
307// the WRONG TREE for weeks -- ★a gate nobody runs does not degrade to neutral, it degrades to a false
308// sense of coverage, because its existence is counted and its verdict is not. So the ratchet writes its
309// own durable line, the way every collected gate in this estate does, and the canonical verdict token is
310// LAST on the line so a positional reader cannot mistake a field for it.
311func da_log(base: i64, cur: i64, nnew: i64, nfixed: i64, green: i64) -> i64 {
  let fd: i64 = sys_openat_append(DA_LOG, DA_MODE_0644)
  if fd < 0 { return 0 - 1 }
  let b: *u8 = sys_mmap(DA_PATH)
  var o: i64 = da_cat(b, 0, "DOMAINADMIT epoch=" as *u8)
  o = da_catn(b, o, sys_now_realtime_sec())
  o = da_cat(b, o, " baseline_faulty=" as *u8); o = da_catn(b, o, base)
  o = da_cat(b, o, " current_faulty=" as *u8);  o = da_catn(b, o, cur)
  o = da_cat(b, o, " new=" as *u8);             o = da_catn(b, o, nnew)
  o = da_cat(b, o, " fixed=" as *u8);           o = da_catn(b, o, nfixed)
  if green == 1 { o = da_cat(b, o, " verdict=GREEN\n" as *u8) } else { o = da_cat(b, o, " verdict=RED\n" as *u8) }
  sys_write(fd, b, o)
  sys_close(fd)
  return 0
325}
326// ==== C7 CONTRACT AGREEMENT (2026-08-23, compare CE5) ====
327// MEASURED BY THE PARENT LANE: the same contract symbol was declared as a RUNG on two boards with two
328// different costs (graphics.plan GR8 ntb_bake_pbr 1u / charsim.plan R4 2u; sr_sss_preint 1 vs 1.5;
329// dyna_bind_skin 1 vs 1.5; fa_expr_morph 2 vs 1). The ranker runs per domain, so one piece of work was
330// priced twice and ranked in two universes that can never reconcile -- the "scattered" the operator named.
331// ONE CONTRACT, DECLARED ONCE: a symbol declared as a rung on more than one board must carry the SAME est
332// on every board, and a symbol on more than one matrix must name the SAME organ path. Deps are domain-local
333// rung ids and are NOT compared. No new row kind: ownership is expressed by agreement, never by a rename.
334// Ratcheted on the SET of disagreeing symbols (kind:sym per line), like the C1 ratchet above: self-
335// baselines on first sight, RED only on a NEW offender, tightens on a fix -- a detector born permanently
336// red is one everyone learns to ignore.
337const DA_C7_BASELINE: *u8 = "knowledge/status/domain_admit_c7.baseline"
338const DA_C7_LOG:      *u8 = "knowledge/status/domain_admit_c7.log"
339const DA_KIND_RUNG:   i64 = 1
340const DA_KIND_MATRIX: i64 = 2
341const DA_REC_FIELDS:  i64 = 4        // kind, dom, sym, val -- one record per declaration
342const DA_SUF_PLAN:    *u8 = ".plan\x00"
343const DA_SUF_MATRIX:  *u8 = ".matrix\x00"
344// The token the C2 bar-check looks for, hoisted so its LENGTH can be derived at the one site that needs
345// it rather than hand-written as an 8 beside the literal -- the two drift the moment the token is retitled.
346const DA_UNPINNED:    *u8 = "UNPINNED\x00"
347
348// da_tenths -- the C7 estimate parser -- MOVED to nx_domain_admit_lib.nx.
349func da_ends_with(name: *u8, ln: i64, suf: *u8) -> i64 {
  let sl: i64 = da_slen(suf)
  if ln <= sl { return 0 }
  var j: i64 = 0
  while j < sl { if name[ln - sl + j] != suf[j] { return 0 } j = j + 1 }
  return 1
355}
356// copy mb[a..b) into the arena as a NUL-terminated string; returns its pointer, advances ao[0]
357func da_arena_put(arena: *u8, ao: *i64, mb: *u8, a: i64, b: i64) -> *u8 {
  let p: *u8 = ((arena as i64) + ao[0]) as *u8
  var i: i64 = a
  var o: i64 = ao[0]
  while i < b { arena[o] = mb[i]; o = o + 1; i = i + 1 }
  arena[o] = 0 as u8
  ao[0] = o + 1
  return p
365}
366// pass 0: total bytes + lines of every *.plan and *.matrix (the DERIVED bounds); pass 1: collect records.
367// rec[i*4+0]=kind, +1=dom ptr, +2=sym ptr, +3=val ptr (est text for a rung, organ path for a matrix row)
368func da_c7_walk(pass: i64, mb: *u8, tot: *i64, rec: *i64, nrec: *i64, arena: *u8, ao: *i64) -> i64 {
  let fd: i64 = sys_openat_rd(DA_CDIR)
  if fd < 0 { return 0 - 1 }
  let dbuf: *u8 = sys_mmap(1 << 16)
  var go: i64 = 1
  while go == 1 {
      let nr: i64 = sys_getdents64(fd, dbuf, 1 << 16)
      if nr <= 0 { go = 0 } else {
          var pos: i64 = 0
          while pos < nr {
              let r: *u8 = ((dbuf as i64) + pos) as *u8
              let reclen: i64 = dirent_reclen(r)
              let name: *u8 = ((r as i64) + 19) as *u8
              var ln: i64 = 0
              while name[ln] != (0 as u8) { ln = ln + 1 }
              var kind: i64 = 0
              var sl: i64 = 0
              // The suffix is ALREADY a named constant here and its length was STILL hand-written
              // beside it -- retitle DA_SUF_PLAN to ".plans" and sl=5 silently truncates every domain
              // name by one character while compiling clean. Derived from the constant it measures.
              if da_ends_with(name, ln, DA_SUF_PLAN) == 1 { kind = DA_KIND_RUNG; sl = da_slen(DA_SUF_PLAN) }
              if da_ends_with(name, ln, DA_SUF_MATRIX) == 1 { kind = DA_KIND_MATRIX; sl = da_slen(DA_SUF_MATRIX) }
              if kind > 0 {
                  let path: *u8 = sys_mmap(DA_PATH)
                  var p: i64 = da_cat(path, 0, DA_CDIRS)
                  var c: i64 = 0
                  while c < ln { path[p] = name[c]; p = p + 1; c = c + 1 }
                  path[p] = 0 as u8
                  let n: i64 = dp_read(path, mb, DA_MCAP - 4)
                  if n > 0 {
                      if pass == 0 { tot[0] = tot[0] + n; tot[1] = tot[1] + da_count_lines(mb, n) + 1; tot[2] = tot[2] + 1 }
                      else {
                          // the domain name, once per file, into the arena
                          let dom: *u8 = da_arena_put(arena, ao, name, 0, ln - sl)
                          var i: i64 = 0
                          while i < n {
                              let le: i64 = da_eol(mb, n, i)
                              if le > i {
                                  var p1: i64 = 0 - 1
                                  var p2: i64 = 0 - 1
                                  var p3: i64 = 0 - 1
                                  var p6: i64 = 0 - 1
                                  var p7: i64 = 0 - 1
                                  var np: i64 = 0
                                  var k: i64 = i
                                  while k < le {
                                      if mb[k] == (DA_PIPE as u8) {
                                          np = np + 1
                                          if np == 1 { p1 = k }
                                          if np == 2 { p2 = k }
                                          if np == 3 { p3 = k }
                                          if np == 6 { p6 = k }
                                          if np == 7 { p7 = k }
                                      }
                                      k = k + 1
                                  }
                                  if kind == DA_KIND_RUNG {
                                      // rung|id|title|sym|done|exec|est|deps -> sym = [p3+1, p4), est = [p6+1, p7)
                                      if p7 > 0 { if da_sl_eq(mb, i, p1, "rung" as *u8) == 1 {
                                          var p4: i64 = p3 + 1
                                          while p4 < le { if mb[p4] == (DA_PIPE as u8) { break } p4 = p4 + 1 }
                                          let b: i64 = nrec[0] * DA_REC_FIELDS
                                          rec[b] = DA_KIND_RUNG
                                          rec[b + 1] = dom as i64
                                          rec[b + 2] = da_arena_put(arena, ao, mb, p3 + 1, p4) as i64
                                          rec[b + 3] = da_arena_put(arena, ao, mb, p6 + 1, p7) as i64
                                          nrec[0] = nrec[0] + 1
                                      } }
                                  } else {
                                      let f: i64 = mb[i] as i64
                                      var skip: i64 = 0
                                      if f == DA_HASH { skip = 1 }
                                      if f == DA_AT { skip = 1 }
                                      if p3 < 0 { skip = 1 }
                                      if skip == 0 {
                                          let sa: i64 = p2 + 1
                                          if da_sl_eq(mb, sa, p3, "_ABSENT_" as *u8) == 0 {
                                              let b2: i64 = nrec[0] * DA_REC_FIELDS
                                              rec[b2] = DA_KIND_MATRIX
                                              rec[b2 + 1] = dom as i64
                                              rec[b2 + 2] = da_arena_put(arena, ao, mb, da_symstart(mb, sa, p3), p3) as i64
                                              rec[b2 + 3] = da_arena_put(arena, ao, mb, p1 + 1, p2) as i64
                                              nrec[0] = nrec[0] + 1
                                          }
                                      }
                                  }
                              }
                              i = le + 1
                          }
                      }
                  }
              }
              if reclen <= 0 { pos = nr } else { pos = pos + reclen }
          }
      }
  }
  sys_close(fd)
  return 0
466}
467func da_streq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 } if b[i] != (0 as u8) { return 0 } return 1 }
468func da_c7_log(base: i64, cur: i64, nnew: i64, nfixed: i64, green: i64) -> i64 {
  let fd: i64 = sys_openat_append(DA_C7_LOG, DA_MODE_0644)
  if fd < 0 { return 0 - 1 }
  let b: *u8 = sys_mmap(DA_PATH)
  var o: i64 = da_cat(b, 0, "DOMAINADMIT-C7 epoch=" as *u8)
  o = da_catn(b, o, sys_now_realtime_sec())
  o = da_cat(b, o, " baseline_disagree=" as *u8); o = da_catn(b, o, base)
  o = da_cat(b, o, " current_disagree=" as *u8);  o = da_catn(b, o, cur)
  o = da_cat(b, o, " new=" as *u8);               o = da_catn(b, o, nnew)
  o = da_cat(b, o, " fixed=" as *u8);             o = da_catn(b, o, nfixed)
  if green == 1 { o = da_cat(b, o, " verdict=GREEN\n" as *u8) } else { o = da_cat(b, o, " verdict=RED\n" as *u8) }
  sys_write(fd, b, o)
  sys_close(fd)
  return 0
482}
483// The census + the ratchet. Returns the number of NEW offenders against the baseline (0 on first sight).
484func da_c7(mb: *u8) -> i64 {
  da_w("\n=== C7 CONTRACT AGREEMENT -- one symbol, one est across every plan; one symbol, one organ across every matrix ===\n" as *u8)
  let tot: *i64 = sys_mmap(24) as *i64
  tot[0] = 0; tot[1] = 0; tot[2] = 0
  if da_c7_walk(0, mb, tot, 0 as *i64, 0 as *i64, 0 as *u8, 0 as *i64) < 0 { da_w("  C7 UNOBSERVABLE: cannot open the compare tree\n" as *u8); return 0 }
  // DERIVED bounds: one record per line at most; the arena holds slices of the files (<= their bytes), two
  // NULs per record, and one domain name per file (a name is bounded by the path slot it came from)
  let maxrec: i64 = tot[1] + 1
  let rec: *i64 = sys_mmap(maxrec * DA_REC_FIELDS * 8) as *i64
  let nrec: *i64 = sys_mmap(16) as *i64
  nrec[0] = 0
  let arena: *u8 = sys_mmap(tot[0] + maxrec * 2 + tot[2] * (DA_PATH + 1))
  let ao: *i64 = sys_mmap(16) as *i64
  ao[0] = 0
  da_c7_walk(1, mb, tot, rec, nrec, arena, ao)
  let n: i64 = nrec[0]
  let seen: *u8 = sys_mmap(n + 1)
  var z: i64 = 0
  while z < n { seen[z] = 0 as u8; z = z + 1 }
  let cur: *u8 = sys_mmap(DA_NAMEBUF)
  var cl: i64 = 0
  var kind: i64 = DA_KIND_RUNG
  var pass: i64 = 0
  var total_single: i64 = 0
  var total_agree: i64 = 0
  var total_disagree: i64 = 0
  while pass < 2 {
      var single: i64 = 0
      var agree: i64 = 0
      var disagree: i64 = 0
      var i: i64 = 0
      while i < n {
          if seen[i] == (0 as u8) { if rec[i * DA_REC_FIELDS] == kind {
              let sym: *u8 = rec[i * DA_REC_FIELDS + 2] as *u8
              let val0: *u8 = rec[i * DA_REC_FIELDS + 3] as *u8
              var members: i64 = 0
              var same: i64 = 1
              var j: i64 = i
              while j < n {
                  if rec[j * DA_REC_FIELDS] == kind { if da_streq(rec[j * DA_REC_FIELDS + 2] as *u8, sym) == 1 {
                      seen[j] = 1 as u8
                      members = members + 1
                      let vj: *u8 = rec[j * DA_REC_FIELDS + 3] as *u8
                      if kind == DA_KIND_RUNG {
                          if da_tenths(vj, 0, da_slen(vj)) != da_tenths(val0, 0, da_slen(val0)) { same = 0 }
                      } else { if da_streq(vj, val0) == 0 { same = 0 } }
                  } }
                  j = j + 1
              }
              if members == 1 { single = single + 1 }
              else {
                  if same == 1 { agree = agree + 1 }
                  else {
                      disagree = disagree + 1
                      da_w("  C7 CONTRACT-DISAGREE kind=" as *u8)
                      if kind == DA_KIND_RUNG { da_w("rung" as *u8) } else { da_w("matrix" as *u8) }
                      da_w(" sym=" as *u8); da_w(sym)
                      var j2: i64 = i
                      while j2 < n {
                          if rec[j2 * DA_REC_FIELDS] == kind { if da_streq(rec[j2 * DA_REC_FIELDS + 2] as *u8, sym) == 1 {
                              da_w(" " as *u8); da_w(rec[j2 * DA_REC_FIELDS + 1] as *u8)
                              if kind == DA_KIND_RUNG { da_w(":est=" as *u8) } else { da_w(":organ=" as *u8) }
                              da_w(rec[j2 * DA_REC_FIELDS + 3] as *u8)
                          } }
                          j2 = j2 + 1
                      }
                      da_w("\n" as *u8)
                      // the offender SET for the ratchet: kind:sym per line
                      if kind == DA_KIND_RUNG { cl = da_cat(cur, cl, "rung:" as *u8) } else { cl = da_cat(cur, cl, "matrix:" as *u8) }
                      if cl + da_slen(sym) + 2 < DA_NAMEBUF { cl = da_cat(cur, cl, sym); cur[cl] = DA_NL as u8; cl = cl + 1 }
                  }
              }
          } }
          i = i + 1
      }
      da_w("  C7 " as *u8)
      if kind == DA_KIND_RUNG { da_w("rung" as *u8) } else { da_w("matrix" as *u8) }
      da_w(" symbols: single=" as *u8); da_n(single); da_w(" multi-agree=" as *u8); da_n(agree); da_w(" multi-disagree=" as *u8); da_n(disagree)
      da_w(" sum=" as *u8); da_n(single + agree + disagree); da_w(" of declarations=" as *u8)
      var decl: i64 = 0
      var q: i64 = 0
      while q < n { if rec[q * DA_REC_FIELDS] == kind { decl = decl + 1 } q = q + 1 }
      da_n(decl); da_w("\n" as *u8)
      total_single = total_single + single; total_agree = total_agree + agree; total_disagree = total_disagree + disagree
      kind = DA_KIND_MATRIX
      pass = pass + 1
  }
  da_w("  C7 partition: single=" as *u8); da_n(total_single); da_w(" multi-agree=" as *u8); da_n(total_agree); da_w(" multi-disagree=" as *u8); da_n(total_disagree)
  da_w(" distinct=" as *u8); da_n(total_single + total_agree + total_disagree); da_w(" records=" as *u8); da_n(n); da_w(" (a declaration belongs to exactly one symbol: sum of member counts == records)\n" as *u8)
  // ---- the ratchet on the offender SET ----
  let base: *u8 = sys_mmap(DA_NAMEBUF)
  let bn: i64 = dp_read(DA_C7_BASELINE, base, DA_NAMEBUF - 4)
  if bn <= 0 {
      let wr: i64 = da_write_file(DA_C7_BASELINE, cur, cl)
      da_w("  C7 RATCHET BASELINE-WRITTEN baseline_disagree=" as *u8); da_n(total_disagree); da_w(" write_rc=" as *u8); da_n(wr)
      da_w(" (self-baselined on first sight -- cannot fail by construction; the standing set is the worklist above)\n" as *u8)
      da_c7_log(total_disagree, total_disagree, 0, 0, 1)
      return 0
  }
  let basecount: i64 = da_count_lines(base, bn)
  var nnew: i64 = 0
  var i2: i64 = 0
  while i2 < cl {
      let e: i64 = da_eol(cur, cl, i2)
      if e > i2 { if da_hasline(base, bn, cur, i2, e - i2) == 0 {
          nnew = nnew + 1
          da_w("  C7 NEW-OFFENDER " as *u8); da_wn(cur, i2, e - i2); da_w("  (not in the baseline -- this one is YOURS)\n" as *u8)
      } }
      i2 = e + 1
  }
  var nfixed: i64 = 0
  var j3: i64 = 0
  while j3 < bn {
      let e2: i64 = da_eol(base, bn, j3)
      if e2 > j3 { if da_hasline(cur, cl, base, j3, e2 - j3) == 0 {
          nfixed = nfixed + 1
          da_w("  C7 FIXED " as *u8); da_wn(base, j3, e2 - j3); da_w("  (was disagreeing, now one contract -- the floor tightens)\n" as *u8)
      } }
      j3 = e2 + 1
  }
  da_w("  C7 RATCHET baseline_disagree=" as *u8); da_n(basecount); da_w(" current_disagree=" as *u8); da_n(total_disagree)
  da_w(" new=" as *u8); da_n(nnew); da_w(" fixed=" as *u8); da_n(nfixed); da_w("\n" as *u8)
  if nnew == 0 { if nfixed > 0 {
      let wr2: i64 = da_write_file(DA_C7_BASELINE, cur, cl)
      da_w("  C7 RATCHET TIGHTENED write_rc=" as *u8); da_n(wr2); da_w("\n" as *u8)
  } }
  if nnew > 0 { da_c7_log(basecount, total_disagree, nnew, nfixed, 0) } else { da_c7_log(basecount, total_disagree, nnew, nfixed, 1) }
  return nnew
612}
613
614func da_ratchet(mb: *u8, sb: *u8, cur: *u8, cl: *i64) -> i64 {
  da_w("=== nx_domain_admit --ratchet -- only NEW offenders fail; the standing set is the worklist ===\n" as *u8)
  da_sweep(mb, sb, cur, DA_NAMEBUF, cl)
  // C7 runs with its own ratchet; its NEW offenders fail this verdict exactly like C1's
  let c7new: i64 = da_c7(mb)
  let cn: i64 = cl[0]
  let curcount: i64 = da_count_lines(cur, cn)
  let base: *u8 = sys_mmap(DA_NAMEBUF)
  let bn: i64 = dp_read(DA_BASELINE, base, DA_NAMEBUF - 4)
  if bn <= 0 {
      let wr: i64 = da_write_file(DA_BASELINE, cur, cn)
      da_w("RATCHET BASELINE-WRITTEN baseline_faulty=" as *u8); da_n(curcount)
      da_w(" current_faulty=" as *u8); da_n(curcount)
      da_w(" new=0 fixed=0 write_rc=" as *u8); da_n(wr); da_w("\n" as *u8)
      if wr != 0 {
          da_w("verdict=RED (self-baseline could not be WRITTEN -- a ratchet that cannot persist its floor is not a ratchet)\n" as *u8)
          sys_exit(1); return 1
      }
      if c7new > 0 {
          da_log(curcount, curcount, 0, 0, 0)
          da_w("verdict=RED (C1 self-baselined, but C7 names a NEW contract disagreement above)\n" as *u8)
          sys_exit(1); return 1
      }
      da_log(curcount, curcount, 0, 0, 1)
      da_w("verdict=GREEN (self-baselined on first sight -- this run CANNOT fail, by construction)\n" as *u8)
      sys_exit(0); return 0
  }
  let basecount: i64 = da_count_lines(base, bn)
  var nnew: i64 = 0
  var i: i64 = 0
  while i < cn {
      let e: i64 = da_eol(cur, cn, i)
      if e > i {
          if da_hasline(base, bn, cur, i, e - i) == 0 {
              nnew = nnew + 1
              da_w("  NEW-OFFENDER domain=" as *u8); da_wn(cur, i, e - i)
              da_w("  (not in the baseline -- this one is YOURS)\n" as *u8)
          }
      }
      i = e + 1
  }
  var nfixed: i64 = 0
  var j: i64 = 0
  while j < bn {
      let e2: i64 = da_eol(base, bn, j)
      if e2 > j {
          if da_hasline(cur, cn, base, j, e2 - j) == 0 {
              nfixed = nfixed + 1
              da_w("  FIXED domain=" as *u8); da_wn(base, j, e2 - j)
              da_w("  (was faulty, now clean -- the floor tightens to exclude it)\n" as *u8)
          }
      }
      j = e2 + 1
  }
  da_w("RATCHET baseline_faulty=" as *u8); da_n(basecount)
  da_w(" current_faulty=" as *u8); da_n(curcount)
  da_w(" new=" as *u8); da_n(nnew)
  da_w(" fixed=" as *u8); da_n(nfixed); da_w("\n" as *u8)
  if nnew > 0 {
      da_log(basecount, curcount, nnew, nfixed, 0)
      da_w("verdict=RED (a domain that was clean at the baseline now declares a symbol no file backs -- each is NAMED above)\n" as *u8)
      sys_exit(1); return 1
  }
  if c7new > 0 {
      da_log(basecount, curcount, nnew, nfixed, 0)
      da_w("verdict=RED (C1 holds, but C7 names a NEW contract disagreement above -- one symbol, one cost)\n" as *u8)
      sys_exit(1); return 1
  }
  if nfixed > 0 {
      let wr2: i64 = da_write_file(DA_BASELINE, cur, cn)
      da_w("RATCHET TIGHTENED write_rc=" as *u8); da_n(wr2)
      da_w(" (a ratchet that does not tighten when you improve is just a threshold)\n" as *u8)
  }
  da_log(basecount, curcount, nnew, nfixed, 1)
  da_w("verdict=GREEN (no NEW offender against a baseline of " as *u8); da_n(basecount)
  da_w(" -- the standing set is the adjudication worklist, printed per domain by --all)\n" as *u8)
  sys_exit(0); return 0
691}
692
693// ==== C4 FRESH-KILL -- da_kv, da_c4_partition and da_c4 MOVED to nx_domain_admit_lib.nx ====
694// The doctrine that justifies the three buckets and the deliberate refusal to assert freshness travels
695// WITH the code, in the library. Duplicating it here would be two copies of one argument, and the copy
696// nobody edits is the one the next reader believes.
697
698func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 {
      da_w("usage: nx_domain_admit <domain> | --all | --ratchet\n" as *u8)
      da_w("  composes the ADMISSION_STANDARD checks into one REFUSING gate\n" as *u8)
      da_w("  --all sweeps every knowledge/compare/*.matrix for C1 symbol grounding + C7 contract agreement (one symbol, one est / one organ)\n" as *u8)
      sys_exit(2); return 2
  }
  let a1: *u8 = argv[1] as *u8
  if a1[0] == (45 as u8) {
      let smb: *u8 = sys_mmap(DA_MCAP)
      let ssb: *u8 = sys_mmap(DA_SCAP)
      let nb: *u8 = sys_mmap(DA_NAMEBUF)
      let nl: *i64 = sys_mmap(16) as *i64
      nl[0] = 0
      if a1[2] == (DA_CH_R as u8) { return da_ratchet(smb, ssb, nb, nl) }
      da_w("=== nx_domain_admit --all -- C1 symbol grounding across every compare matrix + C7 contract agreement ===\n" as *u8)
      let faulty: i64 = da_sweep(smb, ssb, nb, DA_NAMEBUF, nl)
      let c7new: i64 = da_c7(smb)
      if faulty == 0 { if c7new == 0 {
          da_w("VERDICT=ADMIT (every matrix grounds every symbol it declares; no new contract disagreement)\n" as *u8)
          sys_exit(0); return 0
      } }
      if faulty > 0 { da_w("VERDICT=REFUSE (a matrix declares a symbol no file backs)\n" as *u8) }
      else { da_w("VERDICT=REFUSE (C7: a NEW contract disagreement, named above)\n" as *u8) }
      sys_exit(1); return 1
  }
  let dom: *u8 = argv[1] as *u8
  let path: *u8 = sys_mmap(DA_PATH)
  var p: i64 = da_cat(path, 0, DA_CDIRS)
  p = da_cat(path, p, dom)
  p = da_cat(path, p, ".matrix" as *u8)
  path[p] = 0 as u8
730
  let mb: *u8 = sys_mmap(DA_MCAP)
  let mn: i64 = dp_read(path, mb, DA_MCAP - 4)
  da_w("=== nx_domain_admit -- " as *u8); da_w(dom); da_w(" ===\n" as *u8)
  if mn <= 0 {
      da_w("  C1 REFUSE: no readable matrix at " as *u8); da_w(path); da_w("\n" as *u8)
      da_w("VERDICT=REFUSE\n" as *u8)
      sys_exit(3); return 3
  }
739
  let sb: *u8 = sys_mmap(DA_SCAP)
  var rows: i64 = 0
  var absent: i64 = 0
  var grounded: i64 = 0
  var ungrounded: i64 = 0
  var unreadable: i64 = 0
  var newwatch: i64 = 0
747
  var i: i64 = 0
  while i < mn {
      let le: i64 = da_eol(mb, mn, i)
      if le > i {
          let f: i64 = mb[i] as i64
          var skip: i64 = 0
          if f == DA_HASH { skip = 1 }
          if f == DA_AT { skip = 1 }
          if f == DA_NL { skip = 1 }
          if skip == 0 {
              // first three pipes -> label | organ | symbol
              var p1: i64 = 0 - 1
              var p2: i64 = 0 - 1
              var p3: i64 = 0 - 1
              var k: i64 = i
              while k < le {
                  if mb[k] == (DA_PIPE as u8) {
                      if p1 < 0 { p1 = k } else { if p2 < 0 { p2 = k } else { if p3 < 0 { p3 = k; k = le } } }
                  }
                  k = k + 1
              }
              if p3 > 0 {
                  rows = rows + 1
                  let sa: i64 = p2 + 1
                  // Same classifier as the sweep path -- this copy of the row loop is precisely what
                  // da_c1's own comment warns about ("a sweep that re-implements the check is a second
                  // opinion, not a wider one"), and it is why the watch-row defect existed twice.
                  let cls: i64 = da_classify_row(mb, p1, p2, p3, sb)
                  if cls == 0 { absent = absent + 1 }
                  if cls == 1 { grounded = grounded + 1; da_rule_disagree(mb, p1, p2, da_symstart(mb, sa, p3), p3, dom) }
                  if cls == 3 {
                      unreadable = unreadable + 1
                      da_w("  C1 UNREADABLE organ: " as *u8)
                      da_wn(mb, p1 + 1, p2 - (p1 + 1))
                      da_w("   (row: " as *u8); da_wn(mb, i, p1 - i); da_w(")\n" as *u8)
                  }
                  if cls == 4 {
                      newwatch = newwatch + 1
                      da_w("  C1 WATCH-NEW-ORGAN (a contract on an organ that does not exist yet -- counted and named, not a fault): " as *u8)
                      da_wn(mb, p1 + 1, p2 - (p1 + 1))
                      da_w("   (row: " as *u8); da_wn(mb, i, p1 - i); da_w(")\n" as *u8)
                  }
                  if cls == 2 {
                      ungrounded = ungrounded + 1
                      da_w("  C1 UNGROUNDED symbol " as *u8)
                      da_wn(mb, sa, p3 - sa)
                      da_w(" not word-boundary-present in " as *u8)
                      da_wn(mb, p1 + 1, p2 - (p1 + 1))
                      da_w("\n     row: " as *u8); da_wn(mb, i, p1 - i); da_w("\n" as *u8)
                  }
              }
          }
      }
      i = le + 1
  }
803
  // ---- C2: rival bars pinned, or the matrix header declares them unpinned ----
  let bb: *u8 = sys_mmap(DA_MCAP)
  let bn: i64 = dp_read("knowledge/barcheck.conf" as *u8, bb, DA_MCAP - 4)
  var bars: i64 = 0
  if bn > 0 {
      var bi: i64 = 0
      let dl: i64 = da_slen(dom)
      while bi < bn {
          let ble: i64 = da_eol(bb, bn, bi)
          if ble > bi {
              if bb[bi] != (DA_HASH as u8) {
                  var bp: i64 = 0 - 1
                  var bk: i64 = bi
                  while bk < ble { if bb[bk] == (DA_PIPE as u8) { bp = bk; bk = ble } else { bk = bk + 1 } }
                  if bp > bi { if da_sl_eq(bb, bi, bp, dom) == 1 { bars = bars + 1 } }
              }
          }
          bi = ble + 1
      }
  }
  var unpinned_declared: i64 = 0
  if da_wfind(mb, mn, DA_UNPINNED, 0, da_slen(DA_UNPINNED)) >= 0 { unpinned_declared = 1 }
826
  // ---- C3: executable evidence -- ONE resolver, shared with C4 (da_gates_read) ----
  // Strictly additive: this can turn has_gates 0 into 1 and never 1 into 0, and C3 does not gate the
  // verdict, so no domain that passes today can begin to fail because of it. C3 and C4 each built this
  // path independently until 2026-08-25, which is exactly how the 2026-08-20 repoint left one of the
  // two behind and has_gates read 0 for every domain in the estate. One resolver cannot half-move.
  let gn: i64 = da_gates_read(dom, sb)
  var has_gates: i64 = 0
  if gn > 0 { has_gates = 1 }
835
  da_w("\n  rows=" as *u8); da_n(rows)
  da_w("  grounded=" as *u8); da_n(grounded)
  da_w("  absent=" as *u8); da_n(absent)
  da_w("  ungrounded=" as *u8); da_n(ungrounded)
  da_w("  organ-unreadable=" as *u8); da_n(unreadable)
  da_w("  watch-new-organ=" as *u8); da_n(newwatch)
  da_w("\n  C2 bars pinned=" as *u8); da_n(bars)
  da_w("  unpinned-declared=" as *u8); da_n(unpinned_declared)
  da_w("\n  C3 gates file=" as *u8); da_n(has_gates)
  da_w("\n" as *u8)
  da_c4(dom, sb)
  // C5 and C6 were HARD-CODED PLACEHOLDER STRINGS from the day this organ was written until 2026-08-25:
  // every domain in the estate got the same literal UNVERIFIED, which is a constant wearing the shape of
  // a measurement. Both now read real artifacts and both, like C3 and C4, REPORT WITHOUT REFUSING -- so
  // no domain that is admitted today can begin to be refused because of them.
  // rows is passed to C6 on purpose: the evidence stamp cannot tell an honest RED from a read that never
  // saw the domain, and this gate's own row count is the second opinion that separates them.
  da_c5(dom, sb)
  da_c6(dom, sb, rows)
855
  var fail: i64 = 0
  if ungrounded > 0 { fail = 1 }
  if unreadable > 0 { fail = 1 }
  if bars == 0 { if unpinned_declared == 0 { fail = 1 } }
860
  if fail == 1 {
      da_w("\nVERDICT=REFUSE\n" as *u8)
      if ungrounded > 0 { da_w("  reason: a symbol the matrix declares is NOT in the organ it names -- the row asserts coverage no file backs\n" as *u8) }
      if unreadable > 0 { da_w("  reason: a declared organ path could not be read -- an unresolvable citation is not a citation\n" as *u8) }
      if bars == 0 { if unpinned_declared == 0 { da_w("  reason: no barcheck row for this domain AND no UNPINNED declaration -- the comparison is silently unfalsifiable\n" as *u8) } }
      sys_exit(1); return 1
  }
868
  da_w("\nVERDICT=ADMIT" as *u8)
  if has_gates == 0 { da_w(" (CLAIM-ONLY -- no <domain>.gates, which is permitted when declared)" as *u8) }
  da_w("\n" as *u8)
  sys_exit(0)
  return 0
874}
nx_domain_admit.nx source

`nx_domain_admit.nx` source
