icoa-cli 2.19.348 → 2.19.349

package/dist/lib/sample-runner.js

@@ -1 +1,227 @@
-import{chmodSync as e,existsSync as n,mkdirSync as t,readFileSync as s,writeFileSync as r}from"node:fs";import{homedir as a}from"node:os";import{join as i}from"node:path";const o=i(a(),".icoa","bin");export const RUNNER_PY=i(o,"icoa-judge.py");const p=i(o,"icoa-judge");function l(e){try{return(s(e,"utf-8").split("\n",2)[1]||"").includes("ICOA-RUNNER v1")}catch{return!1}}export function placeSampleRunner(){try{if(n(RUNNER_PY)&&l(RUNNER_PY))return{ok:!0,path:RUNNER_PY,updated:!1};if(t(o,{recursive:!0}),r(RUNNER_PY,'#!/usr/bin/env python3\n# ICOA-RUNNER v1\n"""icoa-judge — tiny local sample-test runner for the ioipy Python informatics track.\n\nRuns YOUR Python solution against sample input/expected-output pairs, compares stdout,\nand reports PASS / WRONG / TLE / RUNTIME-ERROR plus the wall-clock time of each run.\n\nThis is a self-check on the SAMPLE cases only — a rough "is it correct and fast enough?"\nfeel. It is NOT the real judge (no hidden tests, no authoritative time/memory limit).\n\nUSAGE\n  icoa-judge SOLUTION.py [SAMPLES]\n    SAMPLES can be:\n      - a directory holding  1.in/1.out, 2.in/2.out, ...  (also accepts .ans/.expected/.exp)\n      - a single  case.in  (its expected output is the sibling  case.out)\n      - two files:  case.in  case.out\n      - omitted: auto-search ./samples, ./tests, a samples/ next to SOLUTION.py, or *.in here\n\nOPTIONS\n  --tl SECONDS   per-case soft time limit (default 5.0 — Python-friendly; a TLE here is a\n                 hint, not a verdict; the real limit is the contest\'s)\n  --py CMD       interpreter for your solution (default: python3; try  --py pypy3  for speed)\n  --raw          exact byte compare (default: whitespace-normalized — trailing spaces and\n                 trailing blank lines are ignored, the usual contest checker behaviour)\n"""\nimport argparse, glob, os, subprocess, sys, time\n\nOUT_EXTS = (".out", ".ans", ".expected", ".exp")\nC = sys.stdout.isatty()\ndef col(s, c): return f"\\033[{c}m{s}\\033[0m" if C else s\ndef green(s): return col(s, "32")\ndef red(s): return col(s, "31")\ndef yellow(s): return col(s, "33")\ndef gray(s): return col(s, "90")\n\ndef find_expected(in_path):\n    stem = in_path[:-3] if in_path.endswith(".in") else os.path.splitext(in_path)[0]\n    for ext in OUT_EXTS:\n        if os.path.exists(stem + ext):\n            return stem + ext\n    return None\n\ndef collect_cases(args):\n    sols_dir = os.path.dirname(os.path.abspath(args.solution)) or "."\n    # explicit: two files (in + out)\n    if args.samples and args.expected:\n        return [(args.samples, args.expected)]\n    # explicit: a single .in file\n    if args.samples and os.path.isfile(args.samples) and args.samples.endswith(".in"):\n        exp = find_expected(args.samples)\n        return [(args.samples, exp)] if exp else []\n    # explicit: a directory\n    if args.samples and os.path.isdir(args.samples):\n        search = [args.samples]\n    else:\n        search = ["samples", "tests", os.path.join(sols_dir, "samples"), "."]\n    for d in search:\n        if not os.path.isdir(d):\n            continue\n        ins = sorted(glob.glob(os.path.join(d, "*.in")))\n        cases = [(i, find_expected(i)) for i in ins]\n        cases = [(i, o) for (i, o) in cases if o]\n        if cases:\n            return cases\n    return []\n\ndef normalize(text, raw):\n    if raw:\n        return text\n    lines = [ln.rstrip() for ln in text.replace("\\r\\n", "\\n").split("\\n")]\n    while lines and lines[-1] == "":\n        lines.pop()\n    return "\\n".join(lines)\n\ndef first_diff(exp, got):\n    e, g = exp.split("\\n"), got.split("\\n")\n    for i in range(max(len(e), len(g))):\n        ev = e[i] if i < len(e) else "<no line>"\n        gv = g[i] if i < len(g) else "<no line>"\n        if ev != gv:\n            return i + 1, ev, gv\n    return None\n\ndef run_case(py, solution, in_path, tl):\n    with open(in_path, "rb") as f:\n        data = f.read()\n    t0 = time.perf_counter()\n    try:\n        p = subprocess.run([py, solution], input=data, stdout=subprocess.PIPE,\n                           stderr=subprocess.PIPE, timeout=tl)\n    except subprocess.TimeoutExpired:\n        return ("TLE", time.perf_counter() - t0, "", "")\n    except FileNotFoundError:\n        sys.exit(red(f"interpreter not found: {py}  (install it, or pass --py python3)"))\n    dt = time.perf_counter() - t0\n    if p.returncode != 0:\n        err = p.stderr.decode("utf-8", "replace").strip().splitlines()\n        return ("RE", dt, p.stdout.decode("utf-8", "replace"), (err[-1] if err else f"exit {p.returncode}"))\n    return ("OK", dt, p.stdout.decode("utf-8", "replace"), "")\n\ndef main():\n    ap = argparse.ArgumentParser(prog="icoa-judge", add_help=True)\n    ap.add_argument("solution")\n    ap.add_argument("samples", nargs="?")\n    ap.add_argument("expected", nargs="?")\n    ap.add_argument("--tl", type=float, default=5.0)\n    ap.add_argument("--py", default="python3")\n    ap.add_argument("--raw", action="store_true")\n    args = ap.parse_args()\n\n    if not os.path.isfile(args.solution):\n        sys.exit(red(f"solution file not found: {args.solution}"))\n    cases = collect_cases(args)\n    if not cases:\n        sys.exit(yellow("no sample cases found. Put 1.in/1.out next to your solution (or in "\n                        "./samples), or pass a directory / a case.in case.out pair."))\n\n    print(gray(f"icoa-judge — {args.py} · {len(cases)} sample case(s) · TL {args.tl:g}s "\n               f"(sample self-check, not the real judge)"))\n    passed = 0\n    slow = False\n    for idx, (in_path, exp_path) in enumerate(cases, 1):\n        name = os.path.basename(in_path)\n        status, dt, got, extra = run_case(args.py, args.solution, in_path, args.tl)\n        ms = f"{dt * 1000:7.1f} ms"\n        if status == "TLE":\n            print(f"  {red(\'TLE \')}  {name:<16} {gray(\'> \' + format(args.tl, \'g\') + \'s\')}")\n            slow = True\n            continue\n        if status == "RE":\n            print(f"  {red(\'ERR \')}  {name:<16} {gray(ms)}   {red(extra)}")\n            continue\n        exp = normalize(open(exp_path, encoding=\'utf-8\', errors=\'replace\').read(), args.raw)\n        out = normalize(got, args.raw)\n        if out == exp:\n            print(f"  {green(\'PASS\')}  {name:<16} {gray(ms)}")\n            passed += 1\n            if dt > 0.5 * args.tl:\n                slow = True\n        else:\n            d = first_diff(exp, out)\n            where = f"line {d[0]}" if d else "output"\n            print(f"  {red(\'WRONG\')} {name:<16} {gray(ms)}   {gray(where)}")\n            if d:\n                print(gray(f"        expected: {d[1][:70]}"))\n                print(gray(f"        got:      {d[2][:70]}"))\n\n    print()\n    tag = green("ALL PASS") if passed == len(cases) else yellow(f"{passed}/{len(cases)} passed")\n    print(f"  {tag}")\n    if slow and args.py != "pypy3":\n        print(gray("  (some runs were slow — if the real judge TLEs, try  --py pypy3,  faster I/O, "\n                   "or an iterative form. Sample timing is only a rough guide.)"))\n    sys.exit(0 if passed == len(cases) else 1)\n\nif __name__ == "__main__":\n    main()\n',"utf-8"),"win32"!==process.platform){try{e(RUNNER_PY,493)}catch{}r(p,`#!/bin/sh\nexec python3 "${RUNNER_PY}" "$@"\n`,"utf-8");try{e(p,493)}catch{}}return{ok:!0,path:RUNNER_PY,updated:!0}}catch(e){return{ok:!1,path:RUNNER_PY,updated:!1,why:e instanceof Error?e.message:String(e)}}}export function sampleRunnerInstalled(){return n(RUNNER_PY)&&l(RUNNER_PY)}
+// Local sample-test runner for the ioipy (Python informatics) track — Hard Rule §4.
+//
+// A tiny STDLIB-ONLY Python script shipped to the student's machine by `env setup`.
+// It runs their Python solution against sample input/output pairs, diffs stdout against
+// the expected output (whitespace-normalized), and prints a rough wall-clock time so they
+// get a *feel* for whether a solution is fast enough. It is deliberately NOT the
+// server-authoritative online judge (that hidden-test layer is the deferred §3 project) —
+// it only checks the SAMPLE cases the student already has, which is exactly what the learn
+// cards (P2+) ask them to do ("implement in Python and run it on the provided samples").
+//
+// The script content travels as a string in the compiled JS, so there is no asset to
+// bundle / resolve at runtime. `placeSampleRunner()` writes it to ~/.icoa/bin/.
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// Bump when the embedded script below changes, so an existing stale copy is rewritten.
+const SAMPLE_RUNNER_VERSION = '1';
+const RUNNER_DIR = join(homedir(), '.icoa', 'bin');
+export const RUNNER_PY = join(RUNNER_DIR, 'icoa-judge.py');
+const RUNNER_SHIM = join(RUNNER_DIR, 'icoa-judge');
+// The shipped runner. Pure Python 3 stdlib (subprocess, argparse, time, glob, sys, os).
+// `# ICOA-RUNNER vN` on line 2 lets us detect/refresh a stale copy.
+const JUDGE_SCRIPT = `#!/usr/bin/env python3
+# ICOA-RUNNER v${SAMPLE_RUNNER_VERSION}
+"""icoa-judge — tiny local sample-test runner for the ioipy Python informatics track.
+
+Runs YOUR Python solution against sample input/expected-output pairs, compares stdout,
+and reports PASS / WRONG / TLE / RUNTIME-ERROR plus the wall-clock time of each run.
+
+This is a self-check on the SAMPLE cases only — a rough "is it correct and fast enough?"
+feel. It is NOT the real judge (no hidden tests, no authoritative time/memory limit).
+
+USAGE
+  icoa-judge SOLUTION.py [SAMPLES]
+    SAMPLES can be:
+      - a directory holding  1.in/1.out, 2.in/2.out, ...  (also accepts .ans/.expected/.exp)
+      - a single  case.in  (its expected output is the sibling  case.out)
+      - two files:  case.in  case.out
+      - omitted: auto-search ./samples, ./tests, a samples/ next to SOLUTION.py, or *.in here
+
+OPTIONS
+  --tl SECONDS   per-case soft time limit (default 5.0 — Python-friendly; a TLE here is a
+                 hint, not a verdict; the real limit is the contest's)
+  --py CMD       interpreter for your solution (default: python3; try  --py pypy3  for speed)
+  --raw          exact byte compare (default: whitespace-normalized — trailing spaces and
+                 trailing blank lines are ignored, the usual contest checker behaviour)
+"""
+import argparse, glob, os, subprocess, sys, time
+
+OUT_EXTS = (".out", ".ans", ".expected", ".exp")
+C = sys.stdout.isatty()
+def col(s, c): return f"\\033[{c}m{s}\\033[0m" if C else s
+def green(s): return col(s, "32")
+def red(s): return col(s, "31")
+def yellow(s): return col(s, "33")
+def gray(s): return col(s, "90")
+
+def find_expected(in_path):
+    stem = in_path[:-3] if in_path.endswith(".in") else os.path.splitext(in_path)[0]
+    for ext in OUT_EXTS:
+        if os.path.exists(stem + ext):
+            return stem + ext
+    return None
+
+def collect_cases(args):
+    sols_dir = os.path.dirname(os.path.abspath(args.solution)) or "."
+    # explicit: two files (in + out)
+    if args.samples and args.expected:
+        return [(args.samples, args.expected)]
+    # explicit: a single .in file
+    if args.samples and os.path.isfile(args.samples) and args.samples.endswith(".in"):
+        exp = find_expected(args.samples)
+        return [(args.samples, exp)] if exp else []
+    # explicit: a directory
+    if args.samples and os.path.isdir(args.samples):
+        search = [args.samples]
+    else:
+        search = ["samples", "tests", os.path.join(sols_dir, "samples"), "."]
+    for d in search:
+        if not os.path.isdir(d):
+            continue
+        ins = sorted(glob.glob(os.path.join(d, "*.in")))
+        cases = [(i, find_expected(i)) for i in ins]
+        cases = [(i, o) for (i, o) in cases if o]
+        if cases:
+            return cases
+    return []
+
+def normalize(text, raw):
+    if raw:
+        return text
+    lines = [ln.rstrip() for ln in text.replace("\\r\\n", "\\n").split("\\n")]
+    while lines and lines[-1] == "":
+        lines.pop()
+    return "\\n".join(lines)
+
+def first_diff(exp, got):
+    e, g = exp.split("\\n"), got.split("\\n")
+    for i in range(max(len(e), len(g))):
+        ev = e[i] if i < len(e) else "<no line>"
+        gv = g[i] if i < len(g) else "<no line>"
+        if ev != gv:
+            return i + 1, ev, gv
+    return None
+
+def run_case(py, solution, in_path, tl):
+    with open(in_path, "rb") as f:
+        data = f.read()
+    t0 = time.perf_counter()
+    try:
+        p = subprocess.run([py, solution], input=data, stdout=subprocess.PIPE,
+                           stderr=subprocess.PIPE, timeout=tl)
+    except subprocess.TimeoutExpired:
+        return ("TLE", time.perf_counter() - t0, "", "")
+    except FileNotFoundError:
+        sys.exit(red(f"interpreter not found: {py}  (install it, or pass --py python3)"))
+    dt = time.perf_counter() - t0
+    if p.returncode != 0:
+        err = p.stderr.decode("utf-8", "replace").strip().splitlines()
+        return ("RE", dt, p.stdout.decode("utf-8", "replace"), (err[-1] if err else f"exit {p.returncode}"))
+    return ("OK", dt, p.stdout.decode("utf-8", "replace"), "")
+
+def main():
+    ap = argparse.ArgumentParser(prog="icoa-judge", add_help=True)
+    ap.add_argument("solution")
+    ap.add_argument("samples", nargs="?")
+    ap.add_argument("expected", nargs="?")
+    ap.add_argument("--tl", type=float, default=5.0)
+    ap.add_argument("--py", default="python3")
+    ap.add_argument("--raw", action="store_true")
+    args = ap.parse_args()
+
+    if not os.path.isfile(args.solution):
+        sys.exit(red(f"solution file not found: {args.solution}"))
+    cases = collect_cases(args)
+    if not cases:
+        sys.exit(yellow("no sample cases found. Put 1.in/1.out next to your solution (or in "
+                        "./samples), or pass a directory / a case.in case.out pair."))
+
+    print(gray(f"icoa-judge — {args.py} · {len(cases)} sample case(s) · TL {args.tl:g}s "
+               f"(sample self-check, not the real judge)"))
+    passed = 0
+    slow = False
+    for idx, (in_path, exp_path) in enumerate(cases, 1):
+        name = os.path.basename(in_path)
+        status, dt, got, extra = run_case(args.py, args.solution, in_path, args.tl)
+        ms = f"{dt * 1000:7.1f} ms"
+        if status == "TLE":
+            print(f"  {red('TLE ')}  {name:<16} {gray('> ' + format(args.tl, 'g') + 's')}")
+            slow = True
+            continue
+        if status == "RE":
+            print(f"  {red('ERR ')}  {name:<16} {gray(ms)}   {red(extra)}")
+            continue
+        exp = normalize(open(exp_path, encoding='utf-8', errors='replace').read(), args.raw)
+        out = normalize(got, args.raw)
+        if out == exp:
+            print(f"  {green('PASS')}  {name:<16} {gray(ms)}")
+            passed += 1
+            if dt > 0.5 * args.tl:
+                slow = True
+        else:
+            d = first_diff(exp, out)
+            where = f"line {d[0]}" if d else "output"
+            print(f"  {red('WRONG')} {name:<16} {gray(ms)}   {gray(where)}")
+            if d:
+                print(gray(f"        expected: {d[1][:70]}"))
+                print(gray(f"        got:      {d[2][:70]}"))
+
+    print()
+    tag = green("ALL PASS") if passed == len(cases) else yellow(f"{passed}/{len(cases)} passed")
+    print(f"  {tag}")
+    if slow and args.py != "pypy3":
+        print(gray("  (some runs were slow — if the real judge TLEs, try  --py pypy3,  faster I/O, "
+                   "or an iterative form. Sample timing is only a rough guide.)"))
+    sys.exit(0 if passed == len(cases) else 1)
+
+if __name__ == "__main__":
+    main()
+`;
+function isCurrent(path) {
+    try {
+        const head = readFileSync(path, 'utf-8').split('\n', 2)[1] || '';
+        return head.includes(`ICOA-RUNNER v${SAMPLE_RUNNER_VERSION}`);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Write the runner to ~/.icoa/bin/icoa-judge.py (+ a `icoa-judge` shell shim on POSIX).
+ * Idempotent: rewrites only if missing or stale (older version line). Stdlib-only —
+ * needs nothing installed beyond a working python3 the student already has.
+ */
+export function placeSampleRunner() {
+    try {
+        if (existsSync(RUNNER_PY) && isCurrent(RUNNER_PY)) {
+            return { ok: true, path: RUNNER_PY, updated: false };
+        }
+        mkdirSync(RUNNER_DIR, { recursive: true });
+        writeFileSync(RUNNER_PY, JUDGE_SCRIPT, 'utf-8');
+        if (process.platform !== 'win32') {
+            try {
+                chmodSync(RUNNER_PY, 0o755);
+            }
+            catch {
+                /* non-fatal */
+            }
+            // Convenience shim so the student can type `icoa-judge ...` once ~/.icoa/bin is on PATH.
+            writeFileSync(RUNNER_SHIM, `#!/bin/sh\nexec python3 "${RUNNER_PY}" "$@"\n`, 'utf-8');
+            try {
+                chmodSync(RUNNER_SHIM, 0o755);
+            }
+            catch {
+                /* non-fatal */
+            }
+        }
+        return { ok: true, path: RUNNER_PY, updated: true };
+    }
+    catch (e) {
+        return { ok: false, path: RUNNER_PY, updated: false, why: e instanceof Error ? e.message : String(e) };
+    }
+}
+/** Is a current copy of the runner present? (for `env` status display) */
+export function sampleRunnerInstalled() {
+    return existsSync(RUNNER_PY) && isCurrent(RUNNER_PY);
+}

package/dist/lib/shell-split.js

@@ -1 +1,69 @@
-export function shellSplit(t){const e=[];let l="",n=!1,s=!1,h=!1;for(let o=0;o<t.length;o++){const p=t[o];n?("'"===p?n=!1:l+=p,h=!0):s?('"'===p?s=!1:"\\"!==p||'"'!==t[o+1]&&"\\"!==t[o+1]?l+=p:l+=t[++o],h=!0):"'"===p?(n=!0,h=!0):'"'===p?(s=!0,h=!0):"\\"===p&&o+1<t.length?(l+=t[++o],h=!0):/\s/.test(p)?h&&(e.push(l),l="",h=!1):(l+=p,h=!0)}return h&&e.push(l),e}
+/**
+ * shellSplit — a minimal, quote-aware tokenizer for REPL commands that forward
+ * raw args straight to a child process (currently `aienv run` / `aienv python`).
+ *
+ * The icoa REPL is NOT a shell: the default command split on /\s+/ turns quotes
+ * into literal characters and tears spaced args apart, so `aienv run "my file.py"`
+ * and `aienv python -c "print(1 + 1)"` reach python mangled. This honours
+ * single/double quotes (and backslash escapes inside double quotes / outside
+ * quotes) the way a real shell would tokenize them. (Direct-CLI invocation never
+ * needs this — there the system shell does the tokenization for us.)
+ *
+ * Scope is deliberately small: word-splitting + quote removal + backslash
+ * escapes. No globbing, no variable/`$()` expansion, no `~` expansion — the
+ * child process / caller handles paths, and we explicitly do not want shell
+ * metacharacter semantics in the REPL.
+ */
+export function shellSplit(input) {
+    const tokens = [];
+    let cur = '';
+    let inSingle = false;
+    let inDouble = false;
+    let hasTok = false; // so an explicit "" / '' still yields an empty-string arg
+    for (let i = 0; i < input.length; i++) {
+        const c = input[i];
+        if (inSingle) {
+            // Inside single quotes everything is literal until the closing quote.
+            if (c === "'")
+                inSingle = false;
+            else
+                cur += c;
+            hasTok = true;
+        }
+        else if (inDouble) {
+            if (c === '"')
+                inDouble = false;
+            else if (c === '\\' && (input[i + 1] === '"' || input[i + 1] === '\\'))
+                cur += input[++i];
+            else
+                cur += c;
+            hasTok = true;
+        }
+        else if (c === "'") {
+            inSingle = true;
+            hasTok = true;
+        }
+        else if (c === '"') {
+            inDouble = true;
+            hasTok = true;
+        }
+        else if (c === '\\' && i + 1 < input.length) {
+            cur += input[++i];
+            hasTok = true;
+        }
+        else if (/\s/.test(c)) {
+            if (hasTok) {
+                tokens.push(cur);
+                cur = '';
+                hasTok = false;
+            }
+        }
+        else {
+            cur += c;
+            hasTok = true;
+        }
+    }
+    if (hasTok)
+        tokens.push(cur);
+    return tokens;
+}

package/dist/lib/sim-cooldown.js

@@ -1 +1,75 @@
-import{mkdirSync as t,readFileSync as n,writeFileSync as o}from"node:fs";import{join as r}from"node:path";import{homedir as e}from"node:os";export const COOLDOWN_SECONDS=60;const l=r(e(),".icoa","sim-cooldown.json");function a(){try{const t=n(l,"utf-8"),o=JSON.parse(t);return"object"==typeof o&&null!==o?o:{}}catch{return{}}}function s(n){try{t(r(e(),".icoa"),{recursive:!0});const s={...a(),...n};o(l,JSON.stringify(s))}catch{}}export function lastSimAt(){const t=a();return"number"==typeof t.lastCallAt?t.lastCallAt:0}export function markSimAt(t){s({lastCallAt:t})}export function cooldownRemaining(){const t=(Date.now()-lastSimAt())/1e3;return Math.max(0,Math.ceil(60-t))}export function lastBundledAt(){const t=a();return"number"==typeof t.lastBundledAt?t.lastBundledAt:0}export function markBundledAt(t){s({lastBundledAt:t})}export function lastArmAt(){const t=a();return"number"==typeof t.lastArmAt?t.lastArmAt:0}export function markArmAt(t){s({lastArmAt:t})}export function hasAnySimHistory(){const t=a();return"number"==typeof t.lastBundledAt&&t.lastBundledAt>0||"number"==typeof t.lastCallAt&&t.lastCallAt>0||"number"==typeof t.lastArmAt&&t.lastArmAt>0}
+/**
+ * Shared 60s cooldown for any client-side caller of the MuJoCo sim
+ * endpoint (`/api/ai/vla/41/sim`). Both `icoa sim <scenario>` and
+ * `icoa demo2`'s parameter mode hit the same render pipeline; the
+ * cooldown lives in a file so they share one budget.
+ *
+ * Why: render is CPU-heavy shared infrastructure. 60s/student keeps
+ * concurrent load survivable.
+ *
+ * Two additional fields piggy-back on the same file so demo2 can detect
+ * what a user has already experienced (bundled dance / interactive arm).
+ * These do NOT gate anything — they are continuity signals only.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+export const COOLDOWN_SECONDS = 60;
+const COOLDOWN_FILE = join(homedir(), '.icoa', 'sim-cooldown.json');
+function readFile() {
+    try {
+        const raw = readFileSync(COOLDOWN_FILE, 'utf-8');
+        const j = JSON.parse(raw);
+        return typeof j === 'object' && j !== null ? j : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeMerge(patch) {
+    try {
+        mkdirSync(join(homedir(), '.icoa'), { recursive: true });
+        const merged = { ...readFile(), ...patch };
+        writeFileSync(COOLDOWN_FILE, JSON.stringify(merged));
+    }
+    catch {
+        // Non-fatal: cooldown is convenience, not security
+    }
+}
+export function lastSimAt() {
+    const f = readFile();
+    return typeof f.lastCallAt === 'number' ? f.lastCallAt : 0;
+}
+export function markSimAt(t) {
+    writeMerge({ lastCallAt: t });
+}
+/** Seconds remaining (0 if clear). */
+export function cooldownRemaining() {
+    const since = (Date.now() - lastSimAt()) / 1000;
+    return Math.max(0, Math.ceil(COOLDOWN_SECONDS - since));
+}
+// ─── Continuity signals (not used for gating) ────────────────────────────
+export function lastBundledAt() {
+    const f = readFile();
+    return typeof f.lastBundledAt === 'number' ? f.lastBundledAt : 0;
+}
+export function markBundledAt(t) {
+    writeMerge({ lastBundledAt: t });
+}
+export function lastArmAt() {
+    const f = readFile();
+    return typeof f.lastArmAt === 'number' ? f.lastArmAt : 0;
+}
+export function markArmAt(t) {
+    writeMerge({ lastArmAt: t });
+}
+/**
+ * Has the user seen any sim render — bundled, server, or arm — at least once?
+ * Used by demo2 + boot screen to switch from "first time" to "continue" copy.
+ */
+export function hasAnySimHistory() {
+    const f = readFile();
+    return ((typeof f.lastBundledAt === 'number' && f.lastBundledAt > 0) ||
+        (typeof f.lastCallAt === 'number' && f.lastCallAt > 0) ||
+        (typeof f.lastArmAt === 'number' && f.lastArmAt > 0));
+}

package/dist/lib/theme.js

@@ -1 +1,119 @@
-const e="]110]111]112",t="";function s(){if(!process.stdout.isTTY)return!1;const e=process.stdout.getColorDepth?.();return"number"!=typeof e||e>=8}function r(){return"1"===process.env.ICOA_TERMINAL}let o=!1;export function setTerminalTheme(n="dark"){if(!s())return;if(r())return;const c="high-contrast"===n?"]10;#FFFFFF]11;#000000]12;#FFFFFF":"]10;#A9B7C6]11;#2B2B2B]12;#A9B7C6",i="Apple_Terminal"===process.env.TERM_PROGRAM?"high-contrast"===n?"":"":"high-contrast"===n?"":"";if(process.stdout.write(c+i),!o){o=!0;const s=()=>{try{process.stdout.write(e+t)}catch{}};process.on("exit",s),process.on("SIGINT",()=>{s(),process.exit(130)}),process.on("SIGTERM",()=>{s(),process.exit(143)}),process.on("SIGHUP",()=>{s(),process.exit(129)})}}export function resetTerminalTheme(){s()&&(r()||process.stdout.write(e+t))}
+// Unified Darcula terminal theme — works across macOS Terminal.app, iTerm2,
+// GNOME Terminal, Konsole, Windows Terminal (cmd/PowerShell/WSL).
+//
+// Three mechanisms are combined so every modern terminal gets the best it can:
+//
+//   1. OSC 10/11/12 sets the terminal's *default* fg/bg/cursor colors.
+//      Honored by iTerm2, GNOME Terminal, Konsole, Windows Terminal → lossless
+//      background, no scrollback or resize artifacts. Ignored by Terminal.app.
+//
+//   2. SGR 38;2/48;2 + \x1b[2J paints with 24-bit truecolor Darcula on every
+//      terminal that supports truecolor. This is the default path.
+//
+//   3. SGR 38;5/48;5 + \x1b[2J paints with 256-color approximation on macOS
+//      Terminal.app. Terminal.app does NOT support truecolor SGR and mis-parses
+//      `\x1b[48;2;43;43;43m` as a sequence of 16-color codes — the trailing
+//      `43` becomes ANSI "bg yellow", which is why v2.19.23/24 rendered with a
+//      yellow background there. Color 235 ≈ #262626 (dark gray, ~#2B2B2B) and
+//      color 250 ≈ #BCBCBC (light gray, ~#A9B7C6) are close enough.
+//
+// Legacy cmd.exe (pre-Win10 1809) can't run Node 22 anyway, so no separate
+// fallback path is needed.
+const OSC_INIT_DARK = '\x1b]10;#A9B7C6\x07' + // default fg
+    '\x1b]11;#2B2B2B\x07' + // default bg
+    '\x1b]12;#A9B7C6\x07'; // cursor color
+// High-contrast: pure black bg + pure white fg. For students with low vision
+// or screens where Darcula's subtle grays wash out (e.g., projectors, cheap
+// LCDs under fluorescent light). Still works with existing chalk colors —
+// cyan/green/yellow/red all show up clearly against pure black.
+const OSC_INIT_HC = '\x1b]10;#FFFFFF\x07' + '\x1b]11;#000000\x07' + '\x1b]12;#FFFFFF\x07';
+const OSC_RESET = '\x1b]110\x07' + // reset default fg
+    '\x1b]111\x07' + // reset default bg
+    '\x1b]112\x07'; // reset cursor color
+const SGR_INIT_TRUECOLOR_DARK = '\x1b[38;2;169;183;198m' + // fg #A9B7C6
+    '\x1b[48;2;43;43;43m' + // bg #2B2B2B
+    '\x1b[2J' +
+    '\x1b[H';
+const SGR_INIT_256_DARK = '\x1b[38;5;250m' + // fg ≈ #BCBCBC
+    '\x1b[48;5;235m' + // bg ≈ #262626
+    '\x1b[2J' +
+    '\x1b[H';
+const SGR_INIT_TRUECOLOR_HC = '\x1b[38;2;255;255;255m' + // fg pure white
+    '\x1b[48;2;0;0;0m' + // bg pure black
+    '\x1b[2J' +
+    '\x1b[H';
+const SGR_INIT_256_HC = '\x1b[38;5;231m' + // fg white (231 = pure white in 256)
+    '\x1b[48;5;16m' + // bg black (16 = pure black in 256)
+    '\x1b[2J' +
+    '\x1b[H';
+const SGR_RESET = '\x1b[0m\x1b[2J\x1b[H';
+function supportsAnsi() {
+    if (!process.stdout.isTTY)
+        return false;
+    const depth = process.stdout.getColorDepth?.();
+    if (typeof depth === 'number')
+        return depth >= 8;
+    return true;
+}
+// When icoa-cli runs inside the ICOA Terminal (Tauri + xterm.js), the host is
+// already pre-themed to the exact Darcula palette we'd be setting. Every OSC
+// and SGR we'd emit is a no-op in terms of color, but the \x1b[2J inside our
+// init/reset sequences would clear the grid visibly. Skip the paint entirely
+// in that environment so the banner simply appears in the shell cursor
+// position and scrollback is preserved on exit.
+function isIcoaTerminal() {
+    return process.env.ICOA_TERMINAL === '1';
+}
+// macOS Terminal.app does not implement SGR truecolor (\x1b[38;2;… / \x1b[48;2;…)
+// and mis-parses those sequences as 16-color codes, producing e.g. a yellow bg.
+// Detect it and fall back to 256-color SGR which Terminal.app handles correctly.
+function isAppleTerminal() {
+    return process.env.TERM_PROGRAM === 'Apple_Terminal';
+}
+let armed = false;
+export function setTerminalTheme(variant = 'dark') {
+    if (!supportsAnsi())
+        return;
+    if (isIcoaTerminal())
+        return; // host is already Darcula; nothing to do
+    const osc = variant === 'high-contrast' ? OSC_INIT_HC : OSC_INIT_DARK;
+    const sgr = isAppleTerminal()
+        ? variant === 'high-contrast'
+            ? SGR_INIT_256_HC
+            : SGR_INIT_256_DARK
+        : variant === 'high-contrast'
+            ? SGR_INIT_TRUECOLOR_HC
+            : SGR_INIT_TRUECOLOR_DARK;
+    process.stdout.write(osc + sgr);
+    if (!armed) {
+        armed = true;
+        // Belt-and-braces cleanup on every exit path. Without these, Ctrl+C leaves
+        // the user's shell stuck with our SGR state.
+        const cleanup = () => {
+            try {
+                process.stdout.write(OSC_RESET + SGR_RESET);
+            }
+            catch { }
+        };
+        process.on('exit', cleanup);
+        process.on('SIGINT', () => {
+            cleanup();
+            process.exit(130);
+        });
+        process.on('SIGTERM', () => {
+            cleanup();
+            process.exit(143);
+        });
+        process.on('SIGHUP', () => {
+            cleanup();
+            process.exit(129);
+        });
+    }
+}
+export function resetTerminalTheme() {
+    if (!supportsAnsi())
+        return;
+    if (isIcoaTerminal())
+        return; // nothing to undo
+    process.stdout.write(OSC_RESET + SGR_RESET);
+}

package/dist/lib/token-format.js

@@ -1 +1,74 @@
-export const CROCKFORD="0123456789ABCDEFGHJKMNPQRSTVWXYZ";const o=new Set(CROCKFORD),e={};for(let n=0;n<32;n++)e[CROCKFORD[n]]=n;export const PREFIX_LEN=2;export const BODY_RANDOM_LEN=7;export const TOKEN_LEN=10;const t={O:"0",I:"1",L:"1",U:"V"};export function normalizeConfusables(o){let e="";for(const n of o.toUpperCase())e+=t[n]??n;return e}export function normalizeTokenBody(o){const e=o.trim().toUpperCase();return e.length<=2?e:e.slice(0,2)+normalizeConfusables(e.slice(2))}export function checksumChar(o){let t=0;for(const n of o)t+=e[n]??0;return CROCKFORD[t%32]}export function validBody(e){if(8!==e.length)return!1;for(const t of e)if(!o.has(t))return!1;return checksumChar(e.slice(0,7))===e[7]}export function validTokenChecksum(o){const e=o.trim().toUpperCase();return 10===e.length&&validBody(e.slice(2))}
+/**
+ * Client mirror of panda/token_alphabet.py — the confusable-free token rule.
+ *
+ * Tokens are <2-char prefix> + <7 random Crockford chars> + <1 checksum char>.
+ * Crockford Base32 excludes I, L, O, U (look like 1, 1, 0, V) so a token copied
+ * off a PDF or dictated aloud can't be mistranscribed.
+ *
+ * Two helpers used at token entry:
+ *  - normalizeTokenBody(): fix look-alikes a human typed (O→0, I/L→1, U→V) in
+ *    the BODY only (prefix is a fixed track/country code, may contain I/O).
+ *  - validTokenChecksum(): verify the trailing Crockford checksum.
+ *
+ * IMPORTANT backward-compat note: tokens issued before 2026-06-07 used the full
+ * 36-char alphabet and have NO valid checksum (and ~61% of learn tokens contain
+ * a real I/L/O/U in the body). So on the LEARN path normalization must be a
+ * FALLBACK (try literal first) and checksum must NEVER hard-block — the server
+ * stays authoritative (BUG-001). Exam tokens have always been Crockford+checksum
+ * so both helpers are safe to apply directly there.
+ */
+export const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+const CROCKFORD_SET = new Set(CROCKFORD);
+const CROCKFORD_INDEX = {};
+for (let i = 0; i < CROCKFORD.length; i++)
+    CROCKFORD_INDEX[CROCKFORD[i]] = i;
+export const PREFIX_LEN = 2;
+export const BODY_RANDOM_LEN = 7;
+export const TOKEN_LEN = PREFIX_LEN + BODY_RANDOM_LEN + 1; // 10
+// Look-alikes a human types → their Crockford canonical char.
+const CONFUSABLE_MAP = { O: '0', I: '1', L: '1', U: 'V' };
+/** Replace confusable letters in a string (uppercased first). */
+export function normalizeConfusables(s) {
+    let out = '';
+    for (const ch of s.toUpperCase())
+        out += CONFUSABLE_MAP[ch] ?? ch;
+    return out;
+}
+/**
+ * Normalize a token's BODY only — the 2-char prefix is a fixed track/country
+ * code (e.g. EI / IO legitimately contain I/O) and must NOT be transformed.
+ * Returns the trimmed, upper-cased token with body confusables canonicalized.
+ */
+export function normalizeTokenBody(token) {
+    const t = token.trim().toUpperCase();
+    if (t.length <= PREFIX_LEN)
+        return t;
+    return t.slice(0, PREFIX_LEN) + normalizeConfusables(t.slice(PREFIX_LEN));
+}
+/** 1-char Crockford mod-32 checksum over the payload chars. */
+export function checksumChar(payload) {
+    let total = 0;
+    for (const ch of payload)
+        total += CROCKFORD_INDEX[ch] ?? 0;
+    return CROCKFORD[total % 32];
+}
+/** True iff `body` is 7 Crockford chars + 1 correct checksum char. */
+export function validBody(body) {
+    if (body.length !== BODY_RANDOM_LEN + 1)
+        return false;
+    for (const ch of body)
+        if (!CROCKFORD_SET.has(ch))
+            return false;
+    return checksumChar(body.slice(0, BODY_RANDOM_LEN)) === body[BODY_RANDOM_LEN];
+}
+/**
+ * Whole-token checksum check for a 10-char `<prefix><body>` token. Returns
+ * false for old (pre-checksum) tokens — only meaningful as a *soft* signal on
+ * the learn path; authoritative only for exam tokens.
+ */
+export function validTokenChecksum(token) {
+    const t = token.trim().toUpperCase();
+    if (t.length !== TOKEN_LEN)
+        return false;
+    return validBody(t.slice(PREFIX_LEN));
+}

package/dist/lib/toolset-hash.js

@@ -1 +1,48 @@
-import{createHash as t}from"node:crypto";import{readFileSync as o,writeFileSync as r}from"node:fs";import{join as e}from"node:path";import{platform as n}from"node:os";import{getIcoaDir as s}from"./config.js";const h=()=>e(s(),"toolset-hash.json");export function computeAndCacheToolsetHash(o){const e=o.map(t=>`${t.name}=${(t.version||"").trim()}`).sort().join("\n"),s=t("sha256").update(e).digest("hex").slice(0,16),a={hash:s,platform:n(),count:o.length,computedAt:(new Date).toISOString()};try{r(h(),JSON.stringify(a))}catch{}return s}export function getCachedToolsetHash(){try{const t=JSON.parse(o(h(),"utf-8"));return"string"==typeof t.hash&&t.hash?t.hash:void 0}catch{return}}
+import { createHash } from 'node:crypto';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { platform } from 'node:os';
+import { getIcoaDir } from './config.js';
+// T3 — environment fingerprint (FORENSIC, not a gate).
+//
+// Hashes the {name=version} of the sanctioned toolset detected on this host.
+// Reported at exam start and stored server-side so a reviewer can compare
+// environments across students (and spot a session whose env fingerprint
+// changed). Honest limits: this proves which sanctioned tools/versions are
+// PRESENT — it does NOT prove the ABSENCE of forbidden tools, and the expected
+// value differs per platform (mac/ubuntu/WSL ship different versions). So it is
+// a comparison fingerprint, never a pass/fail check. See icoa2026event/07.
+const CACHE = () => join(getIcoaDir(), 'toolset-hash.json');
+/** Compute the hash over (name=version) pairs, persist it, return the hash.
+ *  Called once at the end of `env setup` so the exam-start path only READS. */
+export function computeAndCacheToolsetHash(entries) {
+    const norm = entries
+        .map((e) => `${e.name}=${(e.version || '').trim()}`)
+        .sort()
+        .join('\n');
+    const hash = createHash('sha256').update(norm).digest('hex').slice(0, 16);
+    const rec = {
+        hash,
+        platform: platform(),
+        count: entries.length,
+        computedAt: new Date().toISOString(),
+    };
+    try {
+        writeFileSync(CACHE(), JSON.stringify(rec));
+    }
+    catch {
+        /* best-effort — a missing cache just means no env fingerprint is reported */
+    }
+    return hash;
+}
+/** Read the cached env-fingerprint hash. Returns undefined if `env setup` has
+ *  not run (so the exam start path never blocks or spawns 30 version probes). */
+export function getCachedToolsetHash() {
+    try {
+        const rec = JSON.parse(readFileSync(CACHE(), 'utf-8'));
+        return typeof rec.hash === 'string' && rec.hash ? rec.hash : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}