gea-program 0.47.0__tar.gz → 0.49.0__tar.gz

{gea_program-0.47.0 → gea_program-0.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.47.0
+Version: 0.49.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
@@ -648,6 +648,35 @@ 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`.
 
+### Well collision checks
+
+Every well scanned against every other: at each point of one well, the
+closest point of the other, and the ISCWSA separation factor - the distance
+between them less the holes and a surface margin, over k times the
+uncertainty of that distance. Each well's position uncertainty comes from
+the ISCWSA MWD Rev 4 error model (27 error sources, propagated as the model
+says, the errors two wells share taken out of the distance between them),
+checked against all 112 rows of the ISCWSA's own example; the Earth's field
+at each well comes from the World Magnetic Model 2025. Each pair is levelled
+as the ISCWSA's separation rule does - reported below 4.0, the approach
+limit below 1.5, revise the plan below 1.25, below 1.0 only by the
+operator's dispensation - with a company standard's k and margin kept with
+its source. The Volve template's three wells are the worked example. The
+**Collision** tab, `gea collision`, `gea help collision`.
+
+### One record, tied together
+
+The invoice check, rig time, the daily summary, the alerts, the signed
+dossier and the declarations sheet now read each other: an invoice that
+differs is an alert; the morning summary carries each well's invoice check
+and yesterday's rig time; a signed dossier carries the contract, the
+invoices and daily reports as attached, the rig-time targets and casing,
+and both checks as they read at signing. The declarations sheet declares
+the contract, the rig-time targets, block weights, casing shoes and the
+watch and summary settings, and every file the program reads as a table -
+the sheet, an invoice, a daily report - may be an Excel workbook. Casing
+shoes split rig time by hole section.
+
 ### Rig time
 
 What the rig did each second of the drilling record, read from the hook

{gea_program-0.47.0 → gea_program-0.49.0}/README.md

@@ -609,6 +609,35 @@ 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`.
 
+### Well collision checks
+
+Every well scanned against every other: at each point of one well, the
+closest point of the other, and the ISCWSA separation factor - the distance
+between them less the holes and a surface margin, over k times the
+uncertainty of that distance. Each well's position uncertainty comes from
+the ISCWSA MWD Rev 4 error model (27 error sources, propagated as the model
+says, the errors two wells share taken out of the distance between them),
+checked against all 112 rows of the ISCWSA's own example; the Earth's field
+at each well comes from the World Magnetic Model 2025. Each pair is levelled
+as the ISCWSA's separation rule does - reported below 4.0, the approach
+limit below 1.5, revise the plan below 1.25, below 1.0 only by the
+operator's dispensation - with a company standard's k and margin kept with
+its source. The Volve template's three wells are the worked example. The
+**Collision** tab, `gea collision`, `gea help collision`.
+
+### One record, tied together
+
+The invoice check, rig time, the daily summary, the alerts, the signed
+dossier and the declarations sheet now read each other: an invoice that
+differs is an alert; the morning summary carries each well's invoice check
+and yesterday's rig time; a signed dossier carries the contract, the
+invoices and daily reports as attached, the rig-time targets and casing,
+and both checks as they read at signing. The declarations sheet declares
+the contract, the rig-time targets, block weights, casing shoes and the
+watch and summary settings, and every file the program reads as a table -
+the sheet, an invoice, a daily report - may be an Excel workbook. Casing
+shoes split rig time by hole section.
+
 ### Rig time
 
 What the rig did each second of the drilling record, read from the hook

{gea_program-0.47.0 → gea_program-0.49.0}/gea/__init__.py

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

{gea_program-0.47.0 → gea_program-0.49.0}/gea/__main__.py

@@ -590,6 +590,20 @@ def main(argv=None) -> int:
     p_dz.add_argument("--actor", type=str, default="cli")
     p_dz.add_argument("--json", action="store_true")
 
+    p_co = sub.add_parser("collision", help="every well scanned against every other: the closest approach and the ISCWSA separation factor, each well's position uncertainty by the ISCWSA MWD model and the field by WMM2025")
+    p_co.add_argument("--workspace", type=str, default=None)
+    p_co.add_argument("--scene", type=str, default=None, help="workspace (your wells) or volve (the worked example)")
+    p_co.add_argument("--write", action="store_true", help="write the client report")
+    p_co.add_argument("--k", type=str, default=None, help="declare the rule's scaling factor")
+    p_co.add_argument("--surface-margin", type=str, default=None, help="declare the surface margin, m")
+    p_co.add_argument("--sigma-pa", type=str, default=None, help="declare the project-ahead uncertainty, m")
+    p_co.add_argument("--source", type=str, default="", help="where the rule's values came from")
+    p_co.add_argument("--well", type=str, default=None)
+    p_co.add_argument("--hole", type=str, default=None, help="with --well: the hole size in inches ('' removes it)")
+    p_co.add_argument("--field", type=str, default=None, help="the magnetic field at LAT,LON[,YYYY-MM-DD] by WMM2025, and nothing else")
+    p_co.add_argument("--actor", type=str, default="cli")
+    p_co.add_argument("--json", action="store_true")
+
     p_rt = sub.add_parser("rig-time", help="what the rig did each second of the drilling record - drilling, connections, trips, the slips - and the time lost against the pad's own best")
     p_rt.add_argument("--workspace", type=str, required=True)
     p_rt.add_argument("--well", type=str, default=None, help="with --write: one well's report (without it, the pad's)")
@@ -599,6 +613,9 @@ def main(argv=None) -> int:
     p_rt.add_argument("--trip-out", type=str, default=None, help="declare the tripping-out target, ft/h")
     p_rt.add_argument("--source", type=str, default="", help="where the targets came from")
     p_rt.add_argument("--block-weight", type=str, default=None, help="with --well: the block weight in klbf where the estimate is wrong ('' removes it)")
+    p_rt.add_argument("--casing", type=str, default=None, help="with --well, --shoe-md and --source: declare a casing shoe, its size in inches as written (13-3/8)")
+    p_rt.add_argument("--shoe-md", type=str, default=None, help="the shoe's measured depth, ft")
+    p_rt.add_argument("--set-time", type=str, default=None, help="when the casing was set (the recorder's clock); otherwise when the hole is 50 ft past the shoe")
     p_rt.add_argument("--actor", type=str, default="cli")
     p_rt.add_argument("--json", action="store_true")
 
@@ -2205,9 +2222,10 @@ def main(argv=None) -> int:
         if not a.file:
             raise SystemExit("declare: give --file <sheet.csv> (or --template <out.csv> to start one)")
         try:
-            with open(a.file, encoding="utf-8-sig") as f:
-                text_ = f.read()
-        except OSError as e:
+            from . import xlsx_read as _XR
+            with open(a.file, "rb") as f:
+                text_ = _XR.text_of(f.read())
+        except (OSError, ValueError, KeyError) as e:
             raise SystemExit(f"declare: {e}")
         p = _DC.apply(ws, text_, a.actor, os.path.dirname(os.path.abspath(a.file)), write=a.apply)
         print(_json.dumps(p, default=str) if a.json else _DC.text(p))
@@ -2368,6 +2386,42 @@ def main(argv=None) -> int:
         print(f"  {os.path.join(ws.reports_dir, e['path'])}")
         print(f"  key fingerprint {e['fingerprint']}")
         return 0
+    elif a.cmd == "collision":
+        import json as _json
+        from . import collision as _CO
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            if a.field:
+                from . import geomag as _GM
+                parts = [x.strip() for x in a.field.split(",")]
+                f_ = _GM.field(float(parts[0]), float(parts[1]), 0.0, parts[2] if len(parts) > 2 else None)
+                print(f"{f_['model']} at {float(parts[0]):.4f}, {float(parts[1]):.4f} for {f_['decimal_year']:.2f}: declination {f_['declination_deg']:+.3f} deg, "
+                      f"dip {f_['dip_deg']:.3f} deg, total {f_['total_nT']:,.1f} nT" + (f" ({f_['note']})" if f_['note'] else ""))
+                return 0
+            ws = Workspace(a.workspace) if a.workspace else None
+            if ws is not None and (a.k is not None or a.surface_margin is not None or a.sigma_pa is not None or a.hole is not None):
+                if a.hole is not None and not a.well:
+                    raise ValueError("--hole needs --well")
+                s_ = _CO.set_settings(ws, a.actor, a.k, a.surface_margin, a.sigma_pa, (a.well, a.hole) if a.hole is not None else None, a.source)
+                print(f"rule: k {s_['k']:g}, surface margin {s_['surface_margin_m']:g} m, project-ahead {s_['sigma_pa_m']:g} m; holes: "
+                      + (", ".join(f"{k} {v:g} in" for k, v in s_['holes_in'].items()) or "8.5 in by default"))
+                return 0
+            scene = a.scene or ("workspace" if ws is not None else "volve")
+            if a.write:
+                if ws is None:
+                    raise ValueError("--write needs --workspace")
+                r_ = _CO.write_report(ws, __version__, a.actor, scene)
+                print(f"wrote {r_['report_id']}: {r_['paths']['html']}")
+                if r_['paths'].get('pdf'):
+                    print(f"  printable: {r_['paths']['pdf']}")
+                return 0
+            r = _CO.page(ws, scene)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"collision: {e.args[0] if e.args else e}")
+        print(_json.dumps({k: v for k, v in r.items()}, default=str) if a.json else _CO.text(r))
+        return 0
     elif a.cmd == "rig-time":
         import json as _json
         from . import rig_state as _RS
