`nx_actlog.nx` source

↩ module page · 1334 lines · 59646 B
1// nx_actlog.nx -- ACTION LOG + WORKFLOW SEQUENCE MINER (ws=ws-intel3, 2026-07-20).
2// F217 completion (loop design-of-record R3): every cycle action journaled (ws/tool/verb/
3// outcome) + the nx_workflow_mine half = n-gram mining over per-workstream action sequences.
4// Recurring tool:verb bigrams/trigrams with support >= minsup are the EMPIRICAL workflow
5// candidates (executed patterns, not combinatorial proposals -- the complement of
6// nx_atlas_discover). The loop: sessions/seats/plans LOG actions -> mine surfaces patterns
7// -> proposals enter nx_pm_intake -> PM/LLM seat triages -> catalog verb. Sequences NEVER
8// cross workstream boundaries (per-ws successor chains). State derived, append-only,
9// conflict-free (O_APPEND; ws_sync lineage).
10// Frame: <ts>\t<ws>\t<tool>\t<verb>\t<outcome>\t<note>
11// SCALE LAW: windowed reads + declared envelope (window_bytes/truncated/bigrams_capped/
12// trigrams_capped); O(n^3) pair scan honest for journal-window scale, declared.
13// license_tier: ORIGINAL   No hw writes (Rule 26).
14//   log      <journal> <ws> <tool> <verb> <outcome> <note>   -> ACTLOG OK
15//   mine     <journal> [minsup]                              -> JSON (default minsup 2)
16//   freq     <journal>                                       -> JSON per-tool:verb counts, ranked
17//                                                               (the fallback-log ranking verb; F872 rung 2)
18//   harden   <journal> [minsup] [filer]                      -> every tool:verb recurring >= minsup
19//                                                               auto-files a hardening debt via the
20//                                                               ALLOWLIST-RESOLVED filer (default nx_debt;
21//                                                               count-free canonical desc => idempotent)
22//   selftest <scratch-journal>                               -> gate T1..T9 (caller pre-cleans)
23import "nx_sovjson_lib.nx"
24import "nx_syscalls.nx"
25import "nx_gate_verdict.nx"
26import "nx_tool_run.nx"
27const AL_MAGIC_5381: i64 = 5381
28const AL_MAGIC_1100: i64 = 1100
29const AL_MAGIC_1101: i64 = 1101
30const AL_MAGIC_1102: i64 = 1102
31const AL_MAGIC_1103: i64 = 1103
32const AL_MAGIC_1104: i64 = 1104
33const AL_MAGIC_1105: i64 = 1105
34const AL_MAGIC_1106: i64 = 1106
35const AL_MAGIC_1107: i64 = 1107
36const AL_MAGIC_1108: i64 = 1108
37const AL_MAGIC_1110: i64 = 1110
38const AL_MAGIC_1111: i64 = 1111
39const AL_MAGIC_1112: i64 = 1112
40const AL_MAGIC_1113: i64 = 1113
41const AL_MAGIC_1114: i64 = 1114
42const AL_MAGIC_1115: i64 = 1115
43const AL_MAGIC_4096: i64 = 4096
44const AL_MAGIC_1500: i64 = 1500
45const AL_MAGIC_1024: i64 = 1024
46const AL_MAGIC_4090: i64 = 4090
47
48const AL_WIN: i64 = 4194304
49const AL_OUT: i64 = 262144
50const AL_SOFT: i64 = 49152
51const AL_NAME_MAX: i64 = 120
52const AL_MINSUP_DEF: i64 = 2
53const AL_BIGRAM_CAP: i64 = 30
54const AL_TRIGRAM_CAP: i64 = 15
55const AL_FREQ_CAP: i64 = 30
56const AL_FREQ_SLOTS: i64 = 256
57const AL_HARDEN_SEV: i64 = 5
58const AL_HARDEN_CAP: i64 = 10
59const AL_ALLOW_BUF: i64 = 131072
60const AL_IX_TVMAX: i64 = 4096
61const AL_IX_HSLOTS: i64 = 8193
62const AL_IX_GMAX: i64 = 16384
63const AL_IX_GHSLOTS: i64 = 32771
64const AL_IX_ARENA: i64 = 1048576
65const AL_IX_HMOD: i64 = 1000003
66const AL_IX_KEYB: i64 = 8192
67const AL_IX_RING: i64 = 9
68const AL_IX_MAXGAP: i64 = 8
69
70// al_cat/al_catn/al_vlen/al_le/al_col DELEGATE to the shared nx_sovjson_lib (sj_*) -- dup logic eaten (TS04-family)
71func al_cat(d: *u8, o: i64, s: *u8) -> i64 { return sj_cat(d, o, s) }
72func al_catn(d: *u8, o: i64, v: i64) -> i64 { return sj_catn(d, o, v) }
73func al_vlen(s: *u8) -> i64 { return sj_vlen(s) }
74func al_atoi_z(s: *u8) -> i64 { var v: i64=0; var i: i64=0; while s[i]!=(0 as u8){ let c: i64=s[i] as i64; if c>=48 { if c<=57 { v=v*10+(c-48) } } i=i+1 } return v }
75func al_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  var n: i64 = 0
  var go: i64 = 1
  while go == 1 { let r: i64 = sys_read(fd, ((buf as i64)+n) as *u8, cap-n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap { go = 0 } }
  sys_close(fd)
  return n
83}
84func al_append(journal: *u8, ts: i64, ws: *u8, tool: *u8, verb: *u8, outcome: *u8, note: *u8) -> i64 {
  var t: i64 = ts
  if t < 0 { t = sys_now_realtime_sec() }
  let ln: *u8 = sys_mmap(AL_MAGIC_4096)
  var o: i64 = 0
  o = al_catn(ln, o, t)
  ln[o]=9 as u8; o=o+1
  o = al_cat(ln, o, ws)
  ln[o]=9 as u8; o=o+1
  o = al_cat(ln, o, tool)
  ln[o]=9 as u8; o=o+1
  o = al_cat(ln, o, verb)
  ln[o]=9 as u8; o=o+1
  o = al_cat(ln, o, outcome)
  ln[o]=9 as u8; o=o+1
  var i: i64 = 0
  var used: i64 = 0
  while note[i]!=(0 as u8) {
      if used < AL_MAGIC_1500 {
          let c: i64 = note[i] as i64
          if c==9 { ln[o]=32 as u8; o=o+1 } else { if c==10 { ln[o]=32 as u8; o=o+1 } else { if c==13 { ln[o]=32 as u8; o=o+1 } else { ln[o]=c as u8; o=o+1 } } }
          used = used + 1
      }
      i = i + 1
  }
  ln[o]=10 as u8; o=o+1
  let fd: i64 = sys_openat_append(journal, 0x1a4)
  if fd < 0 { return -1 }
  sys_write(fd, ln, o)
  sys_close(fd)
  return 0
115}
116func al_le(q: *u8, i: i64, n: i64) -> i64 { return sj_le(q, i, n) }
117func al_col(q: *u8, ls: i64, le: i64, c: i64, out: *i64) -> i64 { return sj_col(q, ls, le, c, out) }
118func al_span_eq(q: *u8, s1: i64, e1: i64, s2: i64, e2: i64) -> i64 {
  if e1-s1 != e2-s2 { return 0 }
  var i: i64 = 0
  while s1+i < e1 { if q[s1+i]!=q[s2+i] { return 0 } i=i+1 }
  return 1
123}
124func al_lit_eq(q: *u8, s: i64, e: i64, lit: *u8) -> i64 {
  var i: i64 = 0
  while s+i < e { if lit[i]==(0 as u8) { return 0 } if q[s+i]!=lit[i] { return 0 } i=i+1 }
  if lit[i]!=(0 as u8) { return 0 }
  return 1
129}
130func al_frames(q: *u8, n: i64) -> i64 {
  var c: i64 = 0
  var i: i64 = 0
  while i < n { let le: i64 = al_le(q,i,n); c=c+1; i = le + 1 }
  return c
135}
136// successor of frame at ls: next frame (after this line) whose ws (col1) equals this frame's ws.
137// returns line-start or -1.
138func al_succ(q: *u8, cx: *i64, ls: i64) -> i64 {
  let n: i64 = cx[0]
  let w1: *i64 = sys_mmap(16) as *i64
  let w2: *i64 = sys_mmap(16) as *i64
  let le0: i64 = al_le(q,ls,n)
  if al_col(q,ls,le0,1,w1)==0 { return -1 }
  var i: i64 = le0 + 1
  while i < n {
      let le: i64 = al_le(q,i,n)
      if al_col(q,i,le,1,w2)==1 { if al_span_eq(q,w2[0],w2[1],w1[0],w1[1])==1 { return i } }
      i = le + 1
  }
  return -1
151}
152// tool:verb of frame at l1 equals frame at l2?
153func al_tv_eq(q: *u8, cx: *i64, l1: i64, l2: i64) -> i64 {
  let n: i64 = cx[0]
  let a: *i64 = sys_mmap(16) as *i64
  let b: *i64 = sys_mmap(16) as *i64
  let e1: i64 = al_le(q,l1,n)
  let e2: i64 = al_le(q,l2,n)
  if al_col(q,l1,e1,2,a)==0 { return 0 }
  if al_col(q,l2,e2,2,b)==0 { return 0 }
  if al_span_eq(q,a[0],a[1],b[0],b[1])==0 { return 0 }
  if al_col(q,l1,e1,3,a)==0 { return 0 }
  if al_col(q,l2,e2,3,b)==0 { return 0 }
  if al_span_eq(q,a[0],a[1],b[0],b[1])==0 { return 0 }
  return 1
166}
167// bigram at (i,j) content-equal to bigram at (i2,j2)?
168func al_bg_eq(q: *u8, cx: *i64, i: i64, j: i64, i2: i64, j2: i64) -> i64 {
  if al_tv_eq(q,cx,i,i2)==0 { return 0 }
  if al_tv_eq(q,cx,j,j2)==0 { return 0 }
  return 1
172}
173// is (i,j) the FIRST occurrence of its bigram content? scan earlier frames' successor pairs.
174func al_bg_first(q: *u8, cx: *i64, i: i64, j: i64) -> i64 {
  let n: i64 = cx[0]
  var k: i64 = 0
  while k < i {
      let ke: i64 = al_le(q,k,n)
      let m: i64 = al_succ(q,cx,k)
      if m >= 0 { if al_bg_eq(q,cx,k,m,i,j)==1 { return 0 } }
      k = ke + 1
  }
  return 1
184}
185func al_bg_support(q: *u8, cx: *i64, i: i64, j: i64) -> i64 {
  let n: i64 = cx[0]
  var c: i64 = 0
  var k: i64 = 0
  while k < n {
      let ke: i64 = al_le(q,k,n)
      let m: i64 = al_succ(q,cx,k)
      if m >= 0 { if al_bg_eq(q,cx,k,m,i,j)==1 { c=c+1 } }
      k = ke + 1
  }
  return c
196}
197// trigram (i,j,k2) first + support
198func al_tg_first(q: *u8, cx: *i64, i: i64, j: i64, k2: i64) -> i64 {
  let n: i64 = cx[0]
  var a: i64 = 0
  while a < i {
      let ae: i64 = al_le(q,a,n)
      let b: i64 = al_succ(q,cx,a)
      if b >= 0 {
          let c: i64 = al_succ(q,cx,b)
          if c >= 0 { if al_bg_eq(q,cx,a,b,i,j)==1 { if al_tv_eq(q,cx,c,k2)==1 { return 0 } } }
      }
      a = ae + 1
  }
  return 1
211}
212func al_tg_support(q: *u8, cx: *i64, i: i64, j: i64, k2: i64) -> i64 {
  let n: i64 = cx[0]
  var cnt: i64 = 0
  var a: i64 = 0
  while a < n {
      let ae: i64 = al_le(q,a,n)
      let b: i64 = al_succ(q,cx,a)
      if b >= 0 {
          let c: i64 = al_succ(q,cx,b)
          if c >= 0 { if al_bg_eq(q,cx,a,b,i,j)==1 { if al_tv_eq(q,cx,c,k2)==1 { cnt=cnt+1 } } }
      }
      a = ae + 1
  }
  return cnt
226}
227func al_jesc(d: *u8, o: i64, q: *u8, s: i64, e: i64, maxb: i64) -> i64 {
  var p: i64 = o
  var i: i64 = s
  var used: i64 = 0
  while i < e {
      if used >= maxb { i = e } else {
          let c: i64 = q[i] as i64
          if c == 34 { d[p]=92 as u8; p=p+1; d[p]=34 as u8; p=p+1 } else { if c == 92 { d[p]=92 as u8; p=p+1; d[p]=92 as u8; p=p+1 } else { if c < 32 { d[p]=32 as u8; p=p+1 } else { d[p]=c as u8; p=p+1 } } }
          used = used + 2
          i = i + 1
      }
  }
  return p
240}
241func al_key(d: *u8, o: i64, name: *u8) -> i64 {
  d[o]=34 as u8
  var p: i64 = o + 1
  p = al_cat(d,p,name)
  d[p]=34 as u8
  p = p + 1
  d[p]=58 as u8
  p = p + 1
  return p
250}
251func al_qlit(d: *u8, o: i64, s: *u8) -> i64 {
  var p: i64 = o
  d[p]=34 as u8; p=p+1
  p = al_cat(d,p,s)
  d[p]=34 as u8; p=p+1
  return p
257}
258// emit "tool:verb" of frame at l as an escaped json string
259func al_emit_tv(d: *u8, o: i64, q: *u8, cx: *i64, l: i64) -> i64 {
  let n: i64 = cx[0]
  let sp: *i64 = sys_mmap(16) as *i64
  var p: i64 = o
  let le: i64 = al_le(q,l,n)
  d[p]=34 as u8; p=p+1
  if al_col(q,l,le,2,sp)==1 { p = al_jesc(d,p,q,sp[0],sp[1],AL_NAME_MAX) }
  d[p]=58 as u8; p=p+1
  if al_col(q,l,le,3,sp)==1 { p = al_jesc(d,p,q,sp[0],sp[1],AL_NAME_MAX) }
  d[p]=34 as u8; p=p+1
  return p
270}
271func al_mine_json(q: *u8, cx: *i64, minsup: i64, d: *u8) -> i64 {
  let n: i64 = cx[0]
  var p: i64 = 0
  d[p]=123 as u8; p=p+1
  p = al_key(d,p,"v" as *u8)
  p = al_catn(d,p,1)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"tool" as *u8)
  p = al_qlit(d,p,"nx_actlog" as *u8)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"journal" as *u8)
  d[p]=34 as u8; p=p+1
  let jp: *u8 = cx[5] as *u8
  let jl: i64 = al_vlen(jp)
  p = al_jesc(d,p,jp,0,jl,200)
  d[p]=34 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"journal_bytes" as *u8)
  p = al_catn(d,p,n)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"window_bytes" as *u8)
  p = al_catn(d,p,AL_WIN)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"truncated" as *u8)
  p = al_catn(d,p,cx[4])
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"minsup" as *u8)
  p = al_catn(d,p,minsup)
  d[p]=44 as u8; p=p+1
  let fr: i64 = al_frames(q,n)
  p = al_key(d,p,"frames" as *u8)
  p = al_catn(d,p,fr)
  d[p]=44 as u8; p=p+1
  // bigrams
  p = al_key(d,p,"bigrams" as *u8)
  d[p]=91 as u8; p=p+1
  var bcount: i64 = 0
  var bcapped: i64 = 0
  var bfirst: i64 = 1
  var i: i64 = 0
  while i < n {
      let le: i64 = al_le(q,i,n)
      let j: i64 = al_succ(q,cx,i)
      if j >= 0 { if al_bg_first(q,cx,i,j)==1 {
          let sup: i64 = al_bg_support(q,cx,i,j)
          if sup >= minsup {
              if bcount >= AL_BIGRAM_CAP { bcapped=1 } else { if p > AL_SOFT { bcapped=1 } else {
                  if bfirst==0 { d[p]=44 as u8; p=p+1 }
                  bfirst=0
                  d[p]=123 as u8; p=p+1
                  p = al_key(d,p,"a" as *u8)
                  p = al_emit_tv(d,p,q,cx,i)
                  d[p]=44 as u8; p=p+1
                  p = al_key(d,p,"b" as *u8)
                  p = al_emit_tv(d,p,q,cx,j)
                  d[p]=44 as u8; p=p+1
                  p = al_key(d,p,"support" as *u8)
                  p = al_catn(d,p,sup)
                  d[p]=125 as u8; p=p+1
                  bcount = bcount + 1
              } }
          }
      } }
      i = le + 1
  }
  d[p]=93 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"bigrams_capped" as *u8)
  p = al_catn(d,p,bcapped)
  d[p]=44 as u8; p=p+1
  // trigrams
  p = al_key(d,p,"trigrams" as *u8)
  d[p]=91 as u8; p=p+1
  var tcount: i64 = 0
  var tcapped: i64 = 0
  var tfirst: i64 = 1
  var a: i64 = 0
  while a < n {
      let ae: i64 = al_le(q,a,n)
      let b: i64 = al_succ(q,cx,a)
      if b >= 0 {
          let c: i64 = al_succ(q,cx,b)
          if c >= 0 { if al_tg_first(q,cx,a,b,c)==1 {
              let sup2: i64 = al_tg_support(q,cx,a,b,c)
              if sup2 >= minsup {
                  if tcount >= AL_TRIGRAM_CAP { tcapped=1 } else { if p > AL_SOFT { tcapped=1 } else {
                      if tfirst==0 { d[p]=44 as u8; p=p+1 }
                      tfirst=0
                      d[p]=123 as u8; p=p+1
                      p = al_key(d,p,"a" as *u8)
                      p = al_emit_tv(d,p,q,cx,a)
                      d[p]=44 as u8; p=p+1
                      p = al_key(d,p,"b" as *u8)
                      p = al_emit_tv(d,p,q,cx,b)
                      d[p]=44 as u8; p=p+1
                      p = al_key(d,p,"c" as *u8)
                      p = al_emit_tv(d,p,q,cx,c)
                      d[p]=44 as u8; p=p+1
                      p = al_key(d,p,"support" as *u8)
                      p = al_catn(d,p,sup2)
                      d[p]=125 as u8; p=p+1
                      tcount = tcount + 1
                  } }
              }
          } }
      }
      a = ae + 1
  }
  d[p]=93 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"trigrams_capped" as *u8)
  p = al_catn(d,p,tcapped)
  d[p]=125 as u8; p=p+1
  d[p]=10 as u8; p=p+1
  return p
386}
387func al_find(d: *u8, dn: i64, lit: *u8) -> i64 {
  let ll: i64 = al_vlen(lit)
  if ll == 0 { return 0 }
  var i: i64 = 0
  while i + ll <= dn {
      var k: i64 = 0
      var ok: i64 = 1
      while k < ll { if d[i+k]!=lit[k] { ok=0; k=ll } else { k=k+1 } }
      if ok==1 { return 1 }
      i = i + 1
  }
  return 0
399}
400
401// per-tool:verb FREQUENCY over the WHOLE journal (ws-agnostic) -- the fallback-log RANKING verb.
402// "which primary/backup engages most" is a frequency question the sequence miner structurally
403// cannot answer (a lone fallback row has no successor bigram). Ranked by bounded selection
404// (exact, no sort infra), capped + declared like every emitter (scale-law envelope).
405func al_tv_count(q: *u8, cx: *i64, l: i64) -> i64 {
  let n: i64 = cx[0]
  var c: i64 = 0
  var k: i64 = 0
  while k < n {
      let ke: i64 = al_le(q,k,n)
      if al_tv_eq(q,cx,l,k)==1 { c=c+1 }
      k = ke + 1
  }
  return c
415}
416func al_tv_first(q: *u8, cx: *i64, l: i64) -> i64 {
  var k: i64 = 0
  while k < l {
      let ke: i64 = al_le(q,k,cx[0])
      if al_tv_eq(q,cx,l,k)==1 { return 0 }
      k = ke + 1
  }
  return 1
424}
425func al_freq_json(q: *u8, cx: *i64, d: *u8) -> i64 {
  let n: i64 = cx[0]
  let starts: *i64 = sys_mmap(8 * AL_FREQ_SLOTS) as *i64
  let counts: *i64 = sys_mmap(8 * AL_FREQ_SLOTS) as *i64
  let done: *i64 = sys_mmap(8 * AL_FREQ_SLOTS) as *i64
  var nf: i64 = 0
  var fcapped: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = al_le(q,i,n)
      if al_tv_first(q,cx,i)==1 {
          if nf >= AL_FREQ_SLOTS { fcapped=1 } else {
              starts[nf]=i
              counts[nf]=al_tv_count(q,cx,i)
              nf=nf+1
          }
      }
      i = le + 1
  }
  var p: i64 = 0
  d[p]=123 as u8; p=p+1
  p = al_key(d,p,"v" as *u8); p = al_catn(d,p,1); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"tool" as *u8); p = al_qlit(d,p,"nx_actlog" as *u8); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"averb" as *u8); p = al_qlit(d,p,"freq" as *u8); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"journal" as *u8)
  d[p]=34 as u8; p=p+1
  let jp: *u8 = cx[5] as *u8
  let jl: i64 = al_vlen(jp)
  p = al_jesc(d,p,jp,0,jl,200)
  d[p]=34 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"journal_bytes" as *u8); p = al_catn(d,p,n); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"truncated" as *u8); p = al_catn(d,p,cx[4]); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"frames" as *u8); p = al_catn(d,p,al_frames(q,n)); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"distinct" as *u8); p = al_catn(d,p,nf); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"freq" as *u8)
  d[p]=91 as u8; p=p+1
  var shown: i64 = 0
  var efirst: i64 = 1
  var pass: i64 = 0
  while pass < nf {
      if shown < AL_FREQ_CAP { if p <= AL_SOFT {
          var mi: i64 = 0 - 1
          var mx: i64 = 0 - 1
          var k: i64 = 0
          while k < nf {
              if done[k]==0 { if counts[k] > mx { mx = counts[k]; mi = k } }
              k = k + 1
          }
          if mi >= 0 {
              done[mi] = 1
              if efirst==0 { d[p]=44 as u8; p=p+1 }
              efirst = 0
              d[p]=123 as u8; p=p+1
              p = al_key(d,p,"tv" as *u8)
              p = al_emit_tv(d,p,q,cx,starts[mi])
              d[p]=44 as u8; p=p+1
              p = al_key(d,p,"count" as *u8)
              p = al_catn(d,p,mx)
              d[p]=125 as u8; p=p+1
              shown = shown + 1
          }
      } }
      pass = pass + 1
  }
  d[p]=93 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"shown" as *u8); p = al_catn(d,p,shown); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"freq_capped" as *u8); p = al_catn(d,p,fcapped)
  d[p]=125 as u8; p=p+1
  d[p]=10 as u8; p=p+1
  return p
