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

↩ module page · 719 lines · 27916 B
1// nx_memhealth.nx -- SOVEREIGN health instrument for the laptop-local memory corpus. READ-ONLY.
2//
3// CONVERTED TO nx_memplane_lib 2026-08-07. It now owns only the analysis -- document frequency, the
4// duplicate ladder, the series and co-authorship discriminators, the cross-name index. Walk, name
5// table, link scanner, read, join and the derived-artefact test come from the lib.
6// ⚠THIS ORGAN WAS THE THIRD VICTIM of the dump-suppression bug, precisely because it kept a private
7// hardcoded list while its siblings were converted. The conversion retires that list.
8//
9// WHY IT EXISTS
10// -------------
11// nx_memcliff keeps MEMORY.md under the harness cliff (25,000 B / 200 lines, both measured). But the
12// index exists to make memories FINDABLE, and a 25,000 B ceiling can only ever NAME about 35 files
13// out of 2,181. Everything else is reached by following links, or not at all -- which makes link
14// integrity the whole retrieval system, and nothing was measuring it.
15//
16// WHAT IT MEASURES (each a defect, not a statistic)
17//   * DANGLING FROM THE INDEX -- a pointer in MEMORY.md to a file that does not exist. Every session
18//     reads that file, so its pointers are the only ones GUARANTEED to be followed. Gate condition.
19//   * DANGLING ANYWHERE -- 373 corpus-wide; the file the index labels "Read FIRST" emitted 11 alone.
20//   * ORPHANS -- 581 files nothing points to. Written, then unreachable.
21//   * DUPLICATE CANDIDATES -- the ladder below.
22//
23// THE DUPLICATE LADDER, each rung measured rather than assumed:
24//   1 slug prefix only ............ 67 candidates
25//   2 + raw token overlap >=400 ... 13
26//   3 + rarity weighting .......... 10  (true dups rank to the top: 800, 571)
27//   4 + sequence-marker rule ...... 3
28//   plus a CROSS-NAME index (shared rare tokens, no slug similarity required), because
29//   ★★★★★★ A SLUG-ANCHORED DETECTOR CANNOT SEE A DUPLICATE THAT WAS NAMED DIFFERENTLY -- AND A
30//   DUPLICATE IS EXACTLY THE THING TWO AUTHORS NAME DIFFERENTLY.
31//
32// ⚠ AND ITS CEILING, MEASURED: the two files stating the store law share ZERO rare tokens, so every
33// lexical method here is blind to them. Independent wording is what makes a rediscovery a
34// rediscovery, and it is what defeats lexical detection. Found only by ranked search (nx_memfind).
35//
36// usage:  nx_memhealth [--dir <memdir>] [--list] [--dups]
37// exit:   0 = front door intact;  1 = MEMORY.md contains a dangling pointer
38// Sovereign: imports nx_memplane_lib. license_tier: ORIGINAL
39import "nx_memplane_lib.nx"
40
41const MH_DIR:  *u8 = "/mnt/c/Users/elder/.claude/projects/C--Users-elder/memory"
42const MH_IDX:  *u8 = "MEMORY.md"
43const MH_FBUF: i64 = 1048576
44const MH_MSG:  i64 = 16384
45const MH_DUPPFX: i64 = 22         // shared normalised prefix that flags a near-duplicate slug
46const MH_TOK:  i64 = 16384
47const MH_DF:   i64 = 262144
48const MH_RARE: i64 = 20           // in >20 of 2181 files (~1%) => template, not topic
49const MH_TOPK: i64 = 10
50const MH_POST: i64 = 16
51const MH_PIDX: i64 = 65536
52const MH_PAIRH: i64 = 262144
53const MH_MINSHARE: i64 = 3
54
55// ---- token sets ---------------------------------------------------------------------------------
56
57func mh_tokhas(set: *i64, h: i64) -> i64 {
  var p: i64 = h & (MH_TOK - 1)
  var r: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if set[p] == 0 { go = 0 } else {
          if set[p] == h { r = 1; go = 0 } else { p = (p + 1) & (MH_TOK - 1) }
      }
  }
  return r
