gea-program 0.13.0__tar.gz → 0.15.0__tar.gz

{gea_program-0.13.0 → gea_program-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.13.0
+Version: 0.15.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 (327 checks)
+gea accept                     # the product gate (333 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]")
@@ -602,6 +602,44 @@ It will not assume a sidetrack, invent an injection interval or a
 completion, or name a county. `gea ppdm --action parse --number ...` takes a
 number apart from the command line; `gea help ppdm`.
 
+### Machine vibration
+
+The pump's record read the way an operations engineer expects. `gea
+workspace --action vibration-report --well <id> --record pump.csv --vib-unit
+g --rpm 1780 --group 2 --support rigid --bearing 9,7.94,39.04` writes the
+broadband r.m.s. vibration velocity over 10-1000 Hz (2-1000 Hz below 600
+r/min), the quantity ISO 20816-1 defines, and the ISO 20816-3 zone for the
+declared machine group and support class with the boundaries printed; then
+the envelope spectrum of the most impulsive band (chosen by kurtosis, or
+declared) against the bearing's defect frequencies - BPFO, BPFI, BSF, FTF
+from its geometry and the shaft speed - each MATCHED at its fundamental or
+NOT MATCHED, the inner race with its sidebands. A record in counts needs a
+sensitivity; a rate that cannot carry 1000 Hz is PARTIAL BAND, never
+promoted; the group and the support are declarations; a matched frequency
+is not a fault size. CSV or miniSEED/SAC; `gea vibration` runs the labelled
+pump; `gea help vibration`.
+
+### Conformity, in the standards' words
+
+The drift report's "bias inside the instrument's class" is a statement of
+conformity, and ISO/IEC 17025:2017 7.8.6 says what one carries: the result it
+applies to, the specification, and the decision rule - which has to take
+the uncertainty into account. The report now states it that way: the tag's
+bias over the window with its sample count, the certificate's accuracy
+class as the tolerance limit, the bias's expanded uncertainty (k = 2) as the
+guard band, and the ILAC-G8:09/2019 non-binary rule - PASS, CONDITIONAL
+PASS, CONDITIONAL FAIL or FAIL, with the acceptance limit printed; without
+an uncertainty it falls back to simple acceptance and says so. The
+certificate register takes what 7.8.4 asks the paper to carry (the expanded
+uncertainty with k and probability, the traceability statement as worded,
+the conditions, the calibration date, the method, who authorised it) and
+`gea certificates --action conformance` prints each certificate against
+the fourteen items of 7.8.2.1 and 7.8.4.1 - CARRIED, NOT CARRIED, NOT
+RECORDED - with COMPLETE or INCOMPLETE and the missing clauses named. The
+well page's filing form takes the items and its table shows U (k) and the
+standing. `gea conformance --action decide` states one decision. `gea help
+conformance`.
+
 ### Audit / Update
 
 The Audit / Update tab holds three things. The whole audit log

{gea_program-0.13.0 → gea_program-0.15.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 (327 checks)
+gea accept                     # the product gate (333 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]")
@@ -563,6 +563,44 @@ It will not assume a sidetrack, invent an injection interval or a
 completion, or name a county. `gea ppdm --action parse --number ...` takes a
 number apart from the command line; `gea help ppdm`.
 
+### Machine vibration
+
+The pump's record read the way an operations engineer expects. `gea
+workspace --action vibration-report --well <id> --record pump.csv --vib-unit
+g --rpm 1780 --group 2 --support rigid --bearing 9,7.94,39.04` writes the
+broadband r.m.s. vibration velocity over 10-1000 Hz (2-1000 Hz below 600
+r/min), the quantity ISO 20816-1 defines, and the ISO 20816-3 zone for the
+declared machine group and support class with the boundaries printed; then
+the envelope spectrum of the most impulsive band (chosen by kurtosis, or
+declared) against the bearing's defect frequencies - BPFO, BPFI, BSF, FTF
+from its geometry and the shaft speed - each MATCHED at its fundamental or
+NOT MATCHED, the inner race with its sidebands. A record in counts needs a
+sensitivity; a rate that cannot carry 1000 Hz is PARTIAL BAND, never
+promoted; the group and the support are declarations; a matched frequency
+is not a fault size. CSV or miniSEED/SAC; `gea vibration` runs the labelled
+pump; `gea help vibration`.
+
+### Conformity, in the standards' words
+
+The drift report's "bias inside the instrument's class" is a statement of
+conformity, and ISO/IEC 17025:2017 7.8.6 says what one carries: the result it
+applies to, the specification, and the decision rule - which has to take
+the uncertainty into account. The report now states it that way: the tag's
+bias over the window with its sample count, the certificate's accuracy
+class as the tolerance limit, the bias's expanded uncertainty (k = 2) as the
+guard band, and the ILAC-G8:09/2019 non-binary rule - PASS, CONDITIONAL
+PASS, CONDITIONAL FAIL or FAIL, with the acceptance limit printed; without
+an uncertainty it falls back to simple acceptance and says so. The
+certificate register takes what 7.8.4 asks the paper to carry (the expanded
+uncertainty with k and probability, the traceability statement as worded,
+the conditions, the calibration date, the method, who authorised it) and
+`gea certificates --action conformance` prints each certificate against
+the fourteen items of 7.8.2.1 and 7.8.4.1 - CARRIED, NOT CARRIED, NOT
+RECORDED - with COMPLETE or INCOMPLETE and the missing clauses named. The
+well page's filing form takes the items and its table shows U (k) and the
+standing. `gea conformance --action decide` states one decision. `gea help
+conformance`.
+
 ### Audit / Update
 
 The Audit / Update tab holds three things. The whole audit log

{gea_program-0.13.0 → gea_program-0.15.0}/gea/__init__.py

@@ -122,7 +122,7 @@ from .profile_catalog import (
     read_pangaea_txt,
 )
 
-__version__ = "0.13.0"
+__version__ = "0.15.0"
 __all__ = [
     "aging_rate", "rate_psi_yr", "accuracy_psi",
     "Sensor", "SimulatorConfig", "DownholeEngine",

{gea_program-0.13.0 → gea_program-0.15.0}/gea/__main__.py

@@ -282,7 +282,7 @@ def main(argv=None) -> int:
                       choices=["init", "add-file", "add-catalog", "add-live", "remove", "list", "migrate", "refresh", "audit",
                                "add-seismic", "refresh-seismic", "remove-seismic", "sar-film", "refresh-all", "add-track", "refresh-track", "remove-track",
                                "seismic-dataset", "seismic-field", "add-site", "sites", "site-report", "remove-site", "rename",
-                               "set-well", "sra-define", "sra-report", "associate", "osdu-export", "quakeml-export", "well-identity"])
+                               "set-well", "sra-define", "sra-report", "associate", "osdu-export", "quakeml-export", "well-identity", "vibration-report"])
     p_ws.add_argument("--stations", type=str, nargs="+", default=None, help="add-track: two or more array station ids of this workspace")
     p_ws.add_argument("--site", type=str, default=None, help="site-report/remove-site: the site id")
     p_ws.add_argument("--api", type=str, default=None, help="set-well: the API number")
@@ -317,6 +317,15 @@ def main(argv=None) -> int:
     p_ws.add_argument("--operator-org", type=str, default="", help="osdu-export: the operator's Organisation record id on the platform")
     p_ws.add_argument("--out", type=str, default=None, help="osdu-export: the folder to write the manifest and files into; quakeml-export: the file to write")
     p_ws.add_argument("--agency", type=str, default="", help="quakeml-export: the agencyID written in creationInfo (default: the site's name)")
+    p_ws.add_argument("--record", type=str, default=None, help="vibration-report: the machine record (CSV with a timestamp or elapsed-seconds column, or miniSEED/SAC)")
+    p_ws.add_argument("--channel", type=str, default=None, help="vibration-report: the channel to assess (default: the first)")
+    p_ws.add_argument("--vib-unit", type=str, default="g", help="vibration-report: the channel's unit - g, m/s2, mm/s, in/s, or counts with --sensitivity")
+    p_ws.add_argument("--sensitivity", type=float, default=None, help="vibration-report: units per count, when the record is in counts")
+    p_ws.add_argument("--rpm", type=float, default=None, help="vibration-report: the shaft speed, r/min (declared)")
+    p_ws.add_argument("--group", type=int, choices=[1, 2], default=None, help="vibration-report: ISO 20816-3 machine group - 1 above 300 kW, 2 from 15 to 300 kW (declared)")
+    p_ws.add_argument("--support", type=str, choices=["rigid", "flexible"], default=None, help="vibration-report: the support class (declared)")
+    p_ws.add_argument("--bearing", type=str, default=None, help="vibration-report: elements,ball_mm,pitch_mm[,contact_deg] - the bearing geometry (declared)")
+    p_ws.add_argument("--demod-band", type=float, nargs=2, default=None, help="vibration-report: the demodulation band in Hz (default: chosen by kurtosis)")
     p_ws.add_argument("--depth-km", type=float, default=6.0, help="associate: the hypocentral depth the location is made under, km (declared)")
     p_ws.add_argument("--rms-tol", type=float, default=0.15, help="associate: the RMS residual an event must fit within, s")
     p_ws.add_argument("--wells", type=str, nargs="+", default=None, help="add-site: well ids of this workspace")
@@ -400,6 +409,26 @@ def main(argv=None) -> int:
 
     p_osdu = sub.add_parser("osdu", help="the OSDU-shaped export: the self-test on a labelled site")
     p_osdu.add_argument("--action", choices=["selftest"], default="selftest")
+    p_cf = sub.add_parser("conformance", help="ISO/IEC 17025 7.8 certificate items and the ILAC-G8 decision rules: the self-test, or one decision")
+    p_cf.add_argument("--action", choices=["selftest", "decide"], default="selftest")
+    p_cf.add_argument("--value", type=float, default=None, help="decide: the measured value (a deviation; the tolerance is symmetric)")
+    p_cf.add_argument("--tolerance", type=float, default=None, help="decide: the tolerance limit TL")
+    p_cf.add_argument("--uncertainty", type=float, default=None, help="decide: the expanded uncertainty U of the value (omit: simple acceptance)")
+    p_cf.add_argument("--k", type=float, default=2.0)
+    p_cf.add_argument("--rule", choices=["simple-acceptance", "binary-guard-band", "non-binary-guard-band"], default="non-binary-guard-band")
+    p_cf.add_argument("--unit", type=str, default="")
+    p_vib = sub.add_parser("vibration", help="machine vibration: ISO 20816-3 zone and bearing envelope analysis on a record, or the self-test")
+    p_vib.add_argument("--action", choices=["selftest", "assess"], default="selftest")
+    p_vib.add_argument("--record", type=str, default=None, help="assess: the record (CSV with a time column, or miniSEED/SAC)")
+    p_vib.add_argument("--channel", type=str, default=None)
+    p_vib.add_argument("--unit", type=str, default="g", help="g, m/s2, mm/s, in/s, or counts with --sensitivity")
+    p_vib.add_argument("--sensitivity", type=float, default=None)
+    p_vib.add_argument("--rpm", type=float, default=None)
+    p_vib.add_argument("--group", type=int, choices=[1, 2], default=None)
+    p_vib.add_argument("--support", type=str, choices=["rigid", "flexible"], default=None)
+    p_vib.add_argument("--bearing", type=str, default=None, help="elements,ball_mm,pitch_mm[,contact_deg]")
+    p_vib.add_argument("--demod-band", type=float, nargs=2, default=None)
+    p_vib.add_argument("--json", action="store_true")
     p_ppdm = sub.add_parser("ppdm", help="the well named as the US Well Number and PPDM name it: take a number apart, or run the self-test")
     p_ppdm.add_argument("--action", choices=["selftest", "parse"], default="selftest")
     p_ppdm.add_argument("--number", type=str, default=None, help="parse: a US Well Number (10, 12 or 14 digits, dashes optional)")
@@ -501,7 +530,7 @@ def main(argv=None) -> int:
 
     p_ce = sub.add_parser("certificates", help="calibration certificates per instrument: list, file one, status against today")
     p_ce.add_argument("--register", type=str, required=True, help="the well's certificates.jsonl")
-    p_ce.add_argument("--action", choices=["list", "add", "status"], default="list")
+    p_ce.add_argument("--action", choices=["list", "add", "status", "conformance"], default="list")
     p_ce.add_argument("--tag", type=str, default=None)
     p_ce.add_argument("--tags", type=str, default=None, help="comma-separated tags for --action status")
     p_ce.add_argument("--serial", type=str, default="")
@@ -515,6 +544,17 @@ def main(argv=None) -> int:
     p_ce.add_argument("--doc", type=str, default=None, help="the certificate file (hashed, not copied)")
     p_ce.add_argument("--note", type=str, default="")
     p_ce.add_argument("--actor", type=str, default="cli")
+    p_ce.add_argument("--calibrated", type=str, default="", help="ISO/IEC 17025 7.8.2.1 i: the date the calibration was performed")
+    p_ce.add_argument("--method", type=str, default="", help="7.8.2.1 f: the method used")
+    p_ce.add_argument("--authorised-by", type=str, default="", help="7.8.2.1 o: who authorised the certificate")
+    p_ce.add_argument("--uncertainty", type=float, default=None, help="7.8.4.1 a: the expanded uncertainty U, in --uncertainty-unit (default the result's unit)")
+    p_ce.add_argument("--uncertainty-unit", type=str, default="")
+    p_ce.add_argument("--k", type=float, default=None, help="7.8.4.1 a: the coverage factor U is stated at")
+    p_ce.add_argument("--probability", type=float, default=None, help="7.8.4.1 a: the coverage probability as a fraction (0.95)")
+    p_ce.add_argument("--conditions", type=str, default="", help="7.8.4.1 b: the conditions the calibration was made under")
+    p_ce.add_argument("--traceability", type=str, default="", help="7.8.4.1 c: the statement of metrological traceability, as the certificate words it")
+    p_ce.add_argument("--adjustment", type=str, default="", help="7.8.4.1 d: results before and after adjustment, if the certificate carries them")
+    p_ce.add_argument("--decision-rule", type=str, default="", help="7.8.6: the decision rule the certificate's conformity statement names, if any")
 
     p_tr = sub.add_parser("transient", help="shut-in detection and build-up analysis (Horner + Bourdet derivative with a bootstrap band)")
     p_tr.add_argument("--file", type=str, required=True, help="historian file")
@@ -752,7 +792,10 @@ def main(argv=None) -> int:
         if a.action == "add":
             try:
                 print(_json.dumps(reg.add(a.tag or "", a.serial, a.certificate, a.issued or "", a.valid_until or "", a.actor, a.lab,
-                                          a.accuracy_pct_fs, a.full_scale, a.unit, a.doc, a.note), indent=1))
+                                          a.accuracy_pct_fs, a.full_scale, a.unit, a.doc, a.note,
+                                          calibrated_utc=a.calibrated, method=a.method, authorised_by=a.authorised_by, uncertainty=a.uncertainty,
+                                          uncertainty_unit=a.uncertainty_unit, uncertainty_k=a.k, uncertainty_probability=a.probability,
+                                          conditions=a.conditions, traceability=a.traceability, adjustment=a.adjustment, decision_rule=a.decision_rule), indent=1))
             except (ValueError, TypeError) as e:
                 raise SystemExit(f"certificates: {e}")
             return 0
@@ -763,6 +806,13 @@ def main(argv=None) -> int:
                 print(f"{r['tag_id']:24s} {r['status']:9s} {r.get('certificate_id') or '-':16s} until {r.get('valid_until_utc') or '-'}  {('' if r['days_left'] is None else str(r['days_left']) + ' d')}")
             print(_json.dumps(CertificateRegister.summary(rows)))
             return 0 if CertificateRegister.summary(rows)['all_valid'] else 1
+        if a.action == "conformance":
+            from .conformance import report_lines
+            c = reg.conformance()
+            for r in c["rows"]:
+                print("\n".join(report_lines(r)))
+            print(f"certificates: {c['n']} filed, {c['complete']} COMPLETE against ISO/IEC 17025:2017 7.8" + (f"; incomplete: {', '.join(c['incomplete'])}" if c['incomplete'] else ''))
+            return 0 if not c["incomplete"] else 1
         for e in reg.list():
             print(f"{e['tag_id']:24s} {e['serial']:12s} {e['certificate_id']:16s} {e['issued_utc'][:10]} to {e['valid_until_utc'][:10]}  ±{e.get('accuracy_pct_fs') or '-'} % FS  {e.get('lab', '')}")
         print(f"certificates: {len(reg.list())} filed")
@@ -1503,6 +1553,52 @@ def main(argv=None) -> int:
             return 0
         print(f"notifications: {'configured' if n.cfg else 'not configured'}" + (f" - {len(n.cfg['channels'])} channel(s), {len(n.cfg['rules'])} rule(s), quiet {n.cfg['quiet_s']} s" if n.cfg else " (gea notify --example)"))
         return 0
+    elif a.cmd == "conformance":
+        from . import conformance as _C
+        if a.action == "decide":
+            if a.value is None or a.tolerance is None:
+                raise SystemExit("conformance --action decide needs --value and --tolerance")
+            d = _C.decide(a.value, a.tolerance, a.uncertainty, rule=a.rule, k=a.k if a.uncertainty is not None else None,
+                          probability=(0.95 if abs(a.k - 2.0) < 1e-9 else None) if a.uncertainty is not None else None, unit=a.unit)
+            print(d["statement"]); print(f"  {d['rule_text']}")
+            return 0 if d["outcome"] in ("PASS", "CONDITIONAL PASS") else 1
+        r = _C.selftest()
+        print(f"conformance selftest [{r['label']}]: {r['status']}")
+        for k, v in r["checks"].items():
+            print(f"  {'ok ' if v else 'BAD'} {k}")
+        print("\n".join(_C.report_lines(r["full"])))
+        for d in r["decisions"]:
+            print("  " + d["statement"])
+        return 0 if r["status"] == "OK" else 1
+    elif a.cmd == "vibration":
+        from . import vibration as _V
+        if a.action == "assess":
+            if not a.record:
+                raise SystemExit("vibration --action assess needs --record")
+            brg = None
+            if a.bearing:
+                parts = [float(x) for x in a.bearing.split(",")]
+                if len(parts) not in (3, 4):
+                    raise SystemExit("--bearing is elements,ball_mm,pitch_mm[,contact_deg]")
+                brg = {"n_elements": int(parts[0]), "d_mm": parts[1], "D_mm": parts[2], "contact_deg": parts[3] if len(parts) == 4 else 0.0}
+            try:
+                rec = _V.read_record(a.record, a.channel)
+            except ValueError as e:
+                raise SystemExit(f"vibration: {e}")
+            r = _V.assess(rec["x"], rec["fs"], a.unit, a.rpm, group=a.group, support=a.support, bearing=brg,
+                          band_hz=tuple(a.demod_band) if a.demod_band else None, label=f"{rec['name']}:{rec['channel']}", sensitivity=a.sensitivity)
+            r["gaps"] = list(r["gaps"]) + list(rec["notes"])
+            if a.json:
+                print(json.dumps({k: v for k, v in r.items()}, indent=1, default=str))
+            else:
+                print(_V.report_text(r))
+            return 0 if r["status"] == "ASSESSED" else 1
+        r = _V.selftest()
+        print(f"vibration selftest [{r['label']}]: {r['status']}")
+        for k, v in r["checks"].items():
+            print(f"  {'ok ' if v else 'BAD'} {k}")
+        print(_V.report_text(r["assessment"]))
+        return 0 if r["status"] == "OK" else 1
     elif a.cmd == "ppdm":
         from . import ppdm as _P
         if a.action == "parse":
@@ -1790,6 +1886,22 @@ def main(argv=None) -> int:
                                    countries=a.country, operator_org_id=a.operator_org, out_dir=a.out, actor=a.actor)
                 print(_osdu_text(r)); v = r["validate"]
                 print(f"  structure: {'ok' if v['ok'] else 'PROBLEMS'} ({v['records']} record(s))" + ('' if v['ok'] else '; ' + '; '.join(v['problems'][:5]))); return 0
+            elif a.action == "vibration-report":
+                from .vibration import report_text as _vib_text
+                if not a.well or not a.record:
+                    raise SystemExit("vibration-report needs --well <id> and --record <file>")
+                brg = None
+                if a.bearing:
+                    parts = [float(x) for x in a.bearing.split(",")]
+                    if len(parts) not in (3, 4):
+                        raise SystemExit("--bearing is elements,ball_mm,pitch_mm[,contact_deg]")
+                    brg = {"n_elements": int(parts[0]), "d_mm": parts[1], "D_mm": parts[2], "contact_deg": parts[3] if len(parts) == 4 else 0.0}
+                try:
+                    r = ws.vibration_report(a.well, a.record, channel=a.channel, unit=a.vib_unit, rpm=a.rpm, group=a.group, support=a.support, bearing=brg,
+                                            band_hz=a.demod_band, sensitivity=a.sensitivity, actor=a.actor)
+                except ValueError as e:
+                    raise SystemExit(f"vibration-report: {e}")
+                print(_vib_text(r)); print("  written:", r["paths"].get("md") or r["paths"]); return 0
             elif a.action == "well-identity":
                 from .ppdm import report_text as _ppdm_text
                 if not a.well:

{gea_program-0.13.0 → gea_program-0.15.0}/gea/acceptance_tests.py

@@ -2420,7 +2420,7 @@ def section_ah_band2(tmp: str) -> None:
            and Path(wsp, "wells", w1["id"], "records", "certificates", "CERT-1_cert1.txt").exists()
            and st2["P_raw_psi_S2"] == 48 and st2["P_raw_psi_S1"] == 240 and gd["instruments"]["swap_notes"][0]["samples_excluded"] == 192
            and [c["status"] for c in inst["certificate_status"]] == ["VALID", "VALID"] and not [c for c in inst["candidates"] if c["tag_id"] == "P_raw_psi_S2"]
-           and "Instruments: sensor swaps" in drift_html and "CERT-77" in drift_html and "Bias vs accuracy" in drift_html
+           and "Instruments: sensor swaps" in drift_html and "CERT-77" in drift_html and "Conformity" in drift_html and "ISO/IEC 17025 7.8" in drift_html
            and ptr and ptr["analyses"][0]["status"] == "OK" and abs(ptr["analyses"][0]["derived"]["k_md"] - k) / k < 0.05
            and ov["wells"][0]["instruments"]["swaps"] == 1 and ov["wells"][0]["transient"]["analysed"] == 1 and ov["site"]["certificates"]["counts"]["VALID"] == 2
            and "swap.add" in audit and "certificate.add" in audit and "transient.params" in audit,
@@ -5208,6 +5208,251 @@ def section_bg_ppdm(tmp: str) -> None:
        "a number from the command line with the exit code saying whether it is valid, and runs the self-test; the help page names the sidetrack "
        "it will not assume")
 
+
+def section_bh_vibration(tmp: str) -> None:
+    """Section BH - machine vibration: the ISO 20816-3 zone of the declared machine from the broadband r.m.s.
+    velocity, and the bearing's defect frequencies found or not found in the envelope spectrum of the most
+    impulsive band; the declarations named as declarations, the band's limits named, no fault size claimed."""
+    import csv as _csv
+    import subprocess as _sp
+    import numpy as _np
+    from . import vibration as V
+    from . import seismic as S
+    from . import helplib as H
+    from .client_reports import forbidden_terms
+    from .workspace import Workspace
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bh"); d.mkdir()
+
+    # -- the self-test on the labelled pump ----------------------------------------------------------
+    r = V.selftest()
+    a = r["assessment"]
+    ok(r["status"] == "OK" and all(r["checks"].values()) and r["label"] == "SIMULATION_SELF_TEST"
+       and a["zone"]["zone"] == "C" and abs(a["broadband"]["rms_mm_s"] - r["truth"]["unbalance_rms_mm_s"] * (1 + 0.09) ** 0.5) < 0.3
+       and a["envelope"]["match"]["matched"] == ["BPFO"] and len(a["envelope"]["match"]["rows"]["BPFO"]["harmonics_found"]) == 3
+       and r["inner"]["envelope"]["match"]["matched"] == ["BPFI"] and len(r["inner"]["envelope"]["match"]["rows"]["BPFI"]["sidebands"]["found"]) == 2
+       and V.ZONE_BOUNDARIES == {(1, "rigid"): (2.3, 4.5, 7.1), (1, "flexible"): (3.5, 7.1, 11.0), (2, "rigid"): (1.4, 2.8, 4.5), (2, "flexible"): (2.3, 4.5, 7.1)}
+       and V.BAND_HZ == (10.0, 1000.0) and V.BAND_LOW_SPEED_HZ == (2.0, 1000.0) and V.LOW_SPEED_RPM == 600.0
+       and abs(V.bearing_frequencies(1780, 9, 7.94, 39.04)["BPFI"] - 0.5 * 9 * (1780 / 60) * (1 + 7.94 / 39.04)) < 1e-3
+       and abs(V.bearing_frequencies(1780, 9, 7.94, 39.04)["BSF"] - (39.04 / (2 * 7.94)) * (1780 / 60) * (1 - (7.94 / 39.04) ** 2)) < 1e-3
+       and abs(V.bearing_frequencies(1780, 9, 7.94, 39.04)["FTF"] - 0.5 * (1780 / 60) * (1 - 7.94 / 39.04)) < 1e-3
+       and abs(V.bearing_frequencies(1780, 9, 7.94, 39.04, 30.0)["BPFO"] - 0.5 * 9 * (1780 / 60) * (1 - 7.94 / 39.04 * _np.cos(_np.radians(30)))) < 1e-3,
+       "BH1 the self-test on a labelled pump at 1780 r/min: the broadband r.m.s. velocity recovers the unbalance line put into the record to within "
+       "8% and places a Group 2 rigid machine in zone C as the truth says; the most impulsive band is chosen and the outer-race fault is matched at "
+       "its fundamental and two harmonics with the inner race, the ball and the cage not matched; an inner-race scene is matched at BPFI with both "
+       "sidebands at the shaft speed and the outer race not matched; the zone boundaries are ISO 20816-3's for both groups and both supports, the "
+       "band is ISO 20816-1's, and the four defect frequencies are the kinematic formulas including the contact angle")
+
+    # -- what it will not call a measurement ----------------------------------------------------------
+    sc = V.synthetic_scene(seconds=2.0)
+    slow = V.assess(sc["acc_m_s2"][::10], sc["fs"] / 10.0, "m/s2", sc["rpm"], group=2, support="rigid", bearing=sc["bearing"])
+    short = V.assess(sc["acc_m_s2"][:int(0.5 * sc["fs"])], sc["fs"], "m/s2", sc["rpm"], group=2, support="rigid", bearing=sc["bearing"])
+    nod = V.assess(sc["acc_m_s2"], sc["fs"], "m/s2", None)
+    cnt = V.assess(_np.round(sc["acc_m_s2"] / 9.80665 / 1e-4), sc["fs"], "counts", sc["rpm"], group=2, support="rigid", bearing=sc["bearing"])
+    sens = V.assess(_np.round(sc["acc_m_s2"] / 9.80665 / 1e-4), sc["fs"], "g", sc["rpm"], group=2, support="rigid", bearing=sc["bearing"], sensitivity=1e-4)
+    low = V.assess(sc["acc_m_s2"], sc["fs"], "m/s2", 450.0, group=1, support="flexible")
+    declared_band = V.assess(sc["acc_m_s2"], sc["fs"], "m/s2", sc["rpm"], group=2, support="rigid", bearing=sc["bearing"], band_hz=(2000.0, 4000.0))
+    ok(slow["broadband"]["band_partial"] and slow["broadband"]["band_hz"][1] < 1000 and slow["zone"]["zone_qualified"] == "PARTIAL BAND"
+       and any("PARTIAL BAND" in g for g in slow["gaps"])
+       and any("shorter than one second" in g for g in short["gaps"])
+       and nod["zone"] is None and nod["status"] == "PARTIAL" and any("no shaft speed" in g for g in nod["gaps"]) and any("group" in g for g in nod["gaps"])
+       and any("bearing" in g for g in nod["gaps"]) and nod["envelope"]["match"] is None and len(nod["envelope"]["peaks"]) > 0
+       and cnt["status"] == "NOT ASSESSED" and cnt["broadband"]["status"] == "NOT EVALUATED" and cnt["envelope"]["match"]["matched"] == ["BPFO"]
+       and sens["status"] == "ASSESSED" and abs(sens["broadband"]["rms_mm_s"] - a["broadband"]["rms_mm_s"]) < 0.3 and sens["declared"]["sensitivity"] == 1e-4
+       and low["broadband"]["band_hz"][0] == 2.0 and low["zone"]["boundaries_mm_s"] == {"A/B": 3.5, "B/C": 7.1, "C/D": 11.0}
+       and declared_band["envelope"]["band"]["status"] == "DECLARED" and declared_band["envelope"]["band"]["band_hz"] == [2000.0, 4000.0]
+       and declared_band["envelope"]["match"]["matched"] == ["BPFO"]
+       and "fault size" in " ".join(a["not_a_measurement"]) and "declared" in " ".join(a["not_a_measurement"]),
+       "BH2 a record whose rate cannot carry 1000 Hz is evaluated to its own Nyquist frequency and marked PARTIAL BAND, never promoted; a record "
+       "under a second is named; without a shaft speed, a group or a bearing the broadband value is stated, the zone is not, the envelope peaks "
+       "are listed and nothing is matched; a record in counts gets no mm/s and no zone but its envelope is still read, and with a declared "
+       "sensitivity it agrees with the same record in g; below 600 r/min the band starts at 2 Hz and Group 1 flexible has its own boundaries; a "
+       "declared demodulation band is used as declared; the assessment says it is not a fault size and that the machine is a declaration")
+
+    # -- through the workspace and the command line, from a CSV and from a miniSEED record ------------
+    csvp = d / "pump.csv"
+    with open(csvp, "w", newline="") as f:
+        w = _csv.writer(f); w.writerow(["elapsed_s", "acc_g", "temp_C"])
+        for i, x in enumerate(sc["acc_m_s2"]):
+            w.writerow([f"{i / sc['fs']:.6f}", f"{x / 9.80665:.6f}", "41.0"])
+    counts = _np.round(sc["acc_m_s2"] / 9.80665 / 1e-4).astype(_np.int32)
+    S.write_mseed([S.Trace("XX", "PUMP", "", "ACC", 1700000000.1234567, sc["fs"], counts, "synthetic", "INT32")], str(d / "pump.mseed"))
+    back = S.read_any(str(d / "pump.mseed"))
+    hist = d / "swd.csv"
+    with open(hist, "w", newline="") as f:
+        w = _csv.writer(f); w.writerow(["timestamp", "P_surf_psi"])
+        for h in range(24):
+            w.writerow([f"2026-03-01T{h:02d}:00:00Z", "1500"])
+    ws = Workspace.create(str(d / "ws"), "Pad 3", actor="tester")
+    w1 = ws.add_well_file(str(hist), display="SWD 1", actor="tester", station_md_ft=9800.0)
+    run = lambda *a: _sp.run([sys.executable, "-m", "gea", "workspace", "--path", ws.path, "--actor", "tester", *a], capture_output=True, text=True)
+    r1 = run("--action", "vibration-report", "--well", w1["id"], "--record", str(csvp), "--channel", "acc_g", "--vib-unit", "g", "--rpm", "1780",
+             "--group", "2", "--support", "rigid", "--bearing", "9,7.94,39.04")
+    r0 = run("--action", "vibration-report", "--well", w1["id"], "--record", str(csvp), "--channel", "nope")
+    out = Path(ws.path, "reports", "wells", w1["id"])
+    md = (out / "vibration_report.md").read_text(encoding="utf-8"); html = (out / "vibration_report.html").read_text(encoding="utf-8")
+    js = json.loads((out / "vibration_report.json").read_text(encoding="utf-8"))
+    audit = Path(ws.path, "records", "audit.jsonl").read_text(encoding="utf-8")
+    r2 = _sp.run([sys.executable, "-m", "gea", "vibration", "--action", "assess", "--record", str(d / "pump.mseed"), "--unit", "g", "--sensitivity", "1e-4",
+                  "--rpm", "1780", "--group", "2", "--support", "rigid", "--bearing", "9,7.94,39.04"], capture_output=True, text=True)
+    r3 = _sp.run([sys.executable, "-m", "gea", "vibration", "--action", "assess", "--record", str(d / "pump.mseed"), "--unit", "counts", "--rpm", "1780",
+                  "--group", "2", "--support", "rigid"], capture_output=True, text=True)
+    r4 = _sp.run([sys.executable, "-m", "gea", "vibration"], capture_output=True, text=True)
+    help_md = (pkg / "help" / "vibration.md").read_text(encoding="utf-8")
+    ok(len(back) == 1 and back[0].npts == counts.size and not back[0].gaps and abs(back[0].starttime - 1700000000.1234567) < 2e-6
+       and r1.returncode == 0 and "ISO 20816-3 zone C" in r1.stdout and "BPFO 106.3486 Hz: MATCHED" in r1.stdout and "written:" in r1.stdout
+       and r0.returncode != 0 and "no channel" in (r0.stderr + r0.stdout)
+       and Path(ws.path, "wells", w1["id"], "machine", "pump.csv").is_file()
+       and "| **Result** | ZONE C |" in md and "Bearing defect frequencies" in md and "Group 2 (15 kW to 300 kW)" in md and "fault size" in md
+       and not forbidden_terms(md) and not forbidden_terms(html)
+       and js["assessment"]["record"]["sha256"] and js["assessment"]["zone"]["zone"] == "C" and js["assessment"]["declared"]["bearing"]["n_elements"] == 9
+       and "well.vibration" in audit and '"zone": "C"' in audit
+       and r2.returncode == 0 and "from acceleration (g), 2.0 s at 20000 Hz" in r2.stdout and "zone C" in r2.stdout and "MATCHED" in r2.stdout
+       and r3.returncode == 1 and "NOT ASSESSED" in r3.stdout and "without a sensitivity" in r3.stdout
+       and r4.returncode == 0 and "vibration selftest [SIMULATION_SELF_TEST]: OK" in r4.stdout
+       and any(t["topic"] == "vibration" for t in H.topics()) and not H.check("vibration")
+       and "fault size" in help_md.split("will not call a measurement")[1] and "2.3 / 4.5 / 7.1" in help_md,
+       "BH3 a 20 kHz record round-trips through this program's own miniSEED writer as one trace with no gap (the header's 0.1 ms time field "
+       "is coarser than a sample above 5 kHz and every record read back as a gap until blockette 1001 carried the microseconds); "
+       "`--action vibration-report` copies the record beside the well, writes the report in three forms with the zone as its result, the "
+       "declarations in their own table and the defect frequencies each matched or not, audits it with the zone and the declarations, and names "
+       "a channel that is not there; `gea vibration --action assess` reads a miniSEED record in counts with a declared sensitivity and says "
+       "NOT ASSESSED without one; the self-test runs from the command line; the help page carries the boundaries and names the fault size it will not claim")
+
+
+def section_bi_conformance(tmp: str) -> None:
+    """Section BI - conformity in the standards' words: each certificate against the items ISO/IEC 17025:2017
+    7.8.2.1 and 7.8.4.1 ask it to carry, and the drift report's bias-against-class line as a statement of
+    conformity with its ILAC-G8 decision rule named, the uncertainty as the guard band, nothing assumed."""
+    import csv
+    import datetime as D
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import numpy as _np
+    from . import conformance as C
+    from . import helplib as H
+    from .certificates import CertificateRegister
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bi"); d.mkdir()
+
+    # -- the self-test and the rules --------------------------------------------------------------------
+    r = C.selftest()
+    ok(r["status"] == "OK" and all(r["checks"].values())
+       and [x["outcome"] for x in r["decisions"]] == ["PASS", "CONDITIONAL PASS", "CONDITIONAL FAIL", "FAIL", "PASS"]
+       and r["decisions"][4]["rule"] == "simple-acceptance"
+       and C.decide(8.0, 10.0, 2.0)["outcome"] == "PASS" and C.decide(8.0001, 10.0, 2.0)["outcome"] == "CONDITIONAL PASS"
+       and C.decide(10.0, 10.0, 2.0)["outcome"] == "CONDITIONAL PASS" and C.decide(10.0001, 10.0, 2.0)["outcome"] == "CONDITIONAL FAIL"
+       and C.decide(12.0, 10.0, 2.0)["outcome"] == "CONDITIONAL FAIL" and C.decide(12.0001, 10.0, 2.0)["outcome"] == "FAIL"
+       and C.decide(10.0, 10.0, 2.0, rule="simple-acceptance")["outcome"] == "PASS" and C.decide(8.5, 10.0, 2.0, rule="binary-guard-band")["outcome"] == "FAIL"
+       and len(C.CERTIFICATE_CLAUSES) == 14 and {c[0].split(" ")[0] for c in C.CERTIFICATE_CLAUSES} == {"7.8.2.1", "7.8.4.1"}
+       and all(k in " ".join(x[1] for x in C.CERTIFICATE_CLAUSES) for k in ("uncertainty", "traceability", "conditions", "adjustment", "decision_rule", "authorised_by", "method", "calibrated_utc")),
+       "BI1 the ILAC-G8:09/2019 rules give the four outcomes at their boundaries (PASS to TL - U, CONDITIONAL PASS to TL, CONDITIONAL FAIL to TL + U, "
+       "FAIL above), simple acceptance ignores U and says so, the binary rule fails inside the guard band; the certificate items are the fourteen of "
+       "ISO/IEC 17025:2017 7.8.2.1 and 7.8.4.1 - identification, laboratory, item, dates, result, method, authorisation, uncertainty with its "
+       "coverage factor, conditions, traceability, adjustment, decision rule - and a full certificate is COMPLETE, a thin one INCOMPLETE with the "
+       "missing clauses named, an entry filed before the fields existed NOT RECORDED rather than NOT CARRIED")
+
+    # -- the register: the fields recorded from the paper, nothing invented ------------------------------
+    reg = CertificateRegister(str(d / "certs.jsonl"))
+    e1 = reg.add("P1", "S1", "C-1", "2026-01-10", "2027-01-10", "tester", "Acme Cal", 0.1, 10000.0, "psi",
+                 uncertainty=2.5, uncertainty_k=2.0, uncertainty_probability=0.95, traceability="NIST via DWT 1234", conditions="23 ± 1 °C",
+                 calibrated_utc="2026-01-09", method="comparison", authorised_by="J. Doe", adjustment="as found / as left", decision_rule="simple acceptance")
+    e2 = reg.add("P2", "S2", "C-2", "2026-01-10", "2027-01-10", "tester", "Acme Cal", 0.1, 10000.0, "psi")
+    bad = []
+    for kw in ({"uncertainty_k": 0}, {"uncertainty_probability": 1.5}, {"uncertainty": -1}, {"nonsense": "x"}):
+        try:
+            reg.add("P3", "S3", "C-3", "2026-01-10", "2027-01-10", "tester", **kw); bad.append(False)
+        except ValueError:
+            bad.append(True)
+    st = {x["tag_id"]: x for x in reg.status(["P1", "P2"], now=D.datetime(2026, 6, 1, tzinfo=D.timezone.utc))}
+    conf = reg.conformance()
+    r1 = _sp.run([sys.executable, "-m", "gea", "certificates", "--register", str(d / "certs.jsonl"), "--action", "conformance"], capture_output=True, text=True)
+    r2 = _sp.run([sys.executable, "-m", "gea", "certificates", "--register", str(d / "cli.jsonl"), "--action", "add", "--tag", "P9", "--serial", "S9", "--certificate", "C-9",
+                  "--issued", "2026-01-10", "--valid-until", "2027-01-10", "--lab", "Cal Lab GmbH", "--accuracy-pct-fs", "0.05", "--full-scale", "5000", "--unit", "psi", "--uncertainty", "1.2",
+                  "--k", "2", "--probability", "0.95", "--traceability", "PTB via transfer standard 7", "--conditions", "21 °C", "--calibrated", "2026-01-08",
+                  "--method", "comparison", "--authorised-by", "A. B."], capture_output=True, text=True)
+    r3 = _sp.run([sys.executable, "-m", "gea", "certificates", "--register", str(d / "cli.jsonl"), "--action", "conformance"], capture_output=True, text=True)
+    r4 = _sp.run([sys.executable, "-m", "gea", "conformance", "--action", "decide", "--value", "11", "--tolerance", "10", "--uncertainty", "2", "--unit", "psi"], capture_output=True, text=True)
+    r5 = _sp.run([sys.executable, "-m", "gea", "conformance"], capture_output=True, text=True)
+    ok(e1["uncertainty"] == 2.5 and e1["uncertainty_k"] == 2.0 and e1["traceability"] == "NIST via DWT 1234" and e2["uncertainty"] is None and e2["traceability"] == ""
+       and all(bad) and st["P1"]["iso17025"]["status"] == "COMPLETE" and st["P1"]["iso17025"]["carried"] == 14
+       and st["P2"]["iso17025"]["status"] == "INCOMPLETE" and any("7.8.4.1 c" in m for m in st["P2"]["iso17025"]["missing"]) and st["P2"]["uncertainty"] is None
+       and conf["n"] == 2 and conf["complete"] == 1 and conf["incomplete"] == ["C-2"]
+       and r1.returncode == 1 and "C-1 (serial S1, tag P1): COMPLETE - 14 of 14" in r1.stdout and "NOT CARRIED  a statement identifying how the measurements are metrologically traceable" in r1.stdout
+       and r2.returncode == 0 and r3.returncode == 0 and "1 COMPLETE" in r3.stdout
+       and r4.returncode == 1 and "CONDITIONAL FAIL" in r4.stdout and "acceptance limit 8 psi" in r4.stdout
+       and r5.returncode == 0 and "conformance selftest [SELF_TEST]: OK" in r5.stdout,
+       "BI2 the register takes what 7.8.4 asks the paper to carry - the expanded uncertainty with its coverage factor and probability, the "
+       "traceability statement as worded, the conditions, the calibration date, the method, who authorised it, the adjustment results, the "
+       "decision rule - rejects a k of zero, a probability above one, a negative uncertainty and a field it does not know, leaves empty what was "
+       "not filed, and every status row carries the certificate's 7.8 standing; `gea certificates --action conformance` prints it item by item "
+       "and exits 1 while any certificate is incomplete; `gea conformance --action decide` states one decision from the command line")
+
+    # -- the drift report: the statement of conformity with its rule named ----------------------------------
+    rng = _np.random.default_rng(5)
+    n = 240
+    t0 = D.datetime(2026, 3, 1, tzinfo=D.timezone.utc)
+    hist = d / "hist.csv"
+    base = 3000.0 + 0.2 * _np.sin(_np.arange(n) / 24.0)
+    with open(hist, "w", newline="") as f:
+        w = csv.writer(f); w.writerow(["timestamp_utc", "P_raw_psi_S1", "P_raw_psi_S2", "T_raw_F_S1"])
+        for i in range(n):
+            w.writerow([(t0 + D.timedelta(hours=i)).strftime("%Y-%m-%dT%H:%M:%SZ"), round(base[i] + rng.normal(0, 0.8), 2), round(base[i] + 1.5 + rng.normal(0, 0.8), 2), round(80 + 0.1 * rng.normal(), 2)])
+    wsp = str(d / "ws")
+    ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w1 = ws.add_well_file(str(hist), display="Well BI", actor="tester")
+    users = Users(str(Path(wsp, "users.json"))); users.add("op1", "operator-pass-1", "operator")
+    svc = Service(wsp, host="127.0.0.1", port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+    opener = 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")
+        if method == "POST":
+            req.add_header("X-GEA-Action", "1")
+        try:
+            with opener.open(req, timeout=600) as rr:
+                return rr.status, json.loads(rr.read())
+        except urllib.error.HTTPError as ex:
+            return ex.code, json.loads(ex.read())
+    try:
+        call("POST", "/api/login", {"name": "op1", "password": "operator-pass-1"})
+        s_c1, _ = call("POST", f"/api/wells/{w1['id']}/certificates", {"tag_id": "P_raw_psi_S1", "serial": "SN-1", "certificate_id": "CERT-A", "issued_utc": "2026-01-01",
+                                                                       "valid_until_utc": "2027-01-01", "lab": "LabX", "accuracy_pct_fs": 0.02, "full_scale": 10000, "unit": "psi",
+                                                                       "uncertainty": "0.5", "uncertainty_k": "2", "uncertainty_probability": "0.95", "traceability": "NIST via DWT",
+                                                                       "conditions": "23 °C", "calibrated_utc": "2025-12-30", "method": "comparison", "authorised_by": "Q. A."})
+        s_c2, _ = call("POST", f"/api/wells/{w1['id']}/certificates", {"tag_id": "P_raw_psi_S2", "serial": "SN-2", "certificate_id": "CERT-B", "issued_utc": "2026-01-01",
+                                                                       "valid_until_utc": "2027-01-01", "lab": "LabX", "accuracy_pct_fs": 0.02, "full_scale": 10000, "unit": "psi"})
+        call("POST", "/api/refresh", {})
+        svc.app.runner.wait(svc.app.runner.list(1)[0]["id"], 600)
+        inst = call("GET", f"/api/wells/{w1['id']}/instruments")[1]
+        drift_md = Path(wsp, "reports", "wells", w1["id"], "gauge_drift_report.md").read_text(encoding="utf-8")
+        drift_html = Path(wsp, "reports", "wells", w1["id"], "gauge_drift_report.html").read_text(encoding="utf-8")
+        page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+        by = inst["iso17025"]["by_certificate"]
+        ok(s_c1 == 200 and s_c2 == 200 and inst["iso17025"]["n"] == 2 and inst["iso17025"]["complete"] == 1 and inst["iso17025"]["incomplete"] == ["CERT-B"]
+           and by["CERT-A"]["status"] == "COMPLETE" and by["CERT-B"]["status"] == "INCOMPLETE"
+           and "Conformity" in drift_md and "ISO/IEC 17025 7.8" in drift_md and "decision rule: non-binary-guard-band (ILAC-G8:09/2019)" in drift_md
+           and "bias of P_raw_psi_S1 over the evaluation window" in drift_md and "with expanded uncertainty U = " in drift_md and "(k = 2, 95%)" in drift_md
+           and "tolerance limit 2 psi" in drift_md and "acceptance limit" in drift_md and "COMPLETE (12/14)" in drift_md and "INCOMPLETE (5/14)" in drift_md and by["CERT-A"]["carried"] == 12
+           and ("CONDITIONAL" in drift_md or "PASS" in drift_md or "FAIL" in drift_md) and "ISO/IEC 17025:2017 7.8.6" in drift_html
+           and "ctUnc" in page_src and "ctTrace" in page_src and "uncertainty_k" in page_src and "ISO/IEC 17025 7.8" in page_src
+           and any(t["topic"] == "conformance" for t in H.topics()) and not H.check("conformance")
+           and "simple acceptance" in (pkg / "help" / "conformance.md").read_text(encoding="utf-8").split("will not call a measurement")[1],
+           "BI3 through the API: a certificate filed with its uncertainty, coverage factor and traceability is COMPLETE and one filed without them is "
+           "INCOMPLETE; the instruments answer carries every certificate's 7.8 standing; the drift report's bias line is a statement of conformity "
+           "in 7.8.6's words - the result it applies to with its sample count, the certificate's class as the tolerance limit, the bias's expanded "
+           "uncertainty at k = 2, the ILAC-G8 non-binary guard-band rule and the acceptance limit - beside the certificate's own 7.8 standing; the "
+           "page's filing form takes the 7.8.4 items and its table shows U (k) and the standing; the help page names simple acceptance as the "
+           "fallback it will not dress up")
+    finally:
+        svc.stop()
+
 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:
@@ -5270,6 +5515,8 @@ def main() -> int:
         section_be_osdu(tmp)
         section_bf_quakeml(tmp)
         section_bg_ppdm(tmp)
+        section_bh_vibration(tmp)
+        section_bi_conformance(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: