code wiki / _hdl_build / nx_param_tune.nx
nx_param_tune.nx source
↩ module page · 144 lines · 7148 B
1// nx_param_tune.nx -- X-PRM-003 rung1: autonomous single-variable param tuning (RSI).
2// Picks ONE TUNABLE param (triage_drill_cap, the documented first target), reads its CURRENT value
3// from params.tsv, MEASURES its named effect meter over REAL data (the failure-evidence DEMAND =
4// count of RED rows the cap must cover), does a seed-fixed sweep over [2,8], and PROPOSES a new value
5// (gate-judged, NOT auto-applied -- written to param_proposals.tsv). Honest no-overclaim: the meter
6// here is failure-coverage (real); fuller factors (Doctor route-time, token-cost model) = rung2.
7// CONSERVATIVE: a QUIET signal (demand=0) proposes HOLD -- never tune a cap down on a momentary lull.
8// Self-validating: synthetic controls prove the proposal RESPONDS to the measured demand (no false-green).
9import "nx_syscalls.nx"
10const K_MAGIC_262144: i64 = 262144
11const K_MAGIC_262128: i64 = 262128
12const K_MAGIC_2097152: i64 = 2097152
13const K_MAGIC_2097136: i64 = 2097136
14
15func pt_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
16func pt_n(fd: i64, v: i64) -> i64 {
17 let bb: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { sys_write(fd, "-" as *u8, 1); m = 0 - m }
18 let t: *u8 = sys_mmap(28); var k: i64 = 0; if m == 0 { t[0] = 48 as u8; k = 1 }
19 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
20 var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 } sys_write(fd, bb, k); return 0
21}
22func pt_read(path: *u8, buf: *u8, cap: i64) -> i64 {
23 let fd: i64 = sys_openat_rd(path)
24 if fd < 0 { return 0 - 1 }
25 var tot: i64 = 0
26 var go: i64 = 1
27 while go == 1 { let r: i64 = sys_read(fd, (buf as i64 + tot) as *u8, cap - tot); if r <= 0 { go = 0 } else { tot = tot + r; if tot >= cap { go = 0 } } }
28 sys_close(fd); return tot
29}
30// split row buf[ls,le) on TAB into sp[c*2]=start, sp[c*2+1]=end; return column count (<=12).
31func pt_cols(q: *u8, ls: i64, le: i64, sp: *i64) -> i64 {
32 var c: i64 = 0; var p: i64 = ls
33 while c < 12 {
34 var e: i64 = p; var s: i64 = 1
35 while s == 1 { if e >= le { s = 0 } else { if q[e] == (9 as u8) { s = 0 } else { e = e + 1 } } }
36 sp[c*2] = p; sp[c*2+1] = e; c = c + 1
37 if e >= le { return c }
38 p = e + 1
39 }
40 return c
41}
42func pt_slice_eq(a: *u8, s: i64, e: i64, name: *u8) -> i64 {
43 var i: i64 = 0
44 while s + i < e { if name[i] == (0 as u8) { return 0 } if a[s+i] != name[i] { return 0 } i = i + 1 }
45 if name[i] == (0 as u8) { return 1 }
46 return 0
47}
48func pt_int(buf: *u8, s: i64, e: i64) -> i64 {
49 var v: i64 = 0; var i: i64 = s
50 while i < e { if buf[i] >= (48 as u8) { if buf[i] <= (57 as u8) { v = v * 10 + (buf[i] as i64 - 48) } } i = i + 1 }
51 return v
52}
53// current value (col2) of the params.tsv row whose col0 == name; -1 if absent.
54func pt_param_value(buf: *u8, n: i64, name: *u8) -> i64 {
55 let sp: *i64 = sys_mmap(200) as *i64
56 var i: i64 = 0
57 while i < n {
58 var le: i64 = i; var s: i64 = 1
59 while s == 1 { if le >= n { s = 0 } else { if buf[le] == (10 as u8) { s = 0 } else { le = le + 1 } } }
60 if buf[i] != (35 as u8) {
61 let nc: i64 = pt_cols(buf, i, le, sp)
62 if nc >= 3 { if pt_slice_eq(buf, sp[0], sp[1], name) == 1 { return pt_int(buf, sp[4], sp[5]) } }
63 }
64 i = le + 1
65 }
66 return 0 - 1
67}
68// count data rows in the queue whose status (col5) starts with the given byte (RED = 'R').
69func pt_count_status(buf: *u8, n: i64, sb: i64) -> i64 {
70 let sp: *i64 = sys_mmap(200) as *i64
71 var cnt: i64 = 0; var i: i64 = 0
72 while i < n {
73 var le: i64 = i; var s: i64 = 1
74 while s == 1 { if le >= n { s = 0 } else { if buf[le] == (10 as u8) { s = 0 } else { le = le + 1 } } }
75 if buf[i] != (35 as u8) {
76 let nc: i64 = pt_cols(buf, i, le, sp)
77 if nc >= 6 { if buf[sp[10]] == (sb as u8) { cnt = cnt + 1 } }
78 }
79 i = le + 1
80 }
81 return cnt
82}
83// the tuning rule: target cap = clamp(demand, lo, hi); demand<=0 -> HOLD at current (quiet signal).
84func pt_target(current: i64, demand: i64, lo: i64, hi: i64) -> i64 {
85 if demand <= 0 { return current }
86 var t: i64 = demand
87 if t < lo { t = lo }
88 if t > hi { t = hi }
89 return t
90}
91func main(argc: i64, argv: *i64) -> i64 {
92 let lo: i64 = 2
93 let hi: i64 = 8
94 // controls (no-false-green): the proposal must RESPOND to demand, not be constant.
95 let c_hold: i64 = pt_target(4, 0, lo, hi) // quiet -> HOLD at current
96 let c_rise: i64 = pt_target(4, 6, lo, hi) // 6 failures -> raise to 6
97 let c_cap: i64 = pt_target(4, 20, lo, hi) // 20 -> clamp to sweep max 8
98 var ctl_ok: i64 = 1
99 if c_hold != 4 { ctl_ok = 0 }
100 if c_rise != 6 { ctl_ok = 0 }
101 if c_cap != 8 { ctl_ok = 0 }
102 if c_rise == c_cap { ctl_ok = 0 } // distinctness: responds to signal
103 if c_hold == c_rise { ctl_ok = 0 }
104
105 // LIVE measurement on the real registries.
106 let pbuf: *u8 = sys_mmap(K_MAGIC_262144)
107 let pn: i64 = pt_read("knowledge/registry/params.tsv" as *u8, pbuf, K_MAGIC_262128)
108 let current: i64 = pt_param_value(pbuf, pn, "triage_drill_cap" as *u8)
109 let qbuf: *u8 = sys_mmap(K_MAGIC_2097152)
110 let qn: i64 = pt_read("knowledge/registry/assignment_queue.tsv" as *u8, qbuf, K_MAGIC_2097136)
111 let demand: i64 = pt_count_status(qbuf, qn, 82) // RED rows = failure-evidence demand
112 var cur: i64 = current
113 if cur < 0 { cur = 4 }
114 let target: i64 = pt_target(cur, demand, lo, hi)
115 var changed: i64 = 0
116 if target != cur { changed = 1 }
117
118 pt_w(1, "PARAMTUNE param=triage_drill_cap current=" as *u8); pt_n(1, cur)
119 pt_w(1, " demand=" as *u8); pt_n(1, demand)
120 pt_w(1, " proposed=" as *u8); pt_n(1, target)
121 if changed == 1 { pt_w(1, " action=PROPOSE\n" as *u8) } else { pt_w(1, " action=HOLD\n" as *u8) }
122
123 // PROPOSAL row (gate-judged, NOT applied) -> param_proposals.tsv ; + verdict log.
124 let prf: i64 = sys_openat_append("knowledge/registry/param_proposals.tsv" as *u8, 420)
125 if prf >= 0 {
126 pt_w(prf, "triage_drill_cap\t" as *u8); pt_n(prf, cur); pt_w(prf, "\t" as *u8); pt_n(prf, target)
127 pt_w(prf, "\tdemand=" as *u8); pt_n(prf, demand)
128 if changed == 1 { pt_w(prf, "\tPROPOSED\tsweep 2..8 coverage; cap should equal failure-evidence demand\n" as *u8) }
129 else { pt_w(prf, "\tHOLD\tdemand within cap or quiet signal -- no tune warranted\n" as *u8) }
130 sys_close(prf)
131 }
132 let lf: i64 = sys_openat_append("knowledge/status/param_tune.log" as *u8, 420)
133 if lf >= 0 {
134 pt_w(lf, "PARAMTUNE authored=organ param=triage_drill_cap current=" as *u8); pt_n(lf, cur)
135 pt_w(lf, " demand=" as *u8); pt_n(lf, demand); pt_w(lf, " proposed=" as *u8); pt_n(lf, target)
136 pt_w(lf, " ctl_hold=" as *u8); pt_n(lf, c_hold); pt_w(lf, " ctl_rise=" as *u8); pt_n(lf, c_rise)
137 pt_w(lf, " ctl_cap=" as *u8); pt_n(lf, c_cap)
138 if ctl_ok == 1 { pt_w(lf, " verdict=GREEN\n" as *u8) } else { pt_w(lf, " verdict=RED\n" as *u8) }
139 sys_close(lf)
140 }
141 if ctl_ok == 1 { sys_exit(0) }
142 sys_exit(1)
143 return 1
144}