67}
68
69func mh_tokput(set: *i64, h: i64) -> i64 {
  var p: i64 = h & (MH_TOK - 1)
  var r: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if set[p] == 0 { set[p] = h; r = 1; go = 0 } else {
          if set[p] == h { go = 0 } else { p = (p + 1) & (MH_TOK - 1) }
      }
  }
  return r
79}
80
81func mh_tokenise(buf: *u8, n: i64, set: *i64) -> i64 {
  var distinct: i64 = 0
  var h: i64 = 2166136261
  var ln: i64 = 0
  var i: i64 = 0
  while i <= n {
      var c: i64 = 0 - 1
      if i < n {
          let b: u8 = buf[i]
          if b >= (65 as u8) { if b <= (90 as u8) { c = (b as i64) + 32 } }
          if b >= (97 as u8) { if b <= (122 as u8) { c = b as i64 } }
          if b >= (48 as u8) { if b <= (57 as u8) { c = b as i64 } }
      }
      if c >= 0 {
          h = h ^ c
          h = (h * 16777619) & 1073741823
          ln = ln + 1
      } else {
          if ln >= 6 { if h != 0 { distinct = distinct + mh_tokput(set, h) } }
          h = 2166136261
          ln = 0
      }
      i = i + 1
  }
  return distinct
106}
107
108// ---- corpus-wide document frequency: the boilerplate filter -------------------------------------
109// RAW token overlap cannot tell a DUPLICATE from a SERIES: sequential shipping records scored 402-541
110// against each other because siblings written by one process share a TEMPLATE, and a template is
111// mostly common words.
112// ★ THE WORDS THAT PROVE TWO DOCUMENTS ARE THE SAME ARE THE WORDS ALMOST NO OTHER DOCUMENT USES.
113
114func mh_dfslot(dfk: *i64, h: i64) -> i64 {
  var p: i64 = h & (MH_DF - 1)
  var r: i64 = 0 - 1
  var go: i64 = 1
  while go == 1 {
      if dfk[p] == 0 { dfk[p] = h; r = p; go = 0 } else {
          if dfk[p] == h { r = p; go = 0 } else { p = (p + 1) & (MH_DF - 1) }
      }
  }
  return r
124}
125
126func mh_dfget(dfk: *i64, dfv: *i64, h: i64) -> i64 {
  var p: i64 = h & (MH_DF - 1)
  var r: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if dfk[p] == 0 { go = 0 } else {
          if dfk[p] == h { r = dfv[p]; go = 0 } else { p = (p + 1) & (MH_DF - 1) }
      }
  }
  return r
136}
137
138func mh_tokenise_df(buf: *u8, n: i64, set: *i64, dfk: *i64, dfv: *i64) -> i64 {
  var distinct: i64 = 0
  var h: i64 = 2166136261
  var ln: i64 = 0
  var i: i64 = 0
  while i <= n {
      var c: i64 = 0 - 1
      if i < n {
          let b: u8 = buf[i]
          if b >= (65 as u8) { if b <= (90 as u8) { c = (b as i64) + 32 } }
          if b >= (97 as u8) { if b <= (122 as u8) { c = b as i64 } }
          if b >= (48 as u8) { if b <= (57 as u8) { c = b as i64 } }
      }
      if c >= 0 {
          h = h ^ c
          h = (h * 16777619) & 1073741823
          ln = ln + 1
      } else {
          if ln >= 6 {
              if h != 0 {
                  if mh_tokput(set, h) == 1 {
                      distinct = distinct + 1
                      let s: i64 = mh_dfslot(dfk, h)
                      if s >= 0 { dfv[s] = dfv[s] + 1 }
                  }
              }
          }
          h = 2166136261
          ln = 0
      }
      i = i + 1
  }
  return distinct
171}
172
173func mh_rarecount(buf: *u8, n: i64, seen: *i64, dfk: *i64, dfv: *i64) -> i64 {
  var rare: i64 = 0
  var h: i64 = 2166136261
  var ln: i64 = 0
  var i: i64 = 0
  while i <= n {
      var c: i64 = 0 - 1
      if i < n {
          let b: u8 = buf[i]
          if b >= (65 as u8) { if b <= (90 as u8) { c = (b as i64) + 32 } }
          if b >= (97 as u8) { if b <= (122 as u8) { c = b as i64 } }
          if b >= (48 as u8) { if b <= (57 as u8) { c = b as i64 } }
      }
      if c >= 0 {
          h = h ^ c
          h = (h * 16777619) & 1073741823
          ln = ln + 1
      } else {
          if ln >= 6 {
              if h != 0 { if mh_tokput(seen, h) == 1 { if mh_dfget(dfk, dfv, h) <= MH_RARE { rare = rare + 1 } } }
          }
          h = 2166136261
          ln = 0
      }
      i = i + 1
  }
  return rare
200}
201
202// ★★★★★★ CO-AUTHORSHIP EXPLAINS SHARED VOCABULARY; ONLY INDEPENDENT REDISCOVERY IS A DUPLICATE.
203// The cross-name detector's loudest false positive paired an asset catalogue with a DOS emulator at
204// 750 permil -- unrelated, both written by ONE session that shared its vocabulary across everything
205// it wrote that day. The genuine find came from two DIFFERENT sessions.
206// ⚠Applied to the CROSS-NAME path ONLY: a session can duplicate itself (nge-browser-first did), but
207// there the slug similarity is independent corroboration. This filter stands in for the evidence the
208// name would otherwise supply.
209func mh_sesshash(buf: *u8, n: i64) -> i64 {
  let pat: *u8 = "originSessionId" as *u8
  let pl: i64 = mp_len(pat)
  var lim: i64 = n - pl
  if lim > 1200 { lim = 1200 }
  var i: i64 = 0
  while i < lim {
      var j: i64 = 0
      var ok: i64 = 1
      while j < pl { if buf[i + j] != pat[j] { ok = 0; j = pl } else { j = j + 1 } }
      if ok == 1 {
          var p: i64 = i + pl
          var go: i64 = 1
          while go == 1 {
              if p >= n { go = 0 } else {
                  let c: u8 = buf[p]
                  if c == (58 as u8) { p = p + 1 } else {
                      if c == (32 as u8) { p = p + 1 } else {
                          if c == (34 as u8) { p = p + 1 } else { go = 0 }
                      }
                  }
              }
          }
          var h: i64 = 2166136261
          var k: i64 = 0
          while k < 36 {
              if p + k >= n { k = 36 } else {
                  let c2: u8 = buf[p + k]
                  if c2 == (10 as u8) { k = 36 } else {
                      h = h ^ (c2 as i64)
                      h = (h * 16777619) & 1073741823
                      k = k + 1
                  }
              }
          }
          return h
      }
      i = i + 1
  }
  return 0
249}
250
251// rarity-weighted token overlap in permil. Extracted so BOTH candidate sources are judged by the
252// identical ruler -- two generators feeding two scorers would make their counts incomparable.
253func mh_pairsim(dir: *u8, na: *u8, nb: *u8, fbuf: *u8, fbuf2: *u8,
              setA: *i64, setB: *i64, setC: *i64, path: *u8, dfk: *i64, dfv: *i64) -> i64 {
  var z: i64 = 0
  while z < MH_TOK { setA[z] = 0; setB[z] = 0; setC[z] = 0; z = z + 1 }
  mp_join(path, dir, na)
  let la: i64 = mp_readf(path, fbuf, MH_FBUF)
  mp_join(path, dir, nb)
  let lb: i64 = mp_readf(path, fbuf2, MH_FBUF)
  mh_tokenise(fbuf, la, setA)
  let ra: i64 = mh_rarecount(fbuf, la, setC, dfk, dfv)
  var rb: i64 = 0
  var inter: i64 = 0
  var h2: i64 = 2166136261
  var ln2: i64 = 0
  var q3: i64 = 0
  while q3 <= lb {
      var c4: i64 = 0 - 1
      if q3 < lb {
          let b4: u8 = fbuf2[q3]
          if b4 >= (65 as u8) { if b4 <= (90 as u8) { c4 = (b4 as i64) + 32 } }
          if b4 >= (97 as u8) { if b4 <= (122 as u8) { c4 = b4 as i64 } }
          if b4 >= (48 as u8) { if b4 <= (57 as u8) { c4 = b4 as i64 } }
      }
      if c4 >= 0 {
          h2 = h2 ^ c4
          h2 = (h2 * 16777619) & 1073741823
          ln2 = ln2 + 1
      } else {
          if ln2 >= 6 {
              if mh_tokput(setB, h2) == 1 {
                  if mh_dfget(dfk, dfv, h2) <= MH_RARE {
                      rb = rb + 1
                      if mh_tokhas(setA, h2) == 1 { inter = inter + 1 }
                  }
              }
          }
          h2 = 2166136261
          ln2 = 0
      }
      q3 = q3 + 1
  }
  if ra + rb <= 0 { return 0 }
  return (2000 * inter) / (ra + rb)
296}
297
298// ★ A SEQUENCE MARKER IS NOT A TOPIC DIFFERENCE. Rarity weighting improved the RANKING but did not
299// separate: sequential records still scored 418-644, because c2-3b and c2-3c really are about the
300// same subject. No content maths tells "same project, next instalment" from "same doctrine, written
301// twice" -- the discriminator was never in the content, it is in the NAMES.
302func mh_isdigitc(c: u8) -> i64 {
  if c < (48 as u8) { return 0 }
  if c > (57 as u8) { return 0 }
  return 1
306}
307
308func mh_common(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) {
      if a[i] != b[i] { return i }
      i = i + 1
  }
  return i
