From 053aeff71d7cf05663dc573942398133d42e3798 Mon Sep 17 00:00:00 2001
From: mbn <66748817+mbn-code@users.noreply.github.com>
Date: Tue, 15 Sep 2026 20:56:58 +0200
Subject: [PATCH 1/7] feat(engine): compile cache, diagnostics, checkers,
 statement parser, hardened routes

- cache compiled binaries by compiler/std/flags/source with LRU eviction and
  in-flight coalescing; report cached, diagnostics and rejectedFlags on every
  compile
- parse gcc/clang stderr into structured line/column diagnostics
- add tokens and float checkers next to the lines checker and flag
  presentation-only mismatches
- parse pasted Codeforces/AtCoder statements into samples and limits
  (POST /api/samples)
- validate compiler flags against an allowlist; reject path traversal in
  /api/solution and /api/problem-text; 400 on malformed JSON everywhere
- store: atomic writes, whole-workspace records, duplicate, export/import
- /api/test: checker, epsilon, stopOnFirstFailure, SKIPPED, timing summary
- /api/stress: compilerFlags, checker, seedBase, elapsed and timing stats,
  60s budget
- /api/config: version, compiler version, limits, cache size and reset
- vitest unit suite covering the engine against the real compiler
---
 web/app/api/_engine/compare.test.ts     |  118 ++
 web/app/api/_engine/compare.ts          |  157 +-
 web/app/api/_engine/cpp.test.ts         |  138 ++
 web/app/api/_engine/cpp.ts              |  348 ++++-
 web/app/api/_engine/diagnostics.test.ts |   67 +
 web/app/api/_engine/diagnostics.ts      |   71 +
 web/app/api/_engine/flags.test.ts       |   74 +
 web/app/api/_engine/flags.ts            |  131 ++
 web/app/api/_engine/request.ts          |   71 +
 web/app/api/_engine/statement.test.ts   |   80 +
 web/app/api/_engine/statement.ts        |  206 +++
 web/app/api/_engine/store.test.ts       |  146 ++
 web/app/api/_engine/store.ts            |  294 +++-
 web/app/api/config/route.ts             |   89 +-
 web/app/api/problem-text/route.ts       |   26 +-
 web/app/api/problems/route.ts           |  113 +-
 web/app/api/run/route.ts                |   87 +-
 web/app/api/samples/route.ts            |   31 +
 web/app/api/solution/route.ts           |   24 +-
 web/app/api/stress/route.ts             |  240 +--
 web/app/api/template/route.ts           |   21 +-
 web/app/api/test/route.ts               |  192 ++-
 web/package-lock.json                   | 1907 ++++++++++++++++++++---
 web/package.json                        |   15 +-
 web/vitest.config.ts                    |   21 +
 25 files changed, 4017 insertions(+), 650 deletions(-)
 create mode 100644 web/app/api/_engine/compare.test.ts
 create mode 100644 web/app/api/_engine/cpp.test.ts
 create mode 100644 web/app/api/_engine/diagnostics.test.ts
 create mode 100644 web/app/api/_engine/diagnostics.ts
 create mode 100644 web/app/api/_engine/flags.test.ts
 create mode 100644 web/app/api/_engine/flags.ts
 create mode 100644 web/app/api/_engine/request.ts
 create mode 100644 web/app/api/_engine/statement.test.ts
 create mode 100644 web/app/api/_engine/statement.ts
 create mode 100644 web/app/api/_engine/store.test.ts
 create mode 100644 web/app/api/samples/route.ts
 create mode 100644 web/vitest.config.ts

diff --git a/web/app/api/_engine/compare.test.ts b/web/app/api/_engine/compare.test.ts
new file mode 100644
index 0000000..0179a41
--- /dev/null
+++ b/web/app/api/_engine/compare.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import {
+  compareOutputs,
+  normalize,
+  tokenize,
+  tokensEqual,
+  parseCheckerMode,
+  parseEpsilon,
+} from "./compare";
+
+describe("normalize", () => {
+  it("strips CRLF, trailing spaces and trailing blank lines", () => {
+    expect(normalize("1 2 \r\n3\t\r\n\r\n\r\n")).toBe("1 2\n3");
+  });
+  it("keeps leading whitespace and interior blank lines", () => {
+    expect(normalize("  a\n\nb\n")).toBe("  a\n\nb");
+  });
+});
+
+describe("compareOutputs (lines)", () => {
+  it("matches identical output modulo trailing whitespace", () => {
+    const r = compareOutputs("5\n", "5   \r\n\n");
+    expect(r.match).toBe(true);
+    expect(r.diff).toEqual([]);
+    expect(r.firstMismatch).toBe(-1);
+  });
+  it("reports differing lines with 1-based numbers", () => {
+    const r = compareOutputs("1\n2\n3\n", "1\n9\n3\n");
+    expect(r.match).toBe(false);
+    expect(r.firstMismatch).toBe(2);
+    expect(r.diff).toEqual([
+      { line: 2, expected: "2", actual: "9", same: false },
+    ]);
+  });
+  it("marks missing / extra lines with null", () => {
+    const r = compareOutputs("1\n2\n", "1\n");
+    expect(r.diff).toEqual([
+      { line: 2, expected: "2", actual: null, same: false },
+    ]);
+  });
+  it("caps the diff", () => {
+    const exp = Array.from({ length: 500 }, (_, i) => String(i)).join("\n");
+    const act = Array.from({ length: 500 }, () => "x").join("\n");
+    expect(compareOutputs(exp, act, 10).diff).toHaveLength(10);
+    expect(compareOutputs(exp, act, {}, 7).diff).toHaveLength(7);
+  });
+  it("flags presentation-only mismatches", () => {
+    const r = compareOutputs("1 2 3\n", "1\n2\n3\n");
+    expect(r.match).toBe(false);
+    expect(r.presentationOnly).toBe(true);
+  });
+  it("does not flag presentation-only when tokens differ", () => {
+    const r = compareOutputs("1 2 3\n", "1\n2\n4\n");
+    expect(r.presentationOnly).toBeUndefined();
+  });
+});
+
+describe("compareOutputs (tokens)", () => {
+  it("ignores whitespace layout", () => {
+    expect(
+      compareOutputs("1 2 3\n", "1\n2\n   3\n", { mode: "tokens" }).match,
+    ).toBe(true);
+  });
+  it("still rejects different tokens", () => {
+    expect(compareOutputs("1 2 3", "1 2 4", { mode: "tokens" }).match).toBe(
+      false,
+    );
+  });
+  it("rejects a different token count", () => {
+    expect(compareOutputs("1 2 3", "1 2", { mode: "tokens" }).match).toBe(
+      false,
+    );
+  });
+});
+
+describe("compareOutputs (float)", () => {
+  it("accepts values within epsilon", () => {
+    expect(
+      compareOutputs("3.1415926\n", "3.1415927\n", { mode: "float" }).match,
+    ).toBe(true);
+  });
+  it("uses relative tolerance for large magnitudes", () => {
+    expect(
+      compareOutputs("1000000.0", "1000000.5", { mode: "float", epsilon: 1e-6 })
+        .match,
+    ).toBe(true);
+  });
+  it("rejects values outside epsilon", () => {
+    expect(
+      compareOutputs("1.0", "1.1", { mode: "float", epsilon: 1e-6 }).match,
+    ).toBe(false);
+  });
+  it("compares non-numeric tokens exactly", () => {
+    expect(compareOutputs("YES", "yes", { mode: "float" }).match).toBe(false);
+    expect(compareOutputs("YES", "YES", { mode: "float" }).match).toBe(true);
+  });
+});
+
+describe("helpers", () => {
+  it("tokenize splits on any whitespace", () => {
+    expect(tokenize(" a\tb\n\nc ")).toEqual(["a", "b", "c"]);
+  });
+  it("tokensEqual handles scientific notation", () => {
+    expect(tokensEqual("1e3", "1000", 1e-9)).toBe(true);
+    expect(tokensEqual("abc", "1000", 1e-9)).toBe(false);
+  });
+  it("parseCheckerMode falls back to lines", () => {
+    expect(parseCheckerMode("tokens")).toBe("tokens");
+    expect(parseCheckerMode("nonsense")).toBe("lines");
+    expect(parseCheckerMode(undefined)).toBe("lines");
+  });
+  it("parseEpsilon rejects garbage", () => {
+    expect(parseEpsilon(1e-9)).toBe(1e-9);
+    expect(parseEpsilon(-1)).toBe(1e-6);
+    expect(parseEpsilon("x")).toBe(1e-6);
+    expect(parseEpsilon(5)).toBe(1);
+  });
+});
diff --git a/web/app/api/_engine/compare.ts b/web/app/api/_engine/compare.ts
index 75b0fae..71e1f96 100644
--- a/web/app/api/_engine/compare.ts
+++ b/web/app/api/_engine/compare.ts
@@ -3,12 +3,51 @@
  *
  * Output comparison helpers shared by /api/test and /api/stress.
  *
- * Competitive-programming judges accept output that differs only in trailing
- * whitespace, trailing blank lines, and line-ending style. `normalize` encodes
- * that tolerance; `compareOutputs` reports a match plus a compact line diff that
- * the UI can render.
+ * Three checker modes are supported, mirroring what online judges do:
+ *
+ *  - `lines`  (default) — trailing whitespace, trailing blank lines and CRLF
+ *    differences are ignored; everything else must match line for line.
+ *  - `tokens` — outputs are split on any whitespace and compared token by
+ *    token. This is the Codeforces "wcmp" checker and is what most problems
+ *    with "print the numbers in any order/format" actually use.
+ *  - `float`  — like `tokens`, but numeric tokens are compared with an
+ *    absolute-or-relative tolerance (`epsilon`, default 1e-6), matching the
+ *    classic "answer accepted if |a-b| / max(1,|b|) <= eps" checker.
+ *
+ * Every mode reports a match flag plus a compact line diff the UI can render.
  */
 
+export type CheckerMode = "lines" | "tokens" | "float";
+
+export const CHECKER_MODES: readonly CheckerMode[] = [
+  "lines",
+  "tokens",
+  "float",
+];
+
+export const DEFAULT_EPSILON = 1e-6;
+
+export type CheckerOptions = {
+  mode?: CheckerMode;
+  /** Tolerance used by the `float` checker. */
+  epsilon?: number;
+};
+
+/** Coerce request input into a valid checker mode. */
+export function parseCheckerMode(value: unknown): CheckerMode {
+  return typeof value === "string" &&
+    (CHECKER_MODES as string[]).includes(value)
+    ? (value as CheckerMode)
+    : "lines";
+}
+
+/** Coerce request input into a usable epsilon. */
+export function parseEpsilon(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return DEFAULT_EPSILON;
+  return Math.min(1, value);
+}
+
 /**
  * Canonicalise output for tolerant comparison:
  *  - CRLF / CR are converted to LF
@@ -24,6 +63,28 @@ export function normalize(s: string): string {
   return lines.join("\n");
 }
 
+/** Split output into whitespace-separated tokens. */
+export function tokenize(s: string): string[] {
+  return s.split(/\s+/).filter(Boolean);
+}
+
+const NUMERIC = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+
+/** True when two tokens are equal under the float checker. */
+export function tokensEqual(
+  expected: string,
+  actual: string,
+  epsilon: number,
+): boolean {
+  if (expected === actual) return true;
+  if (!NUMERIC.test(expected) || !NUMERIC.test(actual)) return false;
+  const e = Number(expected);
+  const a = Number(actual);
+  if (!Number.isFinite(e) || !Number.isFinite(a)) return false;
+  const diff = Math.abs(e - a);
+  return diff <= epsilon || diff <= epsilon * Math.max(1, Math.abs(e));
+}
+
 export type DiffLine = {
   /** 1-based line number. */
   line: number;
@@ -38,23 +99,24 @@ export type CompareResult = {
   diff: DiffLine[];
   /** First differing line number, or -1 when outputs match. */
   firstMismatch: number;
+  /** The checker mode that produced this verdict. */
+  mode: CheckerMode;
+  /**
+   * Set when the `lines` checker rejected the output but the `tokens` checker
+   * would have accepted it — i.e. the answer is right, only the whitespace
+   * layout differs. The UI surfaces this as a hint.
+   */
+  presentationOnly?: boolean;
 };
 
-/**
- * Compare two outputs with trailing-whitespace tolerance and return a per-line
- * diff of the lines that differ. The diff is capped so a pathological mismatch
- * can't produce an unbounded payload.
- */
-export function compareOutputs(
+/** Build a per-line diff of two normalised outputs (capped at maxDiff rows). */
+function lineDiff(
   expected: string,
   actual: string,
-  maxDiff = 200,
-): CompareResult {
-  const exp = normalize(expected).split("\n");
-  const act = normalize(actual).split("\n");
-  const match = normalize(expected) === normalize(actual);
-  if (match) return { match: true, diff: [], firstMismatch: -1 };
-
+  maxDiff: number,
+): { diff: DiffLine[]; firstMismatch: number } {
+  const exp = expected.split("\n");
+  const act = actual.split("\n");
   const diff: DiffLine[] = [];
   let firstMismatch = -1;
   const max = Math.max(exp.length, act.length);
@@ -67,5 +129,64 @@ export function compareOutputs(
       diff.push({ line: i + 1, expected: e, actual: a, same: false });
     }
   }
-  return { match: false, diff, firstMismatch };
+  return { diff, firstMismatch };
+}
+
+/** Token-wise comparison; returns true on match. */
+function tokensMatch(
+  expected: string,
+  actual: string,
+  epsilon: number | null,
+): boolean {
+  const e = tokenize(expected);
+  const a = tokenize(actual);
+  if (e.length !== a.length) return false;
+  for (let i = 0; i < e.length; i++) {
+    const ok =
+      epsilon === null ? e[i] === a[i] : tokensEqual(e[i], a[i], epsilon);
+    if (!ok) return false;
+  }
+  return true;
+}
+
+/**
+ * Compare two outputs under the chosen checker and return a per-line diff of
+ * the lines that differ. The diff is capped so a pathological mismatch can't
+ * produce an unbounded payload.
+ */
+export function compareOutputs(
+  expected: string,
+  actual: string,
+  options: CheckerOptions | number = {},
+  maxDiff = 200,
+): CompareResult {
+  // Backwards-compatible signature: compareOutputs(exp, act, maxDiff).
+  const opts: CheckerOptions = typeof options === "number" ? {} : options;
+  if (typeof options === "number") maxDiff = options;
+  const mode = opts.mode ?? "lines";
+  const epsilon = opts.epsilon ?? DEFAULT_EPSILON;
+
+  const normExp = normalize(expected);
+  const normAct = normalize(actual);
+
+  let match: boolean;
+  switch (mode) {
+    case "tokens":
+      match = tokensMatch(normExp, normAct, null);
+      break;
+    case "float":
+      match = tokensMatch(normExp, normAct, epsilon);
+      break;
+    default:
+      match = normExp === normAct;
+  }
+
+  if (match) return { match: true, diff: [], firstMismatch: -1, mode };
+
+  const { diff, firstMismatch } = lineDiff(normExp, normAct, maxDiff);
+  const result: CompareResult = { match: false, diff, firstMismatch, mode };
+  if (mode === "lines" && tokensMatch(normExp, normAct, null)) {
+    result.presentationOnly = true;
+  }
+  return result;
 }
diff --git a/web/app/api/_engine/cpp.test.ts b/web/app/api/_engine/cpp.test.ts
new file mode 100644
index 0000000..2fc5665
--- /dev/null
+++ b/web/app/api/_engine/cpp.test.ts
@@ -0,0 +1,138 @@
+import { afterAll, describe, expect, it } from "vitest";
+import {
+  compile,
+  runBinary,
+  cleanup,
+  detectCompiler,
+  compilerVersion,
+  clearCompileCache,
+  compileCacheSize,
+  runVerdict,
+  clampTimeLimit,
+  includeDir,
+} from "./cpp";
+
+/**
+ * These tests exercise the real toolchain. They are skipped (not failed) on a
+ * machine without a C++ compiler so the rest of the unit suite still runs.
+ */
+const hasCompiler = detectCompiler() !== null;
+const maybe = hasCompiler ? describe : describe.skip;
+
+const AB = `#include <bits/stdc++.h>
+using namespace std;
+int main(){ int a,b; cin>>a>>b; cout<<a+b<<"\\n"; }
+`;
+
+afterAll(async () => {
+  await clearCompileCache();
+});
+
+describe("clampTimeLimit", () => {
+  it("clamps into [100, 60000] and defaults", () => {
+    expect(clampTimeLimit(undefined)).toBe(5000);
+    expect(clampTimeLimit(1)).toBe(100);
+    expect(clampTimeLimit(1e9)).toBe(60000);
+    expect(clampTimeLimit(NaN)).toBe(5000);
+    expect(clampTimeLimit(1234.9)).toBe(1234);
+  });
+});
+
+maybe("compile + run", () => {
+  it("reports the compiler version", () => {
+    expect(compilerVersion()).toBeTruthy();
+    expect(includeDir()).toMatch(/include$/);
+  });
+
+  it("compiles and runs A+B, then serves the second compile from cache", async () => {
+    await clearCompileCache();
+    const first = await compile(AB, { std: "gnu++17" });
+    expect(first.ok).toBe(true);
+    expect(first.cached).toBe(false);
+    expect(first.binPath).toBeTruthy();
+    expect(compileCacheSize()).toBe(1);
+
+    const run = await runBinary(first.binPath!, { input: "2 3\n" });
+    expect(run.stdout.trim()).toBe("5");
+    expect(runVerdict(run)).toBe("OK");
+    expect(run.timeMs).toBeGreaterThan(0);
+
+    const second = await compile(AB, { std: "gnu++17" });
+    expect(second.cached).toBe(true);
+    expect(second.ms).toBe(0);
+    expect(second.binPath).toBe(first.binPath);
+    expect(compileCacheSize()).toBe(1);
+
+    // A different standard is a different cache entry.
+    const third = await compile(AB, { std: "gnu++20" });
+    expect(third.cached).toBe(false);
+    expect(compileCacheSize()).toBe(2);
+  });
+
+  it("coalesces identical concurrent compiles", async () => {
+    await clearCompileCache();
+    const src = `${AB}// concurrent\n`;
+    const [a, b] = await Promise.all([compile(src), compile(src)]);
+    expect(a.ok && b.ok).toBe(true);
+    expect(a.binPath).toBe(b.binPath);
+    expect(compileCacheSize()).toBe(1);
+  });
+
+  it("returns structured diagnostics on a compile error", async () => {
+    const r = await compile("int main() { return x; }\n");
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("compile-error");
+    expect(r.stderr).toContain("main.cpp:1");
+    expect(
+      r.diagnostics.some((d) => d.severity === "error" && d.line === 1),
+    ).toBe(true);
+    expect(r.workDir).toBeTruthy();
+    await cleanup(r.workDir);
+  });
+
+  it("drops disallowed flags and reports them", async () => {
+    const r = await compile(AB, { extraFlags: ["-Wall", "-o", "/tmp/evil"] });
+    expect(r.ok).toBe(true);
+    expect(r.rejectedFlags.map((f) => f.flag)).toEqual(["-o", "/tmp/evil"]);
+  });
+
+  it("classifies a timeout as TLE", async () => {
+    const r = await compile("int main(){ for(;;){} }\n");
+    expect(r.ok).toBe(true);
+    const run = await runBinary(r.binPath!, { timeLimitMs: 300 });
+    expect(run.timedOut).toBe(true);
+    expect(runVerdict(run)).toBe("TLE");
+    expect(run.timeMs).toBeGreaterThanOrEqual(250);
+  });
+
+  it("classifies a non-zero exit as RE", async () => {
+    const r = await compile("int main(){ return 3; }\n");
+    const run = await runBinary(r.binPath!);
+    expect(run.exitCode).toBe(3);
+    expect(runVerdict(run)).toBe("RE");
+  });
+
+  it("truncates runaway output and reports it", async () => {
+    const r = await compile(
+      '#include <cstdio>\nint main(){ for(;;) puts("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"); }\n',
+    );
+    const run = await runBinary(r.binPath!, {
+      timeLimitMs: 5000,
+      maxOutputBytes: 64 * 1024,
+    });
+    expect(run.truncated).toBe(true);
+    expect(run.stdout.length).toBeLessThanOrEqual(64 * 1024);
+  });
+
+  it("rejects oversized sources without invoking the compiler", async () => {
+    const r = await compile("x".repeat(2 * 1024 * 1024));
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("source-too-large");
+  });
+
+  it("surfaces a spawn error for a missing binary", async () => {
+    const run = await runBinary("/definitely/not/here/prog");
+    expect(run.spawnError).toBeTruthy();
+    expect(runVerdict(run)).toBe("RE");
+  });
+});
diff --git a/web/app/api/_engine/cpp.ts b/web/app/api/_engine/cpp.ts
index 456f248..9741f20 100644
--- a/web/app/api/_engine/cpp.ts
+++ b/web/app/api/_engine/cpp.ts
@@ -3,24 +3,33 @@
  *
  * Self-contained C++ compile/run engine for the cf workbench API routes.
  *
- * This module depends ONLY on Node.js built-ins (node:child_process, node:fs,
- * node:os, node:path) so the `web/app/api` tree never reaches into other
- * workspaces (e.g. web/lib). It powers /api/run, /api/test and /api/stress.
+ * This module depends ONLY on Node.js built-ins so the `web/app/api` tree
+ * never reaches into other workspaces (e.g. web/lib). It powers /api/run,
+ * /api/test and /api/stress.
  *
  * Design notes:
  *  - The bundled portable `<bits/stdc++.h>` lives at <repoRoot>/include, so every
  *    compile passes `-I <repoRoot>/include` and the idiom resolves on macOS
- *    (clang/libc++) as well as Linux (g++/libstdc++).
+ *    (clang/libc++) as well as Linux (g++/libstdc++) and MinGW on Windows.
  *  - Wall-clock time is measured inside Node with process.hrtime.bigint() around
  *    the spawn — never the shell `time` builtin (which is unreliable on macOS).
- *  - Every compilation happens in a unique os.tmpdir() directory so concurrent
- *    requests never collide, and temp dirs are always cleaned up by callers.
+ *  - Compiled binaries are cached by a hash of (compiler, std, flags, source).
+ *    Re-running unchanged code, or running the same source against many test
+ *    cases, skips the multi-second `<bits/stdc++.h>` instantiation entirely.
+ *    Cache entries live under a per-process temp directory and are evicted
+ *    least-recently-used once the cap is reached.
+ *  - Cache misses compile in a unique temp directory so concurrent requests
+ *    never collide; identical concurrent compiles are coalesced.
  */
 
 import { spawn, spawnSync } from "node:child_process";
-import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { rmSync } from "node:fs";
+import { mkdtemp, mkdir, writeFile, rm, rename, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { validateFlags, validateStd } from "./flags";
+import { parseDiagnostics, type Diagnostic } from "./diagnostics";
 
 // ==================== Tunables ====================
 
@@ -32,14 +41,22 @@ export const DEFAULT_TIME_LIMIT_MS = 5000;
 export const MAX_TIME_LIMIT_MS = 60_000;
 /** Compilation is killed if it exceeds this (runaway template instantiation). */
 export const COMPILE_TIMEOUT_MS = 30_000;
+/** Largest source accepted for compilation. */
+export const MAX_SOURCE_BYTES = 1024 * 1024; // 1 MiB
 /** Largest stdin payload forwarded to a program. */
 export const MAX_INPUT_BYTES = 4 * 1024 * 1024; // 4 MiB
 /** Largest stdout/stderr captured per stream; excess is truncated. */
 export const MAX_OUTPUT_BYTES = 4 * 1024 * 1024; // 4 MiB
+/** Number of compiled binaries kept in the cache before LRU eviction. */
+export const COMPILE_CACHE_ENTRIES = 48;
 
 /** Compiler candidates, in preference order: clang++/c++ (macOS) then g++. */
 const COMPILER_CANDIDATES = ["clang++", "c++", "g++"];
 
+const IS_WINDOWS = process.platform === "win32";
+const BIN_NAME = IS_WINDOWS ? "prog.exe" : "prog";
+const SRC_NAME = "main.cpp";
+
 // ==================== Paths ====================
 
 /** Absolute path to the repository root (the parent of the Next.js `web` dir). */
@@ -56,6 +73,7 @@ export function includeDir(): string {
 // ==================== Compiler detection ====================
 
 let cachedCompiler: string | null = null;
+let cachedVersion: string | null = null;
 
 /**
  * Return the first usable C++ compiler, or null if none is installed.
@@ -70,9 +88,10 @@ export function detectCompiler(): string | null {
     : COMPILER_CANDIDATES;
   for (const cand of candidates) {
     try {
-      const probe = spawnSync(cand, ["--version"], { stdio: "ignore" });
+      const probe = spawnSync(cand, ["--version"], { encoding: "utf8" });
       if (!probe.error && probe.status === 0) {
         cachedCompiler = cand;
+        cachedVersion = (probe.stdout || "").split(/\r?\n/)[0]?.trim() || null;
         return cand;
       }
     } catch {
@@ -82,6 +101,12 @@ export function detectCompiler(): string | null {
   return null;
 }
 
+/** First line of `<compiler> --version`, or null when no compiler is found. */
+export function compilerVersion(): string | null {
+  if (!detectCompiler()) return null;
+  return cachedVersion;
+}
+
 // ==================== Compilation ====================
 
 export type CompileResult = {
@@ -91,27 +116,131 @@ export type CompileResult = {
   compiler: string | null;
   /** Compiler diagnostics (the "CE" text shown to the user). */
   stderr: string;
+  /** Structured diagnostics parsed from `stderr`. */
+  diagnostics: Diagnostic[];
   /** Absolute path to the produced executable, or null on failure. */
   binPath: string | null;
-  /** The unique temp directory holding the sources/binary; clean it up. */
+  /**
+   * The unique temp directory holding the sources/binary for an uncached
+   * failure; null for cache-backed results. Always pass it to cleanup().
+   */
   workDir: string | null;
-  /** Compile wall-clock time in milliseconds. */
+  /** Compile wall-clock time in milliseconds (0 on a cache hit). */
   ms: number;
+  /** True when the binary came from the compile cache. */
+  cached: boolean;
+  /** Flags that were dropped by validation, with a reason each. */
+  rejectedFlags: { flag: string; reason: string }[];
   /** Machine-readable failure cause, when ok === false. */
-  error?: "no-compiler" | "compile-timeout" | "compile-error" | "spawn-error";
+  error?:
+    | "no-compiler"
+    | "compile-timeout"
+    | "compile-error"
+    | "spawn-error"
+    | "source-too-large";
 };
 
 export type CompileOptions = {
   /** C++ standard without the `-std=` prefix (default `gnu++17`). */
   std?: string;
-  /** Extra compiler flags appended verbatim. */
+  /** Extra compiler flags; validated against an allowlist before use. */
   extraFlags?: string[];
   /** Short label used in the temp directory name. */
   label?: string;
 };
 
+type CacheEntry = { binPath: string; stderr: string; lastUsed: number };
+
+const cache = new Map<string, CacheEntry>();
+const inflight = new Map<string, Promise<CompileResult>>();
+let cacheRootPromise: Promise<string> | null = null;
+
+function cacheRoot(): Promise<string> {
+  if (!cacheRootPromise) {
+    cacheRootPromise = mkdtemp(path.join(os.tmpdir(), "cf-cache-")).then(
+      (dir) => {
+        // Reclaim the whole cache when the server exits normally.
+        process.once("exit", () => {
+          try {
+            rmSync(dir, { recursive: true, force: true });
+          } catch {
+            // best effort
+          }
+        });
+        return dir;
+      },
+    );
+  }
+  return cacheRootPromise;
+}
+
+function cacheKey(
+  compiler: string,
+  std: string,
+  flags: string[],
+  source: string,
+): string {
+  return createHash("sha256")
+    .update(compiler)
+    .update("\0")
+    .update(std)
+    .update("\0")
+    .update(flags.join(" "))
+    .update("\0")
+    .update(source)
+    .digest("hex");
+}
+
+async function evictIfNeeded(): Promise<void> {
+  while (cache.size > COMPILE_CACHE_ENTRIES) {
+    let oldestKey: string | null = null;
+    let oldest = Infinity;
+    for (const [k, v] of cache) {
+      if (v.lastUsed < oldest) {
+        oldest = v.lastUsed;
+        oldestKey = k;
+      }
+    }
+    if (!oldestKey) break;
+    const entry = cache.get(oldestKey);
+    cache.delete(oldestKey);
+    if (entry) await cleanup(path.dirname(entry.binPath));
+  }
+}
+
+/** Drop every cached binary. Exposed for tests and for /api/config resets. */
+export async function clearCompileCache(): Promise<void> {
+  const entries = [...cache.values()];
+  cache.clear();
+  await Promise.all(entries.map((e) => cleanup(path.dirname(e.binPath))));
+}
+
+/** Number of binaries currently held in the compile cache. */
+export function compileCacheSize(): number {
+  return cache.size;
+}
+
+function noCompilerResult(): CompileResult {
+  return {
+    ok: false,
+    compiler: null,
+    stderr:
+      "No C++ compiler found. Tried clang++, c++ and g++. Install the Xcode " +
+      "Command Line Tools (`xcode-select --install`), a g++ toolchain, or " +
+      "set CF_CXX to the compiler you want to use.",
+    diagnostics: [],
+    binPath: null,
+    workDir: null,
+    ms: 0,
+    cached: false,
+    rejectedFlags: [],
+    error: "no-compiler",
+  };
+}
+
 /**
- * Compile a single C++ translation unit into a unique temp directory.
+ * Compile a single C++ translation unit, serving from the compile cache when
+ * the exact same (compiler, std, flags, source) tuple was built before.
  * Never throws — failures are reported through the returned CompileResult.
  * Callers MUST cleanup(result.workDir) when finished with the binary.
  */
@@ -120,36 +249,83 @@ export async function compile(
   opts: CompileOptions = {},
 ): Promise<CompileResult> {
   const compiler = detectCompiler();
-  if (!compiler) {
+  if (!compiler) return noCompilerResult();
+
+  const { accepted: flags, rejected } = validateFlags(opts.extraFlags ?? []);
+  const std = validateStd(opts.std, DEFAULT_STD);
+
+  if (Buffer.byteLength(source, "utf8") > MAX_SOURCE_BYTES) {
     return {
       ok: false,
-      compiler: null,
-      stderr:
-        "No C++ compiler found. Tried clang++, c++ and g++. Install the Xcode " +
-        "Command Line Tools (`xcode-select --install`) or a g++ toolchain.",
+      compiler,
+      stderr: `Source exceeds the ${MAX_SOURCE_BYTES / 1024} KiB limit.`,
+      diagnostics: [],
       binPath: null,
       workDir: null,
       ms: 0,
-      error: "no-compiler",
+      cached: false,
+      rejectedFlags: rejected,
+      error: "source-too-large",
     };
   }
 
+  const key = cacheKey(compiler, std, flags, source);
+  const hit = cache.get(key);
+  if (hit) {
+    hit.lastUsed = Date.now();
+    return {
+      ok: true,
+      compiler,
+      stderr: hit.stderr,
+      diagnostics: parseDiagnostics(hit.stderr, SRC_NAME),
+      binPath: hit.binPath,
+      workDir: null,
+      ms: 0,
+      cached: true,
+      rejectedFlags: rejected,
+    };
+  }
+
+  const pending = inflight.get(key);
+  if (pending) {
+    const r = await pending;
+    return { ...r, rejectedFlags: rejected, cached: r.ok ? true : r.cached };
+  }
+
+  const job = compileUncached(source, compiler, std, flags, key, opts.label);
+  inflight.set(key, job);
+  try {
+    const r = await job;
+    return { ...r, rejectedFlags: rejected };
+  } finally {
+    inflight.delete(key);
+  }
+}
+
+async function compileUncached(
+  source: string,
+  compiler: string,
+  std: string,
+  flags: string[],
+  key: string,
+  label?: string,
+): Promise<CompileResult> {
   const workDir = await mkdtemp(
-    path.join(os.tmpdir(), `cf-${opts.label ?? "build"}-`),
+    path.join(os.tmpdir(), `cf-${label ?? "build"}-`),
   );
-  const srcPath = path.join(workDir, "main.cpp");
-  const binPath = path.join(workDir, "prog");
+  const srcPath = path.join(workDir, SRC_NAME);
+  const binPath = path.join(workDir, BIN_NAME);
   await writeFile(srcPath, source, "utf8");
 
   const args = [
-    `-std=${opts.std ?? DEFAULT_STD}`,
+    `-std=${std}`,
     "-O2",
     "-I",
     includeDir(),
     srcPath,
     "-o",
     binPath,
-    ...(opts.extraFlags ?? []),
+    ...flags,
   ];
 
   const start = process.hrtime.bigint();
@@ -157,6 +333,7 @@ export async function compile(
     encoding: "utf8",
     timeout: COMPILE_TIMEOUT_MS,
     maxBuffer: MAX_OUTPUT_BYTES,
+    cwd: workDir,
   });
   const ms = Number(process.hrtime.bigint() - start) / 1e6;
 
@@ -164,27 +341,65 @@ export async function compile(
     !!res.error && (res.error as NodeJS.ErrnoException).code === "ETIMEDOUT";
   const ok = !res.error && res.status === 0;
 
-  let stderr = res.stderr ?? "";
+  // Present the temp path as plain `main.cpp` so diagnostics read naturally.
+  let stderr = (res.stderr ?? "").split(srcPath).join(SRC_NAME);
+  if (IS_WINDOWS)
+    stderr = stderr.split(srcPath.replace(/\\/g, "/")).join(SRC_NAME);
   if (res.error && !timedOut) stderr = `${stderr}\n${res.error.message}`.trim();
   if (timedOut) {
     stderr =
       `${stderr}\nCompilation timed out after ${COMPILE_TIMEOUT_MS} ms.`.trim();
   }
+  const diagnostics = parseDiagnostics(stderr, SRC_NAME);
+
+  if (!ok) {
+    return {
+      ok,
+      compiler,
+      stderr,
+      diagnostics,
+      binPath: null,
+      workDir,
+      ms,
+      cached: false,
+      rejectedFlags: [],
+      error: timedOut
+        ? "compile-timeout"
+        : res.error
+          ? "spawn-error"
+          : "compile-error",
+    };
+  }
+
+  // Move the finished build into the cache. On a rename race the other copy
+  // wins and ours is discarded.
+  const root = await cacheRoot();
+  const target = path.join(root, key);
+  let finalBin = binPath;
+  try {
+    await mkdir(root, { recursive: true });
+    await rename(workDir, target);
+    finalBin = path.join(target, BIN_NAME);
+  } catch {
+    const existing = await stat(path.join(target, BIN_NAME)).catch(() => null);
+    if (existing) {
+      await cleanup(workDir);
+      finalBin = path.join(target, BIN_NAME);
+    }
+  }
+  cache.set(key, { binPath: finalBin, stderr, lastUsed: Date.now() });
+  await evictIfNeeded();
 
   return {
     ok,
     compiler,
     stderr,
-    binPath: ok ? binPath : null,
-    workDir,
+    diagnostics,
+    binPath: finalBin,
+    workDir: null,
     ms,
-    error: ok
-      ? undefined
-      : timedOut
-        ? "compile-timeout"
-        : res.error
-          ? "spawn-error"
-          : "compile-error",
+    cached: false,
+    rejectedFlags: [],
   };
 }
 
@@ -218,9 +433,10 @@ export type RunOptions = {
   maxOutputBytes?: number;
 };
 
-function clamp(n: number, lo: number, hi: number): number {
-  if (!Number.isFinite(n)) return lo;
-  return Math.min(hi, Math.max(lo, n));
+export function clampTimeLimit(n: number | undefined): number {
+  const v = n ?? DEFAULT_TIME_LIMIT_MS;
+  if (!Number.isFinite(v)) return DEFAULT_TIME_LIMIT_MS;
+  return Math.min(MAX_TIME_LIMIT_MS, Math.max(100, Math.floor(v)));
 }
 
 /**
@@ -232,17 +448,15 @@ export function runBinary(
   binPath: string,
   opts: RunOptions = {},
 ): Promise<RunResult> {
-  const timeLimitMs = clamp(
-    opts.timeLimitMs ?? DEFAULT_TIME_LIMIT_MS,
-    100,
-    MAX_TIME_LIMIT_MS,
-  );
+  const timeLimitMs = clampTimeLimit(opts.timeLimitMs);
   const maxOut = opts.maxOutputBytes ?? MAX_OUTPUT_BYTES;
 
   return new Promise<RunResult>((resolve) => {
     const start = process.hrtime.bigint();
-    let stdout = "";
-    let stderr = "";
+    const outChunks: Buffer[] = [];
+    const errChunks: Buffer[] = [];
+    let outLen = 0;
+    let errLen = 0;
     let truncated = false;
     let timedOut = false;
     let settled = false;
@@ -254,6 +468,8 @@ export function runBinary(
     try {
       child = spawn(binPath, opts.args ?? [], {
         stdio: ["pipe", "pipe", "pipe"],
+        cwd: path.dirname(binPath),
+        windowsHide: true,
       });
     } catch (e) {
       const ms = Number(process.hrtime.bigint() - start) / 1e6;
@@ -281,12 +497,12 @@ export function runBinary(
       clearTimeout(timer);
       const timeMs = Number(process.hrtime.bigint() - start) / 1e6;
       resolve({
-        stdout,
-        stderr,
+        stdout: Buffer.concat(outChunks).toString("utf8"),
+        stderr: Buffer.concat(errChunks).toString("utf8"),
         exitCode,
         signal,
         timedOut,
-        timeMs,
+        timeMs: Math.round(timeMs * 10) / 10,
         truncated,
         spawnError,
       });
@@ -298,21 +514,29 @@ export function runBinary(
     });
 
     child.stdout.on("data", (d: Buffer) => {
-      if (stdout.length >= maxOut) return;
-      stdout += d.toString("utf8");
-      if (stdout.length >= maxOut) {
-        stdout = stdout.slice(0, maxOut);
+      if (outLen >= maxOut) return;
+      const room = maxOut - outLen;
+      if (d.length > room) {
+        outChunks.push(d.subarray(0, room));
+        outLen = maxOut;
         truncated = true;
         child.kill("SIGKILL");
+      } else {
+        outChunks.push(d);
+        outLen += d.length;
       }
     });
 
     child.stderr.on("data", (d: Buffer) => {
-      if (stderr.length >= maxOut) return;
-      stderr += d.toString("utf8");
-      if (stderr.length >= maxOut) {
-        stderr = stderr.slice(0, maxOut);
+      if (errLen >= maxOut) return;
+      const room = maxOut - errLen;
+      if (d.length > room) {
+        errChunks.push(d.subarray(0, room));
+        errLen = maxOut;
         truncated = true;
+      } else {
+        errChunks.push(d);
+        errLen += d.length;
       }
     });
 
@@ -334,6 +558,20 @@ export function runBinary(
   });
 }
 
+/** Classify a run as a judge verdict (without output comparison). */
+export function runVerdict(run: RunResult): "OK" | "TLE" | "RE" {
+  if (run.timedOut) return "TLE";
+  if (run.spawnError || run.exitCode !== 0 || run.signal) return "RE";
+  return "OK";
+}
+
+/** Program stderr plus any spawn error, for display. */
+export function runStderr(run: RunResult): string {
+  return run.spawnError
+    ? `${run.stderr}\n${run.spawnError}`.trim()
+    : run.stderr;
+}
+
 // ==================== Cleanup ====================
 
 /** Best-effort recursive removal of a temp work directory. Never throws. */
diff --git a/web/app/api/_engine/diagnostics.test.ts b/web/app/api/_engine/diagnostics.test.ts
new file mode 100644
index 0000000..d4822ee
--- /dev/null
+++ b/web/app/api/_engine/diagnostics.test.ts
@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { parseDiagnostics, summarizeDiagnostics } from "./diagnostics";
+
+const GCC = `main.cpp: In function 'int main()':
+main.cpp:5:9: error: 'x' was not declared in this scope
+    5 |     int y = x;
+      |         ^
+main.cpp:7:5: warning: unused variable 'y' [-Wunused-variable]
+/usr/include/c++/13/bits/stl_vector.h:100:3: note: declared here
+`;
+
+const CLANG = `main.cpp:3:12: error: use of undeclared identifier 'foo'
+    return foo;
+           ^
+1 error generated.
+`;
+
+describe("parseDiagnostics", () => {
+  it("parses gcc output with line and column", () => {
+    const d = parseDiagnostics(GCC);
+    expect(d).toHaveLength(3);
+    expect(d[0]).toEqual({
+      severity: "error",
+      line: 5,
+      column: 9,
+      message: "'x' was not declared in this scope",
+    });
+    expect(d[1].severity).toBe("warning");
+    expect(d[1].line).toBe(7);
+  });
+
+  it("drops line numbers for diagnostics in other files", () => {
+    const d = parseDiagnostics(GCC);
+    expect(d[2]).toEqual({
+      severity: "note",
+      line: null,
+      column: null,
+      message: "declared here",
+    });
+  });
+
+  it("parses clang output", () => {
+    const d = parseDiagnostics(CLANG);
+    expect(d).toHaveLength(1);
+    expect(d[0].line).toBe(3);
+    expect(d[0].column).toBe(12);
+  });
+
+  it("handles fatal errors and windows paths", () => {
+    const d = parseDiagnostics(
+      "C:\\tmp\\cf-x\\main.cpp:1:10: fatal error: foo.h: No such file or directory",
+    );
+    expect(d[0].severity).toBe("error");
+    expect(d[0].line).toBe(1);
+  });
+
+  it("returns nothing for empty stderr", () => {
+    expect(parseDiagnostics("")).toEqual([]);
+  });
+
+  it("summarizes counts", () => {
+    expect(summarizeDiagnostics(parseDiagnostics(GCC))).toEqual({
+      errors: 1,
+      warnings: 1,
+    });
+  });
+});
diff --git a/web/app/api/_engine/diagnostics.ts b/web/app/api/_engine/diagnostics.ts
new file mode 100644
index 0000000..8591c6a
--- /dev/null
+++ b/web/app/api/_engine/diagnostics.ts
@@ -0,0 +1,71 @@
+/**
+ * web/app/api/_engine/diagnostics.ts
+ *
+ * Turn raw compiler stderr into structured diagnostics the UI can render as
+ * gutter markers and a clickable problem list. Both GCC and clang emit the
+ * same `file:line:col: severity: message` shape, which is all this parses.
+ */
+
+export type DiagnosticSeverity = "error" | "warning" | "note";
+
+export type Diagnostic = {
+  severity: DiagnosticSeverity;
+  /** 1-based source line, or null when the diagnostic has no location. */
+  line: number | null;
+  /** 1-based column, or null when unknown. */
+  column: number | null;
+  message: string;
+};
+
+const LINE_RE =
+  /^(?:(.+?):(\d+):(?:(\d+):)?\s+)?(fatal error|error|warning|note):\s+(.*)$/;
+
+/**
+ * Parse compiler output into diagnostics. Only lines that follow the
+ * `path:line:col: severity: message` convention are picked up; everything
+ * else (code excerpts, caret lines, "In function" context) is ignored.
+ *
+ * When `sourceName` is given, diagnostics that point at a different file (for
+ * example the bundled `<bits/stdc++.h>` shim) keep their message but lose the
+ * line number, so the editor never marks a line that is not in the user's
+ * source.
+ */
+export function parseDiagnostics(
+  stderr: string,
+  sourceName = "main.cpp",
+): Diagnostic[] {
+  const out: Diagnostic[] = [];
+  for (const rawLine of stderr.split(/\r?\n/)) {
+    const m = LINE_RE.exec(rawLine.trim());
+    if (!m) continue;
+    const [, file, lineStr, colStr, sev, message] = m;
+    const inSource =
+      !file ||
+      file === sourceName ||
+      file.endsWith(`/${sourceName}`) ||
+      file.endsWith(`\\${sourceName}`);
+    const line = inSource && lineStr ? Number(lineStr) : null;
+    const column = inSource && colStr ? Number(colStr) : null;
+    out.push({
+      severity: sev === "fatal error" ? "error" : (sev as DiagnosticSeverity),
+      line: Number.isFinite(line) ? line : null,
+      column: Number.isFinite(column) ? column : null,
+      message: message.trim(),
+    });
+  }
+  return out;
+}
+
+/** Count errors and warnings in a diagnostics list. */
+export function summarizeDiagnostics(diags: Diagnostic[]): {
+  errors: number;
+  warnings: number;
+} {
+  let errors = 0;
+  let warnings = 0;
+  for (const d of diags) {
+    if (d.severity === "error") errors++;
+    else if (d.severity === "warning") warnings++;
+  }
+  return { errors, warnings };
+}
diff --git a/web/app/api/_engine/flags.test.ts b/web/app/api/_engine/flags.test.ts
new file mode 100644
index 0000000..06ec6f3
--- /dev/null
+++ b/web/app/api/_engine/flags.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { validateFlags, validateStd, tokenizeFlags } from "./flags";
+
+describe("validateFlags", () => {
+  it("accepts the everyday competitive-programming flags", () => {
+    const { accepted, rejected } = validateFlags([
+      "-Wall",
+      "-Wextra",
+      "-O3",
+      "-DLOCAL",
+      "-DDEBUG=1",
+      "-g",
+      "-fsanitize=address,undefined",
+      "-march=native",
+      "-std=gnu++20",
+      "-pedantic",
+    ]);
+    expect(rejected).toEqual([]);
+    expect(accepted).toHaveLength(10);
+  });
+
+  it("rejects flags that write files or load code", () => {
+    const { accepted, rejected } = validateFlags([
+      "-o",
+      "/tmp/x",
+      "-include",
+      "/etc/passwd",
+      "@resp.txt",
+      "-fplugin=evil.so",
+      "-Wl,-rpath,/x",
+      "-I/etc",
+      "-lfoo",
+      "-fprofile-generate",
+    ]);
+    expect(accepted).toEqual([]);
+    expect(rejected.map((r) => r.flag)).toContain("-fplugin=evil.so");
+    expect(rejected.map((r) => r.flag)).toContain("-Wl,-rpath,/x");
+    expect(rejected.map((r) => r.flag)).toContain("-o");
+  });
+
+  it("rejects shell metacharacters and bogus standards", () => {
+    const { accepted, rejected } = validateFlags([
+      "-DX=$(rm -rf /)",
+      "-std=c++99",
+      "-Wall;ls",
+    ]);
+    expect(accepted).toEqual([]);
+    expect(rejected).toHaveLength(3);
+  });
+
+  it("dedupes and accepts a raw string", () => {
+    expect(validateFlags("-Wall -Wall -O2").accepted).toEqual(["-Wall", "-O2"]);
+  });
+
+  it("treats non-list input as empty", () => {
+    expect(validateFlags(42)).toEqual({ accepted: [], rejected: [] });
+  });
+});
+
+describe("validateStd", () => {
+  it("accepts known standards and falls back otherwise", () => {
+    expect(validateStd("gnu++17", "x")).toBe("gnu++17");
+    expect(validateStd("c++23", "x")).toBe("c++23");
+    expect(validateStd("c++98", "gnu++17")).toBe("gnu++17");
+    expect(validateStd("gnu++17; rm", "gnu++17")).toBe("gnu++17");
+    expect(validateStd(undefined, "gnu++17")).toBe("gnu++17");
+  });
+});
+
+describe("tokenizeFlags", () => {
+  it("splits on whitespace", () => {
+    expect(tokenizeFlags("  -Wall\t-O2\n")).toEqual(["-Wall", "-O2"]);
+  });
+});
diff --git a/web/app/api/_engine/flags.ts b/web/app/api/_engine/flags.ts
new file mode 100644
index 0000000..ca0f3bc
--- /dev/null
+++ b/web/app/api/_engine/flags.ts
@@ -0,0 +1,131 @@
+/**
+ * web/app/api/_engine/flags.ts
+ *
+ * Validation for user-supplied compiler flags and language standards.
+ *
+ * The workbench is a local tool, but every /api/* route accepts flags straight
+ * from the browser. A flag such as `-o /some/path`, `-include /etc/passwd`,
+ * `@response-file` or `-fplugin=` turns the compiler into a file writer or a
+ * code loader, so only the flag families a competitive programmer actually
+ * needs are let through. Anything else is reported back as rejected so the UI
+ * can explain why a setting was ignored instead of silently dropping it.
+ */
+
+/** Flag prefixes that are safe to forward verbatim. */
+const ALLOWED_PREFIXES = [
+  "-O", // optimisation level
+  "-W", // warnings (incl. -Werror, -Wno-*)
+  "-w", // silence warnings
+  "-D", // macro definitions
+  "-U", // macro undefinitions
+  "-f", // codegen / sanitizer switches (-fsanitize=..., -fno-omit-frame-pointer)
+  "-g", // debug info
+  "-m", // machine flags (-march=native, -m64)
+  "-std=", // language standard
+  "-pedantic",
+  "-static",
+  "-pthread",
+  "-pipe",
+  "-ansi",
+  "-trigraphs",
+];
+
+/** Flags that are dangerous even though they share an allowed prefix. */
+const DENIED_PREFIXES = [
+  "-fplugin", // loads arbitrary shared objects into the compiler
+  "-fpass-plugin",
+  "-fuse-ld",
+  "-fprofile", // writes files outside the work dir
+  "-fdump",
+  "-fsave",
+  "-frandom-seed",
+  "-fmodule",
+  "-fpch",
+  "-fdebug-prefix-map",
+  "-ffile-prefix-map",
+  "-Wl,", // linker pass-through
+  "-Wa,", // assembler pass-through
+  "-Wp,", // preprocessor pass-through
+];
+
+/** Only the standards the toolchains actually understand. */
+const STD_PATTERN = /^(gnu|c)\+\+(0x|11|14|17|1z|2a|20|2b|23|2c|26)$/;
+
+export type FlagValidation = {
+  /** Flags that passed validation, in their original order. */
+  accepted: string[];
+  /** Flags that were dropped, each paired with a short reason. */
+  rejected: { flag: string; reason: string }[];
+};
+
+/** Split a raw flags string into argv-style tokens (whitespace separated). */
+export function tokenizeFlags(raw: string): string[] {
+  return raw
+    .split(/\s+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Filter a list of compiler flags down to the safe subset.
+ * Never throws; unknown input types are treated as an empty list.
+ */
+export function validateFlags(input: unknown): FlagValidation {
+  const list: string[] = Array.isArray(input)
+    ? input.filter((f): f is string => typeof f === "string")
+    : typeof input === "string"
+      ? tokenizeFlags(input)
+      : [];
+
+  const accepted: string[] = [];
+  const rejected: { flag: string; reason: string }[] = [];
+  const seen = new Set<string>();
+
+  for (const raw of list) {
+    const flag = raw.trim();
+    if (!flag) continue;
+    if (seen.has(flag)) continue;
+    seen.add(flag);
+
+    if (flag.length > 128) {
+      rejected.push({ flag, reason: "flag is too long" });
+      continue;
+    }
+    if (!flag.startsWith("-")) {
+      rejected.push({ flag, reason: "not a flag (must start with '-')" });
+      continue;
+    }
+    if (/[\s"'`$\\;|&<>]/.test(flag)) {
+      rejected.push({ flag, reason: "contains shell metacharacters" });
+      continue;
+    }
+    if (flag === "-std" || flag.startsWith("-std=")) {
+      const std = flag.slice("-std=".length);
+      if (!STD_PATTERN.test(std)) {
+        rejected.push({ flag, reason: "unsupported language standard" });
+        continue;
+      }
+    }
+    if (DENIED_PREFIXES.some((p) => flag.startsWith(p))) {
+      rejected.push({ flag, reason: "flag family is not allowed" });
+      continue;
+    }
+    if (!ALLOWED_PREFIXES.some((p) => flag === p || flag.startsWith(p))) {
+      rejected.push({ flag, reason: "flag family is not allowed" });
+      continue;
+    }
+    accepted.push(flag);
+  }
+
+  return { accepted, rejected };
+}
+
+/**
+ * Validate a `std` value coming from a request. Returns the value when it is a
+ * known standard, otherwise `fallback`.
+ */
+export function validateStd(value: unknown, fallback: string): string {
+  if (typeof value !== "string") return fallback;
+  const std = value.trim();
+  return STD_PATTERN.test(std) ? std : fallback;
+}
diff --git a/web/app/api/_engine/request.ts b/web/app/api/_engine/request.ts
new file mode 100644
index 0000000..486543e
--- /dev/null
+++ b/web/app/api/_engine/request.ts
@@ -0,0 +1,71 @@
+/**
+ * web/app/api/_engine/request.ts
+ *
+ * Request-parsing helpers shared by every API route so the compile/run
+ * options (`std`, `timeLimitMs`, `compilerFlags`, `checker`, `epsilon`) are
+ * interpreted identically everywhere.
+ */
+
+import { NextResponse } from "next/server";
+import { clampTimeLimit, DEFAULT_STD } from "./cpp";
+import { validateStd } from "./flags";
+import { parseCheckerMode, parseEpsilon, type CheckerMode } from "./compare";
+
+export type Body = Record<string, unknown>;
+
+/** Parse a JSON body, or return a 400 response when it is not an object. */
+export async function readJson(
+  request: Request,
+): Promise<
+  { body: Body; error?: undefined } | { body?: undefined; error: NextResponse }
+> {
+  try {
+    const parsed = await request.json();
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {
+        error: NextResponse.json(
+          { error: "Request body must be a JSON object" },
+          { status: 400 },
+        ),
+      };
+    }
+    return { body: parsed as Body };
+  } catch {
+    return {
+      error: NextResponse.json({ error: "Invalid JSON body" }, { status: 400 }),
+    };
+  }
+}
+
+export function badRequest(message: string): NextResponse {
+  return NextResponse.json({ error: message }, { status: 400 });
+}
+
+export type RunOptionsParsed = {
+  std: string;
+  timeLimitMs: number;
+  extraFlags: string[];
+  checker: CheckerMode;
+  epsilon: number;
+};
+
+/** Read the shared compile/run options off a request body. */
+export function parseRunOptions(body: Body): RunOptionsParsed {
+  return {
+    std: validateStd(body.std, DEFAULT_STD),
+    timeLimitMs: clampTimeLimit(
+      typeof body.timeLimitMs === "number" ? body.timeLimitMs : undefined,
+    ),
+    extraFlags: Array.isArray(body.compilerFlags)
+      ? body.compilerFlags.filter((f): f is string => typeof f === "string")
+      : [],
+    checker: parseCheckerMode(body.checker),
+    epsilon: parseEpsilon(body.epsilon),
+  };
+}
+
+/** Read a string field, or "" when absent / not a string. */
+export function str(body: Body, key: string): string {
+  const v = body[key];
+  return typeof v === "string" ? v : "";
+}
diff --git a/web/app/api/_engine/statement.test.ts b/web/app/api/_engine/statement.test.ts
new file mode 100644
index 0000000..331a5ae
--- /dev/null
+++ b/web/app/api/_engine/statement.test.ts
@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { parseStatement, parseTimeLimit, parseMemoryLimit } from "./statement";
+
+const fixture = readFileSync(
+  path.resolve(__dirname, "../../../../tests/fixtures/231A/problem.txt"),
+  "utf8",
+);
+
+describe("parseStatement", () => {
+  it("extracts every sample from a Codeforces statement", () => {
+    const r = parseStatement(fixture);
+    expect(r.title).toBe("A. Team");
+    expect(r.timeLimitMs).toBe(2000);
+    expect(r.memoryLimitMb).toBe(256);
+    expect(r.tests).toEqual([
+      { input: "3\n1 1 0\n1 1 1\n1 0 0\n", expected: "2\n" },
+      { input: "2\n1 0 0\n0 1 1\n", expected: "1\n" },
+    ]);
+  });
+
+  it("stops at the Note section", () => {
+    const r = parseStatement(fixture);
+    expect(r.tests[1].expected).not.toContain("In the first sample");
+  });
+
+  it("accepts the CLI template skeleton with empty samples", () => {
+    const r = parseStatement(
+      "# Paste the problem statement here\n\nExamples\nInput\n\n\nOutput\n\n\n",
+    );
+    expect(r.tests).toEqual([]);
+  });
+
+  it("handles AtCoder-style 'Sample Input 1' headings", () => {
+    const r = parseStatement(
+      "Problem\nSample Input 1\n1 2\nSample Output 1\n3\nSample Input 2\n5 5\nSample Output 2\n10\n",
+    );
+    expect(r.tests).toEqual([
+      { input: "1 2\n", expected: "3\n" },
+      { input: "5 5\n", expected: "10\n" },
+    ]);
+  });
+
+  it("handles a statement without an Examples heading", () => {
+    const r = parseStatement("Sample Input\n4\nSample Output\n16\n");
+    expect(r.tests).toEqual([{ input: "4\n", expected: "16\n" }]);
+  });
+
+  it("does not mistake the input-format section for a sample", () => {
+    const r = parseStatement(
+      "A. X\nInput\nThe first line contains n.\nOutput\nPrint n.\n",
+    );
+    expect(r.tests).toEqual([]);
+  });
+
+  it("ignores 'Copy' button text and CRLF", () => {
+    const r = parseStatement(
+      "Examples\r\nInput\r\nCopy\r\n1\r\nOutput\r\nCopy\r\n2\r\n",
+    );
+    expect(r.tests).toEqual([{ input: "1\n", expected: "2\n" }]);
+  });
+
+  it("returns no tests for prose", () => {
+    expect(parseStatement("just some text").tests).toEqual([]);
+  });
+});
+
+describe("limits", () => {
+  it("parses seconds and milliseconds", () => {
+    expect(parseTimeLimit("time limit per test\n1.5 seconds")).toBe(1500);
+    expect(parseTimeLimit("time limit: 500 ms")).toBe(500);
+    expect(parseTimeLimit("no limit here")).toBeNull();
+  });
+  it("parses megabytes and gigabytes", () => {
+    expect(parseMemoryLimit("memory limit per test\n256 megabytes")).toBe(256);
+    expect(parseMemoryLimit("memory limit 1 GB")).toBe(1024);
+    expect(parseMemoryLimit("")).toBeNull();
+  });
+});
diff --git a/web/app/api/_engine/statement.ts b/web/app/api/_engine/statement.ts
new file mode 100644
index 0000000..e42566f
--- /dev/null
+++ b/web/app/api/_engine/statement.ts
@@ -0,0 +1,206 @@
+/**
+ * web/app/api/_engine/statement.ts
+ *
+ * Parse a problem statement pasted from Codeforces (or a similar judge) into
+ * sample test cases plus the limits the statement declares. This is the same
+ * heuristic the `cf` CLI applies to `problem.txt`, ported to TypeScript so the
+ * web workbench can turn a pasted statement into test cases in one click.
+ *
+ * Recognised layout (headings are case-insensitive, a trailing colon and the
+ * "Copy" button text Codeforces adds are ignored):
+ *
+ *   A. Title
+ *   time limit per test
+ *   2 seconds
+ *   memory limit per test
+ *   256 megabytes
+ *   ...
+ *   Examples            (or "Example", "Sample 1", "Examples:")
+ *   Input               (or "Sample Input", "Sample Input 1", "inputCopy")
+ *   <lines>
+ *   Output              (or "Sample Output", "outputCopy")
+ *   <lines>
+ *   Input ... Output ...  (repeated)
+ *   Note                (ends the examples section)
+ */
+
+export type ParsedStatement = {
+  /** First non-empty line of the statement, typically "A. Title". */
+  title: string | null;
+  /** Time limit in milliseconds when the statement declares one. */
+  timeLimitMs: number | null;
+  /** Memory limit in megabytes when the statement declares one. */
+  memoryLimitMb: number | null;
+  /** Extracted samples, each with a trailing newline. */
+  tests: { input: string; expected: string }[];
+};
+
+function normHead(line: string): string {
+  return line
+    .toLowerCase()
+    .replace(/\s+/g, " ")
+    .replace(/[:：]\s*$/, "")
+    .trim();
+}
+
+function isExamplesHead(line: string): boolean {
+  const h = normHead(line);
+  return (
+    h === "examples" ||
+    h === "example" ||
+    /^example\s*\d+$/.test(h) ||
+    /^samples?$/.test(h) ||
+    /^sample\s*\d+$/.test(h) ||
+    /^sample (tests?|cases?)$/.test(h)
+  );
+}
+
+function isInputHead(line: string): boolean {
+  const h = normHead(line).replace(/copy$/, "").trim();
+  return (
+    h === "input" ||
+    h === "sample input" ||
+    /^sample input\s*\d+$/.test(h) ||
+    /^input\s*\d+$/.test(h) ||
+    h === "standard input"
+  );
+}
+
+function isOutputHead(line: string): boolean {
+  const h = normHead(line).replace(/copy$/, "").trim();
+  return (
+    h === "output" ||
+    h === "sample output" ||
+    /^sample output\s*\d+$/.test(h) ||
+    /^output\s*\d+$/.test(h) ||
+    h === "standard output"
+  );
+}
+
+function isStopHead(line: string): boolean {
+  const h = normHead(line);
+  return (
+    h === "note" ||
+    h === "notes" ||
+    h === "explanation" ||
+    h === "constraints" ||
+    h === "scoring" ||
+    h === "interaction"
+  );
+}
+
+function trimBlock(lines: string[]): string {
+  const copy = [...lines];
+  while (copy.length && copy[0].trim() === "") copy.shift();
+  while (copy.length && copy[copy.length - 1].trim() === "") copy.pop();
+  if (copy.length === 0) return "";
+  return `${copy.map((l) => l.replace(/[ \t]+$/, "")).join("\n")}\n`;
+}
+
+const TIME_RE =
+  /time limit(?: per test)?[^\d]*(\d+(?:\.\d+)?)\s*(seconds?|s\b|ms|milliseconds?)/i;
+const MEM_RE =
+  /memory limit(?: per test)?[^\d]*(\d+(?:\.\d+)?)\s*(megabytes?|mb|gigabytes?|gb|kilobytes?|kb)/i;
+
+/** Parse "2 seconds" / "1.5 s" / "500 ms" style limits into milliseconds. */
+export function parseTimeLimit(text: string): number | null {
+  const m = TIME_RE.exec(text);
+  if (!m) return null;
+  const n = Number(m[1]);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = m[2].toLowerCase();
+  return unit.startsWith("ms") || unit.startsWith("milli")
+    ? Math.round(n)
+    : Math.round(n * 1000);
+}
+
+/** Parse "256 megabytes" / "1 GB" style limits into megabytes. */
+export function parseMemoryLimit(text: string): number | null {
+  const m = MEM_RE.exec(text);
+  if (!m) return null;
+  const n = Number(m[1]);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = m[2].toLowerCase();
+  if (unit.startsWith("g")) return Math.round(n * 1024);
+  if (unit.startsWith("k")) return Math.round(n / 1024);
+  return Math.round(n);
+}
+
+/**
+ * Extract samples and limits from a statement. Never throws; a statement
+ * without an examples section yields `tests: []`.
+ */
+export function parseStatement(text: string): ParsedStatement {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+
+  const firstLine = lines.find((l) => l.trim() !== "") ?? null;
+  const title = firstLine ? firstLine.trim().slice(0, 200) : null;
+
+  // Limits appear in the header; only scan the first few hundred characters
+  // so a "time limit" phrase inside a note is not misread.
+  const head = lines.slice(0, 12).join("\n");
+  const timeLimitMs = parseTimeLimit(head);
+  const memoryLimitMb = parseMemoryLimit(head);
+
+  const tests: { input: string; expected: string }[] = [];
+  let inExamples = false;
+  let block: "input" | "output" | null = null;
+  let curInput: string[] = [];
+  let curOutput: string[] = [];
+  let haveInput = false;
+
+  const flush = () => {
+    if (haveInput) {
+      tests.push({
+        input: trimBlock(curInput),
+        expected: trimBlock(curOutput),
+      });
+    }
+    curInput = [];
+    curOutput = [];
+    haveInput = false;
+  };
+
+  for (const raw of lines) {
+    const line = raw.replace(/\s+$/, "");
+    if (!inExamples) {
+      if (isExamplesHead(line)) inExamples = true;
+      // AtCoder-style statements have no "Examples" heading; their samples
+      // start with an unambiguous "Sample Input N". A bare "Input" is the
+      // input-format section of the statement and must not count.
+      else if (/^sample input/.test(normHead(line))) {
+        inExamples = true;
+        block = "input";
+        haveInput = true;
+      }
+      continue;
+    }
+
+    if (isInputHead(line)) {
+      flush();
+      block = "input";
+      haveInput = true;
+      continue;
+    }
+    if (isOutputHead(line)) {
+      block = "output";
+      continue;
+    }
+    if (isStopHead(line) || (block === "output" && isExamplesHead(line))) {
+      flush();
+      break;
+    }
+    if (block === null) continue;
+    if (normHead(line) === "copy") continue;
+    if (block === "input") curInput.push(line);
+    else curOutput.push(line);
+  }
+  flush();
+
+  return {
+    title,
+    timeLimitMs,
+    memoryLimitMb,
+    tests: tests.filter((t) => t.input !== "" || t.expected !== ""),
+  };
+}
diff --git a/web/app/api/_engine/store.test.ts b/web/app/api/_engine/store.test.ts
new file mode 100644
index 0000000..1161ee1
--- /dev/null
+++ b/web/app/api/_engine/store.test.ts
@@ -0,0 +1,146 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { mkdtemp, rm, readdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import {
+  saveProblem,
+  getProblem,
+  listProblems,
+  listProblemsFull,
+  renameProblem,
+  duplicateProblem,
+  deleteProblem,
+  importProblems,
+  slugify,
+  isSafeProblemName,
+  normalizeProblem,
+  problemsDataDir,
+} from "./store";
+
+let dataDir: string;
+
+beforeAll(async () => {
+  dataDir = await mkdtemp(path.join(os.tmpdir(), "cf-store-test-"));
+  process.env.CF_DATA_DIR = dataDir;
+});
+
+afterAll(async () => {
+  delete process.env.CF_DATA_DIR;
+  await rm(dataDir, { recursive: true, force: true });
+});
+
+describe("slugify", () => {
+  it("normalises names", () => {
+    expect(slugify("1620C - Bad Sums!")).toBe("1620c-bad-sums");
+    expect(slugify("   ")).toBe("problem");
+    expect(slugify("x".repeat(200))).toHaveLength(80);
+  });
+});
+
+describe("isSafeProblemName", () => {
+  it("accepts plain segments and rejects traversal", () => {
+    expect(isSafeProblemName("1000A")).toBe(true);
+    expect(isSafeProblemName("bear-and-big_brother.v2")).toBe(true);
+    expect(isSafeProblemName("../etc")).toBe(false);
+    expect(isSafeProblemName("a/b")).toBe(false);
+    expect(isSafeProblemName("a\\b")).toBe(false);
+    expect(isSafeProblemName(".hidden")).toBe(false);
+    expect(isSafeProblemName("")).toBe(false);
+    expect(isSafeProblemName(null)).toBe(false);
+  });
+});
+
+describe("problems store", () => {
+  it("uses the CF_DATA_DIR override", () => {
+    expect(problemsDataDir()).toBe(path.join(dataDir, "problems"));
+  });
+
+  it("saves and loads a full workspace", async () => {
+    const saved = await saveProblem({
+      name: "Test A",
+      code: "int main(){}",
+      tests: [{ input: "1\n", expected: "2\n" }, { bogus: true }],
+      stdin: "1\n",
+      brute: "// brute",
+      generator: "// gen",
+      settings: { std: "gnu++20", timeLimitMs: 1000, junk: 1 },
+    });
+    expect(saved.slug).toBe("test-a");
+    expect(saved.tests).toEqual([
+      { input: "1\n", expected: "2\n" },
+      { input: "", expected: "" },
+    ]);
+    expect(saved.settings).toEqual({ std: "gnu++20", timeLimitMs: 1000 });
+
+    const loaded = await getProblem("test-a");
+    expect(loaded).toEqual(saved);
+  });
+
+  it("merges partial updates over the existing record", async () => {
+    const updated = await saveProblem({ name: "Test A", stdin: "9\n" });
+    expect(updated.code).toBe("int main(){}");
+    expect(updated.stdin).toBe("9\n");
+    expect(updated.brute).toBe("// brute");
+    expect(updated.createdAt).toBeLessThanOrEqual(updated.updatedAt);
+  });
+
+  it("writes atomically (no temp files left behind)", async () => {
+    const files = await readdir(problemsDataDir());
+    expect(files.filter((f) => f.endsWith(".tmp"))).toEqual([]);
+  });
+
+  it("lists summaries newest first", async () => {
+    await saveProblem({ name: "Test B", code: "b" });
+    const list = await listProblems();
+    expect(list.map((p) => p.slug)).toEqual(["test-b", "test-a"]);
+    expect(list[1].testCount).toBe(2);
+  });
+
+  it("renames, duplicates and deletes", async () => {
+    const renamed = await renameProblem("test-b", "Test C");
+    expect(renamed?.slug).toBe("test-c");
+    expect(await getProblem("test-b")).toBeNull();
+
+    const dup = await duplicateProblem("test-c", "Test D");
+    expect(dup?.code).toBe("b");
+    expect((await listProblems()).map((p) => p.slug).sort()).toEqual([
+      "test-a",
+      "test-c",
+      "test-d",
+    ]);
+
+    expect(await deleteProblem("test-d")).toBe(true);
+    expect(await deleteProblem("test-d")).toBe(false);
+    expect(await deleteProblem("../evil")).toBe(false);
+  });
+
+  it("imports a bundle and respects overwrite", async () => {
+    const bundle = (await listProblemsFull()).map((p) => ({
+      ...p,
+      code: "imported",
+    }));
+    const skipped = await importProblems(bundle, false);
+    expect(skipped).toEqual({ imported: 0, skipped: bundle.length });
+    expect((await getProblem("test-a"))?.code).toBe("int main(){}");
+
+    const over = await importProblems([...bundle, null, { name: "" }], true);
+    expect(over).toEqual({ imported: bundle.length, skipped: 2 });
+    expect((await getProblem("test-a"))?.code).toBe("imported");
+  });
+
+  it("tolerates records written by older versions", () => {
+    const p = normalizeProblem(
+      { name: "Old", code: "c", tests: "nope" },
+      "old",
+    );
+    expect(p).toMatchObject({
+      name: "Old",
+      slug: "old",
+      code: "c",
+      tests: [],
+      stdin: "",
+      settings: null,
+    });
+    expect(normalizeProblem("garbage", "x")).toBeNull();
+  });
+});
diff --git a/web/app/api/_engine/store.ts b/web/app/api/_engine/store.ts
index 8ba605f..f3fe17a 100644
--- a/web/app/api/_engine/store.ts
+++ b/web/app/api/_engine/store.ts
@@ -4,12 +4,14 @@
  * Persistence helpers for the API routes, using only Node built-ins.
  *
  * Two concerns live here:
- *  1. Problems store — saved problems and their test cases, persisted as JSON
- *     under <web>/data/problems/<slug>.json (the canonical store the workbench
- *     reads/writes via /api/problems).
+ *  1. Problems store — saved problems (source, statement, sample tests, the
+ *     custom stdin and the stress sources) persisted as JSON under
+ *     <web>/data/problems/<slug>.json. Writes are atomic (temp file + rename)
+ *     so a crash mid-write never leaves a half-written record behind.
  *  2. Legacy file helpers — solution.cpp / problem.txt persistence under the
  *     repo `src/<problem>/` tree, kept so the /api/solution, /api/problem-text
  *     and /api/template routes stay self-contained (no dependency on web/lib).
+ *     Problem names are validated so a request can never escape the tree.
  */
 
 import {
@@ -19,6 +21,7 @@ import {
   readdir,
   stat,
   rm,
+  rename,
 } from "node:fs/promises";
 import path from "node:path";
 import { repoRoot } from "./cpp";
@@ -27,12 +30,28 @@ import { repoRoot } from "./cpp";
 
 export type TestCase = { input: string; expected: string };
 
+export type ProblemSettings = {
+  std?: string;
+  timeLimitMs?: number;
+  compilerFlags?: string[];
+  checker?: string;
+  epsilon?: number;
+};
+
 export type Problem = {
   name: string;
   slug: string;
   code: string;
   statement: string;
   tests: TestCase[];
+  /** Custom stdin from the Run panel. */
+  stdin: string;
+  /** Brute-force source from the Stress panel. */
+  brute: string;
+  /** Generator source from the Stress panel. */
+  generator: string;
+  /** Per-problem run settings snapshot (optional, merged over defaults). */
+  settings: ProblemSettings | null;
   createdAt: number;
   updatedAt: number;
 };
@@ -71,7 +90,19 @@ async function ensureDataDir(): Promise<void> {
   await mkdir(problemsDataDir(), { recursive: true });
 }
 
-function normalizeTests(tests: unknown): TestCase[] {
+/** Write a file atomically: write to a sibling temp file, then rename. */
+async function atomicWrite(file: string, data: string): Promise<void> {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tmp, data, "utf8");
+  try {
+    await rename(tmp, file);
+  } catch (e) {
+    await rm(tmp, { force: true }).catch(() => {});
+    throw e;
+  }
+}
+
+export function normalizeTests(tests: unknown): TestCase[] {
   if (!Array.isArray(tests)) return [];
   return tests
     .filter((t): t is Record<string, unknown> => !!t && typeof t === "object")
@@ -81,33 +112,79 @@ function normalizeTests(tests: unknown): TestCase[] {
     }));
 }
 
+function normalizeSettings(value: unknown): ProblemSettings | null {
+  if (!value || typeof value !== "object") return null;
+  const v = value as Record<string, unknown>;
+  const out: ProblemSettings = {};
+  if (typeof v.std === "string") out.std = v.std;
+  if (typeof v.timeLimitMs === "number" && Number.isFinite(v.timeLimitMs))
+    out.timeLimitMs = v.timeLimitMs;
+  if (Array.isArray(v.compilerFlags))
+    out.compilerFlags = v.compilerFlags.filter(
+      (f): f is string => typeof f === "string",
+    );
+  if (typeof v.checker === "string") out.checker = v.checker;
+  if (typeof v.epsilon === "number" && Number.isFinite(v.epsilon))
+    out.epsilon = v.epsilon;
+  return Object.keys(out).length ? out : null;
+}
+
+/** Coerce a raw JSON record (possibly from an older version) into a Problem. */
+export function normalizeProblem(
+  raw: unknown,
+  fallbackSlug: string,
+): Problem | null {
+  if (!raw || typeof raw !== "object") return null;
+  const p = raw as Record<string, unknown>;
+  const name =
+    typeof p.name === "string" && p.name.trim() ? p.name.trim() : fallbackSlug;
+  return {
+    name,
+    slug: typeof p.slug === "string" && p.slug ? p.slug : slugify(name),
+    code: typeof p.code === "string" ? p.code : "",
+    statement: typeof p.statement === "string" ? p.statement : "",
+    tests: normalizeTests(p.tests),
+    stdin: typeof p.stdin === "string" ? p.stdin : "",
+    brute: typeof p.brute === "string" ? p.brute : "",
+    generator: typeof p.generator === "string" ? p.generator : "",
+    settings: normalizeSettings(p.settings),
+    createdAt: typeof p.createdAt === "number" ? p.createdAt : 0,
+    updatedAt: typeof p.updatedAt === "number" ? p.updatedAt : 0,
+  };
+}
+
 /** List saved problems (summaries only), newest first. */
 export async function listProblems(): Promise<ProblemSummary[]> {
+  const full = await listProblemsFull();
+  return full.map((p) => ({
+    name: p.name,
+    slug: p.slug,
+    testCount: p.tests.length,
+    updatedAt: p.updatedAt,
+  }));
+}
+
+/** Load every saved problem in full, newest first. */
+export async function listProblemsFull(): Promise<Problem[]> {
   try {
     const entries = await readdir(problemsDataDir(), { withFileTypes: true });
-    const summaries: ProblemSummary[] = [];
+    const out: Problem[] = [];
     for (const e of entries) {
       if (!e.isFile() || !e.name.endsWith(".json")) continue;
+      const slug = e.name.replace(/\.json$/, "");
       try {
         const raw = await readFile(
           path.join(problemsDataDir(), e.name),
           "utf8",
         );
-        const p = JSON.parse(raw) as Problem;
-        summaries.push({
-          name:
-            typeof p.name === "string" ? p.name : e.name.replace(/\.json$/, ""),
-          slug:
-            typeof p.slug === "string" ? p.slug : e.name.replace(/\.json$/, ""),
-          testCount: Array.isArray(p.tests) ? p.tests.length : 0,
-          updatedAt: typeof p.updatedAt === "number" ? p.updatedAt : 0,
-        });
+        const p = normalizeProblem(JSON.parse(raw), slug);
+        if (p) out.push(p);
       } catch {
         // skip unreadable/corrupt files
       }
     }
-    summaries.sort((a, b) => b.updatedAt - a.updatedAt);
-    return summaries;
+    out.sort((a, b) => b.updatedAt - a.updatedAt);
+    return out;
   } catch {
     return [];
   }
@@ -115,50 +192,64 @@ export async function listProblems(): Promise<ProblemSummary[]> {
 
 /** Load one problem by slug, or null when it does not exist. */
 export async function getProblem(slug: string): Promise<Problem | null> {
+  if (!/^[a-z0-9-]+$/.test(slug)) return null;
   try {
     const raw = await readFile(problemPath(slug), "utf8");
-    return JSON.parse(raw) as Problem;
+    return normalizeProblem(JSON.parse(raw), slug);
   } catch {
     return null;
   }
 }
 
-/** Create or update a problem keyed by its slug. Returns the stored record. */
-export async function saveProblem(input: {
+export type SaveProblemInput = {
   name: string;
   code?: string;
   statement?: string;
   tests?: unknown;
-}): Promise<Problem> {
+  stdin?: string;
+  brute?: string;
+  generator?: string;
+  settings?: unknown;
+  /** Preserve these timestamps (used by import). */
+  createdAt?: number;
+  updatedAt?: number;
+};
+
+/** Create or update a problem keyed by its slug. Returns the stored record. */
+export async function saveProblem(input: SaveProblemInput): Promise<Problem> {
   await ensureDataDir();
   const slug = slugify(input.name);
   const now = Date.now();
   const existing = await getProblem(slug);
+  const pick = <T>(v: T | undefined, prev: T | undefined, def: T): T =>
+    v !== undefined ? v : prev !== undefined ? prev : def;
+
   const problem: Problem = {
-    name: input.name,
+    name: input.name.trim(),
     slug,
-    code: typeof input.code === "string" ? input.code : (existing?.code ?? ""),
-    statement:
-      typeof input.statement === "string"
-        ? input.statement
-        : (existing?.statement ?? ""),
+    code: pick(input.code, existing?.code, ""),
+    statement: pick(input.statement, existing?.statement, ""),
     tests:
       input.tests !== undefined
         ? normalizeTests(input.tests)
         : (existing?.tests ?? []),
-    createdAt: existing?.createdAt ?? now,
-    updatedAt: now,
+    stdin: pick(input.stdin, existing?.stdin, ""),
+    brute: pick(input.brute, existing?.brute, ""),
+    generator: pick(input.generator, existing?.generator, ""),
+    settings:
+      input.settings !== undefined
+        ? normalizeSettings(input.settings)
+        : (existing?.settings ?? null),
+    createdAt: input.createdAt ?? existing?.createdAt ?? now,
+    updatedAt: input.updatedAt ?? now,
   };
-  await writeFile(
-    problemPath(slug),
-    `${JSON.stringify(problem, null, 2)}\n`,
-    "utf8",
-  );
+  await atomicWrite(problemPath(slug), `${JSON.stringify(problem, null, 2)}\n`);
   return problem;
 }
 
 /** Delete a problem by slug. Returns true when a file was removed. */
 export async function deleteProblem(slug: string): Promise<boolean> {
+  if (!/^[a-z0-9-]+$/.test(slug)) return false;
   try {
     await rm(problemPath(slug));
     return true;
@@ -175,15 +266,64 @@ export async function renameProblem(
   const existing = await getProblem(from);
   if (!existing) return null;
   const saved = await saveProblem({
+    ...existing,
     name: to,
-    code: existing.code,
-    statement: existing.statement,
-    tests: existing.tests,
+    createdAt: existing.createdAt,
+    updatedAt: undefined,
   });
   if (saved.slug !== from) await deleteProblem(from);
   return saved;
 }
 
+/** Duplicate a problem under a new name. Returns null when `from` is absent. */
+export async function duplicateProblem(
+  from: string,
+  to: string,
+): Promise<Problem | null> {
+  const existing = await getProblem(from);
+  if (!existing) return null;
+  return saveProblem({
+    ...existing,
+    name: to,
+    createdAt: undefined,
+    updatedAt: undefined,
+  });
+}
+
+export type ImportResult = { imported: number; skipped: number };
+
+/**
+ * Import problems from an exported bundle. Existing records are overwritten
+ * only when `overwrite` is true; otherwise they are skipped.
+ */
+export async function importProblems(
+  records: unknown,
+  overwrite: boolean,
+): Promise<ImportResult> {
+  if (!Array.isArray(records)) return { imported: 0, skipped: 0 };
+  let imported = 0;
+  let skipped = 0;
+  for (const raw of records) {
+    const p = normalizeProblem(raw, "");
+    if (!p || !p.name) {
+      skipped++;
+      continue;
+    }
+    const slug = slugify(p.name);
+    if (!overwrite && (await getProblem(slug))) {
+      skipped++;
+      continue;
+    }
+    await saveProblem({
+      ...p,
+      createdAt: p.createdAt || undefined,
+      updatedAt: p.updatedAt || undefined,
+    });
+    imported++;
+  }
+  return { imported, skipped };
+}
+
 // ==================== Legacy file helpers (repo src tree) ====================
 
 /** Directory holding per-problem source folders (overridable with env). */
@@ -193,67 +333,83 @@ export function srcProblemsDir(): string {
     : path.join(repoRoot(), "src");
 }
 
+/**
+ * A problem directory name is a single path segment of safe characters. This
+ * is what keeps `../` (or an absolute path) out of the file helpers below.
+ */
+export function isSafeProblemName(name: unknown): name is string {
+  return (
+    typeof name === "string" &&
+    name.length > 0 &&
+    name.length <= 128 &&
+    /^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(name) &&
+    !name.includes("..")
+  );
+}
+
+function problemFile(problem: string, file: string): string {
+  if (!isSafeProblemName(problem)) throw new Error("Invalid problem name");
+  return path.join(srcProblemsDir(), problem, file);
+}
+
 async function ensureDir(dir: string): Promise<void> {
   if (!(await stat(dir).catch(() => null)))
     await mkdir(dir, { recursive: true });
 }
 
-export async function getSolution(problem: string): Promise<string> {
+async function readOrEmpty(file: string): Promise<string> {
   try {
-    return await readFile(
-      path.join(srcProblemsDir(), problem, "solution.cpp"),
-      "utf8",
-    );
+    return await readFile(file, "utf8");
   } catch {
     return "";
   }
 }
 
+async function writeIfChanged(file: string, content: string): Promise<void> {
+  await ensureDir(path.dirname(file));
+  const current = await readFile(file, "utf8").catch(() => null);
+  if (current === content) return; // avoid churning mtimes
+  await atomicWrite(file, content);
+}
+
+export async function getSolution(problem: string): Promise<string> {
+  return readOrEmpty(problemFile(problem, "solution.cpp"));
+}
+
 export async function saveSolution(
   problem: string,
   code: string,
 ): Promise<void> {
-  const dir = path.join(srcProblemsDir(), problem);
-  await ensureDir(dir);
-  const file = path.join(dir, "solution.cpp");
-  const current = await readFile(file, "utf8").catch(() => null);
-  if (current === code) return; // avoid churning mtimes
-  await writeFile(file, code, "utf8");
+  await writeIfChanged(problemFile(problem, "solution.cpp"), code);
 }
 
 export async function getProblemText(problem: string): Promise<string> {
-  try {
-    return await readFile(
-      path.join(srcProblemsDir(), problem, "problem.txt"),
-      "utf8",
-    );
-  } catch {
-    return "";
-  }
+  return readOrEmpty(problemFile(problem, "problem.txt"));
 }
 
 export async function saveProblemText(
   problem: string,
   text: string,
 ): Promise<void> {
-  const dir = path.join(srcProblemsDir(), problem);
-  await ensureDir(dir);
-  const file = path.join(dir, "problem.txt");
-  const current = await readFile(file, "utf8").catch(() => null);
-  if (current === text) return;
-  await writeFile(file, text, "utf8");
+  await writeIfChanged(problemFile(problem, "problem.txt"), text);
+}
+
+/** Names of the starter templates shipped under the repo `templates/` dir. */
+export async function listTemplates(): Promise<string[]> {
+  try {
+    const entries = await readdir(path.join(repoRoot(), "templates"));
+    return entries
+      .filter((f) => f.endsWith(".cpp"))
+      .map((f) => f.replace(/\.cpp$/, ""))
+      .sort();
+  } catch {
+    return [];
+  }
 }
 
 /** Read a named starter template from the repo `templates/` directory. */
 export async function readTemplate(name: string): Promise<string> {
   const safe = path.basename(String(name || "").replace(/[^a-zA-Z0-9_-]/g, ""));
   if (!safe) return "";
-  try {
-    return await readFile(
-      path.join(repoRoot(), "templates", `${safe}.cpp`),
-      "utf8",
-    );
-  } catch {
-    return "";
-  }
+  return readOrEmpty(path.join(repoRoot(), "templates", `${safe}.cpp`));
 }
diff --git a/web/app/api/config/route.ts b/web/app/api/config/route.ts
index cd97ac9..c6ae589 100644
--- a/web/app/api/config/route.ts
+++ b/web/app/api/config/route.ts
@@ -1,8 +1,95 @@
-import { NextResponse } from 'next/server';
+/**
+ * GET /api/config — environment and toolchain facts the UI displays.
+ *
+ * Response JSON:
+ *   {
+ *     version: string,               // workbench version (package.json)
+ *     platform: string,              // process.platform
+ *     compiler: string|null,         // detected compiler command
+ *     compilerVersion: string|null,  // first line of `<compiler> --version`
+ *     includeDir: string,            // where the bits/stdc++.h shim lives
+ *     defaults: { std, timeLimitMs, maxTimeLimitMs, checker },
+ *     limits: { maxSourceBytes, maxInputBytes, maxOutputBytes, compileTimeoutMs },
+ *     cache: { entries: number },    // compiled binaries currently cached
+ *     startProblem: string|null,     // CF_START_PROBLEM hint from `cf serve`
+ *     problemsDir: string|null       // CF_PROBLEMS_DIR hint from `cf serve`
+ *   }
+ *
+ * DELETE /api/config?cache=1 — drop every cached binary → { ok, cleared }.
+ */
+
+import { NextResponse } from "next/server";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import {
+  detectCompiler,
+  compilerVersion,
+  includeDir,
+  compileCacheSize,
+  clearCompileCache,
+  DEFAULT_STD,
+  DEFAULT_TIME_LIMIT_MS,
+  MAX_TIME_LIMIT_MS,
+  MAX_SOURCE_BYTES,
+  MAX_INPUT_BYTES,
+  MAX_OUTPUT_BYTES,
+  COMPILE_TIMEOUT_MS,
+} from "../_engine/cpp";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+let cachedVersion: string | null = null;
+
+async function packageVersion(): Promise<string> {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const raw = await readFile(
+      path.join(process.cwd(), "package.json"),
+      "utf8",
+    );
+    const v = (JSON.parse(raw) as { version?: unknown }).version;
+    cachedVersion = typeof v === "string" ? v : "0.0.0";
+  } catch {
+    cachedVersion = "0.0.0";
+  }
+  return cachedVersion;
+}
 
 export async function GET() {
   return NextResponse.json({
+    version: await packageVersion(),
+    platform: process.platform,
+    compiler: detectCompiler(),
+    compilerVersion: compilerVersion(),
+    includeDir: includeDir(),
+    defaults: {
+      std: DEFAULT_STD,
+      timeLimitMs: DEFAULT_TIME_LIMIT_MS,
+      maxTimeLimitMs: MAX_TIME_LIMIT_MS,
+      checker: "lines",
+    },
+    limits: {
+      maxSourceBytes: MAX_SOURCE_BYTES,
+      maxInputBytes: MAX_INPUT_BYTES,
+      maxOutputBytes: MAX_OUTPUT_BYTES,
+      compileTimeoutMs: COMPILE_TIMEOUT_MS,
+    },
+    cache: { entries: compileCacheSize() },
     startProblem: process.env.CF_START_PROBLEM || null,
     problemsDir: process.env.CF_PROBLEMS_DIR || null,
   });
 }
+
+export async function DELETE(request: Request) {
+  const { searchParams } = new URL(request.url);
+  if (!searchParams.get("cache")) {
+    return NextResponse.json(
+      { error: "Nothing to delete; pass ?cache=1 to clear the compile cache" },
+      { status: 400 },
+    );
+  }
+  const cleared = compileCacheSize();
+  await clearCompileCache();
+  return NextResponse.json({ ok: true, cleared });
+}
diff --git a/web/app/api/problem-text/route.ts b/web/app/api/problem-text/route.ts
index 6ceb38c..d9a4d7a 100644
--- a/web/app/api/problem-text/route.ts
+++ b/web/app/api/problem-text/route.ts
@@ -4,28 +4,38 @@
  * GET  /api/problem-text?problem=<name> → { text: string }  ("" when absent)
  * POST /api/problem-text  { problem, text } → { success: true }
  *
- * Self-contained (Node built-ins only) so the api tree never imports web/lib.
+ * `problem` must be a single safe path segment; see /api/solution.
  */
 
 import { NextResponse } from "next/server";
-import { getProblemText, saveProblemText } from "../_engine/store";
+import {
+  getProblemText,
+  saveProblemText,
+  isSafeProblemName,
+} from "../_engine/store";
+import { readJson, badRequest, str } from "../_engine/request";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
+const MAX_TEXT_BYTES = 1024 * 1024;
+
 export async function GET(request: Request) {
   const { searchParams } = new URL(request.url);
   const problem = searchParams.get("problem");
-  if (!problem)
-    return NextResponse.json({ error: "Missing problem" }, { status: 400 });
+  if (!isSafeProblemName(problem)) return badRequest("Invalid problem name");
   const text = await getProblemText(problem);
   return NextResponse.json({ text });
 }
 
 export async function POST(request: Request) {
-  const { problem, text } = await request.json();
-  if (!problem)
-    return NextResponse.json({ error: "Missing problem" }, { status: 400 });
-  await saveProblemText(problem, typeof text === "string" ? text : "");
+  const { body, error } = await readJson(request);
+  if (error) return error;
+  const problem = str(body, "problem");
+  if (!isSafeProblemName(problem)) return badRequest("Invalid problem name");
+  const text = str(body, "text");
+  if (Buffer.byteLength(text, "utf8") > MAX_TEXT_BYTES)
+    return badRequest("Statement is too large");
+  await saveProblemText(problem, text);
   return NextResponse.json({ success: true });
 }
diff --git a/web/app/api/problems/route.ts b/web/app/api/problems/route.ts
index 51d3ce0..2a882bf 100644
--- a/web/app/api/problems/route.ts
+++ b/web/app/api/problems/route.ts
@@ -1,18 +1,23 @@
 /**
- * /api/problems — persist saved problems and their test cases as JSON under
+ * /api/problems — persist saved problems as JSON under
  * <web>/data/problems/<slug>.json. Uses only Node built-ins.
  *
- * GET  /api/problems              → { problems: ProblemSummary[] }   (newest first)
- * GET  /api/problems?name=<n|slug>→ { problem: Problem } | 404 { error }
+ * GET  /api/problems                 → { problems: ProblemSummary[] }   (newest first)
+ * GET  /api/problems?name=<n|slug>   → { problem: Problem } | 404 { error }
+ * GET  /api/problems?export=1        → { version: 1, exportedAt, problems: Problem[] }
  * POST /api/problems
- *        { name, code?, statement?, tests? }   → { ok, problem }     (upsert)
- *        { op: "rename", from, to }            → { ok, problem }      (rename)
- * DELETE /api/problems?name=<n|slug>           → { ok, deleted }
+ *        { name, code?, statement?, tests?, stdin?, brute?, generator?, settings? }
+ *                                     → { ok, problem }      (upsert)
+ *        { op: "rename", from, to }   → { ok, problem }      (rename)
+ *        { op: "duplicate", from, to }→ { ok, problem }      (copy)
+ *        { op: "import", problems: Problem[], overwrite?: boolean }
+ *                                     → { ok, imported, skipped }
+ * DELETE /api/problems?name=<n|slug>  → { ok, deleted }
  *
  * Types:
  *   TestCase       = { input: string, expected: string }
- *   Problem        = { name, slug, code, statement, tests: TestCase[],
- *                      createdAt, updatedAt }
+ *   Problem        = { name, slug, code, statement, tests: TestCase[], stdin,
+ *                      brute, generator, settings|null, createdAt, updatedAt }
  *   ProblemSummary = { name, slug, testCount, updatedAt }
  *
  * `slug` is derived from `name` (lowercase, non-alphanumerics → "-") and is the
@@ -22,21 +27,34 @@
 import { NextResponse } from "next/server";
 import {
   listProblems,
+  listProblemsFull,
   getProblem,
   saveProblem,
   deleteProblem,
   renameProblem,
+  duplicateProblem,
+  importProblems,
   slugify,
 } from "../_engine/store";
+import { readJson, badRequest, str } from "../_engine/request";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
+const MAX_NAME = 120;
+
 function resolveSlug(key: string): string {
   // Accept either an exact slug or a human name; slugify is idempotent on slugs.
   return /^[a-z0-9-]+$/.test(key) ? key : slugify(key);
 }
 
+function notFound(name: string) {
+  return NextResponse.json(
+    { error: `Problem not found: ${name}` },
+    { status: 404 },
+  );
+}
+
 export async function GET(request: Request) {
   const { searchParams } = new URL(request.url);
   const name = searchParams.get("name");
@@ -44,58 +62,60 @@ export async function GET(request: Request) {
     const problem =
       (await getProblem(resolveSlug(name))) ??
       (await getProblem(slugify(name)));
-    if (!problem) {
-      return NextResponse.json(
-        { error: `Problem not found: ${name}` },
-        { status: 404 },
-      );
-    }
+    if (!problem) return notFound(name);
     return NextResponse.json({ problem });
   }
+  if (searchParams.get("export")) {
+    const problems = await listProblemsFull();
+    return NextResponse.json({
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      problems,
+    });
+  }
   const problems = await listProblems();
   return NextResponse.json({ problems });
 }
 
 export async function POST(request: Request) {
-  let body: Record<string, unknown>;
-  try {
-    body = await request.json();
-  } catch {
-    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
-  }
+  const { body, error } = await readJson(request);
+  if (error) return error;
 
-  if (body.op === "rename") {
-    const from = typeof body.from === "string" ? body.from : "";
-    const to = typeof body.to === "string" ? body.to : "";
-    if (!from || !to.trim()) {
-      return NextResponse.json(
-        { error: "rename requires `from` and `to`" },
-        { status: 400 },
-      );
-    }
-    const problem = await renameProblem(resolveSlug(from), to.trim());
-    if (!problem) {
-      return NextResponse.json(
-        { error: `Problem not found: ${from}` },
-        { status: 404 },
-      );
-    }
+  const op = str(body, "op");
+
+  if (op === "rename" || op === "duplicate") {
+    const from = str(body, "from");
+    const to = str(body, "to").trim();
+    if (!from || !to) return badRequest(`${op} requires \`from\` and \`to\``);
+    if (to.length > MAX_NAME) return badRequest("Problem name is too long");
+    const problem =
+      op === "rename"
+        ? await renameProblem(resolveSlug(from), to)
+        : await duplicateProblem(resolveSlug(from), to);
+    if (!problem) return notFound(from);
     return NextResponse.json({ ok: true, problem });
   }
 
-  const name = typeof body.name === "string" ? body.name : "";
-  if (!name.trim()) {
-    return NextResponse.json(
-      { error: "Missing required field: name" },
-      { status: 400 },
-    );
+  if (op === "import") {
+    const result = await importProblems(body.problems, body.overwrite === true);
+    return NextResponse.json({ ok: true, ...result });
   }
 
+  if (op) return badRequest(`Unknown op: ${op}`);
+
+  const name = str(body, "name").trim();
+  if (!name) return badRequest("Missing required field: name");
+  if (name.length > MAX_NAME) return badRequest("Problem name is too long");
+
   const problem = await saveProblem({
-    name: name.trim(),
+    name,
     code: typeof body.code === "string" ? body.code : undefined,
     statement: typeof body.statement === "string" ? body.statement : undefined,
     tests: body.tests,
+    stdin: typeof body.stdin === "string" ? body.stdin : undefined,
+    brute: typeof body.brute === "string" ? body.brute : undefined,
+    generator: typeof body.generator === "string" ? body.generator : undefined,
+    settings: body.settings,
   });
   return NextResponse.json({ ok: true, problem });
 }
@@ -103,12 +123,7 @@ export async function POST(request: Request) {
 export async function DELETE(request: Request) {
   const { searchParams } = new URL(request.url);
   const name = searchParams.get("name");
-  if (!name) {
-    return NextResponse.json(
-      { error: "Missing required query param: name" },
-      { status: 400 },
-    );
-  }
+  if (!name) return badRequest("Missing required query param: name");
   const deleted =
     (await deleteProblem(resolveSlug(name))) ||
     (await deleteProblem(slugify(name)));
diff --git a/web/app/api/run/route.ts b/web/app/api/run/route.ts
index f844980..4f776bb 100644
--- a/web/app/api/run/route.ts
+++ b/web/app/api/run/route.ts
@@ -8,47 +8,49 @@
  *     stdin?: string,          // alias for `input`
  *     timeLimitMs?: number,    // wall-clock limit, default 5000, max 60000
  *     std?: string,            // C++ standard sans -std=, default "gnu++17"
- *     compilerFlags?: string[] // extra flags appended to the compile command
+ *     compilerFlags?: string[] // extra flags (validated against an allowlist)
  *   }
  *
  * Response JSON (200):
  *   {
  *     ok: boolean,             // true when verdict === "OK"
  *     verdict: "OK"|"CE"|"RE"|"TLE",
- *     stdout: string,          // program stdout (backward-compatible field)
- *     stderr: string,          // program stderr (backward-compatible field)
- *     exitCode: number|null,   // program exit code (backward-compatible field)
+ *     stdout: string,          // program stdout
+ *     stderr: string,          // program stderr
+ *     exitCode: number|null,   // program exit code
  *     signal: string|null,     // terminating signal, when killed
  *     timedOut: boolean,
  *     timeMs: number,          // run wall-clock time, measured in Node
  *     truncated: boolean,      // output hit the size cap
  *     compiler: string|null,
- *     compile: { ok: boolean, stderr: string, ms: number }
+ *     compile: {
+ *       ok: boolean, stderr: string, ms: number, cached: boolean,
+ *       diagnostics: { severity, line, column, message }[],
+ *       rejectedFlags: { flag, reason }[]
+ *     }
  *   }
  * On a 400 the body is { error: string }.
  */
 
 import { NextResponse } from "next/server";
-import { compile, runBinary, cleanup, type RunResult } from "../_engine/cpp";
+import {
+  compile,
+  runBinary,
+  cleanup,
+  runVerdict,
+  runStderr,
+} from "../_engine/cpp";
+import { readJson, badRequest, parseRunOptions, str } from "../_engine/request";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
 export async function POST(request: Request) {
-  let body: Record<string, unknown>;
-  try {
-    body = await request.json();
-  } catch {
-    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
-  }
+  const { body, error } = await readJson(request);
+  if (error) return error;
 
-  const code = typeof body.code === "string" ? body.code : "";
-  if (!code.trim()) {
-    return NextResponse.json(
-      { error: "Missing required field: code" },
-      { status: 400 },
-    );
-  }
+  const code = str(body, "code");
+  if (!code.trim()) return badRequest("Missing required field: code");
 
   const input =
     typeof body.input === "string"
@@ -56,14 +58,22 @@ export async function POST(request: Request) {
       : typeof body.stdin === "string"
         ? body.stdin
         : undefined;
-  const timeLimitMs =
-    typeof body.timeLimitMs === "number" ? body.timeLimitMs : undefined;
-  const std = typeof body.std === "string" ? body.std : undefined;
-  const extraFlags = Array.isArray(body.compilerFlags)
-    ? body.compilerFlags.filter((f): f is string => typeof f === "string")
-    : undefined;
+  const opts = parseRunOptions(body);
+
+  const compiled = await compile(code, {
+    std: opts.std,
+    extraFlags: opts.extraFlags,
+    label: "run",
+  });
+  const compileBlock = {
+    ok: compiled.ok,
+    stderr: compiled.stderr,
+    ms: Math.round(compiled.ms),
+    cached: compiled.cached,
+    diagnostics: compiled.diagnostics,
+    rejectedFlags: compiled.rejectedFlags,
+  };
 
-  const compiled = await compile(code, { std, extraFlags, label: "run" });
   if (!compiled.ok || !compiled.binPath) {
     await cleanup(compiled.workDir);
     return NextResponse.json({
@@ -77,36 +87,27 @@ export async function POST(request: Request) {
       timeMs: 0,
       truncated: false,
       compiler: compiled.compiler,
-      compile: { ok: false, stderr: compiled.stderr, ms: compiled.ms },
+      compile: compileBlock,
     });
   }
 
-  let run: RunResult;
-  try {
-    run = await runBinary(compiled.binPath, { input, timeLimitMs });
-  } finally {
-    await cleanup(compiled.workDir);
-  }
-
-  const verdict = run.timedOut
-    ? "TLE"
-    : run.spawnError || run.exitCode !== 0 || run.signal
-      ? "RE"
-      : "OK";
+  const run = await runBinary(compiled.binPath, {
+    input,
+    timeLimitMs: opts.timeLimitMs,
+  });
+  const verdict = runVerdict(run);
 
   return NextResponse.json({
     ok: verdict === "OK",
     verdict,
     stdout: run.stdout,
-    stderr: run.spawnError
-      ? `${run.stderr}\n${run.spawnError}`.trim()
-      : run.stderr,
+    stderr: runStderr(run),
     exitCode: run.exitCode,
     signal: run.signal,
     timedOut: run.timedOut,
     timeMs: run.timeMs,
     truncated: run.truncated,
     compiler: compiled.compiler,
-    compile: { ok: true, stderr: compiled.stderr, ms: compiled.ms },
+    compile: compileBlock,
   });
 }
diff --git a/web/app/api/samples/route.ts b/web/app/api/samples/route.ts
new file mode 100644
index 0000000..2108c59
--- /dev/null
+++ b/web/app/api/samples/route.ts
@@ -0,0 +1,31 @@
+/**
+ * POST /api/samples — parse a pasted problem statement into sample tests.
+ *
+ * Request JSON:  { statement: string }
+ * Response JSON: {
+ *   title: string|null,          // first non-empty line ("A. Team")
+ *   timeLimitMs: number|null,    // from "time limit per test 2 seconds"
+ *   memoryLimitMb: number|null,  // from "memory limit per test 256 megabytes"
+ *   tests: { input: string, expected: string }[]
+ * }
+ * On a 400 the body is { error: string }.
+ */
+
+import { NextResponse } from "next/server";
+import { parseStatement } from "../_engine/statement";
+import { readJson, badRequest, str } from "../_engine/request";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const MAX_STATEMENT_BYTES = 1024 * 1024;
+
+export async function POST(request: Request) {
+  const { body, error } = await readJson(request);
+  if (error) return error;
+  const statement = str(body, "statement");
+  if (!statement.trim()) return badRequest("Missing required field: statement");
+  if (Buffer.byteLength(statement, "utf8") > MAX_STATEMENT_BYTES)
+    return badRequest("Statement is too large");
+  return NextResponse.json(parseStatement(statement));
+}
diff --git a/web/app/api/solution/route.ts b/web/app/api/solution/route.ts
index 54a98b1..fad7595 100644
--- a/web/app/api/solution/route.ts
+++ b/web/app/api/solution/route.ts
@@ -4,28 +4,36 @@
  * GET  /api/solution?problem=<name>  → { code: string }   ("" when absent)
  * POST /api/solution  { problem, code } → { success: true }
  *
- * Self-contained (Node built-ins only) so the api tree never imports web/lib.
+ * `problem` must be a single safe path segment (letters, digits, `_`, `-`,
+ * `.`); anything else is rejected with 400 so the route can never read or
+ * write outside the problems directory.
  */
 
 import { NextResponse } from "next/server";
-import { getSolution, saveSolution } from "../_engine/store";
+import { getSolution, saveSolution, isSafeProblemName } from "../_engine/store";
+import { readJson, badRequest, str } from "../_engine/request";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
+const MAX_CODE_BYTES = 1024 * 1024;
+
 export async function GET(request: Request) {
   const { searchParams } = new URL(request.url);
   const problem = searchParams.get("problem");
-  if (!problem)
-    return NextResponse.json({ error: "Missing problem" }, { status: 400 });
+  if (!isSafeProblemName(problem)) return badRequest("Invalid problem name");
   const code = await getSolution(problem);
   return NextResponse.json({ code });
 }
 
 export async function POST(request: Request) {
-  const { problem, code } = await request.json();
-  if (!problem)
-    return NextResponse.json({ error: "Missing problem" }, { status: 400 });
-  await saveSolution(problem, typeof code === "string" ? code : "");
+  const { body, error } = await readJson(request);
+  if (error) return error;
+  const problem = str(body, "problem");
+  if (!isSafeProblemName(problem)) return badRequest("Invalid problem name");
+  const code = str(body, "code");
+  if (Buffer.byteLength(code, "utf8") > MAX_CODE_BYTES)
+    return badRequest("Source is too large");
+  await saveSolution(problem, code);
   return NextResponse.json({ success: true });
 }
diff --git a/web/app/api/stress/route.ts b/web/app/api/stress/route.ts
index 0222224..4303056 100644
--- a/web/app/api/stress/route.ts
+++ b/web/app/api/stress/route.ts
@@ -3,7 +3,7 @@
  *
  * Compiles three C++ sources, then repeatedly: runs `generator <seed>` to make
  * an input, feeds that input to both `solution` and `brute`, and compares their
- * outputs (trailing-whitespace tolerant). Returns the first input on which they
+ * outputs under the chosen checker. Returns the first input on which they
  * disagree (or on which a program crashes / times out).
  *
  * The generator receives the iteration seed as argv[1] so runs are reproducible.
@@ -16,7 +16,10 @@
  *     iterations?: number,     // rounds to run, default 100, max 5000
  *     timeLimitMs?: number,    // per-program limit, default 5000
  *     seedBase?: number,       // first seed, default 1
- *     std?: string             // C++ standard, default gnu++17
+ *     std?: string,            // C++ standard, default gnu++17
+ *     compilerFlags?: string[],
+ *     checker?: "lines"|"tokens"|"float",
+ *     epsilon?: number
  *   }
  *
  * Response JSON (200):
@@ -24,10 +27,13 @@
  *     ok: boolean,                 // compiled & ran (not whether a bug was found)
  *     failed: boolean,             // true when a counter-example was found
  *     iterationsRun: number,
+ *     elapsedMs: number,           // wall-clock time spent iterating
+ *     deadlineHit: boolean,        // true when the request budget cut the search short
+ *     stats: { maxSolutionMs, maxBruteMs, avgSolutionMs },
  *     compile: {                   // per-source compile status
- *       solution: { ok, stderr, ms },
- *       brute:    { ok, stderr, ms },
- *       generator:{ ok, stderr, ms }
+ *       solution: { ok, stderr, ms, cached, diagnostics },
+ *       brute:    { ok, stderr, ms, cached, diagnostics },
+ *       generator:{ ok, stderr, ms, cached, diagnostics }
  *     },
  *     firstFailure?: {
  *       iteration: number,
@@ -49,47 +55,41 @@ import {
   compile,
   runBinary,
   cleanup,
+  runVerdict,
   type CompileResult,
 } from "../_engine/cpp";
 import { compareOutputs } from "../_engine/compare";
+import { readJson, badRequest, parseRunOptions, str } from "../_engine/request";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
 const MAX_ITERATIONS = 5000;
 // Overall wall-clock budget so a slow brute force can't hang a request forever.
-const TOTAL_DEADLINE_MS = 30_000;
+const TOTAL_DEADLINE_MS = 60_000;
 
 export async function POST(request: Request) {
-  let body: Record<string, unknown>;
-  try {
-    body = await request.json();
-  } catch {
-    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
-  }
+  const { body, error } = await readJson(request);
+  if (error) return error;
 
-  const solution = typeof body.solution === "string" ? body.solution : "";
-  const brute = typeof body.brute === "string" ? body.brute : "";
-  const generator = typeof body.generator === "string" ? body.generator : "";
+  const solution = str(body, "solution");
+  const brute = str(body, "brute");
+  const generator = str(body, "generator");
   if (!solution.trim() || !brute.trim() || !generator.trim()) {
-    return NextResponse.json(
-      {
-        error: "Provide non-empty `solution`, `brute` and `generator` sources",
-      },
-      { status: 400 },
+    return badRequest(
+      "Provide non-empty `solution`, `brute` and `generator` sources",
     );
   }
 
   const iterations = clampInt(body.iterations, 100, 1, MAX_ITERATIONS);
-  const timeLimitMs =
-    typeof body.timeLimitMs === "number" ? body.timeLimitMs : undefined;
   const seedBase = clampInt(body.seedBase, 1, 0, Number.MAX_SAFE_INTEGER);
-  const std = typeof body.std === "string" ? body.std : undefined;
+  const opts = parseRunOptions(body);
+  const compileOpts = { std: opts.std, extraFlags: opts.extraFlags };
 
   const [cs, cb, cg] = await Promise.all([
-    compile(solution, { std, label: "sol" }),
-    compile(brute, { std, label: "brute" }),
-    compile(generator, { std, label: "gen" }),
+    compile(solution, { ...compileOpts, label: "sol" }),
+    compile(brute, { ...compileOpts, label: "brute" }),
+    compile(generator, { ...compileOpts, label: "gen" }),
   ]);
 
   const compileBlock = {
@@ -109,115 +109,137 @@ export async function POST(request: Request) {
       ok: false,
       failed: false,
       iterationsRun: 0,
+      elapsedMs: 0,
+      deadlineHit: false,
+      stats: { maxSolutionMs: 0, maxBruteMs: 0, avgSolutionMs: 0 },
       compile: compileBlock,
       message: `Compilation failed for ${which}.`,
     });
   }
 
   const start = process.hrtime.bigint();
+  const elapsed = () => Number(process.hrtime.bigint() - start) / 1e6;
   let iterationsRun = 0;
+  let deadlineHit = false;
+  let maxSolutionMs = 0;
+  let maxBruteMs = 0;
+  let sumSolutionMs = 0;
   let firstFailure: Record<string, unknown> | undefined;
 
-  try {
-    for (let i = 0; i < iterations; i++) {
-      if (Number(process.hrtime.bigint() - start) / 1e6 > TOTAL_DEADLINE_MS)
-        break;
-      iterationsRun = i + 1;
-      const seed = seedBase + i;
-
-      const gen = await runBinary(cg.binPath, {
-        args: [String(seed)],
-        timeLimitMs,
-      });
-      if (gen.timedOut || gen.spawnError || gen.exitCode !== 0 || gen.signal) {
-        firstFailure = {
-          iteration: i + 1,
-          seed,
-          reason: "generator-error",
-          input: gen.stdout,
-          solutionOutput: "",
-          bruteOutput: "",
-          diff: [],
-          generatorStderr: gen.stderr,
-        };
-        break;
-      }
-      const input = gen.stdout;
-
-      const [solRun, bruteRun] = await Promise.all([
-        runBinary(cs.binPath, { input, timeLimitMs }),
-        runBinary(cb.binPath, { input, timeLimitMs }),
-      ]);
-
-      const solBad =
-        solRun.timedOut ||
-        solRun.spawnError ||
-        solRun.exitCode !== 0 ||
-        solRun.signal;
-      const bruteBad =
-        bruteRun.timedOut ||
-        bruteRun.spawnError ||
-        bruteRun.exitCode !== 0 ||
-        bruteRun.signal;
-
-      if (solBad || bruteBad) {
-        const reason = solRun.timedOut
+  for (let i = 0; i < iterations; i++) {
+    if (elapsed() > TOTAL_DEADLINE_MS) {
+      deadlineHit = true;
+      break;
+    }
+    iterationsRun = i + 1;
+    const seed = seedBase + i;
+
+    const gen = await runBinary(cg.binPath, {
+      args: [String(seed)],
+      timeLimitMs: opts.timeLimitMs,
+    });
+    if (runVerdict(gen) !== "OK") {
+      firstFailure = {
+        iteration: i + 1,
+        seed,
+        reason: "generator-error",
+        input: gen.stdout,
+        solutionOutput: "",
+        bruteOutput: "",
+        diff: [],
+        generatorStderr: gen.stderr,
+      };
+      break;
+    }
+    const input = gen.stdout;
+
+    const [solRun, bruteRun] = await Promise.all([
+      runBinary(cs.binPath, { input, timeLimitMs: opts.timeLimitMs }),
+      runBinary(cb.binPath, { input, timeLimitMs: opts.timeLimitMs }),
+    ]);
+    maxSolutionMs = Math.max(maxSolutionMs, solRun.timeMs);
+    maxBruteMs = Math.max(maxBruteMs, bruteRun.timeMs);
+    sumSolutionMs += solRun.timeMs;
+
+    const solV = runVerdict(solRun);
+    const bruteV = runVerdict(bruteRun);
+    if (solV !== "OK" || bruteV !== "OK") {
+      const reason =
+        solV === "TLE"
           ? "solution-tle"
-          : bruteRun.timedOut
+          : bruteV === "TLE"
             ? "brute-tle"
-            : solBad
+            : solV !== "OK"
               ? "solution-error"
               : "brute-error";
-        firstFailure = {
-          iteration: i + 1,
-          seed,
-          reason,
-          input,
-          solutionOutput: solRun.stdout,
-          bruteOutput: bruteRun.stdout,
-          solutionStderr: solRun.stderr,
-          bruteStderr: bruteRun.stderr,
-          diff: [],
-        };
-        break;
-      }
-
-      const cmp = compareOutputs(bruteRun.stdout, solRun.stdout);
-      if (!cmp.match) {
-        firstFailure = {
-          iteration: i + 1,
-          seed,
-          reason: "mismatch",
-          input,
-          solutionOutput: solRun.stdout,
-          bruteOutput: bruteRun.stdout,
-          diff: cmp.diff,
-        };
-        break;
-      }
+      firstFailure = {
+        iteration: i + 1,
+        seed,
+        reason,
+        input,
+        solutionOutput: solRun.stdout,
+        bruteOutput: bruteRun.stdout,
+        solutionStderr: solRun.stderr,
+        bruteStderr: bruteRun.stderr,
+        diff: [],
+      };
+      break;
+    }
+
+    const cmp = compareOutputs(bruteRun.stdout, solRun.stdout, {
+      mode: opts.checker,
+      epsilon: opts.epsilon,
+    });
+    if (!cmp.match) {
+      firstFailure = {
+        iteration: i + 1,
+        seed,
+        reason: "mismatch",
+        input,
+        solutionOutput: solRun.stdout,
+        bruteOutput: bruteRun.stdout,
+        diff: cmp.diff,
+      };
+      break;
     }
-  } finally {
-    await Promise.all([
-      cleanup(cs.workDir),
-      cleanup(cb.workDir),
-      cleanup(cg.workDir),
-    ]);
   }
 
+  const elapsedMs = Math.round(elapsed());
+  const message = firstFailure
+    ? `Found a counter-example on iteration ${firstFailure.iteration}.`
+    : deadlineHit
+      ? `No counter-example in ${iterationsRun} iteration(s) before the ${TOTAL_DEADLINE_MS / 1000}s request budget ran out.`
+      : `No counter-example found in ${iterationsRun} iteration(s).`;
+
   return NextResponse.json({
     ok: true,
     failed: !!firstFailure,
     iterationsRun,
+    elapsedMs,
+    deadlineHit,
+    stats: {
+      maxSolutionMs: round1(maxSolutionMs),
+      maxBruteMs: round1(maxBruteMs),
+      avgSolutionMs: round1(iterationsRun ? sumSolutionMs / iterationsRun : 0),
+    },
     compile: compileBlock,
     firstFailure,
-    message: firstFailure
-      ? `Found a counter-example on iteration ${firstFailure.iteration}.`
-      : `No counter-example found in ${iterationsRun} iteration(s).`,
+    message,
   });
 }
 
 function toCompileStatus(c: CompileResult) {
-  return { ok: c.ok, stderr: c.stderr, ms: c.ms };
+  return {
+    ok: c.ok,
+    stderr: c.stderr,
+    ms: Math.round(c.ms),
+    cached: c.cached,
+    diagnostics: c.diagnostics,
+  };
+}
+
+function round1(n: number): number {
+  return Math.round(n * 10) / 10;
 }
 
 function clampInt(v: unknown, def: number, lo: number, hi: number): number {
diff --git a/web/app/api/template/route.ts b/web/app/api/template/route.ts
index 3e1924e..7f0aed8 100644
--- a/web/app/api/template/route.ts
+++ b/web/app/api/template/route.ts
@@ -1,23 +1,28 @@
 /**
- * POST /api/template — fetch a named starter template from `templates/<name>.cpp`.
+ * /api/template — starter templates shipped under the repo `templates/` dir.
  *
- * Request:  { name: string }     // e.g. "dp", "graph", "math"
- * Response: { stdout: string, stderr: string, exitCode: number, content: string }
+ * GET  /api/template            → { templates: string[] }   // e.g. ["dp","graph","math"]
+ * POST /api/template { name }   → { stdout, stderr, exitCode, content }
  *           `stdout` and `content` both hold the template text (stdout kept for
  *           backward compatibility). On a miss: exitCode 1 and an error stderr.
- *
- * Self-contained (Node built-ins only) so the api tree never imports web/lib.
  */
 
 import { NextResponse } from "next/server";
-import { readTemplate } from "../_engine/store";
+import { readTemplate, listTemplates } from "../_engine/store";
+import { readJson, str } from "../_engine/request";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
+export async function GET() {
+  return NextResponse.json({ templates: await listTemplates() });
+}
+
 export async function POST(request: Request) {
-  const { name } = await request.json();
-  const content = await readTemplate(typeof name === "string" ? name : "");
+  const { body, error } = await readJson(request);
+  if (error) return error;
+  const name = str(body, "name");
+  const content = await readTemplate(name);
   if (!content) {
     return NextResponse.json({
       stdout: "",
diff --git a/web/app/api/test/route.ts b/web/app/api/test/route.ts
index a5751e7..c273bca 100644
--- a/web/app/api/test/route.ts
+++ b/web/app/api/test/route.ts
@@ -7,18 +7,22 @@
  *     tests: { input: string, expected: string }[],  // cases (required)
  *     timeLimitMs?: number,                  // per-case limit, default 5000
  *     std?: string,                          // C++ standard, default gnu++17
- *     compilerFlags?: string[]
+ *     compilerFlags?: string[],              // validated against an allowlist
+ *     checker?: "lines"|"tokens"|"float",    // comparison mode, default lines
+ *     epsilon?: number,                      // float checker tolerance
+ *     stopOnFirstFailure?: boolean           // skip remaining cases after a non-AC
  *   }
  *
  * Response JSON (200):
  *   {
  *     ok: boolean,                           // true when every case is AC
  *     compiler: string|null,
- *     compile: { ok: boolean, stderr: string, ms: number },
- *     summary: { total, passed, failed, verdict },  // verdict is worst-of
+ *     compile: { ok, stderr, ms, cached, diagnostics, rejectedFlags },
+ *     checker: "lines"|"tokens"|"float",
+ *     summary: { total, passed, failed, skipped, verdict, maxTimeMs, totalTimeMs },
  *     results: Array<{
  *       index: number,
- *       verdict: "AC"|"WA"|"TLE"|"RE"|"CE",
+ *       verdict: "AC"|"WA"|"TLE"|"RE"|"CE"|"SKIPPED",
  *       input: string,
  *       expected: string,
  *       actual: string,                      // program stdout
@@ -27,74 +31,71 @@
  *       signal: string|null,
  *       timeMs: number,
  *       truncated: boolean,
+ *       presentationOnly: boolean,           // WA only: tokens match, layout differs
  *       diff: Array<{ line, expected, actual, same }>  // differing lines, WA only
  *     }>
  *   }
  * On a 400 the body is { error: string }.
- *
- * Comparison is trailing-whitespace tolerant (see _engine/compare).
  */
 
 import { NextResponse } from "next/server";
-import { compile, runBinary, cleanup } from "../_engine/cpp";
+import {
+  compile,
+  runBinary,
+  cleanup,
+  runVerdict,
+  runStderr,
+} from "../_engine/cpp";
 import { compareOutputs } from "../_engine/compare";
+import { normalizeTests } from "../_engine/store";
+import { readJson, badRequest, parseRunOptions, str } from "../_engine/request";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
-type Verdict = "AC" | "WA" | "TLE" | "RE" | "CE";
+type Verdict = "AC" | "WA" | "TLE" | "RE" | "CE" | "SKIPPED";
 
 // Worst-of ordering for the overall summary verdict.
 const SEVERITY: Record<Verdict, number> = {
   AC: 0,
+  SKIPPED: 0,
   WA: 1,
   TLE: 2,
   RE: 3,
   CE: 4,
 };
 
+const MAX_TESTS = 200;
+
 export async function POST(request: Request) {
-  let body: Record<string, unknown>;
-  try {
-    body = await request.json();
-  } catch {
-    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
-  }
+  const { body, error } = await readJson(request);
+  if (error) return error;
 
-  const code = typeof body.code === "string" ? body.code : "";
-  if (!code.trim()) {
-    return NextResponse.json(
-      { error: "Missing required field: code" },
-      { status: 400 },
-    );
-  }
+  const code = str(body, "code");
+  if (!code.trim()) return badRequest("Missing required field: code");
 
-  const tests = Array.isArray(body.tests)
-    ? body.tests
-        .filter(
-          (t): t is Record<string, unknown> => !!t && typeof t === "object",
-        )
-        .map((t) => ({
-          input: typeof t.input === "string" ? t.input : "",
-          expected: typeof t.expected === "string" ? t.expected : "",
-        }))
-    : [];
-
-  if (tests.length === 0) {
-    return NextResponse.json(
-      { error: "Provide at least one test case in `tests`" },
-      { status: 400 },
-    );
-  }
+  const tests = normalizeTests(body.tests);
+  if (tests.length === 0)
+    return badRequest("Provide at least one test case in `tests`");
+  if (tests.length > MAX_TESTS)
+    return badRequest(`At most ${MAX_TESTS} test cases per request`);
 
-  const timeLimitMs =
-    typeof body.timeLimitMs === "number" ? body.timeLimitMs : undefined;
-  const std = typeof body.std === "string" ? body.std : undefined;
-  const extraFlags = Array.isArray(body.compilerFlags)
-    ? body.compilerFlags.filter((f): f is string => typeof f === "string")
-    : undefined;
+  const opts = parseRunOptions(body);
+  const stopOnFirstFailure = body.stopOnFirstFailure === true;
 
-  const compiled = await compile(code, { std, extraFlags, label: "test" });
+  const compiled = await compile(code, {
+    std: opts.std,
+    extraFlags: opts.extraFlags,
+    label: "test",
+  });
+  const compileBlock = {
+    ok: compiled.ok,
+    stderr: compiled.stderr,
+    ms: Math.round(compiled.ms),
+    cached: compiled.cached,
+    diagnostics: compiled.diagnostics,
+    rejectedFlags: compiled.rejectedFlags,
+  };
 
   // Compile error → every case reports CE so the UI can badge each row.
   if (!compiled.ok || !compiled.binPath) {
@@ -110,78 +111,109 @@ export async function POST(request: Request) {
       signal: null,
       timeMs: 0,
       truncated: false,
+      presentationOnly: false,
       diff: [],
     }));
     return NextResponse.json({
       ok: false,
       compiler: compiled.compiler,
-      compile: { ok: false, stderr: compiled.stderr, ms: compiled.ms },
+      compile: compileBlock,
+      checker: opts.checker,
       summary: {
         total: tests.length,
         passed: 0,
         failed: tests.length,
+        skipped: 0,
         verdict: "CE",
+        maxTimeMs: 0,
+        totalTimeMs: 0,
       },
       results,
     });
   }
 
   const results = [];
-  try {
-    for (let index = 0; index < tests.length; index++) {
-      const t = tests[index];
-      const run = await runBinary(compiled.binPath, {
-        input: t.input,
-        timeLimitMs,
-      });
-
-      let verdict: Verdict;
-      let diff: ReturnType<typeof compareOutputs>["diff"] = [];
-      if (run.timedOut) {
-        verdict = "TLE";
-      } else if (run.spawnError || run.exitCode !== 0 || run.signal) {
-        verdict = "RE";
-      } else {
-        const cmp = compareOutputs(t.expected, run.stdout);
-        verdict = cmp.match ? "AC" : "WA";
-        diff = cmp.diff;
-      }
-
+  let failedSoFar = false;
+  for (let index = 0; index < tests.length; index++) {
+    const t = tests[index];
+    if (stopOnFirstFailure && failedSoFar) {
       results.push({
         index,
-        verdict,
+        verdict: "SKIPPED" as Verdict,
         input: t.input,
         expected: t.expected,
-        actual: run.stdout,
-        stderr: run.spawnError
-          ? `${run.stderr}\n${run.spawnError}`.trim()
-          : run.stderr,
-        exitCode: run.exitCode,
-        signal: run.signal,
-        timeMs: run.timeMs,
-        truncated: run.truncated,
-        diff,
+        actual: "",
+        stderr: "",
+        exitCode: null,
+        signal: null,
+        timeMs: 0,
+        truncated: false,
+        presentationOnly: false,
+        diff: [],
       });
+      continue;
     }
-  } finally {
-    await cleanup(compiled.workDir);
+
+    const run = await runBinary(compiled.binPath, {
+      input: t.input,
+      timeLimitMs: opts.timeLimitMs,
+    });
+
+    let verdict: Verdict;
+    let diff: ReturnType<typeof compareOutputs>["diff"] = [];
+    let presentationOnly = false;
+    const rv = runVerdict(run);
+    if (rv !== "OK") {
+      verdict = rv;
+    } else {
+      const cmp = compareOutputs(t.expected, run.stdout, {
+        mode: opts.checker,
+        epsilon: opts.epsilon,
+      });
+      verdict = cmp.match ? "AC" : "WA";
+      diff = cmp.diff;
+      presentationOnly = !!cmp.presentationOnly;
+    }
+    if (verdict !== "AC") failedSoFar = true;
+
+    results.push({
+      index,
+      verdict,
+      input: t.input,
+      expected: t.expected,
+      actual: run.stdout,
+      stderr: runStderr(run),
+      exitCode: run.exitCode,
+      signal: run.signal,
+      timeMs: run.timeMs,
+      truncated: run.truncated,
+      presentationOnly,
+      diff,
+    });
   }
 
   const passed = results.filter((r) => r.verdict === "AC").length;
+  const skipped = results.filter((r) => r.verdict === "SKIPPED").length;
   const worst = results.reduce<Verdict>(
     (acc, r) => (SEVERITY[r.verdict] > SEVERITY[acc] ? r.verdict : acc),
     "AC",
   );
+  const maxTimeMs = results.reduce((m, r) => Math.max(m, r.timeMs), 0);
+  const totalTimeMs = results.reduce((s, r) => s + r.timeMs, 0);
 
   return NextResponse.json({
     ok: passed === results.length,
     compiler: compiled.compiler,
-    compile: { ok: true, stderr: compiled.stderr, ms: compiled.ms },
+    compile: compileBlock,
+    checker: opts.checker,
     summary: {
       total: results.length,
       passed,
-      failed: results.length - passed,
+      failed: results.length - passed - skipped,
+      skipped,
       verdict: worst,
+      maxTimeMs: Math.round(maxTimeMs * 10) / 10,
+      totalTimeMs: Math.round(totalTimeMs * 10) / 10,
     },
     results,
   });
diff --git a/web/package-lock.json b/web/package-lock.json
index bcbc3ff..4d91476 100644
--- a/web/package-lock.json
+++ b/web/package-lock.json
@@ -32,7 +32,8 @@
         "typescript": "5.9.3"
       },
       "devDependencies": {
-        "@playwright/test": "^1.49.0"
+        "@playwright/test": "^1.49.0",
+        "vitest": "^3.2.7"
       }
     },
     "node_modules/@alloc/quick-lru": {
@@ -701,6 +702,448 @@
         "tslib": "^2.4.0"
       }
     },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
+      "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz",
+      "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz",
+      "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz",
+      "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz",
+      "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz",
+      "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz",
+      "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz",
+      "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz",
+      "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz",
+      "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz",
+      "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz",
+      "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz",
+      "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz",
+      "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz",
+      "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz",
+      "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz",
+      "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz",
+      "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz",
+      "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz",
+      "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz",
+      "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@eslint-community/eslint-utils": {
       "version": "4.9.1",
       "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
@@ -1627,6 +2070,26 @@
         "node": ">=18"
       }
     },
+    "node_modules/@napi-rs/lzma-linux-x64-gnu": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",
+      "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^22.20 || ^24.12 || >=25"
+      }
+    },
     "node_modules/@napi-rs/wasm-runtime": {
       "version": "0.2.12",
       "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
@@ -3142,87 +3605,226 @@
       },
       "peerDependencies": {
         "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-toolbar": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-toolbar/-/react-toolbar-1.1.11.tgz",
+      "integrity": "sha512-4ol06/1bLoFu1nwUqzdD4Y5RZ9oDdKeiHIsntug54Hcr1pgaHiPqHFEaXI1IFP/EsOfROQZ8Mig9VTIRza6Tjg==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/primitive": "1.1.3",
+        "@radix-ui/react-context": "1.1.2",
+        "@radix-ui/react-direction": "1.1.1",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-roving-focus": "1.1.11",
+        "@radix-ui/react-separator": "1.1.7",
+        "@radix-ui/react-toggle-group": "1.1.11"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-tooltip": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-tooltip/-/react-tooltip-1.2.8.tgz",
+      "integrity": "sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/primitive": "1.1.3",
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-context": "1.1.2",
+        "@radix-ui/react-dismissable-layer": "1.1.11",
+        "@radix-ui/react-id": "1.1.1",
+        "@radix-ui/react-popper": "1.2.8",
+        "@radix-ui/react-portal": "1.1.9",
+        "@radix-ui/react-presence": "1.1.5",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-slot": "1.2.3",
+        "@radix-ui/react-use-controllable-state": "1.2.2",
+        "@radix-ui/react-visually-hidden": "1.2.3"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-use-callback-ref": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz",
+      "integrity": "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-use-controllable-state": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz",
+      "integrity": "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/react-use-effect-event": "0.0.2",
+        "@radix-ui/react-use-layout-effect": "1.1.1"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-use-effect-event": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz",
+      "integrity": "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/react-use-layout-effect": "1.1.1"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-use-escape-keydown": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz",
+      "integrity": "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/react-use-callback-ref": "1.1.1"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-use-is-hydrated": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-is-hydrated/-/react-use-is-hydrated-0.1.0.tgz",
+      "integrity": "sha512-U+UORVEq+cTnRIaostJv9AGdV3G6Y+zbVd+12e18jQ5A3c0xL03IhnHuiU4UV69wolOQp5GfR58NW/EgdQhwOA==",
+      "license": "MIT",
+      "dependencies": {
+        "use-sync-external-store": "^1.5.0"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-use-layout-effect": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz",
+      "integrity": "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
       "peerDependenciesMeta": {
         "@types/react": {
           "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
         }
       }
     },
-    "node_modules/@radix-ui/react-toolbar": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-toolbar/-/react-toolbar-1.1.11.tgz",
-      "integrity": "sha512-4ol06/1bLoFu1nwUqzdD4Y5RZ9oDdKeiHIsntug54Hcr1pgaHiPqHFEaXI1IFP/EsOfROQZ8Mig9VTIRza6Tjg==",
+    "node_modules/@radix-ui/react-use-previous": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz",
+      "integrity": "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==",
       "license": "MIT",
-      "dependencies": {
-        "@radix-ui/primitive": "1.1.3",
-        "@radix-ui/react-context": "1.1.2",
-        "@radix-ui/react-direction": "1.1.1",
-        "@radix-ui/react-primitive": "2.1.3",
-        "@radix-ui/react-roving-focus": "1.1.11",
-        "@radix-ui/react-separator": "1.1.7",
-        "@radix-ui/react-toggle-group": "1.1.11"
-      },
       "peerDependencies": {
         "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
       "peerDependenciesMeta": {
         "@types/react": {
           "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
         }
       }
     },
-    "node_modules/@radix-ui/react-tooltip": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-tooltip/-/react-tooltip-1.2.8.tgz",
-      "integrity": "sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==",
+    "node_modules/@radix-ui/react-use-rect": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz",
+      "integrity": "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==",
       "license": "MIT",
       "dependencies": {
-        "@radix-ui/primitive": "1.1.3",
-        "@radix-ui/react-compose-refs": "1.1.2",
-        "@radix-ui/react-context": "1.1.2",
-        "@radix-ui/react-dismissable-layer": "1.1.11",
-        "@radix-ui/react-id": "1.1.1",
-        "@radix-ui/react-popper": "1.2.8",
-        "@radix-ui/react-portal": "1.1.9",
-        "@radix-ui/react-presence": "1.1.5",
-        "@radix-ui/react-primitive": "2.1.3",
-        "@radix-ui/react-slot": "1.2.3",
-        "@radix-ui/react-use-controllable-state": "1.2.2",
-        "@radix-ui/react-visually-hidden": "1.2.3"
+        "@radix-ui/rect": "1.1.1"
       },
       "peerDependencies": {
         "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
       "peerDependenciesMeta": {
         "@types/react": {
           "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
         }
       }
     },
-    "node_modules/@radix-ui/react-use-callback-ref": {
+    "node_modules/@radix-ui/react-use-size": {
       "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz",
-      "integrity": "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz",
+      "integrity": "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==",
       "license": "MIT",
+      "dependencies": {
+        "@radix-ui/react-use-layout-effect": "1.1.1"
+      },
       "peerDependencies": {
         "@types/react": "*",
         "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
@@ -3233,173 +3835,423 @@
         }
       }
     },
-    "node_modules/@radix-ui/react-use-controllable-state": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz",
-      "integrity": "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==",
+    "node_modules/@radix-ui/react-visually-hidden": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz",
+      "integrity": "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==",
       "license": "MIT",
       "dependencies": {
-        "@radix-ui/react-use-effect-event": "0.0.2",
-        "@radix-ui/react-use-layout-effect": "1.1.1"
+        "@radix-ui/react-primitive": "2.1.3"
       },
       "peerDependencies": {
         "@types/react": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
       "peerDependenciesMeta": {
         "@types/react": {
           "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
         }
       }
     },
-    "node_modules/@radix-ui/react-use-effect-event": {
-      "version": "0.0.2",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz",
-      "integrity": "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==",
+    "node_modules/@radix-ui/rect": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz",
+      "integrity": "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==",
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.3.tgz",
+      "integrity": "sha512-w3Jnvi1ocaVm/c7yVPpfB98XeSRBMyzp6njL5MVVbGyXjpmUkN+s6Hp4t0PqhGCCaI1ZHMKXt/w0lA1RCaLVcw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.3.tgz",
+      "integrity": "sha512-uI/ESiaIbbRYAEhzy8PCUWDp1hB0bjAqM06mW9flOoNO4Q8DQpeoREhBR5Hegfl+wpXiguyJv6XSPzEN7OxyHQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.3.tgz",
+      "integrity": "sha512-oxhrd1jmXLwWZ83eQYDXxuqRdkqkzrjR3JobKeuUyfdNZo11FuQIvqEOZhyIT7OBHxXoGslDDjN0cQcM6T0TqQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.3.tgz",
+      "integrity": "sha512-7/YiIMghVE8DrxKvNdorAaJVdriOFgOIpdStnPx8ppx5zfTwC3jBCSEAIzB7JD5404m65THl6H93UTTVUvypmg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.3.tgz",
+      "integrity": "sha512-GXFZRRoMAytaI5z6N3Zhfw0WL18Q0M8r95D5hlC4GqE/lGk8pbSJNUBoOWDfbm6dTciqHj2nU87tI5f6XhQiOg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.3.tgz",
+      "integrity": "sha512-77W+8X3ddYgPxUpB8nZFQs2Mq+wc4HVlcSRtApXLjYBcnPMkttrSnU8VwKQjeWYhMsITHFs5cWBQ8vz1Q+5RHQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.3.tgz",
+      "integrity": "sha512-FVkwK+iUC+mq+GipVK46rRVticfAPtvPUNlqlGXUDxdVk/UGjQiiiUVPUrEXdSpU2ufU0XxLGyTqDtBidDOVmg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.3.tgz",
+      "integrity": "sha512-+aGU1t3398yQOVj1Bz8o3e+KtswxAPvO+mtxtNdfXYMkXIHu7XhhkCD7/DEH9q8tF8uhDnMWvfpUKI8y1sZJsg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.3.tgz",
+      "integrity": "sha512-cR0kjpRXR2KJ2oQK8E2KTPtphs+b9hZ8IhTZubNryt/RsqgdOZBQ2Zq0q5UedtiIi0rs3jVhJh55RE1ZHUVGUA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.3.tgz",
+      "integrity": "sha512-y1RYi4Q3/9ByVWSSt9kX2ustE0B7kFYbJ6zZdVZVyqopZs3yhCTwRfrjIX4vezUJInma/Gs6BOFDJg7yZmJ0IQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.3.tgz",
+      "integrity": "sha512-DNhEA5viIj3Z5bZLE4z4oV8N5ozWqDwyt7T6KG7VdLDJ0nW+rNOYlphBl4/3HQkK75qipPLsVOfStHHOwN9WSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.3.tgz",
+      "integrity": "sha512-17gQCqrIpXBX2Cmi9/TygnVOqGbzsba/iaqcYSL8FY7lNugg+7AiYNs5c5nKWD+NRQha36Sa0CqkJqH4XVHwnQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.3.tgz",
+      "integrity": "sha512-6LwVnZRIyINpdku/yOcI8Tm9YqLmhHK5emmlOOnW9tO0SYEm1FmKPcsSAGp0NBlqR2P04xaND4jvN6sTHqhq8A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.3.tgz",
+      "integrity": "sha512-xMUqkTXlEUtI/p5AAukMwBRr1enU3efsTeF+bskeFfk8t1C9rcC8sLREcZXmTfAXEbvRdJVSonVJez3TMlbR3w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.3.tgz",
+      "integrity": "sha512-S3E94co9F9WRRqEaUoQZ38K1gCz6KiM+nL7/3ijq7fDGF3OznjS5TasgYITlvl27GQKtu4lOAOsr5MFwkijvOA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.3.tgz",
+      "integrity": "sha512-1QtRDwG42x5BJI3s9mxu5rEjDnfbSnk20HQ9/ylTAYnSwYwxMVb+Vgu34wzzTQ7ogqBybebgQNUDAvZVQ38DbA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.3.tgz",
+      "integrity": "sha512-BQhejF6ZXOpxbngiNTP12GCGQeaDVL2QXGeBVViKIYzFHM5RKxTxwUMB1fr1BeNFphFMpnRqC5QSXFSa4z6UQw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "MIT",
-      "dependencies": {
-        "@radix-ui/react-use-layout-effect": "1.1.1"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "linux"
+      ]
     },
-    "node_modules/@radix-ui/react-use-escape-keydown": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz",
-      "integrity": "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==",
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.3.tgz",
+      "integrity": "sha512-SXagRwnI2Wlwlitllu59UK/nGVbD1CKPcNqDplHwIC4BqJcpXFjD32d1R/RbuISa95HdQrZM3/7v4bKiowFaLA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
       "license": "MIT",
-      "dependencies": {
-        "@radix-ui/react-use-callback-ref": "1.1.1"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "linux"
+      ]
     },
-    "node_modules/@radix-ui/react-use-is-hydrated": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-is-hydrated/-/react-use-is-hydrated-0.1.0.tgz",
-      "integrity": "sha512-U+UORVEq+cTnRIaostJv9AGdV3G6Y+zbVd+12e18jQ5A3c0xL03IhnHuiU4UV69wolOQp5GfR58NW/EgdQhwOA==",
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.3.tgz",
+      "integrity": "sha512-2IPozoEALRCziGqE8O9KMK60PMu5TS1huv4fwoeCexj+WjmcwFtX9CTOVbfXCUqcELAubEwRFPYlzb/WvwY2HQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
       "license": "MIT",
-      "dependencies": {
-        "use-sync-external-store": "^1.5.0"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "linux"
+      ]
     },
-    "node_modules/@radix-ui/react-use-layout-effect": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz",
-      "integrity": "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==",
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.3.tgz",
+      "integrity": "sha512-AoxqosUHT9IX54hFn2TiN6A7d6ZKTtE6pd2bqWtqkkNJ6HJGaU6FRouGX8L1O7R/ZwsnCnpQrHzb4pDEx+UHRQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "@types/react": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
     },
-    "node_modules/@radix-ui/react-use-previous": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz",
-      "integrity": "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==",
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.3.tgz",
+      "integrity": "sha512-d+CaftKgmkFBzCwezMqqy1d0QNNYugqLCMcYVQWBy5SS2YfeMP8Q8ripkgx9O8IyBXXLHrJ+aaCV4U96usv6Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
       "license": "MIT",
-      "peerDependencies": {
-        "@types/react": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
     },
-    "node_modules/@radix-ui/react-use-rect": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz",
-      "integrity": "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==",
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.3.tgz",
+      "integrity": "sha512-xXlDF6nR1eOuXbdDy5Hl5fmtY7teUDevF/k0O7IPoZe4Tpmdv+lgdE5JRsnhQtt37ql9P0VF2kAN9a0OCZdo+Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@radix-ui/rect": "1.1.1"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "win32"
+      ]
     },
-    "node_modules/@radix-ui/react-use-size": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz",
-      "integrity": "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==",
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.3.tgz",
+      "integrity": "sha512-YtXAgLN+JP7Ay6qG3eWhc7IHMQPzLc8r3uvhAvlJIoCz/4Q32+Bl9Fmnywidh8v1GOIMmymjovfqY9ETAtysvA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@radix-ui/react-use-layout-effect": "1.1.1"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "win32"
+      ]
     },
-    "node_modules/@radix-ui/react-visually-hidden": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz",
-      "integrity": "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==",
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.3.tgz",
+      "integrity": "sha512-WuWtSJRNo549vzcfZyEgfqb6zeSgn1F+UE5kQ+BCjzz0W4MGCjntUHkZVc1VRuAM7+ULaSyhiPxD1spyewFvkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@radix-ui/react-primitive": "2.1.3"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-      },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "win32"
+      ]
     },
-    "node_modules/@radix-ui/rect": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz",
-      "integrity": "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==",
-      "license": "MIT"
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.3.tgz",
+      "integrity": "sha512-+lIKX7O0+IGe7WuhATaAMMeT7B76vfhXH/l9wLQL+nvyhbw2ohYCKIdWL56JfDu75CWt5oKRP4QFH/jkMtBquA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
     },
     "node_modules/@rtsao/scc": {
       "version": "1.1.0",
@@ -3754,10 +4606,28 @@
         "tslib": "^2.4.0"
       }
     },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
-      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
       "license": "MIT"
     },
     "node_modules/@types/json-schema": {
@@ -4317,10 +5187,125 @@
         "x64"
       ],
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@vitest/expect": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.7.tgz",
+      "integrity": "sha512-E8eBXaKibuvH2pSZErOjdVb5vF4PbKYcrnluBTYxEk1l/VhhwZg1kZQsdtjq+CsF5CFydf2Rdkz7jDHKSisi3w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "3.2.7",
+        "@vitest/utils": "3.2.7",
+        "chai": "^5.2.0",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.7.tgz",
+      "integrity": "sha512-Trr0hYO9CM3Wj6ksWHRhK9IZpIY6wTMO5u/MqXurMxT57sWBaOPEtP3Oq60ihZuh5JsiagKfz95OcxdEP6dBrA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "3.2.7",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.17"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.7.tgz",
+      "integrity": "sha512-KUHlwqVu0sRlhCdyPdQ/wBoTfRahjUky1MubOmYw9fWfIZy1gNoHpuaaQBPAaMaVYdQYHJLurzj8ECCj5OwTqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.7.tgz",
+      "integrity": "sha512-sB9y4ovltoQP+WaUPwmSxO9WIg9Ig694Di5PalVPsYHklAdE027mehpWF2SQSVq+k6sFgaivbTjTJwZLSHbedA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "3.2.7",
+        "pathe": "^2.0.3",
+        "strip-literal": "^3.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.7.tgz",
+      "integrity": "sha512-7C+MwShwtBSI5Buwoyg3s/iY1eHL9PKAf+O1wVh/TdnjXUtkoL/9YQtre90i4MtNXM6edP1wJ2zOBpfCyhIS7g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.7",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.7.tgz",
+      "integrity": "sha512-Q2eQGI6d2L/hBtZ0qNuKcAGid68XK6cv1xsoaIma6PaJhHPoqcEJhYpXZ/5myCMqkNgtP6UKuBhbc0nHKnrkuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^4.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.7.tgz",
+      "integrity": "sha512-x6BDOd7dyo3PFLY3I9/HJ25X/6OurhGXk2/B9gOZNPF7XDVjeBK4k01lQE5uvDpbuheErh91qYuE1E2OEjK3Rw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.7",
+        "loupe": "^3.1.4",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
     },
     "node_modules/accepts": {
       "version": "2.0.0",
@@ -4635,6 +5620,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/ast-types": {
       "version": "0.16.1",
       "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.16.1.tgz",
@@ -4813,6 +5808,16 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/call-bind": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
@@ -4889,6 +5894,23 @@
       ],
       "license": "CC-BY-4.0"
     },
+    "node_modules/chai": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -4905,6 +5927,16 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/check-error": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
+      "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
     "node_modules/class-variance-authority": {
       "version": "0.7.1",
       "resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz",
@@ -5297,6 +6329,16 @@
         }
       }
     },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -5645,6 +6687,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/es-object-atoms": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
@@ -5701,6 +6750,48 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/esbuild": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
+      "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.28.2",
+        "@esbuild/android-arm": "0.28.2",
+        "@esbuild/android-arm64": "0.28.2",
+        "@esbuild/android-x64": "0.28.2",
+        "@esbuild/darwin-arm64": "0.28.2",
+        "@esbuild/darwin-x64": "0.28.2",
+        "@esbuild/freebsd-arm64": "0.28.2",
+        "@esbuild/freebsd-x64": "0.28.2",
+        "@esbuild/linux-arm": "0.28.2",
+        "@esbuild/linux-arm64": "0.28.2",
+        "@esbuild/linux-ia32": "0.28.2",
+        "@esbuild/linux-loong64": "0.28.2",
+        "@esbuild/linux-mips64el": "0.28.2",
+        "@esbuild/linux-ppc64": "0.28.2",
+        "@esbuild/linux-riscv64": "0.28.2",
+        "@esbuild/linux-s390x": "0.28.2",
+        "@esbuild/linux-x64": "0.28.2",
+        "@esbuild/netbsd-arm64": "0.28.2",
+        "@esbuild/netbsd-x64": "0.28.2",
+        "@esbuild/openbsd-arm64": "0.28.2",
+        "@esbuild/openbsd-x64": "0.28.2",
+        "@esbuild/openharmony-arm64": "0.28.2",
+        "@esbuild/sunos-x64": "0.28.2",
+        "@esbuild/win32-arm64": "0.28.2",
+        "@esbuild/win32-ia32": "0.28.2",
+        "@esbuild/win32-x64": "0.28.2"
+      }
+    },
     "node_modules/escalade": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
@@ -6135,6 +7226,16 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
     "node_modules/esutils": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
@@ -6200,6 +7301,16 @@
         "url": "https://github.com/sindresorhus/execa?sponsor=1"
       }
     },
+    "node_modules/expect-type": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",
+      "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/express": {
       "version": "5.2.1",
       "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
@@ -8099,6 +9210,13 @@
         "loose-envify": "cli.js"
       }
     },
+    "node_modules/loupe": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -8902,6 +10020,23 @@
       "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==",
       "license": "MIT"
     },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pathval": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
+      }
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -9499,6 +10634,52 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/rollup": {
+      "version": "4.63.3",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.63.3.tgz",
+      "integrity": "sha512-1i2XreiAoMMXuPGD6Msj2xWrMMkHojNRKivInxGQcg7/1KuPuYlfUutLyh4drnOxUTHX9cHI4wFoat8D/NKaBw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@napi-rs/lzma-linux-x64-gnu": "1.5.1",
+        "@rollup/rollup-android-arm-eabi": "4.63.3",
+        "@rollup/rollup-android-arm64": "4.63.3",
+        "@rollup/rollup-darwin-arm64": "4.63.3",
+        "@rollup/rollup-darwin-x64": "4.63.3",
+        "@rollup/rollup-freebsd-arm64": "4.63.3",
+        "@rollup/rollup-freebsd-x64": "4.63.3",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.63.3",
+        "@rollup/rollup-linux-arm-musleabihf": "4.63.3",
+        "@rollup/rollup-linux-arm64-gnu": "4.63.3",
+        "@rollup/rollup-linux-arm64-musl": "4.63.3",
+        "@rollup/rollup-linux-loong64-gnu": "4.63.3",
+        "@rollup/rollup-linux-loong64-musl": "4.63.3",
+        "@rollup/rollup-linux-ppc64-gnu": "4.63.3",
+        "@rollup/rollup-linux-ppc64-musl": "4.63.3",
+        "@rollup/rollup-linux-riscv64-gnu": "4.63.3",
+        "@rollup/rollup-linux-riscv64-musl": "4.63.3",
+        "@rollup/rollup-linux-s390x-gnu": "4.63.3",
+        "@rollup/rollup-linux-x64-gnu": "4.63.3",
+        "@rollup/rollup-linux-x64-musl": "4.63.3",
+        "@rollup/rollup-openbsd-x64": "4.63.3",
+        "@rollup/rollup-openharmony-arm64": "4.63.3",
+        "@rollup/rollup-win32-arm64-msvc": "4.63.3",
+        "@rollup/rollup-win32-ia32-msvc": "4.63.3",
+        "@rollup/rollup-win32-x64-gnu": "4.63.3",
+        "@rollup/rollup-win32-x64-msvc": "4.63.3",
+        "fsevents": "~2.3.2"
+      }
+    },
     "node_modules/router": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
@@ -9978,6 +11159,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/signal-exit": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
@@ -10030,6 +11218,13 @@
       "integrity": "sha512-+L3ccpzibovGXFK+Ap/f8LOS0ahMrHTf3xu7mMLSpEGU0EO9ucaysSylKo9eRDFNhWve/y275iPmIZ4z39a9iA==",
       "license": "MIT"
     },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/statuses": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
@@ -10039,6 +11234,13 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/stdin-discarder": {
       "version": "0.2.2",
       "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.2.2.tgz",
@@ -10265,6 +11467,26 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/strip-literal": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz",
+      "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^9.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/strip-literal/node_modules/js-tokens": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz",
+      "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/styled-jsx": {
       "version": "5.1.6",
       "resolved": "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.6.tgz",
@@ -10359,6 +11581,13 @@
       "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
       "license": "MIT"
     },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tinyexec": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
@@ -10413,6 +11642,36 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
+      "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tinyspy": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.6.tgz",
+      "integrity": "sha512-u8KszXvGfU68hVcZpRHKG28T0krMuv2G5nDhiHaMLen/gIuFEgIJhaJuO69qjnXg5paSrbPMFfx3brNuN8eVSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
     "node_modules/tldts": {
       "version": "7.0.23",
       "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.0.23.tgz",
@@ -10888,6 +12147,243 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/vite": {
+      "version": "7.3.6",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.6.tgz",
+      "integrity": "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.27.0 || ^0.28.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-node": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
+      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.4.1",
+        "es-module-lexer": "^1.7.0",
+        "pathe": "^2.0.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/vite/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz",
+      "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/vitest": {
+      "version": "3.2.7",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.7.tgz",
+      "integrity": "sha512-KrxIJ62Fd89gfysR4WotlgZABiz2dqFPgqGzX7s+CwsqLFomRH7777ZcrOD6+WVAh7khPQP41A+BKbpcJFrdEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/expect": "3.2.7",
+        "@vitest/mocker": "3.2.7",
+        "@vitest/pretty-format": "^3.2.7",
+        "@vitest/runner": "3.2.7",
+        "@vitest/snapshot": "3.2.7",
+        "@vitest/spy": "3.2.7",
+        "@vitest/utils": "3.2.7",
+        "chai": "^5.2.0",
+        "debug": "^4.4.1",
+        "expect-type": "^1.2.1",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.2",
+        "std-env": "^3.9.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.2",
+        "tinyglobby": "^0.2.14",
+        "tinypool": "^1.1.1",
+        "tinyrainbow": "^2.0.0",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
+        "vite-node": "3.2.4",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/debug": "^4.1.12",
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "@vitest/browser": "3.2.7",
+        "@vitest/ui": "3.2.7",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/debug": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/picomatch": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz",
+      "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/vitest/node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/web-streams-polyfill": {
       "version": "3.3.3",
       "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
@@ -10997,6 +12493,23 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/word-wrap": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
diff --git a/web/package.json b/web/package.json
index 57cdeff..dc17b5c 100644
--- a/web/package.json
+++ b/web/package.json
@@ -1,14 +1,18 @@
 {
-  "name": "web",
-  "version": "0.1.0",
+  "name": "cf-workbench",
+  "version": "1.0.0",
   "private": true,
-  "//": "Build/lint tooling (typescript, eslint, eslint-config-next, tailwind, shadcn, @types/*) is kept in dependencies rather than devDependencies on purpose: the validation/CI install runs with NODE_ENV=production, which makes `npm install` omit devDependencies. Keeping these as runtime dependencies guarantees `npm run lint` and `npm run build` succeed regardless of NODE_ENV. Only @playwright/test (e2e harness) stays a devDependency.",
+  "//": "Build/lint tooling (typescript, eslint, eslint-config-next, tailwind, shadcn, @types/*) is kept in dependencies rather than devDependencies on purpose: the validation/CI install runs with NODE_ENV=production, which makes `npm install` omit devDependencies. Keeping these as runtime dependencies guarantees `npm run lint` and `npm run build` succeed regardless of NODE_ENV. Only the test harnesses (@playwright/test, vitest) stay devDependencies.",
   "scripts": {
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
     "lint": "eslint",
-    "e2e": "playwright test"
+    "typecheck": "tsc --noEmit -p .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "e2e": "playwright test",
+    "check": "npm run lint && npm run typecheck && npm test && npm run build"
   },
   "dependencies": {
     "@tailwindcss/postcss": "^4",
@@ -35,6 +39,7 @@
     "typescript": "5.9.3"
   },
   "devDependencies": {
-    "@playwright/test": "^1.49.0"
+    "@playwright/test": "^1.49.0",
+    "vitest": "^3.2.7"
   }
 }
diff --git a/web/vitest.config.ts b/web/vitest.config.ts
new file mode 100644
index 0000000..5360823
--- /dev/null
+++ b/web/vitest.config.ts
@@ -0,0 +1,21 @@
+import { defineConfig } from "vitest/config";
+import path from "node:path";
+
+/**
+ * Unit tests for the execution engine and the client-side helpers. They run
+ * in Node against the real C++ toolchain where a compiler is available; the
+ * Playwright suite under ./e2e is separate and is NOT picked up here.
+ */
+export default defineConfig({
+  test: {
+    include: ["app/**/*.test.ts", "lib/**/*.test.ts"],
+    exclude: ["e2e/**", "node_modules/**", ".next/**"],
+    environment: "node",
+    testTimeout: 60_000,
+    hookTimeout: 60_000,
+    reporters: process.env.CI ? ["dot"] : ["default"],
+  },
+  resolve: {
+    alias: { "@": path.resolve(__dirname) },
+  },
+});

From adbe071d0ec1e74c33e77a1b3fb7687a1072b034 Mon Sep 17 00:00:00 2001
From: mbn <66748817+mbn-code@users.noreply.github.com>
Date: Tue, 15 Sep 2026 20:57:41 +0200
Subject: [PATCH 2/7] feat(web): diagnostics, statement import, checkers,
 stress promotion, full-workspace library

- editor: gutter error/warning markers, clickable diagnostics that jump to
  the line, error/warning counts, cursor status bar, Ctrl+/ comment toggle
- run panel: cached-compile marker, diagnostics list, ignored-flag notice,
  copy and clear, persisted stdin
- tests panel: import samples from a pasted statement, run a single case,
  duplicate, use as stdin, expand/collapse all, stop on first failure,
  whitespace-only hints, SKIPPED verdicts, max time
- stress panel: seed base, timing stats, budget notice, add the failing input
  as a test case or as stdin
- settings: checker mode and epsilon, reset, clear compile cache, server info
- sidebar: whole-workspace save (code, tests, stdin, stress, settings),
  duplicate, filter, relative timestamps, dirty indicator, new workspace,
  export/import; constrain width so long names cannot overflow into the editor
- resizable editor/panel split, remembered tab, Ctrl+1..4 and Ctrl+B
  shortcuts, compiler shown in the header, offline-aware API client
- five new Playwright specs; remove the unused lib/cf.ts and scaffold SVGs
---
 web/app/page.tsx                    | 549 ++++++++++++++++++++++++++--
 web/components/CodeEditor.tsx       | 186 +++++++++-
 web/components/DiagnosticsList.tsx  | 105 ++++++
 web/components/ProblemsSidebar.tsx  | 222 ++++++++---
 web/components/Resizer.tsx          |  76 ++++
 web/components/RunPanel.tsx         | 164 +++++++--
 web/components/SettingsPanel.tsx    | 220 +++++++++--
 web/components/StressPanel.tsx      | 278 ++++++++++++--
 web/components/TestsPanel.tsx       | 384 ++++++++++++++++---
 web/components/VerdictBadge.tsx     |  17 +-
 web/e2e/06-diagnostics.spec.ts      |  49 +++
 web/e2e/07-import-statement.spec.ts |  89 +++++
 web/e2e/08-checker.spec.ts          |  69 ++++
 web/e2e/09-stress-promote.spec.ts   |  49 +++
 web/e2e/10-problems-library.spec.ts |  68 ++++
 web/lib/api.ts                      | 216 ++++++++---
 web/lib/cf.ts                       | 208 -----------
 web/lib/storage.ts                  |  92 ++++-
 web/public/file.svg                 |   1 -
 web/public/globe.svg                |   1 -
 web/public/next.svg                 |   1 -
 web/public/vercel.svg               |   1 -
 web/public/window.svg               |   1 -
 23 files changed, 2546 insertions(+), 500 deletions(-)
 create mode 100644 web/components/DiagnosticsList.tsx
 create mode 100644 web/components/Resizer.tsx
 create mode 100644 web/e2e/06-diagnostics.spec.ts
 create mode 100644 web/e2e/07-import-statement.spec.ts
 create mode 100644 web/e2e/08-checker.spec.ts
 create mode 100644 web/e2e/09-stress-promote.spec.ts
 create mode 100644 web/e2e/10-problems-library.spec.ts
 delete mode 100644 web/lib/cf.ts
 delete mode 100644 web/public/file.svg
 delete mode 100644 web/public/globe.svg
 delete mode 100644 web/public/next.svg
 delete mode 100644 web/public/vercel.svg
 delete mode 100644 web/public/window.svg

diff --git a/web/app/page.tsx b/web/app/page.tsx
index dd63a66..e1f5c89 100644
--- a/web/app/page.tsx
+++ b/web/app/page.tsx
@@ -19,6 +19,7 @@ import {
   FileCode,
   Minus,
   Plus,
+  Keyboard,
 } from "lucide-react";
 import { toast } from "sonner";
 import { cn } from "@/lib/utils";
@@ -30,11 +31,20 @@ import {
   getProblem,
   saveProblem,
   renameProblem,
+  duplicateProblem,
   deleteProblem,
+  exportProblems,
+  importProblems,
+  parseSamples,
+  getConfig,
   type RunResponse,
   type TestResponse,
+  type TestCaseResult,
   type RunSettings,
   type ProblemSummary,
+  type Diagnostic,
+  type WorkbenchConfig,
+  type ParsedStatement,
 } from "@/lib/api";
 import {
   STORAGE_KEYS,
@@ -43,11 +53,17 @@ import {
   MIN_FONT_SIZE,
   MAX_FONT_SIZE,
   DEFAULT_TESTS,
+  DEFAULT_STDIN,
+  DEFAULT_LAYOUT,
+  MIN_PANEL_FRACTION,
+  MAX_PANEL_FRACTION,
   loadJSON,
   loadString,
   saveJSON,
   saveString,
   normalizeSettings,
+  normalizeLayout,
+  clampTimeLimit,
   toTestCases,
   type SampleTest,
 } from "@/lib/storage";
@@ -58,20 +74,30 @@ import {
   GENERATOR_TEMPLATE,
 } from "@/lib/templates";
 
-import { CodeEditor } from "@/components/CodeEditor";
+import {
+  CodeEditor,
+  type LineMarkers,
+  type CursorPosition,
+} from "@/components/CodeEditor";
 import { RunPanel } from "@/components/RunPanel";
 import { TestsPanel } from "@/components/TestsPanel";
 import { StressPanel } from "@/components/StressPanel";
 import { SettingsPanel } from "@/components/SettingsPanel";
 import { ProblemsSidebar } from "@/components/ProblemsSidebar";
+import { Resizer } from "@/components/Resizer";
 
 type PanelTab = "run" | "tests" | "stress" | "settings";
 
-const PANEL_TABS: { id: PanelTab; label: string; icon: ElementType }[] = [
-  { id: "run", label: "Run", icon: TerminalIcon },
-  { id: "tests", label: "Tests", icon: FlaskConical },
-  { id: "stress", label: "Stress", icon: Swords },
-  { id: "settings", label: "Settings", icon: SettingsIcon },
+const PANEL_TABS: {
+  id: PanelTab;
+  label: string;
+  icon: ElementType;
+  key: string;
+}[] = [
+  { id: "run", label: "Run", icon: TerminalIcon, key: "1" },
+  { id: "tests", label: "Tests", icon: FlaskConical, key: "2" },
+  { id: "stress", label: "Stress", icon: Swords, key: "3" },
+  { id: "settings", label: "Settings", icon: SettingsIcon, key: "4" },
 ];
 
 type StressState = { brute: string; generator: string; iterations: number };
@@ -90,6 +116,37 @@ function withIds(cases: { input: string; expected: string }[], start: number) {
   }));
 }
 
+function isPanelTab(v: string): v is PanelTab {
+  return PANEL_TABS.some((t) => t.id === v);
+}
+
+/** Everything that is persisted with a problem, for dirty tracking. */
+function snapshot(
+  code: string,
+  tests: SampleTest[],
+  stdin: string,
+  stress: StressState,
+  settings: RunSettings,
+): string {
+  return JSON.stringify({
+    code,
+    tests: toTestCases(tests),
+    stdin,
+    brute: stress.brute,
+    generator: stress.generator,
+    settings,
+  });
+}
+
+function markersFrom(diags: Diagnostic[] | undefined): LineMarkers {
+  const m: LineMarkers = {};
+  for (const d of diags ?? []) {
+    if (d.line === null || d.severity === "note") continue;
+    if (d.severity === "error" || !m[d.line]) m[d.line] = d.severity;
+  }
+  return m;
+}
+
 export default function Workbench() {
   const [mounted, setMounted] = useState(false);
 
@@ -101,23 +158,35 @@ export default function Workbench() {
     withIds(DEFAULT_TESTS, 1),
   );
   const [stress, setStress] = useState<StressState>(DEFAULT_STRESS);
-  const [stdin, setStdin] = useState("2 3\n");
+  const [stdin, setStdin] = useState(DEFAULT_STDIN);
+  const [layout, setLayout] = useState(DEFAULT_LAYOUT);
 
   // Execution results.
   const [runResult, setRunResult] = useState<RunResponse | null>(null);
   const [testResult, setTestResult] = useState<TestResponse | null>(null);
   const [runLoading, setRunLoading] = useState(false);
   const [testLoading, setTestLoading] = useState(false);
+  const [stopOnFirstFailure, setStopOnFirstFailure] = useState(false);
+  const [diagnostics, setDiagnostics] = useState<Diagnostic[]>([]);
 
   // Problems library.
   const [problems, setProblems] = useState<ProblemSummary[]>([]);
   const [activeSlug, setActiveSlug] = useState<string | null>(null);
   const [saveName, setSaveName] = useState("");
   const [problemsBusy, setProblemsBusy] = useState(false);
+  const [savedSnapshot, setSavedSnapshot] = useState<string | null>(null);
+  const [config, setConfig] = useState<WorkbenchConfig | null>(null);
 
   // Layout.
   const [activeTab, setActiveTab] = useState<PanelTab>("run");
   const [sidebarOpen, setSidebarOpen] = useState(false);
+  const [sidebarHidden, setSidebarHidden] = useState(false);
+  const [cursor, setCursor] = useState<CursorPosition>({ line: 1, column: 1 });
+  const [gotoLine, setGotoLine] = useState<{
+    line: number;
+    nonce: number;
+  } | null>(null);
+  const mainRef = useRef<HTMLElement>(null);
 
   const idRef = useRef(1);
   const nextId = useCallback(() => {
@@ -140,6 +209,7 @@ export default function Workbench() {
   // ---- Hydration from localStorage (runs once on mount) ----
   useEffect(() => {
     setCode(loadString(STORAGE_KEYS.code, DEFAULT_CODE));
+    setStdin(loadString(STORAGE_KEYS.stdin, DEFAULT_STDIN));
     const storedFont = loadJSON<number>(
       STORAGE_KEYS.fontSize,
       DEFAULT_FONT_SIZE,
@@ -148,6 +218,9 @@ export default function Workbench() {
     setSettings(
       normalizeSettings(loadJSON(STORAGE_KEYS.settings, DEFAULT_SETTINGS)),
     );
+    setLayout(normalizeLayout(loadJSON(STORAGE_KEYS.layout, DEFAULT_LAYOUT)));
+    const tab = loadString(STORAGE_KEYS.activeTab, "run");
+    if (isPanelTab(tab)) setActiveTab(tab);
 
     const storedTests = loadJSON<SampleTest[]>(STORAGE_KEYS.tests, []);
     const hydrated =
@@ -168,6 +241,9 @@ export default function Workbench() {
 
     setMounted(true);
     refreshProblems();
+    getConfig()
+      .then(setConfig)
+      .catch(() => {});
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
@@ -175,6 +251,9 @@ export default function Workbench() {
   useEffect(() => {
     if (mounted) saveString(STORAGE_KEYS.code, code);
   }, [code, mounted]);
+  useEffect(() => {
+    if (mounted) saveString(STORAGE_KEYS.stdin, stdin);
+  }, [stdin, mounted]);
   useEffect(() => {
     if (mounted) saveJSON(STORAGE_KEYS.fontSize, fontSize);
   }, [fontSize, mounted]);
@@ -187,10 +266,23 @@ export default function Workbench() {
   useEffect(() => {
     if (mounted) saveJSON(STORAGE_KEYS.stress, stress);
   }, [stress, mounted]);
+  useEffect(() => {
+    if (mounted) saveJSON(STORAGE_KEYS.layout, layout);
+  }, [layout, mounted]);
+  useEffect(() => {
+    if (mounted) saveString(STORAGE_KEYS.activeTab, activeTab);
+  }, [activeTab, mounted]);
   useEffect(() => {
     if (mounted) saveString(STORAGE_KEYS.activeProblem, activeSlug ?? "");
   }, [activeSlug, mounted]);
 
+  const dirty = useMemo(
+    () =>
+      savedSnapshot !== null &&
+      savedSnapshot !== snapshot(code, tests, stdin, stress, settings),
+    [savedSnapshot, code, tests, stdin, stress, settings],
+  );
+
   // ---- Execution ----
   const handleRun = useCallback(async () => {
     if (!code.trim()) {
@@ -203,7 +295,10 @@ export default function Workbench() {
     try {
       const res = await runCode(code, stdin, settings);
       setRunResult(res);
+      setDiagnostics(res.compile.diagnostics ?? []);
       if (res.verdict === "CE") toast.error("Compilation error");
+      else if (res.verdict === "TLE") toast.warning("Time limit exceeded");
+      else if (res.verdict === "RE") toast.warning("Runtime error");
     } catch (e) {
       toast.error(e instanceof Error ? e.message : "Run failed");
     } finally {
@@ -224,16 +319,84 @@ export default function Workbench() {
     setActiveTab("tests");
     setTestResult(null);
     try {
-      const res = await runTests(code, toTestCases(tests), settings);
+      const res = await runTests(code, toTestCases(tests), settings, {
+        stopOnFirstFailure,
+      });
       setTestResult(res);
+      setDiagnostics(res.compile.diagnostics ?? []);
+      if (res.summary.verdict === "CE") toast.error("Compilation error");
+      else if (res.ok) toast.success(`All ${res.summary.total} cases passed`);
+      else
+        toast.error(
+          `${res.summary.failed} of ${res.summary.total} case${res.summary.total === 1 ? "" : "s"} failed`,
+        );
     } catch (e) {
       toast.error(e instanceof Error ? e.message : "Tests failed");
     } finally {
       setTestLoading(false);
     }
-  }, [code, tests, settings]);
+  }, [code, tests, settings, stopOnFirstFailure]);
+
+  const handleRunOne = useCallback(
+    async (id: number) => {
+      const idx = tests.findIndex((t) => t.id === id);
+      if (idx === -1) return;
+      if (!code.trim()) {
+        toast.error("The editor is empty");
+        return;
+      }
+      setTestLoading(true);
+      try {
+        const res = await runTests(code, toTestCases([tests[idx]]), settings);
+        setDiagnostics(res.compile.diagnostics ?? []);
+        const single: TestCaseResult = { ...res.results[0], index: idx };
+        setTestResult((prev) => {
+          const results = (prev?.results ?? []).filter((r) => r.index !== idx);
+          results.push(single);
+          results.sort((a, b) => a.index - b.index);
+          const passed = results.filter((r) => r.verdict === "AC").length;
+          const worst = results.reduce(
+            (acc, r) => (rank(r.verdict) > rank(acc) ? r.verdict : acc),
+            single.verdict,
+          );
+          return {
+            ...res,
+            summary: {
+              ...res.summary,
+              total: results.length,
+              passed,
+              failed: results.length - passed,
+              verdict: worst,
+              maxTimeMs: results.reduce((m, r) => Math.max(m, r.timeMs), 0),
+            },
+            results,
+          };
+        });
+        if (single.verdict === "AC") toast.success(`Case ${idx + 1}: AC`);
+        else toast.error(`Case ${idx + 1}: ${single.verdict}`);
+      } catch (e) {
+        toast.error(e instanceof Error ? e.message : "Test failed");
+      } finally {
+        setTestLoading(false);
+      }
+    },
+    [code, tests, settings],
+  );
 
   // ---- Problems library ----
+  const currentProblemPayload = useCallback(
+    (name: string) => ({
+      name,
+      code,
+      tests: toTestCases(tests),
+      stdin,
+      brute: stress.brute,
+      generator: stress.generator,
+      settings,
+    }),
+    [code, tests, stdin, stress, settings],
+  );
+
   const handleSave = useCallback(async () => {
     const name = saveName.trim();
     if (!name) {
@@ -241,42 +404,65 @@ export default function Workbench() {
       return;
     }
     try {
-      const saved = await saveProblem({
-        name,
-        code,
-        tests: toTestCases(tests),
-      });
+      const saved = await saveProblem(currentProblemPayload(name));
       setActiveSlug(saved.slug);
       setSaveName(saved.name);
+      setSavedSnapshot(snapshot(code, tests, stdin, stress, settings));
       await refreshProblems();
       toast.success(`Saved ${saved.name}`);
     } catch (e) {
       toast.error(e instanceof Error ? e.message : "Save failed");
     }
-  }, [saveName, code, tests, refreshProblems]);
+  }, [
+    saveName,
+    currentProblemPayload,
+    code,
+    tests,
+    stdin,
+    stress,
+    settings,
+    refreshProblems,
+  ]);
 
   const handleLoad = useCallback(
     async (slug: string) => {
       try {
         const problem = await getProblem(slug);
-        setCode(problem.code || DEFAULT_CODE);
+        const nextCode = problem.code || DEFAULT_CODE;
         const loaded = problem.tests.map((t) => ({
           id: nextId(),
           input: t.input,
           expected: t.expected,
         }));
+        const nextStress: StressState = {
+          brute: problem.brute || DEFAULT_STRESS.brute,
+          generator: problem.generator || DEFAULT_STRESS.generator,
+          iterations: stress.iterations,
+        };
+        const nextStdin = problem.stdin || problem.tests[0]?.input || "";
+        const nextSettings = problem.settings
+          ? normalizeSettings({ ...settings, ...problem.settings })
+          : settings;
+        setCode(nextCode);
         setTests(loaded);
+        setStdin(nextStdin);
+        setStress(nextStress);
+        setSettings(nextSettings);
         setActiveSlug(problem.slug);
         setSaveName(problem.name);
         setRunResult(null);
         setTestResult(null);
+        setDiagnostics([]);
         setSidebarOpen(false);
+        setSavedSnapshot(
+          snapshot(nextCode, loaded, nextStdin, nextStress, nextSettings),
+        );
         toast.success(`Loaded ${problem.name}`);
       } catch (e) {
         toast.error(e instanceof Error ? e.message : "Load failed");
       }
     },
-    [nextId],
+    [nextId, stress.iterations, settings],
   );
 
   const handleRename = useCallback(
@@ -296,11 +482,27 @@ export default function Workbench() {
     [activeSlug, refreshProblems],
   );
 
+  const handleDuplicate = useCallback(
+    async (slug: string, to: string) => {
+      try {
+        const copy = await duplicateProblem(slug, to);
+        await refreshProblems();
+        toast.success(`Duplicated as ${copy.name}`);
+      } catch (e) {
+        toast.error(e instanceof Error ? e.message : "Duplicate failed");
+      }
+    },
+    [refreshProblems],
+  );
+
   const handleDelete = useCallback(
     async (slug: string) => {
       try {
         await deleteProblem(slug);
-        if (activeSlug === slug) setActiveSlug(null);
+        if (activeSlug === slug) {
+          setActiveSlug(null);
+          setSavedSnapshot(null);
+        }
         await refreshProblems();
         toast.success("Deleted");
       } catch (e) {
@@ -310,12 +512,133 @@ export default function Workbench() {
     [activeSlug, refreshProblems],
   );
 
+  const handleNew = useCallback(() => {
+    if (
+      dirty &&
+      !window.confirm("Discard unsaved changes and start a new workspace?")
+    )
+      return;
+    setCode(DEFAULT_CODE);
+    setTests(withIds(DEFAULT_TESTS, idRef.current));
+    idRef.current += DEFAULT_TESTS.length;
+    setStdin(DEFAULT_STDIN);
+    setStress((s) => ({ ...DEFAULT_STRESS, iterations: s.iterations }));
+    setRunResult(null);
+    setTestResult(null);
+    setDiagnostics([]);
+    setActiveSlug(null);
+    setSaveName("");
+    setSavedSnapshot(null);
+    setSidebarOpen(false);
+    toast.success("New workspace");
+  }, [dirty]);
+
+  const handleExport = useCallback(async () => {
+    try {
+      const bundle = await exportProblems();
+      const blob = new Blob([JSON.stringify(bundle, null, 2)], {
+        type: "application/json",
+      });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `cf-problems-${new Date().toISOString().slice(0, 10)}.json`;
+      a.click();
+      URL.revokeObjectURL(url);
+      toast.success(`Exported ${bundle.problems.length} problem(s)`);
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : "Export failed");
+    }
+  }, []);
+
+  const handleImport = useCallback(
+    async (file: File) => {
+      try {
+        const parsed = JSON.parse(await file.text()) as unknown;
+        const records = Array.isArray(parsed)
+          ? parsed
+          : parsed && typeof parsed === "object"
+            ? (parsed as { problems?: unknown }).problems
+            : undefined;
+        if (!Array.isArray(records))
+          throw new Error("File is not a cf problems export");
+        const { imported, skipped } = await importProblems(records, false);
+        await refreshProblems();
+        toast.success(
+          `Imported ${imported} problem(s)${skipped ? `, skipped ${skipped} existing` : ""}`,
+        );
+      } catch (e) {
+        toast.error(e instanceof Error ? e.message : "Import failed");
+      }
+    },
+    [refreshProblems],
+  );
+
+  // ---- Sample import from a statement ----
+  const handleImportStatement = useCallback(
+    async (statement: string): Promise<ParsedStatement | null> => {
+      try {
+        const parsed = await parseSamples(statement);
+        if (parsed.tests.length === 0) {
+          toast.error("No Input / Output samples found in the statement");
+          return parsed;
+        }
+        const existingEmpty = tests.every(
+          (t) => !t.input.trim() && !t.expected.trim(),
+        );
+        const isDefault =
+          tests.length === DEFAULT_TESTS.length &&
+          tests.every(
+            (t, i) =>
+              t.input === DEFAULT_TESTS[i].input &&
+              t.expected === DEFAULT_TESTS[i].expected,
+          );
+        const fresh = parsed.tests.map((t) => ({ id: nextId(), ...t }));
+        setTests(existingEmpty || isDefault ? fresh : [...tests, ...fresh]);
+        setTestResult(null);
+        if (parsed.timeLimitMs) {
+          setSettings((s) => ({
+            ...s,
+            timeLimitMs: clampTimeLimit(parsed.timeLimitMs as number),
+          }));
+        }
+        if (parsed.title && !saveName.trim()) setSaveName(parsed.title);
+        if (!stdin.trim() || stdin === DEFAULT_STDIN)
+          setStdin(parsed.tests[0].input);
+        toast.success(
+          `Imported ${parsed.tests.length} sample(s)${parsed.timeLimitMs ? `, time limit ${parsed.timeLimitMs} ms` : ""}`,
+        );
+        return parsed;
+      } catch (e) {
+        toast.error(
+          e instanceof Error ? e.message : "Could not parse statement",
+        );
+        return null;
+      }
+    },
+    [tests, nextId, saveName, stdin],
+  );
+
+  const addTestCase = useCallback(
+    (input: string, expected: string) => {
+      setTests((t) => [...t, { id: nextId(), input, expected }]);
+      setActiveTab("tests");
+    },
+    [nextId],
+  );
+
+  const useAsStdin = useCallback((input: string) => {
+    setStdin(input);
+    setActiveTab("run");
+  }, []);
+
   // Editing the source or a case makes any prior verdict stale — drop it so the
   // UI never shows a result that no longer matches the editor. Functional
   // updates keep the same reference (no extra render) when already cleared.
   const invalidateResults = useCallback(() => {
     setRunResult((r) => (r ? null : r));
     setTestResult((r) => (r ? null : r));
+    setDiagnostics((d) => (d.length ? [] : d));
   }, []);
 
   const handleCodeChange = useCallback(
@@ -331,7 +654,11 @@ export default function Workbench() {
     setTestResult((r) => (r ? null : r));
   }, []);
 
-  // ---- Keyboard shortcuts (Cmd/Ctrl+Enter run, +Shift run all, Cmd/Ctrl+S save) ----
+  const jumpToLine = useCallback((line: number) => {
+    setGotoLine({ line, nonce: Date.now() });
+  }, []);
+
+  // ---- Keyboard shortcuts ----
   const runRef = useRef(handleRun);
   const runAllRef = useRef(handleRunAll);
   const saveRef = useRef(handleSave);
@@ -350,9 +677,19 @@ export default function Workbench() {
         e.preventDefault();
         if (e.shiftKey) runAllRef.current();
         else runRef.current();
-      } else if (e.key.toLowerCase() === "s") {
+      } else if (e.key.toLowerCase() === "s" && !e.shiftKey) {
         e.preventDefault();
         if (nameRef.current.trim()) saveRef.current();
+        else toast.error("Enter a problem name in the sidebar to save");
+      } else if (e.key.toLowerCase() === "b" && !e.shiftKey) {
+        e.preventDefault();
+        setSidebarHidden((h) => !h);
+      } else if (!e.shiftKey && !e.altKey) {
+        const tab = PANEL_TABS.find((t) => t.key === e.key);
+        if (tab) {
+          e.preventDefault();
+          setActiveTab(tab.id);
+        }
       }
     };
     window.addEventListener("keydown", onKey);
@@ -377,6 +714,28 @@ export default function Workbench() {
     [problems, activeSlug],
   );
 
+  const markers = useMemo(() => markersFrom(diagnostics), [diagnostics]);
+  const errorCount = diagnostics.filter((d) => d.severity === "error").length;
+  const warningCount = diagnostics.filter(
+    (d) => d.severity === "warning",
+  ).length;
+  const lineCount = useMemo(() => code.split("\n").length, [code]);
+
+  const onResize = useCallback((f: number) => {
+    setLayout({
+      panelFraction: Math.min(
+        MAX_PANEL_FRACTION,
+        Math.max(MIN_PANEL_FRACTION, f),
+      ),
+    });
+  }, []);
+
+  const compilerLabel = config?.compilerVersion
+    ? config.compilerVersion.replace(/\s*\(.*?\)\s*/g, " ").trim()
+    : config
+      ? "no compiler"
+      : null;
+
   return (
     <div className="flex h-screen w-full flex-col overflow-hidden bg-zinc-950 text-zinc-200">
       {/* Top bar */}
@@ -391,6 +750,18 @@ export default function Workbench() {
           >
             <PanelLeft className="h-4 w-4" />
           </button>
+          <button
+            type="button"
+            onClick={() => setSidebarHidden((h) => !h)}
+            aria-label={
+              sidebarHidden ? "Show problems sidebar" : "Hide problems sidebar"
+            }
+            data-testid="collapse-sidebar"
+            title="Ctrl/⌘+B"
+            className="hidden rounded p-1.5 text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100 md:block"
+          >
+            <PanelLeft className="h-4 w-4" />
+          </button>
           <span className="text-sm font-bold tracking-tight text-zinc-100">
             cf
             <span className="ml-1.5 font-mono text-[10px] font-medium uppercase tracking-widest text-zinc-500">
@@ -399,16 +770,38 @@ export default function Workbench() {
           </span>
           {activeName ? (
             <span
-              className="ml-2 truncate font-mono text-xs text-zinc-400"
+              className="ml-2 flex items-center gap-1.5 truncate font-mono text-xs text-zinc-400"
               data-testid="active-problem"
             >
               {activeName}
+              {dirty ? (
+                <span
+                  className="h-1.5 w-1.5 rounded-full bg-amber-500"
+                  title="Unsaved changes"
+                />
+              ) : null}
             </span>
           ) : null}
         </div>
 
         <div className="flex items-center gap-2">
-          <span className="hidden font-mono text-[10px] uppercase tracking-widest text-zinc-600 sm:inline">
+          {compilerLabel ? (
+            <span
+              className={cn(
+                "hidden max-w-[22rem] truncate font-mono text-[10px] lg:inline",
+                config?.compilerVersion ? "text-zinc-600" : "text-red-400",
+              )}
+              title={config?.compilerVersion ?? "No C++ compiler detected"}
+              data-testid="compiler-label"
+            >
+              {compilerLabel}
+            </span>
+          ) : null}
+          <span
+            className="hidden items-center gap-1 font-mono text-[10px] uppercase tracking-widest text-zinc-600 sm:inline-flex"
+            title="Ctrl/⌘+Enter run · Ctrl/⌘+Shift+Enter run all · Ctrl/⌘+S save · Ctrl/⌘+1-4 tabs · Ctrl/⌘+B sidebar · Ctrl/⌘+/ comment"
+          >
+            <Keyboard className="h-3 w-3" />
             ⌘/Ctrl + Enter
           </span>
           <button
@@ -434,27 +827,32 @@ export default function Workbench() {
         <aside
           className={cn(
             "w-60 shrink-0 border-r border-zinc-800 bg-zinc-900",
-            sidebarOpen ? "flex" : "hidden md:flex",
+            sidebarOpen ? "flex" : sidebarHidden ? "hidden" : "hidden md:flex",
           )}
         >
           <ProblemsSidebar
             problems={problems}
             activeSlug={activeSlug}
+            dirty={dirty}
             saveName={saveName}
             onSaveNameChange={setSaveName}
             onSave={handleSave}
             onLoad={handleLoad}
             onRename={handleRename}
+            onDuplicate={handleDuplicate}
             onDelete={handleDelete}
             onRefresh={refreshProblems}
+            onNew={handleNew}
+            onExport={handleExport}
+            onImport={handleImport}
             busy={problemsBusy}
           />
         </aside>
 
         {/* Editor + panels */}
-        <main className="flex min-w-0 flex-1 flex-col">
+        <main ref={mainRef} className="flex min-w-0 flex-1 flex-col">
           {/* Editor */}
-          <section className="flex min-h-0 flex-1 flex-col border-b border-zinc-800">
+          <section className="flex min-h-0 flex-1 flex-col">
             <div className="flex h-10 shrink-0 items-center gap-2 border-b border-zinc-800 bg-zinc-900/60 px-3">
               <FileCode className="h-4 w-4 text-zinc-500" />
               <span className="font-mono text-xs text-zinc-300">
@@ -463,6 +861,21 @@ export default function Workbench() {
               <span className="ml-1 rounded bg-zinc-800 px-1.5 py-0.5 font-mono text-[10px] text-zinc-400">
                 {settings.std}
               </span>
+              {errorCount > 0 ? (
+                <span
+                  className="rounded bg-red-500/15 px-1.5 py-0.5 font-mono text-[10px] text-red-400"
+                  data-testid="error-count"
+                >
+                  {errorCount} error{errorCount === 1 ? "" : "s"}
+                </span>
+              ) : warningCount > 0 ? (
+                <span
+                  className="rounded bg-amber-500/15 px-1.5 py-0.5 font-mono text-[10px] text-amber-400"
+                  data-testid="warning-count"
+                >
+                  {warningCount} warning{warningCount === 1 ? "" : "s"}
+                </span>
+              ) : null}
 
               <div className="ml-auto flex items-center gap-2">
                 <select
@@ -513,6 +926,9 @@ export default function Workbench() {
                   value={code}
                   onChange={handleCodeChange}
                   fontSize={fontSize}
+                  markers={markers}
+                  onCursorChange={setCursor}
+                  gotoLine={gotoLine}
                 />
               ) : (
                 <div className="p-4 font-mono text-sm italic text-zinc-600">
@@ -520,10 +936,36 @@ export default function Workbench() {
                 </div>
               )}
             </div>
+            <div
+              className="flex h-6 shrink-0 items-center gap-3 border-t border-zinc-800 bg-zinc-900/60 px-3 font-mono text-[10px] text-zinc-500"
+              data-testid="editor-status"
+            >
+              <span>
+                Ln {cursor.line}, Col {cursor.column}
+              </span>
+              <span>{lineCount} lines</span>
+              <span>{code.length} chars</span>
+              <span className="ml-auto">
+                {settings.timeLimitMs} ms · {settings.checker}
+                {settings.compilerFlags.length
+                  ? ` · ${settings.compilerFlags.join(" ")}`
+                  : ""}
+              </span>
+            </div>
           </section>
 
+          <Resizer
+            containerRef={mainRef}
+            onResize={onResize}
+            onReset={() => setLayout(DEFAULT_LAYOUT)}
+          />
+
           {/* Bottom panel */}
-          <section className="flex h-[44%] min-h-0 shrink-0 flex-col bg-zinc-900">
+          <section
+            className="flex min-h-0 shrink-0 flex-col bg-zinc-900"
+            style={{ height: `${layout.panelFraction * 100}%` }}
+            data-testid="bottom-panel"
+          >
             <div
               className="flex h-9 shrink-0 items-center border-b border-zinc-800 bg-zinc-900 px-1"
               role="tablist"
@@ -532,6 +974,9 @@ export default function Workbench() {
               {PANEL_TABS.map((tab) => {
                 const Icon = tab.icon;
                 const isActive = activeTab === tab.id;
+                const busy =
+                  (tab.id === "run" && runLoading) ||
+                  (tab.id === "tests" && testLoading);
                 return (
                   <button
                     key={tab.id}
@@ -540,15 +985,32 @@ export default function Workbench() {
                     aria-selected={isActive}
                     onClick={() => setActiveTab(tab.id)}
                     data-testid={`tab-${tab.id}`}
+                    title={`Ctrl/⌘+${tab.key}`}
                     className={cn(
-                      "flex items-center gap-1.5 px-3 py-1.5 text-[11px] font-semibold uppercase tracking-widest transition",
+                      "flex items-center gap-1.5 border-b-2 px-3 py-1.5 text-[11px] font-semibold uppercase tracking-widest transition",
                       isActive
-                        ? "text-zinc-100"
-                        : "text-zinc-500 hover:text-zinc-300",
+                        ? "border-emerald-500 text-zinc-100"
+                        : "border-transparent text-zinc-500 hover:text-zinc-300",
                     )}
                   >
-                    <Icon className="h-3.5 w-3.5" />
+                    {busy ? (
+                      <Loader2 className="h-3.5 w-3.5 animate-spin" />
+                    ) : (
+                      <Icon className="h-3.5 w-3.5" />
+                    )}
                     {tab.label}
+                    {tab.id === "tests" && testResult ? (
+                      <span
+                        className={cn(
+                          "rounded px-1 font-mono text-[9px]",
+                          testResult.ok
+                            ? "bg-emerald-500/15 text-emerald-400"
+                            : "bg-red-500/15 text-red-400",
+                        )}
+                      >
+                        {testResult.summary.passed}/{testResult.summary.total}
+                      </span>
+                    ) : null}
                   </button>
                 );
               })}
@@ -566,6 +1028,11 @@ export default function Workbench() {
                   loading={runLoading}
                   stdin={stdin}
                   onStdinChange={setStdin}
+                  onGotoLine={jumpToLine}
+                  onClear={() => {
+                    setRunResult(null);
+                    setDiagnostics([]);
+                  }}
                 />
               </div>
               <div
@@ -581,6 +1048,12 @@ export default function Workbench() {
                   result={testResult}
                   loading={testLoading}
                   onRunAll={handleRunAll}
+                  onRunOne={handleRunOne}
+                  onUseAsStdin={useAsStdin}
+                  onImportStatement={handleImportStatement}
+                  onGotoLine={jumpToLine}
+                  stopOnFirstFailure={stopOnFirstFailure}
+                  onStopOnFirstFailureChange={setStopOnFirstFailure}
                 />
               </div>
               <div
@@ -606,6 +1079,8 @@ export default function Workbench() {
                     onIterationsChange={(iterations) =>
                       setStress((s) => ({ ...s, iterations }))
                     }
+                    onAddTestCase={addTestCase}
+                    onUseAsStdin={useAsStdin}
                   />
                 ) : null}
               </div>
@@ -620,6 +1095,7 @@ export default function Workbench() {
                   onSettingsChange={setSettings}
                   fontSize={fontSize}
                   onFontSizeChange={setFontSize}
+                  config={config}
                 />
               </div>
             </div>
@@ -629,3 +1105,16 @@ export default function Workbench() {
     </div>
   );
 }
+
+const VERDICT_RANK: Record<string, number> = {
+  AC: 0,
+  SKIPPED: 0,
+  WA: 1,
+  TLE: 2,
+  RE: 3,
+  CE: 4,
+};
+
+function rank(v: string): number {
+  return VERDICT_RANK[v] ?? 0;
+}
diff --git a/web/components/CodeEditor.tsx b/web/components/CodeEditor.tsx
index b8448f3..446b6e9 100644
--- a/web/components/CodeEditor.tsx
+++ b/web/components/CodeEditor.tsx
@@ -1,6 +1,12 @@
 "use client";
 
-import { useEffect, useMemo, useRef } from "react";
+import {
+  useEffect,
+  useMemo,
+  useRef,
+  useCallback,
+  type KeyboardEvent,
+} from "react";
 import Editor from "react-simple-code-editor";
 import Prism from "prismjs";
 import "prismjs/components/prism-clike";
@@ -9,11 +15,19 @@ import "prismjs/components/prism-cpp";
 import "prismjs/themes/prism-tomorrow.css";
 import { cn } from "@/lib/utils";
 
+export type LineMarker = "error" | "warning";
+
+/** Map of 1-based line number → marker severity, drawn in the gutter. */
+export type LineMarkers = Record<number, LineMarker>;
+
+export type CursorPosition = { line: number; column: number };
+
 /**
- * C++ source editor: Prism syntax highlighting, a synced line-number gutter,
- * tab-key handling (4-space soft tabs), and an adjustable font size. The actual
- * <textarea> carries a stable id/data-testid/aria-label so e2e tests can type
- * into it directly (e.g. `#code-editor`).
+ * C++ source editor: Prism syntax highlighting, a synced line-number gutter
+ * with error/warning markers, tab-key handling (4-space soft tabs), Ctrl+/
+ * line-comment toggling, cursor tracking, and an adjustable font size. The
+ * actual <textarea> carries a stable id/data-testid/aria-label so e2e tests
+ * can type into it directly (e.g. `#code-editor`).
  */
 export function CodeEditor({
   value,
@@ -22,6 +36,9 @@ export function CodeEditor({
   minLines = 24,
   testId = "code-editor",
   ariaLabel = "C++ source code editor",
+  markers,
+  onCursorChange,
+  gotoLine,
   className,
 }: {
   value: string;
@@ -30,6 +47,10 @@ export function CodeEditor({
   minLines?: number;
   testId?: string;
   ariaLabel?: string;
+  markers?: LineMarkers;
+  onCursorChange?: (pos: CursorPosition) => void;
+  /** Bump this (e.g. `{ line, nonce }`) to move the caret to a line. */
+  gotoLine?: { line: number; nonce: number } | null;
   className?: string;
 }) {
   const wrapperRef = useRef<HTMLDivElement>(null);
@@ -41,22 +62,107 @@ export function CodeEditor({
     return Math.max(minLines, n);
   }, [value, minLines]);
 
+  const textarea = useCallback(
+    () => wrapperRef.current?.querySelector("textarea") ?? null,
+    [],
+  );
+
   // The library spreads unknown props onto its container <div>, not the inner
   // <textarea>. Stamp the test hooks onto the textarea itself after mount.
   useEffect(() => {
-    const textarea = wrapperRef.current?.querySelector("textarea");
-    if (textarea) {
-      textarea.setAttribute("data-testid", testId);
-      textarea.setAttribute("aria-label", ariaLabel);
-      textarea.setAttribute("spellcheck", "false");
-      textarea.setAttribute("autocapitalize", "off");
-      textarea.setAttribute("autocorrect", "off");
+    const ta = textarea();
+    if (ta) {
+      ta.setAttribute("data-testid", testId);
+      ta.setAttribute("aria-label", ariaLabel);
+      ta.setAttribute("spellcheck", "false");
+      ta.setAttribute("autocapitalize", "off");
+      ta.setAttribute("autocorrect", "off");
+    }
+  }, [testId, ariaLabel, textarea]);
+
+  const reportCursor = useCallback(() => {
+    if (!onCursorChange) return;
+    const ta = textarea();
+    if (!ta) return;
+    const upto = ta.value.slice(0, ta.selectionStart);
+    const line = upto.split("\n").length;
+    const column = upto.length - upto.lastIndexOf("\n");
+    onCursorChange({ line, column });
+  }, [onCursorChange, textarea]);
+
+  useEffect(() => {
+    const ta = textarea();
+    if (!ta || !onCursorChange) return;
+    const handler = () => reportCursor();
+    ta.addEventListener("keyup", handler);
+    ta.addEventListener("click", handler);
+    ta.addEventListener("select", handler);
+    return () => {
+      ta.removeEventListener("keyup", handler);
+      ta.removeEventListener("click", handler);
+      ta.removeEventListener("select", handler);
+    };
+  }, [onCursorChange, reportCursor, textarea]);
+
+  // Jump to a requested line (from a diagnostic click) and scroll it into view.
+  useEffect(() => {
+    if (!gotoLine) return;
+    const ta = textarea();
+    if (!ta) return;
+    const lines = ta.value.split("\n");
+    const target = Math.min(Math.max(1, gotoLine.line), lines.length);
+    let offset = 0;
+    for (let i = 0; i < target - 1; i++) offset += lines[i].length + 1;
+    ta.focus();
+    ta.setSelectionRange(offset, offset + lines[target - 1].length);
+    const container = wrapperRef.current;
+    if (container) {
+      const y = padding + (target - 1) * lineHeight;
+      container.scrollTo({
+        top: Math.max(0, y - container.clientHeight / 2),
+        behavior: "smooth",
+      });
     }
-  }, [testId, ariaLabel]);
+    reportCursor();
+  }, [gotoLine, lineHeight, reportCursor, textarea]);
+
+  // Ctrl+/ toggles `// ` on every selected line.
+  const onKeyDown = (e: KeyboardEvent<HTMLDivElement>) => {
+    if (!(e.ctrlKey || e.metaKey) || e.key !== "/") return;
+    const ta = textarea();
+    if (!ta) return;
+    e.preventDefault();
+    const { selectionStart, selectionEnd } = ta;
+    const text = ta.value;
+    const startLine = text.lastIndexOf("\n", selectionStart - 1) + 1;
+    let endLine = text.indexOf("\n", selectionEnd);
+    if (endLine === -1) endLine = text.length;
+    const block = text.slice(startLine, endLine);
+    const lines = block.split("\n");
+    const allCommented = lines.every(
+      (l) => l.trim() === "" || /^\s*\/\/ ?/.test(l),
+    );
+    const toggled = lines
+      .map((l) =>
+        allCommented
+          ? l.replace(/^(\s*)\/\/ ?/, "$1")
+          : l.trim() === ""
+            ? l
+            : l.replace(/^(\s*)/, "$1// "),
+      )
+      .join("\n");
+    const next = text.slice(0, startLine) + toggled + text.slice(endLine);
+    onChange(next);
+    const delta = toggled.length - block.length;
+    requestAnimationFrame(() => {
+      ta.setSelectionRange(startLine, endLine + delta);
+    });
+  };
 
   return (
     <div
       ref={wrapperRef}
+      onKeyDown={onKeyDown}
       className={cn(
         "relative h-full w-full overflow-auto bg-[#1e1e1e]",
         className,
@@ -65,6 +171,7 @@ export function CodeEditor({
       <div className="flex min-h-full w-max min-w-full">
         <div
           aria-hidden="true"
+          data-testid={`${testId}-gutter`}
           className="shrink-0 select-none border-r border-zinc-800/60 bg-[#1a1a1a] text-right font-mono text-zinc-600"
           style={{
             paddingTop: padding,
@@ -75,14 +182,55 @@ export function CodeEditor({
             lineHeight: `${lineHeight}px`,
           }}
         >
-          {Array.from({ length: lineCount }, (_, i) => (
-            <div key={i} style={{ height: lineHeight }}>
-              {i + 1}
-            </div>
-          ))}
+          {Array.from({ length: lineCount }, (_, i) => {
+            const marker = markers?.[i + 1];
+            return (
+              <div
+                key={i}
+                data-marker={marker}
+                style={{ height: lineHeight }}
+                className={cn(
+                  "relative pl-3",
+                  marker === "error" && "text-red-400",
+                  marker === "warning" && "text-amber-400",
+                )}
+              >
+                {marker ? (
+                  <span
+                    className={cn(
+                      "absolute left-0 top-1/2 h-1.5 w-1.5 -translate-y-1/2 rounded-full",
+                      marker === "error" ? "bg-red-500" : "bg-amber-400",
+                    )}
+                  />
+                ) : null}
+                {i + 1}
+              </div>
+            );
+          })}
         </div>
 
-        <div className="flex-1">
+        <div className="relative flex-1">
+          {markers ? (
+            <div
+              aria-hidden="true"
+              className="pointer-events-none absolute inset-0"
+              style={{ paddingTop: padding }}
+            >
+              {Object.entries(markers).map(([ln, sev]) => (
+                <div
+                  key={ln}
+                  className={cn(
+                    "absolute left-0 right-0",
+                    sev === "error" ? "bg-red-500/10" : "bg-amber-400/10",
+                  )}
+                  style={{
+                    top: padding + (Number(ln) - 1) * lineHeight,
+                    height: lineHeight,
+                  }}
+                />
+              ))}
+            </div>
+          ) : null}
           <Editor
             value={value}
             onValueChange={onChange}
diff --git a/web/components/DiagnosticsList.tsx b/web/components/DiagnosticsList.tsx
new file mode 100644
index 0000000..2c660a6
--- /dev/null
+++ b/web/components/DiagnosticsList.tsx
@@ -0,0 +1,105 @@
+"use client";
+
+import { AlertCircle, AlertTriangle, Info } from "lucide-react";
+import { cn } from "@/lib/utils";
+import type { Diagnostic, RejectedFlag } from "@/lib/api";
+
+/**
+ * Compact list of compiler diagnostics. Entries with a line number are
+ * buttons that jump the editor to that line; notes render muted.
+ */
+export function DiagnosticsList({
+  diagnostics,
+  onGotoLine,
+  testId = "diagnostics-list",
+  className,
+}: {
+  diagnostics: Diagnostic[];
+  onGotoLine?: (line: number) => void;
+  testId?: string;
+  className?: string;
+}) {
+  if (diagnostics.length === 0) return null;
+  return (
+    <ul
+      data-testid={testId}
+      className={cn("space-y-0.5 font-mono text-[11px]", className)}
+    >
+      {diagnostics.map((d, i) => {
+        const Icon =
+          d.severity === "error"
+            ? AlertCircle
+            : d.severity === "warning"
+              ? AlertTriangle
+              : Info;
+        const tone =
+          d.severity === "error"
+            ? "text-red-300"
+            : d.severity === "warning"
+              ? "text-amber-300"
+              : "text-zinc-500";
+        const clickable = d.line !== null && !!onGotoLine;
+        const body = (
+          <>
+            <Icon className={cn("mt-0.5 h-3 w-3 shrink-0", tone)} />
+            <span className="min-w-0 flex-1 whitespace-pre-wrap break-words">
+              {d.line !== null ? (
+                <span className="mr-1.5 text-zinc-500">
+                  {d.line}
+                  {d.column !== null ? `:${d.column}` : ""}
+                </span>
+              ) : null}
+              <span className={tone}>{d.message}</span>
+            </span>
+          </>
+        );
+        return (
+          <li key={i} data-severity={d.severity}>
+            {clickable ? (
+              <button
+                type="button"
+                onClick={() => onGotoLine?.(d.line as number)}
+                className="flex w-full items-start gap-1.5 rounded px-1.5 py-0.5 text-left hover:bg-zinc-800/60"
+              >
+                {body}
+              </button>
+            ) : (
+              <div className="flex items-start gap-1.5 px-1.5 py-0.5">
+                {body}
+              </div>
+            )}
+          </li>
+        );
+      })}
+    </ul>
+  );
+}
+
+/** Notice listing compiler flags the server dropped, with reasons. */
+export function RejectedFlagsNotice({
+  flags,
+  className,
+}: {
+  flags: RejectedFlag[] | undefined;
+  className?: string;
+}) {
+  if (!flags || flags.length === 0) return null;
+  return (
+    <div
+      data-testid="rejected-flags"
+      className={cn(
+        "rounded-md border border-amber-500/30 bg-amber-500/10 px-3 py-2 text-[11px] text-amber-200",
+        className,
+      )}
+    >
+      <span className="font-semibold">Ignored compiler flags: </span>
+      {flags.map((f, i) => (
+        <span key={f.flag} className="font-mono">
+          {i > 0 ? ", " : ""}
+          {f.flag}
+          <span className="text-amber-200/60"> ({f.reason})</span>
+        </span>
+      ))}
+    </div>
+  );
+}
diff --git a/web/components/ProblemsSidebar.tsx b/web/components/ProblemsSidebar.tsx
index 2675deb..e2d9097 100644
--- a/web/components/ProblemsSidebar.tsx
+++ b/web/components/ProblemsSidebar.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useState, type ReactNode } from "react";
+import { useMemo, useRef, useState, type ReactNode } from "react";
 import {
   Save,
   RefreshCw,
@@ -9,68 +9,156 @@ import {
   Check,
   X,
   FileCode2,
+  Copy,
+  Search,
+  Download,
+  Upload,
+  FilePlus2,
 } from "lucide-react";
 import { cn } from "@/lib/utils";
 import type { ProblemSummary } from "@/lib/api";
+import { relativeTime } from "@/lib/storage";
 
 /**
- * Problems sidebar: save the current workspace, list saved problems and load,
- * rename or delete them (each persisted with its test cases via /api/problems).
+ * Problems sidebar: save the current workspace, filter and list saved
+ * problems, load / rename / duplicate / delete them, export the whole library
+ * as JSON and import a bundle back. Each problem persists its source, tests,
+ * stdin, stress sources and settings via /api/problems.
  */
 export function ProblemsSidebar({
   problems,
   activeSlug,
+  dirty,
   saveName,
   onSaveNameChange,
   onSave,
   onLoad,
   onRename,
+  onDuplicate,
   onDelete,
   onRefresh,
+  onNew,
+  onExport,
+  onImport,
   busy,
 }: {
   problems: ProblemSummary[];
   activeSlug: string | null;
+  /** True when the workspace differs from the last saved/loaded state. */
+  dirty: boolean;
   saveName: string;
   onSaveNameChange: (value: string) => void;
   onSave: () => void;
   onLoad: (slug: string) => void;
   onRename: (slug: string, to: string) => void;
+  onDuplicate: (slug: string, to: string) => void;
   onDelete: (slug: string) => void;
   onRefresh: () => void;
+  onNew: () => void;
+  onExport: () => void;
+  onImport: (file: File) => void;
   busy: boolean;
 }) {
   const [renaming, setRenaming] = useState<string | null>(null);
-  const [renameValue, setRenameValue] = useState("");
+  const [duplicating, setDuplicating] = useState<string | null>(null);
+  const [nameValue, setNameValue] = useState("");
   const [confirmDelete, setConfirmDelete] = useState<string | null>(null);
+  const [filter, setFilter] = useState("");
+  const fileRef = useRef<HTMLInputElement>(null);
+
+  const visible = useMemo(() => {
+    const q = filter.trim().toLowerCase();
+    if (!q) return problems;
+    return problems.filter(
+      (p) => p.name.toLowerCase().includes(q) || p.slug.includes(q),
+    );
+  }, [problems, filter]);
 
   const startRename = (p: ProblemSummary) => {
     setRenaming(p.slug);
-    setRenameValue(p.name);
+    setDuplicating(null);
+    setNameValue(p.name);
+    setConfirmDelete(null);
+  };
+
+  const startDuplicate = (p: ProblemSummary) => {
+    setDuplicating(p.slug);
+    setRenaming(null);
+    setNameValue(`${p.name} copy`);
     setConfirmDelete(null);
   };
 
-  const submitRename = (slug: string) => {
-    const to = renameValue.trim();
-    if (to) onRename(slug, to);
+  const submitName = (slug: string) => {
+    const to = nameValue.trim();
+    if (to) {
+      if (renaming === slug) onRename(slug, to);
+      else if (duplicating === slug) onDuplicate(slug, to);
+    }
     setRenaming(null);
+    setDuplicating(null);
   };
 
   return (
-    <div className="flex h-full flex-col" data-testid="problems-sidebar">
+    <div
+      className="flex h-full w-full min-w-0 flex-col overflow-hidden"
+      data-testid="problems-sidebar"
+    >
       <div className="flex shrink-0 items-center justify-between border-b border-zinc-800 px-3 py-2">
         <span className="text-[11px] font-bold uppercase tracking-widest text-zinc-400">
           Problems
+          {problems.length > 0 ? (
+            <span className="ml-1.5 font-mono text-[10px] text-zinc-600">
+              {problems.length}
+            </span>
+          ) : null}
         </span>
-        <button
-          type="button"
-          onClick={onRefresh}
-          aria-label="Refresh problems list"
-          data-testid="refresh-problems-button"
-          className="rounded p-1 text-zinc-500 transition hover:bg-zinc-800 hover:text-zinc-200"
-        >
-          <RefreshCw className={cn("h-3.5 w-3.5", busy && "animate-spin")} />
-        </button>
+        <div className="flex items-center gap-0.5">
+          <IconButton
+            label="New workspace"
+            testId="new-workspace-button"
+            onClick={onNew}
+          >
+            <FilePlus2 className="h-3.5 w-3.5 text-zinc-500" />
+          </IconButton>
+          <IconButton
+            label="Export all problems as JSON"
+            testId="export-problems-button"
+            onClick={onExport}
+          >
+            <Download className="h-3.5 w-3.5 text-zinc-500" />
+          </IconButton>
+          <IconButton
+            label="Import problems from JSON"
+            testId="import-problems-button"
+            onClick={() => fileRef.current?.click()}
+          >
+            <Upload className="h-3.5 w-3.5 text-zinc-500" />
+          </IconButton>
+          <input
+            ref={fileRef}
+            type="file"
+            accept="application/json,.json"
+            className="hidden"
+            data-testid="import-problems-input"
+            onChange={(e) => {
+              const f = e.target.files?.[0];
+              if (f) onImport(f);
+              e.target.value = "";
+            }}
+          />
+          <IconButton
+            label="Refresh problems list"
+            testId="refresh-problems-button"
+            onClick={onRefresh}
+          >
+            <RefreshCw
+              className={cn(
+                "h-3.5 w-3.5 text-zinc-500",
+                busy && "animate-spin",
+              )}
+            />
+          </IconButton>
+        </div>
       </div>
 
       <form
@@ -98,21 +186,45 @@ export function ProblemsSidebar({
         >
           <Save className="h-3.5 w-3.5" />
           Save workspace
+          {dirty && activeSlug ? (
+            <span
+              className="ml-0.5 h-1.5 w-1.5 rounded-full bg-amber-500"
+              title="Unsaved changes"
+              data-testid="dirty-indicator"
+            />
+          ) : null}
         </button>
       </form>
 
+      {problems.length > 3 ? (
+        <div className="flex shrink-0 items-center gap-1.5 border-b border-zinc-800 px-3 py-1.5">
+          <Search className="h-3 w-3 text-zinc-600" />
+          <input
+            type="search"
+            value={filter}
+            onChange={(e) => setFilter(e.target.value)}
+            placeholder="Filter…"
+            aria-label="Filter problems"
+            data-testid="filter-problems"
+            className="w-full bg-transparent text-xs text-zinc-300 outline-none placeholder:text-zinc-600"
+          />
+        </div>
+      ) : null}
+
       <ul
         className="min-h-0 flex-1 overflow-y-auto py-1"
         data-testid="problems-list"
       >
-        {problems.length === 0 ? (
+        {visible.length === 0 ? (
           <li className="px-3 py-6 text-center text-[11px] text-zinc-600">
-            No saved problems yet.
+            {problems.length === 0
+              ? "No saved problems yet."
+              : "No problems match the filter."}
           </li>
         ) : (
-          problems.map((p) => {
+          visible.map((p) => {
             const isActive = p.slug === activeSlug;
-            const isRenaming = renaming === p.slug;
+            const isEditing = renaming === p.slug || duplicating === p.slug;
             return (
               <li
                 key={p.slug}
@@ -122,28 +234,37 @@ export function ProblemsSidebar({
                   isActive && "bg-zinc-800/40",
                 )}
               >
-                {isRenaming ? (
+                {isEditing ? (
                   <div className="flex w-full items-center gap-1">
                     <input
                       autoFocus
-                      value={renameValue}
-                      onChange={(e) => setRenameValue(e.target.value)}
+                      value={nameValue}
+                      onChange={(e) => setNameValue(e.target.value)}
                       onKeyDown={(e) => {
-                        if (e.key === "Enter") submitRename(p.slug);
-                        if (e.key === "Escape") setRenaming(null);
+                        if (e.key === "Enter") submitName(p.slug);
+                        if (e.key === "Escape") {
+                          setRenaming(null);
+                          setDuplicating(null);
+                        }
                       }}
-                      aria-label={`Rename ${p.name}`}
+                      aria-label={
+                        renaming ? `Rename ${p.name}` : `Duplicate ${p.name} as`
+                      }
                       className="w-full rounded border border-zinc-700 bg-zinc-950 px-2 py-1 text-xs text-zinc-200 outline-none focus:border-zinc-500"
                     />
                     <IconButton
-                      label="Confirm rename"
-                      onClick={() => submitRename(p.slug)}
+                      label={renaming ? "Confirm rename" : "Confirm duplicate"}
+                      testId={`confirm-name-${p.slug}`}
+                      onClick={() => submitName(p.slug)}
                     >
                       <Check className="h-3.5 w-3.5 text-emerald-400" />
                     </IconButton>
                     <IconButton
-                      label="Cancel rename"
-                      onClick={() => setRenaming(null)}
+                      label="Cancel"
+                      onClick={() => {
+                        setRenaming(null);
+                        setDuplicating(null);
+                      }}
                     >
                       <X className="h-3.5 w-3.5 text-zinc-400" />
                     </IconButton>
@@ -176,6 +297,7 @@ export function ProblemsSidebar({
                       type="button"
                       onClick={() => onLoad(p.slug)}
                       data-testid={`load-problem-${p.slug}`}
+                      title={`Updated ${relativeTime(p.updatedAt)}`}
                       className="flex min-w-0 flex-1 items-center gap-2 rounded px-1.5 py-1 text-left"
                     >
                       <FileCode2
@@ -184,21 +306,24 @@ export function ProblemsSidebar({
                           isActive ? "text-emerald-400" : "text-zinc-600",
                         )}
                       />
-                      <span
-                        className={cn(
-                          "truncate text-xs",
-                          isActive
-                            ? "font-semibold text-zinc-100"
-                            : "text-zinc-400",
-                        )}
-                      >
-                        {p.name}
-                      </span>
-                      <span className="ml-auto shrink-0 font-mono text-[10px] text-zinc-600">
-                        {p.testCount}t
+                      <span className="flex min-w-0 flex-1 flex-col">
+                        <span
+                          className={cn(
+                            "truncate text-xs",
+                            isActive
+                              ? "font-semibold text-zinc-100"
+                              : "text-zinc-400",
+                          )}
+                        >
+                          {p.name}
+                        </span>
+                        <span className="truncate font-mono text-[9px] text-zinc-600">
+                          {p.testCount} test{p.testCount === 1 ? "" : "s"} ·{" "}
+                          {relativeTime(p.updatedAt)}
+                        </span>
                       </span>
                     </button>
-                    <div className="flex shrink-0 items-center opacity-0 transition group-hover:opacity-100">
+                    <div className="flex shrink-0 items-center opacity-0 transition group-hover:opacity-100 group-focus-within:opacity-100">
                       <IconButton
                         label={`Rename ${p.name}`}
                         testId={`rename-problem-${p.slug}`}
@@ -206,6 +331,13 @@ export function ProblemsSidebar({
                       >
                         <Pencil className="h-3 w-3 text-zinc-500" />
                       </IconButton>
+                      <IconButton
+                        label={`Duplicate ${p.name}`}
+                        testId={`duplicate-problem-${p.slug}`}
+                        onClick={() => startDuplicate(p)}
+                      >
+                        <Copy className="h-3 w-3 text-zinc-500" />
+                      </IconButton>
                       <IconButton
                         label={`Delete ${p.name}`}
                         testId={`delete-problem-${p.slug}`}
diff --git a/web/components/Resizer.tsx b/web/components/Resizer.tsx
new file mode 100644
index 0000000..56884ce
--- /dev/null
+++ b/web/components/Resizer.tsx
@@ -0,0 +1,76 @@
+"use client";
+
+import { useCallback, useRef } from "react";
+import { cn } from "@/lib/utils";
+
+/**
+ * Horizontal drag handle between the editor and the bottom panel. Reports the
+ * pointer's vertical position as a fraction of the container's height so the
+ * parent can size the panel; double-click restores the default.
+ */
+export function Resizer({
+  containerRef,
+  onResize,
+  onReset,
+  className,
+}: {
+  containerRef: React.RefObject<HTMLElement | null>;
+  onResize: (panelFraction: number) => void;
+  onReset?: () => void;
+  className?: string;
+}) {
+  const dragging = useRef(false);
+
+  const onPointerDown = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    if (e.button !== 0) return;
+    dragging.current = true;
+    (e.target as HTMLElement).setPointerCapture(e.pointerId);
+    document.body.style.cursor = "row-resize";
+    document.body.style.userSelect = "none";
+  }, []);
+
+  const onPointerMove = useCallback(
+    (e: React.PointerEvent<HTMLDivElement>) => {
+      if (!dragging.current) return;
+      const el = containerRef.current;
+      if (!el) return;
+      const rect = el.getBoundingClientRect();
+      if (rect.height <= 0) return;
+      const fromBottom = rect.bottom - e.clientY;
+      onResize(fromBottom / rect.height);
+    },
+    [containerRef, onResize],
+  );
+
+  const end = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    if (!dragging.current) return;
+    dragging.current = false;
+    try {
+      (e.target as HTMLElement).releasePointerCapture(e.pointerId);
+    } catch {
+      // capture may already be gone
+    }
+    document.body.style.cursor = "";
+    document.body.style.userSelect = "";
+  }, []);
+
+  return (
+    <div
+      role="separator"
+      aria-orientation="horizontal"
+      aria-label="Resize panel"
+      data-testid="panel-resizer"
+      onPointerDown={onPointerDown}
+      onPointerMove={onPointerMove}
+      onPointerUp={end}
+      onPointerCancel={end}
+      onDoubleClick={onReset}
+      className={cn(
+        "group relative z-10 h-1.5 shrink-0 cursor-row-resize bg-zinc-800 transition hover:bg-zinc-600",
+        className,
+      )}
+    >
+      <div className="pointer-events-none absolute left-1/2 top-1/2 h-0.5 w-8 -translate-x-1/2 -translate-y-1/2 rounded bg-zinc-600 group-hover:bg-zinc-400" />
+    </div>
+  );
+}
diff --git a/web/components/RunPanel.tsx b/web/components/RunPanel.tsx
index 8b1b3e2..208e4ad 100644
--- a/web/components/RunPanel.tsx
+++ b/web/components/RunPanel.tsx
@@ -1,27 +1,32 @@
 "use client";
 
 import { useState } from "react";
-import { Check, Copy, Loader2 } from "lucide-react";
+import { Check, Copy, Loader2, Eraser, Zap } from "lucide-react";
 import { cn } from "@/lib/utils";
 import type { RunResponse } from "@/lib/api";
 import { VerdictBadge } from "./VerdictBadge";
 import { Terminal } from "./Terminal";
+import { DiagnosticsList, RejectedFlagsNotice } from "./DiagnosticsList";
 
 /**
  * Run panel: a custom-stdin box, a metrics row (verdict, exit code, elapsed
- * time, compiler) and the scrollable raw terminal log carrying stdout, stderr
- * and any compile errors.
+ * time, compiler, cache state), a clickable compiler-diagnostics list and the
+ * scrollable raw terminal log carrying stdout, stderr and any compile errors.
  */
 export function RunPanel({
   result,
   loading,
   stdin,
   onStdinChange,
+  onGotoLine,
+  onClear,
 }: {
   result: RunResponse | null;
   loading: boolean;
   stdin: string;
   onStdinChange: (value: string) => void;
+  onGotoLine?: (line: number) => void;
+  onClear?: () => void;
 }) {
   const terminalText = buildTerminalText(result);
   const [copied, setCopied] = useState(false);
@@ -36,15 +41,24 @@ export function RunPanel({
     }
   };
 
+  const diagnostics = result?.compile.diagnostics ?? [];
+  const warnings = diagnostics.filter((d) => d.severity === "warning").length;
+  const errors = diagnostics.filter((d) => d.severity === "error").length;
+
   return (
     <div className="flex h-full flex-col" data-testid="run-panel">
       <div className="shrink-0 border-b border-zinc-800 bg-zinc-900/40 p-3">
-        <label
-          htmlFor="run-stdin"
-          className="mb-1.5 block text-[10px] font-bold uppercase tracking-widest text-zinc-500"
-        >
-          Custom stdin
-        </label>
+        <div className="mb-1.5 flex items-center justify-between">
+          <label
+            htmlFor="run-stdin"
+            className="block text-[10px] font-bold uppercase tracking-widest text-zinc-500"
+          >
+            Custom stdin
+          </label>
+          <span className="font-mono text-[10px] text-zinc-600">
+            {stdin.length} chars
+          </span>
+        </div>
         <textarea
           id="run-stdin"
           data-testid="run-stdin"
@@ -71,17 +85,40 @@ export function RunPanel({
             <VerdictBadge verdict={result.verdict} testId="run-verdict" />
             <Metric
               label="exit"
-              value={result.exitCode === null ? "—" : String(result.exitCode)}
+              value={
+                result.exitCode === null
+                  ? (result.signal ?? "—")
+                  : String(result.exitCode)
+              }
             />
             <Metric
               label="time"
-              value={`${result.timeMs} ms`}
+              value={`${formatMs(result.timeMs)} ms`}
               testId="elapsed-time"
             />
-            <Metric label="compile" value={`${result.compile.ms} ms`} />
+            <Metric
+              label="compile"
+              value={
+                result.compile.cached
+                  ? "cached"
+                  : `${formatMs(result.compile.ms)} ms`
+              }
+              testId="compile-time"
+              icon={result.compile.cached ? Zap : undefined}
+            />
             {result.compiler ? (
               <Metric label="cc" value={shortCompiler(result.compiler)} />
             ) : null}
+            {warnings > 0 ? (
+              <span className="font-semibold text-amber-400">
+                {warnings} warning{warnings === 1 ? "" : "s"}
+              </span>
+            ) : null}
+            {errors > 0 ? (
+              <span className="font-semibold text-red-400">
+                {errors} error{errors === 1 ? "" : "s"}
+              </span>
+            ) : null}
             {result.timedOut ? (
               <span className="font-semibold text-amber-400">timed out</span>
             ) : null}
@@ -90,28 +127,58 @@ export function RunPanel({
                 output truncated
               </span>
             ) : null}
-            {terminalText ? (
-              <button
-                type="button"
-                onClick={handleCopy}
-                data-testid="copy-log-button"
-                aria-label="Copy raw log"
-                className="ml-auto inline-flex items-center gap-1 rounded bg-zinc-800/60 px-2 py-0.5 font-mono text-[10px] uppercase tracking-widest text-zinc-400 transition hover:bg-zinc-700 hover:text-zinc-100"
-              >
-                {copied ? (
-                  <Check className="h-3 w-3 text-emerald-400" />
-                ) : (
-                  <Copy className="h-3 w-3" />
-                )}
-                {copied ? "Copied" : "Copy"}
-              </button>
-            ) : null}
+            <span className="ml-auto flex items-center gap-1">
+              {terminalText ? (
+                <ToolButton
+                  onClick={handleCopy}
+                  testId="copy-log-button"
+                  label="Copy raw log"
+                >
+                  {copied ? (
+                    <Check className="h-3 w-3 text-emerald-400" />
+                  ) : (
+                    <Copy className="h-3 w-3" />
+                  )}
+                  {copied ? "Copied" : "Copy"}
+                </ToolButton>
+              ) : null}
+              {onClear ? (
+                <ToolButton
+                  onClick={onClear}
+                  testId="clear-run-button"
+                  label="Clear result"
+                >
+                  <Eraser className="h-3 w-3" />
+                  Clear
+                </ToolButton>
+              ) : null}
+            </span>
           </>
         ) : (
-          <span className="text-zinc-600">Run to see output.</span>
+          <span className="text-zinc-600">
+            Run to see output. Ctrl/⌘+Enter runs, Ctrl/⌘+Shift+Enter runs all
+            tests.
+          </span>
         )}
       </div>
 
+      {result ? (
+        <div className="shrink-0 space-y-2 empty:hidden">
+          <RejectedFlagsNotice
+            flags={result.compile.rejectedFlags}
+            className="mx-3 mt-2"
+          />
+          {diagnostics.length > 0 ? (
+            <div className="max-h-32 overflow-y-auto border-b border-zinc-800 bg-zinc-900/30 px-1.5 py-1">
+              <DiagnosticsList
+                diagnostics={diagnostics}
+                onGotoLine={onGotoLine}
+              />
+            </div>
+          ) : null}
+        </div>
+      ) : null}
+
       <div className="min-h-0 flex-1">
         <Terminal text={terminalText} placeholder="Waiting for execution…" />
       </div>
@@ -119,14 +186,40 @@ export function RunPanel({
   );
 }
 
+function ToolButton({
+  onClick,
+  testId,
+  label,
+  children,
+}: {
+  onClick: () => void;
+  testId: string;
+  label: string;
+  children: React.ReactNode;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      data-testid={testId}
+      aria-label={label}
+      className="inline-flex items-center gap-1 rounded bg-zinc-800/60 px-2 py-0.5 font-mono text-[10px] uppercase tracking-widest text-zinc-400 transition hover:bg-zinc-700 hover:text-zinc-100"
+    >
+      {children}
+    </button>
+  );
+}
+
 function Metric({
   label,
   value,
   testId,
+  icon: Icon,
 }: {
   label: string;
   value: string;
   testId?: string;
+  icon?: React.ElementType;
 }) {
   return (
     <span
@@ -136,13 +229,19 @@ function Metric({
       <span className="text-[9px] uppercase tracking-widest text-zinc-500">
         {label}
       </span>
+      {Icon ? <Icon className="h-3 w-3 text-emerald-400" /> : null}
       <span className={cn("text-zinc-200")}>{value}</span>
     </span>
   );
 }
 
+export function formatMs(ms: number): string {
+  if (!Number.isFinite(ms)) return "—";
+  return ms >= 100 ? String(Math.round(ms)) : ms.toFixed(1);
+}
+
 function shortCompiler(path: string): string {
-  const parts = path.split("/");
+  const parts = path.split(/[\\/]/);
   return parts[parts.length - 1] || path;
 }
 
@@ -156,6 +255,11 @@ function buildTerminalText(result: RunResponse | null): string {
   if (result.stderr) {
     sections.push(`──── stderr ────\n${result.stderr.replace(/\n$/, "")}`);
   }
+  if (result.compile.stderr) {
+    sections.push(
+      `──── compiler ────\n${result.compile.stderr.replace(/\n$/, "")}`,
+    );
+  }
   if (sections.length === 0) {
     return "(no output)";
   }
diff --git a/web/components/SettingsPanel.tsx b/web/components/SettingsPanel.tsx
index 5190b88..1b73de1 100644
--- a/web/components/SettingsPanel.tsx
+++ b/web/components/SettingsPanel.tsx
@@ -1,30 +1,62 @@
 "use client";
 
-import type { ReactNode } from "react";
-import type { RunSettings } from "@/lib/api";
+import { useState, type ReactNode } from "react";
+import { RotateCcw, Trash2, Loader2 } from "lucide-react";
+import { toast } from "sonner";
+import { cn } from "@/lib/utils";
+import {
+  clearServerCache,
+  type RunSettings,
+  type WorkbenchConfig,
+} from "@/lib/api";
 import {
   STD_OPTIONS,
+  CHECKER_OPTIONS,
   MIN_FONT_SIZE,
   MAX_FONT_SIZE,
+  MIN_TIME_LIMIT_MS,
+  MAX_TIME_LIMIT_MS,
+  DEFAULT_SETTINGS,
   parseFlags,
+  clampTimeLimit,
 } from "@/lib/storage";
 
 /**
- * Settings panel: language standard, time limit, extra compiler flags and
- * editor font size. Values feed straight into every /api/run, /api/test and
- * /api/stress request.
+ * Settings panel: language standard, time limit, checker mode, extra
+ * compiler flags and editor font size. Values feed straight into every
+ * /api/run, /api/test and /api/stress request. A read-only "server" section
+ * shows the detected toolchain and lets you drop the compile cache.
  */
 export function SettingsPanel({
   settings,
   onSettingsChange,
   fontSize,
   onFontSizeChange,
+  config,
 }: {
   settings: RunSettings;
   onSettingsChange: (settings: RunSettings) => void;
   fontSize: number;
   onFontSizeChange: (size: number) => void;
+  config: WorkbenchConfig | null;
 }) {
+  const [flagsText, setFlagsText] = useState<string | null>(null);
+  const [clearing, setClearing] = useState(false);
+
+  const flagsValue = flagsText ?? settings.compilerFlags.join(" ");
+
+  const clearCache = async () => {
+    setClearing(true);
+    try {
+      const n = await clearServerCache();
+      toast.success(`Cleared ${n} cached binar${n === 1 ? "y" : "ies"}`);
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : "Could not clear cache");
+    } finally {
+      setClearing(false);
+    }
+  };
+
   return (
     <div
       className="h-full space-y-5 overflow-y-auto p-4"
@@ -41,7 +73,7 @@ export function SettingsPanel({
           }
           data-testid="settings-std"
           aria-label="Language standard"
-          className="w-44 rounded-md border border-zinc-800 bg-zinc-950 px-2 py-1.5 text-xs text-zinc-200 outline-none focus:border-zinc-600"
+          className={selectClass}
         >
           {STD_OPTIONS.map((s) => (
             <option key={s} value={s}>
@@ -51,42 +83,93 @@ export function SettingsPanel({
         </select>
       </Row>
 
-      <Row label="Time limit (ms)" hint="Wall-clock cap per execution.">
+      <Row
+        label="Time limit (ms)"
+        hint={`Wall-clock cap per execution (${MIN_TIME_LIMIT_MS}–${MAX_TIME_LIMIT_MS}).`}
+      >
         <input
           type="number"
-          min={100}
-          max={60000}
+          min={MIN_TIME_LIMIT_MS}
+          max={MAX_TIME_LIMIT_MS}
           step={100}
           value={settings.timeLimitMs}
           onChange={(e) =>
             onSettingsChange({
               ...settings,
-              timeLimitMs: clampTimeLimit(e.target.value, settings.timeLimitMs),
+              timeLimitMs: readNumber(e.target.value, settings.timeLimitMs),
             })
           }
           data-testid="settings-time-limit"
           aria-label="Time limit in milliseconds"
-          className="w-44 rounded-md border border-zinc-800 bg-zinc-950 px-2 py-1.5 text-center font-mono text-xs text-zinc-200 outline-none focus:border-zinc-600"
+          className={cn(inputClass, "w-44 text-center")}
         />
       </Row>
 
+      <Row label="Output checker" hint="How Tests and Stress compare outputs.">
+        <div className="flex flex-wrap items-center gap-2">
+          <select
+            value={settings.checker}
+            onChange={(e) =>
+              onSettingsChange({
+                ...settings,
+                checker: e.target.value as RunSettings["checker"],
+              })
+            }
+            data-testid="settings-checker"
+            aria-label="Output checker"
+            className={selectClass}
+          >
+            {CHECKER_OPTIONS.map((c) => (
+              <option key={c.id} value={c.id}>
+                {c.label}
+              </option>
+            ))}
+          </select>
+          {settings.checker === "float" ? (
+            <label className="flex items-center gap-2 text-[11px] text-zinc-400">
+              <span className="font-bold uppercase tracking-widest text-zinc-500">
+                eps
+              </span>
+              <input
+                type="text"
+                inputMode="decimal"
+                value={String(settings.epsilon)}
+                onChange={(e) => {
+                  const n = Number(e.target.value);
+                  if (Number.isFinite(n) && n >= 0)
+                    onSettingsChange({ ...settings, epsilon: Math.min(1, n) });
+                }}
+                data-testid="settings-epsilon"
+                aria-label="Float checker epsilon"
+                className={cn(inputClass, "w-24 text-center")}
+              />
+            </label>
+          ) : null}
+          <span className="text-[10px] text-zinc-600">
+            {CHECKER_OPTIONS.find((c) => c.id === settings.checker)?.hint}
+          </span>
+        </div>
+      </Row>
+
       <Row
         label="Extra compiler flags"
-        hint="Space-separated, appended after -O2 (e.g. -Wall -DLOCAL)."
+        hint="Space-separated, appended after -O2. Only -O/-W/-D/-f/-g/-m/-std families are accepted."
       >
         <input
           type="text"
-          value={settings.compilerFlags.join(" ")}
-          onChange={(e) =>
+          value={flagsValue}
+          onChange={(e) => {
+            setFlagsText(e.target.value);
             onSettingsChange({
               ...settings,
               compilerFlags: parseFlags(e.target.value),
-            })
-          }
+            });
+          }}
+          onBlur={() => setFlagsText(null)}
           data-testid="settings-flags"
           aria-label="Extra compiler flags"
-          placeholder="-Wall -Wextra"
-          className="w-64 rounded-md border border-zinc-800 bg-zinc-950 px-2 py-1.5 font-mono text-xs text-zinc-200 outline-none focus:border-zinc-600"
+          placeholder="-Wall -Wextra -DLOCAL -fsanitize=address,undefined"
+          className={cn(inputClass, "w-full max-w-md")}
         />
       </Row>
 
@@ -110,10 +193,75 @@ export function SettingsPanel({
           </span>
         </div>
       </Row>
+
+      <div className="flex flex-wrap items-center gap-2 border-t border-zinc-800 pt-4">
+        <button
+          type="button"
+          onClick={() => {
+            setFlagsText(null);
+            onSettingsChange({ ...DEFAULT_SETTINGS });
+            toast.success("Settings reset to defaults");
+          }}
+          data-testid="settings-reset"
+          className={buttonClass}
+        >
+          <RotateCcw className="h-3.5 w-3.5" />
+          Reset to defaults
+        </button>
+        <button
+          type="button"
+          onClick={clearCache}
+          disabled={clearing}
+          data-testid="settings-clear-cache"
+          className={buttonClass}
+        >
+          {clearing ? (
+            <Loader2 className="h-3.5 w-3.5 animate-spin" />
+          ) : (
+            <Trash2 className="h-3.5 w-3.5" />
+          )}
+          Clear compile cache
+        </button>
+      </div>
+
+      <div
+        className="space-y-1 border-t border-zinc-800 pt-4 font-mono text-[11px] text-zinc-500"
+        data-testid="settings-server-info"
+      >
+        <div className="mb-1 text-[10px] font-bold uppercase tracking-widest text-zinc-500">
+          Server
+        </div>
+        {config ? (
+          <>
+            <Info label="workbench" value={`v${config.version}`} />
+            <Info
+              label="compiler"
+              value={config.compilerVersion ?? "not found"}
+              tone={config.compilerVersion ? undefined : "error"}
+            />
+            <Info label="platform" value={config.platform} />
+            <Info label="include" value={config.includeDir} />
+            <Info
+              label="limits"
+              value={`source ${fmtKb(config.limits.maxSourceBytes)}, stdin ${fmtKb(config.limits.maxInputBytes)}, output ${fmtKb(config.limits.maxOutputBytes)}, compile ${config.limits.compileTimeoutMs / 1000}s`}
+            />
+            <Info label="cache" value={`${config.cache.entries} binaries`} />
+          </>
+        ) : (
+          <div className="text-zinc-600">Server info unavailable.</div>
+        )}
+      </div>
     </div>
   );
 }
 
+const inputClass =
+  "rounded-md border border-zinc-800 bg-zinc-950 px-2 py-1.5 font-mono text-xs text-zinc-200 outline-none focus:border-zinc-600";
+const selectClass =
+  "w-44 rounded-md border border-zinc-800 bg-zinc-950 px-2 py-1.5 text-xs text-zinc-200 outline-none focus:border-zinc-600";
+const buttonClass =
+  "inline-flex items-center gap-1.5 rounded-md border border-zinc-700 bg-zinc-800 px-2.5 py-1.5 text-[11px] font-semibold text-zinc-200 transition hover:bg-zinc-700 disabled:cursor-not-allowed disabled:opacity-50";
+
 function Row({
   label,
   hint,
@@ -125,7 +273,7 @@ function Row({
 }) {
   return (
     <div className="flex flex-col gap-1.5">
-      <div className="flex items-baseline justify-between gap-3">
+      <div className="flex flex-wrap items-baseline justify-between gap-x-3 gap-y-0.5">
         <span className="text-xs font-semibold text-zinc-200">{label}</span>
         <span className="text-[10px] text-zinc-600">{hint}</span>
       </div>
@@ -134,9 +282,39 @@ function Row({
   );
 }
 
-function clampTimeLimit(raw: string, fallback: number): number {
+function Info({
+  label,
+  value,
+  tone,
+}: {
+  label: string;
+  value: string;
+  tone?: "error";
+}) {
+  return (
+    <div className="flex gap-2">
+      <span className="w-20 shrink-0 text-zinc-600">{label}</span>
+      <span
+        className={cn(
+          "break-all",
+          tone === "error" ? "text-red-400" : "text-zinc-400",
+        )}
+      >
+        {value}
+      </span>
+    </div>
+  );
+}
+
+function fmtKb(bytes: number): string {
+  return bytes >= 1024 * 1024
+    ? `${Math.round(bytes / 1024 / 1024)} MiB`
+    : `${Math.round(bytes / 1024)} KiB`;
+}
+
+function readNumber(raw: string, fallback: number): number {
   if (raw.trim() === "") return fallback;
   const n = Math.floor(Number(raw));
   if (!Number.isFinite(n)) return fallback;
-  return Math.min(60000, Math.max(100, n));
+  return clampTimeLimit(n);
 }
diff --git a/web/components/StressPanel.tsx b/web/components/StressPanel.tsx
index 732856c..26cbac9 100644
--- a/web/components/StressPanel.tsx
+++ b/web/components/StressPanel.tsx
@@ -1,7 +1,15 @@
 "use client";
 
 import { useState, type ReactNode } from "react";
-import { Loader2, Swords, CheckCircle2, AlertTriangle } from "lucide-react";
+import {
+  Loader2,
+  Swords,
+  CheckCircle2,
+  AlertTriangle,
+  ListPlus,
+  Terminal as TerminalIcon,
+} from "lucide-react";
+import { toast } from "sonner";
 import { cn } from "@/lib/utils";
 import {
   runStress,
@@ -12,11 +20,14 @@ import {
 } from "@/lib/api";
 import { CodeEditor } from "./CodeEditor";
 import { DiffView } from "./DiffView";
+import { DiagnosticsList } from "./DiagnosticsList";
+import { formatMs } from "./RunPanel";
 
 /**
- * Stress panel: brute-force and generator editors plus an iteration count.
- * Runs /api/stress against the current solution and surfaces the first failing
- * input. Degrades gracefully when the endpoint is missing or errors.
+ * Stress panel: brute-force and generator editors plus iteration count and a
+ * seed base. Runs /api/stress against the current solution and surfaces the
+ * first failing input, which can be promoted straight into a test case or the
+ * Run panel's stdin. Degrades gracefully when the endpoint is missing.
  */
 export function StressPanel({
   solution,
@@ -28,6 +39,8 @@ export function StressPanel({
   onBruteChange,
   onGeneratorChange,
   onIterationsChange,
+  onAddTestCase,
+  onUseAsStdin,
 }: {
   solution: string;
   brute: string;
@@ -38,23 +51,32 @@ export function StressPanel({
   onBruteChange: (value: string) => void;
   onGeneratorChange: (value: string) => void;
   onIterationsChange: (value: number) => void;
+  onAddTestCase?: (input: string, expected: string) => void;
+  onUseAsStdin?: (input: string) => void;
 }) {
   const [result, setResult] = useState<StressResponse | null>(null);
   const [loading, setLoading] = useState(false);
   const [unavailable, setUnavailable] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [seedBase, setSeedBase] = useState(1);
 
   const run = async () => {
+    if (!solution.trim()) {
+      toast.error("The editor is empty");
+      return;
+    }
     setLoading(true);
     setError(null);
     setUnavailable(false);
     setResult(null);
     try {
       const res = await runStress(
-        { solution, brute, generator, iterations },
+        { solution, brute, generator, iterations, seedBase },
         settings,
       );
       setResult(res);
+      if (res.failed) toast.error("Stress found a counter-example");
+      else if (res.ok) toast.success(res.message);
     } catch (e) {
       if (e instanceof ApiError && (e.status === 404 || e.status === 405)) {
         setUnavailable(true);
@@ -86,25 +108,27 @@ export function StressPanel({
           )}
           Run stress
         </button>
-        <label className="flex items-center gap-2 text-[11px] text-zinc-400">
-          <span className="font-bold uppercase tracking-widest text-zinc-500">
-            Iterations
-          </span>
-          <input
-            type="number"
-            min={1}
-            max={5000}
-            value={iterations}
-            onChange={(e) =>
-              onIterationsChange(clampIterations(e.target.value, iterations))
-            }
-            data-testid="stress-iterations"
-            aria-label="Stress iterations"
-            className="w-20 rounded-md border border-zinc-800 bg-zinc-950 px-2 py-1 text-center font-mono text-xs text-zinc-200 outline-none focus:border-zinc-600"
-          />
-        </label>
+        <NumberField
+          label="Iterations"
+          value={iterations}
+          min={1}
+          max={5000}
+          onChange={onIterationsChange}
+          testId="stress-iterations"
+          ariaLabel="Stress iterations"
+        />
+        <NumberField
+          label="Seed"
+          value={seedBase}
+          min={0}
+          max={Number.MAX_SAFE_INTEGER}
+          onChange={setSeedBase}
+          testId="stress-seed"
+          ariaLabel="First generator seed"
+        />
         <span className="text-[10px] text-zinc-600">
-          solution (editor) vs brute, on generator inputs
+          solution (editor) vs brute on generator inputs · checker:{" "}
+          {settings.checker}
         </span>
       </div>
 
@@ -138,12 +162,50 @@ export function StressPanel({
           unavailable={unavailable}
           error={error}
           result={result}
+          onAddTestCase={onAddTestCase}
+          onUseAsStdin={onUseAsStdin}
         />
       </div>
     </div>
   );
 }
 
+function NumberField({
+  label,
+  value,
+  min,
+  max,
+  onChange,
+  testId,
+  ariaLabel,
+}: {
+  label: string;
+  value: number;
+  min: number;
+  max: number;
+  onChange: (v: number) => void;
+  testId: string;
+  ariaLabel: string;
+}) {
+  return (
+    <label className="flex items-center gap-2 text-[11px] text-zinc-400">
+      <span className="font-bold uppercase tracking-widest text-zinc-500">
+        {label}
+      </span>
+      <input
+        type="number"
+        min={min}
+        max={max}
+        value={value}
+        onChange={(e) => onChange(clampInt(e.target.value, value, min, max))}
+        data-testid={testId}
+        aria-label={ariaLabel}
+        className="w-20 rounded-md border border-zinc-800 bg-zinc-950 px-2 py-1 text-center font-mono text-xs text-zinc-200 outline-none focus:border-zinc-600"
+      />
+    </label>
+  );
+}
+
 function EditorSection({
   title,
   subtitle,
@@ -188,11 +250,15 @@ function StressResult({
   unavailable,
   error,
   result,
+  onAddTestCase,
+  onUseAsStdin,
 }: {
   loading: boolean;
   unavailable: boolean;
   error: string | null;
   result: StressResponse | null;
+  onAddTestCase?: (input: string, expected: string) => void;
+  onUseAsStdin?: (input: string) => void;
 }) {
   if (loading) {
     return (
@@ -216,7 +282,8 @@ function StressResult({
   if (!result) {
     return (
       <p className="p-4 text-xs text-zinc-600">
-        Provide a brute force and a generator, then run a stress search.
+        Provide a brute force and a generator, then run a stress search. The
+        first input on which the two programs disagree is shown here.
       </p>
     );
   }
@@ -228,33 +295,77 @@ function StressResult({
 
   if (compileFailed) {
     const which = !result.compile.solution.ok
-      ? { label: "solution", stderr: result.compile.solution.stderr }
+      ? { label: "solution", status: result.compile.solution }
       : !result.compile.brute.ok
-        ? { label: "brute", stderr: result.compile.brute.stderr }
-        : { label: "generator", stderr: result.compile.generator.stderr };
+        ? { label: "brute", status: result.compile.brute }
+        : { label: "generator", status: result.compile.generator };
     return (
       <div className="p-3">
         <Notice tone="error">Compilation failed for {which.label}.</Notice>
+        {which.status.diagnostics && which.status.diagnostics.length > 0 ? (
+          <div className="mt-2 rounded border border-zinc-800 bg-zinc-900/40 px-1 py-1">
+            <DiagnosticsList diagnostics={which.status.diagnostics} />
+          </div>
+        ) : null}
         <pre className="mt-2 max-h-40 overflow-auto whitespace-pre-wrap break-words rounded border border-zinc-800 bg-zinc-950 p-2 font-mono text-[11px] text-red-300">
-          {which.stderr}
+          {which.status.stderr}
         </pre>
       </div>
     );
   }
 
   if (result.failed && result.firstFailure) {
-    return <Failure failure={result.firstFailure} />;
+    return (
+      <Failure
+        failure={result.firstFailure}
+        onAddTestCase={onAddTestCase}
+        onUseAsStdin={onUseAsStdin}
+      />
+    );
   }
 
   return (
-    <div className="flex items-center gap-2 p-4 text-xs text-emerald-400">
-      <CheckCircle2 className="h-4 w-4" />
-      {result.message}
+    <div className="space-y-1 p-4 text-xs">
+      <div className="flex items-center gap-2 text-emerald-400">
+        <CheckCircle2 className="h-4 w-4" />
+        {result.message}
+      </div>
+      <Stats result={result} />
+    </div>
+  );
+}
+
+function Stats({ result }: { result: StressResponse }) {
+  if (!result.stats) return null;
+  return (
+    <div
+      className="flex flex-wrap gap-x-4 gap-y-1 font-mono text-[10px] text-zinc-500"
+      data-testid="stress-stats"
+    >
+      <span>{result.iterationsRun} iterations</span>
+      {result.elapsedMs !== undefined ? (
+        <span>{formatMs(result.elapsedMs)} ms total</span>
+      ) : null}
+      <span>solution max {formatMs(result.stats.maxSolutionMs)} ms</span>
+      <span>solution avg {formatMs(result.stats.avgSolutionMs)} ms</span>
+      <span>brute max {formatMs(result.stats.maxBruteMs)} ms</span>
+      {result.deadlineHit ? (
+        <span className="text-amber-400">request budget reached</span>
+      ) : null}
     </div>
   );
 }
 
-function Failure({ failure }: { failure: StressFailure }) {
+function Failure({
+  failure,
+  onAddTestCase,
+  onUseAsStdin,
+}: {
+  failure: StressFailure;
+  onAddTestCase?: (input: string, expected: string) => void;
+  onUseAsStdin?: (input: string) => void;
+}) {
+  const canPromote = failure.reason === "mismatch" || failure.bruteOutput;
   return (
     <div className="space-y-2 p-3" data-testid="stress-failure">
       <div className="flex flex-wrap items-center gap-2 text-xs">
@@ -265,6 +376,34 @@ function Failure({ failure }: { failure: StressFailure }) {
         <span className="font-mono text-zinc-500">
           iteration {failure.iteration} · seed {failure.seed}
         </span>
+        <span className="ml-auto flex items-center gap-1">
+          {onAddTestCase && canPromote ? (
+            <SmallButton
+              testId="stress-add-test"
+              label="Add failing input as a test case"
+              onClick={() => {
+                onAddTestCase(failure.input, failure.bruteOutput);
+                toast.success("Added the failing input as a test case");
+              }}
+            >
+              <ListPlus className="h-3 w-3" />
+              Add as test
+            </SmallButton>
+          ) : null}
+          {onUseAsStdin ? (
+            <SmallButton
+              testId="stress-use-stdin"
+              label="Use failing input as stdin"
+              onClick={() => {
+                onUseAsStdin(failure.input);
+                toast.success("Copied the failing input to stdin");
+              }}
+            >
+              <TerminalIcon className="h-3 w-3" />
+              Use as stdin
+            </SmallButton>
+          ) : null}
+        </span>
       </div>
 
       <div>
@@ -287,17 +426,77 @@ function Failure({ failure }: { failure: StressFailure }) {
           <OutBlock label="Solution output" value={failure.solutionOutput} />
         </div>
       )}
+
+      {failure.solutionStderr ? (
+        <OutBlock
+          label="Solution stderr"
+          value={failure.solutionStderr}
+          tone="error"
+        />
+      ) : null}
+      {failure.bruteStderr ? (
+        <OutBlock
+          label="Brute stderr"
+          value={failure.bruteStderr}
+          tone="error"
+        />
+      ) : null}
+      {failure.generatorStderr ? (
+        <OutBlock
+          label="Generator stderr"
+          value={failure.generatorStderr}
+          tone="error"
+        />
+      ) : null}
     </div>
   );
 }
 
-function OutBlock({ label, value }: { label: string; value: string }) {
+function SmallButton({
+  onClick,
+  testId,
+  label,
+  children,
+}: {
+  onClick: () => void;
+  testId: string;
+  label: string;
+  children: ReactNode;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      data-testid={testId}
+      aria-label={label}
+      title={label}
+      className="inline-flex items-center gap-1 rounded bg-zinc-800/60 px-2 py-0.5 font-mono text-[10px] uppercase tracking-widest text-zinc-400 transition hover:bg-zinc-700 hover:text-zinc-100"
+    >
+      {children}
+    </button>
+  );
+}
+
+function OutBlock({
+  label,
+  value,
+  tone,
+}: {
+  label: string;
+  value: string;
+  tone?: "error";
+}) {
   return (
     <div>
       <div className="mb-1 text-[10px] font-bold uppercase tracking-widest text-zinc-500">
         {label}
       </div>
-      <pre className="max-h-32 overflow-auto whitespace-pre-wrap break-words rounded border border-zinc-800 bg-zinc-950 p-2 font-mono text-[11px] text-zinc-300">
+      <pre
+        className={cn(
+          "max-h-32 overflow-auto whitespace-pre-wrap break-words rounded border border-zinc-800 bg-zinc-950 p-2 font-mono text-[11px]",
+          tone === "error" ? "text-red-300" : "text-zinc-300",
+        )}
+      >
         {value || " "}
       </pre>
     </div>
@@ -325,9 +524,14 @@ function Notice({
   );
 }
 
-function clampIterations(raw: string, fallback: number): number {
+function clampInt(
+  raw: string,
+  fallback: number,
+  lo: number,
+  hi: number,
+): number {
   if (raw.trim() === "") return fallback;
   const n = Math.floor(Number(raw));
   if (!Number.isFinite(n)) return fallback;
-  return Math.min(5000, Math.max(1, n));
+  return Math.min(hi, Math.max(lo, n));
 }
diff --git a/web/components/TestsPanel.tsx b/web/components/TestsPanel.tsx
index 599407b..fabee59 100644
--- a/web/components/TestsPanel.tsx
+++ b/web/components/TestsPanel.tsx
@@ -8,18 +8,27 @@ import {
   ClipboardPaste,
   ChevronRight,
   Loader2,
+  FileText,
+  Copy,
+  Terminal as TerminalIcon,
+  ChevronsDownUp,
+  ChevronsUpDown,
+  Zap,
 } from "lucide-react";
 import { toast } from "sonner";
 import { cn } from "@/lib/utils";
-import type { TestResponse, TestCaseResult } from "@/lib/api";
+import type { TestResponse, TestCaseResult, ParsedStatement } from "@/lib/api";
 import type { SampleTest } from "@/lib/storage";
 import { VerdictBadge } from "./VerdictBadge";
 import { DiffView } from "./DiffView";
+import { DiagnosticsList, RejectedFlagsNotice } from "./DiagnosticsList";
+import { formatMs } from "./RunPanel";
 
 /**
- * Tests panel: add / edit / delete sample cases, paste-and-split a clipboard
- * blob into input + expected, run every case via /api/test and render per-case
- * AC/WA/TLE/RE/CE badges with an expandable diff view.
+ * Tests panel: add / edit / duplicate / delete sample cases, paste-and-split
+ * a clipboard blob into input + expected, import every sample from a pasted
+ * problem statement, run all cases (or a single one) via /api/test and render
+ * per-case AC/WA/TLE/RE/CE badges with an expandable diff view.
  */
 export function TestsPanel({
   tests,
@@ -28,6 +37,12 @@ export function TestsPanel({
   result,
   loading,
   onRunAll,
+  onRunOne,
+  onUseAsStdin,
+  onImportStatement,
+  onGotoLine,
+  stopOnFirstFailure,
+  onStopOnFirstFailureChange,
 }: {
   tests: SampleTest[];
   onChange: (tests: SampleTest[]) => void;
@@ -35,11 +50,20 @@ export function TestsPanel({
   result: TestResponse | null;
   loading: boolean;
   onRunAll: () => void;
+  onRunOne?: (id: number) => void;
+  onUseAsStdin?: (input: string) => void;
+  onImportStatement?: (statement: string) => Promise<ParsedStatement | null>;
+  onGotoLine?: (line: number) => void;
+  stopOnFirstFailure?: boolean;
+  onStopOnFirstFailureChange?: (v: boolean) => void;
 }) {
   // Only explicit user toggles are stored; a row's default open state is
   // derived from its latest verdict (failing cases auto-expand so the diff is
   // visible without an extra click). This avoids a setState-in-effect.
   const [overrides, setOverrides] = useState<Record<number, boolean>>({});
+  const [importOpen, setImportOpen] = useState(false);
+  const [importText, setImportText] = useState("");
+  const [importing, setImporting] = useState(false);
 
   const update = (id: number, patch: Partial<SampleTest>) =>
     onChange(tests.map((t) => (t.id === id ? { ...t, ...patch } : t)));
@@ -49,6 +73,13 @@ export function TestsPanel({
 
   const removeTest = (id: number) => onChange(tests.filter((t) => t.id !== id));
 
+  const duplicateTest = (id: number) => {
+    const idx = tests.findIndex((t) => t.id === id);
+    if (idx === -1) return;
+    const copy = { ...tests[idx], id: nextId() };
+    onChange([...tests.slice(0, idx + 1), copy, ...tests.slice(idx + 1)]);
+  };
+
   const pasteSplit = async () => {
     try {
       const text = await navigator.clipboard.readText();
@@ -64,6 +95,25 @@ export function TestsPanel({
     }
   };
 
+  const runImport = async () => {
+    if (!onImportStatement || !importText.trim()) return;
+    setImporting(true);
+    try {
+      const parsed = await onImportStatement(importText);
+      if (parsed && parsed.tests.length > 0) {
+        setImportOpen(false);
+        setImportText("");
+      }
+    } finally {
+      setImporting(false);
+    }
+  };
+
+  const setAll = (open: boolean) =>
+    setOverrides(Object.fromEntries(tests.map((t) => [t.id, open])));
+
+  const summary = result?.summary;
+
   return (
     <div className="flex h-full flex-col" data-testid="tests-panel">
       <div className="flex shrink-0 flex-wrap items-center gap-2 border-b border-zinc-800 bg-zinc-900/40 px-3 py-2">
@@ -82,58 +132,174 @@ export function TestsPanel({
           )}
           Run all
         </button>
-        <button
-          type="button"
+        <ToolbarButton
           onClick={addTest}
-          data-testid="add-test-button"
-          aria-label="Add test case"
-          className="inline-flex items-center gap-1.5 rounded-md border border-zinc-700 bg-zinc-800 px-2.5 py-1.5 text-[11px] font-semibold text-zinc-200 transition hover:bg-zinc-700"
+          testId="add-test-button"
+          label="Add test case"
         >
           <Plus className="h-3.5 w-3.5" />
           Add case
-        </button>
-        <button
-          type="button"
+        </ToolbarButton>
+        <ToolbarButton
           onClick={pasteSplit}
-          data-testid="paste-split-button"
-          aria-label="Paste and split clipboard into a test case"
-          className="inline-flex items-center gap-1.5 rounded-md border border-zinc-700 bg-zinc-800 px-2.5 py-1.5 text-[11px] font-semibold text-zinc-200 transition hover:bg-zinc-700"
+          testId="paste-split-button"
+          label="Paste and split clipboard into a test case"
         >
           <ClipboardPaste className="h-3.5 w-3.5" />
           Paste split
-        </button>
-
-        {result ? (
-          <span
-            data-testid="tests-summary"
-            className="ml-auto flex items-center gap-2 text-[11px] text-zinc-400"
+        </ToolbarButton>
+        {onImportStatement ? (
+          <ToolbarButton
+            onClick={() => setImportOpen((o) => !o)}
+            testId="import-statement-button"
+            label="Import samples from a problem statement"
+            active={importOpen}
           >
-            <VerdictBadge
-              verdict={result.summary.verdict}
-              testId="tests-verdict"
+            <FileText className="h-3.5 w-3.5" />
+            From statement
+          </ToolbarButton>
+        ) : null}
+        {onStopOnFirstFailureChange ? (
+          <label className="flex items-center gap-1.5 text-[10px] uppercase tracking-widest text-zinc-500">
+            <input
+              type="checkbox"
+              checked={!!stopOnFirstFailure}
+              onChange={(e) => onStopOnFirstFailureChange(e.target.checked)}
+              data-testid="stop-on-first-failure"
+              className="accent-emerald-500"
             />
-            <span className="font-mono">
-              {result.summary.passed}/{result.summary.total} passed
-            </span>
-          </span>
+            Stop on fail
+          </label>
         ) : null}
+
+        <span className="ml-auto flex items-center gap-2 text-[11px] text-zinc-400">
+          {tests.length > 1 ? (
+            <>
+              <IconOnly
+                label="Expand all"
+                testId="expand-all-button"
+                onClick={() => setAll(true)}
+              >
+                <ChevronsUpDown className="h-3.5 w-3.5" />
+              </IconOnly>
+              <IconOnly
+                label="Collapse all"
+                testId="collapse-all-button"
+                onClick={() => setAll(false)}
+              >
+                <ChevronsDownUp className="h-3.5 w-3.5" />
+              </IconOnly>
+            </>
+          ) : null}
+          {result && summary ? (
+            <span
+              data-testid="tests-summary"
+              className="flex items-center gap-2"
+            >
+              <VerdictBadge verdict={summary.verdict} testId="tests-verdict" />
+              <span className="font-mono">
+                {summary.passed}/{summary.total} passed
+              </span>
+              {summary.maxTimeMs !== undefined ? (
+                <span className="font-mono text-[10px] text-zinc-500">
+                  max {formatMs(summary.maxTimeMs)} ms
+                </span>
+              ) : null}
+              {result.compile.cached ? (
+                <Zap
+                  className="h-3 w-3 text-emerald-400"
+                  aria-label="Compiled binary served from cache"
+                />
+              ) : null}
+            </span>
+          ) : null}
+        </span>
       </div>
 
+      {importOpen ? (
+        <div
+          className="shrink-0 space-y-2 border-b border-zinc-800 bg-zinc-900/30 p-3"
+          data-testid="import-statement-panel"
+        >
+          <textarea
+            value={importText}
+            onChange={(e) => setImportText(e.target.value)}
+            data-testid="import-statement-text"
+            aria-label="Problem statement to import samples from"
+            spellCheck={false}
+            placeholder={
+              "Paste the whole Codeforces problem statement here. Every Input / Output pair under Examples becomes a test case; the time limit is applied to Settings."
+            }
+            className="h-28 w-full resize-y rounded-md border border-zinc-800 bg-zinc-950 px-3 py-2 font-mono text-xs text-zinc-200 outline-none focus:border-zinc-600"
+          />
+          <div className="flex items-center gap-2">
+            <button
+              type="button"
+              onClick={runImport}
+              disabled={importing || !importText.trim()}
+              data-testid="import-statement-submit"
+              className="inline-flex items-center gap-1.5 rounded-md bg-zinc-200 px-2.5 py-1.5 text-[11px] font-bold uppercase tracking-widest text-zinc-950 transition hover:bg-white disabled:cursor-not-allowed disabled:opacity-40"
+            >
+              {importing ? (
+                <Loader2 className="h-3.5 w-3.5 animate-spin" />
+              ) : (
+                <FileText className="h-3.5 w-3.5" />
+              )}
+              Import samples
+            </button>
+            <button
+              type="button"
+              onClick={() => setImportOpen(false)}
+              className="text-[11px] text-zinc-500 hover:text-zinc-300"
+            >
+              Cancel
+            </button>
+          </div>
+        </div>
+      ) : null}
+
+      {result ? (
+        <div className="shrink-0 space-y-2 empty:hidden">
+          <RejectedFlagsNotice
+            flags={result.compile.rejectedFlags}
+            className="mx-3 mt-2"
+          />
+          {result.compile.diagnostics &&
+          result.compile.diagnostics.length > 0 ? (
+            <div className="max-h-28 overflow-y-auto border-b border-zinc-800 bg-zinc-900/30 px-1.5 py-1">
+              <DiagnosticsList
+                diagnostics={result.compile.diagnostics}
+                onGotoLine={onGotoLine}
+              />
+            </div>
+          ) : null}
+        </div>
+      ) : null}
+
       <div className="min-h-0 flex-1 space-y-3 overflow-y-auto p-3">
         {tests.length === 0 ? (
           <p className="px-1 py-6 text-center text-xs text-zinc-600">
-            No sample cases yet. Add one or paste-split from the clipboard.
+            No sample cases yet. Add one, paste-split from the clipboard, or
+            import them from the problem statement.
           </p>
         ) : (
           tests.map((t, i) => {
-            const r = result?.results[i];
-            const autoOpen = !!r && r.verdict !== "AC";
+            const r = result?.results.find((x) => x.index === i);
+            const autoOpen =
+              !!r && r.verdict !== "AC" && r.verdict !== "SKIPPED";
             const isOpen = t.id in overrides ? overrides[t.id] : autoOpen;
             return (
               <div
                 key={t.id}
                 data-testid={`test-case-${i}`}
-                className="overflow-hidden rounded-lg border border-zinc-800 bg-zinc-900/30"
+                className={cn(
+                  "overflow-hidden rounded-lg border bg-zinc-900/30",
+                  r?.verdict === "AC"
+                    ? "border-emerald-500/20"
+                    : r && r.verdict !== "SKIPPED"
+                      ? "border-red-500/20"
+                      : "border-zinc-800",
+                )}
               >
                 <div className="flex items-center gap-2 border-b border-zinc-800 bg-zinc-900/40 px-3 py-1.5">
                   <button
@@ -158,15 +324,45 @@ export function TestsPanel({
                   ) : (
                     <span className="text-[10px] text-zinc-600">not run</span>
                   )}
-                  <button
-                    type="button"
-                    onClick={() => removeTest(t.id)}
-                    data-testid={`delete-test-${i}`}
-                    aria-label={`Delete test case ${i + 1}`}
-                    className="ml-auto rounded p-1 text-zinc-500 transition hover:bg-red-500/10 hover:text-red-400"
-                  >
-                    <Trash2 className="h-3.5 w-3.5" />
-                  </button>
+                  <span className="ml-auto flex items-center">
+                    {onRunOne ? (
+                      <IconOnly
+                        label={`Run test case ${i + 1}`}
+                        testId={`run-test-${i}`}
+                        onClick={() => onRunOne(t.id)}
+                        disabled={loading}
+                      >
+                        <Play className="h-3.5 w-3.5" />
+                      </IconOnly>
+                    ) : null}
+                    {onUseAsStdin ? (
+                      <IconOnly
+                        label={`Use test case ${i + 1} input as stdin`}
+                        testId={`stdin-test-${i}`}
+                        onClick={() => {
+                          onUseAsStdin(t.input);
+                          toast.success(`Case ${i + 1} input copied to stdin`);
+                        }}
+                      >
+                        <TerminalIcon className="h-3.5 w-3.5" />
+                      </IconOnly>
+                    ) : null}
+                    <IconOnly
+                      label={`Duplicate test case ${i + 1}`}
+                      testId={`duplicate-test-${i}`}
+                      onClick={() => duplicateTest(t.id)}
+                    >
+                      <Copy className="h-3.5 w-3.5" />
+                    </IconOnly>
+                    <IconOnly
+                      label={`Delete test case ${i + 1}`}
+                      testId={`delete-test-${i}`}
+                      onClick={() => removeTest(t.id)}
+                      tone="danger"
+                    >
+                      <Trash2 className="h-3.5 w-3.5" />
+                    </IconOnly>
+                  </span>
                 </div>
 
                 <div className="grid grid-cols-1 gap-px bg-zinc-800 sm:grid-cols-2">
@@ -196,6 +392,73 @@ export function TestsPanel({
   );
 }
 
+function ToolbarButton({
+  onClick,
+  testId,
+  label,
+  active,
+  children,
+}: {
+  onClick: () => void;
+  testId: string;
+  label: string;
+  active?: boolean;
+  children: React.ReactNode;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      data-testid={testId}
+      aria-label={label}
+      aria-pressed={active}
+      className={cn(
+        "inline-flex items-center gap-1.5 rounded-md border px-2.5 py-1.5 text-[11px] font-semibold text-zinc-200 transition",
+        active
+          ? "border-zinc-500 bg-zinc-700"
+          : "border-zinc-700 bg-zinc-800 hover:bg-zinc-700",
+      )}
+    >
+      {children}
+    </button>
+  );
+}
+
+function IconOnly({
+  label,
+  testId,
+  onClick,
+  disabled,
+  tone,
+  children,
+}: {
+  label: string;
+  testId?: string;
+  onClick: () => void;
+  disabled?: boolean;
+  tone?: "danger";
+  children: React.ReactNode;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      disabled={disabled}
+      data-testid={testId}
+      aria-label={label}
+      title={label}
+      className={cn(
+        "rounded p-1 text-zinc-500 transition disabled:opacity-40",
+        tone === "danger"
+          ? "hover:bg-red-500/10 hover:text-red-400"
+          : "hover:bg-zinc-800 hover:text-zinc-200",
+      )}
+    >
+      {children}
+    </button>
+  );
+}
+
 function RowMetrics({
   result,
   index,
@@ -209,9 +472,20 @@ function RowMetrics({
         verdict={result.verdict}
         testId={`verdict-badge-${index}`}
       />
-      <span className="font-mono text-[10px] text-zinc-500">
-        {result.timeMs} ms
-      </span>
+      {result.verdict !== "SKIPPED" ? (
+        <span className="font-mono text-[10px] text-zinc-500">
+          {formatMs(result.timeMs)} ms
+        </span>
+      ) : null}
+      {result.presentationOnly ? (
+        <span
+          className="text-[10px] text-amber-400"
+          data-testid={`presentation-hint-${index}`}
+          title="Tokens match; only whitespace differs. Switch the checker to Tokens if the judge accepts any layout."
+        >
+          whitespace only
+        </span>
+      ) : null}
     </span>
   );
 }
@@ -228,7 +502,8 @@ function RowDetail({
       {result.diff.length > 0 ? (
         <DiffView diff={result.diff} testId={`diff-view-${index}`} />
       ) : null}
-      {result.verdict !== "AC" && result.diff.length === 0 ? (
+      {(result.verdict === "AC" || result.diff.length === 0) &&
+      result.verdict !== "CE" ? (
         <div className="grid grid-cols-1 gap-2 sm:grid-cols-2">
           <Block label="Expected" value={result.expected} />
           <Block label="Actual" value={result.actual} />
@@ -237,6 +512,9 @@ function RowDetail({
       {result.stderr ? (
         <Block label="stderr" value={result.stderr} tone="error" />
       ) : null}
+      {result.truncated ? (
+        <p className="text-[10px] text-amber-400">output truncated</p>
+      ) : null}
     </div>
   );
 }
@@ -256,8 +534,15 @@ function Field({
 }) {
   return (
     <div className="bg-zinc-900/30">
-      <div className="px-3 pt-2 text-[10px] font-bold uppercase tracking-widest text-zinc-500">
-        {label}
+      <div className="flex items-baseline justify-between px-3 pt-2">
+        <span className="text-[10px] font-bold uppercase tracking-widest text-zinc-500">
+          {label}
+        </span>
+        <span className="font-mono text-[9px] text-zinc-700">
+          {value.length
+            ? `${value.split("\n").length - (value.endsWith("\n") ? 1 : 0)} ln`
+            : ""}
+        </span>
       </div>
       <textarea
         value={value}
@@ -298,7 +583,10 @@ function Block({
 }
 
 /** Split a pasted blob into input / expected on a `---` line or a blank line. */
-function splitClipboard(text: string): { input: string; expected: string } {
+export function splitClipboard(text: string): {
+  input: string;
+  expected: string;
+} {
   const normalized = text.replace(/\r\n/g, "\n");
   const sep = normalized.match(/\n[-=]{3,}\n/);
   if (sep && sep.index !== undefined) {
diff --git a/web/components/VerdictBadge.tsx b/web/components/VerdictBadge.tsx
index a029079..4aa43fa 100644
--- a/web/components/VerdictBadge.tsx
+++ b/web/components/VerdictBadge.tsx
@@ -9,7 +9,8 @@ import { cn } from "@/lib/utils";
  * carrying the raw verdict code so end-to-end tests can target it reliably.
  */
 
-export type AnyVerdict = "OK" | "AC" | "WA" | "TLE" | "RE" | "CE" | "PENDING";
+export type AnyVerdict =
+  "OK" | "AC" | "WA" | "TLE" | "RE" | "CE" | "SKIPPED" | "PENDING";
 
 const STYLES: Record<AnyVerdict, string> = {
   OK: "bg-emerald-500/15 text-emerald-400 border-emerald-500/30",
@@ -18,6 +19,7 @@ const STYLES: Record<AnyVerdict, string> = {
   TLE: "bg-amber-500/15 text-amber-400 border-amber-500/30",
   RE: "bg-orange-500/15 text-orange-400 border-orange-500/30",
   CE: "bg-fuchsia-500/15 text-fuchsia-400 border-fuchsia-500/30",
+  SKIPPED: "bg-zinc-700/30 text-zinc-500 border-zinc-600/40",
   PENDING: "bg-zinc-700/30 text-zinc-400 border-zinc-600/40",
 };
 
@@ -28,9 +30,21 @@ const LABELS: Record<AnyVerdict, string> = {
   TLE: "TLE",
   RE: "RE",
   CE: "CE",
+  SKIPPED: "SKIP",
   PENDING: "…",
 };
 
+const TITLES: Record<AnyVerdict, string> = {
+  OK: "Ran to completion with exit code 0",
+  AC: "Accepted: output matches",
+  WA: "Wrong answer: output differs",
+  TLE: "Time limit exceeded",
+  RE: "Runtime error: non-zero exit or signal",
+  CE: "Compilation error",
+  SKIPPED: "Skipped after an earlier failure",
+  PENDING: "Pending",
+};
+
 export function VerdictBadge({
   verdict,
   testId,
@@ -46,6 +60,7 @@ export function VerdictBadge({
       data-verdict={verdict}
       role="status"
       aria-label={`Verdict ${verdict}`}
+      title={TITLES[verdict]}
       className={cn(
         "inline-flex items-center justify-center rounded-md border px-2 py-0.5 text-[11px] font-bold uppercase tracking-wider",
         STYLES[verdict],
diff --git a/web/e2e/06-diagnostics.spec.ts b/web/e2e/06-diagnostics.spec.ts
new file mode 100644
index 0000000..f5d3d45
--- /dev/null
+++ b/web/e2e/06-diagnostics.spec.ts
@@ -0,0 +1,49 @@
+import { test, expect } from "@playwright/test";
+import { gotoWorkbench, setEditor } from "./helpers";
+
+/**
+ * (6) A compile error produces a CE verdict, a clickable diagnostics list
+ * with the failing line, a gutter marker on that line, and an error count in
+ * the editor toolbar. Clicking the diagnostic moves the caret to the line.
+ */
+test("surfaces compiler diagnostics with line markers", async ({ page }) => {
+  await gotoWorkbench(page);
+
+  await setEditor(
+    page,
+    "#include <bits/stdc++.h>\nint main() {\n    int x = y;\n    return 0;\n}\n",
+  );
+  await page.getByTestId("run-button").click();
+
+  await expect(page.getByTestId("run-verdict")).toHaveAttribute(
+    "data-verdict",
+    "CE",
+    { timeout: 120_000 },
+  );
+
+  const diagnostics = page.getByTestId("diagnostics-list");
+  await expect(diagnostics).toBeVisible();
+  await expect(
+    diagnostics.locator("li[data-severity='error']").first(),
+  ).toContainText(/y/);
+
+  // Line 3 carries an error marker in the gutter.
+  const gutter = page.getByTestId("code-editor-gutter");
+  await expect(gutter.locator("[data-marker='error']")).toHaveCount(1);
+  await expect(gutter.locator("[data-marker='error']")).toHaveText("3");
+
+  // gcc and clang disagree on how many errors one undeclared name produces.
+  await expect(page.getByTestId("error-count")).toContainText(/\d+ errors?/);
+
+  // Clicking the diagnostic jumps the caret to line 3.
+  await diagnostics.getByRole("button").first().click();
+  await expect(page.getByTestId("editor-status")).toContainText("Ln 3");
+
+  // Fixing the code clears the stale verdict and the markers.
+  await setEditor(
+    page,
+    "#include <bits/stdc++.h>\nint main() {\n    int y = 1, x = y;\n    return x - 1;\n}\n",
+  );
+  await expect(gutter.locator("[data-marker='error']")).toHaveCount(0);
+  await expect(page.getByTestId("run-verdict")).toHaveCount(0);
+});
diff --git a/web/e2e/07-import-statement.spec.ts b/web/e2e/07-import-statement.spec.ts
new file mode 100644
index 0000000..865bab2
--- /dev/null
+++ b/web/e2e/07-import-statement.spec.ts
@@ -0,0 +1,89 @@
+import { test, expect } from "@playwright/test";
+import { gotoWorkbench, setEditor } from "./helpers";
+
+const STATEMENT = `A. Team
+time limit per test
+2 seconds
+memory limit per test
+256 megabytes
+
+Help the friends find the number of problems for which they will write a solution.
+Input
+The first input line contains a single integer n.
+Output
+Print a single integer.
+Examples
+Input
+Copy
+
+3
+1 1 0
+1 1 1
+1 0 0
+
+Output
+Copy
+
+2
+
+Input
+Copy
+
+2
+1 0 0
+0 1 1
+
+Output
+Copy
+
+1
+
+Note
+In the first sample Petya and Vasya are sure.
+`;
+
+const TEAM_CODE = `#include <bits/stdc++.h>
+using namespace std;
+int main() {
+    int n, ans = 0; cin >> n;
+    while (n--) { int a, b, c; cin >> a >> b >> c; ans += (a + b + c) >= 2; }
+    cout << ans << "\\n";
+}
+`;
+
+/**
+ * (7) Paste a Codeforces statement into the Tests panel: every Input/Output
+ * pair becomes a test case, the time limit is applied to Settings, the title
+ * pre-fills the save name, and running all cases yields AC.
+ */
+test("imports samples and limits from a pasted statement", async ({ page }) => {
+  await gotoWorkbench(page);
+  await setEditor(page, TEAM_CODE);
+
+  await page.getByTestId("tab-tests").click();
+  await page.getByTestId("import-statement-button").click();
+  await page.getByTestId("import-statement-text").fill(STATEMENT);
+  await page.getByTestId("import-statement-submit").click();
+
+  // The default A+B case is replaced by the two parsed samples.
+  await expect(page.getByTestId("test-case-1")).toBeVisible();
+  await expect(page.getByTestId("test-case-2")).toHaveCount(0);
+  await expect(page.getByTestId("test-input-0")).toHaveValue(
+    "3\n1 1 0\n1 1 1\n1 0 0\n",
+  );
+  await expect(page.getByTestId("test-expected-1")).toHaveValue("1\n");
+
+  // The title pre-fills the save name and the time limit reaches Settings.
+  await expect(page.getByTestId("save-problem-name")).toHaveValue("A. Team");
+  await page.getByTestId("tab-settings").click();
+  await expect(page.getByTestId("settings-time-limit")).toHaveValue("2000");
+
+  await page.getByTestId("tab-tests").click();
+  await page.getByTestId("run-all-button").click();
+  await expect(page.getByTestId("tests-verdict")).toHaveAttribute(
+    "data-verdict",
+    "AC",
+    { timeout: 120_000 },
+  );
+  await expect(page.getByTestId("tests-summary")).toContainText("2/2 passed");
+});
diff --git a/web/e2e/08-checker.spec.ts b/web/e2e/08-checker.spec.ts
new file mode 100644
index 0000000..3b2e12f
--- /dev/null
+++ b/web/e2e/08-checker.spec.ts
@@ -0,0 +1,69 @@
+import { test, expect } from "@playwright/test";
+import { gotoWorkbench, setEditor } from "./helpers";
+
+const ONE_PER_LINE = `#include <bits/stdc++.h>
+int main() { std::puts("1\\n2\\n3"); }
+`;
+
+/**
+ * (8) The output checker: under the default "lines" checker an answer whose
+ * tokens match but whose layout differs is WA with a whitespace-only hint;
+ * switching Settings to the "tokens" checker makes the same case AC.
+ */
+test("tokens checker accepts a whitespace-only difference", async ({
+  page,
+}) => {
+  await gotoWorkbench(page);
+  await setEditor(page, ONE_PER_LINE);
+
+  await page.getByTestId("tab-tests").click();
+  await page.getByTestId("test-input-0").fill("x\n");
+  await page.getByTestId("test-expected-0").fill("1 2 3\n");
+
+  await page.getByTestId("run-all-button").click();
+  await expect(page.getByTestId("verdict-badge-0")).toHaveAttribute(
+    "data-verdict",
+    "WA",
+    { timeout: 120_000 },
+  );
+  await expect(page.getByTestId("presentation-hint-0")).toBeVisible();
+
+  await page.getByTestId("tab-settings").click();
+  await page.getByTestId("settings-checker").selectOption("tokens");
+  await expect(page.getByTestId("editor-status")).toContainText("tokens");
+
+  await page.getByTestId("tab-tests").click();
+  await page.getByTestId("run-all-button").click();
+  await expect(page.getByTestId("verdict-badge-0")).toHaveAttribute(
+    "data-verdict",
+    "AC",
+    { timeout: 120_000 },
+  );
+
+  // The second run reuses the cached binary.
+  await expect(page.getByTestId("tests-summary")).toBeVisible();
+});
+
+test("run-one grades a single case and disallowed flags are reported", async ({
+  page,
+}) => {
+  await gotoWorkbench(page);
+
+  await page.getByTestId("tab-settings").click();
+  await page.getByTestId("settings-flags").fill("-Wall -o /tmp/evil");
+
+  await page.getByTestId("tab-tests").click();
+  await page.getByTestId("add-test-button").click();
+  await page.getByTestId("test-input-1").fill("10 20\n");
+  await page.getByTestId("test-expected-1").fill("30\n");
+
+  await page.getByTestId("run-test-1").click();
+  await expect(page.getByTestId("verdict-badge-1")).toHaveAttribute(
+    "data-verdict",
+    "AC",
+    { timeout: 120_000 },
+  );
+  // Only the case that was run has a verdict.
+  await expect(page.getByTestId("verdict-badge-0")).toHaveCount(0);
+  await expect(page.getByTestId("rejected-flags")).toContainText("-o");
+});
diff --git a/web/e2e/09-stress-promote.spec.ts b/web/e2e/09-stress-promote.spec.ts
new file mode 100644
index 0000000..1efb68d
--- /dev/null
+++ b/web/e2e/09-stress-promote.spec.ts
@@ -0,0 +1,49 @@
+import { test, expect } from "@playwright/test";
+import { gotoWorkbench, setEditor } from "./helpers";
+
+// Off by one for large sums so the generator (0..1000) trips it quickly.
+const BUGGY = `#include <bits/stdc++.h>
+using namespace std;
+int main() { long long a, b; cin >> a >> b; cout << (a + b > 1500 ? a + b - 1 : a + b) << "\\n"; }
+`;
+
+/**
+ * (9) Stress finds a counter-example for a buggy solution and the failing
+ * input can be promoted straight into a test case (expected = brute output)
+ * and into the Run panel's stdin.
+ */
+test("stress finds a counter-example and promotes it to a test case", async ({
+  page,
+}) => {
+  await gotoWorkbench(page);
+  await setEditor(page, BUGGY);
+
+  await page.getByTestId("tab-stress").click();
+  await page.getByTestId("stress-iterations").fill("400");
+  await page.getByTestId("stress-run-button").click();
+
+  const failure = page.getByTestId("stress-failure");
+  await expect(failure).toBeVisible({ timeout: 150_000 });
+  await expect(failure).toContainText("mismatch");
+  await expect(page.getByTestId("stress-diff")).toBeVisible();
+
+  const input = (
+    await page.getByTestId("stress-failure-input").innerText()
+  ).trim();
+  expect(input).toMatch(/^\d+ \d+$/);
+
+  await page.getByTestId("stress-add-test").click();
+  await expect(page.getByTestId("tests-panel")).toBeVisible();
+  await expect(page.getByTestId("test-input-1")).toHaveValue(
+    new RegExp(`^${input}\\s*$`),
+  );
+  const expected = await page.getByTestId("test-expected-1").inputValue();
+  const [a, b] = input.split(" ").map(Number);
+  expect(Number(expected.trim())).toBe(a + b);
+
+  await page.getByTestId("tab-stress").click();
+  await page.getByTestId("stress-use-stdin").click();
+  await expect(page.getByTestId("run-stdin")).toHaveValue(
+    new RegExp(`^${input}\\s*$`),
+  );
+});
diff --git a/web/e2e/10-problems-library.spec.ts b/web/e2e/10-problems-library.spec.ts
new file mode 100644
index 0000000..d4f8d8a
--- /dev/null
+++ b/web/e2e/10-problems-library.spec.ts
@@ -0,0 +1,68 @@
+import { test, expect } from "@playwright/test";
+import { gotoWorkbench, setEditor, setStdin } from "./helpers";
+
+const CODE = `#include <bits/stdc++.h>
+int main() { int n; std::cin >> n; std::cout << n * n << "\\n"; }
+`;
+
+/**
+ * (10) The problems library persists the whole workspace: source, tests,
+ * stdin and settings. Saving, resetting to a new workspace and loading again
+ * restores everything; the dirty indicator tracks unsaved edits; rename,
+ * duplicate and delete round-trip through /api/problems.
+ */
+test("saves, reloads, duplicates and deletes a whole workspace", async ({
+  page,
+}) => {
+  const name = `e2e-lib-${Date.now()}`;
+  await gotoWorkbench(page);
+
+  await setEditor(page, CODE);
+  await setStdin(page, "7\n");
+  await page.getByTestId("tab-tests").click();
+  await page.getByTestId("test-input-0").fill("4\n");
+  await page.getByTestId("test-expected-0").fill("16\n");
+  await page.getByTestId("tab-settings").click();
+  await page.getByTestId("settings-std").selectOption("gnu++20");
+
+  await page.getByTestId("save-problem-name").fill(name);
+  await page.getByTestId("save-problem-button").click();
+  await expect(page.getByTestId("active-problem")).toContainText(name);
+  await expect(page.getByTestId("dirty-indicator")).toHaveCount(0);
+
+  // Editing marks the workspace dirty; saving clears it.
+  await page.getByTestId("tab-run").click();
+  await setStdin(page, "8\n");
+  await expect(page.getByTestId("dirty-indicator")).toBeVisible();
+  await page.getByTestId("save-problem-button").click();
+  await expect(page.getByTestId("dirty-indicator")).toHaveCount(0);
+
+  // New workspace resets everything, loading brings it all back.
+  page.once("dialog", (d) => d.accept());
+  await page.getByTestId("new-workspace-button").click();
+  await expect(page.getByTestId("active-problem")).toHaveCount(0);
+  await expect(page.getByTestId("run-stdin")).toHaveValue("2 3\n");
+
+  await page.getByTestId(`load-problem-${name}`).click();
+  await expect(page.getByTestId("active-problem")).toContainText(name);
+  await expect(page.getByTestId("code-editor")).toHaveValue(/n \* n/);
+  await expect(page.getByTestId("run-stdin")).toHaveValue("8\n");
+  await page.getByTestId("tab-tests").click();
+  await expect(page.getByTestId("test-expected-0")).toHaveValue("16\n");
+  await page.getByTestId("tab-settings").click();
+  await expect(page.getByTestId("settings-std")).toHaveValue("gnu++20");
+
+  // Duplicate, then delete both.
+  const item = page.getByTestId(`problem-item-${name}`);
+  await item.hover();
+  await page.getByTestId(`duplicate-problem-${name}`).click();
+  await page.getByTestId(`confirm-name-${name}`).click();
+  await expect(page.getByTestId(`problem-item-${name}-copy`)).toBeVisible();
+
+  for (const slug of [`${name}-copy`, name]) {
+    await page.getByTestId(`problem-item-${slug}`).hover();
+    await page.getByTestId(`delete-problem-${slug}`).click();
+    await page.getByTestId(`confirm-delete-${slug}`).click();
+    await expect(page.getByTestId(`problem-item-${slug}`)).toHaveCount(0);
+  }
+});
diff --git a/web/lib/api.ts b/web/lib/api.ts
index f15cccd..90d18b0 100644
--- a/web/lib/api.ts
+++ b/web/lib/api.ts
@@ -2,12 +2,14 @@
  * Typed client for the cf workbench HTTP API.
  *
  * Every type here mirrors the JSON contract documented at the top of the
- * matching route file under web/app/api/** (owned by the engine task). The UI
- * consumes these shapes directly — keep them in sync with the route comments.
+ * matching route file under web/app/api/**. The UI consumes these shapes
+ * directly — keep them in sync with the route comments.
  */
 
 // ---- Shared ----
 
+export type CheckerMode = "lines" | "tokens" | "float";
+
 export type RunSettings = {
   /** C++ standard without the leading -std=, e.g. "gnu++17". */
   std: string;
@@ -15,14 +17,34 @@ export type RunSettings = {
   timeLimitMs: number;
   /** Extra flags appended to the compile command. */
   compilerFlags: string[];
+  /** Output comparison mode used by Tests and Stress. */
+  checker: CheckerMode;
+  /** Tolerance for the float checker. */
+  epsilon: number;
+};
+
+export type Diagnostic = {
+  severity: "error" | "warning" | "note";
+  line: number | null;
+  column: number | null;
+  message: string;
 };
 
-export type CompileStatus = { ok: boolean; stderr: string; ms: number };
+export type RejectedFlag = { flag: string; reason: string };
+
+export type CompileStatus = {
+  ok: boolean;
+  stderr: string;
+  ms: number;
+  cached?: boolean;
+  diagnostics?: Diagnostic[];
+  rejectedFlags?: RejectedFlag[];
+};
 
 export type DiffLine = {
   line: number;
-  expected: string;
-  actual: string;
+  expected: string | null;
+  actual: string | null;
   same: boolean;
 };
 
@@ -46,7 +68,7 @@ export type RunResponse = {
 
 // ---- /api/test ----
 
-export type TestVerdict = "AC" | "WA" | "TLE" | "RE" | "CE";
+export type TestVerdict = "AC" | "WA" | "TLE" | "RE" | "CE" | "SKIPPED";
 
 export type TestCaseResult = {
   index: number;
@@ -59,6 +81,7 @@ export type TestCaseResult = {
   signal: string | null;
   timeMs: number;
   truncated: boolean;
+  presentationOnly?: boolean;
   diff: DiffLine[];
 };
 
@@ -66,11 +89,15 @@ export type TestResponse = {
   ok: boolean;
   compiler: string | null;
   compile: CompileStatus;
+  checker?: CheckerMode;
   summary: {
     total: number;
     passed: number;
     failed: number;
+    skipped?: number;
     verdict: TestVerdict;
+    maxTimeMs?: number;
+    totalTimeMs?: number;
   };
   results: TestCaseResult[];
 };
@@ -102,6 +129,9 @@ export type StressResponse = {
   ok: boolean;
   failed: boolean;
   iterationsRun: number;
+  elapsedMs?: number;
+  deadlineHit?: boolean;
+  stats?: { maxSolutionMs: number; maxBruteMs: number; avgSolutionMs: number };
   compile: {
     solution: CompileStatus;
     brute: CompileStatus;
@@ -115,12 +145,18 @@ export type StressResponse = {
 
 export type TestCase = { input: string; expected: string };
 
+export type ProblemSettings = Partial<RunSettings>;
+
 export type Problem = {
   name: string;
   slug: string;
   code: string;
   statement: string;
   tests: TestCase[];
+  stdin: string;
+  brute: string;
+  generator: string;
+  settings: ProblemSettings | null;
   createdAt: number;
   updatedAt: number;
 };
@@ -132,6 +168,46 @@ export type ProblemSummary = {
   updatedAt: number;
 };
 
+export type ProblemBundle = {
+  version: number;
+  exportedAt: string;
+  problems: Problem[];
+};
+
+// ---- /api/samples ----
+
+export type ParsedStatement = {
+  title: string | null;
+  timeLimitMs: number | null;
+  memoryLimitMb: number | null;
+  tests: TestCase[];
+};
+
+// ---- /api/config ----
+
+export type WorkbenchConfig = {
+  version: string;
+  platform: string;
+  compiler: string | null;
+  compilerVersion: string | null;
+  includeDir: string;
+  defaults: {
+    std: string;
+    timeLimitMs: number;
+    maxTimeLimitMs: number;
+    checker: CheckerMode;
+  };
+  limits: {
+    maxSourceBytes: number;
+    maxInputBytes: number;
+    maxOutputBytes: number;
+    compileTimeoutMs: number;
+  };
+  cache: { entries: number };
+  startProblem: string | null;
+  problemsDir: string | null;
+};
+
 /** Thrown when a request reaches the server but it answers with an error body. */
 export class ApiError extends Error {
   status: number;
@@ -142,12 +218,13 @@ export class ApiError extends Error {
   }
 }
 
-async function postJson<T>(url: string, body: unknown): Promise<T> {
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-  });
+async function request<T>(url: string, init?: RequestInit): Promise<T> {
+  let res: Response;
+  try {
+    res = await fetch(url, init);
+  } catch {
+    throw new ApiError("Could not reach the workbench server", 0);
+  }
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
     const message =
@@ -159,17 +236,22 @@ async function postJson<T>(url: string, body: unknown): Promise<T> {
   return data as T;
 }
 
-async function getJson<T>(url: string): Promise<T> {
-  const res = await fetch(url);
-  const data = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    const message =
-      data && typeof data.error === "string"
-        ? data.error
-        : `Request failed (${res.status})`;
-    throw new ApiError(message, res.status);
-  }
-  return data as T;
+function postJson<T>(url: string, body: unknown): Promise<T> {
+  return request<T>(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+function settingsBody(settings: RunSettings) {
+  return {
+    timeLimitMs: settings.timeLimitMs,
+    std: settings.std,
+    compilerFlags: settings.compilerFlags,
+    checker: settings.checker,
+    epsilon: settings.epsilon,
+  };
 }
 
 // ---- Operations ----
@@ -182,9 +264,7 @@ export function runCode(
   return postJson<RunResponse>("/api/run", {
     code,
     input,
-    timeLimitMs: settings.timeLimitMs,
-    std: settings.std,
-    compilerFlags: settings.compilerFlags,
+    ...settingsBody(settings),
   });
 }
 
@@ -192,13 +272,13 @@ export function runTests(
   code: string,
   tests: TestCase[],
   settings: RunSettings,
+  options: { stopOnFirstFailure?: boolean } = {},
 ): Promise<TestResponse> {
   return postJson<TestResponse>("/api/test", {
     code,
     tests,
-    timeLimitMs: settings.timeLimitMs,
-    std: settings.std,
-    compilerFlags: settings.compilerFlags,
+    ...settingsBody(settings),
+    stopOnFirstFailure: !!options.stopOnFirstFailure,
   });
 }
 
@@ -208,26 +288,39 @@ export function runStress(
     brute: string;
     generator: string;
     iterations: number;
+    seedBase?: number;
   },
   settings: RunSettings,
 ): Promise<StressResponse> {
   return postJson<StressResponse>("/api/stress", {
-    solution: args.solution,
-    brute: args.brute,
-    generator: args.generator,
-    iterations: args.iterations,
-    timeLimitMs: settings.timeLimitMs,
-    std: settings.std,
+    ...args,
+    ...settingsBody(settings),
   });
 }
 
+export function parseSamples(statement: string): Promise<ParsedStatement> {
+  return postJson<ParsedStatement>("/api/samples", { statement });
+}
+
+export function getConfig(): Promise<WorkbenchConfig> {
+  return request<WorkbenchConfig>("/api/config");
+}
+
+export async function clearServerCache(): Promise<number> {
+  const data = await request<{ ok: boolean; cleared: number }>(
+    "/api/config?cache=1",
+    { method: "DELETE" },
+  );
+  return data.cleared;
+}
+
 export async function listProblems(): Promise<ProblemSummary[]> {
-  const data = await getJson<{ problems: ProblemSummary[] }>("/api/problems");
+  const data = await request<{ problems: ProblemSummary[] }>("/api/problems");
   return Array.isArray(data.problems) ? data.problems : [];
 }
 
 export async function getProblem(slug: string): Promise<Problem> {
-  const data = await getJson<{ problem: Problem }>(
+  const data = await request<{ problem: Problem }>(
     `/api/problems?name=${encodeURIComponent(slug)}`,
   );
   return data.problem;
@@ -238,6 +331,10 @@ export async function saveProblem(input: {
   code?: string;
   statement?: string;
   tests?: TestCase[];
+  stdin?: string;
+  brute?: string;
+  generator?: string;
+  settings?: ProblemSettings | null;
 }): Promise<Problem> {
   const data = await postJson<{ ok: boolean; problem: Problem }>(
     "/api/problems",
@@ -257,20 +354,37 @@ export async function renameProblem(
   return data.problem;
 }
 
+export async function duplicateProblem(
+  from: string,
+  to: string,
+): Promise<Problem> {
+  const data = await postJson<{ ok: boolean; problem: Problem }>(
+    "/api/problems",
+    { op: "duplicate", from, to },
+  );
+  return data.problem;
+}
+
 export async function deleteProblem(slug: string): Promise<boolean> {
-  const res = await fetch(`/api/problems?name=${encodeURIComponent(slug)}`, {
-    method: "DELETE",
-  });
-  const data = (await res.json().catch(() => ({}))) as {
-    ok?: boolean;
-    deleted?: boolean;
-    error?: string;
-  };
-  if (!res.ok) {
-    throw new ApiError(
-      data.error ?? `Request failed (${res.status})`,
-      res.status,
-    );
-  }
+  const data = await request<{ ok?: boolean; deleted?: boolean }>(
+    `/api/problems?name=${encodeURIComponent(slug)}`,
+    { method: "DELETE" },
+  );
   return !!data.deleted;
 }
+
+export function exportProblems(): Promise<ProblemBundle> {
+  return request<ProblemBundle>("/api/problems?export=1");
+}
+
+export async function importProblems(
+  problems: unknown,
+  overwrite: boolean,
+): Promise<{ imported: number; skipped: number }> {
+  const data = await postJson<{
+    ok: boolean;
+    imported: number;
+    skipped: number;
+  }>("/api/problems", { op: "import", problems, overwrite });
+  return { imported: data.imported, skipped: data.skipped };
+}
diff --git a/web/lib/cf.ts b/web/lib/cf.ts
deleted file mode 100644
index be88010..0000000
--- a/web/lib/cf.ts
+++ /dev/null
@@ -1,208 +0,0 @@
-import { spawn } from "child_process";
-import path from "path";
-import fs from "fs/promises";
-
-const REPO_ROOT = path.resolve(process.cwd(), "..");
-const CF_SCRIPT = path.join(REPO_ROOT, "scripts", "cf");
-
-export function getProblemsDir() {
-  return process.env.CF_PROBLEMS_DIR || path.join(REPO_ROOT, "src");
-}
-
-export type ParsedResult = {
-  verdict: "Accepted" | "Wrong Answer" | "Runtime Error" | "Internal Error";
-  passedCount: number;
-  totalCount: number;
-  runtime?: number;
-  memory?: string;
-  timestamp: string;
-  samples: Array<{
-    id: number;
-    passed: boolean;
-    input?: string;
-    expected?: string;
-    actual?: string;
-  }>;
-};
-
-export function parseCfOutput(
-  stdout: string,
-  stderr: string,
-  exitCode: number,
-): ParsedResult {
-  const result: ParsedResult = {
-    verdict: exitCode === 0 ? "Accepted" : "Wrong Answer",
-    passedCount: 0,
-    totalCount: 0,
-    samples: [],
-    timestamp: new Date().toLocaleTimeString(),
-  };
-
-  // Strip ANSI escape codes and combine
-  const combined = (stdout + "\n" + stderr).replace(
-    /\x1B\[[0-9;]*[JKmsu]/g,
-    "",
-  );
-
-  // Parse resource usage (taking max over all runs)
-  const usageMatches = Array.from(
-    combined.matchAll(/RESOURCE_USAGE:\s*([\d.]+)\s*(\d+)/g),
-  );
-  let maxRuntime = 0;
-  let maxMemory = 0;
-  let hasUsage = false;
-  for (const m of usageMatches) {
-    hasUsage = true;
-    maxRuntime = Math.max(maxRuntime, Math.round(parseFloat(m[1]) * 1000));
-    maxMemory = Math.max(maxMemory, parseInt(m[2]));
-  }
-  if (hasUsage) {
-    result.runtime = maxRuntime;
-    result.memory = (maxMemory / 1024).toFixed(1);
-  }
-
-  // Parse total counts: Total: 3 | Passed: 3 | Failed: 0
-  const summaryMatch = combined.match(
-    /Total:\s*(\d+)\s*\|\s*Passed:\s*(\d+)\s*\|\s*Failed:\s*(\d+)/,
-  );
-  if (summaryMatch) {
-    result.totalCount = parseInt(summaryMatch[1]);
-    result.passedCount = parseInt(summaryMatch[2]);
-    if (result.passedCount < result.totalCount) {
-      result.verdict = "Wrong Answer";
-    }
-  }
-
-  // Parse individual samples
-  const sampleRegex = /Sample #(\d+): (PASSED|FAILED)/g;
-  let match;
-  while ((match = sampleRegex.exec(combined)) !== null) {
-    result.samples.push({
-      id: parseInt(match[1]),
-      passed: match[2] === "PASSED",
-    });
-  }
-
-  // If we only have 1 sample (e.g. from run command)
-  if (result.totalCount === 0 && result.samples.length === 0) {
-    const singlePassed = combined.includes("Output matches expected.");
-    const singleFailed = combined.includes("Output does not match expected.");
-    if (singlePassed || singleFailed) {
-      result.totalCount = 1;
-      result.passedCount = singlePassed ? 1 : 0;
-      result.verdict = singlePassed ? "Accepted" : "Wrong Answer";
-      result.samples.push({ id: 1, passed: singlePassed });
-    }
-  }
-
-  if (stderr && exitCode !== 0 && !summaryMatch) {
-    result.verdict = "Runtime Error";
-  }
-
-  return result;
-}
-
-export async function runCfCommand(
-  args: string[],
-  options: { cwd?: string; input?: string } = {},
-): Promise<{
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  parsed?: ParsedResult;
-}> {
-  return new Promise((resolve) => {
-    const child = spawn(CF_SCRIPT, args, {
-      cwd: options.cwd || REPO_ROOT,
-      env: { ...process.env, CF_REPO_ROOT: REPO_ROOT, CF_NONINTERACTIVE: "1" },
-    });
-
-    if (options.input) {
-      child.stdin.write(options.input);
-      child.stdin.end();
-    }
-
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    child.on("close", (code) => {
-      const exitCode = code ?? 0;
-      const parsed = parseCfOutput(stdout, stderr, exitCode);
-      resolve({ stdout, stderr, exitCode, parsed });
-    });
-  });
-}
-
-export async function listProblems() {
-  const problemsDir = getProblemsDir();
-  try {
-    const entries = await fs.readdir(problemsDir, { withFileTypes: true });
-    return entries
-      .filter((e) => e.isDirectory())
-      .map((e) => e.name)
-      .filter(
-        (name) =>
-          !name.startsWith(".") &&
-          name !== "include" &&
-          name !== "build" &&
-          name !== "web",
-      );
-  } catch {
-    return [];
-  }
-}
-
-export async function saveSolution(problem: string, code: string) {
-  const problemDir = path.join(getProblemsDir(), problem);
-  if (!(await fs.stat(problemDir).catch(() => null))) {
-    await fs.mkdir(problemDir, { recursive: true });
-  }
-  const solutionFile = path.join(problemDir, "solution.cpp");
-
-  // Only write if content changed to prevent unnecessary overrides and preserve timestamps
-  const current = await fs.readFile(solutionFile, "utf-8").catch(() => null);
-  if (current === code) return;
-
-  await fs.writeFile(solutionFile, code);
-}
-
-export async function getSolution(problem: string) {
-  const solutionFile = path.join(getProblemsDir(), problem, "solution.cpp");
-  try {
-    return await fs.readFile(solutionFile, "utf-8");
-  } catch {
-    return "";
-  }
-}
-
-export async function saveProblemText(problem: string, text: string) {
-  const problemsDir = getProblemsDir();
-  const problemDir = path.join(problemsDir, problem);
-  if (!(await fs.stat(problemDir).catch(() => null))) {
-    await fs.mkdir(problemDir, { recursive: true });
-  }
-  const problemFile = path.join(problemDir, "problem.txt");
-
-  // Only write if content changed
-  const current = await fs.readFile(problemFile, "utf-8").catch(() => null);
-  if (current === text) return;
-
-  await fs.writeFile(problemFile, text);
-}
-
-export async function getProblemText(problem: string) {
-  const problemFile = path.join(getProblemsDir(), problem, "problem.txt");
-  try {
-    return await fs.readFile(problemFile, "utf-8");
-  } catch {
-    return "";
-  }
-}
diff --git a/web/lib/storage.ts b/web/lib/storage.ts
index 87113d8..76dae98 100644
--- a/web/lib/storage.ts
+++ b/web/lib/storage.ts
@@ -1,24 +1,29 @@
 /**
  * localStorage keys and defaults for workbench state that should survive a
- * reload (editor contents, settings, sample tests, stress sources). All access
- * is guarded so it is safe to import during server rendering.
+ * reload (editor contents, settings, sample tests, stress sources, layout).
+ * All access is guarded so it is safe to import during server rendering.
  */
 
-import type { RunSettings, TestCase } from "./api";
+import type { CheckerMode, RunSettings, TestCase } from "./api";
 
 export const STORAGE_KEYS = {
   code: "cf:code",
   settings: "cf:settings",
   tests: "cf:tests",
   stress: "cf:stress",
+  stdin: "cf:stdin",
   activeProblem: "cf:activeProblem",
   fontSize: "cf:fontSize",
+  layout: "cf:layout",
+  activeTab: "cf:activeTab",
 } as const;
 
 export const DEFAULT_SETTINGS: RunSettings = {
   std: "gnu++17",
   timeLimitMs: 5000,
   compilerFlags: [],
+  checker: "lines",
+  epsilon: 1e-6,
 };
 
 export const STD_OPTIONS = [
@@ -27,14 +32,46 @@ export const STD_OPTIONS = [
   "gnu++23",
   "c++17",
   "c++20",
+  "c++23",
 ] as const;
 
+export const CHECKER_OPTIONS: {
+  id: CheckerMode;
+  label: string;
+  hint: string;
+}[] = [
+  {
+    id: "lines",
+    label: "Lines",
+    hint: "Exact lines; trailing whitespace ignored.",
+  },
+  {
+    id: "tokens",
+    label: "Tokens",
+    hint: "Whitespace-insensitive token compare (Codeforces wcmp).",
+  },
+  {
+    id: "float",
+    label: "Float",
+    hint: "Tokens, numbers within an absolute/relative epsilon.",
+  },
+];
+
 export const DEFAULT_FONT_SIZE = 14;
 export const MIN_FONT_SIZE = 10;
 export const MAX_FONT_SIZE = 24;
 
+export const MIN_TIME_LIMIT_MS = 100;
+export const MAX_TIME_LIMIT_MS = 60000;
+
+export const DEFAULT_STDIN = "2 3\n";
 export const DEFAULT_TESTS: TestCase[] = [{ input: "2 3\n", expected: "5\n" }];
 
+/** Editor / bottom-panel split as a fraction of the main column height. */
+export const DEFAULT_LAYOUT = { panelFraction: 0.44 };
+export const MIN_PANEL_FRACTION = 0.15;
+export const MAX_PANEL_FRACTION = 0.85;
+
 /** A sample test case carrying a stable id for React keys / row identity. */
 export type SampleTest = { id: number; input: string; expected: string };
 
@@ -82,6 +119,13 @@ export function saveString(key: string, value: string): void {
   }
 }
 
+export function clampTimeLimit(n: number): number {
+  return Math.min(
+    MAX_TIME_LIMIT_MS,
+    Math.max(MIN_TIME_LIMIT_MS, Math.floor(n)),
+  );
+}
+
 /** Coerce a possibly-partial persisted settings object into a valid one. */
 export function normalizeSettings(value: unknown): RunSettings {
   if (!value || typeof value !== "object") return { ...DEFAULT_SETTINGS };
@@ -90,12 +134,22 @@ export function normalizeSettings(value: unknown): RunSettings {
     typeof v.std === "string" && v.std.trim() ? v.std : DEFAULT_SETTINGS.std;
   const timeLimitMs =
     typeof v.timeLimitMs === "number" && Number.isFinite(v.timeLimitMs)
-      ? Math.min(60000, Math.max(100, Math.floor(v.timeLimitMs)))
+      ? clampTimeLimit(v.timeLimitMs)
       : DEFAULT_SETTINGS.timeLimitMs;
   const compilerFlags = Array.isArray(v.compilerFlags)
     ? v.compilerFlags.filter((f): f is string => typeof f === "string")
     : DEFAULT_SETTINGS.compilerFlags;
-  return { std, timeLimitMs, compilerFlags };
+  const checker: CheckerMode =
+    v.checker === "tokens" || v.checker === "float" || v.checker === "lines"
+      ? v.checker
+      : DEFAULT_SETTINGS.checker;
+  const epsilon =
+    typeof v.epsilon === "number" &&
+    Number.isFinite(v.epsilon) &&
+    v.epsilon >= 0
+      ? Math.min(1, v.epsilon)
+      : DEFAULT_SETTINGS.epsilon;
+  return { std, timeLimitMs, compilerFlags, checker, epsilon };
 }
 
 /** Parse a whitespace-separated flags string into an argv array. */
@@ -105,3 +159,31 @@ export function parseFlags(raw: string): string[] {
     .map((s) => s.trim())
     .filter(Boolean);
 }
+
+/** Coerce a persisted layout object. */
+export function normalizeLayout(value: unknown): { panelFraction: number } {
+  if (!value || typeof value !== "object") return { ...DEFAULT_LAYOUT };
+  const v = value as Record<string, unknown>;
+  const f =
+    typeof v.panelFraction === "number" && Number.isFinite(v.panelFraction)
+      ? Math.min(
+          MAX_PANEL_FRACTION,
+          Math.max(MIN_PANEL_FRACTION, v.panelFraction),
+        )
+      : DEFAULT_LAYOUT.panelFraction;
+  return { panelFraction: f };
+}
+
+/** Human-friendly "3 min ago" for the problems list. */
+export function relativeTime(ts: number, now = Date.now()): string {
+  if (!ts) return "";
+  const s = Math.max(0, Math.round((now - ts) / 1000));
+  if (s < 45) return "just now";
+  const m = Math.round(s / 60);
+  if (m < 60) return `${m} min ago`;
+  const h = Math.round(m / 60);
+  if (h < 24) return `${h} h ago`;
+  const d = Math.round(h / 24);
+  if (d < 30) return `${d} d ago`;
+  return new Date(ts).toLocaleDateString();
+}
diff --git a/web/public/file.svg b/web/public/file.svg
deleted file mode 100644
index 004145c..0000000
--- a/web/public/file.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg fill="none" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M14.5 13.5V5.41a1 1 0 0 0-.3-.7L9.8.29A1 1 0 0 0 9.08 0H1.5v13.5A2.5 2.5 0 0 0 4 16h8a2.5 2.5 0 0 0 2.5-2.5m-1.5 0v-7H8v-5H3v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1M9.5 5V2.12L12.38 5zM5.13 5h-.62v1.25h2.12V5zm-.62 3h7.12v1.25H4.5zm.62 3h-.62v1.25h7.12V11z" clip-rule="evenodd" fill="#666" fill-rule="evenodd"/></svg>
\ No newline at end of file
diff --git a/web/public/globe.svg b/web/public/globe.svg
deleted file mode 100644
index 567f17b..0000000
--- a/web/public/globe.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g clip-path="url(#a)"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.27 14.1a6.5 6.5 0 0 0 3.67-3.45q-1.24.21-2.7.34-.31 1.83-.97 3.1M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16m.48-1.52a7 7 0 0 1-.96 0H7.5a4 4 0 0 1-.84-1.32q-.38-.89-.63-2.08a40 40 0 0 0 3.92 0q-.25 1.2-.63 2.08a4 4 0 0 1-.84 1.31zm2.94-4.76q1.66-.15 2.95-.43a7 7 0 0 0 0-2.58q-1.3-.27-2.95-.43a18 18 0 0 1 0 3.44m-1.27-3.54a17 17 0 0 1 0 3.64 39 39 0 0 1-4.3 0 17 17 0 0 1 0-3.64 39 39 0 0 1 4.3 0m1.1-1.17q1.45.13 2.69.34a6.5 6.5 0 0 0-3.67-3.44q.65 1.26.98 3.1M8.48 1.5l.01.02q.41.37.84 1.31.38.89.63 2.08a40 40 0 0 0-3.92 0q.25-1.2.63-2.08a4 4 0 0 1 .85-1.32 7 7 0 0 1 .96 0m-2.75.4a6.5 6.5 0 0 0-3.67 3.44 29 29 0 0 1 2.7-.34q.31-1.83.97-3.1M4.58 6.28q-1.66.16-2.95.43a7 7 0 0 0 0 2.58q1.3.27 2.95.43a18 18 0 0 1 0-3.44m.17 4.71q-1.45-.12-2.69-.34a6.5 6.5 0 0 0 3.67 3.44q-.65-1.27-.98-3.1" fill="#666"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h16v16H0z"/></clipPath></defs></svg>
\ No newline at end of file
diff --git a/web/public/next.svg b/web/public/next.svg
deleted file mode 100644
index 5174b28..0000000
--- a/web/public/next.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 394 80"><path fill="#000" d="M262 0h68.5v12.7h-27.2v66.6h-13.6V12.7H262V0ZM149 0v12.7H94v20.4h44.3v12.6H94v21h55v12.6H80.5V0h68.7zm34.3 0h-17.8l63.8 79.4h17.9l-32-39.7 32-39.6h-17.9l-23 28.6-23-28.6zm18.3 56.7-9-11-27.1 33.7h17.8l18.3-22.7z"/><path fill="#000" d="M81 79.3 17 0H0v79.3h13.6V17l50.2 62.3H81Zm252.6-.4c-1 0-1.8-.4-2.5-1s-1.1-1.6-1.1-2.6.3-1.8 1-2.5 1.6-1 2.6-1 1.8.3 2.5 1a3.4 3.4 0 0 1 .6 4.3 3.7 3.7 0 0 1-3 1.8zm23.2-33.5h6v23.3c0 2.1-.4 4-1.3 5.5a9.1 9.1 0 0 1-3.8 3.5c-1.6.8-3.5 1.3-5.7 1.3-2 0-3.7-.4-5.3-1s-2.8-1.8-3.7-3.2c-.9-1.3-1.4-3-1.4-5h6c.1.8.3 1.6.7 2.2s1 1.2 1.6 1.5c.7.4 1.5.5 2.4.5 1 0 1.8-.2 2.4-.6a4 4 0 0 0 1.6-1.8c.3-.8.5-1.8.5-3V45.5zm30.9 9.1a4.4 4.4 0 0 0-2-3.3 7.5 7.5 0 0 0-4.3-1.1c-1.3 0-2.4.2-3.3.5-.9.4-1.6 1-2 1.6a3.5 3.5 0 0 0-.3 4c.3.5.7.9 1.3 1.2l1.8 1 2 .5 3.2.8c1.3.3 2.5.7 3.7 1.2a13 13 0 0 1 3.2 1.8 8.1 8.1 0 0 1 3 6.5c0 2-.5 3.7-1.5 5.1a10 10 0 0 1-4.4 3.5c-1.8.8-4.1 1.2-6.8 1.2-2.6 0-4.9-.4-6.8-1.2-2-.8-3.4-2-4.5-3.5a10 10 0 0 1-1.7-5.6h6a5 5 0 0 0 3.5 4.6c1 .4 2.2.6 3.4.6 1.3 0 2.5-.2 3.5-.6 1-.4 1.8-1 2.4-1.7a4 4 0 0 0 .8-2.4c0-.9-.2-1.6-.7-2.2a11 11 0 0 0-2.1-1.4l-3.2-1-3.8-1c-2.8-.7-5-1.7-6.6-3.2a7.2 7.2 0 0 1-2.4-5.7 8 8 0 0 1 1.7-5 10 10 0 0 1 4.3-3.5c2-.8 4-1.2 6.4-1.2 2.3 0 4.4.4 6.2 1.2 1.8.8 3.2 2 4.3 3.4 1 1.4 1.5 3 1.5 5h-5.8z"/></svg>
\ No newline at end of file
diff --git a/web/public/vercel.svg b/web/public/vercel.svg
deleted file mode 100644
index 7705396..0000000
--- a/web/public/vercel.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1155 1000"><path d="m577.3 0 577.4 1000H0z" fill="#fff"/></svg>
\ No newline at end of file
diff --git a/web/public/window.svg b/web/public/window.svg
deleted file mode 100644
index b2b2a44..0000000
--- a/web/public/window.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 2.5h13v10a1 1 0 0 1-1 1h-11a1 1 0 0 1-1-1zM0 1h16v11.5a2.5 2.5 0 0 1-2.5 2.5h-11A2.5 2.5 0 0 1 0 12.5zm3.75 4.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5M7 4.75a.75.75 0 1 1-1.5 0 .75.75 0 0 1 1.5 0m1.75.75a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5" fill="#666"/></svg>
\ No newline at end of file

From 5cc984dca5ca76c438abda0db6ac0105adb130d0 Mon Sep 17 00:00:00 2001
From: mbn <66748817+mbn-code@users.noreply.github.com>
Date: Tue, 15 Sep 2026 20:57:47 +0200
Subject: [PATCH 3/7] feat(cli): stress, samples, watch, doctor, clean,
 checkers and timing

- new commands: stress (solution vs brute.cpp on gen.cpp inputs, saves the
  first counter-example), samples, watch, doctor, clean, version; `new` as
  an alias for template
- template --from dp|graph|math|<file>
- --checker lines|tokens (or CF_CHECKER) on run/test/stress with a hint when
  only whitespace differs; --timeout; per-sample and max timing in cf test
- explicit problem argument wins over the cwd in cf test; brute/gen sources
  are excluded from the solution build; CF_CXX/CXX, NO_COLOR, CF_NO_EDITOR,
  CF_SERVE_PROD; cf update pulls --ff-only
- tests/cli_test.sh: 57 end-to-end checks against the real compiler,
  replacing tests/parser_test.sh and test_full.sh
- scripts/test.sh: report the real exit status (was the negated `if !`
  result), delegate to the CLI suite, shellcheck clean
---
 scripts/cf           | 959 +++++++++++++++++++++++++++++++------------
 scripts/test.sh      |  45 +-
 test_full.sh         |  79 ----
 tests/cli_test.sh    | 275 +++++++++++++
 tests/parser_test.sh |  39 --
 5 files changed, 996 insertions(+), 401 deletions(-)
 delete mode 100755 test_full.sh
 create mode 100644 tests/cli_test.sh
 delete mode 100755 tests/parser_test.sh

diff --git a/scripts/cf b/scripts/cf
index 01b1a48..db5ccf0 100755
--- a/scripts/cf
+++ b/scripts/cf
@@ -1,44 +1,48 @@
 #!/usr/bin/env bash
 
 ################################################################################
-# cf - Production-grade Codeforces CLI Tool
+# cf - Codeforces CLI Tool
 #
-# Main command-line interface for C++ competitive programming
+# Main command-line interface for C++ competitive programming.
 #
 # Usage:
-#   cf template <name>         - Create new problem template
-#   cf <name> [input]          - Compile and run solution
-#   cf test                    - Run all tests with timeout protection
-#   cf serve [problem]         - Start web interface
+#   cf template <name> [--from T]  - Create a new problem directory
+#   cf <name|file> [input]         - Compile and run a solution
+#   cf test [name]                 - Run every sample in problem.txt
+#   cf stress [name] [-n N]        - Solution vs brute force on generated input
+#   cf samples [name]              - Print the parsed samples
+#   cf watch [name]                - Re-run the samples whenever a file changes
+#   cf serve [name]                - Start the web workbench
+#   cf doctor                      - Check the toolchain
+#   cf clean                       - Drop the build cache
+#   cf update                      - Pull the latest version
 #
 # Examples:
-#   cf template 1000A          - Create src/1000A/ with solution.cpp
-#   cf 1000A input.txt         - Compile and run with input.txt
-#   cf 1000A "5\n1 2 3 4 5"    - Compile and run with inline input
-#   cf test                    - Run all tests with timeout protection
-#   cf serve                   - Start web interface
-#   cf serve 1000A             - Create (if needed) and serve problem 1000A
+#   cf template 1000A              - Create ./1000A with solution.cpp + problem.txt
+#   cf 1000A                       - Run src/1000A (or ./1000A) against sample #1
+#   cf 1000A "5\n1 2 3 4 5"        - Run with inline stdin
+#   cf problem.txt --sample 2      - Run sample #2 of problem.txt
+#   cf test --checker tokens       - Compare whitespace-insensitively
+#   cf stress -n 500               - Run 500 iterations of brute.cpp vs solution
 #
 # Features:
-#   - Auto-detects .cpp files
-#   - Handles multi-file compilation
-#   - Timeout protection (prevents infinite loops)
-#   - Input validation and error checking
-#   - Cross-platform (Linux/macOS/WSL)
-#   - Idempotent and robust
-#   - Production-grade error handling
+#   - Auto-detects .cpp files and problem.txt in the working directory
+#   - Timeout protection, per-sample timing, build cache
+#   - Line and token output checkers
+#   - Cross-platform (Linux / macOS / WSL / Git Bash)
 #
 ################################################################################
 
 set -euo pipefail
 
+CF_VERSION="1.0.0"
+
 # ==================== CONFIGURATION ====================
 
 # Determine repository root (handle symlinks)
 if [ -f "${BASH_SOURCE[0]}" ]; then
     SCRIPT_PATH="${BASH_SOURCE[0]}"
-    if command -v readlink &> /dev/null;
-        then
+    if command -v readlink &> /dev/null; then
         SCRIPT_PATH="$(readlink -f "$SCRIPT_PATH" 2>/dev/null || printf '%s' "$SCRIPT_PATH")"
     fi
     SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
@@ -57,14 +61,14 @@ SRC_DIR="$REPO_ROOT/src"
 INCLUDE_DIR="$REPO_ROOT/include"
 SCRIPTS_DIR="$REPO_ROOT/scripts"
 BUILD_DIR="$REPO_ROOT/build"
-TESTS_DIR="$REPO_ROOT/tests"
+TEMPLATES_DIR="$REPO_ROOT/templates"
 
-# Compiler selection: prefer g++, fall back to clang++
-if command -v g++ &> /dev/null;
-    then
+# Compiler selection: CF_CXX/CXX override, then g++, then clang++
+if [ -n "${CF_CXX:-${CXX:-}}" ] && command -v "${CF_CXX:-${CXX:-}}" &> /dev/null; then
+    COMPILER="${CF_CXX:-${CXX:-}}"
+elif command -v g++ &> /dev/null; then
     COMPILER="g++"
-elif command -v clang++ &> /dev/null;
-    then
+elif command -v clang++ &> /dev/null; then
     COMPILER="clang++"
 else
     printf '%s\n' "Error: No C++ compiler found. Install g++ or clang++." >&2
@@ -77,18 +81,20 @@ CXXFLAGS_DEFAULT="-std=c++23 -O2 -Wall -Wextra"
 # Execution timeout (seconds)
 EXEC_TIMEOUT_DEFAULT=5
 
-# Color codes
-if [ -t 1 ]; then
+# Color codes (disabled when not a TTY or NO_COLOR is set)
+if [ -t 1 ] && [ -z "${NO_COLOR:-}" ]; then
     RED='\033[0;31m'
     GREEN='\033[0;32m'
     YELLOW='\033[1;33m'
     BLUE='\033[0;34m'
+    DIM='\033[2m'
     NC='\033[0m'
 else
     RED=''
     GREEN=''
     YELLOW=''
     BLUE=''
+    DIM=''
     NC=''
 fi
 
@@ -99,7 +105,6 @@ VERBOSE=${CF_VERBOSE:-0}
 EXIT_USAGE=2
 EXIT_IO=3
 EXIT_COMPILE=4
-EXIT_RUNTIME=5
 EXIT_UPDATE=6
 
 # Config overrides (optional)
@@ -116,6 +121,9 @@ COMPILATION_WARNINGS=""
 CXXFLAGS="${CF_CXXFLAGS:-$CXXFLAGS_DEFAULT}"
 EXEC_TIMEOUT="${CF_TIMEOUT:-$EXEC_TIMEOUT_DEFAULT}"
 BUILD_CACHE_DIR="${CF_BUILD_CACHE_DIR:-$BUILD_DIR/.cache}"
+# Output checker: "lines" (exact lines, trailing whitespace ignored) or
+# "tokens" (whitespace-insensitive, like the Codeforces wcmp checker).
+CHECKER="${CF_CHECKER:-lines}"
 
 # ==================== HELPER FUNCTIONS ====================
 
@@ -149,7 +157,7 @@ print_header() {
 
 print_warnings_if_any() {
     if [ -n "${COMPILATION_WARNINGS:-}" ]; then
-        printf "\n${YELLOW}Compilation Warnings:${NC}\n"
+        printf '%b\n' "\n${YELLOW}Compilation Warnings:${NC}"
         printf '%s\n' "$COMPILATION_WARNINGS"
     fi
 }
@@ -180,35 +188,73 @@ validate_dir() {
     fi
 }
 
-# Find .cpp files in a directory
-find_cpp_files() {
-    local dir="$1"
-    find "$dir" -maxdepth 1 -name "*.cpp" -type f
-}
-
 # Check if directory exists
 dir_exists() {
     [ -d "$1" ]
 }
 
+# Milliseconds since the epoch (bash 5 EPOCHREALTIME, GNU date, or seconds).
+now_ms() {
+    if [ -n "${EPOCHREALTIME:-}" ]; then
+        local s="${EPOCHREALTIME%.*}"
+        local us="${EPOCHREALTIME#*.}"
+        printf '%s' "$(( s * 1000 + 10#${us:0:3} ))"
+    elif date +%s%N 2>/dev/null | grep -q '^[0-9]\{13,\}$'; then
+        local ns
+        ns=$(date +%s%N)
+        printf '%s' "$(( ns / 1000000 ))"
+    else
+        printf '%s' "$(( $(date +%s) * 1000 ))"
+    fi
+}
+
+# Validate the checker name
+validate_checker() {
+    case "$1" in
+        lines|tokens) return 0 ;;
+        *) error_exit "Unknown checker: $1 (use lines or tokens)" "$EXIT_USAGE" ;;
+    esac
+}
+
+# Resolve a problem directory from an argument (or the cwd). Prints the
+# absolute path, or nothing when no problem context can be found.
+#   1. <arg> as a directory containing problem.txt
+#   2. src/<arg>
+#   3. the cwd, when it holds problem.txt
+resolve_problem_dir() {
+    local arg="${1:-}"
+    if [ -n "$arg" ]; then
+        if [ -d "$arg" ] && [ -f "$arg/problem.txt" ]; then
+            (cd "$arg" && pwd)
+            return 0
+        elif [ -d "$SRC_DIR/$arg" ] && [ -f "$SRC_DIR/$arg/problem.txt" ]; then
+            printf '%s' "$SRC_DIR/$arg"
+            return 0
+        fi
+        return 1
+    fi
+    if [ -f "$PWD/problem.txt" ]; then
+        printf '%s' "$PWD"
+        return 0
+    fi
+    return 1
+}
+
 # Global flag to track if timeout warning has been shown
 TIMEOUT_WARNING_SHOWN=0
 
 # Check for timeout command availability
 check_timeout_cmd() {
-    if command -v timeout &> /dev/null;
-        then
+    if command -v timeout &> /dev/null; then
         TIMEOUT_CMD="timeout"
         return 0
-    elif command -v gtimeout &> /dev/null;
-        then
+    elif command -v gtimeout &> /dev/null; then
         TIMEOUT_CMD="gtimeout"
         return 0
     else
         if [ "$TIMEOUT_WARNING_SHOWN" -eq 0 ]; then
             print_warning "timeout command not found; execution timeout protection disabled"
-            if command -v brew &> /dev/null;
-                then
+            if command -v brew &> /dev/null; then
                 print_info "Install on macOS: brew install coreutils"
             fi
             TIMEOUT_WARNING_SHOWN=1
@@ -234,18 +280,16 @@ trap 'run_cleanup' EXIT
 compute_sources_hash() {
     local sources=("$@")
     local hash_cmd=""
-    if command -v sha256sum &> /dev/null;
-        then
+    if command -v sha256sum &> /dev/null; then
         hash_cmd="sha256sum"
-    elif command -v shasum &> /dev/null;
-        then
+    elif command -v shasum &> /dev/null; then
         hash_cmd="shasum -a 256"
     else
         return 1
     fi
 
     {
-        printf '%s\n' "$CXXFLAGS"
+        printf '%s\n' "$COMPILER" "$CXXFLAGS"
         for s in "${sources[@]}"; do
             printf '%s\n' "$s"
             cat "$s"
@@ -253,7 +297,8 @@ compute_sources_hash() {
     } | eval "$hash_cmd" | awk '{print $1}'
 }
 
-# Safe execution with timeout and resource tracking
+# Safe execution with timeout and resource tracking. Sets LAST_RUN_MS.
+LAST_RUN_MS=0
 safe_execute() {
     local output_file=""
     if [[ "$1" == --output=* ]]; then
@@ -275,7 +320,7 @@ safe_execute() {
     cmd+=("$binary")
 
     local exit_code=0
-    
+
     local use_time=0
     if [ -x "/usr/bin/time" ]; then
         # Check if /usr/bin/time supports the -f flag (GNU time)
@@ -284,6 +329,8 @@ safe_execute() {
         fi
     fi
 
+    local started
+    started=$(now_ms)
     if [ "$use_time" -eq 1 ]; then
         if [ -n "$output_file" ]; then
             if [ -n "$input_file" ] && [ -f "$input_file" ]; then
@@ -317,13 +364,13 @@ safe_execute() {
         fi
         exit_code=$?
     fi
+    LAST_RUN_MS=$(( $(now_ms) - started ))
 
     if [ $exit_code -eq 124 ]; then
         print_error "Execution timeout (exceeded ${timeout_sec}s)"
         return 1
     elif [ $exit_code -ne 0 ]; then
-        # We don't always want to return 1 here because some solutions might return non-zero but still be correct (though rare in CP)
-        # But for Codeforces, exit code should be 0.
+        # Codeforces requires exit code 0.
         print_error "Runtime error (exit code: $exit_code)"
         return 1
     fi
@@ -342,6 +389,7 @@ safe_compile() {
     COMPILATION_WARNINGS=""
 
     local compile_out
+    # shellcheck disable=SC2086  # CXXFLAGS is intentionally word-split
     compile_out=$($COMPILER $CXXFLAGS -I "$INCLUDE_DIR" "${sources[@]}" -o "$output" 2>&1)
     local ret=$?
 
@@ -357,6 +405,36 @@ safe_compile() {
     return 0
 }
 
+# Compile the given sources into the build cache (or a temp file when hashing
+# is unavailable). Prints the binary path. Honors CF_FORCE_REBUILD=1.
+compile_cached() {
+    local label="$1"
+    shift
+    local sources=("$@")
+    local output_file
+    local sources_hash=""
+    sources_hash=$(compute_sources_hash "${sources[@]}") || true
+    if [ -n "$sources_hash" ]; then
+        mkdir -p "$BUILD_CACHE_DIR" || error_exit "Failed to create build cache directory" "$EXIT_IO"
+        output_file="$BUILD_CACHE_DIR/$sources_hash"
+    else
+        output_file=$(mktemp) || error_exit "Failed to create temp file" "$EXIT_IO"
+        add_cleanup "$output_file"
+    fi
+
+    if [ -x "$output_file" ] && [ -n "$sources_hash" ] && [ "${CF_FORCE_REBUILD:-0}" -ne 1 ]; then
+        print_info "$label: using cached build" >&2
+    else
+        print_info "$label: compiling with $COMPILER..." >&2
+        if ! safe_compile "$output_file" "${sources[@]}"; then
+            rm -f "$output_file" 2>/dev/null || true
+            return 1
+        fi
+        chmod +x "$output_file" 2>/dev/null || true
+    fi
+    printf '%s' "$output_file"
+}
+
 # Extract example block (input or output) from problem description file
 extract_example_block() {
     local file="$1"
@@ -368,8 +446,7 @@ extract_example_block() {
     fi
 
     # Check if this looks like a problem description with Examples section
-    if grep -qi "Examples\|Example" "$file" 2>/dev/null;
-        then
+    if grep -qi "Examples\|Example" "$file" 2>/dev/null; then
         awk -v idx="$sample_index" -v target="$target" '
             function norm(s){ gsub(/\r/, "", s); return s }
             function trim(s){ sub(/^[[:space:]]+/, "", s); sub(/[[:space:]]+$/, "", s); return s }
@@ -382,7 +459,7 @@ extract_example_block() {
             {
                 line=norm($0)
                 if (!in_examples && line ~ /^[[:space:]]*$/) next
-                if (!in_examples && tolower(line) ~ /^examples?$/) { in_examples=1; next }
+                if (!in_examples && tolower(line) ~ /^examples?:?$/) { in_examples=1; next }
                 if (!in_examples && tolower(line) ~ /^example[[:space:]]*[0-9]*$/) { in_examples=1; next }
                 if (!in_examples) next
 
@@ -429,8 +506,7 @@ extract_test_input() {
         return 1
     fi
 
-    if grep -qi "Examples\|Example" "$file" 2>/dev/null;
-        then
+    if grep -qi "Examples\|Example" "$file" 2>/dev/null; then
         extract_example_block "$file" "$sample_index" "input"
     else
         # Regular input file, return as-is
@@ -447,8 +523,7 @@ extract_expected_output() {
         return 1
     fi
 
-    if grep -qi "Examples\|Example" "$file" 2>/dev/null;
-        then
+    if grep -qi "Examples\|Example" "$file" 2>/dev/null; then
         extract_example_block "$file" "$sample_index" "output"
     else
         return 1
@@ -463,8 +538,7 @@ count_samples() {
         return 0
     fi
 
-    if ! grep -qi "Examples\|Example" "$file" 2>/dev/null;
-        then
+    if ! grep -qi "Examples\|Example" "$file" 2>/dev/null; then
         printf '0'
         return 0
     fi
@@ -478,7 +552,7 @@ count_samples() {
         {
             line=norm($0)
             if (!in_examples && line ~ /^[[:space:]]*$/) next
-            if (!in_examples && tolower(line) ~ /^examples?$/) { in_examples=1; next }
+            if (!in_examples && tolower(line) ~ /^examples?:?$/) { in_examples=1; next }
             if (!in_examples && tolower(line) ~ /^example[[:space:]]*[0-9]*$/) { in_examples=1; next }
             if (!in_examples) next
 
@@ -488,8 +562,14 @@ count_samples() {
     ' "$file"
 }
 
-# Normalize output for comparison: strip \r, trim blank edges, trim trailing spaces per line
+# Normalize output for comparison according to $CHECKER.
+#   lines:  strip \r, trim blank edges, trim trailing spaces per line
+#   tokens: one whitespace-separated token per line
 normalize_output() {
+    if [ "$CHECKER" = "tokens" ]; then
+        printf '%s' "$1" | tr -d '\r' | tr -s '[:space:]' '\n' | sed '/^$/d'
+        return 0
+    fi
     printf '%s' "$1" | tr -d '\r' | awk '
         { sub(/[[:space:]]+$/, "", $0); lines[NR]=$0 }
         END {
@@ -504,13 +584,59 @@ normalize_output() {
     '
 }
 
+# Compare two output strings under the active checker. Returns 0 on match.
+outputs_match() {
+    local expected="$1"
+    local actual="$2"
+    local a b
+    a=$(mktemp)
+    b=$(mktemp)
+    add_cleanup "$a"
+    add_cleanup "$b"
+    normalize_output "$expected" > "$a"
+    normalize_output "$actual" > "$b"
+    cmp -s "$a" "$b"
+}
+
+# Collect the .cpp files of a problem directory into the cpp_files array.
+collect_cpp_files() {
+    local dir="$1"
+    cpp_files=()
+    while IFS= read -r file; do
+        [ -n "$file" ] && cpp_files+=("$file")
+    done < <(find "$dir" -maxdepth 1 -name "*.cpp" -type f 2>/dev/null | sort)
+}
+
 # ==================== TEMPLATE COMMAND ====================
 
 cmd_template() {
-    local problem_name="$1"
+    local problem_name=""
+    local from=""
+
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            --from|-f)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --from" "$EXIT_USAGE"
+                from="$1"
+                ;;
+            --help|-h)
+                cmd_help
+                return 0
+                ;;
+            *)
+                if [ -z "$problem_name" ]; then
+                    problem_name="$1"
+                else
+                    print_warning "Ignoring extra argument: $1"
+                fi
+                ;;
+        esac
+        shift || true
+    done
 
     if [ -z "$problem_name" ]; then
-        print_error "Usage: cf template <name>"
+        print_error "Usage: cf template <name> [--from dp|graph|math]"
         printf '%s\n' "Example: cf template 1000A"
         return 1
     fi
@@ -521,6 +647,20 @@ cmd_template() {
         return 1
     fi
 
+    # Pick the template source
+    local template_src="$SRC_DIR/template.cpp"
+    if [ -n "$from" ]; then
+        if [ -f "$from" ]; then
+            template_src="$from"
+        elif [ -f "$TEMPLATES_DIR/$from.cpp" ]; then
+            template_src="$TEMPLATES_DIR/$from.cpp"
+        else
+            local available
+            available=$(find "$TEMPLATES_DIR" -maxdepth 1 -name '*.cpp' -exec basename {} .cpp \; 2>/dev/null | sort | tr '\n' ' ')
+            error_exit "Template not found: $from (available: ${available:-none})" "$EXIT_IO"
+        fi
+    fi
+
     # Create problem directory in current working directory
     local problem_dir="$PWD/$problem_name"
 
@@ -537,11 +677,11 @@ cmd_template() {
     if [ -f "$solution_file" ]; then
         print_info "Solution already exists: $solution_file"
     else
-        if [ -f "$SRC_DIR/template.cpp" ]; then
-            cp "$SRC_DIR/template.cpp" "$solution_file" || error_exit "Failed to copy template" "$EXIT_IO"
-            print_success "Created solution: $solution_file"
+        if [ -f "$template_src" ]; then
+            cp "$template_src" "$solution_file" || error_exit "Failed to copy template" "$EXIT_IO"
+            print_success "Created solution: $solution_file (from $(basename "$template_src"))"
         else
-            error_exit "Template file not found: $SRC_DIR/template.cpp" "$EXIT_IO"
+            error_exit "Template file not found: $template_src" "$EXIT_IO"
         fi
     fi
 
@@ -578,8 +718,7 @@ EOF
     fi
 
     # Open files in VS Code if available
-    if [ "${CF_SERVE_MODE:-0}" -eq 0 ] && command -v code &> /dev/null;
-        then
+    if [ "${CF_SERVE_MODE:-0}" -eq 0 ] && [ "${CF_NO_EDITOR:-0}" -eq 0 ] && command -v code &> /dev/null; then
         print_info "Opening files in VS Code..."
         code "$problem_file" "$solution_file" 2>/dev/null || true
         print_success "Opened in VS Code"
@@ -590,7 +729,7 @@ EOF
         printf '%s\n' "Next steps:"
         printf '%s\n' "  1. Paste problem statement in $problem_file"
         printf '%s\n' "  2. Edit solution in $solution_file"
-        printf '%s\n' "  3. cd $problem_name && cf problem.txt"
+        printf '%s\n' "  3. cd $problem_name && cf test"
     fi
 }
 
@@ -612,21 +751,32 @@ cmd_run() {
                 fi
                 sample_index="$1"
                 sample_set=1
-                ;; 
+                ;;
             --input|--file|-i)
                 shift || true
                 if [ -z "${1:-}" ]; then
                     error_exit "Missing value for --input" "$EXIT_USAGE"
                 fi
                 input_arg="$1"
-                ;; 
+                ;;
+            --checker|-c)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --checker" "$EXIT_USAGE"
+                CHECKER="$1"
+                validate_checker "$CHECKER"
+                ;;
+            --timeout|-t)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --timeout" "$EXIT_USAGE"
+                EXEC_TIMEOUT="$1"
+                ;;
             --stdin)
                 use_stdin=1
-                ;; 
+                ;;
             --help|-h)
                 cmd_help
                 return 0
-                ;; 
+                ;;
             *)
                 if [ -z "$input_arg" ]; then
                     input_arg="$1"
@@ -652,14 +802,12 @@ cmd_run() {
     # (this is what makes `cf <problem>` work from the repo root).
     local prob_dir=""
     if [ -n "$input_arg" ] && [ ! -f "$input_arg" ]; then
-        if [ -d "$input_arg" ] && [ -f "$input_arg/problem.txt" ]; then
-            prob_dir="$(cd "$input_arg" && pwd)"
-            input_arg="$prob_dir/problem.txt"
-        elif [ -d "$SRC_DIR/$input_arg" ] && [ -f "$SRC_DIR/$input_arg/problem.txt" ]; then
-            prob_dir="$SRC_DIR/$input_arg"
+        if prob_dir=$(resolve_problem_dir "$input_arg"); then
             input_arg="$prob_dir/problem.txt"
         elif [ "$(basename "$PWD")" = "$input_arg" ] && [ -f "$PWD/problem.txt" ]; then
             input_arg="$PWD/problem.txt"
+        else
+            prob_dir=""
         fi
     fi
 
@@ -669,40 +817,17 @@ cmd_run() {
 
     # Find .cpp files in the problem dir (when named) or current directory.
     local src_ctx="${prob_dir:-$PWD}"
-    cpp_files=()
-    while IFS= read -r file; do
-        [ -n "$file" ] && cpp_files+=("$file")
-    done < <(find "$src_ctx" -maxdepth 1 -name "*.cpp" -type f 2>/dev/null)
+    collect_cpp_files "$src_ctx"
     if [ ${#cpp_files[@]} -eq 0 ]; then
         error_exit "No C++ file found in $src_ctx" "$EXIT_USAGE"
     fi
 
     print_info "Using: ${#cpp_files[@]} source file(s)"
 
-    # Prepare output file (build cache)
+    # Compile (build cache)
     local output_file
-    local sources_hash=""
-    sources_hash=$(compute_sources_hash "${cpp_files[@]}") || true
-    if [ -n "$sources_hash" ]; then
-        mkdir -p "$BUILD_CACHE_DIR" || error_exit "Failed to create build cache directory" "$EXIT_IO"
-        output_file="$BUILD_CACHE_DIR/$sources_hash"
-    else
-        output_file=$(mktemp) || error_exit "Failed to create temp file" "$EXIT_IO"
-        add_cleanup "$output_file"
-    fi
-
-    # Compile
-    if [ -x "$output_file" ] && [ -n "$sources_hash" ] && [ "${CF_FORCE_REBUILD:-0}" -ne 1 ]; then
-        print_info "Using cached build"
-    else
-        print_info "Compiling with $COMPILER..."
-        if ! safe_compile "$output_file" "${cpp_files[@]}"; then
-            rm -f "$output_file" 2>/dev/null || true
-            return 1
-        fi
-        chmod +x "$output_file" 2>/dev/null || true
-        print_success "Compiled successfully"
-    fi
+    output_file=$(compile_cached "solution" "${cpp_files[@]}") || return 1
+    print_success "Compiled successfully"
 
     # Prepare input
     local input_data=""
@@ -726,8 +851,7 @@ cmd_run() {
             print_info "Running with input from: $input_arg"
 
             # Check if this is a problem file and extract expected output
-            if grep -qi "Examples\|Example" "$input_arg" 2>/dev/null;
-                then
+            if grep -qi "Examples\|Example" "$input_arg" 2>/dev/null; then
                 is_problem_file=true
                 local sample_count
                 sample_count=$(count_samples "$input_arg")
@@ -793,7 +917,9 @@ cmd_run() {
     local tmp_actual_output=""
     if [ -n "$temp_input" ]; then
         tmp_actual_output=$(mktemp)
+        add_cleanup "$tmp_actual_output"
         if ! safe_execute --output="$tmp_actual_output" "$output_file" "$temp_input"; then
+            cat "$tmp_actual_output" 2>/dev/null || true
             print_warnings_if_any
             return 1
         fi
@@ -808,6 +934,7 @@ cmd_run() {
     fi
 
     printf -- '\n---\n'
+    printf '%b\n' "${DIM}Elapsed: ${LAST_RUN_MS} ms${NC}"
 
     # Display expected output if available
     if [ "$is_problem_file" = true ] && [ "$compare_enabled" = true ]; then
@@ -818,24 +945,18 @@ cmd_run() {
             printf '%s' "$expected_output"
             printf -- '\n---\n'
 
-            # Create temporary file for normalization to avoid shell variable limitations with null bytes
-            local tmp_normalized_actual
-            local tmp_normalized_expected
-            tmp_normalized_actual=$(mktemp)
-            tmp_normalized_expected=$(mktemp)
-            add_cleanup "$tmp_normalized_actual"
-            add_cleanup "$tmp_normalized_expected"
-
-            # Normalize outputs from files
-            normalize_output "$(cat "$tmp_actual_output")" > "$tmp_normalized_actual"
-            normalize_output "$expected_output" > "$tmp_normalized_expected"
-
-            # Compare normalized outputs from files
-            if cmp -s "$tmp_normalized_actual" "$tmp_normalized_expected"; then
+            if outputs_match "$expected_output" "$(cat "$tmp_actual_output")"; then
                 print_success "Output matches expected."
             else
                 print_warning "Output does not match expected."
-                rm -f "$tmp_actual_output" 2>/dev/null || true
+                if [ "$CHECKER" = "lines" ]; then
+                    local saved_checker="$CHECKER"
+                    CHECKER="tokens"
+                    if outputs_match "$expected_output" "$(cat "$tmp_actual_output")"; then
+                        print_info "Tokens match; only whitespace differs (try --checker tokens)."
+                    fi
+                    CHECKER="$saved_checker"
+                fi
                 print_warnings_if_any
                 return 1
             fi
@@ -846,9 +967,7 @@ cmd_run() {
         print_warning "Expected output available but input was interactive; skipping compare"
     fi
 
-    # Cleanup
-    rm -f "$tmp_actual_output" 2>/dev/null || true
-
+    print_warnings_if_any
     print_success "Execution complete"
 }
 
@@ -857,101 +976,94 @@ cmd_run() {
 cmd_test_all() {
     local prob_dir="$1"
     local prob_file="$prob_dir/problem.txt"
-    
+
     validate_dir "$prob_dir"
     validate_file "$prob_file"
-    
-    # Find .cpp files
-    cpp_files=()
-    while IFS= read -r file; do
-        [ -n "$file" ] && cpp_files+=("$file")
-    done < <(find "$prob_dir" -maxdepth 1 -name "*.cpp" -type f 2>/dev/null)
-    if [ ${#cpp_files[@]} -eq 0 ]; then
+
+    # Find .cpp files (brute/generator sources are not part of the solution)
+    collect_cpp_files "$prob_dir"
+    local sources=()
+    local f
+    for f in "${cpp_files[@]}"; do
+        case "$(basename "$f")" in
+            brute.cpp|gen.cpp|generator.cpp) ;;
+            *) sources+=("$f") ;;
+        esac
+    done
+    if [ ${#sources[@]} -eq 0 ]; then
         error_exit "No C++ file found in $prob_dir" "$EXIT_USAGE"
     fi
 
     print_info "Testing problem in: $prob_dir"
-    print_info "Found ${#cpp_files[@]} source file(s)"
+    print_info "Found ${#sources[@]} source file(s), checker: $CHECKER"
 
     # Compile
     local output_binary
-    output_binary=$(mktemp)
-    add_cleanup "$output_binary"
-    
-    print_info "Compiling..."
-    if ! safe_compile "$output_binary" "${cpp_files[@]}"; then
-        return 1
-    fi
-    chmod +x "$output_binary"
+    output_binary=$(compile_cached "solution" "${sources[@]}") || return 1
 
     local sample_count
     sample_count=$(count_samples "$prob_file")
-    
+
     if [ "$sample_count" -eq 0 ]; then
         print_warning "No samples found in $prob_file"
         return 0
     fi
 
     print_info "Found $sample_count samples. Starting tests..."
-    
+
     local passed=0
     local failed=0
+    local max_ms=0
 
     for ((i=1; i<=sample_count; i++)); do
         printf '\n'
         print_info "Running Sample #$i..."
-        
+
         local temp_input
-        local temp_expected
         local temp_actual
         temp_input=$(mktemp)
-        temp_expected=$(mktemp)
         temp_actual=$(mktemp)
         add_cleanup "$temp_input"
-        add_cleanup "$temp_expected"
         add_cleanup "$temp_actual"
 
         if ! extract_test_input "$prob_file" "$i" > "$temp_input"; then
             print_warning "Failed to extract input for sample #$i"
             continue
         fi
-        
+
         local expected_data
         expected_data=$(extract_expected_output "$prob_file" "$i") || true
-        printf '%s' "$expected_data" > "$temp_expected"
 
         if ! safe_execute --output="$temp_actual" "$output_binary" "$temp_input"; then
-            print_error "Sample #$i: Runtime Error or Timeout"
+            print_error "Sample #$i: Runtime Error or Timeout (${LAST_RUN_MS} ms)"
+            sed 's/^/  /' "$temp_actual" | head -20
             failed=$((failed + 1))
             continue
         fi
+        [ "$LAST_RUN_MS" -gt "$max_ms" ] && max_ms="$LAST_RUN_MS"
 
-        # Compare
-        local norm_actual
-        local norm_expected
-        norm_actual=$(mktemp)
-        norm_expected=$(mktemp)
-        add_cleanup "$norm_actual"
-        add_cleanup "$norm_expected"
-        
-        normalize_output "$(cat "$temp_actual")" > "$norm_actual"
-        normalize_output "$expected_data" > "$norm_expected"
-
-        if cmp -s "$norm_actual" "$norm_expected"; then
-            print_success "Sample #$i: PASSED"
+        if outputs_match "$expected_data" "$(cat "$temp_actual")"; then
+            print_success "Sample #$i: PASSED (${LAST_RUN_MS} ms)"
             passed=$((passed + 1))
         else
-            print_error "Sample #$i: FAILED (Output Mismatch)"
-            printf "${YELLOW}Input Used:${NC}\n"
-            cat "$temp_input" | sed 's/^/  /'
-            printf "${YELLOW}Expected Output:${NC}\n"
+            print_error "Sample #$i: FAILED (Output Mismatch, ${LAST_RUN_MS} ms)"
+            printf '%b\n' "${YELLOW}Input Used:${NC}"
+            sed 's/^/  /' "$temp_input"
+            printf '%b\n' "${YELLOW}Expected Output:${NC}"
             printf '%s\n' "$expected_data" | sed 's/^/  /'
-            printf "${YELLOW}Your Output:${NC}\n"
-            cat "$temp_actual" | sed 's/^/  /'
-            
+            printf '%b\n' "${YELLOW}Your Output:${NC}"
+            sed 's/^/  /' "$temp_actual"
+
             # Show diff if possible
             if command -v diff &> /dev/null; then
-                printf "${YELLOW}Diff:${NC}\n"
+                local norm_actual norm_expected
+                norm_actual=$(mktemp)
+                norm_expected=$(mktemp)
+                add_cleanup "$norm_actual"
+                add_cleanup "$norm_expected"
+                normalize_output "$(cat "$temp_actual")" > "$norm_actual"
+                normalize_output "$expected_data" > "$norm_expected"
+                printf '%b\n' "${YELLOW}Diff:${NC}"
                 diff -u "$norm_expected" "$norm_actual" | sed 's/^/  /' || true
             fi
             failed=$((failed + 1))
@@ -960,9 +1072,10 @@ cmd_test_all() {
 
     printf '\n'
     print_header "Test Summary"
-    print_info "Total: $sample_count | Passed: ${GREEN}$passed${NC} | Failed: ${RED}$failed${NC}"
-    
+    print_info "Total: $sample_count | Passed: ${GREEN}$passed${NC} | Failed: ${RED}$failed${NC} | Max time: ${max_ms} ms"
+
     if [ "$failed" -eq 0 ]; then
+        print_warnings_if_any
         print_success "All problem samples passed!"
         return 0
     else
@@ -972,18 +1085,41 @@ cmd_test_all() {
 }
 
 cmd_test() {
-    local arg="${1:-}"
-    
-    # Check if we are in a problem directory or argument is a problem
+    local arg=""
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            --checker|-c)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --checker" "$EXIT_USAGE"
+                CHECKER="$1"
+                validate_checker "$CHECKER"
+                ;;
+            --timeout|-t)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --timeout" "$EXIT_USAGE"
+                EXEC_TIMEOUT="$1"
+                ;;
+            --help|-h)
+                cmd_help
+                return 0
+                ;;
+            *)
+                if [ -z "$arg" ]; then
+                    arg="$1"
+                else
+                    print_warning "Ignoring extra argument: $1"
+                fi
+                ;;
+        esac
+        shift || true
+    done
+
+    # An explicit problem argument wins; otherwise fall back to the cwd.
     local prob_dir=""
-    if [ -f "$PWD/problem.txt" ]; then
-        prob_dir="$PWD"
-    elif [ -n "$arg" ]; then
-        if [ -d "$PWD/$arg" ] && [ -f "$PWD/$arg/problem.txt" ]; then
-            prob_dir="$PWD/$arg"
-        elif [ -d "$SRC_DIR/$arg" ] && [ -f "$SRC_DIR/$arg/problem.txt" ]; then
-            prob_dir="$SRC_DIR/$arg"
-        fi
+    if [ -n "$arg" ]; then
+        prob_dir=$(resolve_problem_dir "$arg") || error_exit "Problem not found: $arg (looked in ./$arg and $SRC_DIR/$arg)" "$EXIT_IO"
+    else
+        prob_dir=$(resolve_problem_dir) || true
     fi
 
     if [ -n "$prob_dir" ]; then
@@ -1017,6 +1153,291 @@ cmd_test() {
     fi
 }
 
+# ==================== SAMPLES COMMAND ====================
+
+cmd_samples() {
+    local arg="${1:-}"
+    local prob_dir
+    prob_dir=$(resolve_problem_dir "$arg") || error_exit "No problem.txt found${arg:+ for $arg}" "$EXIT_IO"
+    local prob_file="$prob_dir/problem.txt"
+    local n
+    n=$(count_samples "$prob_file")
+    print_info "$prob_file: $n sample(s)"
+    local i
+    for ((i=1; i<=n; i++)); do
+        printf '\n%b\n' "${BLUE}Sample #$i input:${NC}"
+        normalize_output "$(extract_test_input "$prob_file" "$i")" | sed 's/^/  /'
+        printf '\n%b\n' "${BLUE}Sample #$i output:${NC}"
+        normalize_output "$(extract_expected_output "$prob_file" "$i" || printf '(none)')" | sed 's/^/  /'
+        printf '\n'
+    done
+}
+
+# ==================== STRESS COMMAND ====================
+
+cmd_stress() {
+    local arg=""
+    local iterations="${CF_STRESS_ITERATIONS:-200}"
+    local brute_src=""
+    local gen_src=""
+    local seed_base=1
+
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            -n|--iterations)
+                shift || true
+                [[ "${1:-}" =~ ^[0-9]+$ ]] || error_exit "Invalid iteration count: ${1:-}" "$EXIT_USAGE"
+                iterations="$1"
+                ;;
+            --brute|-b)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --brute" "$EXIT_USAGE"
+                brute_src="$1"
+                ;;
+            --gen|--generator|-g)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --gen" "$EXIT_USAGE"
+                gen_src="$1"
+                ;;
+            --seed)
+                shift || true
+                [[ "${1:-}" =~ ^[0-9]+$ ]] || error_exit "Invalid seed: ${1:-}" "$EXIT_USAGE"
+                seed_base="$1"
+                ;;
+            --checker|-c)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --checker" "$EXIT_USAGE"
+                CHECKER="$1"
+                validate_checker "$CHECKER"
+                ;;
+            --timeout|-t)
+                shift || true
+                [ -z "${1:-}" ] && error_exit "Missing value for --timeout" "$EXIT_USAGE"
+                EXEC_TIMEOUT="$1"
+                ;;
+            --help|-h)
+                cmd_help
+                return 0
+                ;;
+            *)
+                if [ -z "$arg" ]; then
+                    arg="$1"
+                else
+                    print_warning "Ignoring extra argument: $1"
+                fi
+                ;;
+        esac
+        shift || true
+    done
+
+    local prob_dir
+    if [ -n "$arg" ]; then
+        prob_dir=$(resolve_problem_dir "$arg") || {
+            if [ -d "$arg" ]; then prob_dir="$(cd "$arg" && pwd)"; else error_exit "Problem not found: $arg" "$EXIT_IO"; fi
+        }
+    else
+        prob_dir="$PWD"
+    fi
+
+    [ -z "$brute_src" ] && brute_src="$prob_dir/brute.cpp"
+    if [ -z "$gen_src" ]; then
+        if [ -f "$prob_dir/gen.cpp" ]; then gen_src="$prob_dir/gen.cpp"; else gen_src="$prob_dir/generator.cpp"; fi
+    fi
+    validate_file "$brute_src"
+    validate_file "$gen_src"
+
+    collect_cpp_files "$prob_dir"
+    local sources=()
+    local f
+    for f in "${cpp_files[@]}"; do
+        case "$(basename "$f")" in
+            brute.cpp|gen.cpp|generator.cpp) ;;
+            *) sources+=("$f") ;;
+        esac
+    done
+    [ ${#sources[@]} -eq 0 ] && error_exit "No solution source found in $prob_dir" "$EXIT_USAGE"
+
+    print_header "Stress test: ${iterations} iterations, checker $CHECKER"
+    local sol_bin brute_bin gen_bin
+    sol_bin=$(compile_cached "solution" "${sources[@]}") || return 1
+    brute_bin=$(compile_cached "brute" "$brute_src") || return 1
+    gen_bin=$(compile_cached "generator" "$gen_src") || return 1
+
+    local input_tmp sol_out brute_out
+    input_tmp=$(mktemp); sol_out=$(mktemp); brute_out=$(mktemp)
+    add_cleanup "$input_tmp"; add_cleanup "$sol_out"; add_cleanup "$brute_out"
+
+    local i seed started max_ms=0
+    started=$(now_ms)
+    for ((i=0; i<iterations; i++)); do
+        seed=$((seed_base + i))
+        if ! "$gen_bin" "$seed" > "$input_tmp" 2>/dev/null; then
+            print_error "Generator failed on seed $seed"
+            return 1
+        fi
+        if ! safe_execute --output="$sol_out" "$sol_bin" "$input_tmp" > /dev/null; then
+            print_error "Solution crashed or timed out on iteration $((i+1)) (seed $seed)"
+            cp "$input_tmp" "$prob_dir/stress_fail.txt"
+            print_info "Failing input saved to $prob_dir/stress_fail.txt"
+            return 1
+        fi
+        [ "$LAST_RUN_MS" -gt "$max_ms" ] && max_ms="$LAST_RUN_MS"
+        if ! safe_execute --output="$brute_out" "$brute_bin" "$input_tmp" > /dev/null; then
+            print_error "Brute force crashed or timed out on iteration $((i+1)) (seed $seed)"
+            cp "$input_tmp" "$prob_dir/stress_fail.txt"
+            return 1
+        fi
+        if ! outputs_match "$(cat "$brute_out")" "$(cat "$sol_out")"; then
+            printf '\n'
+            print_error "Counter-example found on iteration $((i+1)) (seed $seed)"
+            printf '%b\n' "${YELLOW}Input:${NC}"
+            sed 's/^/  /' "$input_tmp"
+            printf '%b\n' "${YELLOW}Brute output:${NC}"
+            sed 's/^/  /' "$brute_out"
+            printf '%b\n' "${YELLOW}Solution output:${NC}"
+            sed 's/^/  /' "$sol_out"
+            cp "$input_tmp" "$prob_dir/stress_fail.txt"
+            print_info "Failing input saved to $prob_dir/stress_fail.txt"
+            return 1
+        fi
+        if is_tty && (( (i+1) % 25 == 0 )); then
+            printf '\r%b' "${DIM}  $((i+1))/$iterations ok, max ${max_ms} ms${NC}"
+        fi
+    done
+    is_tty && printf '\r'
+    print_success "No counter-example in $iterations iterations ($(( $(now_ms) - started )) ms, solution max ${max_ms} ms)"
+}
+
+# ==================== WATCH COMMAND ====================
+
+# Signature of the watched files: mtimes of every .cpp and problem.txt.
+watch_signature() {
+    local dir="$1"
+    find "$dir" -maxdepth 1 \( -name '*.cpp' -o -name 'problem.txt' \) -type f -exec ls -l --time-style=+%s {} + 2>/dev/null \
+        || find "$dir" -maxdepth 1 \( -name '*.cpp' -o -name 'problem.txt' \) -type f -exec stat -f '%m %N' {} + 2>/dev/null
+}
+
+cmd_watch() {
+    local arg="${1:-}"
+    local prob_dir
+    prob_dir=$(resolve_problem_dir "$arg") || error_exit "No problem.txt found${arg:+ for $arg}" "$EXIT_IO"
+    print_info "Watching $prob_dir (Ctrl+C to stop)"
+    local last=""
+    while true; do
+        local sig
+        sig=$(watch_signature "$prob_dir")
+        if [ "$sig" != "$last" ]; then
+            last="$sig"
+            if is_tty; then printf '\033[2J\033[H'; fi
+            printf '%b\n' "${DIM}$(date '+%H:%M:%S') change detected${NC}"
+            cmd_test_all "$prob_dir" || true
+            printf '\n%b\n' "${DIM}Waiting for changes...${NC}"
+        fi
+        sleep 1
+    done
+}
+
+# ==================== DOCTOR COMMAND ====================
+
+doctor_check() {
+    local status="$1"
+    local label="$2"
+    local detail="${3:-}"
+    if [ "$status" = ok ]; then
+        printf '%b\n' "  ${GREEN}ok${NC}    $label${detail:+ ${DIM}($detail)${NC}}"
+    elif [ "$status" = warn ]; then
+        printf '%b\n' "  ${YELLOW}warn${NC}  $label${detail:+ ${DIM}($detail)${NC}}"
+    else
+        printf '%b\n' "  ${RED}fail${NC}  $label${detail:+ ${DIM}($detail)${NC}}"
+    fi
+}
+
+cmd_doctor() {
+    local problems=0
+    print_header "cf doctor (v$CF_VERSION)"
+    printf '%b\n' "  repo  $REPO_ROOT"
+
+    local cxx_ver
+    cxx_ver=$($COMPILER --version 2>/dev/null | head -1)
+    doctor_check ok "compiler: $COMPILER" "$cxx_ver"
+
+    if [ -f "$INCLUDE_DIR/bits/stdc++.h" ]; then
+        doctor_check ok "bits/stdc++.h shim" "$INCLUDE_DIR"
+    else
+        doctor_check fail "bits/stdc++.h shim missing" "$INCLUDE_DIR"
+        problems=$((problems + 1))
+    fi
+
+    local tmp_src tmp_bin
+    tmp_src=$(mktemp).cpp
+    tmp_bin=$(mktemp)
+    add_cleanup "$tmp_src"; add_cleanup "$tmp_bin"
+    printf '%s\n' '#include <bits/stdc++.h>' 'int main(){int a,b;std::cin>>a>>b;std::cout<<a+b<<"\n";}' > "$tmp_src"
+    local started
+    started=$(now_ms)
+    if safe_compile "$tmp_bin" "$tmp_src" > /dev/null 2>&1; then
+        local out
+        out=$(printf '2 3\n' | "$tmp_bin" 2>/dev/null || true)
+        if [ "$out" = "5" ]; then
+            doctor_check ok "compile + run smoke test" "$(( $(now_ms) - started )) ms with $CXXFLAGS"
+        else
+            doctor_check fail "smoke test produced '$out' instead of 5"
+            problems=$((problems + 1))
+        fi
+    else
+        doctor_check fail "smoke test failed to compile" "flags: $CXXFLAGS"
+        problems=$((problems + 1))
+    fi
+
+    if command -v timeout &> /dev/null || command -v gtimeout &> /dev/null; then
+        doctor_check ok "timeout command" "execution limit ${EXEC_TIMEOUT}s"
+    else
+        doctor_check warn "timeout command missing" "brew install coreutils"
+    fi
+
+    local tool
+    for tool in node npm make shellcheck; do
+        if command -v "$tool" &> /dev/null; then
+            doctor_check ok "$tool" "$("$tool" --version 2>/dev/null | head -1)"
+        elif [ "$tool" = node ] || [ "$tool" = npm ]; then
+            doctor_check warn "$tool missing" "needed for cf serve"
+        else
+            doctor_check warn "$tool missing" "optional"
+        fi
+    done
+
+    if [ -d "$REPO_ROOT/web/node_modules" ]; then
+        doctor_check ok "web dependencies installed"
+    else
+        doctor_check warn "web dependencies not installed" "cf serve runs npm install"
+    fi
+
+    if [ -d "$BUILD_CACHE_DIR" ]; then
+        local n
+        n=$(find "$BUILD_CACHE_DIR" -maxdepth 1 -type f 2>/dev/null | wc -l | tr -d ' ')
+        doctor_check ok "build cache" "$n binaries in $BUILD_CACHE_DIR"
+    fi
+
+    printf '\n'
+    if [ "$problems" -eq 0 ]; then
+        print_success "Everything looks good"
+    else
+        error_exit "$problems problem(s) found" 1
+    fi
+}
+
+# ==================== CLEAN COMMAND ====================
+
+cmd_clean() {
+    local n=0
+    if [ -d "$BUILD_CACHE_DIR" ]; then
+        n=$(find "$BUILD_CACHE_DIR" -maxdepth 1 -type f 2>/dev/null | wc -l | tr -d ' ')
+        rm -rf "$BUILD_CACHE_DIR"
+    fi
+    rm -rf "$BUILD_DIR"
+    print_success "Removed build cache ($n cached binaries)"
+}
+
 # ==================== UPDATE COMMAND ====================
 
 cmd_update() {
@@ -1034,11 +1455,9 @@ cmd_update() {
     cd "$REPO_ROOT" || error_exit "Failed to change to repository directory" 1
 
     # Check for uncommitted changes
-    if ! git diff-index --quiet HEAD -- 2>/dev/null;
-        then
+    if ! git diff-index --quiet HEAD -- 2>/dev/null; then
         print_warning "You have uncommitted changes in the repository"
-        if [ "${CF_NONINTERACTIVE:-0}" -eq 1 ] || ! is_tty;
-            then
+        if [ "${CF_NONINTERACTIVE:-0}" -eq 1 ] || ! is_tty; then
             error_exit "Update aborted in non-interactive mode due to uncommitted changes" "$EXIT_UPDATE"
         fi
         printf '%s' "Continue with update? (y/N): "
@@ -1056,7 +1475,7 @@ cmd_update() {
     local remote
     local remote_branch
     current_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || true)
-    upstream=$(git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null || true)
+    upstream=$(git rev-parse --abbrev-ref --symbolic-full-name '@{u}' 2>/dev/null || true)
     if [ -z "$upstream" ] && [ -n "$current_branch" ]; then
         upstream="origin/$current_branch"
     fi
@@ -1068,21 +1487,19 @@ cmd_update() {
 
     # Fetch and pull latest changes
     print_info "Fetching latest changes from $remote..."
-    if ! git fetch "$remote" 2>&1;
-        then
+    if ! git fetch "$remote" 2>&1; then
         error_exit "Failed to fetch from remote repository" "$EXIT_UPDATE"
     fi
 
     print_info "Pulling latest changes from $remote/$remote_branch..."
-    if ! git pull "$remote" "$remote_branch" 2>&1;
-        then
-        error_exit "Failed to pull latest changes" "$EXIT_UPDATE"
+    if ! git pull --ff-only "$remote" "$remote_branch" 2>&1; then
+        error_exit "Failed to pull latest changes (non fast-forward?)" "$EXIT_UPDATE"
     fi
 
     print_success "Repository updated successfully"
 
     # Run setup script if it exists
-    if [ -f "$SCRIPTS_DIR/setup.sh" ]; then
+    if [ -f "$SCRIPTS_DIR/setup.sh" ] && [ "${CF_UPDATE_SKIP_SETUP:-0}" -ne 1 ]; then
         print_info "Running setup script..."
         if bash "$SCRIPTS_DIR/setup.sh"; then
             print_success "Setup completed successfully"
@@ -1090,7 +1507,7 @@ cmd_update() {
             print_warning "Setup script encountered issues, but update completed"
         fi
     else
-        print_warning "Setup script not found, skipping setup"
+        print_info "Skipping setup script"
     fi
 
     # Return to original directory
@@ -1132,22 +1549,31 @@ cmd_serve() {
 
     export CF_PROBLEMS_DIR="$problems_dir"
     export CF_SERVE_MODE=1
-    
+
     print_info "Starting CF Toolkit Web Interface..."
     print_info "Problems directory: $problems_dir"
-    
+
     if [ ! -d "$REPO_ROOT/web" ]; then
         error_exit "Web interface directory not found: $REPO_ROOT/web" "$EXIT_IO"
     fi
 
+    if ! command -v npm &> /dev/null; then
+        error_exit "npm not found; install Node.js 20+ to run the web workbench" "$EXIT_IO"
+    fi
+
     cd "$REPO_ROOT/web"
-    
+
     if [ ! -d "node_modules" ]; then
         print_info "Installing dependencies..."
         npm install
     fi
 
     # Use exec to replace the shell process and ensure signals are handled
+    if [ "${CF_SERVE_PROD:-0}" -eq 1 ]; then
+        print_info "Production mode: building..."
+        npm run build
+        exec npm run start
+    fi
     exec npm run dev
 }
 
@@ -1159,56 +1585,66 @@ cf - Codeforces CLI Tool
 
 USAGE:
   cf <command> [args]
-    cf [input] [--sample N] [--input FILE] [--stdin]
+  cf [problem|file|"inline input"] [--sample N] [--input FILE] [--stdin]
 
 COMMANDS:
-  template <name>    Create new problem template
-  test               Run test suite with validation
-  serve [name]       Start web interface (auto-creates problem if name given)
-  update             Update cf tool to latest version
-  help               Show this help message
+  template <name> [--from T]  Create a problem directory (T: dp, graph, math, or a file)
+  test [name]                 Run every sample in problem.txt, with timing
+  stress [name] [-n N]        Solution vs brute.cpp on gen.cpp inputs (seed = argv[1])
+  samples [name]              Print the samples parsed from problem.txt
+  watch [name]                Re-run the samples whenever a source changes
+  serve [name]                Start the web workbench (auto-creates the problem)
+  doctor                      Check compiler, shim, timeout and web toolchain
+  clean                       Remove the build cache
+  update                      Pull the latest version of cf
+  version                     Print the version
+  help                        Show this help message
+
+OPTIONS (run / test / stress):
+  --sample N, -s N            Use sample #N (run)
+  --input FILE, -i FILE       Explicit input file (run)
+  --stdin                     Force interactive stdin (run)
+  --checker lines|tokens      Output comparison mode (default: lines)
+  --timeout SEC, -t SEC       Execution time limit (default: 5)
+  -n N, --brute F, --gen F    Stress iterations / brute source / generator source
+  --seed N                    First generator seed (stress)
 
 EXAMPLES:
-  cf template 1000A           Create new problem 1000A
-  cf serve                    Start web interface
-  cf serve 1000A              Create (if needed) and serve 1000A in web
-  cf problem.txt              Run solution with input from file
+  cf template 1000A           Create ./1000A with solution.cpp and problem.txt
+  cf template 1000A --from dp Start from templates/dp.cpp
+  cf 1000A                    Compile src/1000A (or ./1000A) and run sample #1
   cf problem.txt 2            Run sample #2 from problem.txt
-  cf --sample 2               Run sample #2 from problem.txt (auto)
-    cf --input input.txt         Run with explicit input file
-    cf --stdin                   Force interactive stdin
-  cf "5\n1 2 3 4 5"           Run solution with inline input
-  cf test                     Run test suite
-
-FEATURES:
-    - Auto-detects .cpp files in current directory
-    - Auto-uses problem.txt when present
-    - Supports multiple samples with --sample N
-    - Timeout protection (5s) prevents infinite loops
-    - Validates input and handles errors gracefully
-    - Compares output with expected results
-    - Build caching for faster repeated runs
-    - Cross-platform (Linux/macOS/WSL)
-    - Production-grade reliability
-    - Web Interface with 'cf serve'
+  cf "5\n1 2 3 4 5"           Run the solution in the cwd with inline input
+  cf test                     Run all samples of the problem in the cwd
+  cf test 1000A --checker tokens
+  cf stress -n 1000           1000 iterations of brute.cpp vs solution.cpp
+  cf watch                    Re-test on every save
+  cf serve 1000A              Open the web workbench on problem 1000A
 
 ENVIRONMENT:
   CF_REPO_ROOT        Override repository root directory
-  CF_PROBLEMS_DIR     Directory containing problem folders
+  CF_PROBLEMS_DIR     Directory containing problem folders (serve)
+  CF_CXX / CXX        Compiler to use (default: g++, then clang++)
+  CF_CXXFLAGS         Override compiler flags (default: -std=c++23 -O2 -Wall -Wextra)
+  CF_TIMEOUT          Execution timeout in seconds (default: 5)
+  CF_CHECKER          Default checker: lines or tokens
+  CF_STRESS_ITERATIONS Default stress iterations (200)
+  CF_BUILD_CACHE_DIR  Override build cache location
+  CF_FORCE_REBUILD    Force rebuild (set to 1)
+  CF_NONINTERACTIVE   Disable prompts (set to 1)
+  CF_NO_EDITOR        Do not open VS Code after cf template (set to 1)
+  CF_SERVE_PROD       cf serve runs a production build (set to 1)
   CF_VERBOSE          Set to 1 for debug output
-    CF_CXXFLAGS         Override compiler flags
-    CF_TIMEOUT          Override execution timeout (seconds)
-    CF_BUILD_CACHE_DIR  Override build cache location
-    CF_FORCE_REBUILD    Force rebuild (set to 1)
-    CF_NONINTERACTIVE   Disable prompts (set to 1)
+  NO_COLOR            Disable colored output
 
-NEXT STEPS:
-  1. Start web interface: cf serve
-  2. Or CLI: cf template 1000A
-  3. Edit solution.cpp and run: cf problem.txt
+FILES:
+  problem.txt         Statement pasted from Codeforces; samples are parsed from Examples
+  solution.cpp        Your solution (every .cpp in the directory is compiled together)
+  brute.cpp, gen.cpp  Reference solution and input generator for cf stress
+  samples/N.in|.out   Optional explicit sample files used when problem.txt has none
+  .cfconfig           Optional shell snippet sourced for per-repo overrides
 
 For more information, visit: https://github.com/mbn-code/cf
-
 EOF
 }
 
@@ -1220,29 +1656,46 @@ main() {
     shift || true
 
     case "$command" in
-        template)
+        template|new)
             # Validate repo structure for template command
             if [ ! -d "$SRC_DIR" ]; then
                 error_exit "Repository structure not found. Expected $SRC_DIR" 2
             fi
             cmd_template "$@"
-            ;; 
+            ;;
         test)
-            # Validate repo structure for test command
             if [ ! -d "$SRC_DIR" ]; then
                 error_exit "Repository structure not found. Expected $SRC_DIR" 2
             fi
             cmd_test "$@"
-            ;; 
+            ;;
+        stress)
+            cmd_stress "$@"
+            ;;
+        samples)
+            cmd_samples "$@"
+            ;;
+        watch)
+            cmd_watch "$@"
+            ;;
         serve)
             cmd_serve "$@"
             ;;
+        doctor)
+            cmd_doctor "$@"
+            ;;
+        clean)
+            cmd_clean "$@"
+            ;;
         update)
             cmd_update "$@"
-            ;; 
+            ;;
+        version|--version|-V)
+            printf 'cf %s\n' "$CF_VERSION"
+            ;;
         help|--help|-h)
             cmd_help
-            ;; 
+            ;;
         "")
             # Auto-detect problem.txt if no args given
             if [ -f "$PWD/problem.txt" ]; then
@@ -1253,18 +1706,20 @@ main() {
                 printf '%s\n' "Commands:"
                 printf '%s\n' "  cf template <name>     Create new problem template"
                 printf '%s\n' "  cf [input]             Compile and run solution"
-                printf '%s\n' "  cf test                Run test suite"
-                printf '%s\n' "  cf update              Update to latest version"
+                printf '%s\n' "  cf test                Run all samples"
+                printf '%s\n' "  cf stress              Solution vs brute force"
+                printf '%s\n' "  cf serve               Start the web workbench"
+                printf '%s\n' "  cf doctor              Check the toolchain"
                 printf '%s\n' "  cf help                Show help"
                 printf '\n'
                 printf '%s\n' "For more information: cf help"
                 return 1
             fi
-            ;; 
+            ;;
         *)
             cmd_run "$command" "$@"
-            ;; 
+            ;;
     esac
 }
 
-main "$@"
\ No newline at end of file
+main "$@"
diff --git a/scripts/test.sh b/scripts/test.sh
index 26a5b67..39ac545 100755
--- a/scripts/test.sh
+++ b/scripts/test.sh
@@ -48,7 +48,6 @@ fi
 CXXFLAGS="-std=c++23 -O2 -Wall -Wextra"
 INCLUDE_FLAGS="-I$INCLUDE_DIR"
 DEFAULT_TIMEOUT=5  # seconds
-DEFAULT_MEMORY_LIMIT=256  # MB
 VERBOSE=0
 TIMEOUT_CMD="timeout"
 
@@ -133,6 +132,7 @@ compile_solution() {
 
     print_info "Compiling: $(basename "$source_file")"
 
+    # shellcheck disable=SC2086  # CXXFLAGS/INCLUDE_FLAGS are intentionally word-split
     if ! compiler_output=$($COMPILER $CXXFLAGS $INCLUDE_FLAGS "$source_file" -o "$binary_name" 2>&1); then
         print_failure "Compilation failed for $source_file"
         echo -e "${RED}${compiler_output}${NC}"
@@ -152,12 +152,13 @@ run_with_timeout() {
 
     local temp_output
     temp_output=$(mktemp)
-    trap "rm -f $temp_output" RETURN
-
-    # Run with timeout
-    if ! $TIMEOUT_CMD "$timeout_sec" "$binary" < "$input_file" > "$temp_output" 2>&1; then
-        local exit_code=$?
+    trap 'rm -f "$temp_output"' RETURN
 
+    # Run with timeout. Capture the real status: `$?` after `if !` is the
+    # negated result, not the program's exit code.
+    local exit_code=0
+    $TIMEOUT_CMD "$timeout_sec" "$binary" < "$input_file" > "$temp_output" 2>&1 || exit_code=$?
+    if [[ $exit_code -ne 0 ]]; then
         # Exit code 124 = timeout
         if [[ $exit_code -eq 124 ]]; then
             print_failure "TIMEOUT (exceeded ${timeout_sec}s)"
@@ -235,34 +236,16 @@ test_solution() {
     return 0
 }
 
-test_all_in_directory() {
-    local test_dir="$1"
-
-    if [[ ! -d "$test_dir" ]]; then
-        print_failure "Test directory not found: $test_dir"
-        return 1
-    fi
-
-    print_header "Running all tests in $test_dir"
-
-    find "$test_dir" -maxdepth 1 -name "*.cpp" -type f | sort | while read -r source_file; do
-        test_solution "$source_file" \
-            "${test_dir}/$(basename "$source_file" .cpp)_input.txt" \
-            "${test_dir}/$(basename "$source_file" .cpp)_output.txt" \
-            "$DEFAULT_TIMEOUT"
-    done
-}
-
 run_parser_tests() {
-    if [[ -f "$TESTS_DIR/parser_test.sh" ]]; then
-        print_header "Parser Tests"
-        if ! bash "$TESTS_DIR/parser_test.sh"; then
-            print_failure "Parser tests failed"
+    if [[ -f "$TESTS_DIR/cli_test.sh" ]]; then
+        print_header "CLI Tests"
+        if ! bash "$TESTS_DIR/cli_test.sh"; then
+            print_failure "CLI tests failed"
             return 1
         fi
-        print_success "Parser tests passed"
+        print_success "CLI tests passed"
     else
-        print_warning "Parser test script not found: $TESTS_DIR/parser_test.sh"
+        print_warning "CLI test script not found: $TESTS_DIR/cli_test.sh"
     fi
     return 0
 }
@@ -274,7 +257,7 @@ run_shellcheck() {
     fi
 
     print_header "ShellCheck"
-    if ! shellcheck "$PROJECT_ROOT/scripts/cf" "$PROJECT_ROOT/scripts/test.sh"; then
+    if ! shellcheck "$PROJECT_ROOT/scripts/cf" "$PROJECT_ROOT/scripts/test.sh" "$PROJECT_ROOT/scripts/check.sh" "$PROJECT_ROOT/tests/cli_test.sh"; then
         print_failure "ShellCheck reported issues"
         return 1
     fi
diff --git a/test_full.sh b/test_full.sh
deleted file mode 100755
index a3fdc8f..0000000
--- a/test_full.sh
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/bin/bash
-
-# Get the directory where the test script is located
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-CF_REPO_ROOT="$SCRIPT_DIR"
-
-echo "╔════════════════════════════════════════╗"
-echo "║  PRODUCTION READINESS TEST SUITE       ║"
-echo "╚════════════════════════════════════════╝"
-echo ""
-
-# Test 1: Makefile
-echo "Test 1: Makefile build system"
-cd "$CF_REPO_ROOT" && make all > /dev/null 2>&1 && echo "  Compilation: PASS" || echo "  Compilation: FAIL"
-echo ""
-
-# Test 2: CLI - Template creation
-echo "Test 2: CLI template creation"
-cd /tmp && rm -rf cf_test2 && mkdir cf_test2 && cd cf_test2
-bash "$CF_REPO_ROOT/scripts/cf" template 1000A > /dev/null 2>&1
-if [ -f "1000A/solution.cpp" ]; then
-  echo "  Template creation: PASS"
-else
-  echo "  Template creation: FAIL"
-fi
-echo ""
-
-# Test 3: Input validation
-echo "Test 3: Template input validation functions"
-cd "$CF_REPO_ROOT"
-if grep -q "validateRange" src/template.cpp && grep -q "canAdd" src/template.cpp; then
-  echo "  Input validation: PASS"
-else
-  echo "  Input validation: FAIL"
-fi
-echo ""
-
-# Test 4: Error handling
-echo "Test 4: Error handling in build system"
-echo "int main(){" > /tmp/test_bad.cpp
-if ! g++ -std=c++23 /tmp/test_bad.cpp -o /tmp/test_bad 2>/dev/null; then
-  echo "  Compilation error detection: PASS"
-else
-  echo "  Compilation error detection: FAIL"
-fi
-echo ""
-
-# Test 5: Timeout protection
-echo "Test 5: Timeout protection"
-if timeout 1 sleep 2 2>/dev/null; then
-  echo "  Timeout protection: FAIL"
-else
-  echo "  Timeout protection: PASS"
-fi
-echo ""
-
-# Test 6: Documentation
-echo "Test 6: Documentation completeness"
-cd "$CF_REPO_ROOT"
-doc_checks=0
-[ -f "README.md" ] && ((doc_checks++))
-[ -f "PRODUCTION_UPGRADE.md" ] && ((doc_checks++))
-[ -f "CONTRIBUTING.md" ] && ((doc_checks++))
-echo "  Documentation files: $doc_checks/3 present"
-echo ""
-
-# Test 7: Scripts executable
-echo "Test 7: Script permissions"
-scripts_ok=0
-[ -x "scripts/cf" ] && ((scripts_ok++))
-[ -x "scripts/test.sh" ] && ((scripts_ok++))
-[ -x "scripts/build.sh" ] && ((scripts_ok++))
-echo "  Executable scripts: $scripts_ok/3 ready"
-echo ""
-
-echo "╔════════════════════════════════════════╗"
-echo "║  PRODUCTION READINESS: COMPLETE        ║"
-echo "║  Status: READY FOR REAL-WORLD USE      ║"
-echo "╚════════════════════════════════════════╝"
diff --git a/tests/cli_test.sh b/tests/cli_test.sh
new file mode 100644
index 0000000..9c4e159
--- /dev/null
+++ b/tests/cli_test.sh
@@ -0,0 +1,275 @@
+#!/usr/bin/env bash
+#
+# tests/cli_test.sh - end-to-end tests for the `cf` command-line tool.
+#
+# Every case runs the real script against the real compiler in a throwaway
+# directory, so a green run proves statement parsing, sample comparison, the
+# checkers, stress testing and templating actually work on this machine.
+#
+# Usage: bash tests/cli_test.sh        (exit 0 = all cases passed)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+CF="$PROJECT_ROOT/scripts/cf"
+FIXTURE_DIR="$PROJECT_ROOT/tests/fixtures/231A"
+
+export NO_COLOR=1
+export CF_NO_EDITOR=1
+export CF_NONINTERACTIVE=1
+
+if [ ! -f "$CF" ]; then
+    printf '%s\n' "Error: cf script not found: $CF" >&2
+    exit 1
+fi
+if [ ! -f "$FIXTURE_DIR/problem.txt" ] || [ ! -f "$FIXTURE_DIR/solution.cpp" ]; then
+    printf '%s\n' "Error: fixture files missing in $FIXTURE_DIR" >&2
+    exit 1
+fi
+
+TMP_DIR="$(mktemp -d)"
+# Keep the build cache inside the sandbox so tests never touch the real one.
+export CF_BUILD_CACHE_DIR="$TMP_DIR/.cache"
+trap 'rm -rf "$TMP_DIR"' EXIT
+
+PASSED=0
+FAILED=0
+OUT=""
+
+run_cf() {
+    # Capture combined output and exit status without aborting the suite.
+    set +e
+    OUT=$(bash "$CF" "$@" 2>&1)
+    STATUS=$?
+    set -e
+}
+
+check() {
+    local name="$1"
+    local ok="$2"
+    if [ "$ok" -eq 0 ]; then
+        printf 'ok   %s\n' "$name"
+        PASSED=$((PASSED + 1))
+    else
+        printf 'FAIL %s\n' "$name"
+        printf '%s\n' "$OUT" | sed 's/^/     | /' | head -40
+        FAILED=$((FAILED + 1))
+    fi
+}
+
+expect_status() {
+    local name="$1" want="$2"
+    [ "$STATUS" -eq "$want" ]; check "$name (exit $want)" $?
+}
+
+expect_contains() {
+    local name="$1" needle="$2"
+    printf '%s' "$OUT" | grep -qF -- "$needle"; check "$name contains '$needle'" $?
+}
+
+expect_not_contains() {
+    local name="$1" needle="$2"
+    local found=0
+    printf '%s' "$OUT" | grep -qF -- "$needle" && found=1
+    check "$name lacks '$needle'" "$found"
+}
+
+# ---- version / help -------------------------------------------------------
+
+run_cf version
+expect_status "cf version" 0
+expect_contains "cf version" "cf "
+
+run_cf help
+expect_status "cf help" 0
+expect_contains "cf help" "stress"
+
+run_cf
+expect_status "cf with no args outside a problem" 1
+
+# ---- statement parsing on the real fixture --------------------------------
+
+mkdir -p "$TMP_DIR/231A"
+cp "$FIXTURE_DIR/problem.txt" "$FIXTURE_DIR/solution.cpp" "$TMP_DIR/231A/"
+pushd "$TMP_DIR/231A" > /dev/null
+
+run_cf problem.txt
+expect_status "run sample #1" 0
+expect_contains "run sample #1" "Output matches expected"
+
+run_cf problem.txt 2
+expect_status "run sample #2 (positional)" 0
+expect_contains "run sample #2 (positional)" "Output matches expected"
+
+run_cf --sample 2
+expect_status "run sample #2 (--sample)" 0
+
+run_cf --sample 9
+expect_status "run out-of-range sample falls back" 0
+expect_contains "run out-of-range sample" "only 2 found"
+
+run_cf test
+expect_status "cf test in problem dir" 0
+expect_contains "cf test" "Passed: 2"
+expect_contains "cf test" "Max time:"
+
+run_cf samples
+expect_status "cf samples" 0
+expect_contains "cf samples" "2 sample(s)"
+expect_contains "cf samples" "1 1 0"
+
+run_cf "3\n1 1 1\n1 1 1\n1 1 1"
+expect_status "inline input" 0
+expect_contains "inline input" "3"
+
+popd > /dev/null
+
+# `cf test <dir>` from outside the directory
+run_cf test "$TMP_DIR/231A"
+expect_status "cf test <dir> from outside" 0
+
+# An explicit argument must win over the cwd's problem.txt
+mkdir -p "$TMP_DIR/other"
+printf 'Examples\nInput\n1\nOutput\n2\n' > "$TMP_DIR/other/problem.txt"
+cat > "$TMP_DIR/other/solution.cpp" <<'EOF'
+#include <iostream>
+int main(){int x;std::cin>>x;std::cout<<x*2<<"\n";}
+EOF
+pushd "$TMP_DIR/other" > /dev/null
+run_cf test "$TMP_DIR/231A"
+expect_status "explicit problem beats cwd" 0
+expect_contains "explicit problem beats cwd" "231A"
+popd > /dev/null
+
+# ---- wrong answer, runtime error, timeout ---------------------------------
+
+mkdir -p "$TMP_DIR/wa"
+printf 'Examples\nInput\n1\nOutput\n5\n' > "$TMP_DIR/wa/problem.txt"
+cat > "$TMP_DIR/wa/solution.cpp" <<'EOF'
+#include <iostream>
+int main(){std::cout<<"4\n";}
+EOF
+run_cf test "$TMP_DIR/wa"
+expect_status "wrong answer fails" 1
+expect_contains "wrong answer" "FAILED"
+expect_contains "wrong answer shows diff" "Diff:"
+
+cat > "$TMP_DIR/wa/solution.cpp" <<'EOF'
+#include <cstdlib>
+int main(){std::abort();}
+EOF
+run_cf test "$TMP_DIR/wa"
+expect_status "runtime error fails" 1
+expect_contains "runtime error" "Runtime Error"
+
+if command -v timeout >/dev/null 2>&1 || command -v gtimeout >/dev/null 2>&1; then
+    cat > "$TMP_DIR/wa/solution.cpp" <<'EOF'
+int main(){for(;;){}}
+EOF
+    run_cf test "$TMP_DIR/wa" --timeout 1
+    expect_status "timeout fails" 1
+    expect_contains "timeout" "timeout"
+fi
+
+cat > "$TMP_DIR/wa/solution.cpp" <<'EOF'
+int main(){ return x; }
+EOF
+run_cf test "$TMP_DIR/wa"
+expect_status "compile error fails" 1
+expect_contains "compile error" "Compilation failed"
+
+# ---- checkers ---------------------------------------------------------------
+
+mkdir -p "$TMP_DIR/tok"
+printf 'Examples\nInput\n1\nOutput\n1 2 3\n' > "$TMP_DIR/tok/problem.txt"
+cat > "$TMP_DIR/tok/solution.cpp" <<'EOF'
+#include <cstdio>
+int main(){puts("1\n2\n3");}
+EOF
+run_cf test "$TMP_DIR/tok"
+expect_status "lines checker rejects layout difference" 1
+
+run_cf test "$TMP_DIR/tok" --checker tokens
+expect_status "tokens checker accepts layout difference" 0
+
+CF_CHECKER=tokens run_cf test "$TMP_DIR/tok"
+expect_status "CF_CHECKER env selects tokens" 0
+
+pushd "$TMP_DIR/tok" > /dev/null
+run_cf problem.txt
+expect_status "run reports whitespace-only mismatch" 1
+expect_contains "run whitespace hint" "only whitespace differs"
+popd > /dev/null
+
+run_cf test "$TMP_DIR/tok" --checker bogus
+expect_status "unknown checker is rejected" 2
+
+# ---- stress -----------------------------------------------------------------
+
+mkdir -p "$TMP_DIR/st"
+printf 'Examples\nInput\n2 3\nOutput\n5\n' > "$TMP_DIR/st/problem.txt"
+cat > "$TMP_DIR/st/solution.cpp" <<'EOF'
+#include <iostream>
+int main(){long long a,b;std::cin>>a>>b;std::cout<<(a+b>1500?a+b-1:a+b)<<"\n";}
+EOF
+cat > "$TMP_DIR/st/brute.cpp" <<'EOF'
+#include <iostream>
+int main(){long long a,b;std::cin>>a>>b;std::cout<<a+b<<"\n";}
+EOF
+cat > "$TMP_DIR/st/gen.cpp" <<'EOF'
+#include <iostream>
+#include <random>
+#include <cstdlib>
+int main(int c,char**v){std::mt19937 r(c>1?atoi(v[1]):0);std::cout<<r()%1000<<" "<<r()%1000<<"\n";}
+EOF
+run_cf stress "$TMP_DIR/st" -n 300
+expect_status "stress finds a counter-example" 1
+expect_contains "stress counter-example" "Counter-example found"
+[ -f "$TMP_DIR/st/stress_fail.txt" ]; check "stress saves stress_fail.txt" $?
+
+run_cf test "$TMP_DIR/st"
+expect_status "cf test ignores brute.cpp/gen.cpp" 0
+expect_not_contains "cf test ignores brute.cpp/gen.cpp" "Found 3 source"
+
+cp "$TMP_DIR/st/brute.cpp" "$TMP_DIR/st/solution.cpp"
+run_cf stress "$TMP_DIR/st" -n 50
+expect_status "stress passes for a correct solution" 0
+expect_contains "stress pass" "No counter-example in 50 iterations"
+
+# ---- template ---------------------------------------------------------------
+
+pushd "$TMP_DIR" > /dev/null
+run_cf template 1000A
+expect_status "cf template" 0
+[ -f 1000A/solution.cpp ] && [ -f 1000A/problem.txt ]; check "template creates files" $?
+
+run_cf template 1000A
+expect_status "cf template is idempotent" 0
+expect_contains "template idempotent" "already exists"
+
+run_cf template dpprob --from dp
+expect_status "cf template --from dp" 0
+grep -q "dp" dpprob/solution.cpp; check "template --from dp uses templates/dp.cpp" $?
+
+run_cf template "bad name"
+expect_status "invalid template name" 1
+
+run_cf template nope --from does-not-exist
+expect_status "unknown --from template" 3
+popd > /dev/null
+
+# ---- doctor / clean ---------------------------------------------------------
+
+run_cf doctor
+expect_status "cf doctor" 0
+expect_contains "cf doctor" "smoke test"
+
+run_cf clean
+expect_status "cf clean" 0
+[ ! -d "$CF_BUILD_CACHE_DIR" ]; check "clean removes the cache" $?
+
+# ---- summary ----------------------------------------------------------------
+
+printf '\n%d passed, %d failed\n' "$PASSED" "$FAILED"
+[ "$FAILED" -eq 0 ]
diff --git a/tests/parser_test.sh b/tests/parser_test.sh
deleted file mode 100755
index d464159..0000000
--- a/tests/parser_test.sh
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
-CF_SCRIPT="$PROJECT_ROOT/scripts/cf"
-FIXTURE_DIR="$PROJECT_ROOT/tests/fixtures/231A"
-
-if [ ! -f "$CF_SCRIPT" ]; then
-    printf '%s\n' "Error: cf script not found: $CF_SCRIPT" >&2
-    exit 1
-fi
-
-if [ ! -f "$FIXTURE_DIR/problem.txt" ] || [ ! -f "$FIXTURE_DIR/solution.cpp" ]; then
-    printf '%s\n' "Error: fixture files missing in $FIXTURE_DIR" >&2
-    exit 1
-fi
-
-TMP_DIR="$(mktemp -d)"
-trap 'rm -rf "$TMP_DIR"' EXIT
-
-cp "$FIXTURE_DIR/problem.txt" "$TMP_DIR/problem.txt"
-cp "$FIXTURE_DIR/solution.cpp" "$TMP_DIR/solution.cpp"
-
-pushd "$TMP_DIR" > /dev/null
-
-printf '%s\n' "Running parser sample #1..."
-bash "$CF_SCRIPT" problem.txt > /dev/null
-
-printf '%s\n' "Running parser sample #2 (positional)..."
-bash "$CF_SCRIPT" problem.txt 2 > /dev/null
-
-printf '%s\n' "Running parser sample #2 (--sample)..."
-bash "$CF_SCRIPT" --sample 2 > /dev/null
-
-popd > /dev/null
-
-printf '%s\n' "Parser tests passed."

From 4d8f54e4d484149a7fb20f650e05bcf01e977781 Mon Sep 17 00:00:00 2001
From: mbn <66748817+mbn-code@users.noreply.github.com>
Date: Tue, 15 Sep 2026 20:57:54 +0200
Subject: [PATCH 4/7] chore(tooling): quality gate, CI and release workflows,
 LF line endings

- scripts/check.sh and `make check`: shellcheck, CLI tests, lint, typecheck,
  unit tests, production build and a CLI/web version-consistency check
- Makefile: check, check-quick, validate and web-* targets; shared source
  resolution for build/run/test/debug
- GitHub Actions CI on Ubuntu and macOS (CLI, web, Playwright) and a release
  workflow that publishes the CHANGELOG section for a pushed v* tag
- .gitattributes pins LF for scripts and C++ sources so Windows checkouts
  run unchanged
---
 .gitattributes                |  15 ++++
 .github/workflows/ci.yml      | 123 +++++++++++++++++++++++++++++++++
 .github/workflows/release.yml |  43 ++++++++++++
 Makefile                      |  84 ++++++++++++++++-------
 scripts/check.sh              | 125 ++++++++++++++++++++++++++++++++++
 5 files changed, 367 insertions(+), 23 deletions(-)
 create mode 100644 .gitattributes
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 .github/workflows/release.yml
 create mode 100644 scripts/check.sh

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..77fa1df
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,15 @@
+# Normalise line endings so shell scripts and the C++ shim run unchanged on
+# Windows (Git Bash / WSL) checkouts. Binaries are left untouched.
+* text=auto
+
+scripts/cf     text eol=lf
+*.sh           text eol=lf
+Makefile       text eol=lf
+*.cpp          text eol=lf
+*.h            text eol=lf
+*.c++          text eol=lf
+
+*.png  binary
+*.ico  binary
+*.jpg  binary
+*.gif  binary
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..0cea9dd
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,123 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  cli:
+    name: CLI (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install shellcheck (macOS)
+        if: runner.os == 'macOS'
+        run: brew install shellcheck coreutils
+
+      - name: shellcheck
+        run: shellcheck -s bash scripts/cf scripts/check.sh scripts/test.sh scripts/validate.sh tests/cli_test.sh
+
+      - name: Toolchain
+        run: |
+          which g++ clang++ || true
+          (g++ --version || clang++ --version) | head -1
+
+      - name: CLI test suite
+        run: bash tests/cli_test.sh
+
+      - name: Makefile smoke test
+        run: |
+          make all
+          make test FILE=watermelon
+
+  web:
+    name: Web (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    defaults:
+      run:
+        working-directory: web
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: web/package-lock.json
+
+      - name: Install
+        run: npm ci --include=dev --no-audit --no-fund
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Typecheck
+        run: npm run typecheck
+
+      - name: Unit tests
+        run: npm test
+
+      - name: Build
+        run: npm run build
+
+      - name: Version consistency
+        working-directory: .
+        run: |
+          cli=$(sed -n 's/^CF_VERSION="\(.*\)"$/\1/p' scripts/cf)
+          pkg=$(node -p "require('./web/package.json').version")
+          test "$cli" = "$pkg" || { echo "scripts/cf=$cli web/package.json=$pkg"; exit 1; }
+
+  e2e:
+    name: End-to-end (Playwright)
+    runs-on: ubuntu-latest
+    needs: [web]
+    defaults:
+      run:
+        working-directory: web
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: web/package-lock.json
+
+      - name: Install
+        run: npm ci --include=dev --no-audit --no-fund
+
+      - name: Install Playwright browser
+        run: npx playwright install --with-deps chromium
+
+      - name: Playwright
+        run: npx playwright test
+        env:
+          CI: "1"
+
+      - name: Upload report on failure
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-report
+          path: |
+            web/playwright-report
+            web/test-results
+          retention-days: 7
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..9229ff9
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,43 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    name: Publish GitHub release
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check the tag matches the shipped version
+        run: |
+          tag="${GITHUB_REF_NAME#v}"
+          cli=$(sed -n 's/^CF_VERSION="\(.*\)"$/\1/p' scripts/cf)
+          pkg=$(node -p "require('./web/package.json').version")
+          test "$tag" = "$cli" && test "$tag" = "$pkg" || {
+            echo "tag=$tag scripts/cf=$cli web/package.json=$pkg"; exit 1; }
+
+      - name: Extract release notes from CHANGELOG.md
+        id: notes
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          awk -v v="$version" '
+            /^## / { if (found) exit; if (index($0, "[" v "]") || index($0, " " v " ") || $2 == v) { found = 1; next } }
+            found { print }
+          ' CHANGELOG.md > release-notes.md
+          if [ ! -s release-notes.md ]; then
+            echo "No CHANGELOG section for $version; using git log" >&2
+            git log --format='- %s' "$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || git rev-list --max-parents=0 HEAD)..HEAD" > release-notes.md
+          fi
+          cat release-notes.md
+
+      - name: Create release
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: release-notes.md
+          generate_release_notes: false
diff --git a/Makefile b/Makefile
index 2a9b283..865a26f 100644
--- a/Makefile
+++ b/Makefile
@@ -8,6 +8,14 @@
 #   make run FILE=x      - Compile and run, with a portable timeout + timing
 #   make test FILE=x     - Compile and run against src/x/input.txt, diff expected
 #   make debug FILE=x    - Compile with debug symbols (-g)
+#   make check           - Shellcheck + CLI tests + web lint/typecheck/unit/build
+#   make check-quick     - Same without the production build
+#   make web-install     - npm install in web/
+#   make web-dev         - Start the workbench dev server
+#   make web-build       - Production build of the workbench
+#   make web-test        - Unit tests (vitest)
+#   make web-e2e         - Playwright end-to-end suite
+#   make validate        - Full release gate (scripts/validate.sh)
 #   make clean           - Remove build artifacts
 #   make help            - Show this help
 #
@@ -27,7 +35,7 @@
 #     works on macOS (bash 3.2 / zsh) without coreutils.
 ################################################################################
 
-.PHONY: all build run test debug clean help
+.PHONY: all build run test debug clean help check check-quick web-install web-dev web-build web-test web-e2e validate
 
 # ==================== Configuration ====================
 
@@ -39,12 +47,22 @@ CXXFLAGS ?= -std=$(CXXSTD) -O2 -Wall -Wextra
 INCLUDE := -I include
 SRC_DIR := src
 BUILD_DIR := build
+WEB_DIR := web
 FILE    ?= solution
 TL      ?= 5
 
 .DEFAULT_GOAL := help
 
-# ==================== Targets ====================
+# Resolve FILE to a source path (shared by build/run/test/debug).
+define resolve_src
+	src=""; \
+	if [ -f "$(SRC_DIR)/$(FILE).cpp" ]; then src="$(SRC_DIR)/$(FILE).cpp"; \
+	elif [ -f "$(SRC_DIR)/$(FILE)/solution.cpp" ]; then src="$(SRC_DIR)/$(FILE)/solution.cpp"; \
+	elif [ -f "$(FILE)" ]; then src="$(FILE)"; fi; \
+	if [ -z "$$src" ]; then echo "error: cannot find source for FILE=$(FILE)"; exit 1; fi
+endef
+
+# ==================== C++ targets ====================
 
 all:
 	@mkdir -p $(BUILD_DIR); \
@@ -62,22 +80,14 @@ all:
 
 build:
 	@mkdir -p $(BUILD_DIR); \
-	src=""; \
-	if [ -f "$(SRC_DIR)/$(FILE).cpp" ]; then src="$(SRC_DIR)/$(FILE).cpp"; \
-	elif [ -f "$(SRC_DIR)/$(FILE)/solution.cpp" ]; then src="$(SRC_DIR)/$(FILE)/solution.cpp"; \
-	elif [ -f "$(FILE)" ]; then src="$(FILE)"; fi; \
-	if [ -z "$$src" ]; then echo "error: cannot find source for FILE=$(FILE)"; exit 1; fi; \
+	$(resolve_src); \
 	out="$(BUILD_DIR)/$(FILE)"; mkdir -p "`dirname "$$out"`"; \
 	echo "Compiling $$src -> $$out with $(CXX) ..."; \
 	$(CXX) $(CXXFLAGS) $(INCLUDE) "$$src" -o "$$out" && echo "OK: $$out"
 
 run:
 	@mkdir -p $(BUILD_DIR); \
-	src=""; \
-	if [ -f "$(SRC_DIR)/$(FILE).cpp" ]; then src="$(SRC_DIR)/$(FILE).cpp"; \
-	elif [ -f "$(SRC_DIR)/$(FILE)/solution.cpp" ]; then src="$(SRC_DIR)/$(FILE)/solution.cpp"; \
-	elif [ -f "$(FILE)" ]; then src="$(FILE)"; fi; \
-	if [ -z "$$src" ]; then echo "error: cannot find source for FILE=$(FILE)"; exit 1; fi; \
+	$(resolve_src); \
 	bin="$(BUILD_DIR)/cf_run_bin"; \
 	echo "Compiling $$src with $(CXX) ..."; \
 	if ! $(CXX) $(CXXFLAGS) $(INCLUDE) "$$src" -o "$$bin"; then echo "compile failed"; exit 1; fi; \
@@ -100,11 +110,7 @@ run:
 
 test:
 	@mkdir -p $(BUILD_DIR); \
-	src=""; \
-	if [ -f "$(SRC_DIR)/$(FILE).cpp" ]; then src="$(SRC_DIR)/$(FILE).cpp"; \
-	elif [ -f "$(SRC_DIR)/$(FILE)/solution.cpp" ]; then src="$(SRC_DIR)/$(FILE)/solution.cpp"; \
-	elif [ -f "$(FILE)" ]; then src="$(FILE)"; fi; \
-	if [ -z "$$src" ]; then echo "error: cannot find source for FILE=$(FILE)"; exit 1; fi; \
+	$(resolve_src); \
 	bin="$(BUILD_DIR)/cf_test_bin"; \
 	echo "Compiling $$src with $(CXX) ..."; \
 	if ! $(CXX) $(CXXFLAGS) $(INCLUDE) "$$src" -o "$$bin"; then echo "compile failed"; exit 1; fi; \
@@ -129,11 +135,7 @@ test:
 
 debug:
 	@mkdir -p $(BUILD_DIR); \
-	src=""; \
-	if [ -f "$(SRC_DIR)/$(FILE).cpp" ]; then src="$(SRC_DIR)/$(FILE).cpp"; \
-	elif [ -f "$(SRC_DIR)/$(FILE)/solution.cpp" ]; then src="$(SRC_DIR)/$(FILE)/solution.cpp"; \
-	elif [ -f "$(FILE)" ]; then src="$(FILE)"; fi; \
-	if [ -z "$$src" ]; then echo "error: cannot find source for FILE=$(FILE)"; exit 1; fi; \
+	$(resolve_src); \
 	out="$(BUILD_DIR)/$(FILE)_debug"; mkdir -p "`dirname "$$out"`"; \
 	echo "Compiling $$src with debug symbols ..."; \
 	$(CXX) $(CXXFLAGS) -g $(INCLUDE) "$$src" -o "$$out" && echo "Debug binary: $$out"
@@ -143,10 +145,38 @@ clean:
 	find $(SRC_DIR) -name '*.o' -delete 2>/dev/null || true; \
 	echo "Cleaned build artifacts"
 
+# ==================== Quality gates ====================
+
+check:
+	@bash scripts/check.sh
+
+check-quick:
+	@bash scripts/check.sh --quick
+
+validate:
+	@bash scripts/validate.sh
+
+# ==================== Web workbench ====================
+
+web-install:
+	@cd $(WEB_DIR) && npm install --include=dev --no-audit --no-fund
+
+web-dev:
+	@cd $(WEB_DIR) && npm run dev
+
+web-build:
+	@cd $(WEB_DIR) && npm run build
+
+web-test:
+	@cd $(WEB_DIR) && npm test
+
+web-e2e:
+	@cd $(WEB_DIR) && npx playwright install chromium && npm run e2e
+
 help:
 	@echo "cf Makefile - portable C++ build/run/test"; \
 	echo ""; \
-	echo "Targets:"; \
+	echo "C++ targets:"; \
 	echo "  make all            Compile every src/**/*.cpp into build/"; \
 	echo "  make build FILE=x   Compile one source"; \
 	echo "  make run FILE=x     Compile and run (timeout $(TL)s, timed)"; \
@@ -154,6 +184,14 @@ help:
 	echo "  make debug FILE=x   Compile with -g"; \
 	echo "  make clean          Remove build artifacts"; \
 	echo ""; \
+	echo "Quality gates:"; \
+	echo "  make check          shellcheck + CLI tests + web lint/typecheck/unit/build"; \
+	echo "  make check-quick    Same, without the production build"; \
+	echo "  make validate       Full release gate incl. Playwright e2e"; \
+	echo ""; \
+	echo "Web workbench:"; \
+	echo "  make web-install | web-dev | web-build | web-test | web-e2e"; \
+	echo ""; \
 	echo "Knobs: FILE, TL (time limit s), CXXSTD, CXXFLAGS, CXX"; \
 	echo "Compiler: $(CXX)"; \
 	echo "Flags:    $(CXXFLAGS) $(INCLUDE)"; \
diff --git a/scripts/check.sh b/scripts/check.sh
new file mode 100644
index 0000000..e83fc9f
--- /dev/null
+++ b/scripts/check.sh
@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+
+################################################################################
+# check.sh - Fast local quality gate (what CI runs, minus the browser suite)
+#
+#   1. shellcheck on every shell script
+#   2. CLI test suite            (tests/cli_test.sh, real compiler)
+#   3. web: lint + typecheck     (eslint, tsc --noEmit)
+#   4. web: unit tests           (vitest, real compiler)
+#   5. web: production build     (next build)
+#
+# Usage:
+#   bash scripts/check.sh            # everything
+#   bash scripts/check.sh --quick    # skip the production build
+#   bash scripts/check.sh --no-web   # shell + CLI only
+#
+# For the full end-to-end gate (Playwright against a production build) run
+# scripts/validate.sh instead.
+################################################################################
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+WEB_DIR="$REPO_ROOT/web"
+
+QUICK=0
+WEB=1
+for arg in "$@"; do
+    case "$arg" in
+        --quick) QUICK=1 ;;
+        --no-web) WEB=0 ;;
+        -h|--help) sed -n '3,20p' "$0"; exit 0 ;;
+        *) printf 'Unknown option: %s\n' "$arg" >&2; exit 2 ;;
+    esac
+done
+
+if [ -t 1 ] && [ -z "${NO_COLOR:-}" ]; then
+    BLUE='\033[0;34m'; GREEN='\033[0;32m'; RED='\033[0;31m'; YELLOW='\033[1;33m'; NC='\033[0m'
+else
+    BLUE=''; GREEN=''; RED=''; YELLOW=''; NC=''
+fi
+
+step()    { printf '%b\n' "${BLUE}==> $1${NC}"; }
+ok()      { printf '%b\n' "${GREEN}PASS: $1${NC}"; }
+warn()    { printf '%b\n' "${YELLOW}WARN: $1${NC}"; }
+fail()    { printf '%b\n' "${RED}FAIL: $1${NC}" >&2; exit 1; }
+
+STARTED=$(date +%s)
+
+# ---- 1. shellcheck ----------------------------------------------------------
+
+step "[1/5] shellcheck"
+SHELL_FILES=(
+    "$REPO_ROOT/scripts/cf"
+    "$REPO_ROOT/scripts/check.sh"
+    "$REPO_ROOT/scripts/test.sh"
+    "$REPO_ROOT/scripts/validate.sh"
+    "$REPO_ROOT/tests/cli_test.sh"
+)
+if command -v shellcheck >/dev/null 2>&1; then
+    # Windows checkouts may carry CRLF; lint an LF copy so the verdict matches CI.
+    tmp=$(mktemp -d)
+    trap 'rm -rf "$tmp"' EXIT
+    for f in "${SHELL_FILES[@]}"; do
+        name=$(basename "$f")
+        tr -d '\r' < "$f" > "$tmp/$name"
+    done
+    (cd "$tmp" && shellcheck -s bash ./*) || fail "shellcheck reported issues"
+    ok "shellcheck clean (${#SHELL_FILES[@]} files)"
+else
+    warn "shellcheck not installed; skipping"
+fi
+
+# ---- 2. CLI tests ---------------------------------------------------------------
+
+step "[2/5] CLI test suite"
+bash "$REPO_ROOT/tests/cli_test.sh" | tail -1 || fail "CLI tests failed"
+ok "CLI tests passed"
+
+if [ "$WEB" -eq 0 ]; then
+    ok "done in $(( $(date +%s) - STARTED ))s (web checks skipped)"
+    exit 0
+fi
+
+# ---- 3. web lint + typecheck ---------------------------------------------------
+
+cd "$WEB_DIR"
+command -v npm >/dev/null 2>&1 || fail "npm not found; install Node.js 20+"
+if [ ! -d node_modules ]; then
+    step "installing web dependencies"
+    npm install --include=dev --no-audit --no-fund
+fi
+
+step "[3/5] web lint + typecheck"
+npm run --silent lint || fail "eslint reported issues"
+npm run --silent typecheck || fail "typecheck failed"
+ok "lint + typecheck clean"
+
+# ---- 4. unit tests -----------------------------------------------------------------
+
+step "[4/5] web unit tests (vitest)"
+npm run --silent test || fail "unit tests failed"
+ok "unit tests passed"
+
+# ---- 5. production build ----------------------------------------------------------
+
+if [ "$QUICK" -eq 1 ]; then
+    warn "skipping production build (--quick)"
+else
+    step "[5/5] production build"
+    npm run --silent build > /dev/null || fail "next build failed"
+    ok "production build succeeded"
+fi
+
+# ---- version consistency ---------------------------------------------------------
+
+CLI_VERSION=$(sed -n 's/^CF_VERSION="\(.*\)"$/\1/p' "$REPO_ROOT/scripts/cf" | tr -d '\r')
+PKG_VERSION=$(node -p "require('./package.json').version")
+if [ "$CLI_VERSION" != "$PKG_VERSION" ]; then
+    fail "version mismatch: scripts/cf says $CLI_VERSION, web/package.json says $PKG_VERSION"
+fi
+ok "version $PKG_VERSION consistent across CLI and web"
+
+ok "all checks passed in $(( $(date +%s) - STARTED ))s"

From ebfc392c203d66d32d0d254a837946be29b00bda Mon Sep 17 00:00:00 2001
From: mbn <66748817+mbn-code@users.noreply.github.com>
Date: Tue, 15 Sep 2026 20:58:00 +0200
Subject: [PATCH 5/7] docs: rewrite for 1.0.0 (features, API, architecture,
 development, troubleshooting)

- README: CLI and workbench feature overview, quick start for both, updated
  repository map and command table
- docs: every new panel feature, CLI command and option; the compile cache,
  checkers, statement parser, flag allowlist and store in architecture.md;
  every route contract in api.md; quality gates, test suites, CI and the
  release procedure in development.md; new troubleshooting entries for
  ignored flags, the cache, checkers, statement import and Windows
- CHANGELOG.md for 1.0.0; CONTRIBUTING reflects the test layers and gate;
  SECURITY describes the local-only threat model and private reporting
---
 CHANGELOG.md            | 122 +++++++++++++
 CONTRIBUTING.md         | 164 ++++++++++-------
 README.md               | 222 +++++++++++++++--------
 SECURITY.md             |  45 ++++-
 docs/README.md          |  45 ++---
 docs/UPDATE_COMMAND.md  |  11 +-
 docs/api.md             | 383 ++++++++++++++++++++++++----------------
 docs/architecture.md    | 353 +++++++++++++++++-------------------
 docs/development.md     | 235 +++++++++++++++++-------
 docs/features.md        | 278 ++++++++++++++++++++---------
 docs/troubleshooting.md | 189 +++++++++++++-------
 11 files changed, 1318 insertions(+), 729 deletions(-)
 create mode 100644 CHANGELOG.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..37e6d61
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,122 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/).
+
+## [1.0.0] - 2026-09-15
+
+First tagged release. Everything below is relative to the untagged workbench
+that preceded it.
+
+### Added
+
+**Execution engine**
+
+- Compile cache keyed by compiler, standard, flags and source. Re-running
+  unchanged code, or running one program against many test cases, no longer
+  rebuilds it. Identical concurrent compiles are coalesced; entries are
+  evicted least-recently-used and the cache is reclaimed on exit.
+- Structured compiler diagnostics (`file:line:col: severity: message`) parsed
+  from gcc/clang output and returned by every compile.
+- Output checkers: `lines` (default), `tokens` (whitespace-insensitive, the
+  Codeforces `wcmp` behaviour) and `float` (absolute/relative epsilon). A `WA`
+  whose tokens match is flagged `presentationOnly`.
+- Statement parser that turns a pasted Codeforces (or AtCoder-style) problem
+  into sample tests plus the declared time and memory limits.
+- Windows support for the engine (`prog.exe`, path normalisation in
+  diagnostics).
+
+**API**
+
+- `POST /api/samples` parses a statement into tests and limits.
+- `GET /api/problems?export=1` and `POST /api/problems {op:"import"}` move a
+  whole library as one JSON bundle; `{op:"duplicate"}` copies a problem.
+- `/api/test` accepts `checker`, `epsilon` and `stopOnFirstFailure`, and
+  reports `SKIPPED` cases, `maxTimeMs` and `totalTimeMs`.
+- `/api/stress` accepts `compilerFlags`, `checker`, `epsilon` and `seedBase`,
+  and reports `elapsedMs`, `deadlineHit` and per-program timing statistics.
+- `GET /api/config` reports the workbench version, compiler version, limits
+  and cache size; `DELETE /api/config?cache=1` drops the compile cache.
+- `GET /api/template` lists the bundled starter templates.
+- Every compile response carries `cached`, `diagnostics` and `rejectedFlags`.
+
+**Web workbench**
+
+- Gutter error/warning markers, a clickable diagnostics list that jumps to the
+  line, an error/warning count in the toolbar and a cursor/line/char status
+  bar. `Ctrl+/` toggles line comments.
+- Tests panel: import samples from a pasted statement, run a single case,
+  duplicate a case, send a case's input to stdin, expand/collapse all, stop on
+  first failure, whitespace-only hints, per-run max time.
+- Stress panel: seed base, timing statistics, request-budget notice, and
+  buttons that promote the failing input to a test case or to stdin.
+- Settings: checker mode and epsilon, reset to defaults, clear the server
+  compile cache, and a read-only server section (compiler, limits, cache).
+- Problems sidebar: whole-workspace save (source, statement, tests, stdin,
+  stress sources, settings), duplicate, filter, relative timestamps, unsaved
+  changes indicator, new-workspace button, export/import of the library.
+- Resizable editor/panel split (double-click resets), the active tab and the
+  custom stdin persist across reloads, `Ctrl/Cmd+1..4` switch panels,
+  `Ctrl/Cmd+B` toggles the sidebar, and the header shows the detected
+  compiler.
+- Toasts for run/test outcomes and an offline-aware API client.
+
+**CLI (`scripts/cf`)**
+
+- New commands: `stress`, `samples`, `watch`, `doctor`, `clean`, `version`,
+  plus `new` as an alias for `template`.
+- `template --from dp|graph|math|<file>` scaffolds from a bundled starter.
+- `--checker lines|tokens` (or `CF_CHECKER`) on `run`, `test` and `stress`;
+  a lines-mode mismatch whose tokens match prints a hint.
+- `--timeout` on `run`, `test` and `stress`; per-sample and maximum timing in
+  `cf test`; `CF_CXX`/`CXX` compiler override; `NO_COLOR`; `CF_NO_EDITOR`;
+  `CF_SERVE_PROD`.
+- `brute.cpp`, `gen.cpp` and `generator.cpp` are excluded from the solution
+  build so a stress setup lives next to the solution.
+
+**Tooling**
+
+- Vitest unit suite for the engine (compile, cache, TLE/RE classification,
+  output caps, checkers, diagnostics, flag validation, statement parsing and
+  the store), run with `npm test`.
+- `tests/cli_test.sh`: 57 end-to-end checks of the CLI against the real
+  compiler (replaces `tests/parser_test.sh` and `test_full.sh`).
+- Five new Playwright specs covering diagnostics, statement import, checkers,
+  run-one, stress promotion and the problems library.
+- `scripts/check.sh` / `make check`: shellcheck, CLI tests, lint, typecheck,
+  unit tests, production build and a version-consistency check.
+- GitHub Actions: CI on Ubuntu and macOS (CLI, web, Playwright) and a release
+  workflow that publishes the CHANGELOG section for a pushed `v*` tag.
+- `.gitattributes` pins LF line endings for scripts and sources so Windows
+  checkouts run unchanged.
+
+### Changed
+
+- Compiler flags from the browser are validated against an allowlist
+  (`-O`, `-W`, `-D`, `-U`, `-f`, `-g`, `-m`, `-std=`, ...). Flags that write
+  files or load code (`-o`, `-include`, `@file`, `-fplugin`, `-Wl,` ...) are
+  rejected and reported.
+- `/api/solution` and `/api/problem-text` reject problem names that are not a
+  single safe path segment, closing a path-traversal hole. Malformed JSON on
+  any route now yields a 400 instead of a 500.
+- The problem store writes atomically (temp file + rename) and tolerates
+  records written by older versions.
+- The stress request budget is 60 seconds (was 30).
+- `cf test <name>` honours the explicit argument even when the working
+  directory contains a `problem.txt`.
+- `cf update` pulls with `--ff-only` and can skip setup with
+  `CF_UPDATE_SKIP_SETUP=1`.
+- `scripts/test.sh` reports the program's real exit status (previously the
+  negated `if !` status), lints every script and delegates to the CLI suite.
+- Version bumped to 1.0.0 in `scripts/cf` and `web/package.json`; CI fails if
+  they diverge.
+
+### Removed
+
+- `web/lib/cf.ts` (an unused wrapper that spawned the Bash CLI from Node).
+- Unused Next.js scaffold assets under `web/public/`.
+- `test_full.sh` and `tests/parser_test.sh` (superseded by
+  `tests/cli_test.sh` and `scripts/check.sh`).
+
+[1.0.0]: https://github.com/mbn-code/cf/releases/tag/v1.0.0
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index de2830f..4796d97 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,87 +1,131 @@
-# Contributing to cf Toolkit
+# Contributing to cf
 
-First off, thanks for taking the time to contribute! Contributions are what make the open-source community such an amazing place to learn, inspire, and create.
+Thanks for taking the time to contribute. This page covers how to report
+problems, how the repository is laid out, and what a pull request needs to
+pass.
 
-## How Can I Contribute?
+## How can I contribute?
 
-### Reporting Bugs
-- Use the [Bug Report Template](.github/ISSUE_TEMPLATE/bug_report.yml).
-- Provide a clear and concise description of the bug.
-- Include reproduction steps and your environment details.
+### Reporting bugs
 
-### Suggesting Enhancements
-- Use the [Feature Request Template](.github/ISSUE_TEMPLATE/feature_request.yml).
-- Explain why the feature would be useful.
+- Use the [bug report template](.github/ISSUE_TEMPLATE/bug_report.yml).
+- Include the output of `cf doctor` (or the Server block of the Settings tab)
+  so we know the compiler and platform.
+- Provide reproduction steps: the source, the input, and what you expected.
 
-### Pull Requests
-1. Fork the repo and create your branch from `main`.
-2. If you've added code that should be tested, add tests.
-3. Ensure the test suite passes.
-4. Make sure your code follows the existing style.
-5. Write a clear title and description for your pull request.
+### Suggesting enhancements
 
-> [!IMPORTANT]
-> Always run `npm run lint` and `npm run build` in the `web` directory before submitting a PR to catch any TypeScript or styling errors.
+- Use the [feature request template](.github/ISSUE_TEMPLATE/feature_request.yml).
+- Explain the workflow the feature would improve.
 
-## Development Setup
+### Pull requests
 
-### CLI Development
-The core logic resides in `scripts/`. If you modify `cf`, `test.sh`, or `build.sh`, make sure to test them across different problem structures.
+1. Fork the repository and create your branch from `main`.
+2. Add or update tests for the behaviour you change (see below).
+3. Run `make check` and make sure it is green.
+4. Match the surrounding style; the formatter runs on save for the web app.
+5. Write a clear title and description, and add a `CHANGELOG.md` entry under
+   an `Unreleased` heading for user-visible changes.
 
-> [!WARNING]
-> Be careful when modifying the `cf` script's path resolution logic, as it needs to work for both local clones and global installations.
+## Development setup
+
+### CLI
+
+The CLI is the single Bash script `scripts/cf`. It must keep working for
+both a local clone and a global installation (see the path resolution at the
+top of the script), on Linux, macOS (bash 3.2 and zsh) and Git Bash on
+Windows.
 
 ```bash
-# Test the CLI locally
-./scripts/cf --version
+bash scripts/cf doctor          # toolchain check
+bash tests/cli_test.sh          # 50+ end-to-end checks against the real compiler
+shellcheck -s bash scripts/cf   # must be clean
 ```
 
-### Web Interface Development
-The web interface is built with **Next.js 15**, **Tailwind CSS 4**, and **Shadcn UI**.
+### Web workbench
+
+The workbench is built with Next.js 16, React 19, Tailwind CSS 4 and
+shadcn/ui. The execution engine under `web/app/api/_engine/` uses only Node
+built-ins so it can be unit-tested without the framework.
 
 ```bash
 cd web
 npm install
-npm run dev
+npm run dev        # http://localhost:3000
+npm test           # vitest unit suite
+npm run e2e        # Playwright (npx playwright install chromium once)
+npm run check      # lint + typecheck + test + build
 ```
 
-The web interface communicates with the local filesystem via API routes in `web/app/api/`.
+Every `/api/*` route documents its request and response shape in a comment
+at the top of the file and in [docs/api.md](docs/api.md); keep the comment,
+the doc and the typed client in `web/lib/api.ts` in sync when you change a
+contract.
+
+## Project structure
+
+- `scripts/`: the `cf` CLI, `check.sh` (local quality gate), `validate.sh`
+  (release gate), `test.sh`, `build.sh`, `setup.sh`.
+- `web/`: the Next.js workbench (UI, API routes, engine, unit and e2e tests).
+- `src/`: sample solutions and the CLI template (`template.cpp`).
+- `templates/`: C++ starters used by `cf template --from`.
+- `include/`: the portable `<bits/stdc++.h>` shim.
+- `tests/`: the CLI suite and its fixtures.
+- `docs/`: user and developer documentation.
 
-## Project Structure
+## Tests
 
-- `scripts/`: Core bash tools.
-- `web/`: Next.js web workbench.
-- `src/`: User solutions area.
-- `templates/`: C++ algorithm templates.
-- `include/`: Shared C++ headers.
-- `tests/`: Automated test suite for the toolkit itself.
+| Layer   | Command                  | What it proves                                                   |
+| ------- | ------------------------ | ---------------------------------------------------------------- |
+| Engine  | `cd web && npm test`     | Compile cache, verdict classification, checkers, parsers, store. |
+| CLI     | `bash tests/cli_test.sh` | Real `cf` runs against the real compiler.                        |
+| Browser | `cd web && npm run e2e`  | The whole workbench end to end in Chromium.                      |
+| Gate    | `make check`             | shellcheck, CLI, lint, typecheck, unit tests, build, versions.   |
 
-## Style Guidelines
+Tests must be able to fail for a real reason. Prefer exercising the real
+compiler over mocking it.
+
+## Style guidelines
 
 ### Bash
-- Use `[[ ]]` instead of `[ ]` for conditions.
-- Quote variables to prevent word splitting.
-- Use meaningful names for functions.
+
+- `set -euo pipefail`, quote every expansion, prefer `[ ]` with explicit
+  tests as the existing script does, and keep shellcheck clean.
+- New commands get a `cmd_<name>` function, a `case` entry in `main`, a help
+  entry, and CLI tests.
 
 ### C++
+
 - Follow the patterns in `src/template.cpp`.
-- Use modern C++ features (C++20/23).
-- Keep performance in mind (Fast I/O, efficient algorithms).
-
-### TypeScript/React
-- Use functional components and hooks.
-- Follow Tailwind CSS best practices.
-- Ensure components are accessible.
-
-## Commit Messages
-We follow a simple convention for commit messages:
-- `feat:` for new features.
-- `fix:` for bug fixes.
-- `docs:` for documentation changes.
-- `refactor:` for code changes that neither fix a bug nor add a feature.
-- `chore:` for updating build tasks, etc.
-
-Example: `feat: add support for interactive problems in web UI`
-
-## Code of Conduct
-Please note that this project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms.
+- Anything shipped as a template must compile with `-std=c++23 -Wall -Wextra`
+  and against the shim.
+
+### TypeScript / React
+
+- Functional components and hooks; keep the API tree free of imports from
+  `web/lib`.
+- Expose a stable `data-testid` on anything the e2e suite needs.
+- Guard every `localStorage` access so server rendering keeps working.
+
+## Commit messages
+
+Use the conventional prefixes already in the history:
+
+- `feat:` new features
+- `fix:` bug fixes
+- `docs:` documentation
+- `refactor:` code changes that neither fix a bug nor add a feature
+- `chore:` build, CI and tooling
+
+Example: `feat: import samples from a pasted statement`
+
+## Releasing
+
+See [docs/development.md](docs/development.md#releasing). Versions live in
+`scripts/cf` (`CF_VERSION`) and `web/package.json` and must match; CI
+enforces it.
+
+## Code of conduct
+
+This project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md).
+By participating you agree to abide by its terms.
diff --git a/README.md b/README.md
index 6f3fa90..c1519b8 100644
--- a/README.md
+++ b/README.md
@@ -2,14 +2,15 @@
 
 # cf Workbench
 
-**A local Codeforces-style workbench for writing, running, and stress-testing C++ solutions.**
+**A local Codeforces-style workbench for writing, running, testing and stress-testing C++ solutions.**
 
+[![CI](https://github.com/mbn-code/cf/actions/workflows/ci.yml/badge.svg)](https://github.com/mbn-code/cf/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![C++](https://img.shields.io/badge/C%2B%2B-gnu%2B%2B17%20default-blue.svg)](https://en.cppreference.com/w/cpp/17)
 [![Next.js](https://img.shields.io/badge/Next.js-16-black.svg)](https://nextjs.org/)
-[![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20WSL-success.svg)](README.md)
+[![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20WSL%20%7C%20Windows-success.svg)](README.md)
 
-[Features](#features) - [Quick start](#quick-start) - [How it works](#how-it-works) - [Documentation](#documentation)
+[Features](#features) - [Quick start](#quick-start) - [CLI](#command-line-tool) - [How it works](#how-it-works) - [Documentation](#documentation)
 
 </div>
 
@@ -18,43 +19,73 @@
 ## About
 
 `cf` is a self-hosted workbench for competitive programming in C++. It pairs a
-browser IDE (a Next.js app under `web/`) with a server-side execution engine that
-compiles and runs your code against the **real** C++ toolchain on your machine.
-Everything runs locally: there is no sandbox VM, no remote judge, and no account.
-
-The workbench is built to make the macOS toolchain a first-class target. The
-`#include <bits/stdc++.h>` idiom is a GCC/libstdc++ detail that Apple clang does
-not ship, so the repository bundles a portable shim at
-[`include/bits/stdc++.h`](include/bits/stdc++.h) and every compile is invoked with
-`-I include`. The same flag is used by the web engine and the [`Makefile`](Makefile),
-so code that compiles in the UI compiles from the terminal too.
-
-This is a stable release: the engine, the UI, and the build tooling are feature
-complete and the production build (`npm run build`) passes clean.
+browser IDE (a Next.js app under `web/`) and a Bash CLI (`scripts/cf`) with a
+server-side execution engine that compiles and runs your code against the
+**real** C++ toolchain on your machine. Everything runs locally: there is no
+sandbox VM, no remote judge, and no account.
+
+The workbench treats every toolchain as a first-class target. The
+`#include <bits/stdc++.h>` idiom is a GCC/libstdc++ detail that Apple clang
+does not ship, so the repository bundles a portable shim at
+[`include/bits/stdc++.h`](include/bits/stdc++.h) and every compile is invoked
+with `-I include`. The same flag is used by the web engine, the CLI and the
+[`Makefile`](Makefile), so code that compiles in the UI compiles from the
+terminal too. Linux (g++), macOS (Apple clang), WSL and Windows (MinGW or
+LLVM, via Git Bash) are all exercised by the test suites.
 
 ---
 
 ## Features
 
-- **C++ editor** with Prism syntax highlighting, a synced line-number gutter,
-  soft-tab handling, and an adjustable font. Editor contents persist to
-  `localStorage` across reloads.
-- **Insertable templates** (Minimal, A + B, Fast I/O + helpers, Brute force,
-  Generator) plus a Settings panel for the language standard, per-run time limit,
-  and extra compiler flags.
-- **Run panel** that POSTs to `/api/run` with custom stdin and renders the verdict,
-  exit code, elapsed wall-clock time, compiler, and a scrollable raw terminal log
-  of stdout / stderr / compile errors.
-- **Tests panel** to add, edit, delete, and paste-and-split sample cases, then
-  _Run all_ via `/api/test` for per-case **AC / WA / TLE / RE / CE** badges with an
-  expandable, whitespace-tolerant diff.
-- **Stress panel** that compiles a solution, a brute force, and a generator, runs
-  them for a configurable number of iterations, and surfaces the first failing
-  input. It degrades gracefully if the endpoint is unavailable.
-- **Problems sidebar** to save, load, rename, and delete problems and their test
-  cases, persisted as JSON under `web/data/`.
-- **Keyboard shortcuts**: `Cmd/Ctrl+Enter` runs, `Cmd/Ctrl+Shift+Enter` runs all
-  tests, `Cmd/Ctrl+S` saves the current problem.
+### Browser workbench
+
+- **C++ editor** with Prism syntax highlighting, a line-number gutter that
+  shows compiler error and warning markers, soft tabs, `Ctrl+/` comment
+  toggling, a cursor position status bar and an adjustable font. Contents
+  persist to `localStorage` across reloads.
+- **Compiler diagnostics** parsed into a clickable list: click an error to
+  jump to the offending line. Disallowed compiler flags are reported rather
+  than silently dropped.
+- **Compile cache**: a source that has already been built is not rebuilt.
+  Running the same program against twenty cases, or re-running after editing
+  only the stdin, skips the multi-second `<bits/stdc++.h>` instantiation.
+- **Run panel** with custom stdin, verdict, exit code, wall-clock time,
+  compile time and a scrollable raw terminal log.
+- **Tests panel** to add, edit, duplicate and delete sample cases, run all of
+  them or a single one, stop on the first failure, and see per-case
+  **AC / WA / TLE / RE / CE** badges with a line diff. **Import from
+  statement** turns a pasted Codeforces problem into test cases and applies
+  the statement's time limit.
+- **Output checkers**: exact lines (trailing whitespace ignored),
+  whitespace-insensitive tokens (the Codeforces `wcmp` checker), or floating
+  point with an absolute/relative epsilon. A `WA` whose tokens match is
+  flagged as a whitespace-only difference.
+- **Stress panel** that compiles a solution, a brute force and a generator,
+  runs them for a configurable number of seeded iterations, reports timing
+  statistics, and surfaces the first failing input. One click adds that input
+  as a test case (with the brute force's answer as expected output) or sends
+  it to the Run panel's stdin.
+- **Problems sidebar** that saves the whole workspace (source, statement,
+  tests, stdin, stress sources and settings) as JSON under `web/data/`, with
+  load, rename, duplicate, delete, filter, an unsaved-changes indicator, and
+  export/import of the whole library.
+- **Resizable layout**, remembered tab, and keyboard shortcuts:
+  `Ctrl/Cmd+Enter` run, `Ctrl/Cmd+Shift+Enter` run all, `Ctrl/Cmd+S` save,
+  `Ctrl/Cmd+1..4` switch panels, `Ctrl/Cmd+B` toggle the sidebar.
+
+### Command-line tool
+
+- `cf test` parses `problem.txt` (pasted straight from Codeforces), runs every
+  sample with a timeout, prints a diff on failure and reports per-sample
+  timing.
+- `cf stress` runs `solution.cpp` against `brute.cpp` on inputs from
+  `gen.cpp`, saving the first counter-example to `stress_fail.txt`.
+- `cf watch` re-runs the samples whenever a source file changes.
+- `cf template <name> --from dp|graph|math` scaffolds a problem directory from
+  one of the bundled starters; `cf samples`, `cf doctor`, `cf clean` and
+  `cf version` round out the toolkit.
+- Line and token checkers (`--checker tokens` or `CF_CHECKER=tokens`), a
+  build cache keyed by source and flags, and `NO_COLOR` support.
 
 See [`docs/features.md`](docs/features.md) for the complete feature guide.
 
@@ -64,9 +95,12 @@ See [`docs/features.md`](docs/features.md) for the complete feature guide.
 
 ### Prerequisites
 
-- A working C++ compiler. Apple clang (`clang++` / `c++`) or GCC (`g++`) both work.
-  On macOS, install the Xcode Command Line Tools: `xcode-select --install`.
-- Node.js 20 or newer (the web app targets Next.js 16).
+- A working C++ compiler. Apple clang (`clang++` / `c++`), GCC (`g++`) and
+  MinGW/LLVM on Windows all work. On macOS, install the Xcode Command Line
+  Tools: `xcode-select --install`.
+- Node.js 20 or newer for the web workbench (the app targets Next.js 16).
+- Bash for the CLI (Git Bash on Windows). `timeout` (GNU coreutils) enables
+  time limits in the CLI; on macOS `brew install coreutils`.
 
 ### Run the workbench
 
@@ -77,8 +111,10 @@ npm install
 npm run dev
 ```
 
-Open <http://localhost:3000>. The editor loads with an A + B program and a `2 3 -> 5`
-sample test, so you can click **Run** and see a result immediately.
+Open <http://localhost:3000>. The editor loads with an A + B program and a
+`2 3 -> 5` sample test, so you can click **Run** and see a result
+immediately. Paste a Codeforces statement into **Tests -> From statement** to
+turn its examples into test cases.
 
 For a production build:
 
@@ -87,15 +123,31 @@ npm run build
 npm run start
 ```
 
+### Use the CLI
+
+```bash
+# optional: put `cf` on your PATH
+ln -s "$PWD/scripts/cf" ~/.local/bin/cf     # or: bash scripts/setup.sh
+
+cf doctor                    # verify compiler, shim, timeout, node
+cf template 1000A            # ./1000A/solution.cpp + problem.txt
+cd 1000A                     # paste the statement into problem.txt
+cf test                      # run every sample, timed, with diffs
+cf test --checker tokens     # whitespace-insensitive comparison
+cf stress -n 500             # needs brute.cpp and gen.cpp next to solution.cpp
+cf serve                     # open this problem in the web workbench
+```
+
 ### Build from the terminal
 
-The repository also ships a portable [`Makefile`](Makefile) that uses the same
-compiler detection and `-I include` flag as the engine:
+The [`Makefile`](Makefile) uses the same compiler detection and `-I include`
+flag as the engine:
 
 ```bash
 make build FILE=src/solution.cpp   # compile one source
 make run   FILE=src/solution.cpp   # compile and run with a timeout
 make test  FILE=myproblem          # compile and diff vs src/myproblem/input.txt
+make check                         # shellcheck + CLI tests + web lint/typecheck/unit/build
 ```
 
 Full setup, build, and test instructions are in
@@ -107,33 +159,43 @@ Full setup, build, and test instructions are in
 
 ```
 cf/
+|- scripts/cf                   Bash CLI: template, run, test, stress, watch, serve, doctor
 |- web/                         Next.js workbench (UI + API)
 |  |- app/
-|  |  |- page.tsx               Workbench shell (editor, panels, shortcuts)
+|  |  |- page.tsx               Workbench shell (editor, panels, shortcuts, layout)
 |  |  |- api/
 |  |  |  |- _engine/            Server execution engine (Node built-ins only)
-|  |  |  |  |- cpp.ts           Compiler detection, compile, run, time-limit, caps
-|  |  |  |  |- compare.ts       Whitespace-tolerant output comparison + diff
-|  |  |  |  |- store.ts         JSON problem store under web/data
-|  |  |  |- run/                POST /api/run    - compile + run once
-|  |  |  |- test/               POST /api/test   - run many cases, AC/WA/...
-|  |  |  |- stress/             POST /api/stress - solution vs brute + generator
-|  |  |  |- problems/           CRUD for saved problems
-|  |  |  |- {config,problem-text,solution,template}/
-|  |  |- components/            Editor, Run/Tests/Stress panels, sidebar, badges
+|  |  |  |  |- cpp.ts           Compiler detection, compile cache, run, time limit, caps
+|  |  |  |  |- compare.ts       lines / tokens / float checkers + line diff
+|  |  |  |  |- diagnostics.ts   gcc/clang stderr -> structured diagnostics
+|  |  |  |  |- flags.ts         Compiler-flag allowlist and -std validation
+|  |  |  |  |- statement.ts     Codeforces statement -> samples + limits
+|  |  |  |  |- store.ts         Atomic JSON problem store under web/data
+|  |  |  |- run/                POST /api/run      - compile + run once
+|  |  |  |- test/               POST /api/test     - run many cases, AC/WA/...
+|  |  |  |- stress/             POST /api/stress   - solution vs brute + generator
+|  |  |  |- samples/            POST /api/samples  - parse a pasted statement
+|  |  |  |- problems/           CRUD + export/import for saved problems
+|  |  |  |- config/             Toolchain facts, compile-cache reset
+|  |  |- components/            Editor, Run/Tests/Stress/Settings panels, sidebar
 |  |  |- lib/                   Typed API client, localStorage helpers, templates
-|  |- data/problems/           Saved problems (one JSON file per problem)
+|  |- e2e/                      Playwright suite (real browser, real compiler)
+|  |- data/problems/            Saved problems (one JSON file per problem)
 |- include/bits/stdc++.h        Portable <bits/stdc++.h> shim for clang/libc++
-|- Makefile                     Portable terminal build/run/test
+|- templates/                   dp / graph / math starters for `cf template --from`
+|- tests/cli_test.sh            CLI end-to-end suite (real compiler)
+|- Makefile                     Portable terminal build/run/test + quality gates
 |- docs/                        This documentation
 ```
 
-The execution engine compiles each submission to a unique `os.tmpdir()` directory
-with `-std=gnu++17 -O2 -I include`, measures wall-clock time inside Node with
-`process.hrtime.bigint()`, enforces the time limit with `SIGKILL` (reported as TLE),
-caps stdin / stdout / stderr at 4 MiB, and distinguishes compile errors (CE) from
-runtime errors (RE) and spawn failures. Output comparison tolerates trailing
-whitespace and trailing blank lines.
+The execution engine writes each submission to a unique temp directory,
+compiles it with `-std=gnu++17 -O2 -I include` plus any allowlisted extra
+flags, and caches the binary by a hash of compiler, standard, flags and
+source. Runs are measured with `process.hrtime.bigint()`, killed with
+`SIGKILL` at the time limit (reported as TLE), and capped at 4 MiB of stdin,
+stdout and stderr. Compile errors (CE) are distinguished from runtime errors
+(RE) and spawn failures, and compiler output is parsed into
+`file:line:col` diagnostics.
 
 A deeper walkthrough lives in [`docs/architecture.md`](docs/architecture.md).
 
@@ -141,34 +203,40 @@ A deeper walkthrough lives in [`docs/architecture.md`](docs/architecture.md).
 
 ## Documentation
 
-| Document                                             | Contents                                                  |
-| ---------------------------------------------------- | --------------------------------------------------------- |
-| [`docs/features.md`](docs/features.md)               | Full feature guide for every panel and setting.           |
-| [`docs/architecture.md`](docs/architecture.md)       | The execution engine, the macOS shim, and the data store. |
-| [`docs/api.md`](docs/api.md)                         | Request / response contract for every `/api/*` route.     |
-| [`docs/development.md`](docs/development.md)         | Install, run, build, and the Playwright e2e suite.        |
-| [`docs/troubleshooting.md`](docs/troubleshooting.md) | Compiler-not-found, time limits, and macOS notes.         |
+| Document                                             | Contents                                                        |
+| ---------------------------------------------------- | --------------------------------------------------------------- |
+| [`docs/features.md`](docs/features.md)               | Full feature guide for every panel, setting and CLI command.    |
+| [`docs/architecture.md`](docs/architecture.md)       | The execution engine, checkers, the macOS shim, the data store. |
+| [`docs/api.md`](docs/api.md)                         | Request / response contract for every `/api/*` route.           |
+| [`docs/development.md`](docs/development.md)         | Install, run, build, unit tests, the Playwright suite and CI.   |
+| [`docs/troubleshooting.md`](docs/troubleshooting.md) | Compiler-not-found, time limits, Windows and macOS notes.       |
+| [`CHANGELOG.md`](CHANGELOG.md)                       | Release history.                                                |
 
 ---
 
-## Command-line tools
+## Command-line tool
 
-Alongside the workbench, the repository ships a Bash CLI (`scripts/cf`) and the
-`Makefile` for terminal-first workflows:
+| Command                             | Description                                                                                  |
+| ----------------------------------- | -------------------------------------------------------------------------------------------- |
+| `cf template <name> [--from T]`     | Scaffold `./<name>/` with `solution.cpp` and `problem.txt` (T: dp, graph, math).             |
+| `cf <name\|file> [input]`           | Compile and run a solution against a sample, a file or inline input.                         |
+| `cf test [name] [--checker tokens]` | Run every sample in `problem.txt` with a timeout, timing and diffs.                          |
+| `cf stress [name] [-n N]`           | Solution vs `brute.cpp` on `gen.cpp` inputs; saves the first counter-example.                |
+| `cf samples [name]`                 | Print the samples parsed from `problem.txt`.                                                 |
+| `cf watch [name]`                   | Re-run the samples whenever a source file changes.                                           |
+| `cf serve [name]`                   | Start the web workbench (creates the problem if needed).                                     |
+| `cf doctor`                         | Check compiler, shim, `timeout`, Node and the build cache.                                   |
+| `cf clean`                          | Remove the build cache.                                                                      |
+| `cf update`                         | Fast-forward to the latest version (see [`docs/UPDATE_COMMAND.md`](docs/UPDATE_COMMAND.md)). |
 
-| Command              | Description                                                                                        |
-| -------------------- | -------------------------------------------------------------------------------------------------- |
-| `cf template <name>` | Scaffold `src/<name>/` with a solution and sample files.                                           |
-| `cf <name> [input]`  | Compile and run a solution with file or inline input.                                              |
-| `cf test`            | Run a solution against its sample cases with timeout protection.                                   |
-| `cf serve [problem]` | Start the web workbench.                                                                           |
-| `cf update`          | Pull the latest toolkit and re-run setup (see [`docs/UPDATE_COMMAND.md`](docs/UPDATE_COMMAND.md)). |
+Run `cf help` for every option and environment variable.
 
 ---
 
 ## Contributing
 
 Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+`make check` runs the same gate as CI.
 
 ## License
 
diff --git a/SECURITY.md b/SECURITY.md
index 9a9d6c6..536398d 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,16 +1,43 @@
 # Security Policy
 
-## Supported Versions
+## Scope
 
-We recommend always using the latest version of the toolkit.
+`cf` is a local development tool. The web workbench binds to `localhost` and
+compiles and executes C++ that you type into it with your own user account;
+it is not designed to be exposed to untrusted users or the public internet.
+Within that model the following protections are in place:
 
-| Version | Supported          |
-| ------- | ------------------ |
-| 1.x     | :white_check_mark: |
-| < 1.0   | :x:                |
+- Compiler flags supplied from the browser are validated against an
+  allowlist; flags that write files, add search paths, load plugins or pass
+  through to the linker are rejected and reported (`web/app/api/_engine/flags.ts`).
+- The `/api/solution` and `/api/problem-text` routes accept only a single
+  safe path segment as the problem name, so requests cannot read or write
+  outside the problems directory.
+- Sources, stdin and captured output are size-capped, compilation and
+  execution are time-limited, and every build runs in its own temporary
+  directory.
+- The problem store writes atomically and never evaluates stored content.
 
-## Reporting a Vulnerability
+Do not run the workbench on a shared host or reverse-proxy it to the
+internet; the programs it runs are not sandboxed beyond the operating
+system's normal process isolation.
 
-If you discover a potential security vulnerability, please do not open a public issue. Instead, please report it privately to [INSERT EMAIL/CONTACT].
+## Supported versions
 
-We will acknowledge your report within 48 hours and provide a timeline for a fix if necessary.
+Only the latest release receives fixes.
+
+| Version | Supported |
+| ------- | --------- |
+| 1.x     | yes       |
+| < 1.0   | no        |
+
+## Reporting a vulnerability
+
+Please do not open a public issue for a security problem. Use GitHub's
+private vulnerability reporting on this repository
+(**Security -> Report a vulnerability**) so the report stays confidential
+until a fix is available. Include the version (`cf version` or the Settings
+Server block), the platform, and steps to reproduce.
+
+Reports are acknowledged within a few days, and a fix or mitigation is
+released as soon as one is ready.
diff --git a/docs/README.md b/docs/README.md
index 13c0a0b..bb0b17e 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,36 +1,39 @@
 # cf Workbench documentation
 
-This folder documents the `cf` workbench as a stable release. Start with the
-[project README](../README.md) for a high-level tour, then dive into the topic
-you need below.
+This folder documents the `cf` workbench. Start with the
+[project README](../README.md) for a high-level tour, then dive into the
+topic you need below.
 
 ## Contents
 
-| Document                                 | What it covers                                                                                                                           |
-| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| [features.md](features.md)               | Every panel and setting in the browser workbench, plus the keyboard shortcuts and what persists across reloads.                          |
-| [architecture.md](architecture.md)       | The server execution engine (`web/app/api/_engine`), the macOS `<bits/stdc++.h>` shim, the comparison logic, and the JSON problem store. |
-| [api.md](api.md)                         | The request / response contract for every `/api/*` route.                                                                                |
-| [development.md](development.md)         | Prerequisites, install, run, build, lint, the `Makefile`, and the Playwright end-to-end suite.                                           |
-| [troubleshooting.md](troubleshooting.md) | Compiler not found, time limits, output caps, and macOS / bash 3.2 notes.                                                                |
-| [UPDATE_COMMAND.md](UPDATE_COMMAND.md)   | The `cf update` CLI command.                                                                                                             |
+| Document                                 | What it covers                                                                                                                                 |
+| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| [features.md](features.md)               | Every panel and setting in the browser workbench, every CLI command, the keyboard shortcuts and what persists across reloads.                  |
+| [architecture.md](architecture.md)       | The server execution engine (`web/app/api/_engine`), the compile cache, the checkers, the statement parser, the macOS shim and the JSON store. |
+| [api.md](api.md)                         | The request / response contract for every `/api/*` route.                                                                                      |
+| [development.md](development.md)         | Prerequisites, install, run, build, the quality gates, the unit / CLI / Playwright suites, CI and releasing.                                   |
+| [troubleshooting.md](troubleshooting.md) | Compiler not found, ignored flags, time limits, output caps, checkers, the cache, Windows and macOS notes.                                     |
+| [UPDATE_COMMAND.md](UPDATE_COMMAND.md)   | The `cf update` CLI command.                                                                                                                   |
+| [../CHANGELOG.md](../CHANGELOG.md)       | Release history.                                                                                                                               |
 
 ## What `cf` is
 
-`cf` is a local-first workbench for competitive programming in C++. A Next.js app
-under `web/` provides the editor and panels; a server-side engine compiles and runs
-your code against the real C++ toolchain installed on the machine. Nothing is sent
-to a remote service.
+`cf` is a local-first workbench for competitive programming in C++. A
+Next.js app under `web/` provides the editor and panels, a Bash CLI under
+`scripts/` covers the terminal workflow, and a server-side engine compiles
+and runs your code against the real C++ toolchain installed on the machine.
+Nothing is sent to a remote service.
 
-The defining design choice is portability across toolchains. Every compile passes
-`-std=gnu++17 -O2 -I include`, and the bundled [`include/bits/stdc++.h`](../include/bits/stdc++.h)
-shim makes the ubiquitous `#include <bits/stdc++.h>` idiom resolve on Apple clang
-and libc++ (macOS) as well as g++ and libstdc++ (Linux / WSL).
+The defining design choice is portability across toolchains. Every compile
+passes `-std=gnu++17 -O2 -I include`, and the bundled
+[`include/bits/stdc++.h`](../include/bits/stdc++.h) shim makes the ubiquitous
+`#include <bits/stdc++.h>` idiom resolve on Apple clang and libc++ (macOS) as
+well as g++ and libstdc++ (Linux / WSL) and MinGW or LLVM on Windows.
 
 ## Conventions in these docs
 
 - Paths are relative to the repository root unless noted.
 - "The engine" means the shared module at `web/app/api/_engine/`.
-- Request / response field names are quoted verbatim from the route source so the
-  docs stay in lockstep with the implementation.
+- Request / response field names are quoted verbatim from the route source so
+  the docs stay in lockstep with the implementation.
 - This project does not use emojis in documentation.
diff --git a/docs/UPDATE_COMMAND.md b/docs/UPDATE_COMMAND.md
index c0f0bf9..80ad5f4 100644
--- a/docs/UPDATE_COMMAND.md
+++ b/docs/UPDATE_COMMAND.md
@@ -20,10 +20,13 @@ cf update
 
 ### Update Process
 
-1. Fetches latest changes from `origin` remote
-2. Pulls changes from `origin/main` branch
-3. Runs setup script automatically (if it exists)
-4. Returns to original directory
+1. Fetches latest changes from the tracked remote (`origin` by default)
+2. Fast-forwards the current branch (`git pull --ff-only`); a diverged
+   branch is reported instead of being merged
+3. Runs the setup script automatically (skip with `CF_UPDATE_SKIP_SETUP=1`)
+4. Returns to the original directory
+
+Run `cf version` afterwards to confirm the new version.
 
 ### Error Handling
 
diff --git a/docs/api.md b/docs/api.md
index 2937670..fde01b1 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -1,12 +1,12 @@
 # API reference
 
-The workbench's server API lives under `web/app/api/`. Every route runs on the Node
-runtime (`runtime = "nodejs"`) and is dynamic (`dynamic = "force-dynamic"`). Field
-names below are transcribed from each route's source and its top-of-file contract
-comment; the typed client in `web/lib/api.ts` mirrors them.
+The workbench's server API lives under `web/app/api/`. Every route runs on the
+Node runtime (`runtime = "nodejs"`) and is dynamic (`dynamic = "force-dynamic"`).
+Field names below are transcribed from each route's source and its top-of-file
+contract comment; the typed client in `web/lib/api.ts` mirrors them.
 
-All request bodies are JSON. On a bad request a route replies with a non-2xx status
-and a body of `{ "error": string }`.
+All request bodies are JSON objects. On a bad request a route replies with a
+non-2xx status and a body of `{ "error": string }`; malformed JSON is a 400.
 
 ## Summary
 
@@ -15,91 +15,138 @@ and a body of `{ "error": string }`.
 | `/api/run`          | POST                | Compile a source and run it once.                             |
 | `/api/test`         | POST                | Compile once, run against many cases, return AC/WA/TLE/RE/CE. |
 | `/api/stress`       | POST                | Compare a solution to a brute force on generated inputs.      |
-| `/api/problems`     | GET / POST / DELETE | CRUD for saved problems.                                      |
-| `/api/config`       | GET                 | Read environment-provided hints.                              |
-| `/api/problem-text` | GET / POST          | Load / save a problem statement (`problem.txt`).              |
-| `/api/solution`     | GET / POST          | Load / save a solution (`solution.cpp`).                      |
-| `/api/template`     | POST                | Fetch a named starter template.                               |
+| `/api/samples`      | POST                | Parse a pasted statement into sample tests and limits.        |
+| `/api/problems`     | GET / POST / DELETE | CRUD, duplicate, export and import for saved problems.        |
+| `/api/config`       | GET / DELETE        | Toolchain facts and limits; clear the compile cache.          |
+| `/api/template`     | GET / POST          | List / fetch the bundled starter templates.                   |
+| `/api/problem-text` | GET / POST          | Load / save a problem statement (`problem.txt`) in `src/`.    |
+| `/api/solution`     | GET / POST          | Load / save a solution (`solution.cpp`) in `src/`.            |
 
-The shared compile/run parameters -- `code`, `timeLimitMs`, `std`, `compilerFlags` --
-behave identically everywhere: `std` defaults to `gnu++17`, `timeLimitMs` defaults to
-5000 and is clamped to `[100, 60000]`, and `compilerFlags` is a string array appended
-to the compile command.
+### Shared compile / run options
+
+`/api/run`, `/api/test` and `/api/stress` accept the same option fields:
+
+| Field           | Type     | Default   | Notes                                                                  |
+| --------------- | -------- | --------- | ---------------------------------------------------------------------- |
+| `std`           | string   | `gnu++17` | Validated; unknown standards fall back to the default.                 |
+| `timeLimitMs`   | number   | `5000`    | Clamped to `[100, 60000]`.                                             |
+| `compilerFlags` | string[] | `[]`      | Validated against an allowlist; rejected flags are reported.           |
+| `checker`       | string   | `lines`   | `lines`, `tokens` or `float` (see [architecture.md](architecture.md)). |
+| `epsilon`       | number   | `1e-6`    | Float checker tolerance, clamped to `[0, 1]`.                          |
+
+### Shared compile block
+
+Every compile reports the same `compile` object:
+
+```json
+{
+  "ok": true,
+  "stderr": "",
+  "ms": 912,
+  "cached": false,
+  "diagnostics": [
+    {
+      "severity": "error",
+      "line": 5,
+      "column": 9,
+      "message": "'x' was not declared in this scope"
+    }
+  ],
+  "rejectedFlags": [{ "flag": "-o", "reason": "flag family is not allowed" }]
+}
+```
+
+`ms` is 0 and `cached` is true when the binary was served from the compile
+cache. `diagnostics[].line` is `null` for diagnostics that point at another
+file (for example the bundled shim). Sources larger than 1 MiB are refused
+with `error: "source-too-large"`; compilation is killed after 30 s.
 
 ---
 
 ## POST /api/run
 
-Compile a single C++ source and run it once with the given stdin.
+Compile a single C++ source and run it once.
 
-### Request
+Request:
 
 ```json
 {
-  "code": "string (required)",
-  "input": "string (stdin; `stdin` is accepted as an alias)",
-  "timeLimitMs": 5000,
+  "code": "#include <bits/stdc++.h> ...",
+  "input": "2 3\n",
+  "timeLimitMs": 2000,
   "std": "gnu++17",
   "compilerFlags": ["-Wall"]
 }
 ```
 
-`code` is required and must be non-empty (otherwise 400). `input` and `stdin` are
-interchangeable.
+`stdin` is accepted as an alias for `input`. `code` is required.
 
-### Response (200)
+Response (200):
 
 ```json
 {
   "ok": true,
   "verdict": "OK",
-  "stdout": "string",
-  "stderr": "string",
+  "stdout": "5\n",
+  "stderr": "",
   "exitCode": 0,
   "signal": null,
   "timedOut": false,
-  "timeMs": 1.83,
+  "timeMs": 3.2,
   "truncated": false,
   "compiler": "clang++",
-  "compile": { "ok": true, "stderr": "", "ms": 412.5 }
+  "compile": {
+    "ok": true,
+    "stderr": "",
+    "ms": 912,
+    "cached": false,
+    "diagnostics": [],
+    "rejectedFlags": []
+  }
 }
 ```
 
-- `verdict` is one of `OK`, `CE`, `RE`, `TLE`; `ok` is `verdict === "OK"`.
-- A compile failure returns 200 with `verdict: "CE"`, `compile.ok: false`, and the
-  diagnostics in `compile.stderr` (also mirrored to the top-level `stderr`).
-- `stdout`, `stderr`, and `exitCode` are preserved as top-level fields for backward
-  compatibility.
+`verdict` is `OK`, `CE` (compile failed; `compile.stderr` holds the text),
+`RE` (non-zero exit, signal or spawn failure) or `TLE` (killed at the time
+limit). `timeMs` is wall-clock time measured in Node. `truncated` is set when
+stdout or stderr hit the 4 MiB cap.
 
 ---
 
 ## POST /api/test
 
-Compile the source once and run it against an array of cases. The binary is reused
-across cases.
+Compile once and run against many cases.
 
-### Request
+Request:
 
 ```json
 {
-  "code": "string (required)",
+  "code": "...",
   "tests": [{ "input": "2 3\n", "expected": "5\n" }],
-  "timeLimitMs": 5000,
-  "std": "gnu++17",
-  "compilerFlags": []
+  "checker": "tokens",
+  "stopOnFirstFailure": false
 }
 ```
 
-`tests` must contain at least one case (otherwise 400).
+`code` and a non-empty `tests` array (at most 200 cases) are required.
 
-### Response (200)
+Response (200):
 
 ```json
 {
   "ok": true,
   "compiler": "clang++",
-  "compile": { "ok": true, "stderr": "", "ms": 408.1 },
-  "summary": { "total": 1, "passed": 1, "failed": 0, "verdict": "AC" },
+  "compile": { "...": "..." },
+  "checker": "tokens",
+  "summary": {
+    "total": 2,
+    "passed": 2,
+    "failed": 0,
+    "skipped": 0,
+    "verdict": "AC",
+    "maxTimeMs": 4.1,
+    "totalTimeMs": 7.9
+  },
   "results": [
     {
       "index": 0,
@@ -110,182 +157,204 @@ across cases.
       "stderr": "",
       "exitCode": 0,
       "signal": null,
-      "timeMs": 1.2,
+      "timeMs": 3.8,
       "truncated": false,
+      "presentationOnly": false,
       "diff": []
     }
   ]
 }
 ```
 
-- Per-case `verdict` is one of `AC`, `WA`, `TLE`, `RE`, `CE`.
-- `diff` is populated only for `WA`: an array of `{ line, expected, actual, same }`
-  for the differing lines (capped at 200), under whitespace-tolerant comparison.
-- `summary.verdict` is the worst verdict across all cases (ordered
-  `AC < WA < TLE < RE < CE`); `ok` is true only when every case is `AC`.
-- On a compile failure the route returns 200 with every case marked `CE` (so the UI
-  can badge each row) and `summary.verdict: "CE"`.
+Per-case `verdict` is `AC`, `WA`, `TLE`, `RE`, `CE` (every case, when the
+compile fails) or `SKIPPED` (after a failure with `stopOnFirstFailure`).
+`summary.verdict` is the worst verdict in `CE > RE > TLE > WA > AC` order.
+`diff` lists only the differing lines (capped at 200) as
+`{ line, expected, actual, same }`, with `null` for a missing side.
+`presentationOnly` is true for a `WA` under the `lines` checker whose tokens
+match.
 
 ---
 
 ## POST /api/stress
 
-Compile a solution, a brute force, and a generator, then loop: run `generator <seed>`
-to produce an input, feed it to both programs, and compare their outputs. Returns the
-first input on which they disagree (or on which a program crashes or times out).
+Compile three sources and search for a counter-example.
 
-### Request
+Request:
 
 ```json
 {
-  "solution": "string (required)",
-  "brute": "string (required)",
-  "generator": "string (required)",
-  "iterations": 100,
-  "timeLimitMs": 5000,
+  "solution": "...",
+  "brute": "...",
+  "generator": "...",
+  "iterations": 200,
   "seedBase": 1,
-  "std": "gnu++17"
+  "timeLimitMs": 2000,
+  "checker": "lines"
 }
 ```
 
-- All three sources are required and must be non-empty (otherwise 400).
-- `iterations` defaults to 100 and is clamped to `[1, 5000]`.
-- `seedBase` defaults to 1; iteration `i` uses seed `seedBase + i`, passed to the
-  generator as `argv[1]`.
+All three sources are required. `iterations` is clamped to `[1, 5000]`; the
+generator receives `seedBase + i` as `argv[1]`.
 
-### Response (200)
+Response (200):
 
 ```json
 {
   "ok": true,
   "failed": true,
-  "iterationsRun": 37,
+  "iterationsRun": 7,
+  "elapsedMs": 412,
+  "deadlineHit": false,
+  "stats": { "maxSolutionMs": 5.2, "maxBruteMs": 4.9, "avgSolutionMs": 3.1 },
   "compile": {
-    "solution": { "ok": true, "stderr": "", "ms": 410 },
-    "brute": { "ok": true, "stderr": "", "ms": 405 },
-    "generator": { "ok": true, "stderr": "", "ms": 398 }
+    "solution": {
+      "ok": true,
+      "stderr": "",
+      "ms": 900,
+      "cached": false,
+      "diagnostics": []
+    },
+    "brute": { "...": "..." },
+    "generator": { "...": "..." }
   },
   "firstFailure": {
-    "iteration": 37,
-    "seed": 37,
+    "iteration": 7,
+    "seed": 7,
     "reason": "mismatch",
-    "input": "...",
-    "solutionOutput": "...",
-    "bruteOutput": "...",
-    "diff": [{ "line": 1, "expected": "...", "actual": "...", "same": false }]
+    "input": "615 892\n",
+    "solutionOutput": "1506\n",
+    "bruteOutput": "1507\n",
+    "diff": [{ "line": 1, "expected": "1507", "actual": "1506", "same": false }]
   },
-  "message": "Found a counter-example on iteration 37."
+  "message": "Found a counter-example on iteration 7."
 }
 ```
 
-- `ok` means the three sources compiled and the loop ran -- not that the solution is
-  correct. `failed` is true when a counter-example was found.
-- `firstFailure.reason` is one of `mismatch`, `solution-error`, `brute-error`,
-  `solution-tle`, `brute-tle`, `generator-error`. Depending on the reason, the
-  failure may also carry `generatorStderr`, `solutionStderr`, or `bruteStderr`.
-- If a source fails to compile, the route returns 200 with `ok: false`,
-  `failed: false`, and the offending `compile.<which>.stderr` populated.
-- The loop is bounded by an overall 30-second deadline, so `iterationsRun` may be less
-  than the requested `iterations`.
+`ok` means the sources compiled and the search ran; `failed` means a
+counter-example was found. `reason` is one of `mismatch`, `solution-error`,
+`brute-error`, `solution-tle`, `brute-tle`, `generator-error`; the error
+variants also carry `solutionStderr`, `bruteStderr` or `generatorStderr`. A
+compile failure returns `ok: false` with the offending `compile.*.stderr`
+populated. The request is bounded by a 60 s budget; `deadlineHit` says when
+that cut the search short.
 
 ---
 
-## /api/problems
-
-CRUD for saved problems, persisted as `web/data/problems/<slug>.json`. A `slug` is
-derived from a problem's `name` and is the stable key; saving with the same name
-updates the existing record. Routes accept either an exact slug or a human name and
-resolve it with `slugify`.
+## POST /api/samples
 
-### GET /api/problems
+Parse a pasted statement.
 
-- `GET /api/problems` returns `{ "problems": ProblemSummary[] }`, newest first.
-  `ProblemSummary = { name, slug, testCount, updatedAt }`.
-- `GET /api/problems?name=<name|slug>` returns `{ "problem": Problem }`, or 404 with
-  `{ "error": string }` if not found.
+Request: `{ "statement": "A. Team\ntime limit per test\n2 seconds\n...Examples\nInput\n...\nOutput\n..." }`
 
-`Problem = { name, slug, code, statement, tests: { input, expected }[], createdAt, updatedAt }`.
-
-### POST /api/problems
-
-Two shapes:
+Response (200):
 
 ```json
-{ "name": "Two Sum", "code": "...", "statement": "...", "tests": [ ... ] }
-```
-
-upserts a problem and returns `{ "ok": true, "problem": Problem }`. `name` is
-required; `code`, `statement`, and `tests` are optional and preserved from the
-existing record when omitted.
-
-```json
-{ "op": "rename", "from": "<name|slug>", "to": "New Name" }
+{
+  "title": "A. Team",
+  "timeLimitMs": 2000,
+  "memoryLimitMb": 256,
+  "tests": [{ "input": "3\n1 1 0\n1 1 1\n1 0 0\n", "expected": "2\n" }]
+}
 ```
 
-renames a problem and returns `{ "ok": true, "problem": Problem }`, or 404 if the
-source does not exist.
-
-### DELETE /api/problems
-
-`DELETE /api/problems?name=<name|slug>` removes the problem and returns
-`{ "ok": true, "deleted": boolean }`. `deleted` is false when no matching file existed.
+Headings are matched case-insensitively (`Examples`, `Example`, `Sample 1`,
+`Input`, `Output`, `Sample Input N`, `Sample Output N`, `inputCopy`); a
+`Note` heading ends the examples. A statement without samples yields
+`tests: []`.
 
 ---
 
-## GET /api/config
-
-Returns environment-provided hints for the UI:
-
-```json
-{ "startProblem": "1000A or null", "problemsDir": "/path or null" }
-```
+## /api/problems
 
-Backed by `CF_START_PROBLEM` and `CF_PROBLEMS_DIR`.
+Saved problems are JSON files under `web/data/problems/<slug>.json` (or
+`$CF_DATA_DIR/problems`). `slug` is derived from `name` (lowercase,
+non-alphanumerics become `-`) and is the stable key; saving with the same
+name updates the record. Writes are atomic.
 
----
+Types:
 
-## /api/problem-text
+```ts
+TestCase       = { input: string; expected: string }
+ProblemSettings= { std?, timeLimitMs?, compilerFlags?, checker?, epsilon? }
+Problem        = { name, slug, code, statement, tests: TestCase[], stdin,
+                   brute, generator, settings: ProblemSettings | null,
+                   createdAt, updatedAt }
+ProblemSummary = { name, slug, testCount, updatedAt }
+```
 
-Per-problem statement stored as `src/<problem>/problem.txt`.
+| Request                                                                                         | Response                                                           |
+| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
+| `GET /api/problems`                                                                             | `{ problems: ProblemSummary[] }` newest first                      |
+| `GET /api/problems?name=<name or slug>`                                                         | `{ problem: Problem }` or 404                                      |
+| `GET /api/problems?export=1`                                                                    | `{ version: 1, exportedAt, problems: Problem[] }`                  |
+| `POST /api/problems { name, code?, statement?, tests?, stdin?, brute?, generator?, settings? }` | `{ ok, problem }` (upsert; omitted fields keep their stored value) |
+| `POST /api/problems { op: "rename", from, to }`                                                 | `{ ok, problem }` or 404                                           |
+| `POST /api/problems { op: "duplicate", from, to }`                                              | `{ ok, problem }` or 404                                           |
+| `POST /api/problems { op: "import", problems: Problem[], overwrite? }`                          | `{ ok, imported, skipped }`                                        |
+| `DELETE /api/problems?name=<name or slug>`                                                      | `{ ok: true, deleted: boolean }`                                   |
 
-- `GET /api/problem-text?problem=<name>` returns `{ "text": string }` (empty string
-  when absent). Missing `problem` is a 400.
-- `POST /api/problem-text` with `{ "problem", "text" }` returns `{ "success": true }`.
+Names are limited to 120 characters. Import skips problems that already exist
+unless `overwrite` is true, and tolerates records written by older versions.
 
 ---
 
-## /api/solution
+## /api/config
 
-Per-problem solution stored as `src/<problem>/solution.cpp`.
+`GET /api/config` returns facts the UI shows in Settings:
 
-- `GET /api/solution?problem=<name>` returns `{ "code": string }` (empty string when
-  absent). Missing `problem` is a 400.
-- `POST /api/solution` with `{ "problem", "code" }` returns `{ "success": true }`.
-  A write is skipped when the content is unchanged.
+```json
+{
+  "version": "1.0.0",
+  "platform": "darwin",
+  "compiler": "clang++",
+  "compilerVersion": "Apple clang version 16.0.0 (clang-1600.0.26.4)",
+  "includeDir": "/path/to/cf/include",
+  "defaults": {
+    "std": "gnu++17",
+    "timeLimitMs": 5000,
+    "maxTimeLimitMs": 60000,
+    "checker": "lines"
+  },
+  "limits": {
+    "maxSourceBytes": 1048576,
+    "maxInputBytes": 4194304,
+    "maxOutputBytes": 4194304,
+    "compileTimeoutMs": 30000
+  },
+  "cache": { "entries": 3 },
+  "startProblem": null,
+  "problemsDir": null
+}
+```
 
----
+`startProblem` and `problemsDir` echo `CF_START_PROBLEM` / `CF_PROBLEMS_DIR`
+as set by `cf serve`. `DELETE /api/config?cache=1` drops every cached binary
+and returns `{ ok: true, cleared: <count> }`.
 
-## POST /api/template
+---
 
-Fetch a named starter template from `templates/<name>.cpp`.
+## /api/template
 
-### Request
+- `GET /api/template` returns `{ "templates": ["dp", "graph", "math"] }`, the
+  `.cpp` files under the repository `templates/` directory.
+- `POST /api/template` with `{ "name": "dp" }` returns
+  `{ stdout, stderr, exitCode, content }`; `stdout` and `content` both hold the
+  template text (`stdout` is kept for backward compatibility). A miss returns
+  `exitCode: 1` and an error in `stderr`.
 
-```json
-{ "name": "dp" }
-```
+## /api/problem-text and /api/solution
 
-### Response (200)
+These read and write `problem.txt` / `solution.cpp` under `src/<problem>/`
+(or `$CF_PROBLEMS_DIR/<problem>/`) for CLI interoperability.
 
-```json
-{
-  "stdout": "<template text>",
-  "stderr": "",
-  "exitCode": 0,
-  "content": "<template text>"
-}
-```
+- `GET /api/problem-text?problem=<name>` returns `{ "text": string }` (empty
+  when absent); `POST /api/problem-text` with `{ "problem", "text" }` returns
+  `{ "success": true }`.
+- `GET /api/solution?problem=<name>` returns `{ "code": string }`;
+  `POST /api/solution` with `{ "problem", "code" }` returns
+  `{ "success": true }`.
 
-`content` and `stdout` both hold the template text (`stdout` is kept for backward
-compatibility). On a miss the route returns `exitCode: 1`, an error in `stderr`, and
-empty `content`. The bundled templates are `dp`, `graph`, and `math`.
+`problem` must be a single path segment of letters, digits, `_`, `-` and `.`
+that does not start with a dot; anything else (including `..` and path
+separators) is rejected with 400. Bodies are capped at 1 MiB.
diff --git a/docs/architecture.md b/docs/architecture.md
index eb2302f..dbcf166 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1,201 +1,176 @@
 # Architecture
 
-This document describes how the workbench compiles and runs C++ on the server. The
-authoritative source is the engine under `web/app/api/_engine/`; the contracts that
-the routes expose on top of it are in [api.md](api.md).
+This document describes how the workbench executes code: the server engine
+under `web/app/api/_engine/`, the checkers, the statement parser, the
+portable `<bits/stdc++.h>` shim, the problem store, and how the CLI relates
+to all of it.
 
 ## Overview
 
 ```
-Browser (web/app/page.tsx, components/**)
-        |
-        |  fetch JSON  (web/lib/api.ts)
-        v
-Next.js API routes (web/app/api/*/route.ts)   runtime = "nodejs"
-        |
-        v
-Engine (web/app/api/_engine/)
-   cpp.ts      compiler detection, compile(), runBinary(), cleanup()
-   compare.ts  normalize(), compareOutputs()
-   store.ts    problems JSON store + legacy src helpers
-        |
-        v
-Host C++ toolchain  +  include/bits/stdc++.h  +  web/data/**
+browser (web/app/page.tsx + components)
+   |  fetch JSON                       web/lib/api.ts (typed client)
+   v
+Next.js route handlers (web/app/api/*/route.ts)
+   |  plain function calls
+   v
+engine (web/app/api/_engine/*.ts, Node built-ins only)
+   |  child_process.spawn / spawnSync
+   v
+host C++ toolchain (clang++ / c++ / g++) + include/bits/stdc++.h
 ```
 
-Two ground rules shape the engine:
+The engine deliberately depends only on Node built-ins (`node:child_process`,
+`node:fs`, `node:os`, `node:path`, `node:crypto`) so the `web/app/api` tree
+never imports from `web/lib`, and so it can be unit-tested with Vitest
+without booting Next.
 
-1. **Node built-ins only.** `cpp.ts`, `compare.ts`, and `store.ts` import nothing but
-   `node:child_process`, `node:fs`, `node:os`, and `node:path`. The API tree never
-   reaches into `web/lib`, so the server and client never share runtime code.
-2. **No shared mutable state on disk.** Every compilation happens in its own unique
-   `os.tmpdir()` directory, so concurrent requests cannot collide, and the directory
-   is always cleaned up afterwards.
-
-All API routes declare `export const runtime = "nodejs"` and
-`export const dynamic = "force-dynamic"` so they run on the Node runtime (not the
-Edge runtime) and are never statically cached.
-
----
-
-## The execution engine: `cpp.ts`
+## The engine (`_engine/cpp.ts`)
 
 ### Compiler detection
 
-`detectCompiler()` returns the first usable C++ compiler or `null`. It honours an
-explicit `CF_CXX` (or `CXX`) override, then falls back to a preference list of
-`clang++`, `c++`, `g++`. Each candidate is probed with `--version`; the first that
-exits 0 is cached for the lifetime of the process. The preference order puts the
-macOS default (`clang++` / `c++`) first while still finding `g++` on Linux.
-
-### Compilation
-
-`compile(source, opts)` writes the source to `main.cpp` in a fresh
-`mkdtemp(os.tmpdir(), "cf-<label>-")` directory and invokes the compiler with:
-
-```
--std=<std>  -O2  -I <repoRoot>/include  main.cpp  -o prog  [extraFlags...]
-```
-
-- `<std>` defaults to `gnu++17` (the project's canonical standard).
-- `<repoRoot>/include` is resolved from `CF_REPO_ROOT` if set, otherwise the parent
-  of the Next.js `web` directory. This is the directory that holds the
-  `<bits/stdc++.h>` shim.
-- `extraFlags` are the user's "extra compiler flags" setting, appended verbatim.
-
-Compilation runs through `spawnSync` with a 30-second timeout and a 4 MiB stderr
-buffer. The result distinguishes four failure causes via an `error` field:
-`no-compiler`, `compile-timeout`, `compile-error`, and `spawn-error`. Compile
-wall-clock time is measured with `process.hrtime.bigint()`. `compile()` never throws;
-callers must call `cleanup(workDir)` when done with the produced binary.
-
-### Execution
-
-`runBinary(binPath, opts)` spawns the compiled program and:
-
-- feeds `opts.input` to stdin, truncated to **4 MiB** (`MAX_INPUT_BYTES`);
-- passes `opts.args` as argv (used to give the stress generator its seed);
-- measures wall-clock time with `process.hrtime.bigint()` around the spawn -- never
-  the shell `time` builtin, which is unreliable on macOS;
-- enforces a time limit (default 5000 ms, clamped to `[100, 60000]` ms). On timeout
-  the child is killed with `SIGKILL` and `timedOut` is set;
-- caps each of stdout and stderr at **4 MiB** (`MAX_OUTPUT_BYTES`); hitting the cap
-  sets `truncated` and (for stdout) kills the child;
-- reports the exit code, terminating signal, and any spawn error.
-
-Like `compile()`, `runBinary()` never throws; a failure to spawn surfaces through the
-`spawnError` field. `EPIPE` on stdin is ignored, because a program may exit before
-consuming all of its input.
-
-### Tunable limits
-
-| Constant                | Value     | Meaning                                       |
-| ----------------------- | --------- | --------------------------------------------- |
-| `DEFAULT_STD`           | `gnu++17` | Default C++ standard.                         |
-| `DEFAULT_TIME_LIMIT_MS` | 5000      | Default per-run wall-clock limit.             |
-| `MAX_TIME_LIMIT_MS`     | 60000     | Hard ceiling on a requested time limit.       |
-| `COMPILE_TIMEOUT_MS`    | 30000     | Compilation is killed past this.              |
-| `MAX_INPUT_BYTES`       | 4 MiB     | Largest stdin payload forwarded to a program. |
-| `MAX_OUTPUT_BYTES`      | 4 MiB     | Per-stream output cap before truncation.      |
-
-### How verdicts are derived
-
-The routes turn an engine result into a verdict:
-
-- **TLE** when `timedOut` is true.
-- **RE** when there is a spawn error, a non-zero exit code, or a terminating signal.
-- **CE** when `compile()` failed (no binary was produced).
-- **OK** / **AC** otherwise. For tests, `AC` additionally requires the output to
-  match the expected output under tolerant comparison; a non-matching run is `WA`.
-
----
-
-## Output comparison: `compare.ts`
-
-Competitive-programming judges accept output that differs only in trailing
-whitespace, trailing blank lines, and line-ending style. `normalize(s)` encodes that
-tolerance:
-
-- convert CRLF and lone CR to LF,
-- strip trailing spaces and tabs from every line,
-- drop trailing blank lines.
-
-`compareOutputs(expected, actual, maxDiff = 200)` normalizes both sides, reports
-whether they match, and returns a compact per-line diff of only the differing lines
-(`{ line, expected, actual, same }`). The diff is capped at 200 lines so a
-pathological mismatch cannot produce an unbounded payload. `firstMismatch` gives the
-1-based line number of the first difference (or -1 on a match). This logic backs both
-`/api/test` and `/api/stress`.
-
----
-
-## Persistence: `store.ts`
-
-`store.ts` owns two kinds of persistence.
-
-### The problems store (`web/data`)
-
-Saved problems live as one JSON file per problem under
-`<web>/data/problems/<slug>.json` (override the base with `CF_DATA_DIR`). A `Problem`
-record is:
-
-```ts
-{ name, slug, code, statement, tests: { input, expected }[], createdAt, updatedAt }
-```
-
-`slugify(name)` derives the stable file key by lowercasing, replacing runs of
-non-alphanumerics with `-`, trimming dashes, and truncating to 80 characters; an empty
-result falls back to `problem`. The store exposes `listProblems` (summaries, newest
-first), `getProblem`, `saveProblem` (upsert keyed by slug), `deleteProblem`, and
-`renameProblem`. Corrupt or unreadable files are skipped rather than failing a listing.
-
-### Legacy file helpers (`src` tree)
-
-`getSolution` / `saveSolution` and `getProblemText` / `saveProblemText` read and write
-`solution.cpp` and `problem.txt` under `src/<problem>/` (override the base with
-`CF_PROBLEMS_DIR`), keeping the `/api/solution`, `/api/problem-text`, and
-`/api/template` routes self-contained. `readTemplate(name)` reads a starter from the
-repository's `templates/<name>.cpp`, with the name sanitized to a safe basename.
-
----
-
-## The macOS shim: `include/bits/stdc++.h`
-
-`#include <bits/stdc++.h>` is a libstdc++ (GCC) convenience header that pulls in the
-whole Standard Library. It is not part of the C++ standard, and Apple clang with
-libc++ -- the default on macOS -- does not ship it, so the idiom fails to compile
-there.
-
-The repository bundles a portable replacement at `include/bits/stdc++.h`. Because
-both the engine and the `Makefile` compile with `-I include`, the idiom resolves to
-this shim on macOS, while on GCC it simply shadows the native header with an
-equivalent set of includes. Every header that may be absent depending on the standard
-library or language mode is gated behind `__has_include`, and the file avoids
-GCC-only headers (`<ext/...>`, `<tr1/...>`), so it compiles cleanly on Apple clang /
-libc++ and on g++ / libstdc++ alike from C++17 onward.
-
-There is also an `include/stl_utilities.h` header available on the same include path
-for shared helpers.
-
----
-
-## Environment overrides
-
-| Variable           | Effect                                                    |
-| ------------------ | --------------------------------------------------------- |
-| `CF_CXX` / `CXX`   | Force a specific C++ compiler instead of auto-detection.  |
-| `CF_REPO_ROOT`     | Override the repository root used to locate `include/`.   |
-| `CF_DATA_DIR`      | Override the base directory for the problems JSON store.  |
-| `CF_PROBLEMS_DIR`  | Override the `src` directory for the legacy file helpers. |
-| `CF_START_PROBLEM` | Reported by `/api/config` as a starting problem hint.     |
-
----
-
-## Concurrency and cleanup
-
-Because each compile and run uses a unique temp directory and time is measured
-per-process inside Node, multiple requests can execute in parallel without
-interfering. The stress route exploits this: it compiles the solution, brute force,
-and generator together with `Promise.all`, and runs the solution and brute force on
-each input concurrently. Every route wraps its work in `try/finally` and calls
-`cleanup()` on each temp directory, so binaries and sources never accumulate.
+`detectCompiler()` honours a `CF_CXX` / `CXX` override, then probes
+`clang++`, `c++` and `g++` with `--version`. The first responder is cached
+for the process lifetime along with the first line of its version output
+(exposed by `/api/config`). No compiler means every compile returns
+`error: "no-compiler"` with an installation hint.
+
+### Compilation and the cache
+
+`compile(source, { std, extraFlags, label })`:
+
+1. Validates `extraFlags` with `flags.ts` and `std` with `validateStd`.
+   Rejected flags are returned as `rejectedFlags` so the UI can explain them.
+2. Refuses sources above 1 MiB.
+3. Computes a SHA-256 key over compiler, standard, accepted flags and source.
+   A cache hit returns the stored binary path immediately with `cached: true`
+   and `ms: 0`. Concurrent requests for the same key share one in-flight
+   compile.
+4. On a miss, writes `main.cpp` into a fresh `mkdtemp` directory, runs
+   `<compiler> -std=<std> -O2 -I <repo>/include main.cpp -o prog [flags]`
+   with a 30 s timeout, and rewrites the temp path in stderr back to
+   `main.cpp` so diagnostics read naturally.
+5. A successful build is renamed into the per-process cache root
+   (`os.tmpdir()/cf-cache-*`). The cache keeps 48 binaries and evicts the
+   least recently used; it is removed when the server exits. A failed build
+   keeps its `workDir` so the caller can `cleanup()` it.
+
+On Windows the binary is `prog.exe`; everywhere else it is `prog`.
+
+### Running
+
+`runBinary(binPath, { input, args, timeLimitMs, maxOutputBytes })` spawns the
+program with piped stdio, writes stdin (capped at 4 MiB) and collects stdout
+and stderr as byte buffers up to 4 MiB each. A `setTimeout` at the clamped
+time limit sends `SIGKILL` and marks the run `timedOut`; hitting the stdout
+cap also kills the process and sets `truncated`. Wall-clock time is measured
+with `process.hrtime.bigint()` around the spawn and rounded to 0.1 ms.
+
+`runVerdict(run)` maps a run to `TLE` (timed out), `RE` (spawn error,
+non-zero exit or signal) or `OK`. Routes turn `OK` into `AC`/`WA` by
+comparing output.
+
+### Diagnostics (`_engine/diagnostics.ts`)
+
+`parseDiagnostics(stderr)` extracts every `path:line:col: severity: message`
+line that gcc and clang emit. Diagnostics that point at a file other than the
+user's `main.cpp` (for example inside the shim) keep their message but drop
+the line number so the editor never marks a line that is not in the source.
+
+### Flag validation (`_engine/flags.ts`)
+
+The browser sends compiler flags verbatim, so the engine allowlists the
+families a contestant needs (`-O`, `-W`, `-w`, `-D`, `-U`, `-f`, `-g`, `-m`,
+`-std=`, `-pedantic`, `-static`, `-pthread`, `-pipe`) and denies the ones
+that would turn the compiler into a file writer or code loader (`-o`, `-I`,
+`-L`, `-l`, `-include`, `@file`, `-fplugin*`, `-fprofile*`, `-Wl,`, `-Wa,`,
+`-Wp,`), anything with shell metacharacters, and unknown `-std=` values.
+
+## Checkers (`_engine/compare.ts`)
+
+`compareOutputs(expected, actual, { mode, epsilon })` first normalises both
+sides (CRLF to LF, trailing whitespace stripped per line, trailing blank
+lines removed), then:
+
+| Mode     | Accepts when                                                                                                      |
+| -------- | ----------------------------------------------------------------------------------------------------------------- |
+| `lines`  | the normalised strings are identical.                                                                             |
+| `tokens` | the whitespace-separated token sequences are identical (the Codeforces `wcmp` checker).                           |
+| `float`  | token counts match and each pair is equal, or both are numbers within `epsilon` absolutely or relative to `max(1, | expected | )`. |
+
+A mismatch produces a per-line diff (`{ line, expected, actual, same }`,
+`null` for a missing side, capped at 200 rows) and, in `lines` mode, a
+`presentationOnly` flag when the `tokens` checker would have accepted the
+output. The CLI implements the same `lines` and `tokens` semantics in Bash.
+
+## Statement parser (`_engine/statement.ts`)
+
+`parseStatement(text)` walks a pasted statement line by line. It records the
+first non-empty line as the title, reads `time limit per test` /
+`memory limit per test` from the header, and once it sees an `Examples`
+heading (or an AtCoder-style `Sample Input N`) collects every
+`Input` / `Output` pair until a `Note`, `Explanation` or `Constraints`
+heading. Codeforces' `Copy` button text and CRLF line endings are ignored.
+Each sample is trimmed and terminated with a single newline. The CLI's awk
+parser in `scripts/cf` follows the same rules.
+
+## The problem store (`_engine/store.ts`)
+
+Problems live as `web/data/problems/<slug>.json` (or under `CF_DATA_DIR`).
+A record holds the whole workspace: `code`, `statement`, `tests`, `stdin`,
+`brute`, `generator`, an optional `settings` snapshot and timestamps.
+`normalizeProblem` coerces records written by older versions, so upgrading
+never loses a library. Writes go to a sibling temp file and are renamed into
+place, so a crash mid-write never leaves a half-written record.
+
+The legacy helpers that read and write `src/<problem>/solution.cpp` and
+`problem.txt` validate the problem name as a single safe path segment before
+touching the filesystem.
+
+## The `<bits/stdc++.h>` shim
+
+Apple clang ships libc++, which has no `bits/stdc++.h`. The repository
+bundles `include/bits/stdc++.h`, an aggregate that includes the whole
+Standard Library with optional headers gated behind `__has_include`. Every
+compile (engine, CLI and Makefile) passes `-I <repo>/include`, so the idiom
+resolves on macOS, Linux and Windows alike; on GCC the shim simply shadows the
+native header with an equivalent set of includes.
+
+## Routes
+
+Each route under `web/app/api/*/route.ts` parses its body with the helpers in
+`_engine/request.ts` (`readJson`, `parseRunOptions`), calls the engine and
+serialises the result. The contracts are documented in [api.md](api.md).
+`/api/test` runs cases sequentially so timings are not skewed by CPU
+contention; `/api/stress` runs the solution and brute force for one input in
+parallel and bounds the whole request at 60 s.
+
+## The browser
+
+`web/app/page.tsx` owns all workbench state, hydrates it from `localStorage`
+after mount, persists it back on change, and wires the panels. The panels
+are presentational components under `web/components/`; `web/lib/api.ts` is
+the only place that talks HTTP. Compiler diagnostics from the latest run feed
+the editor's gutter markers until the source changes.
+
+## The CLI
+
+`scripts/cf` is a standalone Bash script with the same conventions: it
+compiles with `-I include`, caches binaries under `build/.cache` by a hash of
+compiler, flags and sources, parses `problem.txt` with awk, enforces time
+limits with GNU `timeout`, and reports `lines`/`tokens` verdicts. `cf serve`
+starts the Next.js app with `CF_PROBLEMS_DIR` / `CF_START_PROBLEM` exported,
+which `/api/config` reports back to the UI.
+
+## Environment variables
+
+| Variable           | Read by | Effect                                                       |
+| ------------------ | ------- | ------------------------------------------------------------ |
+| `CF_CXX` / `CXX`   | both    | Compiler to use before the default probe order.              |
+| `CF_REPO_ROOT`     | both    | Repository root (default: parent of `web/`).                 |
+| `CF_DATA_DIR`      | web     | Where `problems/` JSON files live.                           |
+| `CF_PROBLEMS_DIR`  | both    | Directory of `src/<problem>/` folders.                       |
+| `CF_START_PROBLEM` | web     | Reported by `/api/config` as a starting problem hint.        |
+| `CF_CXXFLAGS`      | CLI     | Full compile flags (default `-std=c++23 -O2 -Wall -Wextra`). |
+| `CF_TIMEOUT`       | CLI     | Execution limit in seconds.                                  |
+| `CF_CHECKER`       | CLI     | `lines` or `tokens`.                                         |
diff --git a/docs/development.md b/docs/development.md
index 07fda87..ae397e4 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -1,22 +1,24 @@
 # Development, build, and test
 
-This guide covers running the workbench locally, building it for production, the
-portable `Makefile`, and the Playwright end-to-end suite.
+This guide covers running the workbench locally, building it for production,
+the quality gates, the portable `Makefile`, and the test suites.
 
 ## Prerequisites
 
-- **A C++ compiler.** Apple clang (`clang++` / `c++`) or GCC (`g++`). On macOS:
-  `xcode-select --install`. On Debian / Ubuntu: `sudo apt-get install g++`.
+- **A C++ compiler.** Apple clang (`clang++` / `c++`), GCC (`g++`) or, on
+  Windows, MinGW-w64 or LLVM on `PATH`. On macOS: `xcode-select --install`.
+  On Debian / Ubuntu: `sudo apt-get install g++`.
 - **Node.js 20 or newer.** The web app targets Next.js 16.
-- No global C++ setup is required for `<bits/stdc++.h>`: the bundled shim under
-  `include/` is added to every compile via `-I include`.
+- **Bash** for the CLI and the scripts (Git Bash on Windows).
+- **GNU `timeout`** for CLI time limits (`brew install coreutils` on macOS).
+- **shellcheck** (optional) for `make check`.
+- No global C++ setup is required for `<bits/stdc++.h>`: the bundled shim
+  under `include/` is added to every compile via `-I include`.
 
-Verify the compiler resolves the bundled header before starting:
+`cf doctor` verifies all of the above and runs a compile-and-run smoke test:
 
 ```bash
-printf '#include <bits/stdc++.h>\nint main(){int a,b;std::cin>>a>>b;std::cout<<a+b;}\n' > /tmp/cf_hdr_check.cpp
-c++ -std=gnu++17 -I include /tmp/cf_hdr_check.cpp -o /tmp/cf_hdr_check
-echo '2 3' | /tmp/cf_hdr_check     # prints 5
+bash scripts/cf doctor
 ```
 
 ## Web app
@@ -30,32 +32,152 @@ npm run dev        # start the dev server on http://localhost:3000
 npm run build      # production build
 npm run start      # serve the production build (after npm run build)
 npm run lint       # eslint
+npm run typecheck  # tsc --noEmit
+npm test           # vitest unit suite (engine + helpers)
 npm run e2e        # Playwright end-to-end tests (see below)
+npm run check      # lint + typecheck + test + build
 ```
 
-`npm run dev` enables hot reload; edit `app/page.tsx`, the components, or the API
-routes and the page updates. The API routes execute the host compiler, so a working
-toolchain is required even in development.
+`npm run dev` enables hot reload; edit `app/page.tsx`, the components, or the
+API routes and the page updates. The API routes execute the host compiler, so
+a working toolchain is required even in development.
 
 ### A note on build tooling and `NODE_ENV`
 
-The build- and lint-critical packages (`typescript`, `eslint`, `eslint-config-next`,
-`tailwindcss`, `@tailwindcss/postcss`, the `@types/*` packages, and friends) live in
-`dependencies` rather than `devDependencies` in `web/package.json`. This is
-deliberate and documented with a `"//"` note in that file: when an install runs under
-`NODE_ENV=production`, npm omits `devDependencies`, which would otherwise make
-`npm run lint` and `npm run build` fail with "Cannot find package" errors. Keeping
-them in `dependencies` guarantees the production build is reproducible regardless of
-`NODE_ENV`. Only `@playwright/test` remains a `devDependency`. Do not move these back
-into `devDependencies`.
+The build- and lint-critical packages (`typescript`, `eslint`,
+`eslint-config-next`, `tailwindcss`, `@tailwindcss/postcss`, the `@types/*`
+packages, and friends) live in `dependencies` rather than `devDependencies`
+in `web/package.json`. This is deliberate and documented with a `"//"` note
+in that file: when an install runs under `NODE_ENV=production`, npm omits
+`devDependencies`, which would otherwise make `npm run lint` and
+`npm run build` fail with "Cannot find package" errors. Only the test
+harnesses (`@playwright/test`, `vitest`) are `devDependencies`. Do not move
+the build tooling back.
+
+## Quality gates
+
+`scripts/check.sh` (also `make check`) is the local equivalent of CI:
+
+1. shellcheck on `scripts/cf`, `scripts/check.sh`, `scripts/test.sh`,
+   `scripts/validate.sh` and `tests/cli_test.sh` (an LF copy is linted so a
+   CRLF checkout gives the same verdict as CI);
+2. the CLI test suite;
+3. `npm run lint` and `npm run typecheck`;
+4. `npm test` (Vitest);
+5. `npm run build`;
+6. a version-consistency check between `CF_VERSION` in `scripts/cf` and
+   `web/package.json`.
+
+`bash scripts/check.sh --quick` skips the production build and
+`--no-web` runs only the shell and CLI checks. `scripts/validate.sh`
+(`make validate`) is the heavier release gate: install, production build,
+Playwright browser install and the full e2e suite.
+
+## Unit tests (Vitest)
+
+`web/app/api/_engine/*.test.ts` exercise the engine directly:
+
+- `cpp.test.ts` compiles and runs real programs: cache hits and coalescing,
+  structured diagnostics on a compile error, flag rejection, TLE and RE
+  classification, output truncation, oversized sources and spawn failures.
+  These cases are skipped (not failed) on a machine without a compiler.
+- `compare.test.ts`, `flags.test.ts`, `diagnostics.test.ts`,
+  `statement.test.ts` and `store.test.ts` cover the pure helpers; the store
+  tests run against a temporary `CF_DATA_DIR`.
+
+```bash
+cd web
+npm test                 # one run
+npm run test:watch       # watch mode
+```
+
+## CLI tests
+
+`tests/cli_test.sh` runs the real `scripts/cf` against the real compiler in a
+throwaway directory with its own build cache. It covers statement parsing on
+the fixture under `tests/fixtures/231A`, sample selection, inline input,
+argument precedence, WA / RE / TLE / CE reporting, both checkers, stress
+testing (a buggy solution must be caught; a correct one must pass),
+templating, `doctor` and `clean`.
+
+```bash
+bash tests/cli_test.sh
+```
+
+`scripts/test.sh` is the older toolkit runner; it now delegates to the CLI
+suite, lints the scripts with `--shellcheck`, and can still compile and diff a
+single solution against `tests/example_input.txt` / `example_output.txt`.
+
+## End-to-end tests (Playwright)
+
+The web app ships a Playwright harness. The configuration is in
+`web/playwright.config.ts`: it points at `testDir: "./e2e"`, runs a single
+worker, and uses a `webServer` that builds and starts the app on
+`http://localhost:3000` so the specs drive the real Next app against the real
+C++ toolchain (no network mocking). Locally an already-running server on
+port 3000 is reused.
+
+```bash
+cd web
+npm install
+npx playwright install chromium   # one-time browser download
+npm run e2e                        # or: npx playwright test
+```
+
+The specs under `web/e2e/` cover: the smoke path, Run, Tests (AC and WA with
+a diff), Stress (no counter-example), persistence across reload, compiler
+diagnostics and gutter markers, statement import, the tokens checker and
+run-one with rejected flags, stress promotion of a failing input, and the
+problems library (save, dirty tracking, new workspace, load, duplicate,
+delete). Because the suite compiles real C++ on first run, the timeouts are
+generous; the compile cache makes subsequent runs much faster.
+
+### Stable selectors
+
+The UI exposes stable `data-testid` hooks for the e2e suite, including
+`run-button`, `run-stdin`, `run-verdict`, `elapsed-time`, `compile-time`,
+`terminal-output`, `diagnostics-list`, `rejected-flags`; `#code-editor` and
+`code-editor-gutter` (gutter rows carry `data-marker="error|warning"`);
+`editor-status`, `error-count`, `warning-count`; `run-all-button`,
+`add-test-button`, `import-statement-*`, `run-test-<i>`, `stdin-test-<i>`,
+`duplicate-test-<i>`, `test-input-<i>`, `test-expected-<i>`,
+`verdict-badge-<i>` (each verdict badge also carries `data-verdict`),
+`presentation-hint-<i>`, `tests-summary`; the Stress controls
+(`stress-run-button`, `stress-iterations`, `stress-seed`, `stress-failure`,
+`stress-add-test`, `stress-use-stdin`, `stress-stats`); the Settings
+controls (`settings-std`, `settings-time-limit`, `settings-checker`,
+`settings-epsilon`, `settings-flags`, `settings-reset`,
+`settings-clear-cache`); and the Problems controls (`save-problem-name`,
+`save-problem-button`, `dirty-indicator`, `new-workspace-button`,
+`export-problems-button`, `import-problems-input`, `load-problem-<slug>`,
+`rename-problem-<slug>`, `duplicate-problem-<slug>`, `confirm-name-<slug>`,
+`delete-problem-<slug>`, `confirm-delete-<slug>`). Target these rather than
+text or DOM structure so the tests stay robust.
+
+## Continuous integration
+
+`.github/workflows/ci.yml` runs on every push to `main` and every pull
+request:
+
+- **CLI** on Ubuntu and macOS: shellcheck, `tests/cli_test.sh`, and a
+  `Makefile` smoke test.
+- **Web** on Ubuntu and macOS: `npm ci`, lint, typecheck, unit tests, build,
+  and the version-consistency check.
+- **End-to-end** on Ubuntu: the Playwright suite against a production build,
+  with the report uploaded on failure.
+
+`.github/workflows/release.yml` runs when a `v*` tag is pushed: it checks
+that the tag matches `CF_VERSION` and `web/package.json`, extracts that
+version's section from `CHANGELOG.md`, and publishes a GitHub release.
 
 ## Portable Makefile
 
-The root `Makefile` builds and runs C++ from the terminal with the same compiler
-detection and `-I include` flag as the web engine. It is written to work on macOS's
-default bash 3.2 and zsh, with no bashisms and no GNU-only flags. It avoids both the
-GNU `timeout` command and the shell `time` builtin, using Node for high-resolution
-timing when available and a pure-POSIX background-and-kill timer otherwise.
+The root `Makefile` builds and runs C++ from the terminal with the same
+compiler detection and `-I include` flag as the web engine. It is written to
+work on macOS's default bash 3.2 and zsh, with no bashisms and no GNU-only
+flags. It avoids both the GNU `timeout` command and the shell `time` builtin,
+using Node for high-resolution timing when available and a pure-POSIX
+background-and-kill timer otherwise.
 
 ```bash
 make help                       # show targets and the detected compiler
@@ -65,10 +187,13 @@ make run   FILE=src/x.cpp       # compile and run with a timeout, timed
 make test  FILE=myproblem       # compile and diff vs src/myproblem/input.txt
 make debug FILE=src/x.cpp       # compile with -g
 make clean                      # remove build artifacts
+make check                      # the local quality gate
+make web-install | web-dev | web-build | web-test | web-e2e
 ```
 
-`FILE` resolves, in order, to `src/<FILE>.cpp`, then `src/<FILE>/solution.cpp`, then a
-literal path. Useful knobs (override on the command line):
+`FILE` resolves, in order, to `src/<FILE>.cpp`, then
+`src/<FILE>/solution.cpp`, then a literal path. Useful knobs (override on the
+command line):
 
 | Knob       | Default                            | Meaning                               |
 | ---------- | ---------------------------------- | ------------------------------------- |
@@ -78,48 +203,22 @@ literal path. Useful knobs (override on the command line):
 | `CXXFLAGS` | `-std=$(CXXSTD) -O2 -Wall -Wextra` | Full compile flags.                   |
 | `CXX`      | auto-detected                      | Compiler (`clang++` / `c++` / `g++`). |
 
-```bash
-make run FILE=src/x.cpp TL=2          # 2-second time limit
-make all CXXSTD=gnu++20               # build everything as gnu++20
-```
-
-`make test` reads `src/<FILE>/input.txt`, runs the binary, and diffs the output
-against `src/<FILE>/expected.txt` (with trailing whitespace stripped), printing `AC`
-or `WA`.
-
-## End-to-end tests (Playwright)
-
-The web app ships a Playwright harness. The configuration is in
-`web/playwright.config.ts`: it points at `testDir: "./e2e"`, runs a single worker, and
-uses a `webServer` that builds and starts the app on `http://localhost:3000` so the
-specs drive the real Next app against the real C++ toolchain (no network mocking).
-
-```bash
-cd web
-npm install
-npx playwright install chromium   # one-time browser download
-npm run e2e                        # or: npx playwright test
-```
+`make test` reads `src/<FILE>/input.txt`, runs the binary, and diffs the
+output against `src/<FILE>/expected.txt` (with trailing whitespace stripped),
+printing `AC` or `WA`.
 
-The specs live under `web/e2e/`. They exercise the full pipeline end to end: typing a
-`<bits/stdc++.h>` A + B program and running it, adding an `AC` and a `WA` case in the
-Tests panel and asserting the badges and diff, and the Stress / Problems happy paths.
-Because the suite compiles real C++ on first run, give the `webServer` and the test
-timeouts enough headroom for compilation.
-
-### Stable selectors
+## Releasing
 
-The UI exposes stable `data-testid` hooks for the e2e suite, including `run-button`,
-`run-stdin`, `run-verdict`, `elapsed-time`, `terminal-output`; `#code-editor`;
-`run-all-button`, `add-test-button`, `test-input-<i>`, `test-expected-<i>`, and
-`verdict-badge-<i>` (each verdict badge also carries `data-verdict="<CODE>"`); the
-Stress controls (`stress-run-button`, `stress-iterations`, `stress-failure`); and the
-Problems controls (`save-problem-button`, `load-problem-<slug>`, and so on). Target
-these rather than text or DOM structure so the tests stay robust.
+1. Bump `CF_VERSION` in `scripts/cf` and `version` in `web/package.json`
+   to the same value and add a section to `CHANGELOG.md`.
+2. Run `make check` (and ideally `make validate`).
+3. Merge to `main`, then tag and push: `git tag v1.2.3 && git push origin v1.2.3`.
+   The release workflow publishes the GitHub release with the changelog
+   section as its notes.
 
 ## A working compiler is required at runtime
 
-Both the dev server and the production build serve API routes that shell out to the
-host compiler. If no compiler is found, `/api/run` and `/api/test` return a `CE`
-verdict whose message explains how to install one; see
+Both the dev server and the production build serve API routes that shell out
+to the host compiler. If no compiler is found, `/api/run` and `/api/test`
+return a `CE` verdict whose message explains how to install one; see
 [troubleshooting.md](troubleshooting.md).
diff --git a/docs/features.md b/docs/features.md
index a44ee6f..c31da05 100644
--- a/docs/features.md
+++ b/docs/features.md
@@ -1,15 +1,17 @@
 # Feature guide
 
-This is a tour of the browser workbench (`web/app/page.tsx` and the components under
-`web/components/`). Every feature listed here is implemented in the shipped UI.
+This is a tour of the browser workbench (`web/app/page.tsx` and the components
+under `web/components/`) followed by the command-line tool (`scripts/cf`).
+Every feature listed here is implemented and covered by the unit, CLI or
+Playwright suites.
 
 The workbench is a single page with three regions:
 
 - a collapsible **Problems sidebar** on the left,
-- the **editor** with its toolbar in the center, and
-- a tabbed **panel** area (Run, Tests, Stress, Settings).
+- the **editor** with its toolbar and status bar in the center, and
+- a tabbed, resizable **panel** area (Run, Tests, Stress, Settings).
 
-A clean dark theme is fixed (the page renders with `<html className="dark">`).
+A dark theme is fixed (the page renders with `<html className="dark">`).
 
 ---
 
@@ -17,21 +19,26 @@ A clean dark theme is fixed (the page renders with `<html className="dark">`).
 
 - **Syntax highlighting** for C++ via Prism, rendered behind a transparent
   `<textarea>` (`react-simple-code-editor`).
-- **Line-number gutter** kept in sync with the editor's scroll position.
-- **Soft tabs**: pressing Tab inserts four spaces rather than moving focus.
-- **Adjustable font size** from the toolbar (range 10-24 px, default 14 px). Use the
-  font decrease / increase controls; the size is remembered across reloads.
-- **Persistence**: editor contents are written to `localStorage` under the key
+- **Line-number gutter** with **error and warning markers**: after a compile,
+  lines that produced a diagnostic get a red (error) or amber (warning) dot and
+  a tinted background. Markers clear as soon as the source changes.
+- **Soft tabs**: Tab inserts four spaces rather than moving focus.
+- **`Ctrl/Cmd+/`** toggles `// ` on the current line or selection.
+- **Status bar** with the caret position (`Ln`, `Col`), line and character
+  counts, and the active time limit, checker and extra flags.
+- **Adjustable font size** (10-24 px, default 14) from the toolbar or Settings.
+- **Persistence**: editor contents are written to `localStorage` under
   `cf:code` on every change and restored on load.
+- The toolbar shows the language standard and, after a compile, the number of
+  errors or warnings.
 
-The editor opens with `DEFAULT_CODE` (defined in `web/lib/templates.ts`): an A + B
-program that reads two integers from stdin and prints their sum. It compiles against
-the bundled `<bits/stdc++.h>` shim out of the box.
+The editor opens with `DEFAULT_CODE` (in `web/lib/templates.ts`): an A + B
+program that reads two integers from stdin and prints their sum. It compiles
+against the bundled `<bits/stdc++.h>` shim out of the box.
 
 ### Templates
 
-The toolbar's template selector inserts one of these starter programs (from
-`web/lib/templates.ts`):
+The toolbar's template selector inserts one of these starter programs:
 
 | Template           | Purpose                                                          |
 | ------------------ | ---------------------------------------------------------------- |
@@ -42,45 +49,67 @@ The toolbar's template selector inserts one of these starter programs (from
 | Generator          | A seeded random input generator (the seed arrives as `argv[1]`). |
 
 The Brute force and Generator templates also seed the Stress panel's editors.
+The repository's `templates/` directory (dp, graph, math) is available to the
+CLI through `cf template --from` and to tools through `GET /api/template`.
 
 ---
 
 ## Run panel
 
-The Run panel sends the current editor contents to `POST /api/run` with the stdin
-you provide. It renders:
-
-- a **verdict** badge: `OK`, `CE` (compile error), `RE` (runtime error), or `TLE`
-  (time-limit exceeded);
-- run **metrics**: exit code, elapsed wall-clock time (measured server-side in Node),
-  the detected compiler, and compile time;
-- a **scrollable raw terminal log** combining stdout, stderr, and compile diagnostics.
-  The log auto-scrolls to the newest output but lets you scroll back through history.
-
-Set custom input in the stdin field (it defaults to `2 3`). Press **Run** or use the
-`Cmd/Ctrl+Enter` shortcut.
+The Run panel sends the current editor contents to `POST /api/run` with the
+stdin you provide. It renders:
+
+- a **verdict** badge: `OK`, `CE` (compile error), `RE` (runtime error) or
+  `TLE` (time-limit exceeded);
+- run **metrics**: exit code (or the terminating signal), elapsed wall-clock
+  time measured server-side in Node, compile time or a `cached` marker when
+  the binary came from the compile cache, and the detected compiler;
+- warning and error counts, plus `timed out` / `output truncated` flags;
+- a **diagnostics list** parsed from the compiler output. Entries with a
+  location are buttons: click one and the editor jumps to that line;
+- a notice listing any **ignored compiler flags** and why they were rejected;
+- a **scrollable raw terminal log** combining stdout, stderr and compiler
+  output. The log auto-scrolls to the newest output but lets you scroll back.
+- **Copy** the raw log and **Clear** the result.
+
+The stdin field defaults to `2 3` and is remembered across reloads. Press
+**Run** or use `Ctrl/Cmd+Enter`.
 
 ---
 
 ## Tests panel
 
 The Tests panel runs the current code against many sample cases through
-`POST /api/test`. The code is compiled once and reused for every case.
-
-- **Add / edit / delete** cases. Each case has an input and an expected output.
-- **Paste and split**: paste a block of text and split it into input / expected on a
-  separator (a line of `---` or `===`, or a blank line), which is handy for pasting a
-  problem's sample block.
+`POST /api/test`. The code is compiled once (or served from the cache) and
+reused for every case.
+
+- **Add / edit / duplicate / delete** cases. Each case has an input and an
+  expected output; the field header shows the line count.
+- **Paste split**: paste a block of text and split it into input / expected
+  on a separator (a line of `---` or `===`, or a blank line).
+- **From statement**: paste a whole Codeforces problem statement. Every
+  `Input` / `Output` pair under `Examples` becomes a test case (replacing the
+  default case, or appended when you already have real cases). The
+  statement's time limit is applied to Settings, its title pre-fills the save
+  name, and the first sample becomes the Run panel's stdin when that is still
+  the default. AtCoder-style `Sample Input N` headings are understood too.
 - **Run all** compiles once, runs each case, and shows a per-case badge:
-  - `AC` accepted (output matches),
+  - `AC` accepted (output matches under the active checker),
   - `WA` wrong answer (output differs),
   - `TLE` time-limit exceeded,
   - `RE` runtime error (non-zero exit or killed by a signal),
-  - `CE` compile error (reported on every case when compilation fails).
-- **Diff view**: a failing case expands to a per-line diff of expected vs actual.
-  Comparison is tolerant of trailing whitespace and trailing blank lines, so a stray
-  newline never causes a spurious `WA`.
-- A **summary** reports totals and the worst verdict across all cases.
+  - `CE` compile error (reported on every case when compilation fails),
+  - `SKIP` not run because **Stop on fail** was enabled and an earlier case
+    failed.
+- **Run one** (the play button on a case) grades just that case and merges the
+  result into the existing verdicts.
+- **Use as stdin** copies a case's input to the Run panel.
+- **Diff view**: a failing case expands to a per-line diff of expected vs
+  actual. A `WA` whose tokens match but whose whitespace layout differs is
+  marked **whitespace only**; switch the checker to Tokens if the judge
+  accepts any layout.
+- **Expand all / collapse all**, and a **summary** with the worst verdict,
+  passed count and the slowest case.
 
 The default workspace ships with one case, `2 3` expecting `5`.
 
@@ -88,17 +117,18 @@ The default workspace ships with one case, `2 3` expecting `5`.
 
 ## Stress panel
 
-The Stress panel finds counter-examples by comparing your solution against a brute
-force on randomly generated inputs. It POSTs to `/api/stress` with three C++ sources
-and an iteration count:
+The Stress panel finds counter-examples by comparing your solution against a
+brute force on randomly generated inputs. It POSTs to `/api/stress` with
+three C++ sources, an iteration count and a seed base:
 
 - **Solution**: the candidate you want to verify (the editor's current code).
 - **Brute force**: a simple, obviously correct reference.
-- **Generator**: a program that prints a random test case; the harness passes the
-  iteration seed as `argv[1]` so runs are reproducible.
+- **Generator**: a program that prints a random test case; the harness passes
+  the iteration seed (`seed base + i`) as `argv[1]` so runs are reproducible.
 
-The harness compiles all three, then loops: generate an input, feed it to both the
-solution and the brute force, and compare their outputs. It reports the **first
+The harness compiles all three (using the compile cache), then loops:
+generate an input, feed it to both the solution and the brute force, and
+compare their outputs under the active checker. It reports the **first
 failing input** along with the reason:
 
 - `mismatch` the two outputs differ,
@@ -106,25 +136,40 @@ failing input** along with the reason:
 - `solution-tle` / `brute-tle` a program exceeded the time limit,
 - `generator-error` the generator itself failed.
 
-Iterations default to 100 (maximum 5000), and the whole request is bounded by a
-30-second deadline so a slow brute force cannot hang the page. If the `/api/stress`
-endpoint is unavailable, the panel shows a graceful "endpoint not available" notice
-instead of erroring.
+For a failure, **Add as test** appends the input as a test case with the
+brute force's output as the expected answer, and **Use as stdin** sends it to
+the Run panel. A clean run shows iteration count, total elapsed time and the
+maximum and average solution time.
+
+Iterations default to 100 (maximum 5000), and the whole request is bounded by
+a 60-second deadline so a slow brute force cannot hang the page; the result
+says when the budget cut the search short. If the `/api/stress` endpoint is
+unavailable, the panel shows a graceful notice instead of erroring.
 
 ---
 
 ## Problems sidebar
 
-The sidebar manages saved problems through `/api/problems`. Each problem bundles a
-name, the solution code, an optional statement, and its test cases, stored as a JSON
-file under `web/data/problems/`.
-
-- **Save** the current workspace under a name (`Cmd/Ctrl+S`, when a name is set).
-- **Load** a saved problem back into the editor and Tests panel.
-- **Rename** a problem (the on-disk slug is recomputed from the new name).
-- **Delete** a problem with a confirmation step.
-
-The active problem is remembered across reloads via `localStorage`.
+The sidebar manages saved problems through `/api/problems`. Each problem is
+a complete workspace: name, source, statement, test cases, the custom stdin,
+the brute-force and generator sources and the run settings, stored as one
+JSON file under `web/data/problems/`.
+
+- **Save** the current workspace under a name (`Ctrl/Cmd+S`, when a name is
+  set). An amber dot on the save button and next to the active problem name
+  marks unsaved changes.
+- **Load** a saved problem back into every panel.
+- **Rename** (the on-disk slug is recomputed), **duplicate** under a new name,
+  and **delete** with a confirmation step.
+- **Filter** the list once it has more than a handful of entries; each row
+  shows the test count and when it was last updated.
+- **New workspace** resets the editor, tests, stdin and stress sources
+  (asking first when there are unsaved changes).
+- **Export** downloads the whole library as one JSON bundle; **Import** reads
+  such a bundle back, skipping problems that already exist.
+
+The active problem is remembered across reloads via `localStorage`, and the
+sidebar can be collapsed with `Ctrl/Cmd+B`.
 
 ---
 
@@ -132,24 +177,45 @@ The active problem is remembered across reloads via `localStorage`.
 
 The Settings tab controls how every request is compiled and run:
 
-| Setting              | Default   | Notes                                                          |
-| -------------------- | --------- | -------------------------------------------------------------- |
-| Language standard    | `gnu++17` | Choose from `gnu++17`, `gnu++20`, `gnu++23`, `c++17`, `c++20`. |
-| Time limit           | 5000 ms   | Per execution; clamped server-side to 100-60000 ms.            |
-| Extra compiler flags | none      | Whitespace-separated flags appended to the compile command.    |
-| Font size            | 14 px     | Editor font, range 10-24 px.                                   |
-
-These settings are sent on every Run, Run all, and Stress request.
+| Setting              | Default   | Notes                                                                               |
+| -------------------- | --------- | ----------------------------------------------------------------------------------- |
+| Language standard    | `gnu++17` | `gnu++17`, `gnu++20`, `gnu++23`, `c++17`, `c++20`, `c++23`.                         |
+| Time limit           | 5000 ms   | Per execution; clamped server-side to 100-60000 ms.                                 |
+| Output checker       | Lines     | Lines (exact, trailing whitespace ignored), Tokens (whitespace-insensitive), Float. |
+| Float epsilon        | `1e-6`    | Shown for the Float checker; `                                                      | a-b | <= eps`or` | a-b | <= eps * max(1, | b   | )`. |
+| Extra compiler flags | none      | Space-separated; validated against an allowlist (see below).                        |
+| Font size            | 14 px     | Editor font, range 10-24 px.                                                        |
+
+Below the settings, **Reset to defaults** and **Clear compile cache** act
+immediately, and a read-only **Server** block shows the workbench version,
+the compiler version, the platform, the include directory, the size limits
+and how many binaries are cached.
+
+### Allowed compiler flags
+
+Flags reach the compiler command line, so only the families a competitive
+programmer needs are forwarded: `-O*`, `-W*`, `-w`, `-D*`, `-U*`, `-f*`,
+`-g*`, `-m*`, `-std=<known standard>`, `-pedantic`, `-static`, `-pthread`,
+`-pipe`. Flags that write files or load code (`-o`, `-I`, `-L`, `-l`,
+`-include`, `@file`, `-fplugin*`, `-fprofile*`, `-Wl,`, `-Wa,`, `-Wp,`) and
+anything containing shell metacharacters are dropped, and the Run and Tests
+panels list what was ignored and why.
 
 ---
 
 ## Keyboard shortcuts
 
-| Shortcut               | Action                                              |
-| ---------------------- | --------------------------------------------------- |
-| `Cmd/Ctrl+Enter`       | Run the current code in the Run panel.              |
-| `Cmd/Ctrl+Shift+Enter` | Run all test cases.                                 |
-| `Cmd/Ctrl+S`           | Save the current problem (when a save name is set). |
+| Shortcut               | Action                                                  |
+| ---------------------- | ------------------------------------------------------- |
+| `Ctrl/Cmd+Enter`       | Run the current code in the Run panel.                  |
+| `Ctrl/Cmd+Shift+Enter` | Run all test cases.                                     |
+| `Ctrl/Cmd+S`           | Save the current problem (when a save name is set).     |
+| `Ctrl/Cmd+1` .. `4`    | Switch to the Run / Tests / Stress / Settings panel.    |
+| `Ctrl/Cmd+B`           | Collapse or expand the problems sidebar.                |
+| `Ctrl/Cmd+/`           | Toggle a line comment on the selection (in the editor). |
+
+The divider between the editor and the panel area can be dragged;
+double-click it to restore the default split.
 
 ---
 
@@ -158,14 +224,58 @@ These settings are sent on every Run, Run all, and Stress request.
 The workbench stores UI state in `localStorage` (keys defined in
 `web/lib/storage.ts`). Persisted state is restored on the next load:
 
-| Key                | Holds                                          |
-| ------------------ | ---------------------------------------------- |
-| `cf:code`          | Editor contents.                               |
-| `cf:settings`      | Language standard, time limit, compiler flags. |
-| `cf:tests`         | Sample test cases.                             |
-| `cf:stress`        | Stress panel sources and iteration count.      |
-| `cf:activeProblem` | The currently loaded problem slug.             |
-| `cf:fontSize`      | Editor font size.                              |
-
-All `localStorage` access is guarded, so the app renders correctly on the server and
-simply skips persistence if storage is unavailable.
+| Key                | Holds                                                   |
+| ------------------ | ------------------------------------------------------- |
+| `cf:code`          | Editor contents.                                        |
+| `cf:stdin`         | The Run panel's custom stdin.                           |
+| `cf:settings`      | Language standard, time limit, checker, epsilon, flags. |
+| `cf:tests`         | Sample test cases.                                      |
+| `cf:stress`        | Stress panel sources and iteration count.               |
+| `cf:activeProblem` | The currently loaded problem slug.                      |
+| `cf:activeTab`     | The selected panel tab.                                 |
+| `cf:layout`        | The editor / panel split.                               |
+| `cf:fontSize`      | Editor font size.                                       |
+
+All `localStorage` access is guarded, so the app renders correctly on the
+server and simply skips persistence if storage is unavailable.
+
+---
+
+## Command-line tool
+
+`scripts/cf` is a Bash script that works from any directory; `bash
+scripts/setup.sh` links it onto your `PATH` as `cf`. It shares the include
+shim and the statement format with the web workbench.
+
+| Command                          | What it does                                                                                                                                                                           |
+| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cf template <name> [--from T]`  | Create `./<name>/solution.cpp` and `problem.txt`, verify they compile, open them in VS Code when available. `T` is `dp`, `graph`, `math` or a file.                                    |
+| `cf` / `cf <name>` / `cf <file>` | Compile every `.cpp` in the problem directory and run sample #1 (or `--sample N`, an input file, or inline stdin such as `cf "5\n1 2 3"`).                                             |
+| `cf test [name]`                 | Run every sample in `problem.txt` with a timeout; prints input, expected, actual and a unified diff on failure, per-sample timing and a summary.                                       |
+| `cf stress [name] [-n N]`        | Compile `solution.cpp`, `brute.cpp` and `gen.cpp`, run `N` seeded iterations (default 200, `--seed` to change the first seed) and save the first counter-example to `stress_fail.txt`. |
+| `cf samples [name]`              | Print the samples parsed from `problem.txt`.                                                                                                                                           |
+| `cf watch [name]`                | Poll the problem directory and re-run `cf test` whenever a `.cpp` or `problem.txt` changes.                                                                                            |
+| `cf serve [name]`                | Start the web workbench (`CF_SERVE_PROD=1` for a production build), creating the problem first if needed.                                                                              |
+| `cf doctor`                      | Check the compiler, the shim, a compile-and-run smoke test, `timeout`, Node, npm, make, shellcheck and the cache.                                                                      |
+| `cf clean`                       | Remove the build cache.                                                                                                                                                                |
+| `cf update`                      | Fast-forward the repository and re-run setup.                                                                                                                                          |
+| `cf version`                     | Print the version.                                                                                                                                                                     |
+
+Options shared by `run`, `test` and `stress`:
+
+- `--checker lines|tokens` (or `CF_CHECKER`): `lines` ignores trailing
+  whitespace and blank lines; `tokens` ignores all whitespace layout. In lines
+  mode a mismatch whose tokens match prints a hint.
+- `--timeout SEC` (or `CF_TIMEOUT`): execution limit, default 5 seconds. Needs
+  GNU `timeout` (or `gtimeout` from Homebrew coreutils on macOS).
+
+`problem.txt` is the statement pasted from Codeforces; samples are parsed from
+its `Examples` section exactly as the web importer does. `brute.cpp`,
+`gen.cpp` and `generator.cpp` are excluded from the solution build so a stress
+setup can live next to the solution. A `samples/N.in` / `samples/N.out` pair
+is used when the statement has no examples.
+
+Compiled binaries are cached under `build/.cache` keyed by compiler, flags and
+source; `CF_FORCE_REBUILD=1` bypasses the cache. `NO_COLOR=1` disables
+colors, `CF_VERBOSE=1` prints debug output, and `.cfconfig` at the repository
+root is sourced for per-repo overrides.
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
index 52ff280..31e04dc 100644
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -1,33 +1,43 @@
 # Troubleshooting
 
-Common issues when running the workbench, and what to do about them. The behavior
-described here comes from the engine (`web/app/api/_engine/cpp.ts`) and the routes.
+Common issues when running the workbench or the CLI, and what to do about
+them. The behaviour described here comes from the engine
+(`web/app/api/_engine/cpp.ts`), the routes and `scripts/cf`.
+
+Start with `cf doctor`: it checks the compiler, the shim, a compile-and-run
+smoke test, `timeout`, Node, npm, make and shellcheck, and reports the build
+cache.
 
 ## "No C++ compiler found" / every run is a CE
 
-The engine probes `clang++`, then `c++`, then `g++` (after any `CF_CXX` / `CXX`
-override). If none responds to `--version`, `/api/run` and `/api/test` return a `CE`
-verdict whose message is:
+The engine probes `clang++`, then `c++`, then `g++` (after any `CF_CXX` /
+`CXX` override). If none responds to `--version`, `/api/run` and `/api/test`
+return a `CE` verdict whose message is:
 
-> No C++ compiler found. Tried clang++, c++ and g++. Install the Xcode Command Line
-> Tools (`xcode-select --install`) or a g++ toolchain.
+> No C++ compiler found. Tried clang++, c++ and g++. Install the Xcode Command
+> Line Tools (`xcode-select --install`), a g++ toolchain, or set CF_CXX to the
+> compiler you want to use.
 
 Fixes:
 
 - **macOS:** `xcode-select --install` installs Apple clang as `clang++` / `c++`.
 - **Debian / Ubuntu:** `sudo apt-get install g++`.
-- **Use a specific compiler:** set `CF_CXX` (or `CXX`) to its path or name before
-  starting the server, for example `CF_CXX=g++-14 npm run dev`. The override is tried
-  first, then the default list.
+- **Windows:** install MinGW-w64 (for example through MSYS2 or Scoop) or LLVM
+  and make sure `g++` or `clang++` is on `PATH` for the shell that starts the
+  server.
+- **Use a specific compiler:** set `CF_CXX` (or `CXX`) to its path or name
+  before starting the server, for example `CF_CXX=g++-14 npm run dev`. The
+  override is tried first, then the default list.
 
 The detected compiler is cached for the process lifetime, so if you install a
-compiler while the server is running, restart it.
+compiler while the server is running, restart it. The Settings tab's Server
+block and the header show which compiler was detected.
 
 ## `<bits/stdc++.h>` will not compile
 
-The bundled shim at `include/bits/stdc++.h` only resolves when the compile includes
-`-I include`. The web engine and the `Makefile` add this automatically. If you compile
-by hand, include it yourself:
+The bundled shim at `include/bits/stdc++.h` only resolves when the compile
+includes `-I include`. The web engine, the CLI and the `Makefile` add this
+automatically. If you compile by hand, include it yourself:
 
 ```bash
 c++ -std=gnu++17 -I include solution.cpp -o solution
@@ -40,74 +50,133 @@ printf '#include <bits/stdc++.h>\nint main(){std::cout<<"ok\\n";}\n' > /tmp/h.cp
 c++ -std=gnu++17 -I include /tmp/h.cpp -o /tmp/h && /tmp/h
 ```
 
-The shim gates optional headers behind `__has_include` and avoids GCC-only headers,
-so it should build on any C++17-or-later toolchain. If a specific Standard Library
-type is missing, raise the standard in Settings (for example `gnu++20`).
+The shim gates optional headers behind `__has_include` and avoids GCC-only
+headers, so it should build on any C++17-or-later toolchain. If a specific
+Standard Library type is missing, raise the standard in Settings (for example
+`gnu++20`).
+
+## A compiler flag I set is ignored
+
+Extra flags are validated against an allowlist (see
+[features.md](features.md#allowed-compiler-flags)). The Run and Tests panels
+show an "Ignored compiler flags" notice with the reason for each dropped
+flag; `/api/*` responses carry them in `compile.rejectedFlags`. Flags that
+write files (`-o`), add include or library paths, load plugins or pass
+through to the linker are never forwarded.
 
 ## Time-limit exceeded (TLE) when you did not expect it
 
-- The default time limit is **5000 ms**. Raise it in Settings (Time limit) -- it is
-  clamped server-side to the range 100-60000 ms.
-- A program that waits for more input than it receives will block until the limit and
-  then be killed as `TLE`. Check that your program reads exactly the input it is given.
-- On timeout the process is terminated with `SIGKILL`, so partial output may be lost.
+- The default time limit is **5000 ms**. Raise it in Settings (Time limit);
+  it is clamped server-side to the range 100-60000 ms. Importing a statement
+  sets the limit to the one it declares (often 1000 or 2000 ms).
+- A program that waits for more input than it receives will block until the
+  limit and then be killed as `TLE`. Check that your program reads exactly
+  the input it is given.
+- On timeout the process is terminated with `SIGKILL`, so partial output may
+  be lost.
+- In the CLI, time limits need GNU `timeout` (`gtimeout` from Homebrew
+  coreutils on macOS). Without it `cf` warns once and runs unbounded.
 
 ## Output looks truncated
 
-Each of stdin, stdout, and stderr is capped at **4 MiB**. When a stream hits the cap,
-the response sets `truncated: true` and the program may be killed. Reduce the volume
-of output (for example, avoid debug prints in a hot loop) if you hit this.
+Each of stdin, stdout and stderr is capped at **4 MiB**. When a stream hits
+the cap, the response sets `truncated: true` and the program may be killed.
+Reduce the volume of output (for example, avoid debug prints in a hot loop)
+if you hit this.
 
 ## A correct answer is flagged WA
 
-Comparison is tolerant of trailing whitespace, trailing blank lines, and CRLF vs LF,
-so those are not the cause. Genuine differences -- a wrong value, a missing line, or
-extra interior whitespace -- will show in the expanded diff. The diff lists up to 200
-differing lines; a larger mismatch is truncated to that cap.
+Comparison is tolerant of trailing whitespace, trailing blank lines, and CRLF
+vs LF, so those are not the cause. Two things to check:
+
+- **"whitespace only"** next to the verdict means the tokens match but the
+  layout differs (for example one number per line instead of one line). If
+  the judge accepts any layout, switch the checker to **Tokens** in Settings
+  (`--checker tokens` in the CLI).
+- **Floating-point answers** need the **Float** checker; set the epsilon the
+  problem specifies (default `1e-6`, absolute or relative).
+
+Genuine differences show in the expanded diff, which lists up to 200
+differing lines.
+
+## The compile cache serves a stale binary
+
+The cache key includes the compiler, the standard, the accepted flags and the
+exact source, so any change to those produces a new build. If you replaced
+the compiler on disk without restarting the server, restart it, or click
+**Clear compile cache** in Settings (`DELETE /api/config?cache=1`). The CLI
+cache lives in `build/.cache`; `cf clean` removes it and `CF_FORCE_REBUILD=1`
+bypasses it.
 
 ## Stress testing finds nothing, or stops early
 
-- `/api/stress` runs up to the requested `iterations` (default 100, max 5000) but is
-  also bounded by a 30-second overall deadline, so `iterationsRun` can be lower than
-  requested. A slow brute force is the usual reason it stops early.
-- The generator must print a valid input to stdout and exit 0; if it fails, the run
-  reports a `generator-error`. The iteration seed arrives as `argv[1]` -- use it to
-  vary the generated input, or every iteration tests the same case.
-- If the Stress panel shows "endpoint not available", the `/api/stress` route is not
-  reachable; restart the dev server or rebuild.
+- `/api/stress` runs up to the requested `iterations` (default 100, max 5000)
+  but is also bounded by a 60-second overall deadline, so `iterationsRun` can
+  be lower than requested; the result says "request budget reached" when
+  that happens. A slow brute force is the usual reason.
+- The generator must print a valid input to stdout and exit 0; if it fails,
+  the run reports a `generator-error`. The iteration seed arrives as
+  `argv[1]`; use it to vary the generated input, or every iteration tests the
+  same case. Change the seed base to explore a different region.
+- The CLI needs `brute.cpp` and `gen.cpp` (or `generator.cpp`) next to the
+  solution, or `--brute` / `--gen` paths.
+- If the Stress panel shows "endpoint not available", the `/api/stress` route
+  is not reachable; restart the dev server or rebuild.
+
+## Statement import finds no samples
+
+The parser looks for an `Examples` / `Example` heading followed by `Input` and
+`Output` headings (or AtCoder-style `Sample Input N` / `Sample Output N`).
+Paste the statement as plain text from the problem page, including the
+`Examples` heading; the `Copy` button labels Codeforces adds are ignored. A
+bare `Input` / `Output` section without an `Examples` heading is treated as
+the input-format description, not a sample.
 
 ## Saved problems do not appear
 
-Problems are stored as JSON under `web/data/problems/` (or `CF_DATA_DIR` if set). The
-directory is created on first save. A file that is not valid JSON is silently skipped
-when listing, so a hand-edited, malformed file will simply not show up. Check the
-directory contents and the file's JSON if a problem goes missing.
+Problems are stored as JSON under `web/data/problems/` (or `CF_DATA_DIR` if
+set). The directory is created on first save. A file that is not valid JSON
+is silently skipped when listing, so a hand-edited, malformed file will
+simply not show up. Check the directory contents and the file's JSON if a
+problem goes missing. **Export** in the sidebar downloads the whole library
+as one bundle, which is the easiest way to move or back it up.
+
+## Windows notes
+
+- Run the CLI from Git Bash (or WSL). The repository's `.gitattributes` pins
+  LF line endings for scripts, so a checkout with `core.autocrlf=true` still
+  runs them unchanged.
+- The engine names binaries `prog.exe` and normalises the temp path in
+  diagnostics, so the workbench works with MinGW-w64 and LLVM.
+- `timeout` comes with Git for Windows' coreutils.
 
 ## macOS and bash 3.2 notes
 
-macOS ships bash 3.2, and many users run zsh. The `Makefile` and CLI are written for
-that reality:
+macOS ships bash 3.2, and many users run zsh. The `Makefile` and CLI are
+written for that reality:
 
-- No bashisms and no GNU-only flags are used, so the `Makefile` runs under bash 3.2
-  and zsh without GNU coreutils.
-- Timing and timeouts use Node when it is available (high-resolution, cross-platform)
-  and fall back to a pure-POSIX background-and-kill timer otherwise. The GNU `timeout`
-  command and the shell `time` builtin are intentionally avoided because they are
-  unreliable or absent on macOS.
-- The web engine never relies on the shell for timing; it measures wall-clock time in
-  Node with `process.hrtime.bigint()`.
+- No bashisms and no GNU-only flags are used, so the `Makefile` runs under
+  bash 3.2 and zsh without GNU coreutils.
+- Timing and timeouts use Node when it is available (high-resolution,
+  cross-platform) and fall back to a pure-POSIX background-and-kill timer
+  otherwise.
+- `scripts/cf` reports timings in milliseconds when `EPOCHREALTIME` (bash 5)
+  or GNU `date +%s%N` is available and falls back to whole seconds.
+- The web engine never relies on the shell for timing; it measures wall-clock
+  time in Node with `process.hrtime.bigint()`.
 
 ## `node` / `npm` behave oddly in a custom shell
 
-Some shells wrap `node` / `npm` with an nvm lazy-load shim that can misbehave in
-non-interactive contexts. If you see odd errors, invoke the real binaries directly,
-for example `/opt/homebrew/bin/node` and `/opt/homebrew/bin/npm` on Apple Silicon, or
-the paths your Node install reports via `which -a node`.
+Some shells wrap `node` / `npm` with an nvm lazy-load shim that can misbehave
+in non-interactive contexts. If you see odd errors, invoke the real binaries
+directly, for example `/opt/homebrew/bin/node` and `/opt/homebrew/bin/npm` on
+Apple Silicon, or the paths your Node install reports via `which -a node`.
 
 ## `next build` fails with "Cannot find module 'typescript'" (or eslint, tailwind)
 
-This happens when dependencies were installed under `NODE_ENV=production`, which makes
-npm omit `devDependencies`. The project keeps build-critical tooling in
-`dependencies` precisely to avoid this; if you still hit it, ensure your install used
-the project's `web/package.json` unmodified and re-run `npm install`. See
-[development.md](development.md) for the rationale.
+This happens when dependencies were installed under `NODE_ENV=production`,
+which makes npm omit `devDependencies`. The project keeps build-critical
+tooling in `dependencies` precisely to avoid this; if you still hit it,
+ensure your install used the project's `web/package.json` unmodified and
+re-run `npm install`. See [development.md](development.md) for the
+rationale.

From 4f0ad82c6c6594645459165fdb05126f224cb039 Mon Sep 17 00:00:00 2001
From: mbn <66748817+mbn-code@users.noreply.github.com>
Date: Tue, 15 Sep 2026 23:57:34 +0200
Subject: [PATCH 6/7] fix: CI portability for gcc 13, macOS bash 3.2 and
 pipe-sized output chunks

- include/bits/stdc++.h: only pull in <coroutine> under C++20 (or
  -fcoroutines); libstdc++ 13 rejects it outright with -std=gnu++17, which
  broke the Makefile smoke test and every compile in the web unit tests
- scripts/cf: expand the cleanup and source-file arrays with the
  ${arr[@]+"${arr[@]}"} idiom so an empty array does not trip `set -u` on
  bash 3.2; the EXIT trap made `cf version` exit 1 on macOS
- tests/cli_test.sh: record assertion results with && instead of a bare
  test so a failing check is reported rather than aborting the suite
  silently under `set -e`
- engine: when a stdout/stderr chunk fills the output cap exactly, flag the
  next chunk as truncation and stop the program; macOS delivered a 64 KiB
  chunk that exactly matched the cap and the run was never marked truncated
---
 include/bits/stdc++.h      |  2 +-
 scripts/cf                 |  6 +++---
 tests/cli_test.sh          | 10 ++++++----
 web/app/api/_engine/cpp.ts | 12 ++++++++++--
 4 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/include/bits/stdc++.h b/include/bits/stdc++.h
index 3118b02..693d00a 100644
--- a/include/bits/stdc++.h
+++ b/include/bits/stdc++.h
@@ -137,7 +137,7 @@
 #if __has_include(<concepts>)
 #include <concepts>
 #endif
-#if __has_include(<coroutine>)
+#if __has_include(<coroutine>) && (__cplusplus >= 202002L || defined(__cpp_impl_coroutine))
 #include <coroutine>
 #endif
 #if __has_include(<source_location>)
diff --git a/scripts/cf b/scripts/cf
index db5ccf0..b2bfc07 100755
--- a/scripts/cf
+++ b/scripts/cf
@@ -270,7 +270,7 @@ add_cleanup() {
 }
 run_cleanup() {
     local item
-    for item in "${CLEANUP_ITEMS[@]}"; do
+    for item in ${CLEANUP_ITEMS[@]+"${CLEANUP_ITEMS[@]}"}; do
         rm -f "$item" 2>/dev/null || true
     done
 }
@@ -984,7 +984,7 @@ cmd_test_all() {
     collect_cpp_files "$prob_dir"
     local sources=()
     local f
-    for f in "${cpp_files[@]}"; do
+    for f in ${cpp_files[@]+"${cpp_files[@]}"}; do
         case "$(basename "$f")" in
             brute.cpp|gen.cpp|generator.cpp) ;;
             *) sources+=("$f") ;;
@@ -1249,7 +1249,7 @@ cmd_stress() {
     collect_cpp_files "$prob_dir"
     local sources=()
     local f
-    for f in "${cpp_files[@]}"; do
+    for f in ${cpp_files[@]+"${cpp_files[@]}"}; do
         case "$(basename "$f")" in
             brute.cpp|gen.cpp|generator.cpp) ;;
             *) sources+=("$f") ;;
diff --git a/tests/cli_test.sh b/tests/cli_test.sh
index 9c4e159..3309cd8 100644
--- a/tests/cli_test.sh
+++ b/tests/cli_test.sh
@@ -59,13 +59,15 @@ check() {
 }
 
 expect_status() {
-    local name="$1" want="$2"
-    [ "$STATUS" -eq "$want" ]; check "$name (exit $want)" $?
+    local name="$1" want="$2" ok=1
+    [ "$STATUS" -eq "$want" ] && ok=0
+    check "$name (exit $want)" "$ok"
 }
 
 expect_contains() {
-    local name="$1" needle="$2"
-    printf '%s' "$OUT" | grep -qF -- "$needle"; check "$name contains '$needle'" $?
+    local name="$1" needle="$2" ok=1
+    printf '%s' "$OUT" | grep -qF -- "$needle" && ok=0
+    check "$name contains '$needle'" "$ok"
 }
 
 expect_not_contains() {
diff --git a/web/app/api/_engine/cpp.ts b/web/app/api/_engine/cpp.ts
index 9741f20..4f1f3a4 100644
--- a/web/app/api/_engine/cpp.ts
+++ b/web/app/api/_engine/cpp.ts
@@ -514,7 +514,12 @@ export function runBinary(
     });
 
     child.stdout.on("data", (d: Buffer) => {
-      if (outLen >= maxOut) return;
+      if (outLen >= maxOut) {
+        // A chunk filled the cap exactly; anything after it is overflow.
+        truncated = true;
+        child.kill("SIGKILL");
+        return;
+      }
       const room = maxOut - outLen;
       if (d.length > room) {
         outChunks.push(d.subarray(0, room));
@@ -528,7 +533,10 @@ export function runBinary(
     });
 
     child.stderr.on("data", (d: Buffer) => {
-      if (errLen >= maxOut) return;
+      if (errLen >= maxOut) {
+        truncated = true;
+        return;
+      }
       const room = maxOut - errLen;
       if (d.length > room) {
         errChunks.push(d.subarray(0, room));

From 7d98f5dad11f2c74f4dd6ae2c8b842bee707f7c1 Mon Sep 17 00:00:00 2001
From: mbn <66748817+mbn-code@users.noreply.github.com>
Date: Wed, 16 Sep 2026 00:23:06 +0200
Subject: [PATCH 7/7] test(engine): make the TLE fixture loop unremovable by
 the optimizer

A side-effect-free `for(;;){}` is undefined behaviour in C++ and gcc 13 at
-O2 on the ubuntu runner deleted it, so the binary returned immediately and
`timedOut` was false. A volatile counter keeps the loop observable on every
compiler.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 web/app/api/_engine/cpp.test.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/web/app/api/_engine/cpp.test.ts b/web/app/api/_engine/cpp.test.ts
index 2fc5665..959220e 100644
--- a/web/app/api/_engine/cpp.test.ts
+++ b/web/app/api/_engine/cpp.test.ts
@@ -97,7 +97,11 @@ maybe("compile + run", () => {
   });
 
   it("classifies a timeout as TLE", async () => {
-    const r = await compile("int main(){ for(;;){} }\n");
+    // A side-effect-free infinite loop is UB in C++ and gcc -O2 deletes it
+    // (the ubuntu runner returned immediately); the volatile write keeps it.
+    const r = await compile(
+      "int main(){ volatile unsigned long long n = 0; for(;;){ ++n; } }\n",
+    );
     expect(r.ok).toBe(true);
     const run = await runBinary(r.binPath!, { timeLimitMs: 300 });
     expect(run.timedOut).toBe(true);