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

↩ module page · 334 lines · 15299 B
1// nx_worldgen_refine.nx -- TEAM-OWNED worldgen quality gate + AUTO-REFINE
2// loop (operator 2026-06-10: "s class exceed instead of our crummy proc gen
3// -- build the team to do the work"; operator 2026-05-16: "build an iterative
4// loop ... i dont want to have to manually check if you generate good maps").
5//
6// The loop nobody has to babysit:
7//   nx_procgen_landscape(seed, preset, w, h, density)   -- current generator
8//     -> nx_world_quality_grade (8 axes, Q14, sealed F..S, refine_axis)
9//     -> hill-climb the exposed knobs (preset x density x seed batch)
10//     -> bank the BEST params to /tmp/nishi_worldgen_best.conf (data-driven;
11//        the voxel build reads params, never hardcodes them -- Cardinal 11)
12//
13// HONEST BASELINE FIRST: the first sweep grades the CURRENT generator as-is.
14// "Crummy" becomes a NUMBER with named failing axes; every later rung
15// (composed primitives: causal rivers, erosion, constraint placement per
16// the procgen cardinals) must MOVE that number through this same gate.
17// Note the grader's own posture: Minecraft/No-Man's-Sky/Houdini have NO
18// mathematical world-quality verdict -- this instrument is itself the
19// EXCEED axis; S-class = the generator earns NX_GRADE_S under it.
20//
21// WORLDGEN lines -> stdout + /tmp/nishi_worldgen_gate.log.
22// Exit: 0 if best grade >= floor (argv[1], default C=2), else 1.
23// license_tier: ORIGINAL
24import "nx_syscalls.nx"
25import "nx_tier.nx"
26import "nx_worldgen_tunelib.nx"
27const WR_MAGIC_8192: i64 = 8192
28const WR_MAGIC_8191: i64 = 8191
29
30const WR_W: i64 = 64
31const WR_H: i64 = 64
32const WR_RELIEF: i64 = 1024          // Q10 full-scale elevation
33const WR_SEEDS_PER_CFG: i64 = 3      // median-ish stability without burning cycles
34const WR_DENSITY_STEPS: i64 = 4      // density_q10 in {512, 1024, 1536, 2048}
35
36func wr_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
37func wr_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 }
38func wr_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
49}
50
51func wr_grade_name(g: i64) -> *u8 {
  if g == NX_GRADE_F { return "F" as *u8 }
  if g == NX_GRADE_D { return "D" as *u8 }
  if g == NX_GRADE_C { return "C" as *u8 }
  if g == NX_GRADE_B { return "B" as *u8 }
  if g == NX_GRADE_A { return "A" as *u8 }
  if g == NX_GRADE_S { return "S" as *u8 }
  return "?" as *u8
59}
60
61func wr_refine_name(r: i64) -> *u8 {
  if r == NX_WQG_REFINE_NONE          { return "NONE" as *u8 }
  if r == NX_WQG_REFINE_MORE_RELIEF   { return "MORE_RELIEF" as *u8 }
  if r == NX_WQG_REFINE_MORE_FEATURES { return "MORE_FEATURES" as *u8 }
  if r == NX_WQG_REFINE_LESS_FLATNESS { return "LESS_FLATNESS" as *u8 }
  if r == NX_WQG_REFINE_ADD_DETAIL    { return "ADD_DETAIL" as *u8 }
  if r == NX_WQG_REFINE_SMOOTH_NOISE  { return "SMOOTH_NOISE" as *u8 }
  if r == NX_WQG_REFINE_FIX_FRACTAL   { return "FIX_FRACTAL" as *u8 }
  if r == NX_WQG_REFINE_FIX_BIOMES    { return "FIX_BIOMES" as *u8 }
  if r == NX_WQG_REFINE_MORE_VARIETY  { return "MORE_VARIETY" as *u8 }
  if r == NX_WQG_REFINE_IMPROVE_READ  { return "IMPROVE_READ" as *u8 }
  return "?" as *u8
73}
74
75// grade ONE config (preset, density) over WR_SEEDS_PER_CFG seeds; returns the
76// WORST grade across seeds (a preset must be reliably good, not lucky) and
77// copies the worst-seed verdict into out12.
78func wr_eval_cfg(preset: i64, density_q10: i64, out12: *i64) -> i64 {
  // The eval body lives in nx_worldgen_tunelib (tl_compose_world =
  // P1 signature + P4 water + detail, knob-explicit; tl_eval feeds the
  // P2 biome + P3 feature axes).  Knobs come from the TUNER's banked
  // conf (config hierarchy: banked > preset table), so the gate metric
  // IS the tuned metric -- the tuner's win shows up here next beat.
  let knobs: *i64 = sys_mmap(TL_K_COUNT * 8) as *i64
  tl_load_knobs("knowledge/status/worldgen_knobs.conf" as *u8, preset, knobs)
  return tl_eval(preset, density_q10, knobs, out12)
87}
88
89func wr_report(logfd: i64, ts: i64, preset: i64, density: i64, out12: *i64) -> i64 {
  let line: *u8 = sys_mmap(512)
  var o: i64 = 0
  o = wr_cat(line, o, "WORLDGEN ts=" as *u8)
  o = wr_cat_n(line, o, ts)
  o = wr_cat(line, o, " preset=" as *u8)
  o = wr_cat_n(line, o, preset)
  o = wr_cat(line, o, " density=" as *u8)
  o = wr_cat_n(line, o, density)
  o = wr_cat(line, o, " grade=" as *u8)
  o = wr_cat(line, o, wr_grade_name(out12[0]))
  o = wr_cat(line, o, " div=" as *u8);   o = wr_cat_n(line, o, out12[1])
  o = wr_cat(line, o, " var=" as *u8);   o = wr_cat_n(line, o, out12[2])
  o = wr_cat(line, o, " ext=" as *u8);   o = wr_cat_n(line, o, out12[3])
  o = wr_cat(line, o, " flat=" as *u8);  o = wr_cat_n(line, o, out12[4])
  o = wr_cat(line, o, " frac=" as *u8);  o = wr_cat_n(line, o, out12[5])
  o = wr_cat(line, o, " biome=" as *u8); o = wr_cat_n(line, o, out12[6])
  o = wr_cat(line, o, " feat=" as *u8);  o = wr_cat_n(line, o, out12[7])
  o = wr_cat(line, o, " read=" as *u8);  o = wr_cat_n(line, o, out12[8])
  o = wr_cat(line, o, " refine=" as *u8)
  o = wr_cat(line, o, wr_refine_name(out12[9]))
  o = wr_cat(line, o, "\n" as *u8)
  sys_write(1, line, o)
  if logfd >= 0 { sys_write(logfd, line, o) }
  return 0
114}
115
116// OSCILLATION DETECTOR (2026-06-10): the verdict loop's own callout
117// handler.  Each verdict CHANGE appends its axis to a durable history;
118// when the newest axis equals the one before last (A -> B -> A) while
119// the grade did not climb, knob-space is provably exhausted between the
120// two axes -- the loop files ONE STRUCTURAL escalation naming both,
121// instead of re-filing the same two assignments forever (the ext/read
122// ping-pong at grade C that motivated this).
123func wr_oscillation_check(ts: i64, grade: i64, axis: i64) -> i64 {
  let hist: *u8 = "knowledge/status/worldgen_verdict_hist.log" as *u8
  // append this change: "AXIS <id> GRADE <g>\n" (ids parse back as ints)
  let hfd: i64 = sys_openat_append(hist, 0x1a4)
  if hfd >= 0 {
      let hl: *u8 = sys_mmap(64)
      var ho: i64 = 0
      ho = wr_cat(hl, ho, "AXIS " as *u8)
      ho = wr_cat_n(hl, ho, axis)
      ho = wr_cat(hl, ho, " GRADE " as *u8)
      ho = wr_cat_n(hl, ho, grade)
      ho = wr_cat(hl, ho, "\n" as *u8)
      sys_write(hfd, hl, ho)
      sys_fsync(hfd)
      sys_close(hfd)
  }
  // read back the last 3 entries (axis, grade)
  let buf: *u8 = sys_mmap(WR_MAGIC_8192)
  let n: i64 = tl_read_file(hist, buf, WR_MAGIC_8191)
  if n <= 0 { return 0 }
  let ax: *i64 = sys_mmap(3 * 8) as *i64
  let gr: *i64 = sys_mmap(3 * 8) as *i64
  var cnt: i64 = 0
  var i: i64 = 0
  while i < n {
      var at_start: i64 = 0
      if i == 0 { at_start = 1 }
      if i > 0 { if buf[i - 1] == (10 as u8) { at_start = 1 } }
      if at_start == 1 {
          if buf[i] == (65 as u8) {            // 'A' of AXIS
              var v: i64 = 0
              var j: i64 = i + 5
              while j < n {
                  let c: i64 = buf[j] as i64
                  if c >= 48 { if c <= 57 { v = v * 10 + (c - 48); j = j + 1 } else { j = n + 1 } } else { j = n + 1 }
              }
              // grade after " GRADE "
              var g: i64 = 0 - 1
              var k: i64 = i + 5
              while k < n {
                  if buf[k] == (10 as u8) { k = n + 1 } else {
                      if buf[k] == (71 as u8) {     // 'G'
                          var gv: i64 = 0
                          var m: i64 = k + 6
                          var any: i64 = 0
                          while m < n {
                              let c2: i64 = buf[m] as i64
                              if c2 >= 48 { if c2 <= 57 { gv = gv * 10 + (c2 - 48); any = 1; m = m + 1 } else { m = n + 1 } } else { m = n + 1 }
                          }
                          if any == 1 { g = gv }
                          k = n + 1
                      } else { k = k + 1 }
                  }
              }
              // shift-in (keep last 3)
              if cnt < 3 {
                  ax[cnt] = v; gr[cnt] = g; cnt = cnt + 1
              } else {
                  ax[0] = ax[1]; ax[1] = ax[2]; ax[2] = v
                  gr[0] = gr[1]; gr[1] = gr[2]; gr[2] = g
              }
          }
      }
      i = i + 1
  }
  if cnt < 3 { return 0 }
  // A -> B -> A with no grade climb = structural escalation
  if ax[2] != ax[0] { return 0 }
  if ax[1] == ax[2] { return 0 }
  if gr[2] > gr[0] { return 0 }
  let pfd: i64 = sys_openat_append("knowledge/status/pm_plan_durable.log" as *u8, 0x1a4)
  if pfd >= 0 {
      let row: *u8 = sys_mmap(512)
      var ro: i64 = 0
      ro = wr_cat(row, ro, "arc=PROCGEN step=STRUCTURAL-ESCALATION ts=" as *u8)
      ro = wr_cat_n(row, ro, ts)
      ro = wr_cat(row, ro, " AUTO-FILED by nx_worldgen_refine OSCILLATION DETECTOR: verdict ping-pong " as *u8)
      ro = wr_cat(row, ro, wr_refine_name(ax[0]))
      ro = wr_cat(row, ro, " <-> " as *u8)
      ro = wr_cat(row, ro, wr_refine_name(ax[1]))
      ro = wr_cat(row, ro, " at grade=" as *u8)
      ro = wr_cat(row, ro, wr_grade_name(grade))
      ro = wr_cat(row, ro, " with no grade climb -- KNOB-SPACE EXHAUSTED between these axes; a composed-primitive STRUCTURAL rung is required (tuning cannot close this) owner=Builder\n" as *u8)
      sys_write(pfd, row, ro)
      sys_fsync(pfd)
      sys_close(pfd)
  }
  return 1
211}
212
213func main(argc: i64, argv: *i64) -> i64 {
  // Default floor = the measured 2026-06-10 BASELINE (D): the gate's job in
  // the game-gate is REGRESSION protection (never ship worse than today).
  // The CLIMB target (S, per the PROCGEN arc) lives in the PM plan and is
  // asserted by running this gate with argv[1]=5 at each rung's close.
  var floor_grade: i64 = NX_GRADE_D
  if argc >= 2 {
      let a: *u8 = argv[1] as *u8
      if a[0] >= 48 { if a[0] <= 53 { floor_grade = (a[0] as i64) - 48 } }
  }
  let logfd: i64 = sys_openat_append("/tmp/nishi_worldgen_gate.log" as *u8, 0x1a4)
  let ts: i64 = sys_now_realtime_sec()
225
  let out12: *i64 = sys_mmap(8 * 12) as *i64
  var best_grade: i64 = 0 - 1
  var best_preset: i64 = 0
  var best_density: i64 = 0
  let best12: *i64 = sys_mmap(8 * 12) as *i64
231
  // full sweep: every preset x density step.  This IS the refine loop at
  // Tier-1 (the only knobs the current generator exposes).  When composed
  // primitives land (rivers/erosion/constraints), their knobs join here.
  var preset: i64 = 0
  while preset <= NX_PROCGEN_PRESET_MOUNTAIN {
      var d: i64 = 0
      while d < WR_DENSITY_STEPS {
          let density: i64 = 512 + d * 512
          let g: i64 = wr_eval_cfg(preset, density, out12)
          wr_report(logfd, ts, preset, density, out12)
          if g > best_grade {
              best_grade = g
              best_preset = preset
              best_density = density
              var c: i64 = 0
              while c < 12 { best12[c] = out12[c]; c = c + 1 }
          }
          d = d + 1
      }
      preset = preset + 1
  }
253
  // bank the best params (data-driven config -- consumers read, not hardcode)
  let cl: *u8 = sys_mmap(256)
  var co: i64 = 0
  co = wr_cat(cl, co, "preset=" as *u8);  co = wr_cat_n(cl, co, best_preset)
  co = wr_cat(cl, co, "\ndensity_q10=" as *u8); co = wr_cat_n(cl, co, best_density)
  co = wr_cat(cl, co, "\ngrade=" as *u8); co = wr_cat(cl, co, wr_grade_name(best_grade))
  co = wr_cat(cl, co, "\nrefine_axis=" as *u8); co = wr_cat(cl, co, wr_refine_name(best12[9]))
  co = wr_cat(cl, co, "\n" as *u8)
262
  // VERDICT-CHANGE AUTONOMY (2026-06-10): the grader's directive is an
  // ASSIGNMENT, not a suggestion.  Compare against the DURABLE banked
  // verdict (reboot-proof home); when it changed, auto-file one pm_plan
  // row naming the next axis -- the team's backlog grows from gate
  // evidence with no LLM in the loop.  One row per CHANGE, never per
  // beat (the durable conf is the dedup state).
  let durable_conf: *u8 = "knowledge/status/worldgen_best.conf" as *u8
  var changed: i64 = 1
  let ofd: i64 = sys_openat_rd(durable_conf)
  if ofd >= 0 {
      let old: *u8 = sys_mmap(256)
      let on: i64 = sys_read(ofd, old, 255)
      sys_close(ofd)
      if on == co {
          changed = 0
          var ci: i64 = 0
          while ci < co {
              if old[ci] != cl[ci] { changed = 1; ci = co } else { ci = ci + 1 }
          }
      }
  }
  if changed == 1 {
      let pfd: i64 = sys_openat_append("knowledge/status/pm_plan_durable.log" as *u8, 0x1a4)
      if pfd >= 0 {
          let row: *u8 = sys_mmap(512)
          var ro: i64 = 0
          ro = wr_cat(row, ro, "arc=PROCGEN step=REFINE-VERDICT ts=" as *u8)
          ro = wr_cat_n(row, ro, ts)
          ro = wr_cat(row, ro, " AUTO-FILED by nx_worldgen_refine (verdict changed): best grade=" as *u8)
          ro = wr_cat(row, ro, wr_grade_name(best_grade))
          ro = wr_cat(row, ro, " preset=" as *u8)
          ro = wr_cat_n(row, ro, best_preset)
          ro = wr_cat(row, ro, " density=" as *u8)
          ro = wr_cat_n(row, ro, best_density)
          ro = wr_cat(row, ro, " next-refine=" as *u8)
          ro = wr_cat(row, ro, wr_refine_name(best12[9]))
          ro = wr_cat(row, ro, " -- the named axis is the next PROCGEN assignment owner=Builder\n" as *u8)
          sys_write(pfd, row, ro)
          sys_fsync(pfd)
          sys_close(pfd)
      }
      wr_oscillation_check(ts, best_grade, best12[9])
  }
306
  // dual-write: durable home first (the dedup state), then the /tmp
  // consumer contract (voxel build reads this path)
  let dfd: i64 = sys_openat_wr(durable_conf, 0x1a4)
  if dfd >= 0 { sys_write(dfd, cl, co); sys_fsync(dfd); sys_close(dfd) }
  let cfd: i64 = sys_openat_wr("/tmp/nishi_worldgen_best.conf" as *u8, 0x1a4)
  if cfd >= 0 { sys_write(cfd, cl, co); sys_close(cfd) }
313
  let sline: *u8 = sys_mmap(384)
  var o: i64 = 0
  o = wr_cat(sline, o, "WORLDGEN SUMMARY ts=" as *u8)
  o = wr_cat_n(sline, o, ts)
  o = wr_cat(sline, o, " BEST grade=" as *u8)
  o = wr_cat(sline, o, wr_grade_name(best_grade))
  o = wr_cat(sline, o, " preset=" as *u8)
  o = wr_cat_n(sline, o, best_preset)
  o = wr_cat(sline, o, " density=" as *u8)
  o = wr_cat_n(sline, o, best_density)
  o = wr_cat(sline, o, " next-refine=" as *u8)
  o = wr_cat(sline, o, wr_refine_name(best12[9]))
  o = wr_cat(sline, o, " floor=" as *u8)
  o = wr_cat(sline, o, wr_grade_name(floor_grade))
  o = wr_cat(sline, o, "\n" as *u8)
  sys_write(1, sline, o)
  if logfd >= 0 { sys_write(logfd, sline, o); sys_close(logfd) }
331
  if best_grade < floor_grade { return 1 }
  return 0
334}
nx_worldgen_refine.nx source

`nx_worldgen_refine.nx` source
