gea-program 0.33.0__tar.gz → 0.35.0__tar.gz

{gea_program-0.33.0/gea_program.egg-info → gea_program-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.33.0
+Version: 0.35.0
 Summary: GEA-Program: downhole gauge monitoring - canonical measurement records, quality rules, drift evaluation with a re-fit change log, well-test validation, alarm management, model cards, store-and-forward, monthly SLA measurement, FAT/SAT protocols and a dashboard, generated from live objects in the client's reporting outline.
 Author: Daniel T. Murphy
 License: MPL-2.0
@@ -125,7 +125,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (386 checks)
+gea accept                     # the product gate (389 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -648,6 +648,39 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### The control room
+
+The Control room tab opens the wall: a screen read from across the room, one
+tile per well, worst first, each with its state in a shape and a word -
+Serious, Watch, Good, No data - the reasons in plain words, the alarms, the
+gauges, and for a drilling recorder the bottom, the bit, the rate of
+penetration and the hours on bottom at the end of the record. It refreshes
+itself every 30 seconds, says how old its last answer is, and puts a notice
+across the screen when the service stops answering; a recorded well is
+described at the end of its record and never called stale. F is full screen;
+the screen is kept awake where the browser allows it; when the wells do not
+fit, the pages turn, the worst first. The outgoing operator writes the shift
+handover - what is open, what is being watched, what was done - and it stays
+on the wall until the incoming operator acknowledges it; both go in the audit
+log. A wall pass lets a screen show the wall and nothing else with no one's
+account signed in. `gea wall`, `gea handover`, `gea help control-room`.
+
+### The site map
+
+The Map tab puts everything in the workspace that has a position in one
+WGS84 frame: the wells at their declared surface positions (a NAD27
+declaration moved by its datum shift, the shift shown), the structure layers
+- faults and folds, formation contours, areas, points - each drawn at the
+detail the view needs without a vertex moved, the World Stress Map's SHmax
+directions, the seismic stations and the Seismicity Response Areas, over the
+outline of the US states and counties. The outline ships with the program
+(US Census Bureau 2017 cartographic boundaries by way of us-atlas, with its
+provenance), so the map needs no network. A well without a declared position
+is listed as not placed and is never drawn. Drag, the wheel or the keys pan
+and zoom; click anywhere for what every layer says about that spot and the
+distance to every placed well; rings draw distance circles around the wells.
+`gea help map`.
+
 ### The charts
 
 A well's page carries the Charts card: up to four channels stacked on one

{gea_program-0.33.0 → gea_program-0.35.0}/README.md

@@ -86,7 +86,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (386 checks)
+gea accept                     # the product gate (389 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -609,6 +609,39 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### The control room
+
+The Control room tab opens the wall: a screen read from across the room, one
+tile per well, worst first, each with its state in a shape and a word -
+Serious, Watch, Good, No data - the reasons in plain words, the alarms, the
+gauges, and for a drilling recorder the bottom, the bit, the rate of
+penetration and the hours on bottom at the end of the record. It refreshes
+itself every 30 seconds, says how old its last answer is, and puts a notice
+across the screen when the service stops answering; a recorded well is
+described at the end of its record and never called stale. F is full screen;
+the screen is kept awake where the browser allows it; when the wells do not
+fit, the pages turn, the worst first. The outgoing operator writes the shift
+handover - what is open, what is being watched, what was done - and it stays
+on the wall until the incoming operator acknowledges it; both go in the audit
+log. A wall pass lets a screen show the wall and nothing else with no one's
+account signed in. `gea wall`, `gea handover`, `gea help control-room`.
+
+### The site map
+
+The Map tab puts everything in the workspace that has a position in one
+WGS84 frame: the wells at their declared surface positions (a NAD27
+declaration moved by its datum shift, the shift shown), the structure layers
+- faults and folds, formation contours, areas, points - each drawn at the
+detail the view needs without a vertex moved, the World Stress Map's SHmax
+directions, the seismic stations and the Seismicity Response Areas, over the
+outline of the US states and counties. The outline ships with the program
+(US Census Bureau 2017 cartographic boundaries by way of us-atlas, with its
+provenance), so the map needs no network. A well without a declared position
+is listed as not placed and is never drawn. Drag, the wheel or the keys pan
+and zoom; click anywhere for what every layer says about that spot and the
+distance to every placed well; rings draw distance circles around the wells.
+`gea help map`.
+
 ### The charts
 
 A well's page carries the Charts card: up to four channels stacked on one

{gea_program-0.33.0 → gea_program-0.35.0}/gea/__init__.py

@@ -123,7 +123,7 @@ from .profile_catalog import (
     read_pangaea_txt,
 )
 
-__version__ = "0.33.0"
+__version__ = "0.35.0"
 __all__ = [
     "aging_rate", "rate_psi_yr", "accuracy_psi",
     "Sensor", "SimulatorConfig", "DownholeEngine",

{gea_program-0.33.0 → gea_program-0.35.0}/gea/__main__.py

@@ -475,6 +475,21 @@ def main(argv=None) -> int:
     p_ck.add_argument("--note", type=str, default="", help="--confirm: what it was checked against (required)")
     p_ck.add_argument("--actor", type=str, default="cli")
 
+    p_wl = sub.add_parser("wall", help="the control-room board as text: a line per well, worst first, its state and why (the same board the wall screen shows)")
+    p_wl.add_argument("--workspace", type=str, default=None, help="the workspace folder, e.g. C:\\site")
+    p_wl.add_argument("--json", action="store_true")
+
+    p_ho = sub.add_parser("handover", help="the shift handover: list the notes, sign one (--write) or acknowledge one (--ack)")
+    p_ho.add_argument("--workspace", type=str, default=None, help="the workspace folder, e.g. C:\\site")
+    p_ho.add_argument("--write", action="store_true", help="sign a note: give at least one of --open, --watching, --done")
+    p_ho.add_argument("--open", type=str, default="", help="--write: what the next shift must pick up")
+    p_ho.add_argument("--watching", type=str, default="", help="--write: what is being watched, and why")
+    p_ho.add_argument("--done", type=str, default="", help="--write: what this shift did")
+    p_ho.add_argument("--ack", type=str, default=None, help="acknowledge the note with this id (not your own)")
+    p_ho.add_argument("--comment", type=str, default="", help="--ack: an optional comment")
+    p_ho.add_argument("--actor", type=str, default=None, help="who signs or acknowledges (required with --write and --ack)")
+    p_ho.add_argument("--json", action="store_true")
+
     p_sv = sub.add_parser("serve", help="serve the dashboard over a workspace: the page, the reports and the JSON API (standard library HTTP)")
     p_sv.add_argument("--workspace", type=str, required=True, help="the workspace folder (gea workspace --action init)")
     p_sv.add_argument("--host", type=str, default="127.0.0.1", help="bind address; 0.0.0.0 exposes it on the site network (put TLS in front)")
@@ -1922,6 +1937,51 @@ def main(argv=None) -> int:
         else:
             print(_SC.text(r))
         return 0 if r["ready"] else 2
+    elif a.cmd in ("wall", "handover"):
+        import json as _json
+        from . import control_room as _CR
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        if not a.workspace:
+            raise SystemExit(f"{a.cmd} needs --workspace, e.g. --workspace C:\\site")
+        try:
+            ws = Workspace(a.workspace)
+        except WorkspaceError as e:
+            raise SystemExit(f"{a.cmd}: {e}")
+        if a.cmd == "wall":
+            b = _CR.board(ws)
+            print(_json.dumps(b, indent=1) if a.json else _CR.text(b))
+            return 0
+        try:
+            if a.write:
+                if not a.actor:
+                    raise SystemExit("handover --write needs --actor, the name the note is signed with")
+                b = _CR.board(ws)
+                counts = {**b["counts"], "alarms_unacked": sum(((t.get("alarms") or {}).get("unacked") or 0) for t in b["tiles"])}
+                n = _CR.write_note(ws, a.actor, a.open, a.watching, a.done, counts)
+                print(f"handover {n['id']} signed by {n['by']} at {n['utc']}")
+                return 0
+            if a.ack:
+                if not a.actor:
+                    raise SystemExit("handover --ack needs --actor, the incoming operator's name")
+                r = _CR.ack_note(ws, a.ack, a.actor, a.comment)
+                print(f"handover {a.ack} acknowledged by {r['by']} at {r['utc']}")
+                return 0
+        except (ValueError, KeyError, PermissionError) as e:
+            raise SystemExit(f"handover: {e.args[0] if e.args else e}")
+        ns = _CR.notes(ws, 0)
+        if a.json:
+            print(_json.dumps(ns, indent=1))
+        elif not ns:
+            print("no handover notes yet")
+        else:
+            for n in ns:
+                print(f"{n['id']}  {n['utc']}  by {n['by']}  " + (f"acknowledged by {n['ack']['by']} at {n['ack']['utc']}" if n.get('ack') else "NOT YET ACKNOWLEDGED"))
+                for k in _CR.NOTE_FIELDS:
+                    if n.get(k):
+                        print(f"    {k}: {n[k]}")
+        return 0
     elif a.cmd == "serve":
         from .service import Service
         from .workspace import WorkspaceError

{gea_program-0.33.0 → gea_program-0.35.0}/gea/acceptance_tests.py

@@ -8304,6 +8304,315 @@ def section_cb_charts(tmp: str) -> None:
        "kept while a window loads, the drilling progress chart with one colour per well in a fixed order in both themes; the help page"
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
+
+def section_cc_site_map(tmp: str) -> None:
+    """Section CC - the site map: the shipped state and county outline with its provenance, every positioned thing in one
+    WGS84 frame (a NAD27 well moved by its datum shift and saying so, a well without a position never drawn), a layer
+    thinned to the view's pixel without a vertex moved, what every layer says about a spot, the page."""
+    import hashlib as _hl
+    import http.cookiejar
+    import math as _m
+    import urllib.request
+    import urllib.error
+    from . import edr as E
+    from . import helplib as H
+    from . import shapefile as SF
+    from . import site_map as SM
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "cc"); d.mkdir()
+
+    ol = SM.outline_data()
+    prov = json.loads((pkg / "reference" / "us_outline.provenance.json").read_text(encoding="utf-8"))
+    cul = [c for c in ol["counties"] if c["name"] == "Culberson"]
+    wide = SM.outline_view([-110.0, 25.0, -90.0, 37.0], 0.02)
+    near = SM.outline_view([-105.2, 31.0, -104.0, 32.0], 0.002)
+    c1 = {
+        "outline": len(ol["counties"]) == 3231 and ol["states"].get("48") == "Texas" and cul and cul[0]["fips"] == "48109"
+                   and abs(cul[0]["label"][0] + 104.65) < 0.2 and abs(cul[0]["label"][1] - 31.47) < 0.2,
+        "provenance": prov["sha256"] == _hl.sha256((pkg / "reference" / "us_outline.json").read_bytes()).hexdigest() and prov["package_license"] == "ISC"
+                      and "Copyright 2013-2019 Michael Bostock" in prov["package_license_text"] and "public domain" in prov["original_source"]
+                      and prov["counts"]["counties"] == 3231,
+        "detail": all(a["s"] == 1 for a in wide["arcs"]) and not wide["labels"] and any(a["s"] == 0 for a in near["arcs"])
+                  and "Culberson" in [x["name"] for x in near["labels"]],
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CC1 the outline ships with the program: the US Census Bureau's 2017 cartographic counties by way of us-atlas 3.0.1, 3,231 counties, the "
+       "provenance with its hash, the package's ISC notice and the public-domain source; state lines only in a wide view, county lines and names "
+       "once the view is close (Culberson, FIPS 48109)"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    lat1, lon1 = 31.42, -104.10
+    kmlon = 1.0 / (111.195 * _m.cos(_m.radians(lat1)))
+    faults = [([[(lon1 - 0.2 + 0.01 * i, lat1 - 0.3 + 0.0002 * j) for j in range(3001)]], {"TYPE": "normal fault", "NAME": f"F{i}"}) for i in range(0, 40, 8)]
+    SF.write(str(d / "Faults"), "PolyLine", faults, [("TYPE", "C", 20, 0), ("NAME", "C", 10, 0)], SF.NAD83_GEOGCS)
+    ctr = [([[(lon1 + (i - 1.5) * 4 * kmlon + 0.001 * k, lat1 - 0.3 + 0.006 * k) for k in range(100)]], {"ElevTop_ft": -8500.0 + 500.0 * i}) for i in range(4)]
+    SF.write(str(d / "Top_A"), "PolyLine", ctr, [("ElevTop_ft", "F", 10, 1)], SF.NAD83_GEOGCS)
+    SF.write(str(d / "Picks"), "Point", [([[(lon1 + 0.0001 * i, lat1 + 0.00005 * i)]], {"NAME": f"P{i}"}) for i in range(6000)], [("NAME", "C", 10, 0)], SF.NAD83_GEOGCS)
+    with open(d / "wsm.csv", "w", encoding="utf-8") as f:
+        f.write("ID,LAT,LON,AZI,TYPE,DEPTH,QUALITY,REGIME,LOCALITY\n")
+        for i in range(40):
+            f.write(f"W{i},{lat1 - 0.1 + 0.005 * i:.4f},{lon1 - 0.05:.4f},{60 + i},BO,2.5,{'DCBA'[i % 4]},NF,test\n")
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    empty_view = SM.overview(ws)["view"]
+    ws.add_layer(str(d / "Faults.shp"), "Basement faults", actor="tester", citation="test")
+    ws.add_layer(str(d / "Top_A.shp"), "Wolfcamp top", actor="tester", formation="Wolfcamp", role="top", citation="test")
+    ws.add_layer(str(d / "Picks.shp"), "Picks", actor="tester", citation="test")
+    ws.add_stress_map(str(d / "wsm.csv"), actor="tester", citation="test WSM")
+    layer_view0 = SM.overview(ws)["view"]
+    a = E.selftest(str(d)); b = E.selftest_events(str(d))
+    wa = ws.add_well_file(a["path"], display="Well A", actor="tester"); wb = ws.add_well_file(b["path"], display="Well B", actor="tester")
+    wc = ws.add_well_file(a["path"], display="Well C", actor="tester")
+    ws.set_well(wa["id"], surface={"lat": 31.41, "lon": -104.12, "datum": "NAD27"}, actor="tester")
+    ws.set_well(wb["id"], surface={"lat": 31.43, "lon": -104.08, "datum": "NAD83"}, actor="tester")
+    o = SM.overview(ws)
+    wl = {w["id"]: w for w in o["wells"]}
+    view = o["view"]["bbox"]
+    fine = SM.layer_view(ws, "Basement-faults", [-105, 30, -103, 32], 0.0)
+    coarse = SM.layer_view(ws, "Basement-faults", [-105, 30, -103, 32], 0.01)
+    raw = SM._layer(ws, "Basement-faults")
+    src_pts = {(round(float(x), 5), round(float(y), 5)) for f in raw["feats"] for pp in f["parts"] for x, y in pp}
+    moved = [p for f in coarse["features"] for pp in f["parts"] for p in pp if (p[0], p[1]) not in src_pts]
+    ends_kept = all(f["parts"][0][0] == fine["features"][k]["parts"][0][0] and f["parts"][0][-1] == fine["features"][k]["parts"][0][-1] for k, f in enumerate(coarse["features"]))
+    pts = SM.layer_view(ws, "Picks", [-105, 30, -103, 32], 0.0, max_points=1000)
+    wh = SM.what_here(ws, 31.42, -104.10)
+    sv = SM.stress_view(ws, [-104.3, 31.2, -103.9, 31.6])
+    c2 = {
+        "frame": "WGS84" in o["frame"] and o["view"]["why"] == "the placed wells" and empty_view["why"].startswith("nothing in the workspace")
+                 and layer_view0["why"].startswith("the area most of the layers cover (the median extent of 3 of the 3)"),
+        "wells": wl[wa["id"]]["placed"] and 30.0 < wl[wa["id"]]["shift_m"] < 90.0 and wl[wa["id"]]["declared"]["datum"] == "NAD27"
+                 and wl[wb["id"]]["placed"] and wl[wb["id"]]["shift_m"] == 0.0 and not wl[wc["id"]]["placed"] and "lat" not in wl[wc["id"]]
+                 and view[0] < -104.12 < view[2] and view[1] < 31.43 < view[3],
+        "layers": [(l["id"], l["kind"]) for l in o["layers"]] == [("Basement-faults", "structure"), ("Wolfcamp-top", "contours"), ("Picks", "points")]
+                  and o["layers"][0]["classes"] == ["fault"] and o["layers"][0]["n_points"] == 5 * 3001 and o["stress_map"]["n_records"] == 40,
+        "thinning": fine["vertices"] == 5 * 3001 and coarse["vertices"] < fine["vertices"] / 10 and not moved and ends_kept
+                    and all(f.get("cls") == "fault" for f in coarse["features"]),
+        "points": pts["in_view"] == 6000 and pts["shown"] == 1000 and pts["kind"] == "points",
+        "what_here": wh["answered"] >= 2 and any("Nearest mapped fault" in ln for l_ in wh["layers"] for ln in (l_["lines"] or []))
+                     and any("contours" in ln for l_ in wh["layers"] for ln in (l_["lines"] or []))
+                     and [w["id"] for w in wh["wells"]] == sorted([wa["id"], wb["id"]], key=lambda i: next(x["distance_km"] for x in wh["wells"] if x["id"] == i))
+                     and len(wh["wells"]) == 2,
+        "stress": sv["n_in_view"] == 40 and sv["records"][0]["quality"] == "A" and sv["records"][-1]["quality"] == "D" and sv["citation"] == "test WSM",
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CC2 one frame: a well declared on NAD27 moved to WGS84 by its datum shift and the shift kept with it, a well declared on NAD83 not moved, a "
+       "well with no position never placed; the map opens on the placed wells (else the area most layers cover, else Texas, said so); a layer "
+       "thinned to the view's pixel keeps its ends and moves no vertex, points sampled evenly past the limit; each layer's own statement for a spot "
+       "and the distance to every placed well; the stress records in view, best quality first"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    Users(str(Path(wsp, "users.json"))).add("v", "viewer-pass-1", "viewer")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+    op = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+    def call(path):
+        req = urllib.request.Request(base_url + path, method="GET")
+        try:
+            with op.open(req, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        lreq = urllib.request.Request(base_url + "/api/login", method="POST", data=json.dumps({"name": "v", "password": "viewer-pass-1"}).encode())
+        lreq.add_header("Content-Type", "application/json"); lreq.add_header("X-GEA-Action", "1"); op.open(lreq, timeout=30)
+        bb = ",".join(f"{x:.5f}" for x in view)
+        st_o, ov = call("/api/map")
+        st_l, lv = call(f"/api/map/layer/Wolfcamp-top?bbox={bb}&tol=0.001")
+        st_ol, olv = call(f"/api/map/outline?bbox={bb}&tol=0.001")
+        st_s, svv = call(f"/api/map/stress?bbox={bb}")
+        st_a, at = call("/api/map/at?lat=31.42&lon=-104.10")
+        st_bad, _ = call("/api/map/layer/Wolfcamp-top?bbox=1,2,3")
+        st_nol, _ = call(f"/api/map/layer/no-such-layer?bbox={bb}")
+        st_noll, _ = call("/api/map/at?lat=x")
+    finally:
+        svc.stop()
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_md = (pkg / "help" / "map.md").read_text(encoding="utf-8")
+    c3 = {
+        "api": st_o == 200 and len(ov["wells"]) == 3 and st_l == 200 and lv["kind"] == "contours" and all("value" in f for f in lv["features"])
+               and st_ol == 200 and st_s == 200 and st_a == 200 and len(at["wells"]) == 2 and st_bad == 400 and st_nol == 404 and st_noll == 400,
+        "page": all(x in page_src for x in ("VIEWS.map", "['#/map', 'Map']", "/api/map/layer/", "/api/map/outline", "/api/map/stress", "/api/map/at",
+                                             "Not placed", "declare it", "data-fit", "mpRings", "ArrowUp", "'Home' || k === 'Escape'", "scale bar", "'wheel'",
+                                             "What is at", "setPointerCapture")),
+        "help": any(t["topic"] == "map" for t in H.topics()) and not H.check("map") and H.VIEW_TOPIC.get("map") == "map"
+                and "never moved" in help_md.split("will not call a measurement")[1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CC3 the API (the contents, a layer with its contour values, the outline, the stress records, what is at a spot; a malformed box, an unknown "
+       "layer and a missing position named) and the Map tab: pan and zoom by pointer, wheel and keys, layer toggles and fit, distance rings, a scale "
+       "bar, the not-placed wells with the way to place them, what is at a click; the help page"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
+def section_cd_control_room(tmp: str) -> None:
+    """Section CD - the control room: the wall board judged by its stated rule (a shape and a word for each state, worst
+    first, a recorded well never called stale, a live feed's age measured), the shift handover signed by one operator and
+    acknowledged by another with both in the audit log, wall passes that show the wall and nothing else, the page."""
+    import http.cookiejar
+    import urllib.request
+    import urllib.error
+    from datetime import datetime as _dt, timedelta as _td, timezone as _tz
+    from . import control_room as CR
+    from . import edr as E
+    from . import helplib as H
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "cd"); d.mkdir()
+
+    ev = E.selftest_events(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wd = ws.add_well_file(ev["path"], display="Drilling well", actor="tester")
+    wa = ws.add_well_file(ev["path"], display="Alarm well", actor="tester")
+    wc = ws.add_well_catalog("volve_f12_f14_production_excerpt", "15/9-F-12", 10000.0, actor="tester")
+    ws.refresh_dashboard(actor="tester")
+    wn = ws.add_well_file(ev["path"], display="New well", actor="tester")          # added after the refresh: no reports yet
+    ra = Path(ws.reports_dir, "wells", wa["id"])
+    (ra / "alarm_event_report.json").write_text(json.dumps({"active": [
+        {"alarm_id": "SPP.HH_RANGE", "state": "ACTIVE_UNACKED", "priority": "P2", "tag_id": "SPP"},
+        {"alarm_id": "HKLD.QUALITY", "state": "ACTIVE_ACKED", "priority": "P4", "tag_id": "HKLD"}], "shelved": []}), encoding="utf-8")
+    now = _dt(2026, 10, 15, 12, 0, 0, tzinfo=_tz.utc)
+    iso = lambda s: (now - _td(seconds=s)).strftime("%Y-%m-%dT%H:%M:%SZ")
+    feed = lambda age, status="CONNECTED", wid=wn["id"]: [{"name": "p1", "well_id": wid, "status": status, "last_sample_utc": (iso(age) if age is not None else None), "patch": {"stale_after_s": 120.0}}]
+    b0 = CR.board(ws, [], now=now)
+    t0 = {t["well_id"]: t for t in b0["tiles"]}
+    dr = t0[wd["id"]]["drilling"]
+    live = {k: {t["well_id"]: t for t in CR.board(ws, feed(*a), now=now)["tiles"]}[wn["id"]] for k, a in
+            {"fresh": (30,), "late": (400,), "silent": (1000,), "down": (60, "DOWN"), "none": (None,)}.items()}
+    c1 = {
+        "states": t0[wa["id"]]["state"] == "SERIOUS" and t0[wa["id"]]["reasons"][:2] == ["1 unacknowledged P2 alarm(s)", "1 other active alarm(s)"]
+                  and t0[wc["id"]]["state"] == "SERIOUS" and "no explanation" in t0[wc["id"]]["reasons"][0]
+                  and t0[wd["id"]]["state"] == "GOOD" and t0[wd["id"]]["reasons"] == ["nothing needs attention"]
+                  and t0[wn["id"]]["state"] == "NO_DATA",
+        "shape_word": all(t["shape"] == CR.SHAPE[t["state"]] and t["word"] == CR.WORD[t["state"]] for t in b0["tiles"])
+                      and len(set(CR.SHAPE.values())) == 4 and len(set(CR.WORD.values())) == 4,
+        "order": [t["state"] for t in b0["tiles"]] == sorted((t["state"] for t in b0["tiles"]), key=CR.STATES.index)
+                 and b0["counts"] == {"SERIOUS": 2, "WATCH": 0, "GOOD": 1, "NO_DATA": 1},
+        "recorded": t0[wd["id"]]["live"] is None and t0[wd["id"]]["recorded"]["record_end_utc"] == dr["record_end_utc"]
+                    and "never called stale" in b0["rule"],
+        "read_only": not Path(wsp, "handover").exists() and not Path(wsp, "wall").exists(),
+        "drilling": dr["cache"] and dr["td_md_ft"] == 5750.0 and dr["bottom_ft"] == 5750.0 and dr["on_bottom_hours"] is not None
+                    and (dr["rop_ft_h"] is not None) == bool(dr["drilling_now"]),
+        "live": live["fresh"]["state"] == "GOOD" and live["late"]["state"] == "WATCH" and "past the 2 min stale limit" in live["late"]["reasons"][0]
+                and live["silent"]["state"] == "SERIOUS" and live["silent"]["reasons"][0].startswith("no live sample for 16 min")
+                and live["down"]["state"] == "SERIOUS" and live["none"]["state"] == "WATCH" and abs(live["fresh"]["live"]["age_s"] - 30) < 1e-6,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CD1 the wall board by its stated rule, read without writing anything: an unacknowledged P2 alarm and a gauge off with no explanation SERIOUS, a well with reports and "
+       "nothing else GOOD, a well with neither reports nor a live sample NO DATA, each state its own shape and word, worst first; a recorded well "
+       "described at the end of its record and never called stale (bottom 5,750 ft, the ROP only while drilling at the end); a live feed's "
+       "measured age against its stale limit - 30 s good, 400 s watch, 1,000 s serious, a patch down serious"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    users = Users(str(Path(wsp, "users.json")))
+    for n_, r_ in (("adm", "admin"), ("op1", "operator"), ("op2", "operator"), ("v", "viewer")):
+        users.add(n_, f"{n_}-pass-123", r_)
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def opener():
+        return urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+    def call(op, method, path, body=None):
+        req = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        if method == "POST":
+            req.add_header("Content-Type", "application/json"); req.add_header("X-GEA-Action", "1")
+        try:
+            with op.open(req, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+
+    def signin(name):
+        op = opener(); call(op, "POST", "/api/login", {"name": name, "password": f"{name}-pass-123"}); return op
+    try:
+        anon = opener()
+        st_anon, _ = call(anon, "GET", "/api/wall")
+        V, O1, O2, A = signin("v"), signin("op1"), signin("op2"), signin("adm")
+        st_v, bv = call(V, "GET", "/api/wall")
+        st_vw, _ = call(V, "POST", "/api/handover", {"open": "x"})
+        st_empty, _ = call(O1, "POST", "/api/handover", {"open": " ", "watching": "", "done": ""})
+        st_long, _ = call(O1, "POST", "/api/handover", {"open": "x" * 2001})
+        st_w, note = call(O1, "POST", "/api/handover", {"open": "Pump 2 liner swap not finished.", "watching": "SPP on the alarm well.", "done": "Reamed to bottom."})
+        _, bdg1 = call(V, "GET", "/api/badges")
+        _, wall1 = call(V, "GET", "/api/wall")
+        st_self, self_ = call(O1, "POST", "/api/handover/ack", {"id": note.get("id")})
+        st_ack, ack = call(O2, "POST", "/api/handover/ack", {"id": note.get("id"), "comment": "read at 06:05"})
+        st_ack2, _ = call(O2, "POST", "/api/handover/ack", {"id": note.get("id")})
+        st_nf, _ = call(O2, "POST", "/api/handover/ack", {"id": "H-none"})
+        _, bdg2 = call(V, "GET", "/api/badges")
+        _, hv = call(V, "GET", "/api/handover")
+        # wall passes
+        st_pv, _ = call(V, "POST", "/api/wall/pass", {"label": "doghouse"})
+        st_pnl, _ = call(A, "POST", "/api/wall/pass", {"label": " "})
+        st_pc, wp = call(A, "POST", "/api/wall/pass", {"label": "doghouse wall", "days": 30})
+        _, plist = call(A, "GET", "/api/wall/passes")
+        W = opener()
+        st_bad, _ = call(W, "POST", "/api/wall/enter", {"code": wp["id"] + ".wrong"})
+        st_in, _ = call(W, "POST", "/api/wall/enter", {"code": wp["code"]})
+        st_ww, wwall = call(W, "GET", "/api/wall")
+        _, wsess = call(W, "GET", "/api/session")
+        st_wo, _ = call(W, "GET", "/api/overview")
+        st_wh, _ = call(W, "GET", "/api/handover")
+        st_wpost, _ = call(W, "POST", "/api/handover", {"open": "x"})
+        st_rv, _ = call(A, "POST", "/api/wall/pass/revoke", {"id": wp["id"]})
+        st_after, _ = call(W, "GET", "/api/wall")
+        _, plist2 = call(A, "GET", "/api/wall/passes")
+        L = opener()
+        lock = [call(L, "POST", "/api/wall/enter", {"code": "W000000.nope"})[0] for _ in range(6)]
+    finally:
+        svc.stop()
+    audit = [e["action"] for e in ws.audit_log(5000)]
+    raw = (Path(wsp, "wall", "passes.json")).read_text(encoding="utf-8")
+    lines = Path(wsp, "handover", "notes.jsonl").read_text(encoding="utf-8").splitlines()
+    c2 = {
+        "roles": st_anon == 401 and st_v == 200 and len(bv["tiles"]) == 4 and st_vw == 403,
+        "note": st_empty == 400 and st_long == 400 and st_w == 200 and note["by"] == "op1" and note["ack"] is None
+                and note["board"]["SERIOUS"] == 2 and note["board"]["alarms_unacked"] == 1
+                and wall1["handover"]["id"] == note["id"] and wall1["handover"]["ack"] is None and bdg1["handover_unacked"] == 1,
+        "ack": st_self == 403 and "author cannot acknowledge" in self_["error"] and st_ack == 200 and ack["by"] == "op2"
+               and st_ack2 == 400 and st_nf == 404 and bdg2["handover_unacked"] == 0
+               and hv["notes"][0]["ack"]["by"] == "op2" and hv["notes"][0]["ack"]["comment"] == "read at 06:05",
+        "append_only": len(lines) == 2 and json.loads(lines[0])["kind"] == "note" and json.loads(lines[1])["kind"] == "ack",
+        "audit": all(a_ in audit for a_ in ("handover.write", "handover.ack", "wall.pass.create", "wall.pass.failed", "wall.pass.enter", "wall.pass.revoke")),
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CD2 the shift handover: a viewer reads the wall and cannot write; an empty or over-long note refused; a signed note keeps its author, its "
+       "time and the board's counts (2 serious, 1 unacknowledged alarm), shows on the wall and badges the tab until acknowledged; the author "
+       "cannot acknowledge it, the next operator can (once, with a comment); notes and acknowledgements appended, never rewritten; every step in "
+       "the audit log"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_md = (pkg / "help" / "control-room.md").read_text(encoding="utf-8")
+    c3 = {
+        "pass": st_pv == 403 and st_pnl == 400 and st_pc == 200 and wp["code"].startswith(wp["id"] + ".") and wp["code"].split(".", 1)[1] not in raw
+                and "hash" not in json.dumps(plist) and plist["passes"][0]["status"] == "ACTIVE",
+        "wall_only": st_bad == 401 and st_in == 200 and st_ww == 200 and len(wwall["tiles"]) == 4 and wsess["user"] is None
+                     and wsess["wall_pass"]["label"] == "doghouse wall" and st_wo == 401 and st_wh == 401 and st_wpost == 401,
+        "revoke": st_rv == 200 and st_after == 401 and plist2["passes"][0]["status"] == "REVOKED" and lock[-1] == 429,
+        "page": all(x in page_src for x in ("VIEWS.wall", "VIEWS.control", "['#/control', 'Control room']", "/api/wall", "/api/handover/ack",
+                                             "NOT UPDATING", "wakeLock", "requestFullscreen", "SIGNED OUT", "This is a wall screen",
+                                             "crShape", "data-age0", "turns pages", "/api/wall/pass/revoke", "handover_unacked")),
+        "help": any(t["topic"] == "control-room" for t in H.topics()) and not H.check("control-room") and H.VIEW_TOPIC.get("control") == "control-room"
+                and "never called stale" in help_md.split("will not call a measurement")[1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CD3 wall passes: issued by an administrator only and named for the screen, the code shown once and only its hash kept; a wrong pass "
+       "refused and locked out after repeats; a pass shows the wall and nothing else - no other page, no handover list, no writing - until it is "
+       "revoked; the page: the wall full screen with its shapes and words, the age of its last answer, NOT UPDATING across the screen when the "
+       "service stops, the screen kept awake, pages turned when the wells do not fit, the handover written and acknowledged; the help page"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
 def main() -> int:
     print("GEA-Program - ACCEPTANCE SUITE (the product gate)")
     # a handle a job subprocess still holds at the end must not turn a finished gate into a traceback on Windows:
@@ -8387,6 +8696,8 @@ def main() -> int:
         section_bz_tool_library(tmp)
         section_ca_setup_checklist(tmp)
         section_cb_charts(tmp)
+        section_cc_site_map(tmp)
+        section_cd_control_room(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: