gea-program 0.30.0__tar.gz → 0.31.0__tar.gz

{gea_program-0.30.0/gea_program.egg-info → gea_program-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.30.0
+Version: 0.31.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 (376 checks)
+gea accept                     # the product gate (380 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]")
@@ -650,8 +650,26 @@ itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 
 ### Tools and ports
 
-The Tools & ports tab (`#/tools`, `gea tools`) is the program's two
-registers in one place: the tool library - every downhole and surface tool
+The Tools & ports tab (`#/tools`, `gea tools`) opens on the **downhole tool
+library**: every class of downhole tool in use across the industry - bits
+and hole openers, motors and rotary steerable systems, MWD and LWD, the drill
+string and its subs, casing and cementing equipment, completion and
+artificial lift, wireline and cased-hole tools, fishing and milling, test
+tools - ninety-six classes in nine categories. Point at a tool, or Tab to
+it, for a one-line description; click, tap or press Enter for its tutorial:
+what it is, where it runs, how it works, what it shows in the data, what to
+watch, and what this program does with it, with the published figures
+quoted from the pages they cite and the pages themselves. The tutorials
+carry no numbers of their own; a figure on a tool's card is the cited page's
+words, most often one maker's product, never a limit for the class. Your
+**fleet** - the tools you actually run - goes in beside the classes, each
+with its maker, model, serial and the datasheet that rates it
+(`gea tools --action fleet-add --workspace C:\site --class pdm_motor
+--maker ... --model ... --datasheet ...`, or from the tutorial), kept in the
+workspace and audited. `gea tools --action classes`, `--action tutorial
+--class drilling_jar`.
+
+Below it are the program's two registers: the gauge library - every gauge
 with its source citation, ratings, what it measures, the telemetry interface
 it declares and its datasheet aging rate where the vendor published one -
 and the ports, the file formats read and the eleven live protocols spoken,
@@ -730,8 +748,14 @@ on bottom and rotating, the rate of penetration on bottom, the connections,
 the peaks; for the well, total depth and when the bit was first on bottom
 there, the recorder's TVD at it; per channel what was missing and how
 often; and the **MD-TVD table**, hole depth against the recorder's
-interpolated TVD, labelled an interpolation and not a survey. A recorder
-that resets its hole depth at a restart is named, not corrected. `gea edr
+interpolated TVD, labelled an interpolation and not a survey. Before any
+footage is counted the hole depth is read for what it can be trusted for:
+a depth carried over from the last well, a depth set back and counted up
+again by running pipe, a sidetrack, an overstated or understated depth
+corrected - each named as a depth event in the record and on the well
+page, and handled so that total depth is the final borehole's and the
+footage adds up. The recorder's gamma is written as a LAS log by bit
+depth. `gea edr
 --file C:\site\_incoming\30636033.csv`; `gea workspace --action add-file`
 then `refresh` for the record beside the well's other reports. `gea help
 edr`.

{gea_program-0.30.0 → gea_program-0.31.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 (376 checks)
+gea accept                     # the product gate (380 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]")
@@ -611,8 +611,26 @@ itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 
 ### Tools and ports
 
-The Tools & ports tab (`#/tools`, `gea tools`) is the program's two
-registers in one place: the tool library - every downhole and surface tool
+The Tools & ports tab (`#/tools`, `gea tools`) opens on the **downhole tool
+library**: every class of downhole tool in use across the industry - bits
+and hole openers, motors and rotary steerable systems, MWD and LWD, the drill
+string and its subs, casing and cementing equipment, completion and
+artificial lift, wireline and cased-hole tools, fishing and milling, test
+tools - ninety-six classes in nine categories. Point at a tool, or Tab to
+it, for a one-line description; click, tap or press Enter for its tutorial:
+what it is, where it runs, how it works, what it shows in the data, what to
+watch, and what this program does with it, with the published figures
+quoted from the pages they cite and the pages themselves. The tutorials
+carry no numbers of their own; a figure on a tool's card is the cited page's
+words, most often one maker's product, never a limit for the class. Your
+**fleet** - the tools you actually run - goes in beside the classes, each
+with its maker, model, serial and the datasheet that rates it
+(`gea tools --action fleet-add --workspace C:\site --class pdm_motor
+--maker ... --model ... --datasheet ...`, or from the tutorial), kept in the
+workspace and audited. `gea tools --action classes`, `--action tutorial
+--class drilling_jar`.
+
+Below it are the program's two registers: the gauge library - every gauge
 with its source citation, ratings, what it measures, the telemetry interface
 it declares and its datasheet aging rate where the vendor published one -
 and the ports, the file formats read and the eleven live protocols spoken,
@@ -691,8 +709,14 @@ on bottom and rotating, the rate of penetration on bottom, the connections,
 the peaks; for the well, total depth and when the bit was first on bottom
 there, the recorder's TVD at it; per channel what was missing and how
 often; and the **MD-TVD table**, hole depth against the recorder's
-interpolated TVD, labelled an interpolation and not a survey. A recorder
-that resets its hole depth at a restart is named, not corrected. `gea edr
+interpolated TVD, labelled an interpolation and not a survey. Before any
+footage is counted the hole depth is read for what it can be trusted for:
+a depth carried over from the last well, a depth set back and counted up
+again by running pipe, a sidetrack, an overstated or understated depth
+corrected - each named as a depth event in the record and on the well
+page, and handled so that total depth is the final borehole's and the
+footage adds up. The recorder's gamma is written as a LAS log by bit
+depth. `gea edr
 --file C:\site\_incoming\30636033.csv`; `gea workspace --action add-file`
 then `refresh` for the record beside the well's other reports. `gea help
 edr`.

{gea_program-0.30.0 → gea_program-0.31.0}/gea/__init__.py

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

{gea_program-0.30.0 → gea_program-0.31.0}/gea/__main__.py

@@ -285,6 +285,17 @@ 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("--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")
+    p_tl.add_argument("--workspace", type=str, default=None, help="fleet actions: the workspace folder")
+    p_tl.add_argument("--maker", type=str, default=""); p_tl.add_argument("--model", type=str, default="")
+    p_tl.add_argument("--datasheet", type=str, default="", help="fleet-add: the datasheet that rates the tool - title and revision, or its URL (required)")
+    p_tl.add_argument("--serial", type=str, default=""); p_tl.add_argument("--od-in", type=float, default=None); p_tl.add_argument("--note", type=str, default="")
+    p_tl.add_argument("--id", type=str, default=None, help="fleet-remove: the fleet tool id (gea tools --action fleet lists them)")
+    p_tl.add_argument("--actor", type=str, default="cli")
     p_cc = sub.add_parser("comcat", help="USGS ComCat / any FDSN event service: --lat --lon --radius-km --start --end prints the text-format query to open; --file reads the export it returns")
     p_cc.add_argument("--lat", type=float, default=None); p_cc.add_argument("--lon", type=float, default=None); p_cc.add_argument("--radius-km", type=float, default=25.0)
     p_cc.add_argument("--start", type=str, default=None); p_cc.add_argument("--end", type=str, default=None); p_cc.add_argument("--min-mag", type=float, default=1.0)
@@ -2374,6 +2385,71 @@ def main(argv=None) -> int:
     elif a.cmd == "tools":
         import json as _json
         from . import tool_catalog as _TC
+        if a.action:
+            from . import tool_taxonomy as _TX
+            from .cli import _safe_stdout
+            _safe_stdout()                                  # the cited figures carry fractions and degree signs
+            if a.action == "classes":
+                cs = _TX.classes(a.category, a.find)
+                if a.category and a.category not in _TX.CATEGORY_NAMES:
+                    raise SystemExit(f"tools: no category {a.category!r}; one of {', '.join(_TX.CATEGORY_NAMES)}")
+                if a.json:
+                    print(_json.dumps(cs, indent=1)); return 0
+                sm = _TX.summary()
+                print(f"{len(cs)} of {sm['classes']} tool classes; {sm['sources']} pages checked (fetched {sm['sources_fetched']}); {sm['figures']} published figures, each quoted from its page")
+                last = None
+                for t in cs:
+                    if t["category"] != last:
+                        print(f"\n{t['category_name']}"); last = t["category"]
+                    print(f"  {t['id']:<24s} {t['name']}")
+                    print(f"      {t['one_line']}")
+                print("\n`gea tools --action tutorial --class ID` opens one.")
+                return 0
+            if a.action == "tutorial":
+                if not a.class_id:
+                    raise SystemExit("tools: tutorial needs --class, e.g. --class pdm_motor (gea tools --action classes lists them)")
+                try:
+                    if a.json:
+                        print(_json.dumps(_TX.tool_class(a.class_id), indent=1)); return 0
+                    print(_TX.tutorial_text(a.class_id))
+                except KeyError as e:
+                    raise SystemExit(f"tools: {e.args[0]}")
+                return 0
+            if not a.workspace:
+                raise SystemExit(f"tools: --action {a.action} needs --workspace, e.g. --workspace C:\\site")
+            from .workspace import Workspace, WorkspaceError
+            try:
+                ws = Workspace(a.workspace)
+            except WorkspaceError as e:
+                raise SystemExit(f"tools: {e}")
+            if a.action == "fleet":
+                fl = _TX.fleet_list(ws.path)
+                if a.json:
+                    print(_json.dumps(fl, indent=1)); return 0
+                if not fl:
+                    print("the fleet is empty: gea tools --action fleet-add --workspace ... --class pdm_motor --maker ... --model ... --datasheet ...")
+                for t in fl:
+                    print(f"{t['id']:<32s} {t['class_name']}  -  {t['maker']} {t['model']}" + (f" s/n {t['serial']}" if t['serial'] else '') + (f", {t['od_in']:g} in OD" if t['od_in'] else ''))
+                    print(f"      datasheet: {t['datasheet']}")
+                return 0
+            if a.action == "fleet-add":
+                try:
+                    rec = _TX.fleet_add(ws.path, a.class_id or "", a.maker, a.model, a.datasheet, serial=a.serial, od_in=a.od_in, note=a.note, actor=a.actor)
+                except ValueError as e:
+                    raise SystemExit(f"tools: {e}")
+                ws.audit(a.actor, 'fleet.add', {'id': rec['id'], 'class': rec['class_id'], 'datasheet': rec['datasheet']})
+                print(f"added {rec['id']}: {rec['maker']} {rec['model']} ({rec['class_name']}); datasheet {rec['datasheet']}")
+                return 0
+            if a.action == "fleet-remove":
+                if not a.id:
+                    raise SystemExit("tools: fleet-remove needs --id (gea tools --action fleet lists them)")
+                try:
+                    rec = _TX.fleet_remove(ws.path, a.id)
+                except ValueError as e:
+                    raise SystemExit(f"tools: {e}")
+                ws.audit(a.actor, 'fleet.remove', {'id': rec['id'], 'class': rec['class_id']})
+                print(f"removed {rec['id']}")
+                return 0
         if a.rating or a.station:
             stations = []
             for spec in (a.station or []):

{gea_program-0.30.0 → gea_program-0.31.0}/gea/acceptance_tests.py

@@ -7697,10 +7697,11 @@ def section_by_edr(tmp: str) -> None:
         "sections": rec["n_sections"] == 3 and all(x["rows"] == 3000 and x["hours"] == 0.83 for x in secs) and secs[0]["gap_before_hours"] is None
                     and secs[1]["gap_before_hours"] == 48.0 and secs[2]["gap_before_hours"] == 48.0 and all(x["connections"] == 25 for x in secs)
                     and all(x["rop_on_bottom_mean_ft_h"] == 600.0 and x["on_bottom_hours"] == 0.69 and x["rotating_hours"] == 0.69 for x in secs)
-                    and secs[0]["hole_depth_at_start_ft"] == 1500.2 and abs(secs[0]["feet_drilled"] - 416.5) < 0.2 and secs[0]["feet_by_increments"] == secs[0]["feet_drilled"]
-                    and "hole_depth_drops" not in secs[0] and secs[0]["wob_max_klbf"] == 20.0 and secs[0]["rpm_max"] == 60.0,
+                    and secs[0]["hole_depth_at_start_ft"] == 1500.2 and abs(secs[0]["feet_drilled"] - 416.5) < 0.2 and "depth_events" not in secs[0]
+                    and secs[1]["hole_depth_at_start_ft"] == 1916.7 and secs[0]["wob_max_klbf"] == 20.0 and secs[0]["rpm_max"] == 60.0,
         "well": rec["total_depth_md_ft"] == 2750.0 and rec["tvd_at_td_ft"] == 2015.0 and rec["on_bottom_hours"] == 2.08 and abs(rec["feet_drilled"] - 1249.8) < 0.2
-                and rec["feet_by_increments"] == rec["feet_drilled"] and not rec["notes"]
+                and rec["depth_events"] == [] and rec["excluded_hours"] == 0.0 and rec["flag_idle_hours"] == 0.0 and not rec["notes"]
+                and rec["first_hole_depth_ft"] == 1500.2 and [b["status"] for b in rec["boreholes"]] == ["FINAL"]
                 and abs(rec["feet_per_on_bottom_hour"] - 600.9) < 0.2 and rec["hours_recorded"] == 2.5 and rec["span_days"] == 4.1 and rec["reached_td"].startswith("2026-06-05T02:29"),
         "md_tvd": rec["md_tvd"]["status"] == "OK" and rec["md_tvd"]["n"] == 13 and rec["md_tvd"]["tvd_decreasing_steps"] == 0 and rec["md_tvd"]["samples_without_tvd"] == 900
                   and "not a survey" in rec["md_tvd"]["source"] and rec["lateral"]["lateral_start_md_ft"] == 1999.8 and abs(rec["lateral"]["lateral_length_ft"] - 750.2) < 0.2
@@ -7716,6 +7717,27 @@ def section_by_edr(tmp: str) -> None:
         "registry": PORT_REGISTRY["edr"].status == "IMPLEMENTED" and read_any(r["path"]).source_format == "edr"
                     and any(p["name"] == "edr" and p["status"] == "IMPLEMENTED" for p in TC.catalog()["ports"]["files"]),
     }
+    # the depth events: a stale opening, a re-reference, a sidetrack and a correction, each named and handled
+    ev = E.selftest_events(str(d)); er = ev["record"]
+    types = [(e["type"], e["from_ft"], e["to_ft"]) for e in er["depth_events"]]
+    bh = er["boreholes"]
+    c4 = {}
+    c4["events"] = (types == [("STALE OPENING", 9999.0, 5200.2), ("RE-REFERENCE", 5400.0, 2000.0), ("SIDETRACK", 5500.0, 4800.0), ("CORRECTION", 5700.0, 5650.2)]
+                    and er["total_depth_md_ft"] == 5750.0 and abs(er["feet_drilled"] - 1449.8) < 0.2 and er["first_hole_depth_ft"] == 5000.2
+                    and len(bh) == 2 and bh[0]["status"].startswith("ABANDONED") and bh[0]["deepest_ft"] == 5500.0 and bh[1]["status"] == "FINAL" and bh[1]["from_ft"] == 4800.0
+                    and er["on_bottom_hours"] == 8.45 and er["on_bottom_flag_hours"] == 9.39 and er["excluded_hours"] == 1.03
+                    and any("largest value is 9,999.0 ft" in x for x in er["notes"])
+                    and er["gamma"]["status"] == "OK" and er["gamma"]["bins"] == 951 and er["gamma"]["depth_from_ft"] == 4800.0 and er["gamma"]["depth_to_ft"] == 5750.0
+                    and len(ev["gamma"].index) == 951 and bool(np.all(ev["gamma"].channels["GR"].values == 110.0))
+                    and er["md_tvd"]["n"] == 10 and any(l.startswith("Depth event, SIDETRACK") and "abandoned" in l for l in er["lines"])
+                    and any(l.startswith("Boreholes:") for l in er["lines"]))
+    fl = E.selftest_flag(str(d))["record"]
+    c4["flag_and_corrections"] = ([(e["type"], e["from_ft"], e["to_ft"]) for e in fl["depth_events"]] == [("CORRECTION", 1060.0, 1080.0), ("CORRECTION", 1140.0, 1128.0), ("CORRECTION", 1128.0, 1140.0),
+                                                                                                      ("STALE OPENING", 9999.0, None), ("STALE OPENING", 9999.0, None), ("STALE OPENING", 9999.0, 1200.1)]
+                                  and fl["total_depth_md_ft"] == 1230.0 and fl["first_hole_depth_ft"] == 1000.1 and abs(fl["feet_drilled"] - 229.9) < 0.05
+                                  and fl["on_bottom_hours"] == 0.58 and fl["flag_idle_hours"] == 0.56 and fl["excluded_hours"] == 0.18 and fl["on_bottom_flag_hours"] == 1.14
+                                  and [x.get("hole_depth_at_start_ft") for x in fl["sections"]] == [1000.1, 1128.0, None, None, 1200.0] and len(fl["boreholes"]) == 1
+                                  and any("nothing drilled" in l for l in fl["lines"]))
     odd = str(d / "odd.csv")
     with open(r["path"], encoding="utf-8") as f, open(odd, "w", encoding="utf-8") as g:
         for i, line in enumerate(f):
@@ -7820,6 +7842,168 @@ def section_by_edr(tmp: str) -> None:
        "written gamma LAS converts its feet once, says so, recognizes the gamma and says what it lacks; the help page and its index entry"
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
+    c4["help"] = all(t in help_md for t in ("STALE OPENING", "RE-REFERENCE", "SIDETRACK", "CORRECTION", "UNRESOLVED")) and "daily drilling report" in help_md \
+        and "nothing drilled" in help_md and "total depth less the first depth" in help_md
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "BY4 the depth events: a section opening on another well's depth (STALE OPENING, excluded), a depth set back and regained by counting pipe at 3,600 "
+       "ft/h (RE-REFERENCE, excluded), a 700 ft set-back time-drilled at 5 ft/h (SIDETRACK: total depth 5,750 ft from the final borehole, 1,449.8 ft drilled "
+       "counting the abandoned 4,800-5,500 ft, the gamma log and TVD table kept off the abandoned hole) and a 50 ft overstated depth (CORRECTION) each named; "
+       "a 20 ft set-forward off bottom added, a 12 ft fall regained only in the next section a correction and never a re-reference, the next section drilling "
+       "on from its opening depth not a stale opening, three restarts on another well's depth each a stale opening (judged against the last depth the file can "
+       "be trusted for), and 2,000 s of on-bottom flag with nothing drilled kept out of the drilling hours - footage exactly total depth less the first depth "
+       "(229.9 ft); the help page names every event"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
+
+def section_bz_tool_library(tmp: str) -> None:
+    """Section BZ - the downhole tool library: every class of downhole tool in use across the industry, a one-line
+    description on hover and a tutorial that opens on a click, the published figures quoted from the pages they cite and
+    nothing more, and the operator's own fleet tied to the classes and to the datasheets that rate them."""
+    import http.cookiejar
+    import re as _re
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    from urllib.parse import urlparse
+    from . import tool_taxonomy as TX
+    from . import helplib as H
+    from .client_reports import FORBIDDEN_TERMS
+    from .tool_library import TOOL_LIBRARY
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bz"); d.mkdir()
+
+    def _raises(fn, exc, words=""):
+        try:
+            fn()
+        except exc as e:
+            return words in str(e)
+        return False
+
+    sm = TX.summary()
+    cls = list(TX.TAXONOMY.values())
+    prose = lambda t: " ".join([t["one_line"]] + [t["tutorial"][p] for p in TX.PARTS])
+    lowtier = _re.compile(r"(wikipedia\.org|rigzone\.com|drillingmanual\.com|petroleumacronyms|turbodrill\.com)$")
+    figs = [f for t in cls for f in t["figures"]]
+    c1 = {
+        "breadth": sm["classes"] >= 90 and len(sm["categories"]) == 9 and all(c["classes"] >= 1 for c in sm["categories"])
+                   and {"pdm_motor", "rss_push", "mwd_mud_pulse", "lwd_gamma", "drilling_jar", "production_packer", "esp", "perforating_gun",
+                        "pdg", "wl_formation_tester", "cbl", "overshot", "dst"} <= set(TX.TAXONOMY),
+        "hover": all(0 < len(t["one_line"]) <= 140 for t in cls),
+        "tutorial": all(all(len(t["tutorial"][p]) > 20 for p in TX.PARTS) for t in cls) and TX.PARTS == ("what", "where", "how", "reads", "watch", "program"),
+        "no_numbers_in_prose": not any(_re.search(r"\d", prose(t)) for t in cls),
+        "words": not any(w in (t["name"] + " " + prose(t)).lower() for t in cls for w in FORBIDDEN_TERMS),
+        "sources": all(t["sources"] for t in cls) and all(urlparse(x["url"]).scheme == "https" and x.get("publisher") for t in cls for x in t["sources"])
+                   and not any(lowtier.search(urlparse(x["url"]).netloc.lower()) for t in cls for x in t["sources"])
+                   and (pkg / "reference" / "tool_sources.json").is_file() and sm["sources"] >= 150 and sm["sources_fetched"] == "2026-10-14",
+        "figures": len(figs) == sm["figures"] and len(figs) >= 150 and all(f.get("quote") and f.get("url") and f.get("publisher") and f.get("what") for f in figs)
+                   and not any("..." in f["quote"] for f in figs)
+                   and all(("not a limit for the class" in t["figures_note"]) if t["figures"] else ("supply your model's datasheet" in t["figures_note"]) for t in cls),
+        "lookup": [t["id"] for t in TX.classes("drive")][:1] == ["pdm_motor"] and {t["id"] for t in TX.classes(None, "packer")} >= {"production_packer"}
+                  and TX.classes(None, "no such tool zzz") == [],
+        "unknown": _raises(lambda: TX.tool_class("no_such_tool"), KeyError),
+        "text": all(TX.PART_TITLES[p] + ": " in TX.tutorial_text("pdm_motor") for p in TX.PARTS) and "Sources (fetched 2026-10-14)" in TX.tutorial_text("pdm_motor")
+                and "Published figures (" in TX.tutorial_text("agitator") and "8-12 Hz" in TX.tutorial_text("agitator"),
+        "gauges": all(TX.GAUGE_CLASS_TO_TAXONOMY.get(t.tool_class) in TX.TAXONOMY for t in TOOL_LIBRARY.values()),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "BZ1 the downhole tool library: at least ninety classes in nine categories from bits to test tools, each with a one-line description for the hover "
+       "and a six-part tutorial for the pop-open; the prose carries no number at all and none of the words a client report may not; every class checked "
+       "against at least one public page (none of them an encyclopaedia or a re-publisher); every published figure is the cited page's own words with its "
+       "unit and page, never a limit for the class, and a class with none says to supply the datasheet; the classes searchable; an unknown class named; "
+       "every gauge in the gauge library opens its class's tutorial"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    wsp = str(d / "ws"); Workspace.create(wsp, "Pad 3", actor="tester")
+    e_ds = _raises(lambda: TX.fleet_add(wsp, "pdm_motor", "Acme", "M1", ""), ValueError, "datasheet")
+    e_cls = _raises(lambda: TX.fleet_add(wsp, "warp_drive", "Acme", "M1", "sheet"), ValueError, "no tool class")
+    r1 = TX.fleet_add(wsp, "pdm_motor", "Acme", "M1", "Acme M1 datasheet rev B", serial="A100", od_in=6.75)
+    e_dup = _raises(lambda: TX.fleet_add(wsp, "pdm_motor", "Acme", "M1", "Acme M1 datasheet rev B", serial="A100"), ValueError, "already")
+    users = Users(str(Path(wsp, "users.json"))); users.add("op", "operator-pass-1", "operator"); users.add("v", "viewer-pass-1", "viewer")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def session():
+        o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+        def call(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))
+            req.add_header("Content-Type", "application/json"); req.add_header("X-GEA-Action", "1")
+            try:
+                with o.open(req, timeout=60) as rr_:
+                    return rr_.status, json.loads(rr_.read())
+            except urllib.error.HTTPError as e:
+                return e.code, json.loads(e.read())
+        return call
+    try:
+        view, op = session(), session()
+        view("POST", "/api/login", {"name": "v", "password": "viewer-pass-1"}); op("POST", "/api/login", {"name": "op", "password": "operator-pass-1"})
+        st_t, tx = view("GET", "/api/tools/taxonomy")
+        st_q, txq = view("GET", "/api/tools/taxonomy?q=jar")
+        st_v, _ = view("POST", "/api/tools/fleet", {"class_id": "esp", "maker": "Acme", "model": "P2", "datasheet": "Acme P2 sheet"})
+        st_nods, nods = op("POST", "/api/tools/fleet", {"class_id": "esp", "maker": "Acme", "model": "P2", "datasheet": ""})
+        st_add, added = op("POST", "/api/tools/fleet", {"class_id": "esp", "maker": "Acme", "model": "P2", "datasheet": "Acme P2 sheet rev A", "od_in": "5.38"})
+        st_fl, fl = view("GET", "/api/tools/fleet")
+        st_rm, _ = op("POST", f"/api/tools/fleet/{r1['id']}/remove", {})
+        st_rm2, _ = op("POST", "/api/tools/fleet/nothing-here/remove", {})
+    finally:
+        svc.stop()
+    audit = Path(wsp, "records", "audit.jsonl").read_text(encoding="utf-8")
+    c2 = {
+        "fleet_rules": e_ds and e_cls and e_dup and r1["id"] == "acme-m1-a100" and r1["class_name"] == TX.TAXONOMY["pdm_motor"]["name"] and r1["od_in"] == 6.75
+                       and Path(wsp, "config", "fleet.json").is_file(),
+        "api": st_t == 200 and len(tx["classes"]) == sm["classes"] and [p[0] for p in tx["parts"]] == list(TX.PARTS) and tx["summary"]["figures"] == sm["figures"]
+               and st_q == 200 and {c["id"] for c in txq["classes"]} >= {"drilling_jar", "jar_accelerator"} and len(txq["classes"]) < 10
+               and tx["fleet"] and tx["fleet"][0]["id"] == "acme-m1-a100",
+        "roles": st_v == 403 and st_nods == 400 and "datasheet" in nods.get("error", "") and st_add == 200 and added["od_in"] == 5.38
+                 and st_fl == 200 and {t["id"] for t in fl["tools"]} == {"acme-m1-a100", "acme-p2"} and st_rm == 200 and st_rm2 == 404
+                 and [t["id"] for t in TX.fleet_list(wsp)] == ["acme-p2"],
+        "audit": '"fleet.add"' in audit and '"fleet.remove"' in audit and "Acme P2 sheet rev A" in audit,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "BZ2 the fleet: a tool of yours needs its class and its datasheet citation, and is not added twice; it is kept in the workspace's config; the API "
+       "serves the classes, the tutorial parts and the fleet to any signed-in user, adds and removes for an operator and not a viewer, says why an "
+       "addition without a datasheet is turned away, and every addition and removal is 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" / "tools.md").read_text(encoding="utf-8")
+    r_cls = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "classes"], capture_output=True, text=True)
+    r_cat = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "classes", "--category", "fishing"], capture_output=True, text=True)
+    r_tut = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "tutorial", "--class", "drilling_jar"], capture_output=True, text=True)
+    r_none = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "tutorial"], capture_output=True, text=True)
+    r_bad = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "tutorial", "--class", "warp_drive"], capture_output=True, text=True)
+    r_add = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "fleet-add", "--workspace", wsp, "--class", "drilling_jar", "--maker", "Acme",
+                     "--model", "J9", "--datasheet", "Acme J9 sheet rev C"], capture_output=True, text=True)
+    r_nods = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "fleet-add", "--workspace", wsp, "--class", "drilling_jar", "--maker", "Acme",
+                      "--model", "J10"], capture_output=True, text=True)
+    r_list = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "fleet", "--workspace", wsp], capture_output=True, text=True)
+    r_nows = _sp.run([sys.executable, "-m", "gea", "tools", "--action", "fleet"], capture_output=True, text=True)
+    c3 = {
+        "page": all(x in page_src for x in ("Downhole tool library", "class=\"tl-chip\"", 'role="tooltip"', "aria-haspopup=\"dialog\"", ".tl-chip:focus-visible .tl-tip",
+                                             "@media (hover:none)", "showModal()", "dialog.tl-dlg::backdrop", "/api/tools/taxonomy", "/api/tools/fleet", "Add one of yours",
+                                             "Your fleet", "tl-open", "Esc closes it")),
+        "cli": r_cls.returncode == 0 and f"{sm['classes']} of {sm['classes']} tool classes" in r_cls.stdout and "Fishing, milling and intervention" in r_cls.stdout
+               and r_cat.returncode == 0 and "overshot" in r_cat.stdout and "pdm_motor" not in r_cat.stdout
+               and r_tut.returncode == 0 and "What it is: " in r_tut.stdout and "In this program: " in r_tut.stdout
+               and r_none.returncode != 0 and "--class pdm_motor" in (r_none.stderr + r_none.stdout) and "<" not in (r_none.stderr + r_none.stdout)
+               and r_bad.returncode != 0 and "no tool class 'warp_drive'" in (r_bad.stderr + r_bad.stdout),
+        "cli_fleet": r_add.returncode == 0 and "added acme-j9" in r_add.stdout and r_nods.returncode != 0 and "datasheet" in (r_nods.stderr + r_nods.stdout)
+                     and r_list.returncode == 0 and "Acme J9 sheet rev C" in r_list.stdout and r_nows.returncode != 0 and "needs --workspace" in (r_nows.stderr + r_nows.stdout),
+        "help": not H.check("tools") and "tutorial" in help_md and "fleet" in help_md and "the tutorials carry no numbers at all" in help_md.split("will not call a measurement")[1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "BZ3 the page and the command line: a chip per class that shows its description on hover and on keyboard focus (not on a touch screen, where a tap "
+       "opens it), a tutorial dialog that opens on click, tap or Enter and closes on Esc or the backdrop, a find box and a category filter, the fleet card, "
+       "the gauge library's Tutorial buttons; `gea tools --action classes | tutorial | fleet | fleet-add`, each refusing a missing argument by name without "
+       "a placeholder; the help page"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
 def main() -> int:
     print("GEA-Program - ACCEPTANCE SUITE (the product gate)")
@@ -7901,6 +8085,7 @@ def main() -> int:
         section_bw_catalog_map(tmp)
         section_bx_pasteable(tmp)
         section_by_edr(tmp)
+        section_bz_tool_library(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: