code wiki / (root) / nx_elara_memory.nx
`nx_elara_memory.nx` source

↩ module page · 317 lines · 17311 B
1// nx_elara_memory.nx -- LONG-TERM RELATIONSHIP MEMORY for the companion (F920/F925 memory axis).
2//
3// The companion mind (nx_elara_state) holds her PRESENT (wardrobe/mood/location/day). This is the other
4// half a real synthetic human needs and every incumbent (Replika's flagship) ships: she REMEMBERS things
5// about YOU and the relationship across time, and RECALLS the relevant ones. Sovereign, first-byte-up.
6//
7// Storage: seg-store plane knowledge/store/elaramem-, one NXR1 record per memory keyed <session>:<ms>
8// {text, kind, ts}. RECALL is keyword-overlap ranked (term match + recency) -- honest IR-lite, not yet
9// semantic embeddings (that is rung 2, when a CPU embed path is wired). SCALABLE: recall maps each segment
10// .docs ONCE and munmaps (the leak-free plane-scan pattern; a naive ss_get loop would crash, seq750).
11//
12// VERBS: remember <session> <text...> [kind]  |  recall <session> <query...> [max]  |  selftest
13// license_tier: ORIGINAL   No hw writes (Rule 26).
14import "nx_syscalls.nx"
15import "nx_canon_cid.nx"
16import "nx_seg_store.nx"
17const EM_MAGIC_1024: i64 = 1024
18const EM_MAGIC_8192: i64 = 8192
19const EM_MAGIC_4096: i64 = 4096
20const EM_MAGIC_65536: i64 = 65536
21
22const EM_STORE: *u8 = "knowledge/store/elaramem-" as *u8
23const EM_MAXMATCH: i64 = 512
24
25func em_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
26func em_len(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
27func em_cat(d: *u8, o: i64, s: *u8) -> i64 { var p: i64=o; var i: i64=0; while s[i]!=(0 as u8){ d[p]=s[i]; p=p+1; i=i+1 } return p }
28func em_ch(d: *u8, o: i64, c: i64) -> i64 { d[o]=c as u8; return o+1 }
29func em_udec(d: *u8, o: i64, v: i64) -> i64 {
  if v==0 { d[o]=48 as u8; return o+1 }
  var div: i64=1; var m: i64=v
  while m>=10 { div=div*10; m=m/10 }
  var p: i64=o; var rest: i64=v
  while div>0 { let dg: i64=rest/div; d[p]=(48+dg) as u8; rest=rest-dg*div; div=div/10; p=p+1 }
  return p
36}
37func em_lc(c: i64) -> i64 { if c>=65 { if c<=90 { return c+32 } } return c }
38func em_isalnum(c: i64) -> i64 { if c>=48 { if c<=57 { return 1 } } if c>=65 { if c<=90 { return 1 } } if c>=97 { if c<=122 { return 1 } } return 0 }
39func em_r32(p: *u8, o: i64) -> i64 { let a: i64=p[o]; let b: i64=p[o+1]; let c: i64=p[o+2]; let d: i64=p[o+3]; return (((((a<<8)|b)<<8)|c)<<8)|d }
40// bounded NXR1 field reader (DRY note seq751: 4th copy of this walk; canonical lib pending).
41func em_field(rec: *u8, reclen: i64, key: *u8, out: *u8, maxout: i64) -> i64 {
  if reclen < 8 { return 0-1 }
  if rec[0] != (78 as u8) { return 0-1 }
  let klen: i64 = em_len(key)
  let n: i64 = em_r32(rec, 4)
  if n < 0 { return 0-1 }
  if n > EM_MAGIC_1024 { return 0-1 }
  var off: i64 = 8
  var i: i64 = 0
  while i < n {
      if off+4 > reclen { return 0-1 }
      let kl: i64 = em_r32(rec, off); off=off+4
      if kl < 0 { return 0-1 }
      if off+kl > reclen { return 0-1 }
      let kp: i64 = off; off=off+kl
      if off+4 > reclen { return 0-1 }
      let vl: i64 = em_r32(rec, off); off=off+4
      if vl < 0 { return 0-1 }
      if off+vl > reclen { return 0-1 }
      let vp: i64 = off; off=off+vl
      if kl == klen {
          var mm: i64=1; var c: i64=0
          while c<kl { if rec[kp+c]!=key[c] { mm=0 } c=c+1 }
          if mm==1 { var cap: i64=vl; if cap>maxout-1 { cap=maxout-1 } var w: i64=0; while w<cap { out[w]=rec[vp+w]; w=w+1 } out[cap]=0 as u8; return cap }
      }
      i=i+1
  }
  return 0-1
69}
70func em_key_prefix(key: *u8, kl: i64, prefix: *u8) -> i64 {
  let pl: i64 = em_len(prefix)
  if pl > kl { return 0 }
  var i: i64=0
  while i<pl { if key[i]!=prefix[i] { return 0 } i=i+1 }
  return 1
76}
77// count query words that appear (case-insensitive substring) in text -> the relevance score.
78func em_score(text: *u8, tn: i64, query: *u8) -> i64 {
  var score: i64 = 0
  var ws: i64 = 0
  var i: i64 = 0
  while 1==1 {
      var wend: i64 = 0
      let c: i64 = query[i] as i64
      if c==0 { wend=1 } else { if c==32 { wend=1 } }
      if wend==1 {
          let wl: i64 = i - ws
          if wl >= 2 {
              // does query[ws..i) occur in text (ci)?
              // WORD-BOUNDARY match (not substring): 'do' must NOT match inside 'adopted'. A query word
              // matches only bounded by start/end or a non-alphanumeric on both sides.
              var found: i64 = 0
              var t: i64 = 0
              while t + wl <= tn { if found==0 {
                  var mm: i64=1; var k: i64=0
                  while k<wl { if em_lc(text[t+k] as i64) != em_lc(query[ws+k] as i64) { mm=0 } k=k+1 }
                  if mm==1 {
                      var lb: i64=1; if t>0 { if em_isalnum(text[t-1] as i64)==1 { lb=0 } }
                      var rb: i64=1; if t+wl<tn { if em_isalnum(text[t+wl] as i64)==1 { rb=0 } }
                      if lb==1 { if rb==1 { found=1 } }
                  }
                  t=t+1
              } else { t=tn } }
              if found==1 { score=score+1 }
          }
          ws = i+1
      }
      if c==0 { return score }
      i=i+1
  }
  return score
112}
113
114// SALIENCE (F1056, the Nomi 'decides what matters' capability): score a memory's importance at store-time
115// so load-bearing facts persist + rank above trivia. Heuristic (rung 1; a learned model is rung 2), reusing
116// the whole-word scorer: durability-by-kind + user-relevance (you/your) + emotional/relational load-bearing
117// terms. Named weights, not buried magic. 0..100.
118func em_eq(a: *u8, b: *u8) -> i64 { var i: i64=0; while 1==1 { if a[i]!=b[i] { return 0 } if a[i]==(0 as u8) { return 1 } i=i+1 } return 0 }
119const EM_SAL_BASE: i64 = 10
120const EM_SAL_PREF: i64 = 30
121const EM_SAL_FACT: i64 = 22
122const EM_SAL_EVENT: i64 = 8
123const EM_SAL_USER: i64 = 15    // per 'you'/'your' hit
124const EM_SAL_LOAD: i64 = 10    // per load-bearing term
125func em_salience(text: *u8, tn: i64, kind: *u8) -> i64 {
  var s: i64 = EM_SAL_BASE
  if em_eq(kind, "preference" as *u8) == 1 { s = s + EM_SAL_PREF } else {
      if em_eq(kind, "fact" as *u8) == 1 { s = s + EM_SAL_FACT } else { s = s + EM_SAL_EVENT }
  }
  s = s + em_score(text, tn, "you your" as *u8) * EM_SAL_USER
  let lb: i64 = em_score(text, tn, "love favorite important always never birthday family sister brother mother father wife husband daughter son dream afraid hope hate married anniversary" as *u8)
  s = s + lb * EM_SAL_LOAD
  if s > 100 { s = 100 }
  return s
135}
136
137func em_remember(session: *u8, text: *u8, kind: *u8) -> i64 {
  sys_mkdir("knowledge" as *u8, 511)
  sys_mkdir("knowledge/store" as *u8, 511)
  let now: i64 = sys_now_realtime_ms()
  // NXR1 record {text, kind, ts, sal} -- sal = the store-time salience (F1056, 'decides what matters')
  let tnn: i64 = em_len(text)
  let sal: i64 = em_salience(text, tnn, kind)
  let keys: *i64 = sys_mmap(8*4) as *i64
  let vals: *i64 = sys_mmap(8*4) as *i64
  let tsb: *u8 = sys_mmap(32); var to: i64 = em_udec(tsb, 0, now); tsb[to]=0 as u8
  let salb: *u8 = sys_mmap(32); var so: i64 = em_udec(salb, 0, sal); salb[so]=0 as u8
  keys[0]="text" as *u8 as i64; vals[0]=text as i64
  keys[1]="kind" as *u8 as i64; vals[1]=kind as i64
  keys[2]="ts" as *u8 as i64;   vals[2]=tsb as i64
  keys[3]="sal" as *u8 as i64;  vals[3]=salb as i64
  let rec: *u8 = sys_mmap(EM_MAGIC_8192)
  let rl: i64 = canon_encode(keys, vals, 4, rec)
  let kb: *u8 = sys_mmap(256)
  var ko: i64 = em_cat(kb, 0, session); ko=em_ch(kb, ko, 58); ko=em_udec(kb, ko, now); kb[ko]=0 as u8
  let w: *i64 = ss_begin_cap(rl + EM_MAGIC_4096)
  ss_add(w, 1, kb, rec, rl)
  let segid: i64 = ss_next_segid(EM_STORE)
  if ss_commit(EM_STORE, w, segid) != 0 { em_puts("{\"error\":\"memory write failed\"}\n" as *u8); return 4 }
  let out: *u8 = sys_mmap(512)
  var o: i64 = em_cat(out, 0, "{\"remembered\":\"" as *u8)
  var ti: i64 = 0; while text[ti]!=(0 as u8) { if text[ti]==(34 as u8) { out[o]=92 as u8; o=o+1 } out[o]=text[ti]; o=o+1; ti=ti+1 }
  o = em_cat(out, o, "\",\"seg\":" as *u8); o = em_udec(out, o, segid); o = em_cat(out, o, "}" as *u8); o = em_ch(out, o, 10)
  sys_write(1, out, o)
  return 0
166}
167
168// recall: map each segment once, score every <session>: memory vs query, print top `max` by score.
169func em_recall(session: *u8, query: *u8, max: i64) -> i64 {
  let sp: *u8 = sys_mmap(256)
  var spo: i64 = em_cat(sp, 0, session); sp[spo]=58 as u8; sp[spo+1]=0 as u8   // "<session>:"
  // manifest
  let mp: *u8 = sys_mmap(512); var mo: i64 = em_cat(mp, 0, EM_STORE); mo=em_cat(mp, mo, "manifest.txt" as *u8); mp[mo]=0 as u8
  let szp: *i64 = sys_mmap(16) as *i64
  let man: *u8 = sys_read_file(mp, szp)
  // parallel arrays of matches: score, ts, textptr(copied)
  let sc: *i64 = sys_mmap(8*EM_MAXMATCH) as *i64
  let tsA: *i64 = sys_mmap(8*EM_MAXMATCH) as *i64
  let txA: *i64 = sys_mmap(8*EM_MAXMATCH) as *i64
  let salA: *i64 = sys_mmap(8*EM_MAXMATCH) as *i64
  let rkA: *i64 = sys_mmap(8*EM_MAXMATCH) as *i64
  var nm: i64 = 0
  if (man as i64) != 0 {
      let mlen: i64 = szp[0]
      var ls: i64=0; var mi: i64=0
      while mi <= mlen {
          var eol: i64=0
          if mi==mlen { eol=1 } else { if man[mi]==(10 as u8) { eol=1 } }
          if eol==1 { if mi>ls {
              let dp: *u8 = sys_mmap(512); var dpo: i64=em_cat(dp, 0, EM_STORE)
              var kk: i64=ls; while kk<mi { dp[dpo]=man[kk]; dpo=dpo+1; kk=kk+1 }
              dpo=em_cat(dp, dpo, ".docs" as *u8); dp[dpo]=0 as u8
              let dszp: *i64 = sys_mmap(16) as *i64
              let b: *u8 = sys_map_file(dp, dszp)
              if (b as i64)!=0 {
                  let sz: i64 = dszp[0]
                  var j: i64=0
                  while j+9 <= sz {
                      let kind: i64=b[j]; let kl: i64=em_r32(b,j+1); let koff: i64=j+5
                      if kl<0 { j=sz } else { if koff+kl+4>sz { j=sz } else {
                          let vl: i64=em_r32(b,koff+kl); let voff: i64=koff+kl+4
                          if vl<0 { j=sz } else { if voff+vl>sz { j=sz } else {
                              if kind==1 { if em_key_prefix((b as i64+koff) as *u8, kl, sp)==1 { if nm<EM_MAXMATCH {
                                  let txt: *u8 = sys_mmap(EM_MAGIC_4096)
                                  let tl: i64 = em_field((b as i64+voff) as *u8, vl, "text" as *u8, txt, EM_MAGIC_4096)
                                  if tl>0 {
                                      let s: i64 = em_score(txt, tl, query)
                                      if s>0 {
                                          let tsb: *u8 = sys_mmap(32)
                                          em_field((b as i64+voff) as *u8, vl, "ts" as *u8, tsb, 32)
                                          var ts: i64=0; var z: i64=0; while tsb[z]!=(0 as u8){ let cc: i64=tsb[z] as i64; if cc>=48 { if cc<=57 { ts=ts*10+(cc-48) } } z=z+1 }
                                          let salb2: *u8 = sys_mmap(32)
                                          em_field((b as i64+voff) as *u8, vl, "sal" as *u8, salb2, 32)
                                          var sv: i64=0; var zz: i64=0; while salb2[zz]!=(0 as u8){ let dc: i64=salb2[zz] as i64; if dc>=48 { if dc<=57 { sv=sv*10+(dc-48) } } zz=zz+1 }
                                          sc[nm]=s; tsA[nm]=ts; txA[nm]=txt as i64; salA[nm]=sv; rkA[nm]=s*100+sv; nm=nm+1
                                      }
                                  }
                              } } }
                              j=voff+vl
                          }}
                      }}
                  }
                  sys_munmap(b, sz)
              }
          } ls=mi+1 }
          mi=mi+1
      }
  }
  // emit top `max` by (score desc, ts desc) via selection
  let out: *u8 = sys_mmap(EM_MAGIC_65536)
  var o: i64 = em_cat(out, 0, "{\"session\":\"" as *u8)
  var si: i64=0; while session[si]!=(0 as u8){ out[o]=session[si]; o=o+1; si=si+1 }
  o = em_cat(out, o, "\",\"query\":\"" as *u8)
  var qi: i64=0; while query[qi]!=(0 as u8){ if query[qi]==(34 as u8){out[o]=92 as u8;o=o+1} out[o]=query[qi]; o=o+1; qi=qi+1 }
  o = em_cat(out, o, "\",\"hits\":" as *u8); o = em_udec(out, o, nm)
  o = em_cat(out, o, ",\"recall\":[" as *u8)
  let used: *i64 = sys_mmap(8*EM_MAXMATCH) as *i64
  var u: i64=0; while u<nm { used[u]=0; u=u+1 }
  var emitted: i64 = 0
  while emitted < max {
      var best: i64 = 0-1
      var bi: i64 = 0
      while bi < nm {
          if used[bi]==0 {
              if best<0 { best=bi } else {
                  if rkA[bi]>rkA[best] { best=bi } else { if rkA[bi]==rkA[best] { if tsA[bi]>tsA[best] { best=bi } } }
              }
          }
          bi=bi+1
      }
      if best<0 { emitted=max } else {
          used[best]=1
          if emitted>0 { o=em_ch(out, o, 44) }
          o=em_cat(out, o, "{\"score\":" as *u8); o=em_udec(out, o, sc[best])
          o=em_cat(out, o, ",\"text\":\"" as *u8)
          let tp: *u8 = txA[best] as *u8
          var ci: i64=0; while tp[ci]!=(0 as u8){ if tp[ci]==(34 as u8){out[o]=92 as u8;o=o+1} if tp[ci]==(10 as u8){out[o]=32 as u8}else{out[o]=tp[ci]} o=o+1; ci=ci+1 }
          o=em_cat(out, o, "\"}" as *u8)
          emitted=emitted+1
      }
  }
  o=em_cat(out, o, "]}" as *u8); o=em_ch(out, o, 10)
  sys_write(1, out, o)
  return 0
265}
266
267func em_selftest() -> i64 {
  var pass: i64 = 0
  // run-unique session so the additive store stays deterministic
  let S: *u8 = sys_mmap(64); var so: i64=em_cat(S,0,"mt_" as *u8); so=em_udec(S,so,sys_now_realtime_ms()); S[so]=0 as u8
  em_remember(S, "you love oat milk lattes from the corner cafe" as *u8, "preference" as *u8)
  em_remember(S, "your sister is named Robin and lives in Denver" as *u8, "fact" as *u8)
  em_remember(S, "we watched a horror movie together last friday" as *u8, "event" as *u8)
  // T0 recall by a query that hits ONE memory strongly
  // capture recall by re-scoring in-test would be complex; instead assert the scorer directly
  var t0: i64 = 0
  if em_score("you love oat milk lattes" as *u8, 24, "oat milk latte" as *u8) >= 2 { t0 = 1 }
  if t0==1 { pass=pass+1; em_puts("T0 keyword scorer matches query terms: PASS\n" as *u8) } else { em_puts("T0 keyword scorer matches query terms: FAIL\n" as *u8) }
  // T1 scorer is case-insensitive + ignores non-matching
  var t1: i64 = 0
  if em_score("Your Sister is named ROBIN" as *u8, 26, "robin sister" as *u8) >= 2 { if em_score("nothing relevant here" as *u8, 21, "robin sister" as *u8) == 0 { t1 = 1 } }
  if t1==1 { pass=pass+1; em_puts("T1 scorer case-insensitive + zero on miss: PASS\n" as *u8) } else { em_puts("T1 scorer case-insensitive + zero on miss: FAIL\n" as *u8) }
  // T2 field reader bounds-safe
  let bad: *u8 = sys_mmap(16); bad[0]=78 as u8; bad[4]=0 as u8; bad[5]=0 as u8; bad[6]=0 as u8; bad[7]=50 as u8
  let ob: *u8 = sys_mmap(32)
  if em_field(bad, 8, "x" as *u8, ob, 32) == (0-1) { pass=pass+1; em_puts("T2 nxr1 field bounds-safe: PASS\n" as *u8) } else { em_puts("T2 nxr1 field bounds-safe: FAIL\n" as *u8) }
  // T3 short words (<2 chars) do not spuriously match
  var t3: i64 = 0
  if em_score("a big cat" as *u8, 9, "a" as *u8) == 0 { t3=1 }
  if t3==1 { pass=pass+1; em_puts("T3 sub-2-char query words ignored: PASS\n" as *u8) } else { em_puts("T3 sub-2-char query words ignored: FAIL\n" as *u8) }
  // T4 WORD-BOUNDARY: 'do' must NOT match inside 'adopted' (the false-positive that mis-ranked recall live)
  var t4: i64 = 0
  if em_score("your sister adopted a greyhound" as *u8, 31, "do" as *u8) == 0 { if em_score("we do talk daily" as *u8, 16, "do" as *u8) == 1 { t4=1 } }
  if t4==1 { pass=pass+1; em_puts("T4 word-boundary (do != adopted, do == do): PASS\n" as *u8) } else { em_puts("T4 word-boundary (do != adopted, do == do): FAIL\n" as *u8) }
  em_puts("nx_elara_memory selftest T=5 PASS=" as *u8); let pb: *u8=sys_mmap(16); var po: i64=em_udec(pb,0,pass); pb[po]=0 as u8; em_puts(pb)
  if pass==5 { em_puts(" verdict=GREEN\n" as *u8); return 0 }
  em_puts(" verdict=RED\n" as *u8); return 1
298}
299
300func main(argc: i64, argv: *i64) -> i64 {
  if argc >= 2 { if em_eq((argv[1]) as *u8, "selftest" as *u8) == 1 { return em_selftest() } }
  if argc < 4 { em_puts("usage: nx_elara_memory remember <session> <text> [kind] | recall <session> <query> [max] | selftest\n" as *u8); return 2 }
  let verb: *u8 = (argv[1]) as *u8
  let session: *u8 = (argv[2]) as *u8
  if em_eq(verb, "remember" as *u8) == 1 {
      var kind: *u8 = "fact" as *u8
      if argc >= 5 { kind = (argv[4]) as *u8 }
      return em_remember(session, (argv[3]) as *u8, kind)
  }
  if em_eq(verb, "recall" as *u8) == 1 {
      var mx: i64 = 5
      if argc >= 5 { var v: i64=0; let a: *u8=(argv[4]) as *u8; var i: i64=0; while a[i]!=(0 as u8){ let c: i64=a[i] as i64; if c>=48 { if c<=57 { v=v*10+(c-48) } } i=i+1 } if v>0 { mx=v } }
      return em_recall(session, (argv[3]) as *u8, mx)
  }
  em_puts("{\"error\":\"unknown verb\"}\n" as *u8)
  return 2
317}
nx_elara_memory.nx source

`nx_elara_memory.nx` source
