From 9bd97216b5a5f1b45d2393b00e8f3f757ec12ae1 Mon Sep 17 00:00:00 2001
From: "Peter B. Johnson" <peterbjohnson@gmail.com>
Date: Wed, 23 Sep 2026 03:56:51 +0100
Subject: [PATCH] implement: Run the web page through the two-route conversion
 (t41)

---
 README.md                    |  23 +-
 in2lambda_agent/routes.py    |  44 +++-
 in2lambda_agent/ui/page.html | 156 +++++-------
 in2lambda_agent/ui/server.py | 232 ++++++------------
 tests/test_routes.py         |  19 ++
 tests/test_ui.py             | 456 ++++++++++++++++-------------------
 6 files changed, 413 insertions(+), 517 deletions(-)

diff --git a/README.md b/README.md
index 43f0f3a..bd5381b 100644
--- a/README.md
+++ b/README.md
@@ -294,16 +294,19 @@ This serves one page on `http://127.0.0.1:8765/` and opens it; `--no-open` print
 address and opens nothing. The page lists `--corpus` — `./ExampleContents` by default,
 or the current directory where there is no such folder — one directory at a time:
 click a folder to list it, and a document to pick it. A source elsewhere goes into the
-box by hand. Set the options the `run` command takes, and press Go. Each stage line
-arrives on the page as the stage finishes, with the tokens
-and seconds of each model call. A run in review mode stops with its questions, each
-beside its rendered PDF, and approve, reject and edit answer them without leaving the
-page; the stages of a rejection's fixing rounds arrive the same way. When the run
-ends, the page links to the zip, the rendered PDFs, the draft, the spec and the run
-record.
-
-It is a harness for trying the agent by hand. It listens on this machine only, has no
-authentication, and runs one run at a time.
+box by hand.
+
+The page runs the `convert` command: the two routes, the reconciliation and the build.
+Name the solutions document, or leave that box empty for the document beside the source;
+name a Lua filter for route B, or tick Write filter for one model call that writes
+`filter.lua` into the out directory; then press Go. Each stage line — `ocr`, `route A`,
+`route B`, `fields`, `build` — arrives on the page as the stage finishes. When the run
+ends, the page shows each flagged field with the reason it is flagged and each route's
+reading of it, the counts of the reconciliation, the tokens, and links to the zip and to
+the filter where the run wrote one.
+
+The page is a harness for trying the agent by hand. It listens on this machine only, has
+no authentication, and runs one conversion at a time.
 
 ### Checking the OCR against the page
 
diff --git a/in2lambda_agent/routes.py b/in2lambda_agent/routes.py
index 730ccee..a968ff7 100644
--- a/in2lambda_agent/routes.py
+++ b/in2lambda_agent/routes.py
@@ -26,7 +26,7 @@
 import subprocess
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Callable, Optional
 
 from in2lambda.api.part import Part
 from in2lambda.api.question import Question
@@ -440,6 +440,22 @@ def markdown_of(document: Path, cache_dir: Path, settings: Settings) -> tuple[st
     return out.stdout.decode("utf-8"), document.parent
 
 
+def _read_as(document: Path, cache_dir: Path) -> str:
+    """How one document's markdown is got, for the ocr stage line.
+
+    Asked before the conversion, because a PDF the cache held no entry for is cached by
+    the time the line is written.
+    """
+    suffix = Path(document).suffix.lower()
+    if suffix in (".md", ".markdown"):
+        return "read"
+    if suffix != ".pdf":
+        return "pandoc"
+    from in2lambda_agent.ocr import cached
+
+    return "cached" if cached(document, cache_dir) is not None else "mathpix"
+
+
 def convert(
     document: Path,
     solutions: Optional[Path] = None,
@@ -450,6 +466,7 @@ def convert(
     settings: Optional[Settings] = None,
     lua: Optional[Path] = None,
     name: str = "set",
+    on_stage: Optional[Callable[[str, str], None]] = None,
 ) -> Converted:
     """Route A, route B where a filter is given, reconcile, verify, write.
 
@@ -457,16 +474,31 @@ def convert(
     merged before the comparison. Where a filter run fails, the route A reply is the
     result and `route_b_error` holds pandoc's message, so that one sheet of a folder does
     not stop the other eight.
+
+    `on_stage`, where it is given, is called with a name and a message as each step
+    finishes - `ocr`, `route A`, `route B`, `fields`, `build` - so that a caller watching
+    a run shows each line as the step ends rather than the report at the end of it.
     """
     settings = settings or load_settings()
     backend = backend or choose_backend(settings)
+
+    def said(stage: str, message: str) -> None:
+        if on_stage is not None:
+            on_stage(stage, message)
+
+    read = [f"{Path(d).name}: {_read_as(d, cache_dir)}" for d in (document, solutions) if d is not None]
     markdown, images = markdown_of(document, cache_dir, settings)
     solutions_md = markdown_of(solutions, cache_dir, settings)[0] if solutions else None
+    said("ocr", "; ".join(read))
     source = markdown + ("\n" + solutions_md if solutions_md else "")
     reply, usage = direct(markdown, solutions_md, backend)
+    tokens = usage.usage.input_tokens + usage.usage.output_tokens
+    said("route A", f"{tokens} tokens")
     counts, error = (0, 0, 0, 0), None
     flags = [Flag(k, fields(reply)[k], "", "not a quote of the source") for k in not_verbatim(reply, source)]
-    if lua is not None:
+    if lua is None:
+        said("route B", "did not run: no filter")
+    else:
         try:
             other = run_filter(lua, document)
             if solutions is not None:
@@ -474,6 +506,7 @@ def convert(
         except (subprocess.CalledProcessError, json.JSONDecodeError) as problem:
             stderr = getattr(problem, "stderr", None)
             error = (stderr.decode("utf-8", "replace") if stderr else str(problem)).strip()
+            said("route B", f"failed: {error}")
         else:
             reconciled = reconcile(reply, other, source, backend)
             reply, flags = reconciled.fields, reconciled.flags
@@ -481,13 +514,16 @@ def convert(
                 reconciled.agreed + reconciled.defaulted + reconciled.adjudicated,
                 reconciled.agreed, reconciled.defaulted, reconciled.adjudicated,
             )
+            said("route B", "ran")
     for k in stray_minus(reply):
         if not any(f.field == k for f in flags):
             flags.append(Flag(k, fields(reply)[k], "", STRAY_MINUS))
+    said("fields", _counted([*counts, len(flags)]))
     built = to_set(reply, name=name, directory=images)
+    zip_path = build(built, out_dir)
+    said("build", str(zip_path))
     return Converted(
-        set=built, zip_path=build(built, out_dir), flags=flags, reply=reply,
-        tokens=usage.usage.input_tokens + usage.usage.output_tokens,
+        set=built, zip_path=zip_path, flags=flags, reply=reply, tokens=tokens,
         fields=counts[0], agreed=counts[1], defaulted=counts[2], adjudicated=counts[3],
         route_b_error=error,
     )
diff --git a/in2lambda_agent/ui/page.html b/in2lambda_agent/ui/page.html
index df77781..0aa4f87 100644
--- a/in2lambda_agent/ui/page.html
+++ b/in2lambda_agent/ui/page.html
@@ -1,11 +1,11 @@
 <!DOCTYPE html>
 <!--
-  The whole page: no build step, no framework. It posts /api/run, reads the
-  stage lines off /api/events, and answers a waiting review through
-  /api/review. The server sends each event as JSON on a server-sent event
-  stream, and ends the stream with the event that leaves the run idle. The
-  page counts the events it has read and opens the next stream with ?since=,
-  so the stages of an answered review follow the review itself.
+  The whole page: no build step, no framework. It posts /api/run and reads the
+  stage lines of the conversion off /api/events. The server sends each event as
+  JSON on a server-sent event stream, and ends the stream with the event that
+  leaves the run idle: the `done` that carries the flags a person reads, or an
+  `error`. The page counts the events it has read and opens the next stream
+  with ?since=.
 -->
 <html lang="en">
   <head>
@@ -30,7 +30,6 @@
         padding: 0.8rem;
         white-space: pre-wrap;
       }
-      iframe { border: 1px solid #ccc; height: 22rem; width: 100%; }
       #entries {
         border: 1px solid #ddd;
         list-style: none;
@@ -42,7 +41,8 @@
       }
       #entries a { color: #06c; cursor: pointer; }
       #where { margin: 0.4rem 0 0.2rem 9rem; }
-      .question { border-top: 1px solid #ddd; margin-top: 1rem; padding-top: 1rem; }
+      .flag { border-top: 1px solid #ddd; margin-top: 1rem; padding-top: 1rem; }
+      .flag h3 { font-size: 1rem; margin: 0; }
       .error { color: #b00; }
       .note { color: #666; }
     </style>
@@ -58,32 +58,22 @@ <h1>in2lambda agent</h1>
     </label>
     <p class="note" id="where"></p>
     <ul id="entries"></ul>
-    <label><span>Spec file</span>
-      <input type="text" id="spec" placeholder="the one beside the source" />
+    <label><span>Solutions file</span>
+      <input type="text" id="solutions" placeholder="the one beside the source" />
     </label>
-    <label><span>Review</span>
-      <select id="review">
-        <option value="none">none</option>
-        <option value="sample">sample</option>
-        <option value="per-question">per-question</option>
-      </select>
+    <label><span>Filter file</span>
+      <input type="text" id="filter" placeholder="route B runs only with one" />
     </label>
-    <label><span>Sample count</span>
-      <input type="number" id="sample" value="3" min="1" />
-    </label>
-    <label><span>Rounds</span>
-      <input type="number" id="rounds" value="3" min="0" />
+    <label><span>Write filter</span>
+      <input type="checkbox" id="write-filter" />
     </label>
     <label><span>Out directory</span>
       <input type="text" id="out" value="out" />
     </label>
-    <label><span>Fresh OCR</span>
-      <input type="checkbox" id="fresh" />
-    </label>
     <p><button id="go">Go</button> <span id="said" class="error"></span></p>
 
     <pre id="log"></pre>
-    <div id="review-panel"></div>
+    <div id="flags"></div>
     <div id="links"></div>
 
     <script>
@@ -134,12 +124,10 @@ <h1>in2lambda agent</h1>
       async function go() {
         const body = {
           source: byId("source").value,
-          spec: byId("spec").value,
-          review: byId("review").value,
-          sample: Number(byId("sample").value),
-          rounds: Number(byId("rounds").value),
+          solutions: byId("solutions").value,
+          filter: byId("filter").value,
+          write_filter: byId("write-filter").checked,
           out: byId("out").value,
-          fresh_ocr: byId("fresh").checked,
         };
         const answer = await fetch("/api/run", {
           method: "POST",
@@ -152,7 +140,7 @@ <h1>in2lambda agent</h1>
         }
         byId("said").textContent = "";
         byId("log").textContent = "";
-        byId("review-panel").innerHTML = "";
+        byId("flags").innerHTML = "";
         byId("links").innerHTML = "";
         read = 0;
         watch();
@@ -166,95 +154,61 @@ <h1>in2lambda agent</h1>
 
       function show(event) {
         read += 1;
-        // The server ends the stream after each of these three, so the page
+        // The server ends the stream after each of these two, so the page
         // closes its own end rather than letting EventSource reconnect.
-        if (["done", "error", "review"].includes(event.type)) stream.close();
+        if (["done", "error"].includes(event.type)) stream.close();
         if (event.type === "stage") {
           line(event.name.padEnd(9) + " " + event.message);
-        } else if (event.type === "review") {
-          reviewing(event);
         } else if (event.type === "done") {
-          linksTo(event.links, event.reason);
+          flagged(event);
+          linksTo(event.links);
         } else if (event.type === "error") {
           line("error     " + event.message);
           byId("said").textContent = event.message.split("\n")[0];
         }
       }
 
-      function reviewing(event) {
-        const panel = byId("review-panel");
-        panel.innerHTML = "<h2>Review (" + event.mode + ")</h2>";
-        if (event.errors.length) {
-          const faulted = document.createElement("p");
-          faulted.className = "error";
-          faulted.textContent =
-            "The checks fault the draft, so there is no zip yet. A reject or " +
-            "an edit below answers them: " + event.errors.join("; ");
-          panel.append(faulted);
+      // The flags are what a person reads after the build: the field, why it
+      // is flagged, and each route's reading of it where the two disagree.
+      function flagged(event) {
+        const where = byId("flags");
+        where.innerHTML = "<h2>Flags</h2>";
+        if (!event.flags.length) {
+          where.innerHTML += "<p class='note'>No field was flagged.</p>";
         }
-        for (const question of event.questions) {
-          panel.append(questionForm(question));
+        for (const one of event.flags) {
+          const block = document.createElement("div");
+          block.className = "flag";
+          block.innerHTML = "<h3></h3><p class='note'></p>";
+          block.querySelector("h3").textContent = one.field;
+          block.querySelector("p").textContent = one.reason;
+          if (one.a && one.b) {
+            block.append(reading("A: ", one.a), reading("B: ", one.b));
+          } else {
+            block.append(reading("", one.a || one.b));
+          }
+          where.append(block);
         }
-      }
-
-      function questionForm(question) {
-        const where = document.createElement("div");
-        where.className = "question";
-        const lines = question.lines.map((one) => one.join("-")).join(", ");
-        where.innerHTML =
-          "<h3>" + question.key + " — " + question.status +
-          " <span class='note'>lines " + (lines || "none") + "</span></h3>" +
-          (question.pdf
-            ? "<iframe src='" + question.pdf + "'></iframe>"
-            : "<p class='note'>No PDF was rendered.</p>") +
-          "<p><button data-do='approve'>Approve</button></p>" +
-          "<p><input type='text' data-field='note' placeholder='what is wrong' " +
-          "size='60' /> <button data-do='reject'>Reject</button></p>" +
-          "<p><input type='text' data-field='field' placeholder='" +
-          question.key + ".text' /> " +
-          "<input type='text' data-field='old' placeholder='old wording' /> " +
-          "<input type='text' data-field='new' placeholder='new wording' /> " +
-          "<button data-do='edit'>Edit</button></p>";
-        const read = (name) =>
-          where.querySelector("[data-field='" + name + "']").value;
-        for (const button of where.querySelectorAll("button")) {
-          button.onclick = () =>
-            answer({
-              verdict: button.dataset.do,
-              key: question.key,
-              note: read("note"),
-              field: read("field"),
-              old: read("old"),
-              new: read("new"),
-            });
+        const counts = document.createElement("p");
+        counts.textContent = event.fields + ", " + event.tokens + " tokens";
+        where.append(counts);
+        if (event.route_b_error) {
+          const failed = document.createElement("p");
+          failed.className = "error";
+          failed.textContent = "route B failed: " + event.route_b_error;
+          where.append(failed);
         }
-        return where;
       }
 
-      async function answer(body) {
-        const sent = await fetch("/api/review", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(body),
-        });
-        if (!sent.ok) {
-          byId("said").textContent = (await sent.json()).error;
-          return;
-        }
-        byId("said").textContent = "";
-        byId("review-panel").innerHTML = "";
-        watch();
+      function reading(label, text) {
+        const block = document.createElement("pre");
+        block.textContent = label + text;
+        return block;
       }
 
-      function linksTo(links, reason) {
+      function linksTo(links) {
         const where = byId("links");
         where.innerHTML = "<h2>Written</h2>";
-        if (reason) {
-          const said = document.createElement("p");
-          said.className = "note";
-          said.textContent = reason;
-          where.append(said);
-        }
         if (!links.length) {
           where.innerHTML += "<p class='note'>The run wrote no files.</p>";
           return;
diff --git a/in2lambda_agent/ui/server.py b/in2lambda_agent/ui/server.py
index 8f150b3..a4a42f4 100644
--- a/in2lambda_agent/ui/server.py
+++ b/in2lambda_agent/ui/server.py
@@ -1,19 +1,18 @@
 """The server behind the page: one run at a time, on 127.0.0.1.
 
 A run happens in a thread of its own, and reports each stage through
-`pipeline.run`'s `on_stage` callback. The callback appends an event to the
+`routes.convert`'s `on_stage` callback. The callback appends an event to the
 run's list; `/api/events` reads that list and sends each event to the browser
 over server-sent events. The list is kept from the start of the run, so a page
 that connects late still receives every line.
 
-A stream ends with the event that leaves the run idle: `done`, `error`, or the
-`review` the run stopped for. The page counts the events it has read and opens
-the next stream with `?since=`, so the stages of a resume follow the review
-they answer with no event read twice.
+A stream ends with the event that leaves the run idle: `done` or `error`. The
+page counts the events it has read and opens the next stream with `?since=`, so
+no event is read twice.
 
-The page may fetch a file only when the server has linked to it — the zip, a
-rendered PDF, the draft, the spec, the run record. `Runner.served` holds those
-paths, and `/file` refuses anything else.
+The page may fetch a file only when the server has linked to it — the zip, and
+the filter where the run wrote one. `Runner.served` holds those paths, and
+`/file` refuses anything else.
 
 Every endpoint answers a failure with the exception's message, under the same
 `error` key as a refusal. See `_answering`.
@@ -21,6 +20,7 @@
 
 import functools
 import json
+import subprocess
 import threading
 import traceback
 import webbrowser
@@ -35,13 +35,10 @@
 from starlette.responses import FileResponse, JSONResponse, Response, StreamingResponse
 from starlette.routing import Route
 
-from in2lambda_agent import corpus, pipeline, spec
+from in2lambda_agent import corpus, pair, pipeline, routes
 from in2lambda_agent.mathpix import MathpixError
-from in2lambda_agent.model import ModelError, ModelUnavailable
-from in2lambda_agent.package import CommandRefused, SpecRejected
-from in2lambda_agent.review import RECORD, ReviewError
+from in2lambda_agent.model import ModelError, ModelUnavailable, choose_backend
 from in2lambda_agent.settings import Settings, load_settings
-from in2lambda_agent.spec import BadSpec
 
 PAGE = Path(__file__).parent / "page.html"
 
@@ -50,27 +47,19 @@
 
 DEFAULT_PORT = 8765
 
-LAST = ("done", "error", "review")
-"""The events that end a stream: the run has ended, or it is waiting for the
-reviewer. Every other event is followed by another on the same stream."""
+LAST = ("done", "error")
+"""The events that end a stream: the run has ended. Every other event is
+followed by another on the same stream."""
 
 POLL_SECONDS = 0.05
 """How often the event stream looks for events the run thread has added. The
 run thread cannot wake the event loop, and a sleep this short is a stage line
 in the browser as soon as the stage finishes."""
 
-FAILURES = (
-    MathpixError,
-    ModelUnavailable,
-    ModelError,
-    BadSpec,
-    SpecRejected,
-    ReviewError,
-    CommandRefused,
-)
-"""The failures the command prints as one line, which the page shows the same
-way. Any other exception reaches the page as a traceback: the page is a
-development harness, and the developer reads the traceback."""
+FAILURES = (MathpixError, ModelUnavailable, ModelError)
+"""The failures the `convert` command prints as one line, which the page shows
+the same way. Any other exception reaches the page as a traceback: the page is
+a development harness, and the developer reads the traceback."""
 
 
 class RunBusy(RuntimeError):
@@ -111,11 +100,9 @@ class Options:
 
     source: Path
     out_dir: Path
-    spec: Optional[Path] = None
-    review: str = "none"
-    rounds: int = 3
-    sample: int = 3
-    fresh_ocr: bool = False
+    solutions: Optional[Path] = None
+    filter: Optional[Path] = None
+    write_filter: bool = False
 
 
 class Runner:
@@ -152,25 +139,6 @@ def start(self, options: Options) -> None:
             self.options = options
         self._start(self._run, options)
 
-    def answer(self, verdict: str, **given: Any) -> None:
-        """Answers the review the run stopped for, and continues the run.
-
-        The events of the resume are appended to the run's own, so the page
-        reads the stage lines of a rejection's fixing rounds on the stream it
-        already has open.
-
-        Args:
-            verdict: `approve`, `reject` or `edit`.
-            given: The key, note, field, old, new and by of that verdict.
-
-        Raises:
-            RunBusy: a run is already going.
-        """
-        with self.state:
-            if self.busy:
-                raise RunBusy("a run is already going: wait for it to finish")
-        self._start(self._answer, verdict, given)
-
     def since(self, index: int) -> list[dict[str, Any]]:
         """The events from `index` onwards, which is none while a stage runs.
 
@@ -184,97 +152,80 @@ def since(self, index: int) -> list[dict[str, Any]]:
             return self.events[index:]
 
     def _start(self, target: Any, *arguments: Any) -> None:
-        """Runs one call to the pipeline in a thread of its own."""
+        """Runs one conversion in a thread of its own."""
         self.thread = threading.Thread(target=target, args=arguments, daemon=True)
         self.thread.start()
 
     def _run(self, options: Options) -> None:
-        """The run thread: one call to `pipeline.run`, and then its result."""
+        """The run thread: one call to `routes.convert`, and then its result."""
         try:
-            result = pipeline.run(
+            solutions = options.solutions or pair.solutions_beside(options.source)
+            backend = choose_backend(self.settings)
+            lua = options.filter
+            if options.write_filter:
+                options.out_dir.mkdir(parents=True, exist_ok=True)
+                lua = options.out_dir / "filter.lua"
+                lua.write_text(
+                    routes.write_filter(options.source, solutions, backend)[0],
+                    encoding="utf-8",
+                )
+                self._stage("filter", str(lua))
+            result = routes.convert(
                 options.source,
+                solutions,
                 out_dir=options.out_dir,
-                settings=self.settings,
-                spec=options.spec,
-                review=options.review,
-                rounds=options.rounds,
-                sample=options.sample,
                 cache_dir=self.cache_dir,
-                fresh_ocr=options.fresh_ocr,
-                on_stage=self._stage,
-            )
-        except FAILURES as error:
-            self._emit({"type": "error", "message": str(error)})
-        except Exception:
-            self._emit({"type": "error", "message": traceback.format_exc()})
-        else:
-            self._finished(result)
-
-    def _answer(self, verdict: str, given: dict[str, Any]) -> None:
-        """The resume thread: one verdict, and then the result it left."""
-        try:
-            result = pipeline.resume(
-                self.cache_dir,
-                verdict=verdict,
+                backend=backend,
                 settings=self.settings,
+                lua=lua,
+                name=options.source.stem,
                 on_stage=self._stage,
-                **given,
             )
         except FAILURES as error:
             self._emit({"type": "error", "message": str(error)})
+        except subprocess.CalledProcessError as error:
+            # pandoc read the document, or ran the filter, and refused. Its own
+            # message names the line; the exit status alone names nothing.
+            stderr = (error.stderr or b"").decode("utf-8", "replace").strip()
+            self._emit({"type": "error", "message": stderr or str(error)})
         except Exception:
             self._emit({"type": "error", "message": traceback.format_exc()})
         else:
             self._finished(result)
 
-    def _stage(self, stage: pipeline.StageResult) -> None:
+    def _stage(self, name: str, message: str) -> None:
         """One stage line, on its way to the page."""
-        self._emit({"type": "stage", "name": stage.name, "message": stage.message})
-
-    def _finished(self, result: pipeline.RunResult) -> None:
-        """The last event of a run: the questions to review, or the links."""
-        review = result.review
-        # The record, not `Review.done`, is what says the review is still
-        # waiting: `done` means only that every question has been approved,
-        # and `resume` has paths that leave it so with the review unanswered —
-        # a last approval whose re-validate faults the draft, and an edit made
-        # after every approval. `resume` removes the record only once the zip
-        # is written, so while it is there the reviewer still has something to
-        # answer, and `review.errors` on the event says what.
-        if review is not None and (self.cache_dir / RECORD).exists():
-            self._emit(
-                {
-                    "type": "review",
-                    "mode": review.mode,
-                    "errors": review.errors,
-                    "questions": [
-                        {
-                            "key": question.key,
-                            "status": question.status,
-                            "note": question.note,
-                            "lines": question.lines,
-                            "pdf": self._url(question.pdf),
-                        }
-                        for question in review.questions
-                    ],
-                }
-            )
-            return
+        self._emit({"type": "stage", "name": name, "message": message})
+
+    def _finished(self, result: routes.Converted) -> None:
+        """The last event of a run: the flags a person reads, and the links."""
         self._emit(
-            {"type": "done", "reason": result.reason, "links": self._links(result)}
+            {
+                "type": "done",
+                "flags": [
+                    {"field": one.field, "a": one.a, "b": one.b, "reason": one.reason}
+                    for one in result.flags
+                ],
+                "fields": routes._counted(
+                    [
+                        result.fields,
+                        result.agreed,
+                        result.defaulted,
+                        result.adjudicated,
+                        len(result.flags),
+                    ]
+                ),
+                "route_b_error": result.route_b_error,
+                "tokens": result.tokens,
+                "links": self._links(result),
+            }
         )
 
-    def _links(self, result: pipeline.RunResult) -> list[dict[str, str]]:
+    def _links(self, result: routes.Converted) -> list[dict[str, str]]:
         """What the run wrote, as links the page shows when the run has ended."""
-        found = [("zip", result.zip_path), ("draft", result.draft)]
-        if result.review is not None:
-            found += [
-                (f"{question.key}.pdf", question.pdf)
-                for question in result.review.questions
-            ]
-        if self.options is not None:
-            saved = spec.spec_path(self.options.source, self.options.spec)
-            found += [("spec", saved), ("runs", saved.parent / spec.RECORD_NAME)]
+        found = [("zip", result.zip_path)]
+        if self.options is not None and self.options.write_filter:
+            found.append(("filter.lua", self.options.out_dir / "filter.lua"))
         links = []
         for label, path in found:
             url = self._url(path)
@@ -337,7 +288,7 @@ def build_app(
             nothing is named.
         settings: The environment a run has available, read from the process's
             own where nothing is given.
-        cache_dir: Where the OCR of each PDF, and a waiting review, are kept.
+        cache_dir: Where the OCR of each PDF is kept.
 
     Returns:
         The application `serve` runs, and the tests drive with a test client.
@@ -388,11 +339,9 @@ async def run(request: Request) -> Response:
         options = Options(
             source=source,
             out_dir=Path(body.get("out") or "out"),
-            spec=Path(body["spec"]) if body.get("spec") else None,
-            review=body.get("review") or "none",
-            rounds=int(body.get("rounds", 3)),
-            sample=int(body.get("sample", 3)),
-            fresh_ocr=bool(body.get("fresh_ocr")),
+            solutions=Path(body["solutions"]) if body.get("solutions") else None,
+            filter=Path(body["filter"]) if body.get("filter") else None,
+            write_filter=bool(body.get("write_filter")),
         )
         try:
             runner.start(options)
@@ -400,36 +349,6 @@ async def run(request: Request) -> Response:
             return JSONResponse({"error": str(busy)}, status_code=409)
         return JSONResponse({"started": str(source)})
 
-    @_answering
-    async def review(request: Request) -> Response:
-        body = await request.json()
-        verdict = body.get("verdict")
-        if verdict not in ("approve", "reject", "edit"):
-            return JSONResponse(
-                {"error": f"{verdict} is not approve, reject or edit"}, status_code=400
-            )
-        if verdict == "reject" and not (body.get("note") or "").strip():
-            # The note is the whole of what a fixing round is asked where the
-            # checks are quiet, so an empty one is a paid model call with no
-            # instruction, free to edit a draft that had passed. `review
-            # reject --note` is required for the same reason.
-            return JSONResponse(
-                {
-                    "error": "a rejection needs a note: what is wrong with the "
-                    "question, for the agent to fix"
-                },
-                status_code=400,
-            )
-        given = {
-            name: body.get(name) for name in ("key", "note", "field", "old", "new")
-        }
-        given["by"] = body.get("by") or "reviewer"
-        try:
-            runner.answer(verdict, **given)
-        except RunBusy as busy:
-            return JSONResponse({"error": str(busy)}, status_code=409)
-        return JSONResponse({"answered": verdict})
-
     @_answering
     async def events(request: Request) -> Response:
         index = int(request.query_params.get("since", 0))
@@ -466,7 +385,6 @@ async def file(request: Request) -> Response:
             Route("/", page),
             Route("/api/sources", sources),
             Route("/api/run", run, methods=["POST"]),
-            Route("/api/review", review, methods=["POST"]),
             Route("/api/events", events),
             Route("/file", file),
         ]
diff --git a/tests/test_routes.py b/tests/test_routes.py
index 2fa4a58..175ca80 100644
--- a/tests/test_routes.py
+++ b/tests/test_routes.py
@@ -450,6 +450,25 @@ def test_a_flag_only_one_route_filled_shows_the_one_text(tmp_path):
     ]
 
 
+def test_convert_reports_each_stage_as_it_happens(tmp_path):
+    # The page prints each line as it arrives, so a stage is reported when it
+    # has finished and not with the rest of them at the end.
+    seen = []
+    result = routes.convert(
+        ME2 / "questions.md",
+        solutions=ME2 / "solutions.md",
+        out_dir=tmp_path / "out",
+        backend=FakeBackend(json.dumps(REPLY)),
+        settings=Settings(),
+        on_stage=lambda name, message: seen.append((name, message)),
+    )
+    assert [name for name, _ in seen] == ["ocr", "route A", "route B", "fields", "build"]
+    assert dict(seen)["ocr"] == "questions.md: read; solutions.md: read"
+    assert dict(seen)["route B"] == "did not run: no filter"
+    assert dict(seen)["fields"].endswith("flagged 2")
+    assert dict(seen)["build"] == str(result.zip_path)
+
+
 def test_the_report_says_where_route_b_did_not_run(tmp_path):
     # No filter, so no field was compared and every field is route A's.
     result = routes.Converted(set=None, zip_path=tmp_path / "sheet.zip", flags=[], reply=[])
diff --git a/tests/test_ui.py b/tests/test_ui.py
index 38c7120..4e0dcd6 100644
--- a/tests/test_ui.py
+++ b/tests/test_ui.py
@@ -1,12 +1,14 @@
-"""The local page's endpoints, over a faked pipeline.
+"""The local page's endpoints, over a faked conversion.
 
-No test here calls a model, starts a server on a port, or opens a browser: the
-test client drives the application in this process, and `pipeline.run` and
-`pipeline.resume` are replaced by functions that report the stages a run would
-have reported.
+No test here calls a model, starts a server on a port, or opens a browser,
+except the live one at the end: the test client drives the application in this
+process, and `routes.convert` is replaced by a function that reports the stages
+a run would have reported.
 """
 
 import json
+import os
+import subprocess
 import threading
 from pathlib import Path
 
@@ -17,24 +19,32 @@
 import anyio  # noqa: E402
 from starlette.testclient import TestClient  # noqa: E402
 
-from in2lambda_agent import pipeline  # noqa: E402
+from in2lambda_agent import routes  # noqa: E402
 from in2lambda_agent.model import ModelUnavailable  # noqa: E402
-from in2lambda_agent.review import RECORD, Question, Review  # noqa: E402
-from in2lambda_agent.settings import Settings  # noqa: E402
-from in2lambda_agent.spec import RECORD_NAME, SPEC_NAME  # noqa: E402
+from in2lambda_agent.settings import Settings, load_settings  # noqa: E402
 from in2lambda_agent.ui import server  # noqa: E402
 
 FIXTURES = Path(__file__).parent / "fixtures"
 
+ME2_TARGET = Path(
+    "/Users/peterbjohnson/code/lambdafeedback/in2lambda-agent/ExampleContents/targets/"
+    "ME2_Fluids_introduction"
+)
+
+live = pytest.mark.skipif(
+    not os.environ.get("IN2LAMBDA_LIVE") or not ME2_TARGET.is_dir(),
+    reason="calls Mathpix and a model over the private corpus",
+)
+
 
 @pytest.fixture
 def root(tmp_path):
-    """A corpus of one sheet, one PDF and one tex fragment, with a spec beside."""
+    """A corpus of one sheet, its solutions, a PDF and one tex fragment."""
     folder = tmp_path / "corpus"
     (folder / "figures").mkdir(parents=True)
     (folder / "sheet.md").write_text((FIXTURES / "sheet.md").read_text())
+    (folder / "sheet_solutions.md").write_text((FIXTURES / "sheet-2.md").read_text())
     (folder / "sheet.pdf").write_bytes(b"%PDF-1.4 not really a PDF")
-    (folder / SPEC_NAME).write_text((FIXTURES / "sheet-spec.yaml").read_text())
     # A tex file with no \begin{document}: input to a document, not one itself.
     (folder / "figures" / "ball.tex").write_text(r"\draw (0,0) circle (1);")
     return folder
@@ -61,66 +71,28 @@ def written(tmp_path, name="set.zip", text="a zip"):
     return path
 
 
-def waiting_review(root, tmp_path, status="pending", saved=True, errors=()):
-    """A review of one question with a PDF, as a stopped run leaves one.
-
-    Args:
-        root: The corpus the source and the spec are in.
-        tmp_path: Where the draft, the PDF and the cache are.
-        status: What the reviewer has said about the question so far.
-        saved: Whether the record is on disk, as it is for every review that is
-            still waiting: `resume` unlinks it only once the zip is written.
-        errors: What the checks last found, which is what a review left
-            waiting after its last approval carries.
-
-    Returns:
-        The review the faked call returns.
-    """
-    pdf = written(tmp_path / "out" / "render", "q1.pdf", "a PDF")
-    review = Review(
-        mode="per-question",
-        count=1,
-        source=str(root / "sheet.md"),
-        spec=str(root / SPEC_NAME),
-        out_dir=str(tmp_path / "out"),
-        limit=3,
-        draft=str(tmp_path / "draft.json"),
-        frozen=str(root / "sheet.md"),
-        reused=True,
-        coverage=None,
-        questions=[Question(key="q1", pdf=str(pdf), lines=[[3, 5]], status=status)],
-        errors=list(errors),
-    )
-    record = tmp_path / "cache" / RECORD
-    if saved:
-        review.save(record)
-    elif record.exists():
-        record.unlink()
-    return review
-
-
-def faked(monkeypatch, name, stages=(), **fields):
-    """Replaces one pipeline call with one that reports `stages` and returns.
+def faked(monkeypatch, stages=(), **fields):
+    """Replaces `routes.convert` with one that reports `stages` and returns.
 
     Args:
         monkeypatch: The fixture that puts the real call back afterwards.
-        name: `run` or `resume`.
         stages: The stage lines the call reports through `on_stage`.
-        fields: What the RunResult it returns carries.
+        fields: What the `Converted` it returns carries.
 
     Returns:
-        A list the call appends its keyword arguments to.
+        A list the call appends its arguments to.
     """
     seen = []
 
     def call(*positional, on_stage=None, **given):
         seen.append({"positional": positional, **given})
-        result = pipeline.RunResult(on_stage=on_stage, **fields)
-        for stage, message in stages:
-            result.add_stage(stage, message)
-        return result
+        for name, message in stages:
+            on_stage(name, message)
+        return routes.Converted(
+            **{"set": None, "zip_path": None, "flags": [], "reply": [], **fields}
+        )
 
-    monkeypatch.setattr(pipeline, name, call)
+    monkeypatch.setattr(server.routes, "convert", call)
     return seen
 
 
@@ -202,8 +174,11 @@ def test_the_picker_lists_one_directory_of_the_corpus(client, root):
     assert (answer["root"], answer["path"]) == (str(root), str(root))
     assert answer["up"] is None
     assert [one["name"] for one in answer["folders"]] == ["figures"]
-    # The sheet and the PDF, and not the spec file beside them.
-    assert [one["name"] for one in answer["documents"]] == ["sheet.md", "sheet.pdf"]
+    assert [one["name"] for one in answer["documents"]] == [
+        "sheet.md",
+        "sheet.pdf",
+        "sheet_solutions.md",
+    ]
     assert answer["documents"][0]["path"] == str(root / "sheet.md")
 
 
@@ -239,49 +214,128 @@ def refuse(path):
 
 
 def test_a_field_the_page_did_not_fill_in_is_one_line(client, root):
-    answer = client.post(
-        "/api/run", json={"source": str(root / "sheet.md"), "rounds": None}
-    )
+    answer = client.post("/api/run", json={"source": str(root / "sheet.md"), "out": 3})
 
     assert answer.status_code == 500
     assert answer.json()["error"].startswith("TypeError: ")
 
 
-def test_a_run_streams_its_stages_and_then_its_links(
+def test_a_run_streams_its_stages_and_then_its_flags(
     client, root, tmp_path, monkeypatch
 ):
     zip_path = written(tmp_path / "out", "set.zip")
-    (root / RECORD_NAME).write_text("{}\n")
-    seen = faked(
+    faked(
         monkeypatch,
-        "run",
-        stages=[("ocr", "not needed for sheet.md"), ("build", str(zip_path))],
+        stages=[
+            ("ocr", "sheet.md: read"),
+            ("route A", "1200 tokens"),
+            ("route B", "did not run: no filter"),
+            ("fields", "10 fields, agreed 9, defaulted 0, adjudicated 0, flagged 1"),
+            ("build", str(zip_path)),
+        ],
         zip_path=zip_path,
-        draft=tmp_path / "draft.json",
-        reason="",
+        flags=[routes.Flag("q2.p2.content", "Find the drag.", "Find the drag, in N.", "two readings")],
+        fields=10,
+        agreed=9,
+        tokens=1200,
     )
-    written(tmp_path, "draft.json", "{}")
 
     started = client.post(
+        "/api/run",
+        json={"source": str(root / "sheet.md"), "out": str(tmp_path / "out")},
+    )
+    found = events(client)
+
+    assert started.status_code == 200
+    assert [one["name"] for one in found if one["type"] == "stage"] == [
+        "ocr",
+        "route A",
+        "route B",
+        "fields",
+        "build",
+    ]
+    done = found[-1]
+    assert done["type"] == "done"
+    assert done["flags"] == [
+        {
+            "field": "q2.p2.content",
+            "a": "Find the drag.",
+            "b": "Find the drag, in N.",
+            "reason": "two readings",
+        }
+    ]
+    assert done["fields"] == "10 fields, agreed 9, defaulted 0, adjudicated 0, flagged 1"
+    assert (done["tokens"], done["route_b_error"]) == (1200, None)
+    links = {one["label"]: one["url"] for one in done["links"]}
+    assert set(links) == {"zip"}
+    assert client.get(links["zip"]).text == "a zip"
+
+
+def test_the_solutions_beside_the_source_are_converted_with_it(
+    client, root, monkeypatch
+):
+    seen = faked(monkeypatch)
+
+    client.post("/api/run", json={"source": str(root / "sheet.md")})
+    events(client)
+
+    assert seen[0]["positional"] == (
+        root / "sheet.md",
+        root / "sheet_solutions.md",
+    )
+
+
+def test_a_named_solutions_file_is_taken_over_the_one_beside(
+    client, root, tmp_path, monkeypatch
+):
+    named = written(tmp_path, "elsewhere.md", "# Solutions\n")
+    seen = faked(monkeypatch)
+
+    client.post(
+        "/api/run",
+        json={"source": str(root / "sheet.md"), "solutions": str(named)},
+    )
+    events(client)
+
+    assert seen[0]["positional"] == (root / "sheet.md", named)
+
+
+def test_a_filter_file_reaches_the_conversion(client, root, tmp_path, monkeypatch):
+    lua = written(tmp_path, "set.lua", "function Pandoc(doc) end\n")
+    seen = faked(monkeypatch)
+
+    client.post(
+        "/api/run", json={"source": str(root / "sheet.md"), "filter": str(lua)}
+    )
+    events(client)
+
+    assert seen[0]["lua"] == lua
+
+
+def test_the_page_writes_a_filter_and_links_it(client, root, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        server.routes,
+        "write_filter",
+        lambda document, solutions, backend: ("function Pandoc(doc) end\n", None),
+    )
+    seen = faked(monkeypatch, zip_path=written(tmp_path / "out", "set.zip"))
+
+    client.post(
         "/api/run",
         json={
             "source": str(root / "sheet.md"),
             "out": str(tmp_path / "out"),
-            "review": "none",
-            "rounds": 2,
-            "sample": 1,
-            "fresh_ocr": True,
+            "write_filter": True,
         },
     )
     found = events(client)
-
-    assert started.status_code == 200
-    assert seen[0]["positional"] == (root / "sheet.md",)
-    assert (seen[0]["rounds"], seen[0]["sample"], seen[0]["fresh_ocr"]) == (2, 1, True)
-    assert [one["name"] for one in found if one["type"] == "stage"] == ["ocr", "build"]
     links = {one["label"]: one["url"] for one in found[-1]["links"]}
-    assert set(links) == {"zip", "draft", "spec", "runs"}
-    assert client.get(links["zip"]).text == "a zip"
+
+    lua = tmp_path / "out" / "filter.lua"
+    assert lua.read_text() == "function Pandoc(doc) end\n"
+    assert seen[0]["lua"] == lua
+    assert [one["name"] for one in found if one["type"] == "stage"] == ["filter"]
+    assert client.get(links["filter.lua"]).text == "function Pandoc(doc) end\n"
 
 
 def test_a_stage_reaches_the_page_before_the_run_ends(client, app, root, monkeypatch):
@@ -289,14 +343,13 @@ def test_a_stage_reaches_the_page_before_the_run_ends(client, app, root, monkeyp
     ended = threading.Event()
 
     def call(*positional, on_stage=None, **given):
-        result = pipeline.RunResult(on_stage=on_stage)
-        result.add_stage("ocr", "not needed for sheet.md")
+        on_stage("ocr", "sheet.md: read")
         held.wait(timeout=10)
-        result.add_stage("build", "set.zip")
+        on_stage("build", "set.zip")
         ended.set()
-        return result
+        return routes.Converted(set=None, zip_path=None, flags=[], reply=[])
 
-    monkeypatch.setattr(pipeline, "run", call)
+    monkeypatch.setattr(server.routes, "convert", call)
     client.post("/api/run", json={"source": str(root / "sheet.md")})
 
     first = first_event(app)
@@ -305,11 +358,7 @@ def call(*positional, on_stage=None, **given):
     still_going = not ended.is_set()
     held.set()
 
-    assert first == {
-        "type": "stage",
-        "name": "ocr",
-        "message": "not needed for sheet.md",
-    }
+    assert first == {"type": "stage", "name": "ocr", "message": "sheet.md: read"}
     assert still_going
 
 
@@ -317,7 +366,7 @@ def test_a_link_escapes_the_path_it_carries(client, root, tmp_path, monkeypatch)
     # A corpus folder can be named anything, and `#`, `&` and `+` all mean
     # something else in a URL.
     zip_path = written(tmp_path / "Problem Sheet #3 & 4+", "set.zip")
-    faked(monkeypatch, "run", zip_path=zip_path)
+    faked(monkeypatch, zip_path=zip_path)
 
     client.post("/api/run", json={"source": str(root / "sheet.md")})
     found = events(client)
@@ -332,9 +381,9 @@ def test_a_second_run_while_one_is_going_is_refused(client, root, monkeypatch):
 
     def call(*positional, on_stage=None, **given):
         held.wait(timeout=10)
-        return pipeline.RunResult()
+        return routes.Converted(set=None, zip_path=None, flags=[], reply=[])
 
-    monkeypatch.setattr(pipeline, "run", call)
+    monkeypatch.setattr(server.routes, "convert", call)
     body = {"source": str(root / "sheet.md")}
 
     first = client.post("/api/run", json=body)
@@ -359,7 +408,7 @@ def test_a_failure_the_command_prints_reaches_the_page_as_one_line(
     def call(*positional, on_stage=None, **given):
         raise ModelUnavailable("set ANTHROPIC_API_KEY")
 
-    monkeypatch.setattr(pipeline, "run", call)
+    monkeypatch.setattr(server.routes, "convert", call)
 
     client.post("/api/run", json={"source": str(root / "sheet.md")})
     found = events(client)
@@ -367,158 +416,24 @@ def call(*positional, on_stage=None, **given):
     assert found[-1] == {"type": "error", "message": "set ANTHROPIC_API_KEY"}
 
 
-def test_a_run_that_stops_for_review_sends_its_questions_and_their_pdfs(
-    client, root, tmp_path, monkeypatch
-):
-    faked(
-        monkeypatch,
-        "run",
-        stages=[("review", "mode per-question, 1 of 1 questions waiting")],
-        review=waiting_review(root, tmp_path),
-    )
-
-    client.post(
-        "/api/run",
-        json={"source": str(root / "sheet.md"), "review": "per-question"},
-    )
-    found = events(client)
-    question = found[-1]["questions"][0]
-
-    assert found[-1]["mode"] == "per-question"
-    assert (question["key"], question["status"]) == ("q1", "pending")
-    assert question["lines"] == [[3, 5]]
-    assert client.get(question["pdf"]).status_code == 200
-
-
-def test_a_rejection_is_answered_and_its_rounds_stream_on(
-    client, root, tmp_path, monkeypatch
-):
-    faked(monkeypatch, "run", review=waiting_review(root, tmp_path))
-    client.post(
-        "/api/run",
-        json={"source": str(root / "sheet.md"), "review": "per-question"},
-    )
-    stopped = events(client)
-    zip_path = written(tmp_path / "out", "set.zip")
-    seen = faked(
-        monkeypatch,
-        "resume",
-        stages=[("fix", "round 1: field replace, 900 tokens, 2.0s")],
-        # The round answered the note, the last approval built the zip, and
-        # `resume` removed the record: the run is over.
-        review=waiting_review(root, tmp_path, status="approved", saved=False),
-        zip_path=zip_path,
-    )
-
-    answered = client.post(
-        "/api/review",
-        json={"verdict": "reject", "key": "q1", "note": "part (b) is the solution"},
-    )
-    # The page reads on from the review it answered, which is where the stream
-    # that carried the review ended.
-    found = events(client, since=len(stopped))
-
-    assert answered.status_code == 200
-    assert [one["type"] for one in stopped] == ["review"]
-    assert (seen[0]["verdict"], seen[0]["key"]) == ("reject", "q1")
-    assert seen[0]["note"] == "part (b) is the solution"
-    assert [one["name"] for one in found if one["type"] == "stage"] == ["fix"]
-    assert "zip" in {one["label"] for one in found[-1]["links"]}
-
-
-def test_an_edit_carries_the_field_and_the_reviewer(
-    client, root, tmp_path, monkeypatch
-):
-    seen = faked(monkeypatch, "resume", review=waiting_review(root, tmp_path))
-
-    answered = client.post(
-        "/api/review",
-        json={
-            "verdict": "edit",
-            "field": "q1.text",
-            "old": r"\mathrm{m/s$",
-            "new": r"\mathrm{m/s}$",
-            "by": "peter",
-        },
-    )
-    events(client)
-
-    assert answered.status_code == 200
-    assert seen[0]["field"] == "q1.text"
-    assert (seen[0]["old"], seen[0]["new"]) == (r"\mathrm{m/s$", r"\mathrm{m/s}$")
-    assert seen[0]["by"] == "peter"
-
-
-def test_a_verdict_that_is_not_one_of_the_three_is_refused(client):
-    answer = client.post("/api/review", json={"verdict": "maybe", "key": "q1"})
-
-    assert answer.status_code == 400
-    assert "approve, reject or edit" in answer.json()["error"]
-
-
-def test_a_rejection_with_no_note_is_refused(client, root, tmp_path, monkeypatch):
-    seen = faked(monkeypatch, "resume", review=waiting_review(root, tmp_path))
-
-    empty = client.post(
-        "/api/review", json={"verdict": "reject", "key": "q1", "note": ""}
-    )
-    missing = client.post("/api/review", json={"verdict": "reject", "key": "q1"})
-
-    assert (empty.status_code, missing.status_code) == (400, 400)
-    assert "needs a note" in empty.json()["error"]
-    assert "needs a note" in missing.json()["error"]
-    # An uninstructed round is a paid model call, so nothing reached the
-    # pipeline at all.
-    assert seen == []
-
-
-def test_the_last_approval_the_checks_fault_leaves_the_review_waiting(
-    client, root, tmp_path, monkeypatch
+def test_a_document_pandoc_refuses_reaches_the_page_as_pandocs_own_message(
+    client, root, monkeypatch
 ):
-    # Every question approved, but the re-validate faulted the draft the
-    # reviewer's own edits had changed, so `resume` saved the record again and
-    # built no zip.
-    faked(
-        monkeypatch,
-        "resume",
-        stages=[("validate", "q1.text: KaTeX rejects \\mathrm{m/s")],
-        review=waiting_review(
-            root,
-            tmp_path,
-            status="approved",
-            errors=["q1.text: KaTeX rejects \\mathrm{m/s"],
-        ),
-        zip_path=None,
-    )
-
-    client.post("/api/review", json={"verdict": "approve", "key": "q1"})
-    found = events(client)
-
-    assert found[-1]["type"] == "review"
-    assert found[-1]["errors"] == ["q1.text: KaTeX rejects \\mathrm{m/s"]
-    assert found[-1]["questions"][0]["status"] == "approved"
-
+    # The exit status alone names nothing; pandoc's message names the line.
+    def call(*positional, on_stage=None, **given):
+        raise subprocess.CalledProcessError(
+            43, ["pandoc"], stderr=b"Error at (line 4, column 1)\n"
+        )
 
-def test_an_edit_after_every_approval_leaves_the_review_waiting(
-    client, root, tmp_path, monkeypatch
-):
-    faked(
-        monkeypatch,
-        "resume",
-        review=waiting_review(
-            root, tmp_path, status="approved", errors=["q1.text: unbalanced $"]
-        ),
-        zip_path=None,
-    )
+    monkeypatch.setattr(server.routes, "convert", call)
 
-    client.post(
-        "/api/review",
-        json={"verdict": "edit", "field": "q1.text", "old": "a", "new": "b"},
-    )
+    client.post("/api/run", json={"source": str(root / "sheet.md")})
     found = events(client)
 
-    assert found[-1]["type"] == "review"
-    assert found[-1]["errors"] == ["q1.text: unbalanced $"]
+    assert found[-1] == {
+        "type": "error",
+        "message": "Error at (line 4, column 1)",
+    }
 
 
 def test_a_file_the_run_did_not_write_is_not_served(client, root):
@@ -532,7 +447,7 @@ def test_a_link_to_a_file_that_has_gone_is_not_served(
     client, root, tmp_path, monkeypatch
 ):
     zip_path = written(tmp_path / "out", "set.zip")
-    faked(monkeypatch, "run", zip_path=zip_path)
+    faked(monkeypatch, zip_path=zip_path)
     client.post("/api/run", json={"source": str(root / "sheet.md")})
     links = {one["label"]: one["url"] for one in events(client)[-1]["links"]}
     zip_path.unlink()
@@ -541,3 +456,54 @@ def test_a_link_to_a_file_that_has_gone_is_not_served(
 
     assert answer.status_code == 404
     assert "is not a file this run wrote" in answer.json()["error"]
+
+
+@live
+def test_the_me2_pair_runs_from_the_page(tmp_path):
+    # The ticket's run: the two PDFs posted from the page, the stages as they
+    # happen, the flags a person reads and the zip.
+    (pdf,) = [p for p in ME2_TARGET.glob("*.pdf") if "solutions" not in p.name]
+    (solutions,) = ME2_TARGET.glob("*solutions.pdf")
+    app = server.build_app(
+        ME2_TARGET, settings=load_settings(), cache_dir=tmp_path / "cache"
+    )
+
+    with TestClient(app) as client:
+        started = client.post(
+            "/api/run",
+            json={
+                "source": str(pdf),
+                "solutions": str(solutions),
+                "out": str(tmp_path / "out"),
+            },
+        )
+        found = events(client)
+        print()
+        for one in found:
+            if one["type"] == "stage":
+                print(f"{one['name']:<9} {one['message']}")
+            elif one["type"] == "done":
+                for flag in one["flags"]:
+                    print(f"flag      {flag['field']}: {flag['reason']}")
+                print(f"links     {[link['url'] for link in one['links']]}")
+            else:
+                print(f"error     {one['message']}")
+
+        assert started.status_code == 200
+        assert [one["name"] for one in found if one["type"] == "stage"] == [
+            "ocr",
+            "route A",
+            "route B",
+            "fields",
+            "build",
+        ]
+        done = found[-1]
+        # The printed solutions PDF holds separator lines that Mathpix reads as
+        # minus signs, so the worked solutions of Friction on a plate and Towing
+        # a submarine are flagged.
+        assert [(one["field"], one["reason"]) for one in done["flags"]] == [
+            ("q2.p1.worked_solution", routes.STRAY_MINUS),
+            ("q3.p1.worked_solution", routes.STRAY_MINUS),
+        ]
+        links = {one["label"]: one["url"] for one in done["links"]}
+        assert client.get(links["zip"]).status_code == 200