@tangle-network/agent-bench 0.1.0 → 0.3.5

package/src/coordination-mcp-container-reach.mts

@@ -0,0 +1,181 @@
+/**
+ * Manual reachability probe for the coordination MCP from inside a Docker container.
+ *
+ * Run: `npx tsx bench/src/coordination-mcp-container-reach.mts`.
+ */
+
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+import {
+  type Agent,
+  type AgentProfile,
+  type AgentSpec,
+  createExecutorRegistry,
+  createSupervisor,
+  type Executor,
+  type ExecutorResult,
+  InMemoryResultBlobStore,
+  InMemorySpawnJournal,
+  type Scope,
+  type UsageEvent,
+} from '../../src/runtime/index'
+import { serveCoordinationMcp } from '../../src/runtime/supervise/coordination-mcp'
+
+const HOST_BIND = '0.0.0.0'
+const DOCKER_BRIDGE_GATEWAY = process.env.DOCKER_BRIDGE_GATEWAY ?? '172.17.0.1'
+
+function trivialWorker(name: string): Agent<unknown, unknown> {
+  const ex: Executor<unknown> = {
+    runtime: 'router',
+    execute() {
+      return (async function* () {
+        yield { kind: 'iteration' } as UsageEvent
+      })()
+    },
+    teardown: () => Promise.resolve({ destroyed: true }),
+    resultArtifact: (): ExecutorResult<unknown> => ({
+      outRef: `w:${name}`,
+      out: { ok: true },
+      verdict: { valid: true, score: 1 },
+      spent: { iterations: 1, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 },
+    }),
+  }
+  const spec: AgentSpec = { profile: { name } as AgentProfile, harness: null, executor: ex }
+  return { name, act: async () => ({ ok: true }), executorSpec: spec } as Agent<unknown, unknown> & {
+    executorSpec: AgentSpec
+  }
+}
+
+interface ToolsListResponse {
+  result?: { tools?: Array<{ name: string; description?: string; inputSchema?: unknown }> }
+  error?: { code: number; message: string }
+}
+
+async function dockerCurlToolsList(
+  containerUrl: string,
+): Promise<{ raw: string; parsed: ToolsListResponse; cmd: string }> {
+  const rpc = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list' })
+  const args = [
+    'run',
+    '--rm',
+    '--add-host',
+    'host.docker.internal:host-gateway',
+    'curlimages/curl',
+    '-s',
+    '-X',
+    'POST',
+    containerUrl,
+    '-H',
+    'content-type: application/json',
+    '-d',
+    rpc,
+  ]
+  const cmd = `docker ${args.join(' ')}`
+  const { stdout } = await execFileAsync('docker', args, { encoding: 'utf8', timeout: 120_000 })
+  return { raw: stdout, parsed: JSON.parse(stdout) as ToolsListResponse, cmd }
+}
+
+function opencodeConfigSnippet(containerUrl: string): string {
+  return JSON.stringify(
+    {
+      $schema: 'https://opencode.ai/config.json',
+      permission: {
+        external_directory: 'allow',
+        bash: 'allow',
+        edit: 'allow',
+        read: 'allow',
+        write: 'allow',
+        webfetch: 'allow',
+        task: 'allow',
+        plan_enter: 'allow',
+        plan_exit: 'allow',
+        question: 'allow',
+      },
+      mcp: {
+        coordination: {
+          type: 'remote',
+          url: containerUrl,
+          enabled: true,
+        },
+      },
+    },
+    null,
+    2,
+  )
+}
+
+async function main(): Promise<void> {
+  const blobs = new InMemoryResultBlobStore()
+  let ok = false
+
+  const root: Agent<unknown, unknown> = {
+    name: 'coordination-mcp-container-reach',
+    async act(_t, scope: Scope<unknown>) {
+      const mcp = await serveCoordinationMcp({
+        scope,
+        blobs,
+        makeWorkerAgent: () => trivialWorker('w'),
+        perWorker: { maxIterations: 4, maxTokens: 2000 },
+        host: HOST_BIND,
+      })
+      // Docker containers reach the host through the bridge gateway, not the 0.0.0.0 bind URL.
+      const containerUrl = `http://${DOCKER_BRIDGE_GATEWAY}:${mcp.port}/mcp`
+      const hostDockerInternalUrl = `http://host.docker.internal:${mcp.port}/mcp`
+
+      console.error(`[probe] host-binding used         : ${HOST_BIND}`)
+      console.error(`[probe] server url (mcp.url)       : ${mcp.url}`)
+      console.error(`[probe] container-reachable url    : ${containerUrl}`)
+      console.error(`[probe] alt (host.docker.internal) : ${hostDockerInternalUrl}`)
+      console.error('')
+
+      try {
+        console.error('[probe] POSTing tools/list from inside a docker container ...')
+        const { raw, parsed, cmd } = await dockerCurlToolsList(containerUrl)
+        console.error(`[probe] container ran: ${cmd}`)
+        console.error(`[probe] container got back (${raw.length} bytes):`)
+        console.error(raw)
+        console.error('')
+
+        const toolNames = (parsed.result?.tools ?? []).map((t) => t.name)
+        const hasSpawn = toolNames.includes('spawn_agent')
+        const hasAwait = toolNames.includes('await_event')
+        console.error(`[probe] tools advertised: ${toolNames.join(', ')}`)
+        console.error(`[probe] spawn_agent present = ${hasSpawn}; await_event present = ${hasAwait}`)
+        ok = hasSpawn && hasAwait
+
+        if (ok) {
+          console.error('')
+          console.error('[probe] opencode.json snippet (arm B writes this via OPENCODE_CONFIG):')
+          console.error(opencodeConfigSnippet(containerUrl))
+        }
+        return ok ? { reachable: true } : undefined
+      } finally {
+        await mcp.close()
+      }
+    },
+  }
+
+  await createSupervisor<unknown, unknown>().run(root, 'reach', {
+    budget: { maxIterations: 100, maxTokens: 400_000 },
+    runId: 'coordination-mcp-container-reach',
+    journal: new InMemorySpawnJournal(),
+    blobs,
+    executors: createExecutorRegistry(),
+    maxDepth: 4,
+    now: () => Date.now(),
+  })
+
+  console.error(
+    ok
+      ? 'CONTAINER-REACHABLE: docker tools/list returned spawn_agent and await_event.'
+      : 'NOT reachable from container; see output above.',
+  )
+  process.exit(ok ? 0 : 1)
+}
+
+main().catch((e) => {
+  console.error(e instanceof Error ? (e.stack ?? e.message) : String(e))
+  process.exit(1)
+})

package/src/decoder-live.mts

@@ -47,7 +47,7 @@ async function main(): Promise<number> {
       },
       profile: { name: 'decoder-live' },
     },
-  } as never)) as Record<string, (...a: never[]) => unknown> & { id?: string }
+  } as never)) as unknown as Record<string, (...a: never[]) => unknown> & { id?: string }
 
   try {
     console.error('[live] box', box.id, '— waiting for running…')

package/src/examples/README.md

@@ -1,58 +1,122 @@
-# Examples — the optimization suite in three layers
+# Bench examples — make an AI actually earn its answer
 
-`strategy-demo.mts` is the smallest end-to-end demonstration of the optimization suite.
-It runs on a toy "counter" `Environment` so it needs only a router key — no benchmark
-dataset, no sandbox, no gym.
+Four runnable programs that share one idea: never trust an AI's answer on its word — put a **check**
+in front of it and let the AI keep trying until the check passes. A check is just a function that
+returns pass/fail (grade a number, run a test suite, compile a proof). Give the AI a check and a
+compute budget and this toolkit finds the best way to spend that budget: try many answers and keep
+the best, or let a critic read the failure and steer the next attempt.
+
+All four run from the `bench/` directory (`cd bench` first). Nothing here needs a special framework —
+each is a single file you can read top to bottom.
+
+## Which one to run first
+
+| run this | what you learn | needs a key? |
+|---|---|---|
+| **`strategy-demo.mts`** | the whole idea on a 20-line toy task | yes (one router key) |
+| **`math-demo.mts`** | the same thing grading real answers (word problems) | yes |
+| **`lean-proof-gate.mts`** | a check the AI literally cannot fool (a theorem prover) | no — offline mode |
+| **`benchmark-matrix.mts`** | rank many AI agents against public benchmarks | no — offline demo |
+
+---
+
+## `strategy-demo.mts` — the whole idea in one small file
+
+The smallest end-to-end demo. The task is a toy: drive a counter to exactly 5 using an `increment`
+tool. Because the task is trivial, it needs only a router key — no dataset, no cloud sandbox — so you
+can watch the machinery instead of the problem.
+
+It shows three ways to use the toolkit, each a few lines:
+
+1. **Just run it.** Hand it your task and your check; it compares the built-in ways of spending the
+   budget and reports which won.
+2. **Pick the tactics.** Choose from `sample` (make N independent attempts, keep the best-scoring
+   one), `refine` (attempt, let a critic read what went wrong, steer the next attempt, repeat), and
+   `adaptiveRefine` (refine, but abandon and restart a line that stops improving).
+3. **Write your own.** `defineStrategy(name, body)` composes two moves — `shot()` (one worker
+   attempt) and `critique()` (a separate reviewer reads the transcript and returns a steer) — into
+   any tactic you invent. The demo authors one called `doubleCheck` in ~10 lines.
+
+```bash
+TANGLE_API_KEY=...  WORKER_MODEL=gpt-4o-mini  tsx src/examples/strategy-demo.mts
+```
+
+Prints two leaderboards: the built-in tactics, then the built-ins plus your authored `doubleCheck`,
+each scored by the counter task's own check. Default model is `deepseek-v4-flash`; override with
+`WORKER_MODEL`.
+
+## `math-demo.mts` — the same toolkit grading real answers
+
+Identical machinery, but the check now grades **answers**: three grade-school word problems, scored
+by exact numeric match against the known answer. The worker gets a `calculator` tool and must submit
+a final number. This is the template for any domain where success means "did the final answer come
+out right" — a tax return value, a computed total, a rubric score. To move it to your domain you swap
+one function: the check.
 
 ```bash
-TANGLE_API_KEY=... WORKER_MODEL=gpt-4o-mini pnpm tsx src/examples/strategy-demo.mts
+TANGLE_API_KEY=...  WORKER_MODEL=gpt-4o-mini  BUDGET=3  tsx src/examples/math-demo.mts
 ```
 
-## The model
+Compares `sample`, `refine`, and `sampleThenRefine` (N fresh attempts, then critique-and-iterate on
+the best) at an equal budget of `BUDGET` attempts each, so you can see whether iterating on feedback
+actually beats blind resampling. Needs `TANGLE_API_KEY`; default model `deepseek-v4-flash`.
 
-You have a **task**, a deployable **check**, and a compute **budget**. A *strategy* is
-**how you spend the budget to beat the check**. You implement an `Environment` (5 hooks)
-and get the strategies compared, scored by your own check, for free.
+## `lean-proof-gate.mts` — a check the AI cannot fool
 
-## The three layers (each is a few lines in the demo)
+An AI writes a mathematical proof and **Lean 4** (a real theorem prover) compiles it. A wrong proof
+is rejected with a precise error the AI reads and fixes; the loop repeats until Lean accepts a
+genuinely correct proof. This is the most honest check in the folder: correctness is machine-verified,
+not judged by another model. It has its own full walkthrough in
+[`lean-proof-gate.README.md`](./lean-proof-gate.README.md).
 
-1. **Just run it** — `runBenchmark({ environment, tasks, worker })` compares the default
-   strategies and reports the paired lift. Black box; no vocabulary needed.
+```bash
+# See the checker work — no API key (builds a Lean image, first run ~3 min):
+tsx src/examples/lean-proof-gate.mts --verify-only
 
-2. **Pick strategies** — pass `strategies: [sample, refine, adaptiveRefine]`. Named by
-   what they *do*:
-   - **`sample`** — N independent attempts, keep the best-verifying (best-of-N / resample).
-   - **`refine`** — attempt → a critic reads the trace → steer the next → repeat (iterate).
-   - **`adaptiveRefine`** — refine, but abandon-and-restart a line that stops improving
-     (branch-when-stuck).
+# Run the full write-check-retry loop — needs a model:
+TANGLE_API_KEY=...  WORKER_MODEL=gpt-4.1  BUDGET=3  tsx src/examples/lean-proof-gate.mts
+```
 
-3. **Author your own** — `defineStrategy(name, body)`. A strategy body composes two steps
-   — `shot()` (one worker attempt over an artifact) and `critique()` (the firewalled
-   analyst reads the trace → a steer) — with **zero** Supervisor/Scope ceremony. The demo
-   authors `doubleCheck` inline in ~10 lines. This is the unit a skill (or an agent) emits.
+The `--verify-only` mode compiles five real proofs plus one deliberately wrong one and shows the
+wrong one getting rejected — proof the check is real before you spend a cent on a model.
 
-## The answer-shaped template — `math-demo.mts`
+## `benchmark-matrix.mts` — rank many agents across many benchmarks
 
-`math-demo.mts` is the same suite on the **answer-shaped** domain template — the shape
-tax/legal/gtm products use. `createVerifierEnvironment({ name, check, extraTools,
-callExtra })` builds the whole `Environment` from one deterministic `check` (here: 3
-GSM8K-style problems, graded by exact numeric match), and `sampleThenRefine` joins the
-built-ins compared at equal budget.
+The other three grade one task domain. This one builds a **leaderboard**: it runs a set of AI agents
+against a set of public coding/research benchmarks (HumanEval, SWE-bench, terminal-bench, and more)
+and ranks them. Each benchmark brings its **own** grader, so the score is the benchmark's, not a
+number we made up. An "agent" here is a **cell** — a combination of coding harness (opencode, Codex,
+a bare router call) and model (e.g. `glm-4.6`, `gpt-5`).
 
 ```bash
-TANGLE_API_KEY=... WORKER_MODEL=gpt-4o-mini pnpm tsx src/examples/math-demo.mts
+# Offline demo — no keys. A stub benchmark with a deterministic grader proves the
+# whole pipeline and prints a ranked board:
+tsx src/examples/benchmark-matrix.mts
+
+# Live — real benchmarks graded by their real graders:
+TANGLE_API_KEY=...  BENCHMARKS=humaneval  tsx src/examples/benchmark-matrix.mts
 ```
 
-## The hooks you customize (world-class-DX surface)
+Pick the benchmarks with the `BENCHMARKS` env var (comma-separated). The **cells** (which
+harness+model agents to rank) are the `cells` array at the top of the file — edit that array to
+change who competes. Other knobs: `N` (tasks per benchmark, default 10), `CONCURRENCY` (default 4),
+and `SANDBOX_BASE` if your harnesses run in a remote sandbox.
+
+---
+
+## Where the interesting results are
+
+On the toy and math tasks the tactics often tie — the task is too easy for the way-you-spend-budget
+to matter. The gap shows up on hard, stateful work: on an internal operations benchmark, `refine`
+(iterate on a critic's feedback) beats blind `sample` by **+16.4 percentage points**. See
+`bench/HARNESS.md` and `bench/src/agentic-run.mts` for that harder environment.
 
-- **the check / verifier** → `Environment.score` (your deployable success criterion)
-- **the critic / steerer** → `worker.analystInstruction` (the analyst prompt; GEPA tunes this)
-- **the worker** → the model (`worker.model`)
-- **the strategy** → `defineStrategy` (or drop to `runAgentic` / the Supervisor for novel topologies)
+## The four hooks you customize
 
-## Where the real results live
+Everything above is built from four swappable pieces. To adapt any of these examples to your problem,
+you change one of these and leave the rest alone:
 
-On a trivial task all strategies tie. The differences (e.g. refine/adaptiveRefine beating
-sample on stateful agentic work, +16.4pp on EnterpriseOps-Gym) show on real domains — see
-`bench/HARNESS.md` and `bench/src/agentic-run.mts` (the EOPS Environment), and
-`bench/src/eops-gepa.mts` (GEPA evolving the analyst/critic prompt against the check).
+- **the check** — your pass/fail function (grade the answer, run the tests, compile the proof).
+- **the reviewer** — the prompt the critic uses to read a failed attempt and suggest a fix.
+- **the worker** — the model that does the work (`WORKER_MODEL`).
+- **the tactic** — how the budget is spent (`sample` / `refine` / your own `defineStrategy`).

package/src/examples/benchmark-matrix.mts

@@ -0,0 +1,101 @@
+/**
+ * Rank a set of AI agents across a set of public benchmarks, and print a leaderboard.
+ *
+ * A "cell" is one agent = a coding harness (opencode, Codex, a bare router call) + a model.
+ * Each benchmark (humaneval, swe-bench, terminal-bench, …) brings its OWN deterministic
+ * grader, so the score is the benchmark's, not one we invented. Pick the benchmarks with
+ * the BENCHMARKS env var; edit the `cells` array below to change who competes.
+ *
+ * Run from bench/:
+ *   # offline demo (no creds): a stub benchmark + stub agent prove the pipeline end to end
+ *   tsx src/examples/benchmark-matrix.mts
+ *
+ *   # live: real benchmarks graded by their real graders
+ *   TANGLE_API_KEY=... BENCHMARKS=humaneval tsx src/examples/benchmark-matrix.mts
+ */
+import type { BenchmarkAdapter, BenchScore, BenchTask } from '../benchmarks/types'
+import { type BenchCell, type BenchShot, printBenchmarksReport, runBenchmarks } from '../run-benchmarks'
+
+/** The matrix: three cells spanning harnesses, models, and transports. */
+const cells: BenchCell[] = [
+  { label: 'opencode/glm-4.6', harness: 'opencode', model: 'glm-4.6', backend: 'sandbox' },
+  { label: 'codex/gpt-5', harness: 'codex', model: 'gpt-5', backend: 'sandbox' },
+  { label: 'router/deepseek-v4-flash', model: 'deepseek-v4-flash', backend: 'router' },
+]
+
+async function live(): Promise<void> {
+  const benchmarks = (process.env.BENCHMARKS ?? 'humaneval')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+  const report = await runBenchmarks({
+    benchmarks,
+    cells,
+    routerBaseUrl: process.env.ROUTER_BASE ?? 'https://router.tangle.tools/v1',
+    routerKey: process.env.TANGLE_API_KEY!,
+    ...(process.env.SANDBOX_BASE ? { sandboxBaseUrl: process.env.SANDBOX_BASE } : {}),
+    n: Number(process.env.N ?? 10),
+    concurrency: Number(process.env.CONCURRENCY ?? 4),
+    onResult: (r) =>
+      console.log(`  [${r.ok ? (r.resolved ? 'PASS' : 'fail') : 'ERR '}] ${r.benchmark} ${r.cell} ${r.taskId}`),
+  })
+  console.log(`\n=== live: ${report.benchmarks.join(', ')} × ${report.cells.length} cells ===`)
+  console.log(printBenchmarksReport(report))
+}
+
+/** Offline proof: a stub registry whose judge is deterministic, and a stub shot whose "ability"
+ *  differs per cell — so the leaderboard ORDER reflects the cells, with no model or sandbox. */
+async function demo(): Promise<void> {
+  const stub = (name: string, n: number): BenchmarkAdapter => ({
+    name,
+    preflight: async () => {},
+    loadTasks: async (o) =>
+      Array.from({ length: o?.limit ?? n }, (_, i) => ({
+        id: `${name}-${i}`,
+        prompt: `task ${i}`,
+        metadata: { gold: `G-${name}-${i}` },
+      })),
+    judge: async (t: BenchTask, a: string): Promise<BenchScore> => ({
+      resolved: a === t.metadata?.gold,
+      score: a === t.metadata?.gold ? 1 : 0,
+    }),
+    goldArtifact: async (t: BenchTask) => String(t.metadata?.gold),
+  })
+  const registry: Record<string, BenchmarkAdapter> = {
+    'demo-coding': stub('demo-coding', 8),
+    'demo-research': stub('demo-research', 8),
+  }
+
+  // Cell ability: opencode/glm solves the most, router the least — deterministic by task index.
+  const ability: Record<string, number> = {
+    'opencode/glm-4.6': 0.88,
+    'codex/gpt-5': 0.62,
+    'router/deepseek-v4-flash': 0.38,
+  }
+  const shot: BenchShot = async ({ task, cell }) => {
+    const idx = Number(task.id.split('-').pop())
+    const solves = idx / 8 < (ability[cell.label] ?? 0.5)
+    return { artifact: solves ? String(task.metadata?.gold) : 'WRONG', ok: true }
+  }
+
+  const report = await runBenchmarks({
+    benchmarks: ['demo-coding', 'demo-research'],
+    cells,
+    routerBaseUrl: 'demo',
+    routerKey: 'demo',
+    runShot: shot,
+    resolveAdapter: (k) => {
+      const a = registry[k]
+      if (!a) throw new Error(`unknown: ${k}`)
+      return a
+    },
+  })
+  console.log('=== offline demo: 2 benchmarks × 3 cells (stub judge, no creds) ===')
+  console.log(printBenchmarksReport(report))
+  console.log('\nSet TANGLE_API_KEY + BENCHMARKS to run real benchmarks against these cells.')
+}
+
+void (process.env.TANGLE_API_KEY ? live() : demo()).catch((e) => {
+  console.error(e instanceof Error ? (e.stack ?? e.message) : String(e))
+  process.exit(1)
+})

package/src/examples/lean-proof-gate.README.md

@@ -0,0 +1,77 @@
+# Prove math with an AI that can't bluff
+
+An AI writes a mathematical proof; a real theorem prover — **Lean 4** — checks it. If the proof is
+wrong, Lean says exactly why, the AI reads that error and tries again, and it repeats until Lean
+accepts a genuinely correct proof. Nothing is taken on the model's word: every proof that passes
+here is machine-verified.
+
+This is the automatable core of [pipeline-math](https://github.com/Pengbinghui/pipeline-math), which
+used the same prover-and-checker idea to crack open mathematics problems.
+
+## Why it matters
+
+Ask a language model to "prove X" and it will hand you a confident, fluent, and often **wrong**
+proof. Here it cannot get away with that. Lean compiles the proof and rejects anything that doesn't
+actually follow — and we also reject `sorry`/`admit` (Lean's "trust me, skip this" placeholders). The
+checker is ground truth, so looping against it turns a plausible-sounding guesser into a prover whose
+every answer is verified.
+
+## How it works — you don't need a special framework
+
+A "prover-verifier loop" sounds exotic; it's two ordinary parts:
+
+1. a **checker** — a function that returns pass/fail. Here: run the Lean compiler on the proof.
+2. a **retry strategy** — show the model its failure and let it try again (`refine`, below).
+
+Point the strategy at the checker and you have the loop. Swap Lean for unit tests and the same setup
+proves *code*; swap it for a rubric and it writes *to spec*.
+
+Two retries actually stack here: **within one attempt** the model calls a `lean_check` tool (the real
+compiler) to fix its proof before answering; **across attempts** `refine` carries the last failure
+forward. `sample` is the honest baseline — one blind attempt, no feedback.
+
+## See the checker work — no API key needed
+
+```bash
+tsx src/examples/lean-proof-gate.mts --verify-only
+```
+
+This builds a Lean 4 image (first run ~3 min) and compiles five real proofs plus one deliberately
+wrong one:
+
+```
+PASS  and-swap        (⟨h.2, h.1⟩)
+PASS  or-swap         (h.symm)
+PASS  add-comm        (by omega)
+PASS  mul-one         (by simp)
+PASS  reverse-reverse (by simp)
+negative control (deliberately wrong): FAIL ✓ rejected
+verifier: 5/5 reference proofs accepted, wrong proof rejected=true
+```
+
+The wrong proof fails with a real Lean error — `argument h.left has type p but is expected to have
+type q` — which is exactly the message the AI reads and fixes.
+
+## Run the full loop — needs a model
+
+```bash
+TANGLE_API_KEY=…  WORKER_MODEL=gpt-4.1  BUDGET=3  tsx src/examples/lean-proof-gate.mts
+```
+
+A real model proves the theorems, calling Lean to check each attempt. The report compares one blind
+attempt (`sample`) against iterating on the checker's feedback (`refine`), so you can see whether the
+loop actually earns its cost.
+
+## Files
+
+| file | what it is |
+|---|---|
+| `lean-proof-gate.mts` | the theorems, the checker wiring, and the run |
+| `lean-verify.ts` | the checker: compile in Docker, reject `sorry`/`admit`, run with no network so a proof can't fetch its way to a pass |
+| `lean.Dockerfile` | the Lean 4 toolchain image |
+
+## Honest scope
+
+The **checker** is real and runs on your machine today (it needs Docker). The **prover** half needs a
+model key for the live loop. The theorems are small and use only core Lean (no `mathlib`) so they
+compile in seconds — the point is the loop and the un-foolable check, not the difficulty of the math.