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

↩ module page · 278 lines · 10050 B
1// nx_gate_loop.nx -- TEAM-OWNED loop daemon that runs nx_gate_sentinel on a
2// cadence (GAME arc step G5: "wire the sentinel into the loop cadence so
3// grades refresh with no human/LLM trigger").  Closes the loop-monitor
4// lesson from [[project-self-running-loop-governed-ingest-2026-06-05]]: a
5// loop must have a MONITORED OUTPUT CHANNEL -- every beat appends one line
6// to /tmp/nishi_game_gate_loop.log, and the sentinel itself escalates
7// regressions to the PM review log, so a DRY or STALLED loop is visible in
8// the logs, not silent.
9//
10// Usage (from nxc2 repo root):
11//   nx_gate_loop.elf                      # production: 30-min beat, forever, daemonized
12//   nx_gate_loop.elf <beat_ms>            # custom beat, forever, daemonized
13//   nx_gate_loop.elf <beat_ms> <n_beats>  # TEST MODE: n beats, FOREGROUND (no daemonize)
14// Daemonized = fork + setsid; the launcher returns immediately and the loop
15// survives the launching terminal (pattern from the sites-daemon arc).
16//
17// license_tier: ORIGINAL
18import "nx_syscalls.nx"
19
20const GL_DEFAULT_BEAT_MS: i64 = 1800000   // 30 min
21const GL_LOG: i64 = 0
22
23func gl_cat(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 } return off + i }
24func gl_cat_n(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64 = off
  var m: i64 = v
  if m < 0 { dst[o] = 45; o = o + 1; m = 0 - m }
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48; k = 1 }
  while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { dst[o+i] = t[k-1-i]; i = i + 1 }
  return o + k
35}
36
37// parse a decimal arg; -1 if absent/garbage
38func gl_atoi(s: *u8) -> i64 {
  if s == (0 as *u8) { return 0 - 1 }
  var v: i64 = 0
  var any: i64 = 0
  var i: i64 = 0
  while s[i] != (0 as u8) {
      let c: i64 = s[i] as i64
      if c < 48 { return 0 - 1 }
      if c > 57 { return 0 - 1 }
      v = v * 10 + (c - 48)
      any = 1
      i = i + 1
  }
  if any == 0 { return 0 - 1 }
  return v
53}
54
55// ---- singleton guard -------------------------------------------------
56// Two loop instances would run two gates CONCURRENTLY, and the gate's
57// /tmp/<module>.gg.s artifacts are shared paths -> corrupted builds ->
58// spurious REGRESSION beats (observed live on first deploy 2026-06-09:
59// the build-runner's argless run daemonized an instance, then test mode
60// raced it; one beat reported a phantom regression).  Pidfile + /proc
61// aliveness check; stale pidfile (dead pid) is reclaimed.
62
63// getpid WITHOUT the syscall table: __syscall(172 rv64-getpid) returned
64// -ENOSYS live 2026-06-09 -- the rv64->x86 translation table doesn't cover
65// 172, so x86 received 172=iopl.  /proc/self/stat's first field is the pid
66// and depends on no table.  (Translation-table gap flagged in the PM log.)
67func gl_getpid() -> i64 {
  let len_p: *i64 = sys_mmap(8) as *i64
  let buf: *u8 = sys_read_file("/proc/self/stat" as *u8, len_p)
  if (buf as i64) == 0 { return 0 - 1 }
  let n: i64 = len_p[0]
  var v: i64 = 0
  var any: i64 = 0
  var i: i64 = 0
  while i < n {
      let c: i64 = buf[i] as i64
      if c >= 48 {
          if c <= 57 { v = v * 10 + (c - 48); any = 1; i = i + 1; continue }
      }
      if any == 1 { i = n }
      if any == 0 { i = i + 1 }
  }
  if any == 0 { return 0 - 1 }
  return v
85}
86
87// is pid alive?  openat /proc/<pid>/comm succeeds only for live processes.
88func gl_pid_alive(pid: i64) -> i64 {
  if pid <= 0 { return 0 }
  let p: *u8 = sys_mmap(64)
  var o: i64 = 0
  o = gl_cat(p, o, "/proc/" as *u8)
  o = gl_cat_n(p, o, pid)
  o = gl_cat(p, o, "/comm" as *u8)
  p[o] = 0 as u8
  let fd: i64 = sys_openat_rd(p)
  if fd < 0 { return 0 }
  sys_close(fd)
  return 1
100}
101
102func gl_read_pidfile(path: *u8) -> i64 {
  let len_p: *i64 = sys_mmap(8) as *i64
  let buf: *u8 = sys_read_file(path, len_p)
  if (buf as i64) == 0 { return 0 - 1 }
  let n: i64 = len_p[0]
  var v: i64 = 0
  var any: i64 = 0
  var i: i64 = 0
  while i < n {
      let c: i64 = buf[i] as i64
      if c >= 48 { if c <= 57 { v = v * 10 + (c - 48); any = 1 } }
      i = i + 1
  }
  if any == 0 { return 0 - 1 }
  return v
117}
118
119// returns 1 if we acquired the lock (pidfile written with our pid), 0 if
120// another live instance holds it.
121func gl_acquire_lock() -> i64 {
  let path: *u8 = "/tmp/nishi_game_gate_loop.pid" as *u8
  let other: i64 = gl_read_pidfile(path)
  if other > 0 {
      if gl_pid_alive(other) == 1 { return 0 }
  }
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 }
  let buf: *u8 = sys_mmap(32)
  var o: i64 = gl_cat_n(buf, 0, gl_getpid())
  buf[o] = 0x0A as u8
  sys_write(fd, buf, o + 1)
  sys_close(fd)
  return 1
