`nx_confdup.nx` source

↩ module page · 531 lines · 21091 B
1// nx_confdup.nx -- find CONFIG FILES THAT DECLARE THE SAME CONCERN TWICE.
2//
3// WHY THIS EXISTS (measured 2026-07-30, media-vault lane): /api/promote reads
4// `knowledge/organ_kinds.conf` (PLURAL, values hyphenated `one-shot`) while
5// nx_organkind reads `knowledge/status/organ_kind.conf` (SINGULAR, values
6// unhyphenated `oneshot`). I added a row to the singular file, promote kept
7// working, and I concluded the row was the fix -- it was INERT. Undeclared
8// names fall through to a name-substring heuristic, so the wrong file "worked"
9// by luck until a name that failed the heuristic (nx_mvault_walk) became
10// unshippable by any sanctioned route.
11//
12// ★★★LAW: A SILENTLY-INERT CONFIG ROW IS WORSE THAN A MISSING ONE -- it
13// manufactures false confidence. The failure is invisible precisely because
14// the other source of truth keeps answering.
15//
16// This is a RECURRING class in this ecosystem, not a one-off:
17//   * organ_kind.conf vs organ_kinds.conf        (this session)
18//   * nx_fs root=nishihost vs /api/build buildroot/runtime -- TWO ROOTS ONE NAME
19//   * the ruler reading the wrong evidence root (rollup saw 181 of 1164 logs)
20// So it gets a DETECTOR rather than another banked warning.
21//
22// WHAT IT FLAGS -- two independent signals, reported separately because they
23// have different remedies:
24//   COLLIDE-STEM  two config files whose names normalize to the SAME stem
25//                 (plural/singular, hyphen/underscore, trailing digits).
26//                 Remedy: one file, or make one provably derived.
27//   COLLIDE-BASE  the SAME basename living under two different directories.
28//                 Remedy: name the roots apart, or collapse them.
29//
30// Normalization is deliberately AGGRESSIVE (drop ext, lowercase, '-'->'_',
31// strip trailing digits/underscores, strip ONE trailing plural 's') because a
32// false positive costs a glance while a false negative costs a session.
33//
34//   nx_confdup scan [root]        (default root: knowledge)
35//
36// Read-only. license_tier: ORIGINAL   No hw writes (Rule 26).
37
38import "nx_syscalls.nx"
39const CD_MAGIC_2048: i64 = 2048
40
41const CD_QCAP:     i64 = 1048576    // dir-queue arena
42const CD_DIRBUF:   i64 = 262144     // getdents buffer
43const CD_ARENA:    i64 = 1048576    // path + stem text arena
44const CD_MAXFILES: i64 = 8192       // bounded, and the cap is REPORTED not silent
45const CD_PATH:     i64 = 4096
46const CD_STEM:     i64 = 256
47const CD_OUT:      i64 = 1048576
48const CD_FBUF:     i64 = 1048576    // per-file read buffer for the COLLIDE-ROW pass
49const CD_MAXROWS:  i64 = 16384      // bounded, and the cap is REPORTED not silent
50const CD_KEY:      i64 = 160
51const CD_UNIQPCT:  i64 = 90        // a file is "unique-key shaped" when >=90% of its rows carry a distinct key
52
53func cd_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
54
55func cd_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var o: i64 = off
  var i: i64 = 0
  while s[i] != (0 as u8) { dst[o] = s[i]; o = o + 1; i = i + 1 }
  return o
60}
61
62func cd_ch(dst: *u8, off: i64, c: i64) -> i64 { dst[off] = c as u8; return off + 1 }
63
64func cd_udec(dst: *u8, off: i64, v: i64) -> i64 {
  if v == 0 { dst[off] = 48 as u8; return off + 1 }
  let tmp: *u8 = sys_mmap(32)
  var m: i64 = v
  var k: i64 = 0
  while m > 0 { tmp[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var o: i64 = off
  var i: i64 = k - 1
  while i >= 0 { dst[o] = tmp[i]; o = o + 1; i = i - 1 }
  sys_munmap(tmp, 32)
  return o
75}
76
77// "<dir>/<name>" into dst; returns length
78func cd_join(dst: *u8, dir: *u8, name: *u8) -> i64 {
  var o: i64 = cd_cat(dst, 0, dir)
  o = cd_ch(dst, o, 47)
  o = cd_cat(dst, o, name)
  dst[o] = 0 as u8
  return o
84}
85
86// last path component of a NUL-terminated path
87func cd_basename(p: *u8) -> *u8 {
  let n: i64 = cd_len(p)
  var last: i64 = 0 - 1
  var i: i64 = 0
  while i < n {
      if p[i] == (47 as u8) { last = i }
      i = i + 1
  }
  return ((p as i64) + last + 1) as *u8
96}
97
98// does the name end in ".conf"?
99func cd_is_conf(name: *u8) -> i64 {
  let n: i64 = cd_len(name)
  if n < 6 { return 0 }
  let s: *u8 = ".conf" as *u8
  var i: i64 = 0
  while i < 5 {
      if name[n - 5 + i] != s[i] { return 0 }
      i = i + 1
  }
  return 1
109}
110
111// Normalize a basename to a concern STEM. See the header for why this is
112// aggressive. Returns the stem length.
113func cd_norm(dst: *u8, name: *u8) -> i64 {
  let n: i64 = cd_len(name)
  // drop the extension (last '.')
  var end: i64 = n
  var i: i64 = n - 1
  var scanning: i64 = 1
  while scanning == 1 {
      if i <= 0 { scanning = 0 } else {
          if name[i] == (46 as u8) { end = i; scanning = 0 } else { i = i - 1 }
      }
  }
  var o: i64 = 0
  i = 0
  while i < end {
      var c: i64 = name[i]
      if c >= 65 { if c <= 90 { c = c + 32 } }   // lowercase
      if c == 45 { c = 95 }                       // '-' -> '_'
      if o < CD_STEM - 2 { dst[o] = c as u8; o = o + 1 }
      i = i + 1
  }
  // strip trailing digits (foo2 == foo)
  var go: i64 = 1
  while go == 1 {
      go = 0
      if o > 1 {
          let c2: i64 = dst[o - 1]
          if c2 >= 48 { if c2 <= 57 { o = o - 1; go = 1 } }
      }
  }
  // strip trailing underscores
  go = 1
  while go == 1 {
      go = 0
      if o > 1 { if dst[o - 1] == (95 as u8) { o = o - 1; go = 1 } }
  }
  // strip ONE trailing plural 's' (kind/kinds)
  if o > 2 { if dst[o - 1] == (115 as u8) { o = o - 1 } }
  dst[o] = 0 as u8
  return o
152}
153
154func cd_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while 1 == 1 {
      if a[i] != b[i] { return 0 }
      if a[i] == (0 as u8) { return 1 }
      i = i + 1
  }
  return 0
162}
163
164// ---- COLLIDE-ROW: the SAME KEY declared TWICE INSIDE one config file -------------------------
165// WHY THIS WAS ADDED (measured 2026-08-06). This detector shipped able to see duplicate config
166// FILES and completely blind to duplicate config ROWS -- and the row case is the COMMON one. It
167// bit live: nx_schema_backfill auto-appended a second `nx_prodladder` row to tool_schemas.conf
168// carrying DIFFERENT safety flags (destructive=1 open_world=1) than the hand-written row
169// (read_only=1 destructive=0). Both were true-looking, both were live, and whichever the reader
170// happens to hit decides how the fleet treats that tool. nx_confdup scanned that exact file and
171// returned collisions=3 -- none of them this one.
172// ★★AN INSTRUMENT BLIND TO THE COMMON CASE ONLY EVER SEES CRISES.
173// ★A GENERATED ROW AND A HAND-WRITTEN ROW DISAGREEING IS NOT A TIE -- IT IS TWO ANSWERS TO A
174// QUESTION THAT MUST HAVE ONE.
175// Key = field 0 (up to the first TAB or SPACE), which is how every reader in this corpus keys a
176// .conf row. Blank lines and `#` comments are skipped; a repeated key is reported with EVERY line
177// number, because the remedy needs to know which copy to delete.
178func cd_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  var tot: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let n: i64 = sys_read(fd, ((buf as i64) + tot) as *u8, cap - tot)
      if n <= 0 { go = 0 } else {
          tot = tot + n
          if tot >= cap { go = 0 }
      }
  }
  sys_close(fd)
  return tot
