gea-program 0.38.0__tar.gz → 0.40.0__tar.gz

{gea_program-0.38.0/gea_program.egg-info → gea_program-0.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.38.0
+Version: 0.40.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,30 @@ 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`.
 
+### Drill string
+
+The Drill String tab holds each run's string from the bit up - drawn as a
+build diagram - and follows every component's hours, footage and, for a
+motor, revolutions from the drilling record across runs and wells against
+its declared service interval. The downhole motor tracker charts the
+differential against the maker's limits, the stalls, the motor's and the
+bit's speed and a torque estimate, and judges the motor's stability from
+the slow oscillations of the torque and the differential, block by block.
+The tool catalogue carries 41 downhole motors with the maker's figures.
+`gea drillstring`, `gea tools --action motors`, `gea help drillstring`.
+
+### Simulation
+
+The Simulation tab drills a well again on the screen: the bit runs down its
+path in 3D among the mapped formations, on the clock it was drilled by,
+while a mud-log panel beside it grows with the hole - the formations, the
+rock and fluid volumes, the logs and the drilling parameters - and a
+readout says what the record carries at the bit. Volve 15/9-F-4 ships with
+its logging-while-drilling record and Schlumberger's interpretation of it
+(mineral volumes, porosity, water saturation, hydrocarbon volume); every
+well with a drilling record plays on its recorder's own clock.
+`gea simulation`, `gea help simulation`.
+
 ### The client well report
 
 `gea well-report` writes one printable document per well and one for the

{gea_program-0.38.0 → gea_program-0.40.0}/README.md

@@ -609,6 +609,30 @@ 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`.
 
+### Drill string
+
+The Drill String tab holds each run's string from the bit up - drawn as a
+build diagram - and follows every component's hours, footage and, for a
+motor, revolutions from the drilling record across runs and wells against
+its declared service interval. The downhole motor tracker charts the
+differential against the maker's limits, the stalls, the motor's and the
+bit's speed and a torque estimate, and judges the motor's stability from
+the slow oscillations of the torque and the differential, block by block.
+The tool catalogue carries 41 downhole motors with the maker's figures.
+`gea drillstring`, `gea tools --action motors`, `gea help drillstring`.
+
+### Simulation
+
+The Simulation tab drills a well again on the screen: the bit runs down its
+path in 3D among the mapped formations, on the clock it was drilled by,
+while a mud-log panel beside it grows with the hole - the formations, the
+rock and fluid volumes, the logs and the drilling parameters - and a
+readout says what the record carries at the bit. Volve 15/9-F-4 ships with
+its logging-while-drilling record and Schlumberger's interpretation of it
+(mineral volumes, porosity, water saturation, hydrocarbon volume); every
+well with a drilling record plays on its recorder's own clock.
+`gea simulation`, `gea help simulation`.
+
 ### The client well report
 
 `gea well-report` writes one printable document per well and one for the

{gea_program-0.38.0 → gea_program-0.40.0}/gea/__init__.py

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

{gea_program-0.38.0 → gea_program-0.40.0}/gea/__main__.py

@@ -285,8 +285,8 @@ def main(argv=None) -> int:
     p_tl.add_argument("--station", type=str, action="append", default=None, help="a station as DEPTH_FT:TOOL, e.g. 9850:quartz_pt_geoq177_16k")
     p_tl.add_argument("--surface-temp-f", type=float, default=75.0); p_tl.add_argument("--temp-gradient-f-ft", type=float, default=0.018)
     p_tl.add_argument("--surface-pressure-psi", type=float, default=14.7); p_tl.add_argument("--pressure-gradient-psi-ft", type=float, default=0.465)
-    p_tl.add_argument("--action", choices=["classes", "tutorial", "fleet", "fleet-add", "fleet-remove"], default=None,
-                      help="the downhole tool classes in use across the industry: classes (--category, --find), tutorial --class ID, and the workspace's own fleet (fleet, fleet-add, fleet-remove)")
+    p_tl.add_argument("--action", choices=["classes", "tutorial", "fleet", "fleet-add", "fleet-remove", "motors"], default=None,
+                      help="the downhole tool classes in use across the industry: classes (--category, --find), tutorial --class ID, the workspace's own fleet (fleet, fleet-add, fleet-remove), and the downhole motor specifications (motors)")
     p_tl.add_argument("--category", type=str, default=None, help="classes: one category (bits, drive, measure, bha, casing, completion, logging, fishing, testing)")
     p_tl.add_argument("--find", type=str, default="", help="classes: words to look for in the name and description")
     p_tl.add_argument("--class", dest="class_id", type=str, default=None, help="tutorial / fleet-add: the tool class id, e.g. pdm_motor")
@@ -516,6 +516,20 @@ def main(argv=None) -> int:
     p_3d.add_argument("--workspace", type=str, default=None)
     p_3d.add_argument("--json", action="store_true")
 
+    p_ds = sub.add_parser("drillstring", help="the drill string: each declared run's components from the bit up, their usage from the drilling record and their service life; the downhole motor's statistics and the stability of its oscillations")
+    p_ds.add_argument("--workspace", type=str, required=True)
+    p_ds.add_argument("--well", type=str, default=None)
+    p_ds.add_argument("--declare", type=str, default=None, help="a JSON file declaring a run: {well_id, name, start, end, components:[{class_id, maker, model, serial, od_in, length_ft, motor_id | motor{...}, service_limit, service_basis, service_source}]}")
+    p_ds.add_argument("--remove", type=str, default=None, help="a run id to remove")
+    p_ds.add_argument("--actor", type=str, default="cli")
+    p_ds.add_argument("--json", action="store_true")
+
+    p_sm = sub.add_parser("simulation", help="the simulation in words: the scenes (Volve 15/9-F-4 with its logs and interpretation, Volve F-5 and F-10 on the survey clock, every drilling-recorder well), and what the record says at a depth (the Simulation tab replays it)")
+    p_sm.add_argument("--workspace", type=str, default=None)
+    p_sm.add_argument("--scene", type=str, default=None, help="e.g. volve-f4, or well:Well-30636033")
+    p_sm.add_argument("--at", type=float, default=None, help="a measured depth, in the scene's unit (m for Volve, ft for a workspace well)")
+    p_sm.add_argument("--json", action="store_true")
+
     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")
@@ -2035,6 +2049,56 @@ def main(argv=None) -> int:
             r = _WR.write_pad(ws, __version__, actor=a.actor)
             print(f"pad: {r['paths']['html']}")
         return 0
+    elif a.cmd == "drillstring":
+        import json as _json
+        from . import drill_string as _DS
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            ws = Workspace(a.workspace)
+        except WorkspaceError as e:
+            raise SystemExit(f"drillstring: {e}")
+        try:
+            if a.declare:
+                with open(a.declare, encoding="utf-8") as f:
+                    d = _json.load(f)
+                r = _DS.save_run(ws, a.actor, d.get("well_id", ""), d.get("name", ""), d.get("components") or [], d.get("start"), d.get("end"),
+                                 d.get("depth_in_ft"), d.get("depth_out_ft"), d.get("note", ""), d.get("run_id"))
+                print(f"declared {r['id']}: {r['name']} on {r['well_id']}, {len(r['components'])} component(s)")
+                return 0
+            if a.remove:
+                _DS.remove_run(ws, a.actor, a.remove); print(f"removed {a.remove}"); return 0
+            p = _DS.page(ws, a.well)
+        except (ValueError, KeyError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"drillstring: {e.args[0] if e.args else e}")
+        print(_json.dumps(p, default=str) if a.json else _DS.text(p))
+        return 0
+    elif a.cmd == "simulation":
+        import json as _json
+        from . import simulation as _SIM
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        ws = None
+        if a.workspace:
+            try:
+                ws = Workspace(a.workspace)
+            except WorkspaceError as e:
+                raise SystemExit(f"simulation: {e}")
+        if not a.scene:
+            for s_ in _SIM.scenes(ws):
+                print(f"{s_['id']:<28} {s_['title']}  ({s_['note']})")
+            return 0
+        try:
+            sim = _SIM.scene(ws, a.scene)
+        except KeyError as e:
+            raise SystemExit(f"simulation: {e.args[0] if e.args else e}")
+        if a.json:
+            print(_json.dumps(sim if a.at is None else _SIM.at(sim, a.at * (0.3048 if sim.get('depth_unit') == 'ft' else 1.0)), default=str))
+        else:
+            print(_SIM.text(sim, a.at))
+        return 0
     elif a.cmd in ("trajectory", "well3d"):
         import json as _json
         from . import well3d as _W3
@@ -2610,6 +2674,10 @@ def main(argv=None) -> int:
             from . import tool_taxonomy as _TX
             from .cli import _safe_stdout
             _safe_stdout()                                  # the cited figures carry fractions and degree signs
+            if a.action == "motors":
+                from . import drill_string as _DS
+                print(_json.dumps(_DS.catalogue(), indent=1) if a.json else _DS.motor_text())
+                return 0
             if a.action == "classes":
                 cs = _TX.classes(a.category, a.find)
                 if a.category and a.category not in _TX.CATEGORY_NAMES:

{gea_program-0.38.0 → gea_program-0.40.0}/gea/acceptance_tests.py

@@ -9137,6 +9137,316 @@ def section_cg_well_report(tmp: str) -> None:
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
 
+def section_ch_simulation(tmp: str) -> None:
+    """Section CH - the simulation: Volve 15/9-F-4's logs and their interpretation shipped verbatim and checked against
+    themselves, read back at a depth to the value in the file; the bit on the clock each record carries (stepped along
+    measured depth where none was recorded, on the survey stations' times, on a drilling recorder's own clock) with the
+    hole never behind the bit; a workspace well's path from its survey or from the recorder's MD-TVD pairs; the API, the
+    CLI, the tab and its help page."""
+    import gzip as _gz
+    import hashlib as _hl
+    import http.cookiejar
+    import subprocess as _sp
+    import tempfile as _tf
+    import urllib.request
+    import urllib.error
+    from . import edr as E
+    from . import helplib as H
+    from . import ports as PT
+    from . import simulation as SIM
+    from . import well3d as W
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "ch"); d.mkdir()
+    prov = json.loads((pkg / "reference" / "volve_f4_logs.provenance.json").read_text(encoding="utf-8"))
+    hashes = all(_hl.sha256((pkg / "reference" / f["file"]).read_bytes()).hexdigest() == f["sha256"]
+                 and _hl.sha256(_gz.decompress((pkg / "reference" / f["file"]).read_bytes())).hexdigest() == f["sha256_uncompressed"]
+                 and len(f["source"]["commit"]) == 40 for f in prov["files"].values())
+    files = {}
+    for k, f in prov["files"].items():
+        p = d / (k + ".las"); p.write_bytes(_gz.decompress((pkg / "reference" / f["file"]).read_bytes())); files[k] = PT.read_las(str(p))
+    itp, lwd = files["interpretation"], files["lwd"]
+
+    def ch(st, n):
+        v = np.asarray(st.channels[n].values, dtype=float).copy(); v[v <= -999] = np.nan; return v
+    mins = sum(np.nan_to_num(ch(itp, n)) for n in ("VQFM", "VCLA", "VCLC", "VDOL", "VPYR", "VSID", "VANH", "VEVA", "VCOA"))
+    phit, swt, vuhy = ch(itp, "PHIT"), ch(itp, "SWT"), ch(itp, "VUHY")
+    sim = SIM.scene(None, "volve-f4")
+    col = sim["columns"][0]
+    sums = [sum(x or 0 for x in r) for r in col["f"]]
+    a = SIM.at(sim, 3300.0)
+    md_l, gr = np.asarray(lwd.index, dtype=float), ch(lwd, "GRMA")
+    gr_hand = float(np.interp(3300.0, md_l, gr))
+    md_i = np.asarray(itp.index, dtype=float)
+    rp = sim["scene"]["wells"][0]["replay"]
+    c1 = {
+        "shipped": hashes and "may not be sold" in prov["license"] and "Equinor" in prov["attribution"] and len(lwd.index) == 3636 and len(itp.index) == 3531
+                   and abs(float(lwd.index[0]) - 2955.95) < 1e-6,
+        "self_consistent": float(np.nanmax(np.abs(mins + phit - 1))) < 2e-3 and float(np.nanmax(np.abs(vuhy - phit * (1 - swt)))) < 1e-3,
+        "volumes": col["parts"][:2] == ["Water (in the pores)", "Hydrocarbon (in the pores)"] and min(sums) > 0.995 and max(sums) < 1.005
+                   and abs(a["columns"]["Rock and fluid volumes"]["Hydrocarbon (in the pores)"] - float(vuhy[int(np.argmin(np.abs(md_i - 3300.0)))])) < 2e-3,
+        "read_back": abs(a["tracks"]["Gamma ray"]["value"] - gr_hand) < 0.01 * max(1.0, abs(gr_hand)) and a["formation"] == "Hugin Fm. VOLVE"
+                     and {"gr", "rhob", "nphi", "rt", "phit", "sw", "k"} <= {t["id"] for t in sim["tracks"]},
+        "depth_clock": sim["clock"]["kind"] == "measured depth" and len(rp["md"]) == SIM.DEPTH_STEPS and rp["md"][0] == 0.0 and abs(rp["md"][-1] - 3510.0) < 0.01
+                       and all(t is None for t in rp["t"]) and "no drilling times" in sim["clock"]["note"],
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CH1 Volve 15/9-F-4's logging-while-drilling record and Schlumberger's interpretation of it shipped verbatim with their hashes, the "
+       "licence and the attribution; the interpretation's mineral volumes and total porosity summing to one and its hydrocarbon volume "
+       "equal to the porosity times one less the water saturation; the volume column summing to one; the gamma ray read back at 3,300 m as "
+       "the file has it, in the Hugin formation; the bit stepped along measured depth because the survey carries no drilling times"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    f5 = SIM.scene(None, "volve-f5"); f5w = next(w for w in W.volve_scene()["wells"] if w["id"] == "F-5")
+    r5 = f5["scene"]["wells"][0]["replay"]
+    ev = E.selftest_events(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wb = ws.add_well_file(ev["path"], display="Well B", actor="tester"); wc = ws.add_well_file(ev["path"], display="Well C", actor="tester")
+    ws.set_well(wb["id"], surface={"lat": 31.42, "lon": -104.10, "datum": "NAD83", "elevation": {"ft": 3000.0, "datum": "KB", "source": "test plat"}}, actor="tester")
+    csv_ok = "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"
+    W.attach_trajectory(ws, wb["id"], "s.csv", csv_ok.encode(), "tester", "true", "ft", None, None, None, "test survey")
+    ws.refresh_dashboard(actor="tester")
+    rec = json.loads(Path(ws.reports_dir, "wells", wc["id"], "drilling_record.json").read_text(encoding="utf-8"))
+    not_built = None
+    import shutil as _sh
+    _sh.rmtree(Path(wsp, "cache", "series", wc["id"]), ignore_errors=True)       # no chart cache yet: the read-only path says so
+    try:
+        SIM.scene(ws, "well:" + wc["id"], build_cache=False)
+    except KeyError as e:
+        not_built = str(e)
+    sb, sc_ = SIM.scene(ws, "well:" + wb["id"]), SIM.scene(ws, "well:" + wc["id"])
+    rc = sc_["scene"]["wells"][0]["replay"]
+    holes = [h for h in rc["hole"] if h is not None]
+    bad = None
+    try:
+        SIM.scene(ws, "nope")
+    except KeyError as e:
+        bad = str(e)
+    pc = sc_["scene"]["wells"][0]["path"]
+    mt = rec["md_tvd"]
+    c2 = {
+        "survey_clock": f5["clock"]["kind"] == "recorded" and r5["t"] == f5w["replay"]["t"] and r5["md"] == f5w["replay"]["md"]
+                        and all(b >= a_ for a_, b in zip(r5["hole"], r5["hole"][1:])) and all(h >= m - 1e-6 for h, m in zip(r5["hole"], r5["md"])),
+        "recorder_clock": sc_["clock"]["kind"] == "recorded" and rc["t"][0].startswith("2026-07-01") and not rc["t"][0].endswith("Z")
+                          and abs(max(holes) - rec["total_depth_md_ft"] * 0.3048) < 0.5 and all(b >= a_ - 1e-6 for a_, b in zip(holes, holes[1:]))
+                          and not_built is not None and "chart cache" in not_built,
+        "tracks": {t["name"] for t in sc_["tracks"]} >= {"Gamma", "Rate of penetration"} and sc_["depth_unit"] == "ft"
+                  and any("density" in n for n in sc_["not_measured"]),
+        "paths": sb["path_how"].startswith("the directional survey") and sb["scene"]["z_ref"] == "sea level"
+                 and sc_["path_how"].startswith("the drilling recorder's own MD-TVD pairs") and sc_["scene"]["z_ref"].startswith("the rig floor")
+                 and (mt.get("status") != "OK" or abs(pc["z"][pc["md"].index(next(m for m in pc["md"] if abs(m - mt["rows"][-1]["md_ft"] * 0.3048) < 0.01))] - mt["rows"][-1]["tvd_ft"] * 0.3048) < 0.01)
+                 and all(y == 0.0 for y in pc["y"]) and sc_["scene"]["no_north"] is True and sb["scene"]["no_north"] is False,
+        "unknown": bad is not None and "nope" in bad,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CH2 the clock: 15/9-F-5's bit on its survey stations' own times as the 3D tab replays them; a drilling-recorder well's bit and "
+       "bottom of the hole on the recorder's own clock (not called UTC), the hole never behind the bit and reaching the record's total "
+       "depth; its channels by bit depth, and density, porosity and fluids named as not measured; its path from the attached survey, or "
+       "from the recorder's MD-TVD pairs in one vertical plane below the rig floor when nothing places it; an unknown scene named"
+       + (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("/")
+    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": "v", "password": "viewer-pass-1"}).encode())
+    rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1"); o.open(rq, timeout=30)
+
+    def getj(path):
+        try:
+            with o.open(base_url + path, timeout=120) as r_:
+                return r_.status, json.loads(r_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        s_l, li = getj("/api/sim/scenes")
+        s_f, jf = getj("/api/sim/scene/volve-f4")
+        s_w, jw = getj("/api/sim/scene/well%3A" + wb["id"])
+        s_n, _ = getj("/api/sim/scene/nope")
+    finally:
+        svc.stop()
+    cli = _sp.run([sys.executable, "-m", "gea", "simulation"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_at = _sp.run([sys.executable, "-m", "gea", "simulation", "--scene", "volve-f4", "--at", "3300"], capture_output=True, text=True, cwd=str(pkg.parent))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c3 = {
+        "api": s_l == 200 and [x["id"] for x in li["scenes"]][:3] == ["volve-f4", "volve-f5", "volve-f10"] and "well:" + wb["id"] in [x["id"] for x in li["scenes"]]
+               and s_f == 200 and jf["columns"][0]["name"] == "Rock and fluid volumes" and s_w == 200 and jw["well_id"] == wb["id"] and s_n == 404,
+        "cli": cli.returncode == 0 and "volve-f4" in cli.stdout and cli_at.returncode == 0 and "in Hugin Fm. VOLVE" in cli_at.stdout and "Hydrocarbon (in the pores)" in cli_at.stdout,
+        "page": all(x in page_src for x in ("VIEWS.simulation", "['#/simulation', 'Simulation']", "simPanel", "simSeek", "show the log below the bit", "uCut",
+                                             "/api/sim/scene/", "a gap in the record", "W3.simBit")),
+        "help": any(t[0] == "simulation" for t in H.INDEX) and not H.check("simulation") and H.VIEW_TOPIC.get("simulation") == "simulation",
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CH3 the API (the scenes, a Volve well and a workspace well by name, an unknown one 404), the CLI (the list, and what the record says "
+       "at a depth), the Simulation tab - the 3D view's own renderer with the hole drilled so far and the string inside it, the mud-log panel "
+       "growing with the hole, the readout, a click taking the bit to the depth - and its help page"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
+def section_ci_drill_string(tmp: str) -> None:
+    """Section CI - the drill string: the downhole motor catalogue as the maker's sheets give it; a run declared from the
+    bit up and refused when a part of it is unsourced or impossible; its usage, the motor's revolutions, speed, stalls and
+    torque estimate equal to the hand sums over a labelled synthetic run; components followed across runs to their
+    service interval; the stability rule finding a growing oscillation and a moved frequency and not calling red noise a
+    peak; the API, the CLI, the tab and the help page."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    from datetime import datetime, timedelta
+    from . import drill_string as DS
+    from . import helplib as H
+    from . import tool_catalog as TC
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "ci"); d.mkdir()
+    cat = DS.catalogue()
+    ms = cat["motors"]
+    m64, m89 = DS.motor_spec("msd-6-3-4-78-6.4"), DS.motor_spec("msd-8-3-8-89-4.0")
+    c1 = {
+        "catalogue": len(ms) == 41 and len({m["id"] for m in ms}) == 41 and cat["publisher"].startswith("MS Directional") and cat["url"].startswith("https://")
+                     and cat["fetched"] == "2026-10-17" and TC.catalog()["counts"]["motors"] == 41,
+        "sane": all(m["flow_gpm"][0] < m["flow_gpm"][1] and 0 < m["rev_per_gal"] < 2 and m["max_operating_diff_psi"] <= m["max_diff_psi"]
+                    and m["stator_lobes"] == m["rotor_lobes"] + 1 and m["max_torque_ft_lb"] > 0 and m["od_in"] > 4 for m in ms),
+        "as_printed": (m64["rev_per_gal"], m64["flow_gpm"], m64["max_operating_diff_psi"], m64["max_diff_psi"], m64["max_torque_ft_lb"]) == (0.28, [300, 600], 1000, 1820, 14360)
+                      and (m89["rev_per_gal"], m89["max_diff_psi"], m89["max_torque_ft_lb"], m89["max_operating_wob_lb"]) == (0.09, 1158, 32935, 70000)
+                      and "Motor Handbook" in m64["source"],
+    }
+    try:
+        DS.motor_spec("nope"); c1["unknown"] = False
+    except KeyError:
+        c1["unknown"] = True
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CI1 the downhole motor catalogue: 41 power sections with the maker's flow range, revolutions per gallon, maximum operating and "
+       "maximum differential, maximum torque and weight on bit as its spec sheets print them, the handbook and the date it was read; "
+       "every lobe count one more on the stator than the rotor; counted in the tool catalogue; an unknown motor named"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    syn = DS.synthetic_motor_record(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w = ws.add_well_file(syn["path"], display="SYNTHETIC motor well", actor="tester")
+    ws.refresh_dashboard(actor="tester")
+    comps = [{"class_id": "pdc_bit", "maker": "Acme", "model": "X616", "serial": "B1", "od_in": 8.75, "length_ft": 1.2},
+             {"class_id": "pdm_motor", "motor_id": "msd-6-3-4-78-6.4", "serial": "M100", "length_ft": 30, "service_limit": 20, "service_basis": "circulating_hours", "service_source": "rental contract"},
+             {"class_id": "mwd_mud_pulse", "maker": "Acme", "model": "MWD", "serial": "W7", "od_in": 6.75, "length_ft": 32},
+             {"class_id": "drilling_jar", "maker": "Acme", "model": "Jar", "serial": "J2", "od_in": 6.5, "length_ft": 31, "service_limit": 300, "service_basis": "rotating_hours", "service_source": "shop rule"}]
+    refused = 0
+    for bad in ([{"class_id": "packer"}], [{"class_id": "pdc_bit", "service_limit": 10}], [{"class_id": "drilling_jar", "service_limit": 10, "service_basis": "revolutions", "service_source": "s"}],
+                [{"class_id": "pdm_motor", "motor": {"rev_per_gal": 0.3}}], [{"class_id": "pdm_motor", "motor": {"rev_per_gal": 0.3, "lobes": "seven", "source": "s"}}], []):
+        try:
+            DS.save_run(ws, "tester", w["id"], "bad", bad)
+        except ValueError:
+            refused += 1
+    for args in (("nope", "r", comps), (w["id"], "r", comps, "2026-08-01T10:00", "2026-08-01T09:00")):
+        try:
+            DS.save_run(ws, "tester", *args)
+        except (ValueError, KeyError):
+            refused += 1
+    r1 = DS.save_run(ws, "tester", w["id"], "Run 1", comps)
+    half = (datetime.fromisoformat(syn["start"]) + timedelta(hours=8)).isoformat()
+    r2 = DS.save_run(ws, "tester", w["id"], "Run 2 (second half)", [comps[1]], start=half)
+    tr = DS.run_view(ws, r1)["track"]; u = tr["usage"]; st = tr["motor_stats"]; h = st["hourly"]
+    gal = syn["gallons"]
+    trk = {e["serial"]: e for e in DS.tracking(ws)}
+    c2 = {
+        "refused": refused == 8,
+        "usage": u["circulating_hours"] == 16.0 and u["drilling_hours"] == 16.0 and abs(u["gallons"] - gal) < 1 and abs(u["footage_ft"] - 960.0) < 1.0
+                 and abs(u["revolutions"] - round(0.28 * gal)) < 2,
+        "motor": h["motor_rpm"][0] == 140.0 and h["bit_rpm"][0] == 190.0 and abs(h["whirl_hz"][0] - round(140 / 60 * 7, 3)) < 1e-6
+                 and abs(st["torque_slope_ft_lb_per_psi"] - round(14360 / 1820, 3)) < 1e-9 and 4600 < h["torque_est_ft_lb"][0] < 4900,
+        "stall": len(st["stalls"]) == 1 and st["stalls"][0]["at"] == syn["stall_at"] and st["stalls"][0]["seconds"] == 20 and st["stalls"][0]["peak_psi"] == 1900
+                 and 0.0 < st["hours_above_max_operating"] <= 0.01 and st["diff_on_bottom_psi"]["p50"] == 600.0,
+        "tracking": trk["M100"]["totals"]["circulating_hours"] == 24.0 and len(trk["M100"]["runs"]) == 2 and trk["M100"]["life"]["status"] == "DUE"
+                    and trk["J2"]["life"]["status"] == "OK" and trk["J2"]["totals"]["revolutions"] == 0.0 and "life" not in trk["B1"],
+        "audit": [a["action"] for a in ws.audit_log(200)].count("drillstring.run.declare") == 2,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CI2 a run from the bit up: an unknown class, a service interval with no source, revolutions for a jar, a motor's own figures with "
+       "no spec sheet or a malformed lobe count, an empty string, an unknown well and a run that ends before it starts refused; over a "
+       "labelled synthetic run the circulating hours, the gallons, the footage and the motor's revolutions equal the hand sums, its no-load "
+       "speed is revolutions per gallon times the flow and the bit's the rotary's plus that, the whirl seven times the rotor's turning, the "
+       "torque estimated from the maker's slope, the one stall found at its second; a motor followed across two runs to its interval"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    stab = tr["stability"]
+    tq_rows = [b["torque"] for b in stab["blocks"]]
+    n = 8 * 7200
+    tt = np.arange(n, dtype=float)
+    rng = np.random.default_rng(3)
+    moved = DS._stability(tt, np.ones(n, bool), 9.0 + 0.6 * np.where(tt < n / 2, np.sin(2 * np.pi * 0.10 * tt), np.sin(2 * np.pi * 0.20 * tt)) + rng.normal(0, 0.05, n),
+                          None, datetime(2026, 1, 1))
+    walk = DS._stability(tt, np.ones(n, bool), 9.0 + np.cumsum(rng.normal(0, 0.02, n)), None, datetime(2026, 1, 1))
+    short = DS._stability(tt[:3 * 3600], np.ones(3 * 3600, bool), 9.0 + rng.normal(0, 0.05, 3 * 3600), None, datetime(2026, 1, 1))
+    c3 = {
+        "grows": stab["verdict"]["status"] == "CHANGED" and stab["verdict"]["changed"] == ["surface torque oscillation"] and len(stab["blocks"]) == 8
+                 and all(abs(r["f_hz"] - 0.1016) < 0.002 for r in tq_rows) and 3.5 < tq_rows[-1]["index"] / tq_rows[0]["index"] < 4.5
+                 and abs(tq_rows[0]["index"] - 0.25 / np.sqrt(2) / 9.0) < 0.003,
+        "moves": moved["verdict"]["status"] == "CHANGED" and "surface torque frequency" in moved["verdict"]["changed"]
+                 and abs(moved["blocks"][0]["torque"]["f_hz"] - 0.1016) < 0.002 and abs(moved["blocks"][-1]["torque"]["f_hz"] - 0.20) < 0.004,
+        "red_noise": sum(1 for b in walk["blocks"] if b["torque"]["f_hz"]) <= 1,
+        "short": short["verdict"]["status"] == "TOO FEW BLOCKS",
+    }
+    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_g, pg = call(V, "GET", "/api/drillstring?well=" + w["id"])
+        s_m, mm = call(V, "GET", "/api/tools/motors")
+        s_vp, _ = call(V, "POST", "/api/drillstring/run", {"well_id": w["id"], "name": "x", "components": comps})
+        s_op, rr = call(O, "POST", "/api/drillstring/run", {"well_id": w["id"], "name": "Run 3", "components": comps[:1]})
+        s_bad, _ = call(O, "POST", "/api/drillstring/run", {"well_id": w["id"], "name": "x", "components": [{"class_id": "packer"}]})
+        s_nw, _ = call(O, "POST", "/api/drillstring/run", {"well_id": "nope", "name": "x", "components": comps})
+        s_rm, _ = call(O, "POST", "/api/drillstring/remove", {"run_id": rr.get("id", "")})
+        s_rm2, _ = call(O, "POST", "/api/drillstring/remove", {"run_id": rr.get("id", "")})
+        s_uw, _ = call(V, "GET", "/api/drillstring?well=nope")
+        s_ac, _ = call(O, "POST", "/api/drillstring/nope", {})
+    finally:
+        svc.stop()
+    cli = _sp.run([sys.executable, "-m", "gea", "drillstring", "--workspace", wsp], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_m = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "motors"], capture_output=True, text=True, cwd=str(pkg.parent))
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c3.update({
+        "api": s_g == 200 and len(pg["runs"]) == 2 and pg["runs"][0]["track"]["usage"]["circulating_hours"] == 16.0 and s_m == 200 and len(mm["motors"]) == 41
+               and s_vp == 403 and s_op == 200 and s_bad == 400 and s_nw == 404 and s_rm == 200 and s_rm2 == 404 and s_uw == 404 and s_ac == 404,
+        "cli": cli.returncode == 0 and "stability: CHANGED" in cli.stdout and "DUE: Positive displacement mud motor" in cli.stdout
+               and cli_m.returncode == 0 and "msd-6-3-4-78-6.4" in cli_m.stdout,
+        "page": all(x in page_src for x in ("VIEWS.drillstring", "['#/drillstring', 'Drill string']", "dsDiagram", "Declare a run", "Oscillation index, block by block",
+                                             "Distinct oscillation frequency", "id=\"mtCard\"", "/api/tools/motors", "Every component, across every run")),
+        "help": any(t[0] == "drillstring" for t in H.INDEX) and not H.check("drillstring") and H.VIEW_TOPIC.get("drillstring") == "drillstring",
+    })
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CI3 the stability: a torque oscillation at 0.10 Hz growing fourfold found as a change at its frequency and amplitude, one that moves "
+       "from 0.10 to 0.20 Hz found as moved, red noise rising to the band's edge not called a peak, a short record too few blocks to "
+       "compare; the API (a viewer reads, only an operator declares; a bad class, an unknown well, a second removal and an unknown action "
+       "named), the CLI, the Drill String tab with its build diagram, the motor table on the Tools tab, and 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:
@@ -9225,6 +9535,8 @@ def main() -> int:
         section_ce_well3d(tmp)
         section_cf_economics(tmp)
         section_cg_well_report(tmp)
+        section_ch_simulation(tmp)
+        section_ci_drill_string(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: