nx_autograde_page.nx source
↩ module page · 362 lines · 22078 B
1// nx_autograde_page.nx -- the AUTONOMOUS GRADING dashboard for /compare/autograde, written for HUMANS
2// (operator 2026-07-16: "this is garbage output... what human can understand your weird output" -- v1 rendered
3// raw ledger keys/permille/ge4 jargon. v2 rule: every goal is a PLAIN QUESTION a person would ask, every answer
4// is YES/NOT YET/NOT MEASURED + a percentage bar + ONE sentence of what it means. No permille, no key=value).
5// Presentation ONLY: every number comes from the persisted ledgers written by MEASURING ORGANS (nx_autograde,
6// nx_zero_claude_ledger, nx_codegen_bench). This organ TRANSLATES them to English; it never grades.
7// argv[1]=html (default) | json. Emits to STDOUT. license_tier: ORIGINAL expect_exit: 0
8import "nx_syscalls.nx"
9const K_MAGIC_999999: i64 = 999999
10
11func w(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
12func wn(v: i64) -> i64 {
13 var m: i64 = v
14 if m < 0 { w("-" as *u8); m = 0 - m }
15 let t: *u8 = sys_mmap(24)
16 var k: i64 = 0
17 if m == 0 { t[0] = 48 as u8; k = 1 }
18 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
19 let o: *u8 = sys_mmap(24)
20 var i: i64 = 0
21 while i < k { o[i] = t[k - 1 - i]; i = i + 1 }
22 sys_write(1, o, k)
23 return 0
24}
25func slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
26func streq(a: *u8, b: *u8) -> i64 {
27 var i: i64 = 0
28 var go: i64 = 1
29 var res: i64 = 1
30 while go == 1 {
31 let ca: i64 = a[i] as i64
32 let cb: i64 = b[i] as i64
33 if ca != cb { res = 0; go = 0 }
34 else { if ca == 0 { go = 0 } else { i = i + 1 } }
35 }
36 return res
37}
38func findf(buf: *u8, from: i64, n: i64, needle: *u8) -> i64 {
39 let m: i64 = slen(needle)
40 if m == 0 { return 0 - 1 }
41 var i: i64 = from
42 while i + m <= n {
43 var j: i64 = 0
44 var ok: i64 = 1
45 while j < m { if buf[i+j] != needle[j] { ok = 0; j = m } else { j = j + 1 } }
46 if ok == 1 { return i }
47 i = i + 1
48 }
49 return 0 - 1
50}
51func pint(buf: *u8, n: i64, p: i64) -> i64 {
52 var i: i64 = p
53 if i >= n { return 0 - K_MAGIC_999999 }
54 var neg: i64 = 0
55 if (buf[i] as i64) == 45 { neg = 1; i = i + 1 }
56 var v: i64 = 0
57 var any: i64 = 0
58 var go: i64 = 1
59 while go == 1 {
60 if i >= n { go = 0 }
61 else {
62 let d: i64 = buf[i] as i64
63 if d >= 48 { if d <= 57 { v = v*10 + (d-48); any = 1; i = i + 1 } else { go = 0 } }
64 else { go = 0 }
65 }
66 }
67 if any == 0 { return 0 - K_MAGIC_999999 }
68 if neg == 1 { return 0 - v }
69 return v
70}
71func tok_after(buf: *u8, ls: i64, le: i64, key: *u8, dst: *u8, dcap: i64) -> i64 {
72 let ki: i64 = findf(buf, ls, le, key)
73 if ki < 0 { dst[0] = 0 as u8; return 0 }
74 var i: i64 = ki + slen(key)
75 var j: i64 = 0
76 var go: i64 = 1
77 while go == 1 {
78 if i >= le { go = 0 }
79 else { let c: i64 = buf[i] as i64
80 if c == 32 { go = 0 } else { if c == 10 { go = 0 } else { if j >= dcap-1 { go = 0 } else { dst[j] = buf[i]; j = j + 1; i = i + 1 } } } }
81 }
82 dst[j] = 0 as u8
83 return j
84}
85func int_after(buf: *u8, ls: i64, le: i64, key: *u8) -> i64 {
86 let ki: i64 = findf(buf, ls, le, key)
87 if ki < 0 { return 0 - K_MAGIC_999999 }
88 return pint(buf, le, ki + slen(key))
89}
90func read_ledger(path: *u8, lenout: *i64) -> *u8 {
91 let b: *u8 = sys_read_file(path, lenout)
92 if (b as i64) == 0 { lenout[0] = 0 }
93 return b
94}
95// verdict of target `name` in the LAST autograde run: 1=MET 2=NOTMET 0=UNMEAS -1=absent. value via valout.
96func target_verdict(ag: *u8, n: i64, last_ts: i64, name: *u8, valout: *i64) -> i64 {
97 let nb: *u8 = sys_mmap(64)
98 let vb: *u8 = sys_mmap(32)
99 var p: i64 = 0
100 var res: i64 = 0 - 1
101 while p < n {
102 var e: i64 = p
103 var f: i64 = 0
104 while f == 0 { if e >= n { f = 1 } else { if ag[e] == (10 as u8) { f = 1 } else { e = e + 1 } } }
105 let t: i64 = int_after(ag, p, e, "ts=" as *u8)
106 if t == last_ts {
107 tok_after(ag, p, e, "name=" as *u8, nb, 64)
108 if streq(nb, name) == 1 {
109 valout[0] = int_after(ag, p, e, "value=" as *u8)
110 tok_after(ag, p, e, "verdict=" as *u8, vb, 32)
111 if streq(vb, "MET" as *u8) == 1 { res = 1 }
112 else { if streq(vb, "NOTMET" as *u8) == 1 { res = 2 } else { res = 0 } }
113 }
114 }
115 p = e + 1
116 }
117 return res
118}
119// emit one scoreboard row: a question, a YES/NOT-YET/NOT-MEASURED chip, and a plain sentence
120func row(question: *u8, verdict: i64, sentence: *u8) -> i64 {
121 w("<div class='q'><div class='qq'>" as *u8)
122 w(question)
123 w("</div><div>" as *u8)
124 if verdict == 1 { w("<span class='chip yes'>✓ YES</span>" as *u8) }
125 if verdict == 2 { w("<span class='chip notyet'>NOT YET</span>" as *u8) }
126 if verdict == 0 { w("<span class='chip nomeas'>NOT MEASURED YET</span>" as *u8) }
127 if verdict < 0 { w("<span class='chip nomeas'>NO DATA</span>" as *u8) }
128 w(" <span class='ans'>" as *u8)
129 w(sentence)
130 w("</span></div></div>\n" as *u8)
131 return 0
132}
133
134// AD1 (2026-08-27): the swebench answer must carry its DENOMINATOR. Read resolved & total from the newest
135// SWBL line of swebench_local_ledger.log -- old rows spell resolved=/total=, the rigor-envelope rows spell
136// "k": / "n":. Returns 1 with kbox/nbox filled, 0 when the ledger is absent (the caller then says so).
137// the zero-claude row's DENOMINATOR: local/total from the newest ZCL line (same ledger the trend reads)
138func zcl_kn(kbox: *i64, nbox: *i64) -> i64 {
139 kbox[0] = 0 - 1
140 nbox[0] = 0 - 1
141 let ln: *i64 = sys_mmap(8) as *i64
142 let b: *u8 = read_ledger("/home/elderwesto/nx_stage/zero_claude_ledger.log" as *u8, ln)
143 if (b as i64) == 0 { return 0 }
144 let n: i64 = ln[0]
145 var p: i64 = 0
146 var found: i64 = 0
147 while p < n {
148 var e: i64 = p
149 var f: i64 = 0
150 while f == 0 { if e >= n { f = 1 } else { if b[e] == (10 as u8) { f = 1 } else { e = e + 1 } } }
151 if findf(b, p, e, "ZCL " as *u8) >= 0 {
152 let kk: i64 = int_after(b, p, e, "local=" as *u8)
153 let nn: i64 = int_after(b, p, e, "total=" as *u8)
154 if kk != (0 - K_MAGIC_999999) { if nn != (0 - K_MAGIC_999999) { kbox[0] = kk; nbox[0] = nn; found = 1 } }
155 }
156 p = e + 1
157 }
158 return found
159}
160
161func swbl_kn(kbox: *i64, nbox: *i64) -> i64 {
162 kbox[0] = 0 - 1
163 nbox[0] = 0 - 1
164 let ln: *i64 = sys_mmap(8) as *i64
165 // the ESTATE journal first (the swebench gate appends envelope rows there since AD1); the
166 // dev-box stage ledger stays the fallback for the pulse lane
167 var b: *u8 = read_ledger("knowledge/status/swebench_local.jrnl" as *u8, ln)
168 if (b as i64) == 0 { b = read_ledger("/home/elderwesto/nx_stage/swebench_local_ledger.log" as *u8, ln) }
169 if (b as i64) == 0 { return 0 }
170 let n: i64 = ln[0]
171 if n <= 0 { return 0 }
172 var p: i64 = 0
173 var found: i64 = 0
174 while p < n {
175 var e: i64 = p
176 var f: i64 = 0
177 while f == 0 { if e >= n { f = 1 } else { if b[e] == (10 as u8) { f = 1 } else { e = e + 1 } } }
178 if findf(b, p, e, "SWBL " as *u8) >= 0 {
179 var kk: i64 = int_after(b, p, e, "\"k\":" as *u8)
180 if kk == (0 - K_MAGIC_999999) { kk = int_after(b, p, e, "resolved=" as *u8) }
181 var nn: i64 = int_after(b, p, e, "\"n\":" as *u8)
182 if nn == (0 - K_MAGIC_999999) { nn = int_after(b, p, e, "total=" as *u8) }
183 if kk != (0 - K_MAGIC_999999) { if nn != (0 - K_MAGIC_999999) { kbox[0] = kk; nbox[0] = nn; found = 1 } }
184 }
185 p = e + 1
186 }
187 return found
188}
189
190func main(argc: i64, argv: *i64) -> i64 {
191 var jsonmode: i64 = 0
192 if argc >= 2 {
193 let a1: i64 = argv[1]
194 if streq(a1 as *u8, "json" as *u8) == 1 { jsonmode = 1 }
195 }
196 let ts: i64 = sys_now_realtime_sec()
197
198 // ---- load ledgers ----
199 let agn: *i64 = sys_mmap(8) as *i64
200 let ag: *u8 = read_ledger("/home/elderwesto/nx_stage/autograde_ledger.log" as *u8, agn)
201 let zcn: *i64 = sys_mmap(8) as *i64
202 let zc: *u8 = read_ledger("/home/elderwesto/nx_stage/zero_claude_ledger.log" as *u8, zcn)
203
204 // ---- last autograde run ts ----
205 var last_ts: i64 = 0
206 var p: i64 = 0
207 while p < agn[0] {
208 var e: i64 = p
209 var f: i64 = 0
210 while f == 0 { if e >= agn[0] { f = 1 } else { if ag[e] == (10 as u8) { f = 1 } else { e = e + 1 } } }
211 let t: i64 = int_after(ag, p, e, "ts=" as *u8)
212 if t > last_ts { last_ts = t }
213 p = e + 1
214 }
215
216 // ---- pull each target's verdict ----
217 let vbox: *i64 = sys_mmap(8) as *i64
218 vbox[0] = 0
219 let v_checker: i64 = target_verdict(ag, agn[0], last_ts, "codegen-grader-sound" as *u8, vbox)
220 let v_fixloop: i64 = target_verdict(ag, agn[0], last_ts, "autofix-loop-sound" as *u8, vbox)
221 let v_suite: i64 = target_verdict(ag, agn[0], last_ts, "codegen-ref-passrate" as *u8, vbox)
222 let v_gcc: i64 = target_verdict(ag, agn[0], last_ts, "exceed-gcc-scalar" as *u8, vbox)
223 let v_local: i64 = target_verdict(ag, agn[0], last_ts, "local-codegen-green" as *u8, vbox)
224 let swbbox: *i64 = sys_mmap(8) as *i64
225 swbbox[0] = 0
226 let v_swb: i64 = target_verdict(ag, agn[0], last_ts, "local-fix-resolve-rate" as *u8, swbbox)
227 var swbpct: i64 = 0
228 if swbbox[0] != (0 - K_MAGIC_999999) { swbpct = swbbox[0] }
229 let swbk: *i64 = sys_mmap(8) as *i64
230 let swbn: *i64 = sys_mmap(8) as *i64
231 let swb_has_kn: i64 = swbl_kn(swbk, swbn)
232 let zck: *i64 = sys_mmap(8) as *i64
233 let zcn2: *i64 = sys_mmap(8) as *i64
234 let zc_has_kn: i64 = zcl_kn(zck, zcn2)
235 let liftbox: *i64 = sys_mmap(8) as *i64
236 liftbox[0] = 0
237 let v_lift: i64 = target_verdict(ag, agn[0], last_ts, "zero-claude-lift" as *u8, liftbox)
238 var liftpct: i64 = 0
239 if liftbox[0] != (0 - K_MAGIC_999999) { liftpct = (liftbox[0] + 5) / 10 }
240
241 // ---- zero-claude trend runs (permille -> percent) ----
242 let modbuf: *u8 = sys_mmap(32)
243
244 if jsonmode == 1 {
245 w("{\"v\":2,\"api\":\"nishi-compare\",\"generated_unix\":" as *u8); wn(ts)
246 w(",\"domain\":\"autograde\",\"kind\":\"dashboard\",\"title\":\"Is our system standing on its own? -- live scoreboard\"" as *u8)
247 w(",\"plain_english\":true,\"measured_by\":\"the system itself (nx_autograde runs the tests; this page only translates the results)\"" as *u8)
248 w(",\"scoreboard\":[" as *u8)
249 w("{\"question\":\"Can we automatically check whether generated code is correct?\",\"answer\":\"" as *u8)
250 if v_checker == 1 { w("yes" as *u8) } else { w("not yet" as *u8) }
251 w("\"},{\"question\":\"Can the system find a bug, ask permission, fix it, and undo the fix?\",\"answer\":\"" as *u8)
252 if v_fixloop == 1 { w("yes" as *u8) } else { w("not yet" as *u8) }
253 w("\"},{\"question\":\"How much of the work runs with zero Claude cost?\",\"answer\":\"" as *u8)
254 if zc_has_kn == 1 { wn(zck[0]); w(" of " as *u8); wn(zcn2[0]); w(" tasks answered locally and verified (goal: all of them)" as *u8) } else { wn(liftpct); w(" per hundred, denominator not recorded by this host -- see the trend rows for k and n" as *u8) }
255 w("\"},{\"question\":\"Does the code test suite itself work?\",\"answer\":\"" as *u8)
256 if v_suite == 1 { w("yes" as *u8) } else { w("not yet" as *u8) }
257 w("\"},{\"question\":\"Is our own compiler as fast as the industry standard (gcc)?\",\"answer\":\"" as *u8)
258 if v_gcc == 0 { w("not measured yet -- we refuse to guess" as *u8) } else { if v_gcc == 1 { w("yes" as *u8) } else { w("not yet" as *u8) } }
259 w("\"},{\"question\":\"Can the local AI produce working code by itself?\",\"answer\":\"" as *u8)
260 if v_local == 1 { w("yes for small fixes: it finds the failing function itself, writes the fix, and the machine verifies it -- zero Claude" as *u8) } else { w("not yet" as *u8) }
261 w("\"},{\"question\":\"Graded by the industry bug-fixing benchmark's own rules (SWE-bench contract), what's our resolve rate?\",\"answer\":\"" as *u8)
262 if v_swb == 1 { if swb_has_kn == 1 { wn(swbk[0]); w(" of " as *u8); wn(swbn[0]); w(" sovereign-analog foreign-bug instances resolved under the SWE-bench contract (fix passes, nothing regresses); the rigor envelope publishes the 95 percent interval and n; not the Python set" as *u8) } else { w("resolved rate recorded without its denominator -- REFUSED until the fix-loop ledger is read; see the rigor envelope" as *u8) } } else { w("not measured yet" as *u8) }
263 w("\"}],\"claude_free_trend_percent\":[" as *u8)
264 var first: i64 = 1
265 p = 0
266 while p < zcn[0] {
267 var e3: i64 = p
268 var f3: i64 = 0
269 while f3 == 0 { if e3 >= zcn[0] { f3 = 1 } else { if zc[e3] == (10 as u8) { f3 = 1 } else { e3 = e3 + 1 } } }
270 let lp: i64 = int_after(zc, p, e3, "liftpm=" as *u8)
271 if lp != (0 - K_MAGIC_999999) {
272 tok_after(zc, p, e3, "model=" as *u8, modbuf, 32)
273 if first == 0 { w("," as *u8) }
274 first = 0
275 w("{\"local_model\":\"" as *u8); w(modbuf)
276 w("\",\"percent\":" as *u8); wn((lp + 5) / 10)
277 w("}" as *u8)
278 }
279 p = e3 + 1
280 }
281 w("]}" as *u8)
282 return 0
283 }
284
285 // ---------- HTML ----------
286 w("<!DOCTYPE html>\n<html lang=\"en\"><head><meta charset='utf-8'><meta name='viewport' content='width=device-width, initial-scale=1'>\n" as *u8)
287 w("<title>Is our system standing on its own? -- live scoreboard</title>\n" as *u8)
288 w("<style>body{font-family:-apple-system,Segoe UI,Roboto,sans-serif;max-width:760px;margin:0 auto;padding:0 20px 6vh;line-height:1.65;color:rgb(22,22,34)}h1{color:rgb(42,77,143);font-size:1.7rem}h2{font-size:1.15rem;margin-top:30px}.q{border:1px solid rgb(227,227,234);border-radius:12px;padding:14px 18px;margin:12px 0;box-shadow:0 1px 3px rgba(16,20,28,0.06)}.qq{font-weight:700;margin-bottom:6px}.chip{display:inline-block;font-size:.8rem;font-weight:800;padding:3px 12px;border-radius:20px;color:rgb(255,255,255);vertical-align:middle}.yes{background:rgb(20,130,70)}.notyet{background:rgb(200,120,30)}.nomeas{background:rgb(130,130,140)}.ans{font-size:.95rem;margin-left:8px}.trend{margin:10px 0}.tl{font-size:.9rem;margin-bottom:2px}.tb{background:rgb(236,238,245);border-radius:9px;height:26px;position:relative;overflow:hidden}.tf{background:linear-gradient(90deg,rgb(42,77,143),rgb(90,60,190));height:100%;border-radius:9px 0 0 9px}.tp{position:absolute;left:10px;top:2px;color:rgb(255,255,255);font-weight:800;font-size:.85rem}.mut{color:rgb(102,102,102);font-size:.85rem}@media(prefers-color-scheme:dark){body{background:rgb(15,15,20);color:rgb(230,230,238)}.q{border-color:rgb(38,38,47)}.tb{background:rgb(30,30,40)}}</style></head><body>\n" as *u8)
289 w("<p class='mut'><a href='/compare'>Nishi Compare</a> › Standing on our own</p>\n" as *u8)
290 w("<h1>Is our system standing on its own?</h1>\n" as *u8)
291 w("<p>We are building toward one goal: our own local system does the work, and Claude (the paid AI) is needed less and less. This scoreboard is measured <b>by the system itself</b> — it runs its own tests and reports what actually happened. It cannot be sweet-talked: anything not truly measured says <b>NOT MEASURED YET</b> instead of pretending.</p>\n" as *u8)
292
293 w("<h2>The scoreboard</h2>\n" as *u8)
294 row("Can we automatically check whether generated code is correct?" as *u8, v_checker,
295 "Our checker compiles the code, runs it, and compares the answers. It passed all its self-tests — including the important one: it correctly REJECTS wrong code instead of approving everything." as *u8)
296 row("Can the system find a bug, ask permission, fix it, and undo the fix?" as *u8, v_fixloop,
297 "Proven end to end: it spotted a planted bug on its own, wrote the finding to an approval queue (nothing changes without a person saying yes), applied the fix, re-tested it, and restored the original perfectly." as *u8)
298 // the lift row gets its own bar treatment below the chip
299 w("<div class='q'><div class='qq'>How much of the work already runs with zero Claude cost?</div><div>" as *u8)
300 if v_lift == 1 { w("<span class='chip yes'>✓ DONE</span>" as *u8) } else { w("<span class='chip notyet'>" as *u8); wn(liftpct); w("% SO FAR</span>" as *u8) }
301 w(" <span class='ans'>Goal: 100%. On our test set, " as *u8)
302 wn(liftpct)
303 w("% of tasks were answered by our own local model and verified correct by our own checker — no Claude involved, no tokens spent. The rest still get sent to Claude.</span></div>" as *u8)
304 w("<div class='trend' style='margin-top:10px'>" as *u8)
305 p = 0
306 var run: i64 = 0
307 while p < zcn[0] {
308 var e6: i64 = p
309 var f6: i64 = 0
310 while f6 == 0 { if e6 >= zcn[0] { f6 = 1 } else { if zc[e6] == (10 as u8) { f6 = 1 } else { e6 = e6 + 1 } } }
311 let lp6: i64 = int_after(zc, p, e6, "liftpm=" as *u8)
312 if lp6 != (0 - K_MAGIC_999999) {
313 run = run + 1
314 tok_after(zc, p, e6, "model=" as *u8, modbuf, 32)
315 let pct: i64 = (lp6 + 5) / 10
316 w("<div class='tl'>measurement " as *u8); wn(run)
317 w(" — local model size " as *u8); w(modbuf)
318 w("</div><div class='tb'><div class='tf' style='width:" as *u8)
319 wn(pct)
320 w("%'></div><div class='tp'>" as *u8)
321 wn(pct)
322 w("%</div></div>" as *u8)
323 }
324 p = e6 + 1
325 }
326 w("</div><div class='mut'>The jump came from upgrading the local model. Next jumps: teach it more skills, and train it on exactly the tasks it still hands to Claude.</div></div>\n" as *u8)
327
328 row("Does the code test suite itself work?" as *u8, v_suite,
329 "Health check: known-good solutions pass all tests (so a failure really means the code is wrong, not that the tests are broken)." as *u8)
330 // the gcc row renders the compiler lane's own lap ledger dynamically (value = ratio x1000; 1000 = parity)
331 let gccval: *i64 = sys_mmap(8) as *i64
332 gccval[0] = 0
333 let v_gcc2: i64 = target_verdict(ag, agn[0], last_ts, "exceed-gcc-scalar" as *u8, gccval)
334 w("<div class='q'><div class='qq'>Is our own compiler as fast as the industry standard (gcc)?</div><div>" as *u8)
335 if v_gcc2 == 1 { w("<span class='chip yes'>✓ YES</span> <span class='ans'>At or faster than gcc on the official measured lap — parity is the bar, and we cleared it.</span>" as *u8) }
336 else { if v_gcc2 == 2 {
337 let behind: i64 = (gccval[0] - 1000 + 5) / 10
338 w("<span class='chip notyet'>ALMOST — " as *u8)
339 wn(behind)
340 w("% SLOWER</span> <span class='ans'>Official lap from the compiler team's own ledger: " as *u8)
341 wn(behind)
342 w("% slower than gcc on the toughest scalar loop (and already faster than gcc on one benchmark). The register-allocator work now in progress is expected to close it; every new lap updates this row automatically.</span>" as *u8)
343 } else { w("<span class='chip nomeas'>NOT MEASURED YET</span> <span class='ans'>We refuse to guess: until an official lap is recorded, this row stays unmeasured.</span>" as *u8) } }
344 w("</div></div>\n" as *u8)
345
346 if v_swb == 1 {
347 w("<div class='q'><div class='qq'>Graded by the industry bug-fixing benchmark's own rules, how does our fixer score?</div><div><span class='chip yes'>✓ " as *u8)
348 wn(swbpct)
349 w("% RESOLVED</span> <span class='ans'>SWE-bench is the field's standard bug-fixing test: patch a real issue, and it only counts if the broken tests pass AND nothing that worked before breaks. We graded our own fix loop by that exact cheat-proof rule — it resolves " as *u8)
350 if swb_has_kn == 1 { wn(swbk[0]); w(" of " as *u8); wn(swbn[0]) } else { wn(swbpct); w("%" as *u8) }
351 w(" of our bug set (the denominator is on the record, and the rigor envelope carries the 95 percent interval). Honest scope: this is our own sovereign set under SWE-bench's rules, not its Python problems (a no-Python system can't run those); we claim the same standard, not parity with agents that run the real set.</span></div></div>\n" as *u8)
352 }
353 w("<h2>Can our local AI write working code by itself yet?</h2>\n" as *u8)
354 if v_local == 1 {
355 w("<p><b>YES for small fixes — with honest limits.</b> The local model now runs the whole repair loop on its own: it reads the test results to <b>find which function is broken</b>, pulls that function's source, writes the corrected code, and the independent checker confirms the repair — compiled, ran, exact right answers, zero Claude anywhere in the content. Proven on different bugs in different functions, including a repair shape it was never shown. Writing whole programs from scratch is still beyond it, so every remaining failure is saved automatically as training material. The checker is what keeps this honest: code only counts when it runs and produces exactly the right answer.</p>\n" as *u8)
356 } else {
357 w("<p><b>Not yet — and here is the honest picture.</b> The small model just parrots text back. The bigger model now writes real programs, but like a beginner: 2 of its last 3 programs compiled and ran, yet gave wrong answers (it invented variables it never defined, and guessed instead of reading the input). Every one of these failures is saved automatically and becomes training material. The checker above is what keeps this honest: a program only counts when it runs and produces exactly the right answer.</p>\n" as *u8)
358 }
359
360 w("<p class='mut'>Updated automatically each time the system re-measures itself. This page only translates the measurement records into plain English — the numbers come from the machine, not from anyone's opinion. <a href='/compare/autograde/api.json'>machine-readable version</a></p>\n</body></html>\n" as *u8)
361 return 0
362}