diff --git a/README.md b/README.md
index c00517b..03ed770 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,16 @@ This repository is the single home for PyAutoLens performance measurement. It ex
 
 Results are framed by **astronomy instrument** (HST, Euclid, JWST, …) rather than by raw pixel counts. Pixel counts are recorded too, but the headline numbers a reader sees first are the ones that map onto a real observing programme.
 
+## Latest run-times
+
+The table below is auto-generated from the latest versioned artifacts under `results/`. Each row is the latest steady-state per-call cost for a likelihood path at a given instrument; numbers refresh whenever the producing scripts are rerun and committed. Hardware tier is **CPU only** today — laptop GPU and HPC GPU columns will land once `results/**` artifacts are tagged with a hardware label.
+
+<!-- BEGIN auto-table:headline -->
+_No data yet — run likelihood scripts to populate. See `likelihood/README.md`._
+<!-- END auto-table:headline -->
+
+(Generator: `scripts/build_readme.py`. Run `python scripts/build_readme.py` after producing new artifacts to refresh; `--check` exits non-zero in CI if it would change anything.)
+
 ## JAX gradients — currently out of scope
 
 Gradient profiling (`jax.grad` of the likelihood, autodiff-based optimisers) is **not yet** part of this repo. It is tracked in [`PyAutoLabs/autolens_workspace_developer/jax_profiling/gradient/`](https://github.com/PyAutoLabs/autolens_workspace_developer/tree/main/jax_profiling/gradient) and will fold into this repo in a future phase once the gradient story stabilises.
@@ -54,18 +64,27 @@ Examples that already exist in the source-of-truth repo:
 
 ## Roadmap
 
-This repo is being built in phases:
+This repo is being built in phases. Phase numbers correspond to internal sub-prompts under `PyAutoLabs/PyAutoPrompt/z_features/autolens_profiling.md`.
 
 | Phase | Title | Status |
 |-------|-------|--------|
-| 0 | Repo bootstrap (this commit) | ✓ shipped |
-| 1 | Mirror JIT likelihood profiling scripts + per-section READMEs | not yet started |
-| 2 | Mirror simulator profiling scripts + run-time tracking | not yet started |
-| 3 | Nautilus profiling, design for sampler expansion | not yet started |
-| 4 | Top-level + per-section README dashboard with instrument framing | not yet started |
-| 5 | GitHub Actions for lint + profile re-runs + README refresh | not yet started |
-
-The full multi-phase plan lives in the internal `PyAutoLabs/PyAutoPrompt/z_features/autolens_profiling.md` tracker (not publicly readable). The high-level shape is captured above.
+| 0 | Repo bootstrap | ✓ shipped |
+| 1 | Mirror JIT likelihood profiling scripts + per-section READMEs | ✓ shipped |
+| 2 | Mirror simulator profiling scripts + run-time tracking | ✓ shipped |
+| 3 | Nautilus profiling, design for sampler expansion | ✓ shipped |
+| 4 | Top-level + per-section README dashboard with instrument framing | ✓ shipped |
+| 5 | GitHub Actions for lint + profile re-runs + README refresh | queued |
+
+### Future enhancements (Phase 4 follow-ups)
+
+Dashboards can grow in many directions. The list below captures candidate improvements that fit the "profiling and run-times" theme; none of them block the current dashboard from being useful.
+
+- **Regression-watch indicator** — colour or arrow per cell showing whether the latest cost regressed (>5%) or improved versus the previous PyAutoLens release. Needs the second-latest version per axis kept alongside the latest. Trivial to add to `scripts/build_readme.py`.
+- **Per-axis version-history PNGs** — small inline plot of run-time vs PyAutoLens release version, generated from the JSON artifacts (reusing the `_developer/jax_profiling/results/jit/.../*_v<version>.png` generator). Embeds nicely above each section table.
+- **Plotly-rendered interactive timeline** — hostable on GitHub Pages once the static dashboard stabilises; lets readers hover/filter across instrument × model × release.
+- **Flamegraph captures** — alongside the headline timing numbers, store a flamegraph per instrument × model for the most recent release.
+- **Hardware-tier columns** — extend `scripts/build_readme.py` table renderers to show CPU / laptop GPU / HPC GPU as separate columns once result artifacts encode the hardware label (filename suffix or JSON `"hardware"` field).
+- **Archive old versions** — once a script has >6 minor releases of artifacts, move the older ones to `results/archive/` so the latest views stay uncluttered.
 
 ## Related repos
 
diff --git a/likelihood/datacube/README.md b/likelihood/datacube/README.md
index a05c16a..4dc4dea 100644
--- a/likelihood/datacube/README.md
+++ b/likelihood/datacube/README.md
@@ -37,13 +37,13 @@ That number quantifies how much a future "shared `Lᵀ W̃ L`" optimisation woul
 
 For a realistic per-channel-distinct cube, point the loader at the workspace simulator output at `autolens_workspace/dataset/interferometer/datacube/sim_simple/`. The JIT-cost taxonomy doesn't change — it's a function of which arrays are loop-variables in `FitInterferometer`, not the data values themselves.
 
-## Headline run-times (populated by Phase 4)
+## Headline run-times (latest per dataset)
 
-| Script | Dataset | N channels | CPU | Laptop GPU | A100 |
-|--------|---------|------------|-----|------------|------|
-| `delaunay.py` | SMA × 4 | 4 | _populated_ | _populated_ | _populated_ |
+Auto-generated by `scripts/build_readme.py` from the latest `*_summary_v<version>.json` artifacts under `results/likelihood/datacube/`. Hardware tier is CPU only today.
 
-Numbers are the **steady-state per-call cost** (single-JIT, post-warmup), in milliseconds. Phase 4's dashboard auto-fills this from the latest `*_summary_v<version>.json` artifacts under `results/likelihood/datacube/`.
+<!-- BEGIN auto-table:likelihood-datacube -->
+_No data yet — run a script under this folder to populate. See section README._
+<!-- END auto-table:likelihood-datacube -->
 
 ## Output
 
diff --git a/likelihood/imaging/README.md b/likelihood/imaging/README.md
index 8af3c3c..a74a6e2 100644
--- a/likelihood/imaging/README.md
+++ b/likelihood/imaging/README.md
@@ -37,15 +37,13 @@ XLA may fuse these differently when compiled as one program vs separate pieces,
 
 `dataset/imaging/hst/` — an HST-resolution mock (pixel scale 0.05″, 21×21 PSF) committed to this repo. Other instruments (`euclid`, `jwst`, `ao`) can be regenerated via the source-of-truth scripts at `autolens_workspace_developer/jax_profiling/dataset_setup/imaging.py` and copied into `dataset/imaging/<instrument>/`.
 
-## Headline run-times (populated by Phase 4)
+## Headline run-times (latest per script × instrument)
 
-| Script | Instrument | CPU | Laptop GPU | A100 |
-|--------|------------|-----|------------|------|
-| `mge.py` | HST | _populated_ | _populated_ | _populated_ |
-| `pixelization.py` | HST | _populated_ | _populated_ | _populated_ |
-| `delaunay.py` | HST | _populated_ | _populated_ | _populated_ |
+Auto-generated by `scripts/build_readme.py` from the latest `*_summary_v<version>.json` artifacts under `results/likelihood/imaging/`. Hardware tier is CPU only today.
 
-Numbers are the **steady-state per-call cost** (single-JIT, post-warmup), in milliseconds. Phase 4's dashboard auto-fills this from the latest `*_summary_v<version>.json` artifacts under `results/likelihood/imaging/`.
+<!-- BEGIN auto-table:likelihood-imaging -->
+_No data yet — run a script under this folder to populate. See section README._
+<!-- END auto-table:likelihood-imaging -->
 
 ## Output
 
diff --git a/likelihood/interferometer/README.md b/likelihood/interferometer/README.md
index f7d3f4f..a00e097 100644
--- a/likelihood/interferometer/README.md
+++ b/likelihood/interferometer/README.md
@@ -27,13 +27,11 @@ The interferometer likelihood path is profiled at **full-pipeline JIT** only, no
 
 ## Headline run-times (populated by Phase 4)
 
-| Script | Instrument | CPU | Laptop GPU | A100 |
-|--------|------------|-----|------------|------|
-| `mge.py` | SMA | _populated_ | _populated_ | _populated_ |
-| `pixelization.py` | SMA | _populated_ | _populated_ | _populated_ |
-| `delaunay.py` | SMA | _populated_ | _populated_ | _populated_ |
+Auto-generated by `scripts/build_readme.py` from the latest `*_summary_v<version>.json` artifacts under `results/likelihood/interferometer/`. Hardware tier is CPU only today.
 
-Numbers are the **steady-state per-call cost** (single-JIT, post-warmup), in milliseconds. Phase 4's dashboard auto-fills this from the latest `*_summary_v<version>.json` artifacts under `results/likelihood/interferometer/`.
+<!-- BEGIN auto-table:likelihood-interferometer -->
+_No data yet — run a script under this folder to populate. See section README._
+<!-- END auto-table:likelihood-interferometer -->
 
 ## Output
 
diff --git a/likelihood/point_source/README.md b/likelihood/point_source/README.md
index 63b6a76..b77d487 100644
--- a/likelihood/point_source/README.md
+++ b/likelihood/point_source/README.md
@@ -36,14 +36,13 @@ For both variants:
 
 `dataset/point_source/simple/` — a minimal seeded dataset with `point_dataset_positions_only.json` (4 observed image positions) and the truth `tracer.json`. Both files are committed to this repo.
 
-## Headline run-times (populated by Phase 4)
+## Headline run-times (latest per script × dataset)
 
-| Script | Dataset | CPU | Laptop GPU | A100 |
-|--------|---------|-----|------------|------|
-| `image_plane.py` | simple | _populated_ | _populated_ | _populated_ |
-| `source_plane.py` | simple | _populated_ | _populated_ | _populated_ |
+Auto-generated by `scripts/build_readme.py` from the latest `*_summary_v<version>.json` artifacts under `results/likelihood/point_source/`. Hardware tier is CPU only today. **Cells may show `—` while [PyAutoLens#514](https://github.com/PyAutoLabs/PyAutoLens/issues/514) is open** — the regression assertion in both scripts is intentionally load-bearing while the upstream drift is triaged, so neither script reaches the JSON-write step in the current PyAutoLens release.
 
-Numbers are the **steady-state per-call cost** (single-JIT, post-warmup), in milliseconds. Phase 4's dashboard auto-fills this from the latest `*_summary_v<version>.json` artifacts under `results/likelihood/point_source/`.
+<!-- BEGIN auto-table:likelihood-point_source -->
+_No data yet — run a script under this folder to populate. See section README._
+<!-- END auto-table:likelihood-point_source -->
 
 ## Output
 
diff --git a/scripts/build_readme.py b/scripts/build_readme.py
new file mode 100644
index 0000000..e6bbaff
--- /dev/null
+++ b/scripts/build_readme.py
@@ -0,0 +1,434 @@
+"""
+build_readme.py — refresh auto-generated tables in every README from the
+latest versioned artifacts under `results/`.
+
+Run from the repo root:
+
+    python scripts/build_readme.py            # rewrite README tables in place
+    python scripts/build_readme.py --check    # exit non-zero if rewriting
+                                              # would change any file (CI gate)
+
+Each table region in a README is delimited by sentinel comments, e.g.
+
+    <!-- BEGIN auto-table:likelihood-imaging -->
+    | ... |
+    <!-- END auto-table:likelihood-imaging -->
+
+This script:
+
+  1. Scans `results/**/*_summary_v<version>.json`.
+  2. Parses filenames into (section, sub-folder, script, instrument, version).
+  3. Picks the latest version per group via PEP 440-ish dotted-version sort.
+  4. Generates a markdown table per known region type and replaces the
+     content inside the matching sentinel block.
+
+Sections covered today:
+
+  - top-level README.md
+      <!-- BEGIN auto-table:headline --> ... <!-- END auto-table:headline -->
+  - likelihood/README.md (section overview)
+  - likelihood/imaging/README.md      | likelihood-imaging
+  - likelihood/interferometer/README.md | likelihood-interferometer
+  - likelihood/point_source/README.md | likelihood-point_source
+  - likelihood/datacube/README.md     | likelihood-datacube
+  - simulators/README.md              | simulators
+  - searches/nautilus/README.md       | searches-nautilus
+
+Hardware-tier columns (CPU / laptop GPU / HPC GPU) are deferred — every
+artifact today is implicitly CPU and the table shows a single "Latest"
+column. Once future artifacts encode hardware in the filename or JSON
+(`*_summary_v<version>_<hardware>.json` or `{"hardware": "a100"}`), the
+column logic in `_render_*_table` will be extended without touching the
+sentinel layout.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, Optional
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+RESULTS_ROOT = REPO_ROOT / "results"
+
+# Sentinel block: keeps surrounding hand-written prose intact, only the
+# content between BEGIN and END is rewritten.
+SENTINEL_RE = re.compile(
+    r"(<!-- BEGIN auto-table:(?P<name>[a-z0-9_\-]+) -->)"
+    r".*?"
+    r"(<!-- END auto-table:(?P=name) -->)",
+    re.DOTALL,
+)
+
+# Artifact filename: <script>_summary_<extras>_v<version>.json
+# `<extras>` is optional and captures the instrument / dataset_name suffix
+# used by likelihood/imaging, likelihood/interferometer, likelihood/datacube,
+# likelihood/point_source variants. Examples:
+#   mge_likelihood_summary_hst_v2026.5.14.2.json
+#   image_plane_summary_v2026.5.14.2.json
+#   delaunay_likelihood_summary_sma_v2026.5.14.2.json
+#   imaging_summary_v2026.5.14.2.json
+#   simple_summary_v2026.5.14.2.json
+ARTIFACT_RE = re.compile(
+    r"^(?P<script>[a-z0-9_]+?)_summary"
+    r"(?:_(?P<extra>[a-z0-9_]+?))?"
+    r"_v(?P<version>[0-9]+(?:\.[0-9]+)+)"
+    r"\.json$"
+)
+
+
+@dataclass(frozen=True)
+class Artifact:
+    path: Path
+    section: str  # "likelihood", "simulators", "searches"
+    subfolder: str  # "imaging", "interferometer", "nautilus", or "" for flat
+    script: str  # e.g. "mge", "image_plane", "simple"
+    instrument: Optional[str]  # e.g. "hst", "sma", or None for simulators
+    version: tuple[int, ...]
+    raw_version: str
+
+    @property
+    def data(self) -> dict:
+        return json.loads(self.path.read_text())
+
+
+def _parse_version(s: str) -> tuple[int, ...]:
+    return tuple(int(x) for x in s.split("."))
+
+
+def _scan_artifacts() -> list[Artifact]:
+    if not RESULTS_ROOT.exists():
+        return []
+    out: list[Artifact] = []
+    for p in RESULTS_ROOT.rglob("*_summary*_v*.json"):
+        rel = p.relative_to(RESULTS_ROOT).parts
+        if len(rel) < 2:
+            continue
+        section = rel[0]  # "likelihood" | "simulators" | "searches"
+        subfolder = rel[1] if len(rel) > 2 else ""
+        m = ARTIFACT_RE.match(p.name)
+        if not m:
+            continue
+        # The "extra" group is the instrument label for likelihood scripts
+        # that profile a single instrument (mge / pixelization / delaunay /
+        # image_plane on hst, sma, etc.). For simulators and searches, the
+        # filename has no extras and `extra` is None.
+        script_name = m["script"].replace("_likelihood", "")
+        out.append(
+            Artifact(
+                path=p,
+                section=section,
+                subfolder=subfolder,
+                script=script_name,
+                instrument=m["extra"],
+                version=_parse_version(m["version"]),
+                raw_version=m["version"],
+            )
+        )
+    return out
+
+
+def _latest_per_group(
+    artifacts: Iterable[Artifact], key
+) -> dict[tuple, Artifact]:
+    """For each group key, keep the artifact with the highest version."""
+    latest: dict[tuple, Artifact] = {}
+    for a in artifacts:
+        k = key(a)
+        if k not in latest or a.version > latest[k].version:
+            latest[k] = a
+    return latest
+
+
+# ---------------------------------------------------------------------------
+# Per-region table rendering
+# ---------------------------------------------------------------------------
+
+
+def _no_data_block(message: str) -> str:
+    return f"\n_No data yet — {message}_\n"
+
+
+def _format_time(seconds: Optional[float]) -> str:
+    if seconds is None:
+        return "—"
+    if seconds < 0.001:
+        return f"{seconds * 1e6:.0f} μs"
+    if seconds < 1:
+        return f"{seconds * 1e3:.1f} ms"
+    return f"{seconds:.2f} s"
+
+
+def _likelihood_headline_seconds(art: Artifact) -> Optional[float]:
+    """Steady-state per-call cost for the full-pipeline single JIT.
+
+    Robust to the slight key-shape variation across the imaging /
+    interferometer / point_source / datacube JSON layouts.
+    """
+    data = art.data
+    # Imaging mge/pixelization/delaunay JSON shape: top-level key per-step
+    # plus aggregates at end; the full-pipeline number is under "summary"
+    # in some scripts and at top-level in others. Try several keys.
+    for path in (
+        ("summary", "full_pipeline_single_jit_s"),
+        ("summary", "full_pipeline_s"),
+        ("aggregate", "full_pipeline_single_jit_s"),
+        ("full_pipeline_single_jit_s",),
+        ("full_pipeline_s",),
+    ):
+        node = data
+        ok = True
+        for key in path:
+            if isinstance(node, dict) and key in node:
+                node = node[key]
+            else:
+                ok = False
+                break
+        if ok and isinstance(node, (int, float)):
+            return float(node)
+    return None
+
+
+def _simulator_total_seconds(art: Artifact) -> Optional[float]:
+    data = art.data
+    phases = data.get("phases")
+    if isinstance(phases, dict):
+        try:
+            return float(sum(float(v) for v in phases.values()))
+        except (TypeError, ValueError):
+            return None
+    return None
+
+
+def _nautilus_headline(art: Artifact) -> dict:
+    data = art.data
+    perf = data.get("performance", {})
+    conv = data.get("convergence", {})
+    return {
+        "wall_time_s": perf.get("wall_time_s"),
+        "time_per_eval_ms": perf.get("time_per_eval_ms"),
+        "evals_to_ml": conv.get("evals_to_ml"),
+        "time_to_ml_s": conv.get("time_to_ml_s"),
+        "backend": data.get("backend"),
+    }
+
+
+def _render_likelihood_section_table(
+    artifacts: list[Artifact], subfolder: str
+) -> str:
+    """One row per (script, instrument) pair for a single likelihood subfolder."""
+    relevant = [
+        a for a in artifacts if a.section == "likelihood" and a.subfolder == subfolder
+    ]
+    if not relevant:
+        return _no_data_block(
+            "run a script under this folder to populate. See section README."
+        )
+    latest = _latest_per_group(relevant, key=lambda a: (a.script, a.instrument))
+    rows = ["| Script | Instrument | Latest single-JIT per-call | PyAutoLens version |"]
+    rows.append("|--------|------------|----------------------------|--------------------|")
+    for (script, instrument), art in sorted(latest.items()):
+        seconds = _likelihood_headline_seconds(art)
+        rows.append(
+            f"| `{script}.py` | "
+            f"{instrument or '—'} | "
+            f"{_format_time(seconds)} | "
+            f"v{art.raw_version} |"
+        )
+    return "\n" + "\n".join(rows) + "\n"
+
+
+def _render_simulator_table(artifacts: list[Artifact]) -> str:
+    relevant = [a for a in artifacts if a.section == "simulators"]
+    if not relevant:
+        return _no_data_block(
+            "run a simulator under `simulators/` to populate. See section README."
+        )
+    latest = _latest_per_group(relevant, key=lambda a: a.script)
+    rows = ["| Script | Total wall time | PyAutoLens version |"]
+    rows.append("|--------|-----------------|--------------------|")
+    for script, art in sorted(latest.items()):
+        total = _simulator_total_seconds(art)
+        rows.append(
+            f"| `{script}.py` | {_format_time(total)} | v{art.raw_version} |"
+        )
+    return "\n" + "\n".join(rows) + "\n"
+
+
+def _render_nautilus_table(artifacts: list[Artifact]) -> str:
+    relevant = [
+        a for a in artifacts if a.section == "searches" and a.subfolder == "nautilus"
+    ]
+    if not relevant:
+        return _no_data_block(
+            "run `searches/nautilus/{simple,jax}.py` to populate. See section README."
+        )
+    latest = _latest_per_group(relevant, key=lambda a: a.script)
+    rows = [
+        "| Script | Backend | Wall time | Time / eval | Evals → ML | Time → ML | PyAutoLens version |"
+    ]
+    rows.append(
+        "|--------|---------|-----------|-------------|-----------|-----------|--------------------|"
+    )
+    for script, art in sorted(latest.items()):
+        h = _nautilus_headline(art)
+        wall = _format_time(h["wall_time_s"])
+        per_eval = (
+            f"{h['time_per_eval_ms']:.1f} ms"
+            if h["time_per_eval_ms"] is not None
+            else "—"
+        )
+        evals_to_ml = (
+            f"{h['evals_to_ml']:,}" if h["evals_to_ml"] is not None else "—"
+        )
+        time_to_ml = _format_time(h["time_to_ml_s"])
+        rows.append(
+            f"| `{script}.py` | {h['backend'] or '—'} | "
+            f"{wall} | {per_eval} | {evals_to_ml} | {time_to_ml} | "
+            f"v{art.raw_version} |"
+        )
+    return "\n" + "\n".join(rows) + "\n"
+
+
+def _render_headline_table(artifacts: list[Artifact]) -> str:
+    """Top-level cross-section instrument × model headline.
+
+    Rows are (section, subfolder, instrument); columns are scripts. Today
+    likelihood/ has the richest cross-product; simulators are single-row
+    per script. Build a compact 'latest result per axis' table.
+    """
+    likelihood = [a for a in artifacts if a.section == "likelihood"]
+    if not likelihood:
+        return _no_data_block(
+            "run likelihood scripts to populate. See `likelihood/README.md`."
+        )
+    latest = _latest_per_group(
+        likelihood, key=lambda a: (a.subfolder, a.script, a.instrument)
+    )
+    rows = [
+        "| Section | Script | Instrument | Latest single-JIT per-call | PyAutoLens version |"
+    ]
+    rows.append(
+        "|---------|--------|------------|----------------------------|--------------------|"
+    )
+    for (subfolder, script, instrument), art in sorted(latest.items()):
+        seconds = _likelihood_headline_seconds(art)
+        rows.append(
+            f"| likelihood/{subfolder} | `{script}.py` | "
+            f"{instrument or '—'} | "
+            f"{_format_time(seconds)} | "
+            f"v{art.raw_version} |"
+        )
+    return "\n" + "\n".join(rows) + "\n"
+
+
+# Registry mapping sentinel name → renderer
+RENDERERS = {
+    "headline": _render_headline_table,
+    "likelihood-imaging": lambda arts: _render_likelihood_section_table(arts, "imaging"),
+    "likelihood-interferometer": lambda arts: _render_likelihood_section_table(
+        arts, "interferometer"
+    ),
+    "likelihood-point_source": lambda arts: _render_likelihood_section_table(
+        arts, "point_source"
+    ),
+    "likelihood-datacube": lambda arts: _render_likelihood_section_table(
+        arts, "datacube"
+    ),
+    "simulators": _render_simulator_table,
+    "searches-nautilus": _render_nautilus_table,
+}
+
+
+# Files that may contain auto-table regions. Listing them explicitly (rather
+# than walking the repo) keeps the script's surface obvious and prevents
+# accidental rewrites of e.g. workspace_developer mirror docs that may end
+# up here later.
+TARGET_READMES = [
+    REPO_ROOT / "README.md",
+    REPO_ROOT / "likelihood" / "README.md",
+    REPO_ROOT / "likelihood" / "imaging" / "README.md",
+    REPO_ROOT / "likelihood" / "interferometer" / "README.md",
+    REPO_ROOT / "likelihood" / "point_source" / "README.md",
+    REPO_ROOT / "likelihood" / "datacube" / "README.md",
+    REPO_ROOT / "simulators" / "README.md",
+    REPO_ROOT / "searches" / "README.md",
+    REPO_ROOT / "searches" / "nautilus" / "README.md",
+]
+
+
+def _rewrite_file(
+    path: Path, artifacts: list[Artifact]
+) -> tuple[str, str, list[str]]:
+    """Return (original_text, rewritten_text, unknown_sentinels)."""
+    original = path.read_text()
+    unknown: list[str] = []
+
+    def replace(match: re.Match) -> str:
+        name = match.group("name")
+        begin = match.group(1)
+        end = match.group(3)
+        renderer = RENDERERS.get(name)
+        if renderer is None:
+            unknown.append(name)
+            return match.group(0)  # leave intact
+        body = renderer(artifacts)
+        return f"{begin}{body}{end}"
+
+    rewritten = SENTINEL_RE.sub(replace, original)
+    return original, rewritten, unknown
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Exit non-zero if any target file would be rewritten (CI gate).",
+    )
+    args = parser.parse_args(argv)
+
+    artifacts = _scan_artifacts()
+    print(f"Scanned {len(artifacts)} artifact(s) under {RESULTS_ROOT}")
+
+    any_changed = False
+    all_unknown: list[tuple[Path, str]] = []
+    for target in TARGET_READMES:
+        if not target.exists():
+            print(f"  skip      {target.relative_to(REPO_ROOT)} — not present", flush=True)
+            continue
+        original, rewritten, unknown = _rewrite_file(target, artifacts)
+        for u in unknown:
+            all_unknown.append((target, u))
+        if rewritten == original:
+            print(f"  unchanged {target.relative_to(REPO_ROOT)}", flush=True)
+            continue
+        any_changed = True
+        if args.check:
+            print(f"  WOULD rewrite {target.relative_to(REPO_ROOT)}", flush=True)
+        else:
+            target.write_text(rewritten)
+            print(f"  rewrote   {target.relative_to(REPO_ROOT)}", flush=True)
+
+    for path, name in all_unknown:
+        print(
+            f"WARNING: unknown sentinel '{name}' in {path.relative_to(REPO_ROOT)} — left intact",
+            file=sys.stderr,
+        )
+
+    if args.check and any_changed:
+        print(
+            "ERROR: `build_readme.py --check` found pending changes. "
+            "Run `python scripts/build_readme.py` and commit the result.",
+            file=sys.stderr,
+        )
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/searches/nautilus/README.md b/searches/nautilus/README.md
index ad0cfcb..1995caf 100644
--- a/searches/nautilus/README.md
+++ b/searches/nautilus/README.md
@@ -26,14 +26,13 @@ Both share the same Nautilus configuration so timings are directly comparable: `
 
 The headline JSON+PNG pair is written to `results/searches/nautilus/` per the [section README](../README.md#versioned-artifacts) convention.
 
-## Headline run-times (populated by Phase 4)
+## Headline run-times (latest per script)
 
-| Script | Backend | Wall time | Time / eval | Evals → ML | Time → ML |
-|--------|---------|-----------|-------------|-----------|-----------|
-| `simple.py` | NumPy | _populated_ | _populated_ | _populated_ | _populated_ |
-| `jax.py` | JAX JIT | _populated_ | _populated_ | _populated_ | _populated_ |
+Auto-generated by `scripts/build_readme.py` from the latest `*_summary_v<version>.json` artifacts under `results/searches/nautilus/`.
 
-Numbers are filled in by Phase 4's `scripts/build_readme.py` from the latest `*_summary_v<version>.json` under `results/searches/nautilus/`.
+<!-- BEGIN auto-table:searches-nautilus -->
+_No data yet — run `searches/nautilus/{simple,jax}.py` to populate. See section README._
+<!-- END auto-table:searches-nautilus -->
 
 ## Expected behaviour
 
diff --git a/simulators/README.md b/simulators/README.md
index b328765..bd80fed 100644
--- a/simulators/README.md
+++ b/simulators/README.md
@@ -38,18 +38,13 @@ results/simulators/<script>_summary_v<al.__version__>.{json,png}
 
 Old versions are retained alongside new ones so cross-release trends stay visible.
 
-## Headline run-times (populated by Phase 4)
-
-| Script | Dataset preset | CPU | Laptop GPU | A100 |
-|--------|----------------|-----|-----------|------|
-| `imaging.py` | simple (HST-resolution defaults) | _populated_ | _populated_ | _populated_ |
-| `interferometer.py` | simple (synthetic uv) | _populated_ | _populated_ | _populated_ |
-| `point_source.py` | simple | _populated_ | _populated_ | _populated_ |
-| `cluster.py` | simple | _populated_ | _populated_ | _populated_ |
-| `group.py` | simple | _populated_ | _populated_ | _populated_ |
-| `multi.py` | simple (g+r) | _populated_ | _populated_ | _populated_ |
-
-Numbers are the **total wall time** for the simulator run-to-completion (not per-likelihood, since simulators run once-and-done). Phase 4's `scripts/build_readme.py` auto-fills this from the latest `*_summary_v<version>.json` artifacts.
+## Headline run-times (latest per script)
+
+Auto-generated by `scripts/build_readme.py` from the latest `*_summary_v<version>.json` artifacts under `results/simulators/`. Cell value is the **total wall time** of the simulator run-to-completion (sum of all `timer.section` phases), not per-likelihood. Hardware tier is CPU only today.
+
+<!-- BEGIN auto-table:simulators -->
+_No data yet — run a simulator under `simulators/` to populate. See section README._
+<!-- END auto-table:simulators -->
 
 ## Running a script