From 2d49b695008ab5bcd0989ed0b63d7ef1f7af8d73 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 30 Sep 2026 14:38:00 +0200
Subject: [PATCH 01/80] dotbot/site_editor: read and patch a site pack's
 site.toml over JSON

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py          | 167 ++++++++++++++++++++++++++
 dotbot/site_toml.py            | 198 +++++++++++++++++++++++++++++++
 dotbot/tests/test_site_toml.py | 210 +++++++++++++++++++++++++++++++++
 pyproject.toml                 |   4 +-
 4 files changed, 578 insertions(+), 1 deletion(-)
 create mode 100644 dotbot/site_editor.py
 create mode 100644 dotbot/site_toml.py
 create mode 100644 dotbot/tests/test_site_toml.py

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
new file mode 100644
index 00000000..b3cb42f2
--- /dev/null
+++ b/dotbot/site_editor.py
@@ -0,0 +1,167 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""The site editor's server: one site pack's `site.toml` over JSON, and the
+page that draws it.
+
+It runs on its own, with no controller, broker or robot. Every save is
+checked against the revision the page loaded, so an edit made to the file
+meanwhile is never overwritten.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Literal
+
+import tomlkit
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+
+from dotbot import site_toml
+from dotbot.site import PACK_CALIBRATIONS
+from dotbot.site_packs import PACK_FILE
+
+EDITOR_DIR = Path(__file__).parent / "console-web" / "dist"
+EDITOR_PAGE = "site-editor.html"
+
+
+class AreaModel(BaseModel):
+    name: str
+    x: int
+    y: int
+    w: int = Field(gt=0)
+    h: int = Field(gt=0)
+    role: Literal["field", "staging", "corner"] | None = None
+    comment: str | None = None
+    # The area's name in the file when the page loaded it; None for a new one
+    was: str | None = None
+
+
+class SiteModel(BaseModel):
+    anchor: str | None = None
+    extent_mm: tuple[int, int] | None = None
+    areas: list[AreaModel] = Field(default_factory=list)
+
+
+class SaveRequest(BaseModel):
+    revision: str
+    site: SiteModel
+
+
+@dataclass
+class EditorState:
+    """The pack being edited and where its calibrations may be."""
+
+    name: str
+    pack: Path
+    calibration_dirs: list[Path] = field(default_factory=list)
+
+    @property
+    def path(self) -> Path:
+        return self.pack / PACK_FILE
+
+    def calibrations(self) -> list[dict]:
+        folders = [self.pack / PACK_CALIBRATIONS, *self.calibration_dirs]
+        return [
+            {
+                "folder": str(folder),
+                "count": len(list(folder.glob("*.toml"))) if folder.is_dir() else 0,
+            }
+            for folder in folders
+        ]
+
+
+def _write_atomic(path: Path, text: str) -> None:
+    """Write `text` beside `path` and rename it over, keeping its mode."""
+    mode = path.stat().st_mode & 0o777 if path.exists() else 0o644
+    fd, tmp = tempfile.mkstemp(prefix=f".{path.name}-", dir=path.parent)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="") as handle:
+            handle.write(text)
+        os.chmod(tmp, mode)
+        os.replace(tmp, path)
+    except BaseException:
+        Path(tmp).unlink(missing_ok=True)
+        raise
+
+
+def _model_dict(model: SiteModel) -> dict:
+    data = model.model_dump()
+    data["extent_mm"] = list(model.extent_mm) if model.extent_mm else None
+    return data
+
+
+def create_app(
+    state: EditorState,
+    page_dir: Path = EDITOR_DIR,
+    on_done: Callable[[], None] | None = None,
+) -> FastAPI:
+    """The editor's app for `state`; `on_done` runs when the page says Done."""
+    app = FastAPI(title="DotBot site editor", docs_url=None, redoc_url=None)
+
+    def read() -> tuple[bytes, str]:
+        try:
+            data = state.path.read_bytes()
+        except OSError as exc:
+            raise HTTPException(500, f"could not read {state.path}: {exc}") from exc
+        return data, data.decode("utf-8")
+
+    def body(data: bytes, text: str) -> dict:
+        return {
+            "name": state.name,
+            "path": str(state.path),
+            "revision": site_toml.revision(data),
+            "site": site_toml.site_model(tomlkit.parse(text)),
+            "calibrations": state.calibrations(),
+        }
+
+    def patched(text: str, model: SiteModel) -> str:
+        try:
+            return site_toml.patched_text(text, _model_dict(model))
+        except site_toml.SiteTomlError as exc:
+            raise HTTPException(422, str(exc)) from exc
+
+    @app.get("/api/site")
+    def get_site():
+        return body(*read())
+
+    @app.post("/api/preview")
+    def preview(model: SiteModel):
+        _, text = read()
+        result = patched(text, model)
+        return {"text": result, "changed": result != text}
+
+    @app.put("/api/site")
+    def save(request: SaveRequest):
+        data, text = read()
+        if site_toml.revision(data) != request.revision:
+            raise HTTPException(
+                409, f"{state.path} changed on disk since the page loaded it"
+            )
+        result = patched(text, request.site)
+        written = result != text
+        if written:
+            _write_atomic(state.path, result)
+            data = result.encode("utf-8")
+            text = result
+        return {**body(data, text), "written": written}
+
+    @app.post("/api/done")
+    def done():
+        if on_done is not None:
+            on_done()
+        return {"ok": True}
+
+    @app.get("/", include_in_schema=False)
+    def page():
+        return FileResponse(page_dir / EDITOR_PAGE)
+
+    if page_dir.is_dir():
+        app.mount("/", StaticFiles(directory=page_dir), name="page")
+    return app
diff --git a/dotbot/site_toml.py b/dotbot/site_toml.py
new file mode 100644
index 00000000..0bae1d90
--- /dev/null
+++ b/dotbot/site_toml.py
@@ -0,0 +1,198 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""A site pack's `site.toml` as a model the site editor edits, and back.
+
+`site_model` reads the keys the editor draws from a tomlkit document;
+`patch` writes a model back by assigning only what differs, so comments,
+blank lines, key order and keys the editor does not model survive.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import tomllib
+from typing import Any
+
+import tomlkit
+from pydantic import ValidationError
+from tomlkit.items import InlineTable, SingleKey, Table
+from tomlkit.toml_document import TOMLDocument
+
+from dotbot.config import SiteSection
+
+AREA_KEYS = ("x", "y", "w", "h")
+
+
+class SiteTomlError(ValueError):
+    """A model the file cannot take, or a patched file the schema refuses."""
+
+
+def revision(data: bytes) -> str:
+    """The revision a page edits against: the SHA-256 of the file's bytes."""
+    return hashlib.sha256(data).hexdigest()
+
+
+def _comment(item: Any) -> str | None:
+    comment = item.trivia.comment.strip().removeprefix("#").strip()
+    return comment or None
+
+
+def _areas_table(doc: TOMLDocument) -> Table | None:
+    areas = doc.get("areas")
+    return areas if isinstance(areas, Table) else None
+
+
+def site_model(doc: TOMLDocument) -> dict[str, Any]:
+    """The editor's model of a `site.toml`: anchor, extent, areas in file
+    order with their declared role and comment, and the connection."""
+    areas = []
+    for name, item in (_areas_table(doc) or {}).items():
+        areas.append(
+            {
+                "name": name,
+                **{key: int(item[key]) for key in AREA_KEYS},
+                "role": item.get("role"),
+                "comment": _comment(item),
+            }
+        )
+    extent = doc.get("extent_mm")
+    connection = doc.get("connection")
+    return {
+        "anchor": doc.get("anchor"),
+        "extent_mm": [int(v) for v in extent] if extent is not None else None,
+        "areas": areas,
+        "connection": dict(connection) if connection is not None else None,
+    }
+
+
+def _set(container: Any, key: str, value: Any) -> None:
+    """Assign `value` unless it is already there; None removes the key."""
+    if value is None:
+        if key in container:
+            del container[key]
+    elif container.get(key) != value:
+        container[key] = value
+
+
+def _set_comment(item: Any, comment: str | None) -> None:
+    if _comment(item) == (comment or None):
+        return
+    if comment:
+        if not item.trivia.comment_ws:
+            item.trivia.comment_ws = "  "
+        item.trivia.comment = f"# {comment}"
+    else:
+        item.trivia.comment = ""
+        item.trivia.comment_ws = ""
+
+
+def _new_area(inline: bool, area: dict[str, Any]) -> Table | InlineTable:
+    item = tomlkit.inline_table() if inline else tomlkit.table()
+    if area.get("role") is not None:
+        item["role"] = area["role"]
+    for key in AREA_KEYS:
+        item[key] = area[key]
+    _set_comment(item, area.get("comment"))
+    return item
+
+
+def _check_names(areas: list[dict[str, Any]]) -> None:
+    seen = set()
+    for area in areas:
+        name = area["name"]
+        if not isinstance(name, str) or not name.strip():
+            raise SiteTomlError("an area needs a name")
+        if name != name.strip():
+            raise SiteTomlError(f"area {name!r}: no spaces around the name")
+        if "," in name:
+            raise SiteTomlError(
+                f"area {name!r}: a comma makes the name read as an x,y,w,h literal"
+            )
+        if name in seen:
+            raise SiteTomlError(f"two areas are named {name!r}")
+        seen.add(name)
+
+
+def _patch_areas(doc: TOMLDocument, areas: list[dict[str, Any]]) -> None:
+    table = _areas_table(doc)
+    if table is None:
+        if not areas:
+            return
+        table = tomlkit.table(is_super_table=True)
+        doc["areas"] = table
+    inline = any(isinstance(item, InlineTable) for item in table.values())
+    renames = {
+        area["was"]: area["name"]
+        for area in areas
+        if area.get("was") is not None and area["was"] != area["name"]
+    }
+    kept = {area.get("was") or area["name"] for area in areas}
+    for name in [name for name in table if name not in kept]:
+        del table[name]
+    for was, name in renames.items():
+        if was not in table:
+            raise SiteTomlError(f"area {was!r} is not in the file")
+        # tomlkit has no public rename; this keeps the area's place, comment
+        # and layout
+        item = table[was]
+        table.value._replace(was, name, item)
+        if isinstance(item, Table) and item.display_name:
+            old_key = SingleKey(was).as_string()
+            prefix = item.display_name.removesuffix(old_key)
+            item.display_name = prefix + SingleKey(name).as_string()
+        if isinstance(item, Table):
+            item.name = name
+    for area in areas:
+        name = area["name"]
+        if name not in table:
+            table[name] = _new_area(inline, area)
+            continue
+        item = table[name]
+        _set(item, "role", area.get("role"))
+        for key in AREA_KEYS:
+            _set(item, key, area[key])
+        _set_comment(item, area.get("comment"))
+    if not table:
+        del doc["areas"]
+
+
+def patch(doc: TOMLDocument, model: dict[str, Any]) -> TOMLDocument:
+    """Write `model` into `doc` in place, changing only what differs.
+
+    An area's `was` names it as the file does, so a rename is told from a
+    delete and an add. `connection` is not written.
+    """
+    areas = model.get("areas") or []
+    _check_names(areas)
+    anchor = model.get("anchor")
+    _set(doc, "anchor", anchor if anchor else None)
+    extent = model.get("extent_mm")
+    if extent is None:
+        _set(doc, "extent_mm", None)
+    elif "extent_mm" not in doc:
+        doc["extent_mm"] = [int(v) for v in extent]
+    elif [int(v) for v in doc["extent_mm"]] != [int(v) for v in extent]:
+        array = doc["extent_mm"]
+        array.clear()
+        array.extend(int(v) for v in extent)
+    _patch_areas(doc, areas)
+    return doc
+
+
+def validate(text: str) -> SiteSection:
+    """`text` held to the schema a pack is read with; SiteTomlError if not."""
+    try:
+        return SiteSection.model_validate(tomllib.loads(text))
+    except tomllib.TOMLDecodeError as exc:
+        raise SiteTomlError(f"not valid TOML: {exc}") from exc
+    except ValidationError as exc:
+        raise SiteTomlError(str(exc)) from exc
+
+
+def patched_text(text: str, model: dict[str, Any]) -> str:
+    """`text` with `model` written into it, validated."""
+    doc = tomlkit.parse(text)
+    result = tomlkit.dumps(patch(doc, model))
+    validate(result)
+    return result
diff --git a/dotbot/tests/test_site_toml.py b/dotbot/tests/test_site_toml.py
new file mode 100644
index 00000000..f028d986
--- /dev/null
+++ b/dotbot/tests/test_site_toml.py
@@ -0,0 +1,210 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""The site editor's round trip: a model patched back into `site.toml` keeps
+every comment, blank line and key it did not change."""
+
+import pytest
+import tomlkit
+
+from dotbot import site_toml
+from dotbot.cli.config_cmd import default_site_toml
+from dotbot.site_toml import SiteTomlError, patched_text, site_model
+
+ARENA = """\
+# Site arena: zero is the anchor, x right, y down, millimetres.
+
+anchor = "the corner where the top wall meets the door wall"
+extent_mm = [2000, 4000]   # encloses every area below
+
+[areas.field]     # the 2 x 2 m square at the top
+x = 0
+y = 0
+w = 2000
+h = 2000
+
+[areas.staging]   # the 2 x 2 m square directly below it
+x = 0
+y = 2000
+w = 2000
+h = 2000
+
+[areas."field+staging"]   # the 2 x 4 m rectangle along the door wall
+x = 0
+y = 0
+w = 2000
+h = 4000
+
+[areas.dev-corner]      # a 1 x 1 m development patch
+role = "corner"
+x = 1000
+y = 0
+w = 1000
+h = 1000
+"""
+
+HALL = """\
+# Site hall. Every number below is a placeholder.
+
+anchor = "the north-west corner of the hall's floor marking"   # to be measured
+extent_mm = [20000, 30000]   # to be measured
+
+[connection]
+conn = "mqtts://broker.example:8883"
+swarm_id = "A001"
+
+[areas.field]    # a 2 x 2 m square inside the hall
+x = 5000   # to be measured
+y = 5000   # to be measured
+w = 2000
+h = 2000
+"""
+
+INLINE = """\
+[areas]
+field   = { x = 0, y = 0, w = 1000, h = 1000 }  # the field
+staging = { x = 0, y = 1000, w = 1000, h = 500 }
+"""
+
+
+def _loaded(text):
+    model = site_model(tomlkit.parse(text))
+    for area in model["areas"]:
+        area["was"] = area["name"]
+    return model
+
+
+@pytest.mark.parametrize("text", [ARENA, HALL, INLINE, default_site_toml((2000, 2000))])
+def test_an_unchanged_model_writes_the_file_back_byte_for_byte(text):
+    assert patched_text(text, _loaded(text)) == text
+
+
+def test_the_model_carries_the_declared_role_and_the_comment():
+    model = site_model(tomlkit.parse(ARENA))
+    assert model["extent_mm"] == [2000, 4000]
+    assert [a["name"] for a in model["areas"]] == [
+        "field",
+        "staging",
+        "field+staging",
+        "dev-corner",
+    ]
+    corner = model["areas"][3]
+    assert (corner["role"], corner["comment"]) == (
+        "corner",
+        "a 1 x 1 m development patch",
+    )
+    assert model["areas"][0]["role"] is None
+
+
+def test_moving_an_area_changes_its_numbers_and_nothing_else():
+    model = _loaded(ARENA)
+    model["areas"][3]["x"] = 1050
+    out = patched_text(ARENA, model)
+    changed = [(a, b) for a, b in zip(ARENA.splitlines(), out.splitlines()) if a != b]
+    assert changed == [("x = 1000", "x = 1050")]
+
+
+def test_a_value_keeps_its_own_comment():
+    model = _loaded(HALL)
+    model["areas"][0]["x"] = 5100
+    model["anchor"] = "the door"
+    model["extent_mm"] = [21000, 30000]
+    out = patched_text(HALL, model)
+    assert "x = 5100   # to be measured" in out
+    assert 'anchor = "the door"   # to be measured' in out
+    assert "extent_mm = [21000, 30000]   # to be measured" in out
+
+
+def test_the_connection_is_left_as_it_is():
+    model = _loaded(HALL)
+    model["connection"] = {"conn": "mqtt://elsewhere:1883"}
+    model["areas"][0]["w"] = 2500
+    assert '[connection]\nconn = "mqtts://broker.example:8883"' in patched_text(
+        HALL, model
+    )
+
+
+def test_a_new_area_follows_the_file_style():
+    model = _loaded(ARENA)
+    model["areas"].append(
+        {
+            "name": "dock",
+            "x": 0,
+            "y": 3500,
+            "w": 500,
+            "h": 500,
+            "role": None,
+            "comment": "chargers",
+        }
+    )
+    out = patched_text(ARENA, model)
+    assert out.startswith(ARENA)
+    assert out.endswith("[areas.dock]  # chargers\nx = 0\ny = 3500\nw = 500\nh = 500\n")
+
+    model = _loaded(INLINE)
+    model["areas"].append({"name": "dock", "x": 0, "y": 0, "w": 1, "h": 1})
+    assert "\ndock = {" in patched_text(INLINE, model)
+
+
+def test_a_deleted_area_goes_with_its_comment():
+    model = _loaded(ARENA)
+    del model["areas"][2]
+    out = patched_text(ARENA, model)
+    assert "field+staging" not in out and "along the door wall" not in out
+    assert "[areas.dev-corner]      # a 1 x 1 m development patch" in out
+
+
+def test_a_renamed_area_keeps_its_place_and_comment():
+    model = _loaded(ARENA)
+    model["areas"][2]["name"] = "arena"
+    out = patched_text(ARENA, model)
+    assert out == ARENA.replace('[areas."field+staging"]', "[areas.arena]")
+
+    model = _loaded(INLINE)
+    model["areas"][0]["name"] = "square"
+    model["areas"][0]["role"] = "field"
+    line = patched_text(INLINE, model).splitlines()[1]
+    assert line.startswith("square = {") and line.endswith("# the field")
+
+
+def test_the_first_area_of_an_empty_pack():
+    out = patched_text(
+        'anchor = "a"\n',
+        {
+            "anchor": "a",
+            "extent_mm": [3000, 3000],
+            "areas": [{"name": "field", "x": 0, "y": 0, "w": 1000, "h": 1000}],
+        },
+    )
+    assert site_toml.validate(out).areas["field"].w == 1000
+    assert out.startswith('anchor = "a"\nextent_mm = [3000, 3000]\n')
+
+
+def test_the_comment_is_edited_and_removed():
+    model = _loaded(ARENA)
+    model["areas"][0]["comment"] = "moved"
+    model["areas"][1]["comment"] = None
+    out = patched_text(ARENA, model)
+    assert "[areas.field]     # moved\n" in out
+    assert "[areas.staging]\n" in out
+
+
+@pytest.mark.parametrize(
+    "change, message",
+    [
+        (lambda m: m["areas"][1].update(role="field"), "at most one field"),
+        (lambda m: m["areas"][1].update(name="field"), "two areas are named"),
+        (lambda m: m["areas"][1].update(name="a,b"), "comma"),
+        (lambda m: m["areas"][1].update(name=""), "needs a name"),
+    ],
+)
+def test_a_model_the_schema_refuses_is_an_error(change, message):
+    model = _loaded(ARENA)
+    change(model)
+    with pytest.raises(SiteTomlError, match=message):
+        patched_text(ARENA, model)
+
+
+def test_the_revision_is_the_hash_of_the_bytes():
+    assert site_toml.revision(b"a") != site_toml.revision(b"b")
+    assert len(site_toml.revision(b"")) == 64
diff --git a/pyproject.toml b/pyproject.toml
index 39833132..b362bf27 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -62,7 +62,9 @@ dependencies = [
     "pydotbot-utils >= 0.3.0",
     "swarmit[dashboard] >= 0.11.0",
     "toml           >= 0.10.2",
-    "tomlkit        >= 0.13.0",
+    # 0.15.0 writes invalid TOML when a key is added to or removed from an
+    # inline table, which site_toml does to edit a pack
+    "tomlkit        >= 0.13.0, != 0.15.0",
     # Runs the simulator's firmware control core. Majors ship monthly; the
     # loader is tested on 49 only, and the bound admits the next few on the
     # expectation that the small Engine/Module/Instance/Memory API it uses

From 66ba7a1ea97f9b31ff0fe0da3a20e0f4f1acf826 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 30 Sep 2026 14:38:00 +0200
Subject: [PATCH 02/80] dotbot/console-web: add the site editor page

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/site-editor.html           |  18 +
 dotbot/console-web/src/siteEditor/Canvas.tsx  | 345 ++++++++++++++
 .../console-web/src/siteEditor/Inspector.tsx  | 272 +++++++++++
 .../console-web/src/siteEditor/SiteEditor.tsx | 447 ++++++++++++++++++
 dotbot/console-web/src/siteEditor/api.test.ts |  44 ++
 dotbot/console-web/src/siteEditor/api.ts      |  69 +++
 .../console-web/src/siteEditor/edit.test.ts   | 134 ++++++
 dotbot/console-web/src/siteEditor/edit.ts     | 203 ++++++++
 dotbot/console-web/src/siteEditor/main.tsx    |  11 +
 .../src/siteEditor/siteEditor.test.tsx        | 107 +++++
 dotbot/console-web/src/siteEditor/types.ts    |  37 ++
 dotbot/console-web/vite.config.ts             |  17 +-
 12 files changed, 1702 insertions(+), 2 deletions(-)
 create mode 100644 dotbot/console-web/site-editor.html
 create mode 100644 dotbot/console-web/src/siteEditor/Canvas.tsx
 create mode 100644 dotbot/console-web/src/siteEditor/Inspector.tsx
 create mode 100644 dotbot/console-web/src/siteEditor/SiteEditor.tsx
 create mode 100644 dotbot/console-web/src/siteEditor/api.test.ts
 create mode 100644 dotbot/console-web/src/siteEditor/api.ts
 create mode 100644 dotbot/console-web/src/siteEditor/edit.test.ts
 create mode 100644 dotbot/console-web/src/siteEditor/edit.ts
 create mode 100644 dotbot/console-web/src/siteEditor/main.tsx
 create mode 100644 dotbot/console-web/src/siteEditor/siteEditor.test.tsx
 create mode 100644 dotbot/console-web/src/siteEditor/types.ts

diff --git a/dotbot/console-web/site-editor.html b/dotbot/console-web/site-editor.html
new file mode 100644
index 00000000..22e934fc
--- /dev/null
+++ b/dotbot/console-web/site-editor.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DotBot Site Editor</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&family=IBM+Plex+Sans:wght@400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/siteEditor/main.tsx"></script>
+  </body>
+</html>
diff --git a/dotbot/console-web/src/siteEditor/Canvas.tsx b/dotbot/console-web/src/siteEditor/Canvas.tsx
new file mode 100644
index 00000000..4f9856b6
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/Canvas.tsx
@@ -0,0 +1,345 @@
+import React, { useEffect, useRef, useState } from "react";
+
+import { areaColor } from "../areaColor";
+import { AREA_FALLBACK, siteViewMarginMm, withMargin } from "../frame";
+import {
+  axisTicks,
+  canvasPx,
+  frameMm,
+  gridStepMm,
+  gridSubStepMm,
+  metreLabel,
+  pxPerMm,
+  rulerStepMm,
+  ticksInSite,
+} from "../grid";
+import type { Area } from "../types";
+import { FRAME_CAMERA, viewGeom } from "../zoom";
+import { HANDLES, effectiveRole, moveRect, rectFromDrag, resizeRect } from "./edit";
+import type { Handle, Rect } from "./edit";
+import type { EditArea } from "./types";
+
+// The site drawn to scale: the extent, the metric grid and its rulers, and
+// every area in its role colour. Areas are moved, resized and drawn here; the
+// numbers themselves live in the inspector.
+
+export type Tool = "select" | "area";
+
+const HANDLE_PX = 9;
+const AREA_TINT = 0.12;
+
+type Drag =
+  | { kind: "move"; index: number; start: Rect; from: { x: number; y: number } }
+  | { kind: "resize"; index: number; start: Rect; handle: Handle }
+  | { kind: "draw"; from: { x: number; y: number }; to: { x: number; y: number } };
+
+export interface CanvasProps {
+  extent: [number, number] | null;
+  areas: EditArea[];
+  hidden: Set<string>;
+  selected: number | null;
+  tool: Tool;
+  snapMm: number;
+  onSelect: (index: number | null) => void;
+  onChange: (index: number, rect: Rect) => void;
+  onDraw: (rect: Rect) => void;
+}
+
+function handlePoint(r: Rect, h: Handle): { x: number; y: number } {
+  const x = h.includes("w") ? r.x : h.includes("e") ? r.x + r.w : r.x + r.w / 2;
+  const y = h.includes("n") ? r.y : h.includes("s") ? r.y + r.h : r.y + r.h / 2;
+  return { x, y };
+}
+
+const CURSOR: Record<Handle, string> = {
+  n: "ns-resize",
+  s: "ns-resize",
+  e: "ew-resize",
+  w: "ew-resize",
+  ne: "nesw-resize",
+  sw: "nesw-resize",
+  nw: "nwse-resize",
+  se: "nwse-resize",
+};
+
+export function Canvas(props: CanvasProps) {
+  const wrapRef = useRef<HTMLDivElement>(null);
+  const [size, setSize] = useState({ w: 800, h: 600 });
+  const [drag, setDrag] = useState<Drag | null>(null);
+  const [altHeld, setAltHeld] = useState(false);
+
+  useEffect(() => {
+    const el = wrapRef.current;
+    if (!el) return;
+    const measure = () => {
+      const r = el.getBoundingClientRect();
+      if (r.width > 0 && r.height > 0) setSize({ w: r.width, h: r.height });
+    };
+    measure();
+    const observer = new ResizeObserver(measure);
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, []);
+
+  const extentArea: Area = props.extent
+    ? { x: 0, y: 0, w: props.extent[0], h: props.extent[1] }
+    : AREA_FALLBACK;
+  const viewport = withMargin(extentArea, siteViewMarginMm(extentArea));
+  const geom = viewGeom(size.w, size.h, viewport);
+  const cam = FRAME_CAMERA;
+  const px = (axis: "x" | "y", mm: number) => canvasPx(axis, mm, viewport, geom, cam);
+  const mm = (axis: "x" | "y", p: number) => frameMm(axis, p, viewport, geom, cam);
+  const scale = pxPerMm("x", viewport, geom, cam);
+  const rectPx = (r: Rect) => ({
+    x: px("x", r.x),
+    y: px("y", r.y),
+    width: r.w * scale,
+    height: r.h * scale,
+  });
+
+  const step = gridStepMm(scale);
+  const sub = gridSubStepMm(scale);
+  const ruler = rulerStepMm(step, scale);
+  const extentForTicks = props.extent ? extentArea : null;
+  const xs = axisTicks("x", viewport, geom, cam, step);
+  const ys = axisTicks("y", viewport, geom, cam, step);
+  const subXs = sub ? axisTicks("x", viewport, geom, cam, sub) : [];
+  const subYs = sub ? axisTicks("y", viewport, geom, cam, sub) : [];
+  const labelXs = ticksInSite(axisTicks("x", viewport, geom, cam, ruler), "x", extentForTicks);
+  const labelYs = ticksInSite(axisTicks("y", viewport, geom, cam, ruler), "y", extentForTicks);
+
+  const colourAreas: Area[] = props.areas.map((a) => ({ ...a, role: effectiveRole(a) }));
+  const snapNow = (e: { altKey: boolean }) => (e.altKey ? 1 : props.snapMm);
+
+  const toFrame = (e: React.PointerEvent) => {
+    const r = wrapRef.current!.getBoundingClientRect();
+    return { x: mm("x", e.clientX - r.left), y: mm("y", e.clientY - r.top) };
+  };
+
+  const begin = (e: React.PointerEvent, next: Drag) => {
+    e.stopPropagation();
+    wrapRef.current?.setPointerCapture?.(e.pointerId);
+    setDrag(next);
+  };
+
+  const onBackgroundDown = (e: React.PointerEvent) => {
+    if (e.button !== 0) return;
+    if (props.tool === "area") {
+      const p = toFrame(e);
+      begin(e, { kind: "draw", from: p, to: p });
+    } else {
+      props.onSelect(null);
+    }
+  };
+
+  const onAreaDown = (e: React.PointerEvent, index: number) => {
+    if (e.button !== 0 || props.tool === "area") return;
+    const a = props.areas[index];
+    props.onSelect(index);
+    begin(e, { kind: "move", index, start: { x: a.x, y: a.y, w: a.w, h: a.h }, from: toFrame(e) });
+  };
+
+  const onHandleDown = (e: React.PointerEvent, index: number, handle: Handle) => {
+    if (e.button !== 0) return;
+    const a = props.areas[index];
+    begin(e, { kind: "resize", index, start: { x: a.x, y: a.y, w: a.w, h: a.h }, handle });
+  };
+
+  const onMove = (e: React.PointerEvent) => {
+    setAltHeld(e.altKey);
+    if (!drag) return;
+    const p = toFrame(e);
+    const s = snapNow(e);
+    if (drag.kind === "move") {
+      props.onChange(drag.index, moveRect(drag.start, p.x - drag.from.x, p.y - drag.from.y, s));
+    } else if (drag.kind === "resize") {
+      props.onChange(drag.index, resizeRect(drag.start, drag.handle, p, s));
+    } else {
+      setDrag({ ...drag, to: p });
+    }
+  };
+
+  const onUp = (e: React.PointerEvent) => {
+    if (drag?.kind === "draw") {
+      const r = rectFromDrag(drag.from, toFrame(e), snapNow(e));
+      if (r) props.onDraw(r);
+    }
+    setDrag(null);
+  };
+
+  // Largest first, so a small area inside a large one stays on top to grab.
+  const order = props.areas
+    .map((a, i) => i)
+    .filter((i) => !props.hidden.has(props.areas[i].name) || i === props.selected)
+    .sort((i, j) => props.areas[j].w * props.areas[j].h - props.areas[i].w * props.areas[i].h);
+  const sel = props.selected !== null ? props.areas[props.selected] : null;
+  const preview = drag?.kind === "draw" ? rectFromDrag(drag.from, drag.to, props.snapMm) : null;
+  const extentPx = rectPx(extentArea);
+
+  return (
+    <div
+      ref={wrapRef}
+      data-testid="site-canvas"
+      onPointerDown={onBackgroundDown}
+      onPointerMove={onMove}
+      onPointerUp={onUp}
+      onPointerCancel={() => setDrag(null)}
+      style={{
+        position: "relative",
+        flex: 1,
+        minWidth: 0,
+        minHeight: 0,
+        overflow: "hidden",
+        background: "var(--canvas)",
+        cursor: props.tool === "area" ? "crosshair" : "default",
+        touchAction: "none",
+        userSelect: "none",
+      }}
+    >
+      <svg width={size.w} height={size.h} style={{ display: "block" }}>
+        <rect {...extentPx} fill="var(--surface)" />
+        <g stroke="var(--grid-sub)" strokeWidth={1}>
+          {subXs.map((t) => (
+            <line key={`sx${t.mm}`} x1={t.px} x2={t.px} y1={0} y2={size.h} />
+          ))}
+          {subYs.map((t) => (
+            <line key={`sy${t.mm}`} y1={t.px} y2={t.px} x1={0} x2={size.w} />
+          ))}
+        </g>
+        <g stroke="var(--grid)" strokeWidth={1}>
+          {xs.map((t) => (
+            <line key={`x${t.mm}`} x1={t.px} x2={t.px} y1={0} y2={size.h} />
+          ))}
+          {ys.map((t) => (
+            <line key={`y${t.mm}`} y1={t.px} y2={t.px} x1={0} x2={size.w} />
+          ))}
+        </g>
+        <rect
+          {...extentPx}
+          fill="none"
+          stroke="var(--muted)"
+          strokeWidth={1.5}
+          data-testid="site-extent"
+        />
+        <g fontFamily="var(--font-mono)" fontSize={10} fill="var(--muted)">
+          {labelXs.map((t) => (
+            <text key={`lx${t.mm}`} x={t.px} y={extentPx.y - 6} textAnchor="middle">
+              {metreLabel(t.mm, ruler)}
+            </text>
+          ))}
+          {labelYs.map((t) => (
+            <text key={`ly${t.mm}`} x={extentPx.x - 6} y={t.px + 3} textAnchor="end">
+              {metreLabel(t.mm, ruler)}
+            </text>
+          ))}
+        </g>
+        {order.map((i) => {
+          const a = props.areas[i];
+          const colour = areaColor(colourAreas[i], colourAreas);
+          const role = effectiveRole(a);
+          const composite = a.name.includes("+");
+          const r = rectPx(a);
+          return (
+            <g key={`${i}-${a.was ?? ""}`}>
+              <rect
+                data-testid={`edit-area-${a.name}`}
+                {...r}
+                fill={colour}
+                fillOpacity={composite ? 0.03 : AREA_TINT}
+                stroke={colour}
+                strokeWidth={i === props.selected ? 2.5 : role === "corner" ? 2 : 1.5}
+                strokeDasharray={composite ? "7 5" : role === "corner" ? "3 3" : undefined}
+                style={{ cursor: props.tool === "select" ? "move" : "crosshair" }}
+                onPointerDown={(e) => onAreaDown(e, i)}
+              >
+                <title>{a.name}</title>
+              </rect>
+              {r.width > 40 && r.height > 18 && (
+                <text
+                  x={composite ? r.x + r.width - 6 : r.x + 6}
+                  y={composite ? r.y + r.height - 6 : r.y + 14}
+                  textAnchor={composite ? "end" : "start"}
+                  fontSize={11}
+                  fontFamily="var(--font-ui)"
+                  fill={colour}
+                  style={{ pointerEvents: "none" }}
+                >
+                  {a.name}
+                </text>
+              )}
+            </g>
+          );
+        })}
+        {sel && props.selected !== null && props.tool === "select" && (
+          <g data-testid="selection">
+            <text
+              x={rectPx(sel).x + rectPx(sel).width / 2}
+              y={rectPx(sel).y + rectPx(sel).height + 16}
+              textAnchor="middle"
+              fontSize={11}
+              fontFamily="var(--font-mono)"
+              fill="var(--text)"
+              style={{ pointerEvents: "none" }}
+            >
+              {`${sel.w} x ${sel.h} mm at (${sel.x}, ${sel.y})`}
+            </text>
+            {HANDLES.map((h) => {
+              const p = handlePoint(sel, h);
+              return (
+                <rect
+                  key={h}
+                  data-testid={`handle-${h}`}
+                  x={px("x", p.x) - HANDLE_PX / 2}
+                  y={px("y", p.y) - HANDLE_PX / 2}
+                  width={HANDLE_PX}
+                  height={HANDLE_PX}
+                  fill="var(--surface)"
+                  stroke="var(--text)"
+                  strokeWidth={1.2}
+                  style={{ cursor: CURSOR[h] }}
+                  onPointerDown={(e) => onHandleDown(e, props.selected!, h)}
+                />
+              );
+            })}
+          </g>
+        )}
+        {preview && (
+          <rect
+            data-testid="draw-preview"
+            {...rectPx(preview)}
+            fill="var(--accent)"
+            fillOpacity={0.08}
+            stroke="var(--accent)"
+            strokeDasharray="4 3"
+          />
+        )}
+        <g data-testid="anchor">
+          <circle cx={px("x", 0)} cy={px("y", 0)} r={5} fill="var(--accent)" />
+          <text
+            x={px("x", 0) - 10}
+            y={px("y", 0) - 16}
+            textAnchor="end"
+            fontSize={10}
+            fontFamily="var(--font-mono)"
+            fill="var(--accent)"
+          >
+            anchor (0, 0)
+          </text>
+        </g>
+      </svg>
+      <div
+        style={{
+          position: "absolute",
+          right: 10,
+          bottom: 8,
+          fontSize: 11,
+          color: "var(--muted)",
+          fontFamily: "var(--font-mono)",
+          pointerEvents: "none",
+        }}
+      >
+        {altHeld ? "free placement (Alt)" : `snap ${props.snapMm} mm, Alt for free`}
+      </div>
+    </div>
+  );
+}
diff --git a/dotbot/console-web/src/siteEditor/Inspector.tsx b/dotbot/console-web/src/siteEditor/Inspector.tsx
new file mode 100644
index 00000000..ed9ecb51
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/Inspector.tsx
@@ -0,0 +1,272 @@
+import React from "react";
+
+import type { AreaRole } from "../types";
+import { ROLES, declaredRole, effectiveRole } from "./edit";
+import type { Issue } from "./edit";
+import type { EditArea, SiteModel } from "./types";
+
+// The right pane: every field is a key of site.toml, and what it shows is
+// what Save writes.
+
+const label: React.CSSProperties = {
+  display: "block",
+  fontSize: 11,
+  color: "var(--muted)",
+  margin: "10px 0 3px",
+};
+const input: React.CSSProperties = {
+  width: "100%",
+  padding: "5px 7px",
+  background: "var(--elevated)",
+  color: "var(--text)",
+  border: "1px solid var(--hairline)",
+  borderRadius: 4,
+  fontFamily: "var(--font-mono)",
+  fontSize: 12,
+};
+const section: React.CSSProperties = {
+  borderBottom: "1px solid var(--hairline)",
+  padding: "12px 14px",
+};
+const heading: React.CSSProperties = {
+  fontSize: 11,
+  fontWeight: 600,
+  letterSpacing: 0.6,
+  textTransform: "uppercase",
+  color: "var(--muted)",
+};
+
+function NumberField(props: {
+  name: string;
+  value: number;
+  onChange: (v: number) => void;
+  min?: number;
+}) {
+  return (
+    <label style={{ flex: 1 }}>
+      <span style={label}>{props.name}</span>
+      <input
+        aria-label={props.name}
+        type="number"
+        step={1}
+        min={props.min}
+        value={Number.isFinite(props.value) ? props.value : ""}
+        onChange={(e) => props.onChange(Math.round(Number(e.target.value)))}
+        style={input}
+      />
+    </label>
+  );
+}
+
+export interface InspectorProps {
+  name: string;
+  path: string;
+  site: SiteModel;
+  selected: number | null;
+  hidden: Set<string>;
+  issues: Issue[];
+  onSite: (site: SiteModel) => void;
+  onArea: (index: number, area: EditArea) => void;
+  onSelect: (index: number | null) => void;
+  onDelete: (index: number) => void;
+  onToggle: (name: string) => void;
+  onAdd: () => void;
+}
+
+export function Inspector(props: InspectorProps) {
+  const { site } = props;
+  const area = props.selected !== null ? site.areas[props.selected] : null;
+  const extent = site.extent_mm ?? [0, 0];
+  const setExtent = (i: 0 | 1, v: number) => {
+    const next: [number, number] = [extent[0], extent[1]];
+    next[i] = v;
+    props.onSite({ ...site, extent_mm: next });
+  };
+  const setArea = (patch: Partial<EditArea>) => {
+    if (props.selected === null || !area) return;
+    props.onArea(props.selected, { ...area, ...patch });
+  };
+  const role = area ? effectiveRole(area) : null;
+  const nameIsRole = !!area && (ROLES as string[]).includes(area.name);
+
+  return (
+    <div
+      data-testid="inspector"
+      style={{
+        width: 300,
+        flex: "none",
+        overflowY: "auto",
+        background: "var(--surface)",
+        borderLeft: "1px solid var(--hairline)",
+      }}
+    >
+      <div style={section}>
+        <div style={heading}>Site</div>
+        <span style={label}>name (the pack folder)</span>
+        <div style={{ fontFamily: "var(--font-mono)", fontSize: 13 }}>{props.name}</div>
+        <div style={{ fontSize: 10, color: "var(--muted)", wordBreak: "break-all", marginTop: 2 }}>
+          {props.path}
+        </div>
+        <label>
+          <span style={label}>anchor: where zero is on the floor</span>
+          <textarea
+            aria-label="anchor"
+            rows={3}
+            value={site.anchor ?? ""}
+            onChange={(e) => props.onSite({ ...site, anchor: e.target.value })}
+            style={{ ...input, fontFamily: "var(--font-ui)", resize: "vertical" }}
+          />
+        </label>
+        <div style={{ display: "flex", gap: 8 }}>
+          <NumberField name="extent W (mm)" value={extent[0]} min={1} onChange={(v) => setExtent(0, v)} />
+          <NumberField name="extent H (mm)" value={extent[1]} min={1} onChange={(v) => setExtent(1, v)} />
+        </div>
+        {site.connection && (
+          <div style={{ fontSize: 11, color: "var(--muted)", marginTop: 10 }}>
+            connection (read-only): {site.connection.conn ?? "-"}
+            {site.connection.swarm_id ? `, swarm ${site.connection.swarm_id}` : ""}
+          </div>
+        )}
+      </div>
+
+      {area && props.selected !== null && (
+        <div style={section} data-testid="area-inspector">
+          <div style={heading}>Area</div>
+          <label>
+            <span style={label}>name</span>
+            <input
+              aria-label="area name"
+              value={area.name}
+              onChange={(e) => {
+                const name = e.target.value;
+                setArea({ name, role: declaredRole(name, effectiveRole(area)) });
+              }}
+              style={input}
+            />
+          </label>
+          <label>
+            <span style={label}>role</span>
+            <select
+              aria-label="role"
+              value={role ?? ""}
+              onChange={(e) =>
+                setArea({ role: declaredRole(area.name, (e.target.value || null) as AreaRole | null) })
+              }
+              style={input}
+            >
+              <option value="" disabled={nameIsRole}>
+                none
+              </option>
+              {ROLES.map((r) => (
+                <option key={r} value={r}>
+                  {r}
+                  {area.role === null && r === area.name ? " (from its name)" : ""}
+                </option>
+              ))}
+            </select>
+          </label>
+          <div style={{ display: "flex", gap: 8 }}>
+            <NumberField name="x" value={area.x} onChange={(x) => setArea({ x })} />
+            <NumberField name="y" value={area.y} onChange={(y) => setArea({ y })} />
+          </div>
+          <div style={{ display: "flex", gap: 8 }}>
+            <NumberField name="w" value={area.w} min={1} onChange={(w) => setArea({ w })} />
+            <NumberField name="h" value={area.h} min={1} onChange={(h) => setArea({ h })} />
+          </div>
+          <label>
+            <span style={label}>comment (kept in the file)</span>
+            <input
+              aria-label="comment"
+              value={area.comment ?? ""}
+              onChange={(e) => setArea({ comment: e.target.value })}
+              style={{ ...input, fontFamily: "var(--font-ui)" }}
+            />
+          </label>
+          <button
+            type="button"
+            onClick={() => props.onDelete(props.selected!)}
+            style={{
+              marginTop: 12,
+              background: "transparent",
+              color: "var(--accent)",
+              border: "1px solid var(--accent)",
+              borderRadius: 4,
+              padding: "4px 10px",
+              cursor: "pointer",
+            }}
+          >
+            Delete area
+          </button>
+        </div>
+      )}
+
+      <div style={section}>
+        <div style={{ display: "flex", alignItems: "center" }}>
+          <div style={{ ...heading, flex: 1 }}>Areas</div>
+          <button
+            type="button"
+            onClick={props.onAdd}
+            style={{
+              background: "transparent",
+              color: "var(--text)",
+              border: "1px solid var(--hairline)",
+              borderRadius: 4,
+              padding: "2px 8px",
+              cursor: "pointer",
+              fontSize: 12,
+            }}
+          >
+            + Add area
+          </button>
+        </div>
+        {site.areas.map((a, i) => (
+          <div
+            key={i}
+            style={{
+              display: "flex",
+              alignItems: "center",
+              gap: 6,
+              padding: "4px 6px",
+              marginTop: 4,
+              borderRadius: 4,
+              background: i === props.selected ? "var(--elevated)" : "transparent",
+              cursor: "pointer",
+              fontSize: 12,
+            }}
+            onClick={() => props.onSelect(i)}
+          >
+            <input
+              type="checkbox"
+              aria-label={`show ${a.name}`}
+              title="shown on the canvas (never changes the file)"
+              checked={!props.hidden.has(a.name)}
+              onClick={(e) => e.stopPropagation()}
+              onChange={() => props.onToggle(a.name)}
+            />
+            <span style={{ flex: 1, fontFamily: "var(--font-mono)" }}>{a.name || "(no name)"}</span>
+            <span style={{ color: "var(--muted)", fontSize: 11 }}>{effectiveRole(a) ?? ""}</span>
+          </div>
+        ))}
+      </div>
+
+      {props.issues.length > 0 && (
+        <div style={section} data-testid="issues">
+          <div style={heading}>Checks</div>
+          {props.issues.map((issue, i) => (
+            <div
+              key={i}
+              style={{
+                fontSize: 12,
+                marginTop: 6,
+                color: issue.level === "error" ? "var(--s-Stopping)" : "var(--s-Programming)",
+              }}
+            >
+              {issue.level === "error" ? "error: " : "warning: "}
+              {issue.message}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
new file mode 100644
index 00000000..89208849
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -0,0 +1,447 @@
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+
+import { RefusedSiteError, StaleSiteError, fetchSite, previewSite, saveSite, stopEditor } from "./api";
+import { Canvas } from "./Canvas";
+import type { Tool } from "./Canvas";
+import {
+  SNAP_DEFAULT_MM,
+  SNAP_STEPS_MM,
+  frameChanged,
+  freshName,
+  sameSite,
+  siteIssues,
+} from "./edit";
+import type { Rect } from "./edit";
+import { Inspector } from "./Inspector";
+import type { EditArea, SiteModel, SiteResponse } from "./types";
+
+// The site editor: one site pack's site.toml, drawn. It talks only to the
+// small server `dotbot site new|edit` starts, never to a controller.
+
+type Notice = { kind: "info" | "error" | "stale"; text: string } | null;
+type Dialog = { kind: "toml"; text: string } | { kind: "frame" } | null;
+
+function useTheme(): "dark" | "light" {
+  const preset = new URLSearchParams(window.location.search).get("theme");
+  const query = typeof window.matchMedia === "function" ? window.matchMedia("(prefers-color-scheme: light)") : null;
+  const [light, setLight] = useState(query?.matches ?? false);
+  useEffect(() => {
+    if (!query) return;
+    const onChange = (e: MediaQueryListEvent) => setLight(e.matches);
+    query.addEventListener?.("change", onChange);
+    return () => query.removeEventListener?.("change", onChange);
+  }, [query]);
+  if (preset === "light" || preset === "dark") return preset;
+  return light ? "light" : "dark";
+}
+
+const button: React.CSSProperties = {
+  background: "transparent",
+  color: "var(--text)",
+  border: "1px solid var(--hairline)",
+  borderRadius: 4,
+  padding: "5px 12px",
+  cursor: "pointer",
+  fontSize: 12,
+  fontFamily: "var(--font-ui)",
+};
+
+const TOOLS: { key: Tool | "wall" | "obstacle" | "charger"; label: string; hint: string }[] = [
+  { key: "select", label: "Select", hint: "V: select, move and resize" },
+  { key: "area", label: "Area", hint: "A: drag out a new area" },
+  { key: "wall", label: "Wall", hint: "needs a walls table in site.toml first" },
+  { key: "obstacle", label: "Obstacle", hint: "needs an obstacles table in site.toml first" },
+  { key: "charger", label: "Charger", hint: "needs an objects table in site.toml first" },
+];
+
+function typing(target: EventTarget | null): boolean {
+  const el = target as HTMLElement | null;
+  return !!el && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT");
+}
+
+export function SiteEditor() {
+  const theme = useTheme();
+  const [loaded, setLoaded] = useState<SiteResponse | null>(null);
+  const [site, setSite] = useState<SiteModel | null>(null);
+  const [selected, setSelected] = useState<number | null>(null);
+  const [hidden, setHidden] = useState<Set<string>>(new Set());
+  const [tool, setTool] = useState<Tool>("select");
+  const [snapMm, setSnapMm] = useState(SNAP_DEFAULT_MM);
+  const [notice, setNotice] = useState<Notice>(null);
+  const [dialog, setDialog] = useState<Dialog>(null);
+  const [stopped, setStopped] = useState(false);
+
+  const load = useCallback(async () => {
+    try {
+      const body = await fetchSite();
+      setLoaded(body);
+      setSite(body.site);
+      setSelected(null);
+      setNotice(null);
+    } catch (err) {
+      setNotice({ kind: "error", text: `could not load the site: ${(err as Error).message}` });
+    }
+  }, []);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const issues = useMemo(() => (site ? siteIssues(site) : []), [site]);
+  const errors = issues.filter((i) => i.level === "error");
+  const dirty = !!site && !!loaded && !sameSite(site, loaded.site);
+  const calibrations = loaded?.calibrations.reduce((n, c) => n + c.count, 0) ?? 0;
+
+  const updateArea = (index: number, patch: Partial<EditArea>) => {
+    setSite((s) => (s ? { ...s, areas: s.areas.map((a, i) => (i === index ? { ...a, ...patch } : a)) } : s));
+  };
+  const addArea = (rect: Rect) => {
+    if (!site) return;
+    const area: EditArea = { name: freshName(site.areas), ...rect, role: null, comment: null, was: null };
+    setSite({ ...site, areas: [...site.areas, area] });
+    setSelected(site.areas.length);
+    setTool("select");
+  };
+  const deleteArea = (index: number) => {
+    setSite((s) => (s ? { ...s, areas: s.areas.filter((_, i) => i !== index) } : s));
+    setSelected(null);
+  };
+  const addDefaultArea = () => {
+    const [w, h] = site?.extent_mm ?? [2000, 2000];
+    addArea({ x: 0, y: 0, w: Math.min(1000, w), h: Math.min(1000, h) });
+  };
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (typing(e.target) || e.ctrlKey || e.metaKey) return;
+      if (e.key === "v" || e.key === "V") setTool("select");
+      else if (e.key === "a" || e.key === "A") setTool("area");
+      else if (e.key === "Escape") setSelected(null);
+      else if ((e.key === "Delete" || e.key === "Backspace") && selected !== null) deleteArea(selected);
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [selected]);
+
+  useEffect(() => {
+    const onLeave = (e: BeforeUnloadEvent) => {
+      if (dirty && !stopped) e.preventDefault();
+    };
+    window.addEventListener("beforeunload", onLeave);
+    return () => window.removeEventListener("beforeunload", onLeave);
+  }, [dirty, stopped]);
+
+  const doSave = async () => {
+    if (!site || !loaded) return;
+    setDialog(null);
+    try {
+      const body = await saveSite(loaded.revision, site);
+      setLoaded(body);
+      setSite(body.site);
+      setNotice({ kind: "info", text: body.written ? `saved ${body.path}` : "nothing to save" });
+    } catch (err) {
+      if (err instanceof StaleSiteError) {
+        setNotice({
+          kind: "stale",
+          text: "site.toml changed on disk since this page loaded it, so it was not saved. Reload takes the file as it is now and drops the edits made here.",
+        });
+      } else if (err instanceof RefusedSiteError) {
+        setNotice({ kind: "error", text: `not saved: ${err.message}` });
+      } else {
+        setNotice({ kind: "error", text: `not saved: ${(err as Error).message}` });
+      }
+    }
+  };
+
+  const onSave = () => {
+    if (!site || !loaded) return;
+    if (calibrations > 0 && frameChanged(site, loaded.site)) setDialog({ kind: "frame" });
+    else void doSave();
+  };
+
+  const onViewToml = async () => {
+    if (!site) return;
+    try {
+      const { text } = await previewSite(site);
+      setDialog({ kind: "toml", text });
+    } catch (err) {
+      setNotice({ kind: "error", text: (err as Error).message });
+    }
+  };
+
+  const onDone = async () => {
+    if (dirty && !window.confirm("Stop the editor without saving your changes?")) return;
+    await stopEditor();
+    setStopped(true);
+  };
+
+  const shell: React.CSSProperties = {
+    height: "100vh",
+    width: "100vw",
+    display: "flex",
+    flexDirection: "column",
+    background: "var(--canvas)",
+    color: "var(--text)",
+    fontFamily: "var(--font-ui)",
+    fontSize: 13,
+    overflow: "hidden",
+  };
+
+  if (stopped) {
+    return (
+      <div data-theme={theme} style={{ ...shell, alignItems: "center", justifyContent: "center" }}>
+        The site editor has stopped. You can close this tab.
+      </div>
+    );
+  }
+
+  return (
+    <div data-theme={theme} style={shell}>
+      <div
+        style={{
+          height: 44,
+          flex: "none",
+          display: "flex",
+          alignItems: "center",
+          gap: 10,
+          padding: "0 14px",
+          background: "var(--surface)",
+          borderBottom: "1px solid var(--hairline)",
+        }}
+      >
+        <div style={{ fontWeight: 700, fontSize: 15 }}>Site editor</div>
+        <div style={{ fontFamily: "var(--font-mono)", color: "var(--muted)" }}>
+          {loaded?.name ?? "..."}
+          {dirty ? " (unsaved)" : ""}
+        </div>
+        <div style={{ flex: 1 }} />
+        <label style={{ fontSize: 12, color: "var(--muted)" }}>
+          snap{" "}
+          <select
+            aria-label="snap"
+            value={snapMm}
+            onChange={(e) => setSnapMm(Number(e.target.value))}
+            style={{ ...button, padding: "3px 6px" }}
+          >
+            {SNAP_STEPS_MM.map((s) => (
+              <option key={s} value={s}>
+                {s === 1 ? "off" : `${s} mm`}
+              </option>
+            ))}
+          </select>
+        </label>
+        <button type="button" style={button} onClick={onViewToml} disabled={!site}>
+          View TOML
+        </button>
+        <button
+          type="button"
+          onClick={onSave}
+          disabled={!site || errors.length > 0}
+          title={errors.length > 0 ? errors[0].message : "write site.toml"}
+          style={{
+            ...button,
+            background: dirty && errors.length === 0 ? "var(--accent)" : "transparent",
+            color: dirty && errors.length === 0 ? "#fff" : "var(--text)",
+            opacity: errors.length > 0 ? 0.5 : 1,
+          }}
+        >
+          Save
+        </button>
+        <button type="button" style={button} onClick={onDone}>
+          Done
+        </button>
+      </div>
+
+      {notice && (
+        <div
+          role="status"
+          style={{
+            flex: "none",
+            display: "flex",
+            gap: 10,
+            alignItems: "center",
+            padding: "6px 14px",
+            fontSize: 12,
+            background: "var(--elevated)",
+            color: notice.kind === "info" ? "var(--text)" : "var(--s-Stopping)",
+            borderBottom: "1px solid var(--hairline)",
+          }}
+        >
+          <span style={{ flex: 1 }}>{notice.text}</span>
+          {notice.kind === "stale" && (
+            <button type="button" style={button} onClick={() => void load()}>
+              Reload
+            </button>
+          )}
+          <button type="button" style={{ ...button, border: "none" }} onClick={() => setNotice(null)}>
+            x
+          </button>
+        </div>
+      )}
+
+      <div style={{ flex: 1, display: "flex", minHeight: 0 }}>
+        <div
+          style={{
+            width: 88,
+            flex: "none",
+            display: "flex",
+            flexDirection: "column",
+            gap: 6,
+            padding: 8,
+            background: "var(--surface)",
+            borderRight: "1px solid var(--hairline)",
+          }}
+        >
+          {TOOLS.map((t) => {
+            const enabled = t.key === "select" || t.key === "area";
+            const active = t.key === tool;
+            return (
+              <button
+                key={t.key}
+                type="button"
+                title={t.hint}
+                disabled={!enabled}
+                aria-pressed={active}
+                onClick={() => enabled && setTool(t.key as Tool)}
+                style={{
+                  ...button,
+                  padding: "8px 4px",
+                  opacity: enabled ? 1 : 0.4,
+                  cursor: enabled ? "pointer" : "not-allowed",
+                  background: active ? "var(--elevated)" : "transparent",
+                  borderColor: active ? "var(--accent)" : "var(--hairline)",
+                }}
+              >
+                {t.label}
+              </button>
+            );
+          })}
+        </div>
+
+        {site ? (
+          <Canvas
+            extent={site.extent_mm}
+            areas={site.areas}
+            hidden={hidden}
+            selected={selected}
+            tool={tool}
+            snapMm={snapMm}
+            onSelect={setSelected}
+            onChange={(i, r) => updateArea(i, r)}
+            onDraw={addArea}
+          />
+        ) : (
+          <div style={{ flex: 1 }} />
+        )}
+
+        {site && loaded && (
+          <Inspector
+            name={loaded.name}
+            path={loaded.path}
+            site={site}
+            selected={selected}
+            hidden={hidden}
+            issues={issues}
+            onSite={setSite}
+            onArea={(i, a) => updateArea(i, a)}
+            onSelect={setSelected}
+            onDelete={deleteArea}
+            onToggle={(name) =>
+              setHidden((h) => {
+                const next = new Set(h);
+                if (next.has(name)) next.delete(name);
+                else next.add(name);
+                return next;
+              })
+            }
+            onAdd={addDefaultArea}
+          />
+        )}
+      </div>
+
+      <div
+        style={{
+          flex: "none",
+          padding: "6px 14px",
+          fontSize: 11,
+          color: "var(--muted)",
+          background: "var(--surface)",
+          borderTop: "1px solid var(--hairline)",
+          display: "flex",
+          gap: 18,
+        }}
+      >
+        <span>Save writes only what changed in site.toml; comments and order are kept.</span>
+        {calibrations > 0 && (
+          <span data-testid="calibration-note" style={{ color: "var(--s-Programming)" }}>
+            {calibrations} calibration file{calibrations === 1 ? "" : "s"} for this site: moving the anchor or
+            the extent means collecting again, or calibrate-lh2 reframe. Areas are free to change.
+          </span>
+        )}
+      </div>
+
+      {dialog && (
+        <div
+          role="dialog"
+          style={{
+            position: "fixed",
+            inset: 0,
+            background: "rgba(0,0,0,0.45)",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+          }}
+          onClick={() => setDialog(null)}
+        >
+          <div
+            onClick={(e) => e.stopPropagation()}
+            style={{
+              maxWidth: 720,
+              width: "90vw",
+              maxHeight: "80vh",
+              overflow: "auto",
+              background: "var(--surface)",
+              border: "1px solid var(--hairline)",
+              borderRadius: 6,
+              padding: 16,
+            }}
+          >
+            {dialog.kind === "toml" ? (
+              <>
+                <div style={{ fontWeight: 600, marginBottom: 8 }}>site.toml as Save would write it</div>
+                <pre
+                  data-testid="toml-preview"
+                  style={{ fontFamily: "var(--font-mono)", fontSize: 12, whiteSpace: "pre-wrap", margin: 0 }}
+                >
+                  {dialog.text}
+                </pre>
+              </>
+            ) : (
+              <>
+                <div style={{ fontWeight: 600, marginBottom: 8 }}>Change the frame of a calibrated site?</div>
+                <p style={{ margin: "0 0 12px" }}>
+                  This site has {calibrations} calibration file{calibrations === 1 ? "" : "s"}. They were taken with
+                  the anchor and extent as they are in the file now: after this change, collect again with{" "}
+                  <code>dotbot swarm calibrate-lh2 collect</code>, or re-express a calibration with{" "}
+                  <code>dotbot swarm calibrate-lh2 reframe</code>.
+                </p>
+                <div style={{ display: "flex", gap: 8, justifyContent: "flex-end" }}>
+                  <button type="button" style={button} onClick={() => setDialog(null)}>
+                    Cancel
+                  </button>
+                  <button
+                    type="button"
+                    style={{ ...button, background: "var(--accent)", color: "#fff" }}
+                    onClick={() => void doSave()}
+                  >
+                    Save anyway
+                  </button>
+                </div>
+              </>
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/dotbot/console-web/src/siteEditor/api.test.ts b/dotbot/console-web/src/siteEditor/api.test.ts
new file mode 100644
index 00000000..03f15da8
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/api.test.ts
@@ -0,0 +1,44 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { RefusedSiteError, StaleSiteError, fetchSite, saveSite } from "./api";
+import type { SiteModel } from "./types";
+
+const site: SiteModel = {
+  anchor: "a",
+  extent_mm: [1000, 1000],
+  areas: [{ name: "field", x: 0, y: 0, w: 500, h: 500, role: null, comment: "", was: "field" }],
+};
+
+function reply(status: number, body: unknown) {
+  return vi.fn().mockResolvedValue(
+    new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } }),
+  );
+}
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("site editor api", () => {
+  it("marks each loaded area with its name in the file", async () => {
+    vi.stubGlobal("fetch", reply(200, { name: "s", path: "p", revision: "r", calibrations: [], site }));
+    const body = await fetchSite();
+    expect(body.site.areas[0].was).toBe("field");
+  });
+
+  it("sends the revision the page loaded, and an empty comment as none", async () => {
+    const fetch = reply(200, { name: "s", path: "p", revision: "r2", calibrations: [], site, written: true });
+    vi.stubGlobal("fetch", fetch);
+    await saveSite("r1", site);
+    const [, init] = fetch.mock.calls[0];
+    const sent = JSON.parse(init.body);
+    expect(init.method).toBe("PUT");
+    expect(sent.revision).toBe("r1");
+    expect(sent.site.areas[0].comment).toBeNull();
+  });
+
+  it("tells a stale save from a refused one", async () => {
+    vi.stubGlobal("fetch", reply(409, { detail: "changed on disk" }));
+    await expect(saveSite("r1", site)).rejects.toBeInstanceOf(StaleSiteError);
+    vi.stubGlobal("fetch", reply(422, { detail: "at most one field" }));
+    await expect(saveSite("r1", site)).rejects.toThrow(RefusedSiteError);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
new file mode 100644
index 00000000..d7e6f108
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -0,0 +1,69 @@
+import type { SiteModel, SiteResponse } from "./types";
+
+// The editor's server, relative to the page so it works wherever it is mounted.
+
+export class StaleSiteError extends Error {}
+export class RefusedSiteError extends Error {}
+
+async function detail(res: Response): Promise<string> {
+  try {
+    const body = await res.json();
+    return typeof body.detail === "string" ? body.detail : JSON.stringify(body.detail);
+  } catch {
+    return `${res.status} ${res.statusText}`;
+  }
+}
+
+/** Areas as the server takes them, each with the name the file knows it by. */
+function outgoing(site: SiteModel) {
+  return {
+    anchor: site.anchor || null,
+    extent_mm: site.extent_mm,
+    areas: site.areas.map((a) => ({ ...a, comment: a.comment || null })),
+  };
+}
+
+/** The loaded site, with each area's `was` set to its name in the file. */
+export function withOrigins(body: SiteResponse): SiteResponse {
+  return {
+    ...body,
+    site: { ...body.site, areas: body.site.areas.map((a) => ({ ...a, was: a.name })) },
+  };
+}
+
+export async function fetchSite(): Promise<SiteResponse> {
+  const res = await fetch("api/site");
+  if (!res.ok) throw new Error(await detail(res));
+  return withOrigins(await res.json());
+}
+
+export async function previewSite(site: SiteModel): Promise<{ text: string; changed: boolean }> {
+  const res = await fetch("api/preview", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(outgoing(site)),
+  });
+  if (res.status === 422) throw new RefusedSiteError(await detail(res));
+  if (!res.ok) throw new Error(await detail(res));
+  return res.json();
+}
+
+/**
+ * Save `site` over the file revision the page loaded. A file changed on disk
+ * since throws StaleSiteError; one the schema refuses throws RefusedSiteError.
+ */
+export async function saveSite(revision: string, site: SiteModel): Promise<SiteResponse> {
+  const res = await fetch("api/site", {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ revision, site: outgoing(site) }),
+  });
+  if (res.status === 409) throw new StaleSiteError(await detail(res));
+  if (res.status === 422) throw new RefusedSiteError(await detail(res));
+  if (!res.ok) throw new Error(await detail(res));
+  return withOrigins(await res.json());
+}
+
+export async function stopEditor(): Promise<void> {
+  await fetch("api/done", { method: "POST" });
+}
diff --git a/dotbot/console-web/src/siteEditor/edit.test.ts b/dotbot/console-web/src/siteEditor/edit.test.ts
new file mode 100644
index 00000000..79ce77ce
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/edit.test.ts
@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  declaredRole,
+  effectiveRole,
+  frameChanged,
+  freshName,
+  moveRect,
+  rectFromDrag,
+  resizeRect,
+  sameSite,
+  siteIssues,
+  snap,
+} from "./edit";
+import type { EditArea, SiteModel } from "./types";
+
+const area = (name: string, x: number, y: number, w: number, h: number, role: EditArea["role"] = null): EditArea => ({
+  name,
+  x,
+  y,
+  w,
+  h,
+  role,
+  comment: null,
+  was: name,
+});
+
+const arena = (): SiteModel => ({
+  anchor: "the door corner",
+  extent_mm: [2000, 4000],
+  areas: [
+    area("field", 0, 0, 2000, 2000),
+    area("staging", 0, 2000, 2000, 2000),
+    area("field+staging", 0, 0, 2000, 4000),
+    area("dev-corner", 1000, 0, 1000, 1000, "corner"),
+  ],
+});
+
+describe("snapping and dragging", () => {
+  it("snaps to the step and leaves free placement at 1 mm", () => {
+    expect(snap(1024, 50)).toBe(1000);
+    expect(snap(1026, 50)).toBe(1050);
+    expect(snap(1026.4, 1)).toBe(1026);
+  });
+
+  it("moves the corner onto the grid, keeping the size", () => {
+    expect(moveRect({ x: 1000, y: 0, w: 1000, h: 1000 }, 48, 12, 50)).toEqual({ x: 1050, y: 0, w: 1000, h: 1000 });
+  });
+
+  it("resizes only the dragged edges", () => {
+    const start = { x: 1000, y: 0, w: 1000, h: 1000 };
+    expect(resizeRect(start, "se", { x: 2230, y: 1490 }, 50)).toEqual({ x: 1000, y: 0, w: 1250, h: 1500 });
+    expect(resizeRect(start, "w", { x: 510, y: 9999 }, 50)).toEqual({ x: 500, y: 0, w: 1500, h: 1000 });
+    expect(resizeRect(start, "n", { x: 0, y: 260 }, 50)).toEqual({ x: 1000, y: 250, w: 1000, h: 750 });
+  });
+
+  it("never flips or collapses a rectangle past its opposite edge", () => {
+    const start = { x: 1000, y: 1000, w: 500, h: 500 };
+    expect(resizeRect(start, "e", { x: 200, y: 0 }, 50)).toEqual({ x: 1000, y: 1000, w: 50, h: 500 });
+    expect(resizeRect(start, "nw", { x: 3000, y: 3000 }, 50)).toEqual({ x: 1450, y: 1450, w: 50, h: 50 });
+  });
+
+  it("draws a rectangle from either corner, and ignores a click", () => {
+    expect(rectFromDrag({ x: 1210, y: 990 }, { x: 190, y: 20 }, 50)).toEqual({ x: 200, y: 0, w: 1000, h: 1000 });
+    expect(rectFromDrag({ x: 100, y: 100 }, { x: 110, y: 104 }, 50)).toBeNull();
+  });
+});
+
+describe("roles", () => {
+  it("takes the role from the name unless one is declared", () => {
+    expect(effectiveRole({ name: "field", role: null })).toBe("field");
+    expect(effectiveRole({ name: "dock", role: null })).toBeNull();
+    expect(effectiveRole({ name: "field", role: "corner" })).toBe("corner");
+  });
+
+  it("declares a role only when the name does not already say it", () => {
+    expect(declaredRole("field", "field")).toBeNull();
+    expect(declaredRole("dock", "staging")).toBe("staging");
+    expect(declaredRole("staging", "corner")).toBe("corner");
+  });
+
+  it("picks a name no area has", () => {
+    expect(freshName([area("area-1", 0, 0, 1, 1)])).toBe("area-2");
+  });
+});
+
+describe("siteIssues", () => {
+  it("finds nothing wrong with a well-formed site", () => {
+    expect(siteIssues(arena())).toEqual([]);
+  });
+
+  it("refuses a second field, as the schema does", () => {
+    const site = arena();
+    site.areas[1].role = "field";
+    expect(siteIssues(site).filter((i) => i.level === "error")[0].message).toMatch(/at most one field/);
+  });
+
+  it("refuses names the resolver cannot reach", () => {
+    const site = arena();
+    site.areas[1].name = "a,b";
+    site.areas[3].name = "field";
+    const messages = siteIssues(site).map((i) => i.message);
+    expect(messages.some((m) => m.includes("comma"))).toBe(true);
+    expect(messages.some((m) => m.includes("two areas are named field"))).toBe(true);
+  });
+
+  it("warns about an area outside the extent and an oversized field", () => {
+    const site = arena();
+    site.areas[3].x = 1500;
+    site.areas[0] = area("field", 0, 0, 6000, 2000);
+    const warnings = siteIssues(site).filter((i) => i.level === "warning").map((i) => i.area);
+    expect(warnings).toContain("dev-corner");
+    expect(warnings).toContain("field");
+  });
+
+  it("warns when a composite is not the bounding box of its parts", () => {
+    const site = arena();
+    site.areas[1].h = 1000;
+    const issue = siteIssues(site).find((i) => i.area === "field+staging");
+    expect(issue?.message).toMatch(/0, 0, 2000 x 3000/);
+  });
+});
+
+describe("change tracking", () => {
+  it("tells a frame change from an area change", () => {
+    const site = arena();
+    const moved = { ...site, areas: site.areas.map((a, i) => (i === 3 ? { ...a, x: 950 } : a)) };
+    expect(frameChanged(site, moved)).toBe(false);
+    expect(frameChanged(site, { ...site, extent_mm: [2000, 4050] })).toBe(true);
+    expect(frameChanged(site, { ...site, anchor: "elsewhere" })).toBe(true);
+    expect(sameSite(site, moved)).toBe(false);
+    expect(sameSite(site, { ...site, anchor: "the door corner" })).toBe(true);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/edit.ts b/dotbot/console-web/src/siteEditor/edit.ts
new file mode 100644
index 00000000..5a5b3bdb
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/edit.ts
@@ -0,0 +1,203 @@
+import type { AreaRole } from "../types";
+import type { EditArea, SiteModel } from "./types";
+
+// The editor's geometry and checks, apart from any drawing: snapping, moving,
+// resizing and drawing a rectangle in frame millimetres, and what a site must
+// satisfy before it is saved.
+
+export const ROLES: AreaRole[] = ["field", "staging", "corner"];
+
+/** The snap steps offered, in mm; 1 is free placement. */
+export const SNAP_STEPS_MM = [1, 10, 50, 100, 250, 500];
+export const SNAP_DEFAULT_MM = 50;
+
+/** Above this, one LH2 base station rarely covers the field (as `config init` warns). */
+export const FIELD_COVERAGE_MM = 5000;
+
+export interface Rect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+export type Handle = "n" | "s" | "e" | "w" | "ne" | "nw" | "se" | "sw";
+export const HANDLES: Handle[] = ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
+
+export function snap(v: number, step: number): number {
+  return Math.round(v / step) * step;
+}
+
+/** `start` moved by (dx, dy), its top-left corner on the snap grid. */
+export function moveRect(start: Rect, dx: number, dy: number, step: number): Rect {
+  return { ...start, x: snap(start.x + dx, step), y: snap(start.y + dy, step) };
+}
+
+/**
+ * `start` with the edges `handle` names dragged to `p`, each on the snap grid
+ * and never closer than `step` to the opposite edge, so a rectangle cannot
+ * flip or vanish under the pointer.
+ */
+export function resizeRect(
+  start: Rect,
+  handle: Handle,
+  p: { x: number; y: number },
+  step: number,
+): Rect {
+  const min = Math.max(1, step);
+  let left = start.x;
+  let top = start.y;
+  let right = start.x + start.w;
+  let bottom = start.y + start.h;
+  if (handle.includes("w")) left = Math.min(snap(p.x, step), right - min);
+  if (handle.includes("e")) right = Math.max(snap(p.x, step), left + min);
+  if (handle.includes("n")) top = Math.min(snap(p.y, step), bottom - min);
+  if (handle.includes("s")) bottom = Math.max(snap(p.y, step), top + min);
+  return { x: left, y: top, w: right - left, h: bottom - top };
+}
+
+/** The rectangle a drag from `a` to `b` draws, on the snap grid; null when too small. */
+export function rectFromDrag(
+  a: { x: number; y: number },
+  b: { x: number; y: number },
+  step: number,
+): Rect | null {
+  const x0 = snap(Math.min(a.x, b.x), step);
+  const y0 = snap(Math.min(a.y, b.y), step);
+  const x1 = snap(Math.max(a.x, b.x), step);
+  const y1 = snap(Math.max(a.y, b.y), step);
+  if (x1 - x0 < Math.max(1, step) || y1 - y0 < Math.max(1, step)) return null;
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+
+/** The role an area has: the one it declares, else the one its name is. */
+export function effectiveRole(area: Pick<EditArea, "name" | "role">): AreaRole | null {
+  if (area.role) return area.role;
+  return (ROLES as string[]).includes(area.name) ? (area.name as AreaRole) : null;
+}
+
+/**
+ * The role to declare for a chosen role: none when the name already implies
+ * it, so the file stays as short as a hand-written one.
+ */
+export function declaredRole(name: string, chosen: AreaRole | null): AreaRole | null {
+  if (chosen === null) return null;
+  return (ROLES as string[]).includes(name) && name === chosen ? null : chosen;
+}
+
+/** A name not yet taken, `area-1`, `area-2`, ... */
+export function freshName(areas: EditArea[], base = "area"): string {
+  const taken = new Set(areas.map((a) => a.name));
+  for (let n = 1; ; n += 1) {
+    if (!taken.has(`${base}-${n}`)) return `${base}-${n}`;
+  }
+}
+
+export interface Issue {
+  level: "error" | "warning";
+  message: string;
+  area?: string;
+}
+
+function bbox(rects: Rect[]): Rect {
+  const x = Math.min(...rects.map((r) => r.x));
+  const y = Math.min(...rects.map((r) => r.y));
+  const x1 = Math.max(...rects.map((r) => r.x + r.w));
+  const y1 = Math.max(...rects.map((r) => r.y + r.h));
+  return { x, y, w: x1 - x, h: y1 - y };
+}
+
+/**
+ * What stops a save (errors) and what is worth knowing (warnings). The errors
+ * are the ones the server's schema would refuse, found before the round trip.
+ */
+export function siteIssues(site: SiteModel): Issue[] {
+  const issues: Issue[] = [];
+  const names = new Map<string, number>();
+  for (const a of site.areas) names.set(a.name, (names.get(a.name) ?? 0) + 1);
+
+  const fields = site.areas.filter((a) => effectiveRole(a) === "field");
+  if (fields.length > 1) {
+    issues.push({
+      level: "error",
+      message: `a site has at most one field, and ${fields.map((a) => a.name).join(" and ")} are both one`,
+    });
+  }
+  const extent = site.extent_mm;
+  if (extent && (!(extent[0] > 0) || !(extent[1] > 0))) {
+    issues.push({ level: "error", message: "the extent needs a width and a height" });
+  }
+  for (const a of site.areas) {
+    const name = a.name;
+    if (!name.trim()) {
+      issues.push({ level: "error", area: name, message: "an area needs a name" });
+    } else if (name !== name.trim()) {
+      issues.push({ level: "error", area: name, message: `${name}: no spaces around the name` });
+    } else if (name.includes(",")) {
+      issues.push({
+        level: "error",
+        area: name,
+        message: `${name}: a comma makes the name read as an x,y,w,h literal`,
+      });
+    }
+    if ((names.get(name) ?? 0) > 1) {
+      issues.push({ level: "error", area: name, message: `two areas are named ${name}` });
+    }
+    if (!(a.w > 0) || !(a.h > 0)) {
+      issues.push({ level: "error", area: name, message: `${name} needs a width and a height` });
+    }
+    if (
+      extent &&
+      (a.x < 0 || a.y < 0 || a.x + a.w > extent[0] || a.y + a.h > extent[1])
+    ) {
+      issues.push({
+        level: "warning",
+        area: name,
+        message: `${name} reaches outside the extent, where the bot drops positions`,
+      });
+    }
+    if (effectiveRole(a) === "field" && Math.max(a.w, a.h) > FIELD_COVERAGE_MM) {
+      issues.push({
+        level: "warning",
+        area: name,
+        message: `${name}: one LH2 base station rarely covers a field over ${FIELD_COVERAGE_MM / 1000} x ${FIELD_COVERAGE_MM / 1000} m`,
+      });
+    }
+    const parts = name.split("+");
+    if (parts.length > 1) {
+      const found = parts.map((p) => site.areas.find((b) => b.name === p));
+      if (found.every((b): b is EditArea => !!b)) {
+        const box = bbox(found);
+        if (box.x !== a.x || box.y !== a.y || box.w !== a.w || box.h !== a.h) {
+          issues.push({
+            level: "warning",
+            area: name,
+            message: `${name} is not the bounding box of ${parts.join(" and ")} (${box.x}, ${box.y}, ${box.w} x ${box.h})`,
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+/** Whether the anchor or the extent differ, which a calibration depends on. */
+export function frameChanged(a: SiteModel, b: SiteModel): boolean {
+  return (
+    (a.anchor ?? "") !== (b.anchor ?? "") ||
+    JSON.stringify(a.extent_mm) !== JSON.stringify(b.extent_mm)
+  );
+}
+
+/** Whether two models would write the same file. */
+export function sameSite(a: SiteModel, b: SiteModel): boolean {
+  const strip = (s: SiteModel) =>
+    JSON.stringify({
+      anchor: s.anchor || null,
+      extent_mm: s.extent_mm,
+      areas: s.areas.map(({ name, x, y, w, h, role, comment, was }) => ({
+        name, x, y, w, h, role, comment: comment || null, was: was ?? null,
+      })),
+    });
+  return strip(a) === strip(b);
+}
diff --git a/dotbot/console-web/src/siteEditor/main.tsx b/dotbot/console-web/src/siteEditor/main.tsx
new file mode 100644
index 00000000..4dfd5125
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/main.tsx
@@ -0,0 +1,11 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+
+import "../tokens.css";
+import { SiteEditor } from "./SiteEditor";
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <SiteEditor />
+  </React.StrictMode>,
+);
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
new file mode 100644
index 00000000..17897d66
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -0,0 +1,107 @@
+import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { SiteEditor } from "./SiteEditor";
+import type { SiteResponse } from "./types";
+
+const loaded = (count = 0): SiteResponse => ({
+  name: "arena",
+  path: "/packs/arena/site.toml",
+  revision: "r1",
+  calibrations: [{ folder: "/home/cal/arena", count }],
+  site: {
+    anchor: "the door corner",
+    extent_mm: [2000, 4000],
+    areas: [
+      { name: "field", x: 0, y: 0, w: 2000, h: 2000, role: null, comment: "top" },
+      { name: "dev-corner", x: 1000, y: 0, w: 1000, h: 1000, role: "corner", comment: null },
+    ],
+    connection: null,
+  },
+});
+
+function server(first: SiteResponse, save: { status: number; body: unknown }) {
+  const fetch = vi.fn(async (url: string, init?: RequestInit) => {
+    const json = (status: number, body: unknown) =>
+      new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+    if (url === "api/site" && (!init || !init.method)) return json(200, first);
+    if (url === "api/site" && init?.method === "PUT") return json(save.status, save.body);
+    return json(404, { detail: "no" });
+  });
+  vi.stubGlobal("fetch", fetch);
+  return fetch;
+}
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("SiteEditor", () => {
+  it("draws every area and the anchor", async () => {
+    server(loaded(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    expect(await screen.findByTestId("edit-area-field")).toBeInTheDocument();
+    expect(screen.getByTestId("edit-area-dev-corner")).toBeInTheDocument();
+    expect(screen.getByTestId("anchor")).toBeInTheDocument();
+  });
+
+  it("edits an area's numbers and saves them with the loaded revision", async () => {
+    const fetch = server(loaded(), {
+      status: 200,
+      body: { ...loaded(), revision: "r2", written: true },
+    });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    fireEvent.click(screen.getByLabelText("show dev-corner").parentElement!);
+    fireEvent.change(screen.getByLabelText("x"), { target: { value: "950" } });
+    await act(async () => fireEvent.click(screen.getByText("Save")));
+    const put = fetch.mock.calls.find(([, init]) => init?.method === "PUT")!;
+    const sent = JSON.parse(put[1]!.body as string);
+    expect(sent.revision).toBe("r1");
+    expect(sent.site.areas[1].x).toBe(950);
+    expect(await screen.findByText(/saved \/packs\/arena\/site.toml/)).toBeInTheDocument();
+  });
+
+  it("offers Reload when the file changed on disk", async () => {
+    server(loaded(), { status: 409, body: { detail: "changed" } });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    fireEvent.change(screen.getByLabelText("anchor"), { target: { value: "moved" } });
+    await act(async () => fireEvent.click(screen.getByText("Save")));
+    expect(await screen.findByText("Reload")).toBeInTheDocument();
+  });
+
+  it("asks before changing the frame of a calibrated site, never for an area", async () => {
+    const fetch = server(loaded(2), { status: 200, body: { ...loaded(2), written: true } });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    expect(screen.getByTestId("calibration-note")).toHaveTextContent("2 calibration files");
+    fireEvent.change(screen.getByLabelText("extent W (mm)"), { target: { value: "2500" } });
+    fireEvent.click(screen.getByText("Save"));
+    expect(screen.getByRole("dialog")).toHaveTextContent("calibrate-lh2 reframe");
+    expect(fetch.mock.calls.some(([, init]) => init?.method === "PUT")).toBe(false);
+    await act(async () => fireEvent.click(screen.getByText("Save anyway")));
+    await waitFor(() => expect(fetch.mock.calls.some(([, init]) => init?.method === "PUT")).toBe(true));
+  });
+
+  it("blocks Save while a check fails", async () => {
+    server(loaded(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    fireEvent.click(screen.getByLabelText("show dev-corner").parentElement!);
+    fireEvent.change(screen.getByLabelText("role"), { target: { value: "field" } });
+    expect(screen.getByText("Save")).toBeDisabled();
+    expect(screen.getByTestId("issues")).toHaveTextContent("at most one field");
+  });
+
+  it("moves an area by dragging it, on the snap grid", async () => {
+    server(loaded(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    const corner = await screen.findByTestId("edit-area-dev-corner");
+    // An 800 x 600 canvas draws the 2 x 4 m site with its 400 mm margin at
+    // 0.115 px/mm, so 23 px is 200 mm.
+    fireEvent.pointerDown(corner, { button: 0, clientX: 300, clientY: 100, pointerId: 1 });
+    fireEvent.pointerMove(screen.getByTestId("site-canvas"), { clientX: 323, clientY: 101, pointerId: 1 });
+    fireEvent.pointerUp(screen.getByTestId("site-canvas"), { clientX: 323, clientY: 101, pointerId: 1 });
+    expect(screen.getByLabelText("x")).toHaveValue(1200);
+    expect(screen.getByLabelText("y")).toHaveValue(0);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/types.ts b/dotbot/console-web/src/siteEditor/types.ts
new file mode 100644
index 00000000..eedc331c
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/types.ts
@@ -0,0 +1,37 @@
+import type { AreaRole } from "../types";
+
+// The editor's model of a site pack's `site.toml`, as GET /api/site serves it.
+
+/** One area as the file declares it: `role` is the declared one, not the implied. */
+export interface EditArea {
+  name: string;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  role: AreaRole | null;
+  comment: string | null;
+  /** The area's name in the file when the page loaded it; null for a new one. */
+  was?: string | null;
+}
+
+export interface SiteModel {
+  anchor: string | null;
+  extent_mm: [number, number] | null;
+  areas: EditArea[];
+  connection?: { conn?: string | null; swarm_id?: string | null } | null;
+}
+
+export interface CalibrationFolder {
+  folder: string;
+  count: number;
+}
+
+export interface SiteResponse {
+  name: string;
+  path: string;
+  revision: string;
+  site: SiteModel;
+  calibrations: CalibrationFolder[];
+  written?: boolean;
+}
diff --git a/dotbot/console-web/vite.config.ts b/dotbot/console-web/vite.config.ts
index 97a8e8f9..22968d5f 100644
--- a/dotbot/console-web/vite.config.ts
+++ b/dotbot/console-web/vite.config.ts
@@ -6,18 +6,30 @@ import react from "@vitejs/plugin-react";
 //   /controller -> PyDotBot controller (REST + WS), default :8000
 //   /swarmit    -> swarmit status server (real or fake), default :8001
 //   /mrta       -> MRTA mode server (dotbot-logistics, or the fake), default :8002
-// Override with CONTROLLER_TARGET / SWARMIT_TARGET / MRTA_TARGET env vars when
-// the default ports are occupied by another instance.
+//   /api        -> a `dotbot site edit --port 8010` site editor server
+// Override with CONTROLLER_TARGET / SWARMIT_TARGET / MRTA_TARGET /
+// SITE_EDITOR_TARGET env vars when the default ports are occupied by another
+// instance.
 const controllerTarget =
   process.env.CONTROLLER_TARGET ?? "http://localhost:8000";
 const swarmitTarget = process.env.SWARMIT_TARGET ?? "http://localhost:8001";
 const mrtaTarget = process.env.MRTA_TARGET ?? "http://localhost:8002";
+const siteEditorTarget = process.env.SITE_EDITOR_TARGET ?? "http://127.0.0.1:8010";
 
 export default defineConfig({
   // Relative asset URLs: the production build is mounted at /console by the
   // controller; the dev server stays at /. API paths are absolute either way.
   base: "./",
   plugins: [react()],
+  // Two pages: the console, and the site editor `dotbot site new|edit` serves.
+  build: {
+    rollupOptions: {
+      input: {
+        console: "index.html",
+        siteEditor: "site-editor.html",
+      },
+    },
+  },
   server: {
     port: 5173,
     proxy: {
@@ -29,6 +41,7 @@ export default defineConfig({
         target: swarmitTarget,
         rewrite: (path) => path.replace(/^\/swarmit/, ""),
       },
+      "/api": siteEditorTarget,
       "/mrta": {
         target: mrtaTarget,
         rewrite: (path) => path.replace(/^\/mrta/, ""),

From f54ec654faa1d28e406f01340894674a191327b1 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 30 Sep 2026 14:38:00 +0200
Subject: [PATCH 03/80] dotbot/cli: add site new and site edit

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/main.py               |   3 +-
 dotbot/cli/site_cmd.py           | 129 +++++++++++++++++++++-
 dotbot/tests/test_site_editor.py | 178 +++++++++++++++++++++++++++++++
 3 files changed, 307 insertions(+), 3 deletions(-)
 create mode 100644 dotbot/tests/test_site_editor.py

diff --git a/dotbot/cli/main.py b/dotbot/cli/main.py
index f67e0e77..64f554eb 100644
--- a/dotbot/cli/main.py
+++ b/dotbot/cli/main.py
@@ -71,7 +71,8 @@
     (
         "site",
         "dotbot.cli.site_cmd",
-        "Sites: add a pack, switch with use, list / show, export one to share.",
+        "Sites: add a pack, switch with use, list / show, export one to share, "
+        "new / edit to draw one.",
     ),
 )
 
diff --git a/dotbot/cli/site_cmd.py b/dotbot/cli/site_cmd.py
index d428866d..0ab57ec8 100644
--- a/dotbot/cli/site_cmd.py
+++ b/dotbot/cli/site_cmd.py
@@ -7,7 +7,8 @@
 (`dotbot.site_packs`). `add` copies one into ~/.dotbot/sites/, where every
 folder finds it; `init` writes one around a spin calibration's robots; `use`
 makes a site the active one; `list` and `show` read; `export` writes one as a
-zip. The same folders can be shared with git, cp or unzip.
+zip; `new` and `edit` open the site editor on a pack. The same folders can be
+shared with git, cp or unzip.
 """
 
 import json
@@ -43,7 +44,7 @@
     name="site",
     help=(
         "The places you work in: add a site pack, switch with use, "
-        "list / show, export one to share."
+        "list / show, export one to share, new / edit to draw one."
     ),
 )
 def cmd():
@@ -681,6 +682,61 @@ def area(name: str, note: str) -> str:
     )
 
 
+def _serve_editor(name: str, pack: Path, port: int, headless: bool) -> None:
+    """Serve the editor on `pack` at 127.0.0.1 until Ctrl-C or Done."""
+    import socket
+    import threading
+    import webbrowser
+
+    import uvicorn
+
+    from dotbot.calibration.lighthouse2 import calibration_root
+    from dotbot.site_editor import EDITOR_DIR, EDITOR_PAGE, EditorState, create_app
+
+    if not (EDITOR_DIR / EDITOR_PAGE).is_file():
+        raise click.ClickException(
+            f"the site editor page is not built ({EDITOR_DIR / EDITOR_PAGE} is "
+            "missing). Build it with: npm --prefix dotbot/console-web install && "
+            "npm --prefix dotbot/console-web run build"
+        )
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        sock.bind(("127.0.0.1", port))
+    except OSError as exc:
+        sock.close()
+        raise click.ClickException(f"cannot listen on 127.0.0.1:{port}: {exc}") from exc
+    sock.listen()
+    url = f"http://127.0.0.1:{sock.getsockname()[1]}/"
+    state = EditorState(name, pack, [calibration_root() / name])
+    server = None
+
+    def done():
+        server.should_exit = True
+
+    app = create_app(state, on_done=done)
+    server = uvicorn.Server(uvicorn.Config(app, log_level="warning"))
+    click.echo(f"Editing site {name} ({pack / PACK_FILE})")
+    click.echo(f"Site editor at {url} - Ctrl-C or Done to stop")
+    if not headless:
+        threading.Thread(target=webbrowser.open, args=(url,), daemon=True).start()
+    try:
+        server.run(sockets=[sock])
+    finally:
+        sock.close()
+
+
+_PORT = click.option(
+    "--port",
+    type=int,
+    default=0,
+    show_default="a free port",
+    help="Port on 127.0.0.1 to serve the editor on.",
+)
+_HEADLESS = click.option(
+    "--headless", is_flag=True, help="Print the editor's URL; don't open a browser."
+)
+
+
 @cmd.command()
 @click.argument("name")
 @click.option(
@@ -784,3 +840,72 @@ def init(ctx, name, calibration, size, force):
         f"--lh2-calibration {placed.id8} "
         "--headless"
     )
+
+
+@cmd.command()
+@click.argument("name")
+@click.option(
+    "--field",
+    "field_spec",
+    default="2m",
+    show_default=True,
+    help="The starter field, as for `dotbot config init`: 2m, 2x3m, 1500mm.",
+)
+@_PORT
+@_HEADLESS
+@click.pass_context
+def new(ctx, name, field_spec, port, headless):
+    """Write a new site pack, then open the editor on it.
+
+    The pack goes in sites/NAME/ beside the project's dotbot.toml when one is
+    in use, else in ~/.dotbot/sites/NAME/, so `dotbot site use NAME` finds it
+    at once. It starts as `dotbot config init` starts a site: a field with
+    floor round it and a staging strip below. It is not made the active site.
+    """
+    from dotbot.cli.config_cmd import default_site_toml, parse_field_size
+    from dotbot.site_packs import site_homes
+
+    try:
+        check_site_name(name)
+    except ValueError as exc:
+        raise click.ClickException(str(exc)) from exc
+    field_mm = parse_field_size(field_spec)
+    _, home = site_homes((ctx.obj or {}).get("config"))[0]
+    target = home / name
+    if target.exists():
+        raise click.ClickException(f"{target} already exists")
+    target.mkdir(parents=True)
+    (target / PACK_FILE).write_text(default_site_toml(field_mm))
+    click.echo(f"Wrote {target / PACK_FILE}")
+    _serve_editor(name, target, port, headless)
+    click.echo(f"Work in it with `dotbot site use {name}`, or --site {name}.")
+
+
+@cmd.command()
+@click.argument("site", required=False)
+@_PORT
+@_HEADLESS
+@click.pass_context
+def edit(ctx, site, port, headless):
+    """Open the site editor on a site pack, at 127.0.0.1.
+
+    SITE is a site name or a pack folder's path; it defaults to the active
+    site.
+    """
+    from dotbot.site_packs import is_pack_path, pack_at
+
+    if site is not None and is_pack_path(site):
+        try:
+            entry = pack_at(site)
+        except ConfigError as exc:
+            raise click.ClickException(str(exc)) from exc
+        _serve_editor(entry.name, entry.pack, port, headless)
+        return
+    name = site or active_site(ctx).name
+    entry = _catalog(ctx).get(name)
+    if entry is None:
+        raise click.ClickException(
+            f"unknown site {name!r}; `dotbot site list` names the known ones, "
+            "and `dotbot site new` makes one"
+        )
+    _serve_editor(name, entry.pack, port, headless)
diff --git a/dotbot/tests/test_site_editor.py b/dotbot/tests/test_site_editor.py
new file mode 100644
index 00000000..e68efe71
--- /dev/null
+++ b/dotbot/tests/test_site_editor.py
@@ -0,0 +1,178 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""The site editor's server: read, preview and save one pack, refusing a save
+made against a file that has changed since."""
+
+import pytest
+from click.testing import CliRunner
+from fastapi.testclient import TestClient
+
+from dotbot.cli import site_cmd
+from dotbot.site_editor import EditorState, create_app
+from dotbot.tests.test_site_toml import ARENA
+
+
+@pytest.fixture
+def pack(tmp_path):
+    folder = tmp_path / "arena"
+    folder.mkdir()
+    (folder / "site.toml").write_text(ARENA)
+    return folder
+
+
+@pytest.fixture
+def page(tmp_path):
+    folder = tmp_path / "dist"
+    folder.mkdir()
+    (folder / "site-editor.html").write_text("<html>editor</html>")
+    return folder
+
+
+@pytest.fixture
+def client(pack, page, tmp_path):
+    calibrations = tmp_path / "home-calibrations" / "arena"
+    return TestClient(create_app(EditorState("arena", pack, [calibrations]), page))
+
+
+def _loaded(client):
+    body = client.get("/api/site").json()
+    for area in body["site"]["areas"]:
+        area["was"] = area["name"]
+    return body
+
+
+def test_the_page_and_the_site_are_served(client, pack):
+    assert client.get("/").text == "<html>editor</html>"
+    body = client.get("/api/site").json()
+    assert body["name"] == "arena"
+    assert body["path"] == str(pack / "site.toml")
+    assert body["site"]["extent_mm"] == [2000, 4000]
+    assert [c["count"] for c in body["calibrations"]] == [0, 0]
+
+
+def test_the_calibrations_are_counted(client, pack):
+    (pack / "calibrations").mkdir()
+    (pack / "calibrations" / "lh2-1.toml").write_text("")
+    assert client.get("/api/site").json()["calibrations"][0]["count"] == 1
+
+
+def test_a_save_writes_only_what_changed(client, pack):
+    body = _loaded(client)
+    body["site"]["areas"][3]["x"] = 1050
+    response = client.put(
+        "/api/site", json={"revision": body["revision"], "site": body["site"]}
+    )
+    assert response.status_code == 200
+    assert response.json()["written"] is True
+    assert (pack / "site.toml").read_text() == ARENA.replace(
+        'role = "corner"\nx = 1000', 'role = "corner"\nx = 1050'
+    )
+    assert response.json()["revision"] != body["revision"]
+    assert not [p for p in pack.iterdir() if p.name.startswith(".")]
+
+
+def test_a_save_with_nothing_changed_writes_nothing(client, pack):
+    before = (pack / "site.toml").stat().st_mtime_ns
+    body = _loaded(client)
+    response = client.put(
+        "/api/site", json={"revision": body["revision"], "site": body["site"]}
+    )
+    assert response.json()["written"] is False
+    assert (pack / "site.toml").stat().st_mtime_ns == before
+
+
+def test_a_save_against_a_changed_file_is_refused(client, pack):
+    body = _loaded(client)
+    (pack / "site.toml").write_text(ARENA + "\n# edited by hand\n")
+    body["site"]["areas"][0]["w"] = 1500
+    response = client.put(
+        "/api/site", json={"revision": body["revision"], "site": body["site"]}
+    )
+    assert response.status_code == 409
+    assert (pack / "site.toml").read_text().endswith("# edited by hand\n")
+
+
+def test_a_site_the_schema_refuses_is_a_422_and_the_file_is_untouched(client, pack):
+    body = _loaded(client)
+    body["site"]["areas"][1]["role"] = "field"
+    response = client.put(
+        "/api/site", json={"revision": body["revision"], "site": body["site"]}
+    )
+    assert response.status_code == 422
+    assert "at most one field" in response.json()["detail"]
+    assert (pack / "site.toml").read_text() == ARENA
+
+
+def test_the_preview_is_the_file_as_it_would_be_written(client, pack):
+    body = _loaded(client)
+    body["site"]["anchor"] = "the door"
+    preview = client.post("/api/preview", json=body["site"]).json()
+    assert preview["changed"] is True
+    assert 'anchor = "the door"' in preview["text"]
+    assert (pack / "site.toml").read_text() == ARENA
+
+
+def test_done_runs_the_callback(pack, page):
+    calls = []
+    app = create_app(EditorState("arena", pack), page, on_done=lambda: calls.append(1))
+    assert TestClient(app).post("/api/done").status_code == 200
+    assert calls == [1]
+
+
+@pytest.fixture
+def served(monkeypatch):
+    calls = []
+    monkeypatch.setattr(
+        site_cmd,
+        "_serve_editor",
+        lambda name, pack, port, headless: calls.append((name, pack, headless)),
+    )
+    return calls
+
+
+def test_site_new_writes_a_pack_in_the_user_home_outside_a_project(
+    tmp_path, monkeypatch, served
+):
+    monkeypatch.setattr("dotbot.site_packs.USER_SITES_DIR", tmp_path / "home-sites")
+    monkeypatch.chdir(tmp_path)
+    result = CliRunner().invoke(
+        site_cmd.cmd, ["new", "lab", "--field", "3m", "--headless"], obj={}
+    )
+    assert result.exit_code == 0, result.output
+    pack = tmp_path / "home-sites" / "lab"
+    assert "extent_mm = [6000, 6000]" in (pack / "site.toml").read_text()
+    assert served == [("lab", pack, True)]
+    assert "dotbot site use lab" in result.output
+
+
+def test_site_new_writes_a_pack_beside_the_project(tmp_path, monkeypatch, served):
+    from dotbot.config import load_discovered
+
+    (tmp_path / "dotbot.toml").write_text("")
+    config = load_discovered(environ={}, start_dir=tmp_path)
+    result = CliRunner().invoke(site_cmd.cmd, ["new", "lab"], obj={"config": config})
+    assert result.exit_code == 0, result.output
+    assert (tmp_path.resolve() / "sites" / "lab" / "site.toml").is_file()
+
+
+def test_site_new_refuses_an_existing_folder(tmp_path, monkeypatch, served):
+    monkeypatch.setattr("dotbot.site_packs.USER_SITES_DIR", tmp_path)
+    (tmp_path / "lab").mkdir()
+    result = CliRunner().invoke(site_cmd.cmd, ["new", "lab"], obj={})
+    assert result.exit_code != 0 and "already exists" in result.output
+    assert served == []
+
+
+def test_site_edit_takes_a_pack_folder(pack, served):
+    result = CliRunner().invoke(site_cmd.cmd, ["edit", str(pack)], obj={})
+    assert result.exit_code == 0, result.output
+    assert served == [("arena", pack.resolve(), False)]
+
+
+def test_site_edit_refuses_an_unknown_site(tmp_path, monkeypatch, served):
+    monkeypatch.setattr("dotbot.site_packs.USER_SITES_DIR", tmp_path)
+    result = CliRunner().invoke(site_cmd.cmd, ["edit", "bench"], obj={})
+    assert result.exit_code != 0
+    assert "dotbot site new" in result.output
+    assert served == []

From 8ca5de98f1171ea3adcaa215e7341816644223ca Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Thu, 1 Oct 2026 11:01:30 +0200
Subject: [PATCH 04/80] dotbot/cli: open site edit on the active pack, wherever
 it is

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/site_cmd.py           |  8 +++++++-
 dotbot/tests/test_site_editor.py | 17 +++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/dotbot/cli/site_cmd.py b/dotbot/cli/site_cmd.py
index 0ab57ec8..8edeb6bb 100644
--- a/dotbot/cli/site_cmd.py
+++ b/dotbot/cli/site_cmd.py
@@ -901,7 +901,13 @@ def edit(ctx, site, port, headless):
             raise click.ClickException(str(exc)) from exc
         _serve_editor(entry.name, entry.pack, port, headless)
         return
-    name = site or active_site(ctx).name
+    if site is None:
+        active = active_site(ctx)
+        if active.entry is not None:
+            _serve_editor(active.name, active.entry.pack, port, headless)
+            return
+        site = active.name
+    name = site
     entry = _catalog(ctx).get(name)
     if entry is None:
         raise click.ClickException(
diff --git a/dotbot/tests/test_site_editor.py b/dotbot/tests/test_site_editor.py
index e68efe71..fe03d3e3 100644
--- a/dotbot/tests/test_site_editor.py
+++ b/dotbot/tests/test_site_editor.py
@@ -176,3 +176,20 @@ def test_site_edit_refuses_an_unknown_site(tmp_path, monkeypatch, served):
     assert result.exit_code != 0
     assert "dotbot site new" in result.output
     assert served == []
+
+
+def test_site_edit_defaults_to_the_active_pack_even_by_path(
+    tmp_path, pack, monkeypatch, served
+):
+    from dotbot.config import load_discovered
+
+    monkeypatch.setattr("dotbot.site_packs.USER_SITES_DIR", tmp_path / "home-sites")
+    project = tmp_path / "project"
+    project.mkdir()
+    (project / "dotbot.toml").write_text(f"site = {str(pack)!r}\n")
+    config = load_discovered(environ={}, start_dir=project)
+    result = CliRunner().invoke(site_cmd.cmd, ["edit"], obj={"config": config})
+    assert result.exit_code == 0, result.output
+    assert [(name, path.resolve()) for name, path, _ in served] == [
+        ("arena", pack.resolve())
+    ]

From 76d471583c38afc03fc4bde332530a3fd9b7b901 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Thu, 1 Oct 2026 11:01:48 +0200
Subject: [PATCH 05/80] dotbot/site_editor: refuse a request for any host but
 this machine

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py            |  3 +++
 dotbot/tests/test_site_editor.py | 13 +++++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index b3cb42f2..c4d5eb41 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -22,6 +22,7 @@
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field
+from starlette.middleware.trustedhost import TrustedHostMiddleware
 
 from dotbot import site_toml
 from dotbot.site import PACK_CALIBRATIONS
@@ -104,6 +105,8 @@ def create_app(
 ) -> FastAPI:
     """The editor's app for `state`; `on_done` runs when the page says Done."""
     app = FastAPI(title="DotBot site editor", docs_url=None, redoc_url=None)
+    # A page from another site that rebinds its name to 127.0.0.1 is refused.
+    app.add_middleware(TrustedHostMiddleware, allowed_hosts=["127.0.0.1", "localhost"])
 
     def read() -> tuple[bytes, str]:
         try:
diff --git a/dotbot/tests/test_site_editor.py b/dotbot/tests/test_site_editor.py
index fe03d3e3..84064d7a 100644
--- a/dotbot/tests/test_site_editor.py
+++ b/dotbot/tests/test_site_editor.py
@@ -32,7 +32,10 @@ def page(tmp_path):
 @pytest.fixture
 def client(pack, page, tmp_path):
     calibrations = tmp_path / "home-calibrations" / "arena"
-    return TestClient(create_app(EditorState("arena", pack, [calibrations]), page))
+    return TestClient(
+        create_app(EditorState("arena", pack, [calibrations]), page),
+        base_url="http://127.0.0.1",
+    )
 
 
 def _loaded(client):
@@ -116,7 +119,8 @@ def test_the_preview_is_the_file_as_it_would_be_written(client, pack):
 def test_done_runs_the_callback(pack, page):
     calls = []
     app = create_app(EditorState("arena", pack), page, on_done=lambda: calls.append(1))
-    assert TestClient(app).post("/api/done").status_code == 200
+    client = TestClient(app, base_url="http://127.0.0.1")
+    assert client.post("/api/done").status_code == 200
     assert calls == [1]
 
 
@@ -193,3 +197,8 @@ def test_site_edit_defaults_to_the_active_pack_even_by_path(
     assert [(name, path.resolve()) for name, path, _ in served] == [
         ("arena", pack.resolve())
     ]
+
+
+def test_a_request_for_another_host_is_refused(client):
+    response = client.get("/api/site", headers={"host": "evil.example"})
+    assert response.status_code == 400

From 47918d173f21e9e4efcbc2da7f6a7f9163d0f13a Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:42:47 +0200
Subject: [PATCH 06/80] dotbot/site_editor: answer only loopback clients and
 the editor's own page

Any web page in the browser can send requests to 127.0.0.1 with a valid
Host header, and behind a permissive CORS policy read the replies, so the
Host check alone let it save site.toml; a server bound beyond loopback
took any Host. The peer address, Origin and Sec-Fetch-Site are checked.

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py            | 55 +++++++++++++++++++++++++---
 dotbot/tests/test_site_editor.py | 62 ++++++++++++++++++++++++++++----
 2 files changed, 107 insertions(+), 10 deletions(-)

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index c4d5eb41..3314dab0 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -11,18 +11,19 @@
 
 from __future__ import annotations
 
+import ipaddress
 import os
 import tempfile
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Callable, Literal
+from urllib.parse import urlsplit
 
 import tomlkit
 from fastapi import FastAPI, HTTPException
-from fastapi.responses import FileResponse
+from fastapi.responses import FileResponse, PlainTextResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field
-from starlette.middleware.trustedhost import TrustedHostMiddleware
 
 from dotbot import site_toml
 from dotbot.site import PACK_CALIBRATIONS
@@ -78,6 +79,53 @@ def calibrations(self) -> list[dict]:
         ]
 
 
+def _is_loopback(address: str) -> bool:
+    try:
+        ip = ipaddress.ip_address(address)
+    except ValueError:
+        return False
+    if isinstance(ip, ipaddress.IPv6Address) and ip.ipv4_mapped is not None:
+        ip = ip.ipv4_mapped
+    return ip.is_loopback
+
+
+def _refusal(scope) -> str | None:
+    """Why a request may not reach the editor, or None when it may.
+
+    Only a client on this machine, addressing it by a loopback name, from the
+    editor's own page or from no page at all, is let through."""
+    client = scope.get("client")
+    if client is None or not _is_loopback(client[0]):
+        return "the site editor answers this machine only"
+    headers = {
+        key.decode("latin-1"): value.decode("latin-1")
+        for key, value in scope.get("headers", [])
+    }
+    host = headers.get("host", "")
+    if urlsplit(f"//{host}").hostname not in ("127.0.0.1", "localhost", "::1"):
+        return "the site editor answers 127.0.0.1 and localhost only"
+    if headers.get("sec-fetch-site", "same-origin") not in ("same-origin", "none"):
+        return "the site editor answers its own page only"
+    origin = headers.get("origin")
+    if origin is not None and urlsplit(origin).netloc != host:
+        return "the site editor answers its own page only"
+    return None
+
+
+class LocalOnly:
+    """ASGI middleware refusing, with a 403, any request `_refusal` names."""
+
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        reason = _refusal(scope) if scope["type"] == "http" else None
+        if reason is not None:
+            await PlainTextResponse(reason, status_code=403)(scope, receive, send)
+            return
+        await self.app(scope, receive, send)
+
+
 def _write_atomic(path: Path, text: str) -> None:
     """Write `text` beside `path` and rename it over, keeping its mode."""
     mode = path.stat().st_mode & 0o777 if path.exists() else 0o644
@@ -105,8 +153,7 @@ def create_app(
 ) -> FastAPI:
     """The editor's app for `state`; `on_done` runs when the page says Done."""
     app = FastAPI(title="DotBot site editor", docs_url=None, redoc_url=None)
-    # A page from another site that rebinds its name to 127.0.0.1 is refused.
-    app.add_middleware(TrustedHostMiddleware, allowed_hosts=["127.0.0.1", "localhost"])
+    app.add_middleware(LocalOnly)
 
     def read() -> tuple[bytes, str]:
         try:
diff --git a/dotbot/tests/test_site_editor.py b/dotbot/tests/test_site_editor.py
index 84064d7a..6fd383ec 100644
--- a/dotbot/tests/test_site_editor.py
+++ b/dotbot/tests/test_site_editor.py
@@ -29,13 +29,15 @@ def page(tmp_path):
     return folder
 
 
+def local_client(app) -> TestClient:
+    """A client calling `app` from this machine, as the editor's page does."""
+    return TestClient(app, base_url="http://127.0.0.1", client=("127.0.0.1", 50000))
+
+
 @pytest.fixture
 def client(pack, page, tmp_path):
     calibrations = tmp_path / "home-calibrations" / "arena"
-    return TestClient(
-        create_app(EditorState("arena", pack, [calibrations]), page),
-        base_url="http://127.0.0.1",
-    )
+    return local_client(create_app(EditorState("arena", pack, [calibrations]), page))
 
 
 def _loaded(client):
@@ -119,7 +121,7 @@ def test_the_preview_is_the_file_as_it_would_be_written(client, pack):
 def test_done_runs_the_callback(pack, page):
     calls = []
     app = create_app(EditorState("arena", pack), page, on_done=lambda: calls.append(1))
-    client = TestClient(app, base_url="http://127.0.0.1")
+    client = local_client(app)
     assert client.post("/api/done").status_code == 200
     assert calls == [1]
 
@@ -201,4 +203,52 @@ def test_site_edit_defaults_to_the_active_pack_even_by_path(
 
 def test_a_request_for_another_host_is_refused(client):
     response = client.get("/api/site", headers={"host": "evil.example"})
-    assert response.status_code == 400
+    assert response.status_code == 403
+
+
+def test_a_request_from_another_machine_is_refused_whatever_its_host(pack, page):
+    app = create_app(EditorState("arena", pack), page)
+    remote = TestClient(app, base_url="http://127.0.0.1", client=("192.0.2.7", 5))
+    assert remote.get("/api/site").status_code == 403
+    assert remote.post("/api/done").status_code == 403
+
+
+@pytest.mark.parametrize(
+    "headers",
+    [
+        {"origin": "https://evil.example"},
+        {"origin": "null"},
+        {"origin": "http://127.0.0.1:9999"},
+        {"sec-fetch-site": "cross-site"},
+        {"sec-fetch-site": "same-site"},
+    ],
+)
+def test_a_save_from_another_page_is_refused(client, pack, headers):
+    body = _loaded(client)
+    body["site"]["anchor"] = "moved"
+    response = client.put(
+        "/api/site",
+        json={"revision": body["revision"], "site": body["site"]},
+        headers=headers,
+    )
+    assert response.status_code == 403
+    assert (pack / "site.toml").read_text() == ARENA
+
+
+def test_a_save_from_the_editors_own_page_is_taken(client, pack):
+    body = _loaded(client)
+    body["site"]["anchor"] = "moved"
+    response = client.put(
+        "/api/site",
+        json={"revision": body["revision"], "site": body["site"]},
+        headers={"origin": "http://127.0.0.1", "sec-fetch-site": "same-origin"},
+    )
+    assert response.status_code == 200
+    assert 'anchor = "moved"' in (pack / "site.toml").read_text()
+
+
+def test_a_request_from_an_ipv6_loopback_client_is_taken(pack, page):
+    app = create_app(EditorState("arena", pack), page)
+    for address in ("::1", "::ffff:127.0.0.1"):
+        local = TestClient(app, base_url="http://localhost", client=(address, 5))
+        assert local.get("/api/site").status_code == 200

From 9d0d901de53c398c4386a20bb14e3657eb428734 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:54:32 +0200
Subject: [PATCH 07/80] dotbot/site_toml: refuse layouts it cannot patch, keep
 comments heading tables

A patched file is read back and must give the model that was sent, so a
layout the patcher does not follow is refused rather than written.

AI-assisted: Claude Opus 5.5
---
 dotbot/site_toml.py            | 163 +++++++++++++++++++++++++++++----
 dotbot/tests/test_site_toml.py | 119 ++++++++++++++++++++++++
 2 files changed, 263 insertions(+), 19 deletions(-)

diff --git a/dotbot/site_toml.py b/dotbot/site_toml.py
index 0bae1d90..f5c52aaa 100644
--- a/dotbot/site_toml.py
+++ b/dotbot/site_toml.py
@@ -16,7 +16,7 @@
 
 import tomlkit
 from pydantic import ValidationError
-from tomlkit.items import InlineTable, SingleKey, Table
+from tomlkit.items import AoT, Comment, InlineTable, Table, Whitespace
 from tomlkit.toml_document import TOMLDocument
 
 from dotbot.config import SiteSection
@@ -39,8 +39,17 @@ def _comment(item: Any) -> str | None:
 
 
 def _areas_table(doc: TOMLDocument) -> Table | None:
-    areas = doc.get("areas")
-    return areas if isinstance(areas, Table) else None
+    if "areas" not in doc:
+        return None
+    areas = doc["areas"]
+    if not isinstance(areas, Table):
+        raise SiteTomlError(
+            "the site editor edits areas written as one run of [areas.<name>] "
+            "tables, or as one [areas] table; this file writes them otherwise "
+            "(split by another table, as dotted keys or inline), so edit it by "
+            "hand or gather them first"
+        )
+    return areas
 
 
 def site_model(doc: TOMLDocument) -> dict[str, Any]:
@@ -75,8 +84,15 @@ def _set(container: Any, key: str, value: Any) -> None:
         container[key] = value
 
 
+def _clean_comment(comment: str | None) -> str | None:
+    if comment is not None and ("\n" in comment or "\r" in comment):
+        raise SiteTomlError("a comment is one line")
+    return (comment or "").strip() or None
+
+
 def _set_comment(item: Any, comment: str | None) -> None:
-    if _comment(item) == (comment or None):
+    comment = _clean_comment(comment)
+    if _comment(item) == comment:
         return
     if comment:
         if not item.trivia.comment_ws:
@@ -114,6 +130,75 @@ def _check_names(areas: list[dict[str, Any]]) -> None:
         seen.add(name)
 
 
+def _split_trailing(table: Table) -> str:
+    """Take the comments and blank lines ending `table`, which head whatever
+    follows it in the file, out of it; return them as text."""
+    body = table.value.body
+    end = len(body)
+    while end and body[end - 1][0] is None:
+        if not isinstance(body[end - 1][1], (Comment, Whitespace)):
+            break
+        end -= 1
+    text = "".join(item.as_string() for _, item in body[end:])
+    del body[end:]
+    return text
+
+
+def _end_with(table: Table, text: str) -> None:
+    if text:
+        table.value.body.append((None, Whitespace(text)))
+
+
+def _set_heading(doc: TOMLDocument, key: str, text: str) -> None:
+    """Make `text` the comments and blank lines just above the top-level `key`."""
+    body = doc.body
+    index = next(i for i, (k, _) in enumerate(body) if k is not None and k == key)
+    start = index
+    while start and body[start - 1][0] is None:
+        start -= 1
+    if start < index:
+        body[start] = (None, Whitespace(text))
+        for i in range(start + 1, index):
+            body[i] = (None, Whitespace(""))
+        return
+    before = body[index - 1][1] if index else None
+    if isinstance(before, AoT) and before.body:
+        before = before.body[-1]
+    if isinstance(before, Table):
+        _split_trailing(before)
+        _end_with(before, text)
+
+
+def _delete_table(doc: TOMLDocument, parent: str, table: Table, name: str) -> None:
+    """Delete `table[name]`, keeping the comments that head the next table."""
+    names = list(table)
+    index = names.index(name)
+    item = table[name]
+    if isinstance(item, Table):
+        tail = _split_trailing(item)
+        previous = table[names[index - 1]] if index else None
+        if isinstance(previous, Table):
+            _split_trailing(previous)
+            _end_with(previous, tail)
+        elif index == 0:
+            _set_heading(doc, parent, tail)
+    del table[name]
+
+
+def _rename(table: Table, was: str, name: str) -> None:
+    # tomlkit has no public rename; this keeps the area's place, comment and
+    # layout, the header written in the plain form
+    item = table[was]
+    body = item.value.body if isinstance(item, Table) else None
+    length = len(body) if body is not None else 0
+    table.value._replace(was, name, item)
+    if isinstance(item, Table):
+        if len(body) == length + 1 and body[-1][1].as_string() == "\n":
+            body.pop()
+        item.display_name = None
+        item.name = name
+
+
 def _patch_areas(doc: TOMLDocument, areas: list[dict[str, Any]]) -> None:
     table = _areas_table(doc)
     if table is None:
@@ -129,24 +214,34 @@ def _patch_areas(doc: TOMLDocument, areas: list[dict[str, Any]]) -> None:
     }
     kept = {area.get("was") or area["name"] for area in areas}
     for name in [name for name in table if name not in kept]:
-        del table[name]
-    for was, name in renames.items():
+        _delete_table(doc, "areas", table, name)
+    for was in renames:
         if was not in table:
             raise SiteTomlError(f"area {was!r} is not in the file")
-        # tomlkit has no public rename; this keeps the area's place, comment
-        # and layout
-        item = table[was]
-        table.value._replace(was, name, item)
-        if isinstance(item, Table) and item.display_name:
-            old_key = SingleKey(was).as_string()
-            prefix = item.display_name.removesuffix(old_key)
-            item.display_name = prefix + SingleKey(name).as_string()
-        if isinstance(item, Table):
-            item.name = name
+    # A swap or a chain goes through names no area has, so it never meets itself
+    clash = any(name in table for name in renames.values())
+    passing = {
+        was: f"\0rename-{i}" if clash else name
+        for i, (was, name) in enumerate(renames.items())
+    }
+    try:
+        for was, through in passing.items():
+            _rename(table, was, through)
+        for was, through in passing.items():
+            if through != renames[was]:
+                _rename(table, through, renames[was])
+    except (KeyError, ValueError) as exc:
+        raise SiteTomlError(f"could not rename the areas in this file: {exc}") from exc
     for area in areas:
         name = area["name"]
         if name not in table:
+            last = table[list(table)[-1]] if table else None
+            tail = _split_trailing(last) if isinstance(last, Table) else ""
             table[name] = _new_area(inline, area)
+            if isinstance(table[name], Table):
+                _end_with(table[name], tail)
+            elif isinstance(last, Table):
+                _end_with(last, tail)
             continue
         item = table[name]
         _set(item, "role", area.get("role"))
@@ -157,6 +252,24 @@ def _patch_areas(doc: TOMLDocument, areas: list[dict[str, Any]]) -> None:
         del doc["areas"]
 
 
+def _normal(model: dict[str, Any]) -> dict[str, Any]:
+    """The parts of a model a written file must give back."""
+    extent = model.get("extent_mm")
+    return {
+        "anchor": model.get("anchor") or None,
+        "extent_mm": [int(v) for v in extent] if extent is not None else None,
+        "areas": sorted(
+            (
+                area["name"],
+                *(int(area[key]) for key in AREA_KEYS),
+                area.get("role"),
+                (area.get("comment") or "").strip() or None,
+            )
+            for area in model.get("areas") or []
+        ),
+    }
+
+
 def patch(doc: TOMLDocument, model: dict[str, Any]) -> TOMLDocument:
     """Write `model` into `doc` in place, changing only what differs.
 
@@ -190,9 +303,21 @@ def validate(text: str) -> SiteSection:
         raise SiteTomlError(str(exc)) from exc
 
 
+def parse(text: str) -> TOMLDocument:
+    try:
+        return tomlkit.parse(text)
+    except tomlkit.exceptions.ParseError as exc:
+        raise SiteTomlError(f"not valid TOML: {exc}") from exc
+
+
 def patched_text(text: str, model: dict[str, Any]) -> str:
-    """`text` with `model` written into it, validated."""
-    doc = tomlkit.parse(text)
-    result = tomlkit.dumps(patch(doc, model))
+    """`text` with `model` written into it, validated, and read back as
+    `model`; SiteTomlError when the patch cannot be made faithfully."""
+    result = tomlkit.dumps(patch(parse(text), model))
     validate(result)
+    if _normal(site_model(parse(result))) != _normal(model):
+        raise SiteTomlError(
+            "the edit could not be written into site.toml as it is laid out; "
+            "edit the file by hand"
+        )
     return result
diff --git a/dotbot/tests/test_site_toml.py b/dotbot/tests/test_site_toml.py
index f028d986..3870c70d 100644
--- a/dotbot/tests/test_site_toml.py
+++ b/dotbot/tests/test_site_toml.py
@@ -208,3 +208,122 @@ def test_a_model_the_schema_refuses_is_an_error(change, message):
 def test_the_revision_is_the_hash_of_the_bytes():
     assert site_toml.revision(b"a") != site_toml.revision(b"b")
     assert len(site_toml.revision(b"")) == 64
+
+
+HEADED = """\
+anchor = "a"
+
+# Field: the top.
+[areas.field]
+x = 0
+y = 0
+w = 1000
+h = 1000
+
+# Staging: the strip below.
+# Second line.
+[areas.staging]
+x = 0
+y = 1000
+w = 1000
+h = 500
+
+# The broker.
+[connection]
+conn = "mqtt://h:1883"
+"""
+
+
+def _heading(text, header):
+    """The two lines just above `header` in `text`."""
+    lines = text.splitlines()
+    index = lines.index(header)
+    return lines[index - 2 : index]
+
+
+def _without(text, name):
+    model = _loaded(text)
+    model["areas"] = [a for a in model["areas"] if a["name"] != name]
+    return patched_text(text, model)
+
+
+def test_deleting_an_area_keeps_the_comments_heading_the_next_table():
+    without_field = _without(HEADED, "field")
+    assert _heading(without_field, "[areas.staging]") == [
+        "# Staging: the strip below.",
+        "# Second line.",
+    ]
+    assert "# Field: the top." not in without_field
+    without_staging = _without(HEADED, "staging")
+    assert _heading(without_staging, "[connection]") == ["", "# The broker."]
+    assert "# Staging" not in without_staging
+    assert _heading(_without(without_staging, "field"), "[connection]") == [
+        "",
+        "# The broker.",
+    ]
+
+
+def test_a_new_area_goes_above_the_comments_heading_the_next_table():
+    model = _loaded(HEADED)
+    model["areas"].append(
+        {"name": "c", "x": 1, "y": 2, "w": 3, "h": 4, "role": None, "was": None}
+    )
+    result = patched_text(HEADED, model)
+    assert _heading(result, "[areas.c]") == ["h = 500", ""]
+    assert _heading(result, "[connection]") == ["", "# The broker."]
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        "[areas.field]\nx = 0\ny = 0\nw = 1\nh = 1\n\n[connection]\nconn = 'x'\n\n"
+        "[areas.staging]\nx = 0\ny = 1\nw = 1\nh = 1\n",
+        "areas.field.x = 0\nareas.field.y = 0\nareas.field.w = 1\nareas.field.h = 1\n",
+        "areas = { field = { x = 0, y = 0, w = 1, h = 1 } }\n",
+    ],
+    ids=["split", "dotted", "inline"],
+)
+def test_areas_laid_out_another_way_are_refused_not_wiped(text):
+    with pytest.raises(SiteTomlError, match="edit it by hand"):
+        site_model(tomlkit.parse(text))
+    model = {
+        "areas": [{"name": "c", "x": 1, "y": 1, "w": 1, "h": 1, "was": None}],
+    }
+    with pytest.raises(SiteTomlError):
+        patched_text(text, model)
+
+
+@pytest.mark.parametrize("comment", ['x\nrole = "corner"', "x\r\ny = 1"])
+def test_a_comment_cannot_carry_a_second_line(comment):
+    model = _loaded(ARENA)
+    model["areas"][2]["comment"] = comment
+    with pytest.raises(SiteTomlError, match="one line"):
+        patched_text(ARENA, model)
+
+
+@pytest.mark.parametrize(
+    "header", ['[areas."field"]', "[areas.'field']", "[ areas.field ]"]
+)
+def test_a_rename_reads_any_spelling_of_the_header(header):
+    text = f"{header}  # c\nx = 0\ny = 0\nw = 1\nh = 1\n"
+    model = _loaded(text)
+    model["areas"][0]["name"] = "pitch"
+    first = patched_text(text, model).splitlines()[0]
+    assert first.replace(" ", "") == "[areas.pitch]#c"
+
+
+def test_two_areas_can_swap_names():
+    model = _loaded(HEADED)
+    model["areas"][0]["name"] = "staging"
+    model["areas"][1]["name"] = "field"
+    result = patched_text(HEADED, model)
+    assert [
+        (a["name"], a["y"]) for a in site_model(tomlkit.parse(result))["areas"]
+    ] == [
+        ("staging", 0),
+        ("field", 1000),
+    ]
+    assert _heading(result, "[areas.field]") == [
+        "# Staging: the strip below.",
+        "# Second line.",
+    ]

From 45ac48afbc64be561821b70a3867004e6d0238c7 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:54:32 +0200
Subject: [PATCH 08/80] dotbot/site_editor: save one at a time, through
 symlinks, 422 on unreadable files

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py            | 42 +++++++++++++--------
 dotbot/tests/test_site_editor.py | 63 ++++++++++++++++++++++++++++++++
 2 files changed, 90 insertions(+), 15 deletions(-)

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index 3314dab0..520bc5f8 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -14,12 +14,12 @@
 import ipaddress
 import os
 import tempfile
+import threading
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Callable, Literal
 from urllib.parse import urlsplit
 
-import tomlkit
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import FileResponse, PlainTextResponse
 from fastapi.staticfiles import StaticFiles
@@ -127,7 +127,9 @@ async def __call__(self, scope, receive, send):
 
 
 def _write_atomic(path: Path, text: str) -> None:
-    """Write `text` beside `path` and rename it over, keeping its mode."""
+    """Write `text` beside `path` and rename it over, keeping its mode; a
+    symlink's target is the file written."""
+    path = path.resolve()
     mode = path.stat().st_mode & 0o777 if path.exists() else 0o644
     fd, tmp = tempfile.mkstemp(prefix=f".{path.name}-", dir=path.parent)
     try:
@@ -155,19 +157,28 @@ def create_app(
     app = FastAPI(title="DotBot site editor", docs_url=None, redoc_url=None)
     app.add_middleware(LocalOnly)
 
+    saving = threading.Lock()
+
     def read() -> tuple[bytes, str]:
         try:
             data = state.path.read_bytes()
         except OSError as exc:
             raise HTTPException(500, f"could not read {state.path}: {exc}") from exc
-        return data, data.decode("utf-8")
+        try:
+            return data, data.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            raise HTTPException(422, f"{state.path} is not UTF-8: {exc}") from exc
 
     def body(data: bytes, text: str) -> dict:
+        try:
+            site = site_toml.site_model(site_toml.parse(text))
+        except site_toml.SiteTomlError as exc:
+            raise HTTPException(422, f"{state.path}: {exc}") from exc
         return {
             "name": state.name,
             "path": str(state.path),
             "revision": site_toml.revision(data),
-            "site": site_toml.site_model(tomlkit.parse(text)),
+            "site": site,
             "calibrations": state.calibrations(),
         }
 
@@ -189,17 +200,18 @@ def preview(model: SiteModel):
 
     @app.put("/api/site")
     def save(request: SaveRequest):
-        data, text = read()
-        if site_toml.revision(data) != request.revision:
-            raise HTTPException(
-                409, f"{state.path} changed on disk since the page loaded it"
-            )
-        result = patched(text, request.site)
-        written = result != text
-        if written:
-            _write_atomic(state.path, result)
-            data = result.encode("utf-8")
-            text = result
+        with saving:
+            data, text = read()
+            if site_toml.revision(data) != request.revision:
+                raise HTTPException(
+                    409, f"{state.path} changed on disk since the page loaded it"
+                )
+            result = patched(text, request.site)
+            written = result != text
+            if written:
+                _write_atomic(state.path, result)
+                data = result.encode("utf-8")
+                text = result
         return {**body(data, text), "written": written}
 
     @app.post("/api/done")
diff --git a/dotbot/tests/test_site_editor.py b/dotbot/tests/test_site_editor.py
index 6fd383ec..9844354b 100644
--- a/dotbot/tests/test_site_editor.py
+++ b/dotbot/tests/test_site_editor.py
@@ -252,3 +252,66 @@ def test_a_request_from_an_ipv6_loopback_client_is_taken(pack, page):
     for address in ("::1", "::ffff:127.0.0.1"):
         local = TestClient(app, base_url="http://localhost", client=(address, 5))
         assert local.get("/api/site").status_code == 200
+
+
+def test_a_pack_the_editor_cannot_draw_is_a_422(pack, client):
+    (pack / "site.toml").write_text(
+        "areas = { field = { x = 0, y = 0, w = 1, h = 1 } }\n"
+    )
+    response = client.get("/api/site")
+    assert response.status_code == 422
+    assert "edit it by hand" in response.json()["detail"]
+    (pack / "site.toml").write_bytes(b"anchor = '\xff'\n")
+    assert client.get("/api/site").status_code == 422
+    (pack / "site.toml").write_text("[areas.field\n")
+    assert client.get("/api/site").status_code == 422
+
+
+def test_two_saves_against_one_revision_take_one(client, pack, monkeypatch):
+    import threading
+    import time
+
+    from dotbot import site_toml
+
+    patched = site_toml.patched_text
+
+    def slow(text, model):
+        time.sleep(0.2)
+        return patched(text, model)
+
+    monkeypatch.setattr(site_toml, "patched_text", slow)
+    body = _loaded(client)
+    statuses = []
+
+    def save(x):
+        site = {**body["site"], "areas": [dict(a) for a in body["site"]["areas"]]}
+        site["areas"][0]["x"] = x
+        statuses.append(
+            client.put(
+                "/api/site", json={"revision": body["revision"], "site": site}
+            ).status_code
+        )
+
+    threads = [threading.Thread(target=save, args=(x,)) for x in (100, 200)]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join()
+    assert sorted(statuses) == [200, 409]
+
+
+def test_a_save_through_a_symlink_writes_its_target(tmp_path, page):
+    pack = tmp_path / "linked"
+    pack.mkdir()
+    target = tmp_path / "checkout.toml"
+    target.write_text(ARENA)
+    (pack / "site.toml").symlink_to(target)
+    client = local_client(create_app(EditorState("linked", pack), page))
+    body = _loaded(client)
+    body["site"]["anchor"] = "moved"
+    response = client.put(
+        "/api/site", json={"revision": body["revision"], "site": body["site"]}
+    )
+    assert response.status_code == 200
+    assert (pack / "site.toml").is_symlink()
+    assert 'anchor = "moved"' in target.read_text()

From 3bb1e6b5af97bac774bba10df7b8f54b6b075611 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:55:36 +0200
Subject: [PATCH 09/80] dotbot/cli: check site new's name and port before
 writing its pack

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/site_cmd.py           | 56 ++++++++++++++++++++++----------
 dotbot/tests/test_site_editor.py | 41 ++++++++++++++++++++++-
 2 files changed, 79 insertions(+), 18 deletions(-)

diff --git a/dotbot/cli/site_cmd.py b/dotbot/cli/site_cmd.py
index 8edeb6bb..8fbc49d2 100644
--- a/dotbot/cli/site_cmd.py
+++ b/dotbot/cli/site_cmd.py
@@ -682,22 +682,19 @@ def area(name: str, note: str) -> str:
     )
 
 
-def _serve_editor(name: str, pack: Path, port: int, headless: bool) -> None:
-    """Serve the editor on `pack` at 127.0.0.1 until Ctrl-C or Done."""
+def _editor_socket(port: int):
+    """A socket listening on 127.0.0.1:`port` for the editor, once its page
+    is known to be built."""
     import socket
-    import threading
-    import webbrowser
-
-    import uvicorn
 
-    from dotbot.calibration.lighthouse2 import calibration_root
-    from dotbot.site_editor import EDITOR_DIR, EDITOR_PAGE, EditorState, create_app
+    from dotbot.site_editor import EDITOR_DIR, EDITOR_PAGE
 
     if not (EDITOR_DIR / EDITOR_PAGE).is_file():
         raise click.ClickException(
             f"the site editor page is not built ({EDITOR_DIR / EDITOR_PAGE} is "
-            "missing). Build it with: npm --prefix dotbot/console-web install && "
-            "npm --prefix dotbot/console-web run build"
+            "missing). From a PyDotBot checkout, build it with: npm --prefix "
+            "dotbot/console-web install && npm --prefix dotbot/console-web run "
+            "build"
         )
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     try:
@@ -706,6 +703,19 @@ def _serve_editor(name: str, pack: Path, port: int, headless: bool) -> None:
         sock.close()
         raise click.ClickException(f"cannot listen on 127.0.0.1:{port}: {exc}") from exc
     sock.listen()
+    return sock
+
+
+def _serve_editor(name: str, pack: Path, sock, headless: bool) -> None:
+    """Serve the editor on `pack` from `sock` until Ctrl-C or Done."""
+    import threading
+    import webbrowser
+
+    import uvicorn
+
+    from dotbot.calibration.lighthouse2 import calibration_root
+    from dotbot.site_editor import EditorState, create_app
+
     url = f"http://127.0.0.1:{sock.getsockname()[1]}/"
     state = EditorState(name, pack, [calibration_root() / name])
     server = None
@@ -727,7 +737,7 @@ def done():
 
 _PORT = click.option(
     "--port",
-    type=int,
+    type=click.IntRange(0, 65535),
     default=0,
     show_default="a free port",
     help="Port on 127.0.0.1 to serve the editor on.",
@@ -862,22 +872,32 @@ def new(ctx, name, field_spec, port, headless):
     at once. It starts as `dotbot config init` starts a site: a field with
     floor round it and a staging strip below. It is not made the active site.
     """
+    from dotbot.calibration.lighthouse2 import site_name_as_bytes
     from dotbot.cli.config_cmd import default_site_toml, parse_field_size
     from dotbot.site_packs import site_homes
 
+    config = (ctx.obj or {}).get("config")
     try:
         check_site_name(name)
-    except ValueError as exc:
+        site_name_as_bytes(name)  # the push carries the name to the robots
+        existing = resolve_site_entry(config, name)
+    except (ValueError, ConfigError) as exc:
         raise click.ClickException(str(exc)) from exc
+    if existing is not None:
+        raise click.ClickException(
+            f"site {name} already exists ({existing.pack}); open it with "
+            f"`dotbot site edit {name}`, or pick another name"
+        )
     field_mm = parse_field_size(field_spec)
-    _, home = site_homes((ctx.obj or {}).get("config"))[0]
+    _, home = site_homes(config)[0]
     target = home / name
     if target.exists():
         raise click.ClickException(f"{target} already exists")
+    sock = _editor_socket(port)
     target.mkdir(parents=True)
     (target / PACK_FILE).write_text(default_site_toml(field_mm))
     click.echo(f"Wrote {target / PACK_FILE}")
-    _serve_editor(name, target, port, headless)
+    _serve_editor(name, target, sock, headless)
     click.echo(f"Work in it with `dotbot site use {name}`, or --site {name}.")
 
 
@@ -899,12 +919,14 @@ def edit(ctx, site, port, headless):
             entry = pack_at(site)
         except ConfigError as exc:
             raise click.ClickException(str(exc)) from exc
-        _serve_editor(entry.name, entry.pack, port, headless)
+        _serve_editor(entry.name, entry.pack, _editor_socket(port), headless)
         return
     if site is None:
         active = active_site(ctx)
         if active.entry is not None:
-            _serve_editor(active.name, active.entry.pack, port, headless)
+            _serve_editor(
+                active.name, active.entry.pack, _editor_socket(port), headless
+            )
             return
         site = active.name
     name = site
@@ -914,4 +936,4 @@ def edit(ctx, site, port, headless):
             f"unknown site {name!r}; `dotbot site list` names the known ones, "
             "and `dotbot site new` makes one"
         )
-    _serve_editor(name, entry.pack, port, headless)
+    _serve_editor(name, entry.pack, _editor_socket(port), headless)
diff --git a/dotbot/tests/test_site_editor.py b/dotbot/tests/test_site_editor.py
index 9844354b..4361bfa8 100644
--- a/dotbot/tests/test_site_editor.py
+++ b/dotbot/tests/test_site_editor.py
@@ -129,10 +129,11 @@ def test_done_runs_the_callback(pack, page):
 @pytest.fixture
 def served(monkeypatch):
     calls = []
+    monkeypatch.setattr(site_cmd, "_editor_socket", lambda port: port)
     monkeypatch.setattr(
         site_cmd,
         "_serve_editor",
-        lambda name, pack, port, headless: calls.append((name, pack, headless)),
+        lambda name, pack, sock, headless: calls.append((name, pack, headless)),
     )
     return calls
 
@@ -170,6 +171,44 @@ def test_site_new_refuses_an_existing_folder(tmp_path, monkeypatch, served):
     assert served == []
 
 
+def test_site_new_writes_nothing_when_the_page_is_not_built(tmp_path, monkeypatch):
+    monkeypatch.setattr("dotbot.site_packs.USER_SITES_DIR", tmp_path / "home-sites")
+    monkeypatch.setattr("dotbot.site_editor.EDITOR_DIR", tmp_path / "no-dist")
+    result = CliRunner().invoke(site_cmd.cmd, ["new", "lab", "--headless"], obj={})
+    assert result.exit_code != 0 and "not built" in result.output
+    assert not (tmp_path / "home-sites" / "lab").exists()
+
+
+def test_site_new_refuses_a_port_that_cannot_be(served):
+    result = CliRunner().invoke(site_cmd.cmd, ["new", "lab", "--port", "70000"])
+    assert result.exit_code == 2
+    assert served == []
+
+
+def test_site_new_refuses_a_name_too_long_to_reach_a_robot(
+    tmp_path, monkeypatch, served
+):
+    monkeypatch.setattr("dotbot.site_packs.USER_SITES_DIR", tmp_path)
+    result = CliRunner().invoke(site_cmd.cmd, ["new", "a_very_long_site_name"], obj={})
+    assert result.exit_code != 0 and "to reach a robot" in result.output
+    assert served == [] and not (tmp_path / "a_very_long_site_name").exists()
+
+
+def test_site_new_refuses_a_name_another_home_has(tmp_path, monkeypatch, served):
+    from dotbot.config import load_discovered
+
+    monkeypatch.setattr("dotbot.site_packs.USER_SITES_DIR", tmp_path / "home-sites")
+    (tmp_path / "home-sites" / "lab").mkdir(parents=True)
+    (tmp_path / "home-sites" / "lab" / "site.toml").write_text(ARENA)
+    project = tmp_path / "project"
+    project.mkdir()
+    (project / "dotbot.toml").write_text("")
+    config = load_discovered(environ={}, start_dir=project)
+    result = CliRunner().invoke(site_cmd.cmd, ["new", "lab"], obj={"config": config})
+    assert result.exit_code != 0 and "dotbot site edit lab" in result.output
+    assert served == [] and not (project / "sites" / "lab").exists()
+
+
 def test_site_edit_takes_a_pack_folder(pack, served):
     result = CliRunner().invoke(site_cmd.cmd, ["edit", str(pack)], obj={})
     assert result.exit_code == 0, result.output

From 6cbba6aecca2d4c9a92f8be69c3b6326c4581fdb Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:57:39 +0200
Subject: [PATCH 10/80] dotbot/console-web: select an area without moving it,
 hold edits while saving

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/siteEditor/Canvas.tsx  | 14 ++++++++++++--
 .../console-web/src/siteEditor/SiteEditor.tsx | 14 ++++++++++++--
 dotbot/console-web/src/siteEditor/api.ts      |  2 +-
 .../console-web/src/siteEditor/edit.test.ts   |  9 +++++++++
 dotbot/console-web/src/siteEditor/edit.ts     | 19 ++++++++-----------
 .../src/siteEditor/siteEditor.test.tsx        | 14 ++++++++++++++
 6 files changed, 56 insertions(+), 16 deletions(-)

diff --git a/dotbot/console-web/src/siteEditor/Canvas.tsx b/dotbot/console-web/src/siteEditor/Canvas.tsx
index 4f9856b6..6127c5c9 100644
--- a/dotbot/console-web/src/siteEditor/Canvas.tsx
+++ b/dotbot/console-web/src/siteEditor/Canvas.tsx
@@ -28,8 +28,10 @@ export type Tool = "select" | "area";
 const HANDLE_PX = 9;
 const AREA_TINT = 0.12;
 
+const DRAG_THRESHOLD_PX = 3;
+
 type Drag =
-  | { kind: "move"; index: number; start: Rect; from: { x: number; y: number } }
+  | { kind: "move"; index: number; start: Rect; from: { x: number; y: number }; px: { x: number; y: number } }
   | { kind: "resize"; index: number; start: Rect; handle: Handle }
   | { kind: "draw"; from: { x: number; y: number }; to: { x: number; y: number } };
 
@@ -136,7 +138,13 @@ export function Canvas(props: CanvasProps) {
     if (e.button !== 0 || props.tool === "area") return;
     const a = props.areas[index];
     props.onSelect(index);
-    begin(e, { kind: "move", index, start: { x: a.x, y: a.y, w: a.w, h: a.h }, from: toFrame(e) });
+    begin(e, {
+      kind: "move",
+      index,
+      start: { x: a.x, y: a.y, w: a.w, h: a.h },
+      from: toFrame(e),
+      px: { x: e.clientX, y: e.clientY },
+    });
   };
 
   const onHandleDown = (e: React.PointerEvent, index: number, handle: Handle) => {
@@ -151,6 +159,8 @@ export function Canvas(props: CanvasProps) {
     const p = toFrame(e);
     const s = snapNow(e);
     if (drag.kind === "move") {
+      // A click that selects is not a move, however the pointer jitters
+      if (Math.hypot(e.clientX - drag.px.x, e.clientY - drag.px.y) < DRAG_THRESHOLD_PX) return;
       props.onChange(drag.index, moveRect(drag.start, p.x - drag.from.x, p.y - drag.from.y, s));
     } else if (drag.kind === "resize") {
       props.onChange(drag.index, resizeRect(drag.start, drag.handle, p, s));
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index 89208849..00c70689 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -70,6 +70,7 @@ export function SiteEditor() {
   const [notice, setNotice] = useState<Notice>(null);
   const [dialog, setDialog] = useState<Dialog>(null);
   const [stopped, setStopped] = useState(false);
+  const [saving, setSaving] = useState(false);
 
   const load = useCallback(async () => {
     try {
@@ -113,7 +114,7 @@ export function SiteEditor() {
 
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
-      if (typing(e.target) || e.ctrlKey || e.metaKey) return;
+      if (saving || typing(e.target) || e.ctrlKey || e.metaKey) return;
       if (e.key === "v" || e.key === "V") setTool("select");
       else if (e.key === "a" || e.key === "A") setTool("area");
       else if (e.key === "Escape") setSelected(null);
@@ -134,6 +135,7 @@ export function SiteEditor() {
   const doSave = async () => {
     if (!site || !loaded) return;
     setDialog(null);
+    setSaving(true);
     try {
       const body = await saveSite(loaded.revision, site);
       setLoaded(body);
@@ -150,6 +152,8 @@ export function SiteEditor() {
       } else {
         setNotice({ kind: "error", text: `not saved: ${(err as Error).message}` });
       }
+    } finally {
+      setSaving(false);
     }
   };
 
@@ -171,7 +175,11 @@ export function SiteEditor() {
 
   const onDone = async () => {
     if (dirty && !window.confirm("Stop the editor without saving your changes?")) return;
-    await stopEditor();
+    try {
+      await stopEditor();
+    } catch {
+      // The server is already gone, which is what Done asks for
+    }
     setStopped(true);
   };
 
@@ -185,6 +193,8 @@ export function SiteEditor() {
     fontFamily: "var(--font-ui)",
     fontSize: 13,
     overflow: "hidden",
+    // Edits made while a save is in flight would be replaced by its reply
+    pointerEvents: saving ? "none" : undefined,
   };
 
   if (stopped) {
diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
index d7e6f108..6f7d417a 100644
--- a/dotbot/console-web/src/siteEditor/api.ts
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -1,6 +1,6 @@
 import type { SiteModel, SiteResponse } from "./types";
 
-// The editor's server, relative to the page so it works wherever it is mounted.
+// The editor's server, addressed relative to the page.
 
 export class StaleSiteError extends Error {}
 export class RefusedSiteError extends Error {}
diff --git a/dotbot/console-web/src/siteEditor/edit.test.ts b/dotbot/console-web/src/siteEditor/edit.test.ts
index 79ce77ce..7d3220d9 100644
--- a/dotbot/console-web/src/siteEditor/edit.test.ts
+++ b/dotbot/console-web/src/siteEditor/edit.test.ts
@@ -89,6 +89,15 @@ describe("siteIssues", () => {
     expect(siteIssues(arena())).toEqual([]);
   });
 
+  it("refuses a coordinate or an extent that is not a number", () => {
+    const site = arena();
+    site.areas[1].x = NaN;
+    site.extent_mm = [Infinity, 4000];
+    const errors = siteIssues(site).filter((i) => i.level === "error").map((i) => i.message);
+    expect(errors.some((m) => /must be numbers/.test(m))).toBe(true);
+    expect(errors.some((m) => /extent needs/.test(m))).toBe(true);
+  });
+
   it("refuses a second field, as the schema does", () => {
     const site = arena();
     site.areas[1].role = "field";
diff --git a/dotbot/console-web/src/siteEditor/edit.ts b/dotbot/console-web/src/siteEditor/edit.ts
index 5a5b3bdb..d9729595 100644
--- a/dotbot/console-web/src/siteEditor/edit.ts
+++ b/dotbot/console-web/src/siteEditor/edit.ts
@@ -11,7 +11,8 @@ export const ROLES: AreaRole[] = ["field", "staging", "corner"];
 export const SNAP_STEPS_MM = [1, 10, 50, 100, 250, 500];
 export const SNAP_DEFAULT_MM = 50;
 
-/** Above this, one LH2 base station rarely covers the field (as `config init` warns). */
+/** Above this, one LH2 base station rarely covers the field; keep in step with
+ * FIELD_COVERAGE_MM in dotbot/cli/config_cmd.py. */
 export const FIELD_COVERAGE_MM = 5000;
 
 export interface Rect {
@@ -76,10 +77,7 @@ export function effectiveRole(area: Pick<EditArea, "name" | "role">): AreaRole |
   return (ROLES as string[]).includes(area.name) ? (area.name as AreaRole) : null;
 }
 
-/**
- * The role to declare for a chosen role: none when the name already implies
- * it, so the file stays as short as a hand-written one.
- */
+/** The role to declare for a chosen role: none when the name already implies it. */
 export function declaredRole(name: string, chosen: AreaRole | null): AreaRole | null {
   if (chosen === null) return null;
   return (ROLES as string[]).includes(name) && name === chosen ? null : chosen;
@@ -107,10 +105,7 @@ function bbox(rects: Rect[]): Rect {
   return { x, y, w: x1 - x, h: y1 - y };
 }
 
-/**
- * What stops a save (errors) and what is worth knowing (warnings). The errors
- * are the ones the server's schema would refuse, found before the round trip.
- */
+/** What stops a save (errors) and what is worth knowing (warnings). */
 export function siteIssues(site: SiteModel): Issue[] {
   const issues: Issue[] = [];
   const names = new Map<string, number>();
@@ -124,7 +119,7 @@ export function siteIssues(site: SiteModel): Issue[] {
     });
   }
   const extent = site.extent_mm;
-  if (extent && (!(extent[0] > 0) || !(extent[1] > 0))) {
+  if (extent && (!Number.isFinite(extent[0]) || !Number.isFinite(extent[1]) || !(extent[0] > 0) || !(extent[1] > 0))) {
     issues.push({ level: "error", message: "the extent needs a width and a height" });
   }
   for (const a of site.areas) {
@@ -143,7 +138,9 @@ export function siteIssues(site: SiteModel): Issue[] {
     if ((names.get(name) ?? 0) > 1) {
       issues.push({ level: "error", area: name, message: `two areas are named ${name}` });
     }
-    if (!(a.w > 0) || !(a.h > 0)) {
+    if (![a.x, a.y, a.w, a.h].every(Number.isFinite)) {
+      issues.push({ level: "error", area: name, message: `${name}: x, y, w and h must be numbers` });
+    } else if (!(a.w > 0) || !(a.h > 0)) {
       issues.push({ level: "error", area: name, message: `${name} needs a width and a height` });
     }
     if (
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index 17897d66..a094f520 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -104,4 +104,18 @@ describe("SiteEditor", () => {
     expect(screen.getByLabelText("x")).toHaveValue(1200);
     expect(screen.getByLabelText("y")).toHaveValue(0);
   });
+
+  it("leaves an off-grid area where it is when a click selects it", async () => {
+    const offGrid = loaded();
+    offGrid.site.areas[1] = { ...offGrid.site.areas[1], x: 1073, y: 7 };
+    server(offGrid, { status: 200, body: {} });
+    render(<SiteEditor />);
+    const corner = await screen.findByTestId("edit-area-dev-corner");
+    fireEvent.pointerDown(corner, { button: 0, clientX: 300, clientY: 100, pointerId: 1 });
+    fireEvent.pointerMove(screen.getByTestId("site-canvas"), { clientX: 301, clientY: 101, pointerId: 1 });
+    fireEvent.pointerUp(screen.getByTestId("site-canvas"), { clientX: 301, clientY: 101, pointerId: 1 });
+    expect(screen.getByLabelText("x")).toHaveValue(1073);
+    expect(screen.getByLabelText("y")).toHaveValue(7);
+    expect(screen.queryByText(/unsaved/)).toBeNull();
+  });
 });

From 9173b13f808002a308de4ac22c965452632e6890 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 13:56:16 +0200
Subject: [PATCH 11/80] dotbot/calibration: solve several LH2 stations jointly,
 write schema 4

Breaking: schema 3 calibration files are refused, so a calibration is
collected again. swarmit's own calibration reader still expects schema 3
and needs its matching change before the dashboard reads these files.

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/conics.py                  |  172 +--
 dotbot/calibration/lighthouse2.py             |  173 ++-
 dotbot/calibration/multi_station.py           | 1092 +++++++++++++++++
 dotbot/calibration/spin.py                    |   13 +-
 dotbot/cli/swarm_lh2.py                       |   43 +-
 dotbot/tests/lh2_multi_fixture.py             |  167 +++
 dotbot/tests/lh2_spin_c405.toml               |  110 ++
 dotbot/tests/lh2_wire_fixture.py              |   21 +-
 dotbot/tests/test_calibration_conics.py       |   37 +-
 dotbot/tests/test_calibration_lighthouse2.py  |   49 +-
 .../tests/test_calibration_multi_station.py   |  449 +++++++
 dotbot/tests/test_calibration_push.py         |    4 +-
 dotbot/tests/test_calibration_session.py      |    4 +-
 dotbot/tests/test_calibration_spin.py         |   61 +
 dotbot/tests/test_device.py                   |    2 +-
 15 files changed, 2224 insertions(+), 173 deletions(-)
 create mode 100644 dotbot/calibration/multi_station.py
 create mode 100644 dotbot/tests/lh2_multi_fixture.py
 create mode 100644 dotbot/tests/lh2_spin_c405.toml
 create mode 100644 dotbot/tests/test_calibration_multi_station.py

diff --git a/dotbot/calibration/conics.py b/dotbot/calibration/conics.py
index b2002fd8..6a2806dc 100644
--- a/dotbot/calibration/conics.py
+++ b/dotbot/calibration/conics.py
@@ -21,7 +21,7 @@
 import datetime
 import itertools
 from dataclasses import dataclass, field
-from typing import Sequence
+from typing import TYPE_CHECKING, Sequence
 
 import numpy as np
 
@@ -29,10 +29,14 @@
     Calibration,
     StationSolution,
     TrackSample,
+    union_rect,
 )
 from dotbot.robots import ROBOT_DEFAULT, robot_geometry
 from dotbot.site import Site, starter_layout
 
+if TYPE_CHECKING:
+    from dotbot.calibration.multi_station import JointSolution
+
 # Post-rectification minor/major axis ratio under which a track is not a circle.
 TRACK_AXIS_RATIO_MIN = 0.95
 
@@ -56,23 +60,37 @@
 GATE_ROUNDS_MAX = 4
 
 
+@dataclass(frozen=True)
+class CircleKey:
+    """One physical circle: a robot's spin in one collection round."""
+
+    name: str
+    round: int = 0
+
+
 @dataclass(eq=False)
 class Track:
-    """One circle's camera points, in the order they were read.
+    """One circle's camera points, as one station read them, in order.
 
     `radius_mm` is the circle's true radius when known; tracks that share a
     radius are fitted with one. `turn` is +1 when the robot turned counter
     clockwise as drawn (right wheel faster), -1 clockwise, 0 unknown.
+    Tracks of several stations with the same `key` are the same circle.
     """
 
     points: np.ndarray
     radius_mm: float | None = None
     turn: int = 0
     name: str = ""
+    round: int = 0
 
     def __post_init__(self):
         self.points = np.asarray(self.points, dtype=np.float64).reshape(-1, 2)
 
+    @property
+    def key(self) -> CircleKey:
+        return CircleKey(self.name, self.round)
+
 
 @dataclass
 class TrackFit:
@@ -88,6 +106,11 @@ class TrackFit:
     axis_ratio: float
     rms_mm: float
     why: str = ""
+    round: int = 0
+
+    @property
+    def key(self) -> CircleKey:
+        return CircleKey(self.name, self.round)
 
 
 @dataclass
@@ -496,6 +519,7 @@ def fit_tracks(
                 axis_ratio=axis_ratio(t, H),
                 rms_mm=rms,
                 why=why.get(t, ""),
+                round=t.round,
             )
         )
     return fits
@@ -677,84 +701,79 @@ def solve_calibration(
     site: Site,
     robot: str = ROBOT_DEFAULT,
     tag: str = "",
-) -> tuple[Calibration, dict[int, ConicSolution], dict[int, str]]:
-    """A free-mode calibration from circle tracks, one homography per station.
-
-    The station with the most tracks sets the frame; every other station is
-    aligned to it through the centres of the circles both saw. Returns the
-    calibration, each solved station's solution, and why each other station
-    was not solved. The calibration records `site`'s name only, with
-    `FREE_FRAME_ANCHOR` for its anchor.
+    drop_stations: Sequence[int] = (),
+) -> tuple[Calibration, JointSolution, dict[int, str]]:
+    """A free-mode calibration from circle tracks, every station in one frame.
+
+    One station is solved as `solve` solves it. Several are put in one frame
+    by `multi_station.solve_joint` through the circles they share; one that
+    is not tied to the rest raises `MultiStationError` unless it is in
+    `drop_stations`. Returns the calibration, the joint solution, and why
+    each station with tracks was not solved. The calibration records
+    `site`'s name only, with `FREE_FRAME_ANCHOR` for its anchor.
     """
-    by_station: dict[int, list[Track]] = {}
-    for sample in samples:
-        by_station.setdefault(sample.station, []).append(
-            Track(
-                points=sample.camera_points(),
-                radius_mm=sample.radius_mm,
-                turn=sample.turn,
-                name=sample.name,
-            )
-        )
+    # pylint: disable=import-outside-toplevel,cyclic-import
+    from dotbot.calibration.multi_station import solve_joint, tracks_by_station
+
+    by_station = tracks_by_station(samples)
     if not by_station:
         raise ValueError("no tracks to solve")
-    margin_mm = robot_geometry(robot).axle_reach_mm
-    order = sorted(by_station, key=lambda k: (-len(by_station[k]), k))
-    reference = order[0]
-    solutions = {reference: solve(by_station[reference], margin_mm=margin_mm)}
-    unsolved: dict[int, str] = {}
-    centres = {t.name: t.centre_mm for t in solutions[reference].tracks}
-    for station in order[1:]:
-        try:
-            own = solve(by_station[station], margin_mm=margin_mm)
-        except ValueError as exc:
-            unsolved[station] = str(exc)
-            continue
-        common = [t for t in own.tracks if t.name in centres]
-        if len(common) < 2:
-            unsolved[station] = (
-                f"shares {len(common)} circle(s) with station {reference}; 2 are "
-                "needed to put both in one frame"
-            )
-            continue
-        S = similarity(
-            np.array([t.centre_mm for t in common]),
-            np.array([centres[t.name] for t in common]),
-            scale=False,
-        )
-        H = S @ own.homography
-        own.homography = H / H[2, 2]
-        why = {t.name: t.why for t in own.dropped}
-        own.tracks = fit_tracks(
-            [t for t in by_station[station] if t.name not in why], own.homography
-        )
-        dropped = [t for t in by_station[station] if t.name in why]
-        own.dropped = fit_tracks(
-            dropped, own.homography, {t: why[t.name] for t in dropped}
-        )
-        solutions[station] = own
-    width, height = solutions[reference].field_mm
+    joint = solve_joint(
+        by_station,
+        margin_mm=robot_geometry(robot).axle_reach_mm,
+        drop=drop_stations,
+    )
+    solved_from = "conics-joint" if joint.joint else "conics-free"
     stations = [
         StationSolution(
             index=station,
-            homography=[[float(v) for v in row] for row in sol.homography],
-            points=sum(t.points for t in sol.tracks),
-            residual_mm=sol.residual_mm,
-            solved_from="conics-free",
+            homography=[[float(v) for v in row] for row in H],
+            points=sum(t.points for t in joint.solutions[station].tracks),
+            residual_mm=joint.station_rms_mm[station],
+            solved_from=solved_from,
+            valid_mm=joint.rectangles[station],
         )
-        for station, sol in sorted(solutions.items())
+        for station, H in sorted(joint.homographies.items())
     ]
     now = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
     calibration = Calibration(
         site=Site(name=site.name, anchor=FREE_FRAME_ANCHOR),
-        valid_mm=(0, 0, width, height),
+        valid_mm=joint.valid_mm,
         stations=stations,
         tracks=list(samples),
+        links=sorted(joint.graph.links, key=lambda k: (k.a, k.b)),
         created_at=now,
         tag=tag,
         robot=robot,
     )
-    return calibration, solutions, unsolved
+    return calibration, joint, dict(joint.unsolved)
+
+
+def spin_field(calibration: Calibration) -> tuple[int, int]:
+    """Width and height of a free-mode calibration's field, from its file.
+
+    The field is what `solve` reports: the box from the frame's zero to the
+    furthest kept spin centre, grown by a robot's reach. Kept means passing
+    the health gate under the stored homography.
+    """
+    margin_mm = robot_geometry(calibration.robot).axle_reach_mm
+    centres = []
+    for st in calibration.stations:
+        tracks = [
+            Track(points=t.camera_points(), radius_mm=t.radius_mm, turn=t.turn)
+            for t in calibration.tracks
+            if t.station == st.index and len(t.count1) >= TRACK_POINTS_MIN
+        ]
+        if not tracks:
+            continue
+        gate = health_gate(tracks, st.matrix)
+        centres += [
+            _circle_fit(apply(st.matrix, t.points))[0] for t in tracks if t not in gate
+        ]
+    if not centres:
+        return calibration.valid_mm[2], calibration.valid_mm[3]
+    hi = np.ceil(np.max(centres, axis=0) + margin_mm)
+    return int(hi[0]), int(hi[1])
 
 
 def self_defined_site(
@@ -764,26 +783,30 @@ def self_defined_site(
 ) -> tuple[Site, Calibration]:
     """A site pack's site from a free-mode calibration, and the calibration in it.
 
-    The site is the starter site (`starter_layout`) around the calibration's
-    own fence, the field (see `solve`): a margin of floor round it, or a
-    `size_mm` site with it centred, and a staging strip below it. The
-    calibration is shifted by the field's offset, and a tag gets `-<name>`
-    appended, so the two files answer to different tags.
+    The site is the starter site (`starter_layout`) around the robots'
+    field (`spin_field`): a margin of floor round it, or a `size_mm` site
+    with it centred, and a staging strip below it. The calibration is
+    shifted by the field's offset, each station's rectangle with it, and a
+    tag gets `-<name>` appended, so the two files answer to different tags.
     """
     if (
         not calibration.stations
         or calibration.site.anchor != FREE_FRAME_ANCHOR
-        or any(st.solved_from != "conics-free" for st in calibration.stations)
+        or any(
+            st.solved_from not in ("conics-free", "conics-joint")
+            for st in calibration.stations
+        )
     ):
         raise ValueError(
             f"calibration {calibration.id8} is not a free-mode spin calibration; "
             "a site can only be defined from one"
         )
-    x0, y0, field_w, field_h = calibration.valid_mm
+    x0, y0, _, _ = calibration.valid_mm
     if (x0, y0) != (0, 0):
         raise ValueError(
             f"a free-mode fence starts at (0, 0), got {list(calibration.valid_mm)}"
         )
+    field_w, field_h = spin_field(calibration)
     extent, field_area, staging = starter_layout((field_w, field_h), size_mm)
     dx, dy = field_area.x, field_area.y
     shift = np.array([[1, 0, dx], [0, 1, dy], [0, 0, 1.0]])
@@ -799,6 +822,12 @@ def self_defined_site(
                 points=st.points,
                 residual_mm=st.residual_mm,
                 solved_from=st.solved_from,
+                valid_mm=(
+                    st.valid_mm[0] + dx,
+                    st.valid_mm[1] + dy,
+                    st.valid_mm[2] + dx,
+                    st.valid_mm[3] + dy,
+                ),
             )
         )
     site = Site(
@@ -809,10 +838,11 @@ def self_defined_site(
     )
     placed = Calibration(
         site=Site(name=name, anchor=anchor),
-        valid_mm=(0, 0, *extent),
+        valid_mm=union_rect(st.valid_mm for st in stations),
         placements=calibration.placements,
         stations=stations,
         tracks=calibration.tracks,
+        links=calibration.links,
         created_at=calibration.created_at,
         tag=f"{calibration.tag}-{name}" if calibration.tag else "",
         robot=calibration.robot,
diff --git a/dotbot/calibration/lighthouse2.py b/dotbot/calibration/lighthouse2.py
index 516e5811..6954f95c 100644
--- a/dotbot/calibration/lighthouse2.py
+++ b/dotbot/calibration/lighthouse2.py
@@ -38,12 +38,13 @@
 CALIBRATION_DIR = Path.home() / ".dotbot"
 CALIBRATION_SUBDIR = "calibrations"
 CALIBRATION_TOML_GLOB = "calibration-*.toml"
-CALIBRATION_SCHEMA_VERSION = 3
+CALIBRATION_SCHEMA_VERSION = 4
 
 # [x_min, y_min, x_max, y_max] in frame mm: outside it a reported position is
 # implausible and the bot drops it. A site with a known extent supplies its
 # own fence; this is what a site without one falls back to.
 VALID_MM_DEFAULT = (0, 0, 10000, 10000)
+VALID_MM_MAX = 0xFFFFFFFF
 
 LH2_BASESTATION_COUNT_MAX = 16
 
@@ -182,8 +183,9 @@ class TrackSample:
     """The reads one station took along one circle a robot traced.
 
     `radius_mm` is the circle's true radius and `turn` +1 when the robot
-    turned counter clockwise as drawn, -1 clockwise; `name` tells the
-    circles of one capture apart.
+    turned counter clockwise as drawn, -1 clockwise. A circle is the robot
+    `name` in collection `round`: the same circle seen by several stations
+    ties them together.
     """
 
     station: int
@@ -192,6 +194,7 @@ class TrackSample:
     turn: int
     count1: list[int] = field(default_factory=list)
     count2: list[int] = field(default_factory=list)
+    round: int = 0
 
     def camera_points(self) -> np.ndarray:
         return camera_points_from_counts(
@@ -204,19 +207,41 @@ def camera_points(self) -> np.ndarray:
 
 @dataclass
 class StationSolution:
-    """One station's solved homography and how well it fits its own evidence."""
+    """One station's solved homography and how well it fits its own evidence.
+
+    `valid_mm` is where this station's fixes are believed, frame mm.
+    """
 
     index: int
     homography: list[list[float]]
     points: int
     residual_mm: float
     solved_from: str = "direct"
+    valid_mm: tuple[int, int, int, int] = VALID_MM_DEFAULT
 
     @property
     def matrix(self) -> np.ndarray:
         return np.array(self.homography, dtype=np.float64)
 
 
+@dataclass
+class LinkRecord:
+    """How strongly two stations are tied by the circles both kept.
+
+    `a` < `b`. `spread_mm` is the largest distance between two shared
+    centres, `disagreement_mm` the rms distance between the two stations'
+    centres of the shared circles, `yaw_sigma_mrad` the relative yaw that
+    leaves.
+    """
+
+    a: int
+    b: int
+    shared: int
+    spread_mm: float
+    disagreement_mm: float
+    yaw_sigma_mrad: float
+
+
 @dataclass
 class Calibration:
     """A whole calibration file, in memory."""
@@ -228,6 +253,7 @@ class Calibration:
     placements: list[Placement] = field(default_factory=list)
     stations: list[StationSolution] = field(default_factory=list)
     tracks: list[TrackSample] = field(default_factory=list)
+    links: list[LinkRecord] = field(default_factory=list)
     created_at: str = ""
     tag: str = ""
     robot: str = ROBOT_DEFAULT
@@ -425,6 +451,37 @@ def pushed_id(calibration: Calibration) -> str:
     return calibration.id
 
 
+def union_rect(rects: Iterable[Sequence[int]]) -> tuple[int, int, int, int]:
+    """The smallest `[x_min, y_min, x_max, y_max]` holding every rectangle."""
+    rects = [tuple(int(v) for v in r) for r in rects]
+    if not rects:
+        raise ValueError("no rectangle to take the union of")
+    return (
+        min(r[0] for r in rects),
+        min(r[1] for r in rects),
+        max(r[2] for r in rects),
+        max(r[3] for r in rects),
+    )
+
+
+def station_mask(calibration: Calibration) -> int:
+    """Bit i set for every station i the calibration solved."""
+    mask = 0
+    for station in calibration.stations:
+        if not 0 <= station.index < LH2_BASESTATION_COUNT_MAX:
+            raise ValueError(
+                f"station {station.index} is outside 0 to "
+                f"{LH2_BASESTATION_COUNT_MAX - 1}"
+            )
+        mask |= 1 << station.index
+    return mask
+
+
+def station_label(index: int) -> str:
+    """How a station is named to an operator: its index and its channel."""
+    return f"station {index} (channel {index + 1})"
+
+
 def pushable_stations(calibration: Calibration) -> list[StationSolution]:
     """The stations in index order, refused when a robot would mis-key them.
 
@@ -535,7 +592,7 @@ def canonical_serialisation(calibration: Calibration) -> str:
             lines.append(base + ".count1=" + ",".join(str(c) for c in sample.count1))
             lines.append(base + ".count2=" + ",".join(str(c) for c in sample.count2))
     for track in calibration.tracks:
-        key = f"track.{track.name}.{track.station}"
+        key = f"track.{track.name}.{track.round}.{track.station}"
         lines.append(f"{key}.radius_mm={toml_num(track.radius_mm)}")
         lines.append(f"{key}.turn={track.turn}")
         lines.append(f"{key}.count1=" + ",".join(str(c) for c in track.count1))
@@ -545,10 +602,17 @@ def canonical_serialisation(calibration: Calibration) -> str:
         lines.append(f"{key}.solved_from={station.solved_from}")
         lines.append(f"{key}.points={station.points}")
         lines.append(f"{key}.residual_mm={toml_num(station.residual_mm)}")
+        lines.append(f"{key}.valid_mm=" + ",".join(str(v) for v in station.valid_mm))
         lines.append(
             f"{key}.homography="
             + ";".join(",".join(toml_num(v) for v in row) for row in station.homography)
         )
+    for link in sorted(calibration.links, key=lambda k: (k.a, k.b)):
+        key = f"link.{link.a}.{link.b}"
+        lines.append(f"{key}.shared={link.shared}")
+        lines.append(f"{key}.spread_mm={toml_num(link.spread_mm)}")
+        lines.append(f"{key}.disagreement_mm={toml_num(link.disagreement_mm)}")
+        lines.append(f"{key}.yaw_sigma_mrad={toml_num(link.yaw_sigma_mrad)}")
     return "\n".join(sorted(lines))
 
 
@@ -609,7 +673,7 @@ def toml_escape(text: str) -> str:
 
 
 def render_calibration(calibration: Calibration) -> str:
-    """The schema 3 file, as text."""
+    """The schema 4 file, as text."""
     site = calibration.site
     out = [
         f"schema_version = {CALIBRATION_SCHEMA_VERSION}",
@@ -660,6 +724,7 @@ def render_calibration(calibration: Calibration) -> str:
             "[[track]]",
             f"station = {track.station}",
             f'name = "{toml_escape(track.name)}"',
+            f"round = {track.round}",
             f"radius_mm = {toml_num(track.radius_mm)}",
             f"turn = {track.turn}",
             f"count1 = [{', '.join(str(c) for c in track.count1)}]",
@@ -673,16 +738,30 @@ def render_calibration(calibration: Calibration) -> str:
             f'solved_from = "{station.solved_from}"',
             f"points = {station.points}",
             f"residual_mm = {toml_num(station.residual_mm)}",
+            f"valid_mm = {_toml_int_list(station.valid_mm)}",
             f"homography = {toml_matrix(station.homography)}",
         ]
+    for link in sorted(calibration.links, key=lambda k: (k.a, k.b)):
+        out += [
+            "",
+            "[[link]]",
+            f"a = {link.a}",
+            f"b = {link.b}",
+            f"shared = {link.shared}",
+            f"spread_mm = {toml_num(link.spread_mm)}",
+            f"disagreement_mm = {toml_num(link.disagreement_mm)}",
+            f"yaw_sigma_mrad = {toml_num(link.yaw_sigma_mrad)}",
+        ]
     return "\n".join(out) + "\n"
 
 
 def read_calibration_file(path: Path) -> Calibration:
-    """Parse a schema 3 calibration file.
+    """Parse a schema 4 calibration file.
 
-    A file of any other schema version is rejected: schema 2 homographies
-    were solved on another camera point, and schema 1 has no site.
+    A file of any other schema version is rejected: schema 3 carries one
+    fence for every station and keys circles by robot alone, schema 2
+    homographies were solved on another camera point, and schema 1 has no
+    site.
     """
     path = Path(path)
     with open(path, "rb") as handle:
@@ -691,7 +770,8 @@ def read_calibration_file(path: Path) -> Calibration:
     if schema != CALIBRATION_SCHEMA_VERSION:
         raise ValueError(
             f"{path}: unsupported calibration schema_version {schema} "
-            f"(this build supports {CALIBRATION_SCHEMA_VERSION})"
+            f"(this build supports {CALIBRATION_SCHEMA_VERSION}); collect the "
+            "calibration again"
         )
     if "frame" in data:
         raise ValueError(
@@ -733,16 +813,23 @@ def read_calibration_file(path: Path) -> Calibration:
             )
         )
 
-    stations = [
-        StationSolution(
-            index=int(raw["index"]),
-            homography=[[float(v) for v in row] for row in raw["homography"]],
-            points=int(raw.get("points", 0)),
-            residual_mm=float(raw.get("residual_mm", 0.0)),
-            solved_from=raw.get("solved_from", "direct"),
+    stations = []
+    for raw in data.get("station", []):
+        if "valid_mm" not in raw:
+            raise ValueError(
+                f"{path}: station {raw.get('index')} has no valid_mm, which "
+                f"schema {CALIBRATION_SCHEMA_VERSION} requires"
+            )
+        stations.append(
+            StationSolution(
+                index=int(raw["index"]),
+                homography=[[float(v) for v in row] for row in raw["homography"]],
+                points=int(raw.get("points", 0)),
+                residual_mm=float(raw.get("residual_mm", 0.0)),
+                solved_from=raw.get("solved_from", "direct"),
+                valid_mm=_checked_rect(raw["valid_mm"], path),
+            )
         )
-        for raw in data.get("station", [])
-    ]
 
     tracks = [
         TrackSample(
@@ -752,9 +839,22 @@ def read_calibration_file(path: Path) -> Calibration:
             turn=int(raw.get("turn", 0)),
             count1=[int(c) for c in raw["count1"]],
             count2=[int(c) for c in raw["count2"]],
+            round=int(raw.get("round", 0)),
         )
         for raw in data.get("track", [])
     ]
+    links = [
+        LinkRecord(
+            a=int(raw["a"]),
+            b=int(raw["b"]),
+            shared=int(raw["shared"]),
+            spread_mm=float(raw["spread_mm"]),
+            disagreement_mm=float(raw["disagreement_mm"]),
+            yaw_sigma_mrad=float(raw["yaw_sigma_mrad"]),
+        )
+        for raw in data.get("link", [])
+    ]
+    _check_stations(stations, links, _checked_rect(valid_mm, path), path)
 
     calibration = Calibration(
         site=site,
@@ -762,6 +862,7 @@ def read_calibration_file(path: Path) -> Calibration:
         placements=placements,
         stations=stations,
         tracks=tracks,
+        links=links,
         created_at=metadata.get("created_at", ""),
         tag=metadata.get("tag", ""),
         robot=metadata.get("robot", ROBOT_DEFAULT),
@@ -771,6 +872,39 @@ def read_calibration_file(path: Path) -> Calibration:
     return calibration
 
 
+def _checked_rect(values, path) -> tuple[int, int, int, int]:
+    """A `valid_mm` read from `path`, refused unless it is a uint32 rectangle."""
+    rect = tuple(int(v) for v in values)
+    if (
+        len(rect) != 4
+        or any(v < 0 or v > VALID_MM_MAX for v in rect)
+        or rect[0] >= rect[2]
+        or rect[1] >= rect[3]
+    ):
+        raise ValueError(
+            f"{path}: valid_mm {list(values)} is not [x_min, y_min, x_max, y_max] "
+            "with x_min < x_max and y_min < y_max, in 0 to 2^32-1"
+        )
+    return rect
+
+
+def _check_stations(stations, links, valid_mm, path) -> None:
+    """The schema 4 rules between stations, links and the fence."""
+    indices = [s.index for s in stations]
+    if len(set(indices)) != len(indices):
+        raise ValueError(f"{path}: a station index appears twice: {indices}")
+    if stations and union_rect(s.valid_mm for s in stations) != valid_mm:
+        raise ValueError(
+            f"{path}: [validity] valid_mm {list(valid_mm)} is not the union of "
+            f"the station rectangles {list(union_rect(s.valid_mm for s in stations))}"
+        )
+    joint = [s for s in stations if s.solved_from.startswith("conics")]
+    if len(joint) > 1 and not links:
+        raise ValueError(
+            f"{path}: {len(joint)} spin-solved stations but no [[link]] between them"
+        )
+
+
 def resolve_calibration_path(
     spec: str,
     root: Optional[Path] = None,
@@ -975,6 +1109,7 @@ def solve_station(self, station: int) -> StationSolution:
             homography=[[float(v) for v in row] for row in homography],
             points=len(camera_points),
             residual_mm=residual,
+            valid_mm=self.valid_mm,
         )
 
     def solve(self) -> list[StationSolution]:
diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
new file mode 100644
index 00000000..52f3d374
--- /dev/null
+++ b/dotbot/calibration/multi_station.py
@@ -0,0 +1,1092 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Several LH2 stations in one frame, from the circles robots spin.
+
+Each station is first solved on its own circles (`conics.solve`), which
+makes it metric through the spin radius but leaves it free to turn and
+shift. A circle seen by two stations ties them: the station graph says which
+stations are tied and how strongly, a spanning tree of rigid fits seeds one
+joint refinement over every station and every circle, and the frame is then
+set over every kept centre exactly as free mode sets it for one station.
+
+The predicted error map propagates the joint solve's covariance onto a floor
+grid, so a reviewer sees where the calibration is weak without a camera.
+"""
+
+# pylint: disable=invalid-name,too-many-locals,too-many-arguments
+
+from __future__ import annotations
+
+import math
+from collections.abc import Collection, Mapping, Sequence
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from dotbot.calibration.conics import (
+    TRACK_AXIS_RATIO_MIN,
+    CircleKey,
+    ConicSolution,
+    Track,
+    _circle_fit,
+    apply,
+    axis_ratio,
+    field_angle,
+    fit_tracks,
+    health_gate,
+    similarity,
+    solve,
+)
+from dotbot.calibration.lighthouse2 import (
+    Calibration,
+    LinkRecord,
+    TrackSample,
+    station_label,
+    union_rect,
+)
+from dotbot.robots import robot_geometry
+
+__all__ = [
+    "CircleKey",
+    "ErrorMap",
+    "JointSolution",
+    "MultiStationError",
+    "StationGraph",
+    "error_map_from_calibration",
+    "multi_station_report",
+    "solve_joint",
+    "station_graph",
+]
+
+LINK_SHARED_MIN = 2
+LINK_SPREAD_MIN_MM = 300.0
+LINK_SHARED_ADVISED = 4
+LINK_SPREAD_ADVISED_MM = 600.0
+RECT_MARGIN_MM = 300
+ERROR_MAP_CELL_MM = 100.0
+# Cells whose predicted error is over this are counted in the report.
+ERROR_MAP_LIMIT_MM = 10.0
+
+# Largest share a station's own scale may differ from the joint one.
+SCALE_RATIO_TOLERANCE = 0.02
+# A tied circle whose station centres are further apart than this many
+# times the typical disagreement is untied; the scale has this floor.
+TIE_GATE_SIGMAS = 3.0
+TIE_SIGMA_FLOOR_MM = 1.0
+# Tied circles needed before the typical disagreement means anything.
+TIE_GATE_MIN = 4
+TIE_ROUNDS_MAX = 4
+
+# Huber threshold on the radial residual, mm.
+ROBUST_MM = 5.0
+# Weight of the prior holding the root station's centres where the seed put
+# them: it only removes the rigid freedom of the whole floor.
+GAUGE_PRIOR_WEIGHT = 1e-3
+JOINT_ITERATIONS = 60
+
+# The median of the distance between two centres each off by sigma per axis,
+# in units of sigma * sqrt(2) (Rayleigh).
+_RAYLEIGH_MEDIAN = math.sqrt(2 * math.log(2))
+
+
+@dataclass
+class StationGraph:
+    """Stations as nodes, and a link per pair that shares a kept circle.
+
+    `components` are the groups of stations joined by links that hold
+    (`link_holds`), largest first.
+    """
+
+    stations: list[int]
+    links: list[LinkRecord]
+    components: list[list[int]]
+
+    def link(self, a: int, b: int) -> LinkRecord | None:
+        a, b = min(a, b), max(a, b)
+        for link in self.links:
+            if (link.a, link.b) == (a, b):
+                return link
+        return None
+
+
+@dataclass
+class ErrorMap:
+    """Predicted 1-sigma position error on a floor grid, mm.
+
+    Cell (row, col) is centred on `origin_mm + (col + 0.5, row + 0.5) *
+    cell_mm`; NaN where no station's rectangle covers it.
+    """
+
+    origin_mm: tuple[float, float]
+    cell_mm: float
+    sigma_mm: np.ndarray
+    worst_mm: float
+    cells_over_10mm: int
+
+    def centre(self, row: int, col: int) -> tuple[float, float]:
+        return (
+            self.origin_mm[0] + (col + 0.5) * self.cell_mm,
+            self.origin_mm[1] + (row + 0.5) * self.cell_mm,
+        )
+
+    @property
+    def worst_cell(self) -> tuple[float, float] | None:
+        if np.all(np.isnan(self.sigma_mm)):
+            return None
+        row, col = np.unravel_index(np.nanargmax(self.sigma_mm), self.sigma_mm.shape)
+        return self.centre(int(row), int(col))
+
+    @property
+    def covered(self) -> int:
+        return int(np.sum(~np.isnan(self.sigma_mm)))
+
+
+@dataclass
+class JointSolution:
+    """Every station in one frame, and the evidence of how well it holds."""
+
+    homographies: dict[int, np.ndarray]
+    centres: dict[CircleKey, np.ndarray]
+    rectangles: dict[int, tuple[int, int, int, int]]
+    valid_mm: tuple[int, int, int, int]
+    field_mm: tuple[int, int]
+    graph: StationGraph
+    loops: list[tuple[list[int], float]]
+    station_rms_mm: dict[int, float]
+    scale_ratio: dict[int, float]
+    dropped: dict[CircleKey, str]
+    error_map: ErrorMap
+    # Each solved station's circles under its final homography, kept and dropped.
+    solutions: dict[int, ConicSolution] = field(default_factory=dict)
+    # Stations with tracks that could not be solved, and why.
+    unsolved: dict[int, str] = field(default_factory=dict)
+    # Per link (a, b): rms centre disagreement after the seed, before refinement.
+    seed_disagreement_mm: dict[tuple[int, int], float] = field(default_factory=dict)
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def joint(self) -> bool:
+        return len(self.homographies) > 1
+
+
+class MultiStationError(ValueError):
+    """The stations cannot be put in one frame: an island, or a weak tie."""
+
+    def __init__(
+        self,
+        message: str,
+        islands: Sequence[int] = (),
+        weak: Sequence[LinkRecord] = (),
+    ):
+        super().__init__(message)
+        self.islands = list(islands)
+        self.weak = list(weak)
+
+
+def link_holds(link: LinkRecord) -> bool:
+    """Whether a link is strong enough to tie its two stations at all."""
+    return link.shared >= LINK_SHARED_MIN and link.spread_mm >= LINK_SPREAD_MIN_MM
+
+
+def link_advised(link: LinkRecord) -> bool:
+    """Whether a link is as strong as the report advises."""
+    return (
+        link.shared >= LINK_SHARED_ADVISED and link.spread_mm >= LINK_SPREAD_ADVISED_MM
+    )
+
+
+# --- Graph ------------------------------------------------------------------
+
+
+def _spread(points: np.ndarray) -> float:
+    if len(points) < 2:
+        return 0.0
+    diff = points[:, None, :] - points[None, :, :]
+    return float(np.max(np.linalg.norm(diff, axis=2)))
+
+
+def _tie_stats(pa: np.ndarray, pb: np.ndarray) -> tuple[float, float]:
+    """rms distance between paired centres, and the relative yaw it leaves.
+
+    The yaw sigma is that of a rigid fit on the pairs: per-axis noise over
+    the root of the centres' second moment about their mean.
+    """
+    d = np.linalg.norm(pa - pb, axis=1)
+    rms = float(np.sqrt(np.mean(d**2)))
+    moment = float(np.sum((pa - pa.mean(axis=0)) ** 2))
+    if len(pa) < 2 or moment <= 0:
+        return rms, math.inf
+    return rms, 1000.0 * (rms / math.sqrt(2)) / math.sqrt(moment)
+
+
+def _components(
+    stations: Sequence[int], links: Sequence[LinkRecord]
+) -> list[list[int]]:
+    parent = {s: s for s in stations}
+
+    def find(s):
+        while parent[s] != s:
+            parent[s] = parent[parent[s]]
+            s = parent[s]
+        return s
+
+    for link in links:
+        if link_holds(link) and link.a in parent and link.b in parent:
+            parent[find(link.a)] = find(link.b)
+    groups: dict[int, list[int]] = {}
+    for s in stations:
+        groups.setdefault(find(s), []).append(s)
+    return sorted((sorted(g) for g in groups.values()), key=lambda g: (-len(g), g[0]))
+
+
+def _kept_centres(solution: ConicSolution) -> dict[CircleKey, np.ndarray]:
+    return {t.key: np.array(t.centre_mm) for t in solution.tracks}
+
+
+def _graph_from_centres(
+    centres: Mapping[int, Mapping[CircleKey, np.ndarray]],
+    tied: Mapping[CircleKey, set[int]] | None = None,
+) -> StationGraph:
+    """The graph, with each station's centres expressed in one frame or its own.
+
+    A pair's spread is measured in the first station's centres, which are
+    metric either way; the disagreement is only meaningful when every
+    station's centres are in one frame. `tied` limits which stations a
+    circle ties (all that kept it, by default).
+    """
+    stations = sorted(centres)
+    links = []
+    for i, a in enumerate(stations):
+        for b in stations[i + 1 :]:
+            shared = sorted(
+                (set(centres[a]) & set(centres[b])),
+                key=lambda k: (k.name, k.round),
+            )
+            if tied is not None:
+                shared = [k for k in shared if {a, b} <= tied.get(k, set())]
+            if not shared:
+                continue
+            pa = np.array([centres[a][k] for k in shared])
+            pb = np.array([centres[b][k] for k in shared])
+            rms, yaw = _tie_stats(pa, pb)
+            links.append(
+                LinkRecord(
+                    a=a,
+                    b=b,
+                    shared=len(shared),
+                    spread_mm=_spread(pa),
+                    disagreement_mm=rms,
+                    yaw_sigma_mrad=yaw,
+                )
+            )
+    return StationGraph(
+        stations=stations, links=links, components=_components(stations, links)
+    )
+
+
+def _solve_stations(
+    tracks: Mapping[int, Sequence[Track]], margin_mm: float
+) -> tuple[dict[int, ConicSolution], dict[int, str]]:
+    solutions, unsolved = {}, {}
+    for station in sorted(tracks):
+        try:
+            solutions[station] = solve(tracks[station], margin_mm=margin_mm)
+        except ValueError as exc:
+            unsolved[station] = str(exc)
+    return solutions, unsolved
+
+
+def station_graph(
+    tracks: Mapping[int, Sequence[Track]],
+    solutions: Mapping[int, ConicSolution] | None = None,
+) -> StationGraph:
+    """Which stations the kept circles tie, from each station's own solve.
+
+    Spreads are in each station's own metric frame; disagreements are those
+    left by a rigid fit of one station's shared centres onto the other's.
+    """
+    if solutions is None:
+        solutions, _ = _solve_stations(tracks, robot_geometry().axle_reach_mm)
+    own = {s: _kept_centres(sol) for s, sol in solutions.items()}
+    graph = _graph_from_centres(own)
+    for link in graph.links:
+        keys = sorted(
+            set(own[link.a]) & set(own[link.b]), key=lambda k: (k.name, k.round)
+        )
+        pa = np.array([own[link.a][k] for k in keys])
+        pb = np.array([own[link.b][k] for k in keys])
+        if len(keys) >= 2:
+            pb = apply(similarity(pb, pa, scale=False), pb)
+            link.disagreement_mm, link.yaw_sigma_mrad = _tie_stats(pa, pb)
+        else:
+            link.disagreement_mm, link.yaw_sigma_mrad = 0.0, math.inf
+    return graph
+
+
+# --- Seed -------------------------------------------------------------------
+
+
+def _spanning_tree(graph: StationGraph, root: int) -> dict[int, int]:
+    """Parent of each station in a maximum spanning tree of holding links,
+    weighted by shared count times spread, rooted at `root`."""
+    holding = sorted(
+        (k for k in graph.links if link_holds(k)),
+        key=lambda k: (-k.shared * k.spread_mm, k.a, k.b),
+    )
+    parent_uf = {s: s for s in graph.stations}
+
+    def find(s):
+        while parent_uf[s] != s:
+            s = parent_uf[s]
+        return s
+
+    adjacency: dict[int, list[int]] = {s: [] for s in graph.stations}
+    for link in holding:
+        ra, rb = find(link.a), find(link.b)
+        if ra != rb:
+            parent_uf[ra] = rb
+            adjacency[link.a].append(link.b)
+            adjacency[link.b].append(link.a)
+    parent = {root: root}
+    queue = [root]
+    while queue:
+        s = queue.pop(0)
+        for n in sorted(adjacency[s]):
+            if n not in parent:
+                parent[n] = s
+                queue.append(n)
+    return parent
+
+
+def _loops(
+    graph: StationGraph,
+    parent: Mapping[int, int],
+    own: Mapping[int, Mapping[CircleKey, np.ndarray]],
+) -> list[tuple[list[int], float]]:
+    """Each fundamental cycle of the holding links, and how far a point moves
+    when carried round it by the pairwise rigid fits."""
+    tree = {(min(a, b), max(a, b)) for a, b in parent.items() if a != b}
+    out = []
+
+    def path_to_root(s):
+        path = [s]
+        while parent[path[-1]] != path[-1]:
+            path.append(parent[path[-1]])
+        return path
+
+    def fit(a, b):
+        keys = sorted(set(own[a]) & set(own[b]), key=lambda k: (k.name, k.round))
+        return similarity(
+            np.array([own[a][k] for k in keys]),
+            np.array([own[b][k] for k in keys]),
+            scale=False,
+        )
+
+    for link in graph.links:
+        if not link_holds(link) or (link.a, link.b) in tree:
+            continue
+        if link.a not in parent or link.b not in parent:
+            continue
+        pa, pb = path_to_root(link.a), path_to_root(link.b)
+        common = next(s for s in pa if s in pb)
+        cycle = pa[: pa.index(common) + 1] + list(reversed(pb[: pb.index(common)]))
+        # cycle runs a -> ... -> common -> ... -> b, closed by the link b -> a
+        T = np.eye(3)
+        for x, y in zip(cycle, cycle[1:] + cycle[:1]):
+            T = fit(x, y) @ T
+        start = np.mean(list(own[cycle[0]].values()), axis=0)
+        moved = apply(T, start[None, :])[0]
+        out.append((cycle, float(np.linalg.norm(moved - start))))
+    return out
+
+
+# --- Joint refinement -------------------------------------------------------
+
+
+def _h_params(H: np.ndarray) -> np.ndarray:
+    H = H / H[2, 2]
+    return np.array(
+        [H[0, 0], H[0, 1], H[0, 2], H[1, 0], H[1, 1], H[1, 2], H[2, 0], H[2, 1]]
+    )
+
+
+def _h_matrix(p: np.ndarray) -> np.ndarray:
+    return np.array([[p[0], p[1], p[2]], [p[3], p[4], p[5]], [p[6], p[7], 1.0]])
+
+
+def _map_jacobian(p: np.ndarray, q: np.ndarray):
+    """H(q) for the 8 parameters `p`, and its derivative, (n, 2, 8)."""
+    qx, qy = q[:, 0], q[:, 1]
+    w = p[6] * qx + p[7] * qy + 1.0
+    u = (p[0] * qx + p[1] * qy + p[2]) / w
+    v = (p[3] * qx + p[4] * qy + p[5]) / w
+    G = np.zeros((len(q), 2, 8))
+    G[:, 0, 0], G[:, 0, 1], G[:, 0, 2] = qx / w, qy / w, 1 / w
+    G[:, 1, 3], G[:, 1, 4], G[:, 1, 5] = qx / w, qy / w, 1 / w
+    G[:, 0, 6], G[:, 0, 7] = -u * qx / w, -u * qy / w
+    G[:, 1, 6], G[:, 1, 7] = -v * qx / w, -v * qy / w
+    return np.c_[u, v], G
+
+
+@dataclass
+class _Problem:
+    """The joint least-squares problem: which parameters each read touches."""
+
+    stations: list[int]
+    centre_ids: list  # CircleKey for a tied circle, (CircleKey, station) otherwise
+    blocks: list  # (station, centre id, camera points, radius)
+    prior: dict  # centre id -> (target xy)
+
+    def __post_init__(self):
+        self.s_col = {s: 8 * i for i, s in enumerate(self.stations)}
+        base = 8 * len(self.stations)
+        self.c_col = {c: base + 2 * i for i, c in enumerate(self.centre_ids)}
+        self.n = base + 2 * len(self.centre_ids)
+
+    def pack(self, H: Mapping[int, np.ndarray], C: Mapping) -> np.ndarray:
+        x = np.zeros(self.n)
+        for s, col in self.s_col.items():
+            x[col : col + 8] = _h_params(H[s])
+        for c, col in self.c_col.items():
+            x[col : col + 2] = C[c]
+        return x
+
+    def unpack(self, x: np.ndarray):
+        H = {s: _h_matrix(x[col : col + 8]) for s, col in self.s_col.items()}
+        C = {c: x[col : col + 2].copy() for c, col in self.c_col.items()}
+        return H, C
+
+    def residuals(self, x: np.ndarray, jacobian: bool = True, prior: bool = True):
+        rows_r, rows_J = [], []
+        for s, cid, q, radius in self.blocks:
+            sc, cc = self.s_col[s], self.c_col[cid]
+            uv, G = _map_jacobian(x[sc : sc + 8], q)
+            d = uv - x[cc : cc + 2]
+            rho = np.linalg.norm(d, axis=1)
+            e = d / np.maximum(rho, 1e-12)[:, None]
+            rows_r.append(rho - radius)
+            if jacobian:
+                J = np.zeros((len(q), self.n))
+                J[:, sc : sc + 8] = np.einsum("ni,nij->nj", e, G)
+                J[:, cc : cc + 2] = -e
+                rows_J.append(J)
+        if prior:
+            for cid, target in self.prior.items():
+                cc = self.c_col[cid]
+                rows_r.append(GAUGE_PRIOR_WEIGHT * (x[cc : cc + 2] - target))
+                if jacobian:
+                    J = np.zeros((2, self.n))
+                    J[0, cc] = J[1, cc + 1] = GAUGE_PRIOR_WEIGHT
+                    rows_J.append(J)
+        r = np.concatenate(rows_r)
+        return (r, np.vstack(rows_J)) if jacobian else r
+
+    def read_rows(self) -> int:
+        return sum(len(b[2]) for b in self.blocks)
+
+
+def _huber(r: np.ndarray, reads: int) -> np.ndarray:
+    w = np.ones_like(r)
+    big = np.abs(r[:reads]) > ROBUST_MM
+    w[:reads][big] = np.sqrt(ROBUST_MM / np.abs(r[:reads][big]))
+    return w
+
+
+def _refine(problem: _Problem, x0: np.ndarray) -> np.ndarray:
+    """Levenberg-Marquardt on the Huber-weighted residuals, Marquardt scaling."""
+    reads = problem.read_rows()
+    x = x0.copy()
+    r, J = problem.residuals(x)
+    w = _huber(r, reads)
+    cost = float(np.sum((w * r) ** 2))
+    lam = 1e-3
+    for _ in range(JOINT_ITERATIONS):
+        Jw, rw = J * w[:, None], r * w
+        A = Jw.T @ Jw
+        g = Jw.T @ rw
+        D = np.diag(A).copy()
+        D[D <= 0] = 1e-12
+        improved = False
+        while lam < 1e12:
+            try:
+                dx = np.linalg.solve(A + lam * np.diag(D), -g)
+            except np.linalg.LinAlgError:
+                lam *= 10
+                continue
+            r_new = problem.residuals(x + dx, jacobian=False)
+            cost_new = float(np.sum((w * r_new) ** 2))
+            if np.isfinite(cost_new) and cost_new < cost:
+                gain = cost - cost_new
+                x = x + dx
+                r, J = problem.residuals(x)
+                w = _huber(r, reads)
+                cost = float(np.sum((w * r) ** 2))
+                lam = max(lam / 10, 1e-12)
+                improved = gain > 1e-12 * max(cost, 1e-12)
+                break
+            lam *= 10
+        if not improved:
+            break
+    return x
+
+
+def _covariance(problem: _Problem, x: np.ndarray) -> np.ndarray:
+    """Parameter covariance with the rigid freedom of the floor removed.
+
+    From the read rows only (no prior): the information matrix, scaled to
+    unit diagonal, loses its 3 smallest eigen-directions (the gauge), is
+    inverted, and is scaled by the residual variance.
+    """
+    r, J = problem.residuals(x, prior=False)
+    w = _huber(r, problem.read_rows())
+    Jw, rw = J * w[:, None], r * w
+    A = Jw.T @ Jw
+    d = np.sqrt(np.maximum(np.diag(A), 1e-30))
+    As = A / np.outer(d, d)
+    vals, vecs = np.linalg.eigh(As)
+    gauge = 3
+    keep = np.arange(len(vals)) >= gauge
+    keep &= vals > vals.max() * 1e-14
+    inv = (vecs[:, keep] / vals[keep]) @ vecs[:, keep].T
+    dof = max(len(r) - (problem.n - gauge), 1)
+    variance = float(np.sum(rw**2) / dof)
+    return variance * inv / np.outer(d, d)
+
+
+def _error_map(
+    problem: _Problem,
+    x: np.ndarray,
+    rectangles: Mapping[int, Sequence[int]],
+    cell_mm: float = ERROR_MAP_CELL_MM,
+) -> ErrorMap:
+    cov = _covariance(problem, x)
+    H, _ = problem.unpack(x)
+    x0, y0, x1, y1 = union_rect(rectangles.values())
+    cols = max(1, int(math.ceil((x1 - x0) / cell_mm)))
+    rows = max(1, int(math.ceil((y1 - y0) / cell_mm)))
+    gx = x0 + (np.arange(cols) + 0.5) * cell_mm
+    gy = y0 + (np.arange(rows) + 0.5) * cell_mm
+    XX, YY = np.meshgrid(gx, gy)
+    info = np.zeros((rows, cols))
+    for s, (rx0, ry0, rx1, ry1) in rectangles.items():
+        inside = (XX >= rx0) & (XX <= rx1) & (YY >= ry0) & (YY <= ry1)
+        if not inside.any():
+            continue
+        p = np.c_[XX[inside], YY[inside]]
+        q = apply(np.linalg.inv(H[s]), p)
+        col = problem.s_col[s]
+        _, G = _map_jacobian(x[col : col + 8], q)
+        S = cov[col : col + 8, col : col + 8]
+        var = np.einsum("nij,jk,nik->n", G, S, G)
+        var = np.maximum(var, 1e-12)
+        info[inside] += 1.0 / var
+    sigma = np.full((rows, cols), np.nan)
+    covered = info > 0
+    sigma[covered] = 1.0 / np.sqrt(info[covered])
+    worst = float(np.nanmax(sigma)) if covered.any() else float("nan")
+    return ErrorMap(
+        origin_mm=(float(x0), float(y0)),
+        cell_mm=float(cell_mm),
+        sigma_mm=sigma,
+        worst_mm=worst,
+        cells_over_10mm=int(np.sum(sigma[covered] > ERROR_MAP_LIMIT_MM)),
+    )
+
+
+# --- Frame ------------------------------------------------------------------
+
+
+def _rotation(angle: float) -> np.ndarray:
+    c, s = np.cos(angle), np.sin(angle)
+    return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1.0]])
+
+
+def _upright_turns(mapped: Sequence[np.ndarray], centres: np.ndarray) -> int:
+    """`conics.upright_turns` over the tracks of every station at once."""
+    dirs = []
+    for p in mapped:
+        d = p[0] - _circle_fit(p)[0]
+        dirs.append(d / np.linalg.norm(d))
+    mean = np.mean(dirs, axis=0)
+    if np.linalg.norm(mean) >= 0.5:
+        heading = np.arctan2(mean[1], mean[0])
+        return int(np.round((np.pi / 2 - heading) / (np.pi / 2))) % 4
+    width, height = np.ptp(centres, axis=0)
+    return 1 if width > height else 0
+
+
+def _rect_around(points: np.ndarray, margin: float) -> tuple[int, int, int, int]:
+    lo = np.floor(points.min(axis=0) - margin)
+    hi = np.ceil(points.max(axis=0) + margin)
+    lo = np.maximum(lo, 0)
+    return (int(lo[0]), int(lo[1]), int(hi[0]), int(hi[1]))
+
+
+def _frame(
+    H: dict[int, np.ndarray],
+    C: dict,
+    kept: Mapping[int, Sequence[Track]],
+    margin_mm: float,
+) -> tuple[np.ndarray, tuple[int, int]]:
+    """The move into the free-mode frame over every kept centre, and the field."""
+    centres = np.array(list(C.values()))
+    T = _rotation(-field_angle(centres))
+    mapped = [apply(T @ H[s], t.points) for s in kept for t in kept[s]]
+    turns = _upright_turns(mapped, apply(T, centres))
+    T = np.linalg.matrix_power(_rotation(np.pi / 2), turns) @ T
+    moved = apply(T, centres)
+    lo = moved.min(axis=0) - margin_mm
+    size = np.ceil(moved.max(axis=0) + margin_mm - lo)
+    T = np.array([[1, 0, -lo[0]], [0, 1, -lo[1]], [0, 0, 1.0]]) @ T
+    return T, (int(size[0]), int(size[1]))
+
+
+# --- The solve --------------------------------------------------------------
+
+
+def _island_message(
+    islands: Sequence[int], main: Sequence[int], graph: StationGraph
+) -> tuple[str, list[LinkRecord]]:
+    lines, weak = [], []
+    for s in islands:
+        touching = [k for k in graph.links if s in (k.a, k.b)]
+        weak += touching
+        if touching:
+            ties = "; ".join(
+                f"shares {k.shared} circle(s) {k.spread_mm:.0f} mm apart with "
+                f"{station_label(k.b if k.a == s else k.a)}"
+                for k in touching
+            )
+        else:
+            ties = "shares no kept circle with any station"
+        lines.append(f"{station_label(s)} is not tied to the others: {ties}")
+    names = ", ".join(station_label(s) for s in main)
+    lines.append(
+        f"A tie needs {LINK_SHARED_MIN} or more shared circles at least "
+        f"{LINK_SPREAD_MIN_MM:.0f} mm apart. Put 2 or more robots, well apart, "
+        f"where the station and one of {names} both see them and collect "
+        "another round, or leave it out with "
+        + " ".join(f"--drop-station {s}" for s in islands)
+        + "."
+    )
+    return "\n".join(lines), weak
+
+
+def _single(
+    station: int,
+    solution: ConicSolution,
+    tracks: Sequence[Track],
+    rect_margin_mm: int,
+    unsolved: dict[int, str],
+) -> JointSolution:
+    """One station: free mode's own answer, so a lone station is solved as before."""
+    H = solution.homography / solution.homography[2, 2]
+    kept_names = {t.key for t in solution.tracks}
+    kept = [t for t in tracks if t.key in kept_names]
+    centres = {t.key: np.array(t.centre_mm) for t in solution.tracks}
+    rect = _rect_around(np.array(list(centres.values())), rect_margin_mm)
+    problem = _Problem(
+        stations=[station],
+        centre_ids=list(centres),
+        blocks=[(station, t.key, t.points, t.radius_mm) for t in kept],
+        prior={},
+    )
+    x = problem.pack({station: H}, centres)
+    graph = StationGraph(stations=[station], links=[], components=[[station]])
+    return JointSolution(
+        homographies={station: H},
+        centres=centres,
+        rectangles={station: rect},
+        valid_mm=rect,
+        field_mm=solution.field_mm,
+        graph=graph,
+        loops=[],
+        station_rms_mm={station: solution.residual_mm},
+        scale_ratio={station: 1.0},
+        dropped={},
+        error_map=_error_map(problem, x, {station: rect}),
+        solutions={station: solution},
+        unsolved=unsolved,
+    )
+
+
+def solve_joint(
+    tracks: Mapping[int, Sequence[Track]],
+    *,
+    margin_mm: float | None = None,
+    rect_margin_mm: int = RECT_MARGIN_MM,
+    drop: Collection[int] = (),
+) -> JointSolution:
+    """Every station's homography in one metric frame, from circle tracks.
+
+    Each station is solved on its own circles first; a station that cannot
+    be is listed in `unsolved` and left out. `drop` leaves stations out on
+    purpose. Raises MultiStationError when a solved station is not tied to
+    the rest by links that hold (`link_holds`), naming it.
+    """
+    if margin_mm is None:
+        margin_mm = robot_geometry().axle_reach_mm
+    tracks = {s: list(t) for s, t in tracks.items() if s not in set(drop) and t}
+    if not tracks:
+        raise ValueError("no tracks to solve")
+    solutions, unsolved = _solve_stations(tracks, margin_mm)
+    if not solutions:
+        raise ValueError(
+            "no station could be solved: "
+            + "; ".join(f"{station_label(s)}: {why}" for s, why in unsolved.items())
+        )
+    graph = station_graph(tracks, solutions)
+    root = min(solutions, key=lambda s: (-len(solutions[s].tracks), s))
+    main = next(c for c in graph.components if root in c)
+    islands = [s for s in sorted(solutions) if s not in main]
+    if islands:
+        message, weak = _island_message(islands, main, graph)
+        raise MultiStationError(message, islands=islands, weak=weak)
+    if len(solutions) == 1:
+        return _single(root, solutions[root], tracks[root], rect_margin_mm, unsolved)
+
+    own = {s: _kept_centres(sol) for s, sol in solutions.items()}
+    kept = {s: [t for t in tracks[s] if t.key in own[s]] for s in sorted(solutions)}
+    # Stage 3: seed by composing rigid fits down a maximum spanning tree.
+    parent = _spanning_tree(graph, root)
+    H0: dict[int, np.ndarray] = {}
+    world: dict[int, dict[CircleKey, np.ndarray]] = {}
+    order = sorted(parent, key=lambda s: _depth(parent, s))
+    for s in order:
+        Hs = solutions[s].homography / solutions[s].homography[2, 2]
+        if s != root:
+            p = parent[s]
+            keys = sorted(set(own[s]) & set(own[p]), key=lambda k: (k.name, k.round))
+            S = similarity(
+                np.array([own[s][k] for k in keys]),
+                np.array([world[p][k] for k in keys]),
+                scale=False,
+            )
+            Hs = S @ Hs
+            Hs = Hs / Hs[2, 2]
+        H0[s] = Hs
+        world[s] = {t.key: _circle_fit(apply(Hs, t.points))[0] for t in kept[s]}
+    seed_graph = _graph_from_centres(world)
+    seed_disagreement = {(k.a, k.b): k.disagreement_mm for k in seed_graph.links}
+
+    # Stage 4: one refinement over every station and every circle, untying
+    # circles the stations disagree on.
+    tied: dict[CircleKey, set[int]] = {}
+    for s, centres in world.items():
+        for k in centres:
+            tied.setdefault(k, set()).add(s)
+    dropped: dict[CircleKey, str] = {}
+    H, C = dict(H0), {}
+    problem = None
+    x = None
+    for _ in range(TIE_ROUNDS_MAX):
+        problem, x0 = _build_problem(kept, world, tied, H, root)
+        x = _refine(problem, x0)
+        H, C = problem.unpack(x)
+        per_station = {
+            s: {t.key: _circle_fit(apply(H[s], t.points))[0] for t in kept[s]}
+            for s in kept
+        }
+        untie = _gate_ties(per_station, tied)
+        if not untie:
+            break
+        for k, why in untie.items():
+            dropped[k] = why
+            tied[k] = set()
+        world = per_station
+    per_station = {
+        s: {t.key: _circle_fit(apply(H[s], t.points))[0] for t in kept[s]} for s in kept
+    }
+    graph_after = _graph_from_centres(per_station, tied)
+    islands = [s for s in sorted(kept) if s not in graph_after.components[0]]
+    if islands:
+        message, weak = _island_message(islands, graph_after.components[0], graph_after)
+        raise MultiStationError(
+            "after untying the circles the stations disagree on:\n" + message,
+            islands=islands,
+            weak=weak,
+        )
+
+    # Stage 5: the frame over every kept centre.
+    T, field = _frame(H, C, kept, margin_mm)
+    H = {s: (T @ Hs) / (T @ Hs)[2, 2] for s, Hs in H.items()}
+    C = {c: apply(T, v[None, :])[0] for c, v in C.items()}
+    x = problem.pack(H, C)
+    per_station = {
+        s: {t.key: _circle_fit(apply(H[s], t.points))[0] for t in kept[s]} for s in kept
+    }
+    final_graph = _graph_from_centres(per_station, tied)
+    rectangles = {
+        s: _rect_around(np.array(list(per_station[s].values())), rect_margin_mm)
+        for s in sorted(kept)
+    }
+    for s, rect in rectangles.items():
+        if rect[0] >= rect[2] or rect[1] >= rect[3]:
+            raise ValueError(f"{station_label(s)}: its rectangle {rect} is empty")
+    warnings: list[str] = []
+    final_solutions: dict[int, ConicSolution] = {}
+    scale_ratio: dict[int, float] = {}
+    for s, sol in solutions.items():
+        why = {t.key: t.why for t in sol.dropped}
+        out = [t for t in tracks[s] if t.key in why]
+        sol.homography = H[s]
+        sol.tracks = fit_tracks(kept[s], H[s])
+        sol.dropped = fit_tracks(out, H[s], {t: why[t.key] for t in out})
+        sol.field_mm = field
+        final_solutions[s] = sol
+        pts = np.vstack([t.points for t in kept[s]])
+        own_mapped = apply(H0[s], pts)
+        S = similarity(own_mapped, apply(H[s], pts), scale=True)
+        scale_ratio[s] = float(math.sqrt(abs(np.linalg.det(S[:2, :2]))))
+        if abs(scale_ratio[s] - 1) > SCALE_RATIO_TOLERANCE:
+            warnings.append(
+                f"{station_label(s)}: its own circles' scale is "
+                f"{100 * (scale_ratio[s] - 1):+.1f} % off the joint one"
+            )
+        for t in kept[s]:
+            ratio = axis_ratio(t, H[s])
+            if ratio < TRACK_AXIS_RATIO_MIN:
+                warnings.append(
+                    f"{station_label(s)}: circle {_key_text(t.key)} has axis "
+                    f"ratio {ratio:.3f} after the joint solve"
+                )
+    loops = _loops(graph, parent, own)
+    centres_out: dict[CircleKey, np.ndarray] = {}
+    for c, v in C.items():
+        centres_out.setdefault(c if isinstance(c, CircleKey) else c[0], v)
+    return JointSolution(
+        homographies=H,
+        centres=centres_out,
+        rectangles=rectangles,
+        valid_mm=union_rect(rectangles.values()),
+        field_mm=field,
+        graph=final_graph,
+        loops=loops,
+        station_rms_mm={s: final_solutions[s].residual_mm for s in final_solutions},
+        scale_ratio=scale_ratio,
+        dropped=dropped,
+        error_map=_error_map(problem, x, rectangles),
+        solutions=final_solutions,
+        unsolved=unsolved,
+        seed_disagreement_mm=seed_disagreement,
+        warnings=warnings,
+    )
+
+
+def _depth(parent: Mapping[int, int], s: int) -> int:
+    depth = 0
+    while parent[s] != s:
+        s = parent[s]
+        depth += 1
+    return depth
+
+
+def _key_text(key: CircleKey) -> str:
+    return key.name if key.round == 0 else f"{key.name} round {key.round}"
+
+
+def _build_problem(kept, world, tied, H, root):
+    centre_ids, C0 = [], {}
+    blocks = []
+    for s in sorted(kept):
+        for t in kept[s]:
+            cid = (
+                t.key
+                if len(tied.get(t.key, ())) >= 2 and s in tied[t.key]
+                else (t.key, s)
+            )
+            if cid not in C0:
+                centre_ids.append(cid)
+                if isinstance(cid, CircleKey):
+                    C0[cid] = np.mean([world[x][cid] for x in tied[cid]], axis=0)
+                else:
+                    C0[cid] = world[s][t.key]
+            blocks.append((s, cid, t.points, t.radius_mm))
+    prior = {}
+    for t in kept[root]:
+        cid = t.key if t.key in C0 else (t.key, root)
+        prior[cid] = C0[cid].copy()
+    problem = _Problem(
+        stations=sorted(kept), centre_ids=centre_ids, blocks=blocks, prior=prior
+    )
+    return problem, problem.pack(H, C0)
+
+
+def _gate_ties(
+    per_station: Mapping[int, Mapping[CircleKey, np.ndarray]],
+    tied: Mapping[CircleKey, set[int]],
+) -> dict[CircleKey, str]:
+    """The tied circles whose station centres disagree beyond the gate, and why."""
+    spans = {}
+    for k, stations in tied.items():
+        if len(stations) < 2:
+            continue
+        pts = np.array([per_station[s][k] for s in sorted(stations)])
+        spans[k] = _spread(pts)
+    if len(spans) < TIE_GATE_MIN:
+        return {}
+    scale = max(np.median(list(spans.values())) / _RAYLEIGH_MEDIAN, TIE_SIGMA_FLOOR_MM)
+    limit = TIE_GATE_SIGMAS * scale
+    return {
+        k: (
+            f"its centres from {', '.join(station_label(s) for s in sorted(tied[k]))} "
+            f"are {d:.1f} mm apart, over {limit:.1f} mm"
+        )
+        for k, d in spans.items()
+        if d > limit
+    }
+
+
+# --- From a file ------------------------------------------------------------
+
+
+def tracks_by_station(samples: Sequence[TrackSample]) -> dict[int, list[Track]]:
+    """Calibration tracks as the solver's camera-point tracks, per station."""
+    by_station: dict[int, list[Track]] = {}
+    for sample in samples:
+        by_station.setdefault(sample.station, []).append(
+            Track(
+                points=sample.camera_points(),
+                radius_mm=sample.radius_mm,
+                turn=sample.turn,
+                name=sample.name,
+                round=sample.round,
+            )
+        )
+    return by_station
+
+
+def error_map_from_calibration(
+    calibration: Calibration, cell_mm: float = ERROR_MAP_CELL_MM
+) -> ErrorMap | None:
+    """The predicted error map of a spin calibration, from its file alone.
+
+    Uses each station's stored homography and the tracks that pass the
+    health gate under it; every circle kept by several stations ties them.
+    None when the file holds no spin-solved station.
+    """
+    stations = {
+        st.index: st
+        for st in calibration.stations
+        if st.solved_from.startswith("conics")
+    }
+    by_station = {
+        s: t for s, t in tracks_by_station(calibration.tracks).items() if s in stations
+    }
+    if not by_station:
+        return None
+    kept, world = {}, {}
+    for s, tracks in by_station.items():
+        H = stations[s].matrix
+        gate = health_gate(tracks, H)
+        kept[s] = [t for t in tracks if t not in gate and len(t.points) >= 6]
+        world[s] = {t.key: _circle_fit(apply(H, t.points))[0] for t in kept[s]}
+    kept = {s: t for s, t in kept.items() if t}
+    if not kept:
+        return None
+    tied: dict[CircleKey, set[int]] = {}
+    for s, centres in world.items():
+        for k in centres:
+            tied.setdefault(k, set()).add(s)
+    H = {s: stations[s].matrix for s in kept}
+    root = min(kept, key=lambda s: (-len(kept[s]), s))
+    problem, x = _build_problem(kept, world, tied, H, root)
+    rectangles = {s: stations[s].valid_mm for s in kept}
+    return _error_map(problem, x, rectangles, cell_mm)
+
+
+# --- Report -----------------------------------------------------------------
+
+
+def _link_line(link: LinkRecord, before: float | None = None) -> str:
+    verdict = ""
+    if not link_holds(link):
+        verdict = (
+            f"  not a tie: under {LINK_SHARED_MIN} circles over "
+            f"{LINK_SPREAD_MIN_MM:.0f} mm"
+        )
+    elif not link_advised(link):
+        verdict = (
+            f"  weak: {LINK_SHARED_ADVISED} or more circles over "
+            f"{LINK_SPREAD_ADVISED_MM:.0f} mm advised"
+        )
+    disagreement = f"{link.disagreement_mm:.1f} mm"
+    if before is not None:
+        disagreement = f"{before:.1f} -> {disagreement}"
+    yaw = (
+        "unknown"
+        if math.isinf(link.yaw_sigma_mrad)
+        else f"{link.yaw_sigma_mrad:.1f} mrad"
+    )
+    return (
+        f"  {station_label(link.a)} - {station_label(link.b)}: {link.shared} shared, "
+        f"spread {link.spread_mm:.0f} mm, disagreement {disagreement}, "
+        f"yaw {yaw}{verdict}"
+    )
+
+
+def _error_map_lines(error_map: ErrorMap | None) -> list[str]:
+    if error_map is None or error_map.covered == 0:
+        return []
+    worst = error_map.worst_cell
+    return [
+        f"predicted error ({error_map.cell_mm:.0f} mm cells): worst "
+        f"{error_map.worst_mm:.1f} mm near ({worst[0]:.0f}, {worst[1]:.0f}) mm, "
+        f"{error_map.cells_over_10mm} of {error_map.covered} cells over "
+        f"{ERROR_MAP_LIMIT_MM:.0f} mm"
+    ]
+
+
+def multi_station_report(
+    calibration: Calibration, joint: JointSolution | None = None
+) -> list[str]:
+    """What the operator reads about how the stations hold together.
+
+    From `joint` when the solve just ran; otherwise from the file's
+    stations, links and tracks, with the error map recomputed from them.
+    """
+    lines = ["stations:"]
+    circles: dict[int, int] = {}
+    for track in calibration.tracks:
+        circles[track.station] = circles.get(track.station, 0) + 1
+    for st in sorted(calibration.stations, key=lambda s: s.index):
+        rect = list(st.valid_mm)
+        if joint is not None and st.index in joint.solutions:
+            sol = joint.solutions[st.index]
+            kept = f"{len(sol.tracks)} kept, {len(sol.dropped)} dropped circles"
+            scale = f", scale {joint.scale_ratio.get(st.index, 1.0):.3f}"
+        else:
+            kept = f"{circles.get(st.index, 0)} circles"
+            scale = ""
+        lines.append(
+            f"  {station_label(st.index)}: {kept}, rms {st.residual_mm:.1f} mm, "
+            f"rectangle {rect}{scale}"
+        )
+    if joint is not None:
+        for s, why in sorted(joint.unsolved.items()):
+            lines.append(f"  {station_label(s)}: not solved, {why}")
+    links = joint.graph.links if joint is not None else calibration.links
+    if links:
+        lines.append("links:")
+        for link in sorted(links, key=lambda k: (k.a, k.b)):
+            before = None
+            if joint is not None:
+                before = joint.seed_disagreement_mm.get((link.a, link.b))
+            lines.append(_link_line(link, before))
+    if joint is not None:
+        for cycle, closure in joint.loops:
+            path = " - ".join(str(s) for s in cycle + cycle[:1])
+            lines.append(f"loop {path}: closure {closure:.1f} mm")
+        for key, why in sorted(joint.dropped.items(), key=lambda kv: kv[0].name):
+            lines.append(f"untied circle {_key_text(key)}: {why}")
+        error_map = joint.error_map
+    else:
+        try:
+            error_map = error_map_from_calibration(calibration)
+        except (ValueError, np.linalg.LinAlgError):
+            error_map = None
+    lines += _error_map_lines(error_map)
+    if joint is not None:
+        lines += [f"warning: {w}" for w in joint.warnings]
+    return lines
diff --git a/dotbot/calibration/spin.py b/dotbot/calibration/spin.py
index ee0fde6b..3531c8ea 100644
--- a/dotbot/calibration/spin.py
+++ b/dotbot/calibration/spin.py
@@ -18,7 +18,11 @@
 from typing import Any
 
 from dotbot.calibration.conics import TRACKS_ADVISED, ConicSolution
-from dotbot.calibration.lighthouse2 import LH2CalibrationSample, TrackSample
+from dotbot.calibration.lighthouse2 import (
+    LH2CalibrationSample,
+    TrackSample,
+    station_label,
+)
 from dotbot.calibration.ota import _is_impossible, _parse_records
 from dotbot.calibration.push import in_app, stop_robots
 
@@ -288,12 +292,13 @@ def spin_report(
                 "solved from what did"
             )
     for station, solution in sorted(solutions.items()):
-        lines.append(f"station {station}:")
+        lines.append(f"{station_label(station)}:")
         fits = sorted(solution.tracks + solution.dropped, key=lambda t: t.name)
         for t in fits:
             verdict = f"dropped: {t.why}" if t.why else "kept"
+            name = t.name if not t.round else f"{t.name}#{t.round}"
             lines.append(
-                f"  {t.name:<18} {t.points:4d} reads  centre "
+                f"  {name:<18} {t.points:4d} reads  centre "
                 f"({t.centre_mm[0]:6.0f}, {t.centre_mm[1]:6.0f}) mm  "
                 f"r {t.radius_mm:5.1f} mm  ratio {t.axis_ratio:.3f}  "
                 f"rms {t.rms_mm:4.1f} mm  {verdict}"
@@ -308,5 +313,5 @@ def spin_report(
                 "more, spread over the area, hold the frame better"
             )
     for station, why in sorted(unsolved.items()):
-        lines.append(f"station {station}: not solved, {why}")
+        lines.append(f"{station_label(station)}: not solved, {why}")
     return lines
diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 76fdc5a9..6364a965 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -307,6 +307,18 @@ def _await_point(session, stream, arrivals: queue.Queue):
         "forward). Re-measure it on a different floor."
     ),
 )
+@click.option(
+    "--drop-station",
+    "drop_stations",
+    multiple=True,
+    type=click.IntRange(min=0, max=15),
+    metavar="N",
+    help=(
+        "With --spin: leave station N (0 to 15, channel N+1) out of the "
+        "solve, repeatable. For a station that is not tied to the others by "
+        "shared circles, which otherwise stops the solve."
+    ),
+)
 @click.pass_context
 def _collect(
     ctx,
@@ -324,6 +336,7 @@ def _collect(
     push,
     spin,
     spin_radius,
+    drop_stations,
 ):
     if spin:
         given = [
@@ -343,10 +356,14 @@ def _collect(
             raise click.UsageError(
                 f"--spin takes no {', '.join(given)}: the robots spin where they stand"
             )
-        _collect_spin(ctx, conn, swarm_id, site_name, tag, push, spin_radius)
+        _collect_spin(
+            ctx, conn, swarm_id, site_name, tag, push, spin_radius, drop_stations
+        )
         return
     if spin_radius is not None:
         raise click.UsageError("--spin-radius goes with --spin")
+    if drop_stations:
+        raise click.UsageError("--drop-station goes with --spin")
     if _devices(ctx):
         raise click.UsageError(
             "`dotbot swarm -d` picks the robots of push and collect --spin; a "
@@ -488,10 +505,13 @@ def read_enter() -> None:
             )
 
 
-def _collect_spin(ctx, conn, swarm_id, site_name, tag, push, spin_radius):
+def _collect_spin(
+    ctx, conn, swarm_id, site_name, tag, push, spin_radius, drop_stations=()
+):
     """`collect --spin`: spin the robots, solve their circles, save, report."""
     from dotbot.calibration.conics import solve_calibration
     from dotbot.calibration.lighthouse2 import write_calibration
+    from dotbot.calibration.multi_station import multi_station_report
     from dotbot.calibration.spin import capture_spins, check_spin_robots, spin_report
     from dotbot.robots import ROBOT_DEFAULT, robot_geometry
 
@@ -536,20 +556,29 @@ def _collect_spin(ctx, conn, swarm_id, site_name, tag, push, spin_radius):
             raise click.ClickException(str(exc)) from exc
         samples = [s for spin in spins.values() for s in spin.samples(spin_radius)]
         try:
-            calibration, solutions, unsolved = solve_calibration(
-                samples, site, robot=ROBOT_DEFAULT, tag=tag or ""
+            calibration, joint, unsolved = solve_calibration(
+                samples,
+                site,
+                robot=ROBOT_DEFAULT,
+                tag=tag or "",
+                drop_stations=drop_stations,
             )
         except ValueError as exc:
             for line in spin_report(spins, robots.robots, {}, {}):
                 click.echo(line)
             raise click.ClickException(f"no calibration written: {exc}") from exc
-        for line in spin_report(spins, robots.robots, solutions, unsolved):
+        for line in spin_report(spins, robots.robots, joint.solutions, unsolved):
             click.echo(line)
+        if len({s.station for s in samples}) > 1:
+            click.echo("")
+            for line in multi_station_report(calibration, joint):
+                click.echo(line)
         path = write_calibration(calibration)
-        _, _, width, height = calibration.valid_mm
+        width, height = joint.field_mm
         click.echo(
             f"\nThe robots' field is {width} x {height} mm: the calibration's frame "
-            "is aligned to it, zero at its top-left, not at the site's anchor."
+            "is aligned to it, zero at its top-left, not at the site's anchor. "
+            f"Robots take fixes inside {list(calibration.valid_mm)}."
         )
         click.echo(f"Calibration saved to {path}")
         click.echo(
diff --git a/dotbot/tests/lh2_multi_fixture.py b/dotbot/tests/lh2_multi_fixture.py
new file mode 100644
index 00000000..52d644a7
--- /dev/null
+++ b/dotbot/tests/lh2_multi_fixture.py
@@ -0,0 +1,167 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Synthetic LH2 stations over one floor, and the spins they would record.
+
+Every station is the measured c405 station (a real corner calibration's
+homography) moved and turned over the floor, so each sees its own patch the
+way the real one sees the arena; `aspect` squashes one image axis, as the
+bench's 0.902 does. A spin is seen by every station whose patch centre is
+within `reach_mm` of it.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from dotbot.calibration.conics import Track, apply, similarity
+from dotbot.calibration.lighthouse2 import TrackSample, counts_for_camera_point
+from dotbot.robots import robot_geometry
+
+RADIUS = robot_geometry().spin_radius_mm
+
+# Camera point to floor mm of the c405 station (calibration b54cb043).
+C405 = np.array(
+    [
+        [189.809398943489, 2711.3856245939314, 1001.2158981500457],
+        [-2180.185035995121, 288.17989657057416, 2247.631285943657],
+        [0.08275982451927269, 0.08570280253867424, 1.0],
+    ]
+)
+# The middle of the patch C405 sees well, floor mm.
+C405_PATCH = np.array([1000.0, 1500.0])
+REACH_MM = 1500.0
+
+
+def rigid(dx: float, dy: float, theta_deg: float = 0.0) -> np.ndarray:
+    t = np.radians(theta_deg)
+    return np.array(
+        [[np.cos(t), -np.sin(t), dx], [np.sin(t), np.cos(t), dy], [0, 0, 1.0]]
+    )
+
+
+@dataclass
+class Station:
+    """A synthetic station: `index`, and its floor-to-camera map."""
+
+    index: int
+    floor_to_cam: np.ndarray
+    patch: np.ndarray
+    reach_mm: float = REACH_MM
+
+    def sees(self, centre) -> bool:
+        return bool(np.linalg.norm(np.asarray(centre) - self.patch) <= self.reach_mm)
+
+    @property
+    def cam_to_floor(self) -> np.ndarray:
+        H = np.linalg.inv(self.floor_to_cam)
+        return H / H[2, 2]
+
+
+def station(
+    index: int, move: np.ndarray | None = None, aspect: float = 1.0, reach_mm=REACH_MM
+) -> Station:
+    """C405 moved over the floor by the rigid `move`, one image axis by `aspect`."""
+    move = np.eye(3) if move is None else move
+    squash = np.diag([1.0, aspect, 1.0])
+    floor_to_cam = squash @ np.linalg.inv(C405) @ np.linalg.inv(move)
+    patch = apply(move, C405_PATCH[None, :])[0]
+    return Station(index, floor_to_cam, patch, reach_mm)
+
+
+def circle(centre, radius=RADIUS, n=120, noise=0.0, rng=None, start_deg=90.0):
+    """A counter-clockwise spin as drawn (y down), starting with the nose at +y."""
+    th = np.radians(start_deg) - np.linspace(0, 2 * np.pi, n, endpoint=False)
+    pts = np.c_[centre[0] + radius * np.cos(th), centre[1] + radius * np.sin(th)]
+    if noise:
+        pts = pts + rng.normal(0, noise, pts.shape)
+    return pts
+
+
+def spins(
+    stations: list[Station],
+    centres,
+    noise: float = 0.0,
+    seed: int = 0,
+    round_: int = 0,
+    names: list[str] | None = None,
+    points: int = 120,
+) -> dict[int, list[Track]]:
+    """Per station, the camera-point tracks of every spin it sees."""
+    rng = np.random.default_rng(seed)
+    out: dict[int, list[Track]] = {}
+    for i, centre in enumerate(centres):
+        name = names[i] if names else f"R{i:02d}"
+        for st in stations:
+            if not st.sees(centre):
+                continue
+            pts = circle(centre, n=points, noise=noise, rng=rng)
+            out.setdefault(st.index, []).append(
+                Track(
+                    points=apply(st.floor_to_cam, pts),
+                    radius_mm=RADIUS,
+                    turn=1,
+                    name=name,
+                    round=round_,
+                )
+            )
+    return out
+
+
+def samples(tracks: dict[int, list[Track]]) -> list[TrackSample]:
+    """The tracks as the robots' raw counts, as a capture delivers them."""
+    out = []
+    for index, station_tracks in sorted(tracks.items()):
+        for t in station_tracks:
+            counts = [counts_for_camera_point(x, y, index) for x, y in t.points]
+            out.append(
+                TrackSample(
+                    station=index,
+                    name=t.name,
+                    radius_mm=RADIUS,
+                    turn=1,
+                    count1=[round(c.count1) for c in counts],
+                    count2=[round(c.count2) for c in counts],
+                    round=t.round,
+                )
+            )
+    return out
+
+
+def grid_in(station_: Station, step=150.0, inset=200.0) -> np.ndarray:
+    """Floor points well inside a station's patch."""
+    r = station_.reach_mm - inset
+    xs = np.arange(-r, r + 1, step)
+    pts = np.array([(x, y) for x in xs for y in xs if x * x + y * y <= r * r])
+    return pts + station_.patch
+
+
+def placed_error(homographies, stations: list[Station], step=150.0, centres=None):
+    """Per station, rms and max mm between the solve and the truth over its
+    patch, after the one rigid move that best aligns every station at once.
+
+    With `centres`, only over the patch's points within 500 mm of a spin it
+    saw: where the calibration has evidence, not where it extrapolates.
+    """
+    ours, truth, owner = [], [], []
+    for st in stations:
+        if st.index not in homographies:
+            continue
+        P = grid_in(st, step)
+        if centres is not None:
+            seen = np.array([c for c in centres if st.sees(c)])
+            near = np.min(np.linalg.norm(P[:, None] - seen[None], axis=2), axis=1)
+            P = P[near <= 500]
+        ours.append(apply(homographies[st.index], apply(st.floor_to_cam, P)))
+        truth.append(P)
+        owner += [st.index] * len(P)
+    ours, truth, owner = np.vstack(ours), np.vstack(truth), np.array(owner)
+
+    S = similarity(ours, truth, scale=False)
+    err = np.linalg.norm(apply(S, ours) - truth, axis=1)
+    return {
+        s: (float(np.sqrt(np.mean(err[owner == s] ** 2))), float(err[owner == s].max()))
+        for s in np.unique(owner)
+    }
diff --git a/dotbot/tests/lh2_spin_c405.toml b/dotbot/tests/lh2_spin_c405.toml
new file mode 100644
index 00000000..c8e6b369
--- /dev/null
+++ b/dotbot/tests/lh2_spin_c405.toml
@@ -0,0 +1,110 @@
+# The tracks of a real one-station spin calibration (c405 arena, 13 robots,
+# 2026-10-01), and the homography origin/main's solve_calibration gave them
+# before several stations were solved jointly: one station must still come
+# out exactly so.
+expected_homography = [[1.5788960420067275e+02, 2.6500146576090801e+03, 7.3764193147494746e+02], [-2.1967202966527288e+03, 2.5932151434425185e+02, 1.9755351045672023e+03], [7.8482105599457286e-02, 6.9679760045558634e-02, 1.0]]
+expected_field_mm = [1461, 1460]
+
+[[track]]
+station = 0
+name = "11D3570B3A8CEF2D"
+radius_mm = 51.4
+turn = 1
+count1 = [31385, 31387, 31390, 31396, 31402, 31408, 31416, 31415, 31417, 31416, 31411, 31406, 31399, 31388, 31383, 31373, 31360, 31350, 31335, 31320, 31305, 31287, 31271, 31253, 31233, 31213, 31191, 31168, 31145, 31122, 31100, 31076, 31051, 31028, 31006, 30983, 30959, 30935, 30914, 30891, 30867, 30843, 30821, 30796, 30774, 30756, 30738, 30717, 30702, 30682, 30666, 30655, 30638, 30626, 30614, 30604, 30596, 30593, 30587, 30584, 30585, 30585, 30585, 30590, 30595, 30601, 30609, 30617, 30630, 30643, 30656, 30668, 30683, 30695, 30714, 30733, 30750, 30771, 30792, 30814, 30834, 30857, 30881, 30905, 30927, 30953, 30978, 31003, 31024, 31049, 31071, 31096, 31119, 31141, 31164, 31184, 31207, 31229, 31248, 31271, 31290, 31306, 31321, 31337, 31353, 31368, 31378, 31390, 31399, 31406, 31416, 31421, 31425, 31427, 31425, 31425, 31421, 31415, 31408, 31401, 31392, 31380, 31369, 31353, 31336, 31318, 31302, 31287, 31270, 31252, 31232, 31212, 31189, 31165, 31145, 31119, 31099, 31076, 31052, 31028, 31004, 30983, 30958, 30936, 30911, 30889, 30864, 30842, 30820, 30799, 30778, 30757, 30743, 30725, 30706, 30687, 30674, 30660, 30648, 30636, 30625, 30616, 30608, 30599, 30596, 30592, 30590, 30591, 30593, 30596, 30602, 30607, 30615, 30624, 30633, 30642, 30657, 30673, 30689, 30704, 30725, 30745, 30766, 30784, 30804, 30826, 30846, 30871, 30894, 30918, 30941, 30966, 30991, 31015, 31041, 31063, 31084, 31113, 31133, 31157, 31180, 31202, 31226, 31244, 31265, 31281, 31299, 31316, 31333, 31348, 31363, 31377, 31388, 31395, 31397]
+count2 = [73421, 73413, 73402, 73387, 73370, 73352, 73333, 73307, 73285, 73262, 73234, 73207, 73183, 73157, 73134, 73109, 73083, 73058, 73033, 73008, 72984, 72958, 72931, 72908, 72885, 72861, 72838, 72817, 72798, 72778, 72758, 72742, 72725, 72712, 72696, 72684, 72674, 72661, 72652, 72643, 72634, 72630, 72625, 72622, 72622, 72624, 72627, 72630, 72638, 72643, 72652, 72664, 72673, 72685, 72700, 72714, 72732, 72753, 72771, 72791, 72814, 72837, 72861, 72887, 72910, 72937, 72964, 72988, 73014, 73041, 73066, 73091, 73115, 73138, 73164, 73188, 73212, 73236, 73259, 73279, 73299, 73320, 73341, 73359, 73374, 73393, 73411, 73425, 73434, 73448, 73458, 73468, 73478, 73488, 73494, 73496, 73500, 73501, 73500, 73500, 73498, 73489, 73480, 73473, 73463, 73453, 73439, 73424, 73410, 73393, 73376, 73359, 73339, 73318, 73293, 73270, 73244, 73217, 73194, 73169, 73142, 73115, 73091, 73063, 73036, 73010, 72984, 72961, 72937, 72913, 72892, 72868, 72845, 72824, 72807, 72787, 72770, 72754, 72742, 72729, 72716, 72706, 72696, 72683, 72676, 72667, 72664, 72659, 72654, 72653, 72652, 72648, 72649, 72656, 72660, 72665, 72675, 72686, 72696, 72708, 72721, 72738, 72753, 72770, 72788, 72806, 72828, 72849, 72874, 72899, 72921, 72949, 72974, 73000, 73026, 73052, 73077, 73103, 73130, 73157, 73181, 73209, 73233, 73257, 73280, 73301, 73321, 73343, 73359, 73379, 73399, 73414, 73430, 73444, 73459, 73471, 73480, 73488, 73495, 73501, 73507, 73513, 73515, 73512, 73514, 73513, 73510, 73503, 73498, 73490, 73482, 73471, 73459, 73443, 73439]
+
+[[track]]
+station = 0
+name = "12200A55B9827590"
+radius_mm = 51.4
+turn = 1
+count1 = [27100, 27101, 27104, 27107, 27114, 27122, 27127, 27127, 27131, 27135, 27131, 27130, 27131, 27125, 27124, 27117, 27108, 27102, 27093, 27084, 27074, 27063, 27050, 27037, 27022, 27008, 26993, 26975, 26961, 26940, 26922, 26904, 26886, 26868, 26850, 26830, 26810, 26779, 26763, 26741, 26725, 26707, 26687, 26669, 26652, 26635, 26618, 26604, 26587, 26574, 26563, 26552, 26540, 26531, 26519, 26515, 26509, 26503, 26496, 26494, 26493, 26491, 26492, 26493, 26495, 26498, 26502, 26503, 26510, 26513, 26522, 26530, 26535, 26543, 26548, 26557, 26568, 26574, 26590, 26598, 26610, 26627, 26643, 26661, 26675, 26685, 26703, 26723, 26731, 26761, 26782, 26798, 26817, 26833, 26844, 26861, 26880, 26902, 26921, 26938, 26955, 26970, 26989, 27006, 27021, 27035, 27046, 27056, 27071, 27081, 27089, 27096, 27102, 27105, 27113, 27117, 27116, 27118, 27119, 27117, 27114, 27111, 27105, 27100, 27093, 27085, 27078, 27068, 27055, 27044, 27033, 27020, 27004, 26991, 26974, 26958, 26941, 26924, 26907, 26890, 26872, 26851, 26831, 26811, 26794, 26774, 26743, 26724, 26706, 26688, 26668, 26650, 26632, 26615, 26598, 26586, 26573, 26558, 26544, 26535, 26524, 26513, 26503, 26495, 26489, 26483, 26476, 26474, 26472, 26472, 26471, 26472, 26476, 26478, 26482, 26487, 26494, 26502, 26513, 26522, 26531, 26543, 26552, 26566, 26578, 26595, 26610, 26624, 26641, 26658, 26676, 26693, 26714, 26734, 26761, 26781, 26800, 26819, 26838, 26856, 26868, 26887, 26906, 26925, 26941, 26951, 26965, 26984, 26997, 27014, 27028, 27040, 27050, 27062, 27071, 27080, 27087, 27091, 27091]
+count2 = [66158, 66150, 66144, 66133, 66120, 66104, 66088, 66068, 66053, 66036, 66016, 65998, 65982, 65963, 65946, 65925, 65904, 65886, 65867, 65847, 65827, 65806, 65789, 65770, 65751, 65734, 65716, 65707, 65691, 65676, 65659, 65644, 65630, 65620, 65609, 65599, 65589, 65576, 65571, 65565, 65559, 65559, 65556, 65555, 65556, 65559, 65562, 65568, 65574, 65578, 65588, 65600, 65610, 65622, 65632, 65644, 65659, 65673, 65688, 65707, 65728, 65745, 65763, 65780, 65798, 65816, 65832, 65841, 65861, 65871, 65892, 65914, 65922, 65937, 65947, 65965, 65982, 65992, 66010, 66021, 66039, 66055, 66073, 66090, 66108, 66113, 66129, 66141, 66148, 66170, 66180, 66189, 66199, 66209, 66209, 66216, 66220, 66225, 66230, 66229, 66230, 66230, 66224, 66222, 66220, 66211, 66202, 66194, 66182, 66172, 66159, 66145, 66133, 66117, 66102, 66087, 66069, 66050, 66030, 66014, 65994, 65973, 65955, 65934, 65914, 65895, 65879, 65861, 65840, 65820, 65801, 65782, 65764, 65747, 65730, 65713, 65697, 65680, 65667, 65650, 65640, 65626, 65614, 65602, 65589, 65585, 65573, 65568, 65562, 65561, 65556, 65555, 65556, 65559, 65559, 65564, 65573, 65578, 65585, 65595, 65605, 65616, 65624, 65636, 65653, 65667, 65681, 65700, 65720, 65738, 65756, 65772, 65793, 65812, 65831, 65851, 65870, 65889, 65912, 65931, 65948, 65967, 65985, 65999, 66019, 66037, 66055, 66071, 66087, 66101, 66116, 66130, 66143, 66160, 66174, 66184, 66193, 66204, 66210, 66213, 66216, 66220, 66222, 66225, 66227, 66225, 66225, 66219, 66218, 66211, 66203, 66197, 66186, 66176, 66166, 66154, 66141, 66125, 66123]
+
+[[track]]
+station = 0
+name = "1A817DD5B781D8C0"
+radius_mm = 51.4
+turn = 1
+count1 = [72269, 72261, 72255, 72244, 72229, 72214, 72195, 72175, 72157, 72136, 72125, 72108, 72088, 72064, 72044, 72019, 71996, 71972, 71949, 71927, 71904, 71879, 71857, 71833, 71810, 71786, 71764, 71740, 71722, 71701, 71681, 71666, 71648, 71634, 71618, 71604, 71593, 71580, 71571, 71562, 71554, 71551, 71548, 71543, 71539, 71541, 71544, 71546, 71552, 71556, 71561, 71571, 71575, 71584, 71590, 71601, 71612, 71620, 71636, 71652, 71667, 71686, 71708, 71726, 71736, 71756, 71765, 71786, 71808, 71830, 71850, 71871, 71896, 71919, 71942, 71964, 71989, 72011, 72034, 72058, 72078, 72102, 72122, 72133, 72152, 72161, 72182, 72195, 72203, 72224, 72243, 72248, 72263, 72277, 72291, 72305, 72315, 72320, 72330, 72334, 72335, 72335, 72336, 72337, 72336, 72332, 72328, 72321, 72312, 72305, 72285, 72273, 72260, 72245, 72230, 72214, 72196, 72179, 72155, 72137, 72116, 72093, 72073, 72051, 72028, 72004, 71979, 71953, 71932, 71909, 71885, 71864, 71841, 71816, 71793, 71770, 71748, 71727, 71710, 71688, 71673, 71658, 71641, 71625, 71611, 71600, 71595, 71580, 71571, 71559, 71554, 71547, 71544, 71542, 71541, 71539, 71541, 71546, 71550, 71554, 71559, 71571, 71574, 71585, 71593, 71608, 71624, 71640, 71655, 71673, 71693, 71714, 71732, 71750, 71770, 71792, 71813, 71834, 71853, 71877, 71902, 71926, 71950, 71973, 71999, 72020, 72042, 72063, 72089, 72111, 72130, 72148, 72165, 72183, 72200, 72222, 72235, 72251, 72266, 72282, 72295, 72307, 72316, 72324, 72332, 72337, 72344, 72346, 72345, 72345, 72345, 72341, 72335, 72330, 72320, 72313, 72303, 72290, 72273, 72264, 72264]
+count2 = [26997, 26997, 27003, 27006, 27010, 27019, 27022, 27024, 27028, 27027, 27028, 27027, 27024, 27022, 27016, 27011, 27002, 26993, 26985, 26972, 26962, 26950, 26937, 26921, 26905, 26890, 26872, 26855, 26839, 26816, 26801, 26779, 26758, 26738, 26717, 26695, 26674, 26650, 26631, 26606, 26591, 26572, 26550, 26531, 26514, 26495, 26477, 26463, 26445, 26432, 26417, 26406, 26399, 26387, 26383, 26371, 26362, 26357, 26351, 26344, 26339, 26336, 26333, 26331, 26331, 26331, 26332, 26334, 26337, 26342, 26347, 26353, 26360, 26370, 26378, 26386, 26399, 26411, 26427, 26441, 26456, 26473, 26491, 26498, 26514, 26525, 26543, 26558, 26569, 26590, 26608, 26620, 26640, 26662, 26682, 26705, 26728, 26751, 26771, 26789, 26810, 26830, 26846, 26864, 26884, 26897, 26911, 26928, 26940, 26954, 26965, 26975, 26988, 26994, 27002, 27006, 27010, 27015, 27015, 27017, 27017, 27013, 27012, 27008, 27004, 26997, 26989, 26978, 26970, 26959, 26946, 26933, 26920, 26906, 26891, 26874, 26857, 26840, 26824, 26803, 26785, 26768, 26747, 26728, 26705, 26687, 26677, 26652, 26633, 26609, 26592, 26570, 26548, 26530, 26511, 26492, 26473, 26457, 26450, 26433, 26417, 26406, 26400, 26389, 26375, 26364, 26356, 26348, 26341, 26336, 26331, 26329, 26327, 26326, 26326, 26328, 26329, 26333, 26337, 26342, 26349, 26356, 26366, 26376, 26389, 26400, 26414, 26432, 26447, 26464, 26479, 26495, 26511, 26526, 26545, 26564, 26580, 26600, 26621, 26642, 26664, 26687, 26706, 26727, 26747, 26767, 26789, 26807, 26824, 26846, 26864, 26882, 26899, 26913, 26927, 26940, 26954, 26965, 26975, 26987, 26989]
+
+[[track]]
+station = 0
+name = "77CB95D1780F14AB"
+radius_mm = 51.4
+turn = 1
+count1 = [78548, 78546, 78539, 78529, 78518, 78498, 78478, 78459, 78438, 78416, 78395, 78370, 78348, 78322, 78295, 78265, 78235, 78211, 78182, 78156, 78129, 78101, 78072, 78043, 78018, 77995, 77966, 77940, 77913, 77890, 77864, 77842, 77825, 77806, 77788, 77774, 77756, 77744, 77731, 77722, 77714, 77705, 77699, 77695, 77690, 77688, 77690, 77691, 77693, 77698, 77705, 77711, 77722, 77731, 77744, 77761, 77775, 77786, 77804, 77825, 77839, 77858, 77877, 77900, 77920, 77942, 77964, 77989, 78032, 78061, 78085, 78113, 78141, 78167, 78195, 78222, 78245, 78270, 78298, 78326, 78350, 78372, 78396, 78420, 78443, 78464, 78484, 78507, 78522, 78537, 78553, 78565, 78578, 78584, 78593, 78601, 78604, 78610, 78615, 78612, 78610, 78610, 78605, 78602, 78593, 78584, 78571, 78568, 78557, 78544, 78531, 78510, 78492, 78472, 78453, 78431, 78414, 78392, 78368, 78342, 78317, 78292, 78265, 78232, 78207, 78180, 78150, 78121, 78094, 78066, 78036, 78011, 77984, 77960, 77935, 77913, 77886, 77861, 77842, 77822, 77805, 77786, 77770, 77751, 77740, 77728, 77719, 77712, 77706, 77699, 77695, 77695, 77692, 77695, 77698, 77700, 77706, 77712, 77721, 77735, 77748, 77756, 77772, 77786, 77803, 77822, 77840, 77860, 77883, 77902, 77924, 77947, 77967, 77993, 78017, 78044, 78072, 78101, 78126, 78154, 78179, 78207, 78231, 78256, 78284, 78312, 78335, 78363, 78388, 78409, 78431, 78453, 78474, 78499, 78520, 78535, 78553, 78566, 78577, 78592, 78601, 78606, 78610, 78614, 78617, 78618, 78620, 78618, 78617, 78614, 78609, 78599, 78591, 78581, 78581, 78580]
+count2 = [33080, 33082, 33084, 33090, 33097, 33101, 33108, 33115, 33116, 33117, 33119, 33114, 33113, 33106, 33098, 33091, 33081, 33069, 33056, 33041, 33026, 33008, 32987, 32969, 32948, 32925, 32904, 32878, 32855, 32831, 32805, 32781, 32756, 32732, 32703, 32675, 32652, 32625, 32600, 32576, 32554, 32531, 32508, 32486, 32465, 32444, 32425, 32401, 32382, 32365, 32345, 32330, 32315, 32302, 32292, 32281, 32272, 32264, 32258, 32254, 32250, 32248, 32247, 32246, 32247, 32249, 32254, 32260, 32269, 32278, 32288, 32299, 32312, 32324, 32340, 32357, 32372, 32390, 32410, 32432, 32456, 32474, 32496, 32522, 32548, 32573, 32600, 32631, 32656, 32680, 32704, 32730, 32758, 32779, 32804, 32825, 32844, 32871, 32894, 32912, 32934, 32954, 32975, 32993, 33007, 33022, 33040, 33047, 33055, 33067, 33072, 33077, 33084, 33090, 33093, 33096, 33099, 33096, 33096, 33090, 33084, 33077, 33068, 33057, 33048, 33035, 33019, 33001, 32987, 32966, 32948, 32925, 32905, 32884, 32862, 32837, 32813, 32784, 32760, 32737, 32710, 32681, 32655, 32624, 32600, 32573, 32547, 32523, 32502, 32476, 32454, 32434, 32412, 32392, 32372, 32354, 32336, 32318, 32303, 32293, 32279, 32266, 32256, 32247, 32242, 32238, 32231, 32229, 32228, 32227, 32227, 32230, 32232, 32238, 32245, 32253, 32263, 32275, 32283, 32296, 32309, 32326, 32342, 32361, 32379, 32401, 32419, 32444, 32469, 32489, 32511, 32536, 32561, 32590, 32620, 32646, 32672, 32697, 32719, 32744, 32771, 32793, 32816, 32839, 32867, 32888, 32908, 32929, 32948, 32969, 32986, 33001, 33016, 33030, 33037, 33036]
+
+[[track]]
+station = 0
+name = "7527640CEBA1F2EE"
+radius_mm = 51.4
+turn = 1
+count1 = [70448, 70445, 70433, 70423, 70409, 70394, 70373, 70357, 70339, 70315, 70294, 70274, 70250, 70229, 70204, 70180, 70159, 70134, 70110, 70085, 70060, 70038, 70016, 69993, 69972, 69952, 69929, 69911, 69891, 69874, 69858, 69840, 69826, 69813, 69801, 69789, 69777, 69770, 69762, 69754, 69752, 69749, 69746, 69745, 69745, 69747, 69749, 69756, 69758, 69766, 69775, 69782, 69793, 69806, 69818, 69833, 69851, 69864, 69880, 69897, 69915, 69934, 69956, 69980, 70003, 70026, 70049, 70072, 70095, 70119, 70143, 70167, 70188, 70214, 70234, 70258, 70280, 70299, 70320, 70341, 70364, 70381, 70399, 70412, 70431, 70446, 70460, 70470, 70482, 70491, 70497, 70505, 70512, 70517, 70518, 70520, 70519, 70516, 70515, 70513, 70507, 70499, 70492, 70483, 70474, 70460, 70447, 70433, 70419, 70404, 70388, 70368, 70352, 70330, 70311, 70290, 70265, 70244, 70221, 70196, 70171, 70148, 70124, 70099, 70075, 70048, 70026, 70002, 69982, 69960, 69940, 69921, 69900, 69882, 69862, 69848, 69834, 69819, 69805, 69791, 69783, 69772, 69762, 69756, 69751, 69748, 69745, 69744, 69744, 69746, 69750, 69754, 69762, 69767, 69774, 69787, 69799, 69810, 69819, 69834, 69850, 69864, 69877, 69893, 69912, 69930, 69949, 69973, 69996, 70018, 70037, 70058, 70083, 70105, 70128, 70151, 70177, 70201, 70224, 70246, 70266, 70290, 70311, 70330, 70351, 70370, 70391, 70409, 70424, 70439, 70452, 70464, 70476, 70489, 70498, 70507, 70514, 70518, 70522, 70524, 70523, 70519, 70517, 70513, 70508, 70502, 70494, 70483, 70471, 70459, 70444, 70427, 70413, 70405, 70406]
+count2 = [28348, 28352, 28355, 28360, 28366, 28373, 28374, 28381, 28385, 28385, 28382, 28385, 28379, 28377, 28368, 28360, 28355, 28345, 28334, 28322, 28306, 28293, 28278, 28262, 28246, 28229, 28209, 28191, 28170, 28152, 28130, 28109, 28086, 28064, 28044, 28024, 27999, 27979, 27957, 27935, 27916, 27896, 27877, 27858, 27840, 27822, 27802, 27785, 27771, 27756, 27744, 27729, 27720, 27709, 27699, 27690, 27684, 27676, 27671, 27669, 27666, 27664, 27665, 27666, 27668, 27672, 27676, 27685, 27690, 27699, 27709, 27719, 27729, 27744, 27757, 27770, 27788, 27804, 27821, 27842, 27863, 27882, 27902, 27919, 27943, 27963, 27984, 28003, 28030, 28050, 28067, 28089, 28112, 28133, 28151, 28173, 28192, 28207, 28223, 28244, 28256, 28273, 28288, 28297, 28312, 28328, 28339, 28348, 28353, 28360, 28366, 28367, 28368, 28370, 28370, 28366, 28365, 28358, 28353, 28344, 28336, 28326, 28315, 28301, 28288, 28275, 28260, 28242, 28228, 28208, 28191, 28172, 28152, 28131, 28111, 28089, 28067, 28046, 28025, 28004, 27982, 27958, 27939, 27915, 27895, 27875, 27853, 27836, 27819, 27799, 27781, 27769, 27754, 27741, 27727, 27715, 27704, 27691, 27682, 27676, 27667, 27659, 27656, 27651, 27650, 27650, 27648, 27650, 27654, 27656, 27660, 27666, 27675, 27683, 27692, 27703, 27716, 27730, 27744, 27757, 27775, 27791, 27810, 27827, 27847, 27868, 27886, 27907, 27928, 27946, 27966, 27987, 28010, 28035, 28057, 28074, 28096, 28116, 28134, 28158, 28177, 28192, 28211, 28225, 28244, 28259, 28272, 28284, 28296, 28308, 28316, 28323, 28330, 28335, 28336]
+
+[[track]]
+station = 0
+name = "B0A852A888B52C74"
+radius_mm = 51.4
+turn = 1
+count1 = [28359, 28358, 28360, 28366, 28370, 28379, 28384, 28384, 28385, 28388, 28383, 28383, 28379, 28375, 28370, 28365, 28357, 28349, 28337, 28327, 28319, 28306, 28292, 28277, 28259, 28244, 28225, 28208, 28192, 28174, 28157, 28141, 28118, 28099, 28076, 28059, 28036, 28018, 27999, 27978, 27960, 27942, 27920, 27902, 27887, 27871, 27855, 27839, 27825, 27818, 27804, 27789, 27777, 27767, 27758, 27748, 27741, 27735, 27730, 27725, 27721, 27719, 27716, 27715, 27715, 27719, 27720, 27725, 27729, 27735, 27741, 27750, 27759, 27769, 27778, 27790, 27801, 27808, 27824, 27837, 27856, 27869, 27886, 27904, 27922, 27940, 27961, 27979, 27998, 28018, 28037, 28057, 28076, 28093, 28110, 28131, 28153, 28174, 28191, 28210, 28224, 28238, 28256, 28269, 28282, 28295, 28309, 28318, 28328, 28337, 28342, 28349, 28353, 28357, 28359, 28363, 28361, 28361, 28362, 28358, 28355, 28350, 28343, 28336, 28329, 28323, 28311, 28302, 28291, 28278, 28265, 28252, 28238, 28222, 28206, 28186, 28169, 28152, 28135, 28119, 28099, 28079, 28057, 28038, 28017, 27995, 27979, 27961, 27939, 27919, 27901, 27881, 27864, 27848, 27830, 27816, 27797, 27783, 27770, 27757, 27743, 27733, 27723, 27716, 27709, 27702, 27698, 27697, 27692, 27693, 27692, 27694, 27695, 27698, 27700, 27707, 27713, 27718, 27725, 27736, 27747, 27756, 27760, 27773, 27779, 27792, 27798, 27811, 27828, 27843, 27849, 27863, 27871, 27887, 27908, 27918, 27935, 27943, 27965, 27982, 28003, 28026, 28044, 28064, 28083, 28093, 28111, 28131, 28151, 28168, 28187, 28202, 28222, 28233, 28249, 28263, 28276, 28289, 28292]
+count2 = [64433, 64431, 64420, 64415, 64403, 64380, 64366, 64346, 64330, 64315, 64297, 64282, 64263, 64244, 64229, 64209, 64192, 64174, 64154, 64137, 64122, 64104, 64087, 64070, 64051, 64036, 64019, 64003, 63991, 63975, 63966, 63954, 63936, 63926, 63913, 63908, 63896, 63891, 63886, 63879, 63874, 63874, 63873, 63873, 63875, 63877, 63881, 63887, 63893, 63895, 63902, 63910, 63919, 63932, 63947, 63959, 63974, 63990, 64006, 64019, 64035, 64051, 64068, 64083, 64098, 64119, 64136, 64154, 64172, 64189, 64206, 64225, 64242, 64260, 64279, 64294, 64310, 64319, 64338, 64351, 64369, 64382, 64396, 64413, 64425, 64437, 64449, 64461, 64470, 64480, 64488, 64498, 64505, 64509, 64512, 64516, 64521, 64523, 64523, 64520, 64515, 64510, 64508, 64502, 64494, 64483, 64476, 64461, 64450, 64437, 64421, 64407, 64391, 64377, 64357, 64340, 64323, 64307, 64289, 64270, 64253, 64234, 64214, 64197, 64179, 64162, 64142, 64126, 64108, 64090, 64072, 64057, 64041, 64024, 64010, 63993, 63979, 63966, 63955, 63946, 63934, 63924, 63911, 63904, 63896, 63887, 63884, 63879, 63872, 63869, 63871, 63869, 63872, 63874, 63878, 63881, 63884, 63891, 63900, 63910, 63917, 63928, 63941, 63955, 63967, 63982, 64000, 64018, 64033, 64049, 64066, 64084, 64102, 64120, 64137, 64158, 64176, 64193, 64210, 64230, 64250, 64264, 64271, 64290, 64299, 64317, 64324, 64339, 64355, 64372, 64377, 64389, 64397, 64410, 64425, 64432, 64440, 64443, 64454, 64465, 64475, 64485, 64490, 64496, 64499, 64500, 64504, 64507, 64509, 64509, 64506, 64505, 64504, 64498, 64492, 64486, 64475, 64467, 64466]
+
+[[track]]
+station = 0
+name = "76E9C73799AF6ED7"
+radius_mm = 51.4
+turn = 1
+count1 = [29773, 29780, 29786, 29790, 29800, 29805, 29808, 29811, 29809, 29809, 29807, 29803, 29799, 29795, 29788, 29779, 29771, 29764, 29755, 29742, 29732, 29719, 29705, 29687, 29669, 29653, 29636, 29616, 29596, 29576, 29558, 29533, 29512, 29490, 29467, 29445, 29426, 29401, 29380, 29356, 29336, 29315, 29293, 29274, 29255, 29234, 29218, 29203, 29182, 29169, 29155, 29141, 29126, 29114, 29101, 29094, 29086, 29079, 29072, 29068, 29068, 29065, 29064, 29066, 29070, 29074, 29082, 29090, 29098, 29108, 29118, 29129, 29145, 29157, 29169, 29183, 29202, 29218, 29233, 29250, 29272, 29290, 29314, 29331, 29354, 29375, 29394, 29415, 29437, 29459, 29482, 29506, 29525, 29549, 29579, 29599, 29620, 29638, 29656, 29676, 29692, 29706, 29722, 29733, 29746, 29756, 29770, 29780, 29788, 29795, 29800, 29803, 29806, 29805, 29807, 29804, 29800, 29797, 29790, 29783, 29773, 29761, 29748, 29734, 29720, 29705, 29686, 29669, 29654, 29636, 29617, 29599, 29580, 29563, 29542, 29522, 29499, 29475, 29453, 29430, 29410, 29387, 29366, 29342, 29322, 29301, 29279, 29259, 29239, 29219, 29200, 29185, 29169, 29153, 29138, 29126, 29114, 29101, 29090, 29081, 29074, 29068, 29059, 29055, 29053, 29050, 29051, 29053, 29056, 29058, 29063, 29068, 29078, 29087, 29096, 29106, 29120, 29136, 29151, 29168, 29184, 29208, 29227, 29242, 29264, 29283, 29306, 29325, 29345, 29367, 29385, 29405, 29427, 29450, 29472, 29492, 29517, 29538, 29558, 29579, 29595, 29616, 29632, 29654, 29670, 29686, 29704, 29716, 29728, 29739, 29751, 29761, 29770, 29778, 29778]
+count2 = [68556, 68555, 68546, 68536, 68521, 68503, 68480, 68461, 68442, 68417, 68394, 68373, 68348, 68339, 68317, 68294, 68269, 68260, 68237, 68217, 68196, 68174, 68151, 68131, 68110, 68089, 68069, 68048, 68031, 68012, 67998, 67981, 67965, 67951, 67936, 67926, 67915, 67902, 67895, 67885, 67877, 67874, 67870, 67866, 67864, 67865, 67865, 67867, 67874, 67879, 67884, 67893, 67904, 67916, 67928, 67944, 67961, 67978, 67992, 68011, 68034, 68052, 68071, 68092, 68113, 68137, 68162, 68185, 68212, 68234, 68256, 68278, 68302, 68322, 68342, 68362, 68384, 68402, 68422, 68439, 68460, 68476, 68495, 68510, 68526, 68542, 68552, 68562, 68573, 68585, 68595, 68602, 68607, 68615, 68619, 68621, 68623, 68623, 68623, 68624, 68618, 68610, 68603, 68593, 68586, 68574, 68563, 68547, 68536, 68520, 68503, 68484, 68463, 68443, 68423, 68402, 68378, 68357, 68336, 68312, 68286, 68261, 68237, 68214, 68188, 68164, 68142, 68119, 68097, 68080, 68059, 68041, 68023, 68006, 67990, 67973, 67957, 67942, 67928, 67915, 67907, 67899, 67887, 67881, 67873, 67870, 67866, 67863, 67864, 67863, 67863, 67866, 67872, 67878, 67884, 67891, 67900, 67912, 67920, 67933, 67950, 67965, 67978, 67996, 68013, 68034, 68053, 68069, 68092, 68115, 68137, 68160, 68183, 68207, 68228, 68252, 68285, 68308, 68330, 68353, 68373, 68396, 68417, 68435, 68454, 68471, 68489, 68504, 68519, 68535, 68545, 68555, 68567, 68577, 68586, 68591, 68599, 68604, 68607, 68611, 68610, 68611, 68607, 68605, 68600, 68593, 68587, 68576, 68567, 68557, 68546, 68533, 68518, 68507, 68500]
+
+[[track]]
+station = 0
+name = "B4AB5A04DF9E2426"
+radius_mm = 51.4
+turn = 1
+count1 = [29834, 29836, 29840, 29849, 29854, 29860, 29867, 29868, 29870, 29869, 29868, 29865, 29861, 29856, 29847, 29840, 29831, 29817, 29804, 29792, 29777, 29763, 29744, 29728, 29709, 29690, 29669, 29648, 29628, 29603, 29583, 29561, 29539, 29514, 29492, 29466, 29446, 29419, 29397, 29374, 29349, 29327, 29306, 29282, 29260, 29242, 29219, 29202, 29184, 29169, 29153, 29140, 29125, 29116, 29107, 29097, 29086, 29080, 29075, 29072, 29071, 29072, 29072, 29075, 29079, 29086, 29096, 29105, 29115, 29128, 29140, 29153, 29168, 29186, 29202, 29220, 29239, 29259, 29278, 29301, 29320, 29343, 29366, 29386, 29409, 29433, 29456, 29480, 29503, 29526, 29553, 29575, 29599, 29619, 29641, 29662, 29682, 29704, 29723, 29742, 29759, 29776, 29795, 29808, 29819, 29828, 29836, 29842, 29847, 29851, 29854, 29857, 29856, 29854, 29852, 29846, 29840, 29833, 29824, 29815, 29802, 29791, 29778, 29765, 29748, 29731, 29710, 29690, 29670, 29648, 29630, 29607, 29586, 29563, 29542, 29518, 29492, 29473, 29450, 29428, 29404, 29380, 29357, 29332, 29310, 29288, 29265, 29243, 29226, 29208, 29189, 29169, 29155, 29139, 29124, 29110, 29098, 29088, 29080, 29069, 29064, 29060, 29056, 29053, 29053, 29054, 29055, 29060, 29064, 29072, 29081, 29091, 29101, 29115, 29129, 29140, 29157, 29175, 29191, 29210, 29230, 29250, 29272, 29293, 29316, 29341, 29363, 29384, 29408, 29430, 29456, 29479, 29499, 29524, 29547, 29569, 29592, 29614, 29633, 29654, 29664, 29681, 29693, 29712, 29728, 29745, 29762, 29776, 29789, 29802, 29813, 29821, 29827, 29828]
+count2 = [75307, 75301, 75290, 75280, 75262, 75242, 75222, 75199, 75176, 75153, 75131, 75108, 75083, 75059, 75033, 75008, 74984, 74954, 74930, 74904, 74879, 74856, 74828, 74804, 74778, 74754, 74732, 74709, 74689, 74666, 74647, 74639, 74622, 74604, 74588, 74572, 74560, 74545, 74532, 74525, 74516, 74508, 74502, 74499, 74498, 74497, 74499, 74500, 74503, 74513, 74518, 74531, 74543, 74555, 74569, 74584, 74597, 74625, 74646, 74665, 74687, 74710, 74732, 74758, 74781, 74805, 74843, 74870, 74898, 74925, 74949, 74976, 75002, 75030, 75054, 75076, 75102, 75139, 75160, 75184, 75203, 75225, 75247, 75264, 75279, 75296, 75313, 75326, 75339, 75348, 75361, 75369, 75375, 75378, 75383, 75386, 75390, 75389, 75383, 75377, 75370, 75363, 75348, 75337, 75323, 75307, 75294, 75277, 75259, 75239, 75216, 75195, 75171, 75148, 75124, 75100, 75076, 75064, 75037, 75011, 74985, 74957, 74933, 74908, 74881, 74853, 74827, 74798, 74773, 74749, 74727, 74707, 74684, 74665, 74644, 74625, 74607, 74594, 74580, 74565, 74554, 74540, 74531, 74523, 74514, 74511, 74508, 74504, 74504, 74507, 74509, 74514, 74520, 74527, 74541, 74551, 74563, 74579, 74593, 74605, 74627, 74648, 74665, 74686, 74710, 74733, 74758, 74778, 74802, 74830, 74857, 74883, 74911, 74938, 74965, 74991, 75017, 75042, 75069, 75094, 75117, 75143, 75167, 75191, 75212, 75236, 75255, 75272, 75289, 75306, 75321, 75335, 75344, 75360, 75371, 75378, 75386, 75390, 75390, 75393, 75395, 75393, 75393, 75390, 75385, 75376, 75369, 75360, 75348, 75334, 75322, 75306, 75294, 75294]
+
+[[track]]
+station = 0
+name = "FE715F65F5A8B5D2"
+radius_mm = 51.4
+turn = 1
+count1 = [25838, 25841, 25846, 25850, 25857, 25865, 25868, 25872, 25873, 25876, 25873, 25874, 25870, 25866, 25863, 25857, 25850, 25843, 25833, 25824, 25813, 25803, 25792, 25779, 25765, 25760, 25745, 25729, 25714, 25698, 25682, 25675, 25656, 25641, 25625, 25603, 25597, 25581, 25559, 25543, 25524, 25505, 25488, 25473, 25454, 25448, 25430, 25415, 25398, 25382, 25369, 25353, 25338, 25324, 25312, 25303, 25294, 25283, 25274, 25269, 25264, 25260, 25257, 25253, 25253, 25252, 25252, 25256, 25259, 25264, 25269, 25276, 25280, 25290, 25296, 25309, 25320, 25330, 25341, 25356, 25371, 25386, 25401, 25417, 25435, 25452, 25469, 25483, 25501, 25517, 25534, 25552, 25572, 25591, 25606, 25625, 25644, 25659, 25676, 25693, 25708, 25723, 25738, 25753, 25768, 25780, 25794, 25806, 25816, 25828, 25838, 25844, 25850, 25854, 25859, 25860, 25861, 25863, 25862, 25861, 25856, 25852, 25847, 25840, 25834, 25825, 25816, 25805, 25796, 25783, 25772, 25758, 25744, 25732, 25714, 25702, 25687, 25668, 25649, 25630, 25615, 25595, 25578, 25559, 25541, 25523, 25504, 25487, 25471, 25453, 25435, 25421, 25404, 25397, 25382, 25369, 25355, 25342, 25327, 25323, 25309, 25301, 25295, 25284, 25276, 25271, 25265, 25259, 25259, 25253, 25250, 25248, 25245, 25245, 25245, 25248, 25252, 25256, 25258, 25265, 25271, 25280, 25290, 25299, 25311, 25323, 25332, 25347, 25360, 25377, 25392, 25409, 25427, 25441, 25456, 25473, 25492, 25511, 25526, 25548, 25567, 25586, 25605, 25619, 25639, 25656, 25675, 25688, 25703, 25721, 25734, 25749, 25763, 25774, 25786, 25795, 25807, 25815, 25824, 25829]
+count2 = [67823, 67822, 67814, 67806, 67790, 67775, 67760, 67741, 67722, 67706, 67684, 67668, 67649, 67627, 67608, 67588, 67568, 67548, 67529, 67508, 67488, 67467, 67448, 67429, 67408, 67402, 67387, 67369, 67353, 67337, 67324, 67319, 67304, 67290, 67278, 67265, 67259, 67252, 67240, 67235, 67229, 67221, 67217, 67217, 67214, 67215, 67215, 67217, 67217, 67221, 67227, 67231, 67241, 67249, 67257, 67269, 67282, 67293, 67307, 67322, 67337, 67352, 67368, 67386, 67403, 67423, 67441, 67462, 67480, 67499, 67521, 67540, 67557, 67576, 67595, 67615, 67635, 67652, 67671, 67689, 67709, 67729, 67745, 67760, 67778, 67794, 67808, 67817, 67830, 67840, 67850, 67860, 67869, 67878, 67880, 67884, 67889, 67889, 67892, 67897, 67892, 67888, 67884, 67877, 67874, 67864, 67854, 67845, 67833, 67822, 67809, 67793, 67777, 67760, 67745, 67729, 67708, 67692, 67671, 67652, 67631, 67612, 67591, 67569, 67550, 67530, 67511, 67493, 67473, 67454, 67436, 67418, 67397, 67383, 67364, 67351, 67337, 67321, 67307, 67291, 67283, 67269, 67260, 67248, 67239, 67232, 67224, 67221, 67220, 67216, 67214, 67217, 67218, 67218, 67222, 67227, 67231, 67239, 67244, 67248, 67257, 67270, 67274, 67284, 67299, 67307, 67320, 67337, 67346, 67358, 67376, 67396, 67413, 67432, 67448, 67469, 67490, 67509, 67520, 67541, 67561, 67580, 67601, 67620, 67641, 67659, 67674, 67694, 67714, 67734, 67749, 67766, 67783, 67795, 67808, 67822, 67834, 67847, 67852, 67864, 67871, 67878, 67884, 67887, 67892, 67894, 67898, 67898, 67897, 67896, 67889, 67881, 67878, 67870, 67861, 67851, 67840, 67827, 67815, 67813]
+
+[[track]]
+station = 0
+name = "8362B4D2664D93E1"
+radius_mm = 51.4
+turn = 1
+count1 = [34424, 34425, 34431, 34435, 34443, 34444, 34451, 34454, 34456, 34453, 34454, 34448, 34448, 34441, 34432, 34426, 34414, 34406, 34393, 34379, 34367, 34351, 34334, 34316, 34298, 34279, 34260, 34238, 34216, 34195, 34173, 34148, 34124, 34097, 34071, 34046, 34024, 33996, 33982, 33960, 33935, 33909, 33884, 33863, 33841, 33819, 33799, 33775, 33754, 33734, 33718, 33701, 33687, 33670, 33657, 33644, 33632, 33621, 33614, 33608, 33602, 33597, 33593, 33592, 33591, 33592, 33593, 33599, 33605, 33610, 33616, 33627, 33635, 33645, 33654, 33670, 33683, 33700, 33714, 33731, 33751, 33768, 33789, 33812, 33835, 33855, 33877, 33899, 33922, 33948, 33971, 34010, 34035, 34058, 34085, 34113, 34140, 34162, 34186, 34206, 34227, 34250, 34271, 34292, 34310, 34325, 34343, 34359, 34376, 34387, 34399, 34408, 34413, 34424, 34427, 34427, 34431, 34430, 34433, 34430, 34429, 34425, 34418, 34410, 34406, 34398, 34393, 34381, 34370, 34357, 34342, 34326, 34308, 34293, 34273, 34256, 34236, 34214, 34191, 34167, 34149, 34124, 34098, 34084, 34058, 34035, 34010, 33983, 33958, 33934, 33906, 33880, 33857, 33834, 33811, 33791, 33767, 33745, 33723, 33704, 33687, 33670, 33654, 33642, 33628, 33618, 33610, 33599, 33589, 33583, 33576, 33574, 33572, 33571, 33571, 33571, 33573, 33576, 33585, 33590, 33599, 33610, 33621, 33630, 33643, 33657, 33673, 33687, 33706, 33724, 33738, 33757, 33780, 33804, 33827, 33849, 33874, 33893, 33918, 33941, 33968, 33993, 34014, 34041, 34066, 34094, 34123, 34149, 34169, 34191, 34216, 34239, 34259, 34282, 34302, 34309, 34309]
+count2 = [69466, 69469, 69459, 69449, 69442, 69424, 69405, 69388, 69366, 69346, 69326, 69306, 69285, 69265, 69240, 69214, 69191, 69169, 69142, 69120, 69096, 69075, 69052, 69028, 69008, 68986, 68966, 68946, 68924, 68904, 68884, 68865, 68850, 68830, 68813, 68800, 68784, 68773, 68759, 68752, 68745, 68735, 68729, 68726, 68723, 68722, 68725, 68725, 68729, 68735, 68741, 68747, 68756, 68765, 68777, 68791, 68803, 68814, 68829, 68850, 68867, 68883, 68901, 68921, 68941, 68957, 68978, 69001, 69023, 69046, 69068, 69092, 69112, 69134, 69154, 69182, 69208, 69229, 69251, 69272, 69295, 69315, 69335, 69361, 69381, 69400, 69417, 69434, 69452, 69468, 69484, 69497, 69514, 69526, 69534, 69540, 69549, 69557, 69561, 69562, 69562, 69559, 69557, 69556, 69550, 69542, 69534, 69526, 69514, 69504, 69490, 69474, 69463, 69446, 69427, 69406, 69396, 69378, 69358, 69335, 69312, 69290, 69269, 69248, 69224, 69202, 69194, 69171, 69143, 69120, 69095, 69071, 69049, 69029, 69005, 68981, 68962, 68939, 68919, 68901, 68884, 68869, 68847, 68837, 68821, 68805, 68790, 68777, 68765, 68753, 68742, 68733, 68728, 68723, 68718, 68715, 68717, 68719, 68722, 68725, 68733, 68741, 68751, 68758, 68772, 68786, 68800, 68812, 68828, 68844, 68861, 68875, 68892, 68914, 68934, 68953, 68972, 68997, 69019, 69039, 69064, 69086, 69109, 69130, 69151, 69180, 69204, 69227, 69250, 69270, 69291, 69311, 69334, 69356, 69378, 69399, 69412, 69432, 69447, 69463, 69478, 69492, 69506, 69515, 69527, 69536, 69547, 69556, 69558, 69559, 69562, 69562, 69562, 69558, 69553, 69546, 69548]
+
+[[track]]
+station = 0
+name = "8C176EB10C21D115"
+radius_mm = 51.4
+turn = 1
+count1 = [71420, 71423, 71416, 71405, 71397, 71382, 71363, 71346, 71322, 71300, 71278, 71252, 71230, 71209, 71184, 71157, 71132, 71095, 71067, 71042, 71018, 70994, 70969, 70946, 70921, 70892, 70870, 70844, 70823, 70806, 70784, 70768, 70751, 70736, 70722, 70707, 70697, 70687, 70679, 70675, 70668, 70660, 70655, 70654, 70653, 70652, 70656, 70655, 70660, 70667, 70671, 70681, 70692, 70703, 70715, 70729, 70743, 70759, 70778, 70796, 70814, 70837, 70859, 70879, 70902, 70925, 70949, 70975, 71000, 71026, 71052, 71076, 71100, 71125, 71153, 71179, 71204, 71225, 71247, 71274, 71298, 71317, 71338, 71361, 71378, 71397, 71410, 71426, 71437, 71449, 71461, 71470, 71481, 71482, 71488, 71493, 71493, 71493, 71493, 71488, 71481, 71477, 71467, 71460, 71447, 71436, 71425, 71412, 71400, 71387, 71371, 71353, 71332, 71312, 71289, 71269, 71247, 71227, 71202, 71178, 71154, 71129, 71102, 71075, 71049, 71024, 70998, 70973, 70947, 70922, 70899, 70873, 70850, 70826, 70805, 70783, 70765, 70744, 70725, 70713, 70697, 70685, 70676, 70667, 70659, 70653, 70650, 70646, 70643, 70641, 70644, 70646, 70650, 70653, 70660, 70668, 70678, 70687, 70702, 70718, 70730, 70743, 70752, 70779, 70795, 70811, 70831, 70856, 70878, 70898, 70922, 70947, 70969, 70992, 71019, 71045, 71071, 71096, 71121, 71144, 71171, 71196, 71219, 71242, 71268, 71292, 71314, 71337, 71356, 71375, 71392, 71411, 71428, 71443, 71451, 71464, 71477, 71486, 71494, 71497, 71499, 71498, 71499, 71497, 71495, 71490, 71481, 71471, 71463, 71450, 71438, 71426, 71412, 71400, 71400]
+count2 = [32868, 32868, 32874, 32878, 32885, 32890, 32898, 32904, 32902, 32904, 32906, 32902, 32900, 32895, 32887, 32882, 32871, 32860, 32847, 32833, 32820, 32807, 32786, 32768, 32748, 32724, 32701, 32677, 32655, 32632, 32605, 32579, 32554, 32529, 32503, 32476, 32454, 32432, 32410, 32387, 32363, 32339, 32316, 32294, 32273, 32252, 32231, 32209, 32191, 32176, 32156, 32141, 32126, 32114, 32104, 32096, 32086, 32078, 32072, 32066, 32061, 32059, 32059, 32058, 32058, 32062, 32066, 32072, 32081, 32090, 32100, 32111, 32124, 32136, 32152, 32168, 32188, 32208, 32227, 32252, 32288, 32308, 32334, 32361, 32384, 32410, 32437, 32464, 32488, 32512, 32535, 32562, 32584, 32605, 32624, 32648, 32672, 32694, 32713, 32731, 32751, 32765, 32780, 32794, 32809, 32821, 32836, 32844, 32857, 32863, 32867, 32871, 32876, 32877, 32878, 32880, 32876, 32875, 32868, 32863, 32855, 32843, 32830, 32818, 32805, 32793, 32776, 32757, 32737, 32718, 32698, 32677, 32655, 32630, 32607, 32579, 32554, 32528, 32500, 32474, 32447, 32425, 32399, 32378, 32352, 32324, 32301, 32278, 32252, 32231, 32214, 32192, 32177, 32159, 32144, 32128, 32112, 32100, 32092, 32080, 32070, 32062, 32058, 32051, 32047, 32045, 32044, 32044, 32044, 32047, 32049, 32055, 32061, 32067, 32075, 32087, 32100, 32112, 32127, 32140, 32157, 32174, 32194, 32214, 32234, 32258, 32281, 32304, 32329, 32354, 32378, 32404, 32434, 32459, 32481, 32512, 32537, 32560, 32584, 32604, 32629, 32650, 32673, 32693, 32713, 32734, 32752, 32766, 32780, 32800, 32810, 32825, 32833, 32840, 32839]
+
+[[track]]
+station = 0
+name = "B65553547984E8BE"
+radius_mm = 51.4
+turn = 1
+count1 = [66716, 66712, 66704, 66695, 66678, 66665, 66651, 66641, 66622, 66603, 66585, 66564, 66543, 66525, 66512, 66496, 66475, 66454, 66433, 66410, 66391, 66369, 66350, 66328, 66308, 66287, 66270, 66250, 66233, 66214, 66200, 66185, 66168, 66152, 66138, 66122, 66111, 66101, 66089, 66083, 66075, 66067, 66060, 66057, 66055, 66052, 66053, 66051, 66053, 66058, 66062, 66068, 66075, 66080, 66092, 66105, 66115, 66130, 66143, 66160, 66177, 66192, 66208, 66226, 66245, 66264, 66285, 66305, 66324, 66345, 66365, 66383, 66407, 66426, 66447, 66469, 66487, 66507, 66528, 66549, 66565, 66580, 66597, 66616, 66635, 66652, 66665, 66681, 66694, 66705, 66718, 66730, 66745, 66751, 66757, 66766, 66769, 66774, 66778, 66777, 66776, 66776, 66774, 66768, 66760, 66750, 66743, 66732, 66722, 66709, 66692, 66681, 66666, 66651, 66635, 66618, 66600, 66581, 66561, 66541, 66521, 66503, 66483, 66461, 66439, 66416, 66394, 66375, 66352, 66333, 66311, 66291, 66274, 66254, 66234, 66214, 66197, 66182, 66168, 66152, 66136, 66123, 66109, 66102, 66090, 66079, 66072, 66065, 66055, 66050, 66047, 66043, 66042, 66042, 66042, 66045, 66045, 66050, 66059, 66068, 66074, 66084, 66095, 66108, 66121, 66133, 66149, 66167, 66182, 66202, 66220, 66237, 66257, 66276, 66297, 66318, 66338, 66356, 66379, 66402, 66423, 66446, 66466, 66486, 66506, 66524, 66544, 66562, 66576, 66585, 66604, 66620, 66639, 66655, 66663, 66673, 66683, 66695, 66705, 66717, 66725, 66736, 66742, 66749, 66754, 66761, 66763, 66764, 66763, 66766, 66764, 66760, 66753, 66748, 66740, 66734, 66735, 66733]
+count2 = [31150, 31153, 31156, 31162, 31166, 31174, 31182, 31183, 31187, 31189, 31188, 31188, 31186, 31185, 31180, 31177, 31171, 31163, 31156, 31142, 31132, 31118, 31105, 31091, 31076, 31059, 31043, 31023, 31005, 30988, 30971, 30954, 30931, 30911, 30887, 30861, 30842, 30822, 30798, 30779, 30756, 30731, 30709, 30690, 30671, 30647, 30626, 30603, 30584, 30565, 30546, 30531, 30514, 30499, 30487, 30477, 30465, 30454, 30445, 30440, 30432, 30426, 30423, 30419, 30418, 30417, 30420, 30421, 30425, 30431, 30438, 30445, 30457, 30464, 30473, 30487, 30497, 30511, 30531, 30545, 30561, 30576, 30593, 30614, 30635, 30656, 30674, 30697, 30716, 30736, 30757, 30782, 30806, 30826, 30850, 30871, 30890, 30912, 30935, 30954, 30976, 30997, 31025, 31040, 31058, 31076, 31092, 31103, 31115, 31126, 31137, 31147, 31154, 31162, 31163, 31169, 31171, 31172, 31171, 31171, 31168, 31164, 31159, 31153, 31145, 31135, 31125, 31116, 31100, 31089, 31073, 31058, 31044, 31023, 31005, 30986, 30969, 30950, 30931, 30909, 30874, 30850, 30832, 30813, 30790, 30768, 30747, 30721, 30698, 30680, 30658, 30636, 30612, 30592, 30574, 30555, 30535, 30516, 30502, 30489, 30474, 30462, 30450, 30440, 30431, 30424, 30417, 30411, 30407, 30402, 30400, 30399, 30401, 30404, 30408, 30414, 30421, 30427, 30434, 30446, 30457, 30469, 30482, 30495, 30511, 30526, 30544, 30559, 30575, 30585, 30605, 30623, 30644, 30668, 30674, 30697, 30709, 30728, 30748, 30772, 30793, 30814, 30836, 30857, 30879, 30904, 30922, 30941, 30963, 30986, 31005, 31021, 31038, 31056, 31072, 31077, 31077, 31075]
+
+[[track]]
+station = 0
+name = "A2A411F245E93CBA"
+radius_mm = 51.4
+turn = 1
+count1 = [69551, 69545, 69540, 69530, 69516, 69501, 69484, 69466, 69448, 69428, 69410, 69392, 69372, 69354, 69335, 69315, 69295, 69272, 69253, 69234, 69212, 69192, 69173, 69153, 69131, 69115, 69104, 69085, 69069, 69051, 69035, 69019, 69005, 68992, 68983, 68969, 68960, 68954, 68947, 68938, 68932, 68929, 68927, 68923, 68921, 68921, 68922, 68922, 68924, 68929, 68934, 68941, 68948, 68956, 68966, 68978, 68986, 68996, 69010, 69025, 69050, 69067, 69083, 69099, 69115, 69134, 69154, 69172, 69190, 69211, 69231, 69251, 69269, 69288, 69313, 69335, 69350, 69368, 69388, 69407, 69428, 69443, 69459, 69476, 69490, 69510, 69526, 69539, 69548, 69564, 69571, 69585, 69592, 69596, 69604, 69609, 69612, 69612, 69616, 69616, 69614, 69613, 69611, 69608, 69602, 69592, 69584, 69577, 69568, 69553, 69543, 69529, 69517, 69502, 69485, 69468, 69449, 69429, 69408, 69391, 69372, 69355, 69338, 69315, 69296, 69272, 69253, 69231, 69212, 69192, 69174, 69151, 69132, 69115, 69097, 69080, 69063, 69046, 69030, 69013, 68997, 68986, 68974, 68962, 68952, 68944, 68939, 68932, 68925, 68922, 68919, 68916, 68915, 68915, 68916, 68919, 68922, 68926, 68932, 68941, 68948, 68957, 68967, 68978, 68987, 68999, 69014, 69020, 69039, 69052, 69070, 69088, 69104, 69122, 69142, 69161, 69181, 69199, 69220, 69238, 69257, 69279, 69299, 69321, 69338, 69356, 69375, 69395, 69415, 69432, 69448, 69466, 69483, 69498, 69513, 69530, 69542, 69553, 69568, 69577, 69588, 69596, 69603, 69608, 69611, 69613, 69613, 69615, 69614, 69610, 69607, 69606, 69600, 69591, 69587, 69585]
+count2 = [24561, 24562, 24566, 24570, 24574, 24581, 24586, 24586, 24592, 24591, 24590, 24591, 24589, 24588, 24584, 24581, 24577, 24569, 24564, 24556, 24546, 24536, 24526, 24514, 24502, 24491, 24478, 24462, 24449, 24431, 24413, 24398, 24381, 24365, 24347, 24331, 24316, 24301, 24283, 24267, 24252, 24237, 24228, 24213, 24196, 24182, 24165, 24150, 24137, 24124, 24112, 24098, 24087, 24078, 24068, 24059, 24051, 24046, 24038, 24033, 24026, 24022, 24020, 24018, 24015, 24018, 24018, 24021, 24021, 24027, 24030, 24035, 24042, 24051, 24060, 24068, 24078, 24089, 24098, 24110, 24125, 24136, 24149, 24164, 24178, 24195, 24211, 24227, 24245, 24261, 24281, 24298, 24314, 24331, 24346, 24364, 24378, 24393, 24409, 24426, 24442, 24457, 24473, 24486, 24498, 24508, 24519, 24530, 24542, 24552, 24560, 24567, 24572, 24573, 24579, 24579, 24584, 24585, 24583, 24581, 24578, 24577, 24573, 24570, 24563, 24557, 24549, 24540, 24532, 24523, 24512, 24499, 24490, 24477, 24462, 24448, 24435, 24419, 24405, 24388, 24370, 24354, 24337, 24318, 24303, 24286, 24268, 24253, 24237, 24221, 24206, 24189, 24173, 24159, 24146, 24132, 24119, 24106, 24093, 24083, 24072, 24060, 24052, 24043, 24035, 24029, 24023, 24022, 24015, 24013, 24012, 24008, 24007, 24008, 24009, 24012, 24015, 24019, 24023, 24028, 24034, 24044, 24052, 24060, 24069, 24078, 24091, 24101, 24113, 24127, 24141, 24156, 24170, 24183, 24200, 24217, 24232, 24249, 24267, 24286, 24303, 24321, 24338, 24356, 24373, 24386, 24402, 24420, 24436, 24450, 24463, 24477, 24489, 24502, 24510, 24508]
diff --git a/dotbot/tests/lh2_wire_fixture.py b/dotbot/tests/lh2_wire_fixture.py
index 338afdb1..177b7c86 100644
--- a/dotbot/tests/lh2_wire_fixture.py
+++ b/dotbot/tests/lh2_wire_fixture.py
@@ -1,20 +1,20 @@
 # SPDX-FileCopyrightText: 2026-present Inria
 # SPDX-License-Identifier: BSD-3-Clause
 
-"""A schema 3 calibration and the bytes it reaches a robot as.
+"""A schema 4 calibration and the bytes it reaches a robot as.
 
 swarmit's `tests/lh2_wire_fixture.py` carries the same file and the same
 message bytes: the two packers must agree, so keep the copies identical.
 """
 
-FIXTURE_ID = "19ed0cdb738cdfe5"
+FIXTURE_ID = "80285c9b7db82732"
 
 FIXTURE_TOML = """\
-schema_version = 3
+schema_version = 4
 
 [metadata]
 created_at = "2026-09-10T09:12:00Z"
-id = "19ed0cdb738cdfe5"
+id = "80285c9b7db82732"
 robot = "dotbot-v3"
 tag = "arena-relay"
 
@@ -42,6 +42,7 @@
 solved_from = "direct"
 points = 4
 residual_mm = 0.0
+valid_mm = [0, 0, 3330, 4000]
 homography = [[1523.4, -38.2, 1012.7], [41.9, 1531.8, 988.3], [0.2134, -0.0871, 1.0]]
 
 [[station]]
@@ -49,6 +50,7 @@
 solved_from = "direct"
 points = 4
 residual_mm = 0.0
+valid_mm = [0, 0, 3330, 4000]
 homography = [[-1480.25, 12.5, 2950.0], [-20.75, 1502.125, 1010.5], [-0.1875, 0.0625, 1.0]]
 """
 
@@ -57,18 +59,18 @@
     (
         "0200000000000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
         "88855a3e7c61b2bd0000803f0000000000000000020d0000a00f000063343035"
-        "2d6172656e6100000000000019ed0cdb738cdfe5"
+        "2d6172656e6100000000000080285c9b7db82732"
     ),
     (
         "02000000010000000008b9c400004841006038450000a6c100c4bb4400a07c44"
         "000040be0000803d0000803f0000000000000000020d0000a00f000063343035"
-        "2d6172656e6100000000000019ed0cdb738cdfe5"
+        "2d6172656e6100000000000080285c9b7db82732"
     ),
 ]
 
 # The same file without [site] and [validity], so each reader's defaults reach
 # the wire: site "default" and valid_mm [0, 0, 10000, 10000].
-DEFAULTS_FIXTURE_ID = "999942290d381fd8"
+DEFAULTS_FIXTURE_ID = "4e0d138b62b57aa5"
 
 DEFAULTS_FIXTURE_TOML = (
     FIXTURE_TOML.replace(
@@ -77,6 +79,7 @@
         "",
     )
     .replace("[validity]\nvalid_mm = [0, 0, 3330, 4000]\n\n", "")
+    .replace("valid_mm = [0, 0, 3330, 4000]", "valid_mm = [0, 0, 10000, 10000]")
     .replace(f'id = "{FIXTURE_ID}"', f'id = "{DEFAULTS_FIXTURE_ID}"')
 )
 
@@ -84,11 +87,11 @@
     (
         "0200000000000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
         "88855a3e7c61b2bd0000803f0000000000000000102700001027000064656661"
-        "756c74000000000000000000999942290d381fd8"
+        "756c740000000000000000004e0d138b62b57aa5"
     ),
     (
         "02000000010000000008b9c400004841006038450000a6c100c4bb4400a07c44"
         "000040be0000803d0000803f0000000000000000102700001027000064656661"
-        "756c74000000000000000000999942290d381fd8"
+        "756c740000000000000000004e0d138b62b57aa5"
     ),
 ]
diff --git a/dotbot/tests/test_calibration_conics.py b/dotbot/tests/test_calibration_conics.py
index 99e43153..c436aa9e 100644
--- a/dotbot/tests/test_calibration_conics.py
+++ b/dotbot/tests/test_calibration_conics.py
@@ -272,10 +272,10 @@ def test_the_tracks_are_part_of_the_identity():
 
 
 def test_a_self_defined_site_centres_the_field():
-    calibration, _, _ = conics.solve_calibration(
+    calibration, joint, _ = conics.solve_calibration(
         track_samples(CENTRES), Site(name="lab")
     )
-    field_w, field_h = calibration.valid_mm[2:]
+    field_w, field_h = joint.field_mm
     site, placed = conics.self_defined_site(calibration, "spun", size_mm=(3000, 4000))
     assert site.extent_mm == (3000, 4000)
     field = site.areas["field"]
@@ -284,7 +284,14 @@ def test_a_self_defined_site_centres_the_field():
     staging = site.areas["staging"]
     assert (staging.x, staging.y, staging.w) == (field.x, field.y_max, field.w)
     assert staging.y_max <= 4000
-    assert placed.valid_mm == (0, 0, 3000, 4000)
+    x0, y0, x1, y1 = calibration.stations[0].valid_mm
+    assert placed.stations[0].valid_mm == (
+        x0 + field.x,
+        y0 + field.y,
+        x1 + field.x,
+        y1 + field.y,
+    )
+    assert placed.valid_mm == placed.stations[0].valid_mm
     assert (
         placed.site.anchor
         == site.anchor
@@ -306,22 +313,23 @@ def test_a_self_defined_site_must_hold_the_field():
 
 
 def test_a_self_defined_site_is_the_starter_site_around_the_field():
-    calibration, _, _ = conics.solve_calibration(
+    calibration, joint, _ = conics.solve_calibration(
         track_samples(CENTRES), Site(name="lab")
     )
-    field_w, field_h = calibration.valid_mm[2:]
+    field_w, field_h = joint.field_mm
     site, placed = conics.self_defined_site(calibration, "spun")
     assert site.extent_mm == (field_w + 3000, field_h + 3000)
     assert (site.field.x, site.field.y) == (1500, 1500)
     assert site.staging.y == site.field.y_max
-    assert placed.valid_mm == (0, 0, *site.extent_mm)
+    x0, y0, x1, y1 = placed.valid_mm
+    assert (0, 0) < (x0, y0) and x1 <= site.extent_mm[0] and y1 <= site.extent_mm[1]
 
 
 def test_a_self_defined_site_must_hold_the_staging_strip_too():
-    calibration, _, _ = conics.solve_calibration(
+    calibration, joint, _ = conics.solve_calibration(
         track_samples(CENTRES), Site(name="lab")
     )
-    field_w, field_h = calibration.valid_mm[2:]
+    field_w, field_h = joint.field_mm
     with pytest.raises(ValueError, match="staging strip"):
         conics.self_defined_site(calibration, "spun", size_mm=(field_w, field_h + 600))
 
@@ -393,10 +401,9 @@ def test_a_second_station_lands_in_the_first_ones_frame():
     samples = circle_samples(STATION, CENTRES, 0) + circle_samples(
         STATION_B, CENTRES[1:], 1, start=1
     )
-    calibration, solutions, unsolved = conics.solve_calibration(
-        samples, Site(name="lab")
-    )
-    assert not unsolved and sorted(solutions) == [0, 1]
+    calibration, joint, unsolved = conics.solve_calibration(samples, Site(name="lab"))
+    assert not unsolved and sorted(joint.homographies) == [0, 1]
+    assert {s.solved_from for s in calibration.stations} == {"conics-joint"}
     P = grid(300, 300, 1700, 2600, n=8)
     a = apply(calibration.station(0).matrix, apply(FLOOR_TO_CAM, P))
     b = apply(calibration.station(1).matrix, apply(np.linalg.inv(STATION_B), P))
@@ -407,8 +414,6 @@ def test_a_station_with_too_few_circles_is_reported_not_fatal():
     samples = circle_samples(STATION, CENTRES, 0) + circle_samples(
         STATION_B, CENTRES[:2], 1
     )
-    calibration, solutions, unsolved = conics.solve_calibration(
-        samples, Site(name="lab")
-    )
-    assert sorted(solutions) == [0] and "at least 3 circles" in unsolved[1]
+    calibration, joint, unsolved = conics.solve_calibration(samples, Site(name="lab"))
+    assert sorted(joint.homographies) == [0] and "at least 3 circles" in unsolved[1]
     assert [s.index for s in calibration.stations] == [0]
diff --git a/dotbot/tests/test_calibration_lighthouse2.py b/dotbot/tests/test_calibration_lighthouse2.py
index dce3b64e..08d09790 100644
--- a/dotbot/tests/test_calibration_lighthouse2.py
+++ b/dotbot/tests/test_calibration_lighthouse2.py
@@ -1,4 +1,4 @@
-"""Tests for the LH2 calibration solve, the schema 3 file and the identity.
+"""Tests for the LH2 calibration solve, the schema 4 file and the identity.
 
 Synthetic captures are built by inverting one chosen station matrix, so the
 correspondences are exactly consistent and the solver's own error is the only
@@ -250,12 +250,12 @@ def _saved(monkeypatch, tmp_path, tag=None, **kwargs):
     return manager, manager.save_calibration(tag=tag)
 
 
-def test_save_writes_schema_3_into_the_site_directory(monkeypatch, tmp_path):
+def test_save_writes_schema_4_into_the_site_directory(monkeypatch, tmp_path):
     _, path = _saved(monkeypatch, tmp_path)
 
     assert path.parent == tmp_path / "calibrations" / "default"
     parsed = tomllib.loads(path.read_text())
-    assert parsed["schema_version"] == 3
+    assert parsed["schema_version"] == 4
     assert parsed["site"]["name"] == "default"
     assert parsed["site"]["anchor"] == ""
     assert "frame" not in parsed
@@ -322,7 +322,7 @@ def test_points_from_round_trips_through_the_file(monkeypatch, tmp_path):
 def test_points_from_written_as_a_string_is_rejected(tmp_path):
     path = tmp_path / "calibration-2026-01-01T00-00-00Z-deadbeef.toml"
     path.write_text(
-        "schema_version = 3\n[[placement]]\nindex = 0\npoints_mm = []\n"
+        "schema_version = 4\n[[placement]]\nindex = 0\npoints_mm = []\n"
         'points_from = "over dev-corner"\n',
         encoding="utf-8",
     )
@@ -357,7 +357,7 @@ def test_schema_1_file_is_rejected(tmp_path):
 def test_a_file_carrying_a_frame_table_is_rejected(tmp_path):
     path = tmp_path / "calibration-2026-01-01T00-00-00Z-deadbeef.toml"
     path.write_text(
-        'schema_version = 3\n[frame]\nname = "inria-aio-c"\n', encoding="utf-8"
+        'schema_version = 4\n[frame]\nname = "inria-aio-c"\n', encoding="utf-8"
     )
     with pytest.raises(ValueError, match=r"\[frame\] is not a table"):
         read_calibration_file(path)
@@ -686,41 +686,6 @@ def test_slug_tag_rules():
     assert lighthouse2.slug_tag("***") == ""
 
 
-# The same schema 3 fixture swarmit's test_helpers.py carries, so the two
-# packers cannot drift.
-FIXTURE_TOML = """\
-schema_version = 3
-
-[metadata]
-created_at = "2026-09-10T09:12:00Z"
-id = "3f9a1c07e2b845d6"
-robot = "dotbot-v3"
-
-[site]
-name = "inria-aio-c"
-anchor = "the arena's top-left corner, against the door wall of C405"
-
-[validity]
-valid_mm = [0, 0, 4000, 4500]
-
-[[placement]]
-index = 0
-at = "arena:corners"
-points_mm = [[50.0, 20.0], [2000.0, 20.0], [50.0, 2000.0], [2000.0, 2000.0]]
-captured_at = "2026-09-10T09:10:41Z"
-samples = [
-  { station = 0, point = 0, count1 = [41290], count2 = [51728] },
-]
-
-[[station]]
-index = 0
-solved_from = "direct"
-points = 4
-residual_mm = 0.0
-homography = [[1523.4, -38.2, 1012.7], [41.9, 1531.8, 988.3], [0.2134, -0.0871, 1.0]]
-"""
-
-
 def _wire_fixture(tmp_path):
     from dotbot.tests.lh2_wire_fixture import FIXTURE_TOML as WIRE_TOML
 
@@ -773,8 +738,8 @@ def test_a_message_carries_the_matrix_as_float32_and_the_site_fields(tmp_path):
     )
     assert struct.unpack_from("<4I", message, 44) == (0, 0, 3330, 4000)
     assert message[60:76] == b"c405-arena" + bytes(6)
-    assert message[76:84] == bytes.fromhex("19ed0cdb738cdfe5")
-    assert lighthouse2.message_site(message) == ("c405-arena", "19ed0cdb738cdfe5")
+    assert message[76:84] == bytes.fromhex("80285c9b7db82732")
+    assert lighthouse2.message_site(message) == ("c405-arena", "80285c9b7db82732")
 
 
 def test_a_gap_in_the_station_numbering_is_refused(tmp_path):
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
new file mode 100644
index 00000000..8c904eea
--- /dev/null
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -0,0 +1,449 @@
+"""Tests for several LH2 stations put in one frame from shared spins.
+
+The stations are the measured c405 one moved over the floor (see
+`lh2_multi_fixture`), so every number here is in floor millimetres.
+"""
+
+import tomllib
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from dotbot.calibration import conics
+from dotbot.calibration import multi_station as ms
+from dotbot.calibration.conics import apply, similarity
+from dotbot.calibration.lighthouse2 import (
+    TrackSample,
+    read_calibration_file,
+    render_calibration,
+    station_mask,
+)
+from dotbot.site import Site
+from dotbot.tests import lh2_multi_fixture as F
+
+HERE = Path(__file__).parent
+
+
+def two_stations():
+    a = F.station(0)
+    b = F.station(1, F.rigid(2200, 0, 0), aspect=0.9)
+    return a, b
+
+
+def floor_grid(stations, step=450, y=(300, 2800)):
+    centres = [
+        (x, yy) for x in np.arange(-200, 3500, step) for yy in np.arange(*y, 500)
+    ]
+    return [c for c in centres if any(s.sees(c) for s in stations)]
+
+
+def overlap_disagreement(joint, a, b):
+    P = np.array(
+        [
+            (x, y)
+            for x in np.arange(1300, 2000, 100)
+            for y in np.arange(800, 2200, 100)
+            if a.sees((x, y)) and b.sees((x, y))
+        ]
+    )
+    pa = apply(joint.homographies[a.index], apply(a.floor_to_cam, P))
+    pb = apply(joint.homographies[b.index], apply(b.floor_to_cam, P))
+    return np.linalg.norm(pa - pb, axis=1)
+
+
+def test_two_stations_map_the_overlap_to_the_same_points():
+    a, b = two_stations()
+    tracks = F.spins([a, b], floor_grid([a, b]), noise=1.0, seed=2)
+    joint = ms.solve_joint(tracks)
+    assert sorted(joint.homographies) == [0, 1]
+    assert overlap_disagreement(joint, a, b).max() < 1.0
+    errors = F.placed_error(joint.homographies, [a, b])
+    assert max(rms for rms, _ in errors.values()) < 2.5
+    (link,) = joint.graph.links
+    assert (link.a, link.b) == (0, 1)
+    assert link.shared >= ms.LINK_SHARED_ADVISED and ms.link_advised(link)
+    assert all(abs(r - 1) < 0.005 for r in joint.scale_ratio.values())
+
+
+def test_two_stations_noise_free_are_exact():
+    a, b = two_stations()
+    joint = ms.solve_joint(F.spins([a, b], floor_grid([a, b])))
+    assert overlap_disagreement(joint, a, b).max() < 0.05
+    errors = F.placed_error(joint.homographies, [a, b])
+    assert max(worst for _, worst in errors.values()) < 0.05
+
+
+def test_each_station_gets_its_own_rectangle_and_the_fence_is_their_union():
+    a, b = two_stations()
+    joint = ms.solve_joint(F.spins([a, b], floor_grid([a, b])))
+    ra, rb = joint.rectangles[0], joint.rectangles[1]
+    for s, rect in joint.rectangles.items():
+        centres = np.array(
+            [t.centre_mm for t in joint.solutions[s].tracks], dtype=float
+        )
+        assert rect[0] == max(0, int(np.floor(centres[:, 0].min() - 300)))
+        assert rect[2] == int(np.ceil(centres[:, 0].max() + 300))
+        assert rect[1] == max(0, int(np.floor(centres[:, 1].min() - 300)))
+    assert joint.valid_mm == (
+        min(ra[0], rb[0]),
+        min(ra[1], rb[1]),
+        max(ra[2], rb[2]),
+        max(ra[3], rb[3]),
+    )
+    # station 1 sits to the right of station 0, so its rectangle starts later
+    assert rb[0] > ra[0] + 1000
+
+
+def ring(n=5, radius=1700):
+    stations = []
+    for k in range(n):
+        a = 2 * np.pi * k / n
+        vertex = np.array([radius * np.cos(a), radius * np.sin(a)]) + 3000
+        theta = np.degrees(a) + 90
+        patch = apply(F.rigid(0, 0, theta), F.C405_PATCH[None, :])[0]
+        stations.append(
+            F.station(
+                k, F.rigid(*(vertex - patch), theta), aspect=0.9 if k % 2 else 1.0
+            )
+        )
+    return stations
+
+
+def ring_centres(stations, closed):
+    """Twelve spins per station of its own, and two 400 mm apart per overlap;
+    a chain leaves the last overlap out."""
+    n, middle = len(stations), np.mean([s.patch for s in stations], axis=0)
+    centres = []
+    for k, st in enumerate(stations):
+        out = (st.patch - middle) / np.linalg.norm(st.patch - middle)
+        side = np.array([-out[1], out[0]])
+        centres += [
+            st.patch + out * e + side * d
+            for d in (-450, -150, 150, 450)
+            for e in (0, 400, 800)
+        ]
+        if k == n - 1 and not closed:
+            continue
+        nxt = stations[(k + 1) % n].patch
+        mid = (st.patch + nxt) / 2
+        t = (nxt - st.patch) / np.linalg.norm(nxt - st.patch)
+        normal = np.array([-t[1], t[0]])
+        centres += [mid + normal * d for d in (-200, 200)]
+    if not closed:
+        centres = [
+            c for c in centres if not (stations[0].sees(c) and stations[-1].sees(c))
+        ]
+    return centres
+
+
+def drift(homographies, stations, a, b):
+    """rms mm of station b once station a alone is put on the truth."""
+    pa = F.grid_in(stations[a])
+    S = similarity(
+        apply(homographies[a], apply(stations[a].floor_to_cam, pa)), pa, scale=False
+    )
+    pb = F.grid_in(stations[b], inset=600)
+    got = apply(S @ homographies[b], apply(stations[b].floor_to_cam, pb))
+    return float(np.sqrt(np.mean(np.sum((got - pb) ** 2, axis=1))))
+
+
+def chained(tracks, order):
+    """Pairwise rigid fits composed down `order`: the seed alone."""
+    solutions = {s: conics.solve(tracks[s]) for s in order}
+    own = {
+        s: {t.key: np.array(t.centre_mm) for t in solutions[s].tracks} for s in order
+    }
+    H, world = {order[0]: solutions[order[0]].homography}, {order[0]: own[order[0]]}
+    for p, s in zip(order, order[1:]):
+        keys = sorted(set(own[s]) & set(own[p]), key=lambda k: k.name)
+        S = similarity(
+            np.array([own[s][k] for k in keys]),
+            np.array([world[p][k] for k in keys]),
+            scale=False,
+        )
+        H[s] = S @ solutions[s].homography
+        world[s] = {k: apply(S, v[None, :])[0] for k, v in own[s].items()}
+    return H
+
+
+@pytest.mark.parametrize("seed", [0, 2])
+def test_a_ring_holds_better_than_a_chain_and_beats_chaining(seed):
+    stations = ring()
+    ring_tracks = F.spins(stations, ring_centres(stations, True), noise=2.0, seed=seed)
+    chain_tracks = F.spins(
+        stations, ring_centres(stations, False), noise=2.0, seed=seed
+    )
+    closed = ms.solve_joint(ring_tracks)
+    chain = ms.solve_joint(chain_tracks)
+    assert len(closed.loops) == 1 and not chain.loops
+    assert drift(closed.homographies, stations, 0, 4) < drift(
+        chain.homographies, stations, 0, 4
+    )
+    # the joint solve closes the loop that chaining down the ring cannot
+    assert drift(closed.homographies, stations, 0, 4) < drift(
+        chained(ring_tracks, [0, 1, 2, 3, 4]), stations, 0, 4
+    )
+    assert closed.error_map.worst_mm < chain.error_map.worst_mm
+
+
+def test_an_island_is_refused_by_name_and_dropping_it_solves_the_rest():
+    a, b = two_stations()
+    far = F.station(8, F.rigid(0, 3200, 0))
+    centres = floor_grid([a, b]) + [far.patch + d for d in ((0, 0), (500, 0), (0, 500))]
+    # one robot where station 8 and station 0 both see it: a one-circle link
+    shared = ((a.patch + far.patch) / 2).tolist()
+    a.reach_mm = far.reach_mm = 1800
+    assert a.sees(shared) and far.sees(shared) and not b.sees(shared)
+    tracks = F.spins([a, b, far], centres + [shared])
+    assert {t.key for t in tracks[0]} & {t.key for t in tracks[8]}
+    with pytest.raises(ms.MultiStationError) as caught:
+        ms.solve_joint(tracks)
+    assert caught.value.islands == [8]
+    assert "station 8 (channel 9)" in str(caught.value)
+    assert "--drop-station 8" in str(caught.value)
+    assert [(k.a, k.b, k.shared) for k in caught.value.weak] == [(0, 8, 1)]
+    joint = ms.solve_joint(tracks, drop=[8])
+    assert sorted(joint.homographies) == [0, 1]
+
+
+@pytest.mark.parametrize("apart_mm", [200, 10])
+def test_shared_centres_closer_than_300_mm_are_not_a_link(apart_mm):
+    a = F.station(0)
+    b = F.station(1, F.rigid(2200, 0, 0))
+    own_a = [(500, 1000), (500, 2000), (900, 1500), (300, 1500)]
+    own_b = [(3200, 1000), (3200, 2000), (3600, 1500), (2900, 1500)]
+    tie = [(1800, 1500), (1800 + apart_mm, 1500)]
+    assert all(a.sees(c) and b.sees(c) for c in tie)
+    tracks = F.spins([a, b], own_a + own_b + tie)
+    graph = ms.station_graph(tracks)
+    (link,) = graph.links
+    assert link.shared == 2 and link.spread_mm == pytest.approx(apart_mm, abs=0.5)
+    assert not ms.link_holds(link) and graph.components == [[0], [1]]
+    with pytest.raises(ms.MultiStationError, match="station 1 \\(channel 2\\)"):
+        ms.solve_joint(tracks)
+
+
+def test_the_error_map_predicts_the_spread_of_solves():
+    """Predicted sigma against 20 noisy solves of the same floor."""
+    a, b = two_stations()
+    centres = floor_grid([a, b])
+    reference = None
+    errors = {0: [], 1: []}
+    for seed in range(20):
+        joint = ms.solve_joint(
+            F.spins([a, b], centres, noise=1.0, seed=seed, points=60)
+        )
+        if reference is None:
+            reference = joint
+            em = joint.error_map
+            rows, cols = em.sigma_mm.shape
+            cells = np.array(
+                [em.centre(r, c) for r in range(rows) for c in range(cols)]
+            )
+            cover = {
+                s: (cells[:, 0] >= r[0])
+                & (cells[:, 0] <= r[2])
+                & (cells[:, 1] >= r[1])
+                & (cells[:, 1] <= r[3])
+                for s, r in joint.rectangles.items()
+            }
+            floor = {
+                s: apply(
+                    st.cam_to_floor,
+                    apply(np.linalg.inv(joint.homographies[s]), cells[cover[s]]),
+                )
+                for s, st in ((0, a), (1, b))
+            }
+        ours = {
+            s: apply(joint.homographies[s], apply(st.floor_to_cam, floor[s]))
+            for s, st in ((0, a), (1, b))
+        }
+        S = similarity(
+            np.vstack([ours[0], ours[1]]), np.vstack([floor[0], floor[1]]), scale=False
+        )
+        for s in (0, 1):
+            errors[s].append(apply(S, ours[s]) - floor[s])
+    info = np.zeros(len(cells))
+    for s in (0, 1):
+        e = np.array(errors[s])
+        e -= e.mean(axis=0)
+        info[cover[s]] += 1 / np.mean(np.sum(e**2, axis=2), axis=0)
+    predicted = reference.error_map.sigma_mm.ravel()
+    seen = ~np.isnan(predicted) & (info > 0)
+    ratio = np.median(predicted[seen] / (1 / np.sqrt(info[seen])))
+    assert 1 / 1.5 < ratio < 1.5
+    assert reference.error_map.cells_over_10mm == 0
+    assert reference.error_map.worst_mm == pytest.approx(np.nanmax(predicted))
+
+
+def test_the_error_map_grows_away_from_the_spins():
+    a, b = two_stations()
+    joint = ms.solve_joint(F.spins([a, b], floor_grid([a, b]), noise=1.0, seed=4))
+    em = joint.error_map
+    centres = np.array([v for v in joint.centres.values()])
+    rows, cols = em.sigma_mm.shape
+    near, far = [], []
+    for r in range(rows):
+        for c in range(cols):
+            if np.isnan(em.sigma_mm[r, c]):
+                continue
+            d = np.min(np.linalg.norm(centres - np.array(em.centre(r, c)), axis=1))
+            (near if d < 150 else far if d > 400 else []).append(em.sigma_mm[r, c])
+    assert np.median(far) > np.median(near)
+
+
+def test_a_circle_the_stations_disagree_on_is_untied():
+    a, b = two_stations()
+    centres = floor_grid([a, b], step=300)
+    tracks = F.spins([a, b], centres, noise=0.5, seed=1)
+    shared = sorted(
+        {t.key for t in tracks[0]} & {t.key for t in tracks[1]}, key=lambda k: k.name
+    )
+    assert len(shared) >= 6
+    bad = shared[len(shared) // 2]
+    # station 1 saw that robot's circle 25 mm away from where it was
+    for t in tracks[1]:
+        if t.key == bad:
+            floor = apply(b.cam_to_floor, t.points) + [25.0, 0.0]
+            t.points = apply(b.floor_to_cam, floor)
+    joint = ms.solve_joint(tracks)
+    assert list(joint.dropped) == [bad]
+    assert "mm apart" in joint.dropped[bad]
+    assert overlap_disagreement(joint, a, b).max() < 1.0
+
+
+def test_a_single_station_is_solved_as_free_mode_solves_it():
+    a = F.station(0)
+    tracks = F.spins([a], floor_grid([a]), noise=0.5, seed=3)
+    joint = ms.solve_joint(tracks)
+    own = conics.solve(tracks[0])
+    assert np.array_equal(joint.homographies[0], own.homography / own.homography[2, 2])
+    assert joint.field_mm == own.field_mm
+    assert not joint.graph.links and joint.error_map.covered > 0
+
+
+def real_spin_samples():
+    data = tomllib.loads((HERE / "lh2_spin_c405.toml").read_text())
+    samples = [
+        TrackSample(
+            station=t["station"],
+            name=t["name"],
+            radius_mm=t["radius_mm"],
+            turn=t["turn"],
+            count1=t["count1"],
+            count2=t["count2"],
+        )
+        for t in data["track"]
+    ]
+    return data, samples
+
+
+def test_a_real_single_station_calibration_solves_as_before():
+    data, samples = real_spin_samples()
+    calibration, joint, unsolved = conics.solve_calibration(samples, Site(name="lab"))
+    assert not unsolved
+    (station,) = calibration.stations
+    assert station.solved_from == "conics-free"
+    expected = np.array(data["expected_homography"])
+    cams = np.vstack([s.camera_points() for s in samples])
+    moved = np.linalg.norm(apply(expected, cams) - apply(station.matrix, cams), axis=1)
+    assert moved.max() < 0.1
+    assert list(joint.field_mm) == data["expected_field_mm"]
+    assert calibration.valid_mm == station.valid_mm
+    assert joint.error_map.worst_mm < 10
+
+
+def test_stations_2_and_8_are_written_as_schema_4(tmp_path):
+    two = F.station(2)
+    eight = F.station(8, F.rigid(2200, 0, 0), aspect=0.9)
+    samples = F.samples(F.spins([two, eight], floor_grid([two, eight])))
+    calibration, joint, _ = conics.solve_calibration(samples, Site(name="arena"))
+    assert [s.index for s in calibration.stations] == [2, 8]
+    assert {s.solved_from for s in calibration.stations} == {"conics-joint"}
+    assert station_mask(calibration) == 0x0104
+    assert [(k.a, k.b) for k in calibration.links] == [(2, 8)]
+    path = tmp_path / "cal.toml"
+    path.write_text(render_calibration(calibration), encoding="utf-8")
+    back = read_calibration_file(path)
+    assert back.id == calibration.id == back.stored_id
+    assert back.links == calibration.links
+    assert [s.valid_mm for s in back.stations] == [
+        joint.rectangles[2],
+        joint.rectangles[8],
+    ]
+    assert back.valid_mm == joint.valid_mm
+
+
+def test_circles_are_keyed_by_robot_and_round():
+    a, b = two_stations()
+    first = F.spins([a, b], floor_grid([a, b])[::2], names=None)
+    # the same robots, moved, in a second round
+    second = F.spins([a, b], floor_grid([a, b])[1::2], round_=1)
+    tracks = {s: first.get(s, []) + second.get(s, []) for s in (0, 1)}
+    names = {t.name for t in tracks[0]}
+    assert any(n in {t.name for t in second[0]} for n in names)
+    joint = ms.solve_joint(tracks)
+    keys = set(joint.centres)
+    assert {k.round for k in keys} == {0, 1}
+    same_name = [k for k in keys if k.round == 1 and ms.CircleKey(k.name, 0) in keys]
+    assert same_name
+    for k in same_name:
+        assert (
+            np.linalg.norm(joint.centres[k] - joint.centres[ms.CircleKey(k.name, 0)])
+            > 100
+        )
+    samples = F.samples(tracks)
+    calibration, _, _ = conics.solve_calibration(samples, Site(name="arena"))
+    assert sorted({t.round for t in calibration.tracks}) == [0, 1]
+
+
+def test_a_schema_3_file_is_refused(tmp_path):
+    path = tmp_path / "cal.toml"
+    path.write_text("schema_version = 3\n", encoding="utf-8")
+    with pytest.raises(
+        ValueError, match="schema_version 3.*collect the calibration again"
+    ):
+        read_calibration_file(path)
+
+
+def test_the_report_names_stations_links_and_the_error_map(tmp_path):
+    a, b = two_stations()
+    samples = F.samples(F.spins([a, b], floor_grid([a, b]), noise=0.5, seed=5))
+    calibration, joint, _ = conics.solve_calibration(samples, Site(name="arena"))
+    live = ms.multi_station_report(calibration, joint)
+    text = "\n".join(live)
+    assert "station 0 (channel 1)" in text and "station 1 (channel 2)" in text
+    assert "station 0 (channel 1) - station 1 (channel 2):" in text
+    assert "predicted error (100 mm cells): worst" in text
+    path = tmp_path / "cal.toml"
+    path.write_text(render_calibration(calibration), encoding="utf-8")
+    offline = ms.multi_station_report(read_calibration_file(path))
+    assert any(line.startswith("predicted error") for line in offline)
+    assert any(" - station 1 (channel 2):" in line for line in offline)
+
+
+def test_the_file_rules_are_enforced(tmp_path):
+    a, b = two_stations()
+    samples = F.samples(F.spins([a, b], floor_grid([a, b])))
+    calibration, _, _ = conics.solve_calibration(samples, Site(name="arena"))
+    text = render_calibration(calibration)
+    path = tmp_path / "cal.toml"
+    cases = {
+        "not the union": text.replace(
+            f"valid_mm = [{', '.join(map(str, calibration.valid_mm))}]",
+            "valid_mm = [0, 0, 10, 10]",
+            1,
+        ),
+        "no \\[\\[link\\]\\]": text[: text.index("[[link]]")],
+        "has no valid_mm": text.replace(
+            "valid_mm = ["
+            + ", ".join(map(str, calibration.stations[1].valid_mm))
+            + "]\n",
+            "",
+        ),
+    }
+    for match, broken in cases.items():
+        path.write_text(broken, encoding="utf-8")
+        with pytest.raises(ValueError, match=match):
+            read_calibration_file(path)
diff --git a/dotbot/tests/test_calibration_push.py b/dotbot/tests/test_calibration_push.py
index b4a34f59..afa020f5 100644
--- a/dotbot/tests/test_calibration_push.py
+++ b/dotbot/tests/test_calibration_push.py
@@ -157,7 +157,7 @@ def test_push_sends_the_messages_and_lists_the_worklist(monkeypatch, calibration
     # Device info is read once for the gate and never polled after the push.
     assert fleet.refreshed == [None]
     assert "2 robot(s) hold another id" in result.output
-    assert "Still not on 19ed0cdb (1), push again: LAGGARD" in result.output
+    assert "Still not on 80285c9b (1), push again: LAGGARD" in result.output
 
 
 def test_a_push_checked_for_named_robots_goes_to_exactly_them(calibration_file):
@@ -193,7 +193,7 @@ def test_push_to_another_site_is_refused_without_site_changed(
     moved = _push(monkeypatch, fleet, str(calibration_file), "--site-changed")
     assert moved.exit_code == 0, moved.output
     assert len(fleet.pushed) == 1
-    assert "Every robot reports 19ed0cdb." in moved.output
+    assert "Every robot reports 80285c9b." in moved.output
 
 
 @pytest.mark.parametrize("version", [1, 2])
diff --git a/dotbot/tests/test_calibration_session.py b/dotbot/tests/test_calibration_session.py
index 5cbe1cde..f2e58ca7 100644
--- a/dotbot/tests/test_calibration_session.py
+++ b/dotbot/tests/test_calibration_session.py
@@ -443,7 +443,7 @@ async def test_four_points_carry_a_residual_per_station_and_no_expected_error(
 
 
 @pytest.mark.asyncio
-async def test_save_writes_a_schema_3_file_under_the_site_directory(
+async def test_save_writes_a_schema_4_file_under_the_site_directory(
     monkeypatch, tmp_path
 ):
     monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path)
@@ -456,7 +456,7 @@ async def test_save_writes_a_schema_3_file_under_the_site_directory(
     path = tmp_path / "calibrations" / "c405-arena" / saved["path"].split("/")[-1]
     assert path.exists()
     body = path.read_text(encoding="utf-8")
-    assert "schema_version = 3" in body
+    assert "schema_version = 4" in body
     assert f'id = "{saved["id"]}"' in body
     assert saved["id8"] == saved["id"][:8]
 
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index 4f8a4c58..a780107d 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -30,6 +30,7 @@
 from dotbot.robots import robot_geometry
 from dotbot.site import Site
 from dotbot.site_packs import site_catalog
+from dotbot.tests import lh2_multi_fixture as M
 from dotbot.tests.test_calibration_conics import (
     CENTRES,
     FLOOR_TO_CAM,
@@ -464,3 +465,63 @@ def test_after_site_init_the_tag_still_names_the_spin_calibration(monkeypatch, l
         assert result.exit_code == 0, result.output
     placed = load_calibration("floor-spun", site=site_catalog(lab)["spun"].site())
     assert placed.site.name == "spun"
+
+
+# --- collect --spin with several stations ------------------------------------
+
+
+def _two_stations():
+    return M.station(0), M.station(1, M.rigid(2200, 0, 0), aspect=0.9)
+
+
+def _floor_grid(stations):
+    centres = [(x, y) for x in range(-200, 3500, 450) for y in range(300, 2800, 500)]
+    return [c for c in centres if any(s.sees(c) for s in stations)]
+
+
+def _two_station_fleet(stations, centres):
+    """Robots whose spins carry every station that sees them, station by station."""
+    addrs = [f"{0xA0 + i:02X}" * 8 for i in range(len(centres))]
+    events = {}
+    for i, (addr, centre) in enumerate(zip(addrs, centres)):
+        records = []
+        for st in stations:
+            if not st.sees(centre):
+                continue
+            for x, y in conics.apply(st.floor_to_cam, M.circle(centre, n=200)):
+                c = counts_for_camera_point(x, y, st.index)
+                records.append((st.index, round(c.count1), round(c.count2)))
+        events[addr] = payloads(records, run=i)
+    return addrs, _SpinFleet({a: _node() for a in addrs}, events)
+
+
+def test_collect_spin_solves_two_stations_and_prints_the_report(monkeypatch, lab):
+    a, b = _two_stations()
+    centres = _floor_grid([a, b])[:40]
+    _, fleet = _two_station_fleet([a, b], centres)
+    result = _collect(monkeypatch, lab, fleet)
+    assert result.exit_code == 0, result.output
+    assert "station 0 (channel 1) - station 1 (channel 2):" in result.output
+    assert "predicted error (100 mm cells)" in result.output
+    path = Path(re.search(r"Calibration saved to (\S+)", result.output).group(1))
+    saved = lighthouse2.read_calibration_file(path)
+    assert [s.index for s in saved.stations] == [0, 1]
+    assert [(k.a, k.b) for k in saved.links] == [(0, 1)]
+
+
+def test_collect_spin_refuses_an_island_until_it_is_dropped(monkeypatch, lab):
+    a, b = _two_stations()
+    far = M.station(8, M.rigid(0, 6000, 0))
+    centres = _floor_grid([a, b])[:30] + [
+        tuple(far.patch + d) for d in ((0, 0), (500, 0), (0, 500), (-400, -300))
+    ]
+    _, fleet = _two_station_fleet([a, b, far], centres)
+    result = _collect(monkeypatch, lab, fleet)
+    assert result.exit_code != 0
+    assert "station 8 (channel 9) is not tied to the others" in result.output
+    assert "no calibration written" in result.output
+    _, fleet = _two_station_fleet([a, b, far], centres)
+    result = _collect(monkeypatch, lab, fleet, "--drop-station", "8")
+    assert result.exit_code == 0, result.output
+    path = Path(re.search(r"Calibration saved to (\S+)", result.output).group(1))
+    assert [s.index for s in lighthouse2.read_calibration_file(path).stations] == [0, 1]
diff --git a/dotbot/tests/test_device.py b/dotbot/tests/test_device.py
index 7f41bef7..769d0903 100644
--- a/dotbot/tests/test_device.py
+++ b/dotbot/tests/test_device.py
@@ -556,7 +556,7 @@ def test_the_sandbox_page_with_a_calibration_is_pinned(tmp_path):
         "0000803f0008b9c40000484100603845"
     )
     assert hashlib.sha256(page).hexdigest() == (
-        "65c41c8b838212f248fef6311e28e2fcae51a7e65b0289231f525371c710c94c"
+        "b1d492d3b8021d16976e5f49a984374655fada7df62e13b35bf9e4e351d6e530"
     )
     # Station 1 in slot 1, the fourteen unused slots erased, then the site
     # fields exactly as the calibration message carries them.

From 8abd0e535be6a6551fcdd4a05b6379078ffbd5df Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:54:46 +0200
Subject: [PATCH 12/80] dotbot/calibration: build the joint solve's normal
 equations block by block

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/multi_station.py           | 76 +++++++++++++------
 .../tests/test_calibration_multi_station.py   | 33 ++++++++
 2 files changed, 85 insertions(+), 24 deletions(-)

diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index 52f3d374..f5d4e9d6 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -415,6 +415,13 @@ def _h_matrix(p: np.ndarray) -> np.ndarray:
     return np.array([[p[0], p[1], p[2]], [p[3], p[4], p[5]], [p[6], p[7], 1.0]])
 
 
+def _map(p: np.ndarray, q: np.ndarray) -> np.ndarray:
+    """H(q) for the 8 parameters `p`."""
+    qx, qy = q[:, 0], q[:, 1]
+    w = p[6] * qx + p[7] * qy + 1.0
+    return np.c_[(p[0] * qx + p[1] * qy + p[2]) / w, (p[3] * qx + p[4] * qy + p[5]) / w]
+
+
 def _map_jacobian(p: np.ndarray, q: np.ndarray):
     """H(q) for the 8 parameters `p`, and its derivative, (n, 2, 8)."""
     qx, qy = q[:, 0], q[:, 1]
@@ -457,30 +464,52 @@ def unpack(self, x: np.ndarray):
         C = {c: x[col : col + 2].copy() for c, col in self.c_col.items()}
         return H, C
 
-    def residuals(self, x: np.ndarray, jacobian: bool = True, prior: bool = True):
-        rows_r, rows_J = [], []
+    def residuals(self, x: np.ndarray, prior: bool = True) -> np.ndarray:
+        """The radial residual of every read, in block order, then the prior's."""
+        rows = []
+        for s, cid, q, radius in self.blocks:
+            sc, cc = self.s_col[s], self.c_col[cid]
+            uv = _map(x[sc : sc + 8], q)
+            rows.append(np.linalg.norm(uv - x[cc : cc + 2], axis=1) - radius)
+        if prior:
+            for cid, target in self.prior.items():
+                cc = self.c_col[cid]
+                rows.append(GAUGE_PRIOR_WEIGHT * (x[cc : cc + 2] - target))
+        return np.concatenate(rows)
+
+    def normal(
+        self, x: np.ndarray, w: np.ndarray, prior: bool = True
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """`J.T W² J` and `J.T W² r` for the row weights `w`, block by block.
+
+        Each read touches its station's 8 parameters and its centre's 2, so
+        the Jacobian is never formed whole.
+        """
+        A = np.zeros((self.n, self.n))
+        g = np.zeros(self.n)
+        row = 0
         for s, cid, q, radius in self.blocks:
             sc, cc = self.s_col[s], self.c_col[cid]
             uv, G = _map_jacobian(x[sc : sc + 8], q)
             d = uv - x[cc : cc + 2]
             rho = np.linalg.norm(d, axis=1)
             e = d / np.maximum(rho, 1e-12)[:, None]
-            rows_r.append(rho - radius)
-            if jacobian:
-                J = np.zeros((len(q), self.n))
-                J[:, sc : sc + 8] = np.einsum("ni,nij->nj", e, G)
-                J[:, cc : cc + 2] = -e
-                rows_J.append(J)
+            wb = w[row : row + len(q), None]
+            row += len(q)
+            J = np.empty((len(q), 10))
+            J[:, :8] = np.einsum("ni,nij->nj", e, G)
+            J[:, 8:] = -e
+            J *= wb
+            idx = np.r_[sc : sc + 8, cc : cc + 2]
+            A[np.ix_(idx, idx)] += J.T @ J
+            g[idx] += J.T @ ((rho - radius) * wb[:, 0])
         if prior:
             for cid, target in self.prior.items():
                 cc = self.c_col[cid]
-                rows_r.append(GAUGE_PRIOR_WEIGHT * (x[cc : cc + 2] - target))
-                if jacobian:
-                    J = np.zeros((2, self.n))
-                    J[0, cc] = J[1, cc + 1] = GAUGE_PRIOR_WEIGHT
-                    rows_J.append(J)
-        r = np.concatenate(rows_r)
-        return (r, np.vstack(rows_J)) if jacobian else r
+                A[cc, cc] += GAUGE_PRIOR_WEIGHT**2
+                A[cc + 1, cc + 1] += GAUGE_PRIOR_WEIGHT**2
+                g[cc : cc + 2] += GAUGE_PRIOR_WEIGHT**2 * (x[cc : cc + 2] - target)
+        return A, g
 
     def read_rows(self) -> int:
         return sum(len(b[2]) for b in self.blocks)
@@ -497,14 +526,12 @@ def _refine(problem: _Problem, x0: np.ndarray) -> np.ndarray:
     """Levenberg-Marquardt on the Huber-weighted residuals, Marquardt scaling."""
     reads = problem.read_rows()
     x = x0.copy()
-    r, J = problem.residuals(x)
+    r = problem.residuals(x)
     w = _huber(r, reads)
+    A, g = problem.normal(x, w)
     cost = float(np.sum((w * r) ** 2))
     lam = 1e-3
     for _ in range(JOINT_ITERATIONS):
-        Jw, rw = J * w[:, None], r * w
-        A = Jw.T @ Jw
-        g = Jw.T @ rw
         D = np.diag(A).copy()
         D[D <= 0] = 1e-12
         improved = False
@@ -514,13 +541,14 @@ def _refine(problem: _Problem, x0: np.ndarray) -> np.ndarray:
             except np.linalg.LinAlgError:
                 lam *= 10
                 continue
-            r_new = problem.residuals(x + dx, jacobian=False)
+            r_new = problem.residuals(x + dx)
             cost_new = float(np.sum((w * r_new) ** 2))
             if np.isfinite(cost_new) and cost_new < cost:
                 gain = cost - cost_new
                 x = x + dx
-                r, J = problem.residuals(x)
+                r = problem.residuals(x)
                 w = _huber(r, reads)
+                A, g = problem.normal(x, w)
                 cost = float(np.sum((w * r) ** 2))
                 lam = max(lam / 10, 1e-12)
                 improved = gain > 1e-12 * max(cost, 1e-12)
@@ -538,10 +566,10 @@ def _covariance(problem: _Problem, x: np.ndarray) -> np.ndarray:
     unit diagonal, loses its 3 smallest eigen-directions (the gauge), is
     inverted, and is scaled by the residual variance.
     """
-    r, J = problem.residuals(x, prior=False)
+    r = problem.residuals(x, prior=False)
     w = _huber(r, problem.read_rows())
-    Jw, rw = J * w[:, None], r * w
-    A = Jw.T @ Jw
+    A, _ = problem.normal(x, w, prior=False)
+    rw = r * w
     d = np.sqrt(np.maximum(np.diag(A), 1e-30))
     As = A / np.outer(d, d)
     vals, vecs = np.linalg.eigh(As)
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
index 8c904eea..b60be433 100644
--- a/dotbot/tests/test_calibration_multi_station.py
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -313,6 +313,39 @@ def test_a_circle_the_stations_disagree_on_is_untied():
     assert overlap_disagreement(joint, a, b).max() < 1.0
 
 
+def test_the_normal_equations_match_the_whole_jacobian():
+    a, b = two_stations()
+    tracks = F.spins([a, b], floor_grid([a, b]), noise=1.0, seed=6, points=40)
+    joint = ms.solve_joint(tracks)
+    kept = {
+        s: [t for t in tracks[s] if t.key in {f.key for f in sol.tracks}]
+        for s, sol in joint.solutions.items()
+    }
+    world = {
+        s: {t.key: np.array(t.centre_mm) for t in sol.tracks}
+        for s, sol in joint.solutions.items()
+    }
+    tied = {}
+    for s, centres in world.items():
+        for k in centres:
+            tied.setdefault(k, set()).add(s)
+    problem, x = ms._build_problem(kept, world, tied, joint.homographies, 0)
+    w = np.random.default_rng(0).uniform(0.5, 1.5, len(problem.residuals(x)))
+    step = 1e-6 * np.maximum(np.abs(x), 1e-3)
+    J = np.column_stack(
+        [
+            (problem.residuals(x + dx) - problem.residuals(x - dx)) / (2 * dx[i])
+            for i, dx in enumerate(np.diag(step))
+        ]
+    )
+    A, g = problem.normal(x, w)
+    Jw = J * w[:, None]
+    assert np.allclose(A, Jw.T @ Jw, rtol=1e-4, atol=1e-6 * np.abs(A).max())
+    assert np.allclose(
+        g, Jw.T @ (w * problem.residuals(x)), rtol=1e-4, atol=1e-6 * np.abs(g).max()
+    )
+
+
 def test_a_single_station_is_solved_as_free_mode_solves_it():
     a = F.station(0)
     tracks = F.spins([a], floor_grid([a]), noise=0.5, seed=3)

From 56a592f7b802b5796abcbb92b7caea5483be5a94 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:54:51 +0200
Subject: [PATCH 13/80] dotbot/calibration: re-solve after the last round of
 untied circles

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/multi_station.py           | 12 ++++----
 .../tests/test_calibration_multi_station.py   | 30 +++++++++++--------
 2 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index f5d4e9d6..86b013b4 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -808,7 +808,7 @@ def solve_joint(
     H, C = dict(H0), {}
     problem = None
     x = None
-    for _ in range(TIE_ROUNDS_MAX):
+    for tie_round in range(TIE_ROUNDS_MAX + 1):
         problem, x0 = _build_problem(kept, world, tied, H, root)
         x = _refine(problem, x0)
         H, C = problem.unpack(x)
@@ -816,6 +816,8 @@ def solve_joint(
             s: {t.key: _circle_fit(apply(H[s], t.points))[0] for t in kept[s]}
             for s in kept
         }
+        if tie_round == TIE_ROUNDS_MAX:
+            break
         untie = _gate_ties(per_station, tied)
         if not untie:
             break
@@ -823,13 +825,11 @@ def solve_joint(
             dropped[k] = why
             tied[k] = set()
         world = per_station
-    per_station = {
-        s: {t.key: _circle_fit(apply(H[s], t.points))[0] for t in kept[s]} for s in kept
-    }
     graph_after = _graph_from_centres(per_station, tied)
-    islands = [s for s in sorted(kept) if s not in graph_after.components[0]]
+    main_after = next(c for c in graph_after.components if root in c)
+    islands = [s for s in sorted(kept) if s not in main_after]
     if islands:
-        message, weak = _island_message(islands, graph_after.components[0], graph_after)
+        message, weak = _island_message(islands, main_after, graph_after)
         raise MultiStationError(
             "after untying the circles the stations disagree on:\n" + message,
             islands=islands,
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
index b60be433..088a725f 100644
--- a/dotbot/tests/test_calibration_multi_station.py
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -293,8 +293,8 @@ def test_the_error_map_grows_away_from_the_spins():
     assert np.median(far) > np.median(near)
 
 
-def test_a_circle_the_stations_disagree_on_is_untied():
-    a, b = two_stations()
+def one_bad_circle(a, b):
+    """Tracks of two stations where station 1 saw one shared circle 25 mm off."""
     centres = floor_grid([a, b], step=300)
     tracks = F.spins([a, b], centres, noise=0.5, seed=1)
     shared = sorted(
@@ -302,17 +302,31 @@ def test_a_circle_the_stations_disagree_on_is_untied():
     )
     assert len(shared) >= 6
     bad = shared[len(shared) // 2]
-    # station 1 saw that robot's circle 25 mm away from where it was
     for t in tracks[1]:
         if t.key == bad:
             floor = apply(b.cam_to_floor, t.points) + [25.0, 0.0]
             t.points = apply(b.floor_to_cam, floor)
+    return tracks, bad
+
+
+def test_a_circle_the_stations_disagree_on_is_untied():
+    a, b = two_stations()
+    tracks, bad = one_bad_circle(a, b)
     joint = ms.solve_joint(tracks)
     assert list(joint.dropped) == [bad]
     assert "mm apart" in joint.dropped[bad]
     assert overlap_disagreement(joint, a, b).max() < 1.0
 
 
+def test_a_circle_untied_in_the_last_round_is_out_of_the_solve(monkeypatch):
+    monkeypatch.setattr(ms, "TIE_ROUNDS_MAX", 1)
+    a, b = two_stations()
+    tracks, bad = one_bad_circle(a, b)
+    joint = ms.solve_joint(tracks)
+    assert list(joint.dropped) == [bad]
+    assert overlap_disagreement(joint, a, b).max() < 1.0
+
+
 def test_the_normal_equations_match_the_whole_jacobian():
     a, b = two_stations()
     tracks = F.spins([a, b], floor_grid([a, b]), noise=1.0, seed=6, points=40)
@@ -346,16 +360,6 @@ def test_the_normal_equations_match_the_whole_jacobian():
     )
 
 
-def test_a_single_station_is_solved_as_free_mode_solves_it():
-    a = F.station(0)
-    tracks = F.spins([a], floor_grid([a]), noise=0.5, seed=3)
-    joint = ms.solve_joint(tracks)
-    own = conics.solve(tracks[0])
-    assert np.array_equal(joint.homographies[0], own.homography / own.homography[2, 2])
-    assert joint.field_mm == own.field_mm
-    assert not joint.graph.links and joint.error_map.covered > 0
-
-
 def real_spin_samples():
     data = tomllib.loads((HERE / "lh2_spin_c405.toml").read_text())
     samples = [

From 1c35c099fe14a17f28d9b2c4e9eb95b24eaf3794 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:54:51 +0200
Subject: [PATCH 14/80] dotbot/calibration: floor the centre noise behind a
 link's yaw sigma

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/multi_station.py           | 12 ++++++----
 .../tests/test_calibration_multi_station.py   | 24 +++++++++++++++++++
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index 86b013b4..091b70bf 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -71,8 +71,10 @@
 # Largest share a station's own scale may differ from the joint one.
 SCALE_RATIO_TOLERANCE = 0.02
 # A tied circle whose station centres are further apart than this many
-# times the typical disagreement is untied; the scale has this floor.
+# times the typical disagreement is untied.
 TIE_GATE_SIGMAS = 3.0
+# Least per-axis centre disagreement the tie gate and a link's yaw sigma
+# assume, mm: a fit to two or three circles leaves almost none to measure.
 TIE_SIGMA_FLOOR_MM = 1.0
 # Tied circles needed before the typical disagreement means anything.
 TIE_GATE_MIN = 4
@@ -209,15 +211,17 @@ def _spread(points: np.ndarray) -> float:
 def _tie_stats(pa: np.ndarray, pb: np.ndarray) -> tuple[float, float]:
     """rms distance between paired centres, and the relative yaw it leaves.
 
-    The yaw sigma is that of a rigid fit on the pairs: per-axis noise over
-    the root of the centres' second moment about their mean.
+    The yaw sigma is that of a rigid fit on the pairs: per-axis noise, at
+    least `TIE_SIGMA_FLOOR_MM`, over the root of the centres' second moment
+    about their mean.
     """
     d = np.linalg.norm(pa - pb, axis=1)
     rms = float(np.sqrt(np.mean(d**2)))
     moment = float(np.sum((pa - pa.mean(axis=0)) ** 2))
     if len(pa) < 2 or moment <= 0:
         return rms, math.inf
-    return rms, 1000.0 * (rms / math.sqrt(2)) / math.sqrt(moment)
+    sigma = max(rms / math.sqrt(2), TIE_SIGMA_FLOOR_MM)
+    return rms, 1000.0 * sigma / math.sqrt(moment)
 
 
 def _components(
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
index 088a725f..1ee557ff 100644
--- a/dotbot/tests/test_calibration_multi_station.py
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -360,6 +360,30 @@ def test_the_normal_equations_match_the_whole_jacobian():
     )
 
 
+def test_a_two_circle_link_claims_no_better_yaw_than_its_baseline_allows():
+    a = F.station(0)
+    b = F.station(1, F.rigid(2200, 0, 0))
+    own_a = [(500, 1000), (500, 2000), (900, 1500), (300, 1500)]
+    own_b = [(3200, 1000), (3200, 2000), (3600, 1500), (2900, 1500)]
+    tie = [(1700, 1500), (2100, 1500)]
+    joint = ms.solve_joint(F.spins([a, b], own_a + own_b + tie))
+    (link,) = joint.graph.links
+    assert link.shared == 2 and link.disagreement_mm < 0.1
+    # sqrt(2) sigma / L with sigma at its floor: noise-free fits measure none
+    floor = 1000 * np.sqrt(2) * ms.TIE_SIGMA_FLOOR_MM / link.spread_mm
+    assert link.yaw_sigma_mrad == pytest.approx(floor, rel=0.01)
+
+
+def test_a_single_station_is_solved_as_free_mode_solves_it():
+    a = F.station(0)
+    tracks = F.spins([a], floor_grid([a]), noise=0.5, seed=3)
+    joint = ms.solve_joint(tracks)
+    own = conics.solve(tracks[0])
+    assert np.array_equal(joint.homographies[0], own.homography / own.homography[2, 2])
+    assert joint.field_mm == own.field_mm
+    assert not joint.graph.links and joint.error_map.covered > 0
+
+
 def real_spin_samples():
     data = tomllib.loads((HERE / "lh2_spin_c405.toml").read_text())
     samples = [

From c69f9649b474228f71842bb8741ae5ad3c8b73a6 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:55:06 +0200
Subject: [PATCH 15/80] dotbot/calibration: say what a lone station's solve is,
 not how it was

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/multi_station.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index 091b70bf..ebb1d3da 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -712,7 +712,7 @@ def _single(
     rect_margin_mm: int,
     unsolved: dict[int, str],
 ) -> JointSolution:
-    """One station: free mode's own answer, so a lone station is solved as before."""
+    """One station, exactly as `conics.solve` solves it."""
     H = solution.homography / solution.homography[2, 2]
     kept_names = {t.key for t in solution.tracks}
     kept = [t for t in tracks if t.key in kept_names]

From 783872506908bf2675b619cb9d7218ef124bf8c8 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:01:21 +0200
Subject: [PATCH 16/80] dotbot/calibration: key spins by collection round, find
 a calibration's next round

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/multi_station.py | 27 ++++++++++++++++++++++++++-
 dotbot/calibration/spin.py          |  6 ++++--
 2 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index ebb1d3da..15858573 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -1028,6 +1028,28 @@ def error_map_from_calibration(
     return _error_map(problem, x, rectangles, cell_mm)
 
 
+def appendable_rounds(calibration: Calibration) -> int:
+    """The round a new collection appended to `calibration` takes.
+
+    Refused unless it is a free-mode spin calibration: a placed or corner
+    calibration is in a frame a re-solve would not keep.
+    """
+    # pylint: disable=import-outside-toplevel
+    from dotbot.calibration.conics import FREE_FRAME_ANCHOR
+
+    if (
+        not calibration.tracks
+        or calibration.site.anchor != FREE_FRAME_ANCHOR
+        or not all(st.solved_from.startswith("conics") for st in calibration.stations)
+    ):
+        raise ValueError(
+            f"calibration {calibration.id8} is not a free-mode spin calibration, "
+            "so a round cannot be appended to it; append to the spin calibration "
+            "it was made from"
+        )
+    return max(t.round for t in calibration.tracks) + 1
+
+
 # --- Report -----------------------------------------------------------------
 
 
@@ -1088,9 +1110,12 @@ def multi_station_report(
             sol = joint.solutions[st.index]
             kept = f"{len(sol.tracks)} kept, {len(sol.dropped)} dropped circles"
             scale = f", scale {joint.scale_ratio.get(st.index, 1.0):.3f}"
-        else:
+        elif st.solved_from.startswith("conics"):
             kept = f"{circles.get(st.index, 0)} circles"
             scale = ""
+        else:
+            kept = f"{st.points} marked points"
+            scale = ""
         lines.append(
             f"  {station_label(st.index)}: {kept}, rms {st.residual_mm:.1f} mm, "
             f"rectangle {rect}{scale}"
diff --git a/dotbot/calibration/spin.py b/dotbot/calibration/spin.py
index 3531c8ea..16a0f64b 100644
--- a/dotbot/calibration/spin.py
+++ b/dotbot/calibration/spin.py
@@ -80,8 +80,9 @@ def reads(self) -> list[LH2CalibrationSample]:
         """The records of every chunk received, in order; a lost chunk is a gap."""
         return [r for k in sorted(self.received) for r in self.received[k]]
 
-    def samples(self, radius_mm: float) -> list[TrackSample]:
-        """One counter clockwise track per station, as raw counts."""
+    def samples(self, radius_mm: float, round_: int = 0) -> list[TrackSample]:
+        """One counter clockwise track per station, as raw counts, of
+        collection round `round_`."""
         by_station: dict[int, list[LH2CalibrationSample]] = {}
         for record in self.reads():
             if not _is_impossible(record):
@@ -94,6 +95,7 @@ def samples(self, radius_mm: float) -> list[TrackSample]:
                 turn=1,
                 count1=[r.count1 for r in records],
                 count2=[r.count2 for r in records],
+                round=round_,
             )
             for station, records in sorted(by_station.items())
         ]

From 2f1556313a2f9c4dcde35030e5e3a06d2eb4a612 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:01:21 +0200
Subject: [PATCH 17/80] dotbot/cli: add calibrate-lh2 show and collect --spin
 --append

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/swarm_lh2.py               | 108 ++++++++++++++++++++++++--
 dotbot/tests/test_calibration_spin.py |  75 ++++++++++++++++++
 2 files changed, 177 insertions(+), 6 deletions(-)

diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 6364a965..c1c13064 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -319,6 +319,18 @@ def _await_point(session, stream, arrivals: queue.Queue):
         "shared circles, which otherwise stops the solve."
     ),
 )
+@click.option(
+    "--append",
+    "append",
+    default=None,
+    metavar="CALIBRATION",
+    help=(
+        "With --spin: collect another round onto a saved spin calibration "
+        "(a path, its tag or its id prefix) and solve both rounds together; "
+        "saved as a new file, the old one kept. For a station not yet tied "
+        "to the others, or a weak tie the report names."
+    ),
+)
 @click.pass_context
 def _collect(
     ctx,
@@ -337,6 +349,7 @@ def _collect(
     spin,
     spin_radius,
     drop_stations,
+    append,
 ):
     if spin:
         given = [
@@ -357,13 +370,23 @@ def _collect(
                 f"--spin takes no {', '.join(given)}: the robots spin where they stand"
             )
         _collect_spin(
-            ctx, conn, swarm_id, site_name, tag, push, spin_radius, drop_stations
+            ctx,
+            conn,
+            swarm_id,
+            site_name,
+            tag,
+            push,
+            spin_radius,
+            drop_stations,
+            append,
         )
         return
     if spin_radius is not None:
         raise click.UsageError("--spin-radius goes with --spin")
     if drop_stations:
         raise click.UsageError("--drop-station goes with --spin")
+    if append is not None:
+        raise click.UsageError("--append goes with --spin")
     if _devices(ctx):
         raise click.UsageError(
             "`dotbot swarm -d` picks the robots of push and collect --spin; a "
@@ -506,16 +529,39 @@ def read_enter() -> None:
 
 
 def _collect_spin(
-    ctx, conn, swarm_id, site_name, tag, push, spin_radius, drop_stations=()
+    ctx,
+    conn,
+    swarm_id,
+    site_name,
+    tag,
+    push,
+    spin_radius,
+    drop_stations=(),
+    append=None,
 ):
     """`collect --spin`: spin the robots, solve their circles, save, report."""
     from dotbot.calibration.conics import solve_calibration
-    from dotbot.calibration.lighthouse2 import write_calibration
-    from dotbot.calibration.multi_station import multi_station_report
+    from dotbot.calibration.lighthouse2 import load_calibration, write_calibration
+    from dotbot.calibration.multi_station import (
+        appendable_rounds,
+        multi_station_report,
+    )
     from dotbot.calibration.spin import capture_spins, check_spin_robots, spin_report
     from dotbot.robots import ROBOT_DEFAULT, robot_geometry
 
     site, site_source = site_from_context(ctx, site_name)
+    earlier, round_ = [], 0
+    if append is not None:
+        try:
+            base = load_calibration(append, site=site.name)
+            round_ = appendable_rounds(base)
+        except ValueError as exc:
+            raise click.ClickException(str(exc)) from exc
+        earlier = base.tracks
+        click.echo(
+            f"Appending round {round_} to {base.id8} ({len(earlier)} tracks from "
+            f"{round_} earlier round(s))."
+        )
     radius_from = "--spin-radius"
     if spin_radius is None:
         spin_radius = robot_geometry(ROBOT_DEFAULT).spin_radius_mm
@@ -554,7 +600,9 @@ def _collect_spin(
             spins = capture_spins(client, robots, echo=click.echo)
         except RuntimeError as exc:
             raise click.ClickException(str(exc)) from exc
-        samples = [s for spin in spins.values() for s in spin.samples(spin_radius)]
+        samples = list(earlier) + [
+            s for spin in spins.values() for s in spin.samples(spin_radius, round_)
+        ]
         try:
             calibration, joint, unsolved = solve_calibration(
                 samples,
@@ -569,7 +617,7 @@ def _collect_spin(
             raise click.ClickException(f"no calibration written: {exc}") from exc
         for line in spin_report(spins, robots.robots, joint.solutions, unsolved):
             click.echo(line)
-        if len({s.station for s in samples}) > 1:
+        if len({s.station for s in samples}) > 1 or earlier:
             click.echo("")
             for line in multi_station_report(calibration, joint):
                 click.echo(line)
@@ -731,6 +779,54 @@ def _gated_push(client, calibration, site_changed=False, devices=None, stop=Fals
         click.echo(f"Every robot reports {calibration.id8}.")
 
 
+@cmd.command(
+    name="show",
+    help=(
+        "Print a saved LH2 calibration: its stations and their rectangles, "
+        "the links tying them and the predicted error map, from the file "
+        "alone (no robot, no broker). Takes a file path, its tag or its id "
+        "prefix."
+    ),
+)
+@click.argument("calibration")
+@click.option(
+    "--site",
+    "site_name",
+    default=None,
+    help="The site to look the id up under. Defaults to `site` in the dotbot config.",
+)
+@click.pass_context
+def _show(ctx, calibration, site_name):
+    if _devices(ctx):
+        raise click.UsageError("show reads a file, so it takes no `dotbot swarm -d`")
+    from dotbot.calibration.lighthouse2 import (
+        read_calibration_file,
+        resolve_calibration_path,
+    )
+    from dotbot.calibration.multi_station import multi_station_report
+
+    site, _ = site_from_context(ctx, site_name)
+    try:
+        path = resolve_calibration_path(calibration, site=site)
+        loaded = read_calibration_file(path)
+    except ValueError as exc:
+        raise click.ClickException(str(exc)) from exc
+    rounds = sorted({t.round for t in loaded.tracks})
+    click.echo(f"Calibration {loaded.id}, site {loaded.site.name}, {path}")
+    click.echo(
+        f"Created {loaded.created_at or 'at an unknown time'}"
+        + (f", tag {loaded.tag!r}" if loaded.tag else "")
+        + (
+            f", {len(loaded.tracks)} tracks over {len(rounds)} round(s)"
+            if loaded.tracks
+            else ""
+        )
+        + f", fence {list(loaded.valid_mm)}"
+    )
+    for line in multi_station_report(loaded):
+        click.echo(line)
+
+
 def _parse_shift(_ctx, _param, value):
     try:
         x, y = (float(v) for v in value.split(","))
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index a780107d..e74d303a 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -525,3 +525,78 @@ def test_collect_spin_refuses_an_island_until_it_is_dropped(monkeypatch, lab):
     assert result.exit_code == 0, result.output
     path = Path(re.search(r"Calibration saved to (\S+)", result.output).group(1))
     assert [s.index for s in lighthouse2.read_calibration_file(path).stations] == [0, 1]
+
+
+def test_append_a_round_ties_a_station_the_first_round_left_out(monkeypatch, lab):
+    a, b = _two_stations()
+    # round 0: station 1 sees its own robots and one robot in the overlap only
+    own_a = [c for c in _floor_grid([a]) if not b.sees(c)][:12]
+    own_b = [c for c in _floor_grid([b]) if not a.sees(c)][:8]
+    overlap = [c for c in _floor_grid([a, b]) if a.sees(c) and b.sees(c)]
+    _, fleet = _two_station_fleet([a, b], own_a + own_b + overlap[:1])
+    result = _collect(monkeypatch, lab, fleet)
+    assert result.exit_code != 0
+    assert "station 1 (channel 2) is not tied" in result.output
+    _, fleet = _two_station_fleet([a, b], own_a + own_b + overlap[:1])
+    result = _collect(monkeypatch, lab, fleet, "--drop-station", "1", "--tag", "r0")
+    assert result.exit_code == 0, result.output
+    first = Path(re.search(r"Calibration saved to (\S+)", result.output).group(1))
+    assert [s.index for s in lighthouse2.read_calibration_file(first).stations] == [0]
+
+    # round 1: the same robots (same addresses) spread along the overlap
+    _, fleet = _two_station_fleet([a, b], overlap[1:6])
+    result = _collect(monkeypatch, lab, fleet, "--append", "r0")
+    assert result.exit_code == 0, result.output
+    assert "Appending round 1 to" in result.output
+    assert "station 0 (channel 1) - station 1 (channel 2):" in result.output
+    second = Path(re.search(r"Calibration saved to (\S+)", result.output).group(1))
+    assert second != first and first.exists()
+    saved = lighthouse2.read_calibration_file(second)
+    assert [s.index for s in saved.stations] == [0, 1]
+    assert sorted({t.round for t in saved.tracks}) == [0, 1]
+    names = {(t.name, t.round) for t in saved.tracks}
+    assert any((n, 0) in names and (n, 1) in names for n, _ in names)
+
+
+def test_append_refuses_a_corner_calibration(monkeypatch, lab, tmp_path):
+    from dotbot.tests.lh2_wire_fixture import FIXTURE_TOML
+
+    path = tmp_path / "corner.toml"
+    path.write_text(FIXTURE_TOML.replace('"c405-arena"', '"c405"'), encoding="utf-8")
+    _, fleet = _fleet()
+    result = _collect(monkeypatch, lab, fleet, "--append", str(path))
+    assert result.exit_code != 0
+    assert "not a free-mode spin calibration" in result.output
+    assert fleet.calls == []
+
+
+def test_append_and_drop_station_go_with_spin(lab):
+    for flags in (["--append", "x"], ["--drop-station", "2"]):
+        result = CliRunner().invoke(
+            swarm_lh2.cmd, ["collect", *flags], obj={"config": lab}
+        )
+        assert result.exit_code != 0 and "goes with --spin" in result.output
+
+
+def test_show_prints_the_stations_links_and_error_map(monkeypatch, lab):
+    a, b = _two_stations()
+    _, fleet = _two_station_fleet([a, b], _floor_grid([a, b])[:40])
+    result = _collect(monkeypatch, lab, fleet, "--tag", "two")
+    assert result.exit_code == 0, result.output
+    shown = CliRunner().invoke(swarm_lh2.cmd, ["show", "two"], obj={"config": lab})
+    assert shown.exit_code == 0, shown.output
+    assert "over 1 round(s)" in shown.output
+    assert "station 1 (channel 2): " in shown.output
+    assert "station 0 (channel 1) - station 1 (channel 2):" in shown.output
+    assert "predicted error (100 mm cells): worst" in shown.output
+
+
+def test_show_prints_a_corner_calibration_without_an_error_map(lab, tmp_path):
+    from dotbot.tests.lh2_wire_fixture import FIXTURE_TOML
+
+    path = tmp_path / "corner.toml"
+    path.write_text(FIXTURE_TOML, encoding="utf-8")
+    shown = CliRunner().invoke(swarm_lh2.cmd, ["show", str(path)], obj={"config": lab})
+    assert shown.exit_code == 0, shown.output
+    assert "station 0 (channel 1): 4 marked points" in shown.output
+    assert "predicted error" not in shown.output

From 6255c6ba563b87b386ecb09e11fabf602c462922 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:16:01 +0200
Subject: [PATCH 18/80] dotbot/calibration: push and bake stations by mask,
 each with its rectangle

Breaking, cross-repo: the messages and the config page (magic SWRP, 872
bytes) only match a swarmit bootloader and net core that store stations
by mask, and swarmit's Python must accept mask messages before it relays
them. Robots below device info 4 are refused with a reflash.

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/lighthouse2.py             | 31 ++++++------
 dotbot/calibration/push.py                    |  2 +-
 dotbot/calibration/simulated.py               |  2 +-
 dotbot/firmware/flash.py                      | 46 +++++++++++-------
 dotbot/tests/lh2_wire_fixture.py              | 10 ++--
 dotbot/tests/test_calibration_lighthouse2.py  | 47 ++++++++++++++++---
 .../tests/test_calibration_multi_station.py   | 40 ++++++++++++++++
 dotbot/tests/test_calibration_push.py         |  4 +-
 dotbot/tests/test_calibration_session.py      |  4 +-
 dotbot/tests/test_calibration_spin.py         |  2 +-
 dotbot/tests/test_device.py                   | 28 ++++++-----
 11 files changed, 152 insertions(+), 64 deletions(-)

diff --git a/dotbot/calibration/lighthouse2.py b/dotbot/calibration/lighthouse2.py
index 6954f95c..8114ccca 100644
--- a/dotbot/calibration/lighthouse2.py
+++ b/dotbot/calibration/lighthouse2.py
@@ -379,8 +379,10 @@ def reprojection_residual_mm(
 # --- Wire -------------------------------------------------------------------
 
 # One calibration message per station, `swrmt_lh2_calibration_data_t` in the
-# swarmit netcore: count, index, the matrix, then the site fields every
-# message of a push repeats. swarmit's `helpers.py` packs the same bytes; the
+# swarmit netcore: the station mask, the station's index, its matrix and its
+# rectangle, then the site name and calibration id every message of a push
+# repeats. The net core commits once every station of the mask has arrived,
+# keyed by mask and id. swarmit's `helpers.py` packs the same bytes; the
 # fixture test in each repo pins them.
 LH2_SITE_NAME_BYTES = 16
 LH2_CALIBRATION_ID_BYTES = 8
@@ -483,11 +485,10 @@ def station_label(index: int) -> str:
 
 
 def pushable_stations(calibration: Calibration) -> list[StationSolution]:
-    """The stations in index order, refused when a robot would mis-key them.
+    """The stations in index order, refused when a robot could not hold them.
 
-    The receiver stores a matrix at its index and takes the count as "slots
-    0 to count - 1 are valid", so a gap in the numbering would leave a slot
-    the count claims and nothing filled.
+    A robot stores each station in the slot of its index, 0 to 15, so any
+    set of indices in that range will do.
     """
     ordered = sorted(calibration.stations, key=lambda s: s.index)
     if not ordered:
@@ -497,30 +498,30 @@ def pushable_stations(calibration: Calibration) -> list[StationSolution]:
             f"{len(ordered)} stations exceeds the LH2 limit "
             f"({LH2_BASESTATION_COUNT_MAX})"
         )
-    if [s.index for s in ordered] != list(range(len(ordered))):
-        got = ", ".join(str(s.index) for s in ordered)
+    outside = [s.index for s in ordered if not 0 <= s.index < LH2_BASESTATION_COUNT_MAX]
+    if outside:
         raise ValueError(
-            f"stations must be numbered from zero without gaps to be pushed, got {got}"
+            f"station index {outside} is outside 0 to {LH2_BASESTATION_COUNT_MAX - 1}"
         )
     return ordered
 
 
 def site_fields_as_bytes(calibration: Calibration) -> bytes:
-    """valid_mm, site name and id: the 40 bytes after every matrix."""
-    return (
-        valid_mm_as_bytes(calibration.valid_mm)
-        + site_name_as_bytes(calibration.site.name)
-        + calibration_id_as_bytes(pushed_id(calibration))
+    """Site name and id: the 24 bytes that close every message and the page."""
+    return site_name_as_bytes(calibration.site.name) + calibration_id_as_bytes(
+        pushed_id(calibration)
     )
 
 
 def calibration_messages(calibration: Calibration) -> list[bytes]:
     """One 84-byte calibration message per station, in index order."""
     stations = pushable_stations(calibration)
+    mask = station_mask(calibration)
     site_fields = site_fields_as_bytes(calibration)
     return [
-        struct.pack("<II", len(stations), station.index)
+        struct.pack("<II", mask, station.index)
         + homography_as_float32(station.homography)
+        + valid_mm_as_bytes(station.valid_mm)
         + site_fields
         for station in stations
     ]
diff --git a/dotbot/calibration/push.py b/dotbot/calibration/push.py
index 5573d96d..9492fbf0 100644
--- a/dotbot/calibration/push.py
+++ b/dotbot/calibration/push.py
@@ -25,7 +25,7 @@
 
 from dotbot.calibration.lighthouse2 import Calibration, pushed_id
 
-DEVICE_INFO_VERSION_MIN = 3
+DEVICE_INFO_VERSION_MIN = 4
 # Seconds a pushed robot gets to reset, rejoin and report the pushed id.
 PUSH_REJOIN_TIMEOUT = 30.0
 PUSH_POLL_INTERVAL = 1.0
diff --git a/dotbot/calibration/simulated.py b/dotbot/calibration/simulated.py
index fc0a7b28..d755b145 100644
--- a/dotbot/calibration/simulated.py
+++ b/dotbot/calibration/simulated.py
@@ -115,7 +115,7 @@ def status(self) -> dict[str, Any]:
                 self.pushed[-1][:LH2_CALIBRATION_MESSAGE_BYTES]
             )
         info = SimpleNamespace(
-            info_version=3, lh2_site_name=site, lh2_calibration_id=calibration_id
+            info_version=4, lh2_site_name=site, lh2_calibration_id=calibration_id
         )
         return {self.device: SimpleNamespace(info_gen=1, info=info)}
 
diff --git a/dotbot/firmware/flash.py b/dotbot/firmware/flash.py
index 4fa34417..bd8b3f4a 100644
--- a/dotbot/firmware/flash.py
+++ b/dotbot/firmware/flash.py
@@ -52,22 +52,27 @@
 # swarmit's `swarmit_config_t` (SWARMIT_CONFIG_MAGIC_VALUE). Each value must
 # match its firmware's.
 CONFIG_MAGIC_BY_ROLE = {
-    "dotbot-v3": 0x5753524F,
+    "dotbot-v3": 0x57535250,
     "gateway": 0x5753524D,
 }
 CONFIG_MANIFEST_NAME = "config-manifest.json"
 # swarmit_config_t, little-endian and packed: magic, has_net_id, net_id,
-# homography_count, sixteen 3x3 float32 matrices, valid_mm[4], site_name[16],
-# calibration_id[8]. Every byte the calibration does not set is 0xFF, the
-# erase state the firmware reads as "absent".
+# station_mask, sixteen 3x3 float32 matrices by slot, sixteen valid_mm[4] by
+# slot, site_name[16], calibration_id[8]; 872 bytes. Every byte the
+# calibration does not set is 0xFF, the erase state the firmware reads as
+# "absent"; slots outside the mask are ignored.
 LH2_MATRIX_BYTES = 3 * 3 * 4
+LH2_VALID_MM_BYTES = 4 * 4
 LH2_MAX_HOMOGRAPHIES = 16
-SWARMIT_CONFIG_COUNT_OFFSET = 12
-SWARMIT_CONFIG_MATRICES_OFFSET = SWARMIT_CONFIG_COUNT_OFFSET + 4
-SWARMIT_CONFIG_SITE_OFFSET = (
+SWARMIT_CONFIG_MASK_OFFSET = 12
+SWARMIT_CONFIG_MATRICES_OFFSET = SWARMIT_CONFIG_MASK_OFFSET + 4
+SWARMIT_CONFIG_VALID_MM_OFFSET = (
     SWARMIT_CONFIG_MATRICES_OFFSET + LH2_MAX_HOMOGRAPHIES * LH2_MATRIX_BYTES
 )
-SWARMIT_CONFIG_SITE_BYTES = 4 * 4 + 16 + 8
+SWARMIT_CONFIG_SITE_OFFSET = (
+    SWARMIT_CONFIG_VALID_MM_OFFSET + LH2_MAX_HOMOGRAPHIES * LH2_VALID_MM_BYTES
+)
+SWARMIT_CONFIG_SITE_BYTES = 16 + 8
 SWARMIT_CONFIG_BYTES = SWARMIT_CONFIG_SITE_OFFSET + SWARMIT_CONFIG_SITE_BYTES
 # Application images are linked after the bootloader.
 APP_FLASH_BASE_ADDR = 0x00010000
@@ -163,17 +168,15 @@ def make_config_hex_path(
 
 
 def load_calibration_file(path: Path):
-    """Read a schema 3 calibration file, refused when a robot could not take it."""
+    """Read a calibration file, refused when a robot could not take it."""
     from dotbot.calibration.lighthouse2 import (
-        pushable_stations,
+        calibration_messages,
         read_calibration_file,
-        site_fields_as_bytes,
     )
 
     try:
         calibration = read_calibration_file(Path(path))
-        pushable_stations(calibration)
-        site_fields_as_bytes(calibration)
+        calibration_messages(calibration)
     except (OSError, ValueError) as exc:
         raise click.ClickException(
             f"Cannot use calibration file {path}: {exc}"
@@ -187,22 +190,28 @@ def swarmit_config_page(net_id_value: int, calibration=None) -> bytes:
         homography_as_float32,
         pushable_stations,
         site_fields_as_bytes,
+        station_mask,
+        valid_mm_as_bytes,
     )
 
     page = bytearray(b"\xff" * SWARMIT_CONFIG_BYTES)
-    page[:SWARMIT_CONFIG_COUNT_OFFSET] = struct.pack(
+    page[:SWARMIT_CONFIG_MASK_OFFSET] = struct.pack(
         "<III", CONFIG_MAGIC_BY_ROLE["dotbot-v3"], 1, net_id_value
     )
     if calibration is not None:
         stations = pushable_stations(calibration)
-        page[SWARMIT_CONFIG_COUNT_OFFSET:SWARMIT_CONFIG_MATRICES_OFFSET] = struct.pack(
-            "<I", len(stations)
+        page[SWARMIT_CONFIG_MASK_OFFSET:SWARMIT_CONFIG_MATRICES_OFFSET] = struct.pack(
+            "<I", station_mask(calibration)
         )
         for station in stations:
             offset = SWARMIT_CONFIG_MATRICES_OFFSET + station.index * LH2_MATRIX_BYTES
             page[offset : offset + LH2_MATRIX_BYTES] = homography_as_float32(
                 station.homography
             )
+            offset = SWARMIT_CONFIG_VALID_MM_OFFSET + station.index * LH2_VALID_MM_BYTES
+            page[offset : offset + LH2_VALID_MM_BYTES] = valid_mm_as_bytes(
+                station.valid_mm
+            )
         page[SWARMIT_CONFIG_SITE_OFFSET:] = site_fields_as_bytes(calibration)
     return bytes(page)
 
@@ -410,9 +419,10 @@ def flash_role(
             )
         calibration = load_calibration_file(calibration_path)
         page = swarmit_config_page(net_id_val, calibration)
-        calibration_hex = page[SWARMIT_CONFIG_COUNT_OFFSET:].hex()
+        calibration_hex = page[SWARMIT_CONFIG_MASK_OFFSET:].hex()
         click.echo(
-            f"[INFO] calibration: {len(calibration.stations)} matrices, "
+            f"[INFO] calibration: stations "
+            f"{', '.join(str(s.index) for s in calibration.stations)}, "
             f"site {calibration.site.name}, id {calibration.id} "
             f"from {calibration_path}"
         )
diff --git a/dotbot/tests/lh2_wire_fixture.py b/dotbot/tests/lh2_wire_fixture.py
index 177b7c86..7cd998be 100644
--- a/dotbot/tests/lh2_wire_fixture.py
+++ b/dotbot/tests/lh2_wire_fixture.py
@@ -54,15 +54,15 @@
 homography = [[-1480.25, 12.5, 2950.0], [-20.75, 1502.125, 1010.5], [-0.1875, 0.0625, 1.0]]
 """
 
-# One 84-byte swrmt_lh2_calibration_data_t per station.
+# One 84-byte swrmt_lh2_calibration_data_t per station: station mask 0x3.
 MESSAGE_HEX = [
     (
-        "0200000000000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
+        "0300000000000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
         "88855a3e7c61b2bd0000803f0000000000000000020d0000a00f000063343035"
         "2d6172656e6100000000000080285c9b7db82732"
     ),
     (
-        "02000000010000000008b9c400004841006038450000a6c100c4bb4400a07c44"
+        "03000000010000000008b9c400004841006038450000a6c100c4bb4400a07c44"
         "000040be0000803d0000803f0000000000000000020d0000a00f000063343035"
         "2d6172656e6100000000000080285c9b7db82732"
     ),
@@ -85,12 +85,12 @@
 
 DEFAULTS_MESSAGE_HEX = [
     (
-        "0200000000000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
+        "0300000000000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
         "88855a3e7c61b2bd0000803f0000000000000000102700001027000064656661"
         "756c740000000000000000004e0d138b62b57aa5"
     ),
     (
-        "02000000010000000008b9c400004841006038450000a6c100c4bb4400a07c44"
+        "03000000010000000008b9c400004841006038450000a6c100c4bb4400a07c44"
         "000040be0000803d0000803f0000000000000000102700001027000064656661"
         "756c740000000000000000004e0d138b62b57aa5"
     ),
diff --git a/dotbot/tests/test_calibration_lighthouse2.py b/dotbot/tests/test_calibration_lighthouse2.py
index 08d09790..158ffb93 100644
--- a/dotbot/tests/test_calibration_lighthouse2.py
+++ b/dotbot/tests/test_calibration_lighthouse2.py
@@ -729,8 +729,8 @@ def test_a_message_carries_the_matrix_as_float32_and_the_site_fields(tmp_path):
 
     calibration = _wire_fixture(tmp_path)
     message = calibration_messages(calibration)[1]
-    count, index = struct.unpack_from("<II", message, 0)
-    assert (count, index) == (2, 1)
+    mask, index = struct.unpack_from("<II", message, 0)
+    assert (mask, index) == (0b11, 1)
     assert np.allclose(
         np.array(struct.unpack_from("<9f", message, 8)).reshape(3, 3),
         calibration.station(1).homography,
@@ -742,15 +742,48 @@ def test_a_message_carries_the_matrix_as_float32_and_the_site_fields(tmp_path):
     assert lighthouse2.message_site(message) == ("c405-arena", "80285c9b7db82732")
 
 
-def test_a_gap_in_the_station_numbering_is_refused(tmp_path):
-    """The receiver trusts slots 0 to count - 1, so station 2 alone leaves slot 0 empty."""
+def _stations_2_and_8(tmp_path):
+    calibration = _wire_fixture(tmp_path)
+    two, eight = calibration.stations
+    calibration.stations = [
+        replace(two, index=2, valid_mm=(0, 0, 3330, 2500)),
+        replace(eight, index=8, valid_mm=(1200, 10, 3330, 4000)),
+    ]
+    calibration.stored_id = ""
+    return calibration
+
+
+def test_stations_2_and_8_encode_byte_for_byte_as_the_frozen_layout(tmp_path):
+    """0xA3 payload: mask u32 @0, index u32 @4, float32 H[3][3] @8, this
+    station's u32 valid_mm[4] @44, site_name[16] @60, calibration_id[8] @76."""
+    import struct
+
+    from dotbot.calibration.lighthouse2 import calibration_messages
+
+    calibration = _stations_2_and_8(tmp_path)
+    messages = calibration_messages(calibration)
+    assert [len(m) for m in messages] == [84, 84]
+    for message, station in zip(messages, calibration.stations):
+        expected = (
+            (0x0104).to_bytes(4, "little")
+            + station.index.to_bytes(4, "little")
+            + b"".join(struct.pack("<f", v) for row in station.homography for v in row)
+            + b"".join(v.to_bytes(4, "little") for v in station.valid_mm)
+            + b"c405-arena".ljust(16, b"\x00")
+            + bytes.fromhex(calibration.id[:16])
+        )
+        assert message == expected
+    assert lighthouse2.station_mask(calibration) == 0x0104
+
+
+@pytest.mark.parametrize("index", [16, -1])
+def test_a_station_outside_0_to_15_is_refused(tmp_path, index):
     from dotbot.calibration.lighthouse2 import calibration_messages
 
     calibration = _wire_fixture(tmp_path)
-    calibration.stations = [replace(calibration.stations[1], index=2)]
+    calibration.stations = [replace(calibration.stations[1], index=index)]
     calibration.stored_id = ""
-
-    with pytest.raises(ValueError, match="numbered from zero without gaps"):
+    with pytest.raises(ValueError, match="outside 0 to 15"):
         calibration_messages(calibration)
 
 
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
index 1ee557ff..a916965a 100644
--- a/dotbot/tests/test_calibration_multi_station.py
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -508,3 +508,43 @@ def test_the_file_rules_are_enforced(tmp_path):
         path.write_text(broken, encoding="utf-8")
         with pytest.raises(ValueError, match=match):
             read_calibration_file(path)
+
+
+def test_stations_2_and_8_reach_the_wire_and_the_page_by_slot(tmp_path):
+    """Channels 3 and 9 end to end: solve, file, two 0xA3 payloads, baked page."""
+    import struct
+
+    from dotbot.calibration.lighthouse2 import calibration_messages
+    from dotbot.firmware import flash
+
+    two = F.station(2)
+    eight = F.station(8, F.rigid(2200, 0, 0), aspect=0.9)
+    samples = F.samples(F.spins([two, eight], floor_grid([two, eight])))
+    calibration, _, _ = conics.solve_calibration(samples, Site(name="arena"))
+    path = tmp_path / "cal.toml"
+    path.write_text(render_calibration(calibration), encoding="utf-8")
+    back = read_calibration_file(path)
+
+    messages = calibration_messages(back)
+    assert len(messages) == 2
+    for message, station in zip(messages, back.stations):
+        mask, index = struct.unpack_from("<II", message, 0)
+        assert (mask, index) == (0x0104, station.index)
+        assert struct.unpack_from("<4I", message, 44) == station.valid_mm
+        H = np.array(struct.unpack_from("<9f", message, 8)).reshape(3, 3)
+        assert np.allclose(H, station.matrix, rtol=1e-6)
+
+    page = flash.swarmit_config_page(0x42, flash.load_calibration_file(path))
+    assert len(page) == 872
+    assert struct.unpack_from("<4I", page, 0) == (0x57535250, 1, 0x42, 0x0104)
+    for slot in range(16):
+        matrix = page[16 + 36 * slot : 16 + 36 * (slot + 1)]
+        rect = page[592 + 16 * slot : 592 + 16 * (slot + 1)]
+        station = back.station(slot)
+        if station is None:
+            assert matrix == b"\xff" * 36 and rect == b"\xff" * 16
+            continue
+        assert matrix == messages[[2, 8].index(slot)][8:44]
+        assert struct.unpack("<4I", rect) == station.valid_mm
+    assert page[848:864] == b"arena".ljust(16, b"\x00")
+    assert page[864:872] == bytes.fromhex(back.id[:16])
diff --git a/dotbot/tests/test_calibration_push.py b/dotbot/tests/test_calibration_push.py
index afa020f5..b5635001 100644
--- a/dotbot/tests/test_calibration_push.py
+++ b/dotbot/tests/test_calibration_push.py
@@ -47,7 +47,7 @@ def _lab(tmp_path):
     LAB = load_discovered(environ={}, start_dir=lab)
 
 
-def _info(version=3, site="", calibration_id="", gen=1):
+def _info(version=4, site="", calibration_id="", gen=1):
     info = SimpleNamespace(
         info_version=version, lh2_site_name=site, lh2_calibration_id=calibration_id
     )
@@ -196,7 +196,7 @@ def test_push_to_another_site_is_refused_without_site_changed(
     assert "Every robot reports 80285c9b." in moved.output
 
 
-@pytest.mark.parametrize("version", [1, 2])
+@pytest.mark.parametrize("version", [1, 2, 3])
 def test_push_refuses_a_robot_on_older_firmware(monkeypatch, calibration_file, version):
     # Version 2 is a net core that drops calibrations sent as 0xA3.
     fleet = _Fleet({"OLD": _info(version)})
diff --git a/dotbot/tests/test_calibration_session.py b/dotbot/tests/test_calibration_session.py
index f2e58ca7..83bbd110 100644
--- a/dotbot/tests/test_calibration_session.py
+++ b/dotbot/tests/test_calibration_session.py
@@ -78,7 +78,7 @@ def _press(lh_index: int, count1: int, count2: int, n: int = 1) -> ButtonCapture
     )
 
 
-def _info(version=3, site="", calibration_id=""):
+def _info(version=4, site="", calibration_id=""):
     """A robot's device info as swarmit decodes it."""
     return SimpleNamespace(
         info_version=version, lh2_site_name=site, lh2_calibration_id=calibration_id
@@ -115,7 +115,7 @@ def send_lh2_calibration(self, payload: bytes, devices=None) -> None:
         for addr, info in self.infos.items():
             if devices is not None and addr not in devices:
                 continue
-            if info is not None and info.info_version >= 3:
+            if info is not None and info.info_version >= 4:
                 info.lh2_site_name, info.lh2_calibration_id = message_site(
                     payload[:LH2_CALIBRATION_MESSAGE_BYTES]
                 )
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index e74d303a..a7b3c50b 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -359,7 +359,7 @@ def test_a_spin_push_waits_for_the_robots_to_leave_the_app(monkeypatch, lab):
     sent = []
     fleet.send_lh2_calibration = lambda payload, devices=None: sent.append(devices)
     for node in fleet.nodes.values():
-        node.info.info_version = 3
+        node.info.info_version = 4
         node.info.lh2_site_name = "c405"
         node.info.lh2_calibration_id = ""
         node.info_gen = 1
diff --git a/dotbot/tests/test_device.py b/dotbot/tests/test_device.py
index 769d0903..59fda2cd 100644
--- a/dotbot/tests/test_device.py
+++ b/dotbot/tests/test_device.py
@@ -532,13 +532,13 @@ def test_the_sandbox_page_without_a_calibration_is_erased_past_the_net_id():
     from dotbot.firmware.flash import swarmit_config_page
 
     page = swarmit_config_page(0x1234)
-    assert len(page) == 632
-    assert page[:12] == bytes.fromhex("4f525357" "01000000" "34120000")
-    assert page[12:] == b"\xff" * 620
+    assert len(page) == 872
+    assert page[:12] == bytes.fromhex("50525357" "01000000" "34120000")
+    assert page[12:] == b"\xff" * 860
 
 
 def test_the_sandbox_page_with_a_calibration_is_pinned(tmp_path):
-    """swarmit_config_t, 632 bytes, for the fixture file shared with swarmit."""
+    """swarmit_config_t, 872 bytes, for the fixture file shared with swarmit."""
     import hashlib
 
     from dotbot.firmware.flash import load_calibration_file, swarmit_config_page
@@ -548,22 +548,26 @@ def test_the_sandbox_page_with_a_calibration_is_pinned(tmp_path):
     path.write_text(FIXTURE_TOML, encoding="utf-8")
     page = swarmit_config_page(0x1234, load_calibration_file(path))
 
-    assert len(page) == 632
+    assert len(page) == 872
     assert page[:64].hex() == (
-        "4f525357010000003412000002000000"
+        "50525357010000003412000003000000"
         "cd6cbe44cdcc18c2cd2c7d449a992742"
         "9a79bf443313774488855a3e7c61b2bd"
         "0000803f0008b9c40000484100603845"
     )
     assert hashlib.sha256(page).hexdigest() == (
-        "b1d492d3b8021d16976e5f49a984374655fada7df62e13b35bf9e4e351d6e530"
+        "deda154c7d1991dc043e38a7cac5b4461ffd381d0d16fa53a2d79e045348880f"
     )
-    # Station 1 in slot 1, the fourteen unused slots erased, then the site
-    # fields exactly as the calibration message carries them.
+    # Station 1 in slot 1, the fourteen unused slots erased; each station's
+    # rectangle in its slot, the rest erased; then the site name and id
+    # exactly as the calibration message carries them.
     message = [bytes.fromhex(h) for h in MESSAGE_HEX]
     assert page[16 + 36 : 16 + 72] == message[1][8:44]
     assert page[88:592] == b"\xff" * 504
-    assert page[592:632] == message[0][44:84]
+    assert page[592:608] == message[0][44:60]
+    assert page[608:624] == message[1][44:60]
+    assert page[624:848] == b"\xff" * 224
+    assert page[848:872] == message[0][60:84]
 
 
 def test_the_sandbox_page_has_a_slot_per_station_the_calibration_allows():
@@ -598,9 +602,9 @@ def test_the_manifest_cache_misses_on_the_old_magic(tmp_path):
     from dotbot.firmware.flash import build_manifest_payload, manifest_matches
 
     payload = build_manifest_payload(tmp_path / "c.hex", "dotbot-v3", "local", "1234")
-    assert payload["magic"] == "0x5753524F"
+    assert payload["magic"] == "0x57535250"
     assert manifest_matches(payload, "dotbot-v3", "local", "1234")
-    for old in ("0x5753524E", "0x5753524D"):
+    for old in ("0x5753524F", "0x5753524E", "0x5753524D"):
         payload["magic"] = old
         assert not manifest_matches(payload, "dotbot-v3", "local", "1234")
     gateway = build_manifest_payload(tmp_path / "g.hex", "gateway", "local", "1234")

From 2114ad71273afe31cd55e5577b5705b3e39bc9a2 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:16:01 +0200
Subject: [PATCH 19/80] dotbot/cli: name stations by index and channel in push,
 add push --dry-run

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/swarm_lh2.py               | 46 +++++++++++++++++++++++++--
 dotbot/tests/test_calibration_push.py | 19 +++++++++++
 2 files changed, 62 insertions(+), 3 deletions(-)

diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index c1c13064..9b232cf2 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -699,8 +699,16 @@ def _collect_spin(
         "report another one."
     ),
 )
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help=(
+        "Print the messages the push would send, one per station, and send "
+        "nothing; needs no swarm connection."
+    ),
+)
 @click.pass_context
-def _push(ctx, calibration, conn, swarm_id, site_name, site_changed):
+def _push(ctx, calibration, conn, swarm_id, site_name, site_changed, dry_run):
     from dotbot.calibration.lighthouse2 import (
         read_calibration_file,
         resolve_calibration_path,
@@ -712,17 +720,45 @@ def _push(ctx, calibration, conn, swarm_id, site_name, site_changed):
         loaded = read_calibration_file(path)
     except ValueError as exc:
         raise click.ClickException(str(exc)) from exc
+    if dry_run:
+        _print_messages(loaded)
+        return
     client = _swarmit_client(ctx, conn, swarm_id)
     with client:
         _gated_push(client, loaded, site_changed=site_changed, devices=_devices(ctx))
 
 
+def _print_messages(calibration):
+    """What a push of `calibration` sends, message by message."""
+    from dotbot.calibration.lighthouse2 import (
+        calibration_messages,
+        station_label,
+        station_mask,
+    )
+
+    try:
+        messages = calibration_messages(calibration)
+    except ValueError as exc:
+        raise click.ClickException(str(exc)) from exc
+    stations = sorted(calibration.stations, key=lambda s: s.index)
+    click.echo(
+        f"Would send {len(messages)} message(s), {sum(map(len, messages))} B: "
+        f"id {calibration.id8}, site {calibration.site.name}, station mask "
+        f"0x{station_mask(calibration):04X}"
+    )
+    for station, message in zip(stations, messages):
+        click.echo(
+            f"  {station_label(station.index)}, rectangle {list(station.valid_mm)}: "
+            f"{message.hex()}"
+        )
+
+
 def _gated_push(client, calibration, site_changed=False, devices=None, stop=False):
     """Check the robots' device info, push, and print the stale-id worklist.
 
     With `stop`, the named `devices` still in their app are stopped first.
     """
-    from dotbot.calibration.lighthouse2 import calibration_payload
+    from dotbot.calibration.lighthouse2 import calibration_payload, station_label
     from dotbot.calibration.push import (
         PushRefused,
         gate_push,
@@ -755,8 +791,12 @@ def _gated_push(client, calibration, site_changed=False, devices=None, stop=Fals
             f"{len(check.other_site)} robot(s) move to site "
             f"{calibration.site.name} (--site-changed)."
         )
+    stations = ", ".join(
+        station_label(s.index)
+        for s in sorted(calibration.stations, key=lambda s: s.index)
+    )
     click.echo(
-        f"Sending {len(calibration.stations)} calibration matrix/matrices "
+        f"Sending {stations} "
         f"({len(payload)} B, id {calibration.id8}, site {calibration.site.name}) "
         f"to the swarm; {len(check.stale)} robot(s) hold another id..."
     )
diff --git a/dotbot/tests/test_calibration_push.py b/dotbot/tests/test_calibration_push.py
index b5635001..94f28e65 100644
--- a/dotbot/tests/test_calibration_push.py
+++ b/dotbot/tests/test_calibration_push.py
@@ -368,3 +368,22 @@ def client(ctx, conn, swarm_id):
         )
     assert seen == {"no_server": True}
     assert fleet.pushed_to == [["A"]]
+
+
+def test_a_dry_run_prints_the_messages_and_needs_no_swarm(
+    monkeypatch, calibration_file
+):
+    def no_client(*_args, **_kwargs):
+        raise AssertionError("a dry run opens no swarm connection")
+
+    monkeypatch.setattr(swarm_lh2, "_swarmit_client", no_client)
+    result = CliRunner().invoke(
+        swarm_lh2.cmd,
+        ["push", str(calibration_file), "--dry-run"],
+        obj={"config": LAB},
+    )
+    assert result.exit_code == 0, result.output
+    assert "Would send 2 message(s), 168 B" in result.output
+    assert "station mask 0x0003" in result.output
+    for hexed in MESSAGE_HEX:
+        assert hexed in result.output

From 9e79c4b3afb7e2e399dd45dd4714a0622209e81a Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:16:01 +0200
Subject: [PATCH 20/80] dotbot/console-web: read lh2_station_mask, take device
 info 4 as current

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/dev/fake_swarmit_server.py | 20 ++++++++++---------
 dotbot/console-web/src/fleetViews.test.tsx    |  2 +-
 dotbot/console-web/src/localization.test.ts   |  2 +-
 dotbot/console-web/src/localization.ts        |  2 +-
 dotbot/console-web/src/pushTarget.test.tsx    |  2 +-
 dotbot/console-web/src/types.ts               |  3 ++-
 6 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/dotbot/console-web/dev/fake_swarmit_server.py b/dotbot/console-web/dev/fake_swarmit_server.py
index f961d2ba..aa54e305 100644
--- a/dotbot/console-web/dev/fake_swarmit_server.py
+++ b/dotbot/console-web/dev/fake_swarmit_server.py
@@ -174,17 +174,19 @@ def device_info(addr: str) -> dict:
     seed = _seed(addr)
     name, digest, size = IMAGES[seed % len(IMAGES)]
     # A minority are uncalibrated, which is the state an operator acts on.
-    homographies = 0 if seed % 9 == 0 else (2 if seed % 5 == 0 else 1)
-    flags = LH2_FLAG_VALID | LH2_FLAG_FROM_FLASH if homographies else 0
-    noun = "basestation" if homographies == 1 else "basestations"
+    mask = 0 if seed % 9 == 0 else (0b101 if seed % 5 == 0 else 0b1)
+    flags = LH2_FLAG_VALID | LH2_FLAG_FROM_FLASH if mask else 0
+    stations = [i for i in range(16) if mask >> i & 1]
     summary = (
         "uncalibrated"
-        if not homographies
-        else f"{homographies} {noun} (valid, from flash)"
+        if not mask
+        else f"station{'s' if len(stations) > 1 else ''} "
+        f"{', '.join(map(str, stations))} (channel{'s' if len(stations) > 1 else ''} "
+        f"{', '.join(str(i + 1) for i in stations)}; valid, from flash)"
     )
     return {
         # A few run sandbox firmware too old for this host's calibrations.
-        "info_version": 2 if seed % 7 == 0 else 3,
+        "info_version": 3 if seed % 7 == 0 else 4,
         "info_gen": 4,
         "boot_count": 2 + seed % 30,
         "uptime_s": 60 + seed % 9000,
@@ -198,10 +200,10 @@ def device_info(addr: str) -> dict:
         "image_digest": digest,
         "image_name": name,
         "image_version": "",
-        "lh2_homography_count": homographies,
+        "lh2_station_mask": mask,
         "lh2_flags": flags,
-        "lh2_site_name": FAKE_SITE if homographies else "",
-        "lh2_calibration_id": FAKE_CALIBRATION_ID if homographies else "",
+        "lh2_site_name": FAKE_SITE if mask else "",
+        "lh2_calibration_id": FAKE_CALIBRATION_ID if mask else "",
         "lh2_summary": summary,
         "raw": "8f0104" + f"{seed:08x}" * 4,
     }
diff --git a/dotbot/console-web/src/fleetViews.test.tsx b/dotbot/console-web/src/fleetViews.test.tsx
index 9186e61e..efd5d8de 100644
--- a/dotbot/console-web/src/fleetViews.test.tsx
+++ b/dotbot/console-web/src/fleetViews.test.tsx
@@ -30,7 +30,7 @@ const site: Site = {
 };
 
 const info = (over: Partial<SwarmitDeviceInfo> = {}): SwarmitDeviceInfo => ({
-  info_version: 3,
+  info_version: 4,
   bl_version: "1.25.0",
   net_version: "1.25.0",
   boot_count: 3,
diff --git a/dotbot/console-web/src/localization.test.ts b/dotbot/console-web/src/localization.test.ts
index 7b83a269..8293d15a 100644
--- a/dotbot/console-web/src/localization.test.ts
+++ b/dotbot/console-web/src/localization.test.ts
@@ -56,7 +56,7 @@ const bot = (id: string, calibrationId?: string): UnifiedBot =>
       calibrationId === undefined
         ? null
         : ({
-            info: { info_version: 3, lh2_calibration_id: calibrationId },
+            info: { info_version: 4, lh2_calibration_id: calibrationId },
           } as unknown as SwarmitNode),
   }) as UnifiedBot;
 
diff --git a/dotbot/console-web/src/localization.ts b/dotbot/console-web/src/localization.ts
index 0d05627a..e04bbafa 100644
--- a/dotbot/console-web/src/localization.ts
+++ b/dotbot/console-web/src/localization.ts
@@ -39,7 +39,7 @@ export interface Coverage {
 }
 
 /** The device-info version of firmware that takes this host's calibrations; older needs a reflash. */
-export const DEVICE_INFO_VERSION_MIN = 3;
+export const DEVICE_INFO_VERSION_MIN = 4;
 
 /** Who carries `savedId`, from the calibration id each robot's device info reports. */
 export function calibrationCoverage(bots: UnifiedBot[], savedId: string): Coverage {
diff --git a/dotbot/console-web/src/pushTarget.test.tsx b/dotbot/console-web/src/pushTarget.test.tsx
index ed1140ba..a747f7a9 100644
--- a/dotbot/console-web/src/pushTarget.test.tsx
+++ b/dotbot/console-web/src/pushTarget.test.tsx
@@ -76,7 +76,7 @@ const bot = (id: string, calibrationId: string): UnifiedBot =>
   ({
     id,
     swarmit: {
-      info: { info_version: 3, lh2_calibration_id: calibrationId },
+      info: { info_version: 4, lh2_calibration_id: calibrationId },
     } as unknown as SwarmitNode,
   }) as UnifiedBot;
 
diff --git a/dotbot/console-web/src/types.ts b/dotbot/console-web/src/types.ts
index dac6b4a1..2d43c334 100644
--- a/dotbot/console-web/src/types.ts
+++ b/dotbot/console-web/src/types.ts
@@ -266,7 +266,8 @@ export interface SwarmitDeviceInfo {
   image_name: string;
   image_version: string;
   image_digest: string;
-  lh2_homography_count?: number;
+  // Bit i set: the bot holds station i's homography (channel i + 1).
+  lh2_station_mask?: number;
   lh2_flags?: number;
   // Device info v2: the site and calibration id the bot holds, "" for none.
   lh2_site_name?: string;

From ccd6212fa2376e1606536783b413652a4c44a828 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:48:58 +0200
Subject: [PATCH 21/80] dotbot/tests: pin the wire fixture to stations 2 and 8
 with rectangles of their own

AI-assisted: Claude Opus 5.5
---
 dotbot/tests/lh2_wire_fixture.py             | 49 +++++++++++---------
 dotbot/tests/test_calibration_lighthouse2.py | 11 +++--
 dotbot/tests/test_calibration_push.py        | 10 ++--
 dotbot/tests/test_calibration_spin.py        |  2 +-
 dotbot/tests/test_controller.py              | 10 +++-
 dotbot/tests/test_device.py                  | 28 ++++++-----
 6 files changed, 59 insertions(+), 51 deletions(-)

diff --git a/dotbot/tests/lh2_wire_fixture.py b/dotbot/tests/lh2_wire_fixture.py
index 7cd998be..2bf658d6 100644
--- a/dotbot/tests/lh2_wire_fixture.py
+++ b/dotbot/tests/lh2_wire_fixture.py
@@ -7,14 +7,14 @@
 message bytes: the two packers must agree, so keep the copies identical.
 """
 
-FIXTURE_ID = "80285c9b7db82732"
+FIXTURE_ID = "9b12f56f622f0fb6"
 
 FIXTURE_TOML = """\
 schema_version = 4
 
 [metadata]
 created_at = "2026-09-10T09:12:00Z"
-id = "80285c9b7db82732"
+id = "9b12f56f622f0fb6"
 robot = "dotbot-v3"
 tag = "arena-relay"
 
@@ -31,46 +31,48 @@
 points_mm = [[47.0, 18.5], [1953.0, 18.5], [47.0, 1981.5], [1953.0, 1981.5]]
 captured_at = "2026-09-10T09:10:41Z"
 samples = [
-  { station = 0, point = 0, count1 = [41290, 41291], count2 = [51728, 51727] },
-  { station = 0, point = 1, count1 = [40877, 40878], count2 = [51102, 51101] },
-  { station = 0, point = 2, count1 = [43166, 43167], count2 = [75717, 75716] },
-  { station = 0, point = 3, count1 = [42810, 42811], count2 = [75104, 75103] },
+  { station = 2, point = 0, count1 = [41290, 41291], count2 = [51728, 51727] },
+  { station = 2, point = 1, count1 = [40877, 40878], count2 = [51102, 51101] },
+  { station = 2, point = 2, count1 = [43166, 43167], count2 = [75717, 75716] },
+  { station = 2, point = 3, count1 = [42810, 42811], count2 = [75104, 75103] },
 ]
 
 [[station]]
-index = 0
+index = 2
 solved_from = "direct"
 points = 4
 residual_mm = 0.0
-valid_mm = [0, 0, 3330, 4000]
+valid_mm = [0, 0, 2500, 4000]
 homography = [[1523.4, -38.2, 1012.7], [41.9, 1531.8, 988.3], [0.2134, -0.0871, 1.0]]
 
 [[station]]
-index = 1
+index = 8
 solved_from = "direct"
 points = 4
 residual_mm = 0.0
-valid_mm = [0, 0, 3330, 4000]
+valid_mm = [800, 0, 3330, 4000]
 homography = [[-1480.25, 12.5, 2950.0], [-20.75, 1502.125, 1010.5], [-0.1875, 0.0625, 1.0]]
 """
 
-# One 84-byte swrmt_lh2_calibration_data_t per station: station mask 0x3.
+# One 84-byte swrmt_lh2_calibration_data_t per station: stations 2 and 8
+# (channels 3 and 9), station mask 0x0104, each with its own rectangle, so a
+# packer that keys by position or writes the union into every message fails.
 MESSAGE_HEX = [
     (
-        "0300000000000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
-        "88855a3e7c61b2bd0000803f0000000000000000020d0000a00f000063343035"
-        "2d6172656e6100000000000080285c9b7db82732"
+        "0401000002000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
+        "88855a3e7c61b2bd0000803f0000000000000000c4090000a00f000063343035"
+        "2d6172656e610000000000009b12f56f622f0fb6"
     ),
     (
-        "03000000010000000008b9c400004841006038450000a6c100c4bb4400a07c44"
-        "000040be0000803d0000803f0000000000000000020d0000a00f000063343035"
-        "2d6172656e6100000000000080285c9b7db82732"
+        "04010000080000000008b9c400004841006038450000a6c100c4bb4400a07c44"
+        "000040be0000803d0000803f2003000000000000020d0000a00f000063343035"
+        "2d6172656e610000000000009b12f56f622f0fb6"
     ),
 ]
 
 # The same file without [site] and [validity], so each reader's defaults reach
 # the wire: site "default" and valid_mm [0, 0, 10000, 10000].
-DEFAULTS_FIXTURE_ID = "4e0d138b62b57aa5"
+DEFAULTS_FIXTURE_ID = "87453fc957d6f0ef"
 
 DEFAULTS_FIXTURE_TOML = (
     FIXTURE_TOML.replace(
@@ -79,19 +81,20 @@
         "",
     )
     .replace("[validity]\nvalid_mm = [0, 0, 3330, 4000]\n\n", "")
-    .replace("valid_mm = [0, 0, 3330, 4000]", "valid_mm = [0, 0, 10000, 10000]")
+    .replace("valid_mm = [0, 0, 2500, 4000]", "valid_mm = [0, 0, 10000, 10000]")
+    .replace("valid_mm = [800, 0, 3330, 4000]", "valid_mm = [0, 0, 10000, 10000]")
     .replace(f'id = "{FIXTURE_ID}"', f'id = "{DEFAULTS_FIXTURE_ID}"')
 )
 
 DEFAULTS_MESSAGE_HEX = [
     (
-        "0300000000000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
+        "0401000002000000cd6cbe44cdcc18c2cd2c7d449a9927429a79bf4433137744"
         "88855a3e7c61b2bd0000803f0000000000000000102700001027000064656661"
-        "756c740000000000000000004e0d138b62b57aa5"
+        "756c7400000000000000000087453fc957d6f0ef"
     ),
     (
-        "03000000010000000008b9c400004841006038450000a6c100c4bb4400a07c44"
+        "04010000080000000008b9c400004841006038450000a6c100c4bb4400a07c44"
         "000040be0000803d0000803f0000000000000000102700001027000064656661"
-        "756c740000000000000000004e0d138b62b57aa5"
+        "756c7400000000000000000087453fc957d6f0ef"
     ),
 ]
diff --git a/dotbot/tests/test_calibration_lighthouse2.py b/dotbot/tests/test_calibration_lighthouse2.py
index 158ffb93..d76e6163 100644
--- a/dotbot/tests/test_calibration_lighthouse2.py
+++ b/dotbot/tests/test_calibration_lighthouse2.py
@@ -730,16 +730,17 @@ def test_a_message_carries_the_matrix_as_float32_and_the_site_fields(tmp_path):
     calibration = _wire_fixture(tmp_path)
     message = calibration_messages(calibration)[1]
     mask, index = struct.unpack_from("<II", message, 0)
-    assert (mask, index) == (0b11, 1)
+    assert (mask, index) == (0x0104, 8)
     assert np.allclose(
         np.array(struct.unpack_from("<9f", message, 8)).reshape(3, 3),
-        calibration.station(1).homography,
+        calibration.station(8).homography,
         rtol=1e-7,
     )
-    assert struct.unpack_from("<4I", message, 44) == (0, 0, 3330, 4000)
+    # station 8's own rectangle, not the union
+    assert struct.unpack_from("<4I", message, 44) == (800, 0, 3330, 4000)
     assert message[60:76] == b"c405-arena" + bytes(6)
-    assert message[76:84] == bytes.fromhex("80285c9b7db82732")
-    assert lighthouse2.message_site(message) == ("c405-arena", "80285c9b7db82732")
+    assert message[76:84] == bytes.fromhex("9b12f56f622f0fb6")
+    assert lighthouse2.message_site(message) == ("c405-arena", "9b12f56f622f0fb6")
 
 
 def _stations_2_and_8(tmp_path):
diff --git a/dotbot/tests/test_calibration_push.py b/dotbot/tests/test_calibration_push.py
index 94f28e65..a3f889c7 100644
--- a/dotbot/tests/test_calibration_push.py
+++ b/dotbot/tests/test_calibration_push.py
@@ -157,7 +157,7 @@ def test_push_sends_the_messages_and_lists_the_worklist(monkeypatch, calibration
     # Device info is read once for the gate and never polled after the push.
     assert fleet.refreshed == [None]
     assert "2 robot(s) hold another id" in result.output
-    assert "Still not on 80285c9b (1), push again: LAGGARD" in result.output
+    assert "Still not on 9b12f56f (1), push again: LAGGARD" in result.output
 
 
 def test_a_push_checked_for_named_robots_goes_to_exactly_them(calibration_file):
@@ -193,7 +193,7 @@ def test_push_to_another_site_is_refused_without_site_changed(
     moved = _push(monkeypatch, fleet, str(calibration_file), "--site-changed")
     assert moved.exit_code == 0, moved.output
     assert len(fleet.pushed) == 1
-    assert "Every robot reports 80285c9b." in moved.output
+    assert "Every robot reports 9b12f56f." in moved.output
 
 
 @pytest.mark.parametrize("version", [1, 2, 3])
@@ -235,8 +235,8 @@ def test_reframe_writes_a_new_file_in_the_target_site(
     assert data["metadata"]["id"] != FIXTURE_ID
     assert data["metadata"]["id"] in result.output
     # The fixture's matrices were not solved from its samples, so only
-    # station 0, the one the samples cover, is re-solved.
-    assert [s["index"] for s in data["station"]] == [0]
+    # station 2, the one the samples cover, is re-solved.
+    assert [s["index"] for s in data["station"]] == [2]
 
 
 def test_reframe_into_an_undeclared_site_is_refused(calibration_file):
@@ -384,6 +384,6 @@ def no_client(*_args, **_kwargs):
     )
     assert result.exit_code == 0, result.output
     assert "Would send 2 message(s), 168 B" in result.output
-    assert "station mask 0x0003" in result.output
+    assert "station mask 0x0104" in result.output
     for hexed in MESSAGE_HEX:
         assert hexed in result.output
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index a7b3c50b..30273476 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -598,5 +598,5 @@ def test_show_prints_a_corner_calibration_without_an_error_map(lab, tmp_path):
     path.write_text(FIXTURE_TOML, encoding="utf-8")
     shown = CliRunner().invoke(swarm_lh2.cmd, ["show", str(path)], obj={"config": lab})
     assert shown.exit_code == 0, shown.output
-    assert "station 0 (channel 1): 4 marked points" in shown.output
+    assert "station 2 (channel 3): 4 marked points" in shown.output
     assert "predicted error" not in shown.output
diff --git a/dotbot/tests/test_controller.py b/dotbot/tests/test_controller.py
index 2cb5ef5d..d3295d37 100644
--- a/dotbot/tests/test_controller.py
+++ b/dotbot/tests/test_controller.py
@@ -1597,11 +1597,17 @@ async def test_a_resend_that_fails_drops_the_command(controller, clock):
 
 
 def _old_calibration_settings(tmp_path, **kwargs):
-    """Settings loading the wire fixture, made 2026-09-10, by path."""
+    """Settings loading the wire fixture, made 2026-09-10, by path, with its
+    stations renumbered 0 and 1: a robot advertises the stations it holds in
+    one byte, stations 0 to 7."""
     from dotbot.tests.lh2_wire_fixture import FIXTURE_TOML
 
     path = tmp_path / "calibration.toml"
-    path.write_text(FIXTURE_TOML)
+    path.write_text(
+        FIXTURE_TOML.replace("index = 2\n", "index = 0\n").replace(
+            "index = 8\n", "index = 1\n"
+        )
+    )
     return ControllerSettings(
         port="/dev/null",
         baudrate=115200,
diff --git a/dotbot/tests/test_device.py b/dotbot/tests/test_device.py
index 59fda2cd..3931e5f3 100644
--- a/dotbot/tests/test_device.py
+++ b/dotbot/tests/test_device.py
@@ -549,24 +549,22 @@ def test_the_sandbox_page_with_a_calibration_is_pinned(tmp_path):
     page = swarmit_config_page(0x1234, load_calibration_file(path))
 
     assert len(page) == 872
-    assert page[:64].hex() == (
-        "50525357010000003412000003000000"
-        "cd6cbe44cdcc18c2cd2c7d449a992742"
-        "9a79bf443313774488855a3e7c61b2bd"
-        "0000803f0008b9c40000484100603845"
-    )
+    assert page[:16].hex() == "50525357010000003412000004010000"
     assert hashlib.sha256(page).hexdigest() == (
-        "deda154c7d1991dc043e38a7cac5b4461ffd381d0d16fa53a2d79e045348880f"
+        "c96414cbab5c61fc2bd78d0559dad586d2270c57ea87f10054c1e79f62d1b791"
     )
-    # Station 1 in slot 1, the fourteen unused slots erased; each station's
-    # rectangle in its slot, the rest erased; then the site name and id
-    # exactly as the calibration message carries them.
+    # Stations 2 and 8 in their slots, every other slot erased; each
+    # station's rectangle in its slot; then the site name and id exactly as
+    # the calibration message carries them.
     message = [bytes.fromhex(h) for h in MESSAGE_HEX]
-    assert page[16 + 36 : 16 + 72] == message[1][8:44]
-    assert page[88:592] == b"\xff" * 504
-    assert page[592:608] == message[0][44:60]
-    assert page[608:624] == message[1][44:60]
-    assert page[624:848] == b"\xff" * 224
+    matrix = [page[16 + 36 * i : 16 + 36 * (i + 1)] for i in range(16)]
+    rect = [page[592 + 16 * i : 592 + 16 * (i + 1)] for i in range(16)]
+    for i in range(16):
+        if i in (2, 8):
+            m = message[(2, 8).index(i)]
+            assert matrix[i] == m[8:44] and rect[i] == m[44:60]
+        else:
+            assert matrix[i] == b"\xff" * 36 and rect[i] == b"\xff" * 16
     assert page[848:872] == message[0][60:84]
 
 

From e163dd022ee3ff9c6071fa89ce7fcebd667b6b06 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:59:08 +0200
Subject: [PATCH 22/80] dotbot: read the advertised LH2 station mask in 16 bits

Breaking wire change, landing with DotBot-libs' 16-bit calibrated field:
every advertisement field after the mask moves by one byte and the
vendored dotbot_control.wasm is rebuilt at ABI 3 from that change. With
the one-byte mask, a calibration naming station 8 or above read every
sandbox robot as missing it and resent homographies on each advert.

AI-assisted: Claude Opus 5.5
---
 dotbot/dotbot_simulator.py            |  10 +++++-----
 dotbot/models.py                      |   2 +-
 dotbot/protocol.py                    |   6 +++---
 dotbot/sim/core.py                    |   4 ++--
 dotbot/sim/dotbot_control.json        |   6 +++---
 dotbot/sim/dotbot_control.wasm        | Bin 41053 -> 43583 bytes
 dotbot/tests/test_controller.py       |  13 ++++---------
 dotbot/tests/test_dotbot_simulator.py |   3 ++-
 dotbot/tests/test_protocol.py         |   4 ++--
 dotbot/tests/test_sim_core.py         |  17 ++++++++++-------
 10 files changed, 32 insertions(+), 33 deletions(-)

diff --git a/dotbot/dotbot_simulator.py b/dotbot/dotbot_simulator.py
index efc93f7e..efcb9c44 100644
--- a/dotbot/dotbot_simulator.py
+++ b/dotbot/dotbot_simulator.py
@@ -61,8 +61,8 @@
 # How far apart `--robots N` puts a generated fleet
 FLEET_PITCH_MM = 200
 # The stations a simulated robot holds when neither its world file nor the
-# controller's calibration says: all eight
-CALIBRATED_ALL = 0xFF
+# controller's calibration says: all sixteen
+CALIBRATED_ALL = 0xFFFF
 # The heading of every robot of a generated fleet: up (-y), 0 facing +y
 FLEET_FACING = 180
 
@@ -113,7 +113,7 @@ class SimulatedDotBotSettings(BaseModel):
     estimator starts out tracking; without one the robot faces +y and starts
     with no heading, as a real robot does from boot. `calibrated` is the
     bitmask of stations the robot holds a homography for; without one it
-    holds the stations of the controller's calibration, all eight when none
+    holds the stations of the controller's calibration, all sixteen when none
     is loaded.
     """
 
@@ -522,7 +522,7 @@ def __init__(
         ]
         calibrated = CALIBRATED_ALL if calibrated is None else calibrated
         self._calibrated = [
-            (calibrated if s.calibrated is None else s.calibrated) & 0xFF
+            (calibrated if s.calibrated is None else s.calibrated) & 0xFFFF
             for s in settings
         ]
         self._dotbot_modes = [s.network_mode for s in settings]
@@ -725,7 +725,7 @@ def _gru_residual(self, index: int, model, report):
     def _advertise(self, index: int, packet: bytearray):
         """Send robot `index`'s advertisement, as its firmware encoded it."""
         # The calibration bitmask is the node's, not the control core's
-        packet[1] = self._calibrated[index]
+        packet[1:3] = self._calibrated[index].to_bytes(2, "little")
         self._counts[:, index] = 0
         frame = Frame(header=self._headers[index], packet=Packet.from_bytes(packet))
         if self._dotbot_modes[index] == SimulatedNetworkMode.MARI:
diff --git a/dotbot/models.py b/dotbot/models.py
index 219b6f74..ff3c8d37 100644
--- a/dotbot/models.py
+++ b/dotbot/models.py
@@ -684,7 +684,7 @@ class DotBotModel(BaseModel):
     axle_position: Optional[DotBotLH2Position] = None  # the robot's own estimate
     # Where the robot has been, oldest first
     trail: List[Union[DotBotLH2Position, DotBotGPSPosition]] = []
-    calibrated: int = 0x00  # Bitmask: first lighthouse = 0x01, second lighthouse = 0x02
+    calibrated: int = 0x00  # bit i: the robot holds station i's homography
     battery: float = 3.0  # Voltage in Volts
 
 
diff --git a/dotbot/protocol.py b/dotbot/protocol.py
index cd9be916..c30f1cd3 100644
--- a/dotbot/protocol.py
+++ b/dotbot/protocol.py
@@ -25,7 +25,7 @@
 
 # The advertised `calibrated` bitmask of a robot that holds no per-station
 # homographies at all, such as one running a sandbox app.
-CALIBRATED_NOT_APPLICABLE = 0xFF
+CALIBRATED_NOT_APPLICABLE = 0xFFFF
 
 
 class PayloadType(IntEnum):
@@ -114,7 +114,7 @@ class PayloadDotBotAdvertisement(Payload):
 
     metadata: list[PayloadFieldMetadata] = dataclasses.field(
         default_factory=lambda: [
-            PayloadFieldMetadata(name="calibrated", disp="cal."),
+            PayloadFieldMetadata(name="calibrated", disp="cal.", length=2),
             PayloadFieldMetadata(name="direction", disp="dir.", length=2, signed=True),
             PayloadFieldMetadata(name="pos_x", disp="x", length=4),
             PayloadFieldMetadata(name="pos_y", disp="y", length=4),
@@ -140,7 +140,7 @@ class PayloadDotBotAdvertisement(Payload):
         ]
     )
 
-    calibrated: int = 0x00  # Bitmask: first lighthouse = 0x01, second lighthouse = 0x02
+    calibrated: int = 0x00  # bit i: the robot holds station i's homography
     direction: int = 0xFFFF
     pos_x: int = 0xFFFFFFFF
     pos_y: int = 0xFFFFFFFF
diff --git a/dotbot/sim/core.py b/dotbot/sim/core.py
index 3baafcc3..e9c121bf 100644
--- a/dotbot/sim/core.py
+++ b/dotbot/sim/core.py
@@ -21,7 +21,7 @@
 
 import numpy as np
 
-ABI_VERSION = 2
+ABI_VERSION = 3
 WASM_PATH = Path(__file__).with_name("dotbot_control.wasm")
 MANIFEST_PATH = Path(__file__).with_name("dotbot_control.json")
 
@@ -81,7 +81,7 @@
         ("max_speed_10mm", "u1"),
     ]
 )
-ADVERTISEMENT_BYTES = 42
+ADVERTISEMENT_BYTES = 43
 # fleet_geometry_t: drv/geometry.h as the core was built, mm and degrees
 GEOMETRY = np.dtype(
     [
diff --git a/dotbot/sim/dotbot_control.json b/dotbot/sim/dotbot_control.json
index af6528d3..c2a38030 100644
--- a/dotbot/sim/dotbot_control.json
+++ b/dotbot/sim/dotbot_control.json
@@ -1,8 +1,8 @@
 {
   "file": "dotbot_control.wasm",
   "source": "https://github.com/DotBots/DotBot-libs",
-  "commit": "48cc06bff499db56be1373cd3bf5c852084adddd",
+  "commit": "01976927d5a6e47e9774875547b0d0ad0b5680d7",
   "build": "wasm/fetch-wasi-sdk.sh && make wasm (wasi-sdk 34.0)",
-  "abi_version": 2,
-  "sha256": "53df5c73421442d85b306514d403e968d32289a0e823ed2a12825fb2800a5177"
+  "abi_version": 3,
+  "sha256": "e602b8bbbf7ebadbb099b1c217429f179b8903a0d0abcd5f6a92793a667220e9"
 }
diff --git a/dotbot/sim/dotbot_control.wasm b/dotbot/sim/dotbot_control.wasm
index 5be0d427b9e6096244c2978c195bd3089e78f80d..6464f5bf14cb87f06e2fef59be24101b47b48b73 100755
GIT binary patch
delta 6812
zcmcgwdvH|Oc|Ygu-TT;w_UeJOdgj~%7$FeC7*@&(BVEKJj)L){$>d=d<HSx_B{tN|
zq+^0tP81ghH5Gf7nq)}gH1-s`#Kl>=ab{?Yoz$i^e&D*aq0r(EZaouEhfYZCwv6fT
zJ9k$CM@c9CqYT<}&Ue1|`Of!!_nbZ=o_<ZF*yg*wz!_uwJG^aA>Jz?Q+)4j<@fNFC
zEbe4`K9dulzID(3ur1?TuH)9%H#F2YG&VNPX=rX~X{gUOv^G5ci&0_y^3TPsdUb5T
zi6!GKe8SWB#@hHIy+5|N_|N0x<1A#|;+=0zj5B|FdExTq__r_How$6t>+<E~<;$r{
zmm$lEG66y+p-R#7UndO|&x!LS(txuOFc&FhKyD3W6f>YBtOhgM85pmDjE0wkjFtu@
zYFLx0X;u3C*Y&H`9s%#%7JrzAlzk%&o9%~aaGZV`hMf@_zUr*SP&wu-<Z$GFx;X+a
z@s@Wz;eEa!x&JU3l}!FV=S7%l6_f~Bc*xV^-ioUxV!#Nec)>qFSlEBcF8F^{oiEFY
zaSt#!<V_bN{B_3Fr@YPfTaYs0>5;_7KCn=h|9v7^n<fr|u#?jAAFZ+h`58l=XJ=jg
zOrk>_B(7|bKZ;R`BR?2n?A_IS@q2W2`2x$cM?8Ho(JT&lx+U2)c*YIIx-=8RAo{<h
zLHuRXn)Q9jdv1BdU6+m}A&uwR8!lMIdfAkiVS1?n#$3W>;Q_DU{|T9qiX};YH+Y9J
zD1*J&dj%~7O$hDJlCk93Sm+o0M+~`0N)g7cNprKMzn5BS9LFz}3x?!4KJ7T;?;1~X
z+y{;0#>Xe%{sUeT0v;5Fc@TgDUQ0Sb>aV44(RZX<I^J?|;GF(O+Y4mSId?4dMw6$L
z!qMMNx7|(%-J(fZz{1~XyF$psa{_Q7*+R(eXCw-SLK{J2oP5<S_IX6flwHWt+`#r5
zn57)R_IqMj3`^EaVGz`H&Vw&`<V&j{ZA8pdWJzFy`*Or(x3Hw8Z>`%<wEV-gQzJj+
zrXfGDQk*<~*eL`SMnrDl0qlf4uw%p0lP*|3M}%voy$x)wu!&HCP*4u(amu|W&630_
zGU${m?I?)h`u#AMLjIsAf}=&}4?`n|B|rxQ;g)m8U9N)C-C~z#%#n5uQ!*f>?C`-q
zv`2xBm9L!Iib)5_hnxi5DU2Zka}o}c7I2|PMLHG#$E19l42d>y48y=Cn<=^?l*b5V
zTDSA=7!GbmyYmP|idp?Vzk8j7c)|4y5rf_0bI?qzYnL{Tpgkv2kPN_jGOL$e5P^f}
zB2R70vyQ63SePo{KwimYt+Q^LQ$T*^tQ#GI348E}^&kKeyJ@ska<_k!)WgN@`)Ns~
zFf#VL<lv-C$<(Aw$YjX?Z)sO49V7w3kRS^Y5ecGO<3Fz-t8WgH)x|Ww2mBw_OrJJU
ze=U>gvy5E`-I`qh%-99@#mMMsyR=sy{Quii{7v?lFnb60vS~WZ-l3dj?5wjm$}met
z!8qZK5g7jui4Amkzdi*Rr}}?EPLoW(lt}0e4NXNO>jH%h@fr7&JuUMBl97;>v^V04
zL%ir^@G4wM7Y2WJ1QW`EU~B?{laqFy9il)6B&O_Wi|$XfRiT)7^6UpRTKSK%$4wrS
zGieN@+*o4DPljTfhp*fh+h~9Zs!17Q#=|$AJ3_u)(ZsB-X%7>3(7s;LxS1c;4>b04
zOnNi9!UX=5mlHnOTK4qm##a7Q{dVKxm48oe$%!V(W!$eWd=d@BT`>w-5ch}!)0^1{
za1a2!si|dPpVu!W!6*ylL^nud$c|RQ{|T{<I0)Q|i2ER43>$D*`mv_#i$>reUkduF
zfI+?lm4LV%@^X9`rm?70<XJ9)pK<f7Kbr1}<=H?q{al`XkY>H?p?IF<qiGq_!D#vh
zs8-UnM;wmhO383947g`b3!l<|Jg2v160BCGP_1}q<=NGQ*^R2CPtIxMztF#&Gq-s0
zVr-Ccn1*x4u}eP4(imcWeDNTI$uhQ3`2DB}2DWUFWoXvRa(Pxy%pURrFs0dkPgyyv
zY5t%WAQEY|4<VSt8dR3#V>#B0nJwd(HDGpqtXpJrNQz+EEjn_ni)OtnpJytXt<1Ce
z(QGKst}u9fNscX`Ss%N4kj+INJi@907cQ#2-aKjX<NA*FEI+CLpuNvOK_{l@hFLvg
z*gsl%uKf{?y{(;De!Oyj=Q0P2!}C4`qU`(!_z8VzeiuJcd3pYF&W~zq!A$^dUa+hw
z;*%j~mxW9jUiwcLJdN$ob}t0Qp6*G$<TyzSeAy-IWgs(Um63D(lLRbltpeF8TV+Q2
z<&su&{S$h$XWr6?q)n;_FHm9_#F<+VWtat%VDJJl7&)`#w$)|n>u|BsZHwmWvpom-
z-&FQ2dQNm2<pL!edvG1PwCbW+lkC*04N|r*`6T~q{qmBJw>)pu%Yd&(L7X8wJ_Mhv
z>YHOXMvCABd&It2kdUr_vU2;1>v;Pm8wUh7fN)eG!2>}b&n;~*(yNY%M^0|+PjUW2
zMGo}GmPbNSlpq$7NGS;w#g(b3pisRgK#Dj>R1-`4&sTO2&g1+aDu-6)Ip3#$e)W&=
z`|zq&?we?K(0;tBf4*uh!u-l1)jc7qcY8{ZQ7lAjjEo>q#?j6?(vkKxsETF1W9Z-b
z-|0^e|D?fGGFiVH6$<x;G5@F@2v2sJg9>oQq{;z~x|S*H0h%TJ<GOG4y$F@ZS9c+9
zURk}9^tyJ<ors$suW7-?i8W!p@l?5l@V8}JX5gRhwX;F*o)vm*R%q9{**I*S75ePD
zRkP?&zkY5qG7WJBLx$FW5?X(AeH%Ynd2;=cSo$p<q|g+H96i@L{pHbrMNn_~$bI~R
zKKGHUnkEE%ihO#M!!bzNPx0^_-M`^Veok-MuxnWq9q4k%X@|J-N($aGfrhNuBMySO
zbgIFfh9^(zxz~QBeL|F!Ga$g+p_{oB@eckZXG%YFZPyk1s!~b1NigVjsPDu;6@w6Q
z@cPOd8g+K#V$AirjYCOuQ_ymy{TKAq#!sc913@IDA@=Q!Pvgvfc-_73`6!Cc>*4E%
zic^Rb3LJ><5xY<UwKDB-kC+t7)37EAaA<iG8XoFXSMz=`MT&_5AYtSKpoITy(?L;B
zQlQLda6EKEc17{MB~?Rrpdzh_tPTkpDbZAFgso29@L{L~o}hoK>XHfK9g7?>9ywwh
zWU=IvNm~>-KHcLxtzu^9T)2Ilg>p>U^UM^E!uT%w)3Y!+aKteAvRe7EhS9u?WGc#~
zJ<2_d3LIX%c(M3JG`WN>V>J*#q&xDL{r9afO`mmGd10{-zKaqvDm|jQ=xiflUn<bz
zZHJ)jL%+8TbV9m&15_6p@F4=@-SXamT0+K5Gl;=le_y48Ix%c6FjG#qkjf+~7OpHH
zl|uFXT=^syvcz^(U!WG%!d+wGDOOMoGJ-T}RVN#X|4_N48l!M58+oOwK&a7J%ghk&
zMPDyT%FbcYey@N!`I}jTE3(CVS<;s-5*o3L|27<pR4-;{X}(t@mT-Y}*QH)~e@a?2
zO2(>67N;Hi{#eFmSc>1q?wZ-fUv;HD!;-%rmcPo;nc*n5haKCLR}H2*S!|HeV)i(i
z<z!5zbAu*IA*o=FbP$(8BMlbnn@xElOMCNzW~^}S4W<lQ5W3dLivRxl%CgFq@b+R7
zRxxNL8hr7Zv@IJa%c`x6`_m{}%c`}kl{FynCD$XmgLWFSfmt;LowVu*x@cG$e1L|<
zfuv!15I|O1)@dyvsjix$v$C$5n(NGkPe2OZmO3dZbd*a7=`P%$4q9^ALPN8GwgVc?
zxReC`fB^>px0Fk;#9TI$Dp1{V@s0L%W!#dsQi%wXvb6+*vSkf?>^5P8;B#c_mJ&5c
z@Yz|8oJZM7T6-y3o`G^QzKOE6Et{)AWDXEPzjA2+U4$(=svG!T2G{Ba6{wc#hA)QU
z3EI$at)|xldP{J0-N>RMnguNI<Kmmuf7YZ^JVO8l1!n-6I;?%&NGJIXi?{8R^dW#l
z#^6%l3&Y2UXobfU$!TzKV9<r8UX+BO3wA7(z>W!>luDK9>$%9tGVHl3jlDXe%Bl=}
z>z0u=v9gq3hVL-*RXyMar9(Afnj|#ZaaCg#r%5%{aHN_;Q~cqZxs3nt7AmXs%t@g?
zCN+!AIH4MVw8LS_Ok`4Al1f>eaBGBt*B1bsGEM?IwMbGYE1`*MizqBfED``WOK8+0
zNtvvK9;&^@f_SC@wxCwLTtujqRHwNgXqBN&8=|fx+Yu)v9BiDlMm%E=4rwzcw;Q86
z$RZUVKx4@y7~n#nv+&CF3;|MfW7uvcDu=X97;V!=Ti390NX5~F(J^gwOd7`MBBfPU
zaGbIS@QTG?3~Y8`8(a>b&>2{y7rsO#6u?E7z)b0TZn&#G>bt1U(z!%lCcoS0!%{bP
z7PB}4Jmie?3rU(i_D4_NkMF2)o_t2cc+o;-r^+ve=?mNsGf`cR(d*H45yy8Lg_d<`
zsU{*5m?}OS7*AXgxOnlRsqEm8QqE!J&eU{w)|&3tYC4|t$}k59GIH$j<RWv^skT$=
zi|f(@8~kVJ`aluH^I3kmg76VpbaNQnjz{ds0(_#$I5p(sSDWC3)iLwI4^#TMg|`7T
z8|%;};^v~k8svDmKre_ryS7K!BHE+3Aw7CyXJze;#|1y8TR!$IKUO*Uu}wDrStWn-
zM+JtdO??>jk<IsDF?8!~4u4rcyybrWqV6jU<9BOee)c6}gN4uNHQC-Zzw<xAe+|j_
zcm0?2_YKOw<8AXLof&Jv?}D*z{))bCY<|y+RU*7n$G_>%u)vFe*_w>rJL6#Uow45f
zR|!3tK>*OL@cmcy>9LPD|1CkO*ByD{KVE+JW+c6k`L9(*Kfj5-jQ;EkyE$a`-?^%_
z%97r-rB&1N=?DE6_1Evb0yt0JxhflJR7H6;xT^T2pEVpIl;qY0K)GrwseaSe`3oau
zBg9DAfYBR*RkMRpi)(@M(XC(P|5#DmMm&B>-+uQ_{GPpg9)7(YH{<uSJ38_E)g3n^
lPZ@7G(Ee2AUv_la{GTfP%UfK2rZV=m*KB^eGQ6iV^S@LQ4h{eS

delta 4546
zcmd5<eQ;FO6~Fhsx9{y{H|z@}A>@O(`yjH3gwUwFaRW&nA$&*?v~{W?Uo&>pjasdM
z11-%`f~F-}$PJ@oZKV#*U|U<-jcq!^lvJXi1;t1aEzZztYi3MmwB--5(e`)l+YP3Z
z)_*&hynF9C_nh-PANSn5M^1}(21SHzeBd6=7~_xfvb~X8_HMaGtY5eHIj__VMx%}s
zb&86nPIHP&N}On^Gu_Ds`3hkkd{V4aUoje85e_h~%MP2&E2B@4)`N_`2RRXH)h~>>
zoqx<^GR$Lfaq$OT8Rm>H$0jZ_Kb*krnz-zqxa^s@-1FI`#}cBC2p*Hb*J(TN5CWGc
z#04^`$z?t<;e*noV4kFbY0@Ce(=<9w<9U)sIFY1LYLdwB>WPd)ndiKt-Z%G(E?aF2
zJVQgw`VtLWtOGPu+DRI2vfF5Q!fwZq{gYk8d94bE5=3kZT|KkQzB?_s^9(r^4&Tjr
zC)_mCuJD+bvDLoNHFL%Uc6fVu+BrzOz;8&1Qx--9VSq-&=#Zs832n3vTM2R6QnweZ
zs)v|sI?s_vdm%{)+8vgr^W&Tvh#%78Db{bPz2Q>zbH{SWG^vSyj8TfgU$!y!>7sr3
z9$(Zq#!~E(rDV8NT(neUcxKZf%M(iqnP`Q9&$kE&6D;;^c-~r4XoO*jr`Yor)EISa
zkGQPxvkqu?X)p6GT50ELawB4d$#xuiJp(|%GycO!c{Nb?lUEc;!*kNkvszSyrSOd9
zg<P}LP-MOi8vm?KD5Ie9@u2BgLqO}y2klxNv`nTeh#JIp!`m;?vta~DZ6{2y{6922
zT3FV3*g}#y{jaD<lS6}6hZkBAe!W0goyPWATA3$1T*KE(VTcQoii={`ged-3RJZ|T
zJwbFKSq;D>8QBNgF_35s_>v=9lDSqoAuwO3)s1SR>DnNUA{(MrvO2`h<4X}*;UP&T
z2JI+g5sqZ&$a6pPW?EV@;0%!8F$(zAsNA?PWkBtmva&Pa93~Ewnt2BcmQ%_k5D#k8
zK^O4i;w-9y=z#>Lq$1)5y#0?@D?r7{ajpD{NmTrMRI1o}o@@f+IZFm*AS<n`^INi5
zt~20+iDb2gtn)MCQ1NImLso~&y~}Whpo&~mtBaD!0BXEK20Xr`A|WCW0f7R7*jx}X
z%C|&_?oY8wZHS620?*ZUr_AiP3VFUvI{PghGrxGC$EX#|4eh4UbPIMnLxc%Ot$wK2
z4P#_%9i80*8J6K58IlFPnz*6D4XaoI2pB?00y>5ak=$bE=(vi<oL|!%TzFnU+{#JV
z<HrY{#+w6xj!xlm^8QXlgd9gr<{by&vf}}A98no}T>Yvj_J8H@J^#gFo$}*2V8!G0
zcbuA!PWcp*GsYP@C9O|e9W)R}tfZWO&RM=RwWL!Eo}h{%(NmTi7&mhQ)gmO9fmJw(
zuqf&n&Mji<v6zW}?$d-DfGsdVp^k^5&e%T7aJkRoF*C>7X=6(u#lB6WnKIZ8TkV-v
zkvwHZDZSh~^^mbjV=thaBdW!`5&K?`Z$geoY-|~^msfZN_Yz<IdD=$1KhP*5sNs!8
z)70AHqQp7N$4CXN-8zqh=a7HzSp)?ACn1Vq%|L@d^$RbUc3w~iisyE|L1hRgx$Wc@
zPOk1U1{F9I){6b(%rc*FV4P41{odmjjV3;qST*QaNg-)Uy&@svIlE@s`5hVabqbs+
z*o%MwK{$=nsWl}x_<)-Dd??77XyWs7Ze{EQZveyaZ-Ep`_+}1SDVFr786(9S{pp=4
zb}h~7*prBV%AfXN+T>54htvX^){6cBj-d4RId7B^#1w0x{+j<IPr6lGX&vuU_m>t|
z4M4D2$C{eOLb|D(bnZqORZo}B>U`)^qX`O8Oie6;!KmkRo0y<kjc}3-jhbi;O>7Fy
z>R2MhbiOWFF#sZiqZZv27j&!p(250o>WJkcq#x1^f^OcCU`3djl4Djvn&P4?!Dd|N
zPb(9wie_~zm0~fP)w6|7%+*{zFTt+xxeHQkwm)l0v1)XgL6&pJtIh74-eZ=Zq^O{&
z@mdj#Az8KJpom3e$T_2$D(jtLV!L4(kY=rDb%wIrDxc-$XS7g=c8{VH`@*&?a870y
z&TO#x8FgRv8h%opsD4ap4KlhO^;RiM(0P>`l~uA-&t^Kq*_~Hh&H0cTm~$H+RweO<
zV&7(zwD$=a(RS6E_z|!xYHIj!w!Nl@&+~yha;7YjF&XWH)>)1Q)~A#kgNYe3DxJPw
z<<4@3)xT<IhkcQ9>B6~rSC;W(YU!1q@Rzdfb6*lr9;vUuH(q}$e^KqMzj?au>9MG2
zl_9F^C_!0<5d6Kq#G2;o(jj=<K>UKvnQVDtHHX(7$r*^iuH^iwzVE&t0Y84nk`d02
zWluLI4SrNb7R)Huw@(bsi|(Tcc`b4An94btZCNmz^V8Ye7p6Ghqn>L14ZgRuGzZV)
zZopgNyn3poop-Chw7Bsxo;%vzg1|BlFWR{15w0bTv};RSTFY^b_Ne;S_xbB;x_5M{
zHY|&F%ZS1mVayp)qu$$9esU3hT?|}C5M0$L4syz`dUw$d>F=Pf2e3h?<~?q(&$W9S
zv9eGEU2WS5uxS6<3>~LFt-m)$XOS^kD5J>0ciX)pp9=<R-lv|Mlsa$8WP3A{Qims{
z&R#m1hAm5*C&BRI(ph2O$08s-ss6F_R;2a%W##-#_O4}vM&Wxr7QqwP<FSx8q7q;H
zE9$0d<wN{}I<WGp;xUf!qw^leDAD={xc8y@VC5J1h^o52yTPv<1d5_}h`XU)7lG9$
zN}s=<Lb<g4QjQfO=x5ZM*Y8|6#(Q16Q9!v(XL0_9cKw2eoo;d29@!lr`*`!Cr07|;
zC&wmOR1<x8XP|g!peu<a#<&_-)k?$1t6IXx2n(Kah0Zaxc=eiypClAgA)x$Z^$}#Y
z<Axo<QNIXB)rA{cI=fM5<5x;XxVCbGXgu(+OSmBg5B;+M<hS8*MYroBp48B#Xv8L9
z<BcK%P%;0tMsK?`wM24{9$|P_x_n=+o8N8&BCSbm3Vu|eYwG(RRj&qbye_WgAg{xr
zorG?~kHJMB`$ga|l)2`CWWJ;kBP!{Dw5jIt%*|y+KkVsvqEh=%=Xj?Wc%P}dwN=?U
zYhM@qxVp6d1%5nxc*A;&{~=p>$4vsm*YB#wpq}pd78bF)ziRW}tA`)>4u4q{ZED5$
z#!b~_ujtg95fNToR=4=e|BPK~k%1pMuc+_oEvGg~{)+l&({y}8o8$b1YS>&|`*KbQ
zKjH#UIG0u6X4R~om`T@I0BUw@t}A+#wuht0e;dO=cV1OTHs4(O8d0eR+WJ3w?S-|-
zpU0e2*}5(3sp~xQ;BF3^GqyI*$f=~CebUUMJhI<;S>3nw3ha4oYjc^8D7R%ec2(y$
z-<mo|TmH6nj_m_vD!RF}(EkC0mjzxbCsgyc>Y5x^Yxm*D7{VdVyk}a(gsz@#5Arv&
z<~Q0x{H$8mwH@D=x@P11LDyP*m+z{=_l{jRhR^Ew*zo6Uc4*g3i@%+HclTXEelEMR
O@3h6=%DUgLivAk}eKfuR

diff --git a/dotbot/tests/test_controller.py b/dotbot/tests/test_controller.py
index d3295d37..88fba246 100644
--- a/dotbot/tests/test_controller.py
+++ b/dotbot/tests/test_controller.py
@@ -1597,17 +1597,12 @@ async def test_a_resend_that_fails_drops_the_command(controller, clock):
 
 
 def _old_calibration_settings(tmp_path, **kwargs):
-    """Settings loading the wire fixture, made 2026-09-10, by path, with its
-    stations renumbered 0 and 1: a robot advertises the stations it holds in
-    one byte, stations 0 to 7."""
+    """Settings loading the wire fixture, made 2026-09-10, by path: stations
+    2 and 8."""
     from dotbot.tests.lh2_wire_fixture import FIXTURE_TOML
 
     path = tmp_path / "calibration.toml"
-    path.write_text(
-        FIXTURE_TOML.replace("index = 2\n", "index = 0\n").replace(
-            "index = 8\n", "index = 1\n"
-        )
-    )
+    path.write_text(FIXTURE_TOML)
     return ControllerSettings(
         port="/dev/null",
         baudrate=115200,
@@ -1654,7 +1649,7 @@ def test_robots_holding_stations_the_calibration_does_not_solve_are_warned_once(
         _old_calibration_settings(tmp_path, lh2_calibration_max_age_days=0)
     )
     solved = sorted(station.index for station in controller.lh2_calibration)
-    first, second = sorted(set(range(8)) - set(solved))[:2]
+    first, second = sorted(set(range(16)) - set(solved))[-2:]
     held = sum(1 << index for index in solved)
     with capture_logs() as logs:
         for bot in (BOT, BOT + 1, BOT + 2):
diff --git a/dotbot/tests/test_dotbot_simulator.py b/dotbot/tests/test_dotbot_simulator.py
index e35f6a55..e93f243f 100644
--- a/dotbot/tests/test_dotbot_simulator.py
+++ b/dotbot/tests/test_dotbot_simulator.py
@@ -562,7 +562,8 @@ def test_a_robot_given_a_heading_starts_tracking_it_where_it_was_put(tmp_path):
 
 
 @pytest.mark.parametrize(
-    "calibrated, expected", [(None, [0xFF, 0x05]), (0b11, [0b11, 0x05])]
+    "calibrated, expected",
+    [(None, [0xFFFF, 0x05]), (0b11, [0b11, 0x05]), (0x0104, [0x0104, 0x05])],
 )
 def test_a_robot_holds_the_controllers_stations_unless_its_file_says(
     calibrated, expected
diff --git a/dotbot/tests/test_protocol.py b/dotbot/tests/test_protocol.py
index 0d9ca5de..47e4b810 100644
--- a/dotbot/tests/test_protocol.py
+++ b/dotbot/tests/test_protocol.py
@@ -981,7 +981,7 @@ def test_advertisement_waypoint_report():
         report=True,
     )
     data = advert.to_bytes()
-    assert len(data) == 41
+    assert len(data) == 42
     parsed = PayloadDotBotAdvertisement().from_bytes(data)
     assert parsed.has_report
     assert (parsed.waypoint_idx, parsed.waypoints_status, parsed.waypoints_reason) == (
@@ -993,7 +993,7 @@ def test_advertisement_waypoint_report():
     assert (parsed.axle_x, parsed.axle_y) == (1234, 567)
 
     legacy = PayloadDotBotAdvertisement(direction=-90, waypoint_idx=1).to_bytes()
-    assert len(legacy) == 33
+    assert len(legacy) == 34
     parsed = PayloadDotBotAdvertisement().from_bytes(legacy)
     assert not parsed.has_report
     assert parsed.waypoint_idx == 1 and parsed.batch_id == 0
diff --git a/dotbot/tests/test_sim_core.py b/dotbot/tests/test_sim_core.py
index 31319399..f89d4790 100644
--- a/dotbot/tests/test_sim_core.py
+++ b/dotbot/tests/test_sim_core.py
@@ -179,10 +179,10 @@ def test_the_advertisement_starts_the_encoder_deltas_over():
     second = core.advertisement(0, 2900)
     assert len(first) == control.ADVERTISEMENT_BYTES
     # Type, calibration, direction, x, y, battery, duties, mode, then the deltas
-    assert int.from_bytes(first[17:21], "little", signed=True) == 7
-    assert int.from_bytes(first[21:25], "little", signed=True) == -3
-    assert int.from_bytes(second[17:25], "little") == 0
-    assert int.from_bytes(first[12:14], "little") == 2900
+    assert int.from_bytes(first[18:22], "little", signed=True) == 7
+    assert int.from_bytes(first[22:26], "little", signed=True) == -3
+    assert int.from_bytes(second[18:26], "little") == 0
+    assert int.from_bytes(first[13:15], "little") == 2900
 
 
 def test_a_seeded_robot_tracks_the_pose_it_is_given():
@@ -206,7 +206,10 @@ def test_the_batched_advertisements_are_those_the_step_asked_for():
     indices, packets = core.advertisements(np.array([3000, 3001, 3002, 3003]))
     assert indices.tolist() == [1, 3]
     assert packets.shape == (2, control.ADVERTISEMENT_BYTES)
-    assert [int.from_bytes(p[12:14], "little") for p in packets] == [3001, 3003]
-    assert [int.from_bytes(p[17:21], "little") for p in packets] == [11, 13]
+    assert [int.from_bytes(p[13:15], "little") for p in packets] == [3001, 3003]
+    assert [int.from_bytes(p[18:22], "little") for p in packets] == [11, 13]
     empty_indices, empty_packets = core.advertisements(np.zeros(4))
-    assert empty_indices.size == 0 and empty_packets.shape == (0, 42)
+    assert empty_indices.size == 0 and empty_packets.shape == (
+        0,
+        control.ADVERTISEMENT_BYTES,
+    )

From c4631991cab5df95c38540630d844391c4245d91 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:35:46 +0200
Subject: [PATCH 23/80] dotbot/calibration: fix a spin calibration to the floor
 with anchor robots

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/conics.py                  |  12 +-
 dotbot/calibration/multi_station.py           | 159 +++++++++++++++++-
 .../tests/test_calibration_multi_station.py   |  84 +++++++++
 3 files changed, 243 insertions(+), 12 deletions(-)

diff --git a/dotbot/calibration/conics.py b/dotbot/calibration/conics.py
index 6a2806dc..31425a0c 100644
--- a/dotbot/calibration/conics.py
+++ b/dotbot/calibration/conics.py
@@ -35,7 +35,7 @@
 from dotbot.site import Site, starter_layout
 
 if TYPE_CHECKING:
-    from dotbot.calibration.multi_station import JointSolution
+    from dotbot.calibration.multi_station import Anchor, JointSolution
 
 # Post-rectification minor/major axis ratio under which a track is not a circle.
 TRACK_AXIS_RATIO_MIN = 0.95
@@ -702,6 +702,7 @@ def solve_calibration(
     robot: str = ROBOT_DEFAULT,
     tag: str = "",
     drop_stations: Sequence[int] = (),
+    anchors: Sequence[Anchor] = (),
 ) -> tuple[Calibration, JointSolution, dict[int, str]]:
     """A free-mode calibration from circle tracks, every station in one frame.
 
@@ -710,7 +711,8 @@ def solve_calibration(
     is not tied to the rest raises `MultiStationError` unless it is in
     `drop_stations`. Returns the calibration, the joint solution, and why
     each station with tracks was not solved. The calibration records
-    `site`'s name only, with `FREE_FRAME_ANCHOR` for its anchor.
+    `site`'s name only, with `FREE_FRAME_ANCHOR` for its anchor; with
+    `anchors` it is in `site`'s own frame and records `site`'s anchor.
     """
     # pylint: disable=import-outside-toplevel,cyclic-import
     from dotbot.calibration.multi_station import solve_joint, tracks_by_station
@@ -722,8 +724,12 @@ def solve_calibration(
         by_station,
         margin_mm=robot_geometry(robot).axle_reach_mm,
         drop=drop_stations,
+        anchors=anchors,
     )
     solved_from = "conics-joint" if joint.joint else "conics-free"
+    anchor = FREE_FRAME_ANCHOR
+    if joint.anchored:
+        solved_from, anchor = "conics-anchored", site.anchor
     stations = [
         StationSolution(
             index=station,
@@ -737,7 +743,7 @@ def solve_calibration(
     ]
     now = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
     calibration = Calibration(
-        site=Site(name=site.name, anchor=FREE_FRAME_ANCHOR),
+        site=Site(name=site.name, anchor=anchor),
         valid_mm=joint.valid_mm,
         stations=stations,
         tracks=list(samples),
diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index 15858573..1e7b0ebd 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -48,6 +48,7 @@
 from dotbot.robots import robot_geometry
 
 __all__ = [
+    "Anchor",
     "CircleKey",
     "ErrorMap",
     "JointSolution",
@@ -80,6 +81,10 @@
 TIE_GATE_MIN = 4
 TIE_ROUNDS_MAX = 4
 
+# Anchors spread less than this share of the fence's diagonal hold the
+# frame's yaw over too short a baseline.
+ANCHOR_SPAN_SHARE = 0.5
+
 # Huber threshold on the radial residual, mm.
 ROBUST_MM = 5.0
 # Weight of the prior holding the root station's centres where the seed put
@@ -166,12 +171,29 @@ class JointSolution:
     # Per link (a, b): rms centre disagreement after the seed, before refinement.
     seed_disagreement_mm: dict[tuple[int, int], float] = field(default_factory=dict)
     warnings: list[str] = field(default_factory=list)
+    # Per anchor: its known point and how far the solve puts its spin from it.
+    anchor_residuals: dict[CircleKey, float] = field(default_factory=dict)
+    # Scale of the best similarity from the solved anchors to the known
+    # points: 1 when the spin radius and the floor agree.
+    anchor_scale_ratio: float | None = None
+
+    @property
+    def anchored(self) -> bool:
+        return bool(self.anchor_residuals)
 
     @property
     def joint(self) -> bool:
         return len(self.homographies) > 1
 
 
+@dataclass(frozen=True)
+class Anchor:
+    """A robot that spun with its pivot on a known floor point, site mm."""
+
+    key: CircleKey
+    point_mm: tuple[float, float]
+
+
 class MultiStationError(ValueError):
     """The stations cannot be put in one frame: an island, or a weak tie."""
 
@@ -749,6 +771,30 @@ def solve_joint(
     margin_mm: float | None = None,
     rect_margin_mm: int = RECT_MARGIN_MM,
     drop: Collection[int] = (),
+    anchors: Sequence[Anchor] = (),
+) -> JointSolution:
+    """Every station's homography in one metric frame, from circle tracks.
+
+    Without `anchors` the frame is free mode's (see `_solve_free`). With two
+    or more, the free solution is moved by the one rigid motion that best
+    puts the anchors' spin centres on their known points: the spin radius
+    keeps setting the scale, and how far the anchors disagree with it is
+    reported, never absorbed.
+    """
+    joint = _solve_free(
+        tracks, margin_mm=margin_mm, rect_margin_mm=rect_margin_mm, drop=drop
+    )
+    if not anchors:
+        return joint
+    return _anchored(joint, tracks, anchors, rect_margin_mm)
+
+
+def _solve_free(
+    tracks: Mapping[int, Sequence[Track]],
+    *,
+    margin_mm: float | None = None,
+    rect_margin_mm: int = RECT_MARGIN_MM,
+    drop: Collection[int] = (),
 ) -> JointSolution:
     """Every station's homography in one metric frame, from circle tracks.
 
@@ -906,6 +952,98 @@ def solve_joint(
     )
 
 
+def _anchored(
+    joint: JointSolution,
+    tracks: Mapping[int, Sequence[Track]],
+    anchors: Sequence[Anchor],
+    rect_margin_mm: int,
+) -> JointSolution:
+    if len(anchors) < 2:
+        raise ValueError(
+            f"{len(anchors)} anchor(s): two or more fix the frame to the floor"
+        )
+    missing = [a for a in anchors if a.key not in joint.centres]
+    if missing:
+        raise ValueError(
+            "no station kept the spin of anchor(s) "
+            + ", ".join(_key_text(a.key) for a in missing)
+        )
+    got = np.array([joint.centres[a.key] for a in anchors])
+    want = np.array([a.point_mm for a in anchors], dtype=float)
+    T = similarity(got, want, scale=False)
+    S = similarity(got, want, scale=True)
+    H = {s: (T @ Hs) / (T @ Hs)[2, 2] for s, Hs in joint.homographies.items()}
+    centres = {k: apply(T, v[None, :])[0] for k, v in joint.centres.items()}
+    kept = {
+        s: [t for t in tracks[s] if t.key in {f.key for f in sol.tracks}]
+        for s, sol in joint.solutions.items()
+    }
+    rectangles = {}
+    for s, sol in joint.solutions.items():
+        why = {t.key: t.why for t in sol.dropped}
+        out = [t for t in tracks[s] if t.key in why]
+        sol.homography = H[s]
+        sol.tracks = fit_tracks(kept[s], H[s])
+        sol.dropped = fit_tracks(out, H[s], {t: why[t.key] for t in out})
+        rectangles[s] = _rect_around(
+            np.array([t.centre_mm for t in sol.tracks], dtype=float), rect_margin_mm
+        )
+    valid = union_rect(rectangles.values())
+    warnings = list(joint.warnings)
+    span = _spread(want)
+    diagonal = math.hypot(valid[2] - valid[0], valid[3] - valid[1])
+    if span < ANCHOR_SPAN_SHARE * diagonal:
+        warnings.append(
+            f"the anchors span {span:.0f} mm, under half the fence's "
+            f"{diagonal:.0f} mm diagonal: the frame's yaw is held over a short "
+            "baseline; put anchors at the ends of the longest path across "
+            "the stations"
+        )
+    residuals = {
+        a.key: float(np.linalg.norm(apply(T, g[None, :])[0] - w))
+        for a, g, w in zip(anchors, got, want)
+    }
+    return JointSolution(
+        homographies=H,
+        centres=centres,
+        rectangles=rectangles,
+        valid_mm=valid,
+        field_mm=joint.field_mm,
+        graph=joint.graph,
+        loops=joint.loops,
+        station_rms_mm=joint.station_rms_mm,
+        scale_ratio=joint.scale_ratio,
+        dropped=joint.dropped,
+        error_map=_map_from(H, kept, rectangles),
+        solutions=joint.solutions,
+        unsolved=joint.unsolved,
+        seed_disagreement_mm=joint.seed_disagreement_mm,
+        warnings=warnings,
+        anchor_residuals=residuals,
+        anchor_scale_ratio=float(math.sqrt(abs(np.linalg.det(S[:2, :2])))),
+    )
+
+
+def _map_from(
+    H: Mapping[int, np.ndarray],
+    kept: Mapping[int, Sequence[Track]],
+    rectangles: Mapping[int, Sequence[int]],
+    cell_mm: float = ERROR_MAP_CELL_MM,
+) -> ErrorMap:
+    """The error map of homographies `H` over the kept tracks, every circle
+    seen by several stations tying them."""
+    world = {
+        s: {t.key: _circle_fit(apply(H[s], t.points))[0] for t in kept[s]} for s in kept
+    }
+    tied: dict[CircleKey, set[int]] = {}
+    for s, centres in world.items():
+        for k in centres:
+            tied.setdefault(k, set()).add(s)
+    root = min(kept, key=lambda s: (-len(kept[s]), s))
+    problem, x = _build_problem(kept, world, tied, dict(H), root)
+    return _error_map(problem, x, rectangles, cell_mm)
+
+
 def _depth(parent: Mapping[int, int], s: int) -> int:
     depth = 0
     while parent[s] != s:
@@ -1008,24 +1146,17 @@ def error_map_from_calibration(
     }
     if not by_station:
         return None
-    kept, world = {}, {}
+    kept = {}
     for s, tracks in by_station.items():
         H = stations[s].matrix
         gate = health_gate(tracks, H)
         kept[s] = [t for t in tracks if t not in gate and len(t.points) >= 6]
-        world[s] = {t.key: _circle_fit(apply(H, t.points))[0] for t in kept[s]}
     kept = {s: t for s, t in kept.items() if t}
     if not kept:
         return None
-    tied: dict[CircleKey, set[int]] = {}
-    for s, centres in world.items():
-        for k in centres:
-            tied.setdefault(k, set()).add(s)
     H = {s: stations[s].matrix for s in kept}
-    root = min(kept, key=lambda s: (-len(kept[s]), s))
-    problem, x = _build_problem(kept, world, tied, H, root)
     rectangles = {s: stations[s].valid_mm for s in kept}
-    return _error_map(problem, x, rectangles, cell_mm)
+    return _map_from(H, kept, rectangles, cell_mm)
 
 
 def appendable_rounds(calibration: Calibration) -> int:
@@ -1132,6 +1263,16 @@ def multi_station_report(
                 before = joint.seed_disagreement_mm.get((link.a, link.b))
             lines.append(_link_line(link, before))
     if joint is not None:
+        for key, residual in joint.anchor_residuals.items():
+            lines.append(
+                f"anchor {_key_text(key)}: its spin is {residual:.1f} mm from "
+                "its known point"
+            )
+        if joint.anchor_scale_ratio is not None:
+            lines.append(
+                f"anchor scale ratio {joint.anchor_scale_ratio:.4f}: 1 when the "
+                "spin radius and the floor agree"
+            )
         for cycle, closure in joint.loops:
             path = " - ".join(str(s) for s in cycle + cycle[:1])
             lines.append(f"loop {path}: closure {closure:.1f} mm")
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
index a916965a..e7fac555 100644
--- a/dotbot/tests/test_calibration_multi_station.py
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -548,3 +548,87 @@ def test_stations_2_and_8_reach_the_wire_and_the_page_by_slot(tmp_path):
         assert struct.unpack("<4I", rect) == station.valid_mm
     assert page[848:864] == b"arena".ljust(16, b"\x00")
     assert page[864:872] == bytes.fromhex(back.id[:16])
+
+
+def _absolute_error(joint, stations, centres):
+    """rms mm between the solve and the true floor, with no alignment at all."""
+    errors = []
+    for st in stations:
+        P = F.grid_in(st)
+        seen = np.array([c for c in centres if st.sees(c)])
+        P = P[np.min(np.linalg.norm(P[:, None] - seen[None], axis=2), axis=1) <= 500]
+        got = apply(joint.homographies[st.index], apply(st.floor_to_cam, P))
+        errors.append(np.linalg.norm(got - P, axis=1))
+    return float(np.sqrt(np.mean(np.concatenate(errors) ** 2)))
+
+
+def test_anchored_multi_spread_anchors_recover_the_true_frame():
+    a, b = two_stations()
+    centres = floor_grid([a, b])
+    tracks = F.spins([a, b], centres, noise=1.0, seed=6)
+    # four robots at the far corners of the floor, two under each station
+    corners = []
+    for target in ((0, 300), (0, 2800), (3500, 300), (3500, 2800)):
+        i = int(
+            np.argmin([np.hypot(c[0] - target[0], c[1] - target[1]) for c in centres])
+        )
+        corners.append(i)
+    anchors = [
+        ms.Anchor(ms.CircleKey(f"R{i:02d}", 0), tuple(centres[i])) for i in corners
+    ]
+    assert {a.sees(centres[i]) for i in corners} == {True, False}
+    joint = ms.solve_joint(tracks, anchors=anchors)
+    assert joint.anchored
+    assert _absolute_error(joint, [a, b], centres) < 2.0
+    assert all(r < 5.0 for r in joint.anchor_residuals.values())
+    assert joint.anchor_scale_ratio == pytest.approx(1.0, abs=0.002)
+    assert not any("anchors span" in w for w in joint.warnings)
+
+
+def test_anchored_multi_clustered_anchors_are_warned_about():
+    a, b = two_stations()
+    centres = floor_grid([a, b])
+    tracks = F.spins([a, b], centres, noise=1.0, seed=6)
+    near = sorted(
+        range(len(centres)),
+        key=lambda i: np.hypot(*np.subtract(centres[i], (300, 800))),
+    )[:4]
+    anchors = [ms.Anchor(ms.CircleKey(f"R{i:02d}", 0), tuple(centres[i])) for i in near]
+    joint = ms.solve_joint(tracks, anchors=anchors)
+    assert any("anchors span" in w for w in joint.warnings)
+
+
+def test_anchored_multi_report_shows_a_scale_disagreement():
+    a, b = two_stations()
+    centres = floor_grid([a, b])
+    tracks = F.spins([a, b], centres, noise=0.5, seed=7)
+    corners = [0, len(centres) - 1, 3, len(centres) - 4]
+    # the floor marks are 1 % further apart than the robots' circles say
+    anchors = [
+        ms.Anchor(ms.CircleKey(f"R{i:02d}", 0), tuple(1.01 * np.array(centres[i])))
+        for i in corners
+    ]
+    joint = ms.solve_joint(tracks, anchors=anchors)
+    assert joint.anchor_scale_ratio == pytest.approx(1.01, abs=0.002)
+    calibration, _, _ = conics.solve_calibration(
+        F.samples(tracks), Site(name="arena", anchor="door corner"), anchors=anchors
+    )
+    assert {s.solved_from for s in calibration.stations} == {"conics-anchored"}
+    assert calibration.site.anchor == "door corner"
+    text = "\n".join(ms.multi_station_report(calibration, joint))
+    assert "anchor scale ratio 1.01" in text
+
+
+def test_anchored_multi_needs_two_anchors_the_stations_kept():
+    a, b = two_stations()
+    tracks = F.spins([a, b], floor_grid([a, b]))
+    with pytest.raises(ValueError, match="two or more"):
+        ms.solve_joint(tracks, anchors=[ms.Anchor(ms.CircleKey("R00"), (0, 0))])
+    with pytest.raises(ValueError, match="NOPE"):
+        ms.solve_joint(
+            tracks,
+            anchors=[
+                ms.Anchor(ms.CircleKey("R00"), (0, 0)),
+                ms.Anchor(ms.CircleKey("NOPE"), (1, 1)),
+            ],
+        )

From 9a24167d6c67c50ce263aff8ab4c48e8424b525e Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:35:46 +0200
Subject: [PATCH 24/80] dotbot/cli: add collect --spin --anchor

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/swarm_lh2.py               | 66 +++++++++++++++++++++++----
 dotbot/tests/test_calibration_spin.py | 32 +++++++++++++
 2 files changed, 89 insertions(+), 9 deletions(-)

diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 9b232cf2..7cc2d940 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -331,6 +331,20 @@ def _await_point(session, stream, arrivals: queue.Queue):
         "to the others, or a weak tie the report names."
     ),
 )
+@click.option(
+    "--anchor",
+    "anchors",
+    multiple=True,
+    callback=lambda _ctx, _param, values: [_parse_anchor(v) for v in values],
+    metavar="ADDRESS=X,Y",
+    help=(
+        "With --spin: this robot spins with its pivot on the known site "
+        "point X,Y mm, repeatable. Two or more put the calibration in the "
+        "site's own frame instead of free mode's; spread them across the "
+        "whole site, since anchors bunched together leave the far end's yaw "
+        "loose."
+    ),
+)
 @click.pass_context
 def _collect(
     ctx,
@@ -350,6 +364,7 @@ def _collect(
     spin_radius,
     drop_stations,
     append,
+    anchors,
 ):
     if spin:
         given = [
@@ -379,6 +394,7 @@ def _collect(
             spin_radius,
             drop_stations,
             append,
+            anchors,
         )
         return
     if spin_radius is not None:
@@ -387,6 +403,8 @@ def _collect(
         raise click.UsageError("--drop-station goes with --spin")
     if append is not None:
         raise click.UsageError("--append goes with --spin")
+    if anchors:
+        raise click.UsageError("--anchor goes with --spin")
     if _devices(ctx):
         raise click.UsageError(
             "`dotbot swarm -d` picks the robots of push and collect --spin; a "
@@ -528,6 +546,17 @@ def read_enter() -> None:
             )
 
 
+def _parse_anchor(value: str) -> tuple[str, tuple[float, float]]:
+    try:
+        address, point = value.split("=", 1)
+        x, y = (float(v) for v in point.split(","))
+    except ValueError as exc:
+        raise click.BadParameter(
+            f"{value!r} is not ADDRESS=X,Y, a robot and its pivot's point in mm"
+        ) from exc
+    return address.strip().upper(), (x, y)
+
+
 def _collect_spin(
     ctx,
     conn,
@@ -538,11 +567,14 @@ def _collect_spin(
     spin_radius,
     drop_stations=(),
     append=None,
+    anchors=(),
 ):
     """`collect --spin`: spin the robots, solve their circles, save, report."""
     from dotbot.calibration.conics import solve_calibration
     from dotbot.calibration.lighthouse2 import load_calibration, write_calibration
     from dotbot.calibration.multi_station import (
+        Anchor,
+        CircleKey,
         appendable_rounds,
         multi_station_report,
     )
@@ -550,6 +582,8 @@ def _collect_spin(
     from dotbot.robots import ROBOT_DEFAULT, robot_geometry
 
     site, site_source = site_from_context(ctx, site_name)
+    if len(anchors) == 1:
+        raise click.UsageError("--anchor takes two or more robots")
     earlier, round_ = [], 0
     if append is not None:
         try:
@@ -600,6 +634,9 @@ def _collect_spin(
             spins = capture_spins(client, robots, echo=click.echo)
         except RuntimeError as exc:
             raise click.ClickException(str(exc)) from exc
+        anchored = [
+            Anchor(CircleKey(address, round_), point) for address, point in anchors
+        ]
         samples = list(earlier) + [
             s for spin in spins.values() for s in spin.samples(spin_radius, round_)
         ]
@@ -610,6 +647,7 @@ def _collect_spin(
                 robot=ROBOT_DEFAULT,
                 tag=tag or "",
                 drop_stations=drop_stations,
+                anchors=anchored,
             )
         except ValueError as exc:
             for line in spin_report(spins, robots.robots, {}, {}):
@@ -617,17 +655,23 @@ def _collect_spin(
             raise click.ClickException(f"no calibration written: {exc}") from exc
         for line in spin_report(spins, robots.robots, joint.solutions, unsolved):
             click.echo(line)
-        if len({s.station for s in samples}) > 1 or earlier:
+        if len({s.station for s in samples}) > 1 or earlier or anchors:
             click.echo("")
             for line in multi_station_report(calibration, joint):
                 click.echo(line)
         path = write_calibration(calibration)
         width, height = joint.field_mm
-        click.echo(
-            f"\nThe robots' field is {width} x {height} mm: the calibration's frame "
-            "is aligned to it, zero at its top-left, not at the site's anchor. "
-            f"Robots take fixes inside {list(calibration.valid_mm)}."
-        )
+        if joint.anchored:
+            click.echo(
+                f"\nThe anchors put the calibration in site {site.name}'s own "
+                f"frame. Robots take fixes inside {list(calibration.valid_mm)}."
+            )
+        else:
+            click.echo(
+                f"\nThe robots' field is {width} x {height} mm: the calibration's "
+                "frame is aligned to it, zero at its top-left, not at the site's "
+                f"anchor. Robots take fixes inside {list(calibration.valid_mm)}."
+            )
         click.echo(f"Calibration saved to {path}")
         click.echo(
             f"Calibration id {calibration.id}, site {site.name}"
@@ -637,9 +681,13 @@ def _collect_spin(
         if push:
             _gated_push(client, calibration, devices=robots.robots, stop=True)
         click.echo(
-            "\nNext, make the field a site of its own (--size WxH centres it in a "
-            "bigger site):\n"
-            f"  dotbot site init <name> --from-calibration {calibration.id8}\n"
+            (
+                "\n"
+                if joint.anchored
+                else "\nNext, make the field a site of its own (--size WxH "
+                "centres it in a bigger site):\n"
+                f"  dotbot site init <name> --from-calibration {calibration.id8}\n"
+            )
             + (
                 ""
                 if push
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index 30273476..b266cf1f 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -600,3 +600,35 @@ def test_show_prints_a_corner_calibration_without_an_error_map(lab, tmp_path):
     assert shown.exit_code == 0, shown.output
     assert "station 2 (channel 3): 4 marked points" in shown.output
     assert "predicted error" not in shown.output
+
+
+def test_collect_spin_with_anchors_writes_a_calibration_in_the_site_frame(
+    monkeypatch, lab
+):
+    a, b = _two_stations()
+    centres = _floor_grid([a, b])[:40]
+    addrs, fleet = _two_station_fleet([a, b], centres)
+    ends = [0, len(centres) - 1, 5, len(centres) - 6]
+    flags = []
+    for i in ends:
+        flags += ["--anchor", f"{addrs[i]}={centres[i][0]},{centres[i][1]}"]
+    result = _collect(monkeypatch, lab, fleet, *flags)
+    assert result.exit_code == 0, result.output
+    assert "anchor scale ratio" in result.output
+    assert "site c405's own frame" in result.output
+    assert "--from-calibration" not in result.output
+    path = Path(re.search(r"Calibration saved to (\S+)", result.output).group(1))
+    saved = lighthouse2.read_calibration_file(path)
+    assert {s.solved_from for s in saved.stations} == {"conics-anchored"}
+    assert saved.site.anchor == "the door corner"
+    cam = conics.apply(a.floor_to_cam, np.array([centres[ends[0]]], dtype=float))
+    got = conics.apply(saved.station(0).matrix, cam)[0]
+    assert np.linalg.norm(got - centres[ends[0]]) < 2.0
+
+
+def test_one_anchor_is_refused(monkeypatch, lab):
+    _, fleet = _fleet()
+    result = _collect(monkeypatch, lab, fleet, "--anchor", "B0B0B0B0B0B0B0B0=1,2")
+    assert result.exit_code != 0 and "two or more" in result.output
+    result = _collect(monkeypatch, lab, fleet, "--anchor", "nonsense")
+    assert result.exit_code != 0 and "ADDRESS=X,Y" in result.output

From a9c171c37ce95b8dc3e9faa58b3da8552323b145 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:57:27 +0200
Subject: [PATCH 25/80] dotbot/calibration: refuse anchors that put a station
 below the site's zero

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/multi_station.py            |  7 +++++++
 dotbot/tests/test_calibration_multi_station.py | 13 +++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index 1e7b0ebd..f4573afa 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -988,6 +988,13 @@ def _anchored(
         rectangles[s] = _rect_around(
             np.array([t.centre_mm for t in sol.tracks], dtype=float), rect_margin_mm
         )
+        rect = rectangles[s]
+        if rect[0] >= rect[2] or rect[1] >= rect[3]:
+            raise ValueError(
+                f"{station_label(s)}: the anchors put its circles below the "
+                f"site's zero, leaving the rectangle {list(rect)}; check the "
+                "anchors' points"
+            )
     valid = union_rect(rectangles.values())
     warnings = list(joint.warnings)
     span = _spread(want)
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
index e7fac555..77828ec6 100644
--- a/dotbot/tests/test_calibration_multi_station.py
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -632,3 +632,16 @@ def test_anchored_multi_needs_two_anchors_the_stations_kept():
                 ms.Anchor(ms.CircleKey("NOPE"), (1, 1)),
             ],
         )
+
+
+def test_anchored_multi_refuses_anchors_that_put_a_station_below_zero():
+    a, b = two_stations()
+    centres = floor_grid([a, b])
+    tracks = F.spins([a, b], centres)
+    # every anchor point 5 m left of where its robot spun
+    anchors = [
+        ms.Anchor(ms.CircleKey(f"R{i:02d}"), (centres[i][0] - 5000, centres[i][1]))
+        for i in (0, len(centres) - 1)
+    ]
+    with pytest.raises(ValueError, match="below the site's zero"):
+        ms.solve_joint(tracks, anchors=anchors)

From 2f2eb7e26515f017ea8cc7dbf9c2ad2453cb282c Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:57:27 +0200
Subject: [PATCH 26/80] dotbot/cli: refuse an anchor robot that would not spin,
 before the spin

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/swarm_lh2.py               | 10 +++++++++-
 dotbot/tests/test_calibration_spin.py | 18 ++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 7cc2d940..cca53e17 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -624,6 +624,13 @@ def _collect_spin(
             raise click.ClickException(f"spin refused:\n{refusal}")
         if not robots.robots:
             raise click.ClickException("no robot answered, so none can spin")
+        spinning = {address.upper(): address for address in robots.robots}
+        absent = [address for address, _ in anchors if address not in spinning]
+        if absent:
+            raise click.ClickException(
+                f"anchor robot(s) {', '.join(absent)} would not spin: they are "
+                "not among the robots ready for the spin"
+            )
         click.echo(
             f"Spin calibration in site {site.name} (from {site_source}): "
             f"{len(robots.robots)} robot(s), spin radius {spin_radius:g} mm "
@@ -635,7 +642,8 @@ def _collect_spin(
         except RuntimeError as exc:
             raise click.ClickException(str(exc)) from exc
         anchored = [
-            Anchor(CircleKey(address, round_), point) for address, point in anchors
+            Anchor(CircleKey(spinning[address], round_), point)
+            for address, point in anchors
         ]
         samples = list(earlier) + [
             s for spin in spins.values() for s in spin.samples(spin_radius, round_)
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index b266cf1f..59f4e628 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -632,3 +632,21 @@ def test_one_anchor_is_refused(monkeypatch, lab):
     assert result.exit_code != 0 and "two or more" in result.output
     result = _collect(monkeypatch, lab, fleet, "--anchor", "nonsense")
     assert result.exit_code != 0 and "ADDRESS=X,Y" in result.output
+
+
+def test_an_anchor_that_would_not_spin_is_refused_before_the_spin(monkeypatch, lab):
+    a, b = _two_stations()
+    addrs, fleet = _two_station_fleet([a, b], _floor_grid([a, b])[:10])
+    result = _collect(
+        monkeypatch,
+        lab,
+        fleet,
+        "--anchor",
+        f"{addrs[0].lower()}=0,0",
+        "--anchor",
+        "B0B0B0B0B0B0B0B0=1,2",
+    )
+    assert result.exit_code != 0
+    assert "B0B0B0B0B0B0B0B0 would not spin" in result.output
+    assert addrs[0] not in result.output.split("would not spin")[0]
+    assert "start" not in [c for c, _ in fleet.calls]

From 36f2f14abd341d8abd2332ba0d4d528061bc13f6 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:40:28 +0200
Subject: [PATCH 27/80] dotbot/calibration: suggest where robots should spin in
 the next round

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/multi_station.py           | 112 ++++++++++++++++++
 .../tests/test_calibration_multi_station.py   |  76 ++++++++++++
 2 files changed, 188 insertions(+)

diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index f4573afa..8fad00a3 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -56,6 +56,7 @@
     "StationGraph",
     "error_map_from_calibration",
     "multi_station_report",
+    "next_round",
     "solve_joint",
     "station_graph",
 ]
@@ -1188,6 +1189,117 @@ def appendable_rounds(calibration: Calibration) -> int:
     return max(t.round for t in calibration.tracks) + 1
 
 
+# --- Active collection ------------------------------------------------------
+
+# Least distance between two suggested spins, mm: closer ones tell the
+# solve little more than one.
+NEXT_ROUND_SPACING_MM = 400.0
+# How far inside an overlap its suggested ends sit, mm.
+NEXT_ROUND_INSET_MM = 150.0
+
+
+@dataclass(frozen=True)
+class SpinTarget:
+    """Where one robot should spin in the next round, and why."""
+
+    point_mm: tuple[float, float]
+    stations: tuple[int, ...]
+    why: str
+
+
+def _covering(
+    rectangles: Mapping[int, Sequence[int]], p, inset: float = 0.0
+) -> tuple[int, ...]:
+    """The stations whose rectangle, shrunk by `inset`, holds `p`."""
+    return tuple(
+        s
+        for s, (x0, y0, x1, y1) in sorted(rectangles.items())
+        if x0 + inset <= p[0] <= x1 - inset and y0 + inset <= p[1] <= y1 - inset
+    )
+
+
+def next_round(
+    error_map: ErrorMap,
+    rectangles: Mapping[int, Sequence[int]],
+    links: Sequence[LinkRecord],
+    robots: int = 4,
+    spacing_mm: float = NEXT_ROUND_SPACING_MM,
+) -> list[SpinTarget]:
+    """Where `robots` robots should spin next to strengthen the calibration.
+
+    First the two far ends of every overlap whose link is under the advised
+    strength (or missing), since a spread pair is what ties two stations;
+    then the cells the error map predicts worst, no two closer than
+    `spacing_mm` and none on a rectangle's edge, where a spinning robot
+    would leave it. Points are in the calibration's frame.
+    """
+    targets: list[SpinTarget] = []
+
+    def free(p) -> bool:
+        return all(math.dist(p, t.point_mm) >= spacing_mm for t in targets)
+
+    strength = {(k.a, k.b): k for k in links}
+    stations = sorted(rectangles)
+    for i, a in enumerate(stations):
+        for b in stations[i + 1 :]:
+            ra, rb = rectangles[a], rectangles[b]
+            ox0, oy0 = max(ra[0], rb[0]), max(ra[1], rb[1])
+            ox1, oy1 = min(ra[2], rb[2]), min(ra[3], rb[3])
+            if (
+                ox1 - ox0 <= 2 * NEXT_ROUND_INSET_MM
+                or oy1 - oy0 <= 2 * NEXT_ROUND_INSET_MM
+            ):
+                continue
+            link = strength.get((a, b))
+            if link is not None and link_advised(link):
+                continue
+            inset = NEXT_ROUND_INSET_MM
+            if ox1 - ox0 >= oy1 - oy0:
+                mid = (oy0 + oy1) / 2
+                ends = [(ox0 + inset, mid), (ox1 - inset, mid)]
+            else:
+                mid = (ox0 + ox1) / 2
+                ends = [(mid, oy0 + inset), (mid, oy1 - inset)]
+            why = f"ties {station_label(a)} and {station_label(b)}, " + (
+                f"now {link.shared} circle(s) over {link.spread_mm:.0f} mm"
+                if link is not None
+                else "not tied yet"
+            )
+            for p in ends:
+                if len(targets) < robots and free(p):
+                    targets.append(SpinTarget(p, _covering(rectangles, p), why))
+    sigma = error_map.sigma_mm
+    order = np.argsort(np.where(np.isnan(sigma), -np.inf, sigma), axis=None)[::-1]
+    for flat in order:
+        if len(targets) >= robots:
+            break
+        row, col = np.unravel_index(flat, sigma.shape)
+        value = sigma[row, col]
+        if np.isnan(value):
+            break
+        p = error_map.centre(int(row), int(col))
+        covering = _covering(rectangles, p, NEXT_ROUND_INSET_MM)
+        if covering and free(p):
+            targets.append(
+                SpinTarget(p, covering, f"predicted error {value:.1f} mm here")
+            )
+    return targets
+
+
+def next_round_lines(targets: Sequence[SpinTarget]) -> list[str]:
+    """The suggestions as the operator reads them."""
+    if not targets:
+        return ["next round: nothing to suggest"]
+    lines = [f"next round, {len(targets)} spin(s), in this calibration's frame:"]
+    for t in targets:
+        seen = ", ".join(str(s) for s in t.stations)
+        lines.append(
+            f"  ({t.point_mm[0]:6.0f}, {t.point_mm[1]:6.0f}) mm, seen by station(s) "
+            f"{seen}: {t.why}"
+        )
+    return lines
+
+
 # --- Report -----------------------------------------------------------------
 
 
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
index 77828ec6..7e54dda7 100644
--- a/dotbot/tests/test_calibration_multi_station.py
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -4,6 +4,7 @@
 `lh2_multi_fixture`), so every number here is in floor millimetres.
 """
 
+import math
 import tomllib
 from pathlib import Path
 
@@ -645,3 +646,78 @@ def test_anchored_multi_refuses_anchors_that_put_a_station_below_zero():
     ]
     with pytest.raises(ValueError, match="below the site's zero"):
         ms.solve_joint(tracks, anchors=anchors)
+
+
+def _weak_tie():
+    """Two stations tied by two spins only 350 mm apart, six spins each of their own."""
+    a, b = two_stations()
+    own_a = [(x, y) for x in (200, 600) for y in (900, 1500, 2100)]
+    own_b = [(x, y) for x in (3200, 3600) for y in (900, 1500, 2100)]
+    tie = [(1900, 1300), (1900, 1650)]
+    return a, b, own_a + own_b + tie
+
+
+def _to_floor(joint, stations, p):
+    for st in stations:
+        x0, y0, x1, y1 = joint.rectangles[st.index]
+        if x0 <= p[0] <= x1 and y0 <= p[1] <= y1:
+            cam = apply(np.linalg.inv(joint.homographies[st.index]), np.array([p]))
+            return tuple(apply(st.cam_to_floor, cam)[0])
+    raise AssertionError(f"{p} is in no rectangle")
+
+
+def test_active_next_round_ties_the_weak_link_first():
+    a, b, centres = _weak_tie()
+    joint = ms.solve_joint(F.spins([a, b], centres, noise=1.0, seed=1))
+    (link,) = joint.graph.links
+    assert ms.link_holds(link) and not ms.link_advised(link)
+    targets = ms.next_round(
+        joint.error_map, joint.rectangles, joint.graph.links, robots=4
+    )
+    assert len(targets) == 4
+    assert targets[0].stations == targets[1].stations == (0, 1)
+    assert "ties station 0 (channel 1) and station 1 (channel 2)" in targets[0].why
+    assert math.dist(targets[0].point_mm, targets[1].point_mm) >= 600
+    for t in targets:
+        assert all(
+            math.dist(t.point_mm, u.point_mm) >= ms.NEXT_ROUND_SPACING_MM
+            for u in targets
+            if u is not t
+        )
+
+
+def test_active_spins_where_suggested_beat_random_spins():
+    """In simulation: the worst predicted error after a second round."""
+    a, b, centres = _weak_tie()
+    first = F.spins([a, b], centres, noise=1.0, seed=1)
+    joint = ms.solve_joint(first)
+
+    def after(points):
+        second = F.spins(
+            [a, b],
+            points,
+            noise=1.0,
+            seed=5,
+            round_=1,
+            names=[f"N{i}" for i in range(len(points))],
+        )
+        both = {s: first.get(s, []) + second.get(s, []) for s in (0, 1)}
+        return ms.solve_joint(both).error_map.worst_mm
+
+    targets = ms.next_round(
+        joint.error_map, joint.rectangles, joint.graph.links, robots=4
+    )
+    planned = after([_to_floor(joint, [a, b], t.point_mm) for t in targets])
+    seen = [
+        (x, y)
+        for x in range(-300, 3600, 50)
+        for y in range(0, 3000, 50)
+        if a.sees((x, y)) or b.sees((x, y))
+    ]
+    rng = np.random.default_rng(0)
+    random = [
+        after([seen[i] for i in rng.choice(len(seen), 4, replace=False)])
+        for _ in range(5)
+    ]
+    assert planned < joint.error_map.worst_mm
+    assert planned < np.mean(random)

From b3532f8f3e29a36925f05ff06d1e6bd7b35e7c77 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:40:28 +0200
Subject: [PATCH 28/80] dotbot/cli: add calibrate-lh2 show --next-round

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/swarm_lh2.py               | 36 +++++++++++++++++++++++++--
 dotbot/tests/test_calibration_spin.py | 13 ++++++++++
 2 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index cca53e17..89031186 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -891,15 +891,32 @@ def _gated_push(client, calibration, site_changed=False, devices=None, stop=Fals
     default=None,
     help="The site to look the id up under. Defaults to `site` in the dotbot config.",
 )
+@click.option(
+    "--next-round",
+    "next_robots",
+    type=click.IntRange(min=1, max=64),
+    default=None,
+    metavar="N",
+    help=(
+        "Also say where N robots should spin in another round (collect "
+        "--spin --append) to strengthen the weakest ties and the worst "
+        "predicted error; points in this calibration's frame."
+    ),
+)
 @click.pass_context
-def _show(ctx, calibration, site_name):
+def _show(ctx, calibration, site_name, next_robots):
     if _devices(ctx):
         raise click.UsageError("show reads a file, so it takes no `dotbot swarm -d`")
     from dotbot.calibration.lighthouse2 import (
         read_calibration_file,
         resolve_calibration_path,
     )
-    from dotbot.calibration.multi_station import multi_station_report
+    from dotbot.calibration.multi_station import (
+        error_map_from_calibration,
+        multi_station_report,
+        next_round,
+        next_round_lines,
+    )
 
     site, _ = site_from_context(ctx, site_name)
     try:
@@ -921,6 +938,21 @@ def _show(ctx, calibration, site_name):
     )
     for line in multi_station_report(loaded):
         click.echo(line)
+    if next_robots:
+        error_map = error_map_from_calibration(loaded)
+        if error_map is None:
+            raise click.ClickException(
+                f"{loaded.id8} is not a spin calibration, so it has no error map "
+                "to plan a round from"
+            )
+        targets = next_round(
+            error_map,
+            {s.index: s.valid_mm for s in loaded.stations},
+            loaded.links,
+            robots=next_robots,
+        )
+        for line in next_round_lines(targets):
+            click.echo(line)
 
 
 def _parse_shift(_ctx, _param, value):
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index 59f4e628..b18b9543 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -650,3 +650,16 @@ def test_an_anchor_that_would_not_spin_is_refused_before_the_spin(monkeypatch, l
     assert "B0B0B0B0B0B0B0B0 would not spin" in result.output
     assert addrs[0] not in result.output.split("would not spin")[0]
     assert "start" not in [c for c, _ in fleet.calls]
+
+
+def test_show_next_round_says_where_to_spin(monkeypatch, lab):
+    a, b = _two_stations()
+    _, fleet = _two_station_fleet([a, b], _floor_grid([a, b])[:40])
+    result = _collect(monkeypatch, lab, fleet, "--tag", "two")
+    assert result.exit_code == 0, result.output
+    shown = CliRunner().invoke(
+        swarm_lh2.cmd, ["show", "two", "--next-round", "3"], obj={"config": lab}
+    )
+    assert shown.exit_code == 0, shown.output
+    assert "next round, 3 spin(s), in this calibration's frame:" in shown.output
+    assert shown.output.count("mm, seen by station(s)") == 3

From 523551e6376da661fde8dd3d53bac8ee8c044c93 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:58:23 +0200
Subject: [PATCH 29/80] dotbot/calibration: name next-round stations by index
 and channel

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/multi_station.py   | 6 +++---
 dotbot/tests/test_calibration_spin.py | 3 ++-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index 8fad00a3..8d6e3acb 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -1292,10 +1292,10 @@ def next_round_lines(targets: Sequence[SpinTarget]) -> list[str]:
         return ["next round: nothing to suggest"]
     lines = [f"next round, {len(targets)} spin(s), in this calibration's frame:"]
     for t in targets:
-        seen = ", ".join(str(s) for s in t.stations)
+        seen = ", ".join(station_label(s) for s in t.stations)
         lines.append(
-            f"  ({t.point_mm[0]:6.0f}, {t.point_mm[1]:6.0f}) mm, seen by station(s) "
-            f"{seen}: {t.why}"
+            f"  ({t.point_mm[0]:6.0f}, {t.point_mm[1]:6.0f}) mm, seen by {seen}: "
+            f"{t.why}"
         )
     return lines
 
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index b18b9543..4a9d0d25 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -662,4 +662,5 @@ def test_show_next_round_says_where_to_spin(monkeypatch, lab):
     )
     assert shown.exit_code == 0, shown.output
     assert "next round, 3 spin(s), in this calibration's frame:" in shown.output
-    assert shown.output.count("mm, seen by station(s)") == 3
+    assert shown.output.count("mm, seen by station ") == 3
+

From bfa93a779342af2d8cc5368ca0ef3d0ff8d0133e Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:58:23 +0200
Subject: [PATCH 30/80] dotbot/cli: refuse show --next-round for a calibration
 a round cannot join

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/swarm_lh2.py               |  7 +++++++
 dotbot/tests/test_calibration_spin.py | 12 ++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 89031186..54bc2fb7 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -912,6 +912,7 @@ def _show(ctx, calibration, site_name, next_robots):
         resolve_calibration_path,
     )
     from dotbot.calibration.multi_station import (
+        appendable_rounds,
         error_map_from_calibration,
         multi_station_report,
         next_round,
@@ -939,6 +940,12 @@ def _show(ctx, calibration, site_name, next_robots):
     for line in multi_station_report(loaded):
         click.echo(line)
     if next_robots:
+        try:
+            appendable_rounds(loaded)
+        except ValueError as exc:
+            raise click.ClickException(
+                f"--next-round plans a round for collect --spin --append: {exc}"
+            ) from exc
         error_map = error_map_from_calibration(loaded)
         if error_map is None:
             raise click.ClickException(
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index 4a9d0d25..a87e42c1 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -664,3 +664,15 @@ def test_show_next_round_says_where_to_spin(monkeypatch, lab):
     assert "next round, 3 spin(s), in this calibration's frame:" in shown.output
     assert shown.output.count("mm, seen by station ") == 3
 
+
+def test_show_next_round_refuses_a_calibration_a_round_cannot_join(lab, tmp_path):
+    from dotbot.tests.lh2_wire_fixture import FIXTURE_TOML
+
+    path = tmp_path / "corner.toml"
+    path.write_text(FIXTURE_TOML, encoding="utf-8")
+    shown = CliRunner().invoke(
+        swarm_lh2.cmd, ["show", str(path), "--next-round", "2"], obj={"config": lab}
+    )
+    assert shown.exit_code != 0
+    assert "--next-round plans a round for collect --spin --append" in shown.output
+    assert "not a free-mode spin calibration" in shown.output

From 1990adb077cb51b21efe30eda6e924a767f3f5fb Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 11:41:52 -0300
Subject: [PATCH 31/80] dotbot/calibration: use the site extent as a placed
 spin solve's rectangles

A station that never sees part of the site yields no sweep pair there,
so the extent drops nothing a station could solve, whereas the box around
its spins dropped areas such as a staging strip the robots never spun in.

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/conics.py                  | 21 ++++++++++---------
 dotbot/tests/test_calibration_conics.py       | 11 ++--------
 .../tests/test_calibration_multi_station.py   | 18 ++++++++++++++++
 3 files changed, 31 insertions(+), 19 deletions(-)

diff --git a/dotbot/calibration/conics.py b/dotbot/calibration/conics.py
index 31425a0c..c8fbd2b5 100644
--- a/dotbot/calibration/conics.py
+++ b/dotbot/calibration/conics.py
@@ -728,8 +728,13 @@ def solve_calibration(
     )
     solved_from = "conics-joint" if joint.joint else "conics-free"
     anchor = FREE_FRAME_ANCHOR
+    rectangles, valid_mm = dict(joint.rectangles), joint.valid_mm
     if joint.anchored:
         solved_from, anchor = "conics-anchored", site.anchor
+        # In the site's frame, every station's rectangle is the site extent
+        if site.valid_mm is not None:
+            valid_mm = site.valid_mm
+            rectangles = {station: valid_mm for station in rectangles}
     stations = [
         StationSolution(
             index=station,
@@ -737,14 +742,14 @@ def solve_calibration(
             points=sum(t.points for t in joint.solutions[station].tracks),
             residual_mm=joint.station_rms_mm[station],
             solved_from=solved_from,
-            valid_mm=joint.rectangles[station],
+            valid_mm=rectangles[station],
         )
         for station, H in sorted(joint.homographies.items())
     ]
     now = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
     calibration = Calibration(
         site=Site(name=site.name, anchor=anchor),
-        valid_mm=joint.valid_mm,
+        valid_mm=valid_mm,
         stations=stations,
         tracks=list(samples),
         links=sorted(joint.graph.links, key=lambda k: (k.a, k.b)),
@@ -792,8 +797,9 @@ def self_defined_site(
     The site is the starter site (`starter_layout`) around the robots'
     field (`spin_field`): a margin of floor round it, or a `size_mm` site
     with it centred, and a staging strip below it. The calibration is
-    shifted by the field's offset, each station's rectangle with it, and a
-    tag gets `-<name>` appended, so the two files answer to different tags.
+    shifted by the field's offset, each station's rectangle becomes the
+    site extent, and a tag gets `-<name>` appended, so the two files answer
+    to different tags.
     """
     if (
         not calibration.stations
@@ -828,12 +834,7 @@ def self_defined_site(
                 points=st.points,
                 residual_mm=st.residual_mm,
                 solved_from=st.solved_from,
-                valid_mm=(
-                    st.valid_mm[0] + dx,
-                    st.valid_mm[1] + dy,
-                    st.valid_mm[2] + dx,
-                    st.valid_mm[3] + dy,
-                ),
+                valid_mm=(0, 0, int(extent[0]), int(extent[1])),
             )
         )
     site = Site(
diff --git a/dotbot/tests/test_calibration_conics.py b/dotbot/tests/test_calibration_conics.py
index c436aa9e..6bc40b4b 100644
--- a/dotbot/tests/test_calibration_conics.py
+++ b/dotbot/tests/test_calibration_conics.py
@@ -284,13 +284,7 @@ def test_a_self_defined_site_centres_the_field():
     staging = site.areas["staging"]
     assert (staging.x, staging.y, staging.w) == (field.x, field.y_max, field.w)
     assert staging.y_max <= 4000
-    x0, y0, x1, y1 = calibration.stations[0].valid_mm
-    assert placed.stations[0].valid_mm == (
-        x0 + field.x,
-        y0 + field.y,
-        x1 + field.x,
-        y1 + field.y,
-    )
+    assert placed.stations[0].valid_mm == (0, 0, 3000, 4000)
     assert placed.valid_mm == placed.stations[0].valid_mm
     assert (
         placed.site.anchor
@@ -321,8 +315,7 @@ def test_a_self_defined_site_is_the_starter_site_around_the_field():
     assert site.extent_mm == (field_w + 3000, field_h + 3000)
     assert (site.field.x, site.field.y) == (1500, 1500)
     assert site.staging.y == site.field.y_max
-    x0, y0, x1, y1 = placed.valid_mm
-    assert (0, 0) < (x0, y0) and x1 <= site.extent_mm[0] and y1 <= site.extent_mm[1]
+    assert placed.valid_mm == (0, 0, *site.extent_mm)
 
 
 def test_a_self_defined_site_must_hold_the_staging_strip_too():
diff --git a/dotbot/tests/test_calibration_multi_station.py b/dotbot/tests/test_calibration_multi_station.py
index 7e54dda7..d13aacb9 100644
--- a/dotbot/tests/test_calibration_multi_station.py
+++ b/dotbot/tests/test_calibration_multi_station.py
@@ -721,3 +721,21 @@ def after(points):
     ]
     assert planned < joint.error_map.worst_mm
     assert planned < np.mean(random)
+
+
+def test_anchored_calibration_rectangles_are_the_site_extent():
+    a, b = two_stations()
+    centres = floor_grid([a, b])
+    tracks = F.spins([a, b], centres, noise=0.5, seed=7)
+    corners = [0, len(centres) - 1, 3, len(centres) - 4]
+    anchors = [ms.Anchor(ms.CircleKey(f"R{i:02d}", 0), tuple(centres[i])) for i in corners]
+    site = Site(name="arena", anchor="door corner", extent_mm=(6000, 4000))
+    calibration, joint, _ = conics.solve_calibration(F.samples(tracks), site, anchors=anchors)
+    assert joint.rectangles[a.index] != (0, 0, 6000, 4000)
+    assert {s.valid_mm for s in calibration.stations} == {(0, 0, 6000, 4000)}
+    assert calibration.valid_mm == (0, 0, 6000, 4000)
+    # a free solve has no site frame, so it keeps the box around its spins
+    free, free_joint, _ = conics.solve_calibration(F.samples(tracks), site)
+    assert [s.valid_mm for s in free.stations] == [
+        free_joint.rectangles[s.index] for s in free.stations
+    ]

From 27490953452b91c349400550f7686500cef93f93 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 11:45:52 -0300
Subject: [PATCH 32/80] dotbot/config: record a site's LH2 base stations by
 serial and channel

AI-assisted: Claude Opus 5.5
---
 dotbot/config.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/dotbot/config.py b/dotbot/config.py
index 10074b49..eeccca90 100644
--- a/dotbot/config.py
+++ b/dotbot/config.py
@@ -29,6 +29,7 @@
 
 import difflib
 import os
+import re
 import tomllib
 from dataclasses import dataclass
 from pathlib import Path
@@ -217,6 +218,24 @@ class SiteSection(_Strict):
     extent_mm: tuple[int, int] | None = None
     connection: ConnectionSection | None = None
     areas: dict[str, AreaSection] = Field(default_factory=dict)
+    # LH2 base stations by serial, each with the channel it is set to
+    stations: dict[str, int] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def _stations(self) -> SiteSection:
+        for serial, channel in self.stations.items():
+            if not re.fullmatch(r"[0-9A-F]{8}", serial):
+                raise ValueError(f"station serial {serial!r} is not 8 upper-case hex digits")
+            if not 1 <= channel <= 16:
+                raise ValueError(f"station {serial} on channel {channel}, outside 1 to 16")
+        channels = list(self.stations.values())
+        shared = sorted({c for c in channels if channels.count(c) > 1})
+        if shared:
+            raise ValueError(
+                "two stations on one channel merge into one index: channel "
+                + ", ".join(str(c) for c in shared)
+            )
+        return self
 
     @model_validator(mode="after")
     def _one_field(self) -> SiteSection:

From eeb705bed992a5f3d3502a5dbe763cdaca8b2d37 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 13:41:19 -0300
Subject: [PATCH 33/80] dotbot/controller: hold a batch until its robot has a
 heading

A robot with no heading first gets a 40 mm probe move toward its first
point, and its batch once it has a heading and the probe is done. While
waypoints_awaiting_heading is set, the waypoint report and the mode are
the probe's, so a client watching mode alone sees an early arrival.

AI-assisted: Claude Opus 5.5
---
 dotbot/controller.py                   | 125 ++++++++++++++++
 dotbot/examples/labyrinth/labyrinth.py |   5 +-
 dotbot/examples/motions/motions.py     |   5 +-
 dotbot/models.py                       |   3 +
 dotbot/tests/scenario_harness.py       |   6 +-
 dotbot/tests/test_controller.py        | 193 +++++++++++++++++++++++++
 dotbot/tests/test_scenarios.py         |  24 +++
 7 files changed, 357 insertions(+), 4 deletions(-)

diff --git a/dotbot/controller.py b/dotbot/controller.py
index cae3c854..89088500 100644
--- a/dotbot/controller.py
+++ b/dotbot/controller.py
@@ -84,8 +84,10 @@
     PayloadControlMode,
     PayloadDotBotAdvertisement,
     PayloadLh2CalibrationHomography,
+    PayloadLH2Location,
     PayloadLH2Waypoints,
     PayloadType,
+    PayloadWaypointHeading,
     WaypointsAbortReason,
     WaypointsFailReason,
     WaypointsStatus,
@@ -118,6 +120,12 @@
     PayloadControlMode,
 )
 GPS_POSITION_DISTANCE_THRESHOLD = 5  # meters
+# A robot with no heading is first sent this far toward its first waypoint,
+# from its fix, and gets its batch once it has a heading and that move is done
+PROBE_MM = 40
+PROBE_THRESHOLD_MM = 20
+# How long a held batch waits for its robot's heading before it is dropped
+HOLD_TIMEOUT_S = 30.0
 IGNORED_PAYLOAD_TYPES = (
     PayloadType.CMD_MOVE_RAW,
     PayloadType.CMD_RGB_LED,
@@ -171,6 +179,15 @@ class PendingCommand:
     batch_ids: frozenset = frozenset()
 
 
+@dataclass
+class HeldBatch:
+    """A batch waiting for its robot's heading, and the probe move sent first."""
+
+    payload: PayloadLH2Waypoints
+    probe_batch_id: int
+    since: float
+
+
 @dataclass
 class RobotRecord:
     """What the controller keeps about a robot beside its model.
@@ -383,6 +400,7 @@ def __init__(self, settings: ControllerSettings):
         self.pending_commands: Dict[tuple[str, str], PendingCommand] = {}
         self.batch_ids: Dict[str, int] = {}
         self.advertised_batch_ids: Dict[str, int] = {}
+        self.held_batches: Dict[str, HeldBatch] = {}
         self.site = settings.site or Site()
         self.calibration = None
         self.lh2_calibration = []
@@ -783,6 +801,7 @@ def forget(self, address: str, now: Optional[float] = None) -> None:
         self._dotbot_twin_timestamps.pop(address, None)
         self._unsolved_held.pop(address, None)
         self.advertised_batch_ids.pop(address, None)
+        self.held_batches.pop(address, None)
 
     def _record(self, address: str) -> RobotRecord:
         """The record kept beside `address`'s model, created on first use."""
@@ -947,6 +966,7 @@ def handle_received_frame(
 
             self._set(dotbot, record, "battery", payload.battery / 1000.0, seq)  # mV
             self._set(dotbot, record, "mode", ControlModeType(payload.mode), seq)
+            self._release_held(dotbot, record, payload, seq)
             if debug:
                 self.logger.debug(
                     "Advertisement Data",
@@ -1132,6 +1152,109 @@ def send_confirmed(
         return self.send_payload(int(address, 16), payload)
 
     def send_waypoints(self, address: str, payload: PayloadLH2Waypoints) -> bool:
+        """Send a waypoint batch, or hold it while the robot has no heading.
+
+        A held batch goes out once the robot has a heading and has finished a
+        probe move of `PROBE_MM` toward the first point, sent in its place.
+        Any batch replaces a held one. False when nothing was sent, and a
+        batch held before is then kept.
+        """
+        replaced = self.held_batches.pop(address, None)
+        probe = self._probe(address, payload)
+        if not self._send_batch(address, probe or payload):
+            if replaced is not None:
+                self.held_batches[address] = replaced
+            return False
+        if probe is not None:
+            self.held_batches[address] = HeldBatch(
+                payload, probe.batch_id, time.monotonic()
+            )
+            self.logger.info(
+                "Waypoints held until the robot has a heading",
+                address=address,
+                probe=(probe.waypoints[0].pos_x, probe.waypoints[0].pos_y),
+            )
+        if (probe is not None) != (replaced is not None):
+            self.update_dotbot(address, waypoints_awaiting_heading=probe is not None)
+        return True
+
+    def _probe(
+        self, address: str, payload: PayloadLH2Waypoints
+    ) -> Optional[PayloadLH2Waypoints]:
+        """The probe move to send instead of `payload`, or None when the robot
+        has a heading, has no fix, or its first point is within `PROBE_MM`."""
+        dotbot = self.dotbots[address]
+        fix = dotbot.lh2_position
+        if payload.count == 0 or dotbot.direction is not None or fix is None:
+            return None
+        first = payload.waypoints[0]
+        dx, dy = first.pos_x - fix.x, first.pos_y - fix.y
+        distance = math.hypot(dx, dy)
+        if distance <= PROBE_MM:
+            return None
+        scale = PROBE_MM / distance
+        return PayloadLH2Waypoints(
+            threshold=PROBE_THRESHOLD_MM,
+            count=1,
+            waypoints=[
+                PayloadLH2Location(
+                    pos_x=round(fix.x + dx * scale), pos_y=round(fix.y + dy * scale)
+                )
+            ],
+            headings=[PayloadWaypointHeading()],
+        )
+
+    def _release_held(
+        self,
+        dotbot: DotBotModel,
+        record: RobotRecord,
+        advert: PayloadDotBotAdvertisement,
+        seq: int,
+    ) -> None:
+        """Send a held batch once the robot has a heading and its probe move is
+        done, or the probe never reached it; drop it, clearing the robot's
+        waypoints, when it has no heading by then or after `HOLD_TIMEOUT_S`."""
+        address = dotbot.address
+        held = self.held_batches.get(address)
+        if held is None:
+            return
+        # Gave up on, or superseded by another controller's batch
+        lost = (
+            advert.has_report
+            and advert.batch_id != held.probe_batch_id
+            and (address, PayloadLH2Waypoints.__name__) not in self.pending_commands
+        )
+        probing = (
+            advert.has_report
+            and not lost
+            and (
+                advert.batch_id != held.probe_batch_id
+                or advert.waypoints_status == WaypointsStatus.IN_PROGRESS
+            )
+        )
+        timed_out = time.monotonic() - held.since > HOLD_TIMEOUT_S
+        if probing and not timed_out:
+            return
+        if dotbot.direction is None and not (advert.has_report or timed_out):
+            return
+        del self.held_batches[address]
+        self._set(dotbot, record, "waypoints_awaiting_heading", False, seq)
+        if dotbot.direction is not None and not timed_out:
+            self.logger.info("Heading acquired, sending the held waypoints", address=address)
+            if self._send_batch(address, held.payload):
+                return
+        self._set(dotbot, record, "waypoints", [], seq)
+        self.logger.warning(
+            "Held waypoints dropped",
+            address=address,
+            heading=dotbot.direction is not None,
+            probe_lost=lost,
+            timed_out=timed_out,
+            probe_status=dotbot.waypoints_status,
+            probe_reason=dotbot.waypoints_reason,
+        )
+
+    def _send_batch(self, address: str, payload: PayloadLH2Waypoints) -> bool:
         """Send a waypoint batch under a new batch id, resent until the
         robot advertises that id or another controller's newer batch. False
         when it was not sent."""
@@ -1251,6 +1374,8 @@ def send_payload(self, destination: int, payload: Payload) -> bool:
         if isinstance(payload, DIRECT_COMMANDS):
             # The robot drops its batch on these, so a resend would restart it
             self.pending_commands.pop((dest_str, PayloadLH2Waypoints.__name__), None)
+            if self.held_batches.pop(dest_str, None) is not None:
+                self.update_dotbot(dest_str, waypoints_awaiting_heading=False)
         try:
             self.adapter.send_payload(destination, payload=payload)
         except Exception:  # pylint: disable=broad-exception-caught
diff --git a/dotbot/examples/labyrinth/labyrinth.py b/dotbot/examples/labyrinth/labyrinth.py
index d11c672c..25edc3a2 100644
--- a/dotbot/examples/labyrinth/labyrinth.py
+++ b/dotbot/examples/labyrinth/labyrinth.py
@@ -106,7 +106,10 @@ async def _wait_for_completion(address: str, host: str, port: int) -> None:
             bots = await client.fetch_dotbots(query=DotBotQueryModel(address=address))
             if bots:
                 bot = bots[0]
-                if not bot.waypoints or bot.mode == ControlModeType.MANUAL:
+                if not bot.waypoints or (
+                    bot.mode == ControlModeType.MANUAL
+                    and not bot.waypoints_awaiting_heading
+                ):
                     break
             await asyncio.sleep(0.5)
 
diff --git a/dotbot/examples/motions/motions.py b/dotbot/examples/motions/motions.py
index 39cedce4..6b372592 100644
--- a/dotbot/examples/motions/motions.py
+++ b/dotbot/examples/motions/motions.py
@@ -145,7 +145,10 @@ async def _wait_for_waypoints_done(
                 bot = dotbots[0]
                 if not bot.waypoints:
                     break
-                if bot.mode == ControlModeType.MANUAL:
+                if (
+                    bot.mode == ControlModeType.MANUAL
+                    and not bot.waypoints_awaiting_heading
+                ):
                     break
             await asyncio.sleep(WAYPOINT_POLL_INTERVAL)
 
diff --git a/dotbot/models.py b/dotbot/models.py
index ff3c8d37..1e364273 100644
--- a/dotbot/models.py
+++ b/dotbot/models.py
@@ -677,6 +677,9 @@ class DotBotModel(BaseModel):
     # The waypoint report, from apps that send one (the sandbox dotbot app)
     waypoints_status: Optional[WaypointsStatus] = None
     waypoints_reason: Optional[str] = None  # why FAILED or ABORTED
+    # The controller holds the batch until the robot has a heading; the
+    # waypoint report meanwhile is the probe move's
+    waypoints_awaiting_heading: bool = False
     waypoint_index: Optional[int] = (
         None  # the point being driven to; the count once arrived
     )
diff --git a/dotbot/tests/scenario_harness.py b/dotbot/tests/scenario_harness.py
index cc202dd8..0e33fb6a 100644
--- a/dotbot/tests/scenario_harness.py
+++ b/dotbot/tests/scenario_harness.py
@@ -137,10 +137,12 @@ async def run(
         return until is None
 
     def reported(self, address: str, status: str) -> bool:
-        """Whether the controller holds `status` for the last batch it sent."""
+        """Whether the controller holds `status` for the last batch it sent,
+        and no batch is held behind it."""
         dotbot = self.dotbot(address)
         return (
-            self.controller.advertised_batch_ids.get(address)
+            not dotbot.waypoints_awaiting_heading
+            and self.controller.advertised_batch_ids.get(address)
             == self.controller.batch_ids.get(address)
             and dotbot.waypoints_status is not None
             and dotbot.waypoints_status.name == status
diff --git a/dotbot/tests/test_controller.py b/dotbot/tests/test_controller.py
index 88fba246..c2aa4ef8 100644
--- a/dotbot/tests/test_controller.py
+++ b/dotbot/tests/test_controller.py
@@ -19,7 +19,10 @@
 from dotbot.area import Area
 from dotbot.controller import (
     FORGET_AFTER_S,
+    HOLD_TIMEOUT_S,
     LOST_AFTER_S,
+    PROBE_MM,
+    PROBE_THRESHOLD_MM,
     STALE_AFTER_S,
     Controller,
     ControllerSettings,
@@ -1863,3 +1866,193 @@ async def test_console_url_is_printed_headless_or_not(
     await controller._open_webbrowser()
     assert "Console: http://localhost:8123/console\n" in capsys.readouterr().out
     assert opened.called is not headless
+
+
+# --- a batch held until its robot has a heading ------------------------------
+
+
+def _headingless(**fields) -> Frame:
+    return _report(direction=DIRECTION_NONE, **fields)
+
+
+@pytest.mark.asyncio
+async def test_a_robot_with_no_heading_gets_a_probe_move_first(controller, clock):
+    controller.send_payload = MagicMock()
+    controller.handle_received_frame(_headingless(batch_id=3))
+    address = addr_to_hex(BOT)
+    batch = _batch()
+    assert controller.send_waypoints(address, batch)
+
+    probe = controller.send_payload.call_args.args[1]
+    assert probe is not batch and probe.count == 1
+    assert probe.threshold == PROBE_THRESHOLD_MM
+    # From the fix at (1000, 1000), toward the first point at (1000, 500)
+    assert (probe.waypoints[0].pos_x, probe.waypoints[0].pos_y) == (
+        1000,
+        1000 - PROBE_MM,
+    )
+    assert controller.dotbots[address].waypoints_awaiting_heading
+
+
+@pytest.mark.asyncio
+async def test_a_held_batch_waits_for_a_heading_and_the_probe_end(controller, clock):
+    controller.send_payload = MagicMock()
+    controller.handle_received_frame(_headingless(batch_id=3))
+    address = addr_to_hex(BOT)
+    batch = _batch()
+    controller.send_waypoints(address, batch)
+    probe_id = controller.send_payload.call_args.args[1].batch_id
+
+    in_progress = dict(batch_id=probe_id, waypoints_status=WaypointsStatus.IN_PROGRESS)
+    controller.handle_received_frame(_headingless(**in_progress))
+    controller.handle_received_frame(_report(**in_progress))
+    assert controller.send_payload.call_count == 1  # tracking, still probing
+
+    controller.handle_received_frame(
+        _report(batch_id=probe_id, waypoints_status=WaypointsStatus.ARRIVED)
+    )
+    assert controller.send_payload.call_args.args == (BOT, batch)
+    assert batch.batch_id == probe_id + 1
+    assert not controller.dotbots[address].waypoints_awaiting_heading
+    assert not controller.held_batches
+
+
+@pytest.mark.asyncio
+async def test_a_probe_ending_without_a_heading_drops_the_batch(controller, clock):
+    controller.send_payload = MagicMock()
+    controller.handle_received_frame(_headingless(batch_id=3))
+    address = addr_to_hex(BOT)
+    controller.send_waypoints(address, _batch())
+    probe_id = controller.send_payload.call_args.args[1].batch_id
+
+    controller.handle_received_frame(
+        _headingless(
+            batch_id=probe_id,
+            waypoints_status=WaypointsStatus.FAILED,
+            waypoints_reason=1,
+        )
+    )
+    dotbot = controller.dotbots[address]
+    assert not dotbot.waypoints_awaiting_heading
+    assert dotbot.waypoints_reason == "NO_HEADING"
+    # A heading that comes later does not revive it
+    controller.handle_received_frame(_report(batch_id=probe_id))
+    assert controller.send_payload.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_a_robot_with_a_heading_or_a_short_first_leg_is_not_held(
+    controller, clock
+):
+    controller.send_payload = MagicMock()
+    address = addr_to_hex(BOT)
+    controller.handle_received_frame(_report(batch_id=3))
+    batch = _batch()
+    controller.send_waypoints(address, batch)
+    assert controller.send_payload.call_args.args == (BOT, batch)
+
+    controller.handle_received_frame(_headingless(batch_id=3, pos_x=1000, pos_y=530))
+    batch = _batch()
+    controller.send_waypoints(address, batch)
+    assert controller.send_payload.call_args.args == (BOT, batch)
+    assert not controller.dotbots[address].waypoints_awaiting_heading
+
+
+@pytest.mark.asyncio
+async def test_a_new_batch_replaces_a_held_one(controller, clock):
+    controller.send_payload = MagicMock()
+    controller.handle_received_frame(_headingless(batch_id=3))
+    address = addr_to_hex(BOT)
+    controller.send_waypoints(address, _batch())
+    stop = _batch(count=0)
+    controller.send_waypoints(address, stop)
+    assert controller.send_payload.call_args.args == (BOT, stop)
+    assert not controller.held_batches
+    assert not controller.dotbots[address].waypoints_awaiting_heading
+
+
+@pytest.mark.asyncio
+async def test_a_robot_without_a_report_is_released_by_its_heading(controller, clock):
+    controller.send_payload = MagicMock()
+    address = addr_to_hex(BOT)
+    fix = dict(pos_x=1000, pos_y=1000)
+    controller.handle_received_frame(_advertised(BOT, direction=DIRECTION_NONE, **fix))
+    batch = _batch()
+    controller.send_waypoints(address, batch)
+    controller.handle_received_frame(_advertised(BOT, direction=DIRECTION_NONE, **fix))
+    assert controller.send_payload.call_count == 1
+    controller.handle_received_frame(_advertised(BOT, direction=180, **fix))
+    assert controller.send_payload.call_args.args == (BOT, batch)
+
+
+@pytest.mark.asyncio
+async def test_a_held_batch_is_dropped_after_the_timeout(controller, clock):
+    controller.send_payload = MagicMock()
+    address = addr_to_hex(BOT)
+    fix = dict(pos_x=1000, pos_y=1000)
+    controller.handle_received_frame(_advertised(BOT, direction=DIRECTION_NONE, **fix))
+    controller.send_waypoints(address, _batch())
+    clock.now += HOLD_TIMEOUT_S + 1
+    controller.handle_received_frame(_advertised(BOT, direction=DIRECTION_NONE, **fix))
+    assert not controller.held_batches
+    assert not controller.dotbots[address].waypoints_awaiting_heading
+
+
+@pytest.mark.asyncio
+async def test_a_report_of_the_batch_before_the_probe_does_not_release(
+    controller, clock
+):
+    controller.send_payload = MagicMock()
+    controller.handle_received_frame(_headingless(batch_id=3))
+    address = addr_to_hex(BOT)
+    batch = _batch()
+    controller.send_waypoints(address, batch)
+    probe_id = controller.send_payload.call_args.args[1].batch_id
+    controller.handle_received_frame(
+        _report(batch_id=3, waypoints_status=WaypointsStatus.ARRIVED)
+    )
+    assert controller.send_payload.call_count == 1
+    controller.handle_received_frame(
+        _report(batch_id=probe_id, waypoints_status=WaypointsStatus.ARRIVED)
+    )
+    assert controller.send_payload.call_args.args == (BOT, batch)
+
+
+@pytest.mark.asyncio
+async def test_a_probe_superseded_by_another_controller_releases_on_a_heading(
+    controller, clock
+):
+    controller.send_payload = MagicMock()
+    controller.handle_received_frame(_headingless(batch_id=3))
+    address = addr_to_hex(BOT)
+    batch = _batch()
+    controller.send_waypoints(address, batch)
+    controller.handle_received_frame(_report(batch_id=99))
+    assert controller.send_payload.call_args.args == (BOT, batch)
+    assert not controller.held_batches
+
+
+@pytest.mark.asyncio
+async def test_a_dropped_batch_leaves_no_waypoints_behind(controller, clock):
+    controller.send_payload = MagicMock()
+    controller.handle_received_frame(_headingless(batch_id=3))
+    address = addr_to_hex(BOT)
+    controller.send_waypoints(address, _batch())
+    controller.update_dotbot(address, waypoints=[DotBotLH2Position(x=1000, y=500)])
+    probe_id = controller.send_payload.call_args.args[1].batch_id
+    controller.handle_received_frame(
+        _headingless(batch_id=probe_id, waypoints_status=WaypointsStatus.ARRIVED)
+    )
+    dotbot = controller.dotbots[address]
+    assert dotbot.waypoints == [] and not dotbot.waypoints_awaiting_heading
+
+
+@pytest.mark.asyncio
+async def test_a_direct_command_drops_a_held_batch(controller, clock):
+    controller.adapter = MagicMock()
+    controller.handle_received_frame(_headingless(batch_id=3))
+    address = addr_to_hex(BOT)
+    controller.send_waypoints(address, _batch())
+    controller.send_payload(BOT, PayloadCommandMoveRaw(left_y=50, right_y=50))
+    assert not controller.held_batches
+    assert not controller.dotbots[address].waypoints_awaiting_heading
diff --git a/dotbot/tests/test_scenarios.py b/dotbot/tests/test_scenarios.py
index 4738d9e5..56584b5a 100644
--- a/dotbot/tests/test_scenarios.py
+++ b/dotbot/tests/test_scenarios.py
@@ -120,6 +120,30 @@ def watch():
     assert axle_error_mm(robot, 900, 900) <= 20
 
 
+async def test_a_batch_waits_near_the_start_until_the_robot_has_a_heading(scenario):
+    """Guards the controller's hold: a robot with no heading drives only the
+    probe move until it has one, then the whole batch."""
+    s = scenario([_bot()])
+    await s.run(1.0)
+    robot = s.robots[A]
+    start = (robot.pos_x, robot.pos_y)
+    held_travel = []
+
+    def watch():
+        if s.dotbot(A).waypoints_awaiting_heading:
+            held_travel.append(math.dist((robot.pos_x, robot.pos_y), start))
+
+    await s.waypoints(A, [(1500, 500), (1500, 1000)], threshold=20)
+    assert s.dotbot(A).waypoints_awaiting_heading
+    assert await s.run_until_reported([A], "ARRIVED", seconds=30, each_tick=watch)
+
+    assert held_travel and max(held_travel) < 100
+    assert axle_error_mm(robot, 1500, 1000) <= 20
+    # The stream told the console it was held, then that it no longer is
+    held = [p["waypoints_awaiting_heading"] for p in s.socket.robot_states() if "waypoints_awaiting_heading" in p]
+    assert True in held and held[-1] is False
+
+
 async def test_a_robot_that_never_sees_lh2_fails_no_heading(scenario):
     """Guards the NO_HEADING timeout and its FAILED report."""
     s = scenario([_bot()])

From 23e41868fdb63dcba9ef715bb56449731bda853f Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 13:41:20 -0300
Subject: [PATCH 34/80] dotbot/console-web: show a batch held for a heading as
 under way

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/Footer.tsx            | 4 +++-
 dotbot/console-web/src/heldWaypoints.test.ts | 6 ++++++
 dotbot/console-web/src/heldWaypoints.ts      | 1 +
 dotbot/console-web/src/missions.test.ts      | 9 +++++++++
 dotbot/console-web/src/types.ts              | 7 +++++++
 5 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/dotbot/console-web/src/Footer.tsx b/dotbot/console-web/src/Footer.tsx
index 598a5b33..9ff83757 100644
--- a/dotbot/console-web/src/Footer.tsx
+++ b/dotbot/console-web/src/Footer.tsx
@@ -336,7 +336,9 @@ const ControlDock: React.FC<{
     ? isGroup
       ? "⚠  Not drivable - no DBP in selection"
       : `⚠  Not drivable - ${notDrivableReason(single)}`
-    : anyAuto
+    : single?.mission?.code === "AWAITING_HEADING"
+      ? "▶  Waiting for a heading · a short probe move first"
+      : anyAuto
       ? single?.mission?.state === "in_progress" && single.mission.index !== null
         ? `▶  Navigating · waypoint ${Math.min(single.mission.index + 1, activeCount)} of ${activeCount}`
         : `▶  Navigating · ${activeCount} waypoint${activeCount === 1 ? "" : "s"} left`
diff --git a/dotbot/console-web/src/heldWaypoints.test.ts b/dotbot/console-web/src/heldWaypoints.test.ts
index a9b0e893..c14386ce 100644
--- a/dotbot/console-web/src/heldWaypoints.test.ts
+++ b/dotbot/console-web/src/heldWaypoints.test.ts
@@ -35,6 +35,12 @@ describe("heldWaypoints", () => {
     expect(rows.map((r) => r.status)).toEqual(["under way", "done"]);
   });
 
+  it("reads a batch held for a heading as under way, even between moves", () => {
+    const waiting = { state: "in_progress" as const, index: 0, reason: "waiting for a heading", code: "AWAITING_HEADING" };
+    const rows = heldWaypoints([bot("A", [start, start], { mission: waiting })]);
+    expect(rows[0]).toMatchObject({ status: "waiting for a heading", tone: "run" });
+  });
+
   it("picks the rows of a selection", () => {
     expect(heldAmong(heldWaypoints(bots), new Set(["D", "A"])).map((r) => r.id)).toEqual(["D"]);
   });
diff --git a/dotbot/console-web/src/heldWaypoints.ts b/dotbot/console-web/src/heldWaypoints.ts
index 2965f10c..bc4a63cc 100644
--- a/dotbot/console-web/src/heldWaypoints.ts
+++ b/dotbot/console-web/src/heldWaypoints.ts
@@ -14,6 +14,7 @@ export interface HeldRow {
 
 function statusOf(b: UnifiedBot, n: number): Pick<HeldRow, "status" | "tone"> {
   const m = b.mission;
+  if (m?.code === "AWAITING_HEADING") return { status: m.reason ?? m.code, tone: "run" };
   if (b.nav === "auto") {
     const at = m?.state === "in_progress" && m.index !== null ? Math.min(m.index + 1, n) : null;
     return { status: at === null ? "under way" : `to ${at} of ${n}`, tone: "run" };
diff --git a/dotbot/console-web/src/missions.test.ts b/dotbot/console-web/src/missions.test.ts
index be7f535c..8e06c799 100644
--- a/dotbot/console-web/src/missions.test.ts
+++ b/dotbot/console-web/src/missions.test.ts
@@ -135,6 +135,15 @@ describe("missionReport", () => {
     expect(missionReport(undefined)).toBeNull();
   });
 
+  it("reports a batch the controller holds for a heading as under way", () => {
+    expect(missionReport({ waypoints_status: 2, waypoints_awaiting_heading: true })).toEqual({
+      state: "in_progress",
+      index: 0,
+      reason: "waiting for a heading",
+      code: "AWAITING_HEADING",
+    });
+  });
+
   it("names every reason the controller reports in words", () => {
     const reasons = ["NO_HEADING", "TURN", "PROGRESS", "HEADING_LOST", "HOLD", "SETTLE", "STOP", "DIRECT", "CONTROL_MODE"];
     for (const code of reasons) {
diff --git a/dotbot/console-web/src/types.ts b/dotbot/console-web/src/types.ts
index 2d43c334..a15405f6 100644
--- a/dotbot/console-web/src/types.ts
+++ b/dotbot/console-web/src/types.ts
@@ -114,6 +114,9 @@ export interface PyDotBot {
   // one: 0 NONE, 1 IN_PROGRESS, 2 ARRIVED, 3 FAILED, 4 ABORTED.
   waypoints_status?: number | null;
   waypoints_reason?: string | null;
+  // The controller holds the batch until the robot has a heading, and the
+  // report meanwhile is a short probe move's.
+  waypoints_awaiting_heading?: boolean;
   waypoint_index?: number | null;
   rgb_led?: RgbLed;
   battery?: number; // volts
@@ -362,6 +365,7 @@ const MISSION_REASONS: Record<string, string> = {
   STOP: "stopped",
   DIRECT: "driven by hand",
   CONTROL_MODE: "mode changed",
+  AWAITING_HEADING: "waiting for a heading",
 };
 
 const MISSION_STATES: Record<number, MissionState> = {
@@ -373,6 +377,9 @@ const MISSION_STATES: Record<number, MissionState> = {
 
 /** The robot's report on its batch, or null when it sends none. */
 export function missionReport(py: Partial<PyDotBot> | undefined): MissionReport | null {
+  if (py?.waypoints_awaiting_heading) {
+    return { state: "in_progress", index: 0, reason: MISSION_REASONS.AWAITING_HEADING, code: "AWAITING_HEADING" };
+  }
   const state = MISSION_STATES[py?.waypoints_status ?? 0];
   if (!state) return null;
   const code = py?.waypoints_reason ?? null;

From 77bffdc1697b9dfaff5900c643ffa488aa284739 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 13:42:51 -0300
Subject: [PATCH 35/80] dotbot/config: add a site's spin_radius_mm for spin
 calibration

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/swarm_lh2.py               | 13 ++++++++-----
 dotbot/config.py                      |  2 ++
 dotbot/models.py                      |  3 +++
 dotbot/site.py                        |  3 +++
 dotbot/tests/test_calibration_spin.py | 13 +++++++++++++
 dotbot/tests/test_cli_site.py         |  7 +++++++
 dotbot/tests/test_qrkey_app.py        |  1 +
 dotbot/tests/test_server.py           |  3 +++
 8 files changed, 40 insertions(+), 5 deletions(-)

diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 54bc2fb7..54c18285 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -301,10 +301,10 @@ def _await_point(session, stream, arrivals: queue.Queue):
     metavar="MM",
     help=(
         "With --spin: radius of the photodiode's circle in a spin, in mm, "
-        "which sets the scale of every distance. Default: the robot model's "
-        "measured value (51.4 mm on a DotBot v3, under the 53.5 mm from "
-        "photodiode to axle because the caster drags the turning point "
-        "forward). Re-measure it on a different floor."
+        "which sets the scale of every distance. Default: the site's "
+        "spin_radius_mm, else the robot model's measured value (51.4 mm on "
+        "a DotBot v3, under the 53.5 mm from photodiode to axle because the "
+        "caster drags the turning point forward). It changes with the floor."
     ),
 )
 @click.option(
@@ -597,7 +597,10 @@ def _collect_spin(
             f"{round_} earlier round(s))."
         )
     radius_from = "--spin-radius"
-    if spin_radius is None:
+    if spin_radius is None and site.spin_radius_mm is not None:
+        spin_radius = site.spin_radius_mm
+        radius_from = f"site {site.name}"
+    elif spin_radius is None:
         spin_radius = robot_geometry(ROBOT_DEFAULT).spin_radius_mm
         radius_from = f"{ROBOT_DEFAULT}'s measured value"
     devices = _devices(ctx)
diff --git a/dotbot/config.py b/dotbot/config.py
index eeccca90..4a3ee930 100644
--- a/dotbot/config.py
+++ b/dotbot/config.py
@@ -220,6 +220,8 @@ class SiteSection(_Strict):
     areas: dict[str, AreaSection] = Field(default_factory=dict)
     # LH2 base stations by serial, each with the channel it is set to
     stations: dict[str, int] = Field(default_factory=dict)
+    # The photodiode's circle when a robot spins in place on this floor
+    spin_radius_mm: float | None = Field(default=None, ge=1.0, le=200.0)
 
     @model_validator(mode="after")
     def _stations(self) -> SiteSection:
diff --git a/dotbot/models.py b/dotbot/models.py
index 1e364273..758c6bfb 100644
--- a/dotbot/models.py
+++ b/dotbot/models.py
@@ -259,6 +259,7 @@ class DotBotSiteModel(BaseModel):
     areas: List[DotBotAreaModel] = []
     field: Optional[str] = None
     calibration: Optional[DotBotCalibrationSpanModel] = None
+    spin_radius_mm: Optional[float] = None
 
     @classmethod
     def from_site(cls, site: Site, calibration: Any = None) -> "DotBotSiteModel":
@@ -269,6 +270,7 @@ def from_site(cls, site: Site, calibration: Any = None) -> "DotBotSiteModel":
             extent_mm=list(site.extent_mm) if site.extent_mm else None,
             areas=[DotBotAreaModel(**a.as_dict()) for a in site.areas.values()],
             field=field.name if field is not None else None,
+            spin_radius_mm=site.spin_radius_mm,
             calibration=(
                 DotBotCalibrationSpanModel.from_calibration(calibration)
                 if calibration is not None
@@ -286,6 +288,7 @@ def to_site(self) -> Site:
             areas={
                 a.name: Area(a.x, a.y, a.w, a.h, a.name, a.role) for a in self.areas
             },
+            spin_radius_mm=self.spin_radius_mm,
         )
 
 
diff --git a/dotbot/site.py b/dotbot/site.py
index 769bf79f..075b1da1 100644
--- a/dotbot/site.py
+++ b/dotbot/site.py
@@ -51,6 +51,8 @@ class Site:
     extent_mm: tuple[int, int] | None = None
     areas: dict[str, Area] = field(default_factory=dict)
     pack: Path | None = None
+    # A spin's photodiode radius measured on this floor, if one was
+    spin_radius_mm: float | None = None
 
     @property
     def extent(self) -> Area | None:
@@ -160,6 +162,7 @@ def site_from_table(name: str, table: Any, pack: Path | None = None) -> Site:
         pack=pack,
         anchor=getattr(table, "anchor", None) or "",
         extent_mm=(int(extent[0]), int(extent[1])) if extent else None,
+        spin_radius_mm=getattr(table, "spin_radius_mm", None),
         areas={
             area_name: Area(
                 x=area.x,
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index a87e42c1..1dde66ce 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -287,6 +287,19 @@ def test_spins_end_to_end_into_a_self_defined_site(monkeypatch, lab):
     )
 
 
+def test_the_site_spin_radius_is_used_unless_the_flag_overrides_it(
+    monkeypatch, lab
+):
+    toml = lab.project_dir / "sites" / "c405" / "site.toml"
+    toml.write_text(toml.read_text() + "spin_radius_mm = 53.0\n")
+    _, fleet = _fleet()
+    result = _collect(monkeypatch, lab, fleet)
+    assert "spin radius 53 mm (from site c405)" in result.output
+    _, fleet = _fleet()
+    result = _collect(monkeypatch, lab, fleet, "--spin-radius", "50")
+    assert "spin radius 50 mm (from --spin-radius)" in result.output
+
+
 def test_site_init_refuses_an_existing_name(monkeypatch, lab):
     _, fleet = _fleet()
     result = _collect(monkeypatch, lab, fleet)
diff --git a/dotbot/tests/test_cli_site.py b/dotbot/tests/test_cli_site.py
index df90f7cc..8ed2dea5 100644
--- a/dotbot/tests/test_cli_site.py
+++ b/dotbot/tests/test_cli_site.py
@@ -79,6 +79,13 @@ def test_a_site_table_becomes_its_anchor_extent_and_areas():
     }
 
 
+def test_a_site_table_carries_its_floor_spin_radius():
+    assert site_from_table("tile", _table("spin_radius_mm = 53.0\n")).spin_radius_mm == 53.0
+    assert site_from_table("tile", _table("")).spin_radius_mm is None
+    with pytest.raises(ValueError):
+        _table("spin_radius_mm = 0.5\n")
+
+
 def test_a_named_site_with_no_table_is_empty_rather_than_an_error():
     """The default site is exactly this: a name, and nothing measured yet."""
     site = site_from_table("bench", None)
diff --git a/dotbot/tests/test_qrkey_app.py b/dotbot/tests/test_qrkey_app.py
index ae2f3f68..dfe9a92b 100644
--- a/dotbot/tests/test_qrkey_app.py
+++ b/dotbot/tests/test_qrkey_app.py
@@ -140,4 +140,5 @@ def test_a_site_request_replies_with_the_whole_site(site_client):
         ],
         "field": "arena",
         "calibration": None,
+        "spin_radius_mm": None,
     }
diff --git a/dotbot/tests/test_server.py b/dotbot/tests/test_server.py
index 42276130..6dd1adfc 100644
--- a/dotbot/tests/test_server.py
+++ b/dotbot/tests/test_server.py
@@ -1383,6 +1383,7 @@ async def test_get_controller_site():
         ],
         "field": "field",
         "calibration": None,
+        "spin_radius_mm": None,
     }
 
 
@@ -1426,6 +1427,7 @@ def test_the_site_payload_reads_back_as_the_same_site():
         name="hall",
         anchor="north-west corner",
         extent_mm=(5000, 4000),
+        spin_radius_mm=53.0,
         areas={
             "pen": Area(0, 0, 10, 10, "pen", "corner"),
             "main": Area(5, 5, 10, 10, "main", "field"),
@@ -1457,6 +1459,7 @@ async def test_get_controller_site_with_nothing_measured():
         "areas": [],
         "field": None,
         "calibration": None,
+        "spin_radius_mm": None,
     }
 
 

From 3562082a8bf9cde83a467746fa150d15b4d01e92 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 14:37:00 -0300
Subject: [PATCH 36/80] dotbot/console-web: show the site and id of the robot's
 LH2 calibration

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/Inspector.tsx     | 11 +++++++++++
 dotbot/console-web/src/inspector.test.ts | 17 +++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/dotbot/console-web/src/Inspector.tsx b/dotbot/console-web/src/Inspector.tsx
index 3d628f75..76af33f1 100644
--- a/dotbot/console-web/src/Inspector.tsx
+++ b/dotbot/console-web/src/Inspector.tsx
@@ -30,6 +30,14 @@ export function formatLh2(bot: UnifiedBot): string {
   return bot.swarmit?.info?.lh2_summary ?? "unknown (no device info)";
 }
 
+/** The site the held calibration was made for and its short id; null without device info. */
+export function formatLh2Site(bot: UnifiedBot): string | null {
+  const info = bot.swarmit?.info;
+  if (!info) return null;
+  const id = (info.lh2_calibration_id ?? "").slice(0, 8);
+  return `${info.lh2_site_name || "none"}  (id ${id || "none"})`;
+}
+
 /**
  * The body heading, and where it came from. A travel bearing is the robot's
  * direction of motion, so it is its heading only while it drives straight;
@@ -99,6 +107,8 @@ export function infoText(bot: UnifiedBot): string {
   }
   out.push("");
   out.push(`LH2 calibration   ${formatLh2(bot)}`);
+  const lh2Site = formatLh2Site(bot);
+  if (lh2Site !== null) out.push(`  site            ${lh2Site}`);
   if (sw?.reset_reason !== undefined) {
     out.push("");
     out.push(`Last reset        ${bot.resetCause}`);
@@ -215,6 +225,7 @@ const Card: React.FC<{ bot: UnifiedBot; camera: CameraRobot | null; cameras: boo
 
       <div style={{ height: 8 }} />
       <Row k="LH2 calib" v={formatLh2(bot)} />
+      {formatLh2Site(bot) !== null && <Row k="site" v={formatLh2Site(bot)!} indent />}
 
       {sw?.reset_reason !== undefined && (
         <>
diff --git a/dotbot/console-web/src/inspector.test.ts b/dotbot/console-web/src/inspector.test.ts
index d5e241af..b916c4ae 100644
--- a/dotbot/console-web/src/inspector.test.ts
+++ b/dotbot/console-web/src/inspector.test.ts
@@ -4,6 +4,7 @@ import {
   cameraRobotFor,
   formatCameraHeading,
   formatLh2,
+  formatLh2Site,
   formatUptime,
   infoText,
 } from "./Inspector";
@@ -68,6 +69,22 @@ describe("formatLh2", () => {
   });
 });
 
+describe("formatLh2Site", () => {
+  const info = { bl_version: "", net_version: "", boot_count: 0, uptime_s: 0, image_name: "", image_version: "", image_digest: "" };
+  const withInfo = (over: object) => bot({ swarmit: node({ info: { ...info, ...over } }) });
+
+  it("names the site and the short calibration id the robot holds", () => {
+    expect(formatLh2Site(withInfo({ lh2_site_name: "virmond", lh2_calibration_id: "288a810d1234abcd" }))).toBe(
+      "virmond  (id 288a810d)",
+    );
+  });
+
+  it("says none for a robot holding no calibration, and nothing without device info", () => {
+    expect(formatLh2Site(withInfo({}))).toBe("none  (id none)");
+    expect(formatLh2Site(bot({ swarmit: null }))).toBeNull();
+  });
+});
+
 describe("infoText", () => {
   it("is plain text carrying the identity and the reset cause", () => {
     const t = infoText(

From a6e5abda58bf62de96d46118bfc0cb33a4ecc196 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 14:40:44 -0300
Subject: [PATCH 37/80] dotbot/console-web: name the calibration's site on the
 full grid card

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/GridView.tsx        | 4 ++--
 dotbot/console-web/src/botFacts.ts         | 8 ++++++++
 dotbot/console-web/src/fleetViews.test.tsx | 8 ++++++++
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/dotbot/console-web/src/GridView.tsx b/dotbot/console-web/src/GridView.tsx
index cc051c13..b7f1d982 100644
--- a/dotbot/console-web/src/GridView.tsx
+++ b/dotbot/console-web/src/GridView.tsx
@@ -5,7 +5,7 @@ import {
   areaLabel,
   bootloaderLabel,
   calibrationDiffers,
-  calibrationLabel,
+  calibrationSiteLabel,
   detailText,
   FleetContext,
   firmwareTooOld,
@@ -274,7 +274,7 @@ export const GridView: React.FC<GridViewProps> = ({ bots, selection, onSelect, c
                         )
                       }
                     >
-                      {calibrationLabel(b) || dash}
+                      {calibrationSiteLabel(b) || dash}
                     </Fact>
                     <Fact k="Device">{b.deviceType}</Fact>
                     {b.severity !== "normal" && <Fact k="Last reset">{b.resetCause ?? b.severity}</Fact>}
diff --git a/dotbot/console-web/src/botFacts.ts b/dotbot/console-web/src/botFacts.ts
index a47cd6ca..bf4295db 100644
--- a/dotbot/console-web/src/botFacts.ts
+++ b/dotbot/console-web/src/botFacts.ts
@@ -43,6 +43,14 @@ export function calibrationLabel(bot: UnifiedBot): string {
   return (bot.swarmit?.info?.lh2_calibration_id ?? "").slice(0, 8);
 }
 
+/** "288a810d · virmond": the held calibration's short id and its site, "" for none or unknown. */
+export function calibrationSiteLabel(bot: UnifiedBot): string {
+  const id = calibrationLabel(bot);
+  if (!id) return "";
+  const site = bot.swarmit?.info?.lh2_site_name ?? "";
+  return site ? `${id} · ${site}` : id;
+}
+
 /** Whether the robot reports a calibration other than the one the controller serves. */
 export function calibrationDiffers(bot: UnifiedBot, calibrationId: string): boolean {
   if (!calibrationId || firmwareTooOld(bot)) return false;
diff --git a/dotbot/console-web/src/fleetViews.test.tsx b/dotbot/console-web/src/fleetViews.test.tsx
index efd5d8de..64c910d3 100644
--- a/dotbot/console-web/src/fleetViews.test.tsx
+++ b/dotbot/console-web/src/fleetViews.test.tsx
@@ -7,6 +7,7 @@ import {
   appLabel,
   areaLabel,
   calibrationDiffers,
+  calibrationSiteLabel,
   detailText,
   FleetContext,
   firmwareTooOld,
@@ -96,6 +97,13 @@ describe("botFacts", () => {
     expect(calibrationDiffers(other, "")).toBe(false);
   });
 
+  it("names the held calibration's short id and its site", () => {
+    const withSite = bot("A", { swarmit: { ...bot("A").swarmit!, info: info({ lh2_site_name: "virmond" }) } });
+    expect(calibrationSiteLabel(withSite)).toBe("abcd1234 · virmond");
+    expect(calibrationSiteLabel(bot("A"))).toBe("abcd1234");
+    expect(calibrationSiteLabel(bot("A", { swarmit: null }))).toBe("");
+  });
+
   it("picks the smallest area the robot stands in", () => {
     expect(areaLabel(bot("A"), site)).toBe("field");
     expect(areaLabel(bot("A", { position: { x: 100, y: 100 } }), site)).toBe("bench");

From 1216f90010e344b7cf2d339b166b1ebd8b2f3d7f Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 14:47:16 -0300
Subject: [PATCH 38/80] dotbot/console-web: name the served calibration's site
 in its fleet coverage

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/LocalizationPanel.tsx |  3 ++-
 dotbot/console-web/src/localization.ts       |  6 ++++++
 dotbot/console-web/src/pushTarget.test.tsx   | 16 +++++++++++++++-
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/dotbot/console-web/src/LocalizationPanel.tsx b/dotbot/console-web/src/LocalizationPanel.tsx
index 175c14a6..2b94c98a 100644
--- a/dotbot/console-web/src/LocalizationPanel.tsx
+++ b/dotbot/console-web/src/LocalizationPanel.tsx
@@ -6,6 +6,7 @@ import {
   cameraStatusRows,
   coverageLabel,
   extentLabel,
+  servedCalibrationLabel,
   stationRows,
   stationsSummary,
 } from "./localization";
@@ -186,7 +187,7 @@ export const LocalizationPanel: React.FC<LocalizationPanelProps> = ({
 
         <Section title="Calibration on the fleet">
           <div style={{ ...mono, fontSize: 14, fontWeight: 600 }}>
-            {coverage.unknown ? "not compared" : coverage.id.slice(0, 8)}
+            {coverage.unknown ? "not compared" : servedCalibrationLabel(coverage, session?.site || site?.name || "")}
           </div>
           <div style={{ fontSize: 11.5, color: "var(--muted)", marginTop: 3 }}>
             {coverage.unknown
diff --git a/dotbot/console-web/src/localization.ts b/dotbot/console-web/src/localization.ts
index e04bbafa..e3eb8473 100644
--- a/dotbot/console-web/src/localization.ts
+++ b/dotbot/console-web/src/localization.ts
@@ -60,6 +60,12 @@ export function calibrationCoverage(bots: UnifiedBot[], savedId: string): Covera
   return { id: savedId, carrying, total: bots.length, stale, unchecked, unknown: !wanted };
 }
 
+/** "288a810d (virmond)": the served calibration's short id and the site it was captured on. */
+export function servedCalibrationLabel(coverage: Coverage, site: string): string {
+  const id = coverage.id.slice(0, 8);
+  return site ? `${id} (${site})` : id;
+}
+
 /** "11 of 12 bots", or the absence when the fleet is empty. */
 export function coverageLabel(coverage: Coverage): string {
   if (coverage.total === 0) return "no bots on the control plane";
diff --git a/dotbot/console-web/src/pushTarget.test.tsx b/dotbot/console-web/src/pushTarget.test.tsx
index a747f7a9..acc4fa14 100644
--- a/dotbot/console-web/src/pushTarget.test.tsx
+++ b/dotbot/console-web/src/pushTarget.test.tsx
@@ -87,12 +87,13 @@ const renderPanel = (
   selection: Set<string>,
   onPush = vi.fn(),
   busy = false,
+  session: CalibrationSession = saved,
 ) => {
   render(
     <LocalizationPanel
       site={null}
       bots={bots}
-      session={saved}
+      session={session}
       busy={busy}
       error=""
       onCalibrate={() => {}}
@@ -148,3 +149,16 @@ describe("the Localization tab's push row", () => {
     expect(onPush).not.toHaveBeenCalled();
   });
 });
+
+describe("the Localization tab's calibration on the fleet", () => {
+  it("names the served calibration's id and its site beside its coverage", () => {
+    renderPanel([bot("AA", SAVED), bot("BB", "")], new Set(), vi.fn(), false, { ...saved, site: "virmond" });
+    expect(screen.getByText("3f9a1c07 (virmond)")).toBeTruthy();
+    expect(screen.getByText("on 1 of 2 bots")).toBeTruthy();
+  });
+
+  it("names only the id when the session carries no site", () => {
+    renderPanel([bot("AA", SAVED)], new Set());
+    expect(screen.getByText("3f9a1c07")).toBeTruthy();
+  });
+});

From 0eb35ab90299a503f40057889cb9a70d36968114 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 14:47:16 -0300
Subject: [PATCH 39/80] dotbot/console-web: flag a robot calibrated for another
 site

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/BotMarker.tsx       | 28 ++++++++++
 dotbot/console-web/src/GridView.tsx        | 21 +++----
 dotbot/console-web/src/ListView.tsx        | 14 ++---
 dotbot/console-web/src/MapView.tsx         |  2 +
 dotbot/console-web/src/botChrome.test.tsx  | 27 +++++++++
 dotbot/console-web/src/botFacts.ts         | 44 ++++++++++++++-
 dotbot/console-web/src/fleetViews.test.tsx | 65 ++++++++++++++++++++++
 dotbot/console-web/src/viewChrome.tsx      | 46 +++++++++++++--
 8 files changed, 219 insertions(+), 28 deletions(-)

diff --git a/dotbot/console-web/src/BotMarker.tsx b/dotbot/console-web/src/BotMarker.tsx
index fdfb0240..a49114df 100644
--- a/dotbot/console-web/src/BotMarker.tsx
+++ b/dotbot/console-web/src/BotMarker.tsx
@@ -154,6 +154,8 @@ export interface BotMarkerProps {
   batteryBars: boolean;
   /** What the body is filled with: the swarmit state, or the LED colour. */
   colorMode: BodyColorMode;
+  /** The site of the robot's calibration when it is not the map's, "" otherwise. */
+  otherSite?: string;
   attach: (id: string, el: HTMLElement | null) => void;
   onPointerDown: (e: React.PointerEvent, id: string) => void;
   onHover: React.Dispatch<React.SetStateAction<string | null>>;
@@ -174,6 +176,7 @@ export const BotMarker = React.memo(function BotMarker({
   botCount,
   batteryBars,
   colorMode,
+  otherSite = "",
   attach,
   onPointerDown,
   onHover,
@@ -235,6 +238,30 @@ export const BotMarker = React.memo(function BotMarker({
         >
           <ResetBadge bot={b} size={13} />
         </div>
+        {/* calibrated for another site: the position is in another frame */}
+        {otherSite && (
+          <div
+            data-testid={`other-site-${b.id}`}
+            title={`Calibrated for site ${otherSite}: its position is in another frame`}
+            style={{
+              position: "absolute",
+              left: footprintPx / 2,
+              top: -footprintPx / 2,
+              transform: "translate(-50%, -50%)",
+              zIndex: 4,
+              width: 11,
+              height: 11,
+              borderRadius: "50%",
+              background: "var(--s-Stopping)",
+              border: "1px solid var(--surface)",
+              color: "#fff",
+              font: "700 8px/9px var(--font-mono)",
+              textAlign: "center",
+            }}
+          >
+            !
+          </div>
+        )}
         {/* selection ring, hugging the board */}
         {selected && (
           <div
@@ -333,6 +360,7 @@ function sameMarkerProps(a: BotMarkerProps, b: BotMarkerProps): boolean {
     a.botCount === b.botCount &&
     a.batteryBars === b.batteryBars &&
     a.colorMode === b.colorMode &&
+    a.otherSite === b.otherSite &&
     a.attach === b.attach &&
     a.onPointerDown === b.onPointerDown &&
     a.onHover === b.onHover &&
diff --git a/dotbot/console-web/src/GridView.tsx b/dotbot/console-web/src/GridView.tsx
index b7f1d982..fa6241fd 100644
--- a/dotbot/console-web/src/GridView.tsx
+++ b/dotbot/console-web/src/GridView.tsx
@@ -4,7 +4,8 @@ import {
   appLabel,
   areaLabel,
   bootloaderLabel,
-  calibrationDiffers,
+  calibrationDetail,
+  calibrationMismatch,
   calibrationSiteLabel,
   detailText,
   FleetContext,
@@ -20,6 +21,7 @@ import { UnifiedBot } from "./types";
 import {
   Badge,
   BatteryCell,
+  CalibrationBadge,
   FilterBar,
   HeadingGlyph,
   LedDot,
@@ -95,7 +97,7 @@ const WhereLine: React.FC<{ bot: UnifiedBot; ctx: FleetContext; degrees: boolean
  * or silent reports and the two firmware warnings. */
 const Chips: React.FC<{ bot: UnifiedBot; ctx: FleetContext }> = ({ bot, ctx }) => {
   const slipping = bot.link === "stale" || bot.link === "lost";
-  const differs = calibrationDiffers(bot, ctx.calibrationId);
+  const differs = calibrationMismatch(bot, ctx) !== "none";
   const old = firmwareTooOld(bot);
   const bootloader = bootloaderLabel(bot);
   if (!bootloader && !slipping && !differs && !old) return null;
@@ -104,11 +106,7 @@ const Chips: React.FC<{ bot: UnifiedBot; ctx: FleetContext }> = ({ bot, ctx }) =
       {bootloader && <Badge title="Bootloader version, and the net core's when it differs">bl {bootloader}</Badge>}
       {slipping && <Badge title={reportsDetail(bot, ctx.now)}>{reportsLabel(bot, ctx.now)}</Badge>}
       {old && <TooOld />}
-      {differs && (
-        <Badge tone="warn" title={`The controller serves ${ctx.calibrationId.slice(0, 8)}`}>
-          cal differs
-        </Badge>
-      )}
+      {differs && <CalibrationBadge bot={bot} ctx={ctx} differs="cal differs" />}
     </div>
   );
 };
@@ -266,13 +264,8 @@ export const GridView: React.FC<GridViewProps> = ({ bots, selection, onSelect, c
                     </Fact>
                     <Fact
                       k="LH2 cal"
-                      extra={
-                        calibrationDiffers(b, ctx.calibrationId) && (
-                          <Badge tone="warn" title={`The controller serves ${ctx.calibrationId.slice(0, 8)}`}>
-                            differs
-                          </Badge>
-                        )
-                      }
+                      title={calibrationDetail(b) || undefined}
+                      extra={<CalibrationBadge bot={b} ctx={ctx} />}
                     >
                       {calibrationSiteLabel(b) || dash}
                     </Fact>
diff --git a/dotbot/console-web/src/ListView.tsx b/dotbot/console-web/src/ListView.tsx
index 0ce78055..9bfd55e1 100644
--- a/dotbot/console-web/src/ListView.tsx
+++ b/dotbot/console-web/src/ListView.tsx
@@ -4,7 +4,7 @@ import {
   appLabel,
   areaLabel,
   bootloaderLabel,
-  calibrationDiffers,
+  calibrationDetail,
   calibrationLabel,
   detailText,
   FleetContext,
@@ -19,8 +19,8 @@ import { rowOpacity } from "./link";
 import { store } from "./persisted";
 import { UnifiedBot } from "./types";
 import {
-  Badge,
   BatteryCell,
+  CalibrationBadge,
   FilterBar,
   HeadingGlyph,
   LedDot,
@@ -118,12 +118,10 @@ export const COLUMNS: Column[] = [
     shown: true,
     cell: (b, ctx) => (
       <span style={{ display: "inline-flex", gap: 6, alignItems: "center", whiteSpace: "nowrap" }}>
-        <span style={muted}>{calibrationLabel(b) || dash}</span>
-        {calibrationDiffers(b, ctx.calibrationId) && (
-          <Badge tone="warn" title={`The controller serves ${ctx.calibrationId.slice(0, 8)}`}>
-            differs
-          </Badge>
-        )}
+        <span title={calibrationDetail(b) || undefined} style={muted}>
+          {calibrationLabel(b) || dash}
+        </span>
+        <CalibrationBadge bot={b} ctx={ctx} />
       </span>
     ),
   },
diff --git a/dotbot/console-web/src/MapView.tsx b/dotbot/console-web/src/MapView.tsx
index ee72431b..29ad6b25 100644
--- a/dotbot/console-web/src/MapView.tsx
+++ b/dotbot/console-web/src/MapView.tsx
@@ -31,6 +31,7 @@ import {
   ticksInSite,
 } from "./grid";
 import { hasHeading } from "./BotGlyph";
+import { calibrationOtherSite } from "./botFacts";
 import { BotMarker, MARKER_SCALE_VAR, WAYPOINT_MIN_PX, botDraw as drawBot } from "./BotMarker";
 import { useMarkerPerMm } from "./markerScale";
 import { BodyColorMode, DEFAULT_BODY_COLOR_MODE } from "./bodyColor";
@@ -1569,6 +1570,7 @@ export const MapView: React.FC<MapViewProps> = (props) => {
                   botCount={props.bots.length}
                   batteryBars={props.layers.batteryBars}
                   colorMode={colorMode}
+                  otherSite={calibrationOtherSite(b, props.site)}
                   attach={attachBot}
                   onPointerDown={onBotPointerDown}
                   onHover={setHoverId}
diff --git a/dotbot/console-web/src/botChrome.test.tsx b/dotbot/console-web/src/botChrome.test.tsx
index 100172df..a0a6b393 100644
--- a/dotbot/console-web/src/botChrome.test.tsx
+++ b/dotbot/console-web/src/botChrome.test.tsx
@@ -521,3 +521,30 @@ describe("the possible footprint", () => {
     expect(layer("a", "reach")!.getAttribute("fill")).not.toBe("none");
   });
 });
+
+describe("a robot calibrated for another site", () => {
+  const held = (site: string) =>
+    ({
+      device: "DotBotV3",
+      status: "Running",
+      battery: 2900,
+      pos_x: 0,
+      pos_y: 0,
+      info: { info_version: 4, lh2_calibration_id: "288a810d1234abcd", lh2_site_name: site },
+    }) as UnifiedBot["swarmit"];
+
+  it("is marked on the map, and a robot of this site or of no known site is not", () => {
+    render(
+      <Harness
+        bots={[
+          bot("away", { x: 500, y: 500 }, { swarmit: held("workshop") }),
+          bot("home", { x: 900, y: 900 }, { swarmit: held("c405-arena") }),
+          bot("none", { x: 1200, y: 900 }),
+        ]}
+      />,
+    );
+    expect(screen.getByTestId("other-site-away").getAttribute("title")).toContain("workshop");
+    expect(screen.queryByTestId("other-site-home")).toBeNull();
+    expect(screen.queryByTestId("other-site-none")).toBeNull();
+  });
+});
diff --git a/dotbot/console-web/src/botFacts.ts b/dotbot/console-web/src/botFacts.ts
index bf4295db..9b07f0c7 100644
--- a/dotbot/console-web/src/botFacts.ts
+++ b/dotbot/console-web/src/botFacts.ts
@@ -59,6 +59,46 @@ export function calibrationDiffers(bot: UnifiedBot, calibrationId: string): bool
   return (info.lh2_calibration_id ?? "").toLowerCase() !== calibrationId.toLowerCase();
 }
 
+/** The site of the calibration the robot holds when it is not `site`, "" otherwise or when either is unknown. */
+export function calibrationOtherSite(bot: UnifiedBot, site: Site | null): string {
+  const info = bot.swarmit?.info;
+  if (!info || firmwareTooOld(bot) || !info.lh2_calibration_id) return "";
+  const held = info.lh2_site_name ?? "";
+  const active = site?.name ?? "";
+  if (!held || !active || held.toLowerCase() === active.toLowerCase()) return "";
+  return held;
+}
+
+/** How the robot's calibration differs from what the controller serves: a
+ * calibration of another site puts its positions in another frame, which
+ * outranks a different id of the same site. */
+export type CalibrationMismatch = "none" | "other-site" | "other-id";
+
+export function calibrationMismatch(bot: UnifiedBot, ctx: Pick<FleetContext, "calibrationId" | "site">): CalibrationMismatch {
+  if (calibrationOtherSite(bot, ctx.site)) return "other-site";
+  if (calibrationDiffers(bot, ctx.calibrationId)) return "other-id";
+  return "none";
+}
+
+/** The stations whose homography the robot holds, from its station mask: [0, 1]. */
+export function calibrationStations(bot: UnifiedBot): number[] | null {
+  const mask = bot.swarmit?.info?.lh2_station_mask;
+  if (mask === undefined || mask === null) return null;
+  const out: number[] = [];
+  for (let i = 0; i < 32; i++) if (mask & (1 << i)) out.push(i);
+  return out;
+}
+
+/** "virmond · 288a810d1234abcd · stations 0, 1": the held calibration in full, "" for none or unknown. */
+export function calibrationDetail(bot: UnifiedBot): string {
+  const info = bot.swarmit?.info;
+  if (!info?.lh2_calibration_id) return "";
+  const parts = [info.lh2_site_name ?? "", info.lh2_calibration_id];
+  const stations = calibrationStations(bot);
+  if (stations) parts.push(stations.length ? `stations ${stations.join(", ")}` : "no stations");
+  return parts.filter(Boolean).join(" · ");
+}
+
 /** "1204, 877 mm", or "" with no fix. */
 export function positionLabel(bot: UnifiedBot): string {
   if (!bot.position) return "";
@@ -147,7 +187,9 @@ export function reportsDetail(bot: UnifiedBot, now: number): string {
 export function warnings(bot: UnifiedBot, ctx: FleetContext): string[] {
   const out: string[] = [];
   if (firmwareTooOld(bot)) out.push("bootloader too old for this controller: reflash swarmit-sandbox");
-  else if (calibrationDiffers(bot, ctx.calibrationId)) {
+  else if (calibrationOtherSite(bot, ctx.site)) {
+    out.push(`holds a calibration of site ${calibrationOtherSite(bot, ctx.site)}: its position is in another frame`);
+  } else if (calibrationDiffers(bot, ctx.calibrationId)) {
     const held = calibrationLabel(bot) || "none";
     out.push(`holds calibration ${held}, not ${ctx.calibrationId.slice(0, 8)}: push it`);
   }
diff --git a/dotbot/console-web/src/fleetViews.test.tsx b/dotbot/console-web/src/fleetViews.test.tsx
index 64c910d3..7802ac52 100644
--- a/dotbot/console-web/src/fleetViews.test.tsx
+++ b/dotbot/console-web/src/fleetViews.test.tsx
@@ -6,7 +6,9 @@ import {
   ageLabel,
   appLabel,
   areaLabel,
+  calibrationDetail,
   calibrationDiffers,
+  calibrationMismatch,
   calibrationSiteLabel,
   detailText,
   FleetContext,
@@ -239,3 +241,66 @@ describe("GridView", () => {
     spy.mockRestore();
   });
 });
+
+describe("a calibration other than the one served", () => {
+  beforeEach(() => window.localStorage.clear());
+  afterEach(cleanup);
+
+  const held = (over: Partial<SwarmitDeviceInfo>) =>
+    ({ swarmit: { ...bot("A").swarmit!, info: info({ lh2_site_name: "lab", ...over }) } }) as Partial<UnifiedBot>;
+  const matching = bot("CCCC000000000001", held({}));
+  const otherId = bot("CCCC000000000002", held({ lh2_calibration_id: "99999999eeee" }));
+  const otherSite = bot("CCCC000000000003", held({ lh2_site_name: "workshop", lh2_calibration_id: "99999999eeee" }));
+  const fleet = [matching, otherId, otherSite];
+  const rowOf = (id: string) => screen.getAllByRole("row").find((r) => r.textContent?.includes(id))!;
+
+  it("ranks another site above another id, and needs both site names to compare", () => {
+    expect(calibrationMismatch(matching, ctx)).toBe("none");
+    expect(calibrationMismatch(otherId, ctx)).toBe("other-id");
+    expect(calibrationMismatch(otherSite, ctx)).toBe("other-site");
+    // Same id, other site: still another frame.
+    expect(calibrationMismatch(bot("A", held({ lh2_site_name: "workshop" })), ctx)).toBe("other-site");
+    expect(calibrationMismatch(bot("A", held({ lh2_site_name: "" })), ctx)).toBe("none");
+    expect(calibrationMismatch(otherSite, { ...ctx, site: null })).toBe("other-id");
+    expect(calibrationMismatch(bot("A", held({ lh2_site_name: "LAB" })), ctx)).toBe("none");
+    expect(calibrationMismatch(bot("A", held({ info_version: 2, lh2_site_name: "workshop" })), ctx)).toBe("none");
+    expect(detailText(otherSite, ctx)).toContain("! holds a calibration of site workshop");
+    expect(detailText(otherSite, ctx)).not.toContain("push it");
+  });
+
+  it("spells the held calibration out in full, with its stations", () => {
+    expect(calibrationDetail(bot("A", held({ lh2_station_mask: 0b11 })))).toBe("lab · abcd1234ffff · stations 0, 1");
+    expect(calibrationDetail(bot("A", held({ lh2_station_mask: 0 })))).toBe("lab · abcd1234ffff · no stations");
+    expect(calibrationDetail(bot("A", held({ lh2_site_name: "" })))).toBe("abcd1234ffff");
+    expect(calibrationDetail(bot("A", held({ lh2_calibration_id: "" })))).toBe("");
+  });
+
+  it("is flagged once per robot in the list, the site louder than the id", () => {
+    render(<ListView bots={fleet} selection={new Set()} onSelect={() => {}} ctx={ctx} />);
+    const m = rowOf("CCCC000000000001");
+    expect(within(m).queryByText("differs")).toBeNull();
+    expect(within(m).queryByText(/other site/)).toBeNull();
+    const i = rowOf("CCCC000000000002");
+    expect(within(i).getByText("differs").getAttribute("data-tone")).toBe("warn");
+    expect(within(i).queryByText(/other site/)).toBeNull();
+    const s = rowOf("CCCC000000000003");
+    expect(within(s).getByText("other site: workshop").getAttribute("data-tone")).toBe("alert");
+    expect(within(s).queryByText("differs")).toBeNull();
+  });
+
+  it("carries the full calibration as the list cell's tooltip", () => {
+    const withMask = bot("CCCC000000000004", held({ lh2_station_mask: 0b11 }));
+    render(<ListView bots={[withMask]} selection={new Set()} onSelect={() => {}} ctx={ctx} />);
+    expect(screen.getByText("abcd1234").getAttribute("title")).toBe("lab · abcd1234ffff · stations 0, 1");
+  });
+
+  it("is flagged the same way on compact and full grid cards", () => {
+    render(<GridView bots={fleet} selection={new Set()} onSelect={() => {}} ctx={ctx} />);
+    expect(screen.getAllByText("cal differs")).toHaveLength(1);
+    expect(screen.getAllByText("other site: workshop")).toHaveLength(1);
+    fireEvent.click(screen.getByRole("button", { name: "Full" }));
+    expect(screen.getAllByText("differs")).toHaveLength(1);
+    expect(screen.getAllByText("other site: workshop")).toHaveLength(1);
+    expect(screen.getByText("99999999 · workshop").getAttribute("title")).toBe("workshop · 99999999eeee");
+  });
+});
diff --git a/dotbot/console-web/src/viewChrome.tsx b/dotbot/console-web/src/viewChrome.tsx
index fb5cd79e..010b0ea2 100644
--- a/dotbot/console-web/src/viewChrome.tsx
+++ b/dotbot/console-web/src/viewChrome.tsx
@@ -1,6 +1,15 @@
 import React, { useMemo, useState } from "react";
 
-import { appLabel, areaLabel, bootloaderLabel, calibrationLabel, FleetContext, headingLabel } from "./botFacts";
+import {
+  appLabel,
+  areaLabel,
+  bootloaderLabel,
+  calibrationLabel,
+  calibrationMismatch,
+  calibrationOtherSite,
+  FleetContext,
+  headingLabel,
+} from "./botFacts";
 import { TRAVEL_BODY_OPACITY } from "./BotGlyph";
 import { headingToGlyphRotation } from "./frame";
 import { BotState, STATE_ORDER, UnifiedBot } from "./types";
@@ -322,14 +331,15 @@ export function useQueriedBots(bots: UnifiedBot[], q: ViewQuery, ctx: FleetConte
   return useMemo(() => applyQuery(bots, q, ctx), [bots, q, ctx]);
 }
 
-/** A small pill: a fact, or a warning when `tone` is "warn". */
-export const Badge: React.FC<{ children: React.ReactNode; title?: string; tone?: "warn" | "plain" }> = ({
+/** A small pill: a fact, a warning when `tone` is "warn", a filled one when "alert". */
+export const Badge: React.FC<{ children: React.ReactNode; title?: string; tone?: "warn" | "alert" | "plain" }> = ({
   children,
   title,
   tone = "plain",
 }) => (
   <span
     title={title}
+    data-tone={tone}
     style={{
       fontFamily: "var(--font-mono)",
       fontSize: 10,
@@ -337,14 +347,40 @@ export const Badge: React.FC<{ children: React.ReactNode; title?: string; tone?:
       padding: "0 6px",
       borderRadius: 8,
       whiteSpace: "nowrap",
-      color: tone === "warn" ? "var(--s-Stopping)" : "var(--muted)",
-      border: `1px solid ${tone === "warn" ? "var(--s-Stopping)" : "var(--hairline)"}`,
+      color: tone === "alert" ? "#fff" : tone === "warn" ? "var(--s-Stopping)" : "var(--muted)",
+      background: tone === "alert" ? "var(--s-Stopping)" : undefined,
+      border: `1px solid ${tone === "plain" ? "var(--hairline)" : "var(--s-Stopping)"}`,
     }}
   >
     {children}
   </span>
 );
 
+/** The badge on a robot whose calibration is not the one served: "other site: workshop"
+ * when it is another site's, `differs` when it is another id of this site, nothing otherwise. */
+export const CalibrationBadge: React.FC<{ bot: UnifiedBot; ctx: FleetContext; differs?: string }> = ({
+  bot,
+  ctx,
+  differs = "differs",
+}) => {
+  const mismatch = calibrationMismatch(bot, ctx);
+  if (mismatch === "other-site") {
+    return (
+      <Badge tone="alert" title={`Calibrated for another site: its position is not in ${ctx.site?.name}'s frame`}>
+        other site: {calibrationOtherSite(bot, ctx.site)}
+      </Badge>
+    );
+  }
+  if (mismatch === "other-id") {
+    return (
+      <Badge tone="warn" title={`The controller serves ${ctx.calibrationId.slice(0, 8)}`}>
+        {differs}
+      </Badge>
+    );
+  }
+  return null;
+};
+
 /**
  * The robot's heading as the map draws it: a circle with a radius toward the
  * way it faces, dimmed for a travel bearing, and an empty dashed circle while

From 85fd82dbde813523438890d5bcedbf371f2cb136 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 14:55:48 -0300
Subject: [PATCH 40/80] dotbot/console-web: treat an empty station mask as no
 calibration

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/Inspector.tsx       |  6 +++---
 dotbot/console-web/src/botFacts.ts         | 21 +++++++++++++++------
 dotbot/console-web/src/fleetViews.test.tsx |  5 ++++-
 dotbot/console-web/src/inspector.test.ts   |  3 ++-
 dotbot/console-web/src/localization.ts     |  2 +-
 5 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/dotbot/console-web/src/Inspector.tsx b/dotbot/console-web/src/Inspector.tsx
index 76af33f1..f554b6ef 100644
--- a/dotbot/console-web/src/Inspector.tsx
+++ b/dotbot/console-web/src/Inspector.tsx
@@ -1,6 +1,6 @@
 import React, { useState } from "react";
 
-import { reportsWire } from "./botFacts";
+import { heldCalibrationId, reportsWire } from "./botFacts";
 import { stateLabel } from "./viewChrome";
 
 import { CameraDetection, CameraRobot, REPORTS_LABEL, UnifiedBot } from "./types";
@@ -34,8 +34,8 @@ export function formatLh2(bot: UnifiedBot): string {
 export function formatLh2Site(bot: UnifiedBot): string | null {
   const info = bot.swarmit?.info;
   if (!info) return null;
-  const id = (info.lh2_calibration_id ?? "").slice(0, 8);
-  return `${info.lh2_site_name || "none"}  (id ${id || "none"})`;
+  const id = heldCalibrationId(bot).slice(0, 8);
+  return id ? `${info.lh2_site_name || "none"}  (id ${id})` : "none";
 }
 
 /**
diff --git a/dotbot/console-web/src/botFacts.ts b/dotbot/console-web/src/botFacts.ts
index 9b07f0c7..2b2ac8ad 100644
--- a/dotbot/console-web/src/botFacts.ts
+++ b/dotbot/console-web/src/botFacts.ts
@@ -38,9 +38,18 @@ export function firmwareTooOld(bot: UnifiedBot): boolean {
   return !!info && (info.info_version ?? 0) < DEVICE_INFO_VERSION_MIN;
 }
 
+/** The full LH2 calibration id the robot holds, "" for none or unknown. An
+ * empty station mask means no homography is held, whatever id the device
+ * info still carries. */
+export function heldCalibrationId(bot: UnifiedBot): string {
+  const info = bot.swarmit?.info;
+  if (!info || info.lh2_station_mask === 0) return "";
+  return info.lh2_calibration_id ?? "";
+}
+
 /** The LH2 calibration id the robot holds: its first 8 characters, "" for none or unknown. */
 export function calibrationLabel(bot: UnifiedBot): string {
-  return (bot.swarmit?.info?.lh2_calibration_id ?? "").slice(0, 8);
+  return heldCalibrationId(bot).slice(0, 8);
 }
 
 /** "288a810d · virmond": the held calibration's short id and its site, "" for none or unknown. */
@@ -56,13 +65,13 @@ export function calibrationDiffers(bot: UnifiedBot, calibrationId: string): bool
   if (!calibrationId || firmwareTooOld(bot)) return false;
   const info = bot.swarmit?.info;
   if (!info) return false;
-  return (info.lh2_calibration_id ?? "").toLowerCase() !== calibrationId.toLowerCase();
+  return heldCalibrationId(bot).toLowerCase() !== calibrationId.toLowerCase();
 }
 
 /** The site of the calibration the robot holds when it is not `site`, "" otherwise or when either is unknown. */
 export function calibrationOtherSite(bot: UnifiedBot, site: Site | null): string {
   const info = bot.swarmit?.info;
-  if (!info || firmwareTooOld(bot) || !info.lh2_calibration_id) return "";
+  if (!info || firmwareTooOld(bot) || !heldCalibrationId(bot)) return "";
   const held = info.lh2_site_name ?? "";
   const active = site?.name ?? "";
   if (!held || !active || held.toLowerCase() === active.toLowerCase()) return "";
@@ -91,9 +100,9 @@ export function calibrationStations(bot: UnifiedBot): number[] | null {
 
 /** "virmond · 288a810d1234abcd · stations 0, 1": the held calibration in full, "" for none or unknown. */
 export function calibrationDetail(bot: UnifiedBot): string {
-  const info = bot.swarmit?.info;
-  if (!info?.lh2_calibration_id) return "";
-  const parts = [info.lh2_site_name ?? "", info.lh2_calibration_id];
+  const id = heldCalibrationId(bot);
+  if (!id) return "";
+  const parts = [bot.swarmit?.info?.lh2_site_name ?? "", id];
   const stations = calibrationStations(bot);
   if (stations) parts.push(stations.length ? `stations ${stations.join(", ")}` : "no stations");
   return parts.filter(Boolean).join(" · ");
diff --git a/dotbot/console-web/src/fleetViews.test.tsx b/dotbot/console-web/src/fleetViews.test.tsx
index 7802ac52..cab21780 100644
--- a/dotbot/console-web/src/fleetViews.test.tsx
+++ b/dotbot/console-web/src/fleetViews.test.tsx
@@ -104,6 +104,9 @@ describe("botFacts", () => {
     expect(calibrationSiteLabel(withSite)).toBe("abcd1234 · virmond");
     expect(calibrationSiteLabel(bot("A"))).toBe("abcd1234");
     expect(calibrationSiteLabel(bot("A", { swarmit: null }))).toBe("");
+    const emptied = bot("A", { swarmit: { ...bot("A").swarmit!, info: info({ lh2_station_mask: 0, lh2_site_name: "virmond" }) } });
+    expect(calibrationSiteLabel(emptied)).toBe("");
+    expect(calibrationDiffers(emptied, ctx.calibrationId)).toBe(true);
   });
 
   it("picks the smallest area the robot stands in", () => {
@@ -270,7 +273,7 @@ describe("a calibration other than the one served", () => {
 
   it("spells the held calibration out in full, with its stations", () => {
     expect(calibrationDetail(bot("A", held({ lh2_station_mask: 0b11 })))).toBe("lab · abcd1234ffff · stations 0, 1");
-    expect(calibrationDetail(bot("A", held({ lh2_station_mask: 0 })))).toBe("lab · abcd1234ffff · no stations");
+    expect(calibrationDetail(bot("A", held({ lh2_station_mask: 0 })))).toBe("");
     expect(calibrationDetail(bot("A", held({ lh2_site_name: "" })))).toBe("abcd1234ffff");
     expect(calibrationDetail(bot("A", held({ lh2_calibration_id: "" })))).toBe("");
   });
diff --git a/dotbot/console-web/src/inspector.test.ts b/dotbot/console-web/src/inspector.test.ts
index b916c4ae..e03111d1 100644
--- a/dotbot/console-web/src/inspector.test.ts
+++ b/dotbot/console-web/src/inspector.test.ts
@@ -80,7 +80,8 @@ describe("formatLh2Site", () => {
   });
 
   it("says none for a robot holding no calibration, and nothing without device info", () => {
-    expect(formatLh2Site(withInfo({}))).toBe("none  (id none)");
+    expect(formatLh2Site(withInfo({}))).toBe("none");
+    expect(formatLh2Site(withInfo({ lh2_station_mask: 0, lh2_site_name: "virmond", lh2_calibration_id: "288a810d1234abcd" }))).toBe("none");
     expect(formatLh2Site(bot({ swarmit: null }))).toBeNull();
   });
 });
diff --git a/dotbot/console-web/src/localization.ts b/dotbot/console-web/src/localization.ts
index e3eb8473..e0e3d816 100644
--- a/dotbot/console-web/src/localization.ts
+++ b/dotbot/console-web/src/localization.ts
@@ -53,7 +53,7 @@ export function calibrationCoverage(bots: UnifiedBot[], savedId: string): Covera
     for (const bot of bots) {
       const info = bot.swarmit?.info;
       if (!info || (info.info_version ?? 0) < DEVICE_INFO_VERSION_MIN) unchecked.push(bot.id);
-      else if ((info.lh2_calibration_id ?? "").toLowerCase() === wanted) carrying += 1;
+      else if (info.lh2_station_mask !== 0 && (info.lh2_calibration_id ?? "").toLowerCase() === wanted) carrying += 1;
       else stale.push(bot.id);
     }
   }

From 263977dc5c44c02a57d92a8083c496d0676990fa Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 15:30:09 -0300
Subject: [PATCH 41/80] dotbot/console-web: name a failed LH2 sensor in the
 inspector position

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/Inspector.tsx     | 17 ++++++++++++-----
 dotbot/console-web/src/inspector.test.ts | 11 +++++++++++
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/dotbot/console-web/src/Inspector.tsx b/dotbot/console-web/src/Inspector.tsx
index f554b6ef..0173a869 100644
--- a/dotbot/console-web/src/Inspector.tsx
+++ b/dotbot/console-web/src/Inspector.tsx
@@ -30,6 +30,16 @@ export function formatLh2(bot: UnifiedBot): string {
   return bot.swarmit?.info?.lh2_summary ?? "unknown (no device info)";
 }
 
+/** Matches swarmit's LH2_FLAG_SENSOR_FAILED: the bot's LH2 receiver did not initialise this boot. */
+const LH2_FLAG_SENSOR_FAILED = 1 << 2;
+
+/** "1204, 877", or why there is no position. */
+export function formatPosition(bot: UnifiedBot): string {
+  if (bot.position) return `${Math.round(bot.position.x)}, ${Math.round(bot.position.y)}`;
+  if ((bot.swarmit?.info?.lh2_flags ?? 0) & LH2_FLAG_SENSOR_FAILED) return "LH2 sensor failed";
+  return "no fix";
+}
+
 /** The site the held calibration was made for and its short id; null without device info. */
 export function formatLh2Site(bot: UnifiedBot): string | null {
   const info = bot.swarmit?.info;
@@ -89,7 +99,7 @@ export function infoText(bot: UnifiedBot): string {
   out.push(`Reports           ${REPORTS_LABEL[bot.link]} (${reportsWire(bot)})`);
   out.push(`Battery           ${bot.battery.toFixed(2)}V`);
   out.push(
-    `Position          ${bot.position ? `${Math.round(bot.position.x)}, ${Math.round(bot.position.y)}` : "no fix"}`,
+    `Position          ${formatPosition(bot)}`,
   );
   out.push(`Heading           ${formatHeading(bot)}`);
   if (info) {
@@ -198,10 +208,7 @@ const Card: React.FC<{ bot: UnifiedBot; camera: CameraRobot | null; cameras: boo
       <Row k="Sandbox" v={stateLabel(bot.state)} />
       <Row k="Reports" v={`${REPORTS_LABEL[bot.link]} (${reportsWire(bot)})`} />
       <Row k="Battery" v={`${bot.battery.toFixed(2)}V`} />
-      <Row
-        k="Position"
-        v={bot.position ? `${Math.round(bot.position.x)}, ${Math.round(bot.position.y)}` : "no fix"}
-      />
+      <Row k="Position" v={formatPosition(bot)} />
       <Row k="Heading" v={formatHeading(bot)} />
       {cameras && <Row k="Camera" v={formatCameraHeading(camera)} />}
 
diff --git a/dotbot/console-web/src/inspector.test.ts b/dotbot/console-web/src/inspector.test.ts
index e03111d1..5d292c4c 100644
--- a/dotbot/console-web/src/inspector.test.ts
+++ b/dotbot/console-web/src/inspector.test.ts
@@ -5,6 +5,7 @@ import {
   formatCameraHeading,
   formatLh2,
   formatLh2Site,
+  formatPosition,
   formatUptime,
   infoText,
 } from "./Inspector";
@@ -164,3 +165,13 @@ describe("the camera's heading for the selected robot", () => {
     expect(formatCameraHeading(robot)).toBe("not seen");
   });
 });
+
+describe("formatPosition", () => {
+  const info = { bl_version: "", net_version: "", boot_count: 0, uptime_s: 0, image_name: "", image_version: "", image_digest: "" };
+  it("names a failed LH2 sensor instead of no fix", () => {
+    const failed = bot({ position: null, swarmit: node({ info: { ...info, lh2_station_mask: 3, lh2_flags: 0b111 } }) });
+    expect(formatPosition(failed)).toBe("LH2 sensor failed");
+    expect(formatPosition(bot({ position: null, swarmit: node({ info: { ...info, lh2_flags: 0b011 } }) }))).toBe("no fix");
+    expect(formatPosition(bot())).toBe("1552, 267");
+  });
+});

From 978a8cd64c40a3b04a2483c133ee0f000a5ab56e Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Wed, 14 Oct 2026 15:53:35 -0300
Subject: [PATCH 42/80] dotbot/calibration: confirm a push by a new boot
 reporting its stations

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/driver.py             |  6 +++-
 dotbot/calibration/push.py               | 40 ++++++++++++++++------
 dotbot/cli/swarm_lh2.py                  |  2 +-
 dotbot/tests/test_calibration_push.py    | 43 ++++++++++++++++++++++--
 dotbot/tests/test_calibration_session.py | 10 ++++--
 5 files changed, 83 insertions(+), 18 deletions(-)

diff --git a/dotbot/calibration/driver.py b/dotbot/calibration/driver.py
index 032f9c20..0bdb32d4 100644
--- a/dotbot/calibration/driver.py
+++ b/dotbot/calibration/driver.py
@@ -198,7 +198,11 @@ async def push(
                     client.send_lh2_calibration, payload, check.send_to
                 )
                 stale = await asyncio.to_thread(
-                    push_worklist, client, session.saved, check.addresses
+                    push_worklist,
+                    client,
+                    session.saved,
+                    check.addresses,
+                    check.info_gens,
                 )
             finally:
                 await asyncio.to_thread(self._listen_for_buttons, "")
diff --git a/dotbot/calibration/push.py b/dotbot/calibration/push.py
index 9492fbf0..4b7bca6e 100644
--- a/dotbot/calibration/push.py
+++ b/dotbot/calibration/push.py
@@ -10,11 +10,13 @@
 named robot is in its app, since the net core takes a calibration only in the
 bootloader; a push to the whole fleet leaves such robots out instead, unless
 that leaves none. After the push, the robots whose reported calibration id is
-not the file's are the worklist.
+not the file's, with its stations, from a boot after the push, are the
+worklist.
 
 Everything here takes the `status()` mapping of a swarmit client, duck-typed:
 address to an object with `status`, `info_gen` and `info`, `info` carrying
-`info_version`, `lh2_site_name` and `lh2_calibration_id`, or None.
+`info_version`, `info_gen`, `lh2_site_name`, `lh2_calibration_id` and
+`lh2_station_mask`, or None.
 """
 
 from __future__ import annotations
@@ -23,7 +25,7 @@
 from dataclasses import dataclass, field
 from typing import Any, Mapping
 
-from dotbot.calibration.lighthouse2 import Calibration, pushed_id
+from dotbot.calibration.lighthouse2 import Calibration, pushed_id, station_mask
 
 DEVICE_INFO_VERSION_MIN = 4
 # Seconds a pushed robot gets to reset, rejoin and report the pushed id.
@@ -74,6 +76,7 @@ class PushCheck:
     other_site: dict[str, str] = field(default_factory=dict)
     running: list[str] = field(default_factory=list)
     stale: list[str] = field(default_factory=list)
+    info_gens: dict[str, int] = field(default_factory=dict)
     fleet: bool = False
 
     @property
@@ -140,6 +143,7 @@ def check_push(status: Mapping[str, Any], calibration: Calibration) -> PushCheck
             else:
                 check.unanswered.append(addr)
             continue
+        check.info_gens[addr] = getattr(info, "info_gen", None)
         if int(getattr(info, "info_version", 0)) < DEVICE_INFO_VERSION_MIN:
             check.old_firmware.append(addr)
             continue
@@ -188,23 +192,37 @@ def gate_push(
 
 
 def push_worklist(
-    client: Any, calibration: Calibration, addresses: list[str]
+    client: Any,
+    calibration: Calibration,
+    addresses: list[str],
+    info_gens: Mapping[str, int] | None = None,
 ) -> list[str]:
-    """The pushed robots that do not report the file's id after the push.
-
-    A push resets every robot that takes it, so each gets PUSH_REJOIN_TIMEOUT
-    to rejoin and report; one not heard by then is listed too. Nothing is
-    requested here: a rejoin moves the robot's device-info generation, and
-    swarmit then refreshes its device info by one broadcast.
+    """The pushed robots that do not report the file's id and stations after
+    the push.
+
+    A robot that takes a push commits it and resets, so its device info must
+    come from a later generation than `info_gens`, the one read before the
+    push; one already on the file's id would otherwise pass without having
+    stored anything. Each robot gets PUSH_REJOIN_TIMEOUT to rejoin and
+    report; one not heard by then is listed too. Nothing is requested here: a
+    rejoin moves the robot's device-info generation, and swarmit then
+    refreshes its device info by one broadcast.
     """
     wanted_id = pushed_id(calibration)
+    wanted_mask = station_mask(calibration)
+    before = {addr.upper(): gen for addr, gen in (info_gens or {}).items()}
     pending = {addr.upper() for addr in addresses}
     deadline = time.monotonic() + PUSH_REJOIN_TIMEOUT
     while pending:
         status = client.status()
         for addr in list(pending):
             info = getattr(status.get(addr), "info", None)
-            if info is not None and _reported_id(info) == wanted_id:
+            if (
+                info is not None
+                and _reported_id(info) == wanted_id
+                and getattr(info, "lh2_station_mask", 0) == wanted_mask
+                and (addr not in before or getattr(info, "info_gen", None) != before[addr])
+            ):
                 pending.discard(addr)
         if not pending or time.monotonic() >= deadline:
             break
diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 54c18285..2b26fa18 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -868,7 +868,7 @@ def _gated_push(client, calibration, site_changed=False, devices=None, stop=Fals
         )
     client.send_lh2_calibration(payload, check.send_to)
     click.echo("Sent. Waiting for the robots to report the new id...")
-    stale = push_worklist(client, calibration, check.targets)
+    stale = push_worklist(client, calibration, check.targets, check.info_gens)
     if stale:
         click.echo(
             f"Still not on {calibration.id8} ({len(stale)}), push again: "
diff --git a/dotbot/tests/test_calibration_push.py b/dotbot/tests/test_calibration_push.py
index a3f889c7..fa080257 100644
--- a/dotbot/tests/test_calibration_push.py
+++ b/dotbot/tests/test_calibration_push.py
@@ -47,9 +47,13 @@ def _lab(tmp_path):
     LAB = load_discovered(environ={}, start_dir=lab)
 
 
-def _info(version=4, site="", calibration_id="", gen=1):
+def _info(version=4, site="", calibration_id="", gen=1, mask=0):
     info = SimpleNamespace(
-        info_version=version, lh2_site_name=site, lh2_calibration_id=calibration_id
+        info_version=version,
+        info_gen=gen,
+        lh2_site_name=site,
+        lh2_calibration_id=calibration_id,
+        lh2_station_mask=mask,
     )
     return SimpleNamespace(info_gen=gen, info=info)
 
@@ -57,8 +61,9 @@ def _info(version=4, site="", calibration_id="", gen=1):
 class _Fleet:
     """A swarmit client whose robots commit whatever they are sent."""
 
-    def __init__(self, nodes):
+    def __init__(self, nodes, mask=None):
         self.nodes = nodes
+        self.mask = mask
         self.pushed: list[bytes] = []
         self.pushed_to: list[list[str] | None] = []
         self.refreshed: list[list[str] | None] = []
@@ -86,6 +91,10 @@ def send_lh2_calibration(self, payload, devices=None):
             node.info.lh2_site_name, node.info.lh2_calibration_id = message_site(
                 payload[:LH2_CALIBRATION_MESSAGE_BYTES]
             )
+            node.info.lh2_station_mask = (
+                int.from_bytes(payload[:4], "little") if self.mask is None else self.mask
+            )
+            node.info.info_gen += 1
 
 
 @pytest.fixture
@@ -179,6 +188,34 @@ def test_a_robot_not_heard_after_the_push_is_listed(calibration_file):
     assert push.push_worklist(fleet, calibration, check.addresses) == ["GONE"]
 
 
+def test_a_robot_already_on_the_id_that_does_not_reboot_is_listed(calibration_file):
+    """A dropped push leaves the old device info, id included, in place."""
+    calibration = read_calibration_file(calibration_file)
+    mask = lighthouse2.station_mask(calibration)
+    held = lighthouse2.pushed_id(calibration)
+    fleet = _Fleet({"SAME": _info(calibration_id=held, gen=7, mask=mask)})
+    check = gate_push(fleet, calibration)
+    assert push.push_worklist(fleet, calibration, check.addresses, check.info_gens) == [
+        "SAME"
+    ]
+    fleet.send_lh2_calibration(
+        lighthouse2.calibration_payload(calibration), check.send_to
+    )
+    assert push.push_worklist(fleet, calibration, check.addresses, check.info_gens) == []
+
+
+def test_a_robot_reporting_other_stations_is_listed(calibration_file):
+    calibration = read_calibration_file(calibration_file)
+    fleet = _Fleet({"A": _info()}, mask=0)
+    check = gate_push(fleet, calibration)
+    fleet.send_lh2_calibration(
+        lighthouse2.calibration_payload(calibration), check.send_to
+    )
+    assert push.push_worklist(fleet, calibration, check.addresses, check.info_gens) == [
+        "A"
+    ]
+
+
 def test_push_to_another_site_is_refused_without_site_changed(
     monkeypatch, calibration_file
 ):
diff --git a/dotbot/tests/test_calibration_session.py b/dotbot/tests/test_calibration_session.py
index 83bbd110..2a0d5079 100644
--- a/dotbot/tests/test_calibration_session.py
+++ b/dotbot/tests/test_calibration_session.py
@@ -81,7 +81,11 @@ def _press(lh_index: int, count1: int, count2: int, n: int = 1) -> ButtonCapture
 def _info(version=4, site="", calibration_id=""):
     """A robot's device info as swarmit decodes it."""
     return SimpleNamespace(
-        info_version=version, lh2_site_name=site, lh2_calibration_id=calibration_id
+        info_version=version,
+        info_gen=1,
+        lh2_site_name=site,
+        lh2_calibration_id=calibration_id,
+        lh2_station_mask=0,
     )
 
 
@@ -111,7 +115,7 @@ def request_lh2_capture(self, device: str) -> None:
     def send_lh2_calibration(self, payload: bytes, devices=None) -> None:
         self.pushed.append(payload)
         self.pushed_to = devices
-        # The bot commits the push and reports its site and id from then on.
+        # The bot commits the push, resets and reports its site, id and stations.
         for addr, info in self.infos.items():
             if devices is not None and addr not in devices:
                 continue
@@ -119,6 +123,8 @@ def send_lh2_calibration(self, payload: bytes, devices=None) -> None:
                 info.lh2_site_name, info.lh2_calibration_id = message_site(
                     payload[:LH2_CALIBRATION_MESSAGE_BYTES]
                 )
+                info.lh2_station_mask = int.from_bytes(payload[:4], "little")
+                info.info_gen += 1
 
     def refresh_device_info(self, devices=None) -> None:
         pass

From 72dd3565adac5f0a9c9cb72926616eb7e0a0ffc0 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Thu, 15 Oct 2026 07:57:39 -0300
Subject: [PATCH 43/80] dotbot/calibration: record the spin calibration a
 placed one came from

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/conics.py      | 5 ++++-
 dotbot/calibration/lighthouse2.py | 5 +++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/dotbot/calibration/conics.py b/dotbot/calibration/conics.py
index c8fbd2b5..48ca0f1d 100644
--- a/dotbot/calibration/conics.py
+++ b/dotbot/calibration/conics.py
@@ -690,6 +690,8 @@ def field_angle(centres: np.ndarray) -> float:
 
 # What a free-mode calibration records as its site's anchor: no mark in the
 # room is its origin.
+# A site made by `site init` records the calibration it came from in its anchor
+SELF_DEFINED_ANCHOR = "self-defined from spin calibration "
 FREE_FRAME_ANCHOR = (
     "free mode: zero at the top-left of the rectangle around the spinning "
     "robots, grown by a robot's footprint; axes along that rectangle"
@@ -822,7 +824,7 @@ def self_defined_site(
     extent, field_area, staging = starter_layout((field_w, field_h), size_mm)
     dx, dy = field_area.x, field_area.y
     shift = np.array([[1, 0, dx], [0, 1, dy], [0, 0, 1.0]])
-    anchor = f"self-defined from spin calibration {calibration.id8}"
+    anchor = f"{SELF_DEFINED_ANCHOR}{calibration.id8}"
     stations = []
     for st in calibration.stations:
         H = shift @ st.matrix
@@ -853,5 +855,6 @@ def self_defined_site(
         created_at=calibration.created_at,
         tag=f"{calibration.tag}-{name}" if calibration.tag else "",
         robot=calibration.robot,
+        placed_from=calibration.id,
     )
     return site, placed
diff --git a/dotbot/calibration/lighthouse2.py b/dotbot/calibration/lighthouse2.py
index 8114ccca..7b48b92a 100644
--- a/dotbot/calibration/lighthouse2.py
+++ b/dotbot/calibration/lighthouse2.py
@@ -257,6 +257,8 @@ class Calibration:
     created_at: str = ""
     tag: str = ""
     robot: str = ROBOT_DEFAULT
+    # The id of the free-frame spin calibration this one was moved from
+    placed_from: str = ""
     path: Optional[Path] = None
     # The id the file on disk declares, when this came from one. A mismatch
     # with `id` means the file was hand-edited into a different calibration.
@@ -686,6 +688,8 @@ def render_calibration(calibration: Calibration) -> str:
     ]
     if calibration.tag:
         out.append(f'tag = "{toml_escape(calibration.tag)}"')
+    if calibration.placed_from:
+        out.append(f'placed_from = "{calibration.placed_from}"')
     out += [
         "",
         "[site]",
@@ -867,6 +871,7 @@ def read_calibration_file(path: Path) -> Calibration:
         created_at=metadata.get("created_at", ""),
         tag=metadata.get("tag", ""),
         robot=metadata.get("robot", ROBOT_DEFAULT),
+        placed_from=str(metadata.get("placed_from", "")),
         path=path,
     )
     calibration.stored_id = str(metadata.get("id", ""))

From 2e725feb9492ad08cd5ad1cb690d44f4cdd6d235 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Thu, 15 Oct 2026 07:57:39 -0300
Subject: [PATCH 44/80] dotbot/calibration: name the spin calibration to append
 to instead of a placed one

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/lighthouse2.py     |  9 ++++++
 dotbot/calibration/multi_station.py   | 24 +++++++++++++---
 dotbot/tests/test_calibration_spin.py | 41 +++++++++++++++++++++++++++
 3 files changed, 70 insertions(+), 4 deletions(-)

diff --git a/dotbot/calibration/lighthouse2.py b/dotbot/calibration/lighthouse2.py
index 7b48b92a..c76b8541 100644
--- a/dotbot/calibration/lighthouse2.py
+++ b/dotbot/calibration/lighthouse2.py
@@ -1048,6 +1048,15 @@ def _file_metadata(path: Path) -> dict:
         return {}
 
 
+def calibration_site_of(spec: str) -> Optional[str]:
+    """The site of the one calibration file under any site that `spec`
+    names, None when none or several do."""
+    try:
+        return read_calibration_file(resolve_calibration_path(spec)).site.name
+    except (OSError, ValueError):
+        return None
+
+
 def load_calibration(
     spec: str,
     root: Optional[Path] = None,
diff --git a/dotbot/calibration/multi_station.py b/dotbot/calibration/multi_station.py
index 8d6e3acb..30054e31 100644
--- a/dotbot/calibration/multi_station.py
+++ b/dotbot/calibration/multi_station.py
@@ -1174,17 +1174,33 @@ def appendable_rounds(calibration: Calibration) -> int:
     calibration is in a frame a re-solve would not keep.
     """
     # pylint: disable=import-outside-toplevel
-    from dotbot.calibration.conics import FREE_FRAME_ANCHOR
+    from dotbot.calibration.conics import FREE_FRAME_ANCHOR, SELF_DEFINED_ANCHOR
+    from dotbot.calibration.lighthouse2 import calibration_site_of
 
     if (
         not calibration.tracks
         or calibration.site.anchor != FREE_FRAME_ANCHOR
         or not all(st.solved_from.startswith("conics") for st in calibration.stations)
     ):
-        raise ValueError(
+        refused = (
             f"calibration {calibration.id8} is not a free-mode spin calibration, "
-            "so a round cannot be appended to it; append to the spin calibration "
-            "it was made from"
+            "so a round cannot be appended to it"
+        )
+        anchor = calibration.site.anchor
+        if calibration.placed_from:
+            source = calibration.placed_from
+            how = f"it was placed from spin calibration {source[:8]}"
+        elif anchor.startswith(SELF_DEFINED_ANCHOR):
+            source = anchor[len(SELF_DEFINED_ANCHOR) :].strip()
+            how = f"its site was defined from spin calibration {source[:8]}"
+        else:
+            raise ValueError(
+                f"{refused}; append to the spin calibration it was made from"
+            )
+        where = calibration_site_of(source)
+        raise ValueError(
+            f"{refused}: {how}, so append to that one"
+            + (f" (--append {source[:8]} --site {where})" if where else "")
         )
     return max(t.round for t in calibration.tracks) + 1
 
diff --git a/dotbot/tests/test_calibration_spin.py b/dotbot/tests/test_calibration_spin.py
index 1dde66ce..9b3b9d54 100644
--- a/dotbot/tests/test_calibration_spin.py
+++ b/dotbot/tests/test_calibration_spin.py
@@ -18,6 +18,7 @@
 from dotbot.calibration import conics, lighthouse2, push
 from dotbot.calibration import spin as spin_module
 from dotbot.calibration.lighthouse2 import counts_for_camera_point, load_calibration
+from dotbot.calibration.multi_station import appendable_rounds
 from dotbot.calibration.spin import (
     SPIN_CHUNK_RECORDS,
     SPIN_TAG,
@@ -583,6 +584,46 @@ def test_append_refuses_a_corner_calibration(monkeypatch, lab, tmp_path):
     assert fleet.calls == []
 
 
+def test_append_to_a_placed_calibration_names_the_one_it_came_from(monkeypatch, lab):
+    _, fleet = _fleet()
+    result = _collect(monkeypatch, lab, fleet)
+    free_id = re.search(r"--from-calibration (\w+)", result.output).group(1)
+    result = CliRunner().invoke(
+        site_cmd.cmd,
+        ["init", "spun", "--from-calibration", free_id],
+        obj={"config": lab},
+    )
+    placed_id = re.search(r"push (\w+) --site spun", result.output).group(1)
+    _, fleet = _fleet()
+    result = _collect(monkeypatch, lab, fleet, "--site", "spun", "--append", placed_id)
+    assert result.exit_code != 0
+    assert "not a free-mode spin calibration" in result.output
+    assert f"placed from spin calibration {free_id}" in result.output
+    assert f"--append {free_id} --site c405" in result.output
+    assert fleet.calls == []
+
+
+def test_a_placed_file_without_its_source_falls_back_to_the_site_anchor(
+    monkeypatch, lab
+):
+    _, fleet = _fleet()
+    result = _collect(monkeypatch, lab, fleet)
+    free_id = re.search(r"--from-calibration (\w+)", result.output).group(1)
+    result = CliRunner().invoke(
+        site_cmd.cmd,
+        ["init", "spun", "--from-calibration", free_id],
+        obj={"config": lab},
+    )
+    path = Path(re.search(r"saved to (\S+)", result.output).group(1))
+    text = path.read_text()
+    assert f'placed_from = "{free_id}' in text
+    path.write_text(re.sub(r'placed_from = "\w+"\n', "", text))
+    with pytest.raises(ValueError) as refused:
+        appendable_rounds(lighthouse2.read_calibration_file(path))
+    assert f"its site was defined from spin calibration {free_id}" in str(refused.value)
+    assert f"--append {free_id} --site c405" in str(refused.value)
+
+
 def test_append_and_drop_station_go_with_spin(lab):
     for flags in (["--append", "x"], ["--drop-station", "2"]):
         result = CliRunner().invoke(

From 9440a16487545540445fecb30af35fd9075b525a Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 13:36:14 +0200
Subject: [PATCH 45/80] dotbot/calibration: move a spin calibration onto a site
 as one rigid body

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/placement.py            | 299 +++++++++++++++++++++
 dotbot/cli/site_cmd.py                     |   5 +-
 dotbot/cli/swarm_lh2.py                    |  19 +-
 dotbot/tests/test_calibration_placement.py | 217 +++++++++++++++
 4 files changed, 536 insertions(+), 4 deletions(-)
 create mode 100644 dotbot/calibration/placement.py
 create mode 100644 dotbot/tests/test_calibration_placement.py

diff --git a/dotbot/calibration/placement.py b/dotbot/calibration/placement.py
new file mode 100644
index 00000000..51151674
--- /dev/null
+++ b/dotbot/calibration/placement.py
@@ -0,0 +1,299 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Moving a spin calibration onto a site as one rigid body.
+
+A free-mode calibration (`collect --spin`) defines its own frame, metric
+through the spin radius. `place_calibration` turns and shifts every station
+of it by one `Rigid2D`, so the stations keep their geometry relative to one
+another and the scale is never touched. The site editor's placement and
+`calibrate-lh2 reframe` of a spin calibration both go through it.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import math
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+
+import numpy as np
+
+from dotbot.calibration.conics import Track, fit_tracks
+from dotbot.calibration.lighthouse2 import Calibration, StationSolution
+from dotbot.site import Site
+
+# The solvers whose frame is the calibration's own, set by the spinning
+# robots rather than by marks in the room: only those may be moved.
+FREE_SOLVERS = frozenset({"conics-free", "conics-joint"})
+
+
+class PlacementRefused(ValueError):
+    """A calibration that must not be moved, or a move the robots cannot take."""
+
+
+@dataclass(frozen=True)
+class Rigid2D:
+    """Turn by `theta_deg` about the frame origin, then shift by
+    (`dx_mm`, `dy_mm`): `p' = R p + d`.
+
+    Positive angles turn +x toward +y, which with y pointing down is
+    clockwise as drawn.
+    """
+
+    dx_mm: float = 0.0
+    dy_mm: float = 0.0
+    theta_deg: float = 0.0
+
+    @classmethod
+    def about(
+        cls,
+        pivot: tuple[float, float],
+        theta_deg: float,
+        shift: tuple[float, float] = (0.0, 0.0),
+    ) -> Rigid2D:
+        """Turn about `pivot` by `theta_deg`, then translate by `shift`."""
+        theta = math.radians(theta_deg)
+        c, s = math.cos(theta), math.sin(theta)
+        px, py = pivot
+        return cls(
+            px - c * px + s * py + shift[0],
+            py - s * px - c * py + shift[1],
+            theta_deg,
+        )
+
+    def matrix(self) -> np.ndarray:
+        theta = math.radians(self.theta_deg)
+        c, s = math.cos(theta), math.sin(theta)
+        return np.array([[c, -s, self.dx_mm], [s, c, self.dy_mm], [0.0, 0.0, 1.0]])
+
+    def apply(self, points: Iterable[Sequence[float]]) -> list[tuple[float, float]]:
+        M = self.matrix()
+        return [
+            (
+                float(M[0, 0] * x + M[0, 1] * y + M[0, 2]),
+                float(M[1, 0] * x + M[1, 1] * y + M[1, 2]),
+            )
+            for x, y in points
+        ]
+
+    def box(self, rect: Sequence[float]) -> tuple[int, int, int, int]:
+        """The axis-aligned box `[x0, y0, x1, y1]` round `rect` once moved,
+        rounded outwards to whole millimetres."""
+        x0, y0, x1, y1 = rect
+        corners = self.apply([(x0, y0), (x1, y0), (x1, y1), (x0, y1)])
+        xs = [p[0] for p in corners]
+        ys = [p[1] for p in corners]
+        # A quarter turn lands on whole numbers but for rounding noise
+        return (
+            math.floor(min(xs) + 1e-6),
+            math.floor(min(ys) + 1e-6),
+            math.ceil(max(xs) - 1e-6),
+            math.ceil(max(ys) - 1e-6),
+        )
+
+
+def is_free_mode(calibration: Calibration) -> bool:
+    """Whether every station was solved in the calibration's own frame.
+
+    Read from the stations' solvers rather than the anchor: a placed
+    calibration takes its site's anchor, which a controller checks it
+    against, and stays movable.
+    """
+    return bool(calibration.stations) and all(
+        st.solved_from in FREE_SOLVERS for st in calibration.stations
+    )
+
+
+def station_rect(station: StationSolution) -> tuple[int, int, int, int] | None:
+    """The station's own validity rectangle, for files that carry one."""
+    rect = getattr(station, "valid_mm", None)
+    return tuple(int(v) for v in rect) if rect else None
+
+
+def spin_centres(calibration: Calibration) -> dict[int, list[dict]]:
+    """Each station's circles in the calibration's frame: name, centre and
+    radius in mm, one per `[[track]]` that station saw."""
+    out: dict[int, list[dict]] = {}
+    for station in calibration.stations:
+        samples = [t for t in calibration.tracks if t.station == station.index]
+        tracks = [
+            Track(points=t.camera_points(), radius_mm=t.radius_mm, name=t.name)
+            for t in samples
+            if t.count1
+        ]
+        out[station.index] = [
+            {
+                "name": fit.name,
+                "x": fit.centre_mm[0],
+                "y": fit.centre_mm[1],
+                "radius_mm": fit.radius_mm,
+            }
+            for fit in fit_tracks(tracks, station.matrix)
+        ]
+    return out
+
+
+def _weak(link) -> bool:
+    from dotbot.calibration.multi_station import (
+        LINK_SHARED_ADVISED,
+        LINK_SPREAD_ADVISED_MM,
+    )
+
+    return link.shared < LINK_SHARED_ADVISED or link.spread_mm < LINK_SPREAD_ADVISED_MM
+
+
+def overlay(calibration: Calibration) -> dict:
+    """What the site editor draws for `calibration`, in its own frame: the
+    fence, each station's rectangle (its own, else the fence) and spin
+    centres, and the links between stations."""
+    centres = spin_centres(calibration)
+    fence = [int(v) for v in calibration.valid_mm]
+    stations = []
+    for st in sorted(calibration.stations, key=lambda s: s.index):
+        rect = station_rect(st)
+        circles = centres.get(st.index, [])
+        stations.append(
+            {
+                "index": st.index,
+                "channel": st.index + 1,
+                "rect": list(rect) if rect is not None else fence,
+                "centres": [[c["x"], c["y"]] for c in circles],
+                "circles": circles,
+                "solved_from": st.solved_from,
+            }
+        )
+    return {
+        "id": calibration.id,
+        "id8": calibration.id8,
+        "free": is_free_mode(calibration),
+        "fence": fence,
+        "stations": stations,
+        "links": [
+            {"a": link.a, "b": link.b, "shared": link.shared, "weak": _weak(link)}
+            for link in getattr(calibration, "links", [])
+        ],
+        "tag": calibration.tag,
+        "created_at": calibration.created_at,
+        "site": calibration.site.name,
+        "anchor": calibration.site.anchor,
+    }
+
+
+def placed_tag(tag: str, site_name: str, taken: Iterable[str] = ()) -> str:
+    """The moved calibration's tag: `tag` suffixed with the site, then a
+    number if that tag is taken, so the two files answer to different tags."""
+    if not tag:
+        return ""
+    base = tag if tag.endswith(f"-{site_name}") else f"{tag}-{site_name}"
+    taken = {t.lower() for t in taken}
+    candidate, n = base, 2
+    while candidate.lower() in taken or candidate.lower() == tag.lower():
+        candidate, n = f"{base}-{n}", n + 1
+    return candidate
+
+
+def place_calibration(
+    calibration: Calibration,
+    site: Site,
+    transform: Rigid2D,
+    *,
+    reanchor: bool = False,
+    taken_tags: Iterable[str] = (),
+) -> Calibration:
+    """`calibration` moved by `transform` into `site`, as a new calibration.
+
+    Every station's homography becomes `T . H`, normalised; a station's own
+    rectangle becomes the site's extent, else the box round its turned
+    corners, and the fence their union; placements'
+    points move with it; tracks and links are copied. The original is not
+    modified.
+
+    A corner-collected calibration is tied to the floor through the site's
+    anchor and is refused unless `reanchor`. A move that puts a spin centre
+    or a station's rectangle below zero is refused: robots carry positions as
+    unsigned millimetres.
+    """
+    if not calibration.stations:
+        raise PlacementRefused(f"calibration {calibration.id8} has no solved station")
+    if not is_free_mode(calibration) and not reanchor:
+        kinds = sorted({st.solved_from for st in calibration.stations})
+        raise PlacementRefused(
+            f"calibration {calibration.id8} was collected at points of the room "
+            f"(solved from {', '.join(kinds)}), so its frame is the site's "
+            "anchor: moving it would misplace every robot. Re-anchor it only if "
+            "the anchor itself moved."
+        )
+    T = transform.matrix()
+    extent = site.valid_mm
+    stations = []
+    for st in calibration.stations:
+        H = T @ st.matrix
+        H = H / H[2, 2]
+        changes = {"homography": [[float(v) for v in row] for row in H]}
+        rect = station_rect(st)
+        if extent is not None:
+            changes["valid_mm"] = extent
+        elif rect is not None:
+            changes["valid_mm"] = transform.box(rect)
+        stations.append(dataclasses.replace(st, **changes))
+
+    below = [
+        f"station {st.index} (channel {st.index + 1})'s rectangle "
+        f"{list(station_rect(st))}"
+        for st in stations
+        if station_rect(st) is not None and min(station_rect(st)[:2]) < 0
+    ]
+    for index, circles in spin_centres(
+        dataclasses.replace(calibration, stations=stations)
+    ).items():
+        below += [
+            f"circle {c['name']} (station {index}, channel {index + 1}) at "
+            f"({c['x']:.0f}, {c['y']:.0f})"
+            for c in circles
+            if c["x"] < 0 or c["y"] < 0
+        ]
+    if below:
+        more = f" and {len(below) - 3} more" if len(below) > 3 else ""
+        raise PlacementRefused(
+            "the move puts "
+            + ", ".join(below[:3])
+            + more
+            + " below zero, where a robot cannot report a position"
+        )
+
+    rects = [station_rect(st) for st in stations]
+    if rects and all(r is not None for r in rects):
+        valid_mm = (
+            min(r[0] for r in rects),
+            min(r[1] for r in rects),
+            max(r[2] for r in rects),
+            max(r[3] for r in rects),
+        )
+    elif site.valid_mm is not None:
+        valid_mm = site.valid_mm
+    else:
+        valid_mm = transform.box(calibration.valid_mm)
+    placements = [
+        dataclasses.replace(
+            placement,
+            points_mm=transform.apply(placement.points_mm),
+            samples=[dataclasses.replace(s) for s in placement.samples],
+        )
+        for placement in calibration.placements
+    ]
+    extra = {}
+    if hasattr(calibration, "links"):
+        extra["links"] = list(calibration.links)
+    return Calibration(
+        **extra,
+        site=Site(name=site.name, anchor=site.anchor),
+        valid_mm=tuple(int(v) for v in valid_mm),
+        placements=placements,
+        stations=stations,
+        tracks=list(calibration.tracks),
+        created_at=calibration.created_at,
+        tag=placed_tag(calibration.tag, site.name, taken_tags),
+        robot=calibration.robot,
+        placed_from=calibration.id,
+    )
diff --git a/dotbot/cli/site_cmd.py b/dotbot/cli/site_cmd.py
index 8fbc49d2..fbce2d88 100644
--- a/dotbot/cli/site_cmd.py
+++ b/dotbot/cli/site_cmd.py
@@ -794,6 +794,7 @@ def init(ctx, name, calibration, size, force):
         site_name_as_bytes,
         write_calibration,
     )
+    from dotbot.calibration.placement import Rigid2D, place_calibration
     from dotbot.cli._swarm_inject import swarm_connection
 
     obj = ctx.obj or {}
@@ -822,7 +823,9 @@ def init(ctx, name, calibration, size, force):
         except ValueError:
             path = resolve_calibration_path(calibration)
         source = read_calibration_file(path)
-        site, placed = self_defined_site(source, name, size)
+        site, _ = self_defined_site(source, name, size)
+        field = site.areas["field"]
+        placed = place_calibration(source, site, Rigid2D(field.x, field.y, 0.0))
     except ValueError as exc:
         raise click.ClickException(str(exc)) from exc
     saved = write_calibration(placed)
diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 2b26fa18..ff8073a2 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -979,7 +979,9 @@ def _parse_shift(_ctx, _param, value):
         "Re-express a saved calibration in another site's frame, without a "
         "capture: shift (and turn) every placement's points, re-solve every "
         "station from the stored samples, and save a new file with a new id "
-        "under ~/.dotbot/calibrations/<site>/."
+        "under ~/.dotbot/calibrations/<site>/. A spin calibration has no "
+        "placements: it is moved as one rigid body instead, every station "
+        "with it, as the site editor places one."
     ),
 )
 @click.argument("calibration")
@@ -1005,7 +1007,8 @@ def _parse_shift(_ctx, _param, value):
     show_default=True,
     help=(
         "Degrees to turn the points about the first placement's first point "
-        "before shifting; positive turns x toward y."
+        "(a spin calibration: about its zero) before shifting; positive turns "
+        "x toward y."
     ),
 )
 @click.pass_context
@@ -1020,6 +1023,11 @@ def _reframe(ctx, calibration, site_name, shift, rotate):
         resolve_calibration_path,
         write_calibration,
     )
+    from dotbot.calibration.placement import (
+        Rigid2D,
+        is_free_mode,
+        place_calibration,
+    )
 
     site, _ = site_from_context(ctx, site_name)
     if site.extent_mm is None and not site.anchor:
@@ -1029,7 +1037,12 @@ def _reframe(ctx, calibration, site_name, shift, rotate):
         )
     try:
         source = read_calibration_file(resolve_calibration_path(calibration))
-        reframed = reframe_calibration(source, site, shift, rotate)
+        if is_free_mode(source):
+            reframed = place_calibration(
+                source, site, Rigid2D(shift[0], shift[1], rotate)
+            )
+        else:
+            reframed = reframe_calibration(source, site, shift, rotate)
     except ValueError as exc:
         raise click.ClickException(str(exc)) from exc
     path = write_calibration(reframed)
diff --git a/dotbot/tests/test_calibration_placement.py b/dotbot/tests/test_calibration_placement.py
new file mode 100644
index 00000000..573174e1
--- /dev/null
+++ b/dotbot/tests/test_calibration_placement.py
@@ -0,0 +1,217 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Moving a spin calibration onto a site as one rigid body."""
+
+import dataclasses
+import math
+
+import numpy as np
+import pytest
+
+from dotbot.calibration import conics
+from dotbot.calibration.conics import apply
+from dotbot.calibration.lighthouse2 import transform_points
+from dotbot.calibration.placement import (
+    PlacementRefused,
+    Rigid2D,
+    overlay,
+    place_calibration,
+    placed_tag,
+    spin_centres,
+)
+from dotbot.site import Site
+from dotbot.tests.test_calibration_conics import (
+    CENTRES,
+    FLOOR_TO_CAM,
+    STATION,
+    STATION_B,
+    circle_samples,
+    track_samples,
+)
+
+SITE = Site(name="hand", anchor="the door's left jamb", extent_mm=(5000, 5000))
+
+
+@pytest.fixture(scope="module")
+def spun():
+    calibration, _, _ = conics.solve_calibration(
+        track_samples(CENTRES), Site(name="lab"), tag="spin"
+    )
+    return calibration
+
+
+def _centres(calibration):
+    return {
+        (index, c["name"]): (c["x"], c["y"])
+        for index, circles in spin_centres(calibration).items()
+        for c in circles
+    }
+
+
+def test_a_move_turns_then_shifts():
+    move = Rigid2D(1000, 0, 90)
+    assert move.apply([(100, 0)]) == [pytest.approx((1000, 100))]
+
+
+def test_a_move_about_a_pivot_keeps_the_pivot():
+    move = Rigid2D.about((500, 300), 90)
+    assert move.apply([(500, 300)]) == [pytest.approx((500, 300))]
+    assert move.apply([(600, 300)]) == [pytest.approx((500, 400))]
+
+
+@pytest.mark.parametrize("rotate", [0, 90, 37.5, -90])
+def test_the_move_agrees_with_reframe_s_point_transform(rotate):
+    points = [(0, 0), (1200, 300), (-40, 2000)]
+    move = Rigid2D.about((1200, 300), rotate, (250, -75))
+    assert np.ravel(move.apply(points)) == pytest.approx(
+        np.ravel(transform_points(points, (250, -75), rotate, (1200, 300)))
+    )
+
+
+def test_a_box_turned_by_a_right_angle_stays_exact():
+    assert Rigid2D(3000, 0, 90).box((0, 0, 2000, 1000)) == (2000, 0, 3000, 2000)
+
+
+def test_a_box_turned_freely_grows_to_hold_the_turned_rectangle():
+    x0, y0, x1, y1 = Rigid2D.about((500, 500), 45).box((0, 0, 1000, 1000))
+    half = 500 * math.sqrt(2)
+    assert (x0, y0) == (math.floor(500 - half), math.floor(500 - half))
+    assert (x1, y1) == (math.ceil(500 + half), math.ceil(500 + half))
+
+
+def test_placed_circles_land_where_the_move_puts_them(spun):
+    move = Rigid2D(3000, 400, 90)
+    placed = place_calibration(spun, SITE, move)
+    before, after = _centres(spun), _centres(placed)
+    assert after.keys() == before.keys()
+    for key, (x, y) in before.items():
+        assert after[key] == pytest.approx(move.apply([(x, y)])[0], abs=0.1)
+
+
+def test_a_placement_is_a_new_calibration_in_the_site(spun):
+    placed = place_calibration(spun, SITE, Rigid2D(3000, 400, 90))
+    assert placed.id != spun.id
+    assert placed.site.name == "hand"
+    assert placed.site.anchor == SITE.anchor
+    assert placed.valid_mm == (0, 0, 5000, 5000)
+    assert placed.tracks == spun.tracks
+    assert placed.tag == "spin-hand"
+    assert spun.site.name == "lab" and spun.stations[0].matrix.tolist() != (
+        placed.stations[0].matrix.tolist()
+    )
+
+
+def test_scale_is_kept(spun):
+    placed = place_calibration(spun, SITE, Rigid2D(2500, 600, 33))
+    cam = apply(FLOOR_TO_CAM, np.array([[500.0, 500.0], [1500.0, 2500.0]]))
+    a = apply(spun.stations[0].matrix, cam)
+    b = apply(placed.stations[0].matrix, cam)
+    assert np.linalg.norm(b[1] - b[0]) == pytest.approx(np.linalg.norm(a[1] - a[0]))
+
+
+def test_a_corner_calibration_is_refused_unless_re_anchored(spun):
+    corner = dataclasses.replace(
+        spun,
+        stations=[
+            dataclasses.replace(st, solved_from="direct") for st in spun.stations
+        ],
+    )
+    with pytest.raises(PlacementRefused, match="collected at points of the room"):
+        place_calibration(corner, SITE, Rigid2D(100, 0, 0))
+    placed = place_calibration(corner, SITE, Rigid2D(100, 0, 0), reanchor=True)
+    assert placed.stations[0].solved_from == "direct"
+
+
+def test_a_move_below_zero_is_refused(spun):
+    with pytest.raises(PlacementRefused, match="below zero"):
+        place_calibration(spun, SITE, Rigid2D(0, 0, 90))
+
+
+def test_the_tag_is_suffixed_with_the_site_and_never_reused():
+    assert placed_tag("", "hand") == ""
+    assert placed_tag("spin", "hand") == "spin-hand"
+    assert placed_tag("spin-hand", "hand") == "spin-hand-2"
+    assert placed_tag("spin", "hand", ["spin-hand", "SPIN-HAND-2"]) == "spin-hand-3"
+
+
+def test_every_station_moves_as_one_body_with_its_own_rectangle():
+    samples = circle_samples(STATION, CENTRES, 0) + circle_samples(
+        STATION_B, CENTRES[1:], 1, start=1
+    )
+    calibration, _, unsolved = conics.solve_calibration(samples, Site(name="lab"))
+    assert not unsolved
+    rects = {0: (0, 0, 1500, 1500), 1: (500, 200, 2000, 2800)}
+    calibration = dataclasses.replace(
+        calibration,
+        stations=[
+            dataclasses.replace(st, valid_mm=rects[st.index])
+            for st in calibration.stations
+        ],
+    )
+    # Without an extent, each station's rectangle moves with it
+    unbounded = Site(name=SITE.name, anchor=SITE.anchor)
+    move = Rigid2D(3500, 100, 90)
+    placed = place_calibration(calibration, unbounded, move)
+    before, after = _centres(calibration), _centres(placed)
+    for key, (x, y) in before.items():
+        assert after[key] == pytest.approx(move.apply([(x, y)])[0], abs=0.1)
+    assert {st.index: st.valid_mm for st in placed.stations} == {
+        0: (2000, 100, 3500, 1600),
+        1: (700, 600, 3300, 2100),
+    }
+    drawn = overlay(placed)["stations"]
+    assert [s["rect"] for s in drawn] == [
+        [2000, 100, 3500, 1600],
+        [700, 600, 3300, 2100],
+    ]
+    assert placed.valid_mm == (700, 100, 3500, 2100)
+    assert all(len(s["circles"]) for s in drawn)
+    with pytest.raises(PlacementRefused, match=r"station 1 \(channel 2\)'s rectangle"):
+        place_calibration(calibration, unbounded, Rigid2D(2700, 100, 90))
+
+
+def test_reframe_moves_a_spin_calibration_as_the_editor_does(
+    spun, tmp_path, monkeypatch
+):
+    from click.testing import CliRunner
+
+    from dotbot.calibration import lighthouse2
+    from dotbot.calibration.lighthouse2 import read_calibration_file, write_calibration
+    from dotbot.cli import swarm_lh2
+    from dotbot.config import load_discovered
+
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path / "home")
+    source = write_calibration(spun)
+    lab = tmp_path / "lab"
+    (lab / "sites" / "hand").mkdir(parents=True)
+    (lab / "sites" / "hand" / "site.toml").write_text(
+        f'anchor = "{SITE.anchor}"\nextent_mm = [5000, 5000]\n'
+    )
+    (lab / "dotbot.toml").write_text('site = "hand"\n')
+    result = CliRunner().invoke(
+        swarm_lh2.cmd,
+        [
+            "reframe",
+            str(source),
+            "--site",
+            "hand",
+            "--shift",
+            "3000,400",
+            "--rotate",
+            "90",
+        ],
+        obj={"config": load_discovered(environ={}, start_dir=lab)},
+    )
+    assert result.exit_code == 0, result.output
+    (written,) = (tmp_path / "home" / "calibrations" / "hand").glob("*.toml")
+    expected = place_calibration(spun, SITE, Rigid2D(3000, 400, 90))
+    assert read_calibration_file(written).id == expected.id
+
+
+def test_site_init_s_placement_is_the_editor_s(spun):
+    site, placed = conics.self_defined_site(spun, "spun", size_mm=(4000, 4000))
+    field = site.areas["field"]
+    moved = place_calibration(spun, site, Rigid2D(field.x, field.y, 0))
+    assert moved.id == placed.id
+    assert moved.tag == placed.tag

From 25fda015f4643d46bff6a765152e694499f03be1 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 13:36:14 +0200
Subject: [PATCH 46/80] dotbot/site_editor: list, draw and place LH2
 calibrations

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py               |   3 +
 dotbot/site_placement.py            | 164 ++++++++++++++++++++++++++++
 dotbot/tests/test_site_placement.py | 130 ++++++++++++++++++++++
 3 files changed, 297 insertions(+)
 create mode 100644 dotbot/site_placement.py
 create mode 100644 dotbot/tests/test_site_placement.py

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index 520bc5f8..9a47340a 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -28,6 +28,7 @@
 from dotbot import site_toml
 from dotbot.site import PACK_CALIBRATIONS
 from dotbot.site_packs import PACK_FILE
+from dotbot.site_placement import create_router
 
 EDITOR_DIR = Path(__file__).parent / "console-web" / "dist"
 EDITOR_PAGE = "site-editor.html"
@@ -220,6 +221,8 @@ def done():
             on_done()
         return {"ok": True}
 
+    app.include_router(create_router(state.name, state.pack, lambda: read()[1]))
+
     @app.get("/", include_in_schema=False)
     def page():
         return FileResponse(page_dir / EDITOR_PAGE)
diff --git a/dotbot/site_placement.py b/dotbot/site_placement.py
new file mode 100644
index 00000000..f9edc158
--- /dev/null
+++ b/dotbot/site_placement.py
@@ -0,0 +1,164 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""The site editor's calibration routes: list the LH2 calibrations, draw one
+over the site, and save it moved onto the site as a new calibration.
+
+The file a calibration is loaded from is never written; a placement is saved
+under a new id, beside it in the site's calibration folder.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from collections.abc import Callable
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from dotbot.calibration import lighthouse2
+from dotbot.calibration.placement import (
+    FREE_SOLVERS,
+    PlacementRefused,
+    Rigid2D,
+    is_free_mode,
+    overlay,
+    place_calibration,
+    spin_centres,
+)
+from dotbot.config import SiteSection
+from dotbot.site import PACK_CALIBRATIONS, Site, site_from_table
+
+
+class PlaceRequest(BaseModel):
+    dx_mm: float = 0.0
+    dy_mm: float = 0.0
+    theta_deg: float = 0.0
+    # Move a corner-collected calibration anyway: the anchor itself moved
+    reanchor: bool = False
+
+
+def _folders(pack: Path) -> list[tuple[Path, str]]:
+    return [(pack / PACK_CALIBRATIONS, ""), (lighthouse2.calibration_root(), "*/")]
+
+
+def _files(pack: Path) -> list[Path]:
+    seen, out = set(), []
+    for folder, prefix in _folders(pack):
+        for path in sorted(folder.glob(prefix + lighthouse2.CALIBRATION_TOML_GLOB)):
+            if path.resolve() not in seen:
+                seen.add(path.resolve())
+                out.append(path)
+    return out
+
+
+def _metadata(path: Path) -> dict | None:
+    try:
+        with open(path, "rb") as handle:
+            data = tomllib.load(handle)
+    except (OSError, tomllib.TOMLDecodeError):
+        return None
+    meta = data.get("metadata", {})
+    stations = data.get("station", [])
+    return {
+        "id": meta.get("id", ""),
+        "id8": str(meta.get("id", ""))[:8],
+        "created_at": meta.get("created_at", ""),
+        "free": bool(stations)
+        and all(st.get("solved_from") in FREE_SOLVERS for st in stations),
+        "stations": sorted(int(st.get("index", 0)) for st in stations),
+        "tag": meta.get("tag", ""),
+        "site": data.get("site", {}).get("name", ""),
+        "path": str(path),
+    }
+
+
+def create_router(name: str, pack: Path, site_text: Callable[[], str]) -> APIRouter:
+    """Routes for the site `name` in `pack`; `site_text` reads its site.toml."""
+    router = APIRouter()
+
+    def resolve(spec: str) -> lighthouse2.Calibration:
+        try:
+            path = lighthouse2.resolve_calibration_spec(
+                spec,
+                _folders(pack),
+                glob=lighthouse2.CALIBRATION_TOML_GLOB,
+                metadata=lighthouse2._file_metadata,
+                what="calibration",
+                created_key="created_at",
+            )
+            return lighthouse2.read_calibration_file(path)
+        except ValueError as exc:
+            raise HTTPException(404, str(exc)) from exc
+
+    def current_site() -> Site:
+        try:
+            table = SiteSection.model_validate(tomllib.loads(site_text()))
+        except Exception as exc:  # noqa: BLE001
+            raise HTTPException(409, f"site.toml does not read: {exc}") from exc
+        return site_from_table(name, table, pack)
+
+    @router.get("/api/calibrations")
+    def calibrations():
+        return [m for m in map(_metadata, _files(pack)) if m and m["id"]]
+
+    @router.get("/api/calibrations/{spec}")
+    def calibration(spec: str):
+        cal = resolve(spec)
+        return {**overlay(cal), "path": str(cal.path)}
+
+    @router.post("/api/calibrations/{spec}/place")
+    def place(spec: str, request: PlaceRequest):
+        source = resolve(spec)
+        site = current_site()
+        taken = [
+            m["tag"]
+            for m in map(_metadata, _files(pack))
+            if m and m["site"] == site.name and m["tag"]
+        ]
+        move = Rigid2D(request.dx_mm, request.dy_mm, request.theta_deg)
+        try:
+            placed = place_calibration(
+                source, site, move, reanchor=request.reanchor, taken_tags=taken
+            )
+        except PlacementRefused as exc:
+            raise HTTPException(422, str(exc)) from exc
+        if placed.id == source.id:
+            raise HTTPException(
+                422, "the move changes nothing; the calibration is already there"
+            )
+        path = lighthouse2.write_calibration(placed)
+        warnings = []
+        if site.extent_mm is not None:
+            width, height = site.extent_mm
+            outside = [
+                c["name"]
+                for circles in spin_centres(placed).values()
+                for c in circles
+                if c["x"] > width or c["y"] > height
+            ]
+            if outside:
+                warnings.append(
+                    f"{len(outside)} circle(s) land outside the site's extent "
+                    f"({', '.join(sorted(set(outside)))}), where robots drop "
+                    "their positions"
+                )
+        if not is_free_mode(source):
+            warnings.append(
+                f"{source.id8} was collected at points of the room and has been "
+                "re-anchored; check the anchor in site.toml says where zero is now"
+            )
+        changed = " --site-changed" if source.site.name != site.name else ""
+        return {
+            **overlay(placed),
+            "path": str(path),
+            "source": source.id8,
+            "push": (
+                f"dotbot swarm calibrate-lh2 push {placed.id8} --site {site.name}"
+                f"{changed}"
+            ),
+            "warnings": warnings,
+        }
+
+    return router
diff --git a/dotbot/tests/test_site_placement.py b/dotbot/tests/test_site_placement.py
new file mode 100644
index 00000000..4df3f296
--- /dev/null
+++ b/dotbot/tests/test_site_placement.py
@@ -0,0 +1,130 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""The site editor's calibration routes: list, draw and place a spin
+calibration, never writing the file it was loaded from."""
+
+import dataclasses
+
+import pytest
+from fastapi.testclient import TestClient
+
+from dotbot.calibration import conics, lighthouse2
+from dotbot.calibration.lighthouse2 import read_calibration_file, write_calibration
+from dotbot.calibration.placement import Rigid2D, spin_centres
+from dotbot.site import Site
+from dotbot.site_editor import EditorState, create_app
+from dotbot.tests.test_calibration_conics import CENTRES, track_samples
+from dotbot.tests.test_site_toml import ARENA
+
+
+@pytest.fixture
+def home(tmp_path, monkeypatch):
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path / "home")
+    return tmp_path / "home" / "calibrations"
+
+
+@pytest.fixture
+def spun(home):
+    calibration, _, _ = conics.solve_calibration(
+        track_samples(CENTRES), Site(name="lab"), tag="spin"
+    )
+    write_calibration(calibration)
+    return calibration
+
+
+@pytest.fixture
+def client(tmp_path, home):
+    pack = tmp_path / "arena"
+    pack.mkdir()
+    (pack / "site.toml").write_text(ARENA)
+    page = tmp_path / "dist"
+    page.mkdir()
+    (page / "site-editor.html").write_text("<html></html>")
+    return TestClient(
+        create_app(EditorState("arena", pack, [home / "arena"]), page),
+        base_url="http://127.0.0.1",
+    )
+
+
+def test_the_calibrations_are_listed_with_their_kind(client, spun):
+    listed = client.get("/api/calibrations").json()
+    assert [
+        (c["id"], c["site"], c["tag"], c["free"], c["stations"]) for c in listed
+    ] == [(spun.id, "lab", "spin", True, [0])]
+
+
+def test_a_calibration_is_drawn_by_id_in_its_own_frame(client, spun):
+    body = client.get(f"/api/calibrations/{spun.id8}").json()
+    assert body["id"] == spun.id and body["free"] is True
+    (station,) = body["stations"]
+    assert (station["index"], station["channel"]) == (0, 1)
+    assert len(station["centres"]) == len(CENTRES)
+    assert body["fence"] == station["rect"] == list(spun.valid_mm)
+    assert body["links"] == []
+
+
+def test_an_unknown_calibration_is_a_404(client, spun):
+    assert client.get("/api/calibrations/ffffffff").status_code == 404
+
+
+def test_a_placement_writes_a_new_calibration_and_keeps_the_original(
+    client, spun, home
+):
+    source = spun.path.read_bytes()
+    body = client.post(
+        f"/api/calibrations/{spun.id8}/place",
+        json={"dx_mm": 100, "dy_mm": 200, "theta_deg": 0},
+    ).json()
+    assert spun.path.read_bytes() == source
+    placed = read_calibration_file(home / "arena" / body["path"].split("/")[-1])
+    assert placed.id == body["id"] != spun.id
+    assert placed.site.name == "arena"
+    assert placed.site.anchor == "the corner where the top wall meets the door wall"
+    assert placed.valid_mm == (0, 0, 2000, 4000)
+    assert body["push"] == (
+        f"dotbot swarm calibrate-lh2 push {placed.id8} --site arena --site-changed"
+    )
+    move = Rigid2D(100, 200, 0)
+    before = spin_centres(spun)[0]
+    after = spin_centres(placed)[0]
+    for a, b in zip(before, after):
+        assert (b["x"], b["y"]) == pytest.approx(
+            move.apply([(a["x"], a["y"])])[0], abs=0.1
+        )
+
+
+def test_a_corner_calibration_is_refused_unless_re_anchored(client, spun):
+    corner = dataclasses.replace(
+        spun,
+        stations=[
+            dataclasses.replace(st, solved_from="direct") for st in spun.stations
+        ],
+        tag="corner",
+    )
+    write_calibration(corner)
+    listed = {c["tag"]: c["free"] for c in client.get("/api/calibrations").json()}
+    assert listed == {"spin": True, "corner": False}
+    refused = client.post("/api/calibrations/corner/place", json={"dx_mm": 10})
+    assert refused.status_code == 422
+    assert "collected at points of the room" in refused.json()["detail"]
+    moved = client.post(
+        "/api/calibrations/corner/place", json={"dx_mm": 10, "reanchor": True}
+    )
+    assert moved.status_code == 200
+    assert any("re-anchored" in w for w in moved.json()["warnings"])
+
+
+def test_a_placement_below_zero_is_refused(client, spun):
+    refused = client.post(
+        f"/api/calibrations/{spun.id8}/place", json={"theta_deg": 180}
+    )
+    assert refused.status_code == 422
+    assert "below zero" in refused.json()["detail"]
+
+
+def test_a_placement_outside_the_extent_is_saved_with_a_warning(client, spun):
+    body = client.post(
+        f"/api/calibrations/{spun.id8}/place", json={"dx_mm": 1500}
+    ).json()
+    assert any("outside the site's extent" in w for w in body["warnings"])

From 509996947113a3651c10a6a831195094d527bb90 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 13:36:14 +0200
Subject: [PATCH 47/80] dotbot/console-web: place a spin calibration in the
 site editor

AI-assisted: Claude Opus 5.5
---
 .../src/siteEditor/CalibrationPanel.tsx       | 179 +++++++++++++++++
 dotbot/console-web/src/siteEditor/Canvas.tsx  | 182 +++++++++++++++++-
 .../console-web/src/siteEditor/Inspector.tsx  |   3 +
 .../console-web/src/siteEditor/SiteEditor.tsx |  82 +++++++-
 dotbot/console-web/src/siteEditor/api.ts      |  37 +++-
 .../console-web/src/siteEditor/rigid.test.ts  |  36 ++++
 dotbot/console-web/src/siteEditor/rigid.ts    |  57 ++++++
 .../src/siteEditor/siteEditor.test.tsx        |  94 +++++++++
 dotbot/console-web/src/siteEditor/types.ts    |  52 +++++
 9 files changed, 710 insertions(+), 12 deletions(-)
 create mode 100644 dotbot/console-web/src/siteEditor/CalibrationPanel.tsx
 create mode 100644 dotbot/console-web/src/siteEditor/rigid.test.ts
 create mode 100644 dotbot/console-web/src/siteEditor/rigid.ts

diff --git a/dotbot/console-web/src/siteEditor/CalibrationPanel.tsx b/dotbot/console-web/src/siteEditor/CalibrationPanel.tsx
new file mode 100644
index 00000000..e165e1a2
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/CalibrationPanel.tsx
@@ -0,0 +1,179 @@
+import React, { useState } from "react";
+
+import type { Placement } from "./Canvas";
+import type { Rigid2D } from "./rigid";
+import type { CalibrationListing, PlacedCalibration } from "./types";
+
+// Placing a spin calibration on the site: pick one by id, move it on the
+// canvas or here, and save it as a new calibration of this site.
+
+const small: React.CSSProperties = { fontSize: 11, color: "var(--muted)", marginTop: 6 };
+const field: React.CSSProperties = {
+  width: "100%",
+  padding: "5px 7px",
+  background: "var(--elevated)",
+  color: "var(--text)",
+  border: "1px solid var(--hairline)",
+  borderRadius: 4,
+  fontFamily: "var(--font-mono)",
+  fontSize: 12,
+};
+const button: React.CSSProperties = {
+  background: "transparent",
+  color: "var(--text)",
+  border: "1px solid var(--hairline)",
+  borderRadius: 4,
+  padding: "4px 10px",
+  cursor: "pointer",
+  fontSize: 12,
+};
+
+export interface CalibrationPanelProps {
+  listing: CalibrationListing[];
+  placement: Placement | null;
+  reanchor: boolean;
+  placed: PlacedCalibration | null;
+  /** Why Save is not possible now, if it is not. */
+  blocked: string | null;
+  onLoad: (spec: string) => void;
+  onMove: (move: Rigid2D) => void;
+  onReanchor: (on: boolean) => void;
+  onSave: () => void;
+  onClear: () => void;
+}
+
+function Num(props: { name: string; value: number; onChange: (v: number) => void }) {
+  return (
+    <label style={{ flex: 1 }}>
+      <span style={{ ...small, display: "block", margin: "8px 0 3px" }}>{props.name}</span>
+      <input
+        aria-label={props.name}
+        type="number"
+        step="any"
+        value={props.value}
+        onChange={(e) => {
+          const v = Number(e.target.value);
+          if (Number.isFinite(v)) props.onChange(v);
+        }}
+        style={field}
+      />
+    </label>
+  );
+}
+
+export function CalibrationPanel(props: CalibrationPanelProps) {
+  const [spec, setSpec] = useState("");
+  const overlay = props.placement?.overlay ?? null;
+  const move = props.placement?.move ?? null;
+  const refused = !!overlay && !overlay.free && !props.reanchor;
+
+  return (
+    <div data-testid="calibration-panel" style={{ borderBottom: "1px solid var(--hairline)", padding: "12px 14px" }}>
+      <div
+        style={{
+          fontSize: 11,
+          fontWeight: 600,
+          letterSpacing: 0.6,
+          textTransform: "uppercase",
+          color: "var(--muted)",
+        }}
+      >
+        Place a calibration
+      </div>
+      <div style={small}>
+        A spin calibration defines its own frame. Load one by id, drag it onto the site and turn it with the
+        handle; Save writes a new calibration and leaves the original as it is.
+      </div>
+      <form
+        style={{ display: "flex", gap: 6, marginTop: 8 }}
+        onSubmit={(e) => {
+          e.preventDefault();
+          if (spec.trim()) props.onLoad(spec.trim());
+        }}
+      >
+        <input
+          aria-label="calibration id"
+          list="site-editor-calibrations"
+          placeholder="id, tag or path"
+          value={spec}
+          onChange={(e) => setSpec(e.target.value)}
+          style={field}
+        />
+        <datalist id="site-editor-calibrations">
+          {props.listing.map((c) => (
+            <option key={c.id} value={c.id8}>
+              {`${c.site}${c.tag ? ` ${c.tag}` : ""} ${c.created_at}, station${c.stations.length === 1 ? "" : "s"} ${c.stations.join(", ")}${c.free ? " (spin)" : " (corners)"}`}
+            </option>
+          ))}
+        </datalist>
+        <button type="submit" style={button}>
+          Load
+        </button>
+      </form>
+      {props.listing.length > 0 && (
+        <div style={small}>
+          {props.listing.length} calibration file{props.listing.length === 1 ? "" : "s"} found; type an id prefix,
+          the newest is never picked for you.
+        </div>
+      )}
+
+      {overlay && move && (
+        <div data-testid="placement-inspector">
+          <div style={{ ...small, color: "var(--text)", fontFamily: "var(--font-mono)" }}>
+            {overlay.id8} {overlay.tag ? `(${overlay.tag}) ` : ""}from site {overlay.site},{" "}
+            {overlay.stations.map((st) => `station ${st.index} (channel ${st.channel})`).join(", ")}
+          </div>
+          {!overlay.free && (
+            <div data-testid="placement-refused" style={{ ...small, color: "var(--s-Stopping)" }}>
+              This calibration was collected at points of the room: its frame is the site's anchor, so moving it
+              misplaces every robot. Only re-anchor it if the anchor itself moved.
+              <label style={{ display: "block", marginTop: 4, color: "var(--text)" }}>
+                <input
+                  type="checkbox"
+                  aria-label="re-anchor"
+                  checked={props.reanchor}
+                  onChange={(e) => props.onReanchor(e.target.checked)}
+                />{" "}
+                Re-anchor
+              </label>
+            </div>
+          )}
+          <div style={{ display: "flex", gap: 8 }}>
+            <Num name="shift x (mm)" value={move.dx_mm} onChange={(dx_mm) => props.onMove({ ...move, dx_mm })} />
+            <Num name="shift y (mm)" value={move.dy_mm} onChange={(dy_mm) => props.onMove({ ...move, dy_mm })} />
+          </div>
+          <Num name="turn (deg)" value={move.theta_deg} onChange={(theta_deg) => props.onMove({ ...move, theta_deg })} />
+          <div style={small}>Scale is locked: the file is metric through the spin radius.</div>
+          <div style={{ display: "flex", gap: 8, marginTop: 10 }}>
+            <button
+              type="button"
+              style={{ ...button, opacity: refused || props.blocked ? 0.5 : 1 }}
+              disabled={refused || !!props.blocked}
+              title={props.blocked ?? (refused ? "a corner-collected calibration is not moved" : "write a new calibration")}
+              onClick={props.onSave}
+            >
+              Save calibration
+            </button>
+            <button type="button" style={button} onClick={props.onClear}>
+              Clear
+            </button>
+          </div>
+          {props.blocked && <div style={small}>{props.blocked}</div>}
+        </div>
+      )}
+
+      {props.placed && (
+        <div data-testid="placement-saved" style={{ ...small, color: "var(--text)" }}>
+          Saved {props.placed.id8} (from {props.placed.source}) to {props.placed.path}. Robots still hold the old
+          placement and draw in the wrong place until it is pushed:
+          <pre style={{ ...field, whiteSpace: "pre-wrap", marginTop: 6 }}>{props.placed.push}</pre>
+          {props.placed.warnings.map((w) => (
+            <div key={w} style={{ color: "var(--s-Programming)", marginTop: 4 }}>
+              warning: {w}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/dotbot/console-web/src/siteEditor/Canvas.tsx b/dotbot/console-web/src/siteEditor/Canvas.tsx
index 6127c5c9..cb440e49 100644
--- a/dotbot/console-web/src/siteEditor/Canvas.tsx
+++ b/dotbot/console-web/src/siteEditor/Canvas.tsx
@@ -15,15 +15,27 @@ import {
 } from "../grid";
 import type { Area } from "../types";
 import { FRAME_CAMERA, viewGeom } from "../zoom";
-import { HANDLES, effectiveRole, moveRect, rectFromDrag, resizeRect } from "./edit";
+import { HANDLES, effectiveRole, moveRect, rectFromDrag, resizeRect, snap } from "./edit";
 import type { Handle, Rect } from "./edit";
-import type { EditArea } from "./types";
+import { applyMove, movedBox, movedCorners, snapAngle, turnAbout } from "./rigid";
+import type { Point, Rigid2D } from "./rigid";
+import type { CalibrationOverlay, EditArea } from "./types";
 
 // The site drawn to scale: the extent, the metric grid and its rulers, and
 // every area in its role colour. Areas are moved, resized and drawn here; the
 // numbers themselves live in the inspector.
 
-export type Tool = "select" | "area";
+export type Tool = "select" | "area" | "calibration";
+
+/** A calibration drawn over the site, and the move that places it. */
+export interface Placement {
+  overlay: CalibrationOverlay;
+  move: Rigid2D;
+}
+
+// One colour per station, in station order
+const STATION_COLOURS = ["var(--accent)", "var(--s-Running)", "var(--s-Programming)", "var(--s-Bootloader)"];
+const ROTATE_HANDLE_PX = 28;
 
 const HANDLE_PX = 9;
 const AREA_TINT = 0.12;
@@ -33,7 +45,9 @@ const DRAG_THRESHOLD_PX = 3;
 type Drag =
   | { kind: "move"; index: number; start: Rect; from: { x: number; y: number }; px: { x: number; y: number } }
   | { kind: "resize"; index: number; start: Rect; handle: Handle }
-  | { kind: "draw"; from: { x: number; y: number }; to: { x: number; y: number } };
+  | { kind: "draw"; from: { x: number; y: number }; to: { x: number; y: number } }
+  | { kind: "place-move"; start: Rigid2D; from: { x: number; y: number } }
+  | { kind: "place-turn"; start: Rigid2D; pivot: Point; angle: number };
 
 export interface CanvasProps {
   extent: [number, number] | null;
@@ -45,6 +59,8 @@ export interface CanvasProps {
   onSelect: (index: number | null) => void;
   onChange: (index: number, rect: Rect) => void;
   onDraw: (rect: Rect) => void;
+  placement?: Placement | null;
+  onPlacement?: (move: Rigid2D) => void;
 }
 
 function handlePoint(r: Rect, h: Handle): { x: number; y: number } {
@@ -135,7 +151,7 @@ export function Canvas(props: CanvasProps) {
   };
 
   const onAreaDown = (e: React.PointerEvent, index: number) => {
-    if (e.button !== 0 || props.tool === "area") return;
+    if (e.button !== 0 || props.tool !== "select") return;
     const a = props.areas[index];
     props.onSelect(index);
     begin(e, {
@@ -153,12 +169,44 @@ export function Canvas(props: CanvasProps) {
     begin(e, { kind: "resize", index, start: { x: a.x, y: a.y, w: a.w, h: a.h }, handle });
   };
 
+  const placement = props.placement ?? null;
+  const fence = placement ? placement.overlay.fence : null;
+  const placedBox = placement && fence ? movedBox(placement.move, fence) : null;
+  const placeCentre: Point | null = placedBox
+    ? [(placedBox[0] + placedBox[2]) / 2, (placedBox[1] + placedBox[3]) / 2]
+    : null;
+  const angleTo = (c: Point, p: { x: number; y: number }) =>
+    (Math.atan2(p.y - c[1], p.x - c[0]) * 180) / Math.PI;
+
+  const onPlacementDown = (e: React.PointerEvent) => {
+    if (e.button !== 0 || props.tool !== "calibration" || !placement) return;
+    begin(e, { kind: "place-move", start: placement.move, from: toFrame(e) });
+  };
+
+  const onTurnDown = (e: React.PointerEvent) => {
+    if (e.button !== 0 || !placement || !placeCentre) return;
+    begin(e, { kind: "place-turn", start: placement.move, pivot: placeCentre, angle: angleTo(placeCentre, toFrame(e)) });
+  };
+
   const onMove = (e: React.PointerEvent) => {
     setAltHeld(e.altKey);
     if (!drag) return;
     const p = toFrame(e);
     const s = snapNow(e);
-    if (drag.kind === "move") {
+    if (drag.kind === "place-move") {
+      const dx = snap(drag.start.dx_mm + p.x - drag.from.x, s);
+      const dy = snap(drag.start.dy_mm + p.y - drag.from.y, s);
+      props.onPlacement?.({ ...drag.start, dx_mm: dx, dy_mm: dy });
+    } else if (drag.kind === "place-turn") {
+      const total = snapAngle(drag.start.theta_deg + angleTo(drag.pivot, p) - drag.angle, e.altKey);
+      const turned = turnAbout(drag.start, drag.pivot, total - drag.start.theta_deg);
+      // The zero lands on the snap grid too, so the numbers stay round
+      props.onPlacement?.({
+        theta_deg: total,
+        dx_mm: s > 1 ? snap(turned.dx_mm, s) : Math.round(turned.dx_mm * 10) / 10,
+        dy_mm: s > 1 ? snap(turned.dy_mm, s) : Math.round(turned.dy_mm * 10) / 10,
+      });
+    } else if (drag.kind === "move") {
       // A click that selects is not a move, however the pointer jitters
       if (Math.hypot(e.clientX - drag.px.x, e.clientY - drag.px.y) < DRAG_THRESHOLD_PX) return;
       props.onChange(drag.index, moveRect(drag.start, p.x - drag.from.x, p.y - drag.from.y, s));
@@ -280,6 +328,122 @@ export function Canvas(props: CanvasProps) {
             </g>
           );
         })}
+        {placement && fence && placedBox && placeCentre && (
+          <g data-testid="placement">
+            {placement.overlay.stations.map((st, k) => {
+              const colour = STATION_COLOURS[k % STATION_COLOURS.length];
+              const corners = movedCorners(placement.move, st.rect)
+                .map(([x, y]) => `${px("x", x)},${px("y", y)}`)
+                .join(" ");
+              return (
+                <g key={st.index} data-testid={`placement-station-${st.index}`}>
+                  <polygon points={corners} fill="none" stroke={colour} strokeWidth={1.5} strokeDasharray="6 4" />
+                  {placement.overlay.stations.length > 1 && (
+                    <text
+                      x={px("x", movedBox(placement.move, st.rect)[0]) + 4}
+                      y={px("y", movedBox(placement.move, st.rect)[3]) - 4 - 12 * k}
+                      fontSize={10}
+                      fontFamily="var(--font-mono)"
+                      fill={colour}
+                      style={{ pointerEvents: "none" }}
+                    >
+                      {`station ${st.index} (channel ${st.channel})`}
+                    </text>
+                  )}
+                  {st.circles.map((c) => {
+                    const [x, y] = applyMove(placement.move, [c.x, c.y]);
+                    return (
+                      <g key={c.name} data-testid={`placement-circle-${st.index}-${c.name}`}>
+                        <circle
+                          cx={px("x", x)}
+                          cy={px("y", y)}
+                          r={Math.max(2, c.radius_mm * scale)}
+                          fill="none"
+                          stroke={colour}
+                          strokeWidth={1}
+                        />
+                        <circle cx={px("x", x)} cy={px("y", y)} r={2.5} fill={colour} />
+                      </g>
+                    );
+                  })}
+                </g>
+              );
+            })}
+            {placement.overlay.links.map((link) => {
+              const a = placement.overlay.stations.find((st) => st.index === link.a);
+              const b = placement.overlay.stations.find((st) => st.index === link.b);
+              if (!a || !b) return null;
+              const centre = (rect: number[]) =>
+                applyMove(placement.move, [(rect[0] + rect[2]) / 2, (rect[1] + rect[3]) / 2]);
+              const [ax, ay] = centre(a.rect);
+              const [bx, by] = centre(b.rect);
+              return (
+                <line
+                  key={`${link.a}-${link.b}`}
+                  data-testid={`placement-link-${link.a}-${link.b}`}
+                  x1={px("x", ax)}
+                  y1={px("y", ay)}
+                  x2={px("x", bx)}
+                  y2={px("y", by)}
+                  stroke={link.weak ? "var(--s-Stopping)" : "var(--muted)"}
+                  strokeOpacity={0.5}
+                  strokeDasharray={link.weak ? "2 3" : undefined}
+                >
+                  <title>{`${link.shared} shared circle${link.shared === 1 ? "" : "s"}${link.weak ? ", weak" : ""}`}</title>
+                </line>
+              );
+            })}
+            <polygon
+              data-testid="placement-body"
+              points={movedCorners(placement.move, fence)
+                .map(([x, y]) => `${px("x", x)},${px("y", y)}`)
+                .join(" ")}
+              fill="var(--accent)"
+              fillOpacity={props.tool === "calibration" ? 0.06 : 0}
+              stroke="none"
+              style={{
+                cursor: props.tool === "calibration" ? "move" : "default",
+                pointerEvents: props.tool === "calibration" ? "all" : "none",
+              }}
+              onPointerDown={onPlacementDown}
+            />
+            <text
+              x={px("x", placedBox[0])}
+              y={px("y", placedBox[3]) + 14}
+              fontSize={11}
+              fontFamily="var(--font-mono)"
+              fill="var(--accent)"
+              style={{ pointerEvents: "none" }}
+            >
+              {`${placement.overlay.id8} ${placement.move.theta_deg} deg`}
+            </text>
+            {props.tool === "calibration" && (
+              <g>
+                <line
+                  x1={px("x", placeCentre[0])}
+                  y1={px("y", placedBox[1])}
+                  x2={px("x", placeCentre[0])}
+                  y2={px("y", placedBox[1]) - ROTATE_HANDLE_PX}
+                  stroke="var(--accent)"
+                  strokeWidth={1}
+                />
+                <circle
+                  data-testid="placement-turn"
+                  cx={px("x", placeCentre[0])}
+                  cy={px("y", placedBox[1]) - ROTATE_HANDLE_PX}
+                  r={7}
+                  fill="var(--surface)"
+                  stroke="var(--accent)"
+                  strokeWidth={1.5}
+                  style={{ cursor: "grab" }}
+                  onPointerDown={onTurnDown}
+                >
+                  <title>turn: 90 degree steps, Alt for free</title>
+                </circle>
+              </g>
+            )}
+          </g>
+        )}
         {sel && props.selected !== null && props.tool === "select" && (
           <g data-testid="selection">
             <text
@@ -348,7 +512,11 @@ export function Canvas(props: CanvasProps) {
           pointerEvents: "none",
         }}
       >
-        {altHeld ? "free placement (Alt)" : `snap ${props.snapMm} mm, Alt for free`}
+        {altHeld
+          ? "free placement (Alt)"
+          : props.tool === "calibration"
+            ? `snap ${props.snapMm} mm and 90 deg, Alt for free; scale is locked`
+            : `snap ${props.snapMm} mm, Alt for free`}
       </div>
     </div>
   );
diff --git a/dotbot/console-web/src/siteEditor/Inspector.tsx b/dotbot/console-web/src/siteEditor/Inspector.tsx
index ed9ecb51..75b9bb3c 100644
--- a/dotbot/console-web/src/siteEditor/Inspector.tsx
+++ b/dotbot/console-web/src/siteEditor/Inspector.tsx
@@ -71,6 +71,8 @@ export interface InspectorProps {
   onDelete: (index: number) => void;
   onToggle: (name: string) => void;
   onAdd: () => void;
+  /** Shown at the top of the pane, for a tool with its own controls. */
+  extra?: React.ReactNode;
 }
 
 export function Inspector(props: InspectorProps) {
@@ -100,6 +102,7 @@ export function Inspector(props: InspectorProps) {
         borderLeft: "1px solid var(--hairline)",
       }}
     >
+      {props.extra}
       <div style={section}>
         <div style={heading}>Site</div>
         <span style={label}>name (the pack folder)</span>
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index 00c70689..01511933 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -1,8 +1,19 @@
 import React, { useCallback, useEffect, useMemo, useState } from "react";
 
-import { RefusedSiteError, StaleSiteError, fetchSite, previewSite, saveSite, stopEditor } from "./api";
+import {
+  RefusedSiteError,
+  StaleSiteError,
+  fetchCalibration,
+  fetchCalibrations,
+  fetchSite,
+  placeCalibration,
+  previewSite,
+  saveSite,
+  stopEditor,
+} from "./api";
+import { CalibrationPanel } from "./CalibrationPanel";
 import { Canvas } from "./Canvas";
-import type { Tool } from "./Canvas";
+import type { Placement, Tool } from "./Canvas";
 import {
   SNAP_DEFAULT_MM,
   SNAP_STEPS_MM,
@@ -13,7 +24,8 @@ import {
 } from "./edit";
 import type { Rect } from "./edit";
 import { Inspector } from "./Inspector";
-import type { EditArea, SiteModel, SiteResponse } from "./types";
+import { IDENTITY } from "./rigid";
+import type { CalibrationListing, EditArea, PlacedCalibration, SiteModel, SiteResponse } from "./types";
 
 // The site editor: one site pack's site.toml, drawn. It talks only to the
 // small server `dotbot site new|edit` starts, never to a controller.
@@ -49,6 +61,7 @@ const button: React.CSSProperties = {
 const TOOLS: { key: Tool | "wall" | "obstacle" | "charger"; label: string; hint: string }[] = [
   { key: "select", label: "Select", hint: "V: select, move and resize" },
   { key: "area", label: "Area", hint: "A: drag out a new area" },
+  { key: "calibration", label: "Calibration", hint: "C: place a spin calibration on the site" },
   { key: "wall", label: "Wall", hint: "needs a walls table in site.toml first" },
   { key: "obstacle", label: "Obstacle", hint: "needs an obstacles table in site.toml first" },
   { key: "charger", label: "Charger", hint: "needs an objects table in site.toml first" },
@@ -71,6 +84,10 @@ export function SiteEditor() {
   const [dialog, setDialog] = useState<Dialog>(null);
   const [stopped, setStopped] = useState(false);
   const [saving, setSaving] = useState(false);
+  const [listing, setListing] = useState<CalibrationListing[]>([]);
+  const [placement, setPlacement] = useState<Placement | null>(null);
+  const [reanchor, setReanchor] = useState(false);
+  const [placed, setPlaced] = useState<PlacedCalibration | null>(null);
 
   const load = useCallback(async () => {
     try {
@@ -88,6 +105,37 @@ export function SiteEditor() {
     void load();
   }, [load]);
 
+  useEffect(() => {
+    if (tool !== "calibration") return;
+    fetchCalibrations()
+      .then(setListing)
+      .catch((err) => setNotice({ kind: "error", text: `could not list calibrations: ${(err as Error).message}` }));
+  }, [tool]);
+
+  const loadCalibration = async (spec: string) => {
+    try {
+      const overlay = await fetchCalibration(spec);
+      setPlacement({ overlay, move: IDENTITY });
+      setReanchor(false);
+      setPlaced(null);
+    } catch (err) {
+      setNotice({ kind: "error", text: (err as Error).message });
+    }
+  };
+
+  const savePlacement = async () => {
+    if (!placement) return;
+    try {
+      const result = await placeCalibration(placement.overlay.id, placement.move, reanchor);
+      setPlaced(result);
+      // The new calibration is in this site's frame: drawn where it landed
+      setPlacement({ overlay: result, move: IDENTITY });
+      setNotice({ kind: "info", text: `saved calibration ${result.id8}; push it with: ${result.push}` });
+    } catch (err) {
+      setNotice({ kind: "error", text: `calibration not saved: ${(err as Error).message}` });
+    }
+  };
+
   const issues = useMemo(() => (site ? siteIssues(site) : []), [site]);
   const errors = issues.filter((i) => i.level === "error");
   const dirty = !!site && !!loaded && !sameSite(site, loaded.site);
@@ -117,6 +165,7 @@ export function SiteEditor() {
       if (saving || typing(e.target) || e.ctrlKey || e.metaKey) return;
       if (e.key === "v" || e.key === "V") setTool("select");
       else if (e.key === "a" || e.key === "A") setTool("area");
+      else if (e.key === "c" || e.key === "C") setTool("calibration");
       else if (e.key === "Escape") setSelected(null);
       else if ((e.key === "Delete" || e.key === "Backspace") && selected !== null) deleteArea(selected);
     };
@@ -303,7 +352,7 @@ export function SiteEditor() {
           }}
         >
           {TOOLS.map((t) => {
-            const enabled = t.key === "select" || t.key === "area";
+            const enabled = t.key === "select" || t.key === "area" || t.key === "calibration";
             const active = t.key === tool;
             return (
               <button
@@ -339,6 +388,8 @@ export function SiteEditor() {
             onSelect={setSelected}
             onChange={(i, r) => updateArea(i, r)}
             onDraw={addArea}
+            placement={placement}
+            onPlacement={(move) => setPlacement((p) => (p ? { ...p, move } : p))}
           />
         ) : (
           <div style={{ flex: 1 }} />
@@ -365,6 +416,29 @@ export function SiteEditor() {
               })
             }
             onAdd={addDefaultArea}
+            extra={
+              tool === "calibration" || placement || placed ? (
+                <CalibrationPanel
+                  listing={listing}
+                  placement={placement}
+                  reanchor={reanchor}
+                  placed={placed}
+                  blocked={
+                    frameChanged(site, loaded.site)
+                      ? "Save site.toml first: the calibration takes the anchor and extent from the file."
+                      : null
+                  }
+                  onLoad={(spec) => void loadCalibration(spec)}
+                  onMove={(move) => setPlacement((p) => (p ? { ...p, move } : p))}
+                  onReanchor={setReanchor}
+                  onSave={() => void savePlacement()}
+                  onClear={() => {
+                    setPlacement(null);
+                    setPlaced(null);
+                  }}
+                />
+              ) : null
+            }
           />
         )}
       </div>
diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
index 6f7d417a..8e4bc47d 100644
--- a/dotbot/console-web/src/siteEditor/api.ts
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -1,4 +1,11 @@
-import type { SiteModel, SiteResponse } from "./types";
+import type { Rigid2D } from "./rigid";
+import type {
+  CalibrationListing,
+  CalibrationOverlay,
+  PlacedCalibration,
+  SiteModel,
+  SiteResponse,
+} from "./types";
 
 // The editor's server, addressed relative to the page.
 
@@ -67,3 +74,31 @@ export async function saveSite(revision: string, site: SiteModel): Promise<SiteR
 export async function stopEditor(): Promise<void> {
   await fetch("api/done", { method: "POST" });
 }
+
+export async function fetchCalibrations(): Promise<CalibrationListing[]> {
+  const res = await fetch("api/calibrations");
+  if (!res.ok) throw new Error(await detail(res));
+  return res.json();
+}
+
+export async function fetchCalibration(spec: string): Promise<CalibrationOverlay> {
+  const res = await fetch(`api/calibrations/${encodeURIComponent(spec)}`);
+  if (!res.ok) throw new Error(await detail(res));
+  return res.json();
+}
+
+/** Save `calibration` moved by `move` as a new calibration of this site. */
+export async function placeCalibration(
+  id: string,
+  move: Rigid2D,
+  reanchor: boolean,
+): Promise<PlacedCalibration> {
+  const res = await fetch(`api/calibrations/${encodeURIComponent(id)}/place`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...move, reanchor }),
+  });
+  if (res.status === 422) throw new RefusedSiteError(await detail(res));
+  if (!res.ok) throw new Error(await detail(res));
+  return res.json();
+}
diff --git a/dotbot/console-web/src/siteEditor/rigid.test.ts b/dotbot/console-web/src/siteEditor/rigid.test.ts
new file mode 100644
index 00000000..e47bce31
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/rigid.test.ts
@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+
+import { applyMove, movedBox, snapAngle, turnAbout } from "./rigid";
+
+describe("rigid moves", () => {
+  it("turns about the origin, then shifts", () => {
+    const [x, y] = applyMove({ dx_mm: 1000, dy_mm: 0, theta_deg: 90 }, [100, 0]);
+    expect(x).toBeCloseTo(1000);
+    expect(y).toBeCloseTo(100);
+  });
+
+  it("keeps the pivot of a turn where it is", () => {
+    const start = { dx_mm: 250, dy_mm: -75, theta_deg: 30 };
+    const pivot: [number, number] = [800, 400];
+    const turned = turnAbout(start, pivot, 90);
+    const p: [number, number] = [120, 340];
+    const before = applyMove(start, p);
+    const after = applyMove(turned, p);
+    expect(turned.theta_deg).toBe(120);
+    expect(Math.hypot(after[0] - pivot[0], after[1] - pivot[1])).toBeCloseTo(
+      Math.hypot(before[0] - pivot[0], before[1] - pivot[1]),
+    );
+  });
+
+  it("boxes a quarter-turned rectangle exactly", () => {
+    const box = movedBox({ dx_mm: 3000, dy_mm: 0, theta_deg: 90 }, [0, 0, 2000, 1000]);
+    expect(box.map((v) => Math.round(v))).toEqual([2000, 0, 3000, 2000]);
+  });
+
+  it("snaps a turn to 90 degrees unless free", () => {
+    expect(snapAngle(52, false)).toBe(90);
+    expect(snapAngle(-140, false)).toBe(180);
+    expect(snapAngle(271, false)).toBe(-90);
+    expect(snapAngle(37.46, true)).toBe(37.5);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/rigid.ts b/dotbot/console-web/src/siteEditor/rigid.ts
new file mode 100644
index 00000000..f3b9aca8
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/rigid.ts
@@ -0,0 +1,57 @@
+// A rigid move in frame millimetres, as the server applies it to a
+// calibration: turn by `theta_deg` about the frame origin, then shift by
+// (`dx_mm`, `dy_mm`). Positive angles turn +x toward +y, clockwise as drawn
+// with y down. Keep in step with dotbot/calibration/placement.py's Rigid2D.
+
+export interface Rigid2D {
+  dx_mm: number;
+  dy_mm: number;
+  theta_deg: number;
+}
+
+export type Point = [number, number];
+
+export const IDENTITY: Rigid2D = { dx_mm: 0, dy_mm: 0, theta_deg: 0 };
+
+export function applyMove(m: Rigid2D, [x, y]: Point): Point {
+  const t = (m.theta_deg * Math.PI) / 180;
+  const c = Math.cos(t);
+  const s = Math.sin(t);
+  return [c * x - s * y + m.dx_mm, s * x + c * y + m.dy_mm];
+}
+
+/** `m` followed by a turn of `delta` degrees about `pivot`. */
+export function turnAbout(m: Rigid2D, pivot: Point, delta: number): Rigid2D {
+  const [tx, ty] = applyMove({ dx_mm: 0, dy_mm: 0, theta_deg: delta }, [
+    m.dx_mm - pivot[0],
+    m.dy_mm - pivot[1],
+  ]);
+  return { dx_mm: tx + pivot[0], dy_mm: ty + pivot[1], theta_deg: m.theta_deg + delta };
+}
+
+/** The four corners of `[x0, y0, x1, y1]`, moved. */
+export function movedCorners(m: Rigid2D, rect: number[]): Point[] {
+  const [x0, y0, x1, y1] = rect;
+  const corners: Point[] = [
+    [x0, y0],
+    [x1, y0],
+    [x1, y1],
+    [x0, y1],
+  ];
+  return corners.map((p) => applyMove(m, p));
+}
+
+/** The axis-aligned box `[x0, y0, x1, y1]` round `rect` once moved. */
+export function movedBox(m: Rigid2D, rect: number[]): [number, number, number, number] {
+  const pts = movedCorners(m, rect);
+  const xs = pts.map((p) => p[0]);
+  const ys = pts.map((p) => p[1]);
+  return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
+}
+
+/** `deg` on a 90 degree step, or to a tenth of a degree when free, in (-180, 180]. */
+export function snapAngle(deg: number, free: boolean): number {
+  const snapped = free ? Math.round(deg * 10) / 10 : Math.round(deg / 90) * 90;
+  const wrapped = ((((snapped + 180) % 360) + 360) % 360) - 180;
+  return wrapped === -180 ? 180 : wrapped;
+}
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index a094f520..35f24a76 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -119,3 +119,97 @@ describe("SiteEditor", () => {
     expect(screen.queryByText(/unsaved/)).toBeNull();
   });
 });
+
+describe("SiteEditor calibration placement", () => {
+  const overlay = (free: boolean) => ({
+    id: "3f2a91c0aaaaaaaa",
+    id8: "3f2a91c0",
+    free,
+    fence: [0, 0, 1000, 800],
+    stations: [
+      {
+        index: 0,
+        channel: 1,
+        rect: [0, 0, 1000, 800],
+        centres: [[200, 300]],
+        circles: [{ name: "robot0", x: 200, y: 300, radius_mm: 51.4 }],
+        solved_from: free ? "conics-free" : "direct",
+      },
+    ],
+    links: [],
+    tag: "",
+    created_at: "2026-10-01T10:00:00Z",
+    site: "lab",
+    anchor: "free mode",
+  });
+
+  function placementServer(free: boolean) {
+    const fetch = vi.fn(async (url: string, init?: RequestInit) => {
+      const json = (status: number, body: unknown) =>
+        new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+      if (url === "api/site") return json(200, loaded());
+      if (url === "api/calibrations")
+        return json(200, [
+          { id: "3f2a91c0aaaaaaaa", id8: "3f2a91c0", created_at: "", free, stations: [0], tag: "", site: "lab", path: "" },
+        ]);
+      if (url === "api/calibrations/3f2a91c0") return json(200, overlay(free));
+      if (url === "api/calibrations/3f2a91c0aaaaaaaa/place" && init?.method === "POST")
+        return json(200, {
+          ...overlay(free),
+          id8: "7c0d5e12",
+          path: "/home/cal/arena/calibration-7c0d5e12.toml",
+          source: "3f2a91c0",
+          push: "dotbot swarm calibrate-lh2 push 7c0d5e12 --site arena --site-changed",
+          warnings: [],
+        });
+      return json(404, { detail: "no" });
+    });
+    vi.stubGlobal("fetch", fetch);
+    return fetch;
+  }
+
+  async function loadIt() {
+    render(<SiteEditor />);
+    await screen.findByTestId("edit-area-field");
+    fireEvent.click(screen.getByText("Calibration"));
+    fireEvent.change(await screen.findByLabelText("calibration id"), { target: { value: "3f2a91c0" } });
+    await act(async () => fireEvent.click(screen.getByText("Load")));
+  }
+
+  it("draws a loaded calibration and saves it moved as a new one", async () => {
+    const fetch = placementServer(true);
+    await loadIt();
+    expect(await screen.findByTestId("placement-circle-0-robot0")).toBeInTheDocument();
+    expect(screen.getByTestId("placement-turn")).toBeInTheDocument();
+    fireEvent.change(screen.getByLabelText("shift x (mm)"), { target: { value: "500" } });
+    fireEvent.change(screen.getByLabelText("turn (deg)"), { target: { value: "90" } });
+    await act(async () => fireEvent.click(screen.getByText("Save calibration")));
+    const post = fetch.mock.calls.find(([url]) => url === "api/calibrations/3f2a91c0aaaaaaaa/place")!;
+    expect(JSON.parse(post[1]!.body as string)).toEqual({ dx_mm: 500, dy_mm: 0, theta_deg: 90, reanchor: false });
+    expect(await screen.findByTestId("placement-saved")).toHaveTextContent(
+      "dotbot swarm calibrate-lh2 push 7c0d5e12 --site arena",
+    );
+  });
+
+  it("refuses to move a corner-collected calibration until Re-anchor is ticked", async () => {
+    placementServer(false);
+    await loadIt();
+    expect(await screen.findByTestId("placement-refused")).toBeInTheDocument();
+    expect(screen.getByText("Save calibration")).toBeDisabled();
+    fireEvent.click(screen.getByLabelText("re-anchor"));
+    expect(screen.getByText("Save calibration")).not.toBeDisabled();
+  });
+
+  it("drags the calibration on the snap grid", async () => {
+    placementServer(true);
+    await loadIt();
+    const body = await screen.findByTestId("placement-body");
+    const canvas = screen.getByTestId("site-canvas");
+    fireEvent.pointerDown(body, { button: 0, clientX: 300, clientY: 300, pointerId: 1 });
+    fireEvent.pointerMove(canvas, { clientX: 337, clientY: 300, pointerId: 1 });
+    fireEvent.pointerUp(canvas, { clientX: 337, clientY: 300, pointerId: 1 });
+    const dx = Number((screen.getByLabelText("shift x (mm)") as HTMLInputElement).value);
+    expect(dx % 50).toBe(0);
+    expect(dx).toBeGreaterThan(0);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/types.ts b/dotbot/console-web/src/siteEditor/types.ts
index eedc331c..0be128a0 100644
--- a/dotbot/console-web/src/siteEditor/types.ts
+++ b/dotbot/console-web/src/siteEditor/types.ts
@@ -35,3 +35,55 @@ export interface SiteResponse {
   calibrations: CalibrationFolder[];
   written?: boolean;
 }
+
+/** One LH2 calibration file, as GET /api/calibrations lists it. */
+export interface CalibrationListing {
+  id: string;
+  id8: string;
+  created_at: string;
+  /** Solved in its own frame by spinning robots, so it may be moved. */
+  free: boolean;
+  /** The solved stations' lh_index. */
+  stations: number[];
+  tag: string;
+  site: string;
+  path: string;
+}
+
+/** One spin circle, its centre in the calibration's frame. */
+export interface SpinCircle {
+  name: string;
+  x: number;
+  y: number;
+  radius_mm: number;
+}
+
+/** A calibration as the editor draws it, every number in its own frame. */
+export interface CalibrationOverlay {
+  id: string;
+  id8: string;
+  free: boolean;
+  fence: [number, number, number, number];
+  stations: {
+    index: number;
+    channel: number;
+    /** The station's own rectangle, else the fence. */
+    rect: [number, number, number, number];
+    centres: [number, number][];
+    circles: SpinCircle[];
+    solved_from: string;
+  }[];
+  links: { a: number; b: number; shared: number; weak: boolean }[];
+  tag: string;
+  created_at: string;
+  site: string;
+  anchor: string;
+}
+
+/** What POST /api/calibrations/{id}/place answers: the new calibration. */
+export interface PlacedCalibration extends CalibrationOverlay {
+  path: string;
+  source: string;
+  push: string;
+  warnings: string[];
+}

From 2a00ca0d95cbcaff6dddaec238c547fdab4b7015 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:47:33 +0200
Subject: [PATCH 48/80] dotbot/tests: call the placement routes from a loopback
 client

AI-assisted: Claude Opus 5.5
---
 dotbot/tests/test_site_placement.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/dotbot/tests/test_site_placement.py b/dotbot/tests/test_site_placement.py
index 4df3f296..17446845 100644
--- a/dotbot/tests/test_site_placement.py
+++ b/dotbot/tests/test_site_placement.py
@@ -7,7 +7,6 @@
 import dataclasses
 
 import pytest
-from fastapi.testclient import TestClient
 
 from dotbot.calibration import conics, lighthouse2
 from dotbot.calibration.lighthouse2 import read_calibration_file, write_calibration
@@ -15,6 +14,7 @@
 from dotbot.site import Site
 from dotbot.site_editor import EditorState, create_app
 from dotbot.tests.test_calibration_conics import CENTRES, track_samples
+from dotbot.tests.test_site_editor import local_client
 from dotbot.tests.test_site_toml import ARENA
 
 
@@ -41,10 +41,7 @@ def client(tmp_path, home):
     page = tmp_path / "dist"
     page.mkdir()
     (page / "site-editor.html").write_text("<html></html>")
-    return TestClient(
-        create_app(EditorState("arena", pack, [home / "arena"]), page),
-        base_url="http://127.0.0.1",
-    )
+    return local_client(create_app(EditorState("arena", pack, [home / "arena"]), page))
 
 
 def test_the_calibrations_are_listed_with_their_kind(client, spun):

From 641ca9148fec1e055d46e0873978b012fb0761b1 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:00:58 +0200
Subject: [PATCH 49/80] dotbot/calibration: hold a placement's fence to zero,
 never overwrite a file

A placement's id comes from its stations, not its tag or anchor, so the
same move saved twice, or a move into the source's own site, landed on an
existing path; save_placed keeps that file and refuses the source's id.

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/placement.py            | 77 ++++++++++++++++++----
 dotbot/cli/site_cmd.py                     | 14 ++--
 dotbot/cli/swarm_lh2.py                    | 10 ++-
 dotbot/site_placement.py                   | 14 ++--
 dotbot/tests/test_calibration_placement.py | 40 +++++++++++
 dotbot/tests/test_site_placement.py        | 15 +++++
 6 files changed, 140 insertions(+), 30 deletions(-)

diff --git a/dotbot/calibration/placement.py b/dotbot/calibration/placement.py
index 51151674..ae3c1f57 100644
--- a/dotbot/calibration/placement.py
+++ b/dotbot/calibration/placement.py
@@ -6,8 +6,7 @@
 A free-mode calibration (`collect --spin`) defines its own frame, metric
 through the spin radius. `place_calibration` turns and shifts every station
 of it by one `Rigid2D`, so the stations keep their geometry relative to one
-another and the scale is never touched. The site editor's placement and
-`calibrate-lh2 reframe` of a spin calibration both go through it.
+another and the scale is never touched.
 """
 
 from __future__ import annotations
@@ -16,9 +15,11 @@
 import math
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
+from pathlib import Path
 
 import numpy as np
 
+from dotbot.calibration import lighthouse2
 from dotbot.calibration.conics import Track, fit_tracks
 from dotbot.calibration.lighthouse2 import Calibration, StationSolution
 from dotbot.site import Site
@@ -94,12 +95,7 @@ def box(self, rect: Sequence[float]) -> tuple[int, int, int, int]:
 
 
 def is_free_mode(calibration: Calibration) -> bool:
-    """Whether every station was solved in the calibration's own frame.
-
-    Read from the stations' solvers rather than the anchor: a placed
-    calibration takes its site's anchor, which a controller checks it
-    against, and stays movable.
-    """
+    """Whether every station was solved in the calibration's own frame."""
     return bool(calibration.stations) and all(
         st.solved_from in FREE_SOLVERS for st in calibration.stations
     )
@@ -182,7 +178,7 @@ def overlay(calibration: Calibration) -> dict:
 
 def placed_tag(tag: str, site_name: str, taken: Iterable[str] = ()) -> str:
     """The moved calibration's tag: `tag` suffixed with the site, then a
-    number if that tag is taken, so the two files answer to different tags."""
+    number if that tag is taken."""
     if not tag:
         return ""
     base = tag if tag.endswith(f"-{site_name}") else f"{tag}-{site_name}"
@@ -210,8 +206,9 @@ def place_calibration(
     modified.
 
     A corner-collected calibration is tied to the floor through the site's
-    anchor and is refused unless `reanchor`. A move that puts a spin centre
-    or a station's rectangle below zero is refused: robots carry positions as
+    anchor and is refused unless `reanchor`. A move that puts a spin centre,
+    a station's rectangle (its own, else the calibration's fence) or a
+    placement's point below zero is refused: robots carry positions as
     unsigned millimetres.
     """
     if not calibration.stations:
@@ -238,11 +235,18 @@ def place_calibration(
             changes["valid_mm"] = transform.box(rect)
         stations.append(dataclasses.replace(st, **changes))
 
+    fence = transform.box(calibration.valid_mm)
     below = [
         f"station {st.index} (channel {st.index + 1})'s rectangle "
-        f"{list(station_rect(st))}"
+        f"{list(station_rect(st) or fence)}"
         for st in stations
-        if station_rect(st) is not None and min(station_rect(st)[:2]) < 0
+        if min((station_rect(st) or fence)[:2]) < 0
+    ]
+    below += [
+        f"placement {n}'s point ({x:.0f}, {y:.0f})"
+        for n, placement in enumerate(calibration.placements)
+        for x, y in transform.apply(placement.points_mm)
+        if x < 0 or y < 0
     ]
     for index, circles in spin_centres(
         dataclasses.replace(calibration, stations=stations)
@@ -273,7 +277,11 @@ def place_calibration(
     elif site.valid_mm is not None:
         valid_mm = site.valid_mm
     else:
-        valid_mm = transform.box(calibration.valid_mm)
+        valid_mm = fence
+    try:
+        lighthouse2.valid_mm_as_bytes(valid_mm)
+    except ValueError as exc:
+        raise PlacementRefused(f"the moved calibration's fence: {exc}") from exc
     placements = [
         dataclasses.replace(
             placement,
@@ -297,3 +305,44 @@ def place_calibration(
         robot=calibration.robot,
         placed_from=calibration.id,
     )
+
+
+def site_tags(site_name: str, paths: Iterable[Path] | None = None) -> list[str]:
+    """The tags of the calibrations of `site_name` among `paths`, by default
+    the files in its calibration folder."""
+    if paths is None:
+        paths = lighthouse2.site_dir(site_name).glob(lighthouse2.CALIBRATION_TOML_GLOB)
+    tags = []
+    for path in paths:
+        meta = lighthouse2._file_metadata(path)
+        if meta.get("tag") and _file_site(path) == site_name:
+            tags.append(meta["tag"])
+    return tags
+
+
+def _file_site(path: Path) -> str:
+    import tomllib
+
+    try:
+        with open(path, "rb") as handle:
+            return tomllib.load(handle).get("site", {}).get("name", "")
+    except (OSError, tomllib.TOMLDecodeError):
+        return ""
+
+
+def save_placed(source: Calibration, placed: Calibration) -> tuple[Calibration, Path]:
+    """Write `placed` beside its site's calibrations, or, when a file of its
+    id is there already, leave that file as it is; return what is on disk.
+
+    A placement with the source's own id would overwrite the source, and is
+    refused.
+    """
+    if placed.id == source.id:
+        raise PlacementRefused(
+            f"the move leaves calibration {source.id8} where it is; nothing to write"
+        )
+    for path in lighthouse2.site_dir(placed.site.name).glob(f"*-{placed.id8}.toml"):
+        existing = lighthouse2.read_calibration_file(path)
+        if existing.id == placed.id:
+            return existing, path
+    return placed, lighthouse2.write_calibration(placed)
diff --git a/dotbot/cli/site_cmd.py b/dotbot/cli/site_cmd.py
index fbce2d88..b6680261 100644
--- a/dotbot/cli/site_cmd.py
+++ b/dotbot/cli/site_cmd.py
@@ -792,9 +792,13 @@ def init(ctx, name, calibration, size, force):
         read_calibration_file,
         resolve_calibration_path,
         site_name_as_bytes,
-        write_calibration,
     )
-    from dotbot.calibration.placement import Rigid2D, place_calibration
+    from dotbot.calibration.placement import (
+        Rigid2D,
+        place_calibration,
+        save_placed,
+        site_tags,
+    )
     from dotbot.cli._swarm_inject import swarm_connection
 
     obj = ctx.obj or {}
@@ -825,10 +829,12 @@ def init(ctx, name, calibration, size, force):
         source = read_calibration_file(path)
         site, _ = self_defined_site(source, name, size)
         field = site.areas["field"]
-        placed = place_calibration(source, site, Rigid2D(field.x, field.y, 0.0))
+        placed = place_calibration(
+            source, site, Rigid2D(field.x, field.y, 0.0), taken_tags=site_tags(name)
+        )
+        placed, saved = save_placed(source, placed)
     except ValueError as exc:
         raise click.ClickException(str(exc)) from exc
-    saved = write_calibration(placed)
     target.mkdir(parents=True, exist_ok=True)
     (target / PACK_FILE).write_text(
         _render_site_pack(site, source.id8), encoding="utf-8"
diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index ff8073a2..521cb738 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -1027,6 +1027,8 @@ def _reframe(ctx, calibration, site_name, shift, rotate):
         Rigid2D,
         is_free_mode,
         place_calibration,
+        save_placed,
+        site_tags,
     )
 
     site, _ = site_from_context(ctx, site_name)
@@ -1039,13 +1041,17 @@ def _reframe(ctx, calibration, site_name, shift, rotate):
         source = read_calibration_file(resolve_calibration_path(calibration))
         if is_free_mode(source):
             reframed = place_calibration(
-                source, site, Rigid2D(shift[0], shift[1], rotate)
+                source,
+                site,
+                Rigid2D(shift[0], shift[1], rotate),
+                taken_tags=site_tags(site.name),
             )
+            reframed, path = save_placed(source, reframed)
         else:
             reframed = reframe_calibration(source, site, shift, rotate)
+            path = write_calibration(reframed)
     except ValueError as exc:
         raise click.ClickException(str(exc)) from exc
-    path = write_calibration(reframed)
     click.echo(
         f"Reframed {source.id8} (site {source.site.name}) into site {site.name}: "
         f"shift {shift[0]:g},{shift[1]:g} mm, rotate {rotate:g} deg"
diff --git a/dotbot/site_placement.py b/dotbot/site_placement.py
index f9edc158..ba883a48 100644
--- a/dotbot/site_placement.py
+++ b/dotbot/site_placement.py
@@ -25,6 +25,8 @@
     is_free_mode,
     overlay,
     place_calibration,
+    save_placed,
+    site_tags,
     spin_centres,
 )
 from dotbot.config import SiteSection
@@ -112,23 +114,15 @@ def calibration(spec: str):
     def place(spec: str, request: PlaceRequest):
         source = resolve(spec)
         site = current_site()
-        taken = [
-            m["tag"]
-            for m in map(_metadata, _files(pack))
-            if m and m["site"] == site.name and m["tag"]
-        ]
+        taken = site_tags(site.name, _files(pack))
         move = Rigid2D(request.dx_mm, request.dy_mm, request.theta_deg)
         try:
             placed = place_calibration(
                 source, site, move, reanchor=request.reanchor, taken_tags=taken
             )
+            placed, path = save_placed(source, placed)
         except PlacementRefused as exc:
             raise HTTPException(422, str(exc)) from exc
-        if placed.id == source.id:
-            raise HTTPException(
-                422, "the move changes nothing; the calibration is already there"
-            )
-        path = lighthouse2.write_calibration(placed)
         warnings = []
         if site.extent_mm is not None:
             width, height = site.extent_mm
diff --git a/dotbot/tests/test_calibration_placement.py b/dotbot/tests/test_calibration_placement.py
index 573174e1..efa68bd7 100644
--- a/dotbot/tests/test_calibration_placement.py
+++ b/dotbot/tests/test_calibration_placement.py
@@ -18,6 +18,7 @@
     overlay,
     place_calibration,
     placed_tag,
+    save_placed,
     spin_centres,
 )
 from dotbot.site import Site
@@ -128,6 +129,45 @@ def test_a_move_below_zero_is_refused(spun):
         place_calibration(spun, SITE, Rigid2D(0, 0, 90))
 
 
+def test_a_turn_that_puts_the_fence_below_zero_is_refused(spun):
+    top = max(y for _, y in _centres(spun).values())
+    # Every centre lands at x >= 1, but the fence round them does not; a site
+    # with an extent gives every station that extent instead
+    unbounded = Site(name=SITE.name, anchor=SITE.anchor)
+    with pytest.raises(PlacementRefused, match="rectangle"):
+        place_calibration(spun, unbounded, Rigid2D(math.ceil(top) + 1, 0, 90))
+
+
+def test_a_re_anchored_calibration_without_tracks_is_held_to_zero_too(spun):
+    corner = dataclasses.replace(
+        spun,
+        tracks=[],
+        stations=[
+            dataclasses.replace(st, solved_from="direct") for st in spun.stations
+        ],
+    )
+    bare = Site(name="hand", anchor="the door's left jamb")
+    with pytest.raises(PlacementRefused, match="below zero"):
+        place_calibration(corner, bare, Rigid2D(0, 0, 180), reanchor=True)
+
+
+def test_saving_a_placement_never_overwrites(spun, tmp_path, monkeypatch):
+    from dotbot.calibration import lighthouse2
+
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path / "home")
+    same_site = Site(name=spun.site.name, anchor="the door's left jamb")
+    unmoved = place_calibration(spun, same_site, Rigid2D())
+    if unmoved.id == spun.id:
+        with pytest.raises(PlacementRefused, match="nothing to write"):
+            save_placed(spun, unmoved)
+    first, path = save_placed(spun, place_calibration(spun, SITE, Rigid2D(10, 0, 0)))
+    written = path.read_bytes()
+    again = place_calibration(spun, SITE, Rigid2D(10, 0, 0), taken_tags=[first.tag])
+    second, same = save_placed(spun, again)
+    assert same == path and path.read_bytes() == written
+    assert second.tag == first.tag == "spin-hand"
+
+
 def test_the_tag_is_suffixed_with_the_site_and_never_reused():
     assert placed_tag("", "hand") == ""
     assert placed_tag("spin", "hand") == "spin-hand"
diff --git a/dotbot/tests/test_site_placement.py b/dotbot/tests/test_site_placement.py
index 17446845..2526fb71 100644
--- a/dotbot/tests/test_site_placement.py
+++ b/dotbot/tests/test_site_placement.py
@@ -112,6 +112,21 @@ def test_a_corner_calibration_is_refused_unless_re_anchored(client, spun):
     assert any("re-anchored" in w for w in moved.json()["warnings"])
 
 
+def test_placing_twice_the_same_way_keeps_the_first_file(client, spun, home):
+    move = {"dx_mm": 100, "dy_mm": 200, "theta_deg": 0}
+    first = client.post(f"/api/calibrations/{spun.id8}/place", json=move).json()
+    written = (home / "arena" / first["path"].split("/")[-1]).read_bytes()
+    second = client.post(f"/api/calibrations/{spun.id8}/place", json=move).json()
+    assert (second["id"], second["tag"], second["path"]) == (
+        first["id"],
+        first["tag"],
+        first["path"],
+    )
+    assert len(list((home / "arena").glob("*.toml"))) == 1
+    assert (home / "arena" / first["path"].split("/")[-1]).read_bytes() == written
+    assert client.get(f"/api/calibrations/{first['tag']}").status_code == 200
+
+
 def test_a_placement_below_zero_is_refused(client, spun):
     refused = client.post(
         f"/api/calibrations/{spun.id8}/place", json={"theta_deg": 180}

From 40c933bb060fa26f1fb4170bcac8126db8f5c543 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:02:00 +0200
Subject: [PATCH 50/80] dotbot/console-web: keep a saved placement drawn as
 moved, list the new file

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/siteEditor/SiteEditor.tsx      | 5 +++--
 dotbot/console-web/src/siteEditor/siteEditor.test.tsx | 6 ++++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index 01511933..bdb8f1c5 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -128,8 +128,9 @@ export function SiteEditor() {
     try {
       const result = await placeCalibration(placement.overlay.id, placement.move, reanchor);
       setPlaced(result);
-      // The new calibration is in this site's frame: drawn where it landed
-      setPlacement({ overlay: result, move: IDENTITY });
+      fetchCalibrations()
+        .then(setListing)
+        .catch(() => undefined);
       setNotice({ kind: "info", text: `saved calibration ${result.id8}; push it with: ${result.push}` });
     } catch (err) {
       setNotice({ kind: "error", text: `calibration not saved: ${(err as Error).message}` });
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index 35f24a76..44508295 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -189,6 +189,12 @@ describe("SiteEditor calibration placement", () => {
     expect(await screen.findByTestId("placement-saved")).toHaveTextContent(
       "dotbot swarm calibrate-lh2 push 7c0d5e12 --site arena",
     );
+    // The source stays drawn where it was moved to, and the list takes the new file
+    expect(screen.getByLabelText("shift x (mm)")).toHaveValue(500);
+    expect(screen.getByLabelText("turn (deg)")).toHaveValue(90);
+    await waitFor(() =>
+      expect(fetch.mock.calls.filter(([url]) => url === "api/calibrations").length).toBeGreaterThan(1),
+    );
   });
 
   it("refuses to move a corner-collected calibration until Re-anchor is ticked", async () => {

From 0beec3ecdfaa7efd60cc735cac26a72e73abb894 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 13:44:40 +0200
Subject: [PATCH 51/80] dotbot/site_editor: serve the site's calibration spans
 and camera stills

AI-assisted: Claude Opus 5.5
---
 dotbot/site_backdrops.py            | 158 ++++++++++++++++++++++++++++
 dotbot/site_editor.py               |  14 ++-
 dotbot/tests/test_site_backdrops.py |  81 ++++++++++++++
 3 files changed, 250 insertions(+), 3 deletions(-)
 create mode 100644 dotbot/site_backdrops.py
 create mode 100644 dotbot/tests/test_site_backdrops.py

diff --git a/dotbot/site_backdrops.py b/dotbot/site_backdrops.py
new file mode 100644
index 00000000..2c0c2935
--- /dev/null
+++ b/dotbot/site_backdrops.py
@@ -0,0 +1,158 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""What the site editor can draw under a site, read-only: where each of the
+site's LH2 calibrations was fitted, and each registered camera's still
+warped into the frame.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from collections.abc import Callable, Sequence
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import Response
+
+from dotbot.area import Area
+from dotbot.calibration.lighthouse2 import (
+    CALIBRATION_TOML_GLOB,
+    read_calibration_file,
+)
+from dotbot.calibration.placement import spin_centres
+from dotbot.config import SiteSection
+from dotbot.site import site_from_table
+
+CAMERA_TOML_GLOB = "camera-*.toml"
+# Millimetres per pixel of a warped still: coarse, it is a backdrop
+STILL_MM_PER_PX = 5.0
+
+
+def _glob(folders: Sequence[Path], pattern: str) -> list[Path]:
+    seen, out = set(), []
+    for folder in folders:
+        for path in sorted(folder.glob(pattern)):
+            if path.resolve() not in seen:
+                seen.add(path.resolve())
+                out.append(path)
+    return out
+
+
+def calibration_backdrop(path: Path) -> dict | None:
+    """One LH2 calibration's placements and spin centres, in frame mm."""
+    try:
+        calibration = read_calibration_file(path)
+    except (OSError, ValueError, tomllib.TOMLDecodeError):
+        return None
+    return {
+        "id8": calibration.id8,
+        "tag": calibration.tag,
+        "created_at": calibration.created_at,
+        "placements": [
+            [list(point) for point in placement.points_mm]
+            for placement in calibration.placements
+        ],
+        "centres": [
+            [c["x"], c["y"]]
+            for circles in spin_centres(calibration).values()
+            for c in circles
+        ],
+    }
+
+
+def warp_still(image: Path, matrix, area: Area) -> bytes | None:
+    """The still at `image` warped onto `area` as a PNG, or None when it
+    cannot be (no OpenCV, no readable image)."""
+    try:
+        import cv2
+        import numpy as np
+    except ImportError:
+        return None
+    frame = cv2.imread(str(image))
+    if frame is None:
+        return None
+    scale = np.array(
+        [
+            [1.0 / STILL_MM_PER_PX, 0.0, -area.x / STILL_MM_PER_PX],
+            [0.0, 1.0 / STILL_MM_PER_PX, -area.y / STILL_MM_PER_PX],
+            [0.0, 0.0, 1.0],
+        ]
+    )
+    size = (
+        max(1, round(area.w / STILL_MM_PER_PX)),
+        max(1, round(area.h / STILL_MM_PER_PX)),
+    )
+    warped = cv2.warpPerspective(
+        frame, scale @ np.array(matrix, dtype=np.float64), size
+    )
+    ok, png = cv2.imencode(".png", warped)
+    return png.tobytes() if ok else None
+
+
+def create_router(
+    name: str, folders: Callable[[], list[Path]], site_text: Callable[[], str]
+) -> APIRouter:
+    """Routes for the site `name`, whose calibration files are in `folders`."""
+    from dotbot.camera.registration import read_camera_calibration_file
+
+    router = APIRouter()
+
+    def cameras() -> list[tuple[Path, object]]:
+        out = []
+        for path in _glob(folders(), CAMERA_TOML_GLOB):
+            try:
+                out.append((path, read_camera_calibration_file(path)))
+            except (OSError, ValueError, tomllib.TOMLDecodeError):
+                continue
+        return out
+
+    def area_of(camera) -> Area | None:
+        try:
+            table = SiteSection.model_validate(tomllib.loads(site_text()))
+            return site_from_table(name, table).registry().resolve(camera.area)
+        except Exception:  # noqa: BLE001
+            return None
+
+    @router.get("/api/backdrops")
+    def backdrops():
+        calibrations = [
+            found
+            for found in map(
+                calibration_backdrop, _glob(folders(), CALIBRATION_TOML_GLOB)
+            )
+            if found is not None
+        ]
+        listed = []
+        for path, camera in cameras():
+            area = area_of(camera)
+            still = path.with_suffix(".jpg")
+            listed.append(
+                {
+                    "id8": camera.id8,
+                    "area": camera.area,
+                    "rect": [area.x, area.y, area.w, area.h] if area else None,
+                    "span": [list(p) for p in camera.span_mm],
+                    "still": (
+                        f"api/backdrops/camera/{camera.id8}.png"
+                        if area and still.is_file()
+                        else None
+                    ),
+                }
+            )
+        return {"calibrations": calibrations, "cameras": listed}
+
+    @router.get("/api/backdrops/camera/{id8}.png")
+    def still(id8: str):
+        for path, camera in cameras():
+            if camera.id8 != id8:
+                continue
+            area = area_of(camera)
+            image = path.with_suffix(".jpg")
+            png = warp_still(image, camera.matrix, area) if area else None
+            if png is None:
+                break
+            return Response(png, media_type="image/png")
+        raise HTTPException(404, f"no still for camera {id8}")
+
+    return router
diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index 9a47340a..985765b1 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -25,10 +25,9 @@
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field
 
-from dotbot import site_toml
+from dotbot import site_backdrops, site_placement, site_toml
 from dotbot.site import PACK_CALIBRATIONS
 from dotbot.site_packs import PACK_FILE
-from dotbot.site_placement import create_router
 
 EDITOR_DIR = Path(__file__).parent / "console-web" / "dist"
 EDITOR_PAGE = "site-editor.html"
@@ -221,7 +220,16 @@ def done():
             on_done()
         return {"ok": True}
 
-    app.include_router(create_router(state.name, state.pack, lambda: read()[1]))
+    app.include_router(
+        site_placement.create_router(state.name, state.pack, lambda: read()[1])
+    )
+    app.include_router(
+        site_backdrops.create_router(
+            state.name,
+            lambda: [state.pack / PACK_CALIBRATIONS, *state.calibration_dirs],
+            lambda: read()[1],
+        )
+    )
 
     @app.get("/", include_in_schema=False)
     def page():
diff --git a/dotbot/tests/test_site_backdrops.py b/dotbot/tests/test_site_backdrops.py
new file mode 100644
index 00000000..2ae7973c
--- /dev/null
+++ b/dotbot/tests/test_site_backdrops.py
@@ -0,0 +1,81 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""What the site editor draws under a site: its calibrations' spans and its
+cameras' stills, warped into the frame."""
+
+import numpy as np
+import pytest
+from fastapi.testclient import TestClient
+
+from dotbot.calibration import conics
+from dotbot.calibration.lighthouse2 import write_calibration
+from dotbot.site import Site
+from dotbot.site_editor import EditorState, create_app
+from dotbot.tests.test_calibration_conics import CENTRES, track_samples
+from dotbot.tests.test_site_toml import ARENA
+
+
+@pytest.fixture
+def setup(tmp_path, monkeypatch):
+    from dotbot.calibration import lighthouse2
+
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path / "home")
+    pack = tmp_path / "arena"
+    pack.mkdir()
+    (pack / "site.toml").write_text(ARENA)
+    page = tmp_path / "dist"
+    page.mkdir()
+    (page / "site-editor.html").write_text("<html></html>")
+    home = tmp_path / "home" / "calibrations" / "arena"
+    client = TestClient(
+        create_app(EditorState("arena", pack, [home]), page),
+        base_url="http://127.0.0.1",
+    )
+    return client, home
+
+
+def test_a_site_with_no_calibration_has_no_backdrop(setup):
+    client, _ = setup
+    assert client.get("/api/backdrops").json() == {"calibrations": [], "cameras": []}
+
+
+def test_a_calibration_of_the_site_is_drawn_by_its_spin_centres(setup):
+    client, _ = setup
+    calibration, _, _ = conics.solve_calibration(
+        track_samples(CENTRES), Site(name="arena"), tag="spin"
+    )
+    write_calibration(calibration)
+    (drawn,) = client.get("/api/backdrops").json()["calibrations"]
+    assert drawn["id8"] == calibration.id8
+    assert drawn["placements"] == []
+    assert len(drawn["centres"]) == len(CENTRES)
+
+
+def test_a_camera_still_is_warped_onto_its_area(setup):
+    cv2 = pytest.importorskip("cv2")
+    from dotbot.camera.registration import CameraCalibration, write_camera_calibration
+    from dotbot.tests.camera_fixtures import (
+        DEV_CORNER,
+        ground_truth_px_to_mm,
+        synthetic_frame,
+    )
+
+    client, home = setup
+    camera = CameraCalibration(
+        site=Site(name="arena"),
+        area="dev-corner",
+        width=640,
+        height=480,
+        matrix=ground_truth_px_to_mm().tolist(),
+        created="2026-10-02T10:00:00Z",
+    )
+    path = write_camera_calibration(camera, root=home.parent)
+    cv2.imwrite(str(path.with_suffix(".jpg")), synthetic_frame(DEV_CORNER))
+    (listed,) = client.get("/api/backdrops").json()["cameras"]
+    assert listed["rect"] == [1000, 0, 1000, 1000]
+    still = client.get(listed["still"])
+    assert still.status_code == 200
+    image = cv2.imdecode(np.frombuffer(still.content, np.uint8), cv2.IMREAD_COLOR)
+    assert image.shape[:2] == (200, 200)
+    assert client.get("/api/backdrops/camera/ffffffff.png").status_code == 404

From f9fca4cb9069ab18723c901a2b4e93ec8b9f6971 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 13:44:40 +0200
Subject: [PATCH 52/80] dotbot/console-web: add undo, arrow nudges and
 backdrops to the site editor

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/siteEditor/Canvas.tsx  |  55 +++++++-
 .../console-web/src/siteEditor/Inspector.tsx  |  46 ++++++-
 .../console-web/src/siteEditor/SiteEditor.tsx | 118 ++++++++++++++++--
 dotbot/console-web/src/siteEditor/api.ts      |   7 ++
 .../src/siteEditor/history.test.ts            |  40 ++++++
 dotbot/console-web/src/siteEditor/history.ts  |  36 ++++++
 .../src/siteEditor/siteEditor.test.tsx        |  67 ++++++++++
 dotbot/console-web/src/siteEditor/types.ts    |  27 ++++
 8 files changed, 374 insertions(+), 22 deletions(-)
 create mode 100644 dotbot/console-web/src/siteEditor/history.test.ts
 create mode 100644 dotbot/console-web/src/siteEditor/history.ts

diff --git a/dotbot/console-web/src/siteEditor/Canvas.tsx b/dotbot/console-web/src/siteEditor/Canvas.tsx
index cb440e49..e87300a9 100644
--- a/dotbot/console-web/src/siteEditor/Canvas.tsx
+++ b/dotbot/console-web/src/siteEditor/Canvas.tsx
@@ -1,6 +1,7 @@
 import React, { useEffect, useRef, useState } from "react";
 
 import { areaColor } from "../areaColor";
+import { convexHull } from "../calibrationSpan";
 import { AREA_FALLBACK, siteViewMarginMm, withMargin } from "../frame";
 import {
   axisTicks,
@@ -19,7 +20,7 @@ import { HANDLES, effectiveRole, moveRect, rectFromDrag, resizeRect, snap } from
 import type { Handle, Rect } from "./edit";
 import { applyMove, movedBox, movedCorners, snapAngle, turnAbout } from "./rigid";
 import type { Point, Rigid2D } from "./rigid";
-import type { CalibrationOverlay, EditArea } from "./types";
+import type { CalibrationBackdrop, CalibrationOverlay, CameraBackdrop, EditArea } from "./types";
 
 // The site drawn to scale: the extent, the metric grid and its rulers, and
 // every area in its role colour. Areas are moved, resized and drawn here; the
@@ -57,10 +58,13 @@ export interface CanvasProps {
   tool: Tool;
   snapMm: number;
   onSelect: (index: number | null) => void;
-  onChange: (index: number, rect: Rect) => void;
+  /** `key` names the gesture, so one drag undoes as one step. */
+  onChange: (index: number, rect: Rect, key: string) => void;
   onDraw: (rect: Rect) => void;
   placement?: Placement | null;
   onPlacement?: (move: Rigid2D) => void;
+  /** Read-only layers under the areas: only the ones switched on. */
+  backdrops?: { calibrations: CalibrationBackdrop[]; cameras: CameraBackdrop[] };
 }
 
 function handlePoint(r: Rect, h: Handle): { x: number; y: number } {
@@ -134,7 +138,9 @@ export function Canvas(props: CanvasProps) {
     return { x: mm("x", e.clientX - r.left), y: mm("y", e.clientY - r.top) };
   };
 
+  const gesture = useRef(0);
   const begin = (e: React.PointerEvent, next: Drag) => {
+    gesture.current += 1;
     e.stopPropagation();
     wrapRef.current?.setPointerCapture?.(e.pointerId);
     setDrag(next);
@@ -209,9 +215,9 @@ export function Canvas(props: CanvasProps) {
     } else if (drag.kind === "move") {
       // A click that selects is not a move, however the pointer jitters
       if (Math.hypot(e.clientX - drag.px.x, e.clientY - drag.px.y) < DRAG_THRESHOLD_PX) return;
-      props.onChange(drag.index, moveRect(drag.start, p.x - drag.from.x, p.y - drag.from.y, s));
+      props.onChange(drag.index, moveRect(drag.start, p.x - drag.from.x, p.y - drag.from.y, s), `canvas-${gesture.current}`);
     } else if (drag.kind === "resize") {
-      props.onChange(drag.index, resizeRect(drag.start, drag.handle, p, s));
+      props.onChange(drag.index, resizeRect(drag.start, drag.handle, p, s), `canvas-${gesture.current}`);
     } else {
       setDrag({ ...drag, to: p });
     }
@@ -291,6 +297,47 @@ export function Canvas(props: CanvasProps) {
             </text>
           ))}
         </g>
+        {props.backdrops?.cameras.map((cam) =>
+          cam.rect && cam.still ? (
+            <image
+              key={`cam-${cam.id8}`}
+              data-testid={`backdrop-camera-${cam.id8}`}
+              href={cam.still}
+              {...rectPx({ x: cam.rect[0], y: cam.rect[1], w: cam.rect[2], h: cam.rect[3] })}
+              preserveAspectRatio="none"
+              opacity={0.7}
+              style={{ pointerEvents: "none" }}
+            />
+          ) : null,
+        )}
+        {props.backdrops?.calibrations.map((cal) => {
+          const outline = (pts: [number, number][]) =>
+            convexHull(pts)
+              .map(([x, y]) => `${px("x", x)},${px("y", y)}`)
+              .join(" ");
+          return (
+            <g key={`cal-${cal.id8}`} data-testid={`backdrop-calibration-${cal.id8}`} style={{ pointerEvents: "none" }}>
+              {cal.placements
+                .filter((pts) => pts.length >= 3)
+                .map((pts, k) => (
+                  <polygon
+                    key={k}
+                    points={outline(pts)}
+                    fill="var(--s-Programming)"
+                    fillOpacity={0.06}
+                    stroke="var(--s-Programming)"
+                    strokeDasharray="2 3"
+                  />
+                ))}
+              {cal.centres.length >= 3 && (
+                <polygon points={outline(cal.centres)} fill="none" stroke="var(--s-Programming)" strokeDasharray="2 3" />
+              )}
+              {cal.centres.map(([x, y], k) => (
+                <circle key={k} cx={px("x", x)} cy={px("y", y)} r={2.5} fill="var(--s-Programming)" />
+              ))}
+            </g>
+          );
+        })}
         {order.map((i) => {
           const a = props.areas[i];
           const colour = areaColor(colourAreas[i], colourAreas);
diff --git a/dotbot/console-web/src/siteEditor/Inspector.tsx b/dotbot/console-web/src/siteEditor/Inspector.tsx
index 75b9bb3c..f0e7a38d 100644
--- a/dotbot/console-web/src/siteEditor/Inspector.tsx
+++ b/dotbot/console-web/src/siteEditor/Inspector.tsx
@@ -3,7 +3,7 @@ import React from "react";
 import type { AreaRole } from "../types";
 import { ROLES, declaredRole, effectiveRole } from "./edit";
 import type { Issue } from "./edit";
-import type { EditArea, SiteModel } from "./types";
+import type { Backdrops, EditArea, SiteModel } from "./types";
 
 // The right pane: every field is a key of site.toml, and what it shows is
 // what Save writes.
@@ -65,14 +65,19 @@ export interface InspectorProps {
   selected: number | null;
   hidden: Set<string>;
   issues: Issue[];
-  onSite: (site: SiteModel) => void;
-  onArea: (index: number, area: EditArea) => void;
+  /** `key` names the field, so typing into one undoes as one step. */
+  onSite: (site: SiteModel, key: string) => void;
+  onArea: (index: number, area: EditArea, key: string) => void;
   onSelect: (index: number | null) => void;
   onDelete: (index: number) => void;
   onToggle: (name: string) => void;
   onAdd: () => void;
   /** Shown at the top of the pane, for a tool with its own controls. */
   extra?: React.ReactNode;
+  backdrops?: Backdrops | null;
+  /** Keys `cal:<id8>` and `cam:<id8>` of the backdrops switched on. */
+  shownBackdrops?: Set<string>;
+  onToggleBackdrop?: (key: string) => void;
 }
 
 export function Inspector(props: InspectorProps) {
@@ -82,11 +87,11 @@ export function Inspector(props: InspectorProps) {
   const setExtent = (i: 0 | 1, v: number) => {
     const next: [number, number] = [extent[0], extent[1]];
     next[i] = v;
-    props.onSite({ ...site, extent_mm: next });
+    props.onSite({ ...site, extent_mm: next }, `extent-${i}`);
   };
   const setArea = (patch: Partial<EditArea>) => {
     if (props.selected === null || !area) return;
-    props.onArea(props.selected, { ...area, ...patch });
+    props.onArea(props.selected, { ...area, ...patch }, `area-${props.selected}-${Object.keys(patch).sort().join(",")}`);
   };
   const role = area ? effectiveRole(area) : null;
   const nameIsRole = !!area && (ROLES as string[]).includes(area.name);
@@ -116,7 +121,7 @@ export function Inspector(props: InspectorProps) {
             aria-label="anchor"
             rows={3}
             value={site.anchor ?? ""}
-            onChange={(e) => props.onSite({ ...site, anchor: e.target.value })}
+            onChange={(e) => props.onSite({ ...site, anchor: e.target.value }, "anchor")}
             style={{ ...input, fontFamily: "var(--font-ui)", resize: "vertical" }}
           />
         </label>
@@ -252,6 +257,35 @@ export function Inspector(props: InspectorProps) {
         ))}
       </div>
 
+      {props.backdrops && (props.backdrops.calibrations.length > 0 || props.backdrops.cameras.length > 0) && (
+        <div style={section} data-testid="backdrops">
+          <div style={heading}>Backdrops (read-only)</div>
+          {[
+            ...props.backdrops.calibrations.map((c) => ({
+              key: `cal:${c.id8}`,
+              label: `LH2 ${c.id8}${c.tag ? ` ${c.tag}` : ""}`,
+              note: c.placements.length ? "where it was fitted" : "its spin centres",
+            })),
+            ...props.backdrops.cameras.map((c) => ({
+              key: `cam:${c.id8}`,
+              label: `camera ${c.id8} on ${c.area}`,
+              note: c.still ? "its still" : "no still saved",
+            })),
+          ].map((b) => (
+            <label key={b.key} style={{ display: "flex", gap: 6, alignItems: "center", fontSize: 12, marginTop: 6 }}>
+              <input
+                type="checkbox"
+                aria-label={`backdrop ${b.label}`}
+                checked={props.shownBackdrops?.has(b.key) ?? false}
+                onChange={() => props.onToggleBackdrop?.(b.key)}
+              />
+              <span style={{ flex: 1, fontFamily: "var(--font-mono)" }}>{b.label}</span>
+              <span style={{ color: "var(--muted)", fontSize: 11 }}>{b.note}</span>
+            </label>
+          ))}
+        </div>
+      )}
+
       {props.issues.length > 0 && (
         <div style={section} data-testid="issues">
           <div style={heading}>Checks</div>
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index bdb8f1c5..595c6a6b 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -4,6 +4,7 @@ import {
   RefusedSiteError,
   StaleSiteError,
   fetchCalibration,
+  fetchBackdrops,
   fetchCalibrations,
   fetchSite,
   placeCalibration,
@@ -23,9 +24,18 @@ import {
   siteIssues,
 } from "./edit";
 import type { Rect } from "./edit";
+import { record, redo, startHistory, undo } from "./history";
+import type { History } from "./history";
 import { Inspector } from "./Inspector";
 import { IDENTITY } from "./rigid";
-import type { CalibrationListing, EditArea, PlacedCalibration, SiteModel, SiteResponse } from "./types";
+import type {
+  Backdrops,
+  CalibrationListing,
+  EditArea,
+  PlacedCalibration,
+  SiteModel,
+  SiteResponse,
+} from "./types";
 
 // The site editor: one site pack's site.toml, drawn. It talks only to the
 // small server `dotbot site new|edit` starts, never to a controller.
@@ -75,7 +85,15 @@ function typing(target: EventTarget | null): boolean {
 export function SiteEditor() {
   const theme = useTheme();
   const [loaded, setLoaded] = useState<SiteResponse | null>(null);
-  const [site, setSite] = useState<SiteModel | null>(null);
+  const [history, setHistory] = useState<History<SiteModel> | null>(null);
+  const site = history?.present ?? null;
+  /** Change the site; edits sharing `key` (one drag, one field) undo as one. */
+  const setSite = (next: SiteModel | ((s: SiteModel) => SiteModel), key: string | null = null) =>
+    setHistory((h) => {
+      if (!h) return h;
+      const value = typeof next === "function" ? next(h.present) : next;
+      return JSON.stringify(value) === JSON.stringify(h.present) ? h : record(h, value, key);
+    });
   const [selected, setSelected] = useState<number | null>(null);
   const [hidden, setHidden] = useState<Set<string>>(new Set());
   const [tool, setTool] = useState<Tool>("select");
@@ -88,12 +106,14 @@ export function SiteEditor() {
   const [placement, setPlacement] = useState<Placement | null>(null);
   const [reanchor, setReanchor] = useState(false);
   const [placed, setPlaced] = useState<PlacedCalibration | null>(null);
+  const [backdrops, setBackdrops] = useState<Backdrops | null>(null);
+  const [shownBackdrops, setShownBackdrops] = useState<Set<string>>(new Set());
 
   const load = useCallback(async () => {
     try {
       const body = await fetchSite();
       setLoaded(body);
-      setSite(body.site);
+      setHistory(startHistory(body.site));
       setSelected(null);
       setNotice(null);
     } catch (err) {
@@ -105,6 +125,13 @@ export function SiteEditor() {
     void load();
   }, [load]);
 
+  // Read again after a placement, which adds a calibration to the site
+  useEffect(() => {
+    fetchBackdrops()
+      .then(setBackdrops)
+      .catch(() => setBackdrops(null));
+  }, [placed]);
+
   useEffect(() => {
     if (tool !== "calibration") return;
     fetchCalibrations()
@@ -142,8 +169,8 @@ export function SiteEditor() {
   const dirty = !!site && !!loaded && !sameSite(site, loaded.site);
   const calibrations = loaded?.calibrations.reduce((n, c) => n + c.count, 0) ?? 0;
 
-  const updateArea = (index: number, patch: Partial<EditArea>) => {
-    setSite((s) => (s ? { ...s, areas: s.areas.map((a, i) => (i === index ? { ...a, ...patch } : a)) } : s));
+  const updateArea = (index: number, patch: Partial<EditArea>, key: string | null = null) => {
+    setSite((s) => ({ ...s, areas: s.areas.map((a, i) => (i === index ? { ...a, ...patch } : a)) }), key);
   };
   const addArea = (rect: Rect) => {
     if (!site) return;
@@ -153,7 +180,7 @@ export function SiteEditor() {
     setTool("select");
   };
   const deleteArea = (index: number) => {
-    setSite((s) => (s ? { ...s, areas: s.areas.filter((_, i) => i !== index) } : s));
+    setSite((s) => ({ ...s, areas: s.areas.filter((_, i) => i !== index) }));
     setSelected(null);
   };
   const addDefaultArea = () => {
@@ -161,9 +188,39 @@ export function SiteEditor() {
     addArea({ x: 0, y: 0, w: Math.min(1000, w), h: Math.min(1000, h) });
   };
 
+  const nudge = (dx: number, dy: number) => {
+    if (tool === "calibration" && placement) {
+      setPlacement({ ...placement, move: { ...placement.move, dx_mm: placement.move.dx_mm + dx, dy_mm: placement.move.dy_mm + dy } });
+    } else if (selected !== null && site?.areas[selected]) {
+      const a = site.areas[selected];
+      updateArea(selected, { x: a.x + dx, y: a.y + dy }, `nudge-${selected}`);
+    }
+  };
+
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
-      if (saving || typing(e.target) || e.ctrlKey || e.metaKey) return;
+      if (saving || typing(e.target)) return;
+      if (e.ctrlKey || e.metaKey) {
+        const key = e.key.toLowerCase();
+        if (key === "z" && !e.shiftKey) setHistory((h) => (h ? undo(h) : h));
+        else if ((key === "z" && e.shiftKey) || key === "y") setHistory((h) => (h ? redo(h) : h));
+        else return;
+        e.preventDefault();
+        return;
+      }
+      const arrows: Record<string, [number, number]> = {
+        ArrowLeft: [-1, 0],
+        ArrowRight: [1, 0],
+        ArrowUp: [0, -1],
+        ArrowDown: [0, 1],
+      };
+      if (arrows[e.key]) {
+        // A snap step; Alt one millimetre, Shift ten steps
+        const step = (e.altKey ? 1 : snapMm) * (e.shiftKey ? 10 : 1);
+        nudge(arrows[e.key][0] * step, arrows[e.key][1] * step);
+        e.preventDefault();
+        return;
+      }
       if (e.key === "v" || e.key === "V") setTool("select");
       else if (e.key === "a" || e.key === "A") setTool("area");
       else if (e.key === "c" || e.key === "C") setTool("calibration");
@@ -172,7 +229,7 @@ export function SiteEditor() {
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
-  }, [selected]);
+  });
 
   useEffect(() => {
     const onLeave = (e: BeforeUnloadEvent) => {
@@ -189,7 +246,8 @@ export function SiteEditor() {
     try {
       const body = await saveSite(loaded.revision, site);
       setLoaded(body);
-      setSite(body.site);
+      // The file's names are the areas' origins now, so older steps no longer apply
+      setHistory(startHistory(body.site));
       setNotice({ kind: "info", text: body.written ? `saved ${body.path}` : "nothing to save" });
     } catch (err) {
       if (err instanceof StaleSiteError) {
@@ -290,6 +348,24 @@ export function SiteEditor() {
             ))}
           </select>
         </label>
+        <button
+          type="button"
+          style={button}
+          title="undo (Ctrl+Z)"
+          disabled={!history || history.past.length === 0}
+          onClick={() => setHistory((h) => (h ? undo(h) : h))}
+        >
+          Undo
+        </button>
+        <button
+          type="button"
+          style={button}
+          title="redo (Ctrl+Shift+Z)"
+          disabled={!history || history.future.length === 0}
+          onClick={() => setHistory((h) => (h ? redo(h) : h))}
+        >
+          Redo
+        </button>
         <button type="button" style={button} onClick={onViewToml} disabled={!site}>
           View TOML
         </button>
@@ -387,10 +463,18 @@ export function SiteEditor() {
             tool={tool}
             snapMm={snapMm}
             onSelect={setSelected}
-            onChange={(i, r) => updateArea(i, r)}
+            onChange={(i, r, key) => updateArea(i, r, key)}
             onDraw={addArea}
             placement={placement}
             onPlacement={(move) => setPlacement((p) => (p ? { ...p, move } : p))}
+            backdrops={
+              backdrops
+                ? {
+                    calibrations: backdrops.calibrations.filter((c) => shownBackdrops.has(`cal:${c.id8}`)),
+                    cameras: backdrops.cameras.filter((c) => shownBackdrops.has(`cam:${c.id8}`)),
+                  }
+                : undefined
+            }
           />
         ) : (
           <div style={{ flex: 1 }} />
@@ -404,8 +488,8 @@ export function SiteEditor() {
             selected={selected}
             hidden={hidden}
             issues={issues}
-            onSite={setSite}
-            onArea={(i, a) => updateArea(i, a)}
+            onSite={(next, key) => setSite(next, key)}
+            onArea={(i, a, key) => updateArea(i, a, key)}
             onSelect={setSelected}
             onDelete={deleteArea}
             onToggle={(name) =>
@@ -417,6 +501,16 @@ export function SiteEditor() {
               })
             }
             onAdd={addDefaultArea}
+            backdrops={backdrops}
+            shownBackdrops={shownBackdrops}
+            onToggleBackdrop={(key) =>
+              setShownBackdrops((shown) => {
+                const next = new Set(shown);
+                if (next.has(key)) next.delete(key);
+                else next.add(key);
+                return next;
+              })
+            }
             extra={
               tool === "calibration" || placement || placed ? (
                 <CalibrationPanel
diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
index 8e4bc47d..ca8bc8d2 100644
--- a/dotbot/console-web/src/siteEditor/api.ts
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -1,5 +1,6 @@
 import type { Rigid2D } from "./rigid";
 import type {
+  Backdrops,
   CalibrationListing,
   CalibrationOverlay,
   PlacedCalibration,
@@ -102,3 +103,9 @@ export async function placeCalibration(
   if (!res.ok) throw new Error(await detail(res));
   return res.json();
 }
+
+export async function fetchBackdrops(): Promise<Backdrops> {
+  const res = await fetch("api/backdrops");
+  if (!res.ok) throw new Error(await detail(res));
+  return res.json();
+}
diff --git a/dotbot/console-web/src/siteEditor/history.test.ts b/dotbot/console-web/src/siteEditor/history.test.ts
new file mode 100644
index 00000000..2e1ef008
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/history.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+
+import { HISTORY_LIMIT, record, redo, startHistory, undo } from "./history";
+
+describe("history", () => {
+  it("undoes and redoes one step at a time", () => {
+    let h = startHistory(0);
+    h = record(h, 1);
+    h = record(h, 2);
+    h = undo(h);
+    expect(h.present).toBe(1);
+    h = undo(h);
+    expect(h.present).toBe(0);
+    expect(undo(h)).toBe(h);
+    h = redo(h);
+    expect(h.present).toBe(1);
+  });
+
+  it("coalesces edits that share a key into one step", () => {
+    let h = startHistory("a");
+    h = record(h, "ab", "name");
+    h = record(h, "abc", "name");
+    h = record(h, "abcd", "other");
+    expect(h.past).toEqual(["a", "abc"]);
+    expect(undo(undo(h)).present).toBe("a");
+  });
+
+  it("drops the redo branch on a new edit", () => {
+    let h = record(record(startHistory(0), 1), 2);
+    h = record(undo(h), 5);
+    expect(h.future).toEqual([]);
+    expect(redo(h)).toBe(h);
+  });
+
+  it("keeps at most the limit of past steps", () => {
+    let h = startHistory(0);
+    for (let i = 1; i <= HISTORY_LIMIT + 10; i += 1) h = record(h, i);
+    expect(h.past).toHaveLength(HISTORY_LIMIT);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/history.ts b/dotbot/console-web/src/siteEditor/history.ts
new file mode 100644
index 00000000..a40a78d0
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/history.ts
@@ -0,0 +1,36 @@
+// Undo and redo over the site model. Consecutive edits that share a key (one
+// drag, one field being typed into) coalesce into a single step.
+
+export const HISTORY_LIMIT = 200;
+
+export interface History<T> {
+  past: T[];
+  present: T;
+  future: T[];
+  key: string | null;
+}
+
+export function startHistory<T>(present: T): History<T> {
+  return { past: [], present, future: [], key: null };
+}
+
+export function record<T>(h: History<T>, next: T, key: string | null = null): History<T> {
+  if (next === h.present) return h;
+  if (key !== null && key === h.key) return { ...h, present: next, future: [] };
+  return { past: [...h.past, h.present].slice(-HISTORY_LIMIT), present: next, future: [], key };
+}
+
+export function undo<T>(h: History<T>): History<T> {
+  if (h.past.length === 0) return h;
+  return {
+    past: h.past.slice(0, -1),
+    present: h.past[h.past.length - 1],
+    future: [h.present, ...h.future],
+    key: null,
+  };
+}
+
+export function redo<T>(h: History<T>): History<T> {
+  if (h.future.length === 0) return h;
+  return { past: [...h.past, h.present], present: h.future[0], future: h.future.slice(1), key: null };
+}
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index 44508295..5a0207e5 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -219,3 +219,70 @@ describe("SiteEditor calibration placement", () => {
     expect(dx).toBeGreaterThan(0);
   });
 });
+
+describe("SiteEditor comfort", () => {
+  const xOf = () => Number((screen.getByLabelText("x") as HTMLInputElement).value);
+
+  it("undoes and redoes an edit, a field's typing as one step", async () => {
+    server(loaded(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    fireEvent.click(screen.getByLabelText("show dev-corner").parentElement!);
+    fireEvent.change(screen.getByLabelText("x"), { target: { value: "9" } });
+    fireEvent.change(screen.getByLabelText("x"), { target: { value: "95" } });
+    fireEvent.change(screen.getByLabelText("x"), { target: { value: "950" } });
+    expect(xOf()).toBe(950);
+    fireEvent.click(screen.getByText("Undo"));
+    expect(xOf()).toBe(1000);
+    expect(screen.getByText("Undo")).toBeDisabled();
+    fireEvent.click(screen.getByText("Redo"));
+    expect(xOf()).toBe(950);
+    fireEvent.keyDown(window, { key: "z", ctrlKey: true });
+    expect(xOf()).toBe(1000);
+    fireEvent.keyDown(window, { key: "z", ctrlKey: true, shiftKey: true });
+    expect(xOf()).toBe(950);
+  });
+
+  it("nudges the selected area by a snap step, Alt by a millimetre", async () => {
+    server(loaded(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    fireEvent.click(screen.getByLabelText("show dev-corner").parentElement!);
+    fireEvent.keyDown(window, { key: "ArrowRight" });
+    expect(xOf()).toBe(1050);
+    fireEvent.keyDown(window, { key: "ArrowLeft", altKey: true });
+    expect(xOf()).toBe(1049);
+    fireEvent.keyDown(window, { key: "ArrowLeft", shiftKey: true });
+    expect(xOf()).toBe(549);
+    fireEvent.click(screen.getByText("Undo"));
+    expect(xOf()).toBe(1000);
+  });
+
+  it("offers a backdrop only for what the site has, and draws it when ticked", async () => {
+    const fetch = vi.fn(async (url: string) => {
+      const json = (status: number, body: unknown) =>
+        new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+      if (url === "api/site") return json(200, loaded());
+      if (url === "api/backdrops")
+        return json(200, {
+          calibrations: [
+            {
+              id8: "b54cb043",
+              tag: "",
+              created_at: "",
+              placements: [[[0, 0], [2000, 0], [2000, 2000], [0, 2000]]],
+              centres: [],
+            },
+          ],
+          cameras: [],
+        });
+      return json(404, { detail: "no" });
+    });
+    vi.stubGlobal("fetch", fetch);
+    render(<SiteEditor />);
+    const box = await screen.findByLabelText("backdrop LH2 b54cb043");
+    expect(screen.queryByTestId("backdrop-calibration-b54cb043")).toBeNull();
+    fireEvent.click(box);
+    expect(screen.getByTestId("backdrop-calibration-b54cb043")).toBeInTheDocument();
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/types.ts b/dotbot/console-web/src/siteEditor/types.ts
index 0be128a0..fd4a16a1 100644
--- a/dotbot/console-web/src/siteEditor/types.ts
+++ b/dotbot/console-web/src/siteEditor/types.ts
@@ -87,3 +87,30 @@ export interface PlacedCalibration extends CalibrationOverlay {
   push: string;
   warnings: string[];
 }
+
+/** One LH2 calibration of this site, drawn read-only under the areas. */
+export interface CalibrationBackdrop {
+  id8: string;
+  tag: string;
+  created_at: string;
+  /** Each placement's points, frame mm. */
+  placements: [number, number][][];
+  /** Spin centres, frame mm. */
+  centres: [number, number][];
+}
+
+/** One registered camera of this site. */
+export interface CameraBackdrop {
+  id8: string;
+  area: string;
+  /** The area it is registered on, [x, y, w, h]; null when the site lacks it. */
+  rect: [number, number, number, number] | null;
+  span: [number, number][];
+  /** The still warped onto `rect`, when one was saved beside the file. */
+  still: string | null;
+}
+
+export interface Backdrops {
+  calibrations: CalibrationBackdrop[];
+  cameras: CameraBackdrop[];
+}

From a107a47b4dbfc7c646d5a54d903f0d6198f85438 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:48:41 +0200
Subject: [PATCH 53/80] dotbot/site_editor: skip backdrop files it cannot draw,
 cap and version stills

AI-assisted: Claude Opus 5.5
---
 dotbot/site_backdrops.py            | 130 ++++++++++++++++++----------
 dotbot/tests/test_site_backdrops.py |  96 ++++++++++++++++++--
 2 files changed, 174 insertions(+), 52 deletions(-)

diff --git a/dotbot/site_backdrops.py b/dotbot/site_backdrops.py
index 2c0c2935..674e54fa 100644
--- a/dotbot/site_backdrops.py
+++ b/dotbot/site_backdrops.py
@@ -8,6 +8,7 @@
 
 from __future__ import annotations
 
+import logging
 import tomllib
 from collections.abc import Callable, Sequence
 from pathlib import Path
@@ -18,15 +19,19 @@
 from dotbot.area import Area
 from dotbot.calibration.lighthouse2 import (
     CALIBRATION_TOML_GLOB,
+    check_calibration_site,
     read_calibration_file,
 )
 from dotbot.calibration.placement import spin_centres
 from dotbot.config import SiteSection
-from dotbot.site import site_from_table
+from dotbot.site import Site, site_from_table
 
+LOGGER = logging.getLogger(__name__)
 CAMERA_TOML_GLOB = "camera-*.toml"
 # Millimetres per pixel of a warped still: coarse, it is a backdrop
 STILL_MM_PER_PX = 5.0
+# Longest side of a warped still; a larger area is drawn coarser
+STILL_MAX_PX = 4096
 
 
 def _glob(folders: Sequence[Path], pattern: str) -> list[Path]:
@@ -39,26 +44,39 @@ def _glob(folders: Sequence[Path], pattern: str) -> list[Path]:
     return out
 
 
-def calibration_backdrop(path: Path) -> dict | None:
-    """One LH2 calibration's placements and spin centres, in frame mm."""
+def calibration_backdrop(path: Path, site: Site | None) -> dict | None:
+    """One LH2 calibration's placements and spin centres, in frame mm; None
+    when the file cannot be read or was made in another frame than `site`'s."""
     try:
         calibration = read_calibration_file(path)
-    except (OSError, ValueError, tomllib.TOMLDecodeError):
+        if site is not None:
+            check_calibration_site(calibration.site, site, path)
+        return {
+            "id8": calibration.id8,
+            "tag": calibration.tag,
+            "created_at": calibration.created_at,
+            "placements": [
+                [list(point) for point in placement.points_mm]
+                for placement in calibration.placements
+            ],
+            "centres": [
+                [c["x"], c["y"]]
+                for circles in spin_centres(calibration).values()
+                for c in circles
+            ],
+        }
+    except Exception as exc:  # noqa: BLE001
+        LOGGER.info("no backdrop from %s: %s", path, exc)
         return None
-    return {
-        "id8": calibration.id8,
-        "tag": calibration.tag,
-        "created_at": calibration.created_at,
-        "placements": [
-            [list(point) for point in placement.points_mm]
-            for placement in calibration.placements
-        ],
-        "centres": [
-            [c["x"], c["y"]]
-            for circles in spin_centres(calibration).values()
-            for c in circles
-        ],
-    }
+
+
+def _homography(matrix):
+    import numpy as np
+
+    array = np.array(matrix, dtype=np.float64)
+    if array.shape != (3, 3) or not np.isfinite(array).all():
+        raise ValueError("a camera's homography is not a 3 x 3 matrix")
+    return array
 
 
 def warp_still(image: Path, matrix, area: Area) -> bytes | None:
@@ -72,24 +90,34 @@ def warp_still(image: Path, matrix, area: Area) -> bytes | None:
     frame = cv2.imread(str(image))
     if frame is None:
         return None
+    mm_per_px = max(STILL_MM_PER_PX, max(area.w, area.h) / STILL_MAX_PX)
     scale = np.array(
         [
-            [1.0 / STILL_MM_PER_PX, 0.0, -area.x / STILL_MM_PER_PX],
-            [0.0, 1.0 / STILL_MM_PER_PX, -area.y / STILL_MM_PER_PX],
+            [1.0 / mm_per_px, 0.0, -area.x / mm_per_px],
+            [0.0, 1.0 / mm_per_px, -area.y / mm_per_px],
             [0.0, 0.0, 1.0],
         ]
     )
     size = (
-        max(1, round(area.w / STILL_MM_PER_PX)),
-        max(1, round(area.h / STILL_MM_PER_PX)),
-    )
-    warped = cv2.warpPerspective(
-        frame, scale @ np.array(matrix, dtype=np.float64), size
+        min(STILL_MAX_PX, max(1, round(area.w / mm_per_px))),
+        min(STILL_MAX_PX, max(1, round(area.h / mm_per_px))),
     )
+    try:
+        warped = cv2.warpPerspective(frame, scale @ _homography(matrix), size)
+    except (ValueError, cv2.error):
+        return None
     ok, png = cv2.imencode(".png", warped)
     return png.tobytes() if ok else None
 
 
+def _can_warp() -> bool:
+    try:
+        import cv2  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
 def create_router(
     name: str, folders: Callable[[], list[Path]], site_text: Callable[[], str]
 ) -> APIRouter:
@@ -98,44 +126,58 @@ def create_router(
 
     router = APIRouter()
 
-    def cameras() -> list[tuple[Path, object]]:
+    def cameras() -> list[tuple[Path, object, list]]:
         out = []
         for path in _glob(folders(), CAMERA_TOML_GLOB):
             try:
-                out.append((path, read_camera_calibration_file(path)))
-            except (OSError, ValueError, tomllib.TOMLDecodeError):
+                camera = read_camera_calibration_file(path)
+                _homography(camera.matrix)
+                span = [[float(x), float(y)] for x, y in camera.span_mm]
+            except Exception as exc:  # noqa: BLE001
+                LOGGER.info("no backdrop from %s: %s", path, exc)
                 continue
+            out.append((path, camera, span))
         return out
 
-    def area_of(camera) -> Area | None:
+    def site() -> Site | None:
         try:
             table = SiteSection.model_validate(tomllib.loads(site_text()))
-            return site_from_table(name, table).registry().resolve(camera.area)
+            return site_from_table(name, table)
+        except Exception:  # noqa: BLE001
+            return None
+
+    def area_of(camera, current: Site | None) -> Area | None:
+        try:
+            return current.registry().resolve(camera.area) if current else None
         except Exception:  # noqa: BLE001
             return None
 
     @router.get("/api/backdrops")
     def backdrops():
-        calibrations = [
-            found
-            for found in map(
-                calibration_backdrop, _glob(folders(), CALIBRATION_TOML_GLOB)
-            )
-            if found is not None
-        ]
+        current = site()
+        seen: set[str] = set()
+        calibrations = []
+        for path in _glob(folders(), CALIBRATION_TOML_GLOB):
+            found = calibration_backdrop(path, current)
+            if found is not None and found["id8"] not in seen:
+                seen.add(found["id8"])
+                calibrations.append(found)
         listed = []
-        for path, camera in cameras():
-            area = area_of(camera)
+        warps = _can_warp()
+        for path, camera, span in cameras():
+            area = area_of(camera, current)
             still = path.with_suffix(".jpg")
+            version = f"{still.stat().st_mtime_ns:x}" if still.is_file() else ""
             listed.append(
                 {
                     "id8": camera.id8,
                     "area": camera.area,
                     "rect": [area.x, area.y, area.w, area.h] if area else None,
-                    "span": [list(p) for p in camera.span_mm],
+                    "span": span,
                     "still": (
-                        f"api/backdrops/camera/{camera.id8}.png"
-                        if area and still.is_file()
+                        f"api/backdrops/camera/{camera.id8}.png?v={version}"
+                        f"-{area.x}-{area.y}-{area.w}-{area.h}"
+                        if area and version and warps
                         else None
                     ),
                 }
@@ -144,10 +186,10 @@ def backdrops():
 
     @router.get("/api/backdrops/camera/{id8}.png")
     def still(id8: str):
-        for path, camera in cameras():
+        for path, camera, _ in cameras():
             if camera.id8 != id8:
                 continue
-            area = area_of(camera)
+            area = area_of(camera, site())
             image = path.with_suffix(".jpg")
             png = warp_still(image, camera.matrix, area) if area else None
             if png is None:
diff --git a/dotbot/tests/test_site_backdrops.py b/dotbot/tests/test_site_backdrops.py
index 2ae7973c..0789edbd 100644
--- a/dotbot/tests/test_site_backdrops.py
+++ b/dotbot/tests/test_site_backdrops.py
@@ -4,15 +4,17 @@
 """What the site editor draws under a site: its calibrations' spans and its
 cameras' stills, warped into the frame."""
 
+import dataclasses
+
 import numpy as np
 import pytest
-from fastapi.testclient import TestClient
 
 from dotbot.calibration import conics
 from dotbot.calibration.lighthouse2 import write_calibration
 from dotbot.site import Site
 from dotbot.site_editor import EditorState, create_app
 from dotbot.tests.test_calibration_conics import CENTRES, track_samples
+from dotbot.tests.test_site_editor import local_client
 from dotbot.tests.test_site_toml import ARENA
 
 
@@ -28,13 +30,23 @@ def setup(tmp_path, monkeypatch):
     page.mkdir()
     (page / "site-editor.html").write_text("<html></html>")
     home = tmp_path / "home" / "calibrations" / "arena"
-    client = TestClient(
-        create_app(EditorState("arena", pack, [home]), page),
-        base_url="http://127.0.0.1",
-    )
+    client = local_client(create_app(EditorState("arena", pack, [home]), page))
     return client, home
 
 
+ARENA_ANCHOR = "the corner where the top wall meets the door wall"
+
+
+def _placed_spin():
+    """A spin calibration recorded against the arena's anchor, as placed."""
+    calibration, _, _ = conics.solve_calibration(
+        track_samples(CENTRES), Site(name="arena"), tag="spin"
+    )
+    return dataclasses.replace(
+        calibration, site=Site(name="arena", anchor=ARENA_ANCHOR)
+    )
+
+
 def test_a_site_with_no_calibration_has_no_backdrop(setup):
     client, _ = setup
     assert client.get("/api/backdrops").json() == {"calibrations": [], "cameras": []}
@@ -42,9 +54,7 @@ def test_a_site_with_no_calibration_has_no_backdrop(setup):
 
 def test_a_calibration_of_the_site_is_drawn_by_its_spin_centres(setup):
     client, _ = setup
-    calibration, _, _ = conics.solve_calibration(
-        track_samples(CENTRES), Site(name="arena"), tag="spin"
-    )
+    calibration = _placed_spin()
     write_calibration(calibration)
     (drawn,) = client.get("/api/backdrops").json()["calibrations"]
     assert drawn["id8"] == calibration.id8
@@ -78,4 +88,74 @@ def test_a_camera_still_is_warped_onto_its_area(setup):
     assert still.status_code == 200
     image = cv2.imdecode(np.frombuffer(still.content, np.uint8), cv2.IMREAD_COLOR)
     assert image.shape[:2] == (200, 200)
+    # The area's own floor fills the still: a lost origin leaves it mostly black
+    assert (image.max(axis=2) == 0).mean() < 0.2
     assert client.get("/api/backdrops/camera/ffffffff.png").status_code == 404
+
+
+def _camera(home, area, matrix):
+    from dotbot.camera.registration import CameraCalibration, write_camera_calibration
+
+    camera = CameraCalibration(
+        site=Site(name="arena"),
+        area=area,
+        width=640,
+        height=480,
+        matrix=matrix,
+        created="2026-10-02T10:00:00Z",
+    )
+    return write_camera_calibration(camera, root=home.parent)
+
+
+def test_a_file_that_cannot_be_read_is_skipped_not_a_500(setup):
+    client, home = setup
+    calibration = _placed_spin()
+    good = write_calibration(calibration)
+    text = good.read_text()
+    (home / "calibration-broken.toml").write_text(
+        text.replace(f'id = "{calibration.id}"', "id = 7")
+    )
+    (home / "calibration-garbage.toml").write_text("[[placement]]\nhomography = 1\n")
+    _camera(home, "dev-corner", [[1.0, 0.0], [0.0, 1.0]])
+    response = client.get("/api/backdrops")
+    assert response.status_code == 200
+    body = response.json()
+    assert [c["id8"] for c in body["calibrations"]] == [calibration.id8]
+    assert body["cameras"] == []
+
+
+def test_a_calibration_in_another_frame_is_not_drawn(setup):
+    client, _ = setup
+    calibration, _, _ = conics.solve_calibration(
+        track_samples(CENTRES), Site(name="arena"), tag="spin"
+    )
+    write_calibration(calibration)
+    assert client.get("/api/backdrops").json()["calibrations"] == []
+
+
+def test_a_still_of_a_huge_area_is_capped(setup):
+    cv2 = pytest.importorskip("cv2")
+    from dotbot.tests.camera_fixtures import ground_truth_px_to_mm, synthetic_frame
+
+    client, home = setup
+    path = _camera(home, "0,0,100000,50000", ground_truth_px_to_mm().tolist())
+    cv2.imwrite(str(path.with_suffix(".jpg")), synthetic_frame())
+    (listed,) = client.get("/api/backdrops").json()["cameras"]
+    still = client.get(listed["still"])
+    assert still.status_code == 200
+    image = cv2.imdecode(np.frombuffer(still.content, np.uint8), cv2.IMREAD_COLOR)
+    assert image.shape[:2] == (2048, 4096)
+
+
+def test_a_still_url_changes_when_its_area_moves(setup):
+    cv2 = pytest.importorskip("cv2")
+    from dotbot.tests.camera_fixtures import ground_truth_px_to_mm, synthetic_frame
+
+    client, home = setup
+    path = _camera(home, "dev-corner", ground_truth_px_to_mm().tolist())
+    cv2.imwrite(str(path.with_suffix(".jpg")), synthetic_frame())
+    before = client.get("/api/backdrops").json()["cameras"][0]["still"]
+    site = home.parent.parent.parent / "arena" / "site.toml"
+    site.write_text(site.read_text().replace("x = 1000", "x = 900"))
+    after = client.get("/api/backdrops").json()["cameras"][0]["still"]
+    assert before != after

From 84ad3e1e77b44cf9ba31eda4577f49b05f9208bc Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 03:50:04 +0200
Subject: [PATCH 54/80] dotbot/console-web: seal undo steps per selection,
 refresh backdrops on save

AI-assisted: Claude Opus 5.5
---
 .../console-web/src/siteEditor/SiteEditor.tsx | 38 ++++++++++---
 .../src/siteEditor/history.test.ts            |  8 ++-
 dotbot/console-web/src/siteEditor/history.ts  |  5 ++
 .../src/siteEditor/siteEditor.test.tsx        | 55 +++++++++++++++++++
 4 files changed, 97 insertions(+), 9 deletions(-)

diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index 595c6a6b..c8287e30 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -24,7 +24,7 @@ import {
   siteIssues,
 } from "./edit";
 import type { Rect } from "./edit";
-import { record, redo, startHistory, undo } from "./history";
+import { record, redo, seal, startHistory, undo } from "./history";
 import type { History } from "./history";
 import { Inspector } from "./Inspector";
 import { IDENTITY } from "./rigid";
@@ -77,9 +77,13 @@ const TOOLS: { key: Tool | "wall" | "obstacle" | "charger"; label: string; hint:
   { key: "charger", label: "Charger", hint: "needs an objects table in site.toml first" },
 ];
 
+const NOT_TYPED = new Set(["checkbox", "radio", "button", "submit", "reset", "range", "color", "file"]);
+
 function typing(target: EventTarget | null): boolean {
   const el = target as HTMLElement | null;
-  return !!el && (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT");
+  if (!el) return false;
+  if (el.tagName === "INPUT") return !NOT_TYPED.has((el as HTMLInputElement).type);
+  return el.tagName === "TEXTAREA" || el.tagName === "SELECT";
 }
 
 export function SiteEditor() {
@@ -125,12 +129,30 @@ export function SiteEditor() {
     void load();
   }, [load]);
 
-  // Read again after a placement, which adds a calibration to the site
+  // Read again after a placement adds a calibration, and after a save or a
+  // reload, which can move the areas cameras are registered on
+  const revision = loaded?.revision;
   useEffect(() => {
+    if (revision === undefined) return;
     fetchBackdrops()
       .then(setBackdrops)
       .catch(() => setBackdrops(null));
-  }, [placed]);
+  }, [placed, revision]);
+
+  // A new selection starts a new undo step, even for the same kind of edit
+  useEffect(() => {
+    setHistory((h) => (h ? seal(h) : h));
+  }, [selected]);
+
+  /** Undo or redo, dropping a selection whose index now names another area. */
+  const travel = (move: (h: History<SiteModel>) => History<SiteModel>) => {
+    if (!history) return;
+    const next = move(history);
+    if (selected !== null && next.present.areas[selected]?.name !== history.present.areas[selected]?.name) {
+      setSelected(null);
+    }
+    setHistory(next);
+  };
 
   useEffect(() => {
     if (tool !== "calibration") return;
@@ -202,8 +224,8 @@ export function SiteEditor() {
       if (saving || typing(e.target)) return;
       if (e.ctrlKey || e.metaKey) {
         const key = e.key.toLowerCase();
-        if (key === "z" && !e.shiftKey) setHistory((h) => (h ? undo(h) : h));
-        else if ((key === "z" && e.shiftKey) || key === "y") setHistory((h) => (h ? redo(h) : h));
+        if (key === "z" && !e.shiftKey) travel(undo);
+        else if ((key === "z" && e.shiftKey) || key === "y") travel(redo);
         else return;
         e.preventDefault();
         return;
@@ -353,7 +375,7 @@ export function SiteEditor() {
           style={button}
           title="undo (Ctrl+Z)"
           disabled={!history || history.past.length === 0}
-          onClick={() => setHistory((h) => (h ? undo(h) : h))}
+          onClick={() => travel(undo)}
         >
           Undo
         </button>
@@ -362,7 +384,7 @@ export function SiteEditor() {
           style={button}
           title="redo (Ctrl+Shift+Z)"
           disabled={!history || history.future.length === 0}
-          onClick={() => setHistory((h) => (h ? redo(h) : h))}
+          onClick={() => travel(redo)}
         >
           Redo
         </button>
diff --git a/dotbot/console-web/src/siteEditor/history.test.ts b/dotbot/console-web/src/siteEditor/history.test.ts
index 2e1ef008..6a4ac0cc 100644
--- a/dotbot/console-web/src/siteEditor/history.test.ts
+++ b/dotbot/console-web/src/siteEditor/history.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { HISTORY_LIMIT, record, redo, startHistory, undo } from "./history";
+import { HISTORY_LIMIT, record, redo, seal, startHistory, undo } from "./history";
 
 describe("history", () => {
   it("undoes and redoes one step at a time", () => {
@@ -37,4 +37,10 @@ describe("history", () => {
     for (let i = 1; i <= HISTORY_LIMIT + 10; i += 1) h = record(h, i);
     expect(h.past).toHaveLength(HISTORY_LIMIT);
   });
+
+  it("starts a new step after a seal, even under the same key", () => {
+    let h = record(startHistory(0), 1, "nudge-0");
+    h = record(seal(h), 2, "nudge-0");
+    expect(undo(h).present).toBe(1);
+  });
 });
diff --git a/dotbot/console-web/src/siteEditor/history.ts b/dotbot/console-web/src/siteEditor/history.ts
index a40a78d0..5a0045b6 100644
--- a/dotbot/console-web/src/siteEditor/history.ts
+++ b/dotbot/console-web/src/siteEditor/history.ts
@@ -34,3 +34,8 @@ export function redo<T>(h: History<T>): History<T> {
   if (h.future.length === 0) return h;
   return { past: [...h.past, h.present], present: h.future[0], future: h.future.slice(1), key: null };
 }
+
+/** End the current coalescing run: the next edit is a step of its own. */
+export function seal<T>(h: History<T>): History<T> {
+  return h.key === null ? h : { ...h, key: null };
+}
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index 5a0207e5..4a80ed2d 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -285,4 +285,59 @@ describe("SiteEditor comfort", () => {
     fireEvent.click(box);
     expect(screen.getByTestId("backdrop-calibration-b54cb043")).toBeInTheDocument();
   });
+
+  it("leaves keys typed into a field to the field, but not those on a checkbox", async () => {
+    server(loaded(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    fireEvent.click(screen.getByLabelText("show dev-corner").parentElement!);
+    const x = screen.getByLabelText("x");
+    fireEvent.keyDown(x, { key: "ArrowRight" });
+    fireEvent.keyDown(x, { key: "Delete" });
+    expect(xOf()).toBe(1000);
+    fireEvent.keyDown(screen.getByLabelText("show field"), { key: "ArrowRight" });
+    expect(xOf()).toBe(1050);
+  });
+
+  it("undoes nudges made in two selections as two steps", async () => {
+    server(loaded(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    const select = (name: string) => fireEvent.click(screen.getByLabelText(`show ${name}`).parentElement!);
+    select("dev-corner");
+    fireEvent.keyDown(window, { key: "ArrowRight" });
+    select("field");
+    select("dev-corner");
+    fireEvent.keyDown(window, { key: "ArrowRight" });
+    expect(xOf()).toBe(1100);
+    fireEvent.click(screen.getByText("Undo"));
+    expect(xOf()).toBe(1050);
+  });
+
+  it("drops the selection when an undo puts another area at its place", async () => {
+    server(loaded(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    fireEvent.click(screen.getByLabelText("show field").parentElement!);
+    fireEvent.keyDown(window, { key: "Delete" });
+    fireEvent.click(screen.getByLabelText("show dev-corner").parentElement!);
+    expect(xOf()).toBe(1000);
+    fireEvent.keyDown(window, { key: "z", ctrlKey: true });
+    expect(screen.getByLabelText("show field")).toBeInTheDocument();
+    expect(screen.queryByLabelText("x")).toBeNull();
+  });
+
+  it("reads the backdrops again after a save", async () => {
+    const saved = { ...loaded(), revision: "r2", written: true };
+    const fetch = server(loaded(), { status: 200, body: saved });
+    render(<SiteEditor />);
+    await screen.findByLabelText("show dev-corner");
+    const backdropReads = () => fetch.mock.calls.filter(([url]) => url === "api/backdrops").length;
+    await waitFor(() => expect(backdropReads()).toBe(1));
+    fireEvent.click(screen.getByLabelText("show dev-corner").parentElement!);
+    fireEvent.keyDown(window, { key: "ArrowRight" });
+    fireEvent.click(screen.getByText("Save"));
+    await waitFor(() => expect(backdropReads()).toBe(2));
+    expect(screen.getByText("Undo")).toBeDisabled();
+  });
 });

From c656ee00e3db840672dd28c032ba60798479d416 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:05:10 +0200
Subject: [PATCH 55/80] dotbot/site: read walls and obstacles from site.toml
 and serve them

AI-assisted: Claude Opus 5.5
---
 dotbot/config.py               | 19 +++++++++++++++++++
 dotbot/models.py               | 27 +++++++++++++++++++++++++--
 dotbot/site.py                 | 29 +++++++++++++++++++++++++++++
 dotbot/tests/test_qrkey_app.py |  2 ++
 dotbot/tests/test_server.py    |  4 ++++
 5 files changed, 79 insertions(+), 2 deletions(-)

diff --git a/dotbot/config.py b/dotbot/config.py
index 4a3ee930..5cfe2b72 100644
--- a/dotbot/config.py
+++ b/dotbot/config.py
@@ -168,6 +168,23 @@ class AreaSection(_Strict):
     role: Role | None = None
 
 
+class WallSection(_Strict):
+    """One `[[walls]]` entry: a polyline robots cannot cross, in frame mm."""
+
+    name: str | None = None
+    points: list[tuple[int, int]] = Field(min_length=2)
+
+
+class ObstacleSection(_Strict):
+    """One `[[obstacles]]` entry: a polygon robots cannot enter, in frame mm.
+
+    The last point joins the first.
+    """
+
+    name: str | None = None
+    points: list[tuple[int, int]] = Field(min_length=3)
+
+
 def _is_simulator(conn: str) -> bool:
     return conn.strip().lower() in ("simulator", "sim")
 
@@ -222,6 +239,8 @@ class SiteSection(_Strict):
     stations: dict[str, int] = Field(default_factory=dict)
     # The photodiode's circle when a robot spins in place on this floor
     spin_radius_mm: float | None = Field(default=None, ge=1.0, le=200.0)
+    walls: list[WallSection] = Field(default_factory=list)
+    obstacles: list[ObstacleSection] = Field(default_factory=list)
 
     @model_validator(mode="after")
     def _stations(self) -> SiteSection:
diff --git a/dotbot/models.py b/dotbot/models.py
index 758c6bfb..edce7ac2 100644
--- a/dotbot/models.py
+++ b/dotbot/models.py
@@ -18,7 +18,7 @@
 from dotbot.calibration.points import PointsKind
 from dotbot.protocol import ApplicationType, ControlModeType, WaypointsStatus
 from dotbot.robots import ROBOT_DEFAULT, BodyPose
-from dotbot.site import Site
+from dotbot.site import Obstacle, Site, Wall
 
 # Points of trail the controller keeps per robot
 MAX_TRAIL_SIZE = 1000
@@ -196,6 +196,13 @@ class DotBotAreaModel(BaseModel):
     role: Optional[Role] = None
 
 
+class DotBotBarrierModel(BaseModel):
+    """A wall (a polyline) or an obstacle (a closed polygon), in frame mm."""
+
+    name: str = ""
+    points: List[List[int]]
+
+
 class DotBotPointsFromModel(BaseModel):
     """How a placement's points were chosen: the field's corners, the corners
     of `area`, a `side_mm` square centred in the field, or given by hand."""
@@ -250,7 +257,8 @@ class DotBotSiteModel(BaseModel):
     area experiments and calibration default to (`Site.field`): an area's
     name, an `x,y,w,h` literal for a site with an extent and no areas, or
     None for a site that declares neither. `calibration` is the LH2
-    calibration the controller loaded, if any.
+    calibration the controller loaded, if any. `walls` (polylines) and
+    `obstacles` (closed polygons) are where robots cannot go.
     """
 
     name: str
@@ -260,6 +268,8 @@ class DotBotSiteModel(BaseModel):
     field: Optional[str] = None
     calibration: Optional[DotBotCalibrationSpanModel] = None
     spin_radius_mm: Optional[float] = None
+    walls: List[DotBotBarrierModel] = []
+    obstacles: List[DotBotBarrierModel] = []
 
     @classmethod
     def from_site(cls, site: Site, calibration: Any = None) -> "DotBotSiteModel":
@@ -271,6 +281,14 @@ def from_site(cls, site: Site, calibration: Any = None) -> "DotBotSiteModel":
             areas=[DotBotAreaModel(**a.as_dict()) for a in site.areas.values()],
             field=field.name if field is not None else None,
             spin_radius_mm=site.spin_radius_mm,
+            walls=[
+                DotBotBarrierModel(name=w.name, points=[list(p) for p in w.points])
+                for w in site.walls
+            ],
+            obstacles=[
+                DotBotBarrierModel(name=o.name, points=[list(p) for p in o.points])
+                for o in site.obstacles
+            ],
             calibration=(
                 DotBotCalibrationSpanModel.from_calibration(calibration)
                 if calibration is not None
@@ -289,6 +307,11 @@ def to_site(self) -> Site:
                 a.name: Area(a.x, a.y, a.w, a.h, a.name, a.role) for a in self.areas
             },
             spin_radius_mm=self.spin_radius_mm,
+            walls=[Wall(tuple(tuple(p) for p in w.points), w.name) for w in self.walls],
+            obstacles=[
+                Obstacle(tuple(tuple(p) for p in o.points), o.name)
+                for o in self.obstacles
+            ],
         )
 
 
diff --git a/dotbot/site.py b/dotbot/site.py
index 075b1da1..fb6158db 100644
--- a/dotbot/site.py
+++ b/dotbot/site.py
@@ -36,6 +36,25 @@
 STAGING_DEPTH_MM = 600
 
 
+Point = tuple[int, int]
+
+
+@dataclass(frozen=True)
+class Wall:
+    """A polyline robots cannot cross, in frame mm."""
+
+    points: tuple[Point, ...]
+    name: str = ""
+
+
+@dataclass(frozen=True)
+class Obstacle:
+    """A polygon robots cannot enter, in frame mm; the last point joins the first."""
+
+    points: tuple[Point, ...]
+    name: str = ""
+
+
 @dataclass
 class Site:
     """A site as the config declares it.
@@ -53,6 +72,8 @@ class Site:
     pack: Path | None = None
     # A spin's photodiode radius measured on this floor, if one was
     spin_radius_mm: float | None = None
+    walls: list[Wall] = field(default_factory=list)
+    obstacles: list[Obstacle] = field(default_factory=list)
 
     @property
     def extent(self) -> Area | None:
@@ -174,4 +195,12 @@ def site_from_table(name: str, table: Any, pack: Path | None = None) -> Site:
             )
             for area_name, area in (getattr(table, "areas", None) or {}).items()
         },
+        walls=[
+            Wall(tuple(tuple(p) for p in wall.points), wall.name or "")
+            for wall in getattr(table, "walls", None) or []
+        ],
+        obstacles=[
+            Obstacle(tuple(tuple(p) for p in obstacle.points), obstacle.name or "")
+            for obstacle in getattr(table, "obstacles", None) or []
+        ],
     )
diff --git a/dotbot/tests/test_qrkey_app.py b/dotbot/tests/test_qrkey_app.py
index dfe9a92b..37276f1c 100644
--- a/dotbot/tests/test_qrkey_app.py
+++ b/dotbot/tests/test_qrkey_app.py
@@ -141,4 +141,6 @@ def test_a_site_request_replies_with_the_whole_site(site_client):
         "field": "arena",
         "calibration": None,
         "spin_radius_mm": None,
+        "walls": [],
+        "obstacles": [],
     }
diff --git a/dotbot/tests/test_server.py b/dotbot/tests/test_server.py
index 6dd1adfc..535df7e8 100644
--- a/dotbot/tests/test_server.py
+++ b/dotbot/tests/test_server.py
@@ -1384,6 +1384,8 @@ async def test_get_controller_site():
         "field": "field",
         "calibration": None,
         "spin_radius_mm": None,
+        "walls": [],
+        "obstacles": [],
     }
 
 
@@ -1460,6 +1462,8 @@ async def test_get_controller_site_with_nothing_measured():
         "field": None,
         "calibration": None,
         "spin_radius_mm": None,
+        "walls": [],
+        "obstacles": [],
     }
 
 

From a8b5e7c8d61082fdf6f04975759bcdc6a25052da Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:05:10 +0200
Subject: [PATCH 56/80] dotbot/sim: stop simulated robots at the site's walls
 and obstacles

AI-assisted: Claude Opus 5.5
---
 dotbot/dotbot_simulator.py         |   2 +
 dotbot/sim/barriers.py             |  94 +++++++++++++++++++++++
 dotbot/sim/plant.py                |  19 ++++-
 dotbot/tests/scenario_harness.py   |   5 +-
 dotbot/tests/test_site_barriers.py | 118 +++++++++++++++++++++++++++++
 5 files changed, 235 insertions(+), 3 deletions(-)
 create mode 100644 dotbot/sim/barriers.py
 create mode 100644 dotbot/tests/test_site_barriers.py

diff --git a/dotbot/dotbot_simulator.py b/dotbot/dotbot_simulator.py
index efcb9c44..e04f39de 100644
--- a/dotbot/dotbot_simulator.py
+++ b/dotbot/dotbot_simulator.py
@@ -37,6 +37,7 @@
 from dotbot.logger import LOGGER
 from dotbot.protocol import DIRECTION_NONE
 from dotbot.sim import core as control
+from dotbot.sim.barriers import Barriers
 from dotbot.sim.plant import (
     INITIAL_BATTERY_VOLTAGE,
     FleetPlant,
@@ -506,6 +507,7 @@ def __init__(
             noise_mm=[s.lh2_noise_mm for s in settings],
             rng=np.random.default_rng(random.getrandbits(64)),
             collisions=collisions,
+            barriers=Barriers.from_site(site),
         )
         self.visible = np.ones(count, dtype=bool)
         self.battery = np.full(count, float(INITIAL_BATTERY_VOLTAGE))
diff --git a/dotbot/sim/barriers.py b/dotbot/sim/barriers.py
new file mode 100644
index 00000000..960b9f82
--- /dev/null
+++ b/dotbot/sim/barriers.py
@@ -0,0 +1,94 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""A site's walls and obstacles, as the simulated bodies meet them.
+
+A robot's body is taken as a disc round its outline's centre, which sits
+ahead of the axle midpoint; a pose whose disc crosses a wall or an
+obstacle's edge, or lies inside an obstacle, is blocked.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+
+from dotbot.kinematics import forward
+from dotbot.robots import RobotGeometry, robot_geometry
+
+
+def _segments(polylines: Sequence[np.ndarray], closed: bool) -> np.ndarray:
+    out = []
+    for points in polylines:
+        ends = np.roll(points, -1, axis=0) if closed else points[1:]
+        starts = points if closed else points[:-1]
+        out.append(np.hstack([starts, ends]))
+    return np.vstack(out) if out else np.zeros((0, 4))
+
+
+class Barriers:
+    """Walls (polylines) and obstacles (polygons) in frame mm."""
+
+    def __init__(
+        self,
+        walls: Sequence[Sequence[Sequence[float]]] = (),
+        obstacles: Sequence[Sequence[Sequence[float]]] = (),
+        geometry: RobotGeometry | None = None,
+    ):
+        geometry = geometry or robot_geometry()
+        self.radius_mm = geometry.envelope_mm / 2
+        # The outline's centre, ahead of the axle along the body (board frame
+        # nose toward low y)
+        self.centre_ahead_mm = geometry.axle_midpoint.y - geometry.outline_centre.y
+        self.polygons = [np.asarray(o, dtype=float) for o in obstacles]
+        self.segments = np.vstack(
+            [
+                _segments([np.asarray(w, dtype=float) for w in walls], closed=False),
+                _segments(self.polygons, closed=True),
+            ]
+        )
+
+    def __bool__(self) -> bool:
+        return len(self.segments) > 0
+
+    @classmethod
+    def from_site(cls, site) -> Barriers | None:
+        """The site's barriers, or None when it has none."""
+        if site is None or not (site.walls or site.obstacles):
+            return None
+        return cls([w.points for w in site.walls], [o.points for o in site.obstacles])
+
+    def blocked(self, x, y, heading_deg) -> np.ndarray:
+        """Whether each pose (axle midpoint and heading) meets a barrier."""
+        x = np.atleast_1d(np.asarray(x, dtype=float))
+        y = np.atleast_1d(np.asarray(y, dtype=float))
+        fx, fy = forward(np.atleast_1d(np.asarray(heading_deg, dtype=float)))
+        cx = x + self.centre_ahead_mm * fx
+        cy = y + self.centre_ahead_mm * fy
+        hit = np.zeros(len(cx), dtype=bool)
+        if len(self.segments):
+            ax, ay, bx, by = (self.segments[:, i][None, :] for i in range(4))
+            dx, dy = bx - ax, by - ay
+            length2 = np.maximum(dx * dx + dy * dy, 1e-12)
+            t = np.clip(
+                ((cx[:, None] - ax) * dx + (cy[:, None] - ay) * dy) / length2, 0, 1
+            )
+            gap2 = (cx[:, None] - ax - t * dx) ** 2 + (cy[:, None] - ay - t * dy) ** 2
+            hit |= (gap2 < self.radius_mm**2).any(axis=1)
+        for polygon in self.polygons:
+            hit |= _inside(polygon, cx, cy)
+        return hit
+
+
+def _inside(polygon: np.ndarray, x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    """Even-odd rule for each point against one polygon."""
+    inside = np.zeros(len(x), dtype=bool)
+    px, py = polygon[:, 0], polygon[:, 1]
+    qx, qy = np.roll(px, -1), np.roll(py, -1)
+    for x0, y0, x1, y1 in zip(px, py, qx, qy):
+        crosses = (y0 > y) != (y1 > y)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            at = x0 + (y - y0) * (x1 - x0) / (y1 - y0)
+        inside ^= crosses & (x < at)
+    return inside
diff --git a/dotbot/sim/plant.py b/dotbot/sim/plant.py
index 1d50ab17..06b972a8 100644
--- a/dotbot/sim/plant.py
+++ b/dotbot/sim/plant.py
@@ -54,6 +54,7 @@ def __init__(
         noise_mm=None,
         rng: np.random.Generator = None,
         collisions: bool = True,
+        barriers=None,
     ):
         self.x = np.array(x, dtype=float)
         self.y = np.array(y, dtype=float)
@@ -72,6 +73,8 @@ def __init__(
         self.rng = rng if rng is not None else np.random.default_rng()
         # Whether robots block one another, see `dotbot.sim.collisions`
         self.collisions = collisions
+        # A site's walls and obstacles (`dotbot.sim.barriers`); None: open floor
+        self.barriers = barriers if barriers else None
         self.mm_per_count = robot_geometry().mm_per_count
         self.speed = np.zeros((2, count))
         self.pwm = np.zeros((2, count))
@@ -113,7 +116,21 @@ def step(self, fixes: np.ndarray):
         )
         travel = (self.speed + speed) / 2.0 * TICK_S
         travel[:, self.held] = 0.0
-        pose = move(self.x, self.y, self.heading_deg, travel[0], travel[1])
+        x, y, heading = move(self.x, self.y, self.heading_deg, travel[0], travel[1])
+        if self.barriers is not None:
+            # A body that would meet a barrier stays where it was, its wheels
+            # stalled; one already in contact may still move off it
+            hit = self.barriers.blocked(x, y, heading)
+            if hit.any():
+                hit[hit] = ~self.barriers.blocked(
+                    self.x[hit], self.y[hit], self.heading_deg[hit]
+                )
+                x = np.where(hit, self.x, x)
+                y = np.where(hit, self.y, y)
+                heading = np.where(hit, self.heading_deg, heading)
+                travel[:, hit] = 0.0
+                speed[:, hit] = 0.0
+        pose = (x, y, heading)
         if self.collisions:
             # A robot whose move is refused stalls: its wheels do not turn
             pose, refused = contact.resolve((self.x, self.y, self.heading_deg), pose)
diff --git a/dotbot/tests/scenario_harness.py b/dotbot/tests/scenario_harness.py
index 0e33fb6a..0e0bf99f 100644
--- a/dotbot/tests/scenario_harness.py
+++ b/dotbot/tests/scenario_harness.py
@@ -63,7 +63,7 @@ def robot_states(self):
 class Scenario:
     """A controller and a simulated fleet sharing a stepped clock."""
 
-    def __init__(self, tmp_path, dotbots: List[dict], seed: int = 0):
+    def __init__(self, tmp_path, dotbots: List[dict], seed: int = 0, site=None):
         random.seed(seed)
         world = tmp_path / "world.toml"
         world.write_text(toml.dumps({"dotbots": dotbots}))
@@ -82,10 +82,11 @@ def __init__(self, tmp_path, dotbots: List[dict], seed: int = 0):
                 headless=True,
                 simulator_init_state=str(world),
                 log_output=str(tmp_path / "pydotbot.log"),
+                site=site,
             )
         )
         self.sim = DotBotSimulatorCommunicationInterface(
-            self.controller.handle_received_frame, str(world)
+            self.controller.handle_received_frame, str(world), site=site
         )
         adapter = DotBotSimulatorAdapter(str(world))
         adapter.simulator = self.sim
diff --git a/dotbot/tests/test_site_barriers.py b/dotbot/tests/test_site_barriers.py
new file mode 100644
index 00000000..ff4c0e1b
--- /dev/null
+++ b/dotbot/tests/test_site_barriers.py
@@ -0,0 +1,118 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""A site's walls and obstacles: read from site.toml, served to the console,
+and met by the simulated robots."""
+
+import tomllib
+
+import numpy as np
+import pytest
+
+from dotbot.config import SiteSection
+from dotbot.models import DotBotSiteModel
+from dotbot.sim.barriers import Barriers
+from dotbot.sim.plant import FleetPlant
+from dotbot.site import Obstacle, Site, Wall, site_from_table
+
+SITE_TOML = """\
+anchor = "the door corner"
+extent_mm = [2000, 2000]
+
+[[walls]]   # the long wall
+name = "north"
+points = [[0, 1000], [1000, 1000]]
+
+[[obstacles]]
+name = "pillar"
+points = [[1500, 1500], [1700, 1500], [1700, 1700], [1500, 1700]]
+"""
+
+
+def _site() -> Site:
+    return site_from_table("lab", SiteSection.model_validate(tomllib.loads(SITE_TOML)))
+
+
+def test_walls_and_obstacles_are_read_from_site_toml():
+    site = _site()
+    assert site.walls == [Wall(((0, 1000), (1000, 1000)), "north")]
+    assert site.obstacles == [
+        Obstacle(((1500, 1500), (1700, 1500), (1700, 1700), (1500, 1700)), "pillar")
+    ]
+
+
+@pytest.mark.parametrize(
+    "table, message",
+    [
+        ("[[walls]]\npoints = [[0, 0]]\n", "at least 2"),
+        ("[[obstacles]]\npoints = [[0, 0], [1, 1]]\n", "at least 3"),
+        ("[[walls]]\npoints = [[0, 0], [1, 1]]\nthickness = 3\n", "thickness"),
+    ],
+)
+def test_a_barrier_the_schema_refuses(table, message):
+    with pytest.raises(ValueError, match=message):
+        SiteSection.model_validate(tomllib.loads(table))
+
+
+def test_the_site_route_serves_walls_and_obstacles():
+    model = DotBotSiteModel.from_site(_site())
+    assert model.walls[0].points == [[0, 1000], [1000, 1000]]
+    assert model.obstacles[0].name == "pillar"
+    assert model.to_site().walls == _site().walls
+
+
+def test_a_body_crossing_a_wall_or_inside_an_obstacle_is_blocked():
+    barriers = Barriers.from_site(_site())
+    # Facing +y (heading 0), the body's centre is 24.5 mm ahead of the axle
+    # and its disc 47.5 mm round it
+    assert list(barriers.blocked([500, 500], [920, 930], [0, 0])) == [False, True]
+    assert barriers.blocked(1600, 1600, 90)[0]
+    assert not barriers.blocked(1600, 1300, 0)[0]
+    assert Barriers.from_site(Site(name="open")) is None
+
+
+def test_a_robot_driven_at_a_wall_stops_at_it():
+    plant = FleetPlant(
+        x=[500.0, 1300.0],
+        y=[500.0, 500.0],
+        heading_deg=[0.0, 0.0],
+        barriers=Barriers.from_site(_site()),
+    )
+    plant.pwm[:] = 60.0
+    for _ in range(500):
+        plant.step(np.zeros(2, dtype=bool))
+    # The first meets the wall; the second, past its end, drives on
+    assert 900 < plant.y[0] < 1000 - 47.5 - 24.5 + 1
+    assert plant.y[1] > 1500
+
+
+def test_a_robot_in_contact_may_back_off():
+    plant = FleetPlant(
+        x=[500.0], y=[928.0], heading_deg=[0.0], barriers=Barriers.from_site(_site())
+    )
+    plant.pwm[:] = -60.0
+    for _ in range(100):
+        plant.step(np.zeros(1, dtype=bool))
+    assert plant.y[0] < 900
+
+
+@pytest.mark.scenario
+@pytest.mark.asyncio
+async def test_a_waypoint_behind_a_wall_is_not_reached(tmp_path):
+    from dotbot.tests.scenario_harness import Scenario
+
+    address = "BADCAFE111111111"
+    s = Scenario(
+        tmp_path,
+        [{"address": address, "pos_x": 500, "pos_y": 500, "direction": 0}],
+        site=_site(),
+    )
+    try:
+        await s.run(1.0)
+        await s.waypoints(address, [(500, 1500)], threshold=20)
+        await s.run(15.0)
+        assert s.robots[address].pos_y < 1000 - 47.5 - 24.5 + 1
+        site = (await s.client.get("/controller/site")).json()
+        assert site["walls"][0]["points"] == [[0, 1000], [1000, 1000]]
+    finally:
+        await s.close()

From b4683b365249fbe66217fc291d19154dcae2c081 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:05:10 +0200
Subject: [PATCH 57/80] dotbot/site_editor: patch walls and obstacles in
 site.toml

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py          | 10 +++++
 dotbot/site_toml.py            | 59 ++++++++++++++++++++++++
 dotbot/tests/test_site_toml.py | 82 +++++++++++++++++++++++++++++++++-
 3 files changed, 150 insertions(+), 1 deletion(-)

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index 985765b1..b9612782 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -45,10 +45,20 @@ class AreaModel(BaseModel):
     was: str | None = None
 
 
+class BarrierModel(BaseModel):
+    name: str | None = None
+    points: list[tuple[int, int]]
+    comment: str | None = None
+    # The entry's index in the file when the page loaded it; None for a new one
+    was: int | None = None
+
+
 class SiteModel(BaseModel):
     anchor: str | None = None
     extent_mm: tuple[int, int] | None = None
     areas: list[AreaModel] = Field(default_factory=list)
+    walls: list[BarrierModel] = Field(default_factory=list)
+    obstacles: list[BarrierModel] = Field(default_factory=list)
 
 
 class SaveRequest(BaseModel):
diff --git a/dotbot/site_toml.py b/dotbot/site_toml.py
index f5c52aaa..96aefac9 100644
--- a/dotbot/site_toml.py
+++ b/dotbot/site_toml.py
@@ -22,6 +22,8 @@
 from dotbot.config import SiteSection
 
 AREA_KEYS = ("x", "y", "w", "h")
+# The arrays of tables of barriers, and the fewest points each entry takes
+BARRIERS = {"walls": 2, "obstacles": 3}
 
 
 class SiteTomlError(ValueError):
@@ -72,9 +74,24 @@ def site_model(doc: TOMLDocument) -> dict[str, Any]:
         "extent_mm": [int(v) for v in extent] if extent is not None else None,
         "areas": areas,
         "connection": dict(connection) if connection is not None else None,
+        **{key: _barriers_model(doc, key) for key in BARRIERS},
     }
 
 
+def _barriers_model(doc: TOMLDocument, key: str) -> list[dict[str, Any]]:
+    items = doc.get(key)
+    if not isinstance(items, AoT):
+        return []
+    return [
+        {
+            "name": item.get("name"),
+            "points": [[int(x), int(y)] for x, y in item["points"]],
+            "comment": _comment(item),
+        }
+        for item in items
+    ]
+
+
 def _set(container: Any, key: str, value: Any) -> None:
     """Assign `value` unless it is already there; None removes the key."""
     if value is None:
@@ -270,6 +287,45 @@ def _normal(model: dict[str, Any]) -> dict[str, Any]:
     }
 
 
+def _patch_barriers(doc: TOMLDocument, key: str, items: list[dict[str, Any]]) -> None:
+    """Write one array of tables; an entry's `was` is its index in the file."""
+    least = BARRIERS[key]
+    for item in items:
+        if len(item.get("points") or []) < least:
+            raise SiteTomlError(f"each of {key} needs at least {least} points")
+    table = doc.get(key)
+    if not isinstance(table, AoT):
+        if not items:
+            return
+        table = tomlkit.aot()
+        if not tomlkit.dumps(doc).endswith("\n\n"):
+            doc.add(tomlkit.nl())
+        doc[key] = table
+    kept = sorted({item["was"] for item in items if item.get("was") is not None})
+    if any(was >= len(table) for was in kept):
+        raise SiteTomlError(f"{key} changed in the file since the page loaded it")
+    for index in sorted(set(range(len(table))) - set(kept), reverse=True):
+        del table[index]
+    position = {was: k for k, was in enumerate(kept)}
+    for item in items:
+        points = [[int(x), int(y)] for x, y in item["points"]]
+        if item.get("was") is None:
+            entry = tomlkit.table()
+            if item.get("name"):
+                entry["name"] = item["name"]
+            entry["points"] = points
+            _set_comment(entry, item.get("comment"))
+            table.append(entry)
+            continue
+        entry = table[position[item["was"]]]
+        _set(entry, "name", item.get("name") or None)
+        if [[int(x), int(y)] for x, y in entry["points"]] != points:
+            entry["points"] = points
+        _set_comment(entry, item.get("comment"))
+    if not table:
+        del doc[key]
+
+
 def patch(doc: TOMLDocument, model: dict[str, Any]) -> TOMLDocument:
     """Write `model` into `doc` in place, changing only what differs.
 
@@ -290,6 +346,9 @@ def patch(doc: TOMLDocument, model: dict[str, Any]) -> TOMLDocument:
         array.clear()
         array.extend(int(v) for v in extent)
     _patch_areas(doc, areas)
+    for key in BARRIERS:
+        if key in model:
+            _patch_barriers(doc, key, model[key] or [])
     return doc
 
 
diff --git a/dotbot/tests/test_site_toml.py b/dotbot/tests/test_site_toml.py
index 3870c70d..9ffe2e34 100644
--- a/dotbot/tests/test_site_toml.py
+++ b/dotbot/tests/test_site_toml.py
@@ -67,14 +67,36 @@
 """
 
 
+WALLED = (
+    ARENA
+    + """
+[[walls]]   # the door wall
+name = "door"
+points = [[0, 0], [0, 4000]]
+
+[[walls]]
+points = [[2000, 0], [2000, 4000]]   # the far wall
+
+[[obstacles]]
+name = "pillar"
+points = [[1500, 2500], [1700, 2500], [1700, 2700]]
+"""
+)
+
+
 def _loaded(text):
     model = site_model(tomlkit.parse(text))
     for area in model["areas"]:
         area["was"] = area["name"]
+    for key in site_toml.BARRIERS:
+        for index, item in enumerate(model[key]):
+            item["was"] = index
     return model
 
 
-@pytest.mark.parametrize("text", [ARENA, HALL, INLINE, default_site_toml((2000, 2000))])
+@pytest.mark.parametrize(
+    "text", [ARENA, HALL, INLINE, WALLED, default_site_toml((2000, 2000))]
+)
 def test_an_unchanged_model_writes_the_file_back_byte_for_byte(text):
     assert patched_text(text, _loaded(text)) == text
 
@@ -327,3 +349,61 @@ def test_two_areas_can_swap_names():
         "# Staging: the strip below.",
         "# Second line.",
     ]
+
+
+def test_walls_and_obstacles_are_modelled_with_their_comments():
+    model = _loaded(WALLED)
+    assert [(w["name"], w["points"], w["comment"]) for w in model["walls"]] == [
+        ("door", [[0, 0], [0, 4000]], "the door wall"),
+        (None, [[2000, 0], [2000, 4000]], None),
+    ]
+    assert model["obstacles"][0]["points"][2] == [1700, 2700]
+
+
+def test_moving_a_wall_point_changes_that_point_only():
+    model = _loaded(WALLED)
+    model["walls"][1]["points"][1] = [2000, 3500]
+    result = patched_text(WALLED, model)
+    assert result == WALLED.replace(
+        "points = [[2000, 0], [2000, 4000]]   # the far wall",
+        "points = [[2000, 0], [2000, 3500]]   # the far wall",
+    )
+
+
+def test_a_barrier_is_added_and_one_deleted_keeping_the_others():
+    model = _loaded(WALLED)
+    del model["walls"][0]
+    model["obstacles"].append(
+        {"name": "box", "points": [[100, 100], [300, 100], [300, 300]], "was": None}
+    )
+    result = patched_text(WALLED, model)
+    assert "# the door wall" not in result and "# the far wall" in result
+    back = site_model(tomlkit.parse(result))
+    assert [o["name"] for o in back["obstacles"]] == ["pillar", "box"]
+    assert len(back["walls"]) == 1
+
+
+def test_the_first_wall_of_a_pack_and_the_last_removed():
+    model = _loaded(ARENA)
+    model["walls"] = [{"points": [[0, 0], [100, 0]], "was": None}]
+    walled = patched_text(ARENA, model)
+    assert walled.startswith(ARENA) and "[[walls]]" in walled
+    model = _loaded(walled)
+    model["walls"] = []
+    assert patched_text(walled, model).rstrip() == ARENA.rstrip()
+
+
+def test_a_barrier_with_too_few_points_is_refused():
+    model = _loaded(WALLED)
+    model["obstacles"][0]["points"] = [[0, 0], [1, 1]]
+    with pytest.raises(SiteTomlError, match="at least 3"):
+        patched_text(WALLED, model)
+
+
+def test_a_new_array_of_tables_starts_after_a_blank_line():
+    model = _loaded(INLINE)
+    model["walls"] = [{"points": [[0, 0], [100, 0]], "was": None}]
+    model["obstacles"] = [{"points": [[0, 0], [100, 0], [0, 100]], "was": None}]
+    result = patched_text(INLINE, model)
+    assert "500 }\n\n[[walls]]" in result
+    assert "\n\n[[obstacles]]" in result

From fa4b9cbd71c47861cbc92eb371013b4a67bf413d Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:05:10 +0200
Subject: [PATCH 58/80] dotbot/console-web: draw the site's walls and obstacles
 on the map

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/MapView.tsx           | 29 ++++++++++++
 dotbot/console-web/src/barrierLayer.test.tsx | 50 ++++++++++++++++++++
 dotbot/console-web/src/types.ts              |  9 ++++
 3 files changed, 88 insertions(+)
 create mode 100644 dotbot/console-web/src/barrierLayer.test.tsx

diff --git a/dotbot/console-web/src/MapView.tsx b/dotbot/console-web/src/MapView.tsx
index 29ad6b25..b341f2f1 100644
--- a/dotbot/console-web/src/MapView.tsx
+++ b/dotbot/console-web/src/MapView.tsx
@@ -1214,6 +1214,35 @@ export const MapView: React.FC<MapViewProps> = (props) => {
                 <title>{a.name}</title>
               </rect>
             ))}
+            {/* The site's walls and obstacles, solid: they are the floor's,
+                not a view of it. */}
+            {(props.site?.obstacles ?? []).map((o, i) => (
+              <polygon
+                key={`obstacle-${i}`}
+                data-testid={`obstacle-${o.name || i}`}
+                points={pointsPx(o.points)}
+                fill="var(--muted)"
+                fillOpacity={0.35}
+                stroke="var(--text)"
+                strokeWidth={chrome}
+              >
+                <title>{o.name || "obstacle"}</title>
+              </polygon>
+            ))}
+            {(props.site?.walls ?? []).map((w, i) => (
+              <polyline
+                key={`wall-${i}`}
+                data-testid={`wall-${w.name || i}`}
+                points={pointsPx(w.points)}
+                fill="none"
+                stroke="var(--text)"
+                strokeWidth={3 * chrome}
+                strokeLinecap="round"
+                strokeLinejoin="round"
+              >
+                <title>{w.name || "wall"}</title>
+              </polyline>
+            ))}
             {/* The loaded calibration: each placement's span outlined, and
                 the rest of the site hatched, where positions are
                 extrapolated. The hatch is the site masked by the spans, so
diff --git a/dotbot/console-web/src/barrierLayer.test.tsx b/dotbot/console-web/src/barrierLayer.test.tsx
new file mode 100644
index 00000000..b6cad998
--- /dev/null
+++ b/dotbot/console-web/src/barrierLayer.test.tsx
@@ -0,0 +1,50 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+import { MapView } from "./MapView";
+import type { Site } from "./types";
+
+const SITE: Site = {
+  name: "c405-arena",
+  anchor: "",
+  extent_mm: [2000, 4000],
+  areas: [],
+  walls: [{ name: "door", points: [[0, 0], [0, 4000]] }],
+  obstacles: [{ name: "", points: [[1500, 2500], [1700, 2500], [1700, 2700]] }],
+};
+
+describe("MapView barriers", () => {
+  it("draws the site's walls and obstacles", () => {
+    render(
+      <MapView
+        bots={[]}
+        viewport={{ x: -500, y: -500, w: 3000, h: 5000 }}
+        siteAreas={[]}
+        hiddenAreas={new Set()}
+        siteExtent={{ x: 0, y: 0, w: 2000, h: 4000, name: SITE.name }}
+        selection={new Set()}
+        layers={{
+          batteryBars: true,
+          waypoints: true,
+          hotSpots: false,
+          dotBots: true,
+          trails: false,
+          crashedOnly: false,
+          lostBots: false,
+          allWaypoints: false,
+          calibratedSpan: true,
+        }}
+        plannedMissions={[]}
+        cam={{ scale: 1, tx: 0, ty: 0 }}
+        setCam={() => {}}
+        onGeom={() => {}}
+        onSelect={() => {}}
+        onAddWaypoint={() => {}}
+        site={SITE}
+        onZoom={() => {}}
+      />,
+    );
+    expect(screen.getByTestId("wall-door").getAttribute("points")?.split(" ")).toHaveLength(2);
+    expect(screen.getByTestId("obstacle-0").getAttribute("points")?.split(" ")).toHaveLength(3);
+  });
+});
diff --git a/dotbot/console-web/src/types.ts b/dotbot/console-web/src/types.ts
index a15405f6..0618cf76 100644
--- a/dotbot/console-web/src/types.ts
+++ b/dotbot/console-web/src/types.ts
@@ -448,6 +448,15 @@ export interface Site {
   areas: Area[];
   field?: string | null;
   calibration?: SiteCalibration | null;
+  walls?: Barrier[];
+  obstacles?: Barrier[];
+}
+
+// Where robots cannot go, in frame mm: a wall is a polyline, an obstacle a
+// polygon whose last point joins its first.
+export interface Barrier {
+  name: string;
+  points: [number, number][];
 }
 
 // The LH2 calibration the controller loaded: each placement's points in

From ea280dd9054b34862ef864872d01af466f84e188 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:05:10 +0200
Subject: [PATCH 59/80] dotbot/console-web: draw and edit walls and obstacles
 in the site editor

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/siteEditor/Canvas.tsx  | 171 +++++++++++++++++-
 .../console-web/src/siteEditor/Inspector.tsx  | 137 +++++++++++++-
 .../console-web/src/siteEditor/SiteEditor.tsx |  69 ++++++-
 dotbot/console-web/src/siteEditor/api.ts      |   9 +-
 .../console-web/src/siteEditor/edit.test.ts   |  30 +++
 dotbot/console-web/src/siteEditor/edit.ts     |  47 ++++-
 .../src/siteEditor/siteEditor.test.tsx        |  49 ++++-
 dotbot/console-web/src/siteEditor/types.ts    |  13 ++
 8 files changed, 505 insertions(+), 20 deletions(-)

diff --git a/dotbot/console-web/src/siteEditor/Canvas.tsx b/dotbot/console-web/src/siteEditor/Canvas.tsx
index e87300a9..e9fab655 100644
--- a/dotbot/console-web/src/siteEditor/Canvas.tsx
+++ b/dotbot/console-web/src/siteEditor/Canvas.tsx
@@ -16,17 +16,32 @@ import {
 } from "../grid";
 import type { Area } from "../types";
 import { FRAME_CAMERA, viewGeom } from "../zoom";
-import { HANDLES, effectiveRole, moveRect, rectFromDrag, resizeRect, snap } from "./edit";
+import { BARRIER_MIN_POINTS, HANDLES, effectiveRole, finishPoints, movePoints, moveRect, rectFromDrag, resizeRect, snap } from "./edit";
 import type { Handle, Rect } from "./edit";
 import { applyMove, movedBox, movedCorners, snapAngle, turnAbout } from "./rigid";
 import type { Point, Rigid2D } from "./rigid";
-import type { CalibrationBackdrop, CalibrationOverlay, CameraBackdrop, EditArea } from "./types";
+import type {
+  BarrierKind,
+  CalibrationBackdrop,
+  CalibrationOverlay,
+  CameraBackdrop,
+  EditArea,
+  EditBarrier,
+} from "./types";
 
 // The site drawn to scale: the extent, the metric grid and its rulers, and
 // every area in its role colour. Areas are moved, resized and drawn here; the
 // numbers themselves live in the inspector.
 
-export type Tool = "select" | "area" | "calibration";
+export type Tool = "select" | "area" | "calibration" | "wall" | "obstacle";
+
+/** A selected wall or obstacle. */
+export interface BarrierRef {
+  kind: BarrierKind;
+  index: number;
+}
+
+const TOOL_KIND: Partial<Record<Tool, BarrierKind>> = { wall: "walls", obstacle: "obstacles" };
 
 /** A calibration drawn over the site, and the move that places it. */
 export interface Placement {
@@ -48,6 +63,8 @@ type Drag =
   | { kind: "resize"; index: number; start: Rect; handle: Handle }
   | { kind: "draw"; from: { x: number; y: number }; to: { x: number; y: number } }
   | { kind: "place-move"; start: Rigid2D; from: { x: number; y: number } }
+  | { kind: "barrier-move"; ref: BarrierRef; start: [number, number][]; from: { x: number; y: number } }
+  | { kind: "barrier-vertex"; ref: BarrierRef; vertex: number }
   | { kind: "place-turn"; start: Rigid2D; pivot: Point; angle: number };
 
 export interface CanvasProps {
@@ -63,6 +80,13 @@ export interface CanvasProps {
   onDraw: (rect: Rect) => void;
   placement?: Placement | null;
   onPlacement?: (move: Rigid2D) => void;
+  walls?: EditBarrier[];
+  obstacles?: EditBarrier[];
+  selectedBarrier?: BarrierRef | null;
+  onSelectBarrier?: (ref: BarrierRef | null) => void;
+  /** `key` names the gesture, so one drag undoes as one step. */
+  onBarrierChange?: (ref: BarrierRef, points: [number, number][], key: string) => void;
+  onBarrierDraw?: (kind: BarrierKind, points: [number, number][]) => void;
   /** Read-only layers under the areas: only the ones switched on. */
   backdrops?: { calibrations: CalibrationBackdrop[]; cameras: CameraBackdrop[] };
 }
@@ -89,6 +113,33 @@ export function Canvas(props: CanvasProps) {
   const [size, setSize] = useState({ w: 800, h: 600 });
   const [drag, setDrag] = useState<Drag | null>(null);
   const [altHeld, setAltHeld] = useState(false);
+  // A wall or obstacle being drawn, point by point, and where the pointer is
+  const [draft, setDraft] = useState<{ kind: BarrierKind; points: [number, number][] } | null>(null);
+  const [hover, setHover] = useState<[number, number] | null>(null);
+  const draftKind = TOOL_KIND[props.tool] ?? null;
+
+  useEffect(() => {
+    if (!draftKind) setDraft(null);
+  }, [draftKind]);
+
+  const finishDraft = () => {
+    if (!draft) return;
+    const points = finishPoints(draft.points);
+    if (points.length >= BARRIER_MIN_POINTS[draft.kind]) props.onBarrierDraw?.(draft.kind, points);
+    setDraft(null);
+  };
+
+  useEffect(() => {
+    if (!draft) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Enter") finishDraft();
+      else if (e.key === "Escape") setDraft(null);
+      else return;
+      e.stopPropagation();
+    };
+    window.addEventListener("keydown", onKey, true);
+    return () => window.removeEventListener("keydown", onKey, true);
+  });
 
   useEffect(() => {
     const el = wrapRef.current;
@@ -148,14 +199,35 @@ export function Canvas(props: CanvasProps) {
 
   const onBackgroundDown = (e: React.PointerEvent) => {
     if (e.button !== 0) return;
+    if (draftKind) {
+      const p = toFrame(e);
+      const s = snapNow(e);
+      const point: [number, number] = [snap(p.x, s), snap(p.y, s)];
+      setDraft((d) => (d && d.kind === draftKind ? { ...d, points: [...d.points, point] } : { kind: draftKind, points: [point] }));
+      return;
+    }
     if (props.tool === "area") {
       const p = toFrame(e);
       begin(e, { kind: "draw", from: p, to: p });
     } else {
       props.onSelect(null);
+      props.onSelectBarrier?.(null);
     }
   };
 
+  const onBarrierDown = (e: React.PointerEvent, ref: BarrierRef) => {
+    if (e.button !== 0 || props.tool !== "select") return;
+    const b = (ref.kind === "walls" ? props.walls : props.obstacles)?.[ref.index];
+    if (!b) return;
+    props.onSelectBarrier?.(ref);
+    begin(e, { kind: "barrier-move", ref, start: b.points, from: toFrame(e) });
+  };
+
+  const onVertexDown = (e: React.PointerEvent, ref: BarrierRef, vertex: number) => {
+    if (e.button !== 0) return;
+    begin(e, { kind: "barrier-vertex", ref, vertex });
+  };
+
   const onAreaDown = (e: React.PointerEvent, index: number) => {
     if (e.button !== 0 || props.tool !== "select") return;
     const a = props.areas[index];
@@ -196,10 +268,23 @@ export function Canvas(props: CanvasProps) {
 
   const onMove = (e: React.PointerEvent) => {
     setAltHeld(e.altKey);
+    if (draft) {
+      const p = toFrame(e);
+      const s = snapNow(e);
+      setHover([snap(p.x, s), snap(p.y, s)]);
+    }
     if (!drag) return;
     const p = toFrame(e);
     const s = snapNow(e);
-    if (drag.kind === "place-move") {
+    if (drag.kind === "barrier-move") {
+      props.onBarrierChange?.(drag.ref, movePoints(drag.start, p.x - drag.from.x, p.y - drag.from.y, s), `canvas-${gesture.current}`);
+    } else if (drag.kind === "barrier-vertex") {
+      const b = (drag.ref.kind === "walls" ? props.walls : props.obstacles)?.[drag.ref.index];
+      if (b) {
+        const points = b.points.map((q, i): [number, number] => (i === drag.vertex ? [snap(p.x, s), snap(p.y, s)] : q));
+        props.onBarrierChange?.(drag.ref, points, `canvas-${gesture.current}`);
+      }
+    } else if (drag.kind === "place-move") {
       const dx = snap(drag.start.dx_mm + p.x - drag.from.x, s);
       const dy = snap(drag.start.dy_mm + p.y - drag.from.y, s);
       props.onPlacement?.({ ...drag.start, dx_mm: dx, dy_mm: dy });
@@ -248,6 +333,7 @@ export function Canvas(props: CanvasProps) {
       onPointerMove={onMove}
       onPointerUp={onUp}
       onPointerCancel={() => setDrag(null)}
+      onDoubleClick={finishDraft}
       style={{
         position: "relative",
         flex: 1,
@@ -255,7 +341,7 @@ export function Canvas(props: CanvasProps) {
         minHeight: 0,
         overflow: "hidden",
         background: "var(--canvas)",
-        cursor: props.tool === "area" ? "crosshair" : "default",
+        cursor: props.tool === "area" || draftKind ? "crosshair" : "default",
         touchAction: "none",
         userSelect: "none",
       }}
@@ -375,6 +461,77 @@ export function Canvas(props: CanvasProps) {
             </g>
           );
         })}
+        {(["obstacles", "walls"] as BarrierKind[]).map((kind) =>
+          ((kind === "walls" ? props.walls : props.obstacles) ?? []).map((b, i) => {
+            const ref = { kind, index: i };
+            const chosen = props.selectedBarrier?.kind === kind && props.selectedBarrier.index === i;
+            const pts = b.points.map(([x, y]) => `${px("x", x)},${px("y", y)}`).join(" ");
+            const common = {
+              points: pts,
+              stroke: chosen ? "var(--accent)" : "var(--text)",
+              style: { cursor: props.tool === "select" ? "move" : undefined },
+              onPointerDown: (e: React.PointerEvent) => onBarrierDown(e, ref),
+            };
+            return kind === "walls" ? (
+              <polyline
+                key={`w${i}`}
+                data-testid={`edit-wall-${i}`}
+                {...common}
+                fill="none"
+                strokeWidth={chosen ? 5 : 4}
+                strokeLinecap="round"
+                strokeLinejoin="round"
+              >
+                <title>{b.name || `wall ${i + 1}`}</title>
+              </polyline>
+            ) : (
+              <polygon
+                key={`o${i}`}
+                data-testid={`edit-obstacle-${i}`}
+                {...common}
+                fill="var(--muted)"
+                fillOpacity={0.35}
+                strokeWidth={chosen ? 2.5 : 1.5}
+              >
+                <title>{b.name || `obstacle ${i + 1}`}</title>
+              </polygon>
+            );
+          }),
+        )}
+        {props.selectedBarrier && props.tool === "select" &&
+          ((props.selectedBarrier.kind === "walls" ? props.walls : props.obstacles) ?? [])[props.selectedBarrier.index]?.points.map(
+            ([x, y], v) => (
+              <rect
+                key={`v${v}`}
+                data-testid={`vertex-${v}`}
+                x={px("x", x) - HANDLE_PX / 2}
+                y={px("y", y) - HANDLE_PX / 2}
+                width={HANDLE_PX}
+                height={HANDLE_PX}
+                fill="var(--surface)"
+                stroke="var(--accent)"
+                strokeWidth={1.2}
+                style={{ cursor: "move" }}
+                onPointerDown={(e) => onVertexDown(e, props.selectedBarrier!, v)}
+              />
+            ),
+          )}
+        {draft && (
+          <g data-testid="barrier-draft" style={{ pointerEvents: "none" }}>
+            <polyline
+              points={[...draft.points, ...(hover ? [hover] : []), ...(draft.kind === "obstacles" && draft.points.length > 1 ? [draft.points[0]] : [])]
+                .map(([x, y]) => `${px("x", x)},${px("y", y)}`)
+                .join(" ")}
+              fill="none"
+              stroke="var(--accent)"
+              strokeWidth={2}
+              strokeDasharray="5 4"
+            />
+            {draft.points.map(([x, y], k) => (
+              <circle key={k} cx={px("x", x)} cy={px("y", y)} r={3} fill="var(--accent)" />
+            ))}
+          </g>
+        )}
         {placement && fence && placedBox && placeCentre && (
           <g data-testid="placement">
             {placement.overlay.stations.map((st, k) => {
@@ -559,7 +716,9 @@ export function Canvas(props: CanvasProps) {
           pointerEvents: "none",
         }}
       >
-        {altHeld
+        {draftKind
+          ? `click to add points, double-click or Enter to finish, Esc to cancel; snap ${props.snapMm} mm, Alt for free`
+          : altHeld
           ? "free placement (Alt)"
           : props.tool === "calibration"
             ? `snap ${props.snapMm} mm and 90 deg, Alt for free; scale is locked`
diff --git a/dotbot/console-web/src/siteEditor/Inspector.tsx b/dotbot/console-web/src/siteEditor/Inspector.tsx
index f0e7a38d..766e3e16 100644
--- a/dotbot/console-web/src/siteEditor/Inspector.tsx
+++ b/dotbot/console-web/src/siteEditor/Inspector.tsx
@@ -1,9 +1,10 @@
-import React from "react";
+import React, { useState } from "react";
 
 import type { AreaRole } from "../types";
-import { ROLES, declaredRole, effectiveRole } from "./edit";
+import type { BarrierRef } from "./Canvas";
+import { BARRIER_MIN_POINTS, ROLES, declaredRole, effectiveRole, parsePoints } from "./edit";
 import type { Issue } from "./edit";
-import type { Backdrops, EditArea, SiteModel } from "./types";
+import type { Backdrops, BarrierKind, EditArea, EditBarrier, SiteModel } from "./types";
 
 // The right pane: every field is a key of site.toml, and what it shows is
 // what Save writes.
@@ -74,12 +75,95 @@ export interface InspectorProps {
   onAdd: () => void;
   /** Shown at the top of the pane, for a tool with its own controls. */
   extra?: React.ReactNode;
+  selectedBarrier?: BarrierRef | null;
+  onSelectBarrier?: (ref: BarrierRef | null) => void;
+  onBarrier?: (ref: BarrierRef, patch: Partial<EditBarrier>, key: string) => void;
+  onDeleteBarrier?: (ref: BarrierRef) => void;
   backdrops?: Backdrops | null;
   /** Keys `cal:<id8>` and `cam:<id8>` of the backdrops switched on. */
   shownBackdrops?: Set<string>;
   onToggleBackdrop?: (key: string) => void;
 }
 
+const KIND_LABEL: Record<BarrierKind, string> = { walls: "wall", obstacles: "obstacle" };
+
+function BarrierInspector(props: {
+  barrier: EditBarrier;
+  kind: BarrierKind;
+  index: number;
+  onChange: (patch: Partial<EditBarrier>, key: string) => void;
+  onDelete: () => void;
+}) {
+  const { barrier, kind } = props;
+  const shown = barrier.points.map(([x, y]) => `${x}, ${y}`).join("\n");
+  const [text, setText] = useState(shown);
+  const [editing, setEditing] = useState(false);
+  const parsed = parsePoints(text);
+  const tooFew = !!parsed && parsed.length < BARRIER_MIN_POINTS[kind];
+  return (
+    <div style={section} data-testid="barrier-inspector">
+      <div style={heading}>{KIND_LABEL[kind]}</div>
+      <label>
+        <span style={label}>name (optional)</span>
+        <input
+          aria-label="barrier name"
+          value={barrier.name ?? ""}
+          onChange={(e) => props.onChange({ name: e.target.value || null }, `barrier-name`)}
+          style={input}
+        />
+      </label>
+      <label>
+        <span style={label}>points, x, y in mm, one per line{kind === "obstacles" ? " (the last joins the first)" : ""}</span>
+        <textarea
+          aria-label="barrier points"
+          rows={Math.min(10, barrier.points.length + 1)}
+          value={editing ? text : shown}
+          onFocus={() => {
+            setText(shown);
+            setEditing(true);
+          }}
+          onBlur={() => setEditing(false)}
+          onChange={(e) => {
+            setText(e.target.value);
+            const points = parsePoints(e.target.value);
+            if (points && points.length >= BARRIER_MIN_POINTS[kind]) props.onChange({ points }, "barrier-points");
+          }}
+          style={{ ...input, resize: "vertical" }}
+        />
+      </label>
+      {editing && (!parsed || tooFew) && (
+        <div style={{ fontSize: 11, color: "var(--s-Stopping)", marginTop: 4 }}>
+          {!parsed ? "each line is two numbers, x and y" : `a ${KIND_LABEL[kind]} takes at least ${BARRIER_MIN_POINTS[kind]} points`}
+        </div>
+      )}
+      <label>
+        <span style={label}>comment (kept in the file)</span>
+        <input
+          aria-label="barrier comment"
+          value={barrier.comment ?? ""}
+          onChange={(e) => props.onChange({ comment: e.target.value }, "barrier-comment")}
+          style={{ ...input, fontFamily: "var(--font-ui)" }}
+        />
+      </label>
+      <button
+        type="button"
+        onClick={props.onDelete}
+        style={{
+          marginTop: 12,
+          background: "transparent",
+          color: "var(--accent)",
+          border: "1px solid var(--accent)",
+          borderRadius: 4,
+          padding: "4px 10px",
+          cursor: "pointer",
+        }}
+      >
+        Delete {KIND_LABEL[kind]}
+      </button>
+    </div>
+  );
+}
+
 export function Inspector(props: InspectorProps) {
   const { site } = props;
   const area = props.selected !== null ? site.areas[props.selected] : null;
@@ -208,6 +292,19 @@ export function Inspector(props: InspectorProps) {
         </div>
       )}
 
+      {props.selectedBarrier && site[props.selectedBarrier.kind]?.[props.selectedBarrier.index] && (
+        <BarrierInspector
+          key={`${props.selectedBarrier.kind}-${props.selectedBarrier.index}`}
+          kind={props.selectedBarrier.kind}
+          index={props.selectedBarrier.index}
+          barrier={site[props.selectedBarrier.kind]![props.selectedBarrier.index]}
+          onChange={(patch, key) =>
+            props.onBarrier?.(props.selectedBarrier!, patch, `${key}-${props.selectedBarrier!.kind}-${props.selectedBarrier!.index}`)
+          }
+          onDelete={() => props.onDeleteBarrier?.(props.selectedBarrier!)}
+        />
+      )}
+
       <div style={section}>
         <div style={{ display: "flex", alignItems: "center" }}>
           <div style={{ ...heading, flex: 1 }}>Areas</div>
@@ -257,6 +354,40 @@ export function Inspector(props: InspectorProps) {
         ))}
       </div>
 
+      {((site.walls ?? []).length > 0 || (site.obstacles ?? []).length > 0) && (
+        <div style={section} data-testid="barriers">
+          <div style={heading}>Walls and obstacles</div>
+          {(["walls", "obstacles"] as BarrierKind[]).flatMap((kind) =>
+            (site[kind] ?? []).map((b, i) => {
+              const chosen = props.selectedBarrier?.kind === kind && props.selectedBarrier.index === i;
+              return (
+                <div
+                  key={`${kind}-${i}`}
+                  onClick={() => props.onSelectBarrier?.({ kind, index: i })}
+                  style={{
+                    display: "flex",
+                    gap: 6,
+                    padding: "4px 6px",
+                    marginTop: 4,
+                    borderRadius: 4,
+                    background: chosen ? "var(--elevated)" : "transparent",
+                    cursor: "pointer",
+                    fontSize: 12,
+                  }}
+                >
+                  <span style={{ flex: 1, fontFamily: "var(--font-mono)" }}>
+                    {b.name || `${KIND_LABEL[kind]} ${i + 1}`}
+                  </span>
+                  <span style={{ color: "var(--muted)", fontSize: 11 }}>
+                    {KIND_LABEL[kind]}, {b.points.length} points
+                  </span>
+                </div>
+              );
+            }),
+          )}
+        </div>
+      )}
+
       {props.backdrops && (props.backdrops.calibrations.length > 0 || props.backdrops.cameras.length > 0) && (
         <div style={section} data-testid="backdrops">
           <div style={heading}>Backdrops (read-only)</div>
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index c8287e30..d3614f40 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -14,7 +14,7 @@ import {
 } from "./api";
 import { CalibrationPanel } from "./CalibrationPanel";
 import { Canvas } from "./Canvas";
-import type { Placement, Tool } from "./Canvas";
+import type { BarrierRef, Placement, Tool } from "./Canvas";
 import {
   SNAP_DEFAULT_MM,
   SNAP_STEPS_MM,
@@ -30,6 +30,7 @@ import { Inspector } from "./Inspector";
 import { IDENTITY } from "./rigid";
 import type {
   Backdrops,
+  BarrierKind,
   CalibrationListing,
   EditArea,
   PlacedCalibration,
@@ -68,12 +69,12 @@ const button: React.CSSProperties = {
   fontFamily: "var(--font-ui)",
 };
 
-const TOOLS: { key: Tool | "wall" | "obstacle" | "charger"; label: string; hint: string }[] = [
+const TOOLS: { key: Tool | "charger"; label: string; hint: string }[] = [
   { key: "select", label: "Select", hint: "V: select, move and resize" },
   { key: "area", label: "Area", hint: "A: drag out a new area" },
   { key: "calibration", label: "Calibration", hint: "C: place a spin calibration on the site" },
-  { key: "wall", label: "Wall", hint: "needs a walls table in site.toml first" },
-  { key: "obstacle", label: "Obstacle", hint: "needs an obstacles table in site.toml first" },
+  { key: "wall", label: "Wall", hint: "W: click the points of a wall, double-click to finish" },
+  { key: "obstacle", label: "Obstacle", hint: "O: click the corners of an obstacle, double-click to finish" },
   { key: "charger", label: "Charger", hint: "needs an objects table in site.toml first" },
 ];
 
@@ -98,7 +99,18 @@ export function SiteEditor() {
       const value = typeof next === "function" ? next(h.present) : next;
       return JSON.stringify(value) === JSON.stringify(h.present) ? h : record(h, value, key);
     });
-  const [selected, setSelected] = useState<number | null>(null);
+  const [selectedArea, setSelectedArea] = useState<number | null>(null);
+  const [selectedBarrier, setSelectedBarrier] = useState<BarrierRef | null>(null);
+  const selected = selectedArea;
+  // One thing is selected at a time: an area or a barrier
+  const setSelected = (index: number | null) => {
+    setSelectedArea(index);
+    if (index !== null) setSelectedBarrier(null);
+  };
+  const selectBarrier = (ref: BarrierRef | null) => {
+    setSelectedBarrier(ref);
+    if (ref !== null) setSelectedArea(null);
+  };
   const [hidden, setHidden] = useState<Set<string>>(new Set());
   const [tool, setTool] = useState<Tool>("select");
   const [snapMm, setSnapMm] = useState(SNAP_DEFAULT_MM);
@@ -205,6 +217,25 @@ export function SiteEditor() {
     setSite((s) => ({ ...s, areas: s.areas.filter((_, i) => i !== index) }));
     setSelected(null);
   };
+  const updateBarrier = (ref: BarrierRef, points: [number, number][] | null, key: string | null, patch = {}) => {
+    setSite(
+      (s) => ({
+        ...s,
+        [ref.kind]: (s[ref.kind] ?? []).map((b, i) => (i === ref.index ? { ...b, ...(points ? { points } : {}), ...patch } : b)),
+      }),
+      key,
+    );
+  };
+  const addBarrier = (kind: BarrierKind, points: [number, number][]) => {
+    const list = site?.[kind] ?? [];
+    setSite((s) => ({ ...s, [kind]: [...(s[kind] ?? []), { name: null, points, comment: null, was: null }] }));
+    selectBarrier({ kind, index: list.length });
+    setTool("select");
+  };
+  const deleteBarrier = (ref: BarrierRef) => {
+    setSite((s) => ({ ...s, [ref.kind]: (s[ref.kind] ?? []).filter((_, i) => i !== ref.index) }));
+    setSelectedBarrier(null);
+  };
   const addDefaultArea = () => {
     const [w, h] = site?.extent_mm ?? [2000, 2000];
     addArea({ x: 0, y: 0, w: Math.min(1000, w), h: Math.min(1000, h) });
@@ -216,6 +247,13 @@ export function SiteEditor() {
     } else if (selected !== null && site?.areas[selected]) {
       const a = site.areas[selected];
       updateArea(selected, { x: a.x + dx, y: a.y + dy }, `nudge-${selected}`);
+    } else if (selectedBarrier && site?.[selectedBarrier.kind]?.[selectedBarrier.index]) {
+      const b = site[selectedBarrier.kind]![selectedBarrier.index];
+      updateBarrier(
+        selectedBarrier,
+        b.points.map(([x, y]) => [x + dx, y + dy]),
+        `nudge-${selectedBarrier.kind}-${selectedBarrier.index}`,
+      );
     }
   };
 
@@ -246,8 +284,13 @@ export function SiteEditor() {
       if (e.key === "v" || e.key === "V") setTool("select");
       else if (e.key === "a" || e.key === "A") setTool("area");
       else if (e.key === "c" || e.key === "C") setTool("calibration");
-      else if (e.key === "Escape") setSelected(null);
-      else if ((e.key === "Delete" || e.key === "Backspace") && selected !== null) deleteArea(selected);
+      else if (e.key === "w" || e.key === "W") setTool("wall");
+      else if (e.key === "o" || e.key === "O") setTool("obstacle");
+      else if (e.key === "Escape") {
+        setSelected(null);
+        setSelectedBarrier(null);
+      } else if ((e.key === "Delete" || e.key === "Backspace") && selected !== null) deleteArea(selected);
+      else if ((e.key === "Delete" || e.key === "Backspace") && selectedBarrier) deleteBarrier(selectedBarrier);
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
@@ -451,7 +494,7 @@ export function SiteEditor() {
           }}
         >
           {TOOLS.map((t) => {
-            const enabled = t.key === "select" || t.key === "area" || t.key === "calibration";
+            const enabled = t.key !== "charger";
             const active = t.key === tool;
             return (
               <button
@@ -487,6 +530,12 @@ export function SiteEditor() {
             onSelect={setSelected}
             onChange={(i, r, key) => updateArea(i, r, key)}
             onDraw={addArea}
+            walls={site.walls ?? []}
+            obstacles={site.obstacles ?? []}
+            selectedBarrier={selectedBarrier}
+            onSelectBarrier={selectBarrier}
+            onBarrierChange={(ref, points, key) => updateBarrier(ref, points, key)}
+            onBarrierDraw={addBarrier}
             placement={placement}
             onPlacement={(move) => setPlacement((p) => (p ? { ...p, move } : p))}
             backdrops={
@@ -523,6 +572,10 @@ export function SiteEditor() {
               })
             }
             onAdd={addDefaultArea}
+            selectedBarrier={selectedBarrier}
+            onSelectBarrier={selectBarrier}
+            onBarrier={(ref, patch, key) => updateBarrier(ref, null, key, patch)}
+            onDeleteBarrier={deleteBarrier}
             backdrops={backdrops}
             shownBackdrops={shownBackdrops}
             onToggleBackdrop={(key) =>
diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
index ca8bc8d2..53c369ce 100644
--- a/dotbot/console-web/src/siteEditor/api.ts
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -28,6 +28,8 @@ function outgoing(site: SiteModel) {
     anchor: site.anchor || null,
     extent_mm: site.extent_mm,
     areas: site.areas.map((a) => ({ ...a, comment: a.comment || null })),
+    walls: (site.walls ?? []).map((b) => ({ ...b, name: b.name || null, comment: b.comment || null })),
+    obstacles: (site.obstacles ?? []).map((b) => ({ ...b, name: b.name || null, comment: b.comment || null })),
   };
 }
 
@@ -35,7 +37,12 @@ function outgoing(site: SiteModel) {
 export function withOrigins(body: SiteResponse): SiteResponse {
   return {
     ...body,
-    site: { ...body.site, areas: body.site.areas.map((a) => ({ ...a, was: a.name })) },
+    site: {
+      ...body.site,
+      areas: body.site.areas.map((a) => ({ ...a, was: a.name })),
+      walls: (body.site.walls ?? []).map((b, i) => ({ ...b, was: i })),
+      obstacles: (body.site.obstacles ?? []).map((b, i) => ({ ...b, was: i })),
+    },
   };
 }
 
diff --git a/dotbot/console-web/src/siteEditor/edit.test.ts b/dotbot/console-web/src/siteEditor/edit.test.ts
index 7d3220d9..8b808138 100644
--- a/dotbot/console-web/src/siteEditor/edit.test.ts
+++ b/dotbot/console-web/src/siteEditor/edit.test.ts
@@ -12,6 +12,7 @@ import {
   siteIssues,
   snap,
 } from "./edit";
+import { finishPoints, movePoints, parsePoints } from "./edit";
 import type { EditArea, SiteModel } from "./types";
 
 const area = (name: string, x: number, y: number, w: number, h: number, role: EditArea["role"] = null): EditArea => ({
@@ -141,3 +142,32 @@ describe("change tracking", () => {
     expect(sameSite(site, { ...site, anchor: "the door corner" })).toBe(true);
   });
 });
+
+describe("barriers", () => {
+  it("reads points one per line and refuses a line that does not read", () => {
+    expect(parsePoints("0, 0\n1000 0\n\n 1000,  500 ")).toEqual([
+      [0, 0],
+      [1000, 0],
+      [1000, 500],
+    ]);
+    expect(parsePoints("0, 0\n12")).toBeNull();
+  });
+
+  it("moves points with the first on the snap grid, and drops a double-click's repeat", () => {
+    expect(movePoints([[10, 10], [110, 10]], 37, 0, 50)).toEqual([[50, 0], [150, 0]]);
+    expect(finishPoints([[0, 0], [100, 0], [100, 0]])).toEqual([[0, 0], [100, 0]]);
+  });
+
+  it("flags a barrier with too few points and one outside the extent", () => {
+    const site = {
+      anchor: null,
+      extent_mm: [2000, 2000] as [number, number],
+      areas: [],
+      walls: [{ name: "w", points: [[0, 0]] as [number, number][], comment: null }],
+      obstacles: [{ name: null, points: [[0, 0], [3000, 0], [0, 100]] as [number, number][], comment: null }],
+    };
+    const messages = siteIssues(site).map((i) => `${i.level}: ${i.message}`);
+    expect(messages).toContain("error: w needs at least 2 points");
+    expect(messages).toContain("warning: obstacle 1 reaches outside the extent");
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/edit.ts b/dotbot/console-web/src/siteEditor/edit.ts
index d9729595..4d8de61e 100644
--- a/dotbot/console-web/src/siteEditor/edit.ts
+++ b/dotbot/console-web/src/siteEditor/edit.ts
@@ -1,5 +1,8 @@
 import type { AreaRole } from "../types";
-import type { EditArea, SiteModel } from "./types";
+import type { BarrierKind, EditArea, SiteModel } from "./types";
+
+/** The fewest points a wall and an obstacle take, as site.toml's schema. */
+export const BARRIER_MIN_POINTS: Record<BarrierKind, number> = { walls: 2, obstacles: 3 };
 
 // The editor's geometry and checks, apart from any drawing: snapping, moving,
 // resizing and drawing a rectangle in frame millimetres, and what a site must
@@ -175,9 +178,45 @@ export function siteIssues(site: SiteModel): Issue[] {
       }
     }
   }
+  for (const kind of ["walls", "obstacles"] as BarrierKind[]) {
+    (site[kind] ?? []).forEach((b, i) => {
+      const label = b.name || `${kind === "walls" ? "wall" : "obstacle"} ${i + 1}`;
+      if (b.points.length < BARRIER_MIN_POINTS[kind]) {
+        issues.push({ level: "error", message: `${label} needs at least ${BARRIER_MIN_POINTS[kind]} points` });
+      }
+      if (extent && b.points.some(([x, y]) => x < 0 || y < 0 || x > extent[0] || y > extent[1])) {
+        issues.push({ level: "warning", message: `${label} reaches outside the extent` });
+      }
+    });
+  }
   return issues;
 }
 
+/** `points` moved by (dx, dy), its first point on the snap grid. */
+export function movePoints(points: [number, number][], dx: number, dy: number, step: number): [number, number][] {
+  if (points.length === 0) return points;
+  const ox = snap(points[0][0] + dx, step) - points[0][0];
+  const oy = snap(points[0][1] + dy, step) - points[0][1];
+  return points.map(([x, y]) => [x + ox, y + oy]);
+}
+
+/** A drawn polyline without the repeats a double-click leaves at its end. */
+export function finishPoints(points: [number, number][]): [number, number][] {
+  return points.filter((p, i) => i === 0 || p[0] !== points[i - 1][0] || p[1] !== points[i - 1][1]);
+}
+
+/** `x, y` per line, as the inspector shows points; null when a line does not read. */
+export function parsePoints(text: string): [number, number][] | null {
+  const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+  const out: [number, number][] = [];
+  for (const line of lines) {
+    const parts = line.split(/[\s,]+/).filter(Boolean).map(Number);
+    if (parts.length !== 2 || parts.some((v) => !Number.isFinite(v))) return null;
+    out.push([Math.round(parts[0]), Math.round(parts[1])]);
+  }
+  return out;
+}
+
 /** Whether the anchor or the extent differ, which a calibration depends on. */
 export function frameChanged(a: SiteModel, b: SiteModel): boolean {
   return (
@@ -195,6 +234,12 @@ export function sameSite(a: SiteModel, b: SiteModel): boolean {
       areas: s.areas.map(({ name, x, y, w, h, role, comment, was }) => ({
         name, x, y, w, h, role, comment: comment || null, was: was ?? null,
       })),
+      walls: (s.walls ?? []).map(({ name, points, comment, was }) => ({
+        name: name || null, points, comment: comment || null, was: was ?? null,
+      })),
+      obstacles: (s.obstacles ?? []).map(({ name, points, comment, was }) => ({
+        name: name || null, points, comment: comment || null, was: was ?? null,
+      })),
     });
   return strip(a) === strip(b);
 }
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index 4a80ed2d..40887ae6 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -1,4 +1,4 @@
-import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { act, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { SiteEditor } from "./SiteEditor";
@@ -341,3 +341,50 @@ describe("SiteEditor comfort", () => {
     expect(screen.getByText("Undo")).toBeDisabled();
   });
 });
+
+describe("SiteEditor walls and obstacles", () => {
+  const withBarriers = (): SiteResponse => ({
+    ...loaded(),
+    site: {
+      ...loaded().site,
+      walls: [],
+      obstacles: [{ name: "pillar", points: [[100, 100], [300, 100], [300, 300]], comment: null }],
+    },
+  });
+
+  it("draws a wall point by point and saves it as a new entry", async () => {
+    const fetch = server(withBarriers(), { status: 200, body: { ...withBarriers(), revision: "r2", written: true } });
+    render(<SiteEditor />);
+    await screen.findByTestId("edit-obstacle-0");
+    fireEvent.click(screen.getByText("Wall"));
+    const canvas = screen.getByTestId("site-canvas");
+    fireEvent.pointerDown(canvas, { button: 0, clientX: 200, clientY: 200, pointerId: 1 });
+    fireEvent.pointerDown(canvas, { button: 0, clientX: 400, clientY: 200, pointerId: 1 });
+    fireEvent.pointerDown(canvas, { button: 0, clientX: 400, clientY: 200, pointerId: 1 });
+    expect(screen.getByTestId("barrier-draft")).toBeInTheDocument();
+    fireEvent.doubleClick(canvas);
+    expect(await screen.findByTestId("edit-wall-0")).toBeInTheDocument();
+    expect(screen.getByTestId("barrier-inspector")).toHaveTextContent("wall");
+    await act(async () => fireEvent.click(screen.getByText("Save")));
+    const put = fetch.mock.calls.find(([, init]) => init?.method === "PUT")!;
+    const sent = JSON.parse(put[1]!.body as string).site;
+    expect(sent.walls).toHaveLength(1);
+    expect(sent.walls[0].points).toHaveLength(2);
+    expect(sent.walls[0].was).toBeNull();
+    expect(sent.obstacles[0].was).toBe(0);
+  });
+
+  it("edits an obstacle's points as text and deletes it", async () => {
+    server(withBarriers(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    fireEvent.click(within(await screen.findByTestId("barriers")).getByText("pillar"));
+    const points = screen.getByLabelText("barrier points");
+    fireEvent.focus(points);
+    fireEvent.change(points, { target: { value: "100, 100\n500, 100\n500, 500\n100, 500" } });
+    expect(screen.getByTestId("edit-obstacle-0").getAttribute("points")!.split(" ")).toHaveLength(4);
+    fireEvent.change(points, { target: { value: "100, 100\nnot a point" } });
+    expect(screen.getByText("each line is two numbers, x and y")).toBeInTheDocument();
+    fireEvent.click(screen.getByText("Delete obstacle"));
+    expect(screen.queryByTestId("edit-obstacle-0")).toBeNull();
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/types.ts b/dotbot/console-web/src/siteEditor/types.ts
index fd4a16a1..ab6e095c 100644
--- a/dotbot/console-web/src/siteEditor/types.ts
+++ b/dotbot/console-web/src/siteEditor/types.ts
@@ -15,10 +15,23 @@ export interface EditArea {
   was?: string | null;
 }
 
+/** A wall (polyline) or an obstacle (closed polygon), frame mm. */
+export interface EditBarrier {
+  name: string | null;
+  points: [number, number][];
+  comment: string | null;
+  /** The entry's index in the file when the page loaded it; null for a new one. */
+  was?: number | null;
+}
+
+export type BarrierKind = "walls" | "obstacles";
+
 export interface SiteModel {
   anchor: string | null;
   extent_mm: [number, number] | null;
   areas: EditArea[];
+  walls?: EditBarrier[];
+  obstacles?: EditBarrier[];
   connection?: { conn?: string | null; swarm_id?: string | null } | null;
 }
 

From 26b36f17ca6c6405bcb31756bef28c8b80461f3a Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:05:37 +0200
Subject: [PATCH 60/80] dotbot/sim: stop a touching robot going deeper or
 across, check only moving ones

AI-assisted: Claude Opus 5.5
---
 dotbot/sim/barriers.py             | 138 ++++++++++++++++++++++-------
 dotbot/sim/plant.py                |  16 ++--
 dotbot/tests/test_site_barriers.py |  52 +++++++++++
 3 files changed, 168 insertions(+), 38 deletions(-)

diff --git a/dotbot/sim/barriers.py b/dotbot/sim/barriers.py
index 960b9f82..c3b29174 100644
--- a/dotbot/sim/barriers.py
+++ b/dotbot/sim/barriers.py
@@ -42,12 +42,19 @@ def __init__(
         # nose toward low y)
         self.centre_ahead_mm = geometry.axle_midpoint.y - geometry.outline_centre.y
         self.polygons = [np.asarray(o, dtype=float) for o in obstacles]
-        self.segments = np.vstack(
-            [
-                _segments([np.asarray(w, dtype=float) for w in walls], closed=False),
-                _segments(self.polygons, closed=True),
-            ]
+        wall_segments = _segments(
+            [np.asarray(w, dtype=float) for w in walls], closed=False
         )
+        polygon_segments = [_segments([p], closed=True) for p in self.polygons]
+        self.segments = np.vstack([wall_segments, *polygon_segments])
+        # The obstacle each segment bounds, -1 for a wall
+        self.owner = np.concatenate(
+            [np.full(len(wall_segments), -1)]
+            + [np.full(len(seg), k) for k, seg in enumerate(polygon_segments)]
+        ).astype(int)
+        self._lo = np.minimum(self.segments[:, :2], self.segments[:, 2:])
+        self._hi = np.maximum(self.segments[:, :2], self.segments[:, 2:])
+        self._boxes = [(p.min(axis=0), p.max(axis=0)) for p in self.polygons]
 
     def __bool__(self) -> bool:
         return len(self.segments) > 0
@@ -59,36 +66,105 @@ def from_site(cls, site) -> Barriers | None:
             return None
         return cls([w.points for w in site.walls], [o.points for o in site.obstacles])
 
-    def blocked(self, x, y, heading_deg) -> np.ndarray:
-        """Whether each pose (axle midpoint and heading) meets a barrier."""
+    def centres(self, x, y, heading_deg) -> tuple[np.ndarray, np.ndarray]:
+        """Each body's disc centre for a pose (axle midpoint and heading)."""
         x = np.atleast_1d(np.asarray(x, dtype=float))
         y = np.atleast_1d(np.asarray(y, dtype=float))
         fx, fy = forward(np.atleast_1d(np.asarray(heading_deg, dtype=float)))
-        cx = x + self.centre_ahead_mm * fx
-        cy = y + self.centre_ahead_mm * fy
+        return x + self.centre_ahead_mm * fx, y + self.centre_ahead_mm * fy
+
+    def blocked(self, x, y, heading_deg) -> np.ndarray:
+        """Whether each pose meets a barrier."""
+        cx, cy = self.centres(x, y, heading_deg)
         hit = np.zeros(len(cx), dtype=bool)
-        if len(self.segments):
-            ax, ay, bx, by = (self.segments[:, i][None, :] for i in range(4))
-            dx, dy = bx - ax, by - ay
-            length2 = np.maximum(dx * dx + dy * dy, 1e-12)
-            t = np.clip(
-                ((cx[:, None] - ax) * dx + (cy[:, None] - ay) * dy) / length2, 0, 1
-            )
-            gap2 = (cx[:, None] - ax - t * dx) ** 2 + (cy[:, None] - ay - t * dy) ** 2
-            hit |= (gap2 < self.radius_mm**2).any(axis=1)
-        for polygon in self.polygons:
-            hit |= _inside(polygon, cx, cy)
+        for i, j, gap2, _, _ in self._near(cx, cy):
+            hit[i[gap2 < self.radius_mm**2]] = True
+        for k in range(len(self.polygons)):
+            hit |= self._inside(k, cx, cy)
         return hit
 
-
-def _inside(polygon: np.ndarray, x: np.ndarray, y: np.ndarray) -> np.ndarray:
-    """Even-odd rule for each point against one polygon."""
-    inside = np.zeros(len(x), dtype=bool)
-    px, py = polygon[:, 0], polygon[:, 1]
-    qx, qy = np.roll(px, -1), np.roll(py, -1)
-    for x0, y0, x1, y1 in zip(px, py, qx, qy):
-        crosses = (y0 > y) != (y1 > y)
+    def refused(self, before, after) -> np.ndarray:
+        """Which moves from the poses `before` to `after`, each (x, y,
+        heading_deg), the barriers stop: one bringing the body closer to a
+        barrier it touches, carrying its centre across one, or into an
+        obstacle. A body already touching may move off or along it."""
+        x0, y0 = self.centres(*before)
+        x1, y1 = self.centres(*after)
+        stop = np.zeros(len(x1), dtype=bool)
+        r2 = self.radius_mm**2
+        inside0 = [self._inside(k, x0, y0) for k in range(len(self.polygons))]
+        for k, was_in in enumerate(inside0):
+            stop |= ~was_in & self._inside(k, x1, y1)
+        for i, j, gap2, _, _ in self._near(x1, y1, x0, y0):
+            owner = self.owner[j]
+            # An edge of the obstacle a body starts inside never holds it in
+            exempt = np.zeros(len(i), dtype=bool)
+            for k, was_in in enumerate(inside0):
+                exempt |= (owner == k) & was_in[i]
+            seg = self.segments[j]
+            before2 = _gap2(x0[i], y0[i], seg)
+            closer = (gap2 < r2) & (gap2 < before2 - 1e-9)
+            crosses = _crosses(x0[i], y0[i], x1[i], y1[i], seg)
+            stop[i[(closer | crosses) & ~exempt]] = True
+        return stop
+
+    def _near(self, x, y, x0=None, y0=None):
+        """The (body, segment) pairs whose boxes, grown by the disc, overlap
+        the body's path; yields (bodies, segments, new gap squared, ...)."""
+        if not len(self.segments) or not len(x):
+            return
+        x0 = x if x0 is None else x0
+        y0 = y if y0 is None else y0
+        r = self.radius_mm
+        lo_x, hi_x = np.minimum(x, x0) - r, np.maximum(x, x0) + r
+        lo_y, hi_y = np.minimum(y, y0) - r, np.maximum(y, y0) + r
+        near = (
+            (lo_x[:, None] <= self._hi[None, :, 0])
+            & (hi_x[:, None] >= self._lo[None, :, 0])
+            & (lo_y[:, None] <= self._hi[None, :, 1])
+            & (hi_y[:, None] >= self._lo[None, :, 1])
+        )
+        i, j = np.nonzero(near)
+        if len(i):
+            yield i, j, _gap2(x[i], y[i], self.segments[j]), x0[i], y0[i]
+
+    def _inside(self, k: int, x: np.ndarray, y: np.ndarray) -> np.ndarray:
+        """Even-odd rule for each point against obstacle `k`."""
+        lo, hi = self._boxes[k]
+        inside = np.zeros(len(x), dtype=bool)
+        candidate = (x >= lo[0]) & (x <= hi[0]) & (y >= lo[1]) & (y <= hi[1])
+        if not candidate.any():
+            return inside
+        px, py = x[candidate][:, None], y[candidate][:, None]
+        polygon = self.polygons[k]
+        x0, y0 = polygon[:, 0][None, :], polygon[:, 1][None, :]
+        x1, y1 = (
+            np.roll(polygon[:, 0], -1)[None, :],
+            np.roll(polygon[:, 1], -1)[None, :],
+        )
+        crosses = (y0 > py) != (y1 > py)
         with np.errstate(divide="ignore", invalid="ignore"):
-            at = x0 + (y - y0) * (x1 - x0) / (y1 - y0)
-        inside ^= crosses & (x < at)
-    return inside
+            at = x0 + (py - y0) * (x1 - x0) / (y1 - y0)
+        inside[candidate] = (np.count_nonzero(crosses & (px < at), axis=1) % 2) == 1
+        return inside
+
+
+def _gap2(x: np.ndarray, y: np.ndarray, seg: np.ndarray) -> np.ndarray:
+    """Squared distance from each point to its segment, row for row."""
+    ax, ay, bx, by = seg[:, 0], seg[:, 1], seg[:, 2], seg[:, 3]
+    dx, dy = bx - ax, by - ay
+    length2 = np.maximum(dx * dx + dy * dy, 1e-12)
+    t = np.clip(((x - ax) * dx + (y - ay) * dy) / length2, 0, 1)
+    return (x - ax - t * dx) ** 2 + (y - ay - t * dy) ** 2
+
+
+def _crosses(x0, y0, x1, y1, seg: np.ndarray) -> np.ndarray:
+    """Whether each path (x0, y0) -> (x1, y1) properly crosses its segment."""
+    ax, ay, bx, by = seg[:, 0], seg[:, 1], seg[:, 2], seg[:, 3]
+
+    def side(px, py, qx, qy, rx, ry):
+        return np.sign((qx - px) * (ry - py) - (qy - py) * (rx - px))
+
+    return (side(ax, ay, bx, by, x0, y0) * side(ax, ay, bx, by, x1, y1) < 0) & (
+        side(x0, y0, x1, y1, ax, ay) * side(x0, y0, x1, y1, bx, by) < 0
+    )
diff --git a/dotbot/sim/plant.py b/dotbot/sim/plant.py
index 06b972a8..22158a56 100644
--- a/dotbot/sim/plant.py
+++ b/dotbot/sim/plant.py
@@ -117,14 +117,16 @@ def step(self, fixes: np.ndarray):
         travel = (self.speed + speed) / 2.0 * TICK_S
         travel[:, self.held] = 0.0
         x, y, heading = move(self.x, self.y, self.heading_deg, travel[0], travel[1])
-        if self.barriers is not None:
-            # A body that would meet a barrier stays where it was, its wheels
-            # stalled; one already in contact may still move off it
-            hit = self.barriers.blocked(x, y, heading)
+        barriers = self.barriers
+        moving = np.flatnonzero((travel != 0).any(axis=0))
+        if barriers is not None and len(moving):
+            # A body the barriers stop stays where it was, its wheels stalled
+            hit = np.zeros(len(x), dtype=bool)
+            hit[moving] = barriers.refused(
+                (self.x[moving], self.y[moving], self.heading_deg[moving]),
+                (x[moving], y[moving], heading[moving]),
+            )
             if hit.any():
-                hit[hit] = ~self.barriers.blocked(
-                    self.x[hit], self.y[hit], self.heading_deg[hit]
-                )
                 x = np.where(hit, self.x, x)
                 y = np.where(hit, self.y, y)
                 heading = np.where(hit, self.heading_deg, heading)
diff --git a/dotbot/tests/test_site_barriers.py b/dotbot/tests/test_site_barriers.py
index ff4c0e1b..ffecdf36 100644
--- a/dotbot/tests/test_site_barriers.py
+++ b/dotbot/tests/test_site_barriers.py
@@ -96,6 +96,58 @@ def test_a_robot_in_contact_may_back_off():
     assert plant.y[0] < 900
 
 
+def _drive(plant, pwm, ticks):
+    plant.pwm[:] = pwm
+    for _ in range(ticks):
+        plant.step(np.zeros(len(plant.x), dtype=bool))
+
+
+def test_a_robot_placed_against_a_wall_cannot_drive_through_it():
+    # Its disc already overlaps the wall at y = 1000, from the near side
+    plant = FleetPlant(
+        x=[500.0], y=[940.0], heading_deg=[0.0], barriers=Barriers.from_site(_site())
+    )
+    _drive(plant, 80.0, 400)
+    assert plant.y[0] <= 940.0 + 1e-6
+
+
+def test_a_robot_placed_across_a_wall_cannot_drive_back_over_it():
+    plant = FleetPlant(
+        x=[500.0], y=[1050.0], heading_deg=[180.0], barriers=Barriers.from_site(_site())
+    )
+    _drive(plant, 80.0, 400)
+    assert plant.y[0] >= 1050.0 - 1e-6
+
+
+def test_a_robot_placed_inside_an_obstacle_may_drive_out():
+    plant = FleetPlant(
+        x=[1600.0], y=[1600.0], heading_deg=[0.0], barriers=Barriers.from_site(_site())
+    )
+    _drive(plant, 60.0, 400)
+    assert plant.y[0] > 1700 + 47.5
+
+
+def test_a_robot_at_a_wall_may_turn_away_but_not_into_it():
+    barriers = Barriers.from_site(_site())
+    plant = FleetPlant(x=[500.0], y=[920.0], heading_deg=[0.0], barriers=barriers)
+    _drive(plant, 60.0, 200)
+    stopped = plant.heading_deg[0]
+    plant.pwm[:, 0] = [60.0, -60.0]
+    for _ in range(100):
+        plant.step(np.zeros(1, dtype=bool))
+    assert plant.heading_deg[0] != stopped
+    assert not barriers.blocked(plant.x, plant.y, plant.heading_deg)[0]
+
+
+def test_robots_standing_still_are_not_checked(monkeypatch):
+    barriers = Barriers.from_site(_site())
+    calls = []
+    monkeypatch.setattr(barriers, "refused", lambda *a: calls.append(a))
+    plant = FleetPlant(x=[500.0], y=[500.0], heading_deg=[0.0], barriers=barriers)
+    plant.step(np.zeros(1, dtype=bool))
+    assert calls == []
+
+
 @pytest.mark.scenario
 @pytest.mark.asyncio
 async def test_a_waypoint_behind_a_wall_is_not_reached(tmp_path):

From bde08b7b799743c4ef038823b7d1452937a318d7 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:07:49 +0200
Subject: [PATCH 61/80] dotbot/site_toml: keep wall comments on delete, refuse
 inline walls, leave omitted tables

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py            | 11 +++++--
 dotbot/site_toml.py              | 51 ++++++++++++++++++++++++++++----
 dotbot/tests/test_site_editor.py | 12 ++++++++
 dotbot/tests/test_site_toml.py   | 51 ++++++++++++++++++++++++++++++++
 4 files changed, 117 insertions(+), 8 deletions(-)

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index b9612782..997a5b4a 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -57,8 +57,9 @@ class SiteModel(BaseModel):
     anchor: str | None = None
     extent_mm: tuple[int, int] | None = None
     areas: list[AreaModel] = Field(default_factory=list)
-    walls: list[BarrierModel] = Field(default_factory=list)
-    obstacles: list[BarrierModel] = Field(default_factory=list)
+    # None leaves the file's table as it is
+    walls: list[BarrierModel] | None = None
+    obstacles: list[BarrierModel] | None = None
 
 
 class SaveRequest(BaseModel):
@@ -155,7 +156,11 @@ def _write_atomic(path: Path, text: str) -> None:
 def _model_dict(model: SiteModel) -> dict:
     data = model.model_dump()
     data["extent_mm"] = list(model.extent_mm) if model.extent_mm else None
-    return data
+    return {
+        key: value
+        for key, value in data.items()
+        if value is not None or key in ("anchor", "extent_mm")
+    }
 
 
 def create_app(
diff --git a/dotbot/site_toml.py b/dotbot/site_toml.py
index 96aefac9..e04b4fd7 100644
--- a/dotbot/site_toml.py
+++ b/dotbot/site_toml.py
@@ -78,9 +78,22 @@ def site_model(doc: TOMLDocument) -> dict[str, Any]:
     }
 
 
-def _barriers_model(doc: TOMLDocument, key: str) -> list[dict[str, Any]]:
-    items = doc.get(key)
+def _barriers_table(doc: TOMLDocument, key: str) -> AoT | None:
+    if key not in doc:
+        return None
+    items = doc[key]
     if not isinstance(items, AoT):
+        raise SiteTomlError(
+            f"the site editor edits {key} written as [[{key}]] tables; this file "
+            "writes them otherwise (inline), so edit it by hand or rewrite them "
+            "that way first"
+        )
+    return items
+
+
+def _barriers_model(doc: TOMLDocument, key: str) -> list[dict[str, Any]]:
+    items = _barriers_table(doc, key)
+    if items is None:
         return []
     return [
         {
@@ -284,6 +297,20 @@ def _normal(model: dict[str, Any]) -> dict[str, Any]:
             )
             for area in model.get("areas") or []
         ),
+        **{
+            key: sorted(
+                repr(
+                    (
+                        item.get("name") or None,
+                        [[int(x), int(y)] for x, y in item.get("points") or []],
+                        (item.get("comment") or "").strip() or None,
+                    )
+                )
+                for item in model.get(key) or []
+            )
+            for key in BARRIERS
+            if key in model
+        },
     }
 
 
@@ -293,8 +320,8 @@ def _patch_barriers(doc: TOMLDocument, key: str, items: list[dict[str, Any]]) ->
     for item in items:
         if len(item.get("points") or []) < least:
             raise SiteTomlError(f"each of {key} needs at least {least} points")
-    table = doc.get(key)
-    if not isinstance(table, AoT):
+    table = _barriers_table(doc, key)
+    if table is None:
         if not items:
             return
         table = tomlkit.aot()
@@ -305,6 +332,13 @@ def _patch_barriers(doc: TOMLDocument, key: str, items: list[dict[str, Any]]) ->
     if any(was >= len(table) for was in kept):
         raise SiteTomlError(f"{key} changed in the file since the page loaded it")
     for index in sorted(set(range(len(table))) - set(kept), reverse=True):
+        # The comments ending an entry head whatever follows it
+        tail = _split_trailing(table[index])
+        if index:
+            _split_trailing(table[index - 1])
+            _end_with(table[index - 1], tail)
+        else:
+            _set_heading(doc, key, tail)
         del table[index]
     position = {was: k for k, was in enumerate(kept)}
     for item in items:
@@ -315,7 +349,12 @@ def _patch_barriers(doc: TOMLDocument, key: str, items: list[dict[str, Any]]) ->
                 entry["name"] = item["name"]
             entry["points"] = points
             _set_comment(entry, item.get("comment"))
+            tail = ""
+            if len(table):
+                tail = _split_trailing(table[-1])
+                _end_with(table[-1], "\n")
             table.append(entry)
+            _end_with(entry, tail)
             continue
         entry = table[position[item["was"]]]
         _set(entry, "name", item.get("name") or None)
@@ -374,7 +413,9 @@ def patched_text(text: str, model: dict[str, Any]) -> str:
     `model`; SiteTomlError when the patch cannot be made faithfully."""
     result = tomlkit.dumps(patch(parse(text), model))
     validate(result)
-    if _normal(site_model(parse(result))) != _normal(model):
+    want = _normal(model)
+    got = _normal(site_model(parse(result)))
+    if {key: got[key] for key in want} != want:
         raise SiteTomlError(
             "the edit could not be written into site.toml as it is laid out; "
             "edit the file by hand"
diff --git a/dotbot/tests/test_site_editor.py b/dotbot/tests/test_site_editor.py
index 4361bfa8..81d951c1 100644
--- a/dotbot/tests/test_site_editor.py
+++ b/dotbot/tests/test_site_editor.py
@@ -354,3 +354,15 @@ def test_a_save_through_a_symlink_writes_its_target(tmp_path, page):
     assert response.status_code == 200
     assert (pack / "site.toml").is_symlink()
     assert 'anchor = "moved"' in target.read_text()
+
+
+def test_a_save_that_leaves_out_the_walls_keeps_them(client, pack):
+    (pack / "site.toml").write_text(ARENA + "\n[[walls]]\npoints = [[0, 0], [1, 1]]\n")
+    body = _loaded(client)
+    site = {k: v for k, v in body["site"].items() if k not in ("walls", "obstacles")}
+    site["anchor"] = "moved"
+    response = client.put(
+        "/api/site", json={"revision": body["revision"], "site": site}
+    )
+    assert response.status_code == 200
+    assert "[[walls]]" in (pack / "site.toml").read_text()
diff --git a/dotbot/tests/test_site_toml.py b/dotbot/tests/test_site_toml.py
index 9ffe2e34..f2371430 100644
--- a/dotbot/tests/test_site_toml.py
+++ b/dotbot/tests/test_site_toml.py
@@ -407,3 +407,54 @@ def test_a_new_array_of_tables_starts_after_a_blank_line():
     result = patched_text(INLINE, model)
     assert "500 }\n\n[[walls]]" in result
     assert "\n\n[[obstacles]]" in result
+
+
+THREE_WALLS = """\
+anchor = "a"
+
+# a: the door wall
+[[walls]]
+points = [[0, 0], [1, 0]]
+
+# b: the window wall
+[[walls]]
+points = [[0, 1], [1, 1]]
+
+# c: the back wall
+[[walls]]
+points = [[0, 2], [1, 2]]
+
+# The broker.
+[connection]
+conn = "mqtt://h:1883"
+"""
+
+
+@pytest.mark.parametrize("dropped", [0, 1, 2])
+def test_deleting_a_wall_keeps_the_comments_heading_the_others(dropped):
+    model = _loaded(THREE_WALLS)
+    del model["walls"][dropped]
+    result = patched_text(THREE_WALLS, model)
+    kept = [c for k, c in enumerate("abc") if k != dropped]
+    headings = [line for line in result.splitlines() if line.startswith("# ")]
+    assert [h[2] for h in headings[:2]] == kept
+    assert headings[-1] == "# The broker."
+    assert result.splitlines()[result.splitlines().index("[connection]") - 2] == ""
+
+
+def test_a_wall_appended_to_an_array_is_set_apart_by_a_blank_line():
+    model = _loaded(THREE_WALLS)
+    model["walls"].append({"points": [[5, 5], [6, 6]], "was": None})
+    result = patched_text(THREE_WALLS, model)
+    assert (
+        "points = [[0, 2], [1, 2]]\n\n[[walls]]\npoints = [[5, 5], [6, 6]]\n\n# The"
+        in (result)
+    )
+
+
+def test_walls_written_inline_are_refused_not_wiped():
+    text = 'walls = [{ name = "hand", points = [[0, 0], [1, 1]] }]\n'
+    with pytest.raises(SiteTomlError, match="edit it by hand"):
+        site_model(tomlkit.parse(text))
+    with pytest.raises(SiteTomlError):
+        patched_text(text, {"walls": [{"points": [[2, 2], [3, 3]], "was": None}]})

From 0b6706470af84c5d69d1546aa14ea516b0d155e1 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:08:44 +0200
Subject: [PATCH 62/80] dotbot/console-web: delete a selection only with the
 Select tool

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/MapView.tsx                    | 3 +--
 dotbot/console-web/src/siteEditor/SiteEditor.tsx      | 6 ++++--
 dotbot/console-web/src/siteEditor/siteEditor.test.tsx | 9 +++++++++
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/dotbot/console-web/src/MapView.tsx b/dotbot/console-web/src/MapView.tsx
index b341f2f1..abd2de82 100644
--- a/dotbot/console-web/src/MapView.tsx
+++ b/dotbot/console-web/src/MapView.tsx
@@ -1214,8 +1214,7 @@ export const MapView: React.FC<MapViewProps> = (props) => {
                 <title>{a.name}</title>
               </rect>
             ))}
-            {/* The site's walls and obstacles, solid: they are the floor's,
-                not a view of it. */}
+            {/* The site's walls and obstacles */}
             {(props.site?.obstacles ?? []).map((o, i) => (
               <polygon
                 key={`obstacle-${i}`}
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index d3614f40..95155872 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -289,8 +289,10 @@ export function SiteEditor() {
       else if (e.key === "Escape") {
         setSelected(null);
         setSelectedBarrier(null);
-      } else if ((e.key === "Delete" || e.key === "Backspace") && selected !== null) deleteArea(selected);
-      else if ((e.key === "Delete" || e.key === "Backspace") && selectedBarrier) deleteBarrier(selectedBarrier);
+      } else if ((e.key === "Delete" || e.key === "Backspace") && tool === "select") {
+        if (selected !== null) deleteArea(selected);
+        else if (selectedBarrier) deleteBarrier(selectedBarrier);
+      }
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index 40887ae6..c78ea1e2 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -387,4 +387,13 @@ describe("SiteEditor walls and obstacles", () => {
     fireEvent.click(screen.getByText("Delete obstacle"));
     expect(screen.queryByTestId("edit-obstacle-0")).toBeNull();
   });
+
+  it("keeps a selected obstacle when Backspace is pressed while drawing", async () => {
+    server(withBarriers(), { status: 200, body: {} });
+    render(<SiteEditor />);
+    fireEvent.click(within(await screen.findByTestId("barriers")).getByText("pillar"));
+    fireEvent.click(screen.getByText("Wall"));
+    fireEvent.keyDown(window, { key: "Backspace" });
+    expect(screen.getByTestId("edit-obstacle-0")).toBeInTheDocument();
+  });
 });

From f265df4bf5677f45425a2ce79347cae42881d52d Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:14:12 +0200
Subject: [PATCH 63/80] dotbot/site: read objects such as chargers from
 site.toml and serve them

AI-assisted: Claude Opus 5.5
---
 dotbot/config.py               | 18 +++++++++++++++++-
 dotbot/models.py               | 27 +++++++++++++++++++++++++--
 dotbot/site.py                 | 21 +++++++++++++++++++++
 dotbot/tests/test_qrkey_app.py |  1 +
 dotbot/tests/test_server.py    |  2 ++
 5 files changed, 66 insertions(+), 3 deletions(-)

diff --git a/dotbot/config.py b/dotbot/config.py
index 5cfe2b72..e2d9f1cc 100644
--- a/dotbot/config.py
+++ b/dotbot/config.py
@@ -33,7 +33,7 @@
 import tomllib
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Annotated, Any, Mapping, Optional
+from typing import Annotated, Any, Literal, Mapping, Optional
 
 from pydantic import (
     AfterValidator,
@@ -185,6 +185,21 @@ class ObstacleSection(_Strict):
     points: list[tuple[int, int]] = Field(min_length=3)
 
 
+ObjectKind = Literal["charger", "dock", "landmark", "camera"]
+
+
+class ObjectSection(_Strict):
+    """One `[objects.<name>]` table: a thing on the floor at a pose, frame mm.
+
+    `heading_deg` follows the robots' convention.
+    """
+
+    kind: ObjectKind
+    x: int
+    y: int
+    heading_deg: float = 0.0
+
+
 def _is_simulator(conn: str) -> bool:
     return conn.strip().lower() in ("simulator", "sim")
 
@@ -241,6 +256,7 @@ class SiteSection(_Strict):
     spin_radius_mm: float | None = Field(default=None, ge=1.0, le=200.0)
     walls: list[WallSection] = Field(default_factory=list)
     obstacles: list[ObstacleSection] = Field(default_factory=list)
+    objects: dict[str, ObjectSection] = Field(default_factory=dict)
 
     @model_validator(mode="after")
     def _stations(self) -> SiteSection:
diff --git a/dotbot/models.py b/dotbot/models.py
index edce7ac2..20c42b48 100644
--- a/dotbot/models.py
+++ b/dotbot/models.py
@@ -18,7 +18,7 @@
 from dotbot.calibration.points import PointsKind
 from dotbot.protocol import ApplicationType, ControlModeType, WaypointsStatus
 from dotbot.robots import ROBOT_DEFAULT, BodyPose
-from dotbot.site import Obstacle, Site, Wall
+from dotbot.site import Obstacle, Site, SiteObject, Wall
 
 # Points of trail the controller keeps per robot
 MAX_TRAIL_SIZE = 1000
@@ -203,6 +203,17 @@ class DotBotBarrierModel(BaseModel):
     points: List[List[int]]
 
 
+class DotBotSiteObjectModel(BaseModel):
+    """A thing on the floor at a pose, frame mm: a charger, a dock, a
+    landmark or a camera."""
+
+    name: str
+    kind: str
+    x: int
+    y: int
+    heading_deg: float = 0.0
+
+
 class DotBotPointsFromModel(BaseModel):
     """How a placement's points were chosen: the field's corners, the corners
     of `area`, a `side_mm` square centred in the field, or given by hand."""
@@ -258,7 +269,8 @@ class DotBotSiteModel(BaseModel):
     name, an `x,y,w,h` literal for a site with an extent and no areas, or
     None for a site that declares neither. `calibration` is the LH2
     calibration the controller loaded, if any. `walls` (polylines) and
-    `obstacles` (closed polygons) are where robots cannot go.
+    `obstacles` (closed polygons) are where robots cannot go; `objects` are
+    the things on the floor, such as chargers.
     """
 
     name: str
@@ -270,6 +282,7 @@ class DotBotSiteModel(BaseModel):
     spin_radius_mm: Optional[float] = None
     walls: List[DotBotBarrierModel] = []
     obstacles: List[DotBotBarrierModel] = []
+    objects: List[DotBotSiteObjectModel] = []
 
     @classmethod
     def from_site(cls, site: Site, calibration: Any = None) -> "DotBotSiteModel":
@@ -289,6 +302,12 @@ def from_site(cls, site: Site, calibration: Any = None) -> "DotBotSiteModel":
                 DotBotBarrierModel(name=o.name, points=[list(p) for p in o.points])
                 for o in site.obstacles
             ],
+            objects=[
+                DotBotSiteObjectModel(
+                    name=o.name, kind=o.kind, x=o.x, y=o.y, heading_deg=o.heading_deg
+                )
+                for o in site.objects.values()
+            ],
             calibration=(
                 DotBotCalibrationSpanModel.from_calibration(calibration)
                 if calibration is not None
@@ -312,6 +331,10 @@ def to_site(self) -> Site:
                 Obstacle(tuple(tuple(p) for p in o.points), o.name)
                 for o in self.obstacles
             ],
+            objects={
+                o.name: SiteObject(o.name, o.kind, o.x, o.y, o.heading_deg)
+                for o in self.objects
+            },
         )
 
 
diff --git a/dotbot/site.py b/dotbot/site.py
index fb6158db..e48768b0 100644
--- a/dotbot/site.py
+++ b/dotbot/site.py
@@ -55,6 +55,18 @@ class Obstacle:
     name: str = ""
 
 
+@dataclass(frozen=True)
+class SiteObject:
+    """A thing on the floor (a charger, a dock, a landmark, a camera) at a
+    pose in frame mm; `heading_deg` follows the robots' convention."""
+
+    name: str
+    kind: str
+    x: int
+    y: int
+    heading_deg: float = 0.0
+
+
 @dataclass
 class Site:
     """A site as the config declares it.
@@ -74,6 +86,7 @@ class Site:
     spin_radius_mm: float | None = None
     walls: list[Wall] = field(default_factory=list)
     obstacles: list[Obstacle] = field(default_factory=list)
+    objects: dict[str, SiteObject] = field(default_factory=dict)
 
     @property
     def extent(self) -> Area | None:
@@ -130,6 +143,10 @@ def staging(self) -> Area | None:
                 return area
         return None
 
+    def objects_of(self, kind: str) -> list[SiteObject]:
+        """The objects of `kind`, in the order the file declares them."""
+        return [o for o in self.objects.values() if o.kind == kind]
+
     def registry(self) -> AreaRegistry:
         """The resolver `--points` runs against."""
         return AreaRegistry(named=dict(self.areas), site=self.name)
@@ -203,4 +220,8 @@ def site_from_table(name: str, table: Any, pack: Path | None = None) -> Site:
             Obstacle(tuple(tuple(p) for p in obstacle.points), obstacle.name or "")
             for obstacle in getattr(table, "obstacles", None) or []
         ],
+        objects={
+            name: SiteObject(name, o.kind, o.x, o.y, o.heading_deg)
+            for name, o in (getattr(table, "objects", None) or {}).items()
+        },
     )
diff --git a/dotbot/tests/test_qrkey_app.py b/dotbot/tests/test_qrkey_app.py
index 37276f1c..fa800ad0 100644
--- a/dotbot/tests/test_qrkey_app.py
+++ b/dotbot/tests/test_qrkey_app.py
@@ -143,4 +143,5 @@ def test_a_site_request_replies_with_the_whole_site(site_client):
         "spin_radius_mm": None,
         "walls": [],
         "obstacles": [],
+        "objects": [],
     }
diff --git a/dotbot/tests/test_server.py b/dotbot/tests/test_server.py
index 535df7e8..8ac3811e 100644
--- a/dotbot/tests/test_server.py
+++ b/dotbot/tests/test_server.py
@@ -1386,6 +1386,7 @@ async def test_get_controller_site():
         "spin_radius_mm": None,
         "walls": [],
         "obstacles": [],
+        "objects": [],
     }
 
 
@@ -1464,6 +1465,7 @@ async def test_get_controller_site_with_nothing_measured():
         "spin_radius_mm": None,
         "walls": [],
         "obstacles": [],
+        "objects": [],
     }
 
 

From 5f3c3dc37d12c5e629077fedd96469bcfa63565e Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:14:12 +0200
Subject: [PATCH 64/80] dotbot/dotbot_simulator: charge a simulated robot
 standing on a site's charger

AI-assisted: Claude Opus 5.5
---
 dotbot/dotbot_simulator.py | 34 ++++++++++++++++++++++++++++++++--
 dotbot/sim/plant.py        |  4 ++++
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/dotbot/dotbot_simulator.py b/dotbot/dotbot_simulator.py
index e04f39de..ad89d7e9 100644
--- a/dotbot/dotbot_simulator.py
+++ b/dotbot/dotbot_simulator.py
@@ -39,7 +39,10 @@
 from dotbot.sim import core as control
 from dotbot.sim.barriers import Barriers
 from dotbot.sim.plant import (
+    CHARGE_FULL_S,
+    CHARGER_REACH_MM,
     INITIAL_BATTERY_VOLTAGE,
+    MAX_BATTERY_DURATION_S,
     FleetPlant,
     battery_discharge_model,
 )
@@ -510,6 +513,11 @@ def __init__(
             barriers=Barriers.from_site(site),
         )
         self.visible = np.ones(count, dtype=bool)
+        chargers = site.objects_of("charger") if site is not None else []
+        # The site's chargers, (n, 2) mm; None for a site without one
+        self._chargers = (
+            np.array([[c.x, c.y] for c in chargers], dtype=float) if chargers else None
+        )
         self.battery = np.full(count, float(INITIAL_BATTERY_VOLTAGE))
         self._inputs = np.zeros(count, dtype=control.INPUT)
         self._inputs["elapsed_ticks"] = 1
@@ -662,11 +670,15 @@ def _models_update(self):
             reports = self.reports()
             for index, model in self._gru.items():
                 self._gru_residual(index, model, reports[index])
-        linear = battery_discharge_model(self.time_elapsed_s)
+        if self._chargers is None:
+            linear = battery_discharge_model(self.time_elapsed_s)
+        else:
+            linear = self._charged()
         if not self._battery_models:
             self.battery[:] = linear
             return
-        self.battery[~self._battery_modelled] = linear
+        unmodelled = ~self._battery_modelled
+        self.battery[unmodelled] = linear if np.isscalar(linear) else linear[unmodelled]
         import torch
 
         reports = self.reports()
@@ -693,6 +705,24 @@ def _models_update(self):
                 0.0, self.battery[index] + rate * SIMULATOR_STEP_DELTA_T
             )
 
+    def on_charger(self) -> np.ndarray:
+        """Whether each robot's axle midpoint is on one of the site's chargers."""
+        if self._chargers is None:
+            return np.zeros(self.plant.count, dtype=bool)
+        dx = self.plant.x[:, None] - self._chargers[None, :, 0]
+        dy = self.plant.y[:, None] - self._chargers[None, :, 1]
+        return (dx * dx + dy * dy < CHARGER_REACH_MM**2).any(axis=1)
+
+    def _charged(self) -> np.ndarray:
+        """Each robot's battery one tick on: draining at the rate of
+        `battery_discharge_model`, charging while on a charger."""
+        drain = INITIAL_BATTERY_VOLTAGE / MAX_BATTERY_DURATION_S
+        charge = INITIAL_BATTERY_VOLTAGE / CHARGE_FULL_S
+        rate = np.where(self.on_charger(), charge, -drain)
+        return np.clip(
+            self.battery + rate * SIMULATOR_STEP_DELTA_T, 0, INITIAL_BATTERY_VOLTAGE
+        )
+
     def _gru_residual(self, index: int, model, report):
         """Add the GRU's predicted (dx, dy, d_enc_left, d_enc_right) to the truth."""
         buffer = self._gru_buffers[index]
diff --git a/dotbot/sim/plant.py b/dotbot/sim/plant.py
index 22158a56..7e31d1ad 100644
--- a/dotbot/sim/plant.py
+++ b/dotbot/sim/plant.py
@@ -34,6 +34,10 @@
 # Battery: a linear discharge over three hours
 INITIAL_BATTERY_VOLTAGE = 3000  # mV
 MAX_BATTERY_DURATION_S = 60 * 60 * 3
+# A robot whose axle midpoint is this close to a charger's point charges,
+# from empty to full in CHARGE_FULL_S
+CHARGER_REACH_MM = 100.0
+CHARGE_FULL_S = 120.0
 
 
 def battery_discharge_model(time_elapsed_s: float) -> int:

From aca59735dd7974e2247b394339f746e3ab792105 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:14:12 +0200
Subject: [PATCH 65/80] dotbot/examples: take the charging station's charger
 from the site

AI-assisted: Claude Opus 5.5
---
 dotbot/examples/charging_station/README.md    | 14 ++++++++---
 .../charging_station/charging_station.py      | 23 ++++++++++++++-----
 2 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/dotbot/examples/charging_station/README.md b/dotbot/examples/charging_station/README.md
index b6e96af4..4b22ddd1 100644
--- a/dotbot/examples/charging_station/README.md
+++ b/dotbot/examples/charging_station/README.md
@@ -9,9 +9,17 @@ The simulator setup below is the default path for reproducibility.
 
 The example reads its layout from the controller's site, which needs a
 **field** and a **staging** area: robots queue on the border between the two,
-charge one at a time at a charger on staging's far edge, then park along the
-field's opposite edge. It refuses a site without a staging area. The site
-`dotbot config init` writes has both.
+charge one at a time at the site's first `charger` object (else at a point on
+staging's far edge), then park along the field's opposite edge. It refuses a
+site without a staging area. The site `dotbot config init` writes has both; a
+charger is added in `site.toml`, or with the Object tool of `dotbot site edit`:
+
+```toml
+[objects.pad-a]
+kind = "charger"
+x = 3200
+y = 3900
+```
 
 ### 1. Start the simulator
 
diff --git a/dotbot/examples/charging_station/charging_station.py b/dotbot/examples/charging_station/charging_station.py
index dc71be50..95b5b557 100644
--- a/dotbot/examples/charging_station/charging_station.py
+++ b/dotbot/examples/charging_station/charging_station.py
@@ -1,6 +1,7 @@
 """Queue robots on the border between the field and staging, charge them one
-at a time at a charger on staging's far edge, then park them along the field's
-opposite edge. Every position comes from the controller's site."""
+at a time at a charger, then park them along the field's opposite edge. Every
+position comes from the controller's site: the charger is the site's first
+`charger` object, else a point on staging's far edge."""
 
 import asyncio
 import math
@@ -62,7 +63,11 @@ class ChargingLayout:
 
 
 def layout_from_site(site: Site) -> ChargingLayout:
-    """The layout for a site with a field and a staging area above or below it."""
+    """The layout for a site with a field and a staging area above or below it.
+
+    A site with a `charger` object puts the charger there, and the queue's
+    head in line with it.
+    """
     field, staging = site.field, site.staging
     if field is None or staging is None:
         raise ValueError(
@@ -70,11 +75,17 @@ def layout_from_site(site: Site) -> ChargingLayout:
             "`dotbot config init` writes a site with both"
         )
     below = staging.centre[1] >= field.centre[1]
-    head_x = staging.x + min(QUEUE_HEAD_INSET, staging.w // 4)
+    chargers = site.objects_of("charger")
+    if chargers:
+        charger = chargers[0]
+        head_x = charger.x
+    else:
+        charger = None
+        head_x = staging.x + min(QUEUE_HEAD_INSET, staging.w // 4)
     if below:
         return ChargingLayout(
             charger_x=head_x,
-            charger_y=staging.y_max - CHARGER_INSET,
+            charger_y=charger.y if charger else staging.y_max - CHARGER_INSET,
             queue_head_x=head_x,
             queue_head_y=staging.y,
             park_x=field.x + PARK_INSET,
@@ -83,7 +94,7 @@ def layout_from_site(site: Site) -> ChargingLayout:
         )
     return ChargingLayout(
         charger_x=head_x,
-        charger_y=staging.y + CHARGER_INSET,
+        charger_y=charger.y if charger else staging.y + CHARGER_INSET,
         queue_head_x=head_x,
         queue_head_y=staging.y_max,
         park_x=field.x + PARK_INSET,

From 0cb3503b11d88dc540b55c0d65f9e87a2e260f92 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:14:12 +0200
Subject: [PATCH 66/80] dotbot/site_editor: patch objects in site.toml

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py             |  12 +++
 dotbot/site_toml.py               | 116 ++++++++++++++++++++--------
 dotbot/tests/test_site_objects.py | 123 ++++++++++++++++++++++++++++++
 3 files changed, 220 insertions(+), 31 deletions(-)
 create mode 100644 dotbot/tests/test_site_objects.py

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index 997a5b4a..d0cd83fc 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -53,6 +53,17 @@ class BarrierModel(BaseModel):
     was: int | None = None
 
 
+class ObjectModel(BaseModel):
+    name: str
+    kind: Literal["charger", "dock", "landmark", "camera"]
+    x: int
+    y: int
+    heading_deg: float = 0.0
+    comment: str | None = None
+    # The object's name in the file when the page loaded it; None for a new one
+    was: str | None = None
+
+
 class SiteModel(BaseModel):
     anchor: str | None = None
     extent_mm: tuple[int, int] | None = None
@@ -60,6 +71,7 @@ class SiteModel(BaseModel):
     # None leaves the file's table as it is
     walls: list[BarrierModel] | None = None
     obstacles: list[BarrierModel] | None = None
+    objects: list[ObjectModel] | None = None
 
 
 class SaveRequest(BaseModel):
diff --git a/dotbot/site_toml.py b/dotbot/site_toml.py
index e04b4fd7..8f11a4ff 100644
--- a/dotbot/site_toml.py
+++ b/dotbot/site_toml.py
@@ -22,6 +22,11 @@
 from dotbot.config import SiteSection
 
 AREA_KEYS = ("x", "y", "w", "h")
+# Each table of named tables the editor models, and its keys in file order;
+# the first may be left out (None), the rest are whole millimetres
+NAMED = {"areas": ("role", *AREA_KEYS), "objects": ("kind", "x", "y")}
+# An object's optional heading, written only when not zero
+HEADING = "heading_deg"
 # The arrays of tables of barriers, and the fewest points each entry takes
 BARRIERS = {"walls": 2, "obstacles": 3}
 
@@ -40,18 +45,22 @@ def _comment(item: Any) -> str | None:
     return comment or None
 
 
-def _areas_table(doc: TOMLDocument) -> Table | None:
-    if "areas" not in doc:
+def _named_table(doc: TOMLDocument, key: str) -> Table | None:
+    if key not in doc:
         return None
-    areas = doc["areas"]
-    if not isinstance(areas, Table):
+    table = doc[key]
+    if not isinstance(table, Table):
         raise SiteTomlError(
-            "the site editor edits areas written as one run of [areas.<name>] "
-            "tables, or as one [areas] table; this file writes them otherwise "
+            f"the site editor edits {key} written as one run of [{key}.<name>] "
+            f"tables, or as one [{key}] table; this file writes them otherwise "
             "(split by another table, as dotted keys or inline), so edit it by "
             "hand or gather them first"
         )
-    return areas
+    return table
+
+
+def _areas_table(doc: TOMLDocument) -> Table | None:
+    return _named_table(doc, "areas")
 
 
 def site_model(doc: TOMLDocument) -> dict[str, Any]:
@@ -75,6 +84,17 @@ def site_model(doc: TOMLDocument) -> dict[str, Any]:
         "areas": areas,
         "connection": dict(connection) if connection is not None else None,
         **{key: _barriers_model(doc, key) for key in BARRIERS},
+        "objects": [
+            {
+                "name": name,
+                "kind": item.get("kind"),
+                "x": int(item["x"]),
+                "y": int(item["y"]),
+                HEADING: float(item.get(HEADING, 0.0)),
+                "comment": _comment(item),
+            }
+            for name, item in (_named_table(doc, "objects") or {}).items()
+        ],
     }
 
 
@@ -133,30 +153,33 @@ def _set_comment(item: Any, comment: str | None) -> None:
         item.trivia.comment_ws = ""
 
 
-def _new_area(inline: bool, area: dict[str, Any]) -> Table | InlineTable:
+def _new_entry(key: str, inline: bool, entry: dict[str, Any]) -> Table | InlineTable:
     item = tomlkit.inline_table() if inline else tomlkit.table()
-    if area.get("role") is not None:
-        item["role"] = area["role"]
-    for key in AREA_KEYS:
-        item[key] = area[key]
-    _set_comment(item, area.get("comment"))
+    first, *numbers = NAMED[key]
+    if entry.get(first) is not None:
+        item[first] = entry[first]
+    for field in numbers:
+        item[field] = entry[field]
+    if entry.get(HEADING):
+        item[HEADING] = entry[HEADING]
+    _set_comment(item, entry.get("comment"))
     return item
 
 
-def _check_names(areas: list[dict[str, Any]]) -> None:
+def _check_names(entries: list[dict[str, Any]], what: str = "area") -> None:
     seen = set()
-    for area in areas:
-        name = area["name"]
+    for entry in entries:
+        name = entry["name"]
         if not isinstance(name, str) or not name.strip():
-            raise SiteTomlError("an area needs a name")
+            raise SiteTomlError(f"an {what} needs a name")
         if name != name.strip():
-            raise SiteTomlError(f"area {name!r}: no spaces around the name")
+            raise SiteTomlError(f"{what} {name!r}: no spaces around the name")
         if "," in name:
             raise SiteTomlError(
-                f"area {name!r}: a comma makes the name read as an x,y,w,h literal"
+                f"{what} {name!r}: a comma makes the name read as an x,y,w,h literal"
             )
         if name in seen:
-            raise SiteTomlError(f"two areas are named {name!r}")
+            raise SiteTomlError(f"two {what}s are named {name!r}")
         seen.add(name)
 
 
@@ -230,12 +253,20 @@ def _rename(table: Table, was: str, name: str) -> None:
 
 
 def _patch_areas(doc: TOMLDocument, areas: list[dict[str, Any]]) -> None:
-    table = _areas_table(doc)
+    _patch_named(doc, "areas", areas)
+
+
+def _patch_named(doc: TOMLDocument, key: str, areas: list[dict[str, Any]]) -> None:
+    """Write one table of named tables (`areas`, `objects`); an entry's `was`
+    names it as the file does, so a rename is told from a delete and an add."""
+    table = _named_table(doc, key)
     if table is None:
         if not areas:
             return
         table = tomlkit.table(is_super_table=True)
-        doc["areas"] = table
+        if not tomlkit.dumps(doc).endswith("\n\n"):
+            doc.add(tomlkit.nl())
+        doc[key] = table
     inline = any(isinstance(item, InlineTable) for item in table.values())
     renames = {
         area["was"]: area["name"]
@@ -244,11 +275,11 @@ def _patch_areas(doc: TOMLDocument, areas: list[dict[str, Any]]) -> None:
     }
     kept = {area.get("was") or area["name"] for area in areas}
     for name in [name for name in table if name not in kept]:
-        _delete_table(doc, "areas", table, name)
+        _delete_table(doc, key, table, name)
     for was in renames:
         if was not in table:
-            raise SiteTomlError(f"area {was!r} is not in the file")
-    # A swap or a chain goes through names no area has, so it never meets itself
+            raise SiteTomlError(f"{key} entry {was!r} is not in the file")
+    # A swap or a chain goes through names no entry has, so it never meets itself
     clash = any(name in table for name in renames.values())
     passing = {
         was: f"\0rename-{i}" if clash else name
@@ -261,25 +292,28 @@ def _patch_areas(doc: TOMLDocument, areas: list[dict[str, Any]]) -> None:
             if through != renames[was]:
                 _rename(table, through, renames[was])
     except (KeyError, ValueError) as exc:
-        raise SiteTomlError(f"could not rename the areas in this file: {exc}") from exc
+        raise SiteTomlError(f"could not rename the {key} in this file: {exc}") from exc
     for area in areas:
         name = area["name"]
         if name not in table:
             last = table[list(table)[-1]] if table else None
             tail = _split_trailing(last) if isinstance(last, Table) else ""
-            table[name] = _new_area(inline, area)
+            table[name] = _new_entry(key, inline, area)
             if isinstance(table[name], Table):
                 _end_with(table[name], tail)
             elif isinstance(last, Table):
                 _end_with(last, tail)
             continue
         item = table[name]
-        _set(item, "role", area.get("role"))
-        for key in AREA_KEYS:
-            _set(item, key, area[key])
+        first, *numbers = NAMED[key]
+        _set(item, first, area.get(first))
+        for field in numbers:
+            _set(item, field, area[field])
+        if key == "objects":
+            _set(item, HEADING, area.get(HEADING) or None)
         _set_comment(item, area.get("comment"))
     if not table:
-        del doc["areas"]
+        del doc[key]
 
 
 def _normal(model: dict[str, Any]) -> dict[str, Any]:
@@ -311,6 +345,23 @@ def _normal(model: dict[str, Any]) -> dict[str, Any]:
             for key in BARRIERS
             if key in model
         },
+        **(
+            {
+                "objects": sorted(
+                    (
+                        item["name"],
+                        item.get("kind"),
+                        int(item["x"]),
+                        int(item["y"]),
+                        float(item.get(HEADING) or 0.0),
+                        (item.get("comment") or "").strip() or None,
+                    )
+                    for item in model.get("objects") or []
+                )
+            }
+            if "objects" in model
+            else {}
+        ),
     }
 
 
@@ -385,6 +436,9 @@ def patch(doc: TOMLDocument, model: dict[str, Any]) -> TOMLDocument:
         array.clear()
         array.extend(int(v) for v in extent)
     _patch_areas(doc, areas)
+    if "objects" in model:
+        _check_names(model["objects"] or [], "object")
+        _patch_named(doc, "objects", model["objects"] or [])
     for key in BARRIERS:
         if key in model:
             _patch_barriers(doc, key, model[key] or [])
diff --git a/dotbot/tests/test_site_objects.py b/dotbot/tests/test_site_objects.py
new file mode 100644
index 00000000..04eb0388
--- /dev/null
+++ b/dotbot/tests/test_site_objects.py
@@ -0,0 +1,123 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""A site's objects: read from site.toml, served, patched by the editor,
+charged at in the simulator, and used by the charging-station example."""
+
+import tomllib
+
+import pytest
+import tomlkit
+
+from dotbot.config import SiteSection
+from dotbot.dotbot_simulator import (
+    DotBotSimulatorCommunicationInterface,
+    InitStateToml,
+    SimulatedDotBotSettings,
+)
+from dotbot.examples.charging_station.charging_station import layout_from_site
+from dotbot.models import DotBotSiteModel
+from dotbot.sim.plant import INITIAL_BATTERY_VOLTAGE
+from dotbot.site import SiteObject, site_from_table
+from dotbot.site_toml import patched_text, site_model
+
+SITE_TOML = """\
+anchor = "the door corner"
+extent_mm = [2000, 4000]
+
+[areas.field]
+x = 0
+y = 0
+w = 2000
+h = 2000
+
+[areas.staging]
+x = 0
+y = 2000
+w = 2000
+h = 2000
+
+[objects.charger-1]   # the pad by the door
+kind = "charger"
+x = 800
+y = 3800
+heading_deg = 180.0
+"""
+
+
+def _site():
+    table = SiteSection.model_validate(tomllib.loads(SITE_TOML))
+    return site_from_table("lab", table)
+
+
+def test_objects_are_read_and_served():
+    site = _site()
+    assert site.objects == {
+        "charger-1": SiteObject("charger-1", "charger", 800, 3800, 180.0)
+    }
+    assert site.objects_of("charger") == [site.objects["charger-1"]]
+    model = DotBotSiteModel.from_site(site)
+    assert model.objects[0].kind == "charger"
+    assert model.to_site().objects == site.objects
+
+
+def test_an_unknown_kind_is_refused():
+    with pytest.raises(ValueError, match="charger"):
+        SiteSection.model_validate(
+            tomllib.loads('[objects.x]\nkind = "teleporter"\nx = 0\ny = 0\n')
+        )
+
+
+def _loaded(text):
+    model = site_model(tomlkit.parse(text))
+    for key in ("areas", "objects"):
+        for entry in model[key]:
+            entry["was"] = entry["name"]
+    for key in ("walls", "obstacles"):
+        for index, entry in enumerate(model[key]):
+            entry["was"] = index
+    return model
+
+
+def test_the_editor_round_trips_and_moves_an_object():
+    model = _loaded(SITE_TOML)
+    assert patched_text(SITE_TOML, model) == SITE_TOML
+    assert model["objects"][0]["comment"] == "the pad by the door"
+    model["objects"][0]["x"] = 600
+    model["objects"][0]["name"] = "pad"
+    result = patched_text(SITE_TOML, model)
+    assert "[objects.pad]   # the pad by the door\n" in result
+    assert "x = 600\n" in result and "heading_deg = 180.0" in result
+
+
+def test_the_editor_adds_an_object_and_drops_a_zero_heading():
+    model = _loaded(SITE_TOML)
+    model["objects"].append(
+        {"name": "dock", "kind": "dock", "x": 100, "y": 100, "heading_deg": 0}
+    )
+    result = patched_text(SITE_TOML, model)
+    assert '[objects.dock]\nkind = "dock"\nx = 100\ny = 100\n' in result
+
+
+def test_the_charging_station_takes_its_charger_from_the_site():
+    layout = layout_from_site(_site())
+    assert (layout.charger_x, layout.charger_y) == (800, 3800)
+    assert (layout.queue_head_x, layout.queue_head_y) == (800, 2000)
+
+
+def test_a_simulated_robot_on_a_charger_charges_and_one_off_it_drains():
+    state = InitStateToml(
+        dotbots=[
+            SimulatedDotBotSettings(address="0000000000000001", pos_x=800, pos_y=3800),
+            SimulatedDotBotSettings(address="0000000000000002", pos_x=800, pos_y=1000),
+        ]
+    )
+    sim = DotBotSimulatorCommunicationInterface(lambda frame: None, state, site=_site())
+    sim.battery[:] = INITIAL_BATTERY_VOLTAGE / 2
+    for _ in range(1000):
+        sim.step()
+    on, off = sim.battery
+    assert list(sim.on_charger()) == [True, False]
+    # Ten seconds: a twelfth of a full charge on, a sliver of drain off
+    assert on == pytest.approx(INITIAL_BATTERY_VOLTAGE * (0.5 + 10 / 120), abs=1)
+    assert off < INITIAL_BATTERY_VOLTAGE / 2

From 4399f2098d3a933996ec8c2e1e43f06230c890b5 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:14:12 +0200
Subject: [PATCH 67/80] dotbot/console-web: draw the site's objects on the map

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/MapView.tsx           | 33 ++++++++++++++++++++
 dotbot/console-web/src/barrierLayer.test.tsx |  6 ++--
 dotbot/console-web/src/siteObjects.ts        | 21 +++++++++++++
 dotbot/console-web/src/types.ts              | 13 ++++++++
 4 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 dotbot/console-web/src/siteObjects.ts

diff --git a/dotbot/console-web/src/MapView.tsx b/dotbot/console-web/src/MapView.tsx
index abd2de82..5376e7cf 100644
--- a/dotbot/console-web/src/MapView.tsx
+++ b/dotbot/console-web/src/MapView.tsx
@@ -2,6 +2,7 @@ import React, { useCallback, useId, useMemo, useRef, useState } from "react";
 
 import { cameraStreamUrl } from "./api";
 import { areaColor } from "./areaColor";
+import { OBJECT_COLOUR, OBJECT_SIZE_MM, facing } from "./siteObjects";
 import { CalibrationLayer } from "./CalibrationLayer";
 import { calibrationSpans, hatchBox, spanTitle } from "./calibrationSpan";
 import {
@@ -1242,6 +1243,38 @@ export const MapView: React.FC<MapViewProps> = (props) => {
                 <title>{w.name || "wall"}</title>
               </polyline>
             ))}
+            {(props.site?.objects ?? []).map((o) => {
+              const { fx, fy } = areaToFraction({ x: o.x, y: o.y }, props.viewport);
+              const cx = fx * boxW;
+              const cy = fy * boxH;
+              const r = (OBJECT_SIZE_MM / 2) * (boxW / props.viewport.w);
+              const [dx, dy] = facing(o.heading_deg);
+              return (
+                <g key={`object-${o.name}`} data-testid={`object-${o.name}`}>
+                  <rect
+                    x={cx - r}
+                    y={cy - r}
+                    width={2 * r}
+                    height={2 * r}
+                    rx={r / 3}
+                    fill={OBJECT_COLOUR[o.kind]}
+                    fillOpacity={0.25}
+                    stroke={OBJECT_COLOUR[o.kind]}
+                    strokeWidth={chrome * 1.5}
+                  >
+                    <title>{`${o.name} (${o.kind})`}</title>
+                  </rect>
+                  <line
+                    x1={cx}
+                    y1={cy}
+                    x2={cx + dx * r}
+                    y2={cy + dy * r}
+                    stroke={OBJECT_COLOUR[o.kind]}
+                    strokeWidth={chrome * 1.5}
+                  />
+                </g>
+              );
+            })}
             {/* The loaded calibration: each placement's span outlined, and
                 the rest of the site hatched, where positions are
                 extrapolated. The hatch is the site masked by the spans, so
diff --git a/dotbot/console-web/src/barrierLayer.test.tsx b/dotbot/console-web/src/barrierLayer.test.tsx
index b6cad998..6f7f6c14 100644
--- a/dotbot/console-web/src/barrierLayer.test.tsx
+++ b/dotbot/console-web/src/barrierLayer.test.tsx
@@ -11,10 +11,11 @@ const SITE: Site = {
   areas: [],
   walls: [{ name: "door", points: [[0, 0], [0, 4000]] }],
   obstacles: [{ name: "", points: [[1500, 2500], [1700, 2500], [1700, 2700]] }],
+  objects: [{ name: "charger-1", kind: "charger", x: 800, y: 3800, heading_deg: 180 }],
 };
 
-describe("MapView barriers", () => {
-  it("draws the site's walls and obstacles", () => {
+describe("MapView barriers and objects", () => {
+  it("draws the site's walls, obstacles and objects", () => {
     render(
       <MapView
         bots={[]}
@@ -46,5 +47,6 @@ describe("MapView barriers", () => {
     );
     expect(screen.getByTestId("wall-door").getAttribute("points")?.split(" ")).toHaveLength(2);
     expect(screen.getByTestId("obstacle-0").getAttribute("points")?.split(" ")).toHaveLength(3);
+    expect(screen.getByTestId("object-charger-1")).toHaveTextContent("charger-1 (charger)");
   });
 });
diff --git a/dotbot/console-web/src/siteObjects.ts b/dotbot/console-web/src/siteObjects.ts
new file mode 100644
index 00000000..f27eae56
--- /dev/null
+++ b/dotbot/console-web/src/siteObjects.ts
@@ -0,0 +1,21 @@
+import type { SiteObjectKind } from "./types";
+
+// How a site object is drawn, on the map and in the site editor alike.
+
+export const OBJECT_KINDS: SiteObjectKind[] = ["charger", "dock", "landmark", "camera"];
+
+/** The drawn size of an object, in floor mm: about a robot's. */
+export const OBJECT_SIZE_MM = 120;
+
+export const OBJECT_COLOUR: Record<SiteObjectKind, string> = {
+  charger: "var(--s-Running)",
+  dock: "var(--s-Bootloader)",
+  landmark: "var(--s-Programming)",
+  camera: "var(--s-Resetting)",
+};
+
+/** The unit vector an object faces, in frame axes (heading 0 faces +y). */
+export function facing(headingDeg: number): [number, number] {
+  const t = (headingDeg * Math.PI) / 180;
+  return [-Math.sin(t), Math.cos(t)];
+}
diff --git a/dotbot/console-web/src/types.ts b/dotbot/console-web/src/types.ts
index 0618cf76..05d42585 100644
--- a/dotbot/console-web/src/types.ts
+++ b/dotbot/console-web/src/types.ts
@@ -450,6 +450,19 @@ export interface Site {
   calibration?: SiteCalibration | null;
   walls?: Barrier[];
   obstacles?: Barrier[];
+  objects?: SiteObject[];
+}
+
+// A thing on the floor at a pose in frame mm; `heading_deg` follows the
+// robots' convention (0 faces +y).
+export type SiteObjectKind = "charger" | "dock" | "landmark" | "camera";
+
+export interface SiteObject {
+  name: string;
+  kind: SiteObjectKind;
+  x: number;
+  y: number;
+  heading_deg: number;
 }
 
 // Where robots cannot go, in frame mm: a wall is a polyline, an obstacle a

From 313a2d757a4cc81cf9eea317a616bb519431f2f9 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:14:12 +0200
Subject: [PATCH 68/80] dotbot/console-web: place and edit objects in the site
 editor

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/siteEditor/Canvas.tsx  |  72 ++++++++++-
 .../console-web/src/siteEditor/Inspector.tsx  | 112 +++++++++++++++++-
 .../console-web/src/siteEditor/SiteEditor.tsx |  64 +++++++++-
 dotbot/console-web/src/siteEditor/api.ts      |   2 +
 .../console-web/src/siteEditor/edit.test.ts   |  20 +++-
 dotbot/console-web/src/siteEditor/edit.ts     |  23 ++++
 .../src/siteEditor/siteEditor.test.tsx        |  18 +++
 dotbot/console-web/src/siteEditor/types.ts    |  15 ++-
 8 files changed, 313 insertions(+), 13 deletions(-)

diff --git a/dotbot/console-web/src/siteEditor/Canvas.tsx b/dotbot/console-web/src/siteEditor/Canvas.tsx
index e9fab655..49abcce7 100644
--- a/dotbot/console-web/src/siteEditor/Canvas.tsx
+++ b/dotbot/console-web/src/siteEditor/Canvas.tsx
@@ -2,6 +2,7 @@ import React, { useEffect, useRef, useState } from "react";
 
 import { areaColor } from "../areaColor";
 import { convexHull } from "../calibrationSpan";
+import { OBJECT_COLOUR, OBJECT_SIZE_MM, facing } from "../siteObjects";
 import { AREA_FALLBACK, siteViewMarginMm, withMargin } from "../frame";
 import {
   axisTicks,
@@ -27,13 +28,14 @@ import type {
   CameraBackdrop,
   EditArea,
   EditBarrier,
+  EditObject,
 } from "./types";
 
 // The site drawn to scale: the extent, the metric grid and its rulers, and
 // every area in its role colour. Areas are moved, resized and drawn here; the
 // numbers themselves live in the inspector.
 
-export type Tool = "select" | "area" | "calibration" | "wall" | "obstacle";
+export type Tool = "select" | "area" | "calibration" | "wall" | "obstacle" | "object";
 
 /** A selected wall or obstacle. */
 export interface BarrierRef {
@@ -65,6 +67,7 @@ type Drag =
   | { kind: "place-move"; start: Rigid2D; from: { x: number; y: number } }
   | { kind: "barrier-move"; ref: BarrierRef; start: [number, number][]; from: { x: number; y: number } }
   | { kind: "barrier-vertex"; ref: BarrierRef; vertex: number }
+  | { kind: "object-move"; index: number; start: { x: number; y: number }; from: { x: number; y: number } }
   | { kind: "place-turn"; start: Rigid2D; pivot: Point; angle: number };
 
 export interface CanvasProps {
@@ -87,6 +90,11 @@ export interface CanvasProps {
   /** `key` names the gesture, so one drag undoes as one step. */
   onBarrierChange?: (ref: BarrierRef, points: [number, number][], key: string) => void;
   onBarrierDraw?: (kind: BarrierKind, points: [number, number][]) => void;
+  objects?: EditObject[];
+  selectedObject?: number | null;
+  onSelectObject?: (index: number | null) => void;
+  onObjectChange?: (index: number, at: { x: number; y: number }, key: string) => void;
+  onObjectPlace?: (at: { x: number; y: number }) => void;
   /** Read-only layers under the areas: only the ones switched on. */
   backdrops?: { calibrations: CalibrationBackdrop[]; cameras: CameraBackdrop[] };
 }
@@ -206,15 +214,30 @@ export function Canvas(props: CanvasProps) {
       setDraft((d) => (d && d.kind === draftKind ? { ...d, points: [...d.points, point] } : { kind: draftKind, points: [point] }));
       return;
     }
+    if (props.tool === "object") {
+      const p = toFrame(e);
+      const s = snapNow(e);
+      props.onObjectPlace?.({ x: snap(p.x, s), y: snap(p.y, s) });
+      return;
+    }
     if (props.tool === "area") {
       const p = toFrame(e);
       begin(e, { kind: "draw", from: p, to: p });
     } else {
       props.onSelect(null);
       props.onSelectBarrier?.(null);
+      props.onSelectObject?.(null);
     }
   };
 
+  const onObjectDown = (e: React.PointerEvent, index: number) => {
+    if (e.button !== 0 || props.tool !== "select") return;
+    const o = props.objects?.[index];
+    if (!o) return;
+    props.onSelectObject?.(index);
+    begin(e, { kind: "object-move", index, start: { x: o.x, y: o.y }, from: toFrame(e) });
+  };
+
   const onBarrierDown = (e: React.PointerEvent, ref: BarrierRef) => {
     if (e.button !== 0 || props.tool !== "select") return;
     const b = (ref.kind === "walls" ? props.walls : props.obstacles)?.[ref.index];
@@ -276,7 +299,13 @@ export function Canvas(props: CanvasProps) {
     if (!drag) return;
     const p = toFrame(e);
     const s = snapNow(e);
-    if (drag.kind === "barrier-move") {
+    if (drag.kind === "object-move") {
+      props.onObjectChange?.(
+        drag.index,
+        { x: snap(drag.start.x + p.x - drag.from.x, s), y: snap(drag.start.y + p.y - drag.from.y, s) },
+        `canvas-${gesture.current}`,
+      );
+    } else if (drag.kind === "barrier-move") {
       props.onBarrierChange?.(drag.ref, movePoints(drag.start, p.x - drag.from.x, p.y - drag.from.y, s), `canvas-${gesture.current}`);
     } else if (drag.kind === "barrier-vertex") {
       const b = (drag.ref.kind === "walls" ? props.walls : props.obstacles)?.[drag.ref.index];
@@ -341,7 +370,7 @@ export function Canvas(props: CanvasProps) {
         minHeight: 0,
         overflow: "hidden",
         background: "var(--canvas)",
-        cursor: props.tool === "area" || draftKind ? "crosshair" : "default",
+        cursor: props.tool === "area" || props.tool === "object" || draftKind ? "crosshair" : "default",
         touchAction: "none",
         userSelect: "none",
       }}
@@ -516,6 +545,43 @@ export function Canvas(props: CanvasProps) {
               />
             ),
           )}
+        {(props.objects ?? []).map((o, i) => {
+          const r = Math.max(5, (OBJECT_SIZE_MM / 2) * scale);
+          const [cx, cy] = [px("x", o.x), px("y", o.y)];
+          const [dx, dy] = facing(o.heading_deg);
+          const chosen = props.selectedObject === i;
+          return (
+            <g
+              key={`obj-${i}`}
+              data-testid={`edit-object-${o.name}`}
+              style={{ cursor: props.tool === "select" ? "move" : undefined }}
+              onPointerDown={(e) => onObjectDown(e, i)}
+            >
+              <rect
+                x={cx - r}
+                y={cy - r}
+                width={2 * r}
+                height={2 * r}
+                rx={r / 3}
+                fill={OBJECT_COLOUR[o.kind]}
+                fillOpacity={0.25}
+                stroke={chosen ? "var(--accent)" : OBJECT_COLOUR[o.kind]}
+                strokeWidth={chosen ? 2.5 : 1.5}
+              />
+              <line x1={cx} y1={cy} x2={cx + dx * r} y2={cy + dy * r} stroke={OBJECT_COLOUR[o.kind]} strokeWidth={1.5} />
+              <text
+                x={cx + r + 4}
+                y={cy + 4}
+                fontSize={10}
+                fontFamily="var(--font-mono)"
+                fill={OBJECT_COLOUR[o.kind]}
+                style={{ pointerEvents: "none" }}
+              >
+                {o.name}
+              </text>
+            </g>
+          );
+        })}
         {draft && (
           <g data-testid="barrier-draft" style={{ pointerEvents: "none" }}>
             <polyline
diff --git a/dotbot/console-web/src/siteEditor/Inspector.tsx b/dotbot/console-web/src/siteEditor/Inspector.tsx
index 766e3e16..450f089c 100644
--- a/dotbot/console-web/src/siteEditor/Inspector.tsx
+++ b/dotbot/console-web/src/siteEditor/Inspector.tsx
@@ -1,10 +1,11 @@
 import React, { useState } from "react";
 
-import type { AreaRole } from "../types";
+import { OBJECT_KINDS } from "../siteObjects";
+import type { AreaRole, SiteObjectKind } from "../types";
 import type { BarrierRef } from "./Canvas";
 import { BARRIER_MIN_POINTS, ROLES, declaredRole, effectiveRole, parsePoints } from "./edit";
 import type { Issue } from "./edit";
-import type { Backdrops, BarrierKind, EditArea, EditBarrier, SiteModel } from "./types";
+import type { Backdrops, BarrierKind, EditArea, EditBarrier, EditObject, SiteModel } from "./types";
 
 // The right pane: every field is a key of site.toml, and what it shows is
 // what Save writes.
@@ -79,6 +80,10 @@ export interface InspectorProps {
   onSelectBarrier?: (ref: BarrierRef | null) => void;
   onBarrier?: (ref: BarrierRef, patch: Partial<EditBarrier>, key: string) => void;
   onDeleteBarrier?: (ref: BarrierRef) => void;
+  selectedObject?: number | null;
+  onSelectObject?: (index: number | null) => void;
+  onObject?: (index: number, patch: Partial<EditObject>, key: string) => void;
+  onDeleteObject?: (index: number) => void;
   backdrops?: Backdrops | null;
   /** Keys `cal:<id8>` and `cam:<id8>` of the backdrops switched on. */
   shownBackdrops?: Set<string>;
@@ -164,6 +169,76 @@ function BarrierInspector(props: {
   );
 }
 
+function ObjectInspector(props: {
+  object: EditObject;
+  onChange: (patch: Partial<EditObject>, key: string) => void;
+  onDelete: () => void;
+}) {
+  const o = props.object;
+  return (
+    <div style={section} data-testid="object-inspector">
+      <div style={heading}>Object</div>
+      <label>
+        <span style={label}>name</span>
+        <input
+          aria-label="object name"
+          value={o.name}
+          onChange={(e) => props.onChange({ name: e.target.value }, "object-name")}
+          style={input}
+        />
+      </label>
+      <label>
+        <span style={label}>kind</span>
+        <select
+          aria-label="object kind"
+          value={o.kind}
+          onChange={(e) => props.onChange({ kind: e.target.value as SiteObjectKind }, "object-kind")}
+          style={input}
+        >
+          {OBJECT_KINDS.map((k) => (
+            <option key={k} value={k}>
+              {k}
+            </option>
+          ))}
+        </select>
+      </label>
+      <div style={{ display: "flex", gap: 8 }}>
+        <NumberField name="object x" value={o.x} onChange={(x) => props.onChange({ x }, "object-x")} />
+        <NumberField name="object y" value={o.y} onChange={(y) => props.onChange({ y }, "object-y")} />
+      </div>
+      <NumberField
+        name="heading (deg, 0 faces +y)"
+        value={o.heading_deg}
+        onChange={(heading_deg) => props.onChange({ heading_deg }, "object-heading")}
+      />
+      <label>
+        <span style={label}>comment (kept in the file)</span>
+        <input
+          aria-label="object comment"
+          value={o.comment ?? ""}
+          onChange={(e) => props.onChange({ comment: e.target.value }, "object-comment")}
+          style={{ ...input, fontFamily: "var(--font-ui)" }}
+        />
+      </label>
+      <button
+        type="button"
+        onClick={props.onDelete}
+        style={{
+          marginTop: 12,
+          background: "transparent",
+          color: "var(--accent)",
+          border: "1px solid var(--accent)",
+          borderRadius: 4,
+          padding: "4px 10px",
+          cursor: "pointer",
+        }}
+      >
+        Delete object
+      </button>
+    </div>
+  );
+}
+
 export function Inspector(props: InspectorProps) {
   const { site } = props;
   const area = props.selected !== null ? site.areas[props.selected] : null;
@@ -305,6 +380,14 @@ export function Inspector(props: InspectorProps) {
         />
       )}
 
+      {props.selectedObject !== null && props.selectedObject !== undefined && site.objects?.[props.selectedObject] && (
+        <ObjectInspector
+          object={site.objects[props.selectedObject]}
+          onChange={(patch, key) => props.onObject?.(props.selectedObject!, patch, `${key}-${props.selectedObject}`)}
+          onDelete={() => props.onDeleteObject?.(props.selectedObject!)}
+        />
+      )}
+
       <div style={section}>
         <div style={{ display: "flex", alignItems: "center" }}>
           <div style={{ ...heading, flex: 1 }}>Areas</div>
@@ -354,6 +437,31 @@ export function Inspector(props: InspectorProps) {
         ))}
       </div>
 
+      {(site.objects ?? []).length > 0 && (
+        <div style={section} data-testid="objects">
+          <div style={heading}>Objects</div>
+          {(site.objects ?? []).map((o, i) => (
+            <div
+              key={i}
+              onClick={() => props.onSelectObject?.(i)}
+              style={{
+                display: "flex",
+                gap: 6,
+                padding: "4px 6px",
+                marginTop: 4,
+                borderRadius: 4,
+                background: props.selectedObject === i ? "var(--elevated)" : "transparent",
+                cursor: "pointer",
+                fontSize: 12,
+              }}
+            >
+              <span style={{ flex: 1, fontFamily: "var(--font-mono)" }}>{o.name || "(no name)"}</span>
+              <span style={{ color: "var(--muted)", fontSize: 11 }}>{o.kind}</span>
+            </div>
+          ))}
+        </div>
+      )}
+
       {((site.walls ?? []).length > 0 || (site.obstacles ?? []).length > 0) && (
         <div style={section} data-testid="barriers">
           <div style={heading}>Walls and obstacles</div>
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index 95155872..e6ec62b9 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -20,6 +20,7 @@ import {
   SNAP_STEPS_MM,
   frameChanged,
   freshName,
+  freshObjectName,
   sameSite,
   siteIssues,
 } from "./edit";
@@ -33,6 +34,7 @@ import type {
   BarrierKind,
   CalibrationListing,
   EditArea,
+  EditObject,
   PlacedCalibration,
   SiteModel,
   SiteResponse,
@@ -69,13 +71,13 @@ const button: React.CSSProperties = {
   fontFamily: "var(--font-ui)",
 };
 
-const TOOLS: { key: Tool | "charger"; label: string; hint: string }[] = [
+const TOOLS: { key: Tool; label: string; hint: string }[] = [
   { key: "select", label: "Select", hint: "V: select, move and resize" },
   { key: "area", label: "Area", hint: "A: drag out a new area" },
   { key: "calibration", label: "Calibration", hint: "C: place a spin calibration on the site" },
   { key: "wall", label: "Wall", hint: "W: click the points of a wall, double-click to finish" },
   { key: "obstacle", label: "Obstacle", hint: "O: click the corners of an obstacle, double-click to finish" },
-  { key: "charger", label: "Charger", hint: "needs an objects table in site.toml first" },
+  { key: "object", label: "Object", hint: "B: click to place a charger, dock, landmark or camera" },
 ];
 
 const NOT_TYPED = new Set(["checkbox", "radio", "button", "submit", "reset", "range", "color", "file"]);
@@ -101,15 +103,29 @@ export function SiteEditor() {
     });
   const [selectedArea, setSelectedArea] = useState<number | null>(null);
   const [selectedBarrier, setSelectedBarrier] = useState<BarrierRef | null>(null);
+  const [selectedObject, setSelectedObject] = useState<number | null>(null);
   const selected = selectedArea;
-  // One thing is selected at a time: an area or a barrier
+  // One thing is selected at a time: an area, a barrier or an object
   const setSelected = (index: number | null) => {
     setSelectedArea(index);
-    if (index !== null) setSelectedBarrier(null);
+    if (index !== null) {
+      setSelectedBarrier(null);
+      setSelectedObject(null);
+    }
   };
   const selectBarrier = (ref: BarrierRef | null) => {
     setSelectedBarrier(ref);
-    if (ref !== null) setSelectedArea(null);
+    if (ref !== null) {
+      setSelectedArea(null);
+      setSelectedObject(null);
+    }
+  };
+  const selectObject = (index: number | null) => {
+    setSelectedObject(index);
+    if (index !== null) {
+      setSelectedArea(null);
+      setSelectedBarrier(null);
+    }
   };
   const [hidden, setHidden] = useState<Set<string>>(new Set());
   const [tool, setTool] = useState<Tool>("select");
@@ -236,6 +252,27 @@ export function SiteEditor() {
     setSite((s) => ({ ...s, [ref.kind]: (s[ref.kind] ?? []).filter((_, i) => i !== ref.index) }));
     setSelectedBarrier(null);
   };
+  const updateObject = (index: number, patch: Partial<EditObject>, key: string | null = null) => {
+    setSite((s) => ({ ...s, objects: (s.objects ?? []).map((o, i) => (i === index ? { ...o, ...patch } : o)) }), key);
+  };
+  const addObject = (at: { x: number; y: number }) => {
+    const list = site?.objects ?? [];
+    const object: EditObject = {
+      name: freshObjectName(list.map((o) => o.name), "charger"),
+      kind: "charger",
+      ...at,
+      heading_deg: 0,
+      comment: null,
+      was: null,
+    };
+    setSite((s) => ({ ...s, objects: [...(s.objects ?? []), object] }));
+    selectObject(list.length);
+    setTool("select");
+  };
+  const deleteObject = (index: number) => {
+    setSite((s) => ({ ...s, objects: (s.objects ?? []).filter((_, i) => i !== index) }));
+    setSelectedObject(null);
+  };
   const addDefaultArea = () => {
     const [w, h] = site?.extent_mm ?? [2000, 2000];
     addArea({ x: 0, y: 0, w: Math.min(1000, w), h: Math.min(1000, h) });
@@ -247,6 +284,9 @@ export function SiteEditor() {
     } else if (selected !== null && site?.areas[selected]) {
       const a = site.areas[selected];
       updateArea(selected, { x: a.x + dx, y: a.y + dy }, `nudge-${selected}`);
+    } else if (selectedObject !== null && site?.objects?.[selectedObject]) {
+      const o = site.objects[selectedObject];
+      updateObject(selectedObject, { x: o.x + dx, y: o.y + dy }, `nudge-object-${selectedObject}`);
     } else if (selectedBarrier && site?.[selectedBarrier.kind]?.[selectedBarrier.index]) {
       const b = site[selectedBarrier.kind]![selectedBarrier.index];
       updateBarrier(
@@ -286,12 +326,15 @@ export function SiteEditor() {
       else if (e.key === "c" || e.key === "C") setTool("calibration");
       else if (e.key === "w" || e.key === "W") setTool("wall");
       else if (e.key === "o" || e.key === "O") setTool("obstacle");
+      else if (e.key === "b" || e.key === "B") setTool("object");
       else if (e.key === "Escape") {
         setSelected(null);
         setSelectedBarrier(null);
+        setSelectedObject(null);
       } else if ((e.key === "Delete" || e.key === "Backspace") && tool === "select") {
         if (selected !== null) deleteArea(selected);
         else if (selectedBarrier) deleteBarrier(selectedBarrier);
+        else if (selectedObject !== null) deleteObject(selectedObject);
       }
     };
     window.addEventListener("keydown", onKey);
@@ -496,7 +539,7 @@ export function SiteEditor() {
           }}
         >
           {TOOLS.map((t) => {
-            const enabled = t.key !== "charger";
+            const enabled = true;
             const active = t.key === tool;
             return (
               <button
@@ -538,6 +581,11 @@ export function SiteEditor() {
             onSelectBarrier={selectBarrier}
             onBarrierChange={(ref, points, key) => updateBarrier(ref, points, key)}
             onBarrierDraw={addBarrier}
+            objects={site.objects ?? []}
+            selectedObject={selectedObject}
+            onSelectObject={selectObject}
+            onObjectChange={(i, at, key) => updateObject(i, at, key)}
+            onObjectPlace={addObject}
             placement={placement}
             onPlacement={(move) => setPlacement((p) => (p ? { ...p, move } : p))}
             backdrops={
@@ -578,6 +626,10 @@ export function SiteEditor() {
             onSelectBarrier={selectBarrier}
             onBarrier={(ref, patch, key) => updateBarrier(ref, null, key, patch)}
             onDeleteBarrier={deleteBarrier}
+            selectedObject={selectedObject}
+            onSelectObject={selectObject}
+            onObject={(i, patch, key) => updateObject(i, patch, key)}
+            onDeleteObject={deleteObject}
             backdrops={backdrops}
             shownBackdrops={shownBackdrops}
             onToggleBackdrop={(key) =>
diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
index 53c369ce..5436f702 100644
--- a/dotbot/console-web/src/siteEditor/api.ts
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -30,6 +30,7 @@ function outgoing(site: SiteModel) {
     areas: site.areas.map((a) => ({ ...a, comment: a.comment || null })),
     walls: (site.walls ?? []).map((b) => ({ ...b, name: b.name || null, comment: b.comment || null })),
     obstacles: (site.obstacles ?? []).map((b) => ({ ...b, name: b.name || null, comment: b.comment || null })),
+    objects: (site.objects ?? []).map((o) => ({ ...o, comment: o.comment || null })),
   };
 }
 
@@ -42,6 +43,7 @@ export function withOrigins(body: SiteResponse): SiteResponse {
       areas: body.site.areas.map((a) => ({ ...a, was: a.name })),
       walls: (body.site.walls ?? []).map((b, i) => ({ ...b, was: i })),
       obstacles: (body.site.obstacles ?? []).map((b, i) => ({ ...b, was: i })),
+      objects: (body.site.objects ?? []).map((o) => ({ ...o, was: o.name })),
     },
   };
 }
diff --git a/dotbot/console-web/src/siteEditor/edit.test.ts b/dotbot/console-web/src/siteEditor/edit.test.ts
index 8b808138..02e70369 100644
--- a/dotbot/console-web/src/siteEditor/edit.test.ts
+++ b/dotbot/console-web/src/siteEditor/edit.test.ts
@@ -12,7 +12,7 @@ import {
   siteIssues,
   snap,
 } from "./edit";
-import { finishPoints, movePoints, parsePoints } from "./edit";
+import { finishPoints, freshObjectName, movePoints, parsePoints } from "./edit";
 import type { EditArea, SiteModel } from "./types";
 
 const area = (name: string, x: number, y: number, w: number, h: number, role: EditArea["role"] = null): EditArea => ({
@@ -171,3 +171,21 @@ describe("barriers", () => {
     expect(messages).toContain("warning: obstacle 1 reaches outside the extent");
   });
 });
+
+describe("objects", () => {
+  it("names a new object after the ones taken, and checks names", () => {
+    expect(freshObjectName(["charger-1"], "charger")).toBe("charger-2");
+    const site = {
+      anchor: null,
+      extent_mm: [2000, 2000] as [number, number],
+      areas: [],
+      objects: [
+        { name: "a", kind: "charger" as const, x: 0, y: 0, heading_deg: 0, comment: null },
+        { name: "a", kind: "dock" as const, x: 2500, y: 0, heading_deg: 0, comment: null },
+      ],
+    };
+    const messages = siteIssues(site).map((i) => i.message);
+    expect(messages).toContain("two objects are named a");
+    expect(messages).toContain("a is outside the extent");
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/edit.ts b/dotbot/console-web/src/siteEditor/edit.ts
index 4d8de61e..92736722 100644
--- a/dotbot/console-web/src/siteEditor/edit.ts
+++ b/dotbot/console-web/src/siteEditor/edit.ts
@@ -189,9 +189,29 @@ export function siteIssues(site: SiteModel): Issue[] {
       }
     });
   }
+  const objectNames = new Map<string, number>();
+  for (const o of site.objects ?? []) objectNames.set(o.name, (objectNames.get(o.name) ?? 0) + 1);
+  for (const o of site.objects ?? []) {
+    if (!o.name.trim() || o.name !== o.name.trim()) {
+      issues.push({ level: "error", message: `an object needs a name with no spaces around it` });
+    } else if ((objectNames.get(o.name) ?? 0) > 1) {
+      issues.push({ level: "error", message: `two objects are named ${o.name}` });
+    }
+    if (extent && (o.x < 0 || o.y < 0 || o.x > extent[0] || o.y > extent[1])) {
+      issues.push({ level: "warning", message: `${o.name} is outside the extent` });
+    }
+  }
   return issues;
 }
 
+/** A name not yet taken among `names`: `base-1`, `base-2`, ... */
+export function freshObjectName(names: string[], base: string): string {
+  const taken = new Set(names);
+  for (let n = 1; ; n += 1) {
+    if (!taken.has(`${base}-${n}`)) return `${base}-${n}`;
+  }
+}
+
 /** `points` moved by (dx, dy), its first point on the snap grid. */
 export function movePoints(points: [number, number][], dx: number, dy: number, step: number): [number, number][] {
   if (points.length === 0) return points;
@@ -240,6 +260,9 @@ export function sameSite(a: SiteModel, b: SiteModel): boolean {
       obstacles: (s.obstacles ?? []).map(({ name, points, comment, was }) => ({
         name: name || null, points, comment: comment || null, was: was ?? null,
       })),
+      objects: (s.objects ?? []).map(({ name, kind, x, y, heading_deg, comment, was }) => ({
+        name, kind, x, y, heading_deg, comment: comment || null, was: was ?? null,
+      })),
     });
   return strip(a) === strip(b);
 }
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index c78ea1e2..ec38640e 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -397,3 +397,21 @@ describe("SiteEditor walls and obstacles", () => {
     expect(screen.getByTestId("edit-obstacle-0")).toBeInTheDocument();
   });
 });
+
+describe("SiteEditor objects", () => {
+  it("places a charger, turns it into a dock and saves it", async () => {
+    const fetch = server(loaded(), { status: 200, body: { ...loaded(), revision: "r2", written: true } });
+    render(<SiteEditor />);
+    await screen.findByTestId("edit-area-field");
+    fireEvent.click(screen.getByText("Object"));
+    fireEvent.pointerDown(screen.getByTestId("site-canvas"), { button: 0, clientX: 300, clientY: 300, pointerId: 1 });
+    expect(await screen.findByTestId("edit-object-charger-1")).toBeInTheDocument();
+    fireEvent.change(screen.getByLabelText("object kind"), { target: { value: "dock" } });
+    fireEvent.change(screen.getByLabelText("object name"), { target: { value: "dock-a" } });
+    await act(async () => fireEvent.click(screen.getByText("Save")));
+    const put = fetch.mock.calls.find(([, init]) => init?.method === "PUT")!;
+    const [sent] = JSON.parse(put[1]!.body as string).site.objects;
+    expect(sent).toMatchObject({ name: "dock-a", kind: "dock", heading_deg: 0, was: null });
+    expect(sent.x % 50).toBe(0);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/types.ts b/dotbot/console-web/src/siteEditor/types.ts
index ab6e095c..e76b00aa 100644
--- a/dotbot/console-web/src/siteEditor/types.ts
+++ b/dotbot/console-web/src/siteEditor/types.ts
@@ -1,4 +1,4 @@
-import type { AreaRole } from "../types";
+import type { AreaRole, SiteObjectKind } from "../types";
 
 // The editor's model of a site pack's `site.toml`, as GET /api/site serves it.
 
@@ -26,12 +26,25 @@ export interface EditBarrier {
 
 export type BarrierKind = "walls" | "obstacles";
 
+/** One `[objects.<name>]` table: a thing on the floor at a pose, frame mm. */
+export interface EditObject {
+  name: string;
+  kind: SiteObjectKind;
+  x: number;
+  y: number;
+  heading_deg: number;
+  comment: string | null;
+  /** The object's name in the file when the page loaded it; null for a new one. */
+  was?: string | null;
+}
+
 export interface SiteModel {
   anchor: string | null;
   extent_mm: [number, number] | null;
   areas: EditArea[];
   walls?: EditBarrier[];
   obstacles?: EditBarrier[];
+  objects?: EditObject[];
   connection?: { conn?: string | null; swarm_id?: string | null } | null;
 }
 

From 18c9ae4dd8b0c29e6e6bcb4c89818f85fb621387 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:12:02 +0200
Subject: [PATCH 69/80] dotbot/dotbot_simulator: charge a robot with a learned
 battery model too

AI-assisted: Claude Opus 5.5
---
 dotbot/dotbot_simulator.py        |  8 ++++++--
 dotbot/tests/test_site_objects.py | 29 +++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/dotbot/dotbot_simulator.py b/dotbot/dotbot_simulator.py
index ad89d7e9..ed62779c 100644
--- a/dotbot/dotbot_simulator.py
+++ b/dotbot/dotbot_simulator.py
@@ -682,6 +682,7 @@ def _models_update(self):
         import torch
 
         reports = self.reports()
+        charging = self.on_charger()
         for index, model in self._battery_models.items():
             features = torch.tensor(
                 [
@@ -701,8 +702,11 @@ def _models_update(self):
             except Exception as exc:  # noqa: BLE001
                 self.logger.warning("Battery model inference failed", error=str(exc))
                 continue
-            self.battery[index] = max(
-                0.0, self.battery[index] + rate * SIMULATOR_STEP_DELTA_T
+            if charging[index]:
+                rate = INITIAL_BATTERY_VOLTAGE / CHARGE_FULL_S
+            self.battery[index] = min(
+                INITIAL_BATTERY_VOLTAGE,
+                max(0.0, self.battery[index] + rate * SIMULATOR_STEP_DELTA_T),
             )
 
     def on_charger(self) -> np.ndarray:
diff --git a/dotbot/tests/test_site_objects.py b/dotbot/tests/test_site_objects.py
index 04eb0388..4697fdf0 100644
--- a/dotbot/tests/test_site_objects.py
+++ b/dotbot/tests/test_site_objects.py
@@ -6,6 +6,7 @@
 
 import tomllib
 
+import numpy as np
 import pytest
 import tomlkit
 
@@ -121,3 +122,31 @@ def test_a_simulated_robot_on_a_charger_charges_and_one_off_it_drains():
     # Ten seconds: a twelfth of a full charge on, a sliver of drain off
     assert on == pytest.approx(INITIAL_BATTERY_VOLTAGE * (0.5 + 10 / 120), abs=1)
     assert off < INITIAL_BATTERY_VOLTAGE / 2
+
+
+def test_a_robot_with_a_learned_battery_model_charges_on_a_charger_too(monkeypatch):
+    import contextlib
+    import sys
+    import types
+
+    # Stands in for torch: the model below draws 10 mV/s whatever it is fed
+    torch = types.SimpleNamespace(
+        tensor=lambda data, dtype=None: data,
+        float32=None,
+        no_grad=contextlib.nullcontext,
+    )
+    monkeypatch.setitem(sys.modules, "torch", torch)
+    state = InitStateToml(
+        dotbots=[
+            SimulatedDotBotSettings(address="0000000000000001", pos_x=800, pos_y=3800),
+            SimulatedDotBotSettings(address="0000000000000002", pos_x=800, pos_y=1000),
+        ]
+    )
+    sim = DotBotSimulatorCommunicationInterface(lambda frame: None, state, site=_site())
+    sim._battery_models = {0: lambda features: np.array([[-10.0]])}
+    sim._battery_modelled[:] = [True, False]
+    sim.battery[:] = INITIAL_BATTERY_VOLTAGE / 2
+    for _ in range(100):
+        sim.step()
+    assert sim.battery[0] > INITIAL_BATTERY_VOLTAGE / 2
+

From 96f4a05a344ad4598885009fd8485564b2a73484 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:12:02 +0200
Subject: [PATCH 70/80] dotbot/site_editor: leave omitted objects, allow a
 comma in an object name

AI-assisted: Claude Opus 5.5
---
 dotbot/site_editor.py             |  3 ++-
 dotbot/site_toml.py               |  6 +++---
 dotbot/tests/test_site_editor.py  | 14 ++++++++++++++
 dotbot/tests/test_site_objects.py | 13 +++++++++++++
 4 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index d0cd83fc..ae87b3ab 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -26,6 +26,7 @@
 from pydantic import BaseModel, Field
 
 from dotbot import site_backdrops, site_placement, site_toml
+from dotbot.config import ObjectKind
 from dotbot.site import PACK_CALIBRATIONS
 from dotbot.site_packs import PACK_FILE
 
@@ -55,7 +56,7 @@ class BarrierModel(BaseModel):
 
 class ObjectModel(BaseModel):
     name: str
-    kind: Literal["charger", "dock", "landmark", "camera"]
+    kind: ObjectKind
     x: int
     y: int
     heading_deg: float = 0.0
diff --git a/dotbot/site_toml.py b/dotbot/site_toml.py
index 8f11a4ff..9c47d6d8 100644
--- a/dotbot/site_toml.py
+++ b/dotbot/site_toml.py
@@ -22,8 +22,8 @@
 from dotbot.config import SiteSection
 
 AREA_KEYS = ("x", "y", "w", "h")
-# Each table of named tables the editor models, and its keys in file order;
-# the first may be left out (None), the rest are whole millimetres
+# Each table of named tables the editor models, and its keys in file order:
+# the first a word (an area's role may be left out), the rest whole millimetres
 NAMED = {"areas": ("role", *AREA_KEYS), "objects": ("kind", "x", "y")}
 # An object's optional heading, written only when not zero
 HEADING = "heading_deg"
@@ -174,7 +174,7 @@ def _check_names(entries: list[dict[str, Any]], what: str = "area") -> None:
             raise SiteTomlError(f"an {what} needs a name")
         if name != name.strip():
             raise SiteTomlError(f"{what} {name!r}: no spaces around the name")
-        if "," in name:
+        if what == "area" and "," in name:
             raise SiteTomlError(
                 f"{what} {name!r}: a comma makes the name read as an x,y,w,h literal"
             )
diff --git a/dotbot/tests/test_site_editor.py b/dotbot/tests/test_site_editor.py
index 81d951c1..7dc7989f 100644
--- a/dotbot/tests/test_site_editor.py
+++ b/dotbot/tests/test_site_editor.py
@@ -366,3 +366,17 @@ def test_a_save_that_leaves_out_the_walls_keeps_them(client, pack):
     )
     assert response.status_code == 200
     assert "[[walls]]" in (pack / "site.toml").read_text()
+
+
+def test_a_save_that_leaves_out_the_objects_keeps_them(client, pack):
+    (pack / "site.toml").write_text(
+        ARENA + '\n[objects.pad]\nkind = "charger"\nx = 1\ny = 1\n'
+    )
+    body = _loaded(client)
+    site = {k: v for k, v in body["site"].items() if k != "objects"}
+    site["anchor"] = "moved"
+    response = client.put(
+        "/api/site", json={"revision": body["revision"], "site": site}
+    )
+    assert response.status_code == 200
+    assert "[objects.pad]" in (pack / "site.toml").read_text()
diff --git a/dotbot/tests/test_site_objects.py b/dotbot/tests/test_site_objects.py
index 4697fdf0..45346c45 100644
--- a/dotbot/tests/test_site_objects.py
+++ b/dotbot/tests/test_site_objects.py
@@ -150,3 +150,16 @@ def test_a_robot_with_a_learned_battery_model_charges_on_a_charger_too(monkeypat
         sim.step()
     assert sim.battery[0] > INITIAL_BATTERY_VOLTAGE / 2
 
+
+def test_an_object_name_may_hold_a_comma():
+    from dotbot.site_toml import patched_text
+
+    model = {
+        "anchor": None,
+        "extent_mm": None,
+        "areas": [],
+        "objects": [
+            {"name": "pad, east", "kind": "charger", "x": 1, "y": 1, "was": None}
+        ],
+    }
+    assert '[objects."pad, east"]' in patched_text("", model)

From 0c3d6020c111ed8ae85a43dbbc3552676259601f Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:40:35 +0200
Subject: [PATCH 71/80] dotbot/tests: undo the connect-error proxy test's
 monkeypatch

AI-assisted: Claude Opus 5.5
---
 dotbot/tests/test_server.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dotbot/tests/test_server.py b/dotbot/tests/test_server.py
index 8ac3811e..3a3af04d 100644
--- a/dotbot/tests/test_server.py
+++ b/dotbot/tests/test_server.py
@@ -997,7 +997,6 @@ def mock_async_client(*args, **kwargs):
 
     import dotbot.server as server_module
 
-    monkeypatch = pytest.MonkeyPatch()
     monkeypatch.setattr(server_module.httpx, "AsyncClient", mock_async_client)
 
     client = TestClient(api)

From 29041dc6f2ff541e63812d855d24766ba7ef2cd5 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:40:35 +0200
Subject: [PATCH 72/80] dotbot/server: serve the site editor's routes over the
 controller's site pack

AI-assisted: Claude Opus 5.5
---
 dotbot/controller.py                   |  20 +++++
 dotbot/dotbot_simulator.py             |   8 ++
 dotbot/server.py                       |  49 +++++++++++
 dotbot/site_editor.py                  |  12 ++-
 dotbot/tests/test_site_editor_panel.py | 107 +++++++++++++++++++++++++
 5 files changed, 194 insertions(+), 2 deletions(-)
 create mode 100644 dotbot/tests/test_site_editor_panel.py

diff --git a/dotbot/controller.py b/dotbot/controller.py
index 89088500..3c924bac 100644
--- a/dotbot/controller.py
+++ b/dotbot/controller.py
@@ -69,6 +69,7 @@
     DotBotLH2Position,
     DotBotModel,
     DotBotQueryModel,
+    DotBotSiteModel,
     DotBotStatus,
 )
 from dotbot.poses import device_pose, robot_body, robot_models, robot_pose
@@ -1120,6 +1121,25 @@ def _outstanding_point(self):
         point = session.outstanding if session else None
         return None if point is None else point.mm
 
+    def reload_site(self) -> None:
+        """Read the site's pack again, as after the site editor saved it: the
+        map (a `site` event) and a running simulator take the change at once."""
+        from dotbot.site import site_from_table
+        from dotbot.site_packs import read_pack
+
+        if self.site.pack is None:
+            return
+        self.site = site_from_table(
+            self.site.name, read_pack(self.site.pack), self.site.pack
+        )
+        self.settings.site = self.site
+        simulator = getattr(self.adapter, "simulator", None)
+        if hasattr(simulator, "use_site"):
+            simulator.use_site(self.site)
+        model = DotBotSiteModel.from_site(self.site, self.calibration)
+        self.set_event("site", "site", model.model_dump(mode="json"))
+        self.logger.info("Site reloaded from its pack", site=self.site.name)
+
     async def _notify_calibration_session(self, state):
         """A `calibration_session` event per session state change.
 
diff --git a/dotbot/dotbot_simulator.py b/dotbot/dotbot_simulator.py
index ed62779c..bb65587f 100644
--- a/dotbot/dotbot_simulator.py
+++ b/dotbot/dotbot_simulator.py
@@ -709,6 +709,14 @@ def _models_update(self):
                 max(0.0, self.battery[index] + rate * SIMULATOR_STEP_DELTA_T),
             )
 
+    def use_site(self, site: Optional[Site]) -> None:
+        """Take a changed site's walls, obstacles and chargers, robots where they are."""
+        self.plant.barriers = Barriers.from_site(site)
+        chargers = site.objects_of("charger") if site is not None else []
+        self._chargers = (
+            np.array([[c.x, c.y] for c in chargers], dtype=float) if chargers else None
+        )
+
     def on_charger(self) -> np.ndarray:
         """Whether each robot's axle midpoint is on one of the site's chargers."""
         if self._chargers is None:
diff --git a/dotbot/server.py b/dotbot/server.py
index 07a713cf..3fc938b0 100644
--- a/dotbot/server.py
+++ b/dotbot/server.py
@@ -964,6 +964,55 @@ async def root():
     return RedirectResponse(url="/console/")
 
 
+class SiteEditorMount:
+    """The site editor's JSON routes over the controller's site pack, for the
+    console's panel: built on first use, and only for a site read from a pack.
+
+    The editor's app answers only requests addressed to 127.0.0.1 or
+    localhost, so a console opened from another machine cannot write files on
+    this one.
+    """
+
+    def __init__(self):
+        self._app = None
+        self._pack = None
+
+    async def __call__(self, scope, receive, send):
+        import asyncio
+        from pathlib import Path
+
+        from fastapi.responses import JSONResponse
+
+        from dotbot.calibration.lighthouse2 import calibration_root
+        from dotbot.site_editor import EditorState, create_app
+        from dotbot.site_packs import PACK_FILE
+
+        controller = getattr(api, "controller", None)
+        site = controller.site if controller is not None else None
+        pack = Path(site.pack) if site is not None and site.pack else None
+        if pack is None or not (pack / PACK_FILE).is_file():
+            response = JSONResponse(
+                {"detail": "the controller's site is not read from a site pack"},
+                status_code=404,
+            )
+            await response(scope, receive, send)
+            return
+        if self._app is None or self._pack != pack:
+            state = EditorState(site.name, pack, [calibration_root() / site.name])
+            # A save runs on a worker thread; the reload belongs on the loop
+            loop = asyncio.get_running_loop()
+            self._app = create_app(
+                state,
+                page_dir=None,
+                on_saved=lambda: loop.call_soon_threadsafe(controller.reload_site),
+            )
+            self._pack = pack
+        await self._app(scope, receive, send)
+
+
+api.mount("/controller/site-editor", SiteEditorMount(), name="site-editor")
+
+
 # The console is the web UI. Mounted after all routes so they take precedence.
 CONSOLE_DIR = os.path.join(os.path.dirname(__file__), "console-web", "dist")
 
diff --git a/dotbot/site_editor.py b/dotbot/site_editor.py
index ae87b3ab..49048ea4 100644
--- a/dotbot/site_editor.py
+++ b/dotbot/site_editor.py
@@ -178,10 +178,13 @@ def _model_dict(model: SiteModel) -> dict:
 
 def create_app(
     state: EditorState,
-    page_dir: Path = EDITOR_DIR,
+    page_dir: Path | None = EDITOR_DIR,
     on_done: Callable[[], None] | None = None,
+    on_saved: Callable[[], None] | None = None,
 ) -> FastAPI:
-    """The editor's app for `state`; `on_done` runs when the page says Done."""
+    """The editor's app for `state`; `on_done` runs when the page says Done,
+    `on_saved` after a save wrote the file. Without `page_dir` it serves the
+    JSON routes only, as the console's panel uses them."""
     app = FastAPI(title="DotBot site editor", docs_url=None, redoc_url=None)
     app.add_middleware(LocalOnly)
 
@@ -240,6 +243,8 @@ def save(request: SaveRequest):
                 _write_atomic(state.path, result)
                 data = result.encode("utf-8")
                 text = result
+                if on_saved is not None:
+                    on_saved()
         return {**body(data, text), "written": written}
 
     @app.post("/api/done")
@@ -259,6 +264,9 @@ def done():
         )
     )
 
+    if page_dir is None:
+        return app
+
     @app.get("/", include_in_schema=False)
     def page():
         return FileResponse(page_dir / EDITOR_PAGE)
diff --git a/dotbot/tests/test_site_editor_panel.py b/dotbot/tests/test_site_editor_panel.py
new file mode 100644
index 00000000..8f5e8178
--- /dev/null
+++ b/dotbot/tests/test_site_editor_panel.py
@@ -0,0 +1,107 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""The site editor inside the console: its routes on the controller, and a
+save reaching the live map and a running simulator without a restart."""
+
+import asyncio
+
+import httpx
+import pytest
+import pytest_asyncio
+
+from dotbot.server import api
+from dotbot.site_packs import pack_at
+from dotbot.tests.scenario_harness import Scenario
+
+SITE_TOML = """\
+anchor = "the door corner"
+extent_mm = [2000, 2000]
+
+[areas.field]
+x = 0
+y = 0
+w = 2000
+h = 2000
+"""
+
+A = "BADCAFE111111111"
+
+
+@pytest_asyncio.fixture
+async def scenario(tmp_path):
+    pack = tmp_path / "lab"
+    pack.mkdir()
+    (pack / "site.toml").write_text(SITE_TOML)
+    site = pack_at(str(pack)).site()
+    s = Scenario(
+        tmp_path,
+        [{"address": A, "pos_x": 500, "pos_y": 500, "direction": 0}],
+        site=site,
+    )
+    local = httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=api), base_url="http://127.0.0.1"
+    )
+    yield s, local, pack
+    await local.aclose()
+    await s.close()
+
+
+@pytest.mark.asyncio
+async def test_the_panel_edits_the_controller_s_pack(scenario):
+    s, local, pack = scenario
+    loaded = (await local.get("/controller/site-editor/api/site")).json()
+    assert loaded["path"] == str(pack / "site.toml")
+    site = loaded["site"]
+    for area in site["areas"]:
+        area["was"] = area["name"]
+    site["walls"] = [{"points": [[0, 1000], [2000, 1000]]}]
+    saved = await local.put(
+        "/controller/site-editor/api/site",
+        json={"revision": loaded["revision"], "site": site},
+    )
+    assert saved.json()["written"] is True
+    # The reload is handed to the controller's loop
+    await asyncio.sleep(0.05)
+    served = (await local.get("/controller/site")).json()
+    assert served["walls"][0]["points"] == [[0, 1000], [2000, 1000]]
+    _, name, event = s.controller.events["site"]
+    assert name == "site" and event["walls"] == served["walls"]
+    assert s.sim.plant.barriers is not None
+
+
+@pytest.mark.asyncio
+async def test_a_robot_stops_at_a_wall_drawn_while_it_runs(scenario):
+    s, local, _ = scenario
+    await s.run(1.0)
+    loaded = (await local.get("/controller/site-editor/api/site")).json()
+    site = loaded["site"]
+    for area in site["areas"]:
+        area["was"] = area["name"]
+    site["walls"] = [{"points": [[0, 1000], [2000, 1000]]}]
+    await local.put(
+        "/controller/site-editor/api/site",
+        json={"revision": loaded["revision"], "site": site},
+    )
+    await asyncio.sleep(0.05)
+    await s.waypoints(A, [(500, 1500)], threshold=20)
+    await s.run(10.0)
+    assert s.robots[A].pos_y < 1000 - 47.5 - 24.5 + 1
+
+
+@pytest.mark.asyncio
+async def test_the_panel_refuses_another_host(scenario):
+    s, _, _ = scenario
+    response = await s.client.get("/controller/site-editor/api/site")
+    assert response.status_code == 400
+
+
+@pytest.mark.asyncio
+async def test_a_site_without_a_pack_has_no_panel(tmp_path):
+    s = Scenario(tmp_path, [{"address": A, "pos_x": 500, "pos_y": 500}])
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=api), base_url="http://127.0.0.1"
+    ) as local:
+        response = await local.get("/controller/site-editor/api/site")
+    await s.close()
+    assert response.status_code == 404

From 245a138ebee6406c52c70485bc58b289ef26f97c Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Fri, 2 Oct 2026 14:40:35 +0200
Subject: [PATCH 73/80] dotbot/console-web: open the site editor as a console
 panel

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/App.tsx                | 22 +++++++-
 dotbot/console-web/src/RightPane.tsx          | 24 +++++++-
 .../console-web/src/editSiteButton.test.tsx   | 55 +++++++++++++++++++
 .../console-web/src/siteEditor/SiteEditor.tsx | 51 +++++++++++------
 dotbot/console-web/src/siteEditor/api.ts      | 34 ++++++------
 .../src/siteEditor/siteEditor.test.tsx        | 19 +++++++
 dotbot/console-web/src/siteEditorPanel.ts     | 14 +++++
 dotbot/console-web/src/useFleet.ts            |  3 +
 8 files changed, 187 insertions(+), 35 deletions(-)
 create mode 100644 dotbot/console-web/src/editSiteButton.test.tsx
 create mode 100644 dotbot/console-web/src/siteEditorPanel.ts

diff --git a/dotbot/console-web/src/App.tsx b/dotbot/console-web/src/App.tsx
index 0475962d..6995e647 100644
--- a/dotbot/console-web/src/App.tsx
+++ b/dotbot/console-web/src/App.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import React, { Suspense, lazy, useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 import { clearWaypoints, fetchBuild, fetchConnection, putWaypointBatches } from "./api";
 import type { WaypointsSent } from "./api";
@@ -45,6 +45,7 @@ import {
   withView,
 } from "./savedView";
 import { SetupCard } from "./SetupCard";
+import { SITE_EDITOR_BASE, siteEditable } from "./siteEditorPanel";
 import { SpreadPanel, SpreadRun } from "./SpreadPanel";
 import { describeHazards, hazardCount, planSpread, spreadColor, swap } from "./spread";
 import { WaypointSettings, batchFields, loadWaypointSettings, saveWaypointSettings } from "./arrival";
@@ -133,9 +134,17 @@ function robotsNotice(ids: string[], what: string): string {
   return `${ids.length} robot${ids.length === 1 ? "" : "s"} ${what}: ${names.join(", ")}${more}`;
 }
 
+// Loaded only when opened, so the console's own bundle does not carry it
+const SiteEditor = lazy(() => import("./siteEditor/SiteEditor").then((m) => ({ default: m.SiteEditor })));
+
 export const App: React.FC = () => {
   const { bots, site, cameras, cameraDetections, session, setSession, viewport, wsUp } =
     useFleet();
+  const [canEditSite, setCanEditSite] = useState(false);
+  const [editingSite, setEditingSite] = useState(false);
+  useEffect(() => {
+    void siteEditable().then(setCanEditSite);
+  }, [site?.name]);
   // ?theme=dark|light presets the theme (handy for dev/screenshots).
   const [theme, setTheme] = useState<"dark" | "light">(() =>
     new URLSearchParams(window.location.search).get("theme") === "light" ? "light" : "dark",
@@ -1191,6 +1200,16 @@ export const App: React.FC = () => {
           )}
 
           <ShortcutsPanel open={shortcuts} onClose={() => setShortcuts(false)} />
+          {editingSite && (
+            <div
+              data-testid="site-editor-panel"
+              style={{ position: "fixed", inset: 0, zIndex: 50, background: "var(--canvas)" }}
+            >
+              <Suspense fallback={null}>
+                <SiteEditor base={SITE_EDITOR_BASE} theme={theme} onClose={() => setEditingSite(false)} />
+              </Suspense>
+            </div>
+          )}
         </div>
         <RightPane
           tab={rightTab}
@@ -1201,6 +1220,7 @@ export const App: React.FC = () => {
           site={site}
           hiddenAreas={hiddenAreas}
           onAreaToggle={onAreaToggle}
+          onEditSite={canEditSite ? () => setEditingSite(true) : undefined}
           onZoom={zoomTo}
           layers={layers}
           layerRows={layerRows}
diff --git a/dotbot/console-web/src/RightPane.tsx b/dotbot/console-web/src/RightPane.tsx
index 56284d42..bbd93b04 100644
--- a/dotbot/console-web/src/RightPane.tsx
+++ b/dotbot/console-web/src/RightPane.tsx
@@ -512,6 +512,8 @@ interface RightPaneProps {
   site: Site | null;
   hiddenAreas: Set<string>;
   onAreaToggle: (name: string) => void;
+  // Open the site editor, when the controller lets this browser edit its site
+  onEditSite?: () => void;
   // Zoom the map to a named area: the row is where the area's name lives.
   onZoom?: (name: string) => void;
   layers: Layers;
@@ -663,7 +665,27 @@ export const RightPane: React.FC<RightPaneProps> = (props) => {
               />
             )}
 
-            <div style={{ ...label10, margin: "14px 0 4px" }}>Areas</div>
+            <div style={{ display: "flex", alignItems: "center", margin: "14px 0 4px" }}>
+              <div style={{ ...label10, flex: 1 }}>Areas</div>
+              {props.onEditSite && (
+                <button
+                  type="button"
+                  onClick={props.onEditSite}
+                  title="Edit the site's areas, walls and objects; the map follows on save"
+                  style={{
+                    background: "transparent",
+                    color: "var(--text)",
+                    border: "1px solid var(--hairline)",
+                    borderRadius: 4,
+                    padding: "2px 8px",
+                    cursor: "pointer",
+                    fontSize: 11,
+                  }}
+                >
+                  Edit site
+                </button>
+              )}
+            </div>
             {siteAreas.length === 0 && (
               <div style={{ fontSize: 12, color: "var(--muted)", lineHeight: 1.6 }}>
                 This site defines no areas.
diff --git a/dotbot/console-web/src/editSiteButton.test.tsx b/dotbot/console-web/src/editSiteButton.test.tsx
new file mode 100644
index 00000000..7180efad
--- /dev/null
+++ b/dotbot/console-web/src/editSiteButton.test.tsx
@@ -0,0 +1,55 @@
+import { fireEvent, render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+import { RightPane } from "./RightPane";
+import type { Site } from "./types";
+import type { Calibration } from "./useCalibration";
+
+const SITE: Site = { name: "lab", anchor: "", extent_mm: [2000, 2000], areas: [] };
+const LAYERS = {
+  batteryBars: true,
+  waypoints: true,
+  hotSpots: false,
+  dotBots: true,
+  trails: false,
+  crashedOnly: false,
+  lostBots: false,
+  allWaypoints: false,
+  calibratedSpan: true,
+};
+
+function pane(onEditSite?: () => void) {
+  return render(
+    <RightPane
+      tab="layers"
+      setTab={() => {}}
+      collapsed={false}
+      setCollapsed={() => {}}
+      bots={[]}
+      site={SITE}
+      hiddenAreas={new Set()}
+      onAreaToggle={() => {}}
+      onEditSite={onEditSite}
+      layers={LAYERS}
+      layerRows={[]}
+      onLayerToggle={() => {}}
+      session={null}
+      calibration={{} as Calibration}
+      device=""
+      onDeviceChange={() => {}}
+      onCalibrationDone={() => {}}
+    />,
+  );
+}
+
+describe("Edit site", () => {
+  it("is offered only when the controller lets this browser edit its site", () => {
+    const { unmount } = pane();
+    expect(screen.queryByText("Edit site")).toBeNull();
+    unmount();
+    const onEditSite = vi.fn();
+    pane(onEditSite);
+    fireEvent.click(screen.getByText("Edit site"));
+    expect(onEditSite).toHaveBeenCalled();
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index e6ec62b9..0b3c8f6e 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -89,8 +89,20 @@ function typing(target: EventTarget | null): boolean {
   return el.tagName === "TEXTAREA" || el.tagName === "SELECT";
 }
 
-export function SiteEditor() {
-  const theme = useTheme();
+export interface SiteEditorProps {
+  /** Where the editor's server is, ending in "/"; the page's own folder by default. */
+  base?: string;
+  /** Embedded in another page (the console): Close calls this instead of stopping the server. */
+  onClose?: () => void;
+  /** The host page's theme, when it has its own. */
+  theme?: "dark" | "light";
+}
+
+export function SiteEditor(props: SiteEditorProps = {}) {
+  const base = props.base ?? "";
+  const embedded = !!props.onClose;
+  const ownTheme = useTheme();
+  const theme = props.theme ?? ownTheme;
   const [loaded, setLoaded] = useState<SiteResponse | null>(null);
   const [history, setHistory] = useState<History<SiteModel> | null>(null);
   const site = history?.present ?? null;
@@ -143,7 +155,7 @@ export function SiteEditor() {
 
   const load = useCallback(async () => {
     try {
-      const body = await fetchSite();
+      const body = await fetchSite(base);
       setLoaded(body);
       setHistory(startHistory(body.site));
       setSelected(null);
@@ -151,7 +163,7 @@ export function SiteEditor() {
     } catch (err) {
       setNotice({ kind: "error", text: `could not load the site: ${(err as Error).message}` });
     }
-  }, []);
+  }, [base]);
 
   useEffect(() => {
     void load();
@@ -162,10 +174,10 @@ export function SiteEditor() {
   const revision = loaded?.revision;
   useEffect(() => {
     if (revision === undefined) return;
-    fetchBackdrops()
+    fetchBackdrops(base)
       .then(setBackdrops)
       .catch(() => setBackdrops(null));
-  }, [placed, revision]);
+  }, [placed, revision, base]);
 
   // A new selection starts a new undo step, even for the same kind of edit
   useEffect(() => {
@@ -184,14 +196,14 @@ export function SiteEditor() {
 
   useEffect(() => {
     if (tool !== "calibration") return;
-    fetchCalibrations()
+    fetchCalibrations(base)
       .then(setListing)
       .catch((err) => setNotice({ kind: "error", text: `could not list calibrations: ${(err as Error).message}` }));
-  }, [tool]);
+  }, [tool, base]);
 
   const loadCalibration = async (spec: string) => {
     try {
-      const overlay = await fetchCalibration(spec);
+      const overlay = await fetchCalibration(spec, base);
       setPlacement({ overlay, move: IDENTITY });
       setReanchor(false);
       setPlaced(null);
@@ -203,9 +215,9 @@ export function SiteEditor() {
   const savePlacement = async () => {
     if (!placement) return;
     try {
-      const result = await placeCalibration(placement.overlay.id, placement.move, reanchor);
+      const result = await placeCalibration(placement.overlay.id, placement.move, reanchor, base);
       setPlaced(result);
-      fetchCalibrations()
+      fetchCalibrations(base)
         .then(setListing)
         .catch(() => undefined);
       setNotice({ kind: "info", text: `saved calibration ${result.id8}; push it with: ${result.push}` });
@@ -354,7 +366,7 @@ export function SiteEditor() {
     setDialog(null);
     setSaving(true);
     try {
-      const body = await saveSite(loaded.revision, site);
+      const body = await saveSite(loaded.revision, site, base);
       setLoaded(body);
       // The file's names are the areas' origins now, so older steps no longer apply
       setHistory(startHistory(body.site));
@@ -384,7 +396,7 @@ export function SiteEditor() {
   const onViewToml = async () => {
     if (!site) return;
     try {
-      const { text } = await previewSite(site);
+      const { text } = await previewSite(site, base);
       setDialog({ kind: "toml", text });
     } catch (err) {
       setNotice({ kind: "error", text: (err as Error).message });
@@ -392,9 +404,14 @@ export function SiteEditor() {
   };
 
   const onDone = async () => {
+    if (embedded) {
+      if (dirty && !window.confirm("Close the editor without saving your changes?")) return;
+      props.onClose?.();
+      return;
+    }
     if (dirty && !window.confirm("Stop the editor without saving your changes?")) return;
     try {
-      await stopEditor();
+      await stopEditor(base);
     } catch {
       // The server is already gone, which is what Done asks for
     }
@@ -402,8 +419,8 @@ export function SiteEditor() {
   };
 
   const shell: React.CSSProperties = {
-    height: "100vh",
-    width: "100vw",
+    height: embedded ? "100%" : "100vh",
+    width: embedded ? "100%" : "100vw",
     display: "flex",
     flexDirection: "column",
     background: "var(--canvas)",
@@ -494,7 +511,7 @@ export function SiteEditor() {
           Save
         </button>
         <button type="button" style={button} onClick={onDone}>
-          Done
+          {embedded ? "Close" : "Done"}
         </button>
       </div>
 
diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
index 5436f702..a1370e65 100644
--- a/dotbot/console-web/src/siteEditor/api.ts
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -8,7 +8,8 @@ import type {
   SiteResponse,
 } from "./types";
 
-// The editor's server, addressed relative to the page.
+// The editor's server: relative to the page by default, or under `base`
+// (ending in "/") when embedded elsewhere.
 
 export class StaleSiteError extends Error {}
 export class RefusedSiteError extends Error {}
@@ -48,14 +49,14 @@ export function withOrigins(body: SiteResponse): SiteResponse {
   };
 }
 
-export async function fetchSite(): Promise<SiteResponse> {
-  const res = await fetch("api/site");
+export async function fetchSite(base = ""): Promise<SiteResponse> {
+  const res = await fetch(`${base}api/site`);
   if (!res.ok) throw new Error(await detail(res));
   return withOrigins(await res.json());
 }
 
-export async function previewSite(site: SiteModel): Promise<{ text: string; changed: boolean }> {
-  const res = await fetch("api/preview", {
+export async function previewSite(site: SiteModel, base = ""): Promise<{ text: string; changed: boolean }> {
+  const res = await fetch(`${base}api/preview`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(outgoing(site)),
@@ -69,8 +70,8 @@ export async function previewSite(site: SiteModel): Promise<{ text: string; chan
  * Save `site` over the file revision the page loaded. A file changed on disk
  * since throws StaleSiteError; one the schema refuses throws RefusedSiteError.
  */
-export async function saveSite(revision: string, site: SiteModel): Promise<SiteResponse> {
-  const res = await fetch("api/site", {
+export async function saveSite(revision: string, site: SiteModel, base = ""): Promise<SiteResponse> {
+  const res = await fetch(`${base}api/site`, {
     method: "PUT",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ revision, site: outgoing(site) }),
@@ -81,18 +82,18 @@ export async function saveSite(revision: string, site: SiteModel): Promise<SiteR
   return withOrigins(await res.json());
 }
 
-export async function stopEditor(): Promise<void> {
-  await fetch("api/done", { method: "POST" });
+export async function stopEditor(base = ""): Promise<void> {
+  await fetch(`${base}api/done`, { method: "POST" });
 }
 
-export async function fetchCalibrations(): Promise<CalibrationListing[]> {
-  const res = await fetch("api/calibrations");
+export async function fetchCalibrations(base = ""): Promise<CalibrationListing[]> {
+  const res = await fetch(`${base}api/calibrations`);
   if (!res.ok) throw new Error(await detail(res));
   return res.json();
 }
 
-export async function fetchCalibration(spec: string): Promise<CalibrationOverlay> {
-  const res = await fetch(`api/calibrations/${encodeURIComponent(spec)}`);
+export async function fetchCalibration(spec: string, base = ""): Promise<CalibrationOverlay> {
+  const res = await fetch(`${base}api/calibrations/${encodeURIComponent(spec)}`);
   if (!res.ok) throw new Error(await detail(res));
   return res.json();
 }
@@ -102,8 +103,9 @@ export async function placeCalibration(
   id: string,
   move: Rigid2D,
   reanchor: boolean,
+  base = "",
 ): Promise<PlacedCalibration> {
-  const res = await fetch(`api/calibrations/${encodeURIComponent(id)}/place`, {
+  const res = await fetch(`${base}api/calibrations/${encodeURIComponent(id)}/place`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ ...move, reanchor }),
@@ -113,8 +115,8 @@ export async function placeCalibration(
   return res.json();
 }
 
-export async function fetchBackdrops(): Promise<Backdrops> {
-  const res = await fetch("api/backdrops");
+export async function fetchBackdrops(base = ""): Promise<Backdrops> {
+  const res = await fetch(`${base}api/backdrops`);
   if (!res.ok) throw new Error(await detail(res));
   return res.json();
 }
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index ec38640e..63a56f7e 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -415,3 +415,22 @@ describe("SiteEditor objects", () => {
     expect(sent.x % 50).toBe(0);
   });
 });
+
+describe("SiteEditor in the console", () => {
+  it("talks to the controller's routes and closes without stopping a server", async () => {
+    const fetch = vi.fn(async (url: string) => {
+      const json = (status: number, body: unknown) =>
+        new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+      if (url === "/controller/site-editor/api/site") return json(200, loaded());
+      return json(404, { detail: "no" });
+    });
+    vi.stubGlobal("fetch", fetch);
+    const onClose = vi.fn();
+    render(<SiteEditor base="/controller/site-editor/" onClose={onClose} theme="light" />);
+    expect(await screen.findByTestId("edit-area-field")).toBeInTheDocument();
+    fireEvent.click(screen.getByText("Close"));
+    expect(onClose).toHaveBeenCalled();
+    expect(fetch.mock.calls.map(([url]) => url)).not.toContain("api/done");
+    expect(fetch.mock.calls.every(([url]) => String(url).startsWith("/controller/site-editor/"))).toBe(true);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditorPanel.ts b/dotbot/console-web/src/siteEditorPanel.ts
new file mode 100644
index 00000000..b938a9e4
--- /dev/null
+++ b/dotbot/console-web/src/siteEditorPanel.ts
@@ -0,0 +1,14 @@
+// The site editor as a console panel: the controller serves the editor's
+// routes over its own site pack, to a browser on the same machine.
+
+export const SITE_EDITOR_BASE = "/controller/site-editor/";
+
+/** Whether the controller lets this browser edit its site: a pack, on this machine. */
+export async function siteEditable(): Promise<boolean> {
+  try {
+    const res = await fetch(`${SITE_EDITOR_BASE}api/site`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
diff --git a/dotbot/console-web/src/useFleet.ts b/dotbot/console-web/src/useFleet.ts
index 73d9c3e1..77186d28 100644
--- a/dotbot/console-web/src/useFleet.ts
+++ b/dotbot/console-web/src/useFleet.ts
@@ -252,6 +252,9 @@ export function useFleet(): {
       if (event.event === "robot_models") {
         shapesRef.current = (event.data as RobotShapes | null) ?? {};
         rebuildNextFrame();
+      } else if (event.event === "site" && event.data) {
+        // The site editor panel saved the pack and the controller reloaded it
+        setSite(event.data as Site);
       } else if (event.event === "calibration_session") {
         setSession((event.data as CalibrationSession | null) ?? null);
       } else if (event.event === "camera_detection" && event.data) {

From 44c5ea9f952529fbb9fb98e819b633fb63b12911 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:16:27 +0200
Subject: [PATCH 74/80] dotbot/controller: reload the site whole or not at all,
 session included

AI-assisted: Claude Opus 5.5
---
 dotbot/controller.py                   | 45 ++++++++++++----
 dotbot/dotbot_simulator.py             | 14 +++--
 dotbot/server.py                       | 13 ++---
 dotbot/tests/test_site_editor_panel.py | 71 +++++++++++++++++++++++++-
 4 files changed, 119 insertions(+), 24 deletions(-)

diff --git a/dotbot/controller.py b/dotbot/controller.py
index 3c924bac..41f8159c 100644
--- a/dotbot/controller.py
+++ b/dotbot/controller.py
@@ -1122,23 +1122,50 @@ def _outstanding_point(self):
         return None if point is None else point.mm
 
     def reload_site(self) -> None:
-        """Read the site's pack again, as after the site editor saved it: the
-        map (a `site` event) and a running simulator take the change at once."""
+        """Read the site's pack again: the map (a `site` event), the
+        calibration session and a running simulator take the change at once.
+        A pack that no longer reads leaves the site as it was."""
+        from dotbot.calibration.lighthouse2 import check_calibration_site
         from dotbot.site import site_from_table
         from dotbot.site_packs import read_pack
 
         if self.site.pack is None:
             return
-        self.site = site_from_table(
-            self.site.name, read_pack(self.site.pack), self.site.pack
-        )
-        self.settings.site = self.site
+        try:
+            site = site_from_table(
+                self.site.name, read_pack(self.site.pack), self.site.pack
+            )
+            model = DotBotSiteModel.from_site(site, self.calibration)
+        except Exception as exc:  # noqa: BLE001
+            self.logger.warning(
+                "Site pack no longer reads; keeping the site as it was",
+                pack=str(self.site.pack),
+                error=str(exc),
+            )
+            return
+        if self.calibration is not None:
+            try:
+                check_calibration_site(
+                    self.calibration.site, site, self.calibration.path
+                )
+            except ValueError as exc:
+                self.logger.warning(
+                    "Site reloaded against its calibration", error=str(exc)
+                )
+            if site.valid_mm != self.site.valid_mm:
+                self.logger.warning(
+                    "Site extent changed; robots keep the fence of the calibration "
+                    "they hold until a new one is pushed",
+                    site=site.name,
+                )
+        self.site = site
+        self.settings.site = site
+        self.calibration_session.site = site
         simulator = getattr(self.adapter, "simulator", None)
         if hasattr(simulator, "use_site"):
-            simulator.use_site(self.site)
-        model = DotBotSiteModel.from_site(self.site, self.calibration)
+            simulator.use_site(site)
         self.set_event("site", "site", model.model_dump(mode="json"))
-        self.logger.info("Site reloaded from its pack", site=self.site.name)
+        self.logger.info("Site reloaded from its pack", site=site.name)
 
     async def _notify_calibration_session(self, state):
         """A `calibration_session` event per session state change.
diff --git a/dotbot/dotbot_simulator.py b/dotbot/dotbot_simulator.py
index bb65587f..995dc72b 100644
--- a/dotbot/dotbot_simulator.py
+++ b/dotbot/dotbot_simulator.py
@@ -711,18 +711,22 @@ def _models_update(self):
 
     def use_site(self, site: Optional[Site]) -> None:
         """Take a changed site's walls, obstacles and chargers, robots where they are."""
-        self.plant.barriers = Barriers.from_site(site)
+        barriers = Barriers.from_site(site)
         chargers = site.objects_of("charger") if site is not None else []
-        self._chargers = (
+        positions = (
             np.array([[c.x, c.y] for c in chargers], dtype=float) if chargers else None
         )
+        # Each a single assignment: the tick thread reads either the old or the new
+        self.plant.barriers = barriers
+        self._chargers = positions
 
     def on_charger(self) -> np.ndarray:
         """Whether each robot's axle midpoint is on one of the site's chargers."""
-        if self._chargers is None:
+        chargers = self._chargers
+        if chargers is None:
             return np.zeros(self.plant.count, dtype=bool)
-        dx = self.plant.x[:, None] - self._chargers[None, :, 0]
-        dy = self.plant.y[:, None] - self._chargers[None, :, 1]
+        dx = self.plant.x[:, None] - chargers[None, :, 0]
+        dy = self.plant.y[:, None] - chargers[None, :, 1]
         return (dx * dx + dy * dy < CHARGER_REACH_MM**2).any(axis=1)
 
     def _charged(self) -> np.ndarray:
diff --git a/dotbot/server.py b/dotbot/server.py
index 3fc938b0..0f1213c0 100644
--- a/dotbot/server.py
+++ b/dotbot/server.py
@@ -966,16 +966,11 @@ async def root():
 
 class SiteEditorMount:
     """The site editor's JSON routes over the controller's site pack, for the
-    console's panel: built on first use, and only for a site read from a pack.
-
-    The editor's app answers only requests addressed to 127.0.0.1 or
-    localhost, so a console opened from another machine cannot write files on
-    this one.
-    """
+    console's panel: built on first use, and only for a site read from a pack."""
 
     def __init__(self):
         self._app = None
-        self._pack = None
+        self._key = None
 
     async def __call__(self, scope, receive, send):
         import asyncio
@@ -997,7 +992,7 @@ async def __call__(self, scope, receive, send):
             )
             await response(scope, receive, send)
             return
-        if self._app is None or self._pack != pack:
+        if self._app is None or self._key != (id(controller), pack):
             state = EditorState(site.name, pack, [calibration_root() / site.name])
             # A save runs on a worker thread; the reload belongs on the loop
             loop = asyncio.get_running_loop()
@@ -1006,7 +1001,7 @@ async def __call__(self, scope, receive, send):
                 page_dir=None,
                 on_saved=lambda: loop.call_soon_threadsafe(controller.reload_site),
             )
-            self._pack = pack
+            self._key = (id(controller), pack)
         await self._app(scope, receive, send)
 
 
diff --git a/dotbot/tests/test_site_editor_panel.py b/dotbot/tests/test_site_editor_panel.py
index 8f5e8178..464d6427 100644
--- a/dotbot/tests/test_site_editor_panel.py
+++ b/dotbot/tests/test_site_editor_panel.py
@@ -93,7 +93,56 @@ async def test_a_robot_stops_at_a_wall_drawn_while_it_runs(scenario):
 async def test_the_panel_refuses_another_host(scenario):
     s, _, _ = scenario
     response = await s.client.get("/controller/site-editor/api/site")
-    assert response.status_code == 400
+    assert response.status_code == 403
+
+
+@pytest.mark.asyncio
+async def test_the_panel_refuses_another_machine_whatever_its_host(scenario):
+    _, _, pack = scenario
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=api, client=("192.0.2.7", 5000)),
+        base_url="http://localhost",
+    ) as remote:
+        response = await remote.get("/controller/site-editor/api/site")
+    assert response.status_code == 403
+
+
+@pytest.mark.asyncio
+async def test_a_page_on_another_site_cannot_save_through_the_console_s_cors(scenario):
+    _, local, pack = scenario
+    loaded = (await local.get("/controller/site-editor/api/site")).json()
+    loaded["site"]["anchor"] = "moved"
+    response = await local.put(
+        "/controller/site-editor/api/site",
+        json={"revision": loaded["revision"], "site": loaded["site"]},
+        headers={"origin": "https://evil.example", "sec-fetch-site": "cross-site"},
+    )
+    assert response.status_code == 403
+    assert "moved" not in (pack / "site.toml").read_text()
+
+
+@pytest.mark.asyncio
+async def test_a_reload_reaches_the_calibration_session(scenario):
+    s, local, _ = scenario
+    loaded = (await local.get("/controller/site-editor/api/site")).json()
+    loaded["site"]["extent_mm"] = [4000, 3000]
+    for area in loaded["site"]["areas"]:
+        area["was"] = area["name"]
+    await local.put(
+        "/controller/site-editor/api/site",
+        json={"revision": loaded["revision"], "site": loaded["site"]},
+    )
+    await asyncio.sleep(0.05)
+    assert s.controller.calibration_session.site.extent_mm == (4000, 3000)
+
+
+@pytest.mark.asyncio
+async def test_a_pack_that_no_longer_reads_keeps_the_site(scenario):
+    s, _, pack = scenario
+    before = s.controller.site
+    (pack / "site.toml").write_text("[areas.field\n")
+    s.controller.reload_site()
+    assert s.controller.site is before
 
 
 @pytest.mark.asyncio
@@ -105,3 +154,23 @@ async def test_a_site_without_a_pack_has_no_panel(tmp_path):
         response = await local.get("/controller/site-editor/api/site")
     await s.close()
     assert response.status_code == 404
+
+
+def test_barriers_swapped_away_during_a_tick_leave_the_tick_whole():
+    import numpy as np
+
+    from dotbot.sim.barriers import Barriers
+    from dotbot.sim.plant import FleetPlant
+
+    barriers = Barriers(walls=[[(0, 1000), (2000, 1000)]])
+    plant = FleetPlant(x=[500.0], y=[930.0], heading_deg=[0.0], barriers=barriers)
+    refused = barriers.refused
+
+    def swapped(*args):
+        plant.barriers = None
+        return refused(*args)
+
+    barriers.refused = swapped
+    plant.pwm[:] = 60.0
+    plant.step(np.zeros(1, dtype=bool))
+    assert plant.y[0] == 930.0

From dabc202e4992143fc350c3b626cc2be4bc7f6d18 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:16:35 +0200
Subject: [PATCH 75/80] dotbot/console-web: load camera stills from the panel's
 routes

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/siteEditor/api.ts      |  6 +++++-
 .../src/siteEditor/siteEditor.test.tsx        | 19 +++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
index a1370e65..5d1ba9ae 100644
--- a/dotbot/console-web/src/siteEditor/api.ts
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -118,5 +118,9 @@ export async function placeCalibration(
 export async function fetchBackdrops(base = ""): Promise<Backdrops> {
   const res = await fetch(`${base}api/backdrops`);
   if (!res.ok) throw new Error(await detail(res));
-  return res.json();
+  const body: Backdrops = await res.json();
+  return {
+    ...body,
+    cameras: body.cameras.map((c) => ({ ...c, still: c.still === null ? null : `${base}${c.still}` })),
+  };
 }
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index 63a56f7e..9ff05909 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -433,4 +433,23 @@ describe("SiteEditor in the console", () => {
     expect(fetch.mock.calls.map(([url]) => url)).not.toContain("api/done");
     expect(fetch.mock.calls.every(([url]) => String(url).startsWith("/controller/site-editor/"))).toBe(true);
   });
+
+  it("draws a camera still from the controller's routes", async () => {
+    const fetch = vi.fn(async (url: string) => {
+      const json = (status: number, body: unknown) =>
+        new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+      if (url === "/controller/site-editor/api/site") return json(200, loaded());
+      if (url === "/controller/site-editor/api/backdrops")
+        return json(200, {
+          calibrations: [],
+          cameras: [{ id8: "abcd1234", area: "field", rect: [0, 0, 2000, 2000], span: [], still: "api/backdrops/camera/abcd1234.png?v=1" }],
+        });
+      return json(404, { detail: "no" });
+    });
+    vi.stubGlobal("fetch", fetch);
+    const { container } = render(<SiteEditor base="/controller/site-editor/" onClose={() => {}} />);
+    fireEvent.click(await screen.findByLabelText(/backdrop camera abcd1234/));
+    const image = container.querySelector("image");
+    expect(image?.getAttribute("href")).toBe("/controller/site-editor/api/backdrops/camera/abcd1234.png?v=1");
+  });
 });

From d9886890efa96f1bcd89b04db93c8960eac54fea Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Sun, 4 Oct 2026 04:16:35 +0200
Subject: [PATCH 76/80] dotbot/console-web: keep the console's keys off under
 the site editor panel

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/App.tsx                | 23 +++++++++++--------
 .../console-web/src/siteEditorPanel.test.ts   | 21 +++++++++++++++++
 dotbot/console-web/src/useFleet.ts            |  1 -
 3 files changed, 34 insertions(+), 11 deletions(-)
 create mode 100644 dotbot/console-web/src/siteEditorPanel.test.ts

diff --git a/dotbot/console-web/src/App.tsx b/dotbot/console-web/src/App.tsx
index 6995e647..f7e1757a 100644
--- a/dotbot/console-web/src/App.tsx
+++ b/dotbot/console-web/src/App.tsx
@@ -134,7 +134,7 @@ function robotsNotice(ids: string[], what: string): string {
   return `${ids.length} robot${ids.length === 1 ? "" : "s"} ${what}: ${names.join(", ")}${more}`;
 }
 
-// Loaded only when opened, so the console's own bundle does not carry it
+// Loaded only when opened
 const SiteEditor = lazy(() => import("./siteEditor/SiteEditor").then((m) => ({ default: m.SiteEditor })));
 
 export const App: React.FC = () => {
@@ -483,10 +483,12 @@ export const App: React.FC = () => {
   // The shortcuts panel: its key opens it with nothing selected and closes
   // it again; Escape closes it; a key typed into a field is left alone.
   const [shortcuts, setShortcuts] = useState(false);
+  // The console's keys, all but the stop key, stay off under the site editor
+  const keysOff = shortcuts || editingSite;
   const nothingSelected = selection.size === 0;
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
-      if (typingIn(e.target)) return;
+      if (editingSite || typingIn(e.target)) return;
       if (e.key === SHORTCUTS_KEY) {
         if (shortcuts) setShortcuts(false);
         else if (nothingSelected) setShortcuts(true);
@@ -499,12 +501,12 @@ export const App: React.FC = () => {
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
-  }, [shortcuts, nothingSelected]);
+  }, [shortcuts, nothingSelected, editingSite]);
 
   // Each side panel's key collapses it or expands it again, once per press.
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
-      if (shortcuts || e.repeat || typingIn(e.target)) return;
+      if (keysOff || e.repeat || typingIn(e.target)) return;
       if (pressed(e, ACTION_KEY.leftPanel)) setRailCollapsed((c) => !c);
       else if (pressed(e, ACTION_KEY.rightPanel)) setRightCollapsed((c) => !c);
       else return;
@@ -512,7 +514,7 @@ export const App: React.FC = () => {
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
-  }, [shortcuts]);
+  }, [keysOff]);
 
   // Start and Stop act on the selection at once. With none they act on the
   // whole fleet, on a second press of the same key or button, or Enter; Esc
@@ -538,6 +540,7 @@ export const App: React.FC = () => {
     const onKey = (e: KeyboardEvent) => {
       if (e.repeat || typingIn(e.target)) return;
       if (pressed(e, ACTION_KEY.stop)) requestTestbed("stop");
+      else if (editingSite) return;
       else if (!shortcuts && pressed(e, ACTION_KEY.start)) requestTestbed("start");
       // Enter confirms whatever holds the focus, so it never also presses it.
       else if (e.key === "Enter" && confirmTestbed()) e.stopImmediatePropagation();
@@ -547,7 +550,7 @@ export const App: React.FC = () => {
     };
     window.addEventListener("keydown", onKey, true);
     return () => window.removeEventListener("keydown", onKey, true);
-  }, [shortcuts, requestTestbed, confirmTestbed, cancelTestbed]);
+  }, [shortcuts, editingSite, requestTestbed, confirmTestbed, cancelTestbed]);
 
   // replace = set selection to ids · toggle = flip each id · add = union (range select)
   const onSelect = useCallback((ids: string[], mode: "replace" | "toggle" | "add") => {
@@ -739,7 +742,7 @@ export const App: React.FC = () => {
   const queued = pending.length;
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
-      if (shortcuts || typingIn(e.target) || !pressed(e, ACTION_KEY.go)) return;
+      if (keysOff || typingIn(e.target) || !pressed(e, ACTION_KEY.go)) return;
       if (selectedCount === 0) showToast("Nothing selected");
       else if (drivableCount === 0) showToast("Not drivable");
       else if (anyAuto) onStopNav();
@@ -751,7 +754,7 @@ export const App: React.FC = () => {
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
-  }, [shortcuts, selectedCount, drivableCount, anyAuto, queued, onGo, onStopNav, showToast]);
+  }, [keysOff, selectedCount, drivableCount, anyAuto, queued, onGo, onStopNav, showToast]);
 
   const onClearQueue = useCallback(() => {
     setPlanned((prev) => prev.filter((m) => m.key !== selKey));
@@ -790,7 +793,7 @@ export const App: React.FC = () => {
   const [poseMode, setPoseMode] = useState(false);
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
-      if (shortcuts || e.repeat || typingIn(e.target)) return;
+      if (keysOff || e.repeat || typingIn(e.target)) return;
       if (pressed(e, ACTION_KEY.poseMode)) {
         setPoseMode((on) => !on);
         e.preventDefault();
@@ -803,7 +806,7 @@ export const App: React.FC = () => {
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
-  }, [shortcuts, queued, onRemovePending, showToast]);
+  }, [keysOff, queued, onRemovePending, showToast]);
 
   // Recently-completed missions: a bot flipping AUTO -> MANUAL just arrived.
   const [doneMissions, setDoneMissions] = useState<DoneMission[]>([]);
diff --git a/dotbot/console-web/src/siteEditorPanel.test.ts b/dotbot/console-web/src/siteEditorPanel.test.ts
new file mode 100644
index 00000000..c0d8e78c
--- /dev/null
+++ b/dotbot/console-web/src/siteEditorPanel.test.ts
@@ -0,0 +1,21 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { siteEditable } from "./siteEditorPanel";
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("siteEditable", () => {
+  it.each([
+    [200, true],
+    [403, false],
+    [404, false],
+  ])("takes a %i from the editor's routes as %s", async (status, editable) => {
+    vi.stubGlobal("fetch", vi.fn(async () => new Response("{}", { status })));
+    expect(await siteEditable()).toBe(editable);
+  });
+
+  it("takes an unreachable controller as not editable", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => Promise.reject(new Error("down"))));
+    expect(await siteEditable()).toBe(false);
+  });
+});
diff --git a/dotbot/console-web/src/useFleet.ts b/dotbot/console-web/src/useFleet.ts
index 77186d28..eb8ca83e 100644
--- a/dotbot/console-web/src/useFleet.ts
+++ b/dotbot/console-web/src/useFleet.ts
@@ -253,7 +253,6 @@ export function useFleet(): {
         shapesRef.current = (event.data as RobotShapes | null) ?? {};
         rebuildNextFrame();
       } else if (event.event === "site" && event.data) {
-        // The site editor panel saved the pack and the controller reloaded it
         setSite(event.data as Site);
       } else if (event.event === "calibration_session") {
         setSession((event.data as CalibrationSession | null) ?? null);

From 2d6c3fe35063ca5a0c4fcc27979591eec4f7f2a7 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Thu, 15 Oct 2026 09:46:20 -0300
Subject: [PATCH 77/80] dotbot/calibration: save a calibration with its station
 rectangles changed

placed_from keeps naming the free-frame spin calibration that `--append`
points back to; the calibration an edit was made from is edited_from.

AI-assisted: Claude Opus 5.5
---
 dotbot/calibration/lighthouse2.py             |   5 +
 dotbot/calibration/placement.py               |  22 ++-
 dotbot/calibration/station_boxes.py           | 177 ++++++++++++++++++
 .../tests/test_calibration_station_boxes.py   | 140 ++++++++++++++
 4 files changed, 340 insertions(+), 4 deletions(-)
 create mode 100644 dotbot/calibration/station_boxes.py
 create mode 100644 dotbot/tests/test_calibration_station_boxes.py

diff --git a/dotbot/calibration/lighthouse2.py b/dotbot/calibration/lighthouse2.py
index c76b8541..db896bce 100644
--- a/dotbot/calibration/lighthouse2.py
+++ b/dotbot/calibration/lighthouse2.py
@@ -259,6 +259,8 @@ class Calibration:
     robot: str = ROBOT_DEFAULT
     # The id of the free-frame spin calibration this one was moved from
     placed_from: str = ""
+    # The id of the calibration this one is an edit of, its rectangles changed
+    edited_from: str = ""
     path: Optional[Path] = None
     # The id the file on disk declares, when this came from one. A mismatch
     # with `id` means the file was hand-edited into a different calibration.
@@ -690,6 +692,8 @@ def render_calibration(calibration: Calibration) -> str:
         out.append(f'tag = "{toml_escape(calibration.tag)}"')
     if calibration.placed_from:
         out.append(f'placed_from = "{calibration.placed_from}"')
+    if calibration.edited_from:
+        out.append(f'edited_from = "{calibration.edited_from}"')
     out += [
         "",
         "[site]",
@@ -872,6 +876,7 @@ def read_calibration_file(path: Path) -> Calibration:
         tag=metadata.get("tag", ""),
         robot=metadata.get("robot", ROBOT_DEFAULT),
         placed_from=str(metadata.get("placed_from", "")),
+        edited_from=str(metadata.get("edited_from", "")),
         path=path,
     )
     calibration.stored_id = str(metadata.get("id", ""))
diff --git a/dotbot/calibration/placement.py b/dotbot/calibration/placement.py
index ae3c1f57..5d4ec7d8 100644
--- a/dotbot/calibration/placement.py
+++ b/dotbot/calibration/placement.py
@@ -179,9 +179,15 @@ def overlay(calibration: Calibration) -> dict:
 def placed_tag(tag: str, site_name: str, taken: Iterable[str] = ()) -> str:
     """The moved calibration's tag: `tag` suffixed with the site, then a
     number if that tag is taken."""
+    return suffixed_tag(tag, site_name, taken)
+
+
+def suffixed_tag(tag: str, suffix: str, taken: Iterable[str] = ()) -> str:
+    """`tag` suffixed `-<suffix>` unless it already is, then a number if that
+    tag is taken; no tag stays none."""
     if not tag:
         return ""
-    base = tag if tag.endswith(f"-{site_name}") else f"{tag}-{site_name}"
+    base = tag if tag.endswith(f"-{suffix}") else f"{tag}-{suffix}"
     taken = {t.lower() for t in taken}
     candidate, n = base, 2
     while candidate.lower() in taken or candidate.lower() == tag.lower():
@@ -341,8 +347,16 @@ def save_placed(source: Calibration, placed: Calibration) -> tuple[Calibration,
         raise PlacementRefused(
             f"the move leaves calibration {source.id8} where it is; nothing to write"
         )
-    for path in lighthouse2.site_dir(placed.site.name).glob(f"*-{placed.id8}.toml"):
+    return save_new(placed)
+
+
+def save_new(calibration: Calibration) -> tuple[Calibration, Path]:
+    """Write `calibration` beside its site's calibrations, or, when a file of
+    its id is there already, leave that file as it is; return what is on disk."""
+    for path in lighthouse2.site_dir(calibration.site.name).glob(
+        f"*-{calibration.id8}.toml"
+    ):
         existing = lighthouse2.read_calibration_file(path)
-        if existing.id == placed.id:
+        if existing.id == calibration.id:
             return existing, path
-    return placed, lighthouse2.write_calibration(placed)
+    return calibration, lighthouse2.write_calibration(calibration)
diff --git a/dotbot/calibration/station_boxes.py b/dotbot/calibration/station_boxes.py
new file mode 100644
index 00000000..7f71a724
--- /dev/null
+++ b/dotbot/calibration/station_boxes.py
@@ -0,0 +1,177 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Changing where each station of a calibration is trusted.
+
+A station's `valid_mm` is the rectangle its fixes are believed in. `rebox`
+makes a new calibration with some of those rectangles changed and everything
+else, homographies included, as it was; the calibration it came from is
+never written.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Iterable, Mapping, Sequence
+
+from dotbot.calibration import lighthouse2
+from dotbot.calibration.conics import FREE_FRAME_ANCHOR
+from dotbot.calibration.lighthouse2 import Calibration, station_label, union_rect
+from dotbot.calibration.placement import spin_centres, suffixed_tag
+from dotbot.site import Site
+
+TAG_SUFFIX = "boxes"
+
+Rect = tuple[int, int, int, int]
+
+
+class BoxesRefused(ValueError):
+    """A calibration whose rectangles may not be changed here, or a rectangle
+    a robot cannot take."""
+
+
+def frame_refusal(file_site: Site, site: Site) -> str | None:
+    """Why a calibration recorded in `file_site` is not in `site`'s frame,
+    or None when it is."""
+    if file_site.anchor == FREE_FRAME_ANCHOR:
+        return (
+            "it is a free-mode spin calibration, in its own frame: place it on "
+            "the site first"
+        )
+    try:
+        lighthouse2.check_calibration_site(file_site, site, None)
+    except ValueError as exc:
+        return str(exc)
+    return None
+
+
+def rect_refusal(rect: Sequence[int], site: Site) -> str | None:
+    """Why `[x_min, y_min, x_max, y_max]` cannot be a station's rectangle on
+    `site`, or None when it can."""
+    x0, y0, x1, y1 = (int(v) for v in rect)
+    if x1 <= x0 or y1 <= y0:
+        return "is empty"
+    if x0 < 0 or y0 < 0:
+        return "reaches below zero, where a robot cannot report a position"
+    if site.extent_mm is not None:
+        width, height = site.extent_mm
+        if x1 > width or y1 > height:
+            return f"reaches outside the site's extent {width} x {height} mm"
+    try:
+        lighthouse2.valid_mm_as_bytes((x0, y0, x1, y1))
+    except ValueError as exc:
+        return str(exc)
+    return None
+
+
+def reboxed(
+    source: Calibration,
+    site: Site,
+    rects: Mapping[int, Sequence[int]],
+    *,
+    tag: str | None = None,
+    taken_tags: Iterable[str] = (),
+) -> Calibration:
+    """`source` with the stations named in `rects` given those rectangles,
+    as a new calibration; the fence becomes their union.
+
+    `tag` defaults to the source's, suffixed `-boxes` and numbered when
+    taken. Refused when `source` is not in `site`'s frame, was edited by
+    hand, or leaves every rectangle as it was, and for a rectangle
+    `rect_refusal` names.
+    """
+    why = frame_refusal(source.site, site)
+    if why is not None:
+        raise BoxesRefused(f"calibration {source.id8} is not in site {site.name}'s frame: {why}")
+    try:
+        lighthouse2.pushed_id(source)
+    except ValueError as exc:
+        raise BoxesRefused(str(exc)) from exc
+    indices = {st.index for st in source.stations}
+    unknown = sorted(set(rects) - indices)
+    if unknown:
+        raise BoxesRefused(
+            f"calibration {source.id8} has no station {', '.join(map(str, unknown))}; "
+            f"it has {', '.join(map(str, sorted(indices)))}"
+        )
+    refused = []
+    for index, rect in sorted(rects.items()):
+        why = rect_refusal(rect, site)
+        if why is not None:
+            refused.append(f"{station_label(index)}'s rectangle {list(rect)} {why}")
+    if refused:
+        raise BoxesRefused("; ".join(refused))
+    stations = [
+        (
+            dataclasses.replace(st, valid_mm=tuple(int(v) for v in rects[st.index]))
+            if st.index in rects
+            else st
+        )
+        for st in source.stations
+    ]
+    if all(a.valid_mm == b.valid_mm for a, b in zip(stations, source.stations)):
+        raise BoxesRefused(
+            f"every rectangle of {source.id8} is as it was; nothing to write"
+        )
+    taken = list(taken_tags)
+    if tag is None:
+        tag = suffixed_tag(source.tag, TAG_SUFFIX, taken)
+    elif tag and tag.lower() in {t.lower() for t in taken}:
+        raise BoxesRefused(f"tag {tag!r} is taken by another calibration of {site.name}")
+    return dataclasses.replace(
+        source,
+        valid_mm=union_rect(st.valid_mm for st in stations),
+        stations=stations,
+        tag=tag,
+        edited_from=source.id,
+        path=None,
+        stored_id="",
+    )
+
+
+def _inside(rect: Sequence[int], x: float, y: float) -> bool:
+    return rect[0] <= x <= rect[2] and rect[1] <= y <= rect[3]
+
+
+def coverage_warnings(calibration: Calibration) -> list[str]:
+    """One line per station whose rectangle leaves out spin circles or
+    placement points that station saw."""
+    out = []
+    circles = spin_centres(calibration)
+    for st in sorted(calibration.stations, key=lambda s: s.index):
+        names = sorted(
+            {
+                c["name"]
+                for c in circles.get(st.index, [])
+                if not _inside(st.valid_mm, c["x"], c["y"])
+            }
+        )
+        points = sum(
+            1
+            for placement in calibration.placements
+            for sample in placement.samples
+            if sample.station == st.index
+            and not _inside(st.valid_mm, *placement.points_mm[sample.point])
+        )
+        left_out = []
+        if names:
+            left_out.append(
+                f"{len(names)} spin circle(s) ({', '.join(names[:3])}"
+                + (f" and {len(names) - 3} more" if len(names) > 3 else "")
+                + ")"
+            )
+        if points:
+            left_out.append(f"{points} placement point(s)")
+        if left_out:
+            out.append(
+                f"{station_label(st.index)}'s rectangle {list(st.valid_mm)} leaves "
+                f"out {' and '.join(left_out)} it was calibrated on"
+            )
+    return out
+
+
+def push_line(calibration: Calibration) -> str:
+    return (
+        f"dotbot swarm calibrate-lh2 push {calibration.id8} "
+        f"--site {calibration.site.name}"
+    )
diff --git a/dotbot/tests/test_calibration_station_boxes.py b/dotbot/tests/test_calibration_station_boxes.py
new file mode 100644
index 00000000..f310fe19
--- /dev/null
+++ b/dotbot/tests/test_calibration_station_boxes.py
@@ -0,0 +1,140 @@
+# SPDX-FileCopyrightText: 2026-present Inria
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Changing where each station of a calibration is trusted, as a new
+calibration."""
+
+import dataclasses
+
+import pytest
+
+from dotbot.calibration import conics, lighthouse2
+from dotbot.calibration.lighthouse2 import read_calibration_file
+from dotbot.calibration.placement import Rigid2D, place_calibration, save_new
+from dotbot.calibration.station_boxes import (
+    BoxesRefused,
+    coverage_warnings,
+    reboxed,
+)
+from dotbot.site import Site
+from dotbot.tests.test_calibration_conics import (
+    CENTRES,
+    STATION,
+    STATION_B,
+    circle_samples,
+)
+
+ARENA = Site(name="arena", anchor="the door corner", extent_mm=(3000, 4000))
+
+
+@pytest.fixture(scope="module")
+def free():
+    samples = circle_samples(STATION, CENTRES, 0) + circle_samples(
+        STATION_B, CENTRES[1:], 1, start=1
+    )
+    calibration, _, unsolved = conics.solve_calibration(
+        samples, Site(name="lab"), tag="spin"
+    )
+    assert not unsolved
+    return calibration
+
+
+@pytest.fixture(scope="module")
+def placed(free):
+    return place_calibration(free, ARENA, Rigid2D(100, 200, 0))
+
+
+def test_only_the_named_rectangle_and_the_fence_change(placed):
+    boxed = reboxed(placed, ARENA, {0: (0, 0, 1500, 4000)})
+    assert placed.stations[0].valid_mm == (0, 0, 3000, 4000)
+    assert [st.valid_mm for st in boxed.stations] == [
+        (0, 0, 1500, 4000),
+        (0, 0, 3000, 4000),
+    ]
+    assert boxed.valid_mm == (0, 0, 3000, 4000)
+    assert [st.homography for st in boxed.stations] == [
+        st.homography for st in placed.stations
+    ]
+    assert (boxed.tracks, boxed.links, boxed.created_at) == (
+        placed.tracks,
+        placed.links,
+        placed.created_at,
+    )
+    assert boxed.id != placed.id
+    assert boxed.edited_from == placed.id
+    assert boxed.placed_from == placed.placed_from
+    assert boxed.tag == "spin-arena-boxes"
+
+
+def test_the_fence_shrinks_to_the_union(placed):
+    boxed = reboxed(placed, ARENA, {0: (0, 0, 1500, 2000), 1: (1000, 500, 2500, 3000)})
+    assert boxed.valid_mm == (0, 0, 2500, 3000)
+
+
+def test_a_reboxed_calibration_reads_back_with_its_lineage(placed, tmp_path, monkeypatch):
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path)
+    boxed, path = save_new(reboxed(placed, ARENA, {1: (500, 0, 3000, 4000)}))
+    back = read_calibration_file(path)
+    assert back.id == boxed.id
+    assert back.edited_from == placed.id
+    assert back.station(1).valid_mm == (500, 0, 3000, 4000)
+    # Saving the same rectangles again finds the file instead of a second one
+    again, same = save_new(reboxed(placed, ARENA, {1: (500, 0, 3000, 4000)}))
+    assert same == path and again.id == boxed.id
+
+
+def test_a_second_edit_numbers_the_tag(placed):
+    first = reboxed(placed, ARENA, {0: (0, 0, 1500, 4000)})
+    second = reboxed(first, ARENA, {0: (0, 0, 1000, 4000)}, taken_tags=[first.tag])
+    assert second.tag == "spin-arena-boxes-2"
+    assert second.edited_from == first.id
+
+
+@pytest.mark.parametrize(
+    "rect, why",
+    [
+        ((100, 0, 100, 4000), "is empty"),
+        ((500, 0, 100, 4000), "is empty"),
+        ((-10, 0, 1000, 4000), "below zero"),
+        ((0, 0, 3001, 4000), "outside the site's extent"),
+    ],
+)
+def test_a_rectangle_a_robot_cannot_take_is_refused(placed, rect, why):
+    with pytest.raises(BoxesRefused, match=rf"station 0 \(channel 1\)'s rectangle .*{why}"):
+        reboxed(placed, ARENA, {0: rect})
+
+
+def test_a_free_mode_calibration_is_refused(free):
+    with pytest.raises(BoxesRefused, match="free-mode spin calibration"):
+        reboxed(free, Site(name="lab"), {0: (0, 0, 100, 100)})
+
+
+def test_a_calibration_of_another_site_or_anchor_is_refused(placed):
+    with pytest.raises(BoxesRefused, match="not in site hall's frame"):
+        reboxed(placed, dataclasses.replace(ARENA, name="hall"), {0: (0, 0, 10, 10)})
+    with pytest.raises(BoxesRefused, match="anchor"):
+        reboxed(placed, dataclasses.replace(ARENA, anchor="moved"), {0: (0, 0, 10, 10)})
+
+
+def test_an_unknown_station_nothing_changed_and_a_taken_tag_are_refused(placed):
+    with pytest.raises(BoxesRefused, match="has no station 5"):
+        reboxed(placed, ARENA, {5: (0, 0, 10, 10)})
+    with pytest.raises(BoxesRefused, match="nothing to write"):
+        reboxed(placed, ARENA, {0: (0, 0, 3000, 4000)})
+    with pytest.raises(BoxesRefused, match="tag 'mine' is taken"):
+        reboxed(placed, ARENA, {0: (0, 0, 10, 10)}, tag="mine", taken_tags=["Mine"])
+
+
+def test_a_hand_edited_file_is_refused(placed):
+    edited = dataclasses.replace(placed, stored_id="0123456789abcdef")
+    with pytest.raises(BoxesRefused, match="edited after it was written"):
+        reboxed(edited, ARENA, {0: (0, 0, 10, 10)})
+
+
+def test_a_rectangle_leaving_out_circles_is_warned_about(placed):
+    assert coverage_warnings(placed) == []
+    boxed = reboxed(placed, ARENA, {0: (0, 0, 50, 50)})
+    (line,) = coverage_warnings(boxed)
+    assert line.startswith("station 0 (channel 1)'s rectangle [0, 0, 50, 50] leaves out")
+    assert "spin circle(s)" in line
+

From ec1338204d4da39964de64bf558dde480f103f08 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Thu, 15 Oct 2026 09:48:38 -0300
Subject: [PATCH 78/80] dotbot/cli: add calibrate-lh2 rebox

AI-assisted: Claude Opus 5.5
---
 dotbot/cli/swarm_lh2.py                       | 130 ++++++++++++++++++
 .../tests/test_calibration_station_boxes.py   |  63 ++++++++-
 2 files changed, 191 insertions(+), 2 deletions(-)

diff --git a/dotbot/cli/swarm_lh2.py b/dotbot/cli/swarm_lh2.py
index 521cb738..cc17275e 100644
--- a/dotbot/cli/swarm_lh2.py
+++ b/dotbot/cli/swarm_lh2.py
@@ -19,6 +19,8 @@
               another id.
 - `reframe <path|id>` - re-express a saved calibration in another site's
               frame and re-solve it from its stored samples.
+- `rebox <path|id>` - save a new calibration with some stations'
+              rectangles changed, everything else as it was.
 
 The homography solve lives in PyDotBot (`dotbot.calibration.lighthouse2`);
 the transport lives in swarmit.
@@ -1080,3 +1082,131 @@ def _reframe(ctx, calibration, site_name, shift, rotate):
         )
     click.echo(f"\nCalibration saved to {path}")
     click.echo(f"Calibration id {reframed.id}, site {site.name}")
+
+
+def _parse_station_rect(_ctx, _param, values):
+    out = []
+    for value in values:
+        index, sep, rect = value.partition("=")
+        try:
+            index = int(index)
+        except ValueError:
+            index = -1
+        if not sep or not rect.strip() or not 0 <= index <= 15:
+            raise click.BadParameter(
+                f"{value!r}: takes `N=x,y,w,h` (mm) or `N=<area>`, N a station 0 to 15"
+            )
+        out.append((index, rect.strip()))
+    return out
+
+
+@cmd.command(
+    name="rebox",
+    help=(
+        "Change where stations of a saved calibration are trusted: save a "
+        "new file, with a new id, whose named stations have the given "
+        "rectangles and everything else, homographies included, as it was. "
+        "The calibration must be in the site's frame (placed, not free "
+        "mode). Sends nothing; push the new id when it looks right."
+    ),
+)
+@click.argument("calibration")
+@click.option(
+    "--station",
+    "stations",
+    multiple=True,
+    required=True,
+    callback=_parse_station_rect,
+    metavar="N=RECT",
+    help=(
+        "Station N's new rectangle: `x,y,w,h` in mm, or an area of the site "
+        "such as `field+staging`. Repeat for each station to change; the "
+        "others keep theirs."
+    ),
+)
+@click.option(
+    "--tag",
+    default=None,
+    help="Tag of the new calibration. Defaults to the source's, suffixed -boxes.",
+)
+@click.option(
+    "--site",
+    "site_name",
+    default=None,
+    help="The site to look the id up under. Defaults to `site` in the dotbot config.",
+)
+@click.pass_context
+def _rebox(ctx, calibration, stations, tag, site_name):
+    if _devices(ctx):
+        raise click.UsageError("rebox sends nothing, so it takes no `dotbot swarm -d`")
+    from dotbot.calibration.lighthouse2 import (
+        read_calibration_file,
+        resolve_calibration_path,
+        station_label,
+    )
+    from dotbot.calibration.placement import save_new, site_tags
+    from dotbot.calibration.station_boxes import (
+        coverage_warnings,
+        push_line,
+        reboxed,
+    )
+
+    site, _ = site_from_context(ctx, site_name)
+    rects = {}
+    for index, spec in stations:
+        if index in rects:
+            raise click.BadParameter(
+                f"station {index} is given twice", param_hint="--station"
+            )
+        try:
+            area = site.registry().resolve(spec)
+        except ValueError as exc:
+            raise click.BadParameter(str(exc), param_hint="--station") from exc
+        rects[index] = (area.x, area.y, area.x + area.w, area.y + area.h)
+    try:
+        path = resolve_calibration_path(calibration, site=site)
+        source = read_calibration_file(path)
+        boxed = reboxed(
+            source,
+            site,
+            rects,
+            tag=tag,
+            taken_tags=site_tags(site.name, _site_calibration_files(site)),
+        )
+        boxed, saved = save_new(boxed)
+    except ValueError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(f"Reboxed {source.id8} (site {source.site.name}):")
+    before = {s.index: s.valid_mm for s in source.stations}
+    for station in sorted(boxed.stations, key=lambda s: s.index):
+        x0, y0, x1, y1 = station.valid_mm
+        was = before[station.index]
+        change = "" if was != station.valid_mm else ", unchanged"
+        click.echo(
+            f"  {station_label(station.index)}: {x0},{y0},{x1 - x0},{y1 - y0} "
+            f"(x,y,w,h; valid_mm {list(station.valid_mm)}, was {list(was)}{change})"
+        )
+    for line in coverage_warnings(boxed):
+        click.echo(f"warning: {line}", err=True)
+    click.echo(f"\nCalibration saved to {saved}")
+    click.echo(
+        f"Calibration id {boxed.id}"
+        + (f", tag {boxed.tag!r}" if boxed.tag else "")
+        + f", site {boxed.site.name}"
+    )
+    click.echo(f"Send it with:\n  {push_line(boxed)}")
+
+
+def _site_calibration_files(site):
+    """The calibration files `resolve_calibration_path` searches for `site`."""
+    from dotbot.calibration.lighthouse2 import (
+        CALIBRATION_TOML_GLOB,
+        calibration_folders,
+        calibration_root,
+    )
+
+    return [
+        path
+        for folder, prefix in calibration_folders(site, calibration_root())
+        for path in sorted(folder.glob(prefix + CALIBRATION_TOML_GLOB))
+    ]
diff --git a/dotbot/tests/test_calibration_station_boxes.py b/dotbot/tests/test_calibration_station_boxes.py
index f310fe19..30882d5b 100644
--- a/dotbot/tests/test_calibration_station_boxes.py
+++ b/dotbot/tests/test_calibration_station_boxes.py
@@ -2,14 +2,15 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 """Changing where each station of a calibration is trusted, as a new
-calibration."""
+calibration, from Python and from `calibrate-lh2 rebox`."""
 
 import dataclasses
 
 import pytest
+from click.testing import CliRunner
 
 from dotbot.calibration import conics, lighthouse2
-from dotbot.calibration.lighthouse2 import read_calibration_file
+from dotbot.calibration.lighthouse2 import read_calibration_file, write_calibration
 from dotbot.calibration.placement import Rigid2D, place_calibration, save_new
 from dotbot.calibration.station_boxes import (
     BoxesRefused,
@@ -138,3 +139,61 @@ def test_a_rectangle_leaving_out_circles_is_warned_about(placed):
     assert line.startswith("station 0 (channel 1)'s rectangle [0, 0, 50, 50] leaves out")
     assert "spin circle(s)" in line
 
+
+def _lab(tmp_path):
+    lab = tmp_path / "lab"
+    (lab / "sites" / "arena").mkdir(parents=True)
+    (lab / "sites" / "arena" / "site.toml").write_text(
+        f'anchor = "{ARENA.anchor}"\nextent_mm = [3000, 4000]\n\n'
+        "[areas.field]\nx = 0\ny = 0\nw = 3000\nh = 2000\n"
+    )
+    (lab / "dotbot.toml").write_text('site = "arena"\n')
+    return lab
+
+
+def _rebox(tmp_path, *args):
+    from dotbot.cli import swarm_lh2
+    from dotbot.config import load_discovered
+
+    return CliRunner().invoke(
+        swarm_lh2.cmd,
+        ["rebox", *args],
+        obj={"config": load_discovered(environ={}, start_dir=_lab(tmp_path))},
+    )
+
+
+def test_rebox_writes_a_new_calibration_from_literals_and_areas(
+    placed, tmp_path, monkeypatch
+):
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path / "home")
+    source = write_calibration(placed)
+    before = source.read_bytes()
+    result = _rebox(
+        tmp_path, placed.id8, "--station", "0=0,0,1500,4000", "--station", "1=field"
+    )
+    assert result.exit_code == 0, result.output
+    assert source.read_bytes() == before
+    (written,) = set(source.parent.glob("*.toml")) - {source}
+    boxed = read_calibration_file(written)
+    assert boxed.station(0).valid_mm == (0, 0, 1500, 4000)
+    assert boxed.station(1).valid_mm == (0, 0, 3000, 2000)
+    assert boxed.edited_from == placed.id
+    assert f"dotbot swarm calibrate-lh2 push {boxed.id8} --site arena" in result.output
+    assert "0,0,1500,4000 (x,y,w,h; valid_mm [0, 0, 1500, 4000]" in result.output
+
+
+def test_rebox_refuses_a_rectangle_outside_the_site(placed, tmp_path, monkeypatch):
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path / "home")
+    source = write_calibration(placed)
+    result = _rebox(tmp_path, placed.id8, "--station", "0=0,0,3500,4000")
+    assert result.exit_code != 0
+    assert "outside the site's extent" in result.output
+    assert list(source.parent.glob("*.toml")) == [source]
+
+
+def test_rebox_takes_n_equals_a_rectangle(placed, tmp_path, monkeypatch):
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", tmp_path / "home")
+    write_calibration(placed)
+    result = _rebox(tmp_path, placed.id8, "--station", "0,0,1500,4000")
+    assert result.exit_code == 2
+    assert "N=x,y,w,h" in result.output

From 96daf8db97d462c808fddf7ed799297711537222 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Thu, 15 Oct 2026 09:48:38 -0300
Subject: [PATCH 79/80] dotbot/site_editor: save station boxes as a new
 calibration

AI-assisted: Claude Opus 5.5
---
 dotbot/site_placement.py               | 71 +++++++++++++++++++--
 dotbot/tests/test_site_editor_panel.py | 22 +++++++
 dotbot/tests/test_site_placement.py    | 85 ++++++++++++++++++++++++++
 3 files changed, 173 insertions(+), 5 deletions(-)

diff --git a/dotbot/site_placement.py b/dotbot/site_placement.py
index ba883a48..5df3719d 100644
--- a/dotbot/site_placement.py
+++ b/dotbot/site_placement.py
@@ -2,10 +2,11 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 """The site editor's calibration routes: list the LH2 calibrations, draw one
-over the site, and save it moved onto the site as a new calibration.
+over the site, and save it moved onto the site, or with its stations'
+rectangles changed, as a new calibration.
 
-The file a calibration is loaded from is never written; a placement is saved
-under a new id, beside it in the site's calibration folder.
+The file a calibration is loaded from is never written; a new one is saved
+under a new id in the site's calibration folder.
 """
 
 from __future__ import annotations
@@ -17,6 +18,7 @@
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 
+from dotbot import site_toml
 from dotbot.calibration import lighthouse2
 from dotbot.calibration.placement import (
     FREE_SOLVERS,
@@ -27,8 +29,16 @@
     place_calibration,
     save_placed,
     site_tags,
+    save_new,
     spin_centres,
 )
+from dotbot.calibration.station_boxes import (
+    BoxesRefused,
+    coverage_warnings,
+    frame_refusal,
+    push_line,
+    reboxed,
+)
 from dotbot.config import SiteSection
 from dotbot.site import PACK_CALIBRATIONS, Site, site_from_table
 
@@ -41,6 +51,15 @@ class PlaceRequest(BaseModel):
     reanchor: bool = False
 
 
+class BoxesRequest(BaseModel):
+    # Station index to its new `[x_min, y_min, x_max, y_max]`, frame mm
+    stations: dict[int, tuple[int, int, int, int]]
+    # None takes the source's tag suffixed `-boxes`; "" saves it untagged
+    tag: str | None = None
+    # The site.toml revision the page checked the rectangles against
+    revision: str | None = None
+
+
 def _folders(pack: Path) -> list[tuple[Path, str]]:
     return [(pack / PACK_CALIBRATIONS, ""), (lighthouse2.calibration_root(), "*/")]
 
@@ -72,6 +91,7 @@ def _metadata(path: Path) -> dict | None:
         "stations": sorted(int(st.get("index", 0)) for st in stations),
         "tag": meta.get("tag", ""),
         "site": data.get("site", {}).get("name", ""),
+        "anchor": data.get("site", {}).get("anchor", ""),
         "path": str(path),
     }
 
@@ -103,12 +123,24 @@ def current_site() -> Site:
 
     @router.get("/api/calibrations")
     def calibrations():
-        return [m for m in map(_metadata, _files(pack)) if m and m["id"]]
+        try:
+            site = current_site()
+        except HTTPException:
+            site = None
+        listed = [m for m in map(_metadata, _files(pack)) if m and m["id"]]
+        for m in listed:
+            file_site = Site(name=m["site"], anchor=m.pop("anchor"))
+            m["in_frame"] = site is not None and frame_refusal(file_site, site) is None
+        return listed
 
     @router.get("/api/calibrations/{spec}")
     def calibration(spec: str):
         cal = resolve(spec)
-        return {**overlay(cal), "path": str(cal.path)}
+        try:
+            refusal = frame_refusal(cal.site, current_site())
+        except HTTPException as exc:
+            refusal = exc.detail
+        return {**overlay(cal), "path": str(cal.path), "frame_refusal": refusal}
 
     @router.post("/api/calibrations/{spec}/place")
     def place(spec: str, request: PlaceRequest):
@@ -155,4 +187,33 @@ def place(spec: str, request: PlaceRequest):
             "warnings": warnings,
         }
 
+    @router.post("/api/calibrations/{spec}/boxes")
+    def boxes(spec: str, request: BoxesRequest):
+        source = resolve(spec)
+        text = site_text()
+        if (
+            request.revision is not None
+            and site_toml.revision(text.encode("utf-8")) != request.revision
+        ):
+            raise HTTPException(409, "site.toml changed on disk since the page loaded it")
+        site = current_site()
+        try:
+            boxed = reboxed(
+                source,
+                site,
+                request.stations,
+                tag=request.tag,
+                taken_tags=site_tags(site.name, _files(pack)),
+            )
+            boxed, path = save_new(boxed)
+        except BoxesRefused as exc:
+            raise HTTPException(422, str(exc)) from exc
+        return {
+            **overlay(boxed),
+            "path": str(path),
+            "source": source.id8,
+            "push": push_line(boxed),
+            "warnings": coverage_warnings(boxed),
+        }
+
     return router
diff --git a/dotbot/tests/test_site_editor_panel.py b/dotbot/tests/test_site_editor_panel.py
index 464d6427..0efcae01 100644
--- a/dotbot/tests/test_site_editor_panel.py
+++ b/dotbot/tests/test_site_editor_panel.py
@@ -145,6 +145,28 @@ async def test_a_pack_that_no_longer_reads_keeps_the_site(scenario):
     assert s.controller.site is before
 
 
+@pytest.mark.asyncio
+async def test_the_panel_reboxes_a_calibration_of_its_site(scenario, monkeypatch):
+    from dotbot.calibration import conics, lighthouse2
+    from dotbot.calibration.lighthouse2 import read_calibration_file
+    from dotbot.calibration.placement import Rigid2D, place_calibration, save_new
+    from dotbot.site import Site
+    from dotbot.tests.test_calibration_conics import CENTRES, track_samples
+
+    s, local, pack = scenario
+    monkeypatch.setattr(lighthouse2, "CALIBRATION_DIR", pack.parent / "home")
+    spun, _, _ = conics.solve_calibration(track_samples(CENTRES), Site(name="lab"))
+    placed, _ = save_new(place_calibration(spun, s.controller.site, Rigid2D(100, 200)))
+    response = await local.post(
+        f"/controller/site-editor/api/calibrations/{placed.id}/boxes",
+        json={"stations": {"0": [0, 0, 1000, 2000]}},
+    )
+    assert response.status_code == 200, response.text
+    boxed = read_calibration_file(response.json()["path"])
+    assert boxed.station(0).valid_mm == (0, 0, 1000, 2000)
+    assert boxed.edited_from == placed.id
+
+
 @pytest.mark.asyncio
 async def test_a_site_without_a_pack_has_no_panel(tmp_path):
     s = Scenario(tmp_path, [{"address": A, "pos_x": 500, "pos_y": 500}])
diff --git a/dotbot/tests/test_site_placement.py b/dotbot/tests/test_site_placement.py
index 2526fb71..6780a949 100644
--- a/dotbot/tests/test_site_placement.py
+++ b/dotbot/tests/test_site_placement.py
@@ -140,3 +140,88 @@ def test_a_placement_outside_the_extent_is_saved_with_a_warning(client, spun):
         f"/api/calibrations/{spun.id8}/place", json={"dx_mm": 1500}
     ).json()
     assert any("outside the site's extent" in w for w in body["warnings"])
+
+
+@pytest.fixture
+def placed(client, spun, home):
+    body = client.post(
+        f"/api/calibrations/{spun.id8}/place",
+        json={"dx_mm": 100, "dy_mm": 200, "theta_deg": 0},
+    ).json()
+    return read_calibration_file(body["path"])
+
+
+def test_the_listing_says_which_calibrations_are_in_the_site_s_frame(
+    client, spun, placed
+):
+    listed = {c["id"]: c["in_frame"] for c in client.get("/api/calibrations").json()}
+    assert listed == {spun.id: False, placed.id: True}
+    assert client.get(f"/api/calibrations/{placed.id8}").json()["frame_refusal"] is None
+    refusal = client.get(f"/api/calibrations/{spun.id8}").json()["frame_refusal"]
+    assert "free-mode spin calibration" in refusal
+
+
+def test_boxes_write_a_new_calibration_with_only_the_rectangles_changed(
+    client, placed
+):
+    source = placed.path.read_bytes()
+    revision = client.get("/api/site").json()["revision"]
+    response = client.post(
+        f"/api/calibrations/{placed.id}/boxes",
+        json={"revision": revision, "stations": {"0": [0, 0, 1000, 2000]}},
+    )
+    assert response.status_code == 200, response.text
+    body = response.json()
+    assert placed.path.read_bytes() == source
+    boxed = read_calibration_file(body["path"])
+    assert boxed.id == body["id"] != placed.id
+    assert boxed.station(0).valid_mm == (0, 0, 1000, 2000)
+    assert boxed.valid_mm == (0, 0, 1000, 2000)
+    assert boxed.station(0).homography == placed.station(0).homography
+    assert boxed.edited_from == placed.id
+    assert boxed.tag == f"{placed.tag}-boxes"
+    assert body["stations"][0]["rect"] == [0, 0, 1000, 2000]
+    assert body["source"] == placed.id8
+    assert body["push"] == f"dotbot swarm calibrate-lh2 push {boxed.id8} --site arena"
+
+
+def test_boxes_leaving_out_circles_are_saved_with_a_warning(client, placed):
+    body = client.post(
+        f"/api/calibrations/{placed.id}/boxes",
+        json={"stations": {"0": [1500, 3000, 2000, 4000]}},
+    ).json()
+    (warning,) = body["warnings"]
+    assert "leaves out" in warning and "spin circle(s)" in warning
+
+
+@pytest.mark.parametrize(
+    "rect, why",
+    [
+        ([0, 0, 2500, 4000], "outside the site's extent"),
+        ([0, 0, 0, 4000], "is empty"),
+    ],
+)
+def test_boxes_a_robot_cannot_take_are_refused(client, placed, home, rect, why):
+    response = client.post(
+        f"/api/calibrations/{placed.id}/boxes", json={"stations": {"0": rect}}
+    )
+    assert response.status_code == 422
+    assert why in response.json()["detail"]
+    assert len(list((home / "arena").glob("*.toml"))) == 1
+
+
+def test_boxes_of_a_free_mode_calibration_are_refused(client, spun):
+    response = client.post(
+        f"/api/calibrations/{spun.id}/boxes", json={"stations": {"0": [0, 0, 10, 10]}}
+    )
+    assert response.status_code == 422
+    assert "free-mode spin calibration" in response.json()["detail"]
+
+
+def test_boxes_checked_against_an_older_site_toml_are_a_409(client, placed, home):
+    response = client.post(
+        f"/api/calibrations/{placed.id}/boxes",
+        json={"revision": "stale", "stations": {"0": [0, 0, 1000, 2000]}},
+    )
+    assert response.status_code == 409
+    assert len(list((home / "arena").glob("*.toml"))) == 1

From 3158b2a9b54369c88865f7fe4ff0fc4f6bb48066 Mon Sep 17 00:00:00 2001
From: Geovane Fedrecheski <geonnave@gmail.com>
Date: Thu, 15 Oct 2026 09:48:38 -0300
Subject: [PATCH 80/80] dotbot/console-web: edit station boxes in the site
 editor

AI-assisted: Claude Opus 5.5
---
 dotbot/console-web/src/siteEditor/Canvas.tsx  | 139 ++++++++++-
 .../console-web/src/siteEditor/SiteEditor.tsx | 151 +++++++++++-
 .../src/siteEditor/StationBoxesPanel.tsx      | 217 ++++++++++++++++++
 dotbot/console-web/src/siteEditor/api.ts      |  23 ++
 .../console-web/src/siteEditor/boxes.test.ts  |  51 ++++
 dotbot/console-web/src/siteEditor/boxes.ts    |  61 +++++
 .../src/siteEditor/siteEditor.test.tsx        | 148 ++++++++++++
 dotbot/console-web/src/siteEditor/types.ts    |   6 +-
 8 files changed, 780 insertions(+), 16 deletions(-)
 create mode 100644 dotbot/console-web/src/siteEditor/StationBoxesPanel.tsx
 create mode 100644 dotbot/console-web/src/siteEditor/boxes.test.ts
 create mode 100644 dotbot/console-web/src/siteEditor/boxes.ts

diff --git a/dotbot/console-web/src/siteEditor/Canvas.tsx b/dotbot/console-web/src/siteEditor/Canvas.tsx
index 49abcce7..1fb64c3d 100644
--- a/dotbot/console-web/src/siteEditor/Canvas.tsx
+++ b/dotbot/console-web/src/siteEditor/Canvas.tsx
@@ -19,6 +19,7 @@ import type { Area } from "../types";
 import { FRAME_CAMERA, viewGeom } from "../zoom";
 import { BARRIER_MIN_POINTS, HANDLES, effectiveRole, finishPoints, movePoints, moveRect, rectFromDrag, resizeRect, snap } from "./edit";
 import type { Handle, Rect } from "./edit";
+import { STATION_COLOURS } from "./boxes";
 import { applyMove, movedBox, movedCorners, snapAngle, turnAbout } from "./rigid";
 import type { Point, Rigid2D } from "./rigid";
 import type {
@@ -29,13 +30,14 @@ import type {
   EditArea,
   EditBarrier,
   EditObject,
+  SpinCircle,
 } from "./types";
 
 // The site drawn to scale: the extent, the metric grid and its rulers, and
 // every area in its role colour. Areas are moved, resized and drawn here; the
 // numbers themselves live in the inspector.
 
-export type Tool = "select" | "area" | "calibration" | "wall" | "obstacle" | "object";
+export type Tool = "select" | "area" | "calibration" | "boxes" | "wall" | "obstacle" | "object";
 
 /** A selected wall or obstacle. */
 export interface BarrierRef {
@@ -51,8 +53,13 @@ export interface Placement {
   move: Rigid2D;
 }
 
-// One colour per station, in station order
-const STATION_COLOURS = ["var(--accent)", "var(--s-Running)", "var(--s-Programming)", "var(--s-Bootloader)"];
+/** One station's rectangle being edited, frame mm, and the circles it saw. */
+export interface StationBox {
+  index: number;
+  channel: number;
+  rect: Rect;
+  circles: SpinCircle[];
+}
 const ROTATE_HANDLE_PX = 28;
 
 const HANDLE_PX = 9;
@@ -68,7 +75,9 @@ type Drag =
   | { kind: "barrier-move"; ref: BarrierRef; start: [number, number][]; from: { x: number; y: number } }
   | { kind: "barrier-vertex"; ref: BarrierRef; vertex: number }
   | { kind: "object-move"; index: number; start: { x: number; y: number }; from: { x: number; y: number } }
-  | { kind: "place-turn"; start: Rigid2D; pivot: Point; angle: number };
+  | { kind: "place-turn"; start: Rigid2D; pivot: Point; angle: number }
+  | { kind: "box-move"; k: number; start: Rect; from: { x: number; y: number }; px: { x: number; y: number } }
+  | { kind: "box-resize"; k: number; start: Rect; handle: Handle };
 
 export interface CanvasProps {
   extent: [number, number] | null;
@@ -95,6 +104,13 @@ export interface CanvasProps {
   onSelectObject?: (index: number | null) => void;
   onObjectChange?: (index: number, at: { x: number; y: number }, key: string) => void;
   onObjectPlace?: (at: { x: number; y: number }) => void;
+  /** A calibration's station rectangles, edited with the boxes tool. */
+  stationBoxes?: StationBox[] | null;
+  /** The box being edited, by its position in `stationBoxes`. */
+  selectedBox?: number | null;
+  onSelectBox?: (k: number | null) => void;
+  /** `key` names the gesture, so one drag undoes as one step. */
+  onBoxChange?: (k: number, rect: Rect, key: string) => void;
   /** Read-only layers under the areas: only the ones switched on. */
   backdrops?: { calibrations: CalibrationBackdrop[]; cameras: CameraBackdrop[] };
 }
@@ -223,6 +239,8 @@ export function Canvas(props: CanvasProps) {
     if (props.tool === "area") {
       const p = toFrame(e);
       begin(e, { kind: "draw", from: p, to: p });
+    } else if (props.tool === "boxes") {
+      props.onSelectBox?.(null);
     } else {
       props.onSelect(null);
       props.onSelectBarrier?.(null);
@@ -230,6 +248,19 @@ export function Canvas(props: CanvasProps) {
     }
   };
 
+  const onBoxDown = (e: React.PointerEvent, k: number) => {
+    const box = props.stationBoxes?.[k];
+    if (e.button !== 0 || props.tool !== "boxes" || !box) return;
+    props.onSelectBox?.(k);
+    begin(e, { kind: "box-move", k, start: box.rect, from: toFrame(e), px: { x: e.clientX, y: e.clientY } });
+  };
+
+  const onBoxHandleDown = (e: React.PointerEvent, k: number, handle: Handle) => {
+    const box = props.stationBoxes?.[k];
+    if (e.button !== 0 || !box) return;
+    begin(e, { kind: "box-resize", k, start: box.rect, handle });
+  };
+
   const onObjectDown = (e: React.PointerEvent, index: number) => {
     if (e.button !== 0 || props.tool !== "select") return;
     const o = props.objects?.[index];
@@ -326,6 +357,11 @@ export function Canvas(props: CanvasProps) {
         dx_mm: s > 1 ? snap(turned.dx_mm, s) : Math.round(turned.dx_mm * 10) / 10,
         dy_mm: s > 1 ? snap(turned.dy_mm, s) : Math.round(turned.dy_mm * 10) / 10,
       });
+    } else if (drag.kind === "box-move") {
+      if (Math.hypot(e.clientX - drag.px.x, e.clientY - drag.px.y) < DRAG_THRESHOLD_PX) return;
+      props.onBoxChange?.(drag.k, moveRect(drag.start, p.x - drag.from.x, p.y - drag.from.y, s), `canvas-${gesture.current}`);
+    } else if (drag.kind === "box-resize") {
+      props.onBoxChange?.(drag.k, resizeRect(drag.start, drag.handle, p, s), `canvas-${gesture.current}`);
     } else if (drag.kind === "move") {
       // A click that selects is not a move, however the pointer jitters
       if (Math.hypot(e.clientX - drag.px.x, e.clientY - drag.px.y) < DRAG_THRESHOLD_PX) return;
@@ -353,6 +389,16 @@ export function Canvas(props: CanvasProps) {
   const sel = props.selected !== null ? props.areas[props.selected] : null;
   const preview = drag?.kind === "draw" ? rectFromDrag(drag.from, drag.to, props.snapMm) : null;
   const extentPx = rectPx(extentArea);
+  const boxes = props.stationBoxes ?? null;
+  // Largest first and the one being edited last, so each can be grabbed
+  const boxOrder = (boxes ?? [])
+    .map((_, k) => k)
+    .sort((i, j) => {
+      if (i === props.selectedBox) return 1;
+      if (j === props.selectedBox) return -1;
+      return boxes![j].rect.w * boxes![j].rect.h - boxes![i].rect.w * boxes![i].rect.h;
+    });
+  const selBox = boxes && props.selectedBox !== null && props.selectedBox !== undefined ? boxes[props.selectedBox] ?? null : null;
 
   return (
     <div
@@ -598,6 +644,87 @@ export function Canvas(props: CanvasProps) {
             ))}
           </g>
         )}
+        {boxes && (
+          <g data-testid="station-boxes">
+            {boxOrder.map((k) => {
+              const box = boxes[k];
+              const colour = STATION_COLOURS[k % STATION_COLOURS.length];
+              const r = rectPx(box.rect);
+              const editing = props.tool === "boxes";
+              const chosen = editing && props.selectedBox === k;
+              return (
+                <g key={box.index} data-testid={`station-box-${box.index}`}>
+                  <rect
+                    data-testid={`station-box-body-${box.index}`}
+                    {...r}
+                    fill={colour}
+                    fillOpacity={editing ? 0.08 : 0}
+                    stroke={colour}
+                    strokeWidth={chosen ? 2.5 : 1.5}
+                    strokeDasharray={chosen ? undefined : "6 4"}
+                    style={{ cursor: editing ? "move" : "default", pointerEvents: editing ? "all" : "none" }}
+                    onPointerDown={(e) => onBoxDown(e, k)}
+                  >
+                    <title>{`station ${box.index} (channel ${box.channel})`}</title>
+                  </rect>
+                  <text
+                    x={r.x + 4}
+                    y={r.y + 14 + 12 * k}
+                    fontSize={10}
+                    fontFamily="var(--font-mono)"
+                    fill={colour}
+                    style={{ pointerEvents: "none" }}
+                  >
+                    {`station ${box.index} (channel ${box.channel})`}
+                  </text>
+                  {box.circles.map((c) => (
+                    <circle
+                      key={c.name}
+                      cx={px("x", c.x)}
+                      cy={px("y", c.y)}
+                      r={2.5}
+                      fill={colour}
+                      style={{ pointerEvents: "none" }}
+                    />
+                  ))}
+                </g>
+              );
+            })}
+            {selBox && props.tool === "boxes" && props.selectedBox !== null && props.selectedBox !== undefined && (
+              <g data-testid="box-selection">
+                <text
+                  x={rectPx(selBox.rect).x + rectPx(selBox.rect).width / 2}
+                  y={rectPx(selBox.rect).y + rectPx(selBox.rect).height + 16}
+                  textAnchor="middle"
+                  fontSize={11}
+                  fontFamily="var(--font-mono)"
+                  fill="var(--text)"
+                  style={{ pointerEvents: "none" }}
+                >
+                  {`${selBox.rect.w} x ${selBox.rect.h} mm at (${selBox.rect.x}, ${selBox.rect.y})`}
+                </text>
+                {HANDLES.map((h) => {
+                  const p = handlePoint(selBox.rect, h);
+                  return (
+                    <rect
+                      key={h}
+                      data-testid={`box-handle-${h}`}
+                      x={px("x", p.x) - HANDLE_PX / 2}
+                      y={px("y", p.y) - HANDLE_PX / 2}
+                      width={HANDLE_PX}
+                      height={HANDLE_PX}
+                      fill="var(--surface)"
+                      stroke={STATION_COLOURS[props.selectedBox! % STATION_COLOURS.length]}
+                      strokeWidth={1.2}
+                      style={{ cursor: CURSOR[h] }}
+                      onPointerDown={(e) => onBoxHandleDown(e, props.selectedBox!, h)}
+                    />
+                  );
+                })}
+              </g>
+            )}
+          </g>
+        )}
         {placement && fence && placedBox && placeCentre && (
           <g data-testid="placement">
             {placement.overlay.stations.map((st, k) => {
@@ -788,7 +915,9 @@ export function Canvas(props: CanvasProps) {
           ? "free placement (Alt)"
           : props.tool === "calibration"
             ? `snap ${props.snapMm} mm and 90 deg, Alt for free; scale is locked`
-            : `snap ${props.snapMm} mm, Alt for free`}
+            : props.tool === "boxes"
+              ? `drag a station's box or its handles; snap ${props.snapMm} mm, Alt for free`
+              : `snap ${props.snapMm} mm, Alt for free`}
       </div>
     </div>
   );
diff --git a/dotbot/console-web/src/siteEditor/SiteEditor.tsx b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
index 0b3c8f6e..444c2f46 100644
--- a/dotbot/console-web/src/siteEditor/SiteEditor.tsx
+++ b/dotbot/console-web/src/siteEditor/SiteEditor.tsx
@@ -9,9 +9,11 @@ import {
   fetchSite,
   placeCalibration,
   previewSite,
+  reboxCalibration,
   saveSite,
   stopEditor,
 } from "./api";
+import { boxIssues, boxesOf, cornersOf, sameBoxes } from "./boxes";
 import { CalibrationPanel } from "./CalibrationPanel";
 import { Canvas } from "./Canvas";
 import type { BarrierRef, Placement, Tool } from "./Canvas";
@@ -28,11 +30,13 @@ import type { Rect } from "./edit";
 import { record, redo, seal, startHistory, undo } from "./history";
 import type { History } from "./history";
 import { Inspector } from "./Inspector";
+import { StationBoxesPanel } from "./StationBoxesPanel";
 import { IDENTITY } from "./rigid";
 import type {
   Backdrops,
   BarrierKind,
   CalibrationListing,
+  CalibrationOverlay,
   EditArea,
   EditObject,
   PlacedCalibration,
@@ -75,6 +79,7 @@ const TOOLS: { key: Tool; label: string; hint: string }[] = [
   { key: "select", label: "Select", hint: "V: select, move and resize" },
   { key: "area", label: "Area", hint: "A: drag out a new area" },
   { key: "calibration", label: "Calibration", hint: "C: place a spin calibration on the site" },
+  { key: "boxes", label: "Station boxes", hint: "S: change where each LH2 station of a calibration is trusted" },
   { key: "wall", label: "Wall", hint: "W: click the points of a wall, double-click to finish" },
   { key: "obstacle", label: "Obstacle", hint: "O: click the corners of an obstacle, double-click to finish" },
   { key: "object", label: "Object", hint: "B: click to place a charger, dock, landmark or camera" },
@@ -152,6 +157,21 @@ export function SiteEditor(props: SiteEditorProps = {}) {
   const [placed, setPlaced] = useState<PlacedCalibration | null>(null);
   const [backdrops, setBackdrops] = useState<Backdrops | null>(null);
   const [shownBackdrops, setShownBackdrops] = useState<Set<string>>(new Set());
+  // The Station boxes tool: a calibration of this site and its stations'
+  // rectangles, with an undo history of their own
+  const [boxSource, setBoxSource] = useState<CalibrationOverlay | null>(null);
+  const [boxHistory, setBoxHistory] = useState<History<Rect[]> | null>(null);
+  const [selectedBox, setSelectedBox] = useState<number | null>(null);
+  const [boxTag, setBoxTag] = useState("");
+  const [boxSaved, setBoxSaved] = useState<PlacedCalibration | null>(null);
+  const boxes = boxHistory?.present ?? null;
+  const boxesDirty = !!boxSource && !!boxes && !sameBoxes(boxes, boxesOf(boxSource));
+  const setBox = (k: number, rect: Rect, key: string | null = null) =>
+    setBoxHistory((h) => {
+      if (!h) return h;
+      const value = h.present.map((r, i) => (i === k ? rect : r));
+      return sameBoxes(value, h.present) ? h : record(h, value, key);
+    });
 
   const load = useCallback(async () => {
     try {
@@ -183,9 +203,21 @@ export function SiteEditor(props: SiteEditorProps = {}) {
   useEffect(() => {
     setHistory((h) => (h ? seal(h) : h));
   }, [selected]);
+  useEffect(() => {
+    setBoxHistory((h) => (h ? seal(h) : h));
+  }, [selectedBox]);
+
+  // With the boxes tool out, undo and redo act on the boxes
+  const boxTravel = tool === "boxes" && !!boxHistory;
+  const canUndo = boxTravel ? boxHistory!.past.length > 0 : !!history && history.past.length > 0;
+  const canRedo = boxTravel ? boxHistory!.future.length > 0 : !!history && history.future.length > 0;
 
   /** Undo or redo, dropping a selection whose index now names another area. */
-  const travel = (move: (h: History<SiteModel>) => History<SiteModel>) => {
+  const travel = (move: <T>(h: History<T>) => History<T>) => {
+    if (boxTravel) {
+      setBoxHistory((h) => (h ? move(h) : h));
+      return;
+    }
     if (!history) return;
     const next = move(history);
     if (selected !== null && next.present.areas[selected]?.name !== history.present.areas[selected]?.name) {
@@ -195,7 +227,7 @@ export function SiteEditor(props: SiteEditorProps = {}) {
   };
 
   useEffect(() => {
-    if (tool !== "calibration") return;
+    if (tool !== "calibration" && tool !== "boxes") return;
     fetchCalibrations(base)
       .then(setListing)
       .catch((err) => setNotice({ kind: "error", text: `could not list calibrations: ${(err as Error).message}` }));
@@ -226,6 +258,55 @@ export function SiteEditor(props: SiteEditorProps = {}) {
     }
   };
 
+  const startBoxes = (overlay: CalibrationOverlay) => {
+    setBoxSource(overlay);
+    setBoxHistory(startHistory(boxesOf(overlay)));
+    setSelectedBox(null);
+  };
+
+  const loadBoxes = async (spec: string) => {
+    try {
+      startBoxes(await fetchCalibration(spec, base));
+      setBoxSaved(null);
+      setBoxTag("");
+    } catch (err) {
+      setNotice({ kind: "error", text: (err as Error).message });
+    }
+  };
+
+  const saveBoxes = async () => {
+    if (!boxSource || !boxes || !loaded) return;
+    const stations: Record<number, number[]> = {};
+    boxSource.stations.forEach((st, k) => {
+      stations[st.index] = cornersOf(boxes[k]);
+    });
+    try {
+      const result = await reboxCalibration(boxSource.id, stations, boxTag.trim() || null, loaded.revision, base);
+      setBoxSaved(result);
+      // What is drawn is the new file now, so further edits start from it
+      startBoxes({ ...result, frame_refusal: null });
+      setBoxTag("");
+      fetchCalibrations(base)
+        .then(setListing)
+        .catch(() => undefined);
+      setNotice({ kind: "info", text: `saved calibration ${result.id8}; push it with: ${result.push}` });
+    } catch (err) {
+      if (err instanceof StaleSiteError) {
+        setNotice({
+          kind: "stale",
+          text: "site.toml changed on disk since this page loaded it, so the boxes were not saved. Reload takes the file as it is now.",
+        });
+      } else {
+        setNotice({ kind: "error", text: `boxes not saved: ${(err as Error).message}` });
+      }
+    }
+  };
+
+  const boxProblems = useMemo(
+    () => (boxSource && boxes ? boxIssues(boxSource, boxes, site?.extent_mm ?? null) : []),
+    [boxSource, boxes, site?.extent_mm],
+  );
+
   const issues = useMemo(() => (site ? siteIssues(site) : []), [site]);
   const errors = issues.filter((i) => i.level === "error");
   const dirty = !!site && !!loaded && !sameSite(site, loaded.site);
@@ -291,7 +372,12 @@ export function SiteEditor(props: SiteEditorProps = {}) {
   };
 
   const nudge = (dx: number, dy: number) => {
-    if (tool === "calibration" && placement) {
+    if (tool === "boxes") {
+      if (selectedBox !== null && boxes?.[selectedBox]) {
+        const r = boxes[selectedBox];
+        setBox(selectedBox, { ...r, x: r.x + dx, y: r.y + dy }, `nudge-box-${selectedBox}`);
+      }
+    } else if (tool === "calibration" && placement) {
       setPlacement({ ...placement, move: { ...placement.move, dx_mm: placement.move.dx_mm + dx, dy_mm: placement.move.dy_mm + dy } });
     } else if (selected !== null && site?.areas[selected]) {
       const a = site.areas[selected];
@@ -336,10 +422,12 @@ export function SiteEditor(props: SiteEditorProps = {}) {
       if (e.key === "v" || e.key === "V") setTool("select");
       else if (e.key === "a" || e.key === "A") setTool("area");
       else if (e.key === "c" || e.key === "C") setTool("calibration");
+      else if (e.key === "s" || e.key === "S") setTool("boxes");
       else if (e.key === "w" || e.key === "W") setTool("wall");
       else if (e.key === "o" || e.key === "O") setTool("obstacle");
       else if (e.key === "b" || e.key === "B") setTool("object");
       else if (e.key === "Escape") {
+        setSelectedBox(null);
         setSelected(null);
         setSelectedBarrier(null);
         setSelectedObject(null);
@@ -355,11 +443,11 @@ export function SiteEditor(props: SiteEditorProps = {}) {
 
   useEffect(() => {
     const onLeave = (e: BeforeUnloadEvent) => {
-      if (dirty && !stopped) e.preventDefault();
+      if ((dirty || boxesDirty) && !stopped) e.preventDefault();
     };
     window.addEventListener("beforeunload", onLeave);
     return () => window.removeEventListener("beforeunload", onLeave);
-  }, [dirty, stopped]);
+  }, [dirty, boxesDirty, stopped]);
 
   const doSave = async () => {
     if (!site || !loaded) return;
@@ -405,11 +493,11 @@ export function SiteEditor(props: SiteEditorProps = {}) {
 
   const onDone = async () => {
     if (embedded) {
-      if (dirty && !window.confirm("Close the editor without saving your changes?")) return;
+      if ((dirty || boxesDirty) && !window.confirm("Close the editor without saving your changes?")) return;
       props.onClose?.();
       return;
     }
-    if (dirty && !window.confirm("Stop the editor without saving your changes?")) return;
+    if ((dirty || boxesDirty) && !window.confirm("Stop the editor without saving your changes?")) return;
     try {
       await stopEditor(base);
     } catch {
@@ -479,7 +567,7 @@ export function SiteEditor(props: SiteEditorProps = {}) {
           type="button"
           style={button}
           title="undo (Ctrl+Z)"
-          disabled={!history || history.past.length === 0}
+          disabled={!canUndo}
           onClick={() => travel(undo)}
         >
           Undo
@@ -488,7 +576,7 @@ export function SiteEditor(props: SiteEditorProps = {}) {
           type="button"
           style={button}
           title="redo (Ctrl+Shift+Z)"
-          disabled={!history || history.future.length === 0}
+          disabled={!canRedo}
           onClick={() => travel(redo)}
         >
           Redo
@@ -603,6 +691,19 @@ export function SiteEditor(props: SiteEditorProps = {}) {
             onSelectObject={selectObject}
             onObjectChange={(i, at, key) => updateObject(i, at, key)}
             onObjectPlace={addObject}
+            stationBoxes={
+              boxSource && boxes
+                ? boxSource.stations.map((st, k) => ({
+                    index: st.index,
+                    channel: st.channel,
+                    rect: boxes[k],
+                    circles: st.circles,
+                  }))
+                : null
+            }
+            selectedBox={selectedBox}
+            onSelectBox={setSelectedBox}
+            onBoxChange={(k, rect, key) => setBox(k, rect, key)}
             placement={placement}
             onPlacement={(move) => setPlacement((p) => (p ? { ...p, move } : p))}
             backdrops={
@@ -658,7 +759,37 @@ export function SiteEditor(props: SiteEditorProps = {}) {
               })
             }
             extra={
-              tool === "calibration" || placement || placed ? (
+              tool === "boxes" || (boxSource && tool !== "calibration") ? (
+                <StationBoxesPanel
+                  listing={listing.filter((c) => c.in_frame)}
+                  source={boxSource}
+                  boxes={boxes ?? []}
+                  selected={selectedBox}
+                  issues={boxProblems}
+                  tag={boxTag}
+                  dirty={boxesDirty}
+                  saved={boxSaved}
+                  blocked={
+                    frameChanged(site, loaded.site)
+                      ? "Save site.toml first: the boxes are checked against the extent in the file."
+                      : null
+                  }
+                  onLoad={(spec) => void loadBoxes(spec)}
+                  onSelect={(k) => {
+                    setSelectedBox(k);
+                    setTool("boxes");
+                  }}
+                  onBox={(k, rect, key) => setBox(k, rect, key)}
+                  onTag={setBoxTag}
+                  onSave={() => void saveBoxes()}
+                  onClear={() => {
+                    setBoxSource(null);
+                    setBoxHistory(null);
+                    setSelectedBox(null);
+                    setBoxSaved(null);
+                  }}
+                />
+              ) : tool === "calibration" || placement || placed ? (
                 <CalibrationPanel
                   listing={listing}
                   placement={placement}
diff --git a/dotbot/console-web/src/siteEditor/StationBoxesPanel.tsx b/dotbot/console-web/src/siteEditor/StationBoxesPanel.tsx
new file mode 100644
index 00000000..348a93ba
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/StationBoxesPanel.tsx
@@ -0,0 +1,217 @@
+import React, { useState } from "react";
+
+import { STATION_COLOURS } from "./boxes";
+import type { Issue, Rect } from "./edit";
+import type { CalibrationListing, CalibrationOverlay, PlacedCalibration } from "./types";
+
+// Where each LH2 station of a calibration is trusted: pick a calibration in
+// the site's frame, edit its stations' rectangles on the canvas or here, and
+// save them as a new calibration.
+
+const small: React.CSSProperties = { fontSize: 11, color: "var(--muted)", marginTop: 6 };
+const field: React.CSSProperties = {
+  width: "100%",
+  padding: "5px 7px",
+  background: "var(--elevated)",
+  color: "var(--text)",
+  border: "1px solid var(--hairline)",
+  borderRadius: 4,
+  fontFamily: "var(--font-mono)",
+  fontSize: 12,
+};
+const button: React.CSSProperties = {
+  background: "transparent",
+  color: "var(--text)",
+  border: "1px solid var(--hairline)",
+  borderRadius: 4,
+  padding: "4px 10px",
+  cursor: "pointer",
+  fontSize: 12,
+};
+
+export interface StationBoxesPanelProps {
+  /** The calibrations in the site's frame. */
+  listing: CalibrationListing[];
+  source: CalibrationOverlay | null;
+  boxes: Rect[];
+  selected: number | null;
+  issues: Issue[];
+  tag: string;
+  dirty: boolean;
+  saved: PlacedCalibration | null;
+  /** Why Save is not possible now, if it is not. */
+  blocked: string | null;
+  onLoad: (spec: string) => void;
+  onSelect: (k: number) => void;
+  /** `key` names the field, so typing into one undoes as one step. */
+  onBox: (k: number, rect: Rect, key: string) => void;
+  onTag: (tag: string) => void;
+  onSave: () => void;
+  onClear: () => void;
+}
+
+function Num(props: { name: string; label: string; value: number; onChange: (v: number) => void }) {
+  return (
+    <label style={{ flex: 1 }}>
+      <span style={{ ...small, display: "block", margin: "4px 0 2px" }}>{props.label}</span>
+      <input
+        aria-label={props.name}
+        type="number"
+        step={1}
+        value={Number.isFinite(props.value) ? props.value : ""}
+        onChange={(e) => props.onChange(Math.round(Number(e.target.value)))}
+        style={{ ...field, padding: "4px 5px" }}
+      />
+    </label>
+  );
+}
+
+export function StationBoxesPanel(props: StationBoxesPanelProps) {
+  const [spec, setSpec] = useState("");
+  const source = props.source;
+  const errors = props.issues.filter((i) => i.level === "error");
+  const refusal = source?.frame_refusal ?? null;
+  const why = props.blocked ?? refusal ?? (errors.length > 0 ? errors[0].message : null) ?? (props.dirty ? null : "no rectangle changed");
+  const defaultTag = source?.tag ? (source.tag.endsWith("-boxes") ? source.tag : `${source.tag}-boxes`) : "";
+
+  return (
+    <div data-testid="boxes-panel" style={{ borderBottom: "1px solid var(--hairline)", padding: "12px 14px" }}>
+      <div
+        style={{ fontSize: 11, fontWeight: 600, letterSpacing: 0.6, textTransform: "uppercase", color: "var(--muted)" }}
+      >
+        Station boxes
+      </div>
+      <div style={small}>
+        Where each station's fixes are trusted. Load a calibration of this site, drag or type its rectangles; Save writes
+        a new calibration and leaves the loaded one as it is.
+      </div>
+      <form
+        style={{ display: "flex", gap: 6, marginTop: 8 }}
+        onSubmit={(e) => {
+          e.preventDefault();
+          if (spec.trim()) props.onLoad(spec.trim());
+        }}
+      >
+        <input
+          aria-label="boxes calibration id"
+          list="site-editor-box-calibrations"
+          placeholder="id, tag or path"
+          value={spec}
+          onChange={(e) => setSpec(e.target.value)}
+          style={field}
+        />
+        <datalist id="site-editor-box-calibrations">
+          {props.listing.map((c) => (
+            <option key={c.id} value={c.id8}>
+              {`${c.tag ? `${c.tag} ` : ""}${c.created_at}, station${c.stations.length === 1 ? "" : "s"} ${c.stations.join(", ")}`}
+            </option>
+          ))}
+        </datalist>
+        <button type="submit" style={button}>
+          Load
+        </button>
+      </form>
+      <div style={small}>
+        {props.listing.length} calibration{props.listing.length === 1 ? "" : "s"} in this site's frame; a free-mode spin
+        calibration is placed with the Calibration tool first.
+      </div>
+
+      {source && (
+        <div data-testid="boxes-inspector">
+          <div style={{ ...small, color: "var(--text)", fontFamily: "var(--font-mono)" }}>
+            {source.id8} {source.tag ? `(${source.tag})` : ""}
+          </div>
+          {refusal && (
+            <div data-testid="boxes-refused" style={{ ...small, color: "var(--s-Stopping)" }}>
+              Not in this site's frame: {refusal}
+            </div>
+          )}
+          {source.stations.map((st, k) => {
+            const r = props.boxes[k];
+            if (!r) return null;
+            const colour = STATION_COLOURS[k % STATION_COLOURS.length];
+            const set = (patch: Partial<Rect>, f: string) => props.onBox(k, { ...r, ...patch }, `box-${k}-${f}`);
+            const name = `station ${st.index}`;
+            return (
+              <div
+                key={st.index}
+                data-testid={`boxes-station-${st.index}`}
+                style={{
+                  marginTop: 8,
+                  padding: "6px 8px",
+                  border: `1px solid ${props.selected === k ? colour : "var(--hairline)"}`,
+                  borderRadius: 4,
+                }}
+              >
+                <button
+                  type="button"
+                  aria-pressed={props.selected === k}
+                  onClick={() => props.onSelect(k)}
+                  style={{ ...button, border: "none", padding: 0, color: colour, fontFamily: "var(--font-mono)" }}
+                >
+                  {`station ${st.index} (channel ${st.channel})`}
+                </button>
+                <div style={{ display: "flex", gap: 4 }}>
+                  <Num name={`${name} x`} label="x" value={r.x} onChange={(x) => set({ x }, "x")} />
+                  <Num name={`${name} y`} label="y" value={r.y} onChange={(y) => set({ y }, "y")} />
+                  <Num name={`${name} w`} label="w" value={r.w} onChange={(w) => set({ w }, "w")} />
+                  <Num name={`${name} h`} label="h" value={r.h} onChange={(h) => set({ h }, "h")} />
+                </div>
+              </div>
+            );
+          })}
+          {props.issues.length > 0 && (
+            <div data-testid="boxes-issues">
+              {props.issues.map((i) => (
+                <div
+                  key={i.message}
+                  style={{ ...small, color: i.level === "error" ? "var(--s-Stopping)" : "var(--s-Programming)" }}
+                >
+                  {i.level}: {i.message}
+                </div>
+              ))}
+            </div>
+          )}
+          <label>
+            <span style={{ ...small, display: "block", margin: "8px 0 3px" }}>tag of the new calibration</span>
+            <input
+              aria-label="boxes tag"
+              placeholder={defaultTag || "none"}
+              value={props.tag}
+              onChange={(e) => props.onTag(e.target.value)}
+              style={field}
+            />
+          </label>
+          <div style={{ display: "flex", gap: 8, marginTop: 10 }}>
+            <button
+              type="button"
+              style={{ ...button, opacity: why ? 0.5 : 1 }}
+              disabled={!!why}
+              title={why ?? "write a new calibration"}
+              onClick={props.onSave}
+            >
+              Save boxes
+            </button>
+            <button type="button" style={button} onClick={props.onClear}>
+              Clear
+            </button>
+          </div>
+          {props.blocked && <div style={small}>{props.blocked}</div>}
+        </div>
+      )}
+
+      {props.saved && (
+        <div data-testid="boxes-saved" style={{ ...small, color: "var(--text)" }}>
+          Saved {props.saved.id8} (from {props.saved.source}) to {props.saved.path}. Robots keep the old rectangles until
+          it is pushed:
+          <pre style={{ ...field, whiteSpace: "pre-wrap", marginTop: 6 }}>{props.saved.push}</pre>
+          {props.saved.warnings.map((w) => (
+            <div key={w} style={{ color: "var(--s-Programming)", marginTop: 4 }}>
+              warning: {w}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/dotbot/console-web/src/siteEditor/api.ts b/dotbot/console-web/src/siteEditor/api.ts
index 5d1ba9ae..72822a66 100644
--- a/dotbot/console-web/src/siteEditor/api.ts
+++ b/dotbot/console-web/src/siteEditor/api.ts
@@ -115,6 +115,29 @@ export async function placeCalibration(
   return res.json();
 }
 
+/**
+ * Save `id` with its stations' rectangles (`[x_min, y_min, x_max, y_max]` by
+ * station index) as a new calibration of this site, checked against the
+ * site.toml `revision` the page loaded.
+ */
+export async function reboxCalibration(
+  id: string,
+  stations: Record<number, number[]>,
+  tag: string | null,
+  revision: string,
+  base = "",
+): Promise<PlacedCalibration> {
+  const res = await fetch(`${base}api/calibrations/${encodeURIComponent(id)}/boxes`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ stations, tag, revision }),
+  });
+  if (res.status === 409) throw new StaleSiteError(await detail(res));
+  if (res.status === 422) throw new RefusedSiteError(await detail(res));
+  if (!res.ok) throw new Error(await detail(res));
+  return res.json();
+}
+
 export async function fetchBackdrops(base = ""): Promise<Backdrops> {
   const res = await fetch(`${base}api/backdrops`);
   if (!res.ok) throw new Error(await detail(res));
diff --git a/dotbot/console-web/src/siteEditor/boxes.test.ts b/dotbot/console-web/src/siteEditor/boxes.test.ts
new file mode 100644
index 00000000..21a4a38b
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/boxes.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+
+import { boxIssues, boxesOf, cornersOf, rectOf, sameBoxes } from "./boxes";
+import type { CalibrationOverlay } from "./types";
+
+const overlay: CalibrationOverlay = {
+  id: "abcd1234abcd1234",
+  id8: "abcd1234",
+  free: true,
+  fence: [0, 0, 2000, 4000],
+  stations: [
+    {
+      index: 0,
+      channel: 1,
+      rect: [0, 0, 2000, 4000],
+      centres: [[500, 500]],
+      circles: [{ name: "robot0", x: 500, y: 500, radius_mm: 51.4 }],
+      solved_from: "conics-joint",
+    },
+  ],
+  links: [],
+  tag: "",
+  created_at: "",
+  site: "arena",
+  anchor: "the door corner",
+};
+
+describe("station boxes", () => {
+  it("turns the file's corners into x, y, w, h and back", () => {
+    expect(rectOf([100, 200, 1100, 2200])).toEqual({ x: 100, y: 200, w: 1000, h: 2000 });
+    expect(cornersOf({ x: 100, y: 200, w: 1000, h: 2000 })).toEqual([100, 200, 1100, 2200]);
+    expect(sameBoxes(boxesOf(overlay), [{ x: 0, y: 0, w: 2000, h: 4000 }])).toBe(true);
+  });
+
+  it("refuses an empty box, one below zero and one outside the extent", () => {
+    const errors = (r: { x: number; y: number; w: number; h: number }) =>
+      boxIssues(overlay, [r], [2000, 4000])
+        .filter((i) => i.level === "error")
+        .map((i) => i.message);
+    expect(errors({ x: 0, y: 0, w: 2000, h: 4000 })).toEqual([]);
+    expect(errors({ x: 0, y: 0, w: 0, h: 4000 })[0]).toMatch(/is empty/);
+    expect(errors({ x: -50, y: 0, w: 1000, h: 4000 })[0]).toMatch(/below zero/);
+    expect(errors({ x: 1500, y: 0, w: 1000, h: 4000 })[0]).toMatch(/outside the site's extent/);
+  });
+
+  it("warns when a box leaves out a circle its station saw", () => {
+    const [warning] = boxIssues(overlay, [{ x: 1000, y: 0, w: 1000, h: 4000 }], [2000, 4000]);
+    expect(warning.level).toBe("warning");
+    expect(warning.message).toMatch(/leaves out 1 of its 1 spin circle/);
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/boxes.ts b/dotbot/console-web/src/siteEditor/boxes.ts
new file mode 100644
index 00000000..2bdc04f3
--- /dev/null
+++ b/dotbot/console-web/src/siteEditor/boxes.ts
@@ -0,0 +1,61 @@
+import type { Issue, Rect } from "./edit";
+import type { CalibrationOverlay } from "./types";
+
+// A calibration's station rectangles as the Station boxes tool edits them:
+// x, y, w, h in frame mm, where the file keeps [x_min, y_min, x_max, y_max].
+// The checks mirror dotbot/calibration/station_boxes.py, which has the last word.
+
+/** One colour per station, in station order. */
+export const STATION_COLOURS = ["var(--accent)", "var(--s-Running)", "var(--s-Programming)", "var(--s-Bootloader)"];
+
+export type Corners = [number, number, number, number];
+
+export function rectOf([x0, y0, x1, y1]: number[]): Rect {
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+
+export function cornersOf(r: Rect): Corners {
+  return [r.x, r.y, r.x + r.w, r.y + r.h];
+}
+
+/** Each station's rectangle, in the overlay's station order. */
+export function boxesOf(overlay: CalibrationOverlay): Rect[] {
+  return overlay.stations.map((st) => rectOf(st.rect));
+}
+
+export function sameBoxes(a: Rect[], b: Rect[]): boolean {
+  return JSON.stringify(a.map(cornersOf)) === JSON.stringify(b.map(cornersOf));
+}
+
+function label(st: { index: number; channel: number }): string {
+  return `station ${st.index} (channel ${st.channel})`;
+}
+
+/** What stops a save (errors) and what is worth knowing (warnings). */
+export function boxIssues(overlay: CalibrationOverlay, boxes: Rect[], extent: [number, number] | null): Issue[] {
+  const issues: Issue[] = [];
+  overlay.stations.forEach((st, k) => {
+    const r = boxes[k];
+    if (!r) return;
+    const name = label(st);
+    if (![r.x, r.y, r.w, r.h].every(Number.isFinite)) {
+      issues.push({ level: "error", message: `${name}: x, y, w and h must be numbers` });
+      return;
+    }
+    if (!(r.w > 0) || !(r.h > 0)) issues.push({ level: "error", message: `${name}'s rectangle is empty` });
+    if (r.x < 0 || r.y < 0) {
+      issues.push({ level: "error", message: `${name}'s rectangle reaches below zero, where a robot cannot report a position` });
+    }
+    if (extent && (r.x + r.w > extent[0] || r.y + r.h > extent[1])) {
+      issues.push({ level: "error", message: `${name}'s rectangle reaches outside the site's extent` });
+    }
+    const out = st.circles.filter((c) => c.x < r.x || c.x > r.x + r.w || c.y < r.y || c.y > r.y + r.h);
+    if (out.length > 0) {
+      issues.push({
+        level: "warning",
+        message: `${name}'s rectangle leaves out ${out.length} of its ${st.circles.length} spin circle${st.circles.length === 1 ? "" : "s"}`,
+      });
+    }
+  });
+  return issues;
+}
diff --git a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
index 9ff05909..11d51b5a 100644
--- a/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
+++ b/dotbot/console-web/src/siteEditor/siteEditor.test.tsx
@@ -453,3 +453,151 @@ describe("SiteEditor in the console", () => {
     expect(image?.getAttribute("href")).toBe("/controller/site-editor/api/backdrops/camera/abcd1234.png?v=1");
   });
 });
+
+describe("SiteEditor station boxes", () => {
+  const station = (index: number, rect: number[]) => ({
+    index,
+    channel: index + 1,
+    rect,
+    centres: [[500, 500]],
+    circles: [{ name: `robot${index}`, x: 500, y: 500, radius_mm: 51.4 }],
+    solved_from: "conics-joint",
+  });
+  const overlay = (refusal: string | null = null) => ({
+    id: "abcd1234abcd1234",
+    id8: "abcd1234",
+    free: true,
+    fence: [0, 0, 2000, 4000],
+    stations: [station(0, [0, 0, 2000, 4000]), station(1, [0, 0, 2000, 4000])],
+    links: [{ a: 0, b: 1, shared: 3, weak: false }],
+    tag: "rooms",
+    created_at: "2026-10-14T22:25:16Z",
+    site: "arena",
+    anchor: "the door corner",
+    path: "/home/cal/arena/calibration-abcd1234.toml",
+    frame_refusal: refusal,
+  });
+
+  function boxesServer(refusal: string | null = null) {
+    const fetch = vi.fn(async (url: string, init?: RequestInit) => {
+      const json = (status: number, body: unknown) =>
+        new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+      if (url === "api/site") return json(200, loaded());
+      if (url === "api/calibrations")
+        return json(200, [
+          { id: "abcd1234abcd1234", id8: "abcd1234", created_at: "", free: true, stations: [0, 1], tag: "rooms", site: "arena", path: "", in_frame: true },
+          { id: "ffff0000ffff0000", id8: "ffff0000", created_at: "", free: true, stations: [0], tag: "spin", site: "lab", path: "", in_frame: false },
+        ]);
+      if (url === "api/calibrations/abcd1234") return json(200, overlay(refusal));
+      if (url === "api/calibrations/abcd1234abcd1234/boxes" && init?.method === "POST") {
+        const sent = JSON.parse(init.body as string);
+        return json(200, {
+          ...overlay(),
+          id: "9e9e9e9e9e9e9e9e",
+          id8: "9e9e9e9e",
+          tag: "rooms-boxes",
+          stations: [station(0, sent.stations[0]), station(1, sent.stations[1])],
+          path: "/home/cal/arena/calibration-9e9e9e9e.toml",
+          source: "abcd1234",
+          push: "dotbot swarm calibrate-lh2 push 9e9e9e9e --site arena",
+          warnings: [],
+        });
+      }
+      return json(404, { detail: "no" });
+    });
+    vi.stubGlobal("fetch", fetch);
+    return fetch;
+  }
+
+  async function loadBoxes() {
+    render(<SiteEditor />);
+    await screen.findByTestId("edit-area-field");
+    fireEvent.click(screen.getByText("Station boxes"));
+    fireEvent.change(await screen.findByLabelText("boxes calibration id"), { target: { value: "abcd1234" } });
+    await act(async () => fireEvent.click(screen.getByText("Load")));
+    await screen.findByTestId("station-box-0");
+  }
+
+  const value = (label: string) => Number((screen.getByLabelText(label) as HTMLInputElement).value);
+
+  it("offers only the calibrations in the site's frame", async () => {
+    boxesServer();
+    render(<SiteEditor />);
+    await screen.findByTestId("edit-area-field");
+    fireEvent.click(screen.getByText("Station boxes"));
+    await waitFor(() =>
+      expect(document.querySelectorAll("#site-editor-box-calibrations option")).toHaveLength(1),
+    );
+    expect(document.querySelector("#site-editor-box-calibrations option")!.getAttribute("value")).toBe("abcd1234");
+  });
+
+  it("resizes a station's box by a handle on the snap grid and saves it as a new calibration", async () => {
+    const fetch = boxesServer();
+    await loadBoxes();
+    expect(screen.getByText("Save boxes")).toBeDisabled();
+    fireEvent.click(within(screen.getByTestId("boxes-station-0")).getByText("station 0 (channel 1)"));
+    const canvas = screen.getByTestId("site-canvas");
+    fireEvent.pointerDown(screen.getByTestId("box-handle-e"), { button: 0, clientX: 500, clientY: 300, pointerId: 1 });
+    fireEvent.pointerMove(canvas, { clientX: 300, clientY: 300, pointerId: 1 });
+    fireEvent.pointerUp(canvas, { clientX: 300, clientY: 300, pointerId: 1 });
+    const w = value("station 0 w");
+    expect(w % 50).toBe(0);
+    expect(w).toBeGreaterThan(0);
+    expect(w).toBeLessThan(2000);
+    expect(value("station 0 x")).toBe(0);
+    expect(value("station 1 w")).toBe(2000);
+    await act(async () => fireEvent.click(screen.getByText("Save boxes")));
+    const post = fetch.mock.calls.find(([url]) => url === "api/calibrations/abcd1234abcd1234/boxes")!;
+    expect(JSON.parse(post[1]!.body as string)).toEqual({
+      stations: { 0: [0, 0, w, 4000], 1: [0, 0, 2000, 4000] },
+      tag: null,
+      revision: "r1",
+    });
+    expect(await screen.findByTestId("boxes-saved")).toHaveTextContent(
+      "dotbot swarm calibrate-lh2 push 9e9e9e9e --site arena",
+    );
+    // The new file is what is loaded now, so nothing is left to save
+    expect(screen.getByText("Save boxes")).toBeDisabled();
+    expect(value("station 0 w")).toBe(w);
+  });
+
+  it("moves a box by dragging it, and refuses one dragged outside the extent", async () => {
+    boxesServer();
+    await loadBoxes();
+    fireEvent.click(within(screen.getByTestId("boxes-station-1")).getByText("station 1 (channel 2)"));
+    const canvas = screen.getByTestId("site-canvas");
+    fireEvent.pointerDown(screen.getByTestId("station-box-body-1"), { button: 0, clientX: 300, clientY: 300, pointerId: 1 });
+    fireEvent.pointerMove(canvas, { clientX: 323, clientY: 300, pointerId: 1 });
+    fireEvent.pointerUp(canvas, { clientX: 323, clientY: 300, pointerId: 1 });
+    expect(value("station 1 x")).toBe(200);
+    expect(value("station 0 x")).toBe(0);
+    expect(screen.getByTestId("boxes-issues")).toHaveTextContent("station 1 (channel 2)'s rectangle reaches outside the site's extent");
+    expect(screen.getByText("Save boxes")).toBeDisabled();
+  });
+
+  it("undoes and redoes box edits apart from the site's", async () => {
+    boxesServer();
+    await loadBoxes();
+    fireEvent.change(screen.getByLabelText("station 0 w"), { target: { value: "15" } });
+    fireEvent.change(screen.getByLabelText("station 0 w"), { target: { value: "1500" } });
+    fireEvent.change(screen.getByLabelText("station 1 h"), { target: { value: "400" } });
+    expect(screen.getByTestId("boxes-issues")).toHaveTextContent("leaves out");
+    fireEvent.click(screen.getByText("Undo"));
+    expect(value("station 1 h")).toBe(4000);
+    expect(value("station 0 w")).toBe(1500);
+    fireEvent.keyDown(window, { key: "z", ctrlKey: true });
+    expect(value("station 0 w")).toBe(2000);
+    expect(screen.getByText("Undo")).toBeDisabled();
+    fireEvent.click(screen.getByText("Redo"));
+    expect(value("station 0 w")).toBe(1500);
+    expect(screen.queryByText(/unsaved/)).toBeNull();
+  });
+
+  it("says why a calibration outside the site's frame cannot be edited", async () => {
+    boxesServer("it is a free-mode spin calibration, in its own frame: place it on the site first");
+    await loadBoxes();
+    expect(screen.getByTestId("boxes-refused")).toHaveTextContent("place it on the site first");
+    fireEvent.change(screen.getByLabelText("station 0 w"), { target: { value: "1500" } });
+    expect(screen.getByText("Save boxes")).toBeDisabled();
+  });
+});
diff --git a/dotbot/console-web/src/siteEditor/types.ts b/dotbot/console-web/src/siteEditor/types.ts
index e76b00aa..816aebee 100644
--- a/dotbot/console-web/src/siteEditor/types.ts
+++ b/dotbot/console-web/src/siteEditor/types.ts
@@ -74,6 +74,8 @@ export interface CalibrationListing {
   tag: string;
   site: string;
   path: string;
+  /** In this site's frame, so its station boxes may be edited. */
+  in_frame: boolean;
 }
 
 /** One spin circle, its centre in the calibration's frame. */
@@ -104,9 +106,11 @@ export interface CalibrationOverlay {
   created_at: string;
   site: string;
   anchor: string;
+  /** Why it is not in this site's frame; null when it is. */
+  frame_refusal?: string | null;
 }
 
-/** What POST /api/calibrations/{id}/place answers: the new calibration. */
+/** What POST /api/calibrations/{id}/place and /boxes answer: the new calibration. */
 export interface PlacedCalibration extends CalibrationOverlay {
   path: string;
   source: string;