@@ -2376,6 +2430,12 @@ def main(argv=None) -> int:
         _safe_stdout()
         try:
             ws = Workspace(a.workspace)
+            if a.casing:
+                if not a.well:
+                    raise ValueError("--casing needs --well")
+                c_ = _RS.set_casing(ws, a.actor, a.well, a.casing, a.shoe_md, a.source, a.set_time)
+                print(f"casing {c_['size']} in, shoe at {c_['shoe_md_ft']:,.0f} ft MD ({c_['source']})")
+                return 0
             if a.w2w_min is not None or a.trip_in is not None or a.trip_out is not None or a.block_weight is not None:
                 if a.block_weight is not None and not a.well:
                     raise ValueError("--block-weight needs --well")

{gea_program-0.47.0 → gea_program-0.49.0}/gea/acceptance_tests.py

@@ -10913,6 +10913,389 @@ def section_cp_rig_time(tmp: str) -> None:
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
 
+def section_cq_tied_together(tmp: str) -> None:
+    """Section CQ - the recent parts tied together: an Excel workbook read without Excel (shared and inline strings,
+    numbers, booleans, dates and times from their cell formats, the 1904 epoch, a named sheet) and taken wherever a
+    CSV is - the invoice check's files and the declarations sheet; the declarations sheet's new tables (the contract,
+    the rig-time targets, block weights, casing, the watch and summary settings) planned, written, round-tripped and
+    refused when wrong; rig time by hole section from declared casing; the invoice differing raised as an alert and
+    cleared; the daily summary carrying each invoice check and yesterday's rig time; a signed dossier carrying the
+    contract, the files, the targets, the casing and both checks as they read at signing; the API, the CLI, the tabs
+    and the help pages."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import base64 as _b64
+    import zipfile as _zf
+    from datetime import datetime as _dtm, timedelta as _td, timezone as _tz
+    from . import __version__
+    from . import alerts as AL
+    from . import declarations as DC
+    from . import dossier as DZ
+    from . import helplib as H
+    from . import invoice_check as IC
+    from . import pad_summary as PS
+    from . import rig_state as RS
+    from . import seismic_watch as SW
+    from . import xlsx_read as XR
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "cq"); d.mkdir()
+
+    # -- CQ1 the workbook -------------------------------------------------------------------------------------------------
+    XR.write_simple(str(d / "a.xlsx"), [["Date", "Rate Type", "Quantity", "Note"], [_dtm(2026, 7, 1), "Operating day rate", 1, 'with, a "comma"'],
+                                        [_dtm(2026, 7, 2, 6, 30), "Standby", 12.5, None]])
+    a = XR.rows((d / "a.xlsx").read_bytes())
+    ns = 'xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"'
+    with _zf.ZipFile(d / "b.xlsx", "w") as z:                 # a hand-made workbook: two sheets, inline strings, booleans, the 1904 epoch, a custom date format
+        z.writestr("xl/workbook.xml", f'<workbook {ns}><workbookPr date1904="1"/><sheets><sheet name="Notes" sheetId="1" r:id="rId1"/><sheet name="Invoice" sheetId="2" r:id="rId2"/></sheets></workbook>')
+        z.writestr("xl/_rels/workbook.xml.rels", '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Target="worksheets/sheet1.xml" Type="x"/><Relationship Id="rId2" Target="/xl/worksheets/sheet2.xml" Type="x"/></Relationships>')
+        z.writestr("xl/styles.xml", f'<styleSheet {ns}><numFmts count="1"><numFmt numFmtId="164" formatCode="dd/mm/yyyy\\ hh:mm"/><numFmt numFmtId="165" formatCode="#,##0.00"/></numFmts>'
+                                    '<cellXfs count="3"><xf numFmtId="0"/><xf numFmtId="164"/><xf numFmtId="165"/></cellXfs></styleSheet>')
+        z.writestr("xl/worksheets/sheet1.xml", f'<worksheet {ns}><sheetData><row r="1"><c r="A1" t="inlineStr"><is><t>notes</t></is></c></row></sheetData></worksheet>')
+        z.writestr("xl/worksheets/sheet2.xml", f'<worksheet {ns}><sheetData><row r="1"><c r="A1" t="inlineStr"><is><t>When</t></is></c><c r="C1" t="inlineStr"><is><t>Paid</t></is></c></row>'
+                                               '<row r="3"><c r="A3" s="1"><v>44743.25</v></c><c r="B3" s="2"><v>1234.5</v></c><c r="C3" t="b"><v>1</v></c></row></sheetData></worksheet>')
+    bx = (d / "b.xlsx").read_bytes()
+    b2 = XR.rows(bx, "Invoice")
+    c1 = {
+        "simple": a == [["Date", "Rate Type", "Quantity", "Note"], ["2026-07-01", "Operating day rate", "1", 'with, a "comma"'], ["2026-07-02T06:30", "Standby", "12.5"]],
+        "csv": XR.to_csv((d / "a.xlsx").read_bytes()).splitlines()[1] == '2026-07-01,Operating day rate,1,"with, a ""comma"""',
+        "sheets": XR.sheets(bx) == ["Notes", "Invoice"] and XR.rows(bx) == [["notes"]],
+        "hand_made": b2 == [["When", "", "Paid"], [], ["2026-07-02T06:00", "1234.5", "TRUE"]],
+        "text_of": XR.text_of(b"a,b\n1,2\n") == "a,b\n1,2\n" and not XR.is_xlsx(b"PK not a zip"),
+    }
+    try:
+        XR.rows(bx, "Nope"); c1["named"] = False
+    except ValueError as e:
+        c1["named"] = "Notes, Invoice" in str(e)
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CQ1 an Excel workbook read with the standard library: shared and inline strings, a comma and quotes kept, whole numbers without "
+       "'.0', dates and date-times from built-in and custom formats, the 1904 epoch, booleans, a gap row kept as a gap, the first or a "
+       "named sheet; CSV text passed through" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CQ2 the declarations sheet, casing, and the invoice as a workbook --------------------------------------------------
+    F = RS.selftest_edr(str(d))
+    G = IC.selftest_files(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad CQ", actor="tester")
+    w1 = ws.add_well_file(F["path"], display="RIG-1", actor="tester"); w2 = ws.add_well_file(F["path"], display="RIG-2", actor="tester")
+    wi = ws.add_well_file(G["edr"], display="INV-1", actor="tester")
+    sheet = ("[contract],day_start,report_date,operating,standby,repair,repair_hours_per_month,source\n,06:00,start,30000,25000,0,2,daywork contract A\n"
+             "[rig_time],w2w_min,trip_in_ft_h,source\n,,2800,program 2026\n[block_weights],well,block_weight_klbf\n,RIG-2,42\n"
+             "[casing],well,size_in,shoe_md_ft,set,source\n,RIG-1,9-5/8,10150,,tally\n,RIG-2,9-5/8,10150,,tally\n,RIG-1,13-3/8,2000,,tally\n"
+             "[settings],setting,value\n,watch_every_min,10\n,summary_at,10:45\n,summary_send,no\n")
+    rows_ = [ln.split(",") for ln in sheet.strip().splitlines()]
+    XR.write_simple(str(d / "decl.xlsx"), rows_)
+    p_x = DC.plan(ws, XR.text_of((d / "decl.xlsx").read_bytes()))
+    p_w = DC.apply(ws, sheet, "tester", write=True)
+    p_rt = DC.plan(ws, DC.template(ws))
+    p_bad = DC.plan(ws, "[contract],operating,source\n,30000,\n[settings],setting,value\n,watch_mode,sometimes\n,colour,blue\n[casing],well,size_in,shoe_md_ft,source\n,RIG-1,9 5/8,100,x\n,NOPE,7,100,x\n")
+    pad = RS.pad(ws)
+    W1 = next(w for w in pad["wells"] if w["display"] == "RIG-1")
+    secs = [c["section"] for c in W1["connection_list"]]
+    XR.write_simple(str(d / "inv.xlsx"), [ln.split(",") if i == 0 else [(_dtm.fromisoformat(x) if j == 0 else (float(x) if re.fullmatch(r"[\d.]+", x) else x)) for j, x in enumerate(ln.split(","))]
+                                          for i, ln in enumerate(G["invoice"].strip().splitlines())])
+    IC.attach(ws, "tester", wi["id"], "ddr", "ddr.csv", G["ddr"].encode(), "reports")
+    IC.attach(ws, "tester", wi["id"], "invoice", "inv.xlsx", (d / "inv.xlsx").read_bytes(), "invoice as a workbook")
+    ic = IC.check(ws, wi["id"])
+    c2 = {
+        "xlsx_sheet": p_x["counts"]["NEW"] == 6 and p_x["counts"]["CHANGE"] == 3 and not p_x["errors"],
+        "written": p_w["applied"] and IC.terms(ws)["rates_usd_per_day"] == {"operating": 30000.0, "standby": 25000.0, "repair": 0.0}
+                   and RS.settings(ws)["targets"] == {"trip_in_ft_h": 2800.0} and RS.settings(ws)["block_weight_klbf"] == {w2["id"]: 42.0}
+                   and [x["size"] for x in RS.casing(ws)[w1["id"]]] == ["13-3/8", "9-5/8"] and SW.settings(ws)["every_min"] == 10
+                   and PS.settings(ws)["at"] == "10:45" and PS.settings(ws)["send"] is False,
+        "round_trip": p_rt["counts"]["NEW"] == 0 and p_rt["counts"]["CHANGE"] == 0 and not p_rt["errors"],
+        "refused": len(p_bad["errors"]) == 5 and any("watch_mode" in e for e in p_bad["errors"]) and any("no setting 'colour'" in e for e in p_bad["errors"])
+                   and any("13-3/8, 9-5/8 or 7" in e for e in p_bad["errors"]) and any("came from" in e for e in p_bad["errors"]),
+        "sections": secs == ["below the 13-3/8 in shoe", "below the 9-5/8 in shoe", "below the 9-5/8 in shoe"]
+                    and all(x["hole"] == "CASED" for x in W1["trips"]) and set(pad["targets"]["by_section"]) == {"below the 9-5/8 in shoe"}
+                    and next(w for w in pad["wells"] if w["display"] == "RIG-2")["block_weight_klbf"] == 42.0,
+        "invoice_xlsx": ic["status"] == "DIFFERS" and ic["totals"]["usd_in_question"] == 37666.67,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CQ2 the declarations sheet's new tables - the contract, the rig-time targets, a block weight, casing shoes, the watch and summary "
+       "settings - read from a workbook, written, round-tripped to nothing to do, and refused when wrong (no source, an unknown setting, a "
+       "size not in inches as written, a well not there); connections by hole section and trips inside casing; an invoice attached as a "
+       "workbook checked to the same 37,666.67" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CQ3 the alert, the summary, the dossier ----------------------------------------------------------------------
+    now = _dtm(2026, 7, 2, 12, 0, tzinfo=_tz.utc)
+    k1 = AL.check_conditions(ws, None, now, force=True)
+    st1 = dict(AL.state(ws)["conditions"])
+    g = PS.gather(ws, _dtm(2026, 8, 2, 7, 0, tzinfo=_tz.utc), _dtm(2026, 8, 1, 0, 0, tzinfo=_tz.utc))
+    RS.write_report(ws, __version__, "tester")
+    e1 = DZ.build(ws, "tester", __version__, None)
+    with _zf.ZipFile(os.path.join(ws.reports_dir, e1["path"])) as z:
+        names = set(z.namelist())
+        rt = json.loads(z.read("results/rig_time.json"))
+        icj = json.loads(z.read(f"results/invoice_check/{wi['id']}.json"))
+    v1 = DZ.verify(os.path.join(ws.reports_dir, e1["path"]), ws)
+    for f_ in IC.files(ws, wi["id"]):                     # the corrected report and invoice replace them
+        IC.remove(ws, "tester", f_["file"])
+    ddr_ok = G["ddr"].replace("2026-07-02,14:00,16:00,2,6,Trip out", "2026-07-02,14:00,16:00,2,7,Service rig").replace("6200,7600", "6200,7400")
+    inv_ok = ("Date,Rate Type,Quantity,Unit,Unit Price,Amount\n2026-07-01,Operating day rate,1,day,30000,30000\n"
+              "2026-07-02,Operating day rate,22,hour,1250,27500\n2026-07-02,Repair rate,2,hour,0,0\n"
+              "2026-07-03,Standby rate,20,hour,1041.6667,20833.33\n2026-07-03,Operating day rate,4,hour,1250,5000\n2026-07-04,Operating day rate,1,day,30000,30000\n")
+    IC.attach(ws, "tester", wi["id"], "ddr", "ddr_ok.csv", ddr_ok.encode(), "corrected reports")
+    IC.attach(ws, "tester", wi["id"], "invoice", "inv_ok.csv", inv_ok.encode(), "corrected invoice")
+    k2 = AL.check_conditions(ws, None, now + _td(minutes=1))
+    c3 = {
+        "alert": [a_["event"] for a_ in k1 if a_["event"] == "invoice.differs"] == ["invoice.differs"] and f"invoice.differs:{wi['id']}" in st1
+                 and "37,666.67" in next(a_ for a_ in k1 if a_["event"] == "invoice.differs")["detail"],
+        "cleared": [a_["event"] for a_ in k2] == ["condition.cleared"] and k2[0]["cleared"] == "invoice.differs",
+        "summary": any(x["item"] == "the invoice check of INV-1" and x["status"] == "DIFFERS" for x in g["due"])
+                   and [x["well"] for x in g["rig_time"]] == ["RIG-1", "RIG-2"] and all(x["connections"] == 3 and x["date"] == "2026-08-01" for x in g["rig_time"])
+                   and all(x["lost_usd"] is not None for x in g["rig_time"]),
+        "dossier": v1["status"] == "VALID" and {"declarations/economics/invoices/terms.json", "declarations/economics/invoices/files.json",
+                                                 "declarations/drillstring/rig_time.json", "declarations/drillstring/casing.json"} <= names
+                   and any(n.startswith(f"declarations/economics/invoices/{wi['id']}/") and n.endswith("_inv.xlsx") for n in names)
+                   and icj["status"] == "DIFFERS" and len(rt["wells"]) == 3 and rt["targets"]["trip_in_ft_h"]["value"] == 2800,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CQ3 an invoice that differs raised as an alert with its dollars, and cleared when a corrected invoice replaces it; the daily summary "
+       "carrying the invoice check and yesterday's rig time well by well with its cost at the contract's rate; a signed pad dossier carrying "
+       "the contract, the invoice files as attached, the targets and the casing, and both checks as they read at signing - VALID"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- CQ4 the API, the CLI, the tabs, the help ------------------------------------------------------------------------
+    Users(str(Path(wsp, "users.json"))).add("v", "viewer-pass-1", "viewer"); Users(str(Path(wsp, "users.json"))).add("op", "op-pass-123", "operator")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def opener(name, pw_):
+        o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+        rq = urllib.request.Request(base_url + "/api/login", method="POST", data=json.dumps({"name": name, "password": pw_}).encode())
+        rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1"); o.open(rq, timeout=30)
+        return o
+
+    def call(o, method, path, body=None):
+        rq = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        if method == "POST":
+            rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1")
+        try:
+            with o.open(rq, 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:
+        V, O = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_vc, _ = call(V, "POST", "/api/rig-time/casing", {"well_id": w2["id"], "size": "7", "shoe_md_ft": 9000, "source": "x"})
+        s_oc, ocj = call(O, "POST", "/api/rig-time/casing", {"well_id": w2["id"], "size": "7", "shoe_md_ft": 9000, "source": "tally"})
+        s_ob, _ = call(O, "POST", "/api/rig-time/casing", {"well_id": w2["id"], "size": "seven", "shoe_md_ft": 9000, "source": "tally"})
+        s_or, _ = call(O, "POST", "/api/rig-time/casing/remove", {"well_id": w2["id"], "size": "7"})
+        s_dx, dxj = call(O, "POST", "/api/declare", {"content_b64": _b64.b64encode((d / "decl.xlsx").read_bytes()).decode()})
+        s_ia, iaj = call(O, "POST", "/api/invoice-check/attach", {"well_id": wi["id"], "kind": "invoice", "filename": "inv2.xlsx", "source": "workbook",
+                                                                   "content_b64": _b64.b64encode((d / "inv.xlsx").read_bytes()).decode()})
+        s_al, alj = call(V, "GET", "/api/alerts")
+    finally:
+        svc.stop()
+    cli_c = _sp.run([sys.executable, "-m", "gea", "rig-time", "--workspace", wsp, "--well", w2["id"], "--casing", "13-3/8", "--shoe-md", "2000", "--source", "tally"],
+                    capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_d = _sp.run([sys.executable, "-m", "gea", "declare", "--workspace", wsp, "--file", str(d / "decl.xlsx")], capture_output=True, text=True, cwd=str(pkg.parent))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c4 = {
+        "api": s_vc == 403 and s_oc == 200 and ocj["shoe_md_ft"] == 9000 and s_ob == 400 and s_or == 200 and s_dx == 200 and dxj["counts"]["SAME"] == 9
+               and s_ia == 200 and iaj["lines"] == 7 and s_al == 200 and "invoice.differs" in alj["events"],
+        "cli": cli_c.returncode == 0 and "13-3/8 in, shoe at 2,000 ft" in cli_c.stdout and cli_d.returncode == 0 and "already declared" in cli_d.stdout,
+        "page": all(x in page_src for x in ("rtC", "/api/rig-time/casing", ".xlsx", "content_b64: DC.b64", "'invoice.differs': 'Invoice differs'")),
+        "help": all(not H.check(t_) for t_ in ("declare", "rig-time", "invoice-check", "dossier", "alerts", "pad-summary"))
+                and "[casing]" in (pkg / "help" / "declare.md").read_text(encoding="utf-8") and "Hole sections" in (pkg / "help" / "rig-time.md").read_text(encoding="utf-8")
+                and "invoice.differs" in (pkg / "help" / "alerts.md").read_text(encoding="utf-8") and "results/" in (pkg / "help" / "dossier.md").read_text(encoding="utf-8"),
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "CQ4 on the API (only an operator declares or removes a casing shoe, a size that is not one refused; a declarations workbook and an "
+       "invoice workbook sent as they are; the new alert listed), the CLI (a casing shoe, a declarations workbook), the tabs and the help pages"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
+def section_cr_collision(tmp: str) -> None:
+    """Section CR - well collision checks: each well's position uncertainty by the ISCWSA MWD Rev 4 error model,
+    checked against all 112 rows of the ISCWSA's own example; the Earth's field from WMM2025, checked against a
+    published example; the ISCWSA separation factor, its arithmetic recomputed by hand with the errors two wells share
+    taken out; the Volve template as the worked example; a workspace's wells checked, the rule and the hole sizes kept
+    by an operator only; the API, the CLI, the report, the tab and the help."""
+    import hashlib as _hl
+    import http.cookiejar
+    import math as _m
+    import subprocess as _sp
+    import time as _t
+    import urllib.request
+    import urllib.error
+    import numpy as _np
+    from . import collision as CO
+    from . import edr as E
+    from . import geomag as GM
+    from . import helplib as H
+    from . import pdf_report as PR
+    from . import well3d as W
+    from . import wellpos as WP
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "collision"); d.mkdir()
+
+    # -- CR1 the error model and the field against their published examples --------------------------------------------
+    ex = WP.check_example()
+    tot8 = ex["totals"]["8000"]
+    f1 = GM.field(42.283, -71.35, 1000.0, "2028-07-04")
+    f2 = GM.field(31.42, -104.10, 0.0, 2031.5)
+    c1 = {
+        "example": ex["rows"] == 112 and ex["sources"] == 27 and ex["depths_m"] == [1200, 2100, 5100, 8000] and not ex["disagree"] and ex["worst_relative"] < 1e-3,
+        "totals": abs(tot8[0] - 8547.78) < 0.05 and abs(tot8[1] - 712.69) < 0.05 and abs(tot8[2] - 468.13) < 0.05 and abs(tot8[3] + 2252.31) < 0.05,
+        "attribution": "ISCWSA" in ex["source"] and "welleng" in ex["source"] and "Apache" in ex["license"],
+        "wmm": abs(f1["declination_deg"] + 13.6891) < 5e-4 and abs(f1["dip_deg"] - 65.9899) < 5e-4 and abs(f1["total_nT"] - 50940) < 1.0
+               and abs(f1["north_nT"] - 20139) < 1.0 and abs(f1["east_nT"] + 4905) < 1.0 and abs(f1["down_nT"] - 46532) < 1.0 and f1["in_range"],
+        "wmm_range": not f2["in_range"] and "extrapolated" in f2["note"] and abs(GM.decimal_year("2026-07-02") - (2026 + 182 / 365)) < 1e-9,
+        "coefficients": _hl.md5((pkg / "reference" / "WMM2025.COF").read_bytes()).hexdigest() == "a1b6402dd23658d15affb0f31babccc7",
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CR1 each well's uncertainty by the ISCWSA MWD Rev 4 error model: all 112 rows of the ISCWSA's own example (27 error sources "
+       "and the total, at 1,200, 2,100, 5,100 and 8,000 m MD) recomputed and agreeing to the printed digits, its source and licence "
+       "carried; the field by WMM2025 agreeing with a published example (declination -13.6891, dip 65.9899 deg, 50,940 nT), a date "
+       "past the model's years answered and called extrapolated, the coefficients as NOAA published them"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CR2 the separation factor's arithmetic ----------------------------------------------------------------------------
+    fld = {"declination_deg": 6.0, "dip_deg": 60.0, "total_nT": 48000.0}
+    md = [0.0, 500.0, 1000.0, 2000.0]
+    mk = lambda i, x, inc=(0, 0, 0, 0), az=(0, 0, 0, 0), y=0.0: {"id": i, "display": i, "md": md, "inc": list(inc), "az": list(az), "x0": x, "y0": y,
+                                                          "ref_elev_m": 0.0, "field": fld, "hole_in": 8.5}
+    rule = {**CO.DEFAULTS}
+    A, B = CO.prepare(mk("A", 0.0)), CO.prepare(mk("B", 10.0))
+    sAB, sBA = CO.scan(A, B, rule), CO.scan(B, A, rule)
+    u = WP.well_uncertainty(_np.array(md), _np.zeros(4), _np.zeros(4), _np.array(md), 6.0, 60.0, 48000.0)
+    Cee = float(u["cov"][-1][1, 1]); Gee = sum(float(g[-1][1]) ** 2 for g in u["global"].values())
+    sig_hand = _m.sqrt(2.0 * (Cee - Gee))
+    sf_hand = (10.0 - 2 * 8.5 * 0.0254 / 2 - 0.3) / (3.5 * _m.sqrt(sig_hand ** 2 + 0.25))
+    i_td = len(sAB["profile"]["md_m"]) - 1
+    E1, E2 = CO.prepare(mk("E1", 0.0, (0, 0, 30, 30), (90, 90, 90, 90))), CO.prepare(mk("E2", 0.0, (0, 0, 30, 30), (90, 90, 90, 90), 10.0))
+    s_sh = CO.scan(E1, E2, rule)                                  # parallel, inclined east, 10 m apart north-south: the declination moves both
+    s_ng = CO.scan({**E1, "glob": {k: v * 0 for k, v in E1["glob"].items()}}, {**E2, "glob": {k: v * 0 for k, v in E2["glob"].items()}}, rule)
+    j_td = len(s_sh["profile"]["md_m"]) - 1
+    ue = WP.well_uncertainty(_np.array(md), _np.array([0.0, 0.0, 30.0, 30.0]), _np.full(4, 90.0), _np.array(W.Path(md, [0, 0, 30, 30], [90] * 4, 0.0, 0.0, 0.0, 0.0).tvd), 6.0, 60.0, 48000.0)
+    Cnn = float(ue["cov"][-1][0, 0]); Gnn = sum(float(g[-1][0]) ** 2 for g in ue["global"].values())
+    C_, D_ = CO.prepare(mk("C", 0.0, (0, 0, 30, 30), (0, 0, 90, 90))), CO.prepare(mk("D", 30.0, (0, 0, 30, 30), (0, 0, 270, 270)))
+    sCD = CO.scan(C_, D_, rule)
+    c2 = {
+        "hand": abs(sAB["profile"]["sigma_m"][i_td] - sig_hand) < 2e-3 and abs(sAB["profile"]["sf"][i_td] - sf_hand) < 2e-3 and abs(sAB["profile"]["distance_m"][i_td] - 10.0) < 1e-6,
+        "shared_out": set(u["global"]) == {"DECG", "DBHG", "DSTG"} and Gnn > 0.01 and abs(s_sh["profile"]["sigma_m"][j_td] - _m.sqrt(2.0 * (Cnn - Gnn))) < 2e-3
+                      and abs(s_ng["profile"]["sigma_m"][j_td] - _m.sqrt(2.0 * Cnn)) < 2e-3 and abs(s_sh["profile"]["distance_m"][j_td] - 10.0) < 1e-3,
+        "symmetric": abs(sAB["min_sf"] - sBA["min_sf"]) < 1e-6 and sAB["at_md_m"] == 2000.0,
+        "crossing": sCD["min_sf"] < 1.0 and sCD["level"] == "BELOW 1.0" and sCD["closest_m"] < 1.0 and sCD["sections"] and sCD["sections"][0]["from_md_m"] < sCD["at_md_m"],
+        "levels": [CO.level(x)[0] for x in (0.99, 1.0, 1.2, 1.25, 1.4, 1.5, 3.99, 4.0)]
+                  == ["BELOW 1.0", "REVISE THE PLAN", "REVISE THE PLAN", "APPROACH LIMIT", "APPROACH LIMIT", "REPORTED", "REPORTED", "CLEAR"],
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CR2 the separation factor's arithmetic: two vertical wells 10 m apart recomputed by hand at TD - sigma along the line between "
+       "them from each well's covariance less the errors both share (declination, the global magnetic and depth terms), the holes' "
+       "radii, the surface margin, project-ahead and k; leaving the shared errors in widens sigma; the same from either well; two wells "
+       "steered at each other found below 1.0 where they cross; the four levels at their edges"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CR3 the worked example: the Volve template ------------------------------------------------------------------------
+    t0 = _t.time()
+    v = CO.page(None, "volve")
+    dt = _t.time() - t0
+    w_ = v["worst"]; wl = {x["display"]: x for x in v["wells"]}
+    c3 = {
+        "wells": len(v["wells"]) == 3 and len(v["pairs"]) == 6 and abs(wl["15/9-F-10"]["td_md_m"] - 5300.1) < 0.1
+                 and all(abs(x["field"]["declination_deg"] - 1.12) < 0.05 for x in v["wells"]) and all("grid convergence" in x["azimuth_note"] for x in v["wells"]),
+        "worst": w_["level"] == "BELOW 1.0" and abs(w_["min_sf"] - 0.29) < 0.01 and {w_["reference_name"], w_["offset_name"]} == {"15/9-F-5", "15/9-F-10"}
+                 and abs(w_["at_md_m"] - 250) < 15 and abs(w_["distance_m"] - 1.20) < 0.05,
+        "order": [p["min_sf"] for p in v["pairs"]] == sorted(p["min_sf"] for p in v["pairs"]) and all(len(p["profile"]["md_m"]) == len(p["profile"]["sf"]) for p in v["pairs"]),
+        "ellipses": wl["15/9-F-10"]["td_ellipse_1sigma"]["major_m"] > wl["15/9-F-5"]["td_ellipse_1sigma"]["major_m"] > wl["NO 15/9-F-4"]["td_ellipse_1sigma"]["major_m"] > 1.0,
+        "fast": dt < 20.0,
+    }
+    failed3 = [k for k, v_ in c3.items() if not v_]
+    ok(not failed3,
+       "CR3 the worked example, the Volve template's three wells (Equinor's released data): every pair scanned both ways, the field from "
+       "WMM2025 at the template and the grid convergence applied; the closest, 15/9-F-5 and 15/9-F-10 near the surface where the slots "
+       "sit 1.2 m apart, below 1.0; the longest well the widest ellipse at TD"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- CR4 a workspace's wells, the API, the CLI, the report, the tab and the help ----------------------------------------
+    ev = E.selftest_events(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    ids = []
+    for i, n in enumerate(("Well A", "Well B", "Well C")):
+        w = ws.add_well_file(ev["path"], display=n, actor="tester"); ids.append(w["id"])
+        ws.set_well(w["id"], surface={"lat": 31.42, "lon": -104.10 + 0.0001 * i, "datum": "NAD83", "elevation": {"ft": 3000.0, "datum": "KB", "source": "test plat"}}, actor="tester")
+    W.attach_trajectory(ws, ids[0], "a.csv", b"MD (ft),Inc (deg),Azi (deg)\n0,0,0\n1000,0,0\n2000,10,90\n3000,30,90\n4000,45,95\n5750,60,100\n", "tester", "true", "ft", None, None, None, "test survey")
+    W.attach_trajectory(ws, ids[1], "b.csv", b"MD (ft),Inc (deg),Azi (deg)\n0,0,0\n1200,0,0\n2200,12,270\n3500,35,265\n5500,55,260\n", "tester", "true", "ft", None, None, None, "test survey")
+    p0 = CO.page(ws)
+    Users(str(Path(wsp, "users.json"))).add("v", "viewer-pass-1", "viewer"); Users(str(Path(wsp, "users.json"))).add("op", "op-pass-123", "operator")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def opener(name, pw_):
+        o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+        rq = urllib.request.Request(base_url + "/api/login", method="POST", data=json.dumps({"name": name, "password": pw_}).encode())
+        rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1"); o.open(rq, timeout=30)
+        return o
+
+    def call(o, method, path, body=None):
+        rq = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        if method == "POST":
+            rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1")
+        try:
+            with o.open(rq, 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:
+        V, O = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_vg, vg = call(V, "GET", "/api/collision")
+        s_vv, vv = call(V, "GET", "/api/collision?scene=volve")
+        s_bad, _ = call(V, "GET", "/api/collision?scene=nowhere")
+        s_vs, _ = call(V, "POST", "/api/collision/settings", {"k": 3.0, "source": "x"})
+        s_ns, _ = call(O, "POST", "/api/collision/settings", {"k": 3.0})
+        s_lk, _ = call(O, "POST", "/api/collision/settings", {"k": 0.1, "source": "standard"})
+        s_ok, okj = call(O, "POST", "/api/collision/settings", {"k": 3.0, "surface_margin_m": 0.5, "source": "company anti-collision standard, rev 3"})
+        s_hb, _ = call(O, "POST", "/api/collision/settings", {"well_id": ids[0], "hole_in": 99})
+        s_ho, hoj = call(O, "POST", "/api/collision/settings", {"well_id": ids[0], "hole_in": 12.25})
+        s_ag, ag = call(V, "GET", "/api/collision")
+        s_vw, _ = call(V, "POST", "/api/collision/write", {})
+        s_ow, owj = call(O, "POST", "/api/collision/write", {})
+    finally:
+        svc.stop()
+    cli_v = _sp.run([sys.executable, "-m", "gea", "collision", "--scene", "volve"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_f = _sp.run([sys.executable, "-m", "gea", "collision", "--field", "42.283,-71.35,2028-07-04"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_w = _sp.run([sys.executable, "-m", "gea", "collision", "--workspace", wsp, "--write"], capture_output=True, text=True, cwd=str(pkg.parent))
+    pdf = Path(wsp, "reports", "collision.pdf")
+    rd = PR.read(pdf.read_bytes()) if pdf.exists() else {"ok": False, "text": []}
+    audit = Path(ws.audit_path).read_text(encoding="utf-8")
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    wa = next((p for p in ag.get("pairs", []) if p["reference"] == ids[0]), {}) if s_ag == 200 else {}
+    c4 = {
+        "workspace": len(p0["wells"]) == 2 and len(p0["pairs"]) == 2 and [x["id"] for x in p0["left_out"]] == [ids[2]] and "survey" in p0["left_out"][0]["why"]
+                     and all("WMM2025 at the well" in x["field_note"] for x in p0["wells"]) and p0["worst"]["level"] == "BELOW 1.0",
+        "api": s_vg == 200 and vg["scene"] == "workspace" and len(vg["pairs"]) == 2 and s_vv == 200 and len(vv["pairs"]) == 6 and s_bad in (400, 404)
+               and s_vs == 403 and s_ns == 400 and s_lk == 400 and s_ok == 200 and okj["k"] == 3.0 and s_hb == 400 and s_ho == 200 and hoj["holes_in"][ids[0]] == 12.25
+               and s_ag == 200 and ag["rule"]["k"] == 3.0 and ag["rule_source"].startswith("company") and wa.get("min_sf", 0) < p0["pairs"][0]["min_sf"] + 1
+               and next(x for x in ag["wells"] if x["id"] == ids[0])["hole_in"] == 12.25 and s_vw == 403 and s_ow == 200 and owj["report_id"].startswith("COL-"),
+        "cli": cli_v.returncode == 0 and "15/9-F-5" in cli_v.stdout and "BELOW 1.0" in cli_v.stdout and cli_f.returncode == 0 and "declination -13.69" in cli_f.stdout
+               and cli_w.returncode == 0 and "collision" in cli_w.stdout,
+        "report": rd["ok"] and any("separation factor" in t_ for t_ in rd["text"]) and any("Well A" in t_ for t_ in rd["text"])
+                  and "collision.settings" in audit and "report.collision" in audit,
+        "page": all(x in page_src for x in ("VIEWS.collision", "['#/collision', 'Collision']", "/api/collision/settings", "/api/collision/write", "coChart")),
+        "help": not H.check("collision") and H.VIEW_TOPIC.get("collision") == "collision" and "WMM2025" in (pkg / "help" / "collision.md").read_text(encoding="utf-8"),
+    }
+    failed4 = [k for k, v_ in c4.items() if not v_]
+    ok(not failed4,
+       "CR4 a workspace's wells: those with a position, an elevation and a survey checked, the one without listed with why, the field "
+       "at each well; on the API anyone reads it and only an operator keeps a rule (with its source; a k below 0.5 refused) or a hole size "
+       "(inches, 2 to 40) or writes the report; the CLI (the worked example, the field at a place and date, the report); the report as "
+       "PDF; the tab and the help"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 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:
@@ -11010,6 +11393,8 @@ def main() -> int:
         section_cn_four(tmp)
         section_co_invoice_check(tmp)
         section_cp_rig_time(tmp)
+        section_cq_tied_together(tmp)
+        section_cr_collision(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: