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

↩ module page · 370 lines · 18174 B
1// nx_favela_decay.nx -- the TIME DIMENSION on the favela census (operator 2026-07-20: "are landmines getting
2// eaten along with all of our debt"). MEASURED ANSWER THAT MOTIVATED IT: favela rooted_permil=94 vs debt
3// eaten 490permil -- landmines get ROOTED ~5x slower than debt gets eaten. ROOT ASYMMETRY: "mitigated" is a
4// TERMINAL state in the 7-field favela manifest (there is NO time field at all) and it earns HALF CREDIT
5// FOREVER. A mitigation here is overwhelmingly "a WARNING line in MEMORY.md", so tribal knowledge is a
6// load-bearing safety mechanism -- exactly what rule 26 forbids ("proven mechanically, never asserted").
7//
8// THIS ORGAN GIVES A MITIGATION AN EXPIRY. Data-driven per rule 11: the decay window is a CONFIG ROW in the
9// ledger, NEVER a constant in code. Evidence-derived per the R2b law: age comes from an APPEND-ONLY ledger of
10// observations, never from prose and never from an assertion. FAIL-CLOSED: a missing/unreadable config
11// measures decay_days=0 => every mitigation is ALREADY expired => maximally loud. A missing config can never
12// silently grant infinite grace. HONEST: the clock starts at FIRST OBSERVATION, not at the true mitigation
13// date (unknowable -- no historical record exists); the output DECLARES this rather than faking a backdate.
14//
15// COMPOSES, DOES NOT DUPLICATE (board queried before building, 2026-07-20): cap-autonomy owns auto-filing to
16// intake/debt/frontier -- this organ EMITS the DECAYED signal and THAT lane files it. ws-intel8 owns nx_feeder
17// gap-derivation. tsv-to-native-planes owns the favela_classes.tsv migration, so this adds NO TSV: the ledger
18// is an append-only evidence log (the ws_sync.jrnl / token_efficiency.log pattern), conflict-free under
19// concurrent seats via O_APPEND.
20//
21// VERBS: check (default -- auto-stamps then evaluates) | stamp | config <days> | selftest
22// license_tier: ORIGINAL  expect_exit: 0
23import "nx_syscalls.nx"
24import "nx_estate_path.nx"   // ep_anchor: the CWD must not decide this organ's verdict
25const K_MAGIC_1784576000: i64 = 1784576000
26const K_MAGIC_1048576: i64 = 1048576
27const K_MAGIC_4000: i64 = 4000
28const K_MAGIC_3000: i64 = 3000
29const K_MAGIC_65536: i64 = 65536
30const K_MAGIC_262144: i64 = 262144
31const K_MAGIC_86400: i64 = 86400
32
33func fd_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
34func fd_cat(o: *u8, at: i64, s: *u8) -> i64 { var i: i64=0; var a: i64=at; while s[i]!=(0 as u8){o[a]=s[i]; a=a+1; i=i+1} return a }
35func fd_catf(o: *u8, at: i64, p: *u8, n: i64) -> i64 { var i: i64=0; var a: i64=at; while i<n { o[a]=p[i]; a=a+1; i=i+1 } return a }
36func fd_catn(o: *u8, at: i64, v: i64) -> i64 {
  var a: i64=at
  var x: i64=v
  if x<0 { o[a]=45 as u8; a=a+1; x=0-x }
  let tm: *u8=sys_mmap(24)
  var k: i64=0
  if x==0 { tm[0]=48 as u8; k=1 }
  while x>0 { tm[k]=(48+x%10) as u8; x=x/10; k=k+1 }
  var j: i64=0
  while j<k { o[a]=tm[k-1-j]; a=a+1; j=j+1 }
  return a
47}
48func fd_zlen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
49// slice-vs-slice equality; flag-not-early-return (census idiom, early return in loop unproven in nx_cc)
50func fd_slice_eq(a: *u8, an: i64, b: *u8, bn: i64) -> i64 {
  if an!=bn { return 0 }
  var ok: i64=1
  var i: i64=0
  while i<an { if a[i]!=b[i] { ok=0; i=an } else { i=i+1 } }
  return ok
56}
57func fd_atoi(p: *u8, n: i64) -> i64 {
  var v: i64=0
  var i: i64=0
  while i<n {
      let c: i64=p[i] as i64
      if c>=48 { if c<=57 { v=v*10+(c-48) } }
      i=i+1
  }
  return v
66}
67// earliest MITSTAMP epoch for class[cls,cn) in ledger buf; 0 = never stamped. Buffers HOISTED (scale law:
68// no mmap in the per-line loop -- the ark-v1 O(N)-fork lesson applied to allocation).
69func fd_earliest(lb: *u8, ln: i64, cls: *u8, cn: i64) -> i64 {
  let fs: *i64=sys_mmap(64) as *i64
  let fl: *i64=sys_mmap(64) as *i64
  var best: i64=0
  var i: i64=0
  while i<ln {
      let ls: i64=i
      var le: i64=ls
      var scan: i64=1
      while scan==1 { if le>=ln { scan=0 } else { if lb[le]==(10 as u8) { scan=0 } else { le=le+1 } } }
      i=le+1
      var nf: i64=0
      var p: i64=ls
      var fstart: i64=ls
      while p<le {
          if lb[p]==(9 as u8) { if nf<4 { fs[nf]=fstart; fl[nf]=p-fstart; nf=nf+1 } fstart=p+1 }
          p=p+1
      }
      if nf<4 { fs[nf]=fstart; fl[nf]=le-fstart; nf=nf+1 }
      if nf==4 {
          let m1: i64=fd_slice_eq((lb as i64+fs[1]) as *u8, fl[1], cls, cn)
          if m1==1 {
              let m2: i64=fd_slice_eq((lb as i64+fs[2]) as *u8, fl[2], "MITSTAMP\x00" as *u8, 8)
              if m2==1 {
                  let e: i64=fd_atoi((lb as i64+fs[0]) as *u8, fl[0])
                  if e>0 { if best==0 { best=e } else { if e<best { best=e } } }
              }
          }
      }
  }
  return best
100}
101// decay window in DAYS from the ledger CONFIG rows; LAST row wins (append-only semantics).
102// FAIL-CLOSED: absent/unreadable => 0 => every mitigation already expired => maximally loud.
103func fd_cfg_days(lb: *u8, ln: i64) -> i64 {
  let fs: *i64=sys_mmap(64) as *i64
  let fl: *i64=sys_mmap(64) as *i64
  var days: i64=0
  var i: i64=0
  while i<ln {
      let ls: i64=i
      var le: i64=ls
      var scan: i64=1
      while scan==1 { if le>=ln { scan=0 } else { if lb[le]==(10 as u8) { scan=0 } else { le=le+1 } } }
      i=le+1
      var nf: i64=0
      var p: i64=ls
      var fstart: i64=ls
      while p<le {
          if lb[p]==(9 as u8) { if nf<4 { fs[nf]=fstart; fl[nf]=p-fstart; nf=nf+1 } fstart=p+1 }
          p=p+1
      }
      if nf<4 { fs[nf]=fstart; fl[nf]=le-fstart; nf=nf+1 }
      if nf==4 {
          let c1: i64=fd_slice_eq((lb as i64+fs[1]) as *u8, fl[1], "CONFIG\x00" as *u8, 6)
          if c1==1 {
              let c2: i64=fd_slice_eq((lb as i64+fs[2]) as *u8, fl[2], "decay_days\x00" as *u8, 10)
              if c2==1 { days=fd_atoi((lb as i64+fs[3]) as *u8, fl[3]) }
          }
      }
  }
  return days
131}
132
133func main(argc: i64, argv: *i64) -> i64 {
  // ANCHOR FIRST (2026-08-04, nx_cwdguard finding): this organ reads a RELATIVE
  // knowledge/ path, so its answer depended on where it was launched. No-op when
  // already at the estate root, so the cron/MCP context is unchanged.
  ep_anchor()
  let LEDGER: *u8="knowledge/status/favela_mitigations.log\x00" as *u8
  var verb: *u8="check\x00" as *u8
  if argc>1 { verb=argv[1] as *u8 }
  let vn: i64=fd_zlen(verb)
142
  // ---- config <days>: append a CONFIG row (rule 11 -- the window is DATA, never a code constant)
  if fd_slice_eq(verb, vn, "config\x00" as *u8, 6)==1 {
      if argc<3 { fd_puts("usage: nx_favela_decay config <days>\n" as *u8); sys_exit(2); return 2 }
      let dv: *u8=argv[2] as *u8
      let days: i64=fd_atoi(dv, fd_zlen(dv))
      let now: i64=sys_now_realtime_sec()
      let ob: *u8=sys_mmap(256)
      var o: i64=0
      o=fd_catn(ob,o,now); o=fd_cat(ob,o,"\tCONFIG\tdecay_days\t" as *u8); o=fd_catn(ob,o,days); o=fd_cat(ob,o,"\n" as *u8)
      let fd: i64=sys_openat_append(LEDGER, 0x1a4)
      if fd<0 { fd_puts("FAVELA-DECAY RED -- cannot append ledger\n" as *u8); sys_exit(1); return 1 }
      sys_write(fd, ob, o)
      sys_close(fd)
      fd_puts("CONFIG decay_days=" as *u8)
      let pb: *u8=sys_mmap(64); var q: i64=0; q=fd_catn(pb,q,days); q=fd_cat(pb,q," appended (last row wins)\n" as *u8)
      sys_write(1,pb,q)
      return 0
  }
161
  // ---- selftest: pure-core gate + PRODUCTION-SHAPE scale tooth (scale law)
  if fd_slice_eq(verb, vn, "selftest\x00" as *u8, 8)==1 {
      var pass: i64=0
      var fail: i64=0
      // T1 atoi
      if fd_atoi("1784576000\x00" as *u8, 10)==K_MAGIC_1784576000 { pass=pass+1 } else { fail=fail+1 }
      // T2 slice_eq positive + negative (length-sensitive)
      if fd_slice_eq("abc\x00" as *u8,3,"abc\x00" as *u8,3)==1 { pass=pass+1 } else { fail=fail+1 }
      if fd_slice_eq("abc\x00" as *u8,3,"abcd\x00" as *u8,4)==0 { pass=pass+1 } else { fail=fail+1 }
      // T3 FAIL-CLOSED: empty ledger => decay_days 0 => everything already expired
      let eb: *u8=sys_mmap(16)
      if fd_cfg_days(eb,0)==0 { pass=pass+1 } else { fail=fail+1 }
      // T4 config LAST-ROW-WINS
      let cb: *u8=sys_mmap(256)
      var c: i64=0
      c=fd_cat(cb,c,"100\tCONFIG\tdecay_days\t7\n" as *u8)
      c=fd_cat(cb,c,"200\tCONFIG\tdecay_days\t14\n" as *u8)
      if fd_cfg_days(cb,c)==14 { pass=pass+1 } else { fail=fail+1 }
      // T5 earliest stamp wins + unknown class => 0 (never a silent match)
      let sb: *u8=sys_mmap(512)
      var s: i64=0
      s=fd_cat(sb,s,"900\twsl-tmp-wipe\tMITSTAMP\tseen\n" as *u8)
      s=fd_cat(sb,s,"500\twsl-tmp-wipe\tMITSTAMP\tseen\n" as *u8)
      s=fd_cat(sb,s,"700\tcap-lottery-header\tMITSTAMP\tseen\n" as *u8)
      if fd_earliest(sb,s,"wsl-tmp-wipe\x00" as *u8,12)==500 { pass=pass+1 } else { fail=fail+1 }
      if fd_earliest(sb,s,"no-such-class\x00" as *u8,13)==0 { pass=pass+1 } else { fail=fail+1 }
      // T6 NEGATIVE CONTROL: a CONFIG row must NOT be mistaken for a stamp
      if fd_earliest(cb,c,"CONFIG\x00" as *u8,6)==0 { pass=pass+1 } else { fail=fail+1 }
      // T7 SCALE TOOTH (production shape, not a fixture): 4000-row ledger, hoisted buffers, correct earliest
      let big: *u8=sys_mmap(K_MAGIC_1048576)
      var b: i64=0
      var k: i64=0
      while k<K_MAGIC_4000 {
          b=fd_catn(big,b,K_MAGIC_3000+k); b=fd_cat(big,b,"\tfiller-class\tMITSTAMP\tx\n" as *u8)
          k=k+1
      }
      b=fd_catn(big,b,42); b=fd_cat(big,b,"\tneedle-class\tMITSTAMP\tx\n" as *u8)
      if fd_earliest(big,b,"needle-class\x00" as *u8,12)==42 { pass=pass+1 } else { fail=fail+1 }
      if fd_earliest(big,b,"filler-class\x00" as *u8,12)==K_MAGIC_3000 { pass=pass+1 } else { fail=fail+1 }
      let rb: *u8=sys_mmap(256)
      var r: i64=0
      r=fd_cat(rb,r,"nx_favela_decay selftest pass=" as *u8); r=fd_catn(rb,r,pass)
      r=fd_cat(rb,r," fail=" as *u8); r=fd_catn(rb,r,fail)
      if fail==0 { r=fd_cat(rb,r," VERDICT=GREEN\n" as *u8) } else { r=fd_cat(rb,r," VERDICT=RED\n" as *u8) }
      sys_write(1,rb,r)
      if fail>0 { sys_exit(1); return 1 }
      return 0
  }
210
  // ---- manifest (fail-closed, same contract as the census)
  let szp: *i64=sys_mmap(16) as *i64
  let mb: *u8=sys_read_file("knowledge/registry/favela_classes.tsv\x00" as *u8, szp)
  if (mb as i64)==0 {
      fd_puts("FAVELA-DECAY RED -- manifest knowledge/registry/favela_classes.tsv MISSING (fail-closed)\n" as *u8)
      sys_exit(1)
      return 1
  }
  let mn: i64=szp[0]
  let now: i64=sys_now_realtime_sec()
221
  // ---- STAMP PASS (idempotent, rule 10): every mitigated class with no prior stamp gets one
  let lszp: *i64=sys_mmap(16) as *i64
  var lb: *u8=sys_read_file(LEDGER, lszp)
  var ln: i64=0
  if (lb as i64)!=0 { ln=lszp[0] } else { lb=sys_mmap(16); ln=0 }
  let ab: *u8=sys_mmap(K_MAGIC_65536)
  var ao: i64=0
  var added: i64=0
  let fs: *i64=sys_mmap(64) as *i64
  let fl: *i64=sys_mmap(64) as *i64
  var i: i64=0
  while i<mn {
      let ls: i64=i
      var le: i64=ls
      var scan: i64=1
      while scan==1 { if le>=mn { scan=0 } else { if mb[le]==(10 as u8) { scan=0 } else { le=le+1 } } }
      i=le+1
      if le-ls>3 { if mb[ls]!=(35 as u8) {
          var nf: i64=0
          var p: i64=ls
          var fstart: i64=ls
          while p<le {
              if mb[p]==(9 as u8) { if nf<7 { fs[nf]=fstart; fl[nf]=p-fstart; nf=nf+1 } fstart=p+1 }
              p=p+1
          }
          if nf<7 { fs[nf]=fstart; fl[nf]=le-fstart; nf=nf+1 }
          if nf==7 {
              if mb[fs[3]]==(109 as u8) {
                  let e: i64=fd_earliest(lb, ln, (mb as i64+fs[0]) as *u8, fl[0])
                  if e==0 {
                      ao=fd_catn(ab,ao,now); ao=fd_cat(ab,ao,"\t" as *u8)
                      ao=fd_catf(ab,ao,(mb as i64+fs[0]) as *u8, fl[0])
                      ao=fd_cat(ab,ao,"\tMITSTAMP\tfirst-observed-mitigated\n" as *u8)
                      added=added+1
                  }
              }
          }
      } }
  }
  if ao>0 {
      let afd: i64=sys_openat_append(LEDGER, 0x1a4)
      if afd<0 { fd_puts("FAVELA-DECAY RED -- cannot append ledger\n" as *u8); sys_exit(1); return 1 }
      sys_write(afd, ab, ao)
      sys_close(afd)
      lb=sys_read_file(LEDGER, lszp)
      ln=0
      if (lb as i64)!=0 { ln=lszp[0] }
  }
  if fd_slice_eq(verb, vn, "stamp\x00" as *u8, 5)==1 {
      let pb2: *u8=sys_mmap(128); var q2: i64=0
      q2=fd_cat(pb2,q2,"STAMPED new=" as *u8); q2=fd_catn(pb2,q2,added)
      q2=fd_cat(pb2,q2," (idempotent -- existing stamps untouched)\n" as *u8)
      sys_write(1,pb2,q2)
      return 0
  }
277
  // ---- CHECK PASS: age each mitigation, re-weight the expired ones as OPEN
  let days: i64=fd_cfg_days(lb, ln)
  var cfg_present: i64=1
  if days==0 { cfg_present=0 }
  let jb: *u8=sys_mmap(K_MAGIC_262144)
  var j: i64=0
  j=fd_cat(jb,j,"{\x22v\x22:1,\x22domain\x22:\x22favela-decay\x22,\x22title\x22:\x22Mitigation decay -- a mitigation is not allowed to be terminal\x22,\x22decay_days\x22:" as *u8)
  j=fd_catn(jb,j,days)
  j=fd_cat(jb,j,",\x22config_present\x22:" as *u8); j=fd_catn(jb,j,cfg_present)
  j=fd_cat(jb,j,",\x22stamps_added_this_run\x22:" as *u8); j=fd_catn(jb,j,added)
  j=fd_cat(jb,j,",\x22decayed\x22:[" as *u8)
  var total: i64=0; var wnow: i64=0; var wdecay: i64=0
  var nmit: i64=0; var ndec: i64=0; var nclass: i64=0
  var first: i64=1
  i=0
  while i<mn {
      let ls: i64=i
      var le: i64=ls
      var scan: i64=1
      while scan==1 { if le>=mn { scan=0 } else { if mb[le]==(10 as u8) { scan=0 } else { le=le+1 } } }
      i=le+1
      if le-ls>3 { if mb[ls]!=(35 as u8) {
          var nf: i64=0
          var p: i64=ls
          var fstart: i64=ls
          while p<le {
              if mb[p]==(9 as u8) { if nf<7 { fs[nf]=fstart; fl[nf]=p-fstart; nf=nf+1 } fstart=p+1 }
              p=p+1
          }
          if nf<7 { fs[nf]=fstart; fl[nf]=le-fstart; nf=nf+1 }
          if nf==7 {
              let sev: i64=(mb[fs[2]] as i64)-48
              let stc: i64=mb[fs[3]] as i64
              nclass=nclass+1
              total=total+2*sev
              if stc==111 { wnow=wnow+2*sev; wdecay=wdecay+2*sev }
              if stc==114 { wnow=wnow+0; wdecay=wdecay+0 }
              if stc==109 {
                  nmit=nmit+1
                  wnow=wnow+sev
                  let e: i64=fd_earliest(lb, ln, (mb as i64+fs[0]) as *u8, fl[0])
                  var aged: i64=0
                  if e>0 { aged=(now-e)/K_MAGIC_86400 }
                  var dec: i64=0
                  if aged>=days { dec=1 }
                  if dec==1 {
                      ndec=ndec+1
                      wdecay=wdecay+2*sev
                      if first==0 { j=fd_cat(jb,j,"," as *u8) }
                      first=0
                      j=fd_cat(jb,j,"{\x22class\x22:\x22" as *u8); j=fd_catf(jb,j,(mb as i64+fs[0]) as *u8, fl[0])
                      j=fd_cat(jb,j,"\x22,\x22sev\x22:" as *u8); j=fd_catn(jb,j,sev)
                      j=fd_cat(jb,j,",\x22age_days\x22:" as *u8); j=fd_catn(jb,j,aged)
                      j=fd_cat(jb,j,",\x22window_days\x22:" as *u8); j=fd_catn(jb,j,days)
                      j=fd_cat(jb,j,",\x22root_fix\x22:\x22" as *u8); j=fd_catf(jb,j,(mb as i64+fs[6]) as *u8, fl[6])
                      j=fd_cat(jb,j,"\x22,\x22action\x22:\x22re-weighted as OPEN -- root it or re-justify the mitigation\x22}" as *u8)
                  } else {
                      wdecay=wdecay+sev
                  }
              }
          }
      } }
  }
  var fnow: i64=0
  var fdec: i64=0
  if total>0 { fnow=(wnow*1000)/total; fdec=(wdecay*1000)/total }
  j=fd_cat(jb,j,"],\x22classes\x22:" as *u8); j=fd_catn(jb,j,nclass)
  j=fd_cat(jb,j,",\x22mitigated\x22:" as *u8); j=fd_catn(jb,j,nmit)
  j=fd_cat(jb,j,",\x22decayed_count\x22:" as *u8); j=fd_catn(jb,j,ndec)
  j=fd_cat(jb,j,",\x22favela_permil_now\x22:" as *u8); j=fd_catn(jb,j,fnow)
  j=fd_cat(jb,j,",\x22favela_permil_if_all_decay\x22:" as *u8); j=fd_catn(jb,j,fdec)
  j=fd_cat(jb,j,",\x22rule\x22:\x22a mitigation older than decay_days re-weights from sev to 2*sev (same as open): half credit EXPIRES. Root it, or append a fresh justification row.\x22" as *u8)
  j=fd_cat(jb,j,",\x22failclosed\x22:\x22no CONFIG row => decay_days=0 => every mitigation already expired; a missing config can never silently grant infinite grace\x22" as *u8)
  j=fd_cat(jb,j,",\x22envelope\x22:\x22clock starts at FIRST OBSERVATION (the true mitigation date is unknowable -- no historical record existed before this organ), so ages under-report until the ledger matures; ledger scan is O(rows x mitigated-classes) with hoisted buffers, proven to 4000 rows in selftest T7; manifest = the curated favela roster, NOT exhaustive\x22" as *u8)
  j=fd_cat(jb,j,",\x22handoff\x22:\x22DECAYED rows are the signal for the cap-autonomy lane auto-filer (intake/debt/frontier) -- this organ deliberately does NOT file, to avoid double-driving that owner\x22}" as *u8)
  sys_write(1, jb, j)
  sys_write(1, "\n" as *u8, 1)
  let lf: i64=sys_openat_wr("knowledge/status/favela_decay.log\x00" as *u8, 0x1a4)
  if lf>=0 {
      sys_write(lf, jb, j)
      let tail: *u8=sys_mmap(256)
      var t: i64=0
      t=fd_cat(tail,t,"\nVERDICT=" as *u8)
      if ndec==0 { t=fd_cat(tail,t,"GREEN" as *u8) } else { t=fd_cat(tail,t,"RED" as *u8) }
      t=fd_cat(tail,t," decayed=" as *u8); t=fd_catn(tail,t,ndec)
      t=fd_cat(tail,t," mitigated=" as *u8); t=fd_catn(tail,t,nmit)
      t=fd_cat(tail,t," window_days=" as *u8); t=fd_catn(tail,t,days)
      t=fd_cat(tail,t,"\n" as *u8)
      sys_write(lf, tail, t)
      sys_close(lf)
  }
  return 0
370}
nx_favela_decay.nx source

`nx_favela_decay.nx` source
