diff --git a/.github/workflows/validate.yml b/.github/workflows/validate.yml
index 1d58ab1e..b30169ae 100644
--- a/.github/workflows/validate.yml
+++ b/.github/workflows/validate.yml
@@ -345,3 +345,40 @@ jobs:
           [ "$FAILURES" = "0" ] || { echo "::error::failures $FAILURES, clause (d) requires zero"; rc=1; }
           [ "$ERRORS" = "0" ] || { echo "::error::errors $ERRORS, clause (d) requires zero"; rc=1; }
           exit $rc
+
+  # ---------------------------------------------------------------------------
+  # AT-R1, THE HTTP HALF — plan 034 T095 (FR-011's HTTP half; openxFactory
+  # `specs/034-opendox-standalone-operation/spec.md` § "AT-R1"). Release 1's
+  # acceptance: on a clean machine with only openDox installed, a plain git
+  # repository opens, and the wheel, the radar lens and the chat pane are
+  # served, with chat's "no model configured" state.
+  #
+  # ITS OWN JOB, AND WITH NO DATABASE SERVICE, because the harness ASSERTS a
+  # clean machine: nothing answers on PostgreSQL's port or socket, and no DSN
+  # is set. The `validate` job's PostgreSQL service (T036) would break that
+  # precondition, so the two cannot share a job.
+  #
+  # NOT A PYTEST RUN. `acceptance/at_r1_http.py` sits outside `tests/` and
+  # `tests_runtime/`, so `testpaths` never collects it and #1144's F9.1 is
+  # unchanged. It installs `opendox[local]` into a fresh venv of its own,
+  # from this checkout and through the dependency lock, runs the documented
+  # `opendox generate-and-open --local …` over two plain repositories, checks
+  # what the server answers, stops it, and asserts that no bundled PostgreSQL
+  # process is left. It exits non-zero on the first failed assertion, naming
+  # it. So this job installs nothing itself, and the one `pip install` step
+  # in this file stays the `validate` job's.
+  #
+  # NOT A REQUIRED CHECK. Making it one is a ruleset change for the
+  # repository's owner (`docs/branch-protection.md`); this file cannot.
+  acceptance:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: AT-R1, the HTTP half
+        run: python3 acceptance/at_r1_http.py
diff --git a/acceptance/at_r1_http.py b/acceptance/at_r1_http.py
new file mode 100644
index 00000000..684fb5d4
--- /dev/null
+++ b/acceptance/at_r1_http.py
@@ -0,0 +1,3158 @@
+#!/usr/bin/env python3
+"""AT-R1, the HTTP half: release 1's acceptance, run in CI (plan 034 T095).
+
+The brief AT-R1 makes checkable (openxFactory
+`specs/034-opendox-standalone-operation/spec.md` § "AT-R1"): *"on a clean
+machine with only openDox installed, a plain git repo opens, and the wheel,
+radar lens and chat panes work, with chat's 'no model configured' state."*
+This harness is that test's HTTP half: steps 1-4, and the route answers behind
+steps 5-8. The browser half is a Playwright run on the host (T096), whose
+verdict `tests/smoke_signals.py` computes. It realizes FR-011's HTTP half.
+
+WHAT IT IS NOT. It is not a pytest module, and it sits outside `tests/` and
+`tests_runtime/`, so `pyproject.toml`'s `testpaths` never collects it and
+#1144's F9.1 is unchanged. It installs the product and drives it from
+outside, as a user would, so it is no member of this leg's suite, and FR-006's
+"no exclusion" still holds. It runs in its own `acceptance` job in
+`.github/workflows/validate.yml`, which has NO database service, because the
+harness asserts a clean machine and the `validate` job's PostgreSQL service
+would break that precondition. Making `acceptance` a required check is a
+ruleset change for the repository's owner.
+
+WHAT IT DOES, in order. Each step is an assertion with an id; the run stops at
+the FIRST that fails, prints `AT-R1 HTTP half: FAIL [<id>]: <why>` and exits 1
+(`--keep-going` reports every failed assertion instead, and still exits 1).
+A harness that breaks before a verdict exits 2, never 0.
+
+ 1. INSTALLS openDox ALONE into a fresh venv, as `opendox[local]` (R1Q16
+    (iii)), from a copy of this checkout's tracked files. The documented
+    install is `pip install "opendox[local]"`; no release of `opendox` is
+    published to a package index, so this installs the same distribution
+    with the same extra from the checkout, `pip install "<checkout>[local]"`,
+    which is the substitution the openDox root's README states for the first
+    line. With `constraints-cpython312-linux.txt` beside it and a CPython
+    3.12 on Linux, the install reads that lock, as every install of this
+    package does (`tests_runtime/test_deploy_shape.py`); the lock pins
+    versions and adds no package.
+ 2. ASSERTS THE CLEAN MACHINE, in a fresh `OPENDOX_STATE_DIR` created empty
+    for this run (and short, so the bundled server's socket path fits): none
+    of the four siblings (`openxdox`, `ideation_dashboard`, `doc_health`,
+    `corpus_adapter_openxfactory`) is importable; `omp` (the harness the
+    product names, `doxbench_bridge.HARNESS_COMMAND`) is not on the PATH; no
+    identity broker (`openprofiler-broker`, the one that exists) is on the
+    PATH and no issuer is set; no database answers on PostgreSQL's default
+    port or on a distribution's socket, and no DSN is set; and neither
+    repository holds a model binding (`doxbench_binding.bindings_path`).
+ 3. COPIES BOTH PLAIN REPOSITORIES into fresh `git init`s (AT-R1 step 3):
+    (a) 5.0's `tests/fixtures/plain-documents`, and (b) three ordinary
+    Markdown notes with no front matter at all, quickstart.md § 2's. Each gets
+    a git identity (`git config user.name` and `user.email`), which the served
+    actor is read from.
+ 4. RUNS THE DOCUMENTED COMMAND on loopback, once per repository. The command
+    is the one T007 batch H's 10.3 addendum names and the openDox root's
+    README documents, `opendox generate-and-open --local …`. The harness fills
+    the `…` with the verb's own arguments, as quickstart.md § 3 does, and
+    checks its argv against that line before it runs it.
+ 5. FETCHES `/` (it must be HTML), `/snapshot.json` (non-empty, and neutral
+    per F5.3: none of openxFactory's declared governance words in any string
+    value; and it fills the grouping station, so the chat pane can open, R1Q13
+    (a) with (c)) and `/capabilities` (`install.mode == "local"`, and NO
+    console token: a standalone plane hands its token to no loopback
+    caller, T104). As quickstart.md § 3 asserts it (T007 batch N), the RAW
+    payload carries the token neither by name, at any depth, nor by value,
+    which step 6 checks once the opener has handed the harness the token.
+ 6. READS THE CONSOLE TOKEN THE WAY THE USER'S BROWSER IS HANDED IT (plan 034
+    T104; RULED openxFactory#656 `5963851934`). The start prints the PATH of
+    a private opener file, `<OPENDOX_STATE_DIR>/console/<port>.html`, and
+    never the token. The file must be this user's regular file, mode 0600,
+    with one link, in a directory of mode 0700, under a state
+    directory and ancestors no other user can change (T104's own rules for
+    that tree), and outside the served repository. Its one LIVE
+    meta-refresh (none inside a `<template>`, a `<noscript>` or a raw-text
+    element counts, as none forwards a browser that runs scripts) forwards
+    to this plane on loopback with `#console_token=<token>` in the URL's
+    FRAGMENT, and never in the query. Its JSON record (`#opendox-console`, kind
+    `opendox-console-access` v1) must describe that same forward: its port,
+    its token, its `opened_url` and its `page_url`. The harness reads that
+    file itself, with the standard library, as a browser would, and imports
+    nothing from the product. No line the harness prints quotes that token,
+    or any other the opener or `/capabilities` carries (`Verdict.redact`):
+    it reads the opener's tokens as soon as the start answers, before step 5
+    quotes anything (`learn_opener_tokens`), and no diagnostic quotes the
+    entry point's output or a `/capabilities` payload.
+ 7. FETCHES THE MODEL CATALOG, presenting that token in
+    `X-XF-Console-Token`. It must answer the envelope the chat rail adopts
+    (`schema_version` 1, `kind` `workbench-model-catalog`, `models[]`), with
+    no available entry (16.4). Asked WITHOUT the token, it must refuse, so
+    the token the opener carries is the one that opens it.
+ 8. FETCHES EVERY ROUTE THE PANES CAN REQUEST, and none may answer 5xx or
+    drop the connection. The list is DERIVED from the served bundle, not kept
+    here: see `derive_bundle` below.
+ 9. STOPS THE SERVER (SIGTERM to the entry point alone, as `kill` would), and
+    asserts that no bundled PostgreSQL process is left running (R1Q16 (iv))
+    and that the opener file went with the server.
+
+HOW THE ROUTE LIST IS DERIVED (`derive_bundle`). From the RUNNING server, not
+from the source tree: `/` is fetched, its `<script type="module">` and
+stylesheet links are followed, and every module's static `import`/`export …
+from` specifiers are followed in turn, with each literal dynamic `import("…")`
+and each view-binding module `/capabilities` declares. That is the module
+graph a browser loads. Every module is fetched from the server under test:
+a static import must answer 200, since a failed one is a module-load
+`pageerror`, which AT-R1 step 8 forbids and no declaration can excuse; a
+dynamic import may be refused (10.2a's `intent-feed.js` is not owed, and its
+importer degrades), but never with a 5xx. A module the server DOES serve
+(200) must be served as JavaScript, and a linked stylesheet as `text/css`,
+parameters such as `charset` aside: a browser refuses a module script of any
+other type, and a standards-mode page applies no stylesheet of any other type
+(Copilot review of openDox-code#75 at f29b4ddd). Then, in every module of
+that graph, with comments stripped, every string literal that is a
+same-origin path (a leading `/` or `./` and a letter, not a module or
+stylesheet) is a route the bundle can request. A static read cannot tell
+which of them fire on load and which on a click, so ALL of them are
+requested, a superset of the three panes' load-time reads. The action
+routes (`/actions/…`) are requested with a GET too, which never executes
+them (a GET there finds no handler, and their POST is a user's act, not a
+load). A route ending in `/` (`/source/`) is a prefix the wheel, the viewer
+and the workbench's source loader complete with a document path, so it is
+also requested once per document the snapshot lists, plain and keyed by the
+workbench's `(repository, ref)` key, as the panes fill it.
+The chat rail's THREAD READ is not requested with a query, because a
+standalone plane's rail sends none: the rail reads `/workbench/thread` only
+where `/capabilities` contributes a branch-session column,
+`gate.workbench.session`, and otherwise answers "no readable thread" itself
+(`app.js`, `doxbenchThreadSeam`; openDox-code#85, the T102 follow-on, holder
+ruling F1 (i) on openxFactory#656). The harness asserts that this plane
+contributes none, and asks the bare route literal only, as it asks every
+literal.
+Every request carries the console token the opener delivered (step 6), as
+the doxBench transports do, so a guarded read answers from its handler
+rather than from the console check.
+
+RUNNING IT. From an openDox-code checkout, `python3 acceptance/at_r1_http.py`
+installs and drives THAT checkout (the one this file is in); to measure
+another tree, copy this file into it. It takes no path or port: its scratch
+space and its `OPENDOX_STATE_DIR` are fresh temporary directories, so
+`TMPDIR` chooses where they go. Choose a short one that only you can write:
+the bundled server refuses a state directory below a directory any user can
+write without the sticky bit, and so does the harness, before it installs
+anything (exit 2); and the socket path may not pass 107 bytes.
+It needs Linux (it reads `/proc`), `git`, and network access to the package
+index. The standard library only: it runs before, and outside, the
+environment it builds.
+"""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import dataclasses
+import errno
+import html.parser
+import http.client
+import json
+import os
+import re
+import shutil
+import signal
+import socket
+import stat
+import subprocess
+import sys
+import tempfile
+import time
+import traceback
+import urllib.parse
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# What the harness takes from the record, verbatim, so a reader can check it.
+# ---------------------------------------------------------------------------
+
+#: The install and the one start, as T007 batch H's 10.3 addendum names them
+#: (openxFactory `openspec/changes/add-neutral-product-standalone-operability/
+#: tasks.md`, 10.3, "AMENDED — T007 Batch H (`5850003126`; Ruled R1Q15 (b),
+#: R1Q16 (iii))") and as the openDox root's README documents them (T076). The
+#: `…` is U+2026, and it stands for the verb's own arguments.
+DOCUMENTED_INSTALL = 'pip install "opendox[local]"'
+DOCUMENTED_START = "opendox generate-and-open --local …"
+
+#: AT-R1 step 1's four siblings: none may be importable.
+SIBLINGS = ("openxdox", "ideation_dashboard", "doc_health",
+            "corpus_adapter_openxfactory")
+
+#: The harness `omp`, by the name quickstart.md § 1 checks; the product's own
+#: `doxbench_bridge.HARNESS_COMMAND` is checked beside it.
+HARNESS_COMMAND = "omp"
+
+#: The one identity broker that exists (`design.md` § D14, quickstart.md § 1).
+BROKER_COMMANDS = ("openprofiler-broker",)
+
+#: Where a binding lives when the product cannot be asked
+#: (`doxbench_binding.DEFAULT_BINDINGS_RELPATH`, quickstart.md § 2).
+BINDINGS_RELPATH_FALLBACK = "ideation/dashboard/model-provider-bindings.yaml"
+
+#: F5.3's declared vocabulary, verbatim from #1144's falsifier under 5.5: a
+#: neutral snapshot carries none of these in any string VALUE.
+F53_WORDS = ["brainstorm", "staged", "draft", "ratified", "standard",
+             "superseded", "retired", "record", "openspec", "proposal.md",
+             "tasks.md", "design.md", "added requirements",
+             "modified requirements"]
+F53_PATTERN = re.compile(r"\b(" + "|".join(re.escape(w) for w in F53_WORDS)
+                         + r")\b")
+
+#: The console-presence header the doxBench transports carry (`app.js`).
+CONSOLE_TOKEN_HEADER = "X-XF-Console-Token"
+
+#: THE CONSOLE TOKEN'S DELIVERY on a standalone plane (plan 034 T104; RULED
+#: openxFactory#656 `5963851934`, adversarial review 2's M5). `/capabilities`
+#: carries no `console_token`. The start prints the opener's location on a
+#: `console <file URL>` line, and the opener is
+#: `<OPENDOX_STATE_DIR>/console/<port>.html`, mode 0600. Its meta-refresh
+#: carries the token as `#console_token=<token>`, in the fragment and never in
+#: the query, because a fragment never reaches a request line, a server log
+#: or a `Referer`.
+CONSOLE_TOKEN_FIELD = "console_token"
+CONSOLE_DIRNAME = "console"
+CONSOLE_FRAGMENT_KEY = "console_token"
+#: The only token the page accepts from the fragment (T104's
+#: `web/views/notebook.js`, `CONSOLE_TOKEN_SHAPE`, `^[A-Za-z0-9_-]{16,512}$`).
+CONSOLE_TOKEN_SHAPE = re.compile(r"[A-Za-z0-9_-]{16,512}")
+#: What stands for a console token in every line the harness prints
+#: (`Verdict.redact`), and the least length of a value it stands for: the
+#: page's own least length, so a short value never blanks out a word.
+REDACTED = "<the console token>"
+#: A run of a token's characters and `%XX` escapes, which `Verdict.redact`
+#: percent-decodes.
+_ENCODABLE_RUN = re.compile(r"(?:[A-Za-z0-9_-]|%[0-9A-Fa-f]{2})+")
+SECRET_MIN_LENGTH = 16
+CONSOLE_LINE = re.compile(r"^[ \t]*console (?P<where>(?:file:|/)\S*)", re.M)
+#: The opener's machine-readable record, "for a harness or a script"
+#: (`opendox.console_access`, T104): JSON in
+#: `<script type="application/json" id="opendox-console">`. The harness parses
+#: it itself, with the standard library, and imports nothing from the product.
+CONSOLE_RECORD_ID = "opendox-console"
+CONSOLE_RECORD_KIND = "opendox-console-access"
+CONSOLE_RECORD_SCHEMA_VERSION = 1
+OPENER_MODE = 0o600
+#: The most of an opener the harness reads, and it reads it whole: a larger
+#: file is refused by name, never judged by a truncated prefix. T104's is
+#: about one kilobyte.
+OPENER_READ_LIMIT = 64 * 1024
+#: The opener's directory, `console/`, exactly (quickstart.md § 3; T104).
+OPENER_DIRECTORY_MODE = 0o700
+LOOPBACK_HOSTS = ("127.0.0.1", "::1", "localhost")
+#: The paths that serve the console page, `/` and the `/index.html` T104's
+#: entry points open (`serve_mod.server_url(httpd, "/index.html")`).
+CONSOLE_PAGES = ("/", "/index.html")
+
+#: The model-catalog route (`app.js` `CATALOG_ROUTE`), which the derived list
+#: must also name, so this constant cannot drift from the bundle unseen.
+CATALOG_ROUTE = "/workbench/model-catalog"
+
+#: The only catalog envelope the chat rail ADOPTS (`views/doxbench-chat-model.js`,
+#: `adoptCatalog`: `schema_version === 1`, `kind === CATALOG_WIRE_KIND`, and an
+#: array of `models`); it reads any other as unreadable. The served bundle must
+#: name the kind too, so this constant cannot drift from the bundle unseen.
+CATALOG_KIND = "workbench-model-catalog"
+CATALOG_SCHEMA_VERSION = 1
+
+#: The chat rail's thread read, and the contributed binding it is read
+#: through: the rail sends one only where `/capabilities` contributes a
+#: branch-session column, `gate.workbench.session` (`app.js`,
+#: `doxbenchThreadSeam`; openDox-code#85, the T102 follow-on; holder ruling
+#: F1 (i) on openxFactory#656, `5973854291`). A standalone plane has none.
+THREAD_ROUTE = "/workbench/thread"
+SESSION_BINDING_ID = "gate.workbench.session"
+
+#: Repository (b): ordinary Markdown with NO front matter at all, quickstart.md
+#: § 2's three notes, byte for byte.
+PLAIN_NOTES = {
+    "roadmap.md": "# Roadmap\n\nThe roadmap links to the [budget](budget.md) "
+                  "and the [notes](notes.md).\n",
+    "budget.md": "# Budget\n\nBudget figures for the roadmap.\n",
+    "notes.md": "# Meeting notes\n\nWe discussed the roadmap and the budget.\n",
+}
+
+#: Settings a child must not inherit. A database or an issuer the user set
+#: would stand in for the bundle or for local identity; a GIT_* variable
+#: would point git at another repository; an XF_* variable (the suite's
+#: XF_GATE_PRINCIPALS roster, for one) changes who the served actor is; a
+#: PYTHONPATH could make a sibling importable.
+STRIPPED_PREFIXES = ("GIT_", "XF_", "OPENDOX_", "PG")
+STRIPPED_NAMES = ("DATABASE_URL", "PYTHONPATH", "PYTHONHOME", "PYTHONSTARTUP",
+                  "PYTHONUSERBASE", "VIRTUAL_ENV", "__PYVENV_LAUNCHER__")
+#: The names a user-provided database or broker would arrive under, asserted
+#: absent from every child's environment (quickstart.md § 1's `unset` list).
+DATABASE_SETTINGS = ("OPENDOX_DATABASE_URL", "OPENDOX_MIGRATION_DATABASE_URL",
+                     "DATABASE_URL", "PGHOST", "PGPORT", "PGDATABASE",
+                     "PGUSER", "PGPASSWORD", "PGSERVICE")
+IDENTITY_SETTINGS = ("OPENDOX_OIDC_ISSUER", "OPENDOX_OIDC_AUDIENCE",
+                     "OPENDOX_INSTALL_MODE")
+#: Where a distribution's PostgreSQL listens by default (Debian and Ubuntu,
+#: the runner's own family). Probed even where `/proc/net/unix` cannot be
+#: read; every other PostgreSQL socket is found there (`postgres_sockets`).
+DISTRIBUTION_SOCKETS = ("/var/run/postgresql/.s.PGSQL.5432",
+                        "/run/postgresql/.s.PGSQL.5432")
+
+#: The bundled server's socket is `<OPENDOX_STATE_DIR>/postgres/run/.s.PGSQL.5432`
+#: (`runtime/config.py`'s `BUNDLE_SOCKET_DIR` and `BUNDLE_PORT`), and Linux
+#: takes a socket path of at most 107 bytes (`UNIX_SOCKET_PATH_MAX`). The
+#: product refuses a longer one by name; the harness refuses to start a run
+#: whose state directory could not fit, before anything is installed.
+SOCKET_SUFFIX = "/postgres/run/.s.PGSQL.5432"
+SOCKET_PATH_MAX = 107
+
+READY_TIMEOUT_SECONDS = 120.0
+STOP_TIMEOUT_SECONDS = 90.0
+REQUEST_TIMEOUT_SECONDS = 30.0
+INSTALL_TIMEOUT_SECONDS = 900.0
+
+
+# ---------------------------------------------------------------------------
+# The verdict.
+# ---------------------------------------------------------------------------
+
+class HarnessError(Exception):
+    """The harness itself could not proceed: not a verdict on the product.
+    `main` prints it as `AT-R1 HTTP half: ERROR` and exits 2."""
+
+
+class Failed(Exception):
+    """One named assertion that did not hold."""
+
+    def __init__(self, ident: str, why: str) -> None:
+        super().__init__(f"[{ident}]: {why}")
+        self.ident = ident
+        self.why = why
+
+
+class Verdict:
+    """Fail fast by default; with `--keep-going`, record and carry on where
+    the next step does not depend on the failed one.
+
+    NO LINE IT PRINTS QUOTES A CONSOLE TOKEN. Every token the run has seen
+    (`keep_secret`: the one the opener carries, any other its forwards or
+    its record carry, one `/capabilities` publishes) is blanked out of every
+    assertion id, every reason and every note, so a product that echoes its
+    token into an answer or a path cannot make the harness publish it in the
+    CI log."""
+
+    def __init__(self, keep_going: bool) -> None:
+        self.keep_going = keep_going
+        self.failures: list[Failed] = []
+        self.passed = 0
+        self.secrets: set[str] = set()
+
+    def keep_secret(self, value: object) -> None:
+        """Never print `value`: a console token this run has seen. Only a
+        string of a token's least length (`CONSOLE_TOKEN_SHAPE`) is kept, so
+        a short value never blanks words out of an unrelated line."""
+        if isinstance(value, str) and len(value) >= SECRET_MIN_LENGTH:
+            self.secrets.add(value)
+
+    def redact(self, text: str) -> str:
+        """`text` with every secret blanked out: as it is, and inside any run
+        of the token's characters and `%XX` escapes whose percent-decodings
+        hold it, partly encoded or encoded twice (Copilot review of
+        openDox-code#75 at ba216f84, r4178913911)."""
+        for secret in sorted(self.secrets, key=len, reverse=True):
+            text = text.replace(secret, REDACTED)
+        if not self.secrets:
+            return text
+
+        def blank(run: re.Match) -> str:
+            if "%" in run.group(0) and any(
+                    secret in form for form in _decodings(run.group(0))
+                    for secret in self.secrets):
+                return REDACTED
+            return run.group(0)
+        return _ENCODABLE_RUN.sub(blank, text)
+
+    def note(self, text: str) -> None:
+        note(self.redact(text))
+
+    def check(self, ident: str, condition: object, why: str) -> bool:
+        ident, why = self.redact(ident), self.redact(why)
+        if condition:
+            self.passed += 1
+            print(f"ok    [{printable(ident)}]", flush=True)
+            return True
+        failure = Failed(ident, why)
+        if not self.keep_going:
+            raise failure
+        self.failures.append(failure)
+        print(f"FAIL  [{printable(ident)}]: {printable_lines(why)}",
+              flush=True)
+        return False
+
+    def require(self, ident: str, condition: object, why: str) -> None:
+        """A check the following steps depend on: it stops the run even under
+        `--keep-going`."""
+        if not self.check(ident, condition, why):
+            raise self.failures[-1]
+
+    def record(self, failure: Failed) -> None:
+        if failure not in self.failures:
+            self.failures.append(failure)
+
+    def report(self) -> int:
+        if not self.failures:
+            print(f"\nAT-R1 HTTP half: PASS ({self.passed} assertions held)")
+            return 0
+        # Again here: a token learned after a failure was recorded.
+        first = self.failures[0]
+        print("\nAT-R1 HTTP half: FAIL "
+              + self._shown(first.ident, first_line(first.why)))
+        for later in self.failures[1:]:
+            print("      also FAIL "
+                  + self._shown(later.ident, first_line(later.why)))
+        print(f"      {len(self.failures)} failed, {self.passed} held")
+        return 1
+
+    def _shown(self, ident: str, why: str) -> str:
+        return (f"[{printable(self.redact(ident))}]: "
+                f"{printable(self.redact(why))}")
+
+
+def note(text: str) -> None:
+    print(f"      {printable(text)}", flush=True)
+
+
+def first_line(text: str) -> str:
+    return (text.splitlines() or [""])[0]
+
+
+def printable(text: str) -> str:
+    """`text` as one line of the CI log carries it: every character that is
+    not printable written as its escape (a control, a newline, a format
+    character such as a bidirectional override, a lone surrogate, a line or
+    paragraph separator), so nothing a server sends can end a line, forge
+    one, or raise while it is printed (the self-pass after Copilot's review
+    of openDox-code#75 at 4bdb41fb, r4178395690)."""
+    return "".join(c if c.isprintable()
+                   else c.encode("unicode_escape").decode("ascii")
+                   for c in text)
+
+
+def printable_lines(text: str) -> str:
+    """A reason of several lines (the install's output tails), each line
+    `printable`, and every line after the first indented under a `|`, so no
+    line of it can stand at the start of a line of the log."""
+    return "\n      | ".join(printable(line) for line in text.split("\n"))
+
+
+#: ASCII upper case to lower case, and nothing else: `str.lower` also folds
+#: non-ASCII letters, where the HTML and MIME standards compare
+#: ASCII-case-insensitively.
+_ASCII_LOWER = {code: code + 32 for code in range(ord("A"), ord("Z") + 1)}
+
+
+def ascii_lower(text: str) -> str:
+    return text.translate(_ASCII_LOWER)
+
+
+def scalar_values(text: str) -> str:
+    """`text` as a browser reads a URL from a JavaScript or JSON string: as
+    a USVString (WebIDL), a surrogate pair joined into the one code point it
+    encodes and a lone surrogate replaced by U+FFFD. Python keeps
+    `"\\uD83D\\uDE00"`, decoded escape by escape, as two code points that no
+    codec encodes (Copilot review of openDox-code#75 at 4bdb41fb,
+    r4178395690)."""
+    return text.encode("utf-16-le", "surrogatepass").decode("utf-16-le",
+                                                            "replace")
+
+
+def as_object(value) -> dict:
+    """A JSON object the product sent, or an empty one where it sent
+    anything else, so a malformed answer fails a named check instead of
+    raising inside the harness."""
+    return value if isinstance(value, dict) else {}
+
+
+def is_json_number(value) -> bool:
+    """A JSON number as JavaScript reads it: an int or a float, never a
+    bool (which Python counts as an int) and never a string."""
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def as_list(value) -> list:
+    return value if isinstance(value, list) else []
+
+
+@dataclasses.dataclass
+class Context:
+    """What one run holds: its directories, its environments, and every
+    process it started."""
+
+    checkout: Path
+    scratch: Path
+    state_dir: Path
+    git: str
+    base_env: dict[str, str]
+    env: dict[str, str] = dataclasses.field(default_factory=dict)
+    venv: Path | None = None
+    python: Path | None = None
+    server_package: Path | None = None
+    servers: list[subprocess.Popen] = dataclasses.field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Children: a clean environment, and nothing inherited that could stand in.
+# ---------------------------------------------------------------------------
+
+def stripped_environment(base: dict[str, str]) -> tuple[dict[str, str], list[str]]:
+    env, dropped = {}, []
+    for name, value in base.items():
+        if name.startswith(STRIPPED_PREFIXES) or name in STRIPPED_NAMES:
+            dropped.append(name)
+            continue
+        env[name] = value
+    env["LANG"] = env.get("LANG") or "C.UTF-8"
+    return env, sorted(dropped)
+
+
+def run(argv: list[str], *, env: dict[str, str], cwd: Path,
+        timeout: float = 120.0) -> subprocess.CompletedProcess:
+    return subprocess.run(argv, env=env, cwd=str(cwd), capture_output=True,
+                          text=True, timeout=timeout, check=False)
+
+
+def tail(text: str, lines: int = 25) -> str:
+    return "\n".join((text or "").strip().splitlines()[-lines:])
+
+
+# ---------------------------------------------------------------------------
+# Processes: what "no bundled PostgreSQL process is left" is checked against.
+# ---------------------------------------------------------------------------
+
+def _proc_state(pid: str) -> str:
+    try:
+        stat = Path(f"/proc/{pid}/stat").read_text(encoding="utf-8")
+    except OSError:
+        return "?"
+    return stat.rsplit(")", 1)[-1].split()[0]
+
+
+def _process_identity(pid: str) -> tuple[str, str]:
+    """`(executable, command line)` of a process, empty where unreadable."""
+    try:
+        exe = os.readlink(f"/proc/{pid}/exe")
+    except OSError:
+        exe = ""
+    try:
+        argv = Path(f"/proc/{pid}/cmdline").read_bytes().split(b"\0")
+    except OSError:
+        argv = []
+    return exe, " ".join(a.decode("utf-8", "replace") for a in argv if a)
+
+
+def bundled_server_processes(server_dir: Path | None,
+                             state_dir: Path) -> list[tuple[int, str]]:
+    """Every live process that is this install's bundled server: its
+    executable lies in the venv's server package, or its command line names
+    the fresh state directory. Read at the operating system, not from the
+    product's own report. A zombie has exited, so it is not running."""
+    state = str(state_dir.resolve())
+    server = str(server_dir.resolve()) + os.sep if server_dir else None
+    found = []
+    for entry in Path("/proc").iterdir():
+        pid = entry.name
+        if not pid.isdigit() or int(pid) == os.getpid():
+            continue
+        if _proc_state(pid) in ("Z", "X", "?"):
+            continue
+        exe, command = _process_identity(pid)
+        if (server and exe.startswith(server)) or state in command:
+            found.append((int(pid), command or exe))
+    return found
+
+
+def stop_processes(pids: list[int]) -> None:
+    for sig in (signal.SIGTERM, signal.SIGKILL):
+        alive = []
+        for pid in pids:
+            try:
+                os.kill(pid, sig)
+            except (ProcessLookupError, PermissionError):
+                continue
+            alive.append(pid)
+        if not alive:
+            return
+        time.sleep(3.0)
+        pids = [p for p in alive if _proc_state(str(p)) not in ("Z", "X", "?")]
+
+
+# ---------------------------------------------------------------------------
+# HTTP, against loopback only, with the status of every answer kept.
+# ---------------------------------------------------------------------------
+
+def _no_constant(name: str):
+    raise ValueError(f"{name} is no JSON value")
+
+
+def strict_json(text: str):
+    """`text` parsed as a browser's `JSON.parse` and `response.json()`
+    parse it: `NaN`, `Infinity` and `-Infinity`, which `json.loads` admits,
+    are refused as malformed (Copilot review of openDox-code#75 at
+    2dcb98d3, r4178069345)."""
+    return json.loads(text, parse_constant=_no_constant)
+
+
+class Answer:
+    def __init__(self, status: int | None, headers: dict[str, str],
+                 body: bytes, error: str | None) -> None:
+        self.status = status
+        self.headers = headers
+        self.body = body
+        self.error = error
+
+    def json(self):
+        """The body as JSON. A body nested past the parser's depth raises
+        `ValueError`, as any other malformed body does, so every caller's
+        named failure takes it, never a harness ERROR (Copilot review of
+        openDox-code#75 at ec95f451, r4175016692)."""
+        try:
+            # A browser's `response.json()` decodes UTF-8 as the Encoding
+            # standard does: a leading BOM dropped, and invalid bytes read as
+            # U+FFFD, never an error.
+            return strict_json(self.body.decode("utf-8-sig", "replace"))
+        except RecursionError as exc:
+            raise ValueError("JSON nested past the parser's depth") from exc
+
+    def describe(self) -> str:
+        return f"HTTP {self.status}" if self.status is not None else (
+            f"no answer ({self.error})")
+
+
+#: What a browser's URL parser percent-encodes in a path, and in a special
+#: URL's query, beside C0 controls, space and every code point past U+007E
+#: (the URL standard's path and special-query percent-encode sets).
+_PATH_ENCODED = frozenset('"#<>?`{}')
+_QUERY_ENCODED = frozenset('"#<>\'')
+
+
+#: What a 3xx answer reads as: no answer this harness judges.
+REDIRECTED = "a redirect, which this harness does not follow"
+
+
+def browser_target(target: str) -> str:
+    """`target` (a path, perhaps with a query) as a browser requests it:
+    a space, a non-ASCII character or a control percent-encoded, and every
+    `%` left as it is. `http.client` refuses such a target, or raises on a
+    non-ASCII one, where a browser sends it encoded (the self-pass after
+    Copilot's review of openDox-code#75 at 2dcb98d3). A lone surrogate,
+    which no codec encodes, is first read as the browser reads it
+    (`scalar_values`)."""
+    path, mark, query = scalar_values(target).partition("?")
+
+    def encode(text: str, extra: frozenset) -> str:
+        return "".join(
+            urllib.parse.quote(c, safe="")
+            if ord(c) <= 0x20 or ord(c) > 0x7E or c in extra else c
+            for c in text)
+    return encode(path, _PATH_ENCODED) + mark + encode(query, _QUERY_ENCODED)
+
+
+def get(port: int, target: str, *, token: str | None = None,
+        host: str = "127.0.0.1") -> Answer:
+    """`target` asked of the plane on `port` at `host`, as a browser on a
+    page of that origin asks it: `http.client` sends that host in `Host`,
+    which the plane's loopback gate reads."""
+    conn = http.client.HTTPConnection(host, port,
+                                      timeout=REQUEST_TIMEOUT_SECONDS)
+    headers = {"Accept": "*/*", "Cache-Control": "no-store"}
+    if token:
+        headers[CONSOLE_TOKEN_HEADER] = token
+    try:
+        conn.request("GET", browser_target(target), headers=headers)
+        response = conn.getresponse()
+        body = response.read()
+        if 300 <= response.status < 400:
+            # A browser follows it, to a URL this harness would have to
+            # judge in its place: refused by name, never judged as the
+            # status it is (the self-pass after Copilot's review of
+            # openDox-code#75 at 4bdb41fb).
+            return Answer(None, {}, b"", f"HTTP {response.status}, "
+                          f"{REDIRECTED}")
+        # A header sent twice is read as one, its values joined by `, `, as
+        # a browser joins them (Fetch's "get" on a header list).
+        received: dict[str, str] = {}
+        for name, value in response.getheaders():
+            name = name.lower()
+            received[name] = (f"{received[name]}, {value}"
+                              if name in received else value)
+        return Answer(response.status, received, body, None)
+    except (OSError, http.client.HTTPException, ValueError) as exc:
+        return Answer(None, {}, b"", error_name(exc))
+    finally:
+        conn.close()
+
+
+def error_name(exc: BaseException) -> str:
+    """A failed request, named without the text the peer sent: the error's
+    type, and the operating system's own words where it has them. An
+    `http.client` error's message quotes the server's status line or
+    headers, which may carry the token (Copilot review of openDox-code#75
+    at 82869769, r4177924097, carried to every answer)."""
+    strerror = exc.strerror if isinstance(exc, OSError) else None
+    return f"{type(exc).__name__}: {strerror}" if strerror else type(exc).__name__
+
+
+#: A plain MIME type essence, the only `Content-Type` a reason quotes.
+_PLAIN_MEDIA_TYPE = re.compile(r"[a-z0-9!#$&^_.+-]{1,64}/[a-z0-9!#$&^_.+-]{1,64}")
+
+
+def shown_type(answer: Answer) -> str:
+    """The answer's `Content-Type` for a reason: its essence where it is a
+    plain MIME type, and otherwise not quoted, as it is the server's own
+    bytes (r4177924097)."""
+    if "content-type" not in answer.headers:
+        return "no Content-Type"
+    essence = media_type(answer)
+    if _PLAIN_MEDIA_TYPE.fullmatch(essence):
+        return repr(essence)
+    return "a Content-Type that is no plain MIME type (not quoted)"
+
+
+def listening(host: str, port: int) -> bool:
+    family = socket.AF_INET6 if ":" in host else socket.AF_INET
+    try:
+        with socket.socket(family, socket.SOCK_STREAM) as probe:
+            probe.settimeout(1.0)
+            return probe.connect_ex((host, port)) == 0
+    except OSError:
+        return False
+
+
+def free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
+        probe.bind(("127.0.0.1", 0))
+        return probe.getsockname()[1]
+
+
+# ---------------------------------------------------------------------------
+# The served bundle, read as JavaScript well enough to find its strings.
+# ---------------------------------------------------------------------------
+
+#: A `/` after one of these words starts a regular expression, not a division:
+#: the reserved words an expression may follow, and those a line break ends
+#: (`break`, `continue`, `debugger`), after which a statement starts.
+_REGEX_AFTER_WORDS = frozenset({
+    "return", "typeof", "instanceof", "in", "new", "delete", "void",
+    "throw", "case", "default", "do", "else", "extends", "yield", "await",
+    "break", "continue", "debugger"})
+#: ... and `of`, which is a keyword only as a `for` head's separator, after
+#: its binding or target, and a name elsewhere, its initializer, condition and
+#: update included (`for (; of / 2; )` divides). A declaration's keyword
+#: comes before a binding, never before the separator.
+_OF = frozenset({"of"})
+_DECLARATIONS = frozenset({"const", "let", "var"})
+#: What a line break ends, by automatic semicolon insertion, where a `/`
+#: could not go on as a division, so that one on the next line opens a
+#: regular expression: a `break` or `continue` to a label, and a
+#: declaration's one binding with no initializer. (A static import's
+#: specifier is another, which the lexer marks as it reads it.)
+_ENDED_BY_A_LINE_BREAK = re.compile(
+    r"(?<![\w$.])(?:break|continue|let|var|const) [\w$]+$")
+#: ... and so does a `/` after one of these characters, or at the start: an
+#: operator's, a division's own `/` among them (`a / /re/.lastIndex`).
+_REGEX_AFTER_PUNCTUATION = frozenset("(,=:[!&|?{};+-*/%<>~^")
+#: The keywords whose `(…)` is a condition, after which a statement, and so
+#: a regular expression, may start.
+_CONDITION_WORDS = frozenset({"if", "while", "for", "with"})
+#: The last name of some code, whitespace already read as one space: a whole
+#: name, so `ñreturn` is no `return`, and a private one with its `#`. Every
+#: character past ASCII that stands in code is a name's, since the lexer has
+#: read JavaScript's whitespace as a space already, and so is a ZWNJ, a ZWJ, a
+#: combining mark or `℘`, which `\w` lacks (Copilot's review overview at
+#: e4f81d48).
+_LAST_NAME = re.compile(r"(#?(?:[\w$]|[^\x00-\x7f])+) ?$")
+#: The `.` (or `?.`) before a member's name; and a `.` that is no member
+#: access, the last of a spread's `...` or a decimal literal's own point
+#: (`1. in`, but neither `1 .`, `1..`, `1.5.` nor `1e5.`).
+_MEMBER_DOT = re.compile(r"\. ?$")
+_NO_MEMBER_DOT = re.compile(r"(?:\.\.|(?<![\w$.])\d[\d_]*)\. ?$")
+
+
+def _condition_opened(code: str) -> str:
+    """The keyword whose condition a `(` after `code` opens: `if`, `while`,
+    `for` or `with`, and `for` after `for await`; or "" for none."""
+    word = _LAST_NAME.search(code)
+    if word is None:
+        return ""
+    if word.group(1) == "await" and _ends_with_keyword(code[:word.start()],
+                                                       frozenset({"for"})):
+        return "for"
+    return word.group(1) if _ends_with_keyword(code, _CONDITION_WORDS) else ""
+
+
+def _of_separates(code: str) -> bool:
+    """Whether the `of` that ends `code`, standing in a `for` head, is the
+    head's separator: after a binding or a target, so after a name, a `)`,
+    a `]` or a `}`, and never after a declaration's keyword, an operator, a
+    `;` or a keyword (Copilot review of openDox-code#75 at 234229d7,
+    r4180899047). After another bare `of`, it is the separator only where
+    that one is not (`for (const of of xs)`, but `for (x of of / 2)`)."""
+    before = code[:_LAST_NAME.search(code).start()].rstrip(" ")
+    if before.endswith((")", "]", "}")):
+        return True
+    word = _LAST_NAME.search(before)
+    if word is None or _ends_with_keyword(before,
+                                          _REGEX_AFTER_WORDS | _DECLARATIONS):
+        return False
+    if word.group(1) == "of":
+        return not _of_separates(before)
+    return True
+
+
+def _ends_with_keyword(code: str, words: frozenset) -> bool:
+    """Whether `code` ends with one of `words` as a KEYWORD: never as a
+    member's name (`obj.return`, `obj . if`, `obj?.of`), which is an operand
+    (Copilot review of openDox-code#75 at ff04e015, r4180554323), nor as
+    part of a longer or private name (`ñreturn`, `this.#of`). After a
+    spread's `...` or a decimal point (`[...typeof x]`, `1. in x`), it is
+    still the keyword."""
+    word = _LAST_NAME.search(code)
+    if word is None or word.group(1) not in words:
+        return False
+    before = code[:word.start()]
+    return (not _MEMBER_DOT.search(before)
+            or _NO_MEMBER_DOT.search(before) is not None)
+
+
+#: JavaScript's WhiteSpace and LineTerminator code points (ECMA-262): tab,
+#: VT, FF, U+FEFF, every space separator (Zs), LF, CR, LS and PS. Python's
+#: `\s` is not this set: it lacks U+FEFF, and adds U+001C-U+001F and U+0085
+#: (Copilot review of openDox-code#75 at ba216f84, r4178913887).
+_JS_WHITESPACE = frozenset(
+    "\t\v\f \u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006"
+    "\u2007\u2008\u2009\u200a\u202f\u205f\u3000\ufeff\n\r\u2028\u2029")
+
+#: What ends a line comment, as JavaScript's LineTerminator: LF, and CR,
+#: U+2028 and U+2029 as well (Copilot's review of openDox-code#75 at
+#: 9229c659, its overview).
+_JS_LINE_END = re.compile("[\n\r\u2028\u2029]")
+
+#: JavaScript's single-character escapes.
+_JS_SINGLE_ESCAPES = {"b": "\b", "f": "\f", "n": "\n", "r": "\r", "t": "\t",
+                      "v": "\v"}
+_JS_LINE_TERMINATORS = "\r\n\u2028\u2029"
+_JS_DIGITS = "0123456789"
+_JS_HEX2 = re.compile(r"[0-9A-Fa-f]{2}")
+_JS_UNICODE = re.compile(r"\{([0-9A-Fa-f]+)\}|([0-9A-Fa-f]{4})")
+
+
+def js_escape(src: str, j: int) -> tuple[str | None, int]:
+    r"""The text the escape sequence at `src[j]` (a backslash) stands for in
+    a JavaScript string or template, and the index after it: `\n`, `\t` and
+    the other single escapes, `\0` where no digit follows, `\xHH`,
+    `\uHHHH`, `\u{H…}` (any number of digits, up to U+10FFFF), a line
+    continuation (nothing), and any other character as itself. A specifier
+    is read as the browser reads it, so `"./ch\tild.js"` holds a TAB, and
+    `"./\u0063hild.js"` is `./child.js` (found while answering Copilot's
+    review of openDox-code#75 at 2dcb98d3, r4178069374).
+
+    `None` where a MODULE refuses the escape, as it is strict code: a legacy
+    octal escape (`\1`, `\00`), `\8` and `\9`, and a `\x` or `\u` that is
+    not well formed are each a SyntaxError, and a browser loads none of the
+    module (the self-pass after Copilot's review of openDox-code#75 at
+    4bdb41fb)."""
+    c = src[j + 1]
+    if c in _JS_LINE_TERMINATORS:
+        end = j + 2
+        if c == "\r" and src.startswith("\n", end):
+            end += 1
+        return "", end
+    if c in _JS_DIGITS:
+        following = src[j + 2:j + 3]
+        if c == "0" and not (following and following in _JS_DIGITS):
+            return "\0", j + 2
+        return None, j + 2
+    if c in _JS_SINGLE_ESCAPES:
+        return _JS_SINGLE_ESCAPES[c], j + 2
+    if c == "x":
+        if _JS_HEX2.fullmatch(src[j + 2:j + 4]):
+            return chr(int(src[j + 2:j + 4], 16)), j + 4
+        return None, j + 2
+    if c == "u":
+        match = _JS_UNICODE.match(src, j + 2)
+        if match and int(match.group(1) or match.group(2), 16) <= 0x10FFFF:
+            return chr(int(match.group(1) or match.group(2), 16)), match.end()
+        return None, j + 2
+    return c, j + 2
+
+
+class JsStrings:
+    """The string literals of one JavaScript module, comments and regular
+    expressions excluded.
+
+    `scan()` returns `(quote, value, preceding code)` for each literal, where
+    the preceding code is the last 40 characters of code before it (other
+    strings blanked, comments and every run of JavaScript whitespace read
+    as ONE space, so no run is too long for it), so an import specifier can
+    be told from an ordinary string. A template literal's value is its
+    leading static text, before any `${`; each `${…}` in it is CODE, and is
+    read as code is, so an import or a route inside one is found (Copilot
+    review of openDox-code#75 at 3392f934, r4179115282), and a `}` in its
+    strings closes nothing. Each value is read as a browser reads a URL from it
+    (`scalar_values`). `malformed` is set where a string holds an escape a
+    module refuses (`js_escape`), as an untagged template does too, and
+    `ambiguous` where a `/` stands right after a `}`, which a lexer cannot
+    read. It is a lexer for this bundle's own idioms, not a parser.
+
+    ITS ACCEPTED LIMITS (the holder's convergence ruling on openDox-code#75):
+    where only a parser can tell a division from a regular expression, the
+    lexer either refuses the module by name or reads one form wrongly:
+    - a `/` right after a `}`, which divides after an expression's `}` and
+      opens a regular expression after a block's, is refused by name;
+    - after a declaration list's last binding with no initializer, then a
+      line break (`let x, y` [line break] `/re/`), automatic semicolon
+      insertion ends the declaration and the `/` opens a regular
+      expression. The lexer reads a division there, so an import after it
+      on that line can be missed. Telling that comma from an expression's
+      takes knowing that it lies in a declaration.
+    No web module openDox ships holds either. When T095 checked all 39,
+    this lexer and acorn's token stream agreed on every `/` (205), and no
+    regular expression in them followed a name, a literal, a `)`, a `]`
+    or a `}`."""
+
+    def __init__(self, source: str) -> None:
+        self.src = source
+        self.i = 0
+        self.code: list[str] = []
+        self.last = ""
+        self.found: list[tuple[str, str, str]] = []
+        self.malformed = False
+        # `{` open in code; and, for each `${` being read, the depth its `}`
+        # closes at and whether its template is tagged.
+        self.depth = 0
+        self.interpolations: list[tuple[int, bool]] = []
+        # For each `(` open in code, the keyword whose condition it opens
+        # (`if`, `while`, `for` or `with`), or "" for none; and whether the
+        # last `)` closed one.
+        self.parens: list[str] = []
+        self.closed_condition = False
+        # Whether a `/` stood right after a `}`, which this lexer cannot read.
+        self.ambiguous = False
+        # The number of code entries read before each line break (or each
+        # comment holding one), and where the last static import's specifier
+        # ended, for the statements a line break ends.
+        self.breaks: set[int] = set()
+        self.specifier_end = -1
+
+    def scan(self) -> list[tuple[str, str, str]]:
+        while self.i < len(self.src):
+            self._step()
+        return self.found
+
+    def _step(self) -> None:
+        c = self.src[self.i]
+        if self.src.startswith("//", self.i) or (
+                self.i == 0 and self.src.startswith("#!")):  # or a hashbang
+            end = _JS_LINE_END.search(self.src, self.i)
+            self.i = len(self.src) if end is None else end.start()
+        elif self.src.startswith("/*", self.i):
+            start, end = self.i, self.src.find("*/", self.i + 2)
+            self.i = len(self.src) if end < 0 else end + 2
+            broken = _JS_LINE_END.search(self.src, start, self.i) is not None
+            self._space(broken)
+        elif c == "/" and self.last == "}":
+            # A `}` that closes a BLOCK is followed by a statement, so a `/`
+            # opens a regular expression; one that closes an EXPRESSION (an
+            # object literal, a function or class expression) is followed by
+            # a division. Telling them apart takes a parser, so the module is
+            # refused by name, never read by a guess (Copilot review of
+            # openDox-code#75 at d50e8cef, r4180454790). It is read on as a
+            # regular expression.
+            self.ambiguous = True
+            self._skip_regex()
+        elif c == "/" and self._regex_may_start():
+            self._skip_regex()
+        elif c in "\"'":
+            self._quoted(c)
+        elif c == "`":
+            self._template()
+        elif c in _JS_WHITESPACE:
+            self._space(c in _JS_LINE_TERMINATORS)
+            self.i += 1
+        elif (c == "}" and self.interpolations
+                and self.interpolations[-1][0] == self.depth):
+            self._template(resume=self.interpolations.pop()[1])
+        else:
+            if c == "{":
+                self.depth += 1
+            elif c == "}":
+                self.depth -= 1
+            elif c == "(":
+                self.parens.append(_condition_opened(self._recent()))
+            elif c == ")":
+                self.closed_condition = bool(self.parens and self.parens.pop())
+            self.code.append(c)
+            self.last = c
+            self.i += 1
+
+    def _space(self, line_break: bool = False) -> None:
+        if not (self.code and self.code[-1].endswith(" ")):
+            self.code.append(" ")
+        if line_break:
+            self.breaks.add(len(self.code))
+
+    def _recent(self) -> str:
+        return "".join(self.code[-40:])
+
+    def _emit(self, quote: str, value: str, end: int) -> None:
+        before = self._recent()
+        self.found.append((quote, scalar_values(value), before))
+        self.code.append(" s ")
+        self.last = "s"
+        self.i = end
+        if quote != "`" and _STATIC_IMPORT_CONTEXT.search(before):
+            self.specifier_end = len(self.code)
+
+    def _regex_may_start(self) -> bool:
+        """Whether a `/` here opens a regular expression, not a division:
+        where no operand ends just before it. After `)`, only where it closed
+        the condition of an `if`, `while`, `for` or `with`; after `++` or
+        `--`, only where the operator is a prefix, with no operand before it
+        (Copilot review of openDox-code#75 at b7b9b843, r4179348386: `n++ /
+        2` divides). After a spread's `...`, or a keyword an expression may
+        follow, it opens one (the pass after Copilot's review overview at
+        ea4f7838); `of` is that keyword only as a `for` head's separator.
+        After a line break that ends a statement, it opens one as well: a
+        `++` or `--` after a line break is a prefix, and a labelled `break`
+        or `continue`, a declaration's lone binding and a static import's
+        specifier each end their statement there."""
+        if self.last == ")":
+            return self.closed_condition
+        code = self._recent().rstrip(" ")
+        if code.endswith(("++", "--")):
+            return (self._break_before_operator()
+                    or not self._ends_an_operand(code[:-2].rstrip(" ")))
+        if code.endswith("..."):        # a spread, before an expression
+            return True
+        if self.last == "" or self.last in _REGEX_AFTER_PUNCTUATION:
+            return True
+        if len(self.code) in self.breaks and (
+                _ENDED_BY_A_LINE_BREAK.search(code) is not None
+                or (self.last == "s" and self.specifier_end == len(self.code))):
+            return True
+        return self._ends_with_a_keyword(self._recent())
+
+    def _break_before_operator(self) -> bool:
+        """Whether a line break stands right before the `++` or `--` that
+        ends the code read, which makes it a prefix (`a` [line break] `++x`
+        is `a; ++x`)."""
+        j = len(self.code)
+        while j and self.code[j - 1] == " ":
+            j -= 1
+        return j - 2 in self.breaks
+
+    def _ends_with_a_keyword(self, code: str) -> bool:
+        """Whether `code` ends with a keyword an expression may follow:
+        `of` only as the separator of the `for` head it stands in."""
+        if _ends_with_keyword(code, _REGEX_AFTER_WORDS):
+            return True
+        return (bool(self.parens) and self.parens[-1] == "for"
+                and _ends_with_keyword(code, _OF) and _of_separates(code))
+
+    def _ends_an_operand(self, code: str) -> bool:
+        """Whether `code` ends with an operand: a name or a literal that is
+        no keyword before an expression (a member's name, `obj.of`, is
+        none), a `)`, a `]`, or a string."""
+        if code.endswith((")", "]")):
+            return True
+        return (_LAST_NAME.search(code) is not None
+                and not self._ends_with_a_keyword(code))
+
+    def _skip_regex(self) -> None:
+        src, j, in_class = self.src, self.i + 1, False
+        while j < len(src) and src[j] != "\n":
+            ch = src[j]
+            if ch == "\\":
+                j += 2
+                continue
+            if ch == "/" and not in_class:
+                break
+            if ch in "[]":
+                in_class = ch == "["
+            j += 1
+        j += 1
+        while j < len(src) and (src[j].isalnum() or src[j] == "_"):
+            j += 1
+        self.code.append(" re ")
+        self.last = "e"
+        self.i = j
+
+    def _quoted(self, quote: str) -> None:
+        src, j, buf = self.src, self.i + 1, []
+        while j < len(src) and src[j] not in (quote, "\n"):
+            if src[j] == "\\" and j + 1 < len(src):
+                text, j = js_escape(src, j)
+                if text is None:
+                    self.malformed, text = True, ""
+                buf.append(text)
+                continue
+            buf.append(src[j])
+            j += 1
+        self._emit(quote, "".join(buf), j + 1)
+
+    def _template(self, resume: bool | None = None) -> None:
+        """A template's text from `self.i` (its opening backtick, or, where
+        `resume` holds its taggedness, the `}` that closed a `${`) to its
+        closing backtick or its next `${`. Its leading static text is its
+        value; at a `${` the scan goes back to reading code, until the `}`
+        that closes it at the same depth calls this again."""
+        src, j, buf = self.src, self.i + 1, []
+        # A TAGGED template (`String.raw` before one) may hold an escape a
+        # module otherwise refuses. Its tag is an expression, so it stands
+        # where a regular expression could not start.
+        tagged = (not self._regex_may_start()) if resume is None else resume
+        while j < len(src) and src[j] != "`":
+            if src[j] == "\\" and j + 1 < len(src):
+                text, j = js_escape(src, j)
+                if text is None:
+                    self.malformed = self.malformed or not tagged
+                    text = ""
+                buf.append(text)
+            elif src.startswith("${", j):
+                self._close_text(resume, "".join(buf), j + 2)
+                self.interpolations.append((self.depth, tagged))
+                # An EXPRESSION starts here, so a `/` opens a regular
+                # expression, as after any `{` (Copilot review of
+                # openDox-code#75 at 0717f72f, r4179220628).
+                self.code.append("${")
+                self.last = "{"
+                return
+            else:
+                buf.append(src[j])
+                j += 1
+        self._close_text(resume, "".join(buf), j + 1)
+
+    def _close_text(self, resume: bool | None, value: str, end: int) -> None:
+        # The LEADING text is the template's value; a later one is not.
+        if resume is None:
+            self._emit("`", value, end)
+        else:
+            self.code.append(" s ")
+            self.last = "s"
+            self.i = end
+
+
+#: The code before an import's specifier, whitespace already read as one
+#: space (`JsStrings`): `import` or `from`, or `import(`, and never a member
+#: named `import` (`loader.import("x")` is a call, not an import).
+_STATIC_IMPORT_CONTEXT = re.compile(r"(?<![\w$.])(?<!\. )(?:import|from) ?$")
+_DYNAMIC_IMPORT_CONTEXT = re.compile(r"(?<![\w$.])(?<!\. )import ?\( ?$")
+_PATH_LITERAL = re.compile(r"^\.?/[A-Za-z][\w\-./%@~]*(?:\?\S*)?$")
+_MODULE_OR_SHEET = re.compile(r"\.(?:m?js|css)(?:[?#].*)?$")
+
+
+#: Elements whose content a browser that runs scripts (as the console page
+#: needs) never makes live, by the HTML standard's parsing rules: a
+#: `<template>`'s content is inert, a `<noscript>`'s is text where scripts
+#: run, and a raw-text or escapable raw-text element holds text, never
+#: elements. A refresh or a record inside one forwards and records nothing
+#: (Copilot review of openDox-code#75 at 4809b3d2, r4174671390). Two more
+#: are not modeled: `select`, whose content parsers have dropped or kept as
+#: they changed, and `frameset`, after which no other element is inserted,
+#: once the page has allowed one. A tag a reader watches inside a live
+#: `select`, and a live `frameset`, are each refused by name (`_LivePage`).
+_INERT_CONTENT = frozenset({"template", "noscript", "script", "style",
+                            "textarea", "title", "xmp", "iframe", "noembed",
+                            "noframes", "plaintext", "select", "frameset"})
+#: ... and of those, the ones whose content is TEXT: nothing inside opens an
+#: element, and only their own end tag closes them.
+_TEXT_CONTENT = _INERT_CONTENT - {"template", "select", "frameset"}
+#: ... and the ones nothing closes, to the end of the page.
+_NEVER_CLOSED = frozenset({"plaintext", "frameset"})
+
+
+#: A named character reference not ended by `;` (`&amp` before a letter).
+_UNTERMINATED_REFERENCE = re.compile(r"&[A-Za-z][A-Za-z0-9]*(?![A-Za-z0-9;])")
+
+
+def _first_attributes(attrs) -> dict[str, str]:
+    """A tag's attributes as a browser keeps them: where a name repeats,
+    the FIRST value, never the last."""
+    named: dict[str, str] = {}
+    for key, value in attrs:
+        named.setdefault(key.lower(), value or "")
+    return named
+
+
+#: The Encoding standard's labels of UTF-8, the one encoding this harness
+#: reads a page in.
+_UTF8_LABELS = frozenset({"unicode-1-1-utf-8", "unicode11utf8",
+                          "unicode20utf8", "utf-8", "utf8", "x-unicode20utf8"})
+#: A `charset=` as a `Content-Type`, a `<meta charset>`, a `<meta
+#: http-equiv="content-type">` or the encoding prescan of a page's first
+#: bytes reads one.
+_CHARSET = re.compile(
+    r"charset[\t\n\f\r ]*=[\t\n\f\r ]*[\"']?([^\"'\t\n\f\r ;>]*)",
+    re.IGNORECASE | re.ASCII)
+
+
+def not_utf8_because(body: bytes, content_type: str | None) -> str | None:
+    """Why a browser may decode `body` other than as UTF-8, which is how
+    this harness reads a page, or `None`. A UTF-8 byte order mark decides it
+    (it outranks every declaration). Otherwise a UTF-16 one, or any
+    `charset=` in `content_type` or anywhere in the page that names no
+    UTF-8 label, is refused by name: a browser may read such a page's bytes
+    as other characters, or, for a label of the replacement encoding
+    (`iso-2022-kr`), as nothing at all (the self-pass after Copilot's review
+    of openDox-code#75 at 4bdb41fb). The label is not quoted."""
+    if body.startswith(b"\xef\xbb\xbf"):
+        return None
+    if body.startswith((b"\xff\xfe", b"\xfe\xff")):
+        return "it starts with a UTF-16 byte order mark"
+    for where, text in (("its Content-Type", content_type or ""),
+                        ("the page", body.decode("utf-8", "replace"))):
+        for match in _CHARSET.finditer(text):
+            label = ascii_lower(match.group(1).strip(_ASCII_WHITESPACE))
+            if label not in _UTF8_LABELS:
+                return (f"{where} declares a charset other than UTF-8 (not "
+                        "quoted)")
+    return None
+
+
+#: Foreign content, whose parsing this harness does not model: inside `<svg>`
+#: and `<math>`, `<script>` and `<link>` are not HTML elements, `<style>`
+#: and `<title>` hold markup, and `<meta>` breaks out as a live HTML element.
+_FOREIGN_CONTENT = frozenset({"svg", "math"})
+
+
+class _LivePage(html.parser.HTMLParser):
+    """A page's LIVE elements, as a browser that runs scripts parses it:
+    `live_tag(tag, attributes)` is called for each, with the FIRST of a
+    repeated attribute, and nothing inside `_INERT_CONTENT` is live. `/>`
+    closes only a void element, so `<template/>` stays open.
+
+    What this harness does not model is named in `unmodeled`, and each
+    reader refuses the page by name on it, never reading it as an
+    approximation: a live `<svg>` or `<math>`, a live `<frameset>`, and a
+    tag the reader WATCHES inside a live `<select>` (the self-pass after
+    Copilot's review of openDox-code#75 at 4bdb41fb, r4178395669)."""
+
+    WATCHED: frozenset = frozenset()
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._inert: list[str] = []
+        self.unmodeled: list[str] = []
+
+    def handle_starttag(self, tag, attrs) -> None:
+        if self._inert and self._inert[-1] in _TEXT_CONTENT:
+            return                      # text to a browser, not an element
+        live = not self._inert
+        if (not live and tag in self.WATCHED and self._inert[0] == "select"
+                and "template" not in self._inert):
+            self.unmodeled.append(f"a <{tag}> inside a <select>")
+        if tag in _INERT_CONTENT:
+            self._inert.append(tag)
+        if not live:
+            return
+        if tag in _FOREIGN_CONTENT or tag == "frameset":
+            self.unmodeled.append(f"<{tag}> content")
+        self.live_tag(tag, _first_attributes(attrs))
+
+    def handle_startendtag(self, tag, attrs) -> None:
+        # A browser ignores `/>` on any element but a void one.
+        self.handle_starttag(tag, attrs)
+
+    def handle_endtag(self, tag) -> None:
+        if self._inert and tag == self._inert[-1] and tag not in _NEVER_CLOSED:
+            self._inert.pop()
+            self.closed(tag)
+
+    def live_tag(self, tag: str, named: dict[str, str]) -> None:
+        """A live element's start tag."""
+
+    def closed(self, tag: str) -> None:
+        """The end of an inert element's content."""
+
+
+def script_type(named: dict[str, str]) -> str | None:
+    """What a browser makes of a `<script>`, by its `type` and `language`
+    (the HTML standard's "prepare the script element"): `"classic"`,
+    `"module"` or `"importmap"`, or `None` for a data block, which it never
+    runs. A `type` is trimmed of ASCII whitespace and compared
+    ASCII-case-insensitively, so `" Module "` is a module, and
+    `"application/json"` and `"  "` are data blocks."""
+    if "type" in named:
+        if named["type"] == "":
+            return "classic"
+        kind = named["type"].strip(_ASCII_WHITESPACE)
+    elif named.get("language", ""):
+        kind = "text/" + named["language"]
+    else:
+        return "classic"
+    kind = ascii_lower(kind)
+    if kind in JAVASCRIPT_TYPES:
+        return "classic"
+    if kind in ("module", "importmap"):
+        return kind
+    return None
+
+
+class _IndexLinks(_LivePage):
+    """The page's LIVE scripts, stylesheets and `<base>`, read as a browser
+    reads them (`_LivePage`): `rel` as a set of ASCII-case-insensitive
+    tokens, and a script by what a browser makes of it (`script_type`).
+
+    Only a live MODULE script with a `src` is a root of the module graph:
+    a script inside a `<template>` runs nothing, a data block runs nothing,
+    and one with an empty `src` fails to load (Copilot review of
+    openDox-code#75 at 4bdb41fb, r4178395669). A CLASSIC script, by its
+    `src` or inline, and an INLINE module script each run code this harness
+    does not read, so each is a named failure, except a classic script
+    marked `nomodule`, which a browser that runs modules skips. A `<base
+    href>` or an import map changes how a browser resolves what the page
+    loads, and this harness models neither, so each is a named failure too
+    (`_check_page_resolution`)."""
+
+    WATCHED = frozenset({"script", "link", "base"})
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.modules: list[str] = []
+        self.sheets: list[str] = []
+        self.bases: list[str] = []
+        self.import_maps = 0
+        self.classic: list[str] = []        # each `src`, or "" where inline
+        self.inline_modules = 0
+
+    def live_tag(self, tag, named):
+        # `html.unescape` decodes `&copy=2` in an attribute; a browser keeps
+        # a reference with no `;` before `=` or a letter or digit as text, so
+        # the two read different URLs. Refused by name, as the opener's
+        # refresh is (Copilot review of openDox-code#75 at 0717f72f,
+        # r4179220641).
+        if tag in self.WATCHED and _UNTERMINATED_REFERENCE.search(
+                self.get_starttag_text() or ""):
+            self.unmodeled.append(f"a <{tag}> whose attributes hold a "
+                                  "character reference with no `;`")
+            return
+        if tag == "script":
+            kind = script_type(named)
+            if kind == "importmap":
+                self.import_maps += 1
+            elif kind == "module" and "src" not in named:
+                self.inline_modules += 1
+            elif kind == "module" and named["src"]:
+                self.modules.append(named["src"])
+            elif (kind == "classic" and "nomodule" not in named
+                    and named.get("src", "x")):
+                self.classic.append(named.get("src", ""))
+        rel = re.split(r"[ \t\n\f\r]+", ascii_lower(named.get("rel", "")))
+        if tag == "link" and "stylesheet" in rel and named.get("href"):
+            self.sheets.append(named["href"])
+        if tag == "base" and "href" in named:
+            self.bases.append(named["href"])
+
+
+#: The origin a reference is resolved against where no server is named (a
+#: route literal, which is a path). `derive_bundle` resolves the module
+#: graph against the RUNNING server's own origin (`plane_origin`).
+_SAME_ORIGIN = "http://loopback"
+#: What a reference this harness cannot parse resolves to: never a path.
+UNPARSEABLE_PREFIX = "unparseable:"
+#: What a reference a browser reads differently resolves to: never a path.
+#: A browser reads a backslash in an http URL as `/`, so
+#: `http://external.invalid\@127.0.0.1:<port>/x.js` goes to
+#: `external.invalid` and `/\host/x.js` to `host`, and it drops tab and
+#: newline characters and trims spaces and control characters, while
+#: `urllib.parse` keeps them all (Copilot review of openDox-code#75 at
+#: 2dcb98d3, r4178069374). Such a reference is refused by name.
+DIVERGENT_PREFIX = "divergent:"
+#: The URL standard's divergences from `urllib.parse`: a backslash (read as
+#: `/` in an http URL), a tab or newline anywhere (removed), and a C0
+#: control or space at either end (trimmed). An inner space is encoded, not
+#: dropped, so it is no divergence.
+_DIVERGENT_REFERENCE = re.compile(r"\\|[\t\n\r]|^[\x00-\x20]|[\x00-\x20]$")
+#: A path SEGMENT a browser's URL parser reads as `.` or `..` and urljoin
+#: does not: `%2e`, `.%2e`, `%2e.` or `%2e%2e`, in any case. A `%2e` inside
+#: a longer segment (`child%2Ejs`) is no dot segment, and a browser
+#: requests it as it is (Copilot review of openDox-code#75 at ba216f84,
+#: r4178913926). And a URL with user information, which a browser refuses
+#: to fetch a module or a stylesheet from, is divergent too (`_resolve`).
+_ENCODED_DOT = re.compile(r"(?:^|/)(?:%2e|\.%2e|%2e\.|%2e%2e)(?=/|$)",
+                          re.IGNORECASE | re.ASCII)
+_DEFAULT_PORTS = {"http": 80, "https": 443}
+
+
+def plane_origin(port: int, host: str = "127.0.0.1") -> str:
+    """The origin of the page the harness loads: the loopback host the
+    opener's forward names (`127.0.0.1` for `/` itself), on the launched
+    plane's port. Plain HTTP, as the plane serves on loopback only, and the
+    host is one `token_in_fragment` admitted from `LOOPBACK_HOSTS`."""
+    netloc = f"[{host}]:{port}" if ":" in host else f"{host}:{port}"
+    return urllib.parse.urlunsplit(("http", netloc, "", "", ""))
+
+
+def _origin_of(url: str) -> tuple | None:
+    """`(scheme, host, port)` of `url` as the URL standard compares origins
+    (a default port made explicit), or `None` where it has no host or no
+    readable port, which no same-origin check admits."""
+    try:
+        parts = urllib.parse.urlsplit(url)
+        port = parts.port or _DEFAULT_PORTS.get(parts.scheme)
+    except ValueError:
+        return None
+    if not parts.hostname:
+        return None
+    return parts.scheme, parts.hostname, port
+
+
+def _resolve(base: str, ref: str, origin: str = _SAME_ORIGIN) -> str:
+    """`ref` resolved against `base` as a browser resolves it on this plane:
+    a same-origin path (with its query), or, for anything that leaves the
+    plane, the whole absolute URL, which never starts with `/` (Copilot
+    review of openDox-code#75 at 142d1352, previously missed). Same-origin
+    is the RUNNING server's origin, so an absolute
+    `http://127.0.0.1:<port>/app.js` is a path of this plane, as it is to
+    the browser (Copilot review of openDox-code#75 at 82869769,
+    r4177924129). A reference no parser here can read is never a path. A
+    lone surrogate is read first as the browser reads it (`scalar_values`;
+    Copilot review of openDox-code#75 at 4bdb41fb, r4178395690).
+
+    ITS ACCEPTED LIMITS (the holder's convergence ruling on openDox-code#75):
+    `urllib.parse` reads a few references differently from the URL
+    standard, and these are not refused:
+    - `///a.js` and `http:///127.0.0.1:<port>/a.js`;
+    - an empty path segment (`.//a.js`);
+    - a dot segment in an absolute same-origin URL
+      (`http://127.0.0.1:<port>/./a.js`);
+    - an empty path (`http://127.0.0.1:<port>`);
+    - an unencoded `^`;
+    - a loopback host the URL standard rewrites (`127.1`, `0x7f.0.0.1`,
+      `2130706433`, `127.0.0.1.`), which is judged an external host.
+    No module openDox ships holds any of them. When T095 checked its 84
+    import specifiers, static and dynamic, against node's WHATWG `URL`,
+    every one resolved alike."""
+    ref = scalar_values(ref)
+    if (_DIVERGENT_REFERENCE.search(ref)
+            or _ENCODED_DOT.search(re.split(r"[?#]", ref, maxsplit=1)[0])):
+        return DIVERGENT_PREFIX + ref
+    try:
+        joined = urllib.parse.urljoin(origin + base, ref)
+        parts = urllib.parse.urlsplit(joined)
+        credentials = parts.username is not None or parts.password is not None
+    except ValueError:
+        return UNPARSEABLE_PREFIX + ref
+    if credentials or "@" in parts.netloc:
+        return DIVERGENT_PREFIX + ref
+    if _origin_of(joined) != _origin_of(origin):
+        return joined
+    return parts.path + (f"?{parts.query}" if parts.query else "")
+
+
+def _external(where: str) -> bool:
+    return not where.startswith("/")
+
+
+def _check_page_resolution(links: "_IndexLinks", origin: str,
+                           verdict: Verdict, label: str,
+                           page: str = "/") -> None:
+    """A `<base>` other than the page's own root, or an import map, would
+    send the browser elsewhere than the harness resolves to: refused by
+    name (the self-pass after Copilot's review of openDox-code#75 at
+    2dcb98d3). So is what the page runs that this harness does not read,
+    and a page that runs no module at all (Copilot review of
+    openDox-code#75 at 4bdb41fb, r4178395669)."""
+    if links.unmodeled:
+        verdict.check(f"{label}.bundle.unmodeled", False,
+                      f"`/` holds {', '.join(sorted(set(links.unmodeled)))},"
+                      " whose parsing this harness does not model, so it "
+                      "cannot tell which scripts and links a browser loads")
+    for src in links.classic:
+        shown = repr(src) if src else "(inline)"
+        verdict.check(f"{label}.bundle.classic-script {shown}", False,
+                      f"`/` runs {shown} as a CLASSIC script, which this "
+                      "harness does not read: a browser runs it as a script, "
+                      "not a module, and an import in it is a SyntaxError")
+    if links.inline_modules:
+        verdict.check(f"{label}.bundle.inline-module", False,
+                      f"`/` holds {links.inline_modules} inline module "
+                      "script(s), whose imports this harness does not read")
+    verdict.check(f"{label}.bundle.entry", bool(links.modules),
+                  "`/` loads no live module script (`<script type=\"module\" "
+                  "src>`), so a browser runs no application; a view module "
+                  "/capabilities declares is no entry, and neither is a "
+                  "script inside a <template>, a data block, or one with an "
+                  "empty `src`")
+    for base in links.bases[:1]:            # only the first one counts
+        verdict.check(f"{label}.bundle.base",
+                      _resolve(page, base, origin) == "/",
+                      "`/` sets a base URL other than its own root (not "
+                      "quoted); a browser then resolves the page's links "
+                      "against it, and this harness resolves them against "
+                      "`/`")
+    if links.import_maps:
+        verdict.check(f"{label}.bundle.importmap", False,
+                      "`/` declares an import map, which this harness does "
+                      "not resolve: a browser maps bare specifiers through it "
+                      "and may remap relative ones")
+
+
+def _graph_roots(index_html: str, capabilities: dict,
+                 origin: str = _SAME_ORIGIN, verdict: Verdict | None = None,
+                 label: str = "", page: str = "/") -> tuple[list, list]:
+    links = _IndexLinks()
+    links.feed(index_html)
+    if verdict is not None:
+        _check_page_resolution(links, origin, verdict, label, page)
+    # THE DOCUMENT'S BASE URL resolves the page's scripts and stylesheets: a
+    # `<base href>`'s, resolved against the page, where it names a path of
+    # this plane, and the page's own otherwise (Copilot review of
+    # openDox-code#75 at b7b9b843, r4179348414: on `/index.html` with
+    # `<base href="/">`, `src="?m=1"` is `/?m=1`).
+    base = _resolve(page, links.bases[0], origin) if links.bases else page
+    base = base if base.startswith("/") else page
+    roots = [(_resolve(base, m, origin), True, "/") for m in links.modules]
+    for view in as_list(as_object(capabilities.get("views")).get("views")):
+        module = as_object(view).get("module")
+        if isinstance(module, str) and module:
+            roots.append((_resolve("/", module, origin), True,
+                          "/capabilities"))
+    return roots, [_resolve(base, sheet, origin) for sheet in links.sheets]
+
+
+#: The JavaScript MIME type essences the HTML standard lists, as
+#: `tests_runtime/test_served_bundle.py`'s `JAVASCRIPT_TYPES` lists them. A
+#: browser refuses a module script served under any other type.
+JAVASCRIPT_TYPES = frozenset({
+    "application/ecmascript", "application/javascript",
+    "application/x-ecmascript", "application/x-javascript",
+    "text/ecmascript", "text/javascript", "text/javascript1.0",
+    "text/javascript1.1", "text/javascript1.2", "text/javascript1.3",
+    "text/javascript1.4", "text/javascript1.5", "text/jscript",
+    "text/livescript", "text/x-ecmascript", "text/x-javascript",
+})
+#: The one type a standards-mode page applies a linked stylesheet under.
+STYLESHEET_TYPE = "text/css"
+
+
+#: HTTP whitespace, and an HTTP token, as the MIME Sniffing standard reads a
+#: type and a subtype.
+_HTTP_WHITESPACE = " \t\r\n"
+_HTTP_TOKEN = re.compile(r"[!#$%&'*+.^_`|~0-9A-Za-z-]+")
+
+
+def media_type(answer: Answer) -> str:
+    """The answer's MIME type essence as a browser parses it (the MIME
+    Sniffing standard): HTTP whitespace trimmed, a type and a subtype of
+    HTTP token code points, ASCII-lowercased, parameters such as `charset`
+    aside. EMPTY where there is none, where it does not parse
+    (`text/javascript\\xa0`, which `str.strip` would have trimmed), and
+    where `Content-Type` holds more than one value: a browser takes the
+    last that parses (Fetch's "extract a MIME type"), and this harness
+    does not split them (the self-pass after Copilot's review of
+    openDox-code#75 at 4bdb41fb)."""
+    value = answer.headers.get("content-type")
+    if value is None or "," in value:
+        return ""
+    essence = value.split(";", 1)[0].strip(_HTTP_WHITESPACE)
+    kind, slash, subtype = essence.partition("/")
+    if not (slash and _HTTP_TOKEN.fullmatch(kind)
+            and _HTTP_TOKEN.fullmatch(subtype)):
+        return ""
+    return ascii_lower(essence)
+
+
+def _judge_module(answer: Answer, path: str, static: bool, importer: str,
+                  verdict: Verdict, label: str) -> None:
+    if static:
+        verdict.check(
+            f"{label}.bundle.module {path}", answer.status == 200,
+            f"{path}, imported statically by {importer}, answers "
+            f"{answer.describe()}; a failed static import is a module-load "
+            "pageerror (AT-R1 step 8)")
+    else:
+        verdict.check(
+            f"{label}.bundle.dynamic {path}",
+            answer.status is not None and answer.status < 500,
+            f"{path}, imported dynamically by {importer}, answers "
+            f"{answer.describe()}")
+        if answer.status != 200:
+            verdict.note(f"{path} (dynamic, from {importer}) answers "
+                         f"{answer.describe()}: refused, and its importer "
+                         "degrades")
+    if answer.status == 200:
+        # SERVED, so it must be runnable: a module of any other type is
+        # refused by the browser as surely as a 404 (Copilot review of
+        # openDox-code#75 at f29b4ddd, r4173769822).
+        verdict.check(
+            f"{label}.bundle.module-type {path}",
+            media_type(answer) in JAVASCRIPT_TYPES,
+            f"{path}, imported {'statically' if static else 'dynamically'} "
+            f"by {importer}, is served as {shown_type(answer)}, which a "
+            "browser refuses for a module script")
+
+
+#: A bare module specifier (`import "child.js"`), marked so: with no import
+#: map, a browser resolves only a specifier that starts with `/`, `./` or
+#: `../`, or one that is an absolute URL, and throws on any other (the HTML
+#: standard's "resolve a module specifier"). The served page has no import
+#: map (Copilot review of openDox-code#75 at 27479495, r4174411680).
+BARE_PREFIX = "bare:"
+_URL_SCHEME = re.compile(r"^[A-Za-z][A-Za-z0-9+.-]*:")
+
+
+def _specifier(importer: str, value: str,
+               origin: str = _SAME_ORIGIN) -> str:
+    """A module specifier as a browser with no import map resolves it: the
+    resolved path or URL, or `bare:<specifier>` where it throws."""
+    if value.startswith(("/", "./", "../")) or _URL_SCHEME.match(value):
+        return _resolve(importer, value, origin)
+    return BARE_PREFIX + value
+
+
+def _scan_module(path: str, body: bytes, pending: collections.deque,
+                 routes: set[str], literals: set[str] | None = None,
+                 origin: str = _SAME_ORIGIN) -> tuple[bool, bool]:
+    """Queue the module's imports and collect its routes. It is decoded as a
+    browser decodes a module script, as UTF-8 with a leading BOM dropped.
+    Returns whether it holds a string escape a module refuses
+    (`JsStrings.malformed`), and whether a `/` in it stands right after a
+    `}` (`JsStrings.ambiguous`)."""
+    strings = JsStrings(body.decode("utf-8-sig", "replace"))
+    for _quote, value, before in strings.scan():
+        if literals is not None:
+            literals.add(value)
+        if _DYNAMIC_IMPORT_CONTEXT.search(before):
+            pending.append((_specifier(path, value, origin), False, path))
+        elif _STATIC_IMPORT_CONTEXT.search(before):
+            pending.append((_specifier(path, value, origin), True, path))
+        elif _PATH_LITERAL.match(value) and not _MODULE_OR_SHEET.search(value):
+            routes.add(_resolve("/", value))
+    return strings.malformed, strings.ambiguous
+
+
+def _judge_divergent(where: str, importer: str, how: str, verdict: Verdict,
+                     label: str) -> None:
+    ref = where[len(DIVERGENT_PREFIX):]
+    verdict.check(
+        f"{label}.bundle.divergent {ref!r}", False,
+        f"{importer} {how} {ref!r}, which a browser reads as another URL "
+        "than this harness would, or refuses (a backslash, a tab or newline, "
+        "whitespace or a control character at an end, a percent-encoded dot "
+        "segment, or user information): refused, never resolved or fetched")
+
+
+def derive_bundle(port: int, index_html: str, capabilities: dict,
+                  verdict: Verdict, label: str,
+                  literals: set[str] | None = None, *,
+                  host: str = "127.0.0.1",
+                  page: str = "/") -> tuple[list[str], int]:
+    """Walk the module graph the served `/` loads, fetching each module from
+    the server, and return `(routes, modules)`: every same-origin path
+    literal the graph names, and how many modules it holds. Every string
+    literal of the graph is added to `literals` where one is given."""
+    # The page's own origin and path: the browser resolves and asks every
+    # module, sheet and route there (Copilot review of openDox-code#75 at
+    # 3392f934, r4179115311).
+    origin = plane_origin(port, host)
+    roots, sheets = _graph_roots(index_html, capabilities, origin, verdict,
+                                 label, page)
+    for sheet in sheets:
+        if sheet.startswith(DIVERGENT_PREFIX):
+            _judge_divergent(sheet, "/", "links the stylesheet", verdict,
+                             label)
+            continue
+        if _external(sheet):
+            verdict.check(
+                f"{label}.bundle.external {sheet}", False,
+                f"`/` links the stylesheet {sheet}, from outside this plane, "
+                "which a clean machine with only openDox installed cannot be "
+                "assumed to reach")
+            continue
+        answer = get(port, sheet, host=host)
+        verdict.check(f"{label}.bundle.sheet {sheet}", answer.status == 200,
+                      f"the stylesheet `/` links answers {answer.describe()}")
+        if answer.status == 200:
+            # (Copilot review of openDox-code#75 at f29b4ddd, r4173769844.)
+            verdict.check(
+                f"{label}.bundle.sheet-type {sheet}",
+                media_type(answer) == STYLESHEET_TYPE,
+                f"the stylesheet `/` links is served as "
+                f"{shown_type(answer)}, which a standards-mode page does not "
+                "apply as CSS")
+    # Each path is FETCHED and scanned once, but JUDGED once per way it is
+    # imported: a module refused as a dynamic import must still answer 200
+    # where another module imports it statically (Copilot review of
+    # openDox-code#75, r4170450448).
+    pending = collections.deque(roots)
+    answers: dict[str, Answer] = {}
+    judged: set[tuple[str, bool]] = set()
+    routes: set[str] = set()
+    while pending:
+        path, static, importer = pending.popleft()
+        if (path, static) in judged:
+            continue
+        judged.add((path, static))
+        if path.startswith(BARE_PREFIX):
+            verdict.check(
+                f"{label}.bundle.bare {path[len(BARE_PREFIX):]}", False,
+                f"{importer} imports {path[len(BARE_PREFIX):]!r} "
+                f"{'statically' if static else 'dynamically'} as a bare "
+                "specifier, which a browser with no import map refuses; a "
+                "relative one starts with `./` or `../`")
+            continue
+        if path.startswith(DIVERGENT_PREFIX):
+            _judge_divergent(path, importer,
+                             f"imports {'statically' if static else 'dynamically'}",
+                             verdict, label)
+            continue
+        if _external(path):
+            # Never fetched from loopback by its path, where a local file of
+            # the same name would answer for it.
+            verdict.check(
+                f"{label}.bundle.external {path}", False,
+                f"{importer} imports {path} "
+                f"{'statically' if static else 'dynamically'}, from outside "
+                "this plane, which a clean machine with only openDox "
+                "installed cannot be assumed to reach")
+            continue
+        first = path not in answers
+        if first:
+            answers[path] = get(port, path, host=host)
+        answer = answers[path]
+        _judge_module(answer, path, static, importer, verdict, label)
+        if not (first and answer.status == 200):
+            continue
+        malformed, ambiguous = _scan_module(path, answer.body, pending,
+                                            routes, literals, origin)
+        if ambiguous:
+            verdict.check(
+                f"{label}.bundle.ambiguous-slash {path}", False,
+                f"{path} has a `/` right after a `}}`, which divides where the "
+                "`}` ends an expression (an object literal, a function or "
+                "class expression) and opens a regular expression where it "
+                "ends a block; this harness does not tell the two apart, so "
+                "it cannot be sure which imports and routes follow")
+        if malformed:
+            verdict.check(
+                f"{label}.bundle.syntax {path}", False,
+                f"{path} holds a string escape a module refuses (a legacy "
+                "octal escape, `\\8` or `\\9`, or a `\\x` or `\\u` that is "
+                "not well formed): a SyntaxError, so a browser loads none "
+                "of it")
+    modules = sum(1 for answer in answers.values() if answer.status == 200)
+    return sorted(routes), modules
+
+
+# ---------------------------------------------------------------------------
+# Steps 1-3: the install, the clean machine, the repositories.
+# ---------------------------------------------------------------------------
+
+def copy_tracked_tree(checkout: Path, target: Path, git: str,
+                      env: dict[str, str]) -> None:
+    listed = run([git, "-C", str(checkout), "ls-files", "-z"], env=env,
+                 cwd=target.parent)
+    if listed.returncode != 0:
+        raise HarnessError(f"{checkout} is not a git checkout: "
+                           f"{tail(listed.stderr)}")
+    for rel in filter(None, listed.stdout.split("\0")):
+        src = checkout / rel
+        if src.is_file():
+            dst = target / rel
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)
+
+
+def make_repository(root: Path, files: dict[Path, Path | str], git: str,
+                    env: dict[str, str], message: str) -> None:
+    root.mkdir(parents=True)
+    for rel, content in files.items():
+        dst = root / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        if isinstance(content, Path):
+            shutil.copy2(content, dst)
+        else:
+            dst.write_text(content, encoding="utf-8")
+    for argv in (["init", "-q"],
+                 ["config", "user.name", "fixture"],
+                 ["config", "user.email", "fixture@example.invalid"],
+                 ["add", "-A"],
+                 ["commit", "-q", "-m", message]):
+        done = run([git, "-C", str(root), *argv], env=env, cwd=root)
+        if done.returncode != 0:
+            raise HarnessError(f"git {' '.join(argv)} in {root} failed: "
+                               f"{tail(done.stderr)}")
+
+
+_ASK_THE_INSTALL = r"""
+import importlib.metadata as md, importlib.util as iu, json, sys
+siblings = sys.argv[1].split(",")
+out = {"importable": [s for s in siblings if iu.find_spec(s) is not None]}
+try:
+    out["extras"] = sorted(md.metadata("opendox").get_all("Provides-Extra") or [])
+except md.PackageNotFoundError:
+    out["extras"] = None
+try:
+    from opendox import doxbench_bridge
+    out["harness_command"] = doxbench_bridge.HARNESS_COMMAND
+except Exception:
+    out["harness_command"] = None
+try:
+    from opendox import doxbench_binding
+    out["bindings_relpath"] = doxbench_binding.DEFAULT_BINDINGS_RELPATH
+except Exception:
+    out["bindings_relpath"] = None
+spec = iu.find_spec("pixeltable_pgserver")
+out["server_package"] = (list(spec.submodule_search_locations)[0]
+                         if spec and spec.submodule_search_locations else None)
+print(json.dumps(out))
+"""
+
+
+def ask_the_install(ctx: Context) -> dict:
+    """What the installed product says about itself, read in the venv, in
+    isolated mode, from an empty directory."""
+    empty = ctx.scratch / "cwd"
+    empty.mkdir(exist_ok=True)
+    done = run([str(ctx.python), "-I", "-c", _ASK_THE_INSTALL,
+                ",".join(SIBLINGS)], env=ctx.env, cwd=empty)
+    if done.returncode != 0:
+        raise HarnessError(f"could not ask the install about itself: "
+                           f"{tail(done.stderr)}")
+    return json.loads(done.stdout)
+
+
+def install_opendox(ctx: Context, verdict: Verdict) -> dict:
+    """Step 1: openDox alone, into a fresh venv, as `opendox[local]`."""
+    source = ctx.scratch / "openDox-code"
+    copy_tracked_tree(ctx.checkout, source, ctx.git, ctx.base_env)
+    ctx.venv = ctx.scratch / "venv"
+    made = run([sys.executable, "-m", "venv", "--clear", str(ctx.venv)],
+               env=ctx.base_env, cwd=ctx.scratch)
+    verdict.require("install.venv", made.returncode == 0,
+                    f"python -m venv failed: {tail(made.stderr)}")
+    ctx.python = ctx.venv / "bin" / "python"
+    lock = source / "constraints-cpython312-linux.txt"
+    use_lock = (lock.is_file() and sys.platform.startswith("linux")
+                and sys.implementation.name == "cpython"
+                and sys.version_info[:2] == (3, 12))
+    install = [str(ctx.python), "-m", "pip", "install",
+               "--disable-pip-version-check", "--no-input"]
+    if use_lock:
+        install += ["-c", str(lock)]
+    install.append(f"{source}[local]")
+    verdict.note("$ " + " ".join(install[2:]) + (
+        "" if use_lock else "   (no lock: it pins CPython 3.12 on Linux)"))
+    installed = run(install, env=ctx.base_env, cwd=ctx.scratch,
+                    timeout=INSTALL_TIMEOUT_SECONDS)
+    verdict.require("install opendox[local]", installed.returncode == 0,
+                    f"the install failed (rc={installed.returncode}):\n"
+                    f"{tail(installed.stdout)}\n{tail(installed.stderr)}")
+    ctx.env = dict(ctx.base_env)
+    ctx.env["PATH"] = (str(ctx.venv / "bin") + os.pathsep
+                       + ctx.base_env.get("PATH", ""))
+    ctx.env["OPENDOX_STATE_DIR"] = str(ctx.state_dir)
+    about = ask_the_install(ctx)
+    verdict.require("install declares the local extra",
+                    "local" in (about.get("extras") or []),
+                    f"the installed opendox declares the extras "
+                    f"{about.get('extras')}, and no `local` (R1Q16 (iii)): the "
+                    "documented install has no bundled server to bring")
+    if about.get("server_package"):
+        ctx.server_package = Path(about["server_package"])
+    return about
+
+
+def postgres_sockets() -> list[str]:
+    """Every listening Unix socket the kernel lists (`/proc/net/unix`) whose
+    name is PostgreSQL's, `.s.PGSQL.<port>`, wherever it lies: `/tmp`
+    (libpq's upstream default), a distribution's directory, or any other."""
+    try:
+        rows = Path("/proc/net/unix").read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return []
+    found = {row.split()[-1] for row in rows[1:]
+             if len(row.split()) >= 8
+             and Path(row.split()[-1]).name.startswith(".s.PGSQL.")}
+    return sorted(found)
+
+
+def _shared_directory(sock: str) -> bool:
+    """Whether other users can traverse the socket's directory, as they can
+    every default libpq consults (`/tmp`, `/var/run/postgresql`). A socket
+    in a private (0700) directory is another install's own, reachable only
+    by its owner through an explicit setting, and no child inherits one.
+    A directory that cannot be read is treated as shared: fail closed."""
+    try:
+        mode = os.stat(os.path.dirname(sock)).st_mode
+    except OSError:
+        return True
+    return bool(mode & stat.S_IXOTH)
+
+
+def _socket_answers(sock: str) -> bool:
+    if not os.path.exists(sock):
+        return False
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as probe:
+            probe.settimeout(1.0)
+            return probe.connect_ex(sock) == 0
+    except OSError:
+        return False
+
+
+def no_database_answers(verdict: Verdict, env: dict[str, str]) -> None:
+    for host in ("127.0.0.1", "::1"):
+        verdict.check(f"clean.database tcp {host}:5432",
+                      not listening(host, 5432),
+                      f"a database already listens on {host}:5432, so the "
+                      "bundled server would not be the only one")
+    # EVERY PostgreSQL socket the kernel lists, not a list of directories
+    # kept here (Copilot review of openDox-code#75, r4170537350: a server on
+    # `/tmp`'s socket alone, with TCP off, passed a fixed list).
+    for sock in sorted(set(postgres_sockets()) | set(DISTRIBUTION_SOCKETS)):
+        if not _shared_directory(sock):
+            verdict.note(f"{sock} is another install's private socket "
+                         "(its directory admits no other user); no child is "
+                         "configured to reach it")
+            continue
+        verdict.check(f"clean.database socket {sock}",
+                      not _socket_answers(sock),
+                      f"a database already answers on {sock}, a directory "
+                      "every user's libpq can default to")
+    present = [name for name in DATABASE_SETTINGS if env.get(name)]
+    verdict.check("clean.database settings", not present,
+                  f"the child environment names a database: {present}")
+
+
+def assert_clean_machine(ctx: Context, about: dict, verdict: Verdict) -> None:
+    """Step 2: every absence AT-R1 step 1 names, asserted, not assumed."""
+    path = ctx.env["PATH"]
+    verdict.check("clean.siblings", not about["importable"],
+                  f"importable in the fresh venv: {about['importable']}")
+    harnesses = {HARNESS_COMMAND, about.get("harness_command") or HARNESS_COMMAND}
+    on_path = [h for h in sorted(harnesses) if shutil.which(h, path=path)]
+    verdict.check("clean.omp", not on_path,
+                  f"a harness is on the PATH ({on_path}), so no-model is not "
+                  "what this run measures")
+    brokers = [b for b in BROKER_COMMANDS if shutil.which(b, path=path)]
+    identity = [n for n in IDENTITY_SETTINGS if ctx.env.get(n)]
+    verdict.check("clean.identity-broker", not brokers and not identity,
+                  f"an identity broker is present: on the PATH {brokers}, "
+                  f"set {identity}")
+    no_database_answers(verdict, ctx.env)
+    verdict.check("clean.state-dir", not any(ctx.state_dir.iterdir()),
+                  f"OPENDOX_STATE_DIR {ctx.state_dir} is not empty")
+    verdict.check("clean.no-bundled-server-yet",
+                  not bundled_server_processes(ctx.server_package,
+                                               ctx.state_dir),
+                  "a process of this install's bundled server runs before "
+                  "anything started it")
+
+
+def make_repositories(ctx: Context, about: dict,
+                      verdict: Verdict) -> list[tuple[str, Path]]:
+    """Step 3: both plain repositories, each a fresh `git init` with a git
+    identity and no model binding."""
+    fixture = ctx.scratch / "openDox-code" / "tests" / "fixtures" / "plain-documents"
+    verdict.require("repos.fixture", fixture.is_dir(),
+                    f"5.0's fixture is missing at {fixture}")
+    repos = ctx.scratch / "repos"
+    a, b = repos / "plain-documents", repos / "plain-notes"
+    make_repository(a, {p.relative_to(fixture): p
+                        for p in sorted(fixture.rglob("*")) if p.is_file()},
+                    ctx.git, ctx.env, "fixture")
+    make_repository(b, {Path(k): v for k, v in PLAIN_NOTES.items()},
+                    ctx.git, ctx.env, "notes")
+    bindings = about.get("bindings_relpath") or BINDINGS_RELPATH_FALLBACK
+    for label, repo in (("a", a), ("b", b)):
+        verdict.check(f"clean.binding {label}", not (repo / bindings).exists(),
+                      f"{repo} holds a model binding at {bindings}")
+        name = run([ctx.git, "-C", str(repo), "config", "user.name"],
+                   env=ctx.env, cwd=repo)
+        verdict.check(f"repos.{label} git identity",
+                      name.stdout.strip() == "fixture",
+                      f"{repo} has no git identity, so no served actor")
+    return [("a", a), ("b", b)]
+
+
+# ---------------------------------------------------------------------------
+# Steps 4-8, once per repository.
+# ---------------------------------------------------------------------------
+
+class Server:
+    """One launched entry point, and what it has said."""
+
+    def __init__(self, label: str, proc: subprocess.Popen, port: int,
+                 out: Path, err: Path) -> None:
+        self.label = label
+        self.proc = proc
+        self.port = port
+        self.out = out
+        self.err = err
+
+    def said(self) -> str:
+        """Where the entry point's output is, for a diagnostic, and never
+        the output itself: it may hold the console token, and a diagnostic
+        reaches the CI log before the after-stop check could catch a printed
+        token (Copilot review of openDox-code#75 at 33841d4a,
+        r4174621486). `printed()` still reads the whole output for that
+        check."""
+        return (f" (the entry point's output is in {self.out} and "
+                f"{self.err}, not echoed here because it may hold the console "
+                "token; run with --keep to keep it)")
+
+    def printed(self) -> str:
+        """Everything the entry point has written so far, both streams."""
+        return (self.out.read_text("utf-8", "replace") + "\n"
+                + self.err.read_text("utf-8", "replace"))
+
+
+def documented_prefix() -> list[str]:
+    words = DOCUMENTED_START.split(" ")
+    if words[-1] != "…":
+        raise HarnessError("DOCUMENTED_START lost its `…`")
+    return words[:-1]
+
+
+def launch(label: str, repo: Path, ctx: Context,
+           verdict: Verdict) -> tuple[Server, Answer]:
+    """Step 4: the documented start, checked before and after it runs."""
+    port = free_port()
+    for host in ("127.0.0.1", "::1"):
+        verdict.require(f"{label}.start.port-free {host}:{port}",
+                        not listening(host, port),
+                        f"something already listens on {host}:{port}, so a "
+                        "ready answer would not come from this run")
+    prefix = documented_prefix()
+    argv = prefix + ["--repo-root", str(repo), "--repository", "fixture",
+                     "--no-open", "--port", str(port)]
+    verdict.require(f"{label}.start.documented-command",
+                    argv[:len(prefix)] == prefix,
+                    f"the harness would run {argv[:len(prefix)]}, not the "
+                    f"documented `{DOCUMENTED_START}`")
+    program = shutil.which(argv[0], path=ctx.env["PATH"])
+    verdict.require(
+        f"{label}.start.console-script",
+        program is not None
+        and Path(program).resolve().is_relative_to(ctx.venv.resolve()),
+        f"`{argv[0]}` resolves to {program!r}, not the fresh venv's console "
+        "script")
+    verdict.note("$ " + " ".join(argv))
+    out, err = ctx.scratch / f"{label}-server.out", ctx.scratch / f"{label}-server.err"
+    with open(out, "wb") as stdout, open(err, "wb") as stderr:
+        proc = subprocess.Popen(argv, executable=program, env=ctx.env,
+                                cwd=str(ctx.scratch), stdout=stdout,
+                                stderr=stderr, stdin=subprocess.DEVNULL,
+                                start_new_session=True)
+    ctx.servers.append(proc)
+    server = Server(label, proc, port, out, err)
+    index = wait_until_ready(server)
+    verdict.require(
+        f"{label}.start.ready", index is not None,
+        (f"the documented command exited (rc={proc.returncode}) before it "
+         "answered" if proc.poll() is not None else
+         f"no answer on 127.0.0.1:{port} within {READY_TIMEOUT_SECONDS:.0f}s")
+        + server.said())
+    verdict.require(f"{label}.start.serving-process", proc.poll() is None,
+                    "the launched server exited after it answered, so the "
+                    "answer may not have been its own" + server.said())
+    return server, index
+
+
+def wait_until_ready(server: Server) -> Answer | None:
+    deadline = time.monotonic() + READY_TIMEOUT_SECONDS
+    while time.monotonic() < deadline and server.proc.poll() is None:
+        answer = get(server.port, "/")
+        if answer.status == 200:
+            return answer
+        time.sleep(0.5)
+    return None
+
+
+def fetch_object(server: Server, route: str,
+                 verdict: Verdict) -> tuple[dict, str]:
+    """`route`'s JSON object, and its RAW payload as text."""
+    answer = get(server.port, route)
+    verdict.require(f"{server.label}.http {route}", answer.status == 200,
+                    f"{route} answers {answer.describe()}")
+    try:
+        body = answer.json()
+        parsed = f"it is JSON, a {type(body).__name__}"
+    except ValueError:
+        body, parsed = None, "it is not JSON"
+    # The payload itself is not quoted: it may carry the console token
+    # (Copilot review of openDox-code#75 at ec95f451, r4175016672).
+    verdict.require(f"{server.label}.{route} is a JSON object",
+                    isinstance(body, dict),
+                    f"{route} is not a JSON object: {parsed}")
+    return body, answer.body.decode("utf-8", "replace")
+
+
+def string_values(node):
+    if isinstance(node, dict):
+        for value in node.values():
+            yield from string_values(value)
+    elif isinstance(node, list):
+        for value in node:
+            yield from string_values(value)
+    elif isinstance(node, str):
+        yield node
+
+
+def check_pages(server: Server, index: Answer,
+                verdict: Verdict) -> tuple[dict, dict, str]:
+    """Step 5: `/`, `/snapshot.json` and `/capabilities`, whose RAW payload
+    is returned with it, for step 6's by-value check."""
+    label = server.label
+    page = index.body.decode("utf-8", "replace")
+    encoding = not_utf8_because(index.body,
+                                index.headers.get("content-type"))
+    verdict.check(f"{label}.http / is UTF-8", encoding is None,
+                  f"`/` may be decoded other than as UTF-8, as this harness "
+                  f"reads it: {encoding}")
+    verdict.check(f"{label}.http / is HTML",
+                  "<html" in page.lower()
+                  and media_type(index) == "text/html",
+                  f"`/` answered {shown_type(index)}, not text/html with an "
+                  "<html> element")
+    snapshot, _raw = fetch_object(server, "/snapshot.json", verdict)
+    documents = snapshot.get("documents")
+    verdict.check(f"{label}.snapshot non-empty",
+                  isinstance(documents, list) and bool(documents),
+                  f"the snapshot's documents are not a non-empty list: they "
+                  f"are {'an empty list' if documents == [] else 'a ' + type(documents).__name__} "
+                  "(not quoted)")
+    # EVERY DOCUMENT NAMES ITS PATH, or `requests_for` would skip its source
+    # reads and the run would pass on less than it claims (Copilot review of
+    # openDox-code#75 at 33841d4a, r4174621535).
+    pathless = [position for position, document
+                in enumerate(as_list(documents))
+                if not (isinstance(document, dict)
+                        and isinstance(document.get("path"), str)
+                        and document["path"])]
+    verdict.check(f"{label}.snapshot documents each name a path",
+                  not pathless,
+                  f"the snapshot's documents at {pathless[:10]} are not "
+                  "objects with a non-empty string `path`, so no source read "
+                  "can be asked for them")
+    leaks = sorted({m.group(1) for v in string_values(snapshot)
+                    for m in F53_PATTERN.finditer(v.lower())})
+    verdict.check(f"{label}.snapshot neutral (F5.3)", not leaks,
+                  f"openxFactory's vocabulary leaked into the neutral "
+                  f"snapshot: {leaks}")
+    verdict.note(f"the snapshot lists "
+                 f"{len(as_list(snapshot.get('documents')))} documents")
+    caps, caps_raw = fetch_object(server, "/capabilities", verdict)
+    # A token `/capabilities` publishes, under its name at any depth, is
+    # never printed either, though the check below fails on it (T104;
+    # Copilot review of openDox-code#75 at ec95f451, r4175016672).
+    for published in values_under_names(caps, CONSOLE_TOKEN_FIELD):
+        verdict.keep_secret(published)
+    install_block = as_object(caps.get("install"))
+    verdict.check(f"{label}.capabilities install.mode == local",
+                  install_block.get("mode") == "local",
+                  "the served install block reports no mode \"local\" (it "
+                  "is not quoted: /capabilities may carry the console "
+                  "token)")
+    pid = as_object(install_block.get("database_bundle")).get("pid")
+    if isinstance(pid, int):
+        verdict.note(f"the served install reports its bundled server as "
+                     f"pid {pid}")
+    check_no_published_token(label, caps, caps_raw, verdict)
+    return snapshot, caps, caps_raw
+
+
+def values_under_names(node, name: str):
+    """Every string under a key that contains `name`, at any depth."""
+    if isinstance(node, dict):
+        for key, value in node.items():
+            if name in key:
+                yield from string_values(value)
+            else:
+                yield from values_under_names(value, name)
+    elif isinstance(node, list):
+        for value in node:
+            yield from values_under_names(value, name)
+
+
+def keys_at_any_depth(node):
+    """Every key of every JSON object in `node`, however deep."""
+    if isinstance(node, dict):
+        for key, value in node.items():
+            yield key
+            yield from keys_at_any_depth(value)
+    elif isinstance(node, list):
+        for value in node:
+            yield from keys_at_any_depth(value)
+
+
+def check_no_published_token(label: str, caps: dict, caps_raw: str,
+                             verdict: Verdict) -> None:
+    """A standalone plane does not publish its console token on
+    `/capabilities` (plan 034 T104): any loopback caller, another OS user of
+    the machine included, can read that route. BY NAME, at any depth, as
+    quickstart.md § 3 asserts it (T007 batch N): `console_token` nowhere in
+    the RAW payload, and in no key of the parsed one, however deep or
+    however escaped."""
+    named = (CONSOLE_TOKEN_FIELD in caps_raw
+             or any(CONSOLE_TOKEN_FIELD in key
+                    for key in keys_at_any_depth(caps)))
+    verdict.check(f"{label}.capabilities carries no console token",
+                  not named,
+                  f"/capabilities publishes `{CONSOLE_TOKEN_FIELD}` to any "
+                  "loopback caller; a standalone plane delivers it only "
+                  "through the 0600 opener file (T104, adversarial review "
+                  "2's M5)")
+
+
+def check_no_token_value(label: str, caps: dict, caps_raw: str, token: str,
+                         verdict: Verdict) -> None:
+    """Step 6's by-value half of step 5's check (T007 batch N; quickstart.md
+    § 3): the token the opener delivers is nowhere in `/capabilities`' RAW
+    payload, nor in any key or string value of the parsed one, under
+    whatever name. Neither the token nor the payload is quoted."""
+    carried = (token in caps_raw
+               or any(token in text for text in string_values(caps))
+               or any(token in key for key in keys_at_any_depth(caps)))
+    verdict.check(f"{label}.capabilities carries the opener's token nowhere",
+                  not carried,
+                  "/capabilities carries the console token the opener "
+                  "delivers, under another name or inside a value, to any "
+                  "loopback caller (T104; T007 batch N)")
+
+
+def grouping_field_of(caps: dict) -> str:
+    fields = as_object(as_object(caps.get("display")).get("fields"))
+    field = as_object(fields.get("grouping")).get("field")
+    return field if isinstance(field, str) and field else "clusters"
+
+
+def check_grouping(label: str, snapshot: dict, caps: dict,
+                   verdict: Verdict) -> None:
+    """A grouping tile the chat pane can open on: an id and a member
+    document (Copilot review of openDox-code#75, at 32ef3e8c)."""
+    field = grouping_field_of(caps)
+    verdict.check(f"{label}.snapshot fills the grouping station",
+                  grouping_tile(snapshot, field) is not None,
+                  "the snapshot's grouping station (the field /capabilities "
+                  "names, not quoted, nor its value) holds no tile with an id "
+                  "and a member document, so no grouping tile can open the "
+                  "chat pane (R1Q13 (a) with (c); AT-R1 fails and does not "
+                  "skip)")
+
+
+# ---------------------------------------------------------------------------
+# Step 6: the console token, as the user's browser is handed it (T104).
+# ---------------------------------------------------------------------------
+
+class _RefreshContents(_LivePage):
+    """The `content` of every LIVE `<meta http-equiv="refresh">` in a page,
+    unescaped, and the text of every live JSON `<script>` whose id is the
+    console record's (`_LivePage`): `http-equiv` is `refresh` exactly
+    (ASCII case aside, and no whitespace trimmed)."""
+
+    WATCHED = frozenset({"meta", "script"})
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.contents: list[str | None] = []
+        self.records: list[str] = []
+        self._in_record = False
+
+    def live_tag(self, tag, named) -> None:
+        if tag == "script":
+            self._in_record = (
+                named.get("id") == CONSOLE_RECORD_ID
+                and ascii_lower(named.get("type", "").strip(_ASCII_WHITESPACE))
+                == "application/json")
+            if self._in_record:
+                self.records.append("")
+            return
+        equiv = named.get("http-equiv", "")
+        if tag == "meta" and ascii_lower(equiv) == "refresh":
+            # A named character reference with no `;` is decoded by
+            # `html.unescape` and, in an attribute, left as text by a browser
+            # where `=` or a letter or digit follows (`&ampconsole_token=`),
+            # so the two read different URLs: no URL is read from it.
+            raw = self.get_starttag_text() or ""
+            self.contents.append(None if _UNTERMINATED_REFERENCE.search(raw)
+                                 else named.get("content", ""))
+
+    def closed(self, tag) -> None:
+        if tag == "script":
+            self._in_record = False
+
+    def handle_data(self, data) -> None:
+        if self._in_record:
+            self.records[-1] += data
+
+
+def record_disagrees_because(records: list[str], port: int,
+                             target: str | None, token: str) -> str | None:
+    """Why the opener's record does not describe its own forward, or `None`.
+    No reason quotes the token."""
+    if len(records) != 1:
+        return (f"the opener holds {len(records)} `#{CONSOLE_RECORD_ID}` "
+                "JSON records, not one")
+    record = _json_or_none(records[0])
+    if not isinstance(record, dict):
+        return "the opener's record is not a JSON object"
+    version = record.get("schema_version")
+    problems = []
+    if record.get("kind") != CONSOLE_RECORD_KIND or not (
+            is_json_number(version)
+            and version == CONSOLE_RECORD_SCHEMA_VERSION):
+        problems.append(f"it is not {CONSOLE_RECORD_KIND!r} "
+                        f"v{CONSOLE_RECORD_SCHEMA_VERSION}")
+    if not (is_json_number(record.get("port")) and record.get("port") == port):
+        problems.append(f"its port is not {port}")
+    if record.get(CONSOLE_FRAGMENT_KEY) != token:
+        problems.append(f"its `{CONSOLE_FRAGMENT_KEY}` is not the token the "
+                        "forward carries")
+    if record.get("opened_url") != target:
+        problems.append("its `opened_url` is not the URL the forward opens")
+    page_url = record.get("page_url")
+    if not (isinstance(page_url, str) and isinstance(target, str)
+            and target.split("#", 1)[0] == page_url):
+        problems.append("its `page_url` is not the forward's page")
+    if not problems:
+        return None
+    # A record value may hold the token (a `kind` that is the token, say),
+    # and a reason reaches the CI log, so it never quotes it.
+    reason = "the opener's record disagrees with its forward: " + "; ".join(
+        problems)
+    return reason.replace(token, "<the console token>")
+
+
+_ASCII_WHITESPACE = " \t\n\f\r"
+
+
+def refresh_target(content: str | None) -> str | None:
+    """The URL a browser's refresh follows from `content`, or `None` where a
+    browser follows none: the HTML standard's "shared declarative refresh
+    steps", for the forms a refresh takes (`0;url=<target>`, `0; URL='…'`,
+    `0,url=…`, `.5;url=…`, `0;<target>`).
+
+    A browser ABORTS the refresh when the first non-whitespace code point is
+    neither an ASCII digit nor `.`, so `invalid;url=…` and `-1;url=…` open
+    nothing, and a user is left on the opener (Copilot review of
+    openDox-code#75 at 5636eb8d, r4173894317). A `content` with no URL part
+    refreshes the opener itself, which opens no console either."""
+    if content is None:          # unreadable alike (`_RefreshContents`)
+        return None
+    rest = content.lstrip(_ASCII_WHITESPACE)
+    digits = len(rest) - len(rest.lstrip("0123456789"))
+    if digits == 0 and not rest.startswith("."):
+        return None
+    rest = rest[digits:].lstrip("0123456789.")
+    rest = rest.lstrip(_ASCII_WHITESPACE)
+    if rest[:1] in (";", ","):
+        rest = rest[1:]
+    rest = rest.lstrip(_ASCII_WHITESPACE)
+    if rest[:3].lower() == "url":
+        after = rest[3:].lstrip(_ASCII_WHITESPACE)
+        if after.startswith("="):
+            rest = after[1:].lstrip(_ASCII_WHITESPACE)
+    if rest[:1] in ("'", '"'):
+        quote, rest = rest[0], rest[1:]
+        rest = rest.split(quote, 1)[0]
+    target = rest.strip(_ASCII_WHITESPACE)
+    return target or None
+
+
+def opener_location(printed: str) -> Path | None:
+    """The opener's path, from the start's `console <file URL>` line."""
+    match = CONSOLE_LINE.search(printed)
+    if match is None:
+        return None
+    where = match.group("where")
+    if not where.startswith("file:"):
+        return Path(where)
+    # An unparseable file URL is the product's output, so it is the named
+    # `console opener printed` failure, never a harness error (Copilot review
+    # of openDox-code#75 at d53a7378, r4173842805).
+    try:
+        parts = urllib.parse.urlsplit(where)
+    except ValueError:
+        return None
+    if parts.netloc not in ("", "localhost") or parts.query or parts.fragment:
+        return None
+    return Path(urllib.parse.unquote(parts.path))
+
+
+def _writable_by(mode: int) -> str:
+    return "every user" if mode & 0o002 else "its group"
+
+
+def directory_unsafe_because(info: os.stat_result, *, own: bool) -> str | None:
+    """Why one directory on a private file's path lets another user replace
+    what lies below it, or `None`. The rules T104's opener writer holds its
+    own tree to (`opendox.console_access._unsafe_because`, the bundle's,
+    copied), asked again here of what the run left: a directory of the
+    state tree (`own`) is a real directory, this user's, that no one else
+    can write; one above it is this user's or root's, and sticky where
+    others can write it."""
+    mode = info.st_mode
+    if stat.S_ISLNK(mode):
+        return "is a symbolic link"
+    if not stat.S_ISDIR(mode):
+        return "is not a directory"
+    if own:
+        if info.st_uid != os.getuid():
+            return f"is owned by uid {info.st_uid}, not by this user"
+        if mode & 0o022:
+            return (f"is writable by {_writable_by(mode)} "
+                    f"(mode {stat.S_IMODE(mode):o})")
+        return None
+    if info.st_uid not in (os.getuid(), 0):
+        return f"is owned by uid {info.st_uid}, neither this user nor root"
+    if mode & 0o022 and not mode & stat.S_ISVTX:
+        return (f"is writable by {_writable_by(mode)} and is not sticky "
+                f"(mode {stat.S_IMODE(mode):o})")
+    return None
+
+
+def tree_unsafe_because(state: Path) -> tuple[Path, str] | None:
+    """`(directory, why)` for the first directory on `state`'s path that
+    lets another user replace what lies below it, or `None`: `state` itself
+    by the state tree's rule, every directory above it, as written and as
+    resolved, by the rule for the directories above, and every symbolic link
+    on the way, which must be this user's or root's, as T104 holds its own
+    tree (Copilot review of openDox-code#75 at 4809b3d2, r4174671426)."""
+    try:
+        for component in (state, *state.parents):
+            info = os.lstat(component)
+            if stat.S_ISLNK(info.st_mode) and info.st_uid not in (os.getuid(),
+                                                                  0):
+                return component, (f"is a symbolic link owned by uid "
+                                   f"{info.st_uid}, neither this user nor "
+                                   "root, who could point it elsewhere")
+        reason = directory_unsafe_because(os.lstat(state), own=True)
+        if reason is not None:
+            return state, reason
+        resolved = Path(os.path.realpath(state))
+        for directory in dict.fromkeys([*state.parents, *resolved.parents]):
+            reason = directory_unsafe_because(os.stat(directory), own=False)
+            if reason is not None:
+                return directory, reason
+    except OSError as exc:
+        return state, (f"cannot be examined ({type(exc).__name__}: "
+                       f"{exc.strerror})")
+    return None
+
+
+def opener_unsafe_because(path: Path) -> tuple[Path, str] | None:
+    """`(where, why)` for the first reason `path` is not a private opener,
+    or `None`: this user's regular file, mode exactly 0600, with one link,
+    in this user's own directory, mode exactly 0700, under a
+    state directory and ancestors no other user can change. `where` is the
+    file or the directory at fault, and no reason quotes a path, so a
+    caller decides whether it may quote `where`."""
+    try:
+        info = os.lstat(path)
+        directory = os.lstat(path.parent)
+    except OSError as exc:
+        return path, f"cannot be examined ({type(exc).__name__}: {exc.strerror})"
+    uid = os.getuid()
+    mode = stat.S_IMODE(info.st_mode)
+    reason = None
+    if stat.S_ISLNK(info.st_mode):
+        reason = "is a symbolic link"
+    elif not stat.S_ISREG(info.st_mode):
+        reason = "is not a regular file"
+    elif info.st_uid != uid:
+        reason = f"is owned by uid {info.st_uid}, not by this user"
+    elif info.st_nlink != 1:
+        reason = f"has {info.st_nlink} hard links, not one"
+    elif mode != OPENER_MODE:
+        reason = f"has mode {mode:o}, not {OPENER_MODE:o}"
+    if reason is not None:
+        return path, reason
+    if not stat.S_ISDIR(directory.st_mode) or directory.st_uid != uid:
+        return path.parent, "is not this user's own directory"
+    if stat.S_IMODE(directory.st_mode) != OPENER_DIRECTORY_MODE:
+        return path.parent, (f"has mode {stat.S_IMODE(directory.st_mode):o}, "
+                             f"not {OPENER_DIRECTORY_MODE:o}, as quickstart.md "
+                             "§ 3 checks it")
+    return tree_unsafe_because(path.parent.parent)
+
+
+def _read_without_following(path: Path,
+                            limit: int = OPENER_READ_LIMIT) -> bytes:
+    """The file at `path`, opened without following a link and WITHOUT
+    BLOCKING, and read only if what opened is a regular file: a FIFO with no
+    writer would otherwise hang the harness before its verdict and its
+    cleanup (Copilot review of openDox-code#75 at 27479495, previously
+    missed). Read WHOLE, or refused: a file past `limit` bytes is an error,
+    never a truncated page whose checks would judge only its first part,
+    while a browser reads it all (Copilot review of openDox-code#75 at
+    82869769, r4177924060)."""
+    descriptor = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+    try:
+        if not stat.S_ISREG(os.fstat(descriptor).st_mode):
+            raise OSError(errno.EINVAL, "not a regular file")
+        chunks, size = [], 0
+        while size <= limit:
+            chunk = os.read(descriptor, limit + 1 - size)
+            if not chunk:
+                break
+            chunks.append(chunk)
+            size += len(chunk)
+    finally:
+        os.close(descriptor)
+    if size > limit:
+        raise OSError(errno.EFBIG, f"larger than the {limit} bytes this "
+                      "harness reads whole")
+    return b"".join(chunks)
+
+
+def _within(path: Path, root: Path) -> bool:
+    real = Path(os.path.realpath(path))
+    return real.is_relative_to(Path(os.path.realpath(root)))
+
+
+#: What a browser's URL parser reads differently from `urllib.parse`, so a
+#: forward carrying it is refused before it is parsed at all: a backslash,
+#: which a browser reads as `/` in an http URL (`http://evil\@127.0.0.1/`
+#: goes to `evil`), and whitespace and control characters, which a browser
+#: strips or rejects.
+_UNPARSED_ALIKE = re.compile(r"[\\\x00-\x20\x7f]")
+
+
+def served_loopback_hosts(port: int) -> tuple[str, ...]:
+    """The loopback hosts the launched plane answers on: `127.0.0.1` and
+    `::1` each where something listens on `port`, and `localhost`, which a
+    browser resolves to either, where one does."""
+    hosts = [host for host in ("127.0.0.1", "::1") if listening(host, port)]
+    return (*hosts, "localhost") if hosts else ()
+
+
+def token_in_fragment(targets: list[str | None], port: int,
+                      hosts: tuple[str, ...]) -> tuple[str | None, str]:
+    """The token the opener's one forward carries in its FRAGMENT, or `None`
+    and why not. No message here quotes a token, or any part of the URL,
+    which could hold one (Copilot review of openDox-code#75 at d53a7378,
+    r4173842794)."""
+    if len(targets) != 1 or targets[0] is None:
+        return None, (f"the opener has {len(targets)} meta-refresh forwards, "
+                      "not one a browser follows to a URL (a delay that "
+                      "does not start with a digit or `.` aborts it, and a "
+                      "named character reference with no `;` reads "
+                      "differently in a browser)")
+    answering = " and ".join(hosts) or "no host"
+    elsewhere = (f"the opener does not forward to this plane on loopback "
+                 f"port {port}, which answers on {answering} (its forward is "
+                 "not quoted, because it may hold the token)")
+    target = targets[0]
+    # A browser and `urllib.parse` must read the SAME destination, or the
+    # check below judges a URL the browser never opens (r4173842763).
+    if _UNPARSED_ALIKE.search(target):
+        return None, (f"{elsewhere}: it holds a backslash, whitespace or a "
+                      "control character, which a browser reads differently")
+    try:
+        parts = urllib.parse.urlsplit(target)
+        target_port = parts.port
+    except ValueError:      # a malformed authority or port (r4173842811)
+        return None, f"{elsewhere}: it is not a URL this harness can parse"
+    if parts.username is not None or parts.password is not None \
+            or "@" in parts.netloc:
+        return None, (f"{elsewhere}: it carries user information before its "
+                      "host")
+    # A loopback host the LAUNCHED plane answers on: a forward to `[::1]`
+    # reaches nothing where the plane listens on 127.0.0.1 alone (Copilot
+    # review of openDox-code#75 at 142d1352, previously missed).
+    if (parts.scheme != "http" or parts.hostname not in LOOPBACK_HOSTS
+            or parts.hostname not in hosts or target_port != port):
+        return None, elsewhere
+    # THE CONSOLE PAGE, and no other page of this plane: a forward to
+    # `/missing.html` or `/snapshot.json` opens no console, though every
+    # later check asks `/` and the catalog itself (Copilot review of
+    # openDox-code#75 at 486e426e, previously missed).
+    # (An empty path is `/` to a browser, as the URL standard reads it.)
+    if (parts.path or "/") not in CONSOLE_PAGES:
+        return None, (f"the opener's forward opens a page other than the "
+                      f"console ({' or '.join(CONSOLE_PAGES)}) of this plane "
+                      "(the path is not quoted, because it may hold the "
+                      "token)")
+    if CONSOLE_FRAGMENT_KEY in urllib.parse.parse_qs(parts.query,
+                                                     keep_blank_values=True):
+        return None, ("the opener's forward carries the token in its QUERY, "
+                      "which reaches the request line, the server's log and "
+                      "any Referer")
+    values = urllib.parse.parse_qs(parts.fragment, keep_blank_values=True).get(
+        CONSOLE_FRAGMENT_KEY, [])
+    if len(values) != 1 or not values[0]:
+        return None, (f"the opener's forward carries no single "
+                      f"`#{CONSOLE_FRAGMENT_KEY}=` in its fragment")
+    # THE TOKEN THE PAGE ACCEPTS, or the harness could authenticate where the
+    # user's page cannot: T104's `takeDeliveredConsoleToken`
+    # (`web/views/notebook.js`) discards any other value (Copilot review of
+    # openDox-code#75 at 5636eb8d, r4173894352).
+    if not CONSOLE_TOKEN_SHAPE.fullmatch(values[0]):
+        return None, ("the opener's forward carries a token the page "
+                      "discards: `takeDeliveredConsoleToken` accepts only "
+                      f"{CONSOLE_TOKEN_SHAPE.pattern} (the value is not "
+                      "quoted)")
+    # Decoded too, as often as it decodes: a percent-encoded copy in the path
+    # or the query still reaches the request line and the server's log, and
+    # is recovered from them (Copilot review of openDox-code#75 at 142d1352,
+    # r4174355680).
+    if any(values[0] in form for part in (parts.path, parts.query)
+           for form in _decodings(part)):
+        return None, ("the opener's forward carries the token outside its "
+                      "fragment too, perhaps percent-encoded (the copy is "
+                      "not quoted)")
+    return values[0], ""
+
+
+def opener_unread_because(page: bytes,
+                          contents: "_RefreshContents") -> str | None:
+    """Why this harness cannot read the opener as the user's browser reads
+    it, or `None`: an encoding other than UTF-8, or markup it does not model
+    (`_LivePage.unmodeled`). Either is a named failure of the forward check,
+    never a reading by approximation (the self-pass after Copilot's review
+    of openDox-code#75 at 4bdb41fb)."""
+    encoding = not_utf8_because(page, None)
+    if encoding:
+        return (f"the opener may be decoded other than as UTF-8, as this "
+                f"harness reads it: {encoding}")
+    if contents.unmodeled:
+        return (f"the opener holds "
+                f"{', '.join(sorted(set(contents.unmodeled)))}, whose "
+                "parsing this harness does not model, so it cannot tell "
+                "which refresh a browser follows")
+    return None
+
+
+def _json_or_none(text: str):
+    """`text` parsed as JSON, or `None` where it is not JSON or nests past
+    the parser's depth, which is the product's output and so a named
+    failure, never a harness error."""
+    try:
+        return strict_json(text)
+    except (ValueError, RecursionError):
+        return None
+
+
+def carried_tokens(targets: list[str | None], records: list[str]) -> list[str]:
+    """Every value the opener carries under `console_token`: in any
+    forward's fragment or query, or in any of its records, delivered or
+    refused. Each may be this plane's token, so `Verdict.keep_secret` keeps
+    them all out of every line the harness prints."""
+    found: list[str] = []
+    for target in filter(None, targets):
+        try:
+            parts = urllib.parse.urlsplit(target)
+        except ValueError:
+            continue
+        for part in (parts.fragment, parts.query):
+            found += urllib.parse.parse_qs(part, keep_blank_values=True).get(
+                CONSOLE_FRAGMENT_KEY, [])
+    for text in records:
+        value = as_object(_json_or_none(text)).get(CONSOLE_FRAGMENT_KEY)
+        if isinstance(value, str):
+            found.append(value)
+    return found
+
+
+def _decodings(text: str, rounds: int = 5) -> set[str]:
+    """`text` and every percent-decoding of it (with `+` read as a space, and
+    not), repeated until nothing new appears, at most `rounds` deep."""
+    forms, frontier = {text}, [text]
+    for _ in range(rounds):
+        frontier = [decoded for form in frontier
+                    for decoded in (urllib.parse.unquote(form),
+                                    urllib.parse.unquote_plus(form))
+                    if decoded not in forms]
+        if not frontier:
+            break
+        forms.update(frontier)
+    return forms
+
+
+def check_console_opener(label: str, port: int, printed: str, state_dir: Path,
+                         served_root: Path, verdict: Verdict, *,
+                         hosts: tuple[str, ...],
+                         forward: list[str] | None = None,
+                         ) -> tuple[Path | None, str | None]:
+    """Step 6: the opener the start printed, and the token its forward
+    carries, read from the file as the user's browser reads it. Where the
+    forward is the one a browser follows to this plane's console page, it
+    is appended to `forward`, for `check_console_page`."""
+    path = opener_location(printed)
+    verdict.check(f"{label}.console opener printed", path is not None,
+                  "the start printed no `console <file URL>` line naming the "
+                  "opener, so a user has no way to open the console page")
+    if path is None:
+        return None, None
+    expected = state_dir / CONSOLE_DIRNAME / f"{port}.html"
+    here = path == expected
+    verdict.check(f"{label}.console opener is OPENDOX_STATE_DIR/console/<port>.html",
+                  here, f"the start printed another path, not {expected} (the "
+                  "printed path is not quoted here or below: it is the entry "
+                  "point's output, which may hold the console token)")
+
+    def shown(where: Path) -> str:
+        # The printed path is the entry point's output, so it is quoted, and
+        # so is a directory on it, only where it is the path this run made
+        # (Copilot review of openDox-code#75 at 33841d4a, r4174621486).
+        if here:
+            return str(where)
+        return ("the printed opener" if where == path
+                else "a directory on the printed opener's path")
+
+    verdict.check(f"{label}.console opener is outside the served repository",
+                  not _within(path, served_root),
+                  f"{shown(path)} is inside the served repository "
+                  f"{served_root}")
+    unsafe = opener_unsafe_because(path)
+    verdict.check(f"{label}.console opener is private", unsafe is None,
+                  f"{shown(unsafe[0])} {unsafe[1]}" if unsafe else "")
+    try:
+        page = _read_without_following(path)
+    except OSError as exc:
+        verdict.check(f"{label}.console opener forwards with the token in its "
+                      "fragment", False,
+                      f"{shown(path)} cannot be read ({type(exc).__name__}: "
+                      f"{exc.strerror})")
+        return path, None
+    contents = _RefreshContents()
+    contents.feed(page.decode("utf-8", "replace"))
+    contents.close()
+    targets = [refresh_target(content) for content in contents.contents]
+    # Every token the opener carries, delivered or refused, is never printed
+    # from here on, whatever answer or path later echoes it.
+    for carried in carried_tokens(targets, contents.records):
+        verdict.keep_secret(carried)
+    unread = opener_unread_because(page, contents)
+    token, why = ((None, unread) if unread
+                  else token_in_fragment(targets, port, hosts))
+    verdict.check(f"{label}.console opener forwards with the token in its "
+                  "fragment", token is not None, why)
+    if token is not None:
+        disagrees = record_disagrees_because(contents.records, port,
+                                             targets[0], token)
+        verdict.check(f"{label}.console opener record agrees with its forward",
+                      disagrees is None, disagrees or "")
+    if token is not None and forward is not None:
+        forward.append(targets[0])
+    return path, token
+
+
+def console_page_of(target: str) -> tuple[str, str]:
+    """`(host, page)` of a forward `token_in_fragment` has validated: its
+    loopback host, and its path and query without the fragment, as a
+    browser requests it."""
+    parts = urllib.parse.urlsplit(target)
+    return (parts.hostname or "127.0.0.1",
+            (parts.path or "/") + (f"?{parts.query}" if parts.query else ""))
+
+
+def check_console_page(server: Server, target: str,
+                       verdict: Verdict) -> tuple[Answer, str, str]:
+    """Step 6's PAGE: the one the opener's forward opens, asked as the
+    browser asks it, of the forward's own host with its path and query.
+    It must answer 200 as HTML, and be UTF-8; its module graph and the
+    routes are then read from it, at its origin, never from `/` in its
+    place (Copilot review of openDox-code#75 at 3392f934, r4179115311).
+    Returns `(answer, host, page)`. The query is not quoted: it is the
+    product's output."""
+    label = server.label
+    host, page = console_page_of(target)
+    shown = f"{urllib.parse.urlsplit(target).path or '/'} on {host}"
+    answer = get(server.port, page, host=host)
+    body = answer.body.decode("utf-8", "replace")
+    verdict.check(f"{label}.console page is HTML",
+                  answer.status == 200 and media_type(answer) == "text/html"
+                  and "<html" in body.lower(),
+                  f"the page the opener forwards to, {shown}, answers "
+                  f"{answer.describe()} as {shown_type(answer)}, not "
+                  "text/html with an <html> element, so the user's browser "
+                  "opens no console there")
+    encoding = not_utf8_because(answer.body,
+                                answer.headers.get("content-type"))
+    verdict.check(f"{label}.console page is UTF-8", encoding is None,
+                  f"the page the opener forwards to, {shown}, may be decoded "
+                  f"other than as UTF-8, as this harness reads it: {encoding}")
+    return answer, host, page
+
+
+def check_catalog(server: Server, token: str | None, verdict: Verdict, *,
+                  host: str = "127.0.0.1") -> None:
+    """Step 7: the catalog, asked as the console, offers nothing available,
+    and asked without the token, refuses."""
+    label = server.label
+    bare = get(server.port, CATALOG_ROUTE, host=host)
+    verdict.check(f"{label}.catalog refuses a caller without the console token",
+                  bare.status is not None and 400 <= bare.status < 500,
+                  f"{CATALOG_ROUTE} without the token answers "
+                  f"{bare.describe()}, so the token the opener carries would "
+                  "guard nothing")
+    catalog = get(server.port, CATALOG_ROUTE, token=token, host=host)
+    asked = ("with the console token" if token else
+             "with no console token to present (step 6 found none)")
+    # No reason here quotes the catalog's body: it answers a request that
+    # carries the token, so it may echo it, escaped in ways no literal
+    # redaction finds (Copilot review of openDox-code#75 at 82869769,
+    # r4177924097).
+    verdict.check(f"{label}.catalog answers", catalog.status == 200,
+                  f"{CATALOG_ROUTE} {asked} answers "
+                  f"{catalog.describe()} (its body is not quoted)")
+    if catalog.status != 200:
+        return
+    # The payload's SHAPE is a named check, never a harness error: `[]`,
+    # `null` or `{"models": 1}` fail `catalog is a catalog` (Copilot review
+    # of openDox-code#75, r4170450491).
+    try:
+        payload = catalog.json()
+        shape = (f"its `models` is a {type(payload['models']).__name__}"
+                 if isinstance(payload, dict) and "models" in payload else
+                 f"it is JSON, a {type(payload).__name__}")
+    except ValueError:
+        payload, shape = None, "it is not JSON"
+    models = as_object(payload).get("models")
+    verdict.check(f"{label}.catalog is a catalog", isinstance(models, list),
+                  f"{CATALOG_ROUTE} answered no models[]: {shape} (its body "
+                  "is not quoted)")
+    # THE ENVELOPE THE RAIL ADOPTS, or it shows "the catalog could not be
+    # read" and never its no-model state (Copilot review of
+    # openDox-code#75, at f0e0ffe1). JavaScript's `=== 1` admits no `true`
+    # and no `"1"`, so neither does this. It admits every JSON NUMBER equal to
+    # 1, though: `1.0` and `1e0` parse to the same JavaScript number, and
+    # Python reads them as the float 1.0 (Copilot review of #75 at 1c0ff975,
+    # r4173473346).
+    envelope = as_object(payload)
+    version = envelope.get("schema_version")
+    # No reason quotes a value the catalog sent: a token in it, percent- or
+    # otherwise encoded, would pass any literal redaction (Copilot review of
+    # openDox-code#75 at ba216f84, r4178913911).
+    version_ok = (is_json_number(version)
+                  and version == CATALOG_SCHEMA_VERSION)
+    kind_ok = envelope.get("kind") == CATALOG_KIND
+    wrong = [part for part, ok in (("schema_version", version_ok),
+                                   ("kind", kind_ok)) if not ok]
+    verdict.check(f"{label}.catalog envelope is the one the chat rail adopts",
+                  not wrong,
+                  f"the catalog's {' and '.join(wrong)} is not what the chat "
+                  f"rail adopts (schema_version={CATALOG_SCHEMA_VERSION}, "
+                  f"kind={CATALOG_KIND!r}); the values it sent are not "
+                  "quoted")
+    # As the rail reads it: `m.available === true`, and nothing else
+    # (`views/doxbench-chat-model.js`).
+    available = [as_object(m).get("model_id") for m in as_list(models)
+                 if as_object(m).get("available") is True]
+    verdict.check(f"{label}.catalog offers no available entry", not available,
+                  f"no model is configured, yet the catalog offers "
+                  f"{len(available)} available entr"
+                  f"{'y' if len(available) == 1 else 'ies'} (the ids are not "
+                  "quoted)")
+
+
+def grouping_tile(snapshot: dict,
+                  grouping_field: str) -> tuple[str, str] | None:
+    """`(tile id, member document)` for the first grouping tile that has a
+    member document: the tile the chat pane opens from."""
+    for group in map(as_object, as_list(snapshot.get(grouping_field))):
+        if not group.get("id"):
+            continue
+        members = [edge.get("document") for edge in
+                   map(as_object, as_list(group.get("document_edges")))
+                   if edge.get("document")]
+        if members:
+            return str(group["id"]), str(members[0])
+    return None
+
+
+def requests_for(routes: list[str], snapshot: dict) -> list[str]:
+    """Every route literal, and every `/`-ended one completed with each
+    document the snapshot lists. No thread read is completed with a query:
+    a standalone plane's rail sends none (`check_no_thread_read`)."""
+    documents = [urllib.parse.quote(scalar_values(str(d["path"])))
+                 for d in map(as_object, as_list(snapshot.get("documents")))
+                 if d.get("path")]
+    key = urllib.parse.quote(
+        scalar_values(f"{snapshot.get('repository') or ''}@main"), safe="")
+    targets: list[str] = []
+    for route in routes:
+        targets.append(route)
+        if route.endswith("/"):
+            targets += [route + doc for doc in documents]
+            targets += [f"{route}{key}/{doc}" for doc in documents]
+    return targets
+
+
+def session_bindings(caps: dict) -> list[dict]:
+    """The contributed view bindings `/capabilities` declares under the
+    branch-session column's id, as the shell's `resolveView` finds them."""
+    views = as_list(as_object(caps.get("views")).get("views"))
+    return [view for view in map(as_object, views)
+            if view.get("id") == SESSION_BINDING_ID]
+
+
+def check_no_thread_read(label: str, caps: dict, verdict: Verdict) -> None:
+    """The chat rail reads a thread only through a branch-session column
+    (openDox-code#85; holder ruling F1 (i)), and a standalone plane
+    contributes none, so its rail sends no thread read and this harness asks
+    none. A binding whose `requires` would leave it unresolved still counts
+    here: the check fails closed."""
+    verdict.check(f"{label}.chat rail reads no thread (no branch session)",
+                  not session_bindings(caps),
+                  f"/capabilities contributes `{SESSION_BINDING_ID}`, so the "
+                  f"chat rail reads {THREAD_ROUTE} on every switch of its "
+                  "document; a standalone plane has no branch session, and "
+                  "answers each such read 403 with a console error "
+                  "(openDox-code#85, the T102 follow-on)")
+
+
+def check_routes(server: Server, index: Answer, snapshot: dict, caps: dict,
+                 token: str | None, verdict: Verdict, *,
+                 host: str = "127.0.0.1", page: str = "/") -> None:
+    """Step 8: every route the served bundle names answers, below 5xx. The
+    bundle is the one `index` loads, the page at `page` on `host` (the one
+    the opener opens), and every request goes to that origin."""
+    label = server.label
+    literals: set[str] = set()
+    routes, modules = derive_bundle(server.port,
+                                    index.body.decode("utf-8", "replace"),
+                                    caps, verdict, label, literals,
+                                    host=host, page=page)
+    verdict.note(f"derived from the served bundle: {modules} modules, "
+                 f"{len(routes)} routes: {', '.join(routes)}")
+    verdict.check(f"{label}.bundle names the catalog route",
+                  CATALOG_ROUTE in routes,
+                  f"the served bundle no longer names {CATALOG_ROUTE}, so "
+                  "this harness's catalog step asks the wrong route")
+    verdict.check(f"{label}.bundle names the catalog kind",
+                  CATALOG_KIND in literals,
+                  f"the served bundle no longer names {CATALOG_KIND!r}, so "
+                  "this harness's catalog envelope check is stale")
+    check_no_thread_read(label, caps, verdict)
+    for target in requests_for(routes, snapshot):
+        answer = get(server.port, target, token=token, host=host)
+        verdict.note(f"GET {target} -> {answer.describe()}")
+        dropped = ("; a dropped connection is a handler that raised"
+                   if answer.status is None
+                   and not (answer.error or "").endswith(REDIRECTED) else "")
+        verdict.check(f"{label}.route {target}",
+                      answer.status is not None and answer.status < 500,
+                      f"GET {target} answers {answer.describe()}{dropped}"
+                      + server.said())
+
+
+def stop_and_look(server: Server, ctx: Context, verdict: Verdict,
+                  opener: Path | None = None, token: str | None = None) -> None:
+    """Step 9: stop the entry point alone, as `kill` would, and look."""
+    label = server.label
+    server.proc.send_signal(signal.SIGTERM)
+    try:
+        rc = server.proc.wait(timeout=STOP_TIMEOUT_SECONDS)
+    except subprocess.TimeoutExpired:
+        rc = None
+    # EXIT STATUS 0, as `tests_runtime/test_bundled_postgres.py` requires of
+    # the same stop: a server that fails its own shutdown has not stopped
+    # cleanly, whatever it removed first (Copilot review of openDox-code#75
+    # at 142d1352, previously missed).
+    verdict.check(f"{label}.stop exits 0", rc == 0,
+                  f"the server did not exit within {STOP_TIMEOUT_SECONDS:.0f}s "
+                  "of SIGTERM" if rc is None else
+                  f"the server exited rc={rc} after SIGTERM, not 0")
+    verdict.note(f"the entry point exited rc={rc}")
+    left = bundled_server_processes(ctx.server_package, ctx.state_dir)
+    verdict.check(f"{label}.stop leaves no bundled PostgreSQL process",
+                  not left,
+                  "still running after the entry point stopped: "
+                  + "; ".join(f"pid {pid}: {what}" for pid, what in left))
+    # Over the WHOLE serve's output, its shutdown included.
+    check_console_gone(label, opener, token, server.printed(), verdict)
+
+
+def check_console_gone(label: str, opener: Path | None, token: str | None,
+                       printed: str, verdict: Verdict) -> None:
+    """After the stop: the opener went with the server, and the token was
+    never printed, in either stream."""
+    if opener is not None:
+        verdict.check(f"{label}.stop removes the console opener",
+                      not os.path.lexists(opener),
+                      "the opener the start printed is still there after the "
+                      "server stopped, and its token was this serve's")
+    if token is not None:
+        verdict.check(f"{label}.console token never printed",
+                      token not in printed,
+                      "the entry point printed the console token itself; "
+                      "it prints only the opener's path")
+
+
+def learn_opener_tokens(printed: str, verdict: Verdict) -> None:
+    """Every token the opener carries, kept out of every line BEFORE step 5
+    quotes anything a route answered, so a payload that carries the token
+    under any name prints none of it (Copilot review of openDox-code#75 at
+    ec95f451, r4175016672). It only reads the opener, as step 6 reads it,
+    and judges nothing: step 6 does, in its place. The entry point writes
+    the opener before it serves (`console_access.publish`), so it is there
+    once `/` has answered."""
+    path = opener_location(printed)
+    if path is None:
+        return
+    try:
+        page = _read_without_following(path)
+    except OSError:
+        return
+    contents = _RefreshContents()
+    contents.feed(page.decode("utf-8", "replace"))
+    contents.close()
+    targets = [refresh_target(content) for content in contents.contents]
+    for carried in carried_tokens(targets, contents.records):
+        verdict.keep_secret(carried)
+
+
+def serve_one(label: str, repo: Path, ctx: Context, verdict: Verdict) -> None:
+    """Steps 4-9 for one repository: start, fetch, stop, and look."""
+    server, index = launch(label, repo, ctx, verdict)
+    learn_opener_tokens(server.printed(), verdict)
+    snapshot, caps, caps_raw = check_pages(server, index, verdict)
+    check_grouping(label, snapshot, caps, verdict)
+    forward: list[str] = []
+    opener, token = check_console_opener(
+        label, server.port, server.printed(), ctx.state_dir, repo, verdict,
+        hosts=served_loopback_hosts(server.port), forward=forward)
+    # The page the user's browser opens is the forward's, not `/`: the
+    # catalog, the module graph and the routes are read from it, at its
+    # origin. With no forward to follow (a failure already named), `/`.
+    console, host, page = index, "127.0.0.1", "/"
+    if forward:
+        console, host, page = check_console_page(server, forward[0], verdict)
+    if token is not None:
+        check_no_token_value(label, caps, caps_raw, token, verdict)
+    check_catalog(server, token, verdict, host=host)
+    check_routes(server, console, snapshot, caps, token, verdict, host=host,
+                 page=page)
+    stop_and_look(server, ctx, verdict, opener, token)
+
+
+# ---------------------------------------------------------------------------
+# The run.
+# ---------------------------------------------------------------------------
+
+def prepare() -> Context:
+    """The run's directories and its children's base environment, or a
+    HarnessError before anything is installed."""
+    if not Path("/proc/self/exe").exists():
+        raise HarnessError("this harness reads /proc; run it on Linux")
+    git = shutil.which("git")
+    if git is None:
+        raise HarnessError("git is not on the PATH")
+    scratch = Path(tempfile.mkdtemp(prefix="at-r1-http-")).resolve()
+    state_dir = Path(tempfile.mkdtemp(prefix="odx-")).resolve()
+    socket_path = len(os.fsencode(state_dir)) + len(SOCKET_SUFFIX)
+    if socket_path > SOCKET_PATH_MAX:
+        shutil.rmtree(scratch, ignore_errors=True)
+        shutil.rmtree(state_dir, ignore_errors=True)
+        raise HarnessError(
+            f"OPENDOX_STATE_DIR {state_dir} would put the bundled server's "
+            f"socket at {socket_path} bytes, past {SOCKET_PATH_MAX}; set "
+            "TMPDIR to a shorter directory")
+    # THE STATE TREE STARTS PRIVATE, so step 6's verdict on it judges what
+    # the product made of it, never where TMPDIR happened to point.
+    unsafe = tree_unsafe_because(state_dir)
+    if unsafe is not None:
+        shutil.rmtree(scratch, ignore_errors=True)
+        shutil.rmtree(state_dir, ignore_errors=True)
+        raise HarnessError(
+            f"{unsafe[0]} {unsafe[1]}, so another user could replace the "
+            f"console opener under OPENDOX_STATE_DIR {state_dir}; set TMPDIR "
+            "to a directory only you can change")
+    base_env, dropped = stripped_environment(dict(os.environ))
+    if dropped:
+        note(f"not inherited by any child: {', '.join(dropped)}")
+    for name in ("home", "tmp"):
+        (scratch / name).mkdir()
+    base_env.update(HOME=str(scratch / "home"), TMPDIR=str(scratch / "tmp"))
+    return Context(checkout=Path(__file__).resolve().parents[1],
+                   scratch=scratch, state_dir=state_dir, git=git,
+                   base_env=base_env)
+
+
+def cleanup(ctx: Context, keep: bool) -> None:
+    """However the run ended: stop what it started, then remove what it
+    made. A leftover bundled server is killed only here, after the verdict
+    on it has been taken."""
+    for proc in ctx.servers:
+        if proc.poll() is not None:
+            continue
+        try:
+            os.killpg(proc.pid, signal.SIGTERM)
+            proc.wait(timeout=STOP_TIMEOUT_SECONDS)
+        except (ProcessLookupError, subprocess.TimeoutExpired):
+            try:
+                os.killpg(proc.pid, signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+    stop_processes([pid for pid, _ in
+                    bundled_server_processes(ctx.server_package, ctx.state_dir)])
+    if keep:
+        note(f"kept {ctx.scratch} and {ctx.state_dir}")
+        return
+    shutil.rmtree(ctx.scratch, ignore_errors=True)
+    shutil.rmtree(ctx.state_dir, ignore_errors=True)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="AT-R1's HTTP half (plan 034 T095): install the openDox "
+                    "checkout this file is in, alone, assert a clean machine, "
+                    "run the documented command over two plain repositories, "
+                    "and check what it serves. TMPDIR chooses where its "
+                    "scratch and state directories go.")
+    parser.add_argument("--keep", action="store_true",
+                        help="keep the scratch and state directories")
+    parser.add_argument("--keep-going", action="store_true",
+                        help="report every failed assertion instead of "
+                             "stopping at the first (still exits 1)")
+    args = parser.parse_args(argv)
+    # Anything that stops the preparation is the harness's own failure, never
+    # a verdict on the product: a refusal it names, or an error it did not
+    # expect (a full disk under `tempfile.mkdtemp`, for one), and both exit 2
+    # (Copilot review of openDox-code#75, at b4fc637f).
+    try:
+        ctx = prepare()
+    except HarnessError as error:
+        print(f"AT-R1 HTTP half: ERROR: {error}", file=sys.stderr)
+        return 2
+    except Exception:
+        traceback.print_exc()
+        print("AT-R1 HTTP half: ERROR: the harness could not prepare its "
+              "directories", file=sys.stderr)
+        return 2
+    verdict = Verdict(args.keep_going)
+    print(f"AT-R1, the HTTP half (plan 034 T095), over {ctx.checkout}")
+    print(f"      the documented install: {DOCUMENTED_INSTALL}")
+    print(f"      the documented start:   {DOCUMENTED_START}")
+    print(f"      scratch {ctx.scratch}; OPENDOX_STATE_DIR {ctx.state_dir}",
+          flush=True)
+    error = None
+    try:
+        about = install_opendox(ctx, verdict)
+        assert_clean_machine(ctx, about, verdict)
+        for label, repo in make_repositories(ctx, about, verdict):
+            print(f"--- repository ({label}) {repo.name}", flush=True)
+            serve_one(label, repo, ctx, verdict)
+    except Failed as failure:
+        # A fail-fast stop, or a `require` that ended a `--keep-going` run;
+        # reported with the rest, after the cleanup below.
+        verdict.record(failure)
+    except HarnessError as exc:
+        error = str(exc)
+    except Exception:  # the harness itself broke: say so, never a PASS
+        print(verdict.redact(traceback.format_exc()), end="",
+              file=sys.stderr, flush=True)
+        error = "the harness raised before a verdict"
+    finally:
+        cleanup(ctx, args.keep)
+    if error is not None:
+        print("\nAT-R1 HTTP half: ERROR: " + printable(verdict.redact(error)),
+              flush=True)
+        return 2
+    return verdict.report()
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tests/test_at_r1_http_harness.py b/tests/test_at_r1_http_harness.py
new file mode 100644
index 00000000..af36a1dd
--- /dev/null
+++ b/tests/test_at_r1_http_harness.py
@@ -0,0 +1,3075 @@
+"""AT-R1's HTTP harness, its DECISIONS tested in process (plan 034 T095).
+
+`acceptance/at_r1_http.py` is not a member of this suite: it installs the
+product into a fresh venv and drives it from outside, in its own `acceptance`
+job, and `testpaths` never collects it. That is right for the harness, and it
+left its verdict logic with no collected test. On this branch the acceptance
+job stops at the missing `local` extra, before the module-graph walk ever
+runs (Copilot review of openDox-code#75 at b440d12b, "previously missed").
+
+So the decisions are tested here, as `tests/test_smoke_signals.py` tests the
+browser half's oracle without a browser. The harness module is loaded from
+its file, and an in-process server on loopback (the pattern
+`test_model_provider_broker.py` uses) stands in for the product, so nothing
+is installed or started:
+
+  * the lexer finds a module's strings, and not the ones inside a comment or
+    a regular expression;
+  * an import specifier is told from a route literal, and a route is resolved
+    against the page;
+  * the module graph terminates on an import cycle and counts each module once;
+  * a module refused as a DYNAMIC import is still judged where another module
+    imports it STATICALLY (Copilot review of #75 at 1c064bb3, r4170450448);
+  * a module the server serves must be served as JavaScript, and a linked
+    stylesheet as `text/css`, a `charset` parameter aside (Copilot review of
+    #75 at f29b4ddd, r4173769822 and r4173769844);
+  * a malformed 200 catalog is a named failure, never an exception
+    (r4170450491), and so is a catalog whose envelope the chat rail would
+    not adopt (Copilot review of #75 at f0e0ffe1), and so is a catalog that
+    answers a caller without the console token;
+  * the console token is read as a standalone plane delivers it (plan 034
+    T104; RULED openxFactory#656 `5963851934`): never from `/capabilities`,
+    and only from the 0600 opener file the start names, whose meta-refresh
+    carries it in the URL's FRAGMENT. Every way that delivery can be wrong
+    is a named failure: no opener named, one somewhere else, one inside the
+    served repository, one another user could read or replace, a token in
+    the query, a forward to another plane, an opener left after the stop,
+    and a token printed;
+  * only a LIVE refresh forwards, as a browser that runs scripts parses the
+    page: none inside a `<template>`, a `<noscript>` or a raw-text element,
+    the first of a repeated attribute, `http-equiv` read exactly (Copilot
+    review of #75 at 4809b3d2, r4174671390);
+  * the opener's whole path is judged as T104 holds its own tree: the state
+    directory is this user's and no one else can write it, and every
+    directory above it is this user's or root's, sticky where others can
+    write it; the harness refuses a TMPDIR that is not (r4174671426);
+  * no line the harness prints quotes a console token, from the opener, its
+    record or `/capabilities`, or the entry point's output (r4174621486,
+    carried to every diagnostic), or a `/capabilities` payload (r4175016672);
+    a payload nested past the JSON parser's depth is a named failure
+    (r4175016692);
+  * the raw `/capabilities` payload carries the token neither by name, at
+    any depth, nor by value (T007 batch N);
+  * the chat rail's thread read is never asked with a query, as a standalone
+    plane's rail sends none, and the plane must contribute no branch-session
+    column (openDox-code#85, the T102 follow-on);
+  * the opener is read whole or refused, never judged by a truncated prefix
+    (Copilot review of #75 at 82869769, r4177924060); no reason quotes the
+    server's own bytes: a catalog body, a peer's error text, a `Content-Type`
+    that is no plain MIME type (r4177924097); and the module graph resolves
+    against the running server's origin, so an absolute same-origin URL is a
+    path of this plane (r4177924129).
+"""
+
+from __future__ import annotations
+
+import collections
+import contextlib
+import http.server
+import importlib.util
+import json
+import os
+import sys
+import threading
+import types
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+HARNESS = ROOT / "acceptance" / "at_r1_http.py"
+
+
+def _load_harness():
+    spec = importlib.util.spec_from_file_location("at_r1_http_harness", HARNESS)
+    module = importlib.util.module_from_spec(spec)
+    # `dataclasses` resolves a class's module through `sys.modules`.
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+harness = _load_harness()
+
+
+@contextlib.contextmanager
+def served(files: dict[str, tuple[str, str]], guarded: frozenset = frozenset(),
+           seen: list | None = None):
+    """A loopback server answering `files` (`path -> (content type, body)`,
+    or `(content type, body, status)`, where a tuple of content types sends
+    the header once for each), and 404 for anything else. A path in
+    `guarded` answers 403 to a request without the console header, as the
+    product's console check does. Each request's `(path, Host)` is added to
+    `seen` where one is given. Yields its port."""
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802
+            if seen is not None:
+                seen.append((self.path, self.headers.get("Host")))
+            entry = files.get(self.path)
+            if self.path in guarded and not self.headers.get(
+                    harness.CONSOLE_TOKEN_HEADER):
+                self.send_response(403)
+                self.send_header("Content-Length", "0")
+                self.end_headers()
+                return
+            if entry is None:
+                self.send_response(404)
+                self.send_header("Content-Length", "0")
+                self.end_headers()
+                return
+            body = entry[1].encode("utf-8")
+            self.send_response(entry[2] if len(entry) > 2 else 200)
+            for value in ((entry[0],) if isinstance(entry[0], str)
+                          else entry[0]):
+                if value:
+                    self.send_header("Content-Type", value)
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def log_message(self, *args):
+            pass
+
+    server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield server.server_address[1]
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)
+
+
+def _page(*modules: str) -> str:
+    scripts = "".join(f'<script type="module" src="{m}"></script>'
+                      for m in modules)
+    return f"<html><head>{scripts}</head></html>"
+
+
+JS = "text/javascript"
+
+
+def _failures(verdict) -> list[str]:
+    return [failure.ident for failure in verdict.failures]
+
+
+def test_the_lexer_skips_comments_and_regular_expressions() -> None:
+    source = (
+        '// const A = "/in-a-line-comment";\n'
+        '/* const B = "/in-a-block-comment"; */\n'
+        "const quote = /[\"']/g;\n"
+        'const C = "/a-real-route";\n'
+        "const D = `/source/${key}/${path}`;\n"
+        "const E = 'single';\n"
+    )
+    values = [value for _quote, value, _before in
+              harness.JsStrings(source).scan()]
+    assert values == ["/a-real-route", "/source/", "single"], values
+
+
+@pytest.mark.parametrize("source, value", [
+    (r'"a\tb"', "a\tb"),
+    (r'"\x41"', "A"),
+    (r'"B"', "B"),
+    (r'"\u{43}"', "C"),
+    (r'"\u{1F600}"', "\U0001F600"),
+    ('"line\\\ncontinued"', "linecontinued"),
+    (r'"back\\slash"', "back\\slash"),
+    (r'"\d\/"', "d/"),
+    (r'"\0"', "\0"),
+    (r'`./child.js`', "./child.js"),
+    (r'"\uD83D\uDE00"', "\U0001F600"),
+    (r'"\uD83D"', "\ufffd"),
+    (r'"\uDE00\uD83D"', "\ufffd\ufffd"),
+    (r'"\u{0000000041}"', "A"),
+], ids=["tab", "hex", "unicode", "code-point", "astral", "continuation",
+        "backslash", "identity", "nul", "template", "surrogate-pair",
+        "lone-surrogate", "reversed-surrogates", "long-code-point"])
+def test_the_lexer_reads_escapes_as_javascript_does(source: str,
+                                                   value: str) -> None:
+    """A specifier is read as the browser reads it (found while answering
+    Copilot's review of #75 at 2dcb98d3, r4178069374)."""
+    values = [found for _quote, found, _before in
+              harness.JsStrings(f"const s = {source};\n").scan()]
+    assert values == [value]
+
+
+def test_an_import_specifier_is_told_from_a_route_literal() -> None:
+    source = (
+        'import { a } from "./a.js";\n'
+        'export * from "./b.js";\n'
+        'import "./c.js";\n'
+        'const later = () => import("./d.js");\n'
+        'const SNAPSHOT = "./snapshot.json";\n'
+        'const READ = "/workbench/thread";\n'
+        'const SHEET = "/styles.css";\n'
+        'const PROSE = "/not a route";\n'
+    )
+    pending: collections.deque = collections.deque()
+    routes: set[str] = set()
+    harness._scan_module("/views/x.js", source.encode("utf-8"), pending, routes)
+    assert list(pending) == [
+        ("/views/a.js", True, "/views/x.js"),
+        ("/views/b.js", True, "/views/x.js"),
+        ("/views/c.js", True, "/views/x.js"),
+        ("/views/d.js", False, "/views/x.js"),
+    ]
+    # A route is resolved against the PAGE (`/`), not the module that names it,
+    # as `fetch` resolves it; a stylesheet and a sentence are not routes.
+    assert routes == {"/snapshot.json", "/workbench/thread"}
+
+
+def test_the_module_graph_terminates_on_a_cycle_and_counts_each_module_once() -> None:
+    files = {
+        "/app.js": (JS, 'import "./a.js";\nconst R = "/capabilities";\n'),
+        "/a.js": (JS, 'import "./b.js";\nconst S = "/workbench/model-catalog";\n'),
+        "/b.js": (JS, 'import "./a.js";\nimport "./app.js";\n'
+                      'const KIND = "workbench-model-catalog";\n'),
+    }
+    verdict = harness.Verdict(keep_going=True)
+    literals: set[str] = set()
+    with served(files) as port:
+        routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t", literals)
+    assert _failures(verdict) == []
+    assert modules == 3
+    assert routes == ["/capabilities", "/workbench/model-catalog"]
+    # every string literal of the graph is collected, the kind among them
+    assert harness.CATALOG_KIND in literals
+
+
+def test_a_dynamic_refusal_does_not_hide_a_static_import_of_the_same_path() -> None:
+    files = {
+        "/app.js": (JS, 'import("./missing.js").catch(() => null);\n'
+                        'import { x } from "./child.js";\n'),
+        "/child.js": (JS, 'import "./missing.js";\nexport const x = 1;\n'),
+    }
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == ["t.bundle.module /missing.js"]
+    assert modules == 2
+
+
+@pytest.mark.parametrize("static", [True, False], ids=["static", "dynamic"])
+@pytest.mark.parametrize("content_type", ["text/plain", "text/html",
+                                          "application/json", ""])
+def test_a_module_served_as_anything_but_javascript_is_a_named_failure(
+        static: bool, content_type: str) -> None:
+    importer = ('import "./child.js";\n' if static
+                else 'import("./child.js").catch(() => null);\n')
+    files = {"/app.js": (JS, importer),
+             "/child.js": (content_type, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == ["t.bundle.module-type /child.js"]
+
+
+@pytest.mark.parametrize("content_type", [
+    "text/javascript", "text/javascript; charset=utf-8",
+    "Application/JavaScript;charset=UTF-8", "text/ecmascript",
+])
+def test_every_javascript_type_essence_passes(content_type: str) -> None:
+    files = {"/app.js": (content_type, 'import("./child.js");\n'),
+             "/child.js": (content_type, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == []
+    assert modules == 2
+
+
+@pytest.mark.parametrize("content_type, expected", [
+    ("text/css", []),
+    ("text/css; charset=utf-8", []),
+    ("text/plain", ["t.bundle.sheet-type /styles.css"]),
+    ("text/html", ["t.bundle.sheet-type /styles.css"]),
+    ("", ["t.bundle.sheet-type /styles.css"]),
+])
+def test_a_stylesheet_served_as_anything_but_css_is_a_named_failure(
+        content_type: str, expected: list[str]) -> None:
+    files = {"/app.js": (JS, "export const x = 1;\n"),
+             "/styles.css": (content_type, "body { margin: 0; }\n")}
+    page = ('<html><head><link rel="stylesheet" href="./styles.css">'
+            '<script type="module" src="./app.js"></script></head></html>')
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, page, {}, verdict, "t")
+    assert _failures(verdict) == expected
+
+
+@pytest.mark.parametrize("importer, expected", [
+    ('import "https://unreachable.invalid/app.js";\n',
+     "t.bundle.external https://unreachable.invalid/app.js"),
+    ('import("//unreachable.invalid/app.js").catch(() => null);\n',
+     "t.bundle.external http://unreachable.invalid/app.js"),
+    ('export { x } from "data:text/javascript,export const x = 1";\n',
+     "t.bundle.external data:text/javascript,export const x = 1"),
+], ids=["static-https", "dynamic-protocol-relative", "data-url"])
+def test_an_import_from_outside_the_plane_is_a_named_failure(
+        importer: str, expected: str) -> None:
+    """Never fetched from loopback by its path, where the local `/app.js`
+    would answer for it (Copilot review of #75 at 142d1352, previously
+    missed)."""
+    files = {"/app.js": (JS, importer)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == [expected]
+
+
+def test_a_page_link_from_outside_the_plane_is_a_named_failure() -> None:
+    files = {"/app.js": (JS, "export const x = 1;\n"),
+             "/styles.css": ("text/css", "body { margin: 0; }\n")}
+    page = ('<html><head>'
+            '<link rel="stylesheet" href="https://cdn.invalid/styles.css">'
+            '<script type="module" src="https://cdn.invalid/app.js"></script>'
+            '</head></html>')
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(port, page, {}, verdict, "t")
+    assert _failures(verdict) == ["t.bundle.external https://cdn.invalid/styles.css",
+                                  "t.bundle.external https://cdn.invalid/app.js"]
+    assert modules == 0
+
+
+@pytest.mark.parametrize("importer, expected", [
+    ('import "child.js";\n', "t.bundle.bare child.js"),
+    ('import("child.js").catch(() => null);\n', "t.bundle.bare child.js"),
+    ('export { x } from "lib/child.js";\n', "t.bundle.bare lib/child.js"),
+    ('import { x } from "child";\n', "t.bundle.bare child"),
+], ids=["static", "dynamic", "export-from", "package-name"])
+def test_a_bare_specifier_is_a_named_failure(importer: str,
+                                             expected: str) -> None:
+    """With no import map, a browser refuses a specifier that is neither a
+    URL nor `/`, `./` or `../`-led, though `/child.js` is served (Copilot
+    review of #75 at 27479495, r4174411680)."""
+    files = {"/app.js": (JS, importer),
+             "/child.js": (JS, "export const x = 1;\n"),
+             "/lib/child.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == [expected]
+    assert modules == 1                 # never fetched by its path
+
+
+@pytest.mark.parametrize("specifier", ["./child.js", "../views/child.js",
+                                       "/views/child.js"],
+                         ids=["dot-slash", "dot-dot-slash", "absolute-path"])
+def test_every_relative_specifier_resolves(specifier: str) -> None:
+    files = {"/views/app.js": (JS, f'import "{specifier}";\n'),
+             "/views/child.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, _page("/views/app.js"), {}, verdict, "t")
+    assert _failures(verdict) == []
+    assert modules == 2
+
+
+def test_a_dynamic_refusal_alone_is_not_a_failure() -> None:
+    """10.2a's case: `intent-feed.js` is not owed, its importer degrades."""
+    files = {"/app.js": (JS, 'import("./intent-feed.js").catch(() => null);\n')}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == []
+
+
+class _Server:
+    """The two attributes `check_catalog` reads off a launched server."""
+
+    label = "t"
+
+    def __init__(self, port: int) -> None:
+        self.port = port
+
+
+_ENVELOPE = '"schema_version": 1, "kind": "workbench-model-catalog"'
+_NOT_A_CATALOG = ["t.catalog is a catalog",
+                  "t.catalog envelope is the one the chat rail adopts"]
+_WRONG_ENVELOPE = ["t.catalog envelope is the one the chat rail adopts"]
+
+
+@pytest.mark.parametrize("body, expected", [
+    ("[]", _NOT_A_CATALOG),
+    ("null", _NOT_A_CATALOG),
+    ('{"models": 1}', _NOT_A_CATALOG),
+    ("not json", _NOT_A_CATALOG),
+    ('{%s, "models": [1, {"model_id": "m", "available": true}]}' % _ENVELOPE,
+     ["t.catalog offers no available entry"]),
+    ('{%s, "models": [{"model_id": "m", "available": false}]}' % _ENVELOPE, []),
+    ('{%s, "models": []}' % _ENVELOPE, []),
+    # every JSON number equal to 1 is the one `=== 1` adopts (Copilot review
+    # of #75 at 1c0ff975, r4173473346)
+    ('{"schema_version": 1.0, "kind": "workbench-model-catalog", "models": []}',
+     []),
+    ('{"schema_version": 1e0, "kind": "workbench-model-catalog", "models": []}',
+     []),
+    ('{"schema_version": 10E-1, "kind": "workbench-model-catalog", "models": []}',
+     []),
+    # the envelopes `adoptCatalog` refuses (Copilot review of #75 at f0e0ffe1)
+    ('{"models": []}', _WRONG_ENVELOPE),
+    ('{"schema_version": 1, "models": []}', _WRONG_ENVELOPE),
+    ('{"kind": "workbench-model-catalog", "models": []}', _WRONG_ENVELOPE),
+    ('{"schema_version": 2, "kind": "workbench-model-catalog", "models": []}',
+     _WRONG_ENVELOPE),
+    ('{"schema_version": true, "kind": "workbench-model-catalog", "models": []}',
+     _WRONG_ENVELOPE),
+    ('{"schema_version": "1", "kind": "workbench-model-catalog", "models": []}',
+     _WRONG_ENVELOPE),
+    ('{"schema_version": 1.5, "kind": "workbench-model-catalog", "models": []}',
+     _WRONG_ENVELOPE),
+    ('{"schema_version": null, "kind": "workbench-model-catalog", "models": []}',
+     _WRONG_ENVELOPE),
+    ('{"schema_version": 1, "kind": "workbench-model-catalog-v2", "models": []}',
+     _WRONG_ENVELOPE),
+])
+def test_a_malformed_catalog_is_a_named_failure_never_an_exception(
+        body: str, expected: list[str]) -> None:
+    files = {harness.CATALOG_ROUTE: ("application/json", body)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE})) as port:
+        harness.check_catalog(_Server(port), "token", verdict)
+    assert _failures(verdict) == expected
+
+
+def test_a_catalog_that_answers_without_the_token_is_a_named_failure() -> None:
+    """The token the opener carries must be the thing that opens the
+    catalog, or reading it proves nothing."""
+    files = {harness.CATALOG_ROUTE: ("application/json",
+                                     '{%s, "models": []}' % _ENVELOPE)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.check_catalog(_Server(port), "token", verdict)
+    assert _failures(verdict) == [
+        "t.catalog refuses a caller without the console token"]
+
+
+# ---------------------------------------------------------------------------
+# The console token's delivery on a standalone plane (plan 034 T104).
+# ---------------------------------------------------------------------------
+
+PORT = 43123
+TOKEN = "Zq3_token-of-a-standalone-console-0123456789"
+#: The token with every character percent-encoded.
+ENCODED = "".join(f"%{ord(c):02X}" for c in TOKEN)
+FORWARD = f"http://127.0.0.1:{PORT}/index.html#console_token={TOKEN}"
+
+
+def _record(target: str = FORWARD, **changes) -> dict:
+    """The record T104's opener carries for a forward to `target`."""
+    record = {"schema_version": 1, "kind": "opendox-console-access",
+              "page_url": target.split("#", 1)[0], "opened_url": target,
+              "port": PORT, "pid": 4242, "console_token": TOKEN}
+    record.update(changes)
+    return record
+
+
+def _record_script(record) -> str:
+    """As T104 embeds it: `<`, `>` and `&` escaped as JSON `\\u` escapes."""
+    text = json.dumps(record, sort_keys=True)
+    text = (text.replace("<", "\\u003c").replace(">", "\\u003e")
+            .replace("&", "\\u0026"))
+    return ('<script type="application/json" id="opendox-console">'
+            f"{text}</script>\n")
+
+
+def _opener_page(*targets: str, records: list | None = None,
+                 delay: str = "0;url=") -> str:
+    """An opener as T104 writes one: a meta-refresh to each target, and the
+    record of the first (or `records`, as given)."""
+    metas = "".join(f'<meta http-equiv="refresh" content="{delay}{t}">\n'
+                    for t in targets)
+    if records is None:
+        records = [_record(targets[0].replace("&amp;", "&"))] if targets else []
+    scripts = "".join(_record_script(r) for r in records)
+    return ("<!doctype html>\n<html><head><meta charset=\"utf-8\">\n"
+            f"{metas}<title>Opening openDox</title>\n{scripts}</head>"
+            "<body></body></html>\n")
+
+
+def _opener(tmp_path: Path, page: str | None = None, *, mode: int = 0o600,
+            dir_mode: int = 0o700) -> tuple[Path, Path]:
+    """`(state_dir, opener)`: `<state_dir>/console/<PORT>.html`.
+
+    The opener's whole path is judged, to `/`, so every directory made here
+    is set private whatever the umask, and a case changes only what it
+    names."""
+    state = tmp_path / "state"
+    console = state / harness.CONSOLE_DIRNAME
+    console.mkdir(parents=True)
+    tmp_path.chmod(0o700)
+    state.chmod(0o700)
+    opener = console / f"{PORT}.html"
+    opener.write_text(_opener_page(FORWARD) if page is None else page,
+                      encoding="utf-8")
+    opener.chmod(mode)
+    console.chmod(dir_mode)
+    return state, opener
+
+
+def _printed(opener: Path) -> str:
+    return (f"  serving http://127.0.0.1:{PORT}/index.html\n"
+            f"  console {opener.as_uri()} (this user's private copy, mode "
+            "0600: open it to open the console page again)\n"
+            f"http://127.0.0.1:{PORT}/index.html\n")
+
+
+#: What a plane launched as the harness launches it answers on: 127.0.0.1
+#: alone, and `localhost`, which a browser resolves to it.
+SERVED = ("127.0.0.1", "localhost")
+
+
+def _read(state: Path, printed: str, served_root: Path | None = None,
+          hosts: tuple[str, ...] = SERVED):
+    verdict = harness.Verdict(keep_going=True)
+    root = served_root if served_root is not None else state.parent / "repo"
+    path, token = harness.check_console_opener(
+        "t", PORT, printed, state, root, verdict, hosts=hosts)
+    return _failures(verdict), path, token
+
+
+PRIVATE = "t.console opener is private"
+FRAGMENT = "t.console opener forwards with the token in its fragment"
+
+
+@pytest.mark.parametrize("token", ["a" * 16, "Z_-9" * 128],
+                         ids=["shortest", "longest"])
+def test_a_token_at_the_page_s_bounds_is_delivered(tmp_path: Path,
+                                                   token: str) -> None:
+    target = f"http://127.0.0.1:{PORT}/index.html#console_token={token}"
+    state, opener = _opener(tmp_path, _opener_page(
+        target, records=[_record(target, console_token=token)]))
+    failures, _path, delivered = _read(state, _printed(opener))
+    assert failures == []
+    assert delivered == token
+
+
+def test_a_forward_to_a_host_the_plane_answers_on_is_delivered(
+        tmp_path: Path) -> None:
+    """`[::1]` is refused where the plane answers on 127.0.0.1 alone, and
+    accepted where it answers there too."""
+    target = f"http://[::1]:{PORT}/index.html#console_token={TOKEN}"
+    state, opener = _opener(tmp_path, _opener_page(target))
+    assert _read(state, _printed(opener))[0] == [FRAGMENT]
+    failures, _path, token = _read(state, _printed(opener),
+                                   hosts=("127.0.0.1", "::1", "localhost"))
+    assert failures == []
+    assert token == TOKEN
+
+
+def test_the_hosts_a_plane_answers_on_are_probed() -> None:
+    """`served_loopback_hosts` asks the socket, as the browser will."""
+    with served({}) as port:
+        assert harness.served_loopback_hosts(port) == ("127.0.0.1",
+                                                       "localhost")
+    assert harness.served_loopback_hosts(port) == ()
+
+
+def test_the_opener_t104_writes_delivers_its_token(tmp_path: Path) -> None:
+    state, opener = _opener(tmp_path)
+    failures, path, token = _read(state, _printed(opener))
+    assert failures == []
+    assert path == opener
+    assert token == TOKEN
+
+
+@pytest.mark.parametrize("page", [
+    # the forms a meta refresh may take, and an escaped `&` after the token
+    _opener_page(FORWARD).replace("0;url=", "0; URL="),
+    _opener_page(FORWARD).replace(f"url={FORWARD}", f"url='{FORWARD}'"),
+    _opener_page(FORWARD + "&amp;then=1"),
+    # the refresh forms a browser follows (the HTML standard's shared
+    # declarative refresh steps)
+    _opener_page(FORWARD, delay=" 0 , url = "),
+    _opener_page(FORWARD, delay=".5;url="),
+    _opener_page(FORWARD, delay="0; "),
+    _opener_page(FORWARD).replace(f"url={FORWARD}",
+                                  f"url=\'{FORWARD}\' trailing"),
+    # the console page at `/` as well as `/index.html`
+    _opener_page(f"http://127.0.0.1:{PORT}/#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}#console_token={TOKEN}"),
+], ids=["spaced-upper-URL", "quoted", "escaped-ampersand", "comma-spaced",
+        "fractional", "no-url-keyword", "quote-truncates", "root-page",
+        "empty-path"])
+def test_the_opener_is_read_as_a_browser_reads_its_refresh(
+        tmp_path: Path, page: str) -> None:
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == []
+    assert token == TOKEN
+
+
+RECORD = "t.console opener record agrees with its forward"
+
+
+@pytest.mark.parametrize("records", [
+    [],
+    [_record(), _record()],
+    ["not json"],
+    [["a", "list"]],
+    [_record(kind="opendox-console")],
+    [_record(schema_version=2)],
+    [_record(schema_version="1")],
+    [_record(port=PORT + 1)],
+    [_record(port=str(PORT))],
+    [_record(console_token=TOKEN[::-1])],
+    [_record(opened_url=FORWARD.replace("index.html", "other.html"))],
+    [_record(page_url=f"http://127.0.0.1:{PORT}/other.html")],
+], ids=["none", "two", "not-json", "not-an-object", "kind", "version",
+        "version-string", "port", "port-string", "token", "opened-url",
+        "page-url"])
+def test_a_record_that_disagrees_with_the_forward_is_a_named_failure(
+        tmp_path: Path, records: list) -> None:
+    page = _opener_page(FORWARD, records=records).replace(
+        '"not json"', "not json")
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == [RECORD]
+    assert token == TOKEN
+
+
+def test_a_record_escaped_as_t104_writes_it_agrees(tmp_path: Path) -> None:
+    """A token-free `page_url` with every character T104 escapes in it."""
+    target = f"http://127.0.0.1:{PORT}/index.html#console_token={TOKEN}"
+    page = _opener_page(target, records=[_record(target, note="<&>")])
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == []
+    assert token == TOKEN
+
+
+#: The token with every character written as a JSON `\u` escape: the
+#: parsed payload holds it, and the raw text never spells it.
+_ESCAPED = "".join(f"\\u{ord(c):04x}" for c in TOKEN)
+BY_NAME = "t.capabilities carries no console token"
+BY_VALUE = "t.capabilities carries the opener's token nowhere"
+
+
+@pytest.mark.parametrize("raw, named", [
+    ('{"install": {"mode": "local"}}', False),
+    ('{"console_token": "%s"}' % TOKEN, True),
+    ('{"install": {"mode": "local", "console_token": "x"}}', True),
+    ('{"views": {"views": [{"console_token": "x"}]}}', True),
+    ('{"console\\u005ftoken": "x"}', True),
+    ('{"fields": ["console_token"]}', True),
+    ('{"console_token_hint": "x"}', True),
+], ids=["absent", "top-level", "nested", "in-a-list", "escaped-key",
+        "as-a-value", "in-a-longer-key"])
+def test_a_published_token_name_anywhere_in_the_raw_payload_is_a_named_failure(
+        raw: str, named: bool) -> None:
+    """By name, at any depth, as quickstart.md § 3 asserts it on the RAW
+    payload (T007 batch N), and in every parsed key, however escaped."""
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_no_published_token("t", json.loads(raw), raw, verdict)
+    assert _failures(verdict) == ([BY_NAME] if named else [])
+
+
+@pytest.mark.parametrize("raw, carried", [
+    ('{"install": {"mode": "local"}}', False),
+    ('{"session": "%s"}' % TOKEN, True),
+    ('{"install": {"note": "the token is %s"}}' % TOKEN, True),
+    ('{"%s": 1}' % TOKEN, True),
+    ('{"views": ["%s"]}' % TOKEN, True),
+    ('{"session": "%s"}' % _ESCAPED, True),
+    ('{"%s": 1}' % _ESCAPED, True),
+    ('{"session": "%s"}' % TOKEN[::-1], False),
+], ids=["absent", "another-key", "inside-a-value", "as-a-key", "in-a-list",
+        "escaped-value", "escaped-key", "another-token"])
+def test_the_opener_s_token_anywhere_in_the_raw_payload_is_a_named_failure(
+        raw: str, carried: bool, capsys) -> None:
+    """By value, under whatever name: neither the token nor the payload is
+    quoted."""
+    verdict = harness.Verdict(keep_going=True)
+    verdict.keep_secret(TOKEN)
+    harness.check_no_token_value("t", json.loads(raw), raw, TOKEN, verdict)
+    assert _failures(verdict) == ([BY_VALUE] if carried else [])
+    assert TOKEN not in capsys.readouterr().out
+
+
+def test_no_opener_named_is_a_named_failure(tmp_path: Path) -> None:
+    state, _opener_path = _opener(tmp_path)
+    failures, path, token = _read(state, f"http://127.0.0.1:{PORT}/\n")
+    assert failures == ["t.console opener printed"]
+    assert (path, token) == (None, None)
+
+
+def test_an_opener_somewhere_else_is_a_named_failure(tmp_path: Path) -> None:
+    state, _ = _opener(tmp_path)
+    _elsewhere, opener = _opener(tmp_path / "other")
+    failures, _path, _token = _read(state, _printed(opener))
+    assert failures == [
+        "t.console opener is OPENDOX_STATE_DIR/console/<port>.html"]
+
+
+def test_an_opener_inside_the_served_repository_is_a_named_failure(
+        tmp_path: Path) -> None:
+    state, opener = _opener(tmp_path)
+    failures, _path, _token = _read(state, _printed(opener),
+                                    served_root=tmp_path)
+    assert failures == ["t.console opener is outside the served repository"]
+
+
+@pytest.mark.parametrize("mode, dir_mode", [
+    (0o644, 0o700),     # any user can read the token
+    (0o640, 0o700),     # its group can
+    (0o400, 0o700),     # not exactly 0600
+    (0o600, 0o755),     # in a directory others can enter
+    (0o600, 0o750),
+    (0o600, 0o500),     # quickstart.md § 3 checks 0700 exactly
+], ids=["file-0644", "file-0640", "file-0400", "dir-0755", "dir-0750",
+        "dir-0500"])
+def test_an_opener_others_can_reach_is_a_named_failure(
+        tmp_path: Path, mode: int, dir_mode: int) -> None:
+    state, opener = _opener(tmp_path, mode=mode, dir_mode=dir_mode)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == [PRIVATE]
+    assert token == TOKEN
+
+
+def test_a_linked_opener_is_a_named_failure(tmp_path: Path) -> None:
+    state, opener = _opener(tmp_path)
+    real = tmp_path / "planted.html"
+    opener.rename(real)
+    opener.symlink_to(real)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == [PRIVATE, FRAGMENT]     # and never followed to read
+    assert token is None
+
+
+def test_a_fifo_opener_is_a_named_failure_and_never_hangs(
+        tmp_path: Path) -> None:
+    """A FIFO with no writer would block a plain `open` for ever, before the
+    verdict and the cleanup (Copilot review of #75 at 27479495, previously
+    missed). It is refused as not private, and is not read."""
+    state, opener = _opener(tmp_path)
+    opener.unlink()
+    os.mkfifo(opener, 0o600)
+    outcome: dict = {}
+
+    def read() -> None:
+        outcome["result"] = _read(state, _printed(opener))
+
+    reader = threading.Thread(target=read, daemon=True)
+    reader.start()
+    reader.join(timeout=10)
+    if reader.is_alive():
+        # Release the blocked reader so the run can end, then fail.
+        with open(os.open(opener, os.O_WRONLY | os.O_NONBLOCK), "wb"):
+            pass
+        reader.join(timeout=5)
+        pytest.fail("reading a FIFO opener blocked")
+    failures, _path, token = outcome["result"]
+    assert failures == [PRIVATE, FRAGMENT]
+    assert token is None
+
+
+def test_a_fifo_with_a_writer_is_never_read(tmp_path: Path) -> None:
+    """Only a regular file is read: a FIFO that a writer has filled is
+    refused by its descriptor, not read as the opener's page."""
+    fifo = tmp_path / "opener.html"
+    os.mkfifo(fifo, 0o600)
+    holder = os.open(fifo, os.O_RDONLY | os.O_NONBLOCK)   # lets a writer open
+    try:
+        # A whole page waits in the pipe, and its writer has gone, so a
+        # reader would get the page and then an end of file.
+        writer = os.open(fifo, os.O_WRONLY | os.O_NONBLOCK)
+        os.write(writer, _opener_page(FORWARD).encode("utf-8"))
+        os.close(writer)
+        with pytest.raises(OSError):
+            harness._read_without_following(fifo)
+    finally:
+        os.close(holder)
+
+
+def test_a_hard_linked_opener_is_a_named_failure(tmp_path: Path) -> None:
+    state, opener = _opener(tmp_path)
+    os.link(opener, tmp_path / "second-name.html")
+    failures, _path, _token = _read(state, _printed(opener))
+    assert failures == [PRIVATE]
+
+
+@pytest.mark.parametrize("page", [
+    # the token in the QUERY, which a request line, a log and a Referer carry
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html?console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html?console_token={TOKEN}"
+                 f"#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}/{TOKEN}/index.html"
+                 f"#console_token={TOKEN}"),
+    # a forward to another plane, or off loopback
+    _opener_page(FORWARD.replace(str(PORT), str(PORT + 1))),
+    _opener_page(FORWARD.replace("127.0.0.1", "example.com")),
+    _opener_page(FORWARD.replace("http:", "https:")),
+    # no token, an empty one, two of them, two forwards, or none
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html"),
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html#console_token="),
+    _opener_page(FORWARD + f"&amp;console_token={TOKEN}"),
+    _opener_page(FORWARD, FORWARD),
+    _opener_page(),
+    # what a browser reads differently from urllib.parse (Copilot review of
+    # #75 at d53a7378, r4173842763 and r4173842811)
+    _opener_page(f"http://example.invalid\\@127.0.0.1:{PORT}/index.html"
+                 f"#console_token={TOKEN}"),
+    _opener_page(f"http://{TOKEN}@127.0.0.1:{PORT}/index.html"
+                 f"#console_token={TOKEN}"),
+    _opener_page(f"http://user:{TOKEN}@127.0.0.1:{PORT}/index.html"
+                 f"#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html\t#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}/ index.html#console_token={TOKEN}"),
+    _opener_page(f"http://[broken:{PORT}/index.html#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:99999/index.html#console_token={TOKEN}"),
+    # a delay that aborts the browser's refresh (Copilot review of #75 at
+    # 5636eb8d, r4173894317)
+    _opener_page(FORWARD, delay="invalid;url="),
+    _opener_page(FORWARD, delay="-1;url="),
+    _opener_page(FORWARD, delay="; url="),
+    _opener_page(FORWARD, delay="url="),
+    # a token the page's `takeDeliveredConsoleToken` discards (r4173894352)
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html#console_token=short"),
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html#console_token="
+                 + "a" * 513),
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html#console_token="
+                 "token.with.dots.0123456789"),
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html#console_token="
+                 "token%2Bplus%2B0123456789"),
+    # a page of this plane that is not the console, its record agreeing
+    # (Copilot review of #75 at 486e426e, previously missed)
+    _opener_page(f"http://127.0.0.1:{PORT}/missing.html#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}/snapshot.json#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}//index.html#console_token={TOKEN}"),
+    # a percent-encoded copy of the token in the query or the path, which
+    # the request line still carries (Copilot review of #75 at 142d1352,
+    # r4174355680)
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html?extra={ENCODED}"
+                 f"#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}/index.html?extra="
+                 f"{ENCODED.replace('%', '%25')}#console_token={TOKEN}"),
+    _opener_page(f"http://127.0.0.1:{PORT}/{ENCODED}/../index.html"
+                 f"#console_token={TOKEN}"),
+    # a loopback host the launched plane does not answer on (previously
+    # missed at 142d1352)
+    _opener_page(f"http://[::1]:{PORT}/index.html#console_token={TOKEN}"),
+], ids=["query", "query-and-fragment", "path", "other-port", "off-loopback",
+        "https", "no-token", "empty-token", "two-tokens", "two-forwards",
+        "no-forward", "backslash", "userinfo-token", "userinfo-password",
+        "tab", "space", "malformed-host", "port-out-of-range",
+        "delay-word", "delay-negative", "delay-empty", "delay-absent",
+        "token-short", "token-oversized", "token-dots", "token-plus",
+        "page-missing", "page-snapshot", "page-double-slash",
+        "query-encoded", "query-double-encoded", "path-encoded", "ipv6-unserved"])
+def test_a_forward_that_leaks_or_misses_the_token_is_a_named_failure(
+        tmp_path: Path, page: str) -> None:
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == [FRAGMENT]
+    assert token is None
+
+
+@pytest.mark.parametrize("target", [
+    f"http://example.invalid:{PORT}/{TOKEN}/index.html#console_token={TOKEN}",
+    f"https://127.0.0.1:{PORT}/{TOKEN}#console_token={TOKEN}",
+    f"http://{TOKEN}.example:{PORT}/#console_token={TOKEN}",
+    f"http://[{TOKEN}:{PORT}/#console_token={TOKEN}",
+    f"http://x\\{TOKEN}@127.0.0.1:{PORT}/#console_token={TOKEN}",
+], ids=["path-elsewhere", "path-https", "host", "malformed", "backslash"])
+def test_a_refused_forward_never_quotes_its_url(tmp_path: Path,
+                                                target: str) -> None:
+    """A refused destination is not quoted, because it may hold the token
+    (Copilot review of #75 at d53a7378, r4173842794)."""
+    state, opener = _opener(tmp_path, _opener_page(target))
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    assert [failure.ident for failure in verdict.failures] == [FRAGMENT]
+    assert not any(TOKEN in str(failure) for failure in verdict.failures)
+
+
+def test_an_unparseable_printed_location_is_a_named_failure(
+        tmp_path: Path) -> None:
+    """The product's output, so a named failure and never a harness error
+    (Copilot review of #75 at d53a7378, r4173842805)."""
+    state, _opener_path = _opener(tmp_path)
+    failures, path, token = _read(
+        state, "  console file://[broken/opener.html (this user's copy)\n")
+    assert failures == ["t.console opener printed"]
+    assert (path, token) == (None, None)
+
+
+def test_a_record_reason_never_quotes_the_token(tmp_path: Path) -> None:
+    page = _opener_page(FORWARD, records=[_record(kind=TOKEN, port=TOKEN)])
+    state, opener = _opener(tmp_path, page)
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    assert [failure.ident for failure in verdict.failures] == [RECORD]
+    assert not any(TOKEN in str(failure) for failure in verdict.failures)
+
+
+def test_a_token_in_the_query_is_named_and_never_quoted(tmp_path: Path) -> None:
+    state, opener = _opener(tmp_path, _opener_page(
+        f"http://127.0.0.1:{PORT}/index.html?console_token={TOKEN}"
+        f"#console_token={TOKEN}"))
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    assert [failure.ident for failure in verdict.failures] == [FRAGMENT]
+    assert "QUERY" in verdict.failures[0].why
+    assert not any(TOKEN in str(failure) for failure in verdict.failures)
+
+
+def test_after_the_stop_the_opener_is_gone_and_the_token_was_never_printed(
+        tmp_path: Path) -> None:
+    state, opener = _opener(tmp_path)
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_gone("t", opener, TOKEN, _printed(opener), verdict)
+    harness.check_console_gone("u", opener, TOKEN,
+                               _printed(opener) + f"token {TOKEN}\n", verdict)
+    opener.unlink()
+    harness.check_console_gone("v", opener, TOKEN, _printed(opener), verdict)
+    assert _failures(verdict) == ["t.stop removes the console opener",
+                                  "u.stop removes the console opener",
+                                  "u.console token never printed"]
+
+
+def test_the_documented_start_is_the_readme_line_less_its_ellipsis() -> None:
+    """The one command the openDox root README documents (T007 batch H's
+    10.3 addendum): the harness runs these tokens, then fills the `…`."""
+    assert harness.DOCUMENTED_START == "opendox generate-and-open --local …"
+    assert harness.documented_prefix() == ["opendox", "generate-and-open",
+                                           "--local"]
+    assert json.dumps(harness.DOCUMENTED_INSTALL) == '"pip install \\"opendox[local]\\""'
+
+
+# ---------------------------------------------------------------------------
+# The stop's exit status (Copilot review of #75 at 142d1352, previously
+# missed): 0, as `tests_runtime/test_bundled_postgres.py` requires.
+# ---------------------------------------------------------------------------
+
+class _StoppedProc:
+    def __init__(self, rc) -> None:
+        self.rc = rc
+
+    def send_signal(self, _signal) -> None:
+        pass
+
+    def wait(self, timeout=None):
+        if self.rc is None:
+            raise harness.subprocess.TimeoutExpired("opendox", timeout)
+        return self.rc
+
+
+@pytest.mark.parametrize("rc, expected", [
+    (0, []),
+    (1, ["t.stop exits 0"]),
+    (-15, ["t.stop exits 0"]),
+    (None, ["t.stop exits 0"]),
+], ids=["zero", "one", "sigterm", "timeout"])
+def test_the_stop_must_exit_zero(tmp_path: Path, rc, expected) -> None:
+    out, err = tmp_path / "out", tmp_path / "err"
+    out.write_text("", encoding="utf-8")
+    err.write_text("", encoding="utf-8")
+    server = harness.Server("t", _StoppedProc(rc), PORT, out, err)
+    ctx = types.SimpleNamespace(server_package=None,
+                                state_dir=tmp_path / "state-of-no-server")
+    ctx.state_dir.mkdir()
+    verdict = harness.Verdict(keep_going=True)
+    harness.stop_and_look(server, ctx, verdict)
+    assert _failures(verdict) == expected
+
+
+# ---------------------------------------------------------------------------
+# Every document names its path (Copilot review of #75 at 33841d4a,
+# r4174621535), and a diagnostic never echoes the entry point's output
+# (r4174621486).
+# ---------------------------------------------------------------------------
+
+_HTML_INDEX = harness.Answer(200, {"content-type": "text/html; charset=utf-8"},
+                             b"<html><body></body></html>", None)
+_CAPS = json.dumps({"install": {"mode": "local"}})
+
+
+def _snapshot_server(documents) -> dict:
+    return {"/snapshot.json": ("application/json",
+                               json.dumps({"kind": "opendox-snapshot",
+                                           "documents": documents})),
+            "/capabilities": ("application/json", _CAPS)}
+
+
+@pytest.mark.parametrize("documents, expected", [
+    ([{"path": "a.md"}, {"path": "b/c.md"}], []),
+    ([{}], ["t.snapshot documents each name a path"]),
+    ([{"path": ""}], ["t.snapshot documents each name a path"]),
+    ([{"path": 1}], ["t.snapshot documents each name a path"]),
+    (["a.md"], ["t.snapshot documents each name a path"]),
+    ([{"path": "a.md"}, {"title": "no path"}],
+     ["t.snapshot documents each name a path"]),
+], ids=["named", "empty-object", "empty-path", "number-path", "string-entry",
+        "one-of-two"])
+def test_a_document_without_a_path_is_a_named_failure(
+        tmp_path: Path, documents, expected) -> None:
+    out, err = tmp_path / "out", tmp_path / "err"
+    out.write_text("", encoding="utf-8")
+    err.write_text("", encoding="utf-8")
+    verdict = harness.Verdict(keep_going=True)
+    with served(_snapshot_server(documents)) as port:
+        server = harness.Server("t", None, port, out, err)
+        harness.check_pages(server, _HTML_INDEX, verdict)
+    assert _failures(verdict) == expected
+
+
+def test_a_diagnostic_names_where_the_output_is_and_never_echoes_it(
+        tmp_path: Path) -> None:
+    out, err = tmp_path / "t-server.out", tmp_path / "t-server.err"
+    out.write_text(f"  console file:///x\n  token {TOKEN}\n", encoding="utf-8")
+    err.write_text(f"Traceback: {TOKEN}\n", encoding="utf-8")
+    server = harness.Server("t", None, PORT, out, err)
+    said = server.said()
+    assert TOKEN not in said
+    assert str(out) in said and str(err) in said
+    # the after-stop check still reads all of it
+    assert TOKEN in server.printed()
+
+
+# ---------------------------------------------------------------------------
+# Only a LIVE refresh forwards (Copilot review of #75 at 4809b3d2,
+# r4174671390): a browser that runs scripts never acts on one inside a
+# `<template>`, a `<noscript>` or a raw-text element, keeps the first of a
+# repeated attribute, and reads `http-equiv` exactly.
+# ---------------------------------------------------------------------------
+
+_LIVE_META = f'<meta http-equiv="refresh" content="0;url={FORWARD}">'
+_ELSEWHERE_META = ('<meta http-equiv="refresh" '
+                   'content="0;url=http://example.invalid/">')
+
+
+def _page_with(head: str, body: str = "") -> str:
+    """An opener page whose refreshes are `head` and `body`, with T104's
+    live record of `FORWARD`."""
+    return ("<!doctype html>\n<html><head><meta charset=\"utf-8\">\n"
+            f"{head}\n{_record_script(_record())}</head>"
+            f"<body>{body}</body></html>\n")
+
+
+@pytest.mark.parametrize("head, body", [
+    (f"<template>{_LIVE_META}</template>", ""),
+    (f"<noscript>{_LIVE_META}</noscript>", ""),
+    ("", f"<noscript>{_LIVE_META}</noscript>"),
+    ("", f"<template><div>{_LIVE_META}</div></template>"),
+    ("", f"<template><template></template>{_LIVE_META}</template>"),
+    (f"<template/>{_LIVE_META}", ""),
+    (f"<title>{_LIVE_META}</title>", ""),
+    (f"<style>{_LIVE_META}</style>", ""),
+    (f'<script type="text/plain">{_LIVE_META}</script>', ""),
+    ("", f"<textarea>{_LIVE_META}</textarea>"),
+    ("", f"<xmp>{_LIVE_META}</xmp>"),
+    ("", f"<iframe>{_LIVE_META}</iframe>"),
+    ("", f"<noembed>{_LIVE_META}</noembed>"),
+    ("", f"<noframes>{_LIVE_META}</noframes>"),
+    ("", f"<select>{_LIVE_META}</select>"),
+    ("", f"<plaintext></plaintext>{_LIVE_META}"),
+    ("<frameset></frameset>", _LIVE_META),
+], ids=["template", "noscript-head", "noscript-body", "template-nested-div",
+        "template-in-template", "template-self-closed", "title", "style",
+        "script", "textarea", "xmp", "iframe", "noembed", "noframes",
+        "select", "plaintext", "frameset"])
+def test_an_inert_refresh_forwards_nothing(tmp_path: Path, head: str,
+                                          body: str) -> None:
+    """The opener's one refresh sits where a browser never acts on it, so
+    the user never reaches the console, and the run must say so."""
+    state, opener = _opener(tmp_path, _page_with(head, body))
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == [FRAGMENT]
+    assert token is None
+
+
+@pytest.mark.parametrize("head", [
+    f"<template>{_ELSEWHERE_META}</template>{_LIVE_META}",
+    f"<noscript>{_ELSEWHERE_META}</noscript>{_LIVE_META}",
+    f"<title>Opening</title>{_LIVE_META}",
+    # a tag inside text content opens nothing, so its own end tag closes it
+    f"<noscript><template></noscript>{_LIVE_META}",
+    f"<iframe><template></iframe>{_LIVE_META}",
+    f"<textarea><template></textarea>{_LIVE_META}",
+    _LIVE_META.replace(">", "/>"),
+    _LIVE_META.replace('"refresh"', '"REFRESH"'),
+], ids=["after-template", "after-noscript", "after-title",
+        "noscript-holds-tags", "iframe-holds-tags", "textarea-holds-tags",
+        "void-self-closed", "upper-case"])
+def test_a_live_refresh_beside_inert_markup_is_delivered(tmp_path: Path,
+                                                         head: str) -> None:
+    state, opener = _opener(tmp_path, _page_with(head))
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == []
+    assert token == TOKEN
+
+
+@pytest.mark.parametrize("meta, delivered", [
+    ('<meta http-equiv="refresh" content="0;url=http://example.invalid/" '
+     f'content="0;url={FORWARD}">', False),
+    (f'<meta http-equiv="refresh" content="0;url={FORWARD}" '
+     'content="0;url=http://example.invalid/">', True),
+    (f'<meta http-equiv="x" http-equiv="refresh" content="0;url={FORWARD}">',
+     False),
+    (f'<meta http-equiv=" refresh" content="0;url={FORWARD}">', False),
+    (f'<meta http-equiv="refresh " content="0;url={FORWARD}">', False),
+], ids=["first-content-elsewhere", "first-content-here", "first-equiv-other",
+        "equiv-leading-space", "equiv-trailing-space"])
+def test_a_refresh_is_read_by_its_first_attributes_exactly(
+        tmp_path: Path, meta: str, delivered: bool) -> None:
+    state, opener = _opener(tmp_path, _page_with(meta))
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == ([] if delivered else [FRAGMENT])
+    assert token == (TOKEN if delivered else None)
+
+
+@pytest.mark.parametrize("wrapper", ["template", "noscript"])
+def test_an_inert_record_is_no_record(tmp_path: Path, wrapper: str) -> None:
+    page = ("<!doctype html>\n<html><head>\n"
+            f"{_LIVE_META}\n<{wrapper}>{_record_script(_record())}</{wrapper}>"
+            "</head><body></body></html>\n")
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == [RECORD]
+    assert token == TOKEN
+
+
+# ---------------------------------------------------------------------------
+# The opener's whole path, as T104 holds its own tree (Copilot review of #75
+# at 4809b3d2, r4174671426): the state directory is this user's and no one
+# else can write it, and every directory above it is this user's or root's,
+# sticky where others can write it.
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("state_mode, private", [
+    (0o700, True),
+    (0o755, True),
+    (0o711, True),
+    (0o777, False),
+    (0o757, False),
+    (0o775, False),
+    (0o1777, False),
+], ids=["0700", "0755", "0711", "0777", "other-writable", "group-writable",
+        "sticky-0777"])
+def test_a_state_directory_others_can_write_is_a_named_failure(
+        tmp_path: Path, state_mode: int, private: bool) -> None:
+    state, opener = _opener(tmp_path)
+    state.chmod(state_mode)
+    verdict = harness.Verdict(keep_going=True)
+    path, token = harness.check_console_opener(
+        "t", PORT, _printed(opener), state, tmp_path / "repo", verdict,
+        hosts=SERVED)
+    assert _failures(verdict) == ([] if private else [PRIVATE])
+    assert token == TOKEN
+    if not private:
+        assert f"{state} is writable by" in verdict.failures[0].why
+
+
+@pytest.mark.parametrize("above_mode, private", [
+    (0o755, True),
+    (0o700, True),
+    (0o1777, True),
+    (0o1770, True),
+    (0o777, False),
+    (0o775, False),
+    (0o757, False),
+], ids=["0755", "0700", "sticky-0777", "sticky-group", "0777",
+        "group-writable", "other-writable"])
+def test_a_directory_above_the_state_others_can_change_is_a_named_failure(
+        tmp_path: Path, above_mode: int, private: bool) -> None:
+    above = tmp_path / "above"
+    state, opener = _opener(above)
+    above.chmod(above_mode)
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    assert _failures(verdict) == ([] if private else [PRIVATE])
+    if not private:
+        assert verdict.failures[0].why.startswith(f"{above} is writable by")
+        assert "not sticky" in verdict.failures[0].why
+
+
+def test_a_symbolic_link_above_the_state_this_user_owns_is_followed(
+        tmp_path: Path) -> None:
+    """A link on the way that this user owns is this user's to point; the
+    directories it leads to are judged as well."""
+    real = tmp_path / "real"
+    real.mkdir()
+    (tmp_path / "link").symlink_to(real)
+    state, opener = _opener(tmp_path / "link")
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == []
+    assert token == TOKEN
+    real.chmod(0o777)
+    assert _read(state, _printed(opener))[0] == [PRIVATE]
+
+
+def test_a_link_s_target_is_judged_by_its_own_ancestors(tmp_path: Path) -> None:
+    """A link this user owns may lead below a directory others can change;
+    the resolved path's ancestors are judged as well as the written ones."""
+    open_dir = tmp_path / "open"
+    real = open_dir / "real"
+    real.mkdir(parents=True)
+    (tmp_path / "link").symlink_to(real)
+    state, opener = _opener(tmp_path / "link")
+    assert _read(state, _printed(opener))[0] == []
+    open_dir.chmod(0o777)
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    assert _failures(verdict) == [PRIVATE]
+    assert verdict.failures[0].why.startswith(f"{open_dir} is writable by")
+
+
+def _owned_by(real, faked: Path, uid: int):
+    """`real` (`os.lstat` or `os.stat`), answering `faked` as owned by
+    `uid`: no test can chown, so another user's link or directory is told."""
+    def answer(path, *args, **kwargs):
+        info = real(path, *args, **kwargs)
+        if Path(path) != faked:
+            return info
+        fields = list(info[:10])
+        fields[4] = uid
+        return os.stat_result(fields)
+    return answer
+
+
+def test_a_link_another_user_owns_above_the_state_is_a_named_failure(
+        tmp_path: Path, monkeypatch) -> None:
+    real = tmp_path / "real"
+    real.mkdir()
+    link = tmp_path / "link"
+    link.symlink_to(real)
+    state, opener = _opener(link)
+    stranger = os.getuid() + 4242
+    monkeypatch.setattr(harness.os, "lstat",
+                        _owned_by(os.lstat, link, stranger))
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    assert _failures(verdict) == [PRIVATE]
+    assert verdict.failures[0].why == (
+        f"{link} is a symbolic link owned by uid {stranger}, neither this "
+        "user nor root, who could point it elsewhere")
+
+
+@pytest.mark.parametrize("owner, private", [("root", True),
+                                            ("stranger", False)])
+def test_a_directory_above_the_state_another_user_owns_is_a_named_failure(
+        tmp_path: Path, monkeypatch, owner: str, private: bool) -> None:
+    above = tmp_path / "above"
+    state, opener = _opener(above)
+    uid = 0 if owner == "root" else os.getuid() + 4242
+    monkeypatch.setattr(harness.os, "stat", _owned_by(os.stat, above, uid))
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    assert _failures(verdict) == ([] if private else [PRIVATE])
+    if not private:
+        assert verdict.failures[0].why == (
+            f"{above} is owned by uid {uid}, neither this user nor root")
+
+
+def test_a_state_directory_that_is_a_link_is_a_named_failure(
+        tmp_path: Path) -> None:
+    elsewhere, _opener_path = _opener(tmp_path / "elsewhere")
+    state = tmp_path / "state"
+    state.symlink_to(elsewhere)
+    opener = state / harness.CONSOLE_DIRNAME / f"{PORT}.html"
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    assert _failures(verdict) == [PRIVATE]
+    assert verdict.failures[0].why == f"{state} is a symbolic link"
+
+
+@pytest.mark.parametrize("mode, refused", [(0o700, False), (0o1777, False),
+                                           (0o777, True), (0o775, True)],
+                         ids=["0700", "sticky", "0777", "group-writable"])
+def test_the_harness_refuses_a_tmpdir_others_can_change(
+        tmp_path_factory, monkeypatch, mode: int, refused: bool) -> None:
+    """Before anything is installed, so the verdict on the opener's tree
+    judges what the product made, never where TMPDIR pointed (exit 2)."""
+    base = tmp_path_factory.mktemp("t")
+    base.chmod(mode)
+    monkeypatch.setattr(harness.tempfile, "tempdir", str(base))
+    if refused:
+        with pytest.raises(harness.HarnessError, match="set TMPDIR"):
+            harness.prepare()
+        assert list(base.iterdir()) == []      # nothing left behind
+        return
+    ctx = harness.prepare()
+    try:
+        assert ctx.state_dir.parent == base.resolve()
+    finally:
+        harness.shutil.rmtree(ctx.scratch, ignore_errors=True)
+        harness.shutil.rmtree(ctx.state_dir, ignore_errors=True)
+
+
+# ---------------------------------------------------------------------------
+# No line the harness prints quotes a console token, or the entry point's
+# output (Copilot review of #75 at 33841d4a, r4174621486, carried to every
+# diagnostic).
+# ---------------------------------------------------------------------------
+
+def test_a_catalog_answer_that_echoes_the_token_never_prints_it(
+        tmp_path: Path, capsys) -> None:
+    """The catalog is asked with the token, so its answer may echo it, and
+    no line quotes any of the answer's content (Copilot review of #75 at
+    82869769, r4177924097)."""
+    state, opener = _opener(tmp_path)
+    echo = json.dumps({"error": f"unknown token {TOKEN}"})
+    files = {harness.CATALOG_ROUTE: ("application/json", echo)}
+    verdict = harness.Verdict(keep_going=True)
+    _path, token = harness.check_console_opener(
+        "t", PORT, _printed(opener), state, tmp_path / "repo", verdict,
+        hosts=SERVED)
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE})) as port:
+        harness.check_catalog(_Server(port), token, verdict)
+    verdict.report()
+    out = capsys.readouterr().out
+    assert "t.catalog is a catalog" in _failures(verdict)
+    assert not any("unknown token" in str(failure)
+                   for failure in verdict.failures)
+    assert "unknown token" not in out and TOKEN not in out
+
+
+#: The token with every character a JSON `\u` escape, which no literal
+#: redaction finds and any reader decodes (r4177924097).
+_ESCAPED_ECHO = '{"error": "unknown token %s"}' % "".join(
+    f"\\u{ord(c):04x}" for c in TOKEN)
+
+
+@pytest.mark.parametrize("status, failure", [
+    (200, "t.catalog is a catalog"),
+    (403, "t.catalog answers"),
+], ids=["malformed-200", "refused-403"])
+def test_a_catalog_answer_s_body_is_never_quoted(capsys, status: int,
+                                                 failure: str) -> None:
+    files = {harness.CATALOG_ROUTE: ("application/json", _ESCAPED_ECHO,
+                                     status)}
+    verdict = harness.Verdict(keep_going=True)
+    verdict.keep_secret(TOKEN)
+    with served(files) as port:
+        harness.check_catalog(_Server(port), TOKEN, verdict)
+    verdict.report()
+    out = capsys.readouterr().out
+    assert failure in _failures(verdict)
+    assert not any("\\u00" in str(failed) or "unknown token" in str(failed)
+                   for failed in verdict.failures)
+    assert "\\u00" not in out and "unknown token" not in out
+
+
+def test_every_token_the_opener_carries_is_kept_secret(tmp_path: Path) -> None:
+    """A refused forward's token, and its record's, though none is delivered."""
+    other = "Other_token-0123456789abcdef"
+    page = _opener_page(
+        f"http://127.0.0.1:{PORT}/index.html?console_token={TOKEN}"
+        f"#console_token={TOKEN}",
+        records=[_record(console_token=other)])
+    state, opener = _opener(tmp_path, page)
+    verdict = harness.Verdict(keep_going=True)
+    _path, token = harness.check_console_opener(
+        "t", PORT, _printed(opener), state, tmp_path / "repo", verdict,
+        hosts=SERVED)
+    assert token is None
+    assert {TOKEN, other} <= verdict.secrets
+    verdict.check("t.later", False, f"an answer echoed {TOKEN} and {other}")
+    assert verdict.failures[-1].why == (
+        f"an answer echoed {harness.REDACTED} and {harness.REDACTED}")
+
+
+def _quiet_server(tmp_path: Path, port: int):
+    out, err = tmp_path / "out", tmp_path / "err"
+    out.write_text("", encoding="utf-8")
+    err.write_text("", encoding="utf-8")
+    return harness.Server("t", None, port, out, err)
+
+
+def _pages(caps_payload: str) -> dict:
+    return {"/snapshot.json": ("application/json",
+                               json.dumps({"documents": [{"path": "a.md"}]})),
+            "/capabilities": ("application/json", caps_payload)}
+
+
+@pytest.mark.parametrize("caps", [
+    {"console_token": TOKEN, "install": {"mode": "local"}},
+    # Copilot review of #75 at ec95f451, r4175016672's example
+    {"install": {"mode": "hosted", "console_token": TOKEN}},
+    {"install": {"mode": "local"}, "a": [{"b": {"console_token": [TOKEN]}}]},
+], ids=["top-level", "nested-in-install", "nested-in-a-list"])
+def test_a_published_token_is_never_printed(tmp_path: Path, capsys,
+                                            caps: dict) -> None:
+    """Under its name at any depth, the token `/capabilities` publishes is
+    kept out of every later line: here a view module the payload names by
+    it, which step 8's walk reports."""
+    payload = dict(caps, views={"views": [{"module": f"/views/{TOKEN}.js"}]})
+    verdict = harness.Verdict(keep_going=True)
+    with served(_pages(json.dumps(payload))) as port:
+        _snapshot, got, _raw = harness.check_pages(
+            _quiet_server(tmp_path, port), _HTML_INDEX, verdict)
+        harness.derive_bundle(port, "<html></html>", got, verdict, "t")
+    verdict.report()
+    assert BY_NAME in _failures(verdict)
+    assert f"t.bundle.module /views/{harness.REDACTED}.js" in _failures(verdict)
+    assert TOKEN not in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("payload, failure", [
+    (json.dumps({"install": {"mode": "hosted", "session": TOKEN}}),
+     "t.capabilities install.mode == local"),
+    (json.dumps([{"session": TOKEN}]), "t./capabilities is a JSON object"),
+    (json.dumps(f"session {TOKEN}"), "t./capabilities is a JSON object"),
+], ids=["install-block", "a-list", "a-string"])
+def test_no_failure_quotes_a_capabilities_payload(tmp_path: Path, capsys,
+                                                  payload: str,
+                                                  failure: str) -> None:
+    """A token under another name is unknown until step 6 reads the opener,
+    so no step-5 reason quotes the payload at all (Copilot review of #75 at
+    ec95f451, r4175016672: "use a fixed message")."""
+    verdict = harness.Verdict(keep_going=True)
+    with served(_pages(payload)) as port:
+        with contextlib.suppress(harness.Failed):
+            harness.check_pages(_quiet_server(tmp_path, port), _HTML_INDEX,
+                                verdict)
+    verdict.report()
+    assert failure in _failures(verdict)
+    assert not any(TOKEN in str(failed) for failed in verdict.failures)
+    assert TOKEN not in capsys.readouterr().out
+
+
+#: JSON nested past the parser's depth (Copilot review of #75 at ec95f451,
+#: r4175016692): the product's answer, so a named failure, never exit 2.
+_DEEP = "[" * 30000 + "]" * 30000
+
+
+@pytest.mark.parametrize("route", ["/snapshot.json", "/capabilities"])
+def test_a_page_nested_past_the_parser_s_depth_is_a_named_failure(
+        tmp_path: Path, route: str) -> None:
+    files = _pages(json.dumps({"install": {"mode": "local"}}))
+    files[route] = ("application/json", _DEEP)
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        with pytest.raises(harness.Failed) as failed:
+            harness.check_pages(_quiet_server(tmp_path, port), _HTML_INDEX,
+                                verdict)
+    assert failed.value.ident == f"t.{route} is a JSON object"
+    assert failed.value.why.endswith("it is not JSON")
+
+
+def test_a_catalog_nested_past_the_parser_s_depth_is_a_named_failure() -> None:
+    files = {harness.CATALOG_ROUTE: ("application/json", _DEEP)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE})) as port:
+        harness.check_catalog(_Server(port), "token", verdict)
+    assert _failures(verdict) == _NOT_A_CATALOG
+
+
+def test_one_serve_learns_the_opener_s_token_before_it_quotes_a_page(
+        tmp_path: Path, monkeypatch, capsys) -> None:
+    """`serve_one` reads the opener's tokens as soon as the start answers,
+    so a payload carrying the token under another name (here the grouping
+    field `/capabilities` names) prints none of it in step 5, and step 6
+    still fails it by value. The start and the stop are stood in for."""
+    caps = {"install": {"mode": "local"},
+            "display": {"fields": {"grouping": {"field": TOKEN}}}}
+    files = _pages(json.dumps(caps))
+    files[harness.CATALOG_ROUTE] = ("application/json",
+                                    '{%s, "models": []}' % _ENVELOPE)
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE})) as port:
+        target = f"http://127.0.0.1:{port}/index.html#console_token={TOKEN}"
+        state = tmp_path / "state"
+        console = state / harness.CONSOLE_DIRNAME
+        console.mkdir(parents=True)
+        tmp_path.chmod(0o700)
+        state.chmod(0o700)
+        console.chmod(0o700)
+        opener = console / f"{port}.html"
+        opener.write_text(_opener_page(target, records=[
+            _record(target, port=port)]), encoding="utf-8")
+        opener.chmod(0o600)
+        server = _quiet_server(tmp_path, port)
+        server.out.write_text(f"  console {opener.as_uri()}\n",
+                              encoding="utf-8")
+        monkeypatch.setattr(harness, "launch",
+                            lambda *_args: (server, _HTML_INDEX))
+        monkeypatch.setattr(harness, "stop_and_look", lambda *_a, **_k: None)
+        # The token is a secret BEFORE step 5 begins, whatever step 5 prints
+        # today.
+        known_at_step_5: list[bool] = []
+        check_pages = harness.check_pages
+
+        def watched(server_, index_, verdict_):
+            known_at_step_5.append(TOKEN in verdict_.secrets)
+            return check_pages(server_, index_, verdict_)
+        monkeypatch.setattr(harness, "check_pages", watched)
+        verdict = harness.Verdict(keep_going=True)
+        harness.serve_one("t", tmp_path / "repo",
+                          types.SimpleNamespace(state_dir=state), verdict)
+    verdict.report()
+    assert known_at_step_5 == [True]
+    failures = _failures(verdict)
+    assert "t.snapshot fills the grouping station" in failures
+    assert BY_VALUE in failures
+    assert not any(TOKEN in str(failed) for failed in verdict.failures)
+    assert TOKEN not in capsys.readouterr().out
+
+
+def test_a_printed_path_other_than_the_expected_one_is_never_quoted(
+        tmp_path: Path, capsys) -> None:
+    """The printed path is the entry point's output: it may carry the token,
+    so no reason quotes it, or a directory on it."""
+    state, _opener_path = _opener(tmp_path)
+    printed = f"  console /run/{TOKEN}/opener.html (this user's copy)\n"
+    verdict = harness.Verdict(keep_going=True)
+    path, token = harness.check_console_opener(
+        "t", PORT, printed, state, tmp_path / "repo", verdict, hosts=SERVED)
+    assert path == Path(f"/run/{TOKEN}/opener.html") and token is None
+    assert _failures(verdict) == [
+        "t.console opener is OPENDOX_STATE_DIR/console/<port>.html",
+        PRIVATE, FRAGMENT]
+    assert verdict.failures[1].why.startswith("the printed opener ")
+    harness.check_console_gone("t", path, None, printed, verdict)
+    assert not any(TOKEN in str(failure) for failure in verdict.failures)
+    assert TOKEN not in capsys.readouterr().out
+
+
+def test_a_printed_opener_elsewhere_is_judged_but_never_quoted(
+        tmp_path: Path, capsys) -> None:
+    """An opener that exists at a path the harness did not expect is still
+    judged, and its path, which holds a value the harness does not know,
+    is quoted by no reason, the stop's included."""
+    other = "Path_token-0123456789abcdef"
+    state, _expected = _opener(tmp_path / "expected")
+    _elsewhere, printed_opener = _opener(tmp_path / other, mode=0o644)
+    printed = _printed(printed_opener)
+    verdict = harness.Verdict(keep_going=True)
+    path, token = harness.check_console_opener(
+        "t", PORT, printed, state, tmp_path / "repo", verdict, hosts=SERVED)
+    assert (path, token) == (printed_opener, TOKEN)
+    assert _failures(verdict) == [
+        "t.console opener is OPENDOX_STATE_DIR/console/<port>.html", PRIVATE]
+    assert verdict.failures[1].why == "the printed opener has mode 644, not 600"
+    harness.check_console_gone("t", path, token, printed, verdict)
+    assert _failures(verdict)[-1] == "t.stop removes the console opener"
+    assert not any(other in str(failure) for failure in verdict.failures)
+    assert other not in capsys.readouterr().out
+
+
+def test_notes_and_the_report_are_redacted(capsys) -> None:
+    verdict = harness.Verdict(keep_going=True)
+    verdict.check("t.early", False, f"an early line with {TOKEN} in it")
+    verdict.keep_secret(TOKEN)          # learned after the failure was kept
+    verdict.note(f"GET /x?{TOKEN}")
+    assert verdict.report() == 1
+    out = capsys.readouterr().out
+    assert f"GET /x?{harness.REDACTED}" in out
+    report = out[out.index("AT-R1 HTTP half: FAIL"):]
+    assert TOKEN not in report and harness.REDACTED in report
+
+
+@pytest.mark.parametrize("value", [None, "", "short", 12345678901234567890,
+                                   "a" * 15])
+def test_a_short_or_non_string_value_is_never_kept(value) -> None:
+    """A short value would blank words out of unrelated lines."""
+    verdict = harness.Verdict(keep_going=True)
+    verdict.keep_secret(value)
+    assert verdict.secrets == set()
+    assert verdict.redact("a short line") == "a short line"
+
+
+def test_a_record_nested_past_the_parser_s_depth_is_a_named_failure(
+        tmp_path: Path) -> None:
+    """The product's output, so a named failure, never a harness error."""
+    deep = "[" * 30000 + "]" * 30000
+    page = _opener_page(FORWARD, records=[]).replace(
+        "</head>", f'<script type="application/json" id="opendox-console">'
+                   f"{deep}</script></head>")
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == [RECORD]
+    assert token == TOKEN
+
+
+# ---------------------------------------------------------------------------
+# The chat rail's thread read (openDox-code#85, the T102 follow-on; holder
+# ruling F1 (i)): a standalone plane's rail sends none, so the harness asks
+# none with a query, and asserts the plane contributes no branch-session
+# column, the one condition under which the rail would.
+# ---------------------------------------------------------------------------
+
+_SNAPSHOT = {"repository": "fixture", "documents": [{"path": "a.md"}],
+             "clusters": [{"id": "g1", "document_edges": [{"document": "a.md"}]}]}
+
+
+def test_the_rail_s_thread_read_is_never_asked_with_a_query() -> None:
+    """Only the bare literal, as every literal is asked; the `/`-ended
+    prefix is still completed with each document."""
+    targets = harness.requests_for(
+        ["/source/", harness.THREAD_ROUTE, "/snapshot.json"], _SNAPSHOT)
+    assert targets == ["/source/", "/source/a.md", "/source/fixture%40main/a.md",
+                       harness.THREAD_ROUTE, "/snapshot.json"]
+
+
+@pytest.mark.parametrize("caps, reads", [
+    ({}, False),
+    ({"views": {"views": []}}, False),
+    ({"views": {"views": [{"id": "gate.bar", "module": "./g.js"}]}}, False),
+    ({"views": [{"id": "gate.workbench.session"}]}, False),
+    ({"views": {"views": [{"id": "gate.workbench.session",
+                           "module": "./session.js"}]}}, True),
+    ({"views": {"views": [{"id": "gate.bar"},
+                          {"id": "gate.workbench.session"}]}}, True),
+], ids=["no-views", "no-bindings", "another-column", "not-a-manifest",
+        "session-column", "session-among-others"])
+def test_a_contributed_session_column_is_a_named_failure(caps: dict,
+                                                         reads: bool) -> None:
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_no_thread_read("t", caps, verdict)
+    assert _failures(verdict) == (
+        ["t.chat rail reads no thread (no branch session)"] if reads else [])
+
+
+def test_step_8_asserts_the_rail_reads_no_thread(tmp_path: Path) -> None:
+    caps = {"views": {"views": [{"id": "gate.workbench.session"}]}}
+    verdict = harness.Verdict(keep_going=True)
+    with served({}) as port:
+        harness.check_routes(_quiet_server(tmp_path, port), _HTML_INDEX,
+                             _SNAPSHOT, caps, None, verdict)
+    assert "t.chat rail reads no thread (no branch session)" in _failures(verdict)
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at 82869769: the opener is read whole or refused
+# (r4177924060); no reason quotes the server's own bytes (r4177924097); the
+# module graph resolves against the running server's origin (r4177924129).
+# ---------------------------------------------------------------------------
+
+def _padded_to(page: str, size: int) -> str:
+    """`page` with an HTML comment before its end, making it `size` bytes."""
+    pad = size - len(page.encode("utf-8")) - len("<!---->")
+    assert pad >= 0
+    return page.replace("</html>", f"<!--{'x' * pad}--></html>")
+
+
+def test_an_opener_past_the_read_limit_is_refused_never_truncated(
+        tmp_path: Path) -> None:
+    """A valid page within the limit, and a second record past it: read
+    whole, the opener holds two records; truncated, it held one."""
+    limit = harness.OPENER_READ_LIMIT
+    page = _opener_page(FORWARD)
+    head = _padded_to(page, limit).replace("</html>\n", "")
+    oversized = head + "</html>\n" + _record_script(_record())
+    assert len(head.encode("utf-8")) < limit < len(oversized.encode("utf-8"))
+    state, opener = _opener(tmp_path, oversized)
+    verdict = harness.Verdict(keep_going=True)
+    _path, token = harness.check_console_opener(
+        "t", PORT, _printed(opener), state, tmp_path / "repo", verdict,
+        hosts=SERVED)
+    assert _failures(verdict) == [FRAGMENT]
+    assert token is None
+    assert f"larger than the {limit} bytes" in verdict.failures[0].why
+
+
+def test_an_opener_of_exactly_the_read_limit_is_read(tmp_path: Path) -> None:
+    page = _padded_to(_opener_page(FORWARD), harness.OPENER_READ_LIMIT)
+    assert len(page.encode("utf-8")) == harness.OPENER_READ_LIMIT
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == []
+    assert token == TOKEN
+
+
+def test_a_failed_request_is_named_without_the_server_s_bytes() -> None:
+    import http.client
+    line = f"HTTP/1.1 999 {TOKEN}"
+    assert harness.error_name(http.client.BadStatusLine(line)) == "BadStatusLine"
+    assert harness.error_name(
+        ConnectionRefusedError(111, "Connection refused")) == (
+        "ConnectionRefusedError: Connection refused")
+    assert harness.error_name(TimeoutError()) == "TimeoutError"
+
+
+@pytest.mark.parametrize("value, shown", [
+    ("text/javascript; charset=utf-8", "'text/javascript'"),
+    ("Text/HTML", "'text/html'"),
+    (None, "no Content-Type"),
+    ('text/x-\\u0041"; x=1', "a Content-Type that is no plain MIME type "
+                            "(not quoted)"),
+    ("text/" + "%41" * 3, "a Content-Type that is no plain MIME type "
+                          "(not quoted)"),
+], ids=["with-charset", "upper-case", "absent", "escaped", "percent"])
+def test_a_content_type_is_quoted_only_as_a_plain_mime_type(value,
+                                                           shown: str) -> None:
+    headers = {} if value is None else {"content-type": value}
+    assert harness.shown_type(harness.Answer(200, headers, b"", None)) == shown
+
+
+@pytest.mark.parametrize("make", [
+    lambda port: f'import "http://127.0.0.1:{port}/child.js";\n',
+    lambda port: f'import("http://127.0.0.1:{port}/child.js");\n',
+    lambda port: f'import "//127.0.0.1:{port}/child.js";\n',
+], ids=["static-absolute", "dynamic-absolute", "protocol-relative"])
+def test_an_absolute_same_origin_import_is_a_path_of_this_plane(make) -> None:
+    files = {"/child.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        files["/app.js"] = (JS, make(port))
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == []
+    assert modules == 2
+
+
+def test_an_absolute_same_origin_stylesheet_is_a_path_of_this_plane() -> None:
+    files = {"/app.js": (JS, "export const x = 1;\n"),
+             "/styles.css": ("text/plain", "body { margin: 0; }\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        page = ('<html><head><link rel="stylesheet" '
+                f'href="http://127.0.0.1:{port}/styles.css">'
+                '<script type="module" src="./app.js"></script></head></html>')
+        harness.derive_bundle(port, page, {}, verdict, "t")
+    # fetched and judged as this plane's own sheet, never as external
+    assert _failures(verdict) == ["t.bundle.sheet-type /styles.css"]
+
+
+@pytest.mark.parametrize("make, expected", [
+    (lambda port: f'import "http://localhost:{port}/child.js";\n',
+     lambda port: f"t.bundle.external http://localhost:{port}/child.js"),
+    (lambda port: f'import "http://127.0.0.1:{port + 1}/child.js";\n',
+     lambda port: f"t.bundle.external http://127.0.0.1:{port + 1}/child.js"),
+    (lambda port: f'import "https://127.0.0.1:{port}/child.js";\n',
+     lambda port: f"t.bundle.external https://127.0.0.1:{port}/child.js"),
+    (lambda port: 'import "http://[broken/child.js";\n',
+     lambda port: "t.bundle.external unparseable:http://[broken/child.js"),
+], ids=["another-host", "another-port", "another-scheme", "unparseable"])
+def test_an_import_from_another_origin_is_still_external(make,
+                                                         expected) -> None:
+    files = {"/child.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        files["/app.js"] = (JS, make(port))
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+        wanted = expected(port)
+    assert _failures(verdict) == [wanted]
+    assert modules == 1
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at 2dcb98d3: JSON as a browser parses it
+# (r4178069345), and a reference a browser reads differently is refused,
+# never resolved (r4178069374).
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("constant", ["NaN", "Infinity", "-Infinity"])
+def test_a_catalog_with_a_non_json_constant_is_a_named_failure(
+        constant: str) -> None:
+    """`response.json()` refuses it, so the chat rail reads the catalog as
+    unreadable, though `json.loads` admits it."""
+    body = '{%s, "models": [], "extra": %s}' % (_ENVELOPE, constant)
+    files = {harness.CATALOG_ROUTE: ("application/json", body)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE})) as port:
+        harness.check_catalog(_Server(port), "token", verdict)
+    assert _failures(verdict) == _NOT_A_CATALOG
+
+
+@pytest.mark.parametrize("constant", ["NaN", "Infinity", "-Infinity"])
+def test_a_page_with_a_non_json_constant_is_a_named_failure(
+        tmp_path: Path, constant: str) -> None:
+    files = _pages(json.dumps({"install": {"mode": "local"}}))
+    files["/snapshot.json"] = (
+        "application/json",
+        '{"documents": [{"path": "a.md", "weight": %s}]}' % constant)
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        with pytest.raises(harness.Failed) as failed:
+            harness.check_pages(_quiet_server(tmp_path, port), _HTML_INDEX,
+                                verdict)
+    assert failed.value.ident == "t./snapshot.json is a JSON object"
+
+
+@pytest.mark.parametrize("constant", ["NaN", "Infinity", "-Infinity"])
+def test_a_record_with_a_non_json_constant_is_no_record(tmp_path: Path,
+                                                        constant: str) -> None:
+    record = json.dumps(_record(), sort_keys=True).replace(
+        '"pid": 4242', f'"pid": {constant}')
+    page = _opener_page(FORWARD, records=[]).replace(
+        "</head>", '<script type="application/json" id="opendox-console">'
+                   f"{record}</script></head>")
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    assert failures == [RECORD]
+    assert token == TOKEN
+
+
+@pytest.mark.parametrize("where", [
+    "page-script", "stylesheet", "static", "dynamic", "view-module",
+    "slash-backslash", "tab"])
+def test_a_reference_a_browser_reads_differently_is_refused(where: str) -> None:
+    """`external.invalid\\@127.0.0.1` goes to `external.invalid` in a
+    browser, and `/\\host` to `host`; urllib.parse resolves both to this
+    plane's own `/child.js`, which is served. Each is refused by name and
+    never fetched."""
+    files = {"/child.js": (JS, "export const x = 1;\n"),
+             "/app.js": (JS, "export const x = 1;\n"),
+             "/styles.css": ("text/css", "body { margin: 0; }\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        divergent = f"http://external.invalid\\@127.0.0.1:{port}/child.js"
+        page, caps = _page("./app.js"), {}
+        if where == "page-script":
+            page = _page(divergent)
+        elif where == "stylesheet":
+            divergent = divergent.replace("child.js", "styles.css")
+            page = page.replace(
+                "<head>", f'<head><link rel="stylesheet" href="{divergent}">')
+        elif where == "view-module":
+            caps = {"views": {"views": [{"id": "x", "module": divergent}]}}
+        else:
+            if where == "slash-backslash":
+                divergent = "/\\external.invalid/child.js"
+            elif where == "tab":
+                divergent = "./ch\tild.js"
+            escaped = divergent.replace("\\", "\\\\").replace("\t", "\\t")
+            files["/app.js"] = (JS, f'import("{escaped}");\n'
+                                if where == "dynamic"
+                                else f'import "{escaped}";\n')
+        _routes, modules = harness.derive_bundle(port, page, caps, verdict,
+                                                 "t")
+    assert _failures(verdict) == [f"t.bundle.divergent {divergent!r}"]
+    assert modules == (0 if where == "page-script" else 1)
+
+
+# ---------------------------------------------------------------------------
+# The self-pass after Copilot's review of #75 at 2dcb98d3: every parser
+# reads as the browser reads, or refuses by name what it does not model.
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("body, expected", [
+    (b"\xef\xbb\xbf" + ('{%s, "models": []}' % _ENVELOPE).encode(), []),
+    (('{%s, "models": [], "note": "' % _ENVELOPE).encode() + b"\xff\"}", []),
+    (b"\xef\xbb\xbf" + b"NaN", _NOT_A_CATALOG),
+], ids=["leading-bom", "invalid-utf8-in-a-string", "bom-then-nan"])
+def test_json_is_decoded_as_a_browser_decodes_it(body: bytes,
+                                                 expected: list) -> None:
+    """UTF-8 as the Encoding standard decodes it: a BOM dropped, an invalid
+    byte read as U+FFFD, as `response.json()` does."""
+    answer = harness.Answer(200, {"content-type": "application/json"}, body,
+                            None)
+    verdict = harness.Verdict(keep_going=True)
+
+    class _Fixed:
+        label, port = "t", 0
+    original = harness.get
+    try:
+        harness.get = lambda _port, target, token=None, host=None: (
+            answer if token else harness.Answer(403, {}, b"", None))
+        harness.check_catalog(_Fixed(), "token", verdict)
+    finally:
+        harness.get = original
+    assert _failures(verdict) == expected
+
+
+@pytest.mark.parametrize("models, offered", [
+    ('[{"model_id": "m", "available": true}]', ["m"]),
+    ('[{"model_id": "m", "available": 1}]', []),
+    ('[{"model_id": "m", "available": "true"}]', []),
+    ('[{"model_id": "m", "available": [1]}]', []),
+], ids=["true", "one", "a-string", "a-list"])
+def test_an_entry_is_available_only_as_the_rail_reads_it(models: str,
+                                                         offered: list) -> None:
+    """`m.available === true` (`views/doxbench-chat-model.js`)."""
+    body = '{%s, "models": %s}' % (_ENVELOPE, models)
+    files = {harness.CATALOG_ROUTE: ("application/json", body)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE})) as port:
+        harness.check_catalog(_Server(port), "token", verdict)
+    assert _failures(verdict) == (
+        ["t.catalog offers no available entry"] if offered else [])
+
+
+@pytest.mark.parametrize("content_type, html", [
+    ("text/html; charset=utf-8", True),
+    ("TEXT/HTML", True),
+    ("text/htmlx", False),
+    ("application/xhtml+xml; profile=text/html", False),
+    ("text/plain", False),
+], ids=["html", "upper-case", "longer-type", "html-in-a-parameter", "plain"])
+def test_the_page_is_html_by_its_type_s_essence(tmp_path: Path,
+                                               content_type: str,
+                                               html: bool) -> None:
+    index = harness.Answer(200, {"content-type": content_type},
+                           b"<html><body></body></html>", None)
+    verdict = harness.Verdict(keep_going=True)
+    with served(_snapshot_server([{"path": "a.md"}])) as port:
+        harness.check_pages(_quiet_server(tmp_path, port), index, verdict)
+    assert ("t.http / is HTML" in _failures(verdict)) is not html
+
+
+@pytest.mark.parametrize("page, expected", [
+    ('<script type="module" src="./ok.js" src="./missing.js"></script>', []),
+    ('<script type="module" src="./missing.js" src="./ok.js"></script>',
+     ["t.bundle.module /missing.js"]),
+    ('<link rel="Stylesheet" href="./missing.css">',
+     ["t.bundle.sheet /missing.css"]),
+    ('<link rel="preload stylesheet" href="./missing.css">',
+     ["t.bundle.sheet /missing.css"]),
+    ('<link rel="nostylesheet" href="./missing.css">', []),
+    ('<link rel="icon" href="data:,">', []),
+], ids=["first-src-served", "first-src-missing", "rel-upper-case",
+        "rel-among-tokens", "rel-not-a-token", "icon"])
+def test_the_page_s_links_are_read_as_a_browser_reads_them(
+        page: str, expected: list) -> None:
+    files = {"/ok.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(
+            port, f'<html><head>{page}<script type="module" src="./ok.js">'
+                  "</script></head></html>", {}, verdict, "t")
+    assert _failures(verdict) == expected
+
+
+@pytest.mark.parametrize("head, expected", [
+    ('<base href="/">', []),
+    ('<base href="https://cdn.invalid/">', ["t.bundle.base"]),
+    # refused, and judged as the browser resolves under it
+    ('<base href="/elsewhere/">', ["t.bundle.base",
+                                   "t.bundle.module /elsewhere/app.js"]),
+    ('<script type="importmap">{"imports": {}}</script>', ["t.bundle.importmap"]),
+    ('<script type=" ImportMap ">{"imports": {}}</script>',
+     ["t.bundle.importmap"]),
+], ids=["own-root", "another-origin", "another-path", "import-map",
+        "import-map-type-spaced"])
+def test_a_page_that_resolves_its_links_elsewhere_is_a_named_failure(
+        head: str, expected: list) -> None:
+    files = {"/app.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(
+            port, f'<html><head>{head}<script type="module" src="./app.js">'
+                  "</script></head></html>", {}, verdict, "t")
+    assert _failures(verdict) == expected
+
+
+@pytest.mark.parametrize("make", [
+    lambda port: f"http://user@127.0.0.1:{port}/child.js",
+    lambda port: f"http://user:pass@127.0.0.1:{port}/child.js",
+    lambda port: "./%2e%2e/child.js",
+    lambda port: "./%2E/child.js",
+    lambda port: "./sub/%2e%2E/child.js",
+], ids=["user", "user-and-password", "encoded-dot-dot", "encoded-dot",
+        "encoded-mixed-case"])
+def test_a_reference_a_browser_refuses_or_reads_elsewhere_is_refused(
+        make) -> None:
+    files = {"/child.js": (JS, "export const x = 1;\n"),
+             "/sub/child.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        ref = make(port)
+        files["/app.js"] = (JS, f'import "{ref}";\n')
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == [f"t.bundle.divergent {ref!r}"]
+    assert modules == 1
+
+
+def test_an_encoded_dot_in_a_query_is_no_divergence() -> None:
+    files = {"/child.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        files["/app.js"] = (JS, 'import "./child.js?v=/%2e%2e/";\n')
+        files["/child.js?v=/%2e%2e/"] = files["/child.js"]
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == []
+    assert modules == 2
+
+
+@pytest.mark.parametrize("target, sent", [
+    ("/café.js", "/caf%C3%A9.js"),
+    ("/my file.js", "/my%20file.js"),
+    ("/a.js?q=a b&c='d'", "/a.js?q=a%20b&c=%27d%27"),
+    ("/a%20b.js", "/a%20b.js"),
+    ("/{x}`.js", "/%7Bx%7D%60.js"),
+    ("/\ud83d\ude00.js", "/%F0%9F%98%80.js"),
+    ("/\ud83d.js?q=\ude00", "/%EF%BF%BD.js?q=%EF%BF%BD"),
+], ids=["non-ascii", "space", "query", "already-encoded", "path-set",
+        "surrogate-pair", "lone-surrogates"])
+def test_a_request_target_is_encoded_as_a_browser_encodes_it(
+        target: str, sent: str) -> None:
+    assert harness.browser_target(target) == sent
+
+
+def test_a_non_ascii_import_is_fetched_as_the_browser_fetches_it() -> None:
+    """`http.client` raised on it before (exit 2); a browser sends it
+    percent-encoded."""
+    files = {"/caf%C3%A9.js": (JS, "export const x = 1;\n"),
+             "/app.js": (JS, 'import "./café.js";\n')}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == []
+    assert modules == 2
+
+
+@pytest.mark.parametrize("content, delivered", [
+    (f"0;url=http://127.0.0.1:{PORT}/index.html#x=1&amp;console_token={TOKEN}",
+     True),
+    (f"0;url=http://127.0.0.1:{PORT}/index.html#x=1&ampconsole_token={TOKEN}",
+     False),
+    (f"0;url=http://127.0.0.1:{PORT}/index.html#console_token={TOKEN}&copy=1",
+     False),
+], ids=["terminated", "unterminated-before-a-letter",
+        "unterminated-before-equals"])
+def test_a_refresh_with_an_unterminated_reference_is_not_followed(
+        tmp_path: Path, content: str, delivered: bool) -> None:
+    """`html.unescape` decodes `&amp` before a letter; a browser leaves it,
+    so the page would get no `console_token` where the harness found one."""
+    page = _page_with(f'<meta http-equiv="refresh" content="{content}">')
+    state, opener = _opener(tmp_path, page)
+    failures, _path, token = _read(state, _printed(opener))
+    if delivered:
+        assert token == TOKEN and FRAGMENT not in failures
+    else:
+        assert token is None and FRAGMENT in failures
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at 4bdb41fb: only a live module script is an entry
+# (r4178395669), and a reference is read in Unicode scalar values
+# (r4178395690); and the self-pass that closed each class: what the page
+# runs, the markup and encodings this harness does not model, a string
+# escape a module refuses, a redirect, a `Content-Type` a browser parses
+# otherwise, and a printed line a server could forge.
+# ---------------------------------------------------------------------------
+
+_ENTRY = '<script type="module" src="./app.js"></script>'
+_CLASSIC = ["t.bundle.classic-script './app.js'", "t.bundle.entry"]
+
+
+@pytest.mark.parametrize("head, expected", [
+    ('<script src="./app.js"></script>', _CLASSIC),
+    ('<script type="text/javascript" src="./app.js"></script>', _CLASSIC),
+    ('<script type="" src="./app.js"></script>', _CLASSIC),
+    ('<script language="javascript" src="./app.js"></script>', _CLASSIC),
+    ('<script language="json" src="./app.js"></script>', ["t.bundle.entry"]),
+    ('<script type="application/json" src="./app.js"></script>',
+     ["t.bundle.entry"]),
+    ('<script type="  " src="./app.js"></script>', ["t.bundle.entry"]),
+    ('<script type="module; x" src="./app.js"></script>', ["t.bundle.entry"]),
+    (f"<template>{_ENTRY}</template>", ["t.bundle.entry"]),
+    (f"<noscript>{_ENTRY}</noscript>", ["t.bundle.entry"]),
+    ('<script type="module" src=""></script>', ["t.bundle.entry"]),
+    ('<script type="module">import "./app.js";</script>',
+     ["t.bundle.inline-module", "t.bundle.entry"]),
+    (f"<script>document.title = 1;</script>{_ENTRY}",
+     ["t.bundle.classic-script (inline)"]),
+    (f'<script nomodule src="./legacy.js"></script>{_ENTRY}', []),
+    ('<script type="module" nomodule src="./app.js"></script>', []),
+    ('<script type=" MODULE " src="./app.js"></script>', []),
+    ('<script type="module" src="./app.js">import "./gone.js";</script>', []),
+], ids=["no-type", "javascript-type", "empty-type", "language",
+        "language-of-a-data-block", "data-block",
+        "blank-type", "module-with-a-parameter", "in-a-template",
+        "in-a-noscript", "empty-src", "inline-module", "inline-classic",
+        "classic-nomodule", "module-nomodule", "module-type-spaced",
+        "src-over-inline-code"])
+def test_only_a_live_module_script_is_an_entry(head: str,
+                                              expected: list) -> None:
+    """A browser runs a module only from a live `<script type="module">`
+    with a `src`: one without a type, or of a JavaScript type, is a classic
+    script, whose imports are a SyntaxError; a data block and a template's
+    script run nothing (Copilot review of #75 at 4bdb41fb, r4178395669)."""
+    files = {"/app.js": (JS, "export const x = 1;\n"),
+             "/legacy.js": (JS, "var legacy = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, f"<html><head>{head}</head></html>", {},
+                              verdict, "t")
+    assert _failures(verdict) == expected
+
+
+def test_a_view_module_is_no_entry() -> None:
+    """A module `/capabilities` declares is walked, but it stands in for no
+    application entry the page lacks."""
+    caps = {"views": {"views": [{"id": "x", "module": "./app.js"}]}}
+    files = {"/app.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(port, "<html></html>", caps,
+                                                 verdict, "t")
+    assert _failures(verdict) == ["t.bundle.entry"]
+    assert modules == 1
+
+
+@pytest.mark.parametrize("body, unmodeled", [
+    ('<svg><script type="module" src="./app.js"></script></svg>', True),
+    ("<math><mi>x</mi></math>", True),
+    ('<select><script type="module" src="./other.js"></script></select>',
+     True),
+    ('<select><link rel="stylesheet" href="./a.css"></select>', True),
+    ("<frameset></frameset>", True),
+    ("<select><option>x</option></select>", False),
+    ("<template><svg></svg></template>", False),
+    ('<template><select><script type="module" src="./other.js"></script>'
+     "</select></template>", False),
+    ('<select><template><script type="module" src="./other.js"></script>'
+     "</template></select>", False),
+], ids=["svg", "math", "script-in-select", "link-in-select", "frameset",
+        "plain-select", "svg-in-a-template", "select-in-a-template",
+        "template-in-a-select"])
+def test_markup_this_harness_does_not_model_is_refused_by_name(
+        body: str, unmodeled: bool) -> None:
+    files = {"/app.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(
+            port, f"<html><head>{_ENTRY}</head><body>{body}</body></html>",
+            {}, verdict, "t")
+    assert _failures(verdict) == (["t.bundle.unmodeled"] if unmodeled
+                                  else [])
+
+
+@pytest.mark.parametrize("content_type, body, utf8", [
+    ("text/html", b'<html><head><meta charset="utf-8"></head></html>', True),
+    ("text/html; charset=UTF-8", b"<html></html>", True),
+    ("text/html", b'<html><head><meta charset="UTF8"></head></html>', True),
+    ("text/html; charset=iso-2022-kr", b"<html></html>", False),
+    ("text/html", b'<html><head><meta charset="windows-1252"></head></html>',
+     False),
+    ("text/html", b'<html><head><meta http-equiv="Content-Type" '
+                  b'content="text/html; charset=shift_jis"></head></html>',
+     False),
+    ("text/html", b"\xff\xfe<\x00h\x00t\x00m\x00l\x00>\x00", False),
+    ("text/html; charset=iso-2022-kr", b"\xef\xbb\xbf<html></html>", True),
+], ids=["meta-utf-8", "header-utf-8", "meta-utf8-label", "header-other",
+        "meta-other", "http-equiv-other", "utf-16-bom", "utf-8-bom-outranks"])
+def test_the_page_must_be_utf_8_as_the_harness_reads_it(
+        tmp_path: Path, content_type: str, body: bytes, utf8: bool) -> None:
+    index = harness.Answer(200, {"content-type": content_type}, body, None)
+    verdict = harness.Verdict(keep_going=True)
+    with served(_snapshot_server([{"path": "a.md"}])) as port:
+        harness.check_pages(_quiet_server(tmp_path, port), index, verdict)
+    assert ("t.http / is UTF-8" in _failures(verdict)) is not utf8
+
+
+@pytest.mark.parametrize("head, delivered", [
+    (f"{_LIVE_META}<svg></svg>", False),
+    (f"<math></math>{_LIVE_META}", False),
+    (f'<meta charset="iso-2022-kr">{_LIVE_META}', False),
+    ('<meta http-equiv="content-type" content="text/html; '
+     f'charset=windows-1252">{_LIVE_META}', False),
+    (f'<meta charset="UTF8">{_LIVE_META}', True),
+], ids=["svg", "math", "replacement-encoding", "another-encoding",
+        "utf8-label"])
+def test_an_opener_this_harness_cannot_read_forwards_nothing(
+        tmp_path: Path, head: str, delivered: bool) -> None:
+    state, opener = _opener(tmp_path, _page_with(head))
+    failures, _path, token = _read(state, _printed(opener))
+    if delivered:
+        assert token == TOKEN and failures == []
+    else:
+        assert token is None and failures == [FRAGMENT]
+
+
+def test_an_opener_in_utf_16_forwards_nothing(tmp_path: Path) -> None:
+    state, opener = _opener(tmp_path)
+    opener.write_bytes(b"\xff\xfe" + _opener_page(FORWARD).encode("utf-16-le"))
+    failures, _path, token = _read(state, _printed(opener))
+    assert token is None and failures == [FRAGMENT]
+
+
+@pytest.mark.parametrize("escape, served_as", [
+    (r"\uD83D\uDE00", "%F0%9F%98%80"),
+    (r"\u{1F600}", "%F0%9F%98%80"),
+    (r"\uD83D", "%EF%BF%BD"),
+], ids=["surrogate-pair", "code-point", "lone-surrogate"])
+def test_a_surrogate_import_is_fetched_as_the_browser_fetches_it(
+        escape: str, served_as: str) -> None:
+    """Copilot's example: `\\uD83D\\uDE00` is one code point to the browser,
+    and `browser_target` raised on it before (r4178395690)."""
+    files = {f"/{served_as}.js": (JS, "export const x = 1;\n"),
+             "/app.js": (JS, f'import "./{escape}.js";\n')}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == []
+    assert modules == 2
+
+
+def test_a_lone_surrogate_from_json_is_read_as_the_browser_reads_it() -> None:
+    """JSON keeps a lone `\\ud83d` too: as a view module, and as a document
+    path that `requests_for` completes a source read with."""
+    caps = json.loads('{"views": {"views": [{"id": "x", '
+                      '"module": "./\\ud83d.js"}]}}')
+    # ... and the module the page imports as U+FFFD is the same one, judged
+    # once, as the browser loads it once.
+    files = {"/%EF%BF%BD.js": (JS, "export const x = 1;\n"),
+             "/app.js": (JS, 'import "./\\uFFFD.js";\n')}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(port, _page("./app.js"),
+                                                 caps, verdict, "t")
+    assert _failures(verdict) == []
+    assert modules == 2
+    snapshot = json.loads('{"repository": "r\\udc80", '
+                          '"documents": [{"path": "\\ud83d.md"}]}')
+    assert harness.requests_for(["/source/"], snapshot) == [
+        "/source/", "/source/%EF%BF%BD.md",
+        "/source/r%EF%BF%BD%40main/%EF%BF%BD.md"]
+
+
+@pytest.mark.parametrize("source, malformed", [
+    (r'"\1"', True), (r'"\00"', True), (r'"\08"', True), (r'"\8"', True),
+    (r'"\9"', True), (r'"\x4"', True), (r'"\xZZ"', True), (r'"\u12"', True),
+    (r'"\u{110000}"', True), (r'"\u{}"', True), (r"`\1`", True),
+    (r"() => { return `\8`; }", True),
+    (r"String.raw`\1`", False), (r"tag`\u{zz}`", False), (r'"\0"', False),
+    (r'"\u{0000000041}"', False), (r'"\d"', False), (r'"\x41\u0041"', False),
+], ids=["octal", "octal-zero", "zero-then-eight", "eight", "nine",
+        "short-hex", "bad-hex", "short-unicode", "past-u10ffff",
+        "empty-code-point", "untagged-template", "returned-template",
+        "tagged-raw", "tagged", "nul", "long-code-point", "identity",
+        "well-formed"])
+def test_an_escape_a_module_refuses_is_malformed(source: str,
+                                                malformed: bool) -> None:
+    strings = harness.JsStrings(f"const s = {source};\n")
+    strings.scan()
+    assert strings.malformed is malformed
+
+
+def test_a_module_with_a_malformed_escape_is_a_named_failure() -> None:
+    """A module is strict code, so a legacy octal escape is a SyntaxError
+    and the browser loads none of it."""
+    files = {"/app.js": (JS, 'import "./child.js";\n'),
+             "/child.js": (JS, 'export const s = "\\1";\n')}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == ["t.bundle.syntax /child.js"]
+
+
+def test_the_lexer_reads_u_feff_as_whitespace() -> None:
+    """JavaScript's whitespace includes U+FEFF, so a regular expression
+    after `=` and a U+FEFF is still one, and the string inside it is no
+    route."""
+    pending: collections.deque = collections.deque()
+    routes: set[str] = set()
+    source = ('const ok =\ufeff/"\\/hidden"/.test(s);\n'
+              'const R = "/route";\n')
+    harness._scan_module("/app.js", source.encode("utf-8"), pending, routes)
+    assert routes == {"/route"}
+
+
+@pytest.mark.parametrize("static", [True, False], ids=["static", "dynamic"])
+def test_a_redirected_module_is_a_named_failure(static: bool) -> None:
+    """A browser follows a redirect to a module this harness would have to
+    judge in its place: refused by name, never judged as its status."""
+    importer = ('import "./child.js";\n' if static
+                else 'import("./child.js").catch(() => null);\n')
+    files = {"/app.js": (JS, importer), "/child.js": ("", "", 302)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+        answer = harness.get(port, "/child.js")
+    assert _failures(verdict) == [
+        f"t.bundle.{'module' if static else 'dynamic'} /child.js"]
+    assert answer.status is None
+    assert answer.error == f"HTTP 302, {harness.REDIRECTED}"
+
+
+@pytest.mark.parametrize("value, essence", [
+    (" text/javascript ; charset=utf-8", "text/javascript"),
+    ("TEXT/JAVASCRIPT", "text/javascript"),
+    ("text/javascript\xa0", ""),
+    ("text /javascript", ""),
+    ("text/ javascript", ""),
+    ("text/javascript, text/html", ""),
+    ("text/javascript;x=1, text/html", ""),
+    ("/javascript", ""),
+    ("text/", ""),
+    ("text", ""),
+], ids=["whitespace", "upper-case", "nbsp", "space-before-slash",
+        "space-after-slash", "two-values", "parameter-then-value",
+        "no-type", "no-subtype", "no-slash"])
+def test_a_content_type_is_parsed_as_a_browser_parses_it(
+        value: str, essence: str) -> None:
+    answer = harness.Answer(200, {"content-type": value}, b"", None)
+    assert harness.media_type(answer) == essence
+
+
+def test_a_repeated_content_type_is_read_as_one() -> None:
+    """A browser joins a repeated header's values, then takes the last that
+    parses; this harness joins them and does not split them, so a module
+    sent with two types is refused by name, never judged by one of them."""
+    files = {"/app.js": (JS, 'import "./child.js";\n'),
+             "/child.js": ((JS, "text/html"), "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+        answer = harness.get(port, "/child.js")
+    assert answer.headers["content-type"] == f"{JS}, text/html"
+    assert _failures(verdict) == ["t.bundle.module-type /child.js"]
+
+
+def test_no_line_the_harness_prints_can_be_forged_or_raise(capsys) -> None:
+    """A name or a reason may hold what a server sent: a newline, an ANSI
+    escape, a bidirectional override, a lone surrogate. None of it reaches
+    the log as itself, so no line can be forged and none raises."""
+    verdict = harness.Verdict(keep_going=True)
+    verdict.check("t.bundle.bare x\ud83d\nAT-R1 HTTP half: PASS", False,
+                  "a\x1b[32m\u202eb\nAT-R1 HTTP half: PASS (1 assertions held)")
+    verdict.note("GET /\ud83d\r\nAT-R1 HTTP half: PASS")
+    verdict.report()
+    out = capsys.readouterr().out
+    out.encode("utf-8")                 # no lone surrogate reached the stream
+    assert "\x1b" not in out and "\u202e" not in out and "\r" not in out
+    assert not [line for line in out.splitlines()
+                if line.startswith("AT-R1 HTTP half: PASS")]
+    assert "      | AT-R1 HTTP half: PASS (1 assertions held)" in out
+
+
+def test_a_redirected_route_is_named_as_a_redirect(tmp_path: Path) -> None:
+    """Never as a dropped connection, which names a handler that raised."""
+    index = harness.Answer(200, {"content-type": "text/html"},
+                           _page("./app.js").encode("utf-8"), None)
+    files = {"/app.js": (JS, 'const R = "/moved";\n'),
+             "/moved": ("", "", 302)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.check_routes(_quiet_server(tmp_path, port), index,
+                             {"documents": []}, {}, None, verdict)
+    moved = [failure for failure in verdict.failures
+             if failure.ident == "t.route /moved"]
+    assert len(moved) == 1
+    assert harness.REDIRECTED in moved[0].why
+    assert "dropped connection" not in moved[0].why
+
+
+@pytest.mark.parametrize("body, expected", [
+    (f"<frameset></frameset>{_ENTRY}", ["t.bundle.unmodeled", "t.bundle.entry"]),
+    (f"<plaintext></plaintext>{_ENTRY}", ["t.bundle.entry"]),
+], ids=["after-a-frameset", "after-a-plaintext"])
+def test_a_module_script_nothing_closes_the_way_to_is_no_entry(
+        body: str, expected: list) -> None:
+    """Nothing closes a `<frameset>` or a `<plaintext>`: a browser ignores
+    a script after `</frameset>`, and reads one after `<plaintext>` as text."""
+    files = {"/app.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, f"<html><body>{body}</body></html>", {},
+                              verdict, "t")
+    assert _failures(verdict) == expected
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at ba216f84: JavaScript's own whitespace around an
+# import (r4178913887), no server value in a catalog reason, and redaction
+# that sees through percent-encoding (r4178913911), and an encoded dot only
+# as a whole segment (r4178913926).
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("source, queued", [
+    ('import"./a.js";\n', [("/views/a.js", True)]),
+    ('export * from"./b.js";\n', [("/views/b.js", True)]),
+    ('import("./c.js");\n', [("/views/c.js", False)]),
+    ('import("./d.js");\n', [("/views/d.js", False)]),
+    ('import　"./e.js";\n', [("/views/e.js", True)]),
+    ("import" + " \n" * 40 + '"./f.js";\n', [("/views/f.js", True)]),
+    ('import /* ' + "x" * 80 + ' */ "./g.js";\n', [("/views/g.js", True)]),
+    ('import(\n  // ' + "y" * 80 + '\n  "./h.js");\n', [("/views/h.js", False)]),
+    ('loader.import("./i.js");\n', []),
+    ('loader . import("./j.js");\n', []),
+    ('loader?.import("./k.js");\n', []),
+    ('import\x1c"./l.js";\n', []),
+    ('import\x85"./m.js";\n', []),
+], ids=["static-feff", "from-feff", "dynamic-feff", "feff-before-paren",
+        "ideographic-space", "long-whitespace", "long-block-comment",
+        "long-line-comment", "member-call", "spaced-member-call",
+        "optional-member-call", "python-only-space", "next-line"])
+def test_an_import_is_found_through_javascript_s_whitespace(
+        source: str, queued: list) -> None:
+    """U+FEFF and every space separator are JavaScript whitespace, as
+    Python's `\\s` is not; a run of it, or a comment, of any length; and a
+    method named `import` is a call. U+001C and U+0085 are whitespace to
+    Python only, so no import is read through them."""
+    pending: collections.deque = collections.deque()
+    routes: set[str] = set()
+    harness._scan_module("/views/x.js", source.encode("utf-8"), pending, routes)
+    assert [(path, static) for path, static, _importer in pending] == queued
+
+
+@pytest.mark.parametrize("envelope, wrong", [
+    ('"schema_version": 2, "kind": "workbench-model-catalog"', "schema_version"),
+    ('"schema_version": 1, "kind": "SENT-KIND-%s"' % ENCODED, "kind"),
+    ('"schema_version": "SENT-VERSION", "kind": "SENT-KIND"',
+     "schema_version and kind"),
+], ids=["version", "kind-with-an-encoded-token", "both"])
+def test_a_catalog_envelope_reason_quotes_nothing_it_was_sent(
+        capsys, envelope: str, wrong: str) -> None:
+    files = {harness.CATALOG_ROUTE: ("application/json",
+                                     '{%s, "models": []}' % envelope)}
+    verdict = harness.Verdict(keep_going=True)
+    verdict.keep_secret(TOKEN)
+    with served(files) as port:
+        harness.check_catalog(_Server(port), TOKEN, verdict)
+    verdict.report()
+    out = capsys.readouterr().out
+    failed = [f for f in verdict.failures
+              if f.ident == "t.catalog envelope is the one the chat rail adopts"]
+    assert len(failed) == 1 and failed[0].why.startswith(
+        f"the catalog's {wrong} is not what the chat rail adopts")
+    for sent in ("SENT-", ENCODED, TOKEN):
+        assert sent not in out and sent not in failed[0].why
+
+
+def test_an_available_entry_is_counted_and_never_quoted(capsys) -> None:
+    models = [{"model_id": f"SENT-ID-{ENCODED}", "available": True},
+              {"model_id": "SENT-ID-2", "available": True},
+              {"model_id": "SENT-ID-3", "available": False}]
+    files = {harness.CATALOG_ROUTE: (
+        "application/json", json.dumps({"schema_version": 1,
+                                        "kind": harness.CATALOG_KIND,
+                                        "models": models}))}
+    verdict = harness.Verdict(keep_going=True)
+    verdict.keep_secret(TOKEN)
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE})) as port:
+        harness.check_catalog(_Server(port), TOKEN, verdict)
+    verdict.report()
+    out = capsys.readouterr().out
+    assert _failures(verdict) == ["t.catalog offers no available entry"]
+    assert "offers 2 available entries" in verdict.failures[0].why
+    assert "SENT-ID" not in out and ENCODED not in out
+
+
+@pytest.mark.parametrize("make", [
+    lambda: ENCODED,
+    lambda: ENCODED.replace("%", "%25"),
+    lambda: TOKEN[:10] + ENCODED[30:],
+    lambda: "".join(f"%{ord(c):02x}" for c in TOKEN),
+], ids=["encoded", "encoded-twice", "partly-encoded", "lower-case-hex"])
+def test_an_encoded_token_is_redacted_too(capsys, make) -> None:
+    """Every line the harness prints: a percent-encoded token in a bundle
+    path or a request target, which literal replacement passes."""
+    encoded = make()
+    verdict = harness.Verdict(keep_going=True)
+    verdict.keep_secret(TOKEN)
+    verdict.check(f"t.bundle.bare x-{encoded}", False,
+                  f"/app.js imports 'x-{encoded}'")
+    verdict.note(f"GET /source/{encoded}.md -> HTTP 404")
+    verdict.report()
+    out = capsys.readouterr().out
+    assert encoded not in out and TOKEN not in out
+    assert f"/source/{harness.REDACTED}.md" in out
+
+
+def test_an_encoded_run_without_the_token_is_kept(capsys) -> None:
+    verdict = harness.Verdict(keep_going=True)
+    verdict.keep_secret(TOKEN)
+    verdict.note("GET /source/caf%C3%A9-notes.md -> HTTP 200")
+    assert "/source/caf%C3%A9-notes.md" in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("snapshot, caps, reason_holds", [
+    ({"documents": f"SENT-{ENCODED}"}, {}, "they are a str (not quoted)"),
+    ({"documents": []}, {}, "they are an empty list (not quoted)"),
+], ids=["documents-a-string", "documents-empty"])
+def test_a_snapshot_reason_quotes_nothing_it_was_sent(
+        tmp_path: Path, capsys, snapshot: dict, caps: dict,
+        reason_holds: str) -> None:
+    files = {"/snapshot.json": ("application/json", json.dumps(snapshot)),
+             "/capabilities": ("application/json",
+                               json.dumps({"install": {"mode": "local"}}))}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.check_pages(_quiet_server(tmp_path, port), _HTML_INDEX,
+                            verdict)
+    failed = [f for f in verdict.failures if f.ident == "t.snapshot non-empty"]
+    assert len(failed) == 1 and reason_holds in failed[0].why
+    assert "SENT-" not in capsys.readouterr().out
+
+
+def test_a_grouping_reason_quotes_neither_the_field_nor_its_value(
+        capsys) -> None:
+    caps = {"display": {"fields": {"grouping": {"field": "SENT-FIELD"}}}}
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_grouping("t", {"SENT-FIELD": [{"id": "SENT-TILE"}]}, caps,
+                           verdict)
+    assert _failures(verdict) == ["t.snapshot fills the grouping station"]
+    assert "SENT-" not in capsys.readouterr().out
+
+
+def test_a_record_and_base_reason_quote_nothing_they_were_sent(
+        tmp_path: Path, capsys) -> None:
+    page = _opener_page(FORWARD, records=[_record(kind="SENT-KIND",
+                                                  port="SENT-PORT")])
+    state, opener = _opener(tmp_path, page)
+    verdict = harness.Verdict(keep_going=True)
+    harness.check_console_opener("t", PORT, _printed(opener), state,
+                                 tmp_path / "repo", verdict, hosts=SERVED)
+    links = harness._IndexLinks()
+    links.feed(f'<base href="/SENT-BASE/">{_ENTRY}')
+    harness._check_page_resolution(links, harness.plane_origin(PORT), verdict,
+                                   "t")
+    assert _failures(verdict) == [RECORD, "t.bundle.base"]
+    assert "SENT-" not in capsys.readouterr().out
+    assert not any("SENT-" in str(failure) for failure in verdict.failures)
+
+
+@pytest.mark.parametrize("ref, fetched", [
+    ("./child%2Ejs", "/child%2Ejs"),
+    ("./%2e.x/child.js", "/%2e.x/child.js"),
+    ("./x%2e%2e/child.js", "/x%2e%2e/child.js"),
+], ids=["inside-a-file-name", "dot-then-more", "inside-a-directory-name"])
+def test_an_encoded_dot_inside_a_segment_is_no_divergence(
+        ref: str, fetched: str) -> None:
+    """Only a whole `%2e`, `.%2e`, `%2e.` or `%2e%2e` segment is a dot
+    segment to a browser; one inside a name is requested as it is."""
+    files = {fetched: (JS, "export const x = 1;\n"),
+             "/app.js": (JS, f'import "{ref}";\n')}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == []
+    assert modules == 2
+
+
+@pytest.mark.parametrize("ref", ["./.%2E/child.js", "./%2E./child.js",
+                                 "./sub/%2e"],
+                         ids=["dot-encoded-dot", "encoded-dot-dot",
+                              "last-segment"])
+def test_every_encoded_dot_segment_is_refused(ref: str) -> None:
+    files = {"/app.js": (JS, f'import "{ref}";\n')}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == [f"t.bundle.divergent {ref!r}"]
+
+
+@pytest.mark.parametrize("source", [
+    '// a comment\rimport "./a.js";\n',
+    '// a comment\r\nimport "./a.js";\n',
+    '// a comment\u2028import "./a.js";\n',
+    '// a comment\u2029import "./a.js";\n',
+    '#!/usr/bin/env node /*\nimport "./a.js";\n',
+], ids=["cr", "crlf", "line-separator", "paragraph-separator", "hashbang"])
+def test_a_line_comment_ends_where_javascript_ends_it(source: str) -> None:
+    """At any LineTerminator, never only at LF; and a module's first line
+    is a comment where it starts with `#!` (Copilot's review of #75 at
+    9229c659, its overview)."""
+    pending: collections.deque = collections.deque()
+    routes: set[str] = set()
+    harness._scan_module("/views/x.js", source.encode("utf-8"), pending, routes)
+    assert [(path, static) for path, static, _importer in pending] == [
+        ("/views/a.js", True)]
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at 3392f934: a template's `${…}` is code
+# (r4179115282), and the page walked is the one the opener opens, at its
+# own origin (r4179115311).
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("source, queued, routes", [
+    ('const t = `${await import("./child.js")}`;\n',
+     [("/views/child.js", False)], set()),
+    ('const t = `a${ "}" }b${ {k: 1}["/inner"] }c`;\nconst R = "/after";\n',
+     [], {"/inner", "/after"}),
+    ('const t = `${ `in${ import("./deep.js") }` }`;\n',
+     [("/views/deep.js", False)], set()),
+    ('const t = `${x}`;\nimport "./after.js";\n',
+     [("/views/after.js", True)], set()),
+    ('const t = `${/}/.test("}") ? await import("./child.js") : ""}`;\n',
+     [("/views/child.js", False)], set()),
+], ids=["dynamic-import", "brace-in-a-string-and-an-object",
+        "nested-template", "code-after-the-template",
+        "regular-expression-first"])
+def test_a_template_s_interpolation_is_read_as_code(
+        source: str, queued: list, routes: set) -> None:
+    pending: collections.deque = collections.deque()
+    found: set[str] = set()
+    harness._scan_module("/views/x.js", source.encode("utf-8"), pending, found)
+    assert [(path, static) for path, static, _importer in pending] == queued
+    assert found == routes
+
+
+@pytest.mark.parametrize("app", [
+    'const t = `${await import("./child.js")}`;\n',
+    'const t = `${/}/.test("}") ? await import("./child.js") : ""}`;\n',
+], ids=["import", "after-a-regular-expression"])
+def test_a_dependency_imported_inside_an_interpolation_is_judged(
+        app: str) -> None:
+    """Copilot's examples (r4179115282, and r4179220628, where a `/` opens
+    the interpolation as a regular expression holding a `}`): the child,
+    imported only inside `${…}`, imports a module that is missing, which the
+    browser's import fails on."""
+    files = {"/app.js": (JS, app),
+             "/child.js": (JS, 'import "./missing.js";\n')}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == ["t.bundle.module /missing.js"]
+    assert modules == 2
+
+
+_LOCAL_PAGE = ('<html><head><link rel="stylesheet" href="./s.css">'
+               '<script type="module" src="./app.js"></script></head></html>')
+
+
+def test_the_page_its_modules_routes_and_catalog_go_to_the_forward_s_host(
+        tmp_path: Path) -> None:
+    """A browser asks everything of the origin the opener opens, with its
+    host in `Host`, which the plane's loopback gate reads; and it asks the
+    forward's own path and query."""
+    seen: list = []
+    files = {"/index.html?v=1": ("text/html; charset=utf-8", _LOCAL_PAGE),
+             "/app.js": (JS, 'const R = "/snapshot.json";\n'
+                             f'const C = "{harness.CATALOG_ROUTE}";\n'
+                             f'const K = "{harness.CATALOG_KIND}";\n'),
+             "/s.css": ("text/css", "body { margin: 0; }\n"),
+             "/snapshot.json": ("application/json", "{}"),
+             harness.CATALOG_ROUTE: ("application/json",
+                                     '{%s, "models": []}' % _ENVELOPE)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE}),
+                seen=seen) as port:
+        server = _quiet_server(tmp_path, port)
+        answer, host, page = harness.check_console_page(
+            server, f"http://localhost:{port}/index.html?v=1"
+                    f"#console_token={TOKEN}", verdict)
+        harness.check_catalog(server, TOKEN, verdict, host=host)
+        harness.check_routes(server, answer, {"documents": []}, {}, TOKEN,
+                             verdict, host=host, page=page)
+    assert (host, page) == ("localhost", "/index.html?v=1")
+    assert _failures(verdict) == []
+    assert {path for path, _host in seen} == {
+        "/index.html?v=1", "/app.js", "/s.css", "/snapshot.json",
+        harness.CATALOG_ROUTE}
+    assert {sent for _path, sent in seen} == {f"localhost:{port}"}
+
+
+@pytest.mark.parametrize("index_html, expected", [
+    (None, ["t.console page is HTML", "t.bundle.entry",
+            "t.bundle names the catalog route",
+            "t.bundle names the catalog kind"]),
+    (("text/html; charset=iso-2022-kr", _LOCAL_PAGE),
+     ["t.console page is UTF-8"]),
+    (("text/html", _LOCAL_PAGE), []),
+], ids=["missing", "not-utf-8", "served"])
+def test_one_serve_walks_the_page_the_opener_opens(
+        tmp_path: Path, monkeypatch, index_html, expected: list) -> None:
+    """`/` loads a good bundle; the opener opens `/index.html`, which is the
+    page a user's browser shows, so it is the one judged and walked."""
+    files = _pages(json.dumps({"install": {"mode": "local"}}))
+    files["/snapshot.json"] = ("application/json", json.dumps(_SNAPSHOT))
+    files.update({
+        "/": ("text/html", _LOCAL_PAGE),
+        "/app.js": (JS, f'const C = "{harness.CATALOG_ROUTE}";\n'
+                        f'const K = "{harness.CATALOG_KIND}";\n'),
+        "/s.css": ("text/css", ""),
+        harness.CATALOG_ROUTE: ("application/json",
+                                '{%s, "models": []}' % _ENVELOPE)})
+    if index_html is not None:
+        files["/index.html"] = index_html
+    with served(files, guarded=frozenset({harness.CATALOG_ROUTE})) as port:
+        target = f"http://127.0.0.1:{port}/index.html#console_token={TOKEN}"
+        state = tmp_path / "state"
+        console = state / harness.CONSOLE_DIRNAME
+        console.mkdir(parents=True)
+        tmp_path.chmod(0o700)
+        state.chmod(0o700)
+        console.chmod(0o700)
+        opener = console / f"{port}.html"
+        opener.write_text(_opener_page(target, records=[
+            _record(target, port=port)]), encoding="utf-8")
+        opener.chmod(0o600)
+        server = _quiet_server(tmp_path, port)
+        server.out.write_text(f"  console {opener.as_uri()}\n",
+                              encoding="utf-8")
+        index = harness.get(port, "/")
+        monkeypatch.setattr(harness, "launch", lambda *_args: (server, index))
+        monkeypatch.setattr(harness, "stop_and_look", lambda *_a, **_k: None)
+        verdict = harness.Verdict(keep_going=True)
+        harness.serve_one("t", tmp_path / "repo",
+                          types.SimpleNamespace(state_dir=state), verdict)
+    assert [failed for failed in _failures(verdict)
+            if not failed.startswith("t.route ")] == expected
+
+
+def test_a_page_reference_is_resolved_against_the_page() -> None:
+    """A query-only reference names the page's own path, `/index.html`."""
+    files = {"/index.html?m=1": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        _routes, modules = harness.derive_bundle(
+            port, '<html><head><script type="module" src="?m=1"></script>'
+                  "</head></html>", {}, verdict, "t", page="/index.html")
+    assert _failures(verdict) == []
+    assert modules == 1
+
+
+@pytest.mark.parametrize("head, served_as, expected", [
+    (f'{_ENTRY}<script type="module" src="./app.js?v=1&copy=2"></script>',
+     None, ["t.bundle.unmodeled"]),
+    (f'{_ENTRY}<link rel="stylesheet" href="./s.css?v=1&copy=2">',
+     None, ["t.bundle.unmodeled"]),
+    ('<script type="module" src="./app.js?v=1&amp;copy=2"></script>',
+     ("/app.js?v=1&copy=2", (JS, "export const x = 1;\n")), []),
+    (f'<link rel="stylesheet" href="./s.css?v=1&amp;copy=2">{_ENTRY}',
+     ("/s.css?v=1&copy=2", ("text/css", "")), []),
+], ids=["script-unterminated", "sheet-unterminated", "script-escaped",
+        "sheet-escaped"])
+def test_a_page_reference_with_an_unterminated_reference_is_refused(
+        head: str, served_as, expected: list) -> None:
+    """`html.unescape` reads `&copy=2` as `\u00a9=2`; a browser keeps it as
+    text in an attribute, so the two would fetch different URLs (Copilot
+    review of #75 at 0717f72f, r4179220641). `&amp;copy=2` is read alike."""
+    files = {"/app.js": (JS, "export const x = 1;\n")}
+    if served_as is not None:
+        files[served_as[0]] = served_as[1]
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, f"<html><head>{head}</head></html>", {},
+                              verdict, "t")
+    assert _failures(verdict) == expected
+
+
+@pytest.mark.parametrize("host, origin", [
+    ("127.0.0.1", "http://127.0.0.1:8080"),
+    ("localhost", "http://localhost:8080"),
+    ("::1", "http://[::1]:8080"),
+], ids=["ipv4", "localhost", "ipv6"])
+def test_a_page_s_origin_brackets_an_ipv6_host(host: str, origin: str) -> None:
+    assert harness.plane_origin(8080, host) == origin
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at b7b9b843: a `/` after an operand divides, and
+# one after a statement's condition opens a regular expression
+# (r4179348386); the page's links resolve against its base URL
+# (r4179348414).
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("source, queued, routes", [
+    ('let n = 2; const ratio = n++ / 2; import "./missing.js";\n',
+     ["/views/missing.js"], set()),
+    ('let n = 2; const ratio = n-- / 2; import "./missing.js";\n',
+     ["/views/missing.js"], set()),
+    ('const q = a[0]++ / 2; import "./e.js";\n', ["/views/e.js"], set()),
+    ('x = ++/a"/.lastIndex; import "./b.js";\n', ["/views/b.js"], set()),
+    ('function f() { return ++/a"/.lastIndex; } import "./b.js";\n',
+     ["/views/b.js"], set()),
+    ('if (ok) /"/.test(s); import "./c.js";\n', ["/views/c.js"], set()),
+    ('while (a(b)) /"/.test(s); import "./c.js";\n', ["/views/c.js"], set()),
+    ('const q = f(x) / 2; const R = "/route";\n', [], {"/route"}),
+    ('const q = (a + b) / 2; const R = "/route";\n', [], {"/route"}),
+], ids=["postfix-increment", "postfix-decrement", "postfix-after-index",
+        "prefix-increment", "prefix-after-return", "after-if", "after-while",
+        "after-a-call", "after-a-group"])
+def test_a_slash_is_read_as_division_or_a_regular_expression_by_what_ends_before_it(
+        source: str, queued: list, routes: set) -> None:
+    pending: collections.deque = collections.deque()
+    found: set[str] = set()
+    harness._scan_module("/views/x.js", source.encode("utf-8"), pending, found)
+    assert [path for path, _static, _importer in pending] == queued
+    assert found == routes
+
+
+@pytest.mark.parametrize("head, served_as", [
+    ('<base href="/"><script type="module" src="?m=1"></script>',
+     {"/?m=1": (JS, "export const x = 1;\n")}),
+    (f'<base href="/"><link rel="stylesheet" href="?s=1">{_ENTRY}',
+     {"/?s=1": ("text/css", ""), "/app.js": (JS, "export const x = 1;\n")}),
+    ('<base href="./"><script type="module" src="?m=1"></script>',
+     {"/?m=1": (JS, "export const x = 1;\n")}),
+], ids=["script", "stylesheet", "relative-base"])
+def test_the_page_s_links_resolve_against_its_base_url(head: str,
+                                                       served_as: dict) -> None:
+    """On `/index.html` with `<base href="/">`, `?m=1` is `/?m=1`, and
+    never the page's own `/index.html?m=1`, which is not served here."""
+    verdict = harness.Verdict(keep_going=True)
+    with served(served_as) as port:
+        harness.derive_bundle(port, f"<html><head>{head}</head></html>", {},
+                              verdict, "t", page="/index.html")
+    assert _failures(verdict) == []
+
+
+def test_an_empty_base_is_the_page_itself_and_refused() -> None:
+    """`<base href="">` is the page's own URL, `/index.html`, not `/`."""
+    files = {"/app.js": (JS, "export const x = 1;\n")}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, f'<html><head><base href="">{_ENTRY}'
+                                    "</head></html>", {}, verdict, "t",
+                              page="/index.html")
+    assert _failures(verdict) == ["t.bundle.base"]
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at d50e8cef: a `/` right after a `}` divides or opens
+# a regular expression by what the `}` closed, which a lexer cannot tell, so
+# it is refused by name (r4180454790).
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("app", [
+    'const q = {} / 2; import "./missing.js";\n',
+    'const f = function () {} / 2; import "./missing.js";\n',
+    'const o = { m() { return 1; } } / 2; import "./missing.js";\n',
+    'const C = class {} / 2; import "./missing.js";\n',
+    'if (x) { y(); } /"/.test(z); import "./missing.js";\n',
+], ids=["object-literal", "function-expression", "object-with-a-method",
+        "class-expression", "block-then-regular-expression"])
+def test_a_slash_after_a_brace_is_refused_by_name(app: str) -> None:
+    """Copilot's examples, each with a missing static dependency after the
+    `/`: the run fails by name, and never passes past an import it may have
+    read as part of a regular expression."""
+    files = {"/app.js": (JS, app)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+    assert "t.bundle.ambiguous-slash /app.js" in _failures(verdict)
+
+
+@pytest.mark.parametrize("source", [
+    'function f() {} // a comment\nimport "./a.js";\n',
+    'function f() {} /* a comment */ import "./a.js";\n',
+    'const o = {}; const q = o / 2; import "./a.js";\n',
+    'const t = `${ {a: 1}.a / 2 }`; import "./a.js";\n',
+], ids=["line-comment", "block-comment", "after-a-semicolon",
+        "member-then-division"])
+def test_a_brace_with_no_slash_after_it_is_read_as_before(source: str) -> None:
+    strings = harness.JsStrings(source)
+    strings.scan()
+    assert strings.ambiguous is False
+    pending: collections.deque = collections.deque()
+    harness._scan_module("/views/x.js", source.encode("utf-8"), pending, set())
+    assert [path for path, _static, _importer in pending] == ["/views/a.js"]
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at ff04e015: a member's name is never a keyword
+# (r4180554323); and, in the self-pass after it, neither is a longer or a
+# private name, while a keyword after a spread or a decimal point still is.
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("app", [
+    'const q = obj.return / 2; import "./missing.js";\n',
+    'const q = obj . return / 2; import "./missing.js";\n',
+    'const q = obj?.return / 2; import "./missing.js";\n',
+    'const q = obj.if(1) / 2; import "./missing.js";\n',
+    'const q = obj . while (1) / 2; import "./missing.js";\n',
+    'const q = obj.of++ / 2; import "./missing.js";\n',
+    'const q = obj . in-- / 2; import "./missing.js";\n',
+], ids=["member", "spaced-member", "optional-member", "method-call",
+        "spaced-method-call", "postfix-after-a-member",
+        "postfix-after-a-spaced-member"])
+def test_a_member_named_as_a_keyword_is_an_operand(app: str) -> None:
+    """Copilot's examples (review of #75 at ff04e015, r4180554323): a
+    member's name is never a keyword, so the `/` after it divides, and the
+    missing static dependency after it is judged."""
+    files = {"/app.js": (JS, app)}
+    verdict = harness.Verdict(keep_going=True)
+    with served(files) as port:
+        harness.derive_bundle(port, _page("./app.js"), {}, verdict, "t")
+    assert _failures(verdict) == ["t.bundle.module /missing.js"]
+
+
+def _queued(source: str) -> list:
+    pending: collections.deque = collections.deque()
+    harness._scan_module("/views/x.js", source.encode("utf-8"), pending, set())
+    return [path for path, _static, _importer in pending]
+
+
+@pytest.mark.parametrize("source", [
+    'const a = [...typeof /"/]; import "./a.js";\n',
+    'const a = [...await /"/]; import "./a.js";\n',
+    'f(... void /"/); import "./a.js";\n',
+    'const b = 1. in /"/; import "./a.js";\n',
+    'const b = 1_0.\ninstanceof /"/; import "./a.js";\n',
+], ids=["spread-typeof", "spread-await", "spaced-spread-void",
+        "decimal-point-in", "decimal-point-then-a-line-break"])
+def test_a_keyword_after_a_spread_or_a_decimal_point_is_still_one(
+        source: str) -> None:
+    """The `.` of a spread's `...` or of a decimal literal (`1.`) is no
+    member access, so the keyword after it is one, and the `/` after that
+    opens a regular expression, whose `"` hides nothing after it."""
+    assert _queued(source) == ["/views/a.js"]
+
+
+@pytest.mark.parametrize("source", [
+    'const q = \u00f1return / 2; import "./a.js";\n',
+    'const q = \u00f1of++ / 2; import "./a.js";\n',
+    'class C { #return = 1; m() { return this.#return / 2; } }\n'
+    'import "./a.js";\n',
+    'class C { #if() { return 1; } m() { return this.#if() / 2; } }\n'
+    'import "./a.js";\n',
+    'const q = 1..return / 2; import "./a.js";\n',
+    'const q = 1 .return / 2; import "./a.js";\n',
+    'const q = 1.5.return / 2; import "./a.js";\n',
+    'const q = 1e5.of++ / 2; import "./a.js";\n',
+    'const q = a1.return / 2; import "./a.js";\n',
+], ids=["longer-name", "longer-name-then-postfix", "private-name",
+        "private-method-call", "member-of-a-decimal-literal",
+        "member-of-a-spaced-number", "member-of-a-fraction",
+        "member-of-an-exponent", "member-of-a-name-ending-in-a-digit"])
+def test_a_longer_or_private_name_is_no_keyword(source: str) -> None:
+    """A keyword's letters at the end of a longer name (`\u00f1return`), or
+    of a private one (`this.#return`), are no keyword. And a name after the
+    `.` that follows a number (`1..return`, `1 .return`, `1.5.return`) is a
+    member's, as after any other: only a decimal point (`1. in`) leaves the
+    keyword one. Each `/` divides."""
+    assert _queued(source) == ["/views/a.js"]
+
+
+# ---------------------------------------------------------------------------
+# Copilot's review overview at ea4f7838 named "a verified lexer error" with no
+# finding. The pass that followed read every keyword by where it stands: `of`
+# is one only in a `for` head, `for await (` opens a condition, and a spread,
+# `default`, `extends`, `break`, `continue` and `debugger` come before an
+# expression or a statement.
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("source", [
+    'for (const x of /"/.exec(s)) f(x); import "./a.js";\n',
+    'for await (const x of /"/.exec(s)) f(x); import "./a.js";\n',
+    'for await (const x of xs) /"/.test(x); import "./a.js";\n',
+    'for (const x of ++/"/.lastIndex) f(x); import "./a.js";\n',
+    'f(.../"/.exec(s)); import "./a.js";\n',
+    'f(... /"/.exec(s)); import "./a.js";\n',
+    'export default /"/; import "./a.js";\n',
+    'class C extends /"/.constructor {} import "./a.js";\n',
+    'for (;;) { break\n/"/.test(s) } import "./a.js";\n',
+    'for (;;) { continue\n/"/.test(s) } import "./a.js";\n',
+    'debugger\n/"/.test(s); import "./a.js";\n',
+    'const q = a / /"/.lastIndex; import "./a.js";\n',
+], ids=["of-in-a-for-head", "of-in-a-for-await-head",
+        "after-a-for-await-condition", "prefix-after-of-in-a-for-head",
+        "after-a-spread", "after-a-spaced-spread", "after-export-default",
+        "after-extends", "after-break-and-a-line-break",
+        "after-continue-and-a-line-break", "after-debugger-and-a-line-break",
+        "after-a-division"])
+def test_a_slash_where_an_expression_starts_opens_a_regular_expression(
+        source: str) -> None:
+    """Each `/` opens a regular expression, whose `"` hides nothing after
+    it."""
+    assert _queued(source) == ["/views/a.js"]
+
+
+@pytest.mark.parametrize("source", [
+    'const of = 4; const q = of / 2; import "./a.js";\n',
+    'let of = 4; of++ / 2; import "./a.js";\n',
+    'for (const x of f(of / 2)) g(x); import "./a.js";\n',
+    'for (const x of xs) of / 2; import "./a.js";\n',
+    'const q = 1. / 2; import "./a.js";\n',
+    'const q = f(await (x)) / 2; import "./a.js";\n',
+    'const q = await (x) / 2; import "./a.js";\n',
+], ids=["of-as-a-name", "of-as-a-name-then-postfix",
+        "of-in-a-call-in-a-for-head", "of-after-a-for-head",
+        "after-a-decimal-point", "after-a-call-after-await",
+        "after-an-awaited-group"])
+def test_a_slash_after_an_operand_divides(source: str) -> None:
+    """`of` outside a `for` head is a name, a lone `.` ends a number, not
+    a spread, and only `for await (` opens a `for` head, never another
+    `await (`; each `/` divides."""
+    assert _queued(source) == ["/views/a.js"]
+
+
+# ---------------------------------------------------------------------------
+# Copilot review of #75 at 234229d7: `of` is a keyword only as a `for` head's
+# separator, never in a classic loop's initializer, condition or update
+# (r4180899047).
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("source", [
+    # a name, so each `/` divides
+    'let of = 4; for (; of / 2; ) break; import "./a.js";\n',
+    'for (let i = of / 2; i < 1; i++) break; import "./a.js";\n',
+    'for (;; of / 2) break; import "./a.js";\n',
+    'for (let of = 0; of < 2; of++ / 2) f(); import "./a.js";\n',
+    'for (const k in of / 2) f(k); import "./a.js";\n',
+    'for (const x of of / 2) f(x); import "./a.js";\n',
+    # the separator, so each `/` opens a regular expression
+    'for (const [a, b] of /"/.exec(s)) f(a); import "./a.js";\n',
+    'for (const {a} of /"/.exec(s)) f(a); import "./a.js";\n',
+    'for (o.x of /"/.exec(s)) f(); import "./a.js";\n',
+    'for (o.of of /"/.exec(s)) f(); import "./a.js";\n',
+    'for ((x) of /"/.exec(s)) f(); import "./a.js";\n',
+    'for (const of of /"/.exec(s)) f(of); import "./a.js";\n',
+], ids=["name-in-a-condition", "name-in-an-initializer", "name-in-an-update",
+        "name-then-postfix-in-an-update", "name-after-in", "name-as-the-iterable",
+        "after-an-array-pattern", "after-an-object-pattern",
+        "after-a-member-target", "after-a-member-named-of",
+        "after-a-parenthesized-target", "after-a-binding-named-of"])
+def test_of_is_a_keyword_only_as_a_for_head_s_separator(source: str) -> None:
+    """Copilot's example first: in a classic `for` head, `of` is a name, and
+    the import after its division is judged. After a binding or a target,
+    it is the separator, and the `"` of the regular expression after it
+    hides nothing."""
+    assert _queued(source) == ["/views/a.js"]
+
+
+# ---------------------------------------------------------------------------
+# A differential check of the lexer against node's own module parser, run in
+# the pass after r4180899047, found the statements a line break ends
+# (automatic semicolon insertion) read as going on: a `/` on the next line
+# opens a regular expression there.
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("source, queued", [
+    ('let a = 1; a\n++/"/.lastIndex; import "./a.js";\n', ["/views/a.js"]),
+    ('let a = 1; a /* c\n*/ ++/"/.lastIndex; import "./a.js";\n',
+     ["/views/a.js"]),
+    ('outer: for (;;) { break outer\n/"/.lastIndex } import "./a.js";\n',
+     ["/views/a.js"]),
+    ('outer: for (;;) { continue outer\n/"/.lastIndex } import "./a.js";\n',
+     ["/views/a.js"]),
+    ('let x\n/"/.lastIndex; import "./a.js";\n', ["/views/a.js"]),
+    ('import "./b.js"\n/"/.lastIndex; import "./a.js";\n',
+     ["/views/b.js", "/views/a.js"]),
+    ('import b from "./b.js"\n/"/.lastIndex; import "./a.js";\n',
+     ["/views/b.js", "/views/a.js"]),
+    # a line break that ends nothing: each `/` divides
+    ('let a = 1; a++\n/ 2; import "./a.js";\n', ["/views/a.js"]),
+    ('const s = "./b.js"\n/ 2; import "./a.js";\n', ["/views/a.js"]),
+    ('let x = y\n/ 2; import "./a.js";\n', ["/views/a.js"]),
+    ('const q = a\n/ 2; import "./a.js";\n', ["/views/a.js"]),
+], ids=["prefix-after-a-line-break", "prefix-after-a-comment-holding-one",
+        "after-a-labelled-break", "after-a-labelled-continue",
+        "after-a-lone-binding", "after-an-import", "after-an-import-from",
+        "postfix-then-a-line-break", "a-string-then-a-line-break",
+        "a-binding-with-an-initializer", "a-name-then-a-line-break"])
+def test_a_line_break_that_ends_a_statement_opens_a_regular_expression(
+        source: str, queued: list) -> None:
+    assert _queued(source) == queued
+
+
+# ---------------------------------------------------------------------------
+# Copilot's review overview at e4f81d48 named identifier-parsing errors with
+# no finding: a name's character that Python's `\w` lacks split the name, so
+# a keyword at its end was read as the keyword.
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("name", [
+    "x\u200creturn", "x\u200dreturn", "e\u0301return", "x\u203freturn",
+    "\u2118return", "x\u00b7return",
+], ids=["zwnj", "zwj", "combining-mark", "connector", "other-id-start",
+        "other-id-continue"])
+def test_every_character_of_a_name_is_read_as_the_name_s(name: str) -> None:
+    """Each name ends with `return`, which is no keyword there, so the `/`
+    after it divides and the import after that is judged."""
+    source = f'let {name} = 4; const q = {name} / 2; import "./a.js";\n'
+    assert _queued(source) == ["/views/a.js"]
diff --git a/tests_runtime/test_deploy_shape.py b/tests_runtime/test_deploy_shape.py
index d2f58e8b..9547efaa 100644
--- a/tests_runtime/test_deploy_shape.py
+++ b/tests_runtime/test_deploy_shape.py
@@ -14,6 +14,7 @@
 
 import re
 import shlex
+import tomllib
 from pathlib import Path
 from typing import Any
 
@@ -181,19 +182,25 @@ def test_the_run_count_sees_every_shell_separator(script: str, runs: int) -> Non
 
 
 def test_the_workflow_declares_the_required_job_and_its_steps() -> None:
-    """ONE job, the required one, running the WHOLE suite (plan 034 T036).
+    """ONE job runs the suite, the required one, running the WHOLE suite
+    (plan 034 T036).
 
     The DB-backed `runtime` job this pin used to require is folded into
     `validate` (RULED R1Q8 (a): `tests_runtime/` is part of the whole suite,
-    with PostgreSQL in the required job). A second job would now only run the
-    same database-backed cases twice, once required and once not."""
+    with PostgreSQL in the required job). A second suite job would now only
+    run the same database-backed cases twice, once required and once not.
+
+    The one other job is `acceptance` (plan 034 T095), and it runs no suite:
+    it runs AT-R1's HTTP half, a harness outside `testpaths`, on a machine
+    with no database service. The case below holds it to that."""
     jobs = yaml.safe_load(WORKFLOW.read_text(encoding="utf-8"))["jobs"]
     assert "validate" in jobs, (
         "`validate` is this repository's one REQUIRED status check "
         "(openDox-code#2) and the workflow no longer declares it")
-    assert sorted(jobs) == ["validate"], (
+    assert sorted(jobs) == ["acceptance", "validate"], (
         f"the workflow declares {sorted(jobs)}; the whole suite runs in the "
-        "required job, so a second job runs nothing the required one does not")
+        "required job, so a second suite job runs nothing the required one "
+        "does not, and `acceptance` (T095) is the one other job")
     steps = jobs["validate"]["steps"]
     names = [step.get("name") for step in steps]
     assert "pytest" in names and "Pin the triple" in names, names
@@ -219,6 +226,40 @@ def test_the_workflow_declares_the_required_job_and_its_steps() -> None:
         "`testpaths` names, so the step names nothing")
 
 
+def test_the_acceptance_job_runs_the_harness_on_a_clean_machine() -> None:
+    """`acceptance` runs AT-R1's HTTP half and nothing else (plan 034 T095).
+
+    The harness ASSERTS a clean machine, so the job may carry no service: a
+    database the job supplied would answer on the port the harness checks, or
+    stand in for the bundled server the install must bring. It runs no pytest
+    (the harness is not a test module, and `testpaths` does not name
+    `acceptance/`), and it installs nothing itself: the harness installs
+    `opendox[local]` into a fresh venv of its own, through the dependency lock
+    (`test_every_install_of_this_package_reads_one_dependency_lock`)."""
+    jobs = yaml.safe_load(WORKFLOW.read_text(encoding="utf-8"))["jobs"]
+    job = jobs["acceptance"]
+    assert "services" not in job, (
+        "the acceptance job declares a service; the harness asserts a clean "
+        "machine, which a database service breaks")
+    assert "container" not in job, (
+        "the acceptance job runs in a container; the harness asserts a clean "
+        "runner, and an image may carry a database or a sibling")
+    scripts = [step.get("run", "") or "" for step in job["steps"]]
+    assert [run for script in scripts for run in _pytest_runs(script)] == [], (
+        f"the acceptance job runs pytest ({scripts}); AT-R1's harness is not "
+        "a member of the suite")
+    assert not any("pip install" in script for script in scripts), scripts
+    assert scripts.count("python3 acceptance/at_r1_http.py") == 1, scripts
+    harness = ROOT / "acceptance" / "at_r1_http.py"
+    assert harness.is_file(), harness
+    testpaths = tomllib.loads(
+        (ROOT / "pyproject.toml").read_text(encoding="utf-8")
+    )["tool"]["pytest"]["ini_options"]["testpaths"]
+    assert not any(Path(path).parts[:1] == ("acceptance",)
+                   for path in testpaths), testpaths
+    assert not harness.name.startswith("test_"), harness.name
+
+
 def test_the_required_job_supplies_a_postgres_service_and_the_extras() -> None:
     """What the `runtime` job carried, now carried by the required one."""
     jobs = yaml.safe_load(WORKFLOW.read_text(encoding="utf-8"))["jobs"]
@@ -2373,7 +2414,11 @@ def test_every_install_of_this_package_reads_one_dependency_lock() -> None:
     a CONSTRAINTS file rather than a requirements one: it pins what is installed
     and installs nothing, so each install still chooses its own extras. There
     are TWO since plan 034 T036 folded the DB-backed `runtime` job into the
-    required one: that job's install, and the image's.
+    required one: that job's install, and the image's. And a THIRD since plan
+    034 T095, which is no workflow step: AT-R1's harness
+    (`acceptance/at_r1_http.py`) installs `opendox[local]` into a fresh venv
+    of its own, and passes the same lock with `-c` where the lock's own
+    interpreter runs it (CPython 3.12 on Linux, the `acceptance` job's).
 
     AT THE REPOSITORY ROOT, and that is load-bearing: `deploy/` holds the
     git-ignored `.env` that `.dockerignore` exists to keep out of the build
@@ -2411,6 +2456,14 @@ def test_every_install_of_this_package_reads_one_dependency_lock() -> None:
     dockerfile = (COMPOSE / "Dockerfile").read_text(encoding="utf-8")
     for text, where in ((workflow, "validate.yml"), (dockerfile, "Dockerfile")):
         assert text.count("-c constraints-cpython312-linux.txt") >= 1, where
+    # THE HARNESS'S INSTALL reads the same lock: it names the file, and it
+    # hands it to pip as a constraint, beside the `local` extra it installs.
+    harness = (ROOT / "acceptance" / "at_r1_http.py").read_text(
+        encoding="utf-8")
+    assert '"constraints-cpython312-linux.txt"' in harness, (
+        "AT-R1's harness installs this package without the dependency lock")
+    assert re.search(r'install \+= \["-c", str\(lock\)\]', harness), (
+        "AT-R1's harness names the lock but never passes it to pip")
     # AND THE IMAGE CARRIES IT, before the install that reads it.
     assert dockerfile.index("COPY constraints-cpython312-linux.txt") < \
         dockerfile.index("pip install --no-cache-dir"), (