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

↩ module page · 270 lines · 12125 B
1// nx_worldgen_tuner.nx -- TEAM-OWNED verdict-targeted knob tuner
2// (operator 2026-06-10 "build the team's capabilities to handle your
3// callouts").  The refine loop auto-files a verdict row NAMING a weak
4// axis; this organ picks that assignment up MECHANICALLY:
5//
6//   read knowledge/status/worldgen_best.conf  (preset, density, axis)
7//   coordinate-descend the generator's exposed knobs
8//       (river_depth, rill_depth, rill_radius, detail_amp)
9//   score = (worst-of-seeds grade, named-axis value) lexicographic
10//   bank winner -> knowledge/status/worldgen_knobs.conf (+ /tmp copy)
11//   on banked-knobs CHANGE -> auto-file one arc=PROCGEN pm row
12//
13// nx_worldgen_refine consumes the banked knobs each beat, so the tuned
14// metric IS the gate metric.  Verdict -> assignment -> tune -> re-verdict:
15// the loop is closed with the 8-axis grader as referee, no LLM anywhere.
16//
17// TUNER lines -> stdout + /tmp/nishi_worldgen_tuner.log.
18// Exit 0 = tuned (banked best >= starting score), 1 = regression refused.
19// license_tier: ORIGINAL
20import "nx_syscalls.nx"
21import "nx_tier.nx"
22import "nx_worldgen_tunelib.nx"
23const K_MAGIC_1024: i64 = 1024
24const K_MAGIC_1228: i64 = 1228
25const K_MAGIC_1433: i64 = 1433
26const K_MAGIC_4096: i64 = 4096
27const K_MAGIC_4095: i64 = 4095
28
29func tn_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
30func tn_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 }
31func tn_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
42}
43
44// grid tables (DATA -- a new knob = one row here + one tl_ slot)
45func tn_grid_len(knob: i64) -> i64 {
  if knob == TL_K_RIVER_DEPTH { return 4 }
  if knob == TL_K_RILL_DEPTH  { return 5 }
  if knob == TL_K_RILL_RADIUS { return 5 }
  if knob == TL_K_PEAKS_EXTRA { return 3 }
  if knob == TL_K_AMP_BOOST   { return 3 }
  if knob == TL_K_TERRACE     { return 4 }
  return 4                                    // detail_amp
53}
54func tn_grid_val(knob: i64, i: i64) -> i64 {
  if knob == TL_K_RIVER_DEPTH {
      if i == 0 { return 60 }
      if i == 1 { return 90 }
      if i == 2 { return 120 }
      return 150
  }
  if knob == TL_K_RILL_DEPTH {
      if i == 0 { return 0 }
      if i == 1 { return 30 }
      if i == 2 { return 45 }
      if i == 3 { return 60 }
      return 90
  }
  if knob == TL_K_RILL_RADIUS {
      if i == 0 { return 3 }
      if i == 1 { return 4 }
      if i == 2 { return 6 }
      if i == 3 { return 8 }
      return 12                        // sparse-deep drainage (gen-3:
  }                                    // density, not depth, kills read
  if knob == TL_K_PEAKS_EXTRA {
      if i == 0 { return 0 }
      if i == 1 { return 1 }
      return 2
  }
  if knob == TL_K_AMP_BOOST {
      if i == 0 { return K_MAGIC_1024 }
      if i == 1 { return K_MAGIC_1228 }       // 1.2x
      return K_MAGIC_1433                      // 1.4x
  }
  if knob == TL_K_TERRACE {
      if i == 0 { return 0 }          // smooth faces
      if i == 1 { return 3 }
      if i == 2 { return 4 }
      return 6
  }
  if i == 0 { return 0 }
  if i == 1 { return 60 }
  if i == 2 { return 100 }
  return 140
95}
96
97func tn_report(logfd: i64, tag: *u8, ts: i64, knobs: *i64, grade: i64,
              axis: i64, axisval: i64) -> i64 {
  let line: *u8 = sys_mmap(512)
  var o: i64 = 0
  o = tn_cat(line, o, "TUNER ts=" as *u8); o = tn_cat_n(line, o, ts)
  o = tn_cat(line, o, " " as *u8); o = tn_cat(line, o, tag)
  o = tn_cat(line, o, " river_depth=" as *u8); o = tn_cat_n(line, o, knobs[TL_K_RIVER_DEPTH])
  o = tn_cat(line, o, " rill_depth=" as *u8); o = tn_cat_n(line, o, knobs[TL_K_RILL_DEPTH])
  o = tn_cat(line, o, " rill_radius=" as *u8); o = tn_cat_n(line, o, knobs[TL_K_RILL_RADIUS])
  o = tn_cat(line, o, " detail_amp=" as *u8); o = tn_cat_n(line, o, knobs[TL_K_DETAIL_AMP])
  o = tn_cat(line, o, " peaks_extra=" as *u8); o = tn_cat_n(line, o, knobs[TL_K_PEAKS_EXTRA])
  o = tn_cat(line, o, " amp_boost=" as *u8); o = tn_cat_n(line, o, knobs[TL_K_AMP_BOOST])
  o = tn_cat(line, o, " terrace=" as *u8); o = tn_cat_n(line, o, knobs[TL_K_TERRACE])
  o = tn_cat(line, o, " grade=" as *u8); o = tn_cat(line, o, tl_grade_name(grade))
  o = tn_cat(line, o, " axis=" as *u8); o = tn_cat(line, o, tl_refine_name(axis))
  o = tn_cat(line, o, " axisval=" as *u8); o = tn_cat_n(line, o, axisval)
  o = tn_cat(line, o, "\n" as *u8)
  sys_write(1, line, o)
  if logfd >= 0 { sys_write(logfd, line, o) }
  return 0
117}
118
119func main() -> i64 {
  let logfd: i64 = sys_openat_append("/tmp/nishi_worldgen_tuner.log" as *u8, 0x1a4)
  let ts: i64 = sys_now_realtime_sec()
122
  // the ASSIGNMENT: banked verdict (preset, density, named axis)
  let vb: *u8 = sys_mmap(K_MAGIC_4096)
  let vn: i64 = tl_read_file("knowledge/status/worldgen_best.conf" as *u8, vb, K_MAGIC_4095)
  var preset: i64 = 0
  var density: i64 = K_MAGIC_1024
  var axis: i64 = NX_WQG_REFINE_ADD_DETAIL
  if vn > 0 {
      preset  = tl_conf_get(vb, vn, "preset" as *u8, preset)
      density = tl_conf_get(vb, vn, "density_q10" as *u8, density)
      axis    = tl_conf_get_refine(vb, vn, axis)
  }
134
  // starting point: banked knobs (or preset-table defaults)
  let knobs: *i64 = sys_mmap(TL_K_COUNT * 8) as *i64
  tl_load_knobs("knowledge/status/worldgen_knobs.conf" as *u8, preset, knobs)
138
  let out12: *i64 = sys_mmap(8 * 12) as *i64
  var best_grade: i64 = tl_eval(preset, density, knobs, out12)
  var best_score: i64 = tl_score(best_grade, out12, axis)
  let start_score: i64 = best_score
  tn_report(logfd, "START" as *u8, ts, knobs, best_grade, axis, tl_axis_value(out12, axis))
144
  // coordinate descent, 2 passes
  var pass: i64 = 0
  while pass < 2 {
      var knob: i64 = 0
      while knob < TL_K_COUNT {
          let keep: i64 = knobs[knob]
          var best_val: i64 = keep
          var gi: i64 = 0
          while gi < tn_grid_len(knob) {
              let cand: i64 = tn_grid_val(knob, gi)
              if cand != keep {
                  knobs[knob] = cand
                  let g: i64 = tl_eval(preset, density, knobs, out12)
                  let sc: i64 = tl_score(g, out12, axis)
                  if sc > best_score {
                      best_score = sc
                      best_grade = g
                      best_val = cand
                  }
              }
              gi = gi + 1
          }
          knobs[knob] = best_val
          knob = knob + 1
      }
      pass = pass + 1
  }
172
  // JOINT pass over the COUPLED pair (peaks_extra x terrace): terrace
  // only matters WITH landmarks, so greedy per-knob descent never sees
  // the pair (it zeroes peaks before terrace is ever tried -- measured
  // 2026-06-10: read-targeted runs kept walking landmarks back while
  // terrace=0 sat untouched).  Coupled knobs get a 2D sweep.
  var pi: i64 = 0
  while pi < tn_grid_len(TL_K_PEAKS_EXTRA) {
      var ti: i64 = 0
      while ti < tn_grid_len(TL_K_TERRACE) {
          let pv: i64 = tn_grid_val(TL_K_PEAKS_EXTRA, pi)
          let tv: i64 = tn_grid_val(TL_K_TERRACE, ti)
          var differs: i64 = 0
          if pv != knobs[TL_K_PEAKS_EXTRA] { differs = 1 }
          if tv != knobs[TL_K_TERRACE] { differs = 1 }
          if differs == 1 {
              let keep_p: i64 = knobs[TL_K_PEAKS_EXTRA]
              let keep_t: i64 = knobs[TL_K_TERRACE]
              knobs[TL_K_PEAKS_EXTRA] = pv
              knobs[TL_K_TERRACE] = tv
              let g: i64 = tl_eval(preset, density, knobs, out12)
              let sc: i64 = tl_score(g, out12, axis)
              if sc > best_score {
                  best_score = sc
                  best_grade = g
              } else {
                  knobs[TL_K_PEAKS_EXTRA] = keep_p
                  knobs[TL_K_TERRACE] = keep_t
              }
          }
          ti = ti + 1
      }
      pi = pi + 1
  }
206
  // re-eval the winner (out12 = winner's verdict for the report)
  best_grade = tl_eval(preset, density, knobs, out12)
  tn_report(logfd, "BEST" as *u8, ts, knobs, best_grade, axis, tl_axis_value(out12, axis))
210
  // bank: durable home + /tmp consumer copy; auto-file pm row on change
  let cl: *u8 = sys_mmap(384)
  var co: i64 = 0
  co = tn_cat(cl, co, "preset=" as *u8); co = tn_cat_n(cl, co, preset)
  co = tn_cat(cl, co, "\ndensity_q10=" as *u8); co = tn_cat_n(cl, co, density)
  co = tn_cat(cl, co, "\nriver_depth=" as *u8); co = tn_cat_n(cl, co, knobs[TL_K_RIVER_DEPTH])
  co = tn_cat(cl, co, "\nrill_depth=" as *u8); co = tn_cat_n(cl, co, knobs[TL_K_RILL_DEPTH])
  co = tn_cat(cl, co, "\nrill_radius=" as *u8); co = tn_cat_n(cl, co, knobs[TL_K_RILL_RADIUS])
  co = tn_cat(cl, co, "\ndetail_amp=" as *u8); co = tn_cat_n(cl, co, knobs[TL_K_DETAIL_AMP])
  co = tn_cat(cl, co, "\npeaks_extra=" as *u8); co = tn_cat_n(cl, co, knobs[TL_K_PEAKS_EXTRA])
  co = tn_cat(cl, co, "\namp_boost=" as *u8); co = tn_cat_n(cl, co, knobs[TL_K_AMP_BOOST])
  co = tn_cat(cl, co, "\nterrace_steps=" as *u8); co = tn_cat_n(cl, co, knobs[TL_K_TERRACE])
  co = tn_cat(cl, co, "\ngrade=" as *u8); co = tn_cat(cl, co, tl_grade_name(best_grade))
  co = tn_cat(cl, co, "\ntuned_axis=" as *u8); co = tn_cat(cl, co, tl_refine_name(axis))
  co = tn_cat(cl, co, "\n" as *u8)
226
  let durable: *u8 = "knowledge/status/worldgen_knobs.conf" as *u8
  var changed: i64 = 1
  let old: *u8 = sys_mmap(384)
  let on: i64 = tl_read_file(durable, old, 383)
  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 = tn_cat(row, ro, "arc=PROCGEN step=TUNER ts=" as *u8)
          ro = tn_cat_n(row, ro, ts)
          ro = tn_cat(row, ro, " AUTO-FILED by nx_worldgen_tuner (knobs changed): grade=" as *u8)
          ro = tn_cat(row, ro, tl_grade_name(best_grade))
          ro = tn_cat(row, ro, " tuned_axis=" as *u8)
          ro = tn_cat(row, ro, tl_refine_name(axis))
          ro = tn_cat(row, ro, " river_depth=" as *u8); ro = tn_cat_n(row, ro, knobs[TL_K_RIVER_DEPTH])
          ro = tn_cat(row, ro, " rill_depth=" as *u8); ro = tn_cat_n(row, ro, knobs[TL_K_RILL_DEPTH])
          ro = tn_cat(row, ro, " rill_radius=" as *u8); ro = tn_cat_n(row, ro, knobs[TL_K_RILL_RADIUS])
          ro = tn_cat(row, ro, " detail_amp=" as *u8); ro = tn_cat_n(row, ro, knobs[TL_K_DETAIL_AMP])
          ro = tn_cat(row, ro, " peaks_extra=" as *u8); ro = tn_cat_n(row, ro, knobs[TL_K_PEAKS_EXTRA])
          ro = tn_cat(row, ro, " amp_boost=" as *u8); ro = tn_cat_n(row, ro, knobs[TL_K_AMP_BOOST])
          ro = tn_cat(row, ro, " terrace_steps=" as *u8); ro = tn_cat_n(row, ro, knobs[TL_K_TERRACE])
          ro = tn_cat(row, ro, " -- banked to worldgen_knobs.conf, the gate sweep consumes it next beat owner=Builder\n" as *u8)
          sys_write(pfd, row, ro)
          sys_fsync(pfd)
          sys_close(pfd)
      }
  }
  let dfd: i64 = sys_openat_wr(durable, 0x1a4)
  if dfd >= 0 { sys_write(dfd, cl, co); sys_fsync(dfd); sys_close(dfd) }
  let tfd: i64 = sys_openat_wr("/tmp/nishi_worldgen_knobs.conf" as *u8, 0x1a4)
  if tfd >= 0 { sys_write(tfd, cl, co); sys_close(tfd) }
266
  if logfd >= 0 { sys_close(logfd) }
  if best_score < start_score { return 1 }
  return 0
270}
nx_worldgen_tuner.nx source

`nx_worldgen_tuner.nx` source
