code wiki / _hdl_build / nx_tokroi.nx
nx_tokroi.nx source
↩ module page · 302 lines · 15577 B
1// nx_tokroi.nx -- TOKEN-EFFICIENCY ROI LEDGER. Values and statuses are declarations;
2// this report does not resolve evidence references or verify measurement/execution history.
3// Legacy reduction=max(baseline-after,0), daily=reduction*declared uses, and floor payback
4// remain available. Additive signed delta exposes regressions; ceiling break-even assumes
5// comparable units. Only exact REALIZED and PROJECTED states enter their separate totals.
6// license_tier: ORIGINAL. No hardware writes (Rule 26). expect_exit: 0
7// report [roiprefix] -> ROI JSON | selftest [tmpprefix] -> gate T1..T5
8// tokroi- row = id lever status investment baseline after uses_per_day evidence (8-col plane).
9import "nx_sovjson_lib.nx"
10import "json_emit.nx"
11import "nx_store_seed_lib.nx"
12import "nx_seg_store.nx"
13import "nx_gate_verdict.nx"
14import "nx_syscalls.nx"
15
16const TR_CAP: i64 = 1048576
17const TR_OUT: i64 = 16384
18const TR_SPAN: i64 = 16
19const TR_USAGE: i64 = 2
20const TR_ESC: i64 = 90
21
22// Additive report helpers; native source also imports json_emit.nx.
23const TR_E_SOURCE: i64 = 1
24const TR_E_OUTPUT: i64 = 2
25const TR_E_ROW: i64 = 3
26const TR_E_ARITHMETIC: i64 = 4
27const TR_E_ALLOC: i64 = 5
28const TR_I64_MAX: i64 = 9223372036854775807
29const TR_FIELDS: i64 = 8
30const TR_NUMERIC_FIELDS: i64 = 4
31
32func tr_nat(buf: *u8, start: i64, end: i64, dst: *i64) -> i64 {
33 if end <= start { return 0 }
34 var v: i64 = 0
35 var i: i64 = start
36 while i < end {
37 let d: i64 = (buf[i] as i64) - 48
38 if d < 0 { return 0 }
39 if d > 9 { return 0 }
40 if v > (TR_I64_MAX - d)/10 { return 0 }
41 v = v*10 + d; i = i + 1
42 }
43 dst[0] = v
44 return 1
45}
46
47func tr_key(w: *JsonWriter, key: *u8) -> i64 { return json_emit_key(w, key, sj_vlen(key)) }
48// Emit through the bounded writer without the shared integer emitter's per-value allocation.
49// Negative magnitude also handles i64_min without negating it.
50func tr_int(w: *JsonWriter, value: i64) -> i64 {
51 if je_sep(w) < 0 { return 0 - 1 }
52 var v: i64 = value
53 if v < 0 { if je_put(w, 45) < 0 { return 0 - 1 } }
54 if v > 0 { v = 0 - v }
55 var divisor: i64 = 1
56 while v/divisor <= (0 - 10) { divisor = divisor*10 }
57 while divisor > 0 {
58 if je_put(w, 48 - v/divisor) < 0 { return 0 - 1 }
59 v = v % divisor
60 divisor = divisor/10
61 }
62 return 0
63}
64
65func tr_number(w: *JsonWriter, key: *u8, value: i64) -> i64 {
66 if tr_key(w, key) < 0 { return 0 - 1 }
67 return tr_int(w, value)
68}
69func tr_string(w: *JsonWriter, key: *u8, value: *u8, n: i64) -> i64 {
70 if tr_key(w, key) < 0 { return 0 - 1 }
71 return json_emit_string(w, value, n)
72}
73func tr_span(w: *JsonWriter, key: *u8, buf: *u8, bounds: *i64, col: i64) -> i64 {
74 return tr_string(w, key, ((buf as i64) + bounds[col*2]) as *u8, bounds[col*2+1] - bounds[col*2])
75}
76func tr_flag(w: *JsonWriter, key: *u8, value: i64) -> i64 {
77 if tr_key(w, key) < 0 { return 0 - 1 }
78 return json_emit_bool(w, value)
79}
80
81func tr_row(w: *JsonWriter, buf: *u8, bounds: *i64, values: *i64, delta: i64, reduction: i64, daily: i64, payback: i64, ceilpay: i64, recognized: i64) -> i64 {
82 if json_begin_object(w) < 0 { return 0 - 1 }
83 if tr_span(w, "id" as *u8, buf, bounds, 0) < 0 { return 0 - 1 }
84 if tr_span(w, "lever" as *u8, buf, bounds, 1) < 0 { return 0 - 1 }
85 if tr_span(w, "status" as *u8, buf, bounds, 2) < 0 { return 0 - 1 }
86 if tr_number(w, "investment" as *u8, values[0]) < 0 { return 0 - 1 }
87 if tr_number(w, "baseline" as *u8, values[1]) < 0 { return 0 - 1 }
88 if tr_number(w, "after" as *u8, values[2]) < 0 { return 0 - 1 }
89 if tr_number(w, "reduction_per_use" as *u8, reduction) < 0 { return 0 - 1 }
90 if tr_number(w, "uses_per_day" as *u8, values[3]) < 0 { return 0 - 1 }
91 if tr_number(w, "daily_reduction" as *u8, daily) < 0 { return 0 - 1 }
92 if tr_number(w, "payback_uses" as *u8, payback) < 0 { return 0 - 1 }
93 if tr_span(w, "evidence" as *u8, buf, bounds, 7) < 0 { return 0 - 1 }
94 if tr_number(w, "signed_delta" as *u8, delta) < 0 { return 0 - 1 }
95 if tr_key(w, "break_even_uses" as *u8) < 0 { return 0 - 1 }
96 if ceilpay < 0 { if json_emit_null(w) < 0 { return 0 - 1 } }
97 else { if tr_int(w, ceilpay) < 0 { return 0 - 1 } }
98 if tr_flag(w, "aggregation_eligible" as *u8, recognized) < 0 { return 0 - 1 }
99 if tr_flag(w, "evidence_verified" as *u8, 0) < 0 { return 0 - 1 }
100 if json_end_object(w) < 0 { return 0 - 1 }
101 return 0
102}
103
104func tr_total(w: *JsonWriter, key: *u8, daily: i64, investment: i64, levers: i64) -> i64 {
105 if tr_key(w, key) < 0 { return 0 - 1 }
106 if json_begin_object(w) < 0 { return 0 - 1 }
107 if tr_number(w, "daily_reduction" as *u8, daily) < 0 { return 0 - 1 }
108 if tr_number(w, "investment" as *u8, investment) < 0 { return 0 - 1 }
109 if tr_number(w, "levers" as *u8, levers) < 0 { return 0 - 1 }
110 return json_end_object(w)
111}
112
113func tr_report_rows(buf: *u8, n: i64, out: *u8, cap: i64, flags: *i64) -> i64 {
114 if n < 0 { return 0 - TR_E_SOURCE }
115 if cap <= 0 { return 0 - TR_E_OUTPUT }
116 if (out as i64) <= 0 { return 0 - TR_E_ALLOC }
117 if flags[0] < 0 { return 0 - TR_E_SOURCE }
118 if flags[1] < 0 { return 0 - TR_E_SOURCE }
119 if flags[2] < 0 { return 0 - TR_E_SOURCE }
120 let w: *JsonWriter = sys_mmap(__size_of(JsonWriter)) as *JsonWriter
121 let bounds: *i64 = sys_mmap(TR_FIELDS*TR_SPAN) as *i64
122 let values: *i64 = sys_mmap(TR_NUMERIC_FIELDS*8) as *i64
123 let extra: *i64 = sys_mmap(TR_SPAN) as *i64
124 if (w as i64) <= 0 { return 0 - TR_E_ALLOC }
125 if (bounds as i64) <= 0 { return 0 - TR_E_ALLOC }
126 if (values as i64) <= 0 { return 0 - TR_E_ALLOC }
127 if (extra as i64) <= 0 { return 0 - TR_E_ALLOC }
128 // The existing initializer dereferences its mapping before returning; initialize the same
129 // verified writer fields here so allocation failure remains a structured report refusal.
130 let prior: *u8 = sys_mmap(JE_MAX_DEPTH + 16)
131 if (prior as i64) <= 0 { return 0 - TR_E_ALLOC }
132 var wi: i64 = 0
133 while wi < JE_MAX_DEPTH { prior[wi] = 0 as u8; wi = wi + 1 }
134 w.buf = out; w.pos = 0; w.cap = cap; w.depth = 0; w.prior = prior
135 if json_begin_object(w) < 0 { return 0 - TR_E_OUTPUT }
136 if tr_string(w, "organ" as *u8, "nx_tokroi" as *u8, sj_vlen("nx_tokroi" as *u8)) < 0 { return 0 - TR_E_OUTPUT }
137 if tr_string(w, "verb" as *u8, "report" as *u8, sj_vlen("report" as *u8)) < 0 { return 0 - TR_E_OUTPUT }
138 if tr_flag(w, "ok" as *u8, 1) < 0 { return 0 - TR_E_OUTPUT }
139 if tr_key(w, "levers" as *u8) < 0 { return 0 - TR_E_OUTPUT }
140 if json_begin_array(w) < 0 { return 0 - TR_E_OUTPUT }
141 var rd: i64 = 0; var ri: i64 = 0; var rn: i64 = 0
142 var pd: i64 = 0; var pi: i64 = 0; var pn: i64 = 0
143 var unknown: i64 = 0; var rows: i64 = 0; var i: i64 = 0
144 while i < n {
145 let le: i64 = sj_le(buf, i, n)
146 if le > i {
147 var col: i64 = 0
148 while col < TR_FIELDS {
149 if sj_col(buf, i, le, col, ((bounds as i64) + col*TR_SPAN) as *i64) != 1 { return 0 - TR_E_ROW }
150 col = col + 1
151 }
152 if sj_col(buf, i, le, TR_FIELDS, extra) == 1 { return 0 - TR_E_ROW }
153 if bounds[1] <= bounds[0] { return 0 - TR_E_ROW }
154 if bounds[3] <= bounds[2] { return 0 - TR_E_ROW }
155 col = 0
156 while col < TR_NUMERIC_FIELDS {
157 let bc: i64 = (col+3)*2
158 if tr_nat(buf, bounds[bc], bounds[bc+1], ((values as i64) + col*8) as *i64) != 1 { return 0 - TR_E_ROW }
159 col = col + 1
160 }
161 // Counts are validated nonnegative i64: their signed difference lies in [-MAX,MAX].
162 let delta: i64 = values[1] - values[2]
163 var reduction: i64 = delta
164 if reduction < 0 { reduction = 0 }
165 if values[3] > 0 { if reduction > TR_I64_MAX/values[3] { return 0 - TR_E_ARITHMETIC } }
166 let daily: i64 = reduction*values[3]
167 var payback: i64 = 0 - 1
168 var ceilpay: i64 = 0 - 1
169 if reduction > 0 {
170 payback = values[0]/reduction
171 ceilpay = payback
172 // A nonzero remainder proves quotient < investment <= MAX, so +1 cannot overflow.
173 if values[0] % reduction != 0 { ceilpay = ceilpay + 1 }
174 }
175 var recognized: i64 = 0
176 if sj_lit_eq(buf, bounds[4], bounds[5], "REALIZED" as *u8) == 1 {
177 if daily > TR_I64_MAX - rd { return 0 - TR_E_ARITHMETIC }
178 if values[0] > TR_I64_MAX - ri { return 0 - TR_E_ARITHMETIC }
179 rd = rd + daily; ri = ri + values[0]; rn = rn + 1; recognized = 1
180 }
181 if sj_lit_eq(buf, bounds[4], bounds[5], "PROJECTED" as *u8) == 1 {
182 if daily > TR_I64_MAX - pd { return 0 - TR_E_ARITHMETIC }
183 if values[0] > TR_I64_MAX - pi { return 0 - TR_E_ARITHMETIC }
184 pd = pd + daily; pi = pi + values[0]; pn = pn + 1; recognized = 1
185 }
186 if recognized == 0 { unknown = unknown + 1 }
187 if tr_row(w, buf, bounds, values, delta, reduction, daily, payback, ceilpay, recognized) < 0 { return 0 - TR_E_OUTPUT }
188 rows = rows + 1
189 }
190 i = le + 1
191 }
192 if rows != flags[1] { return 0 - TR_E_SOURCE }
193 if json_end_array(w) < 0 { return 0 - TR_E_OUTPUT }
194 if tr_total(w, "realized" as *u8, rd, ri, rn) < 0 { return 0 - TR_E_OUTPUT }
195 if tr_total(w, "projected" as *u8, pd, pi, pn) < 0 { return 0 - TR_E_OUTPUT }
196 if tr_number(w, "rows" as *u8, rows) < 0 { return 0 - TR_E_OUTPUT }
197 if tr_number(w, "unknown_status_rows" as *u8, unknown) < 0 { return 0 - TR_E_OUTPUT }
198 if tr_number(w, "declared_rows" as *u8, flags[0]) < 0 { return 0 - TR_E_OUTPUT }
199 if tr_number(w, "loaded_rows" as *u8, flags[1]) < 0 { return 0 - TR_E_OUTPUT }
200 if tr_number(w, "beyond_count_rows_detected" as *u8, flags[2]) < 0 { return 0 - TR_E_OUTPUT }
201 if tr_key(w, "history_complete" as *u8) < 0 { return 0 - TR_E_OUTPUT }
202 if json_emit_null(w) < 0 { return 0 - TR_E_OUTPUT }
203 let scope: *u8 = "ledger-declared references only; not resolved or benchmark-verified" as *u8
204 if tr_string(w, "evidence_scope" as *u8, scope, sj_vlen(scope)) < 0 { return 0 - TR_E_OUTPUT }
205 if tr_flag(w, "units_verified" as *u8, 0) < 0 { return 0 - TR_E_OUTPUT }
206 let note: *u8 = "Values and statuses are ledger declarations, not verified measurements. investment is an estimate; uses_per_day is an assumption. Legacy reduction=max(baseline-after,0) and payback=floor(investment/reduction) are retained; signed_delta preserves regressions; break_even_uses uses ceiling when reduction>0, otherwise null. Break-even assumes comparable investment/reduction units; this report does not verify units, evidence, historical execution or realized savings. Unknown statuses are excluded from both totals. Current declared rows and bounded beyond-count detection do not establish full history." as *u8
207 if tr_string(w, "note" as *u8, note, sj_vlen(note)) < 0 { return 0 - TR_E_OUTPUT }
208 if json_end_object(w) < 0 { return 0 - TR_E_OUTPUT }
209 if je_put(w, 10) < 0 { return 0 - TR_E_OUTPUT }
210 return w.pos
211}
212
213func tr_report(prefix: *u8, out: *u8) -> i64 {
214 let buf: *u8 = sys_mmap(TR_CAP)
215 let flags: *i64 = sys_mmap(3*8) as *i64
216 if (buf as i64) <= 0 { return 0 - TR_E_ALLOC }
217 if (flags as i64) <= 0 { return 0 - TR_E_ALLOC }
218 let n: i64 = sts_load_honest(prefix, buf, TR_CAP, flags)
219 // This reader cannot distinguish a missing/unreadable plane from a declared empty plane.
220 if n <= 0 { return 0 - TR_E_SOURCE }
221 if n >= TR_CAP { return 0 - TR_E_SOURCE }
222 if flags[0] != flags[1] { return 0 - TR_E_SOURCE }
223 return tr_report_rows(buf, n, out, TR_OUT, flags)
224}
225
226func tr_report_error(out: *u8, code: i64) -> i64 {
227 // Fixed-size error form is below TR_OUT; overwrite every partial report before stdout.
228 var o: i64 = sj_cat(out, 0, "{\"organ\":\"nx_tokroi\",\"verb\":\"report\",\"ok\":false,\"error\":{\"code\":" as *u8)
229 out[o] = (48 + code) as u8; o = o + 1
230 o = sj_cat(out, o, ",\"detail\":\"Report refused: 1=empty/unreadable/incomplete source; 2=output capacity; 3=invalid eight-column row or integer; 4=signed i64 arithmetic overflow; 5=allocation failure. No partial totals published.\"}}\n" as *u8)
231 return o
232}
233
234func tr_selftest(base: *u8) -> i64 {
235 let ctr: *i64 = gv_ctr()
236 gv_head("nx_tokroi selftest -- investment->reduction ledger, realized/projected split" as *u8)
237 let now: i64 = sys_now_realtime_sec()
238 let fp: *u8 = sys_mmap(256)
239 var fo: i64 = sj_cat(fp, 0, base)
240 fo = sj_catn(fp, fo, now)
241 fo = sj_cat(fp, fo, "tokroi-" as *u8)
242 fp[fo] = 0 as u8
243 let seed: *u8 = sys_mmap(TR_CAP)
244 var so: i64 = 0
245 so = sj_cat(seed, so, "R1 boot-digest REALIZED 150000 40000 300 16 seat-S0
246" as *u8)
247 so = sj_cat(seed, so, "R2 fs-lines REALIZED 30000 70847 869 4 fslines
248" as *u8)
249 so = sj_cat(seed, so, "P1 split-brain PROJECTED 250000 85172 0 30 clawf
250" as *u8)
251 sts_seed(fp, seed, so)
252 let out: *u8 = sys_mmap(TR_OUT)
253 let l: i64 = tr_report(fp, out)
254 var t1: i64 = 0
255 if sj_span_has(out, 0, l, "\"reduction_per_use\":39700" as *u8) == 1 { if sj_span_has(out, 0, l, "\"payback_uses\":3" as *u8) == 1 { t1 = 1 } }
256 gv_check("T1 per-lever reduction+payback exact (40000-300=39700, 150000/39700=3)" as *u8, t1, ctr)
257 gv_check("T2 daily = reduction*uses (39700*16=635200)" as *u8, sj_span_has(out, 0, l, "\"daily_reduction\":635200" as *u8), ctr)
258 gv_check("T3 realized totals exact + separate" as *u8, sj_span_has(out, 0, l, "\"realized\":{\"daily_reduction\":915112,\"investment\":180000,\"levers\":2}" as *u8), ctr)
259 gv_check("T4 projected kept SEPARATE (no fake realized)" as *u8, sj_span_has(out, 0, l, "\"projected\":{\"daily_reduction\":2555160,\"investment\":250000,\"levers\":1}" as *u8), ctr)
260 gv_check("T5 methodology declared in-band" as *u8, sj_span_has(out, 0, l, "Values and statuses are ledger declarations, not verified measurements." as *u8), ctr)
261 let rc: i64 = gv_verdict("TOKROI-GATE" as *u8, ctr, "investment->reduction ledger: declared inputs, explicit assumptions, realized/projected split" as *u8)
262 return rc
263}
264func main(argc: i64, argv: *i64) -> i64 {
265 if argc < 2 {
266 sj_werr("usage: nx_tokroi {report [roiprefix] | selftest [tmpprefix]}
267" as *u8)
268 sys_exit(TR_USAGE)
269 return TR_USAGE
270 }
271 let verb: *u8 = argv[1] as *u8
272 if sj_lit_eq(verb, 0, sj_vlen(verb), "report" as *u8) == 1 {
273 var pfx: *u8 = "knowledge/store/tokroi-" as *u8
274 if argc > 2 { pfx = argv[2] as *u8 }
275 let out: *u8 = sys_mmap(TR_OUT)
276 if (out as i64) <= 0 {
277 let message: *u8 = "{\"organ\":\"nx_tokroi\",\"verb\":\"report\",\"ok\":false,\"error\":{\"code\":5,\"detail\":\"Output allocation failed; no totals published.\"}}\n" as *u8
278 sys_write(1, message, sj_vlen(message)); sys_exit(1); return 1
279 }
280 let n: i64 = tr_report(pfx, out)
281 if n < 0 {
282 let en: i64 = tr_report_error(out, 0 - n)
283 sys_write(1, out, en)
284 sys_exit(1); return 1
285 }
286 sys_write(1, out, n)
287 sys_exit(0)
288 return 0
289 }
290 if sj_lit_eq(verb, 0, sj_vlen(verb), "selftest" as *u8) == 1 {
291 var b: *u8 = "/tmp/nxtroi_st" as *u8
292 if argc > 2 { b = argv[2] as *u8 }
293 let rc: i64 = tr_selftest(b)
294 sys_exit(rc)
295 return rc
296 }
297 sj_werr("TOKROI-FAIL unknown verb
298" as *u8)
299 sys_exit(TR_USAGE)
300 return TR_USAGE
301}
302