135}
136
137// run the sentinel once; returns its exit, or 128+sig
138func gl_run_sentinel() -> i64 {
  let path: *u8 = "/tmp/nx_gate_sentinel.sov.elf" as *u8
  let pid: i64 = sys_fork()
  if pid == 0 {
      let devnull: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
      if devnull >= 0 { sys_dup3(devnull, 1, 0) }
      let argv: *i64 = sys_mmap(32) as *i64
      argv[0] = path as i64; argv[1] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64; envp[1] = 0
      sys_execve(path, argv, envp); sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  let sig: i64 = st[0] & 0x7f
  if sig != 0 { return 128 + sig }
  return (st[0] >> 8) & 0xff
155}
156
157func gl_beat_line(beat: i64, rc: i64) -> i64 {
  let fd: i64 = sys_openat_append("/tmp/nishi_game_gate_loop.log" as *u8, 0x1a4)
  if fd < 0 { return 0 - 1 }
  let line: *u8 = sys_mmap(256)
  var o: i64 = 0
  o = gl_cat(line, o, "GATELOOP ts=" as *u8)
  o = gl_cat_n(line, o, sys_now_realtime_sec())
  o = gl_cat(line, o, " beat=" as *u8)
  o = gl_cat_n(line, o, beat)
  o = gl_cat(line, o, " sentinel-exit=" as *u8)
  o = gl_cat_n(line, o, rc)
  o = gl_cat(line, o, " (0=steady-or-better 1=REGRESSION 2=gate-crashed)" as *u8)
  o = gl_cat(line, o, "\n" as *u8)
  sys_write(fd, line, o)
  sys_close(fd)
  return 0
173}
174
175// run the user-journey gate (live-site visitor mimicry) once; best-effort --
176// a missing binary must not break the loop.  Its JOURNEY lines land in
177// /tmp/nishi_user_journey.log.
178func gl_run_journey() -> i64 {
  let path: *u8 = "/tmp/nx_user_journey.sov.elf" as *u8
  let chk: i64 = sys_openat_rd(path)
  if chk < 0 { return 0 - 1 }
  sys_close(chk)
  let pid: i64 = sys_fork()
  if pid == 0 {
      let devnull: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
      if devnull >= 0 { sys_dup3(devnull, 1, 0) }
      let argv: *i64 = sys_mmap(32) as *i64
      argv[0] = path as i64; argv[1] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64; envp[1] = 0
      sys_execve(path, argv, envp); sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  let sig: i64 = st[0] & 0x7f
  if sig != 0 { return 128 + sig }
  return (st[0] >> 8) & 0xff
198}
199
200func gl_loop(beat_ms: i64, n_beats: i64) -> i64 {
  var beat: i64 = 1
  var go: i64 = 1
  while go == 1 {
      let rc: i64 = gl_run_sentinel()
      gl_beat_line(beat, rc)
      // live-site visitor journey each beat (polite: ~7 requests / 30 min)
      let jrc: i64 = gl_run_journey()
      let jfd: i64 = sys_openat_append("/tmp/nishi_game_gate_loop.log" as *u8, 0x1a4)
      if jfd >= 0 {
          let jl: *u8 = sys_mmap(128)
          var jo: i64 = 0
          jo = gl_cat(jl, jo, "GATELOOP journey-exit=" as *u8)
          jo = gl_cat_n(jl, jo, jrc)
          jo = gl_cat(jl, jo, "\n" as *u8)
          sys_write(jfd, jl, jo)
          sys_close(jfd)
      }
      if n_beats > 0 { if beat >= n_beats { go = 0 } }
      if go == 1 {
          sys_sleep_ms(beat_ms)
          beat = beat + 1
      }
  }
  return 0
225}
226
227func main(argc: i64, argv: *i64) -> i64 {
  var beat_ms: i64 = GL_DEFAULT_BEAT_MS
  var n_beats: i64 = 0
  if argc >= 2 { let b: i64 = gl_atoi(argv[1] as *u8); if b > 0 { beat_ms = b } }
  if argc >= 3 { let n: i64 = gl_atoi(argv[2] as *u8); if n > 0 { n_beats = n } }
232
  // TEST MODE (bounded beats): run in the foreground so the harness can wait.
  // Still takes the singleton lock -- a test run racing the production
  // daemon corrupts shared gate artifacts just the same.
  if n_beats > 0 {
      if gl_acquire_lock() == 0 {
          sys_write(1, "GATELOOP another instance is live (pidfile); refusing\n" as *u8, 54)
          return 3
      }
      gl_loop(beat_ms, n_beats)
      return 0
  }
244
  // PRODUCTION: daemonize (fork; parent exits; child setsid + detach stdio)
  // -- the sites-daemon pattern: the launcher returns immediately and the
  // loop survives the launching terminal.
  if gl_read_pidfile("/tmp/nishi_game_gate_loop.pid" as *u8) > 0 {
      if gl_pid_alive(gl_read_pidfile("/tmp/nishi_game_gate_loop.pid" as *u8)) == 1 {
          sys_write(1, "GATELOOP another instance is live (pidfile); refusing\n" as *u8, 54)
          return 3
      }
  }
  let pid: i64 = sys_fork()
  if pid != 0 {
      // parent: report the daemon pid and exit
      let line: *u8 = sys_mmap(128)
      var o: i64 = 0
      o = gl_cat(line, o, "GATELOOP daemonized pid=" as *u8)
      o = gl_cat_n(line, o, pid)
      o = gl_cat(line, o, " beat_ms=" as *u8)
      o = gl_cat_n(line, o, beat_ms)
      o = gl_cat(line, o, "\n" as *u8)
      sys_write(1, line, o)
      return 0
  }
  nx_setsid()
  // lock is taken by the DAEMON child (its own pid), after setsid
  if gl_acquire_lock() == 0 { return 3 }
  let devnull: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
  if devnull >= 0 {
      sys_dup3(devnull, 0, 0)
      sys_dup3(devnull, 1, 0)
      sys_dup3(devnull, 2, 0)
  }
  gl_loop(beat_ms, 0)
  return 0
278}
nx_gate_loop.nx source

`nx_gate_loop.nx` source