192}
193
194func cd_rowdups(path: *u8, fbuf: *u8, keyoff: *i64, keyline: *i64, keytaken: *i64,
              karena: *u8, out: *u8, oin: i64, dupbox: *i64) -> i64 {
  var o: i64 = oin
  let n: i64 = cd_read(path, fbuf, CD_FBUF)
  if n <= 0 { return o }
199
  var ko: i64 = 0
  var nk: i64 = 0
  var line: i64 = 0
  var i: i64 = 0
  while i < n {
      line = line + 1
      var e: i64 = i
      var scan: i64 = 1
      while scan == 1 {
          if e >= n { scan = 0 } else {
              if fbuf[e] == (10 as u8) { scan = 0 } else { e = e + 1 }
          }
      }
      // ★FIELD 0 ENDS AT A TAB IN A TAB-DELIMITED FILE, EVEN IF IT CONTAINS SPACES.
      // Splitting unconditionally on space MANUFACTURED a duplicate: langintel_axiskw.conf is
      // TAB-delimited and its keys are phrases -- "stack overflow", "stack frame", "stack probe"
      // -- which a space-split collapses into three copies of "stack". A detector that invents
      // findings is worse than one that misses them, because it burns the reader's trust on the
      // real ones. So: if the line has a TAB, the key ends at the TAB; fall back to SPACE only
      // for genuinely whitespace-delimited files.
      var hastab: i64 = 0
      var w: i64 = i
      while w < e {
          if fbuf[w] == (9 as u8) { hastab = 1; w = e } else { w = w + 1 }
      }
      var kend: i64 = i
      var s2: i64 = 1
      while s2 == 1 {
          if kend >= e { s2 = 0 } else {
              let c: i64 = fbuf[kend] as i64
              var stop: i64 = 0
              if c == 9 { stop = 1 }
              if hastab == 0 { if c == 32 { stop = 1 } }
              if stop == 1 { s2 = 0 } else { kend = kend + 1 }
          }
      }
      let klen: i64 = kend - i
      var ok: i64 = 1
      if klen <= 0 { ok = 0 }
      if klen >= CD_KEY { ok = 0 }
      if ok == 1 { if fbuf[i] == (35 as u8) { ok = 0 } }
      if ok == 1 { if fbuf[i] == (13 as u8) { ok = 0 } }
      if ok == 1 {
          if nk < CD_MAXROWS {
              if ko + klen + 2 < CD_FBUF {
                  keyoff[nk] = ko
                  var c3: i64 = 0
                  while c3 < klen { karena[ko + c3] = fbuf[i + c3]; c3 = c3 + 1 }
                  karena[ko + klen] = 0 as u8
                  ko = ko + klen + 1
                  keyline[nk] = line
                  keytaken[nk] = 0
                  nk = nk + 1
              }
          }
      }
      i = e + 1
  }
258
  // ★★A DUPLICATE IS ONLY SUSPICIOUS IN A FILE WHOSE KEYS ARE OTHERWISE UNIQUE.
  // Many .conf files here are deliberately MULTI-ROW-PER-KEY tables -- a category in field 0
  // followed by N parameter rows (body_state_profiles.conf `preg` x20, uefi_fence_deny.conf `a` x12).
  // Those are correct BY DESIGN. Reporting them buries the one real finding under noise, which is
  // exactly how a detector earns being ignored -- the same way this one was ignorable before.
  // So measure the FILE'S OWN SHAPE first and only report duplicates where uniqueness is the rule.
  // Files skipped for shape are COUNTED and reported, never silently dropped.
  var distinct: i64 = 0
  var z: i64 = 0
  while z < nk { keytaken[z] = 0; z = z + 1 }
  z = 0
  while z < nk {
      if keytaken[z] == 0 {
          distinct = distinct + 1
          let kz: *u8 = ((karena as i64) + keyoff[z]) as *u8
          keytaken[z] = 1
          var y: i64 = z + 1
          while y < nk {
              if keytaken[y] == 0 {
                  let ky: *u8 = ((karena as i64) + keyoff[y]) as *u8
                  if cd_streq(kz, ky) == 1 { keytaken[y] = 1 }
              }
              y = y + 1
          }
      }
      z = z + 1
  }
  if nk > 0 {
      if (distinct * 100) / nk < CD_UNIQPCT { dupbox[1] = dupbox[1] + 1; return o }
  }
  z = 0
  while z < nk { keytaken[z] = 0; z = z + 1 }
291
  var a: i64 = 0
  while a < nk {
      if keytaken[a] == 0 {
          let ka: *u8 = ((karena as i64) + keyoff[a]) as *u8
          var cnt: i64 = 1
          var b: i64 = a + 1
          while b < nk {
              if keytaken[b] == 0 {
                  let kb: *u8 = ((karena as i64) + keyoff[b]) as *u8
                  if cd_streq(ka, kb) == 1 { cnt = cnt + 1 }
              }
              b = b + 1
          }
          if cnt > 1 {
              dupbox[0] = dupbox[0] + 1
              if o < CD_OUT - CD_MAGIC_2048 {
                  o = cd_cat(out, o, "COLLIDE-ROW file=" as *u8)
                  o = cd_cat(out, o, path)
                  o = cd_cat(out, o, " key=" as *u8)
                  o = cd_cat(out, o, ka)
                  o = cd_cat(out, o, " count=" as *u8)
                  o = cd_udec(out, o, cnt)
                  o = cd_cat(out, o, " lines=" as *u8)
                  o = cd_udec(out, o, keyline[a])
              }
              keytaken[a] = 1
              b = a + 1
              while b < nk {
                  if keytaken[b] == 0 {
                      let kb2: *u8 = ((karena as i64) + keyoff[b]) as *u8
                      if cd_streq(ka, kb2) == 1 {
                          if o < CD_OUT - CD_MAGIC_2048 {
                              o = cd_ch(out, o, 44)
                              o = cd_udec(out, o, keyline[b])
                          }
                          keytaken[b] = 1
                      }
                  }
                  b = b + 1
              }
              if o < CD_OUT - CD_MAGIC_2048 { o = cd_ch(out, o, 10) }
          }
      }
      a = a + 1
  }
  return o
338}
339
340func main(argc: i64, argv: *i64) -> i64 {
  var root: *u8 = "knowledge" as *u8
  if argc > 2 { root = (argv[2]) as *u8 }
343
  let q: *u8 = sys_mmap(CD_QCAP)
  let dbuf: *u8 = sys_mmap(CD_DIRBUF)
  let arena: *u8 = sys_mmap(CD_ARENA)
  let pathoff: *i64 = sys_mmap(8 * CD_MAXFILES) as *i64
  let stemoff: *i64 = sys_mmap(8 * CD_MAXFILES) as *i64
  let taken: *i64 = sys_mmap(8 * CD_MAXFILES) as *i64
  let path: *u8 = sys_mmap(CD_PATH)
  let stem: *u8 = sys_mmap(CD_STEM)
  let out: *u8 = sys_mmap(CD_OUT)
353
  var ao: i64 = 0        // arena offset
  var nf: i64 = 0        // file count
  var truncated: i64 = 0
  var dirs: i64 = 0
  var qh: i64 = 0
  var qt: i64 = 0
360
  var rl: i64 = 0
  while root[rl] != (0 as u8) { q[qt] = root[rl]; qt = qt + 1; rl = rl + 1 }
  q[qt] = 0 as u8
  qt = qt + 1
365
  while qh < qt {
      let dir: *u8 = ((q as i64) + qh) as *u8
      var dl: i64 = 0
      while dir[dl] != (0 as u8) { dl = dl + 1 }
      qh = qh + dl + 1
      dirs = dirs + 1
      let dfd: i64 = sys_openat_rd(dir)
      if dfd >= 0 {
          var done: i64 = 0
          while done == 0 {
              let nread: i64 = sys_getdents64(dfd, dbuf, CD_DIRBUF)
              if nread <= 0 { done = 1 } else {
                  var off: i64 = 0
                  while off < nread {
                      let drec: *u8 = ((dbuf as i64) + off) as *u8
                      let reclen: i64 = dirent_reclen(drec)
                      let dtype: i64 = dirent_type(drec)
                      let name: *u8 = dirent_name(drec)
                      var skip: i64 = 0
                      if name[0] == (46 as u8) { skip = 1 }   // . .. dotdirs
                      if skip == 0 {
                          if dtype == DT_DIR {
                              let need: i64 = cd_join(path, dir, name)
                              if qt + need + 2 < CD_QCAP {
                                  var c: i64 = 0
                                  while c <= need { q[qt + c] = path[c]; c = c + 1 }
                                  qt = qt + need + 1
                              }
                          }
                          if dtype == DT_REG {
                              if cd_is_conf(name) == 1 {
                                  let pl: i64 = cd_join(path, dir, name)
                                  let sl: i64 = cd_norm(stem, name)
                                  if nf >= CD_MAXFILES { truncated = 1 } else {
                                      if ao + pl + sl + 4 >= CD_ARENA { truncated = 1 } else {
                                          pathoff[nf] = ao
                                          var c2: i64 = 0
                                          while c2 <= pl { arena[ao + c2] = path[c2]; c2 = c2 + 1 }
                                          ao = ao + pl + 1
                                          stemoff[nf] = ao
                                          c2 = 0
                                          while c2 <= sl { arena[ao + c2] = stem[c2]; c2 = c2 + 1 }
                                          ao = ao + sl + 1
                                          taken[nf] = 0
                                          nf = nf + 1
                                      }
                                  }
                              }
                          }
                      }
                      if reclen <= 0 { off = nread } else { off = off + reclen }
                  }
              }
          }
          sys_close(dfd)
      }
  }
423
  var o: i64 = 0
  o = cd_cat(out, o, "=== nx_confdup -- config files declaring the SAME CONCERN twice ===\n" as *u8)
  o = cd_cat(out, o, "root=" as *u8)
  o = cd_cat(out, o, root)
  o = cd_cat(out, o, " dirs=" as *u8)
  o = cd_udec(out, o, dirs)
  o = cd_cat(out, o, " conf_files=" as *u8)
  o = cd_udec(out, o, nf)
  if truncated == 1 { o = cd_cat(out, o, " TRUNCATED=1 (raise CD_MAXFILES/CD_ARENA; NOT a silent cap)" as *u8) }
  o = cd_ch(out, o, 10)
434
  var groups: i64 = 0
  var basegroups: i64 = 0
  var i2: i64 = 0
  while i2 < nf {
      if taken[i2] == 0 {
          let si: *u8 = ((arena as i64) + stemoff[i2]) as *u8
          var members: i64 = 0
          var j: i64 = i2 + 1
          while j < nf {
              if taken[j] == 0 {
                  let sj: *u8 = ((arena as i64) + stemoff[j]) as *u8
                  if cd_streq(si, sj) == 1 { members = members + 1 }
              }
              j = j + 1
          }
          if members > 0 {
              groups = groups + 1
              // are the BASENAMES identical too? then it is the two-roots-one-name shape
              let pi: *u8 = ((arena as i64) + pathoff[i2]) as *u8
              var samebase: i64 = 0
              j = i2 + 1
              while j < nf {
                  if taken[j] == 0 {
                      let sj2: *u8 = ((arena as i64) + stemoff[j]) as *u8
                      if cd_streq(si, sj2) == 1 {
                          let pj: *u8 = ((arena as i64) + pathoff[j]) as *u8
                          if cd_streq(cd_basename(pi), cd_basename(pj)) == 1 { samebase = 1 }
                      }
                  }
                  j = j + 1
              }
              if samebase == 1 {
                  basegroups = basegroups + 1
                  o = cd_cat(out, o, "COLLIDE-BASE stem=" as *u8)
              } else {
                  o = cd_cat(out, o, "COLLIDE-STEM stem=" as *u8)
              }
              o = cd_cat(out, o, si)
              o = cd_ch(out, o, 10)
              o = cd_cat(out, o, "    " as *u8)
              o = cd_cat(out, o, pi)
              o = cd_ch(out, o, 10)
              taken[i2] = 1
              j = i2 + 1
              while j < nf {
                  if taken[j] == 0 {
                      let sj3: *u8 = ((arena as i64) + stemoff[j]) as *u8
                      if cd_streq(si, sj3) == 1 {
                          o = cd_cat(out, o, "    " as *u8)
                          o = cd_cat(out, o, ((arena as i64) + pathoff[j]) as *u8)
                          o = cd_ch(out, o, 10)
                          taken[j] = 1
                      }
                  }
                  j = j + 1
              }
          }
      }
      i2 = i2 + 1
  }
495
  // ---- COLLIDE-ROW pass: same key twice inside ONE file (see cd_rowdups header) ----
  let fbuf: *u8 = sys_mmap(CD_FBUF)
  let karena: *u8 = sys_mmap(CD_FBUF)
  let keyoff: *i64 = sys_mmap(8 * CD_MAXROWS) as *i64
  let keyline: *i64 = sys_mmap(8 * CD_MAXROWS) as *i64
  let keytaken: *i64 = sys_mmap(8 * CD_MAXROWS) as *i64
  let dupbox: *i64 = sys_mmap(16) as *i64
  dupbox[0] = 0
  dupbox[1] = 0
  var fi: i64 = 0
  while fi < nf {
      o = cd_rowdups(((arena as i64) + pathoff[fi]) as *u8, fbuf, keyoff, keyline, keytaken, karena, out, o, dupbox)
      fi = fi + 1
  }
510
  o = cd_cat(out, o, "\nNX-CONFDUP collisions=" as *u8)
  o = cd_udec(out, o, groups)
  o = cd_cat(out, o, " same_basename=" as *u8)
  o = cd_udec(out, o, basegroups)
  o = cd_cat(out, o, " row_dups=" as *u8)
  o = cd_udec(out, o, dupbox[0])
  o = cd_cat(out, o, " multirow_files_skipped=" as *u8)
  o = cd_udec(out, o, dupbox[1])
  o = cd_cat(out, o, " scanned=" as *u8)
  o = cd_udec(out, o, nf)
  var bad: i64 = groups
  if dupbox[0] > 0 { bad = bad + dupbox[0] }
  if bad == 0 {
      o = cd_cat(out, o, " verdict=GREEN (no config concern is declared twice, and no file declares a key twice)\n" as *u8)
  } else {
      o = cd_cat(out, o, " verdict=RED (each group is a place a config row can be SILENTLY INERT, and each COLLIDE-ROW is two answers to a question that must have one)\n" as *u8)
  }
  sys_write(1, out, o)
  if bad == 0 { return 0 }
  return 1
531}
nx_confdup.nx source

`nx_confdup.nx` source