315}
316
317func mh_is_series(a: *u8, b: *u8) -> i64 {
  let c: i64 = mh_common(a, b)
  if mh_isdigitc(a[c]) == 1 { return 1 }
  if mh_isdigitc(b[c]) == 1 { return 1 }
  let la: i64 = mp_len(a)
  let lb: i64 = mp_len(b)
  if la == lb {
      var diff: i64 = 0
      var i: i64 = 0
      while i < la { if a[i] != b[i] { diff = diff + 1 } i = i + 1 }
      if diff <= 2 { return 1 }
  }
  return 0
330}
331
332func mh_cmp(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  var r: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let ca: i64 = a[i] as i64
      let cb: i64 = b[i] as i64
      if ca != cb { if ca < cb { r = 0 - 1 } else { r = 1 } go = 0 } else {
          if ca == 0 { go = 0 } else { i = i + 1 }
      }
  }
  return r
344}
345
346func mh_norm(dst: *u8, src: *u8) -> i64 {
  var o: i64 = 0
  var i: i64 = 0
  while src[i] != (0 as u8) {
      let c: u8 = src[i]
      var k: i64 = 0 - 1
      if c >= (65 as u8) { if c <= (90 as u8) { k = (c as i64) + 32 } }
      if c >= (97 as u8) { if c <= (122 as u8) { k = c as i64 } }
      if c >= (48 as u8) { if c <= (57 as u8) { k = c as i64 } }
      if k >= 0 { if o < MP_SLOT - 1 { dst[o] = k as u8; o = o + 1 } }
      i = i + 1
  }
  dst[o] = 0 as u8
  return o
360}
361
362// ---- cross-name candidate generation: shared RARE tokens, no slug similarity required ----------
363
364func mh_post_slot(ptok: *i64, h: i64) -> i64 {
  var p: i64 = h & (MH_PIDX - 1)
  var r: i64 = 0 - 1
  var go: i64 = 1
  while go == 1 {
      if ptok[p] == 0 { ptok[p] = h; r = p; go = 0 } else {
          if ptok[p] == h { r = p; go = 0 } else { p = (p + 1) & (MH_PIDX - 1) }
      }
  }
  return r
374}
375
376func mh_pair_bump(pk: *i64, pv: *i64, key: i64) -> i64 {
  var p: i64 = (key * 2654435761) & (MH_PAIRH - 1)
  var go: i64 = 1
  var r: i64 = 0
  while go == 1 {
      if pk[p] == 0 { pk[p] = key; pv[p] = 1; r = 1; go = 0 } else {
          if pk[p] == key { pv[p] = pv[p] + 1; r = pv[p]; go = 0 } else { p = (p + 1) & (MH_PAIRH - 1) }
      }
  }
  return r
386}
387
388func main(argc: i64, argv: *i64) -> i64 {
  var dir: *u8 = MH_DIR
  var list: i64 = 0
  var dups: i64 = 0
  var ai: i64 = 1
  while ai < argc {
      let a: *u8 = argv[ai] as *u8
      if mp_streq(a, "--list" as *u8) == 1 { list = 1 }
      if mp_streq(a, "--dups" as *u8) == 1 { dups = 1 }
      if mp_streq(a, "--dir" as *u8) == 1 { if ai + 1 < argc { dir = argv[ai + 1] as *u8; ai = ai + 1 } }
      ai = ai + 1
  }
400
  let msg:   *u8 = sys_mmap(MH_MSG)
  let names: *u8 = sys_mmap(MP_MAXF * MP_SLOT)
  let norms: *u8 = sys_mmap(MP_MAXF * MP_SLOT)
  let tbl:   *i64 = sys_mmap(8 * MP_HASH) as *i64
  let inref: *i64 = sys_mmap(8 * MP_MAXF) as *i64
  let sessh: *i64 = sys_mmap(8 * MP_MAXF) as *i64
  let fbuf:  *u8 = sys_mmap(MH_FBUF)
  let fbuf2: *u8 = sys_mmap(MH_FBUF)
  let path:  *u8 = sys_mmap(4096)
  let probe: *u8 = sys_mmap(1024)
  let out:   *i64 = sys_mmap(64) as *i64
  let dfk:   *i64 = sys_mmap(8 * MH_DF) as *i64
  let dfv:   *i64 = sys_mmap(8 * MH_DF) as *i64
  let dfseen: *i64 = sys_mmap(8 * MH_TOK) as *i64
  let setA:  *i64 = sys_mmap(8 * MH_TOK) as *i64
  let setB:  *i64 = sys_mmap(8 * MH_TOK) as *i64
  let setC:  *i64 = sys_mmap(8 * MH_TOK) as *i64
418
  let cnt: i64 = mp_scan(dir, names, tbl, MP_MAXF)
  if cnt < 0 {
      var e: i64 = mp_cat(msg, 0, "nx_memhealth: REFUSED -- cannot open the memory dir.\n" as *u8)
      mp_say(msg, e)
      return 1
  }
  var i: i64 = 0
  while i < cnt { inref[i] = 0; sessh[i] = 0; i = i + 1 }
427
  // ---- pass: links + document frequency + session identity ----
  var dangling: i64 = 0
  var idx_dangling: i64 = 0
  var totrefs: i64 = 0
  var corpus: i64 = 0
  var f: i64 = 0
  while f < cnt {
      let fname: *u8 = mp_nameptr(names, f)
      // ⚠ ASK THE FILE, NOT A NAME LIST. This organ was the THIRD victim of a derived artefact
      // supplying inbound links (orphans read 1 instead of 581, live) precisely because it kept a
      // private hardcoded list while its siblings moved to the shared test.
      var skipf: i64 = 0
      if mp_is_dump(fname) == 1 { skipf = 1 }
      mp_join(path, dir, fname)
      let total: i64 = mp_readf(path, fbuf, MH_FBUF)
      if total > 0 { if mp_is_derived(fbuf, total) == 1 { skipf = 1 } }
      if total > 0 { if skipf == 0 {
          corpus = corpus + total
          var zf: i64 = 0
          while zf < MH_TOK { dfseen[zf] = 0; zf = zf + 1 }
          mh_tokenise_df(fbuf, total, dfseen, dfk, dfv)
          sessh[f] = mh_sesshash(fbuf, total)
          let is_index: i64 = mp_streq(fname, MH_IDX)
          var from: i64 = 0
          var go: i64 = 1
          while go == 1 {
              if mp_link_next(fbuf, total, from, out) == 1 {
                  from = out[3]
                  totrefs = totrefs + 1
                  let hit: i64 = mp_resolve(fbuf, out, names, tbl, probe)
                  if hit < 0 {
                      dangling = dangling + 1
                      if is_index == 1 { idx_dangling = idx_dangling + 1 }
                      if list == 1 {
                          var d: i64 = mp_cat(msg, 0, "  DANGLING " as *u8)
                          d = mp_cat(msg, d, probe)
                          d = mp_cat(msg, d, "   <- " as *u8)
                          d = mp_cat(msg, d, fname)
                          if is_index == 1 { d = mp_cat(msg, d, "   *** FRONT DOOR ***" as *u8) }
                          d = mp_cat(msg, d, "\n" as *u8)
                          mp_say(msg, d)
                      }
                  } else {
                      if hit != f { inref[hit] = inref[hit] + 1 }
                  }
              } else { go = 0 }
          }
      } }
      f = f + 1
  }
478
  // ---- orphans. The index and any derived artefact are neither lost knowledge nor authored. ----
  var orph: i64 = 0
  i = 0
  while i < cnt {
      if inref[i] == 0 {
          let nm: *u8 = mp_nameptr(names, i)
          var isderived: i64 = 0
          if mp_streq(nm, MH_IDX) == 1 { isderived = 1 }
          if mp_is_dump(nm) == 1 { isderived = 1 }
          if isderived == 0 { orph = orph + 1 }
      }
      i = i + 1
  }
492
  // ---- rung 1: slug-similar candidates ----
  i = 0
  while i < cnt { mh_norm(((norms as i64) + i * MP_SLOT) as *u8, mp_nameptr(names, i)); i = i + 1 }
  let ord: *i64 = sys_mmap(8 * MP_MAXF) as *i64
  i = 0
  while i < cnt { ord[i] = i; i = i + 1 }
  var a2: i64 = 1
  while a2 < cnt {
      let v: i64 = ord[a2]
      let vp: *u8 = ((norms as i64) + v * MP_SLOT) as *u8
      var b2: i64 = a2 - 1
      var go4: i64 = 1
      while go4 == 1 {
          if b2 < 0 { go4 = 0 } else {
              if mh_cmp(((norms as i64) + ord[b2] * MP_SLOT) as *u8, vp) > 0 { ord[b2 + 1] = ord[b2]; b2 = b2 - 1 } else { go4 = 0 }
          }
      }
      ord[b2 + 1] = v
      a2 = a2 + 1
  }
  var dupn: i64 = 0
  var dupconf: i64 = 0
  i = 1
  while i < cnt {
      let pa: *u8 = ((norms as i64) + ord[i - 1] * MP_SLOT) as *u8
      let pb: *u8 = ((norms as i64) + ord[i] * MP_SLOT) as *u8
      if mh_common(pa, pb) >= MH_DUPPFX {
          dupn = dupn + 1
          let na: *u8 = mp_nameptr(names, ord[i - 1])
          let nb: *u8 = mp_nameptr(names, ord[i])
          let sim: i64 = mh_pairsim(dir, na, nb, fbuf, fbuf2, setA, setB, setC, path, dfk, dfv)
          let series: i64 = mh_is_series(pa, pb)
          var isdup: i64 = 0
          if sim >= 400 { if series == 0 { isdup = 1 } }
          if isdup == 1 { dupconf = dupconf + 1 }
          if dups == 1 {
              var d2: i64 = mp_cat(msg, 0, "  " as *u8)
              if isdup == 1 { d2 = mp_cat(msg, d2, "DUPLICATE " as *u8) } else {
                  if series == 1 { d2 = mp_cat(msg, d2, "series    " as *u8) } else { d2 = mp_cat(msg, d2, "distinct  " as *u8) }
              }
              d2 = mp_cat(msg, d2, "sim=" as *u8)
              d2 = mp_catn(msg, d2, sim)
              d2 = mp_cat(msg, d2, " permil  " as *u8)
              d2 = mp_cat(msg, d2, na)
              d2 = mp_cat(msg, d2, "\n                          " as *u8)
              d2 = mp_cat(msg, d2, nb)
              d2 = mp_cat(msg, d2, "\n" as *u8)
              mp_say(msg, d2)
          }
      }
      i = i + 1
  }
545
  // ---- CROSS-NAME candidates: shared rare tokens, whatever the files are called ----
  let ptok: *i64 = sys_mmap(8 * MH_PIDX) as *i64
  let pcnt: *i64 = sys_mmap(8 * MH_PIDX) as *i64
  let pfil: *i64 = sys_mmap(8 * MH_PIDX * MH_POST) as *i64
  let pk:   *i64 = sys_mmap(8 * MH_PAIRH) as *i64
  let pv:   *i64 = sys_mmap(8 * MH_PAIRH) as *i64
  i = 0
  while i < MH_PIDX { ptok[i] = 0; pcnt[i] = 0; i = i + 1 }
  i = 0
  while i < MH_PAIRH { pk[i] = 0; pv[i] = 0; i = i + 1 }
556
  var ff: i64 = 0
  while ff < cnt {
      let fn2: *u8 = mp_nameptr(names, ff)
      var isdump: i64 = 0
      if mp_is_dump(fn2) == 1 { isdump = 1 }
      if mp_streq(fn2, MH_IDX) == 1 { isdump = 1 }
      if isdump == 0 {
          mp_join(path, dir, fn2)
          let tl: i64 = mp_readf(path, fbuf, MH_FBUF)
          if mp_is_derived(fbuf, tl) == 1 { isdump = 1 }
          if isdump == 0 {
              var zz: i64 = 0
              while zz < MH_TOK { dfseen[zz] = 0; zz = zz + 1 }
              var kept: i64 = 0
              var h3: i64 = 2166136261
              var ln3: i64 = 0
              var q4: i64 = 0
              while q4 <= tl {
                  var c5: i64 = 0 - 1
                  if q4 < tl {
                      let b5: u8 = fbuf[q4]
                      if b5 >= (65 as u8) { if b5 <= (90 as u8) { c5 = (b5 as i64) + 32 } }
                      if b5 >= (97 as u8) { if b5 <= (122 as u8) { c5 = b5 as i64 } }
                      if b5 >= (48 as u8) { if b5 <= (57 as u8) { c5 = b5 as i64 } }
                  }
                  if c5 >= 0 {
                      h3 = h3 ^ c5
                      h3 = (h3 * 16777619) & 1073741823
                      ln3 = ln3 + 1
                  } else {
                      if ln3 >= 6 {
                          if kept < MH_TOPK {
                              if mh_tokput(dfseen, h3) == 1 {
                                  let dfc: i64 = mh_dfget(dfk, dfv, h3)
                                  if dfc >= 2 { if dfc <= MH_RARE {
                                      let sl: i64 = mh_post_slot(ptok, h3)
                                      if sl >= 0 { if pcnt[sl] < MH_POST {
                                          pfil[sl * MH_POST + pcnt[sl]] = ff
                                          pcnt[sl] = pcnt[sl] + 1
                                          kept = kept + 1
                                      } }
                                  } }
                              }
                          }
                      }
                      h3 = 2166136261
                      ln3 = 0
                  }
                  q4 = q4 + 1
              }
          }
      }
      ff = ff + 1
  }
611
  i = 0
  while i < MH_PIDX {
      if ptok[i] != 0 {
          let c: i64 = pcnt[i]
          if c >= 2 {
              var a3: i64 = 0
              while a3 < c {
                  var b3: i64 = a3 + 1
                  while b3 < c {
                      let fa: i64 = pfil[i * MH_POST + a3]
                      let fb: i64 = pfil[i * MH_POST + b3]
                      var lo: i64 = fa
                      var hi: i64 = fb
                      if fa > fb { lo = fb; hi = fa }
                      mh_pair_bump(pk, pv, lo * MP_MAXF + hi + 1)
                      b3 = b3 + 1
                  }
                  a3 = a3 + 1
              }
          }
      }
      i = i + 1
  }
635
  var cdup: i64 = 0
  var ccand: i64 = 0
  var capped: i64 = 0
  var scored: i64 = 0
  i = 0
  while i < MH_PAIRH {
      if pk[i] != 0 {
          if pv[i] >= MH_MINSHARE {
              ccand = ccand + 1
              if scored >= 3000 { capped = capped + 1 } else {
                  scored = scored + 1
                  let key: i64 = pk[i] - 1
                  let lo2: i64 = key / MP_MAXF
                  let hi2: i64 = key % MP_MAXF
                  let na3: *u8 = mp_nameptr(names, lo2)
                  let nb3: *u8 = mp_nameptr(names, hi2)
                  let pa3: *u8 = ((norms as i64) + lo2 * MP_SLOT) as *u8
                  let pb3: *u8 = ((norms as i64) + hi2 * MP_SLOT) as *u8
                  if mh_common(pa3, pb3) < MH_DUPPFX {
                    var coauth: i64 = 0
                    if sessh[lo2] != 0 { if sessh[lo2] == sessh[hi2] { coauth = 1 } }
                    if coauth == 0 {
                      if mh_is_series(pa3, pb3) == 0 {
                          let s3: i64 = mh_pairsim(dir, na3, nb3, fbuf, fbuf2, setA, setB, setC, path, dfk, dfv)
                          if s3 >= 400 {
                              cdup = cdup + 1
                              if dups == 1 {
                                  var d3: i64 = mp_cat(msg, 0, "  CROSS-NAME DUP  sim=" as *u8)
                                  d3 = mp_catn(msg, d3, s3)
                                  d3 = mp_cat(msg, d3, " shared=" as *u8)
                                  d3 = mp_catn(msg, d3, pv[i])
                                  d3 = mp_cat(msg, d3, "  " as *u8)
                                  d3 = mp_cat(msg, d3, na3)
                                  d3 = mp_cat(msg, d3, "\n                            " as *u8)
                                  d3 = mp_cat(msg, d3, nb3)
                                  d3 = mp_cat(msg, d3, "\n" as *u8)
                                  mp_say(msg, d3)
                              }
                          }
                      }
                    }
                  }
              }
          }
      }
      i = i + 1
  }
683
  var m: i64 = mp_cat(msg, 0, "nx_memhealth: " as *u8)
  m = mp_catn(msg, m, cnt)
  m = mp_cat(msg, m, " .md files, " as *u8)
  m = mp_catn(msg, m, corpus / 1024)
  m = mp_cat(msg, m, " KB, " as *u8)
  m = mp_catn(msg, m, totrefs)
  m = mp_cat(msg, m, " links\n  DANGLING FROM INDEX (front door): " as *u8)
  m = mp_catn(msg, m, idx_dangling)
  m = mp_cat(msg, m, "\n  dangling anywhere              : " as *u8)
  m = mp_catn(msg, m, dangling)
  m = mp_cat(msg, m, "\n  orphans (nothing points to them): " as *u8)
  m = mp_catn(msg, m, orph)
  m = mp_cat(msg, m, "\n  slug-similar pairs (candidates): " as *u8)
  m = mp_catn(msg, m, dupn)
  m = mp_cat(msg, m, "\n  CONTENT-CONFIRMED DUPLICATES   : " as *u8)
  m = mp_catn(msg, m, dupconf)
  m = mp_cat(msg, m, "   (>=400 permil token overlap; the rest are legitimate series)" as *u8)
  m = mp_cat(msg, m, "\n  CROSS-NAME dup pairs           : " as *u8)
  m = mp_catn(msg, m, cdup)
  m = mp_cat(msg, m, "   (from " as *u8)
  m = mp_catn(msg, m, ccand)
  m = mp_cat(msg, m, " shared-rare-token candidates -- these share NO slug prefix, so the name rule is blind to them)" as *u8)
  if capped > 0 {
      // NO SILENT CAPS: a bound that quietly drops work reads as "covered everything".
      m = mp_cat(msg, m, "\n  *** " as *u8)
      m = mp_catn(msg, m, capped)
      m = mp_cat(msg, m, " candidate pairs NOT scored (3000 cap) -- coverage is incomplete ***" as *u8)
  }
  m = mp_cat(msg, m, "\n" as *u8)
  if idx_dangling > 0 {
      m = mp_cat(msg, m, "*** THE FRONT DOOR IS BROKEN: MEMORY.md points at a file that does not exist. Every session reads that pointer and follows it into nothing. ***\n" as *u8)
  }
  mp_say(msg, m)
  if idx_dangling > 0 { return 1 }
  return 0
719}
nx_memhealth.nx source

`nx_memhealth.nx` source