497}
498
499// harden: the F872 rung-3 CLOSER -- every tool:verb recurring >= minsup auto-files a hardening
500// debt through the ALLOWLIST-RESOLVED filer (never a hardcoded sibling path -- the execve-127
501// lesson: allowlist rows are not name-derivable). The desc is CANONICAL and COUNT-FREE so
502// nx_debt's content-idempotent add (F868) makes every re-run a NO-OP for already-filed
503// recurrences: a beat cannot spam. The filer is INJECTABLE (argecho in the gate) so the
504// selftest never writes the production debt plane.
505// DELEGATES to the shared base (rule-15 extraction 2026-07-23) -- the ORIGINAL of the 7 copies
506func al_allow_path(name: *u8, outp: *u8) -> i64 { return sj_allow_path(name, outp) }
507func al_harden_json(q: *u8, cx: *i64, minsup: i64, sev: i64, filer: *u8, d: *u8) -> i64 {
  let n: i64 = cx[0]
  let starts: *i64 = sys_mmap(8 * AL_FREQ_SLOTS) as *i64
  let counts: *i64 = sys_mmap(8 * AL_FREQ_SLOTS) as *i64
  var nf: i64 = 0
  var i: i64 = 0
  while i < n {
      let le: i64 = al_le(q,i,n)
      if al_tv_first(q,cx,i)==1 { if nf < AL_FREQ_SLOTS {
          starts[nf]=i
          counts[nf]=al_tv_count(q,cx,i)
          nf=nf+1
      } }
      i = le + 1
  }
  let fpath: *u8 = sys_mmap(512)
  let fok: i64 = al_allow_path(filer, fpath)
  var p: i64 = 0
  d[p]=123 as u8; p=p+1
  p = al_key(d,p,"v" as *u8); p = al_catn(d,p,1); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"tool" as *u8); p = al_qlit(d,p,"nx_actlog" as *u8); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"averb" as *u8); p = al_qlit(d,p,"harden" as *u8); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"minsup" as *u8); p = al_catn(d,p,minsup); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"sev" as *u8); p = al_catn(d,p,sev); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"filer" as *u8)
  d[p]=34 as u8; p=p+1
  p = al_jesc(d,p,filer,0,al_vlen(filer),120)
  d[p]=34 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"filer_resolved" as *u8); p = al_catn(d,p,fok); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"filed" as *u8)
  d[p]=91 as u8; p=p+1
  var recur: i64 = 0
  var attempted: i64 = 0
  var hcapped: i64 = 0
  var efirst: i64 = 1
  var k: i64 = 0
  while k < nf {
      if counts[k] >= minsup {
          recur = recur + 1
          if attempted >= AL_HARDEN_CAP { hcapped=1 } else { if fok==1 {
              let tvb: *u8 = sys_mmap(256)
              let sp2: *i64 = sys_mmap(16) as *i64
              let le2: i64 = al_le(q,starts[k],n)
              var to: i64 = 0
              if al_col(q,starts[k],le2,2,sp2)==1 { var z: i64=sp2[0]; while z<sp2[1] { if to<100 { tvb[to]=q[z]; to=to+1 } z=z+1 } }
              tvb[to]=58 as u8
              to=to+1
              if al_col(q,starts[k],le2,3,sp2)==1 { var z2: i64=sp2[0]; while z2<sp2[1] { if to<220 { tvb[to]=q[z2]; to=to+1 } z2=z2+1 } }
              tvb[to]=0 as u8
              let desc: *u8 = sys_mmap(AL_MAGIC_1024)
              var dso: i64 = 0
              dso = al_cat(desc,dso,"FALLBACK-RECURRENCE " as *u8)
              dso = al_cat(desc,dso,tvb)
              dso = al_cat(desc,dso," (auto-filed by nx_actlog harden): this backup method engages repeatedly -- root-cause and HARDEN THE PRIMARY; current counts via nx_actlog freq, per-engagement why/evidence in the journal rows" as *u8)
              desc[dso]=0 as u8
              let sevs: *u8 = sys_mmap(8)
              var so: i64 = al_catn(sevs,0,sev)
              sevs[so]=0 as u8
              let av: *i64 = sys_mmap(64) as *i64
              av[0]=fpath as i64
              av[1]="add" as *u8 as i64
              av[2]=sevs as i64
              av[3]="fallback" as *u8 as i64
              av[4]=desc as i64
              av[5]=0
              let cout: *u8 = sys_mmap(AL_MAGIC_4096)
              let colen: *i64 = sys_mmap(8) as *i64
              let ex: i64 = tr_run_capture(fpath, av, cout, AL_MAGIC_4090, colen)
              if efirst==0 { d[p]=44 as u8; p=p+1 }
              efirst=0
              d[p]=123 as u8; p=p+1
              p = al_key(d,p,"tv" as *u8)
              d[p]=34 as u8; p=p+1
              p = al_jesc(d,p,tvb,0,al_vlen(tvb),240)
              d[p]=34 as u8; p=p+1
              d[p]=44 as u8; p=p+1
              p = al_key(d,p,"exit" as *u8); p = al_catn(d,p,ex); d[p]=44 as u8; p=p+1
              p = al_key(d,p,"out" as *u8)
              d[p]=34 as u8; p=p+1
              var ce: i64 = colen[0]
              if ce > 400 { ce = 400 }
              p = al_jesc(d,p,cout,0,ce,800)
              d[p]=34 as u8; p=p+1
              d[p]=125 as u8; p=p+1
              attempted = attempted + 1
          } }
      }
      k = k + 1
  }
  d[p]=93 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"recurring" as *u8); p = al_catn(d,p,recur); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"attempted" as *u8); p = al_catn(d,p,attempted); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"harden_capped" as *u8); p = al_catn(d,p,hcapped)
  d[p]=125 as u8; p=p+1
  d[p]=10 as u8; p=p+1
  return p
605}
606
607// ---------- seq626 O(F) INDEXED MINER ----------
608// One hash-interned pass replaces the O(F^2/F^3) pair scans that died (rc=-1) on the first
609// real-scale journal (8184 frames, F964 backfill). The slow al_succ/al_bg_*/al_tg_*/al_tv_*
610// primitives above are KEPT: the selftest computes supports through them (T4/T5) while the
611// fast emitters produce the JSON (T6/T7/T8) -- fast path must agree with the slow oracle on
612// the fixture. Emission order preserved: first-occurrence, count-desc selection for freq.
613func al_z_eq(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
618}
619func al_z_hash(s: *u8) -> i64 {
  var h: i64 = AL_MAGIC_5381
  var i: i64 = 0
  while s[i] != (0 as u8) { h = (h * 31 + (s[i] as i64)) % AL_IX_HMOD; i = i + 1 }
  return h
624}
625// string intern: open-addressing hash holds id+1; ids are first-seen order; strings in arena.
626func al_ix_sintern(z: *u8, hash: *i64, off: *i64, hslots: i64, maxn: i64, ar: *u8, an: *i64, nn: *i64) -> i64 {
  var h: i64 = al_z_hash(z) % hslots
  var probes: i64 = 0
  while probes < hslots {
      let v: i64 = hash[h]
      if v == 0 {
          if nn[0] >= maxn { return -1 }
          let zl: i64 = al_vlen(z)
          if an[0] + zl + 1 >= AL_IX_ARENA { return -1 }
          let id: i64 = nn[0]
          off[id] = an[0]
          var k: i64 = 0
          while k <= zl { ar[an[0] + k] = z[k]; k = k + 1 }
          an[0] = an[0] + zl + 1
          hash[h] = id + 1
          nn[0] = id + 1
          return id
      }
      if al_z_eq(((ar as i64) + off[v-1]) as *u8, z) == 1 { return v - 1 }
      h = h + 1
      if h >= hslots { h = 0 }
      probes = probes + 1
  }
  return -1
650}
651// numeric-key intern (bigram/trigram packed keys)
652func al_ix_kintern(key: i64, hash: *i64, keys: *i64, hslots: i64, maxn: i64, nn: *i64) -> i64 {
  var h: i64 = key % hslots
  if h < 0 { h = 0 - h }
  var probes: i64 = 0
  while probes < hslots {
      let v: i64 = hash[h]
      if v == 0 {
          if nn[0] >= maxn { return -1 }
          let id: i64 = nn[0]
          keys[id] = key
          hash[h] = id + 1
          nn[0] = id + 1
          return id
      }
      if keys[v-1] == key { return v - 1 }
      h = h + 1
      if h >= hslots { h = 0 }
      probes = probes + 1
  }
  return -1
672}
673// ix ptr slots: 0 tvhash 1 tvoff 2 tvcnt 3 ntv 4 arena 5 aused 6 wshash 7 wsoff 8 wslast 9 wslast2
674// 10 nws 11 bghash 12 bgkey 13 bgcnt 14 nbg 15 tghash 16 tgkey 17 tgcnt 18 ntg 19 frames 20 overflow
675func al_ix_build(q: *u8, cx: *i64, ix: *i64, maxgap: i64) -> i64 {
  ix[0] = sys_mmap(8 * AL_IX_HSLOTS) as i64
  ix[1] = sys_mmap(8 * AL_IX_TVMAX) as i64
  ix[2] = sys_mmap(8 * AL_IX_TVMAX) as i64
  ix[3] = sys_mmap(16) as i64
  ix[4] = sys_mmap(AL_IX_ARENA) as i64
  ix[5] = sys_mmap(16) as i64
  ix[6] = sys_mmap(8 * AL_IX_HSLOTS) as i64
  ix[7] = sys_mmap(8 * AL_IX_TVMAX) as i64
  ix[8] = sys_mmap(8 * AL_IX_TVMAX * AL_IX_RING) as i64
  ix[9] = sys_mmap(8 * AL_IX_TVMAX) as i64
  ix[10] = sys_mmap(16) as i64
  ix[11] = sys_mmap(8 * AL_IX_GHSLOTS) as i64
  ix[12] = sys_mmap(8 * AL_IX_GMAX) as i64
  ix[13] = sys_mmap(8 * AL_IX_GMAX) as i64
  ix[14] = sys_mmap(16) as i64
  ix[15] = sys_mmap(8 * AL_IX_GHSLOTS) as i64
  ix[16] = sys_mmap(8 * AL_IX_GMAX) as i64
  ix[17] = sys_mmap(8 * AL_IX_GMAX) as i64
  ix[18] = sys_mmap(16) as i64
  ix[19] = sys_mmap(16) as i64
  ix[20] = sys_mmap(16) as i64
  let n: i64 = cx[0]
  let sp: *i64 = sys_mmap(16) as *i64
  let tvb: *u8 = sys_mmap(512)
  let wsb: *u8 = sys_mmap(256)
  let fp: *i64 = ix[19] as *i64
  let ov: *i64 = ix[20] as *i64
  var i: i64 = 0
  while i < n {
      let le: i64 = al_le(q,i,n)
      fp[0] = fp[0] + 1
      var ok: i64 = 0
      var wl: i64 = 0
      var to: i64 = 0
      if al_col(q,i,le,1,sp)==1 {
          var z: i64 = sp[0]
          while z < sp[1] { if wl < 200 { wsb[wl] = q[z]; wl = wl + 1 } z = z + 1 }
          wsb[wl] = 0 as u8
          if al_col(q,i,le,2,sp)==1 {
              var z2: i64 = sp[0]
              while z2 < sp[1] { if to < 240 { tvb[to] = q[z2]; to = to + 1 } z2 = z2 + 1 }
              tvb[to] = 58 as u8
              to = to + 1
              if al_col(q,i,le,3,sp)==1 {
                  var z3: i64 = sp[0]
                  while z3 < sp[1] { if to < 480 { tvb[to] = q[z3]; to = to + 1 } z3 = z3 + 1 }
                  tvb[to] = 0 as u8
                  ok = 1
              }
          }
      }
      if ok == 1 {
          let tid: i64 = al_ix_sintern(tvb, ix[0] as *i64, ix[1] as *i64, AL_IX_HSLOTS, AL_IX_TVMAX, ix[4] as *u8, ix[5] as *i64, ix[3] as *i64)
          let wid: i64 = al_ix_sintern(wsb, ix[6] as *i64, ix[7] as *i64, AL_IX_HSLOTS, AL_IX_TVMAX, ix[4] as *u8, ix[5] as *i64, ix[10] as *i64)
          if tid >= 0 { if wid >= 0 {
              let tvcnt: *i64 = ix[2] as *i64
              tvcnt[tid] = tvcnt[tid] + 1
              let ring: *i64 = ix[8] as *i64
              let wln: *i64 = ix[9] as *i64
              let cnt: i64 = wln[wid]
              var dd: i64 = 1
              while dd <= maxgap + 1 {
                  if dd <= cnt {
                      let pv: i64 = ring[wid * AL_IX_RING + ((cnt - dd) % AL_IX_RING)]
                      if pv > 0 {
                          let bkey: i64 = (pv - 1) * AL_IX_KEYB + tid
                          let bid: i64 = al_ix_kintern(bkey, ix[11] as *i64, ix[12] as *i64, AL_IX_GHSLOTS, AL_IX_GMAX, ix[14] as *i64)
                          if bid >= 0 { let bc: *i64 = ix[13] as *i64; bc[bid] = bc[bid] + 1 } else { ov[0] = 1 }
                          if dd == 1 { if cnt >= 2 {
                              let p2v: i64 = ring[wid * AL_IX_RING + ((cnt - 2) % AL_IX_RING)]
                              if p2v > 0 {
                                  let tkey: i64 = ((p2v - 1) * AL_IX_KEYB + (pv - 1)) * AL_IX_KEYB + tid
                                  let tgid: i64 = al_ix_kintern(tkey, ix[15] as *i64, ix[16] as *i64, AL_IX_GHSLOTS, AL_IX_GMAX, ix[18] as *i64)
                                  if tgid >= 0 { let tc: *i64 = ix[17] as *i64; tc[tgid] = tc[tgid] + 1 } else { ov[0] = 1 }
                              }
                          } }
                      }
                  }
                  dd = dd + 1
              }
              ring[wid * AL_IX_RING + (cnt % AL_IX_RING)] = tid + 1
              wln[wid] = cnt + 1
          } else { ov[0] = 1 } } else { ov[0] = 1 }
      }
      i = le + 1
  }
  return 0
763}
764func al_ix_tv_emit(d: *u8, o: i64, ar: *u8, off: i64) -> i64 {
  var p: i64 = o
  d[p]=34 as u8; p=p+1
  let zl: i64 = al_vlen(((ar as i64) + off) as *u8)
  p = al_jesc(d,p,ar,off,off+zl,240)
  d[p]=34 as u8; p=p+1
  return p
771}
772func al_freq_fast(q: *u8, cx: *i64, d: *u8) -> i64 {
  let n: i64 = cx[0]
  let ix: *i64 = sys_mmap(256) as *i64
  al_ix_build(q, cx, ix, 0)
  let ntvp: *i64 = ix[3] as *i64
  let nf: i64 = ntvp[0]
  let cnts: *i64 = ix[2] as *i64
  let offs: *i64 = ix[1] as *i64
  let ar: *u8 = ix[4] as *u8
  let fp: *i64 = ix[19] as *i64
  let ov: *i64 = ix[20] as *i64
  let done: *i64 = sys_mmap(8 * AL_IX_TVMAX) as *i64
  var p: i64 = 0
  d[p]=123 as u8; p=p+1
  p = al_key(d,p,"v" as *u8); p = al_catn(d,p,1); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"tool" as *u8); p = al_qlit(d,p,"nx_actlog" as *u8); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"averb" as *u8); p = al_qlit(d,p,"freq" as *u8); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"journal" as *u8)
  d[p]=34 as u8; p=p+1
  let jp: *u8 = cx[5] as *u8
  p = al_jesc(d,p,jp,0,al_vlen(jp),200)
  d[p]=34 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"journal_bytes" as *u8); p = al_catn(d,p,n); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"truncated" as *u8); p = al_catn(d,p,cx[4]); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"frames" as *u8); p = al_catn(d,p,fp[0]); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"distinct" as *u8); p = al_catn(d,p,nf); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"freq" as *u8)
  d[p]=91 as u8; p=p+1
  var shown: i64 = 0
  var efirst: i64 = 1
  var pass: i64 = 0
  while pass < nf {
      if shown < AL_FREQ_CAP { if p <= AL_SOFT {
          var mi: i64 = 0 - 1
          var mx: i64 = 0 - 1
          var k: i64 = 0
          while k < nf {
              if done[k]==0 { if cnts[k] > mx { mx = cnts[k]; mi = k } }
              k = k + 1
          }
          if mi >= 0 {
              done[mi] = 1
              if efirst==0 { d[p]=44 as u8; p=p+1 }
              efirst = 0
              d[p]=123 as u8; p=p+1
              p = al_key(d,p,"tv" as *u8)
              p = al_ix_tv_emit(d,p,ar,offs[mi])
              d[p]=44 as u8; p=p+1
              p = al_key(d,p,"count" as *u8)
              p = al_catn(d,p,mx)
              d[p]=125 as u8; p=p+1
              shown = shown + 1
          }
      } }
      pass = pass + 1
  }
  d[p]=93 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"shown" as *u8); p = al_catn(d,p,shown); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"index_overflow" as *u8); p = al_catn(d,p,ov[0]); d[p]=44 as u8; p=p+1
  p = al_key(d,p,"freq_capped" as *u8); p = al_catn(d,p,ov[0])
  d[p]=125 as u8; p=p+1
  d[p]=10 as u8; p=p+1
  return p
837}
838// al_bg_is_closed: CLOSED-PATTERN test (CloSpan/BIDE class, the research standard for NON-REDUNDANT
839// sequential mining). A bigram (a,b) is NON-closed (redundant) if some trigram containing it
840// CONTIGUOUSLY -- as prefix (a,b,*) or suffix (*,a,b) -- has the SAME support: its count is fully
841// explained by a longer pattern, so reporting it adds noise. Trigrams are maximal here (no 4-grams)
842// => emitted as closed-up-to-length-3 (declared). Returns 1 closed, 0 subsumed.
843func al_bg_is_closed(a: i64, b: i64, sup: i64, tgkey: *i64, tgcnt: *i64, ntg: i64) -> i64 {
  var i: i64 = 0
  while i < ntg {
      if tgcnt[i] == sup {
          let ta: i64 = tgkey[i] / (AL_IX_KEYB * AL_IX_KEYB)
          let tb: i64 = (tgkey[i] / AL_IX_KEYB) % AL_IX_KEYB
          let tc: i64 = tgkey[i] % AL_IX_KEYB
          if ta == a { if tb == b { return 0 } }
          if tb == a { if tc == b { return 0 } }
      }
      i = i + 1
  }
  return 1
856}
857func al_mine_fast(q: *u8, cx: *i64, minsup: i64, maxgap: i64, closed: i64, d: *u8) -> i64 {
  let n: i64 = cx[0]
  let ix: *i64 = sys_mmap(256) as *i64
  al_ix_build(q, cx, ix, maxgap)
  let offs: *i64 = ix[1] as *i64
  let ar: *u8 = ix[4] as *u8
  let fp: *i64 = ix[19] as *i64
  let ov: *i64 = ix[20] as *i64
  let nbgp: *i64 = ix[14] as *i64
  let bgkey: *i64 = ix[12] as *i64
  let bgcnt: *i64 = ix[13] as *i64
  let ntgp: *i64 = ix[18] as *i64
  let tgkey: *i64 = ix[16] as *i64
  let tgcnt: *i64 = ix[17] as *i64
  let tvcnt: *i64 = ix[2] as *i64
  var p: i64 = 0
  d[p]=123 as u8; p=p+1
  p = al_key(d,p,"v" as *u8)
  p = al_catn(d,p,1)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"tool" as *u8)
  p = al_qlit(d,p,"nx_actlog" as *u8)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"journal" as *u8)
  d[p]=34 as u8; p=p+1
  let jp: *u8 = cx[5] as *u8
  p = al_jesc(d,p,jp,0,al_vlen(jp),200)
  d[p]=34 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"journal_bytes" as *u8)
  p = al_catn(d,p,n)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"window_bytes" as *u8)
  p = al_catn(d,p,AL_WIN)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"truncated" as *u8)
  p = al_catn(d,p,cx[4])
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"minsup" as *u8)
  p = al_catn(d,p,minsup)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"maxgap" as *u8)
  p = al_catn(d,p,maxgap)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"closed" as *u8)
  p = al_catn(d,p,closed)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"frames" as *u8)
  p = al_catn(d,p,fp[0])
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"bigrams" as *u8)
  d[p]=91 as u8; p=p+1
  var bcount: i64 = 0
  var bcapped: i64 = 0
  var bfirst: i64 = 1
  var bi: i64 = 0
  while bi < nbgp[0] {
      var bg_ok: i64 = 0
      if bgcnt[bi] >= minsup { bg_ok = 1 }
      if bg_ok == 1 { if closed == 1 { if al_bg_is_closed(bgkey[bi] / AL_IX_KEYB, bgkey[bi] % AL_IX_KEYB, bgcnt[bi], tgkey, tgcnt, ntgp[0]) == 0 { bg_ok = 0 } } }
      if bg_ok == 1 {
          if bcount >= AL_BIGRAM_CAP { bcapped=1 } else { if p > AL_SOFT { bcapped=1 } else {
              if bfirst==0 { d[p]=44 as u8; p=p+1 }
              bfirst=0
              d[p]=123 as u8; p=p+1
              p = al_key(d,p,"a" as *u8)
              p = al_ix_tv_emit(d,p,ar,offs[bgkey[bi] / AL_IX_KEYB])
              d[p]=44 as u8; p=p+1
              p = al_key(d,p,"b" as *u8)
              p = al_ix_tv_emit(d,p,ar,offs[bgkey[bi] % AL_IX_KEYB])
              d[p]=44 as u8; p=p+1
              p = al_key(d,p,"support" as *u8)
              p = al_catn(d,p,bgcnt[bi])
              d[p]=44 as u8; p=p+1
              // association-rule CONFIDENCE = P(b follows a) = support / freq(a). Total-independent
              // strength: surfaces STRONG transitions vs frequent-by-chance ones (Agrawal et al.).
              p = al_key(d,p,"confidence_permil" as *u8)
              var conf: i64 = 0
              let ca: i64 = bgkey[bi] / AL_IX_KEYB
              if tvcnt[ca] > 0 { conf = bgcnt[bi] * 1000 / tvcnt[ca] }
              p = al_catn(d,p,conf)
              d[p]=125 as u8; p=p+1
              bcount = bcount + 1
          } }
      }
      bi = bi + 1
  }
  d[p]=93 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"bigrams_capped" as *u8)
  p = al_catn(d,p,bcapped)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"trigrams" as *u8)
  d[p]=91 as u8; p=p+1
  var tcount: i64 = 0
  var tcapped: i64 = 0
  var tfirst: i64 = 1
  var ti: i64 = 0
  while ti < ntgp[0] {
      if tgcnt[ti] >= minsup {
          if tcount >= AL_TRIGRAM_CAP { tcapped=1 } else { if p > AL_SOFT { tcapped=1 } else {
              if tfirst==0 { d[p]=44 as u8; p=p+1 }
              tfirst=0
              d[p]=123 as u8; p=p+1
              p = al_key(d,p,"a" as *u8)
              p = al_ix_tv_emit(d,p,ar,offs[tgkey[ti] / (AL_IX_KEYB * AL_IX_KEYB)])
              d[p]=44 as u8; p=p+1
              p = al_key(d,p,"b" as *u8)
              p = al_ix_tv_emit(d,p,ar,offs[(tgkey[ti] / AL_IX_KEYB) % AL_IX_KEYB])
              d[p]=44 as u8; p=p+1
              p = al_key(d,p,"c" as *u8)
              p = al_ix_tv_emit(d,p,ar,offs[tgkey[ti] % AL_IX_KEYB])
              d[p]=44 as u8; p=p+1
              p = al_key(d,p,"support" as *u8)
              p = al_catn(d,p,tgcnt[ti])
              d[p]=125 as u8; p=p+1
              tcount = tcount + 1
          } }
      }
      ti = ti + 1
  }
  d[p]=93 as u8; p=p+1
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"trigrams_capped" as *u8)
  p = al_catn(d,p,tcapped)
  d[p]=44 as u8; p=p+1
  p = al_key(d,p,"index_overflow" as *u8)
  p = al_catn(d,p,ov[0])
  d[p]=125 as u8; p=p+1
  d[p]=10 as u8; p=p+1
  return p
988}
989
990// ---------- F968 BENCH: miner accuracy vs CONSTRUCTED ground truth ----------
991// Synthetic journals with PLANTED patterns = an exact oracle by construction (no external dep):
992// expected supports are known arithmetic facts about the plant. Adversarial families: gapped plants
993// (found ONLY at sufficient maxgap, never at gap 0), ws-split decoys (never cross), pure-noise
994// (nothing fabricated), self-loops + trigrams (exact counts). A wrong support ANYWHERE = RED.
995func al_bench_path(dst: *u8, prefix: *u8, now: i64, sfx: *u8) -> i64 {
  var o: i64 = al_cat(dst, 0, prefix)
  o = al_catn(dst, o, now)
  o = al_cat(dst, o, sfx)
  dst[o] = 0 as u8
  // seq672 FIX: TRUNCATE the bench fixture so two selftest runs in the SAME second (now collides)
  // start empty instead of doubling appended rows -> the exact-support bench assertions stay idempotent.
  let fd: i64 = sys_openat_wr(dst, 0x1a4)
  if fd >= 0 { sys_close(fd) }
  return 0
1005}
1006func al_bench_case(ctr: *i64, name: *u8, jr: *u8, minsup: i64, maxgap: i64, needle: *u8, want: i64) -> i64 {
  let q: *u8 = sys_mmap(AL_WIN)
  let cx: *i64 = sys_mmap(64) as *i64
  let n: i64 = al_read(jr, q, AL_WIN - 8)
  cx[0]=n
  cx[1]=0
  cx[2]=0
  cx[3]=0
  cx[4]=0
  cx[5]=jr as i64
  let d: *u8 = sys_mmap(AL_OUT)
  let dl: i64 = al_mine_fast(q,cx,minsup,maxgap,0,d)
  var got: i64 = 0
  if dl > 0 { got = al_find(d,dl,needle) }
  var ok: i64 = 0
  if got == want { ok = 1 }
  gv_check(name, ok, ctr)
  return ok
1024}
1025func al_bench(prefix: *u8) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_actlog bench -- miner accuracy vs planted-pattern EXACT oracle (F968)" as *u8)
  let now: i64 = sys_now_realtime_sec()
  let jA: *u8 = sys_mmap(512)
  al_bench_path(jA, prefix, now, ".bA" as *u8)
  let jB: *u8 = sys_mmap(512)
  al_bench_path(jB, prefix, now, ".bB" as *u8)
  let jC: *u8 = sys_mmap(512)
  al_bench_path(jC, prefix, now, ".bC" as *u8)
  let jD: *u8 = sys_mmap(512)
  al_bench_path(jD, prefix, now, ".bD" as *u8)
  let jE: *u8 = sys_mmap(512)
  al_bench_path(jE, prefix, now, ".bE" as *u8)
  let jF: *u8 = sys_mmap(512)
  al_bench_path(jF, prefix, now, ".bF" as *u8)
  // jA: X:a Y:b alternating x3 in w1 (contiguous plant, K=3)
  al_append(jA, 900, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jA, 901, "w1" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jA, 902, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jA, 903, "w1" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jA, 904, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jA, 905, "w1" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_bench_case(ctr, "C1 contiguous plant support exact 3 at maxgap 0" as *u8, jA, 2, 0, "\"a\":\"X:a\",\"b\":\"Y:b\",\"support\":3" as *u8, 1)
  al_bench_case(ctr, "C2 gap window never inflates the adjacent plant (still 3 at maxgap 1)" as *u8, jA, 2, 1, "\"a\":\"X:a\",\"b\":\"Y:b\",\"support\":3" as *u8, 1)
  // jB: X:a N:z Y:b x3 in w1 (gapped plant, gap=1, K=3)
  al_append(jB, 910, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jB, 911, "w1" as *u8, "N" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jB, 912, "w1" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jB, 913, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jB, 914, "w1" as *u8, "N" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jB, 915, "w1" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jB, 916, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jB, 917, "w1" as *u8, "N" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jB, 918, "w1" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_bench_case(ctr, "C3 gapped plant INVISIBLE at maxgap 0 (no fabrication)" as *u8, jB, 2, 0, "\"a\":\"X:a\",\"b\":\"Y:b\"" as *u8, 0)
  al_bench_case(ctr, "C4 gapped plant found exact 3 at maxgap 1" as *u8, jB, 2, 1, "\"a\":\"X:a\",\"b\":\"Y:b\",\"support\":3" as *u8, 1)
  al_bench_case(ctr, "C5 wider window stays exact (3 at maxgap 2, no overcount)" as *u8, jB, 2, 2, "\"a\":\"X:a\",\"b\":\"Y:b\",\"support\":3" as *u8, 1)
  // jC: X:a in w1 / Y:b in w2 alternating x3 (ws-split decoy)
  al_append(jC, 920, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jC, 921, "w2" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jC, 922, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jC, 923, "w2" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jC, 924, "w1" as *u8, "X" as *u8, "a" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jC, 925, "w2" as *u8, "Y" as *u8, "b" as *u8, "ok" as *u8, "-" as *u8)
  al_bench_case(ctr, "C6 ws-split decoy never counted even at maxgap 2 (isolation)" as *u8, jC, 2, 2, "\"a\":\"X:a\",\"b\":\"Y:b\"" as *u8, 0)
  // jD: 5 distinct singleton tvs (pure noise)
  al_append(jD, 930, "w1" as *u8, "T1" as *u8, "v" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jD, 931, "w1" as *u8, "T2" as *u8, "v" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jD, 932, "w1" as *u8, "T3" as *u8, "v" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jD, 933, "w1" as *u8, "T4" as *u8, "v" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jD, 934, "w1" as *u8, "T5" as *u8, "v" as *u8, "ok" as *u8, "-" as *u8)
  al_bench_case(ctr, "C7 pure noise yields ZERO patterns at minsup 2" as *u8, jD, 2, 2, "\"support\"" as *u8, 0)
  // jE: P:p Q:q R:r x2 (trigram plant, K=2)
  al_append(jE, 940, "w1" as *u8, "P" as *u8, "p" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jE, 941, "w1" as *u8, "Q" as *u8, "q" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jE, 942, "w1" as *u8, "R" as *u8, "r" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jE, 943, "w1" as *u8, "P" as *u8, "p" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jE, 944, "w1" as *u8, "Q" as *u8, "q" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jE, 945, "w1" as *u8, "R" as *u8, "r" as *u8, "ok" as *u8, "-" as *u8)
  al_bench_case(ctr, "C8 trigram plant support exact 2" as *u8, jE, 2, 0, "\"a\":\"P:p\",\"b\":\"Q:q\",\"c\":\"R:r\",\"support\":2" as *u8, 1)
  // jF: S:s x4 (self-loop, 3 adjacent pairs)
  al_append(jF, 950, "w1" as *u8, "S" as *u8, "s" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jF, 951, "w1" as *u8, "S" as *u8, "s" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jF, 952, "w1" as *u8, "S" as *u8, "s" as *u8, "ok" as *u8, "-" as *u8)
  al_append(jF, 953, "w1" as *u8, "S" as *u8, "s" as *u8, "ok" as *u8, "-" as *u8)
  al_bench_case(ctr, "C9 self-loop support exact 3 (4 frames, 3 adjacent pairs)" as *u8, jF, 2, 0, "\"a\":\"S:s\",\"b\":\"S:s\",\"support\":3" as *u8, 1)
  let rc: i64 = gv_verdict("ACTLOG-BENCH" as *u8, ctr, "planted-pattern oracle: exact supports, honest gaps, ws isolation, zero fabrication" as *u8)
  return rc
1094}
1095
1096// ---------- selftest gate (T1..T9, deterministic) ----------
1097func al_selftest(journal: *u8) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_actlog selftest -- action journal + sequence mining teeth (SELF-cleans scratch)" as *u8)
  // seq672 FIX: truncate the scratch journal to empty so a RE-RUN is idempotent (T1 empty-journal
  // held on every run). Was "caller pre-cleans" -> a 2nd run failed T1 -> FALSE erosion in the
  // harness miner. Truncate-open (O_WRONLY_CT) not unlinkat (the AT_FDCWD dirfd=0 relative-path bug).
  let tfd: i64 = sys_openat_wr(journal, 0x1a4)
  if tfd >= 0 { sys_close(tfd) }
  let q: *u8 = sys_mmap(AL_WIN)
  let cx: *i64 = sys_mmap(64) as *i64
  let rcap: i64 = AL_WIN - 8
  // T1 empty -> zero frames
  var n: i64 = al_read(journal,q,rcap)
  cx[0]=n; cx[1]=0; cx[2]=0; cx[3]=0; cx[4]=0; cx[5]=journal as i64
  var ok1: i64 = 0
  if n==0 { ok1=1 }
  gv_check("T1 empty journal zero frames" as *u8, ok1, ctr)
  // seed w1: A:x -> B:y -> A:x -> B:y  interleaved with w2: C:z after the first frame
  al_append(journal, 1000, "w1" as *u8, "A" as *u8, "x" as *u8, "ok" as *u8, "n1" as *u8)
  al_append(journal, 1001, "w2" as *u8, "C" as *u8, "z" as *u8, "ok" as *u8, "n2" as *u8)
  al_append(journal, 1002, "w1" as *u8, "B" as *u8, "y" as *u8, "ok" as *u8, "n3" as *u8)
  al_append(journal, 1003, "w1" as *u8, "A" as *u8, "x" as *u8, "ok" as *u8, "n4" as *u8)
  al_append(journal, 1004, "w1" as *u8, "B" as *u8, "y" as *u8, "ok" as *u8, "n5" as *u8)
  n = al_read(journal,q,rcap)
  cx[0]=n
  var ok2: i64 = 0
  let fr: i64 = al_frames(q,n)
  if fr==5 { ok2=1 }
  gv_check("T2 five frames logged" as *u8, ok2, ctr)
  // T3 ws isolation: successor of frame0 (w1 A:x) is the w1 B:y frame, NOT the w2 C:z frame
  var ok3: i64 = 0
  let s0: i64 = al_succ(q,cx,0)
  if s0 >= 0 {
      let sp: *i64 = sys_mmap(16) as *i64
      let se: i64 = al_le(q,s0,n)
      if al_col(q,s0,se,2,sp)==1 { if al_lit_eq(q,sp[0],sp[1],"B" as *u8)==1 { ok3=1 } }
  }
  gv_check("T3 successor stays inside workstream" as *u8, ok3, ctr)
  // T4 bigram support: (A:x -> B:y) in w1 occurs twice
  var ok4: i64 = 0
  let s0b: i64 = al_succ(q,cx,0)
  if s0b >= 0 { let sup: i64 = al_bg_support(q,cx,0,s0b); if sup==2 { ok4=1 } }
  gv_check("T4 repeated bigram support exact 2" as *u8, ok4, ctr)
  // T5 trigram support: (A:x -> B:y -> A:x) occurs once
  var ok5: i64 = 0
  if s0b >= 0 {
      let s1: i64 = al_succ(q,cx,s0b)
      if s1 >= 0 { let sup3: i64 = al_tg_support(q,cx,0,s0b,s1); if sup3==1 { ok5=1 } }
  }
  gv_check("T5 trigram support exact 1" as *u8, ok5, ctr)
  // T6 threshold honesty: mine with minsup=99 emits zero bigrams
  let d: *u8 = sys_mmap(AL_OUT)
  let dl6: i64 = al_mine_fast(q,cx,99,0,0,d)
  var ok6: i64 = 0
  if dl6 > 0 { if al_find(d,dl6,"\"support\"" as *u8)==0 { ok6=1 } }
  gv_check("T6 minsup 99 yields no patterns no fabrication" as *u8, ok6, ctr)
  // T7 real mine JSON: support-2 bigram present + envelope keys
  let dl7: i64 = al_mine_fast(q,cx,2,0,0,d)
  var ok7: i64 = 0
  if dl7 > 0 { if d[0]==(123 as u8) { if al_find(d,dl7,"bigrams_capped" as *u8)==1 { if al_find(d,dl7,"A:x" as *u8)==1 { if al_find(d,dl7,"support" as *u8)==1 { ok7=1 } } } } }
  gv_check("T7 mine JSON carries pattern plus declared envelope" as *u8, ok7, ctr)
  // T8 freq: per-tool:verb frequency over the seeded journal -- A:x 2, B:y 2, C:z 1, distinct 3.
  // Non-vacuous two ways: C:z has NO successor so a sequence-only regression cannot emit it, and
  // a dedup regression (first-check broken) reads distinct 5 not 3.
  let dl8: i64 = al_freq_fast(q,cx,d)
  var ok8: i64 = 0
  if dl8 > 0 { if al_find(d,dl8,"\"distinct\":3" as *u8)==1 { if al_find(d,dl8,"\"tv\":\"C:z\",\"count\":1" as *u8)==1 { if al_find(d,dl8,"\"tv\":\"A:x\",\"count\":2" as *u8)==1 { ok8=1 } } } }
  gv_check("T8 freq ranks per-tool:verb counts (A:x 2, C:z 1, distinct 3 -- dedup + non-sequence coverage)" as *u8, ok8, ctr)
  // T9 harden: A:x and B:y recur (count 2 >= minsup 2), C:z does not. With the INJECTED argecho
  // filer, exactly those two file -- their echoed argv must carry the REAL canonical desc (a fork
  // that never ran leaves out empty), and C:z must be absent (a broken recurrence filter files 3).
  let dl9: i64 = al_harden_json(q,cx,2,5,"argecho" as *u8,d)
  var ok9: i64 = 0
  if dl9 > 0 { if al_find(d,dl9,"\"recurring\":2" as *u8)==1 { if al_find(d,dl9,"FALLBACK-RECURRENCE A:x" as *u8)==1 { if al_find(d,dl9,"FALLBACK-RECURRENCE B:y" as *u8)==1 { if al_find(d,dl9,"C:z" as *u8)==0 { ok9=1 } } } } }
  gv_check("T9 harden files EXACTLY the recurring tvs through the injected filer (canonical desc echoed back; C:z absent)" as *u8, ok9, ctr)
  // T10/T11 gap-constrained mining (F966 rung 1): w3 = A:x, C:z, B:y -- A->B has ONE intervening frame
  al_append(journal, 1010, "w3" as *u8, "A" as *u8, "x" as *u8, "ok" as *u8, "g1" as *u8)
  al_append(journal, 1011, "w3" as *u8, "C" as *u8, "z" as *u8, "ok" as *u8, "g2" as *u8)
  al_append(journal, 1012, "w3" as *u8, "B" as *u8, "y" as *u8, "ok" as *u8, "g3" as *u8)
  n = al_read(journal,q,rcap)
  cx[0]=n
  let dl10: i64 = al_mine_fast(q,cx,2,0,0,d)
  var ok10: i64 = 0
  if dl10 > 0 { if al_find(d,dl10,"\"a\":\"A:x\",\"b\":\"B:y\",\"support\":2" as *u8)==1 { ok10=1 } }
  gv_check("T10 maxgap 0 never counts the gapped pair (support stays 2)" as *u8, ok10, ctr)
  let dl11: i64 = al_mine_fast(q,cx,2,1,0,d)
  var ok11: i64 = 0
  if dl11 > 0 { if al_find(d,dl11,"\"a\":\"A:x\",\"b\":\"B:y\",\"support\":3" as *u8)==1 { if al_find(d,dl11,"\"maxgap\":1" as *u8)==1 { ok11=1 } } }
  gv_check("T11 maxgap 1 finds the interleaved pair (support 3, declared)" as *u8, ok11, ctr)
  // T12: the F968 bench itself must be all-exact (accuracy measured, not asserted)
  let rb: i64 = al_bench(journal)
  var ok12: i64 = 0
  if rb == 0 { ok12 = 1 }
  gv_check("T12 bench: planted-pattern accuracy harness all-exact" as *u8, ok12, ctr)
  // T13/T14 CLOSED PATTERNS (CloSpan/BIDE, benchmarked vs a hand-computed closure oracle). w4 = G:x
  // H:y I:z x3 (contiguous) so G:x->H:y and H:y->I:z are SUBSUMED by the trigram G:x->H:y->I:z (equal
  // support 3) = NON-closed. w5 = P:x Q:y R:z / P:x Q:y S:z so P:x->Q:y (sup 2) has NO equal-support
  // trigram (both P:x->Q:y->{R,S} are sup 1) = CLOSED. Fresh tvs (G/H/I/P/Q/R/S) avoid main-journal collisions.
  al_append(journal, AL_MAGIC_1100, "w4" as *u8, "G" as *u8, "x" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1101, "w4" as *u8, "H" as *u8, "y" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1102, "w4" as *u8, "I" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1103, "w4" as *u8, "G" as *u8, "x" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1104, "w4" as *u8, "H" as *u8, "y" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1105, "w4" as *u8, "I" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1106, "w4" as *u8, "G" as *u8, "x" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1107, "w4" as *u8, "H" as *u8, "y" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1108, "w4" as *u8, "I" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1110, "w5" as *u8, "P" as *u8, "x" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1111, "w5" as *u8, "Q" as *u8, "y" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1112, "w5" as *u8, "R" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1113, "w5" as *u8, "P" as *u8, "x" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1114, "w5" as *u8, "Q" as *u8, "y" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1115, "w5" as *u8, "S" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  n = al_read(journal,q,rcap)
  cx[0]=n
  let dlnc: i64 = al_mine_fast(q,cx,2,0,0,d)
  var ok13: i64 = 0
  if dlnc > 0 { if al_find(d,dlnc,"\"a\":\"G:x\",\"b\":\"H:y\",\"support\":3" as *u8)==1 { if al_find(d,dlnc,"\"closed\":0" as *u8)==1 { ok13=1 } } }
  gv_check("T13 non-closed mode emits the subsumed bigram G:x->H:y (support 3)" as *u8, ok13, ctr)
  let dlc: i64 = al_mine_fast(q,cx,2,0,1,d)
  var ok14: i64 = 0
  // the SUBSUMED bigram's specific form ("support" right after "b") must be gone; the trigram
  // G:x->H:y->I:z ("c" after "b") legitimately remains and must NOT be matched as the bigram.
  if dlc > 0 { if al_find(d,dlc,"\"a\":\"G:x\",\"b\":\"H:y\",\"support\"" as *u8)==0 { if al_find(d,dlc,"\"a\":\"P:x\",\"b\":\"Q:y\",\"support\":2" as *u8)==1 { if al_find(d,dlc,"\"closed\":1" as *u8)==1 { ok14=1 } } } }
  gv_check("T14 closed mode DROPS the subsumed bigram, KEEPS the closed P:x->Q:y (CloSpan/BIDE)" as *u8, ok14, ctr)
  // T15 CONFIDENCE (association-rule strength, EXACT + total-independent). w6 = M N M N M P => M appears
  // 3x, M->N 2x, M->P 1x => confidence(M:x->N:y)=support(2)/freq(M)(3)=666 permil regardless of journal size.
  al_append(journal, AL_MAGIC_1100, "w6" as *u8, "M" as *u8, "x" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1100, "w6" as *u8, "N" as *u8, "y" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1100, "w6" as *u8, "M" as *u8, "x" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1100, "w6" as *u8, "N" as *u8, "y" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1100, "w6" as *u8, "M" as *u8, "x" as *u8, "ok" as *u8, "-" as *u8)
  al_append(journal, AL_MAGIC_1100, "w6" as *u8, "P" as *u8, "z" as *u8, "ok" as *u8, "-" as *u8)
  n = al_read(journal,q,rcap)
  cx[0]=n
  let dlcf: i64 = al_mine_fast(q,cx,2,0,0,d)
  var ok15: i64 = 0
  if dlcf > 0 { if al_find(d,dlcf,"\"a\":\"M:x\",\"b\":\"N:y\",\"support\":2,\"confidence_permil\":666" as *u8)==1 { ok15=1 } }
  gv_check("T15 confidence(M:x->N:y)=666 permil (support 2 / freq(M) 3 -- association-rule strength, exact)" as *u8, ok15, ctr)
  let rc: i64 = gv_verdict("ACTLOG-GATE" as *u8, ctr, "action journal + sequence + frequency + harden + gap + bench + closed-pattern + confidence teeth green" as *u8)
  return rc
1238}
1239
1240func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { gv_puts("usage: nx_actlog {log <journal> <ws> <tool> <verb> <outcome> <note> | mine <journal> [minsup] [maxgap] [closed] | freq <journal> | harden <journal> [minsup] [filer] | bench <scratch-prefix> | selftest <journal>}\n" as *u8); sys_exit(2); return 2 }
  let verb: *u8 = argv[1] as *u8
  let journal: *u8 = argv[2] as *u8
  let vl: i64 = al_vlen(verb)
  if al_lit_eq(verb,0,vl,"selftest" as *u8)==1 { let rc: i64 = al_selftest(journal); sys_exit(rc); return rc }
  if al_lit_eq(verb,0,vl,"log" as *u8)==1 {
      if argc < 8 { gv_puts("log needs <journal> <ws> <tool> <verb> <outcome> <note>\n" as *u8); sys_exit(2); return 2 }
      let ws: *u8 = argv[3] as *u8
      let tool: *u8 = argv[4] as *u8
      let averb: *u8 = argv[5] as *u8
      let outcome: *u8 = argv[6] as *u8
      let note: *u8 = argv[7] as *u8
      let rc: i64 = al_append(journal, -1, ws, tool, averb, outcome, note)
      if rc==0 { gv_puts("ACTLOG OK ws=" as *u8); gv_puts(ws); gv_puts(" " as *u8); gv_puts(tool); gv_puts(":" as *u8); gv_puts(averb); gv_puts("\n" as *u8); sys_exit(0); return 0 }
      gv_puts("append FAILED\n" as *u8)
      sys_exit(1)
      return 1
  }
  if al_lit_eq(verb,0,vl,"mine" as *u8)==1 {
      let q: *u8 = sys_mmap(AL_WIN)
      let rcap: i64 = AL_WIN - 8
      let n: i64 = al_read(journal,q,rcap)
      let cx: *i64 = sys_mmap(64) as *i64
      cx[0]=n
      cx[1]=sys_now_realtime_sec()
      cx[2]=0
      cx[3]=0
      cx[4]=0
      if n >= rcap { cx[4]=1 }
      cx[5]=journal as i64
      var minsup: i64 = AL_MINSUP_DEF
      if argc >= 4 { let mz: i64 = al_atoi_z(argv[3] as *u8); if mz > 0 { minsup = mz } }
      var maxgap: i64 = 0
      if argc >= 5 { let gz: i64 = al_atoi_z(argv[4] as *u8); if gz > 0 { maxgap = gz } }
      if maxgap > AL_IX_MAXGAP { maxgap = AL_IX_MAXGAP }
      var closed: i64 = 0
      if argc >= 6 { let cz: i64 = al_atoi_z(argv[5] as *u8); if cz > 0 { closed = 1 } }
      let d: *u8 = sys_mmap(AL_OUT)
      let dl: i64 = al_mine_fast(q,cx,minsup,maxgap,closed,d)
      sys_write(1,d,dl)
      sys_exit(0)
      return 0
  }
  if al_lit_eq(verb,0,vl,"freq" as *u8)==1 {
      let q: *u8 = sys_mmap(AL_WIN)
      let rcap: i64 = AL_WIN - 8
      let n: i64 = al_read(journal,q,rcap)
      let cx: *i64 = sys_mmap(64) as *i64
      cx[0]=n
      cx[1]=0
      cx[2]=0
      cx[3]=0
      cx[4]=0
      if n >= rcap { cx[4]=1 }
      cx[5]=journal as i64
      let d: *u8 = sys_mmap(AL_OUT)
      let dl: i64 = al_freq_fast(q,cx,d)
      sys_write(1,d,dl)
      sys_exit(0)
      return 0
  }
  if al_lit_eq(verb,0,vl,"harden" as *u8)==1 {
      let q: *u8 = sys_mmap(AL_WIN)
      let rcap: i64 = AL_WIN - 8
      let n: i64 = al_read(journal,q,rcap)
      let cx: *i64 = sys_mmap(64) as *i64
      cx[0]=n
      cx[1]=0
      cx[2]=0
      cx[3]=0
      cx[4]=0
      if n >= rcap { cx[4]=1 }
      cx[5]=journal as i64
      var minsup: i64 = AL_MINSUP_DEF
      if argc >= 4 { let mz: i64 = al_atoi_z(argv[3] as *u8); if mz > 0 { minsup = mz } }
      let filer: *u8 = sys_mmap(128)
      var fo2: i64 = 0
      if argc >= 5 { fo2 = al_cat(filer,0,argv[4] as *u8) } else { fo2 = al_cat(filer,0,"nx_debt" as *u8) }
      filer[fo2]=0 as u8
      let d: *u8 = sys_mmap(AL_OUT)
      let dl: i64 = al_harden_json(q,cx,minsup,AL_HARDEN_SEV,filer,d)
      sys_write(1,d,dl)
      sys_exit(0)
      return 0
  }
  if al_lit_eq(verb,0,vl,"bench" as *u8)==1 {
      let rb: i64 = al_bench(journal)
      sys_exit(rb)
      return rb
  }
  gv_puts("unknown verb\n" as *u8)
  sys_exit(2)
  return 2
1334}
nx_actlog.nx source

`nx_actlog.nx` source
