gea-program 0.17.1__tar.gz → 0.19.0__tar.gz

{gea_program-0.17.1 → gea_program-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.17.1
+Version: 0.19.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 (340 checks)
+gea accept                     # the product gate (344 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]")
@@ -710,6 +710,24 @@ after the report was written - and "Update every report from its source"
 dashboard for every well, then every seismic station, errors collected and
 listed, never hidden.
 
+### The month-end packet
+
+A client's month was five or six commands and a walk through the reports
+folder. `gea workspace --path C:\site --action month-end --period 2026-09`
+(or `--period previous`) runs the refresh for the period and collects every
+report the program writes - each well's drift report, alarm month, well-test
+validation, shut-in report, data resilience, machine vibration and the
+certificate register's ISO/IEC 17025 7.8 conformity; each site's SRA packet
+for the period and site report; every seismic station and track; the
+accuracy statement, the SLA month, the FAT/SAT protocol, the model cards and
+the SBOM - into `reports/month_end/<period>/` with `INDEX` (html, md, json:
+every item INCLUDED with its files or NOT AVAILABLE with the reason that
+names what the site lacks; every failed step; OPEN for a month that has not
+ended) and `MANIFEST.json` (every file's SHA-256), zipped beside it. Nothing
+is recomputed in the index. On the Reports page: the packets on record,
+Assemble as a job, and Schedule monthly (day and hour, the previous month).
+`gea help month-end`.
+
 ### Before a site goes live
 
 `deploy/README.md` is the checklist: keep the service on the loopback
@@ -722,6 +740,14 @@ headers on every response, and `gea housekeeping --workspace C:\site --apply`
 than truncating them and prunes finished job folders and old recordings. `gea
 loadtest --patches 16 --seconds 60 --with-service` tells you whether the site
 machine carries the patches it will be given, with the page still answering.
+`gea backup --workspace C:\site --out D:\gea-backups --keep 14` copies the
+whole site into one dated archive with a manifest of every file's hash, onto
+another disk or a share; schedule it daily from Audit / Update, verify an
+archive with `--verify`, and restore one onto an empty folder with
+`--restore ... --to` and open it once before the first well is live - the
+records are the product, and a backup nobody has restored is a hope. The
+doctor warns when there has never been a backup or the last is more than a
+day old. `gea help backup`.
 
 ## The standalone install kit
 

{gea_program-0.17.1 → gea_program-0.19.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 (340 checks)
+gea accept                     # the product gate (344 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]")
@@ -671,6 +671,24 @@ after the report was written - and "Update every report from its source"
 dashboard for every well, then every seismic station, errors collected and
 listed, never hidden.
 
+### The month-end packet
+
+A client's month was five or six commands and a walk through the reports
+folder. `gea workspace --path C:\site --action month-end --period 2026-09`
+(or `--period previous`) runs the refresh for the period and collects every
+report the program writes - each well's drift report, alarm month, well-test
+validation, shut-in report, data resilience, machine vibration and the
+certificate register's ISO/IEC 17025 7.8 conformity; each site's SRA packet
+for the period and site report; every seismic station and track; the
+accuracy statement, the SLA month, the FAT/SAT protocol, the model cards and
+the SBOM - into `reports/month_end/<period>/` with `INDEX` (html, md, json:
+every item INCLUDED with its files or NOT AVAILABLE with the reason that
+names what the site lacks; every failed step; OPEN for a month that has not
+ended) and `MANIFEST.json` (every file's SHA-256), zipped beside it. Nothing
+is recomputed in the index. On the Reports page: the packets on record,
+Assemble as a job, and Schedule monthly (day and hour, the previous month).
+`gea help month-end`.
+
 ### Before a site goes live
 
 `deploy/README.md` is the checklist: keep the service on the loopback
@@ -683,6 +701,14 @@ headers on every response, and `gea housekeeping --workspace C:\site --apply`
 than truncating them and prunes finished job folders and old recordings. `gea
 loadtest --patches 16 --seconds 60 --with-service` tells you whether the site
 machine carries the patches it will be given, with the page still answering.
+`gea backup --workspace C:\site --out D:\gea-backups --keep 14` copies the
+whole site into one dated archive with a manifest of every file's hash, onto
+another disk or a share; schedule it daily from Audit / Update, verify an
+archive with `--verify`, and restore one onto an empty folder with
+`--restore ... --to` and open it once before the first well is live - the
+records are the product, and a backup nobody has restored is a hope. The
+doctor warns when there has never been a backup or the last is more than a
+day old. `gea help backup`.
 
 ## The standalone install kit
 

{gea_program-0.17.1 → gea_program-0.19.0}/gea/__init__.py

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

{gea_program-0.17.1 → gea_program-0.19.0}/gea/__main__.py

@@ -285,7 +285,7 @@ def main(argv=None) -> int:
                                "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", "vibration-report",
-                               "add-live-station", "live-fold", "live-run"])
+                               "add-live-station", "live-fold", "live-run", "month-end"])
     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")
@@ -307,7 +307,7 @@ def main(argv=None) -> int:
     p_ws.add_argument("--checkpoint-months", type=int, default=3, help="sra-define: months between checkpoints with Commission staff (3)")
     p_ws.add_argument("--formation-boundary", type=str, default="base of the Wolfcamp", help="sra-define: the stratigraphic boundary between the two tiers")
     p_ws.add_argument("--triggering-event", type=str, default="", help="sra-define: the catalogue id of the event the plan answers")
-    p_ws.add_argument("--catalog", type=str, default=None, help="sra-report: a TexNet earthquake-catalogue export (CSV)")
+    p_ws.add_argument("--catalog", type=str, default=None, help="sra-report / month-end: a TexNet earthquake-catalogue export (CSV)")
     p_ws.add_argument("--aftershocks", type=str, nargs="*", default=None, help="sra-report: catalogue ids the operator declares as aftershocks (exempt)")
     p_ws.add_argument("--start", type=str, default=None, help="sra-report: first day of the record, YYYY-MM-DD")
     p_ws.add_argument("--end", type=str, default=None, help="sra-report: last day of the record, YYYY-MM-DD")
@@ -359,6 +359,8 @@ def main(argv=None) -> int:
     p_ws.add_argument("--seedlink-config", type=str, default=None, help="add-live-station: the SeedLink config JSON (gea seedlink --write-example-config)")
     p_ws.add_argument("--include-open", action="store_true", help="live-fold: fold the current day's files too (they are still being written)")
     p_ws.add_argument("--seconds", type=float, default=None, help="live-run: how long to run (default: until Ctrl+C)")
+    p_ws.add_argument("--period", type=str, default="previous", help="month-end: the month, YYYY-MM, or 'previous' (the last closed month)")
+    p_ws.add_argument("--no-refresh", action="store_true", help="month-end: collect the reports as they stand without refreshing first")
     p_ws.add_argument("--name", type=str, default=None, help="init: site name; add-*: display name")
     p_ws.add_argument("--file", type=str, default=None, help="add-file: the client's data file; add-live: the port configuration JSON")
     p_ws.add_argument("--entry", type=str, default=None, help="add-catalog: catalogue entry")
@@ -411,6 +413,16 @@ def main(argv=None) -> int:
     p_es.add_argument("--frames", type=int, default=600)
     p_es.add_argument("--interval", type=float, default=1.0, help="seconds between samples")
     p_es.add_argument("--seed", type=int, default=1)
+    p_bk = sub.add_parser("backup", help="the site copied off the machine: one dated archive with a manifest; --verify an archive; --restore one onto an empty folder; --status")
+    p_bk.add_argument("--workspace", type=str, default=None, help="the site folder (for a backup, or --status)")
+    p_bk.add_argument("--out", type=str, default=None, help="the folder the archive goes to - another disk or a share, never inside the workspace")
+    p_bk.add_argument("--keep", type=int, default=None, help="keep only the newest N archives of this site in --out")
+    p_bk.add_argument("--label", type=str, default="", help="a note carried in the manifest (e.g. 'before the gauge swap')")
+    p_bk.add_argument("--verify", type=str, default=None, help="check this archive against its manifest and its .sha256")
+    p_bk.add_argument("--restore", type=str, default=None, help="restore this archive ...")
+    p_bk.add_argument("--to", type=str, default=None, help="... onto this empty folder")
+    p_bk.add_argument("--status", action="store_true", help="when the last backup of --workspace was taken, and whether that is too long ago")
+    p_bk.add_argument("--actor", type=str, default="cli")
     p_sl = sub.add_parser("seedlink", help="the seismic leg's live port: a SeedLink (3 / 4.0) station's records as it writes them, byte for byte into day files; --selftest against the simulator")
     p_sl.add_argument("--config", type=str, default=None, help="the SeedLink config JSON (host, port, streams)")
     p_sl.add_argument("--write-example-config", type=str, default=None, help="write an example config here and exit")
@@ -1934,6 +1946,10 @@ def main(argv=None) -> int:
                     raise SystemExit("well-identity needs --well <id>")
                 r = ws.well_identity(a.well)
                 print(_ppdm_text(r)); return 0
+            elif a.action == "month-end":
+                from .month_end import report_text as _me_text
+                r = ws.month_end(a.period, actor=a.actor, refresh=not a.no_refresh, catalog_csv=a.catalog)
+                print(_me_text(r)); return 0 if not r["errors"] else 1
             elif a.action == "add-live-station":
                 if not a.seedlink_config or not a.name:
                     raise SystemExit("add-live-station needs --name <display> and --seedlink-config <json>")
@@ -2017,6 +2033,24 @@ def main(argv=None) -> int:
             stop.set()
             print("wits0-sim: stopped")
         return 0
+    elif a.cmd == "backup":
+        from . import backup as _B
+        try:
+            if a.verify:
+                r = _B.verify(a.verify); print(_B.report_text(r, "verify")); return 0 if r["status"] == "OK" else 1
+            if a.restore:
+                if not a.to:
+                    raise SystemExit("backup --restore needs --to <empty folder>")
+                print(_B.report_text(_B.restore(a.restore, a.to, a.actor), "restore")); return 0
+            if not a.workspace:
+                raise SystemExit("backup needs --workspace <site folder> (with --out <another disk>), or --verify / --restore an archive")
+            if a.status:
+                r = _B.status(a.workspace); print(_B.report_text(r, "status")); return 0 if not (r["never"] or r["stale"]) else 1
+            if not a.out:
+                raise SystemExit("backup needs --out <a folder on another disk or a share>")
+            print(_B.report_text(_B.make(a.workspace, a.out, a.actor, keep=a.keep, label=a.label), "make")); return 0
+        except (ValueError, OSError) as e:
+            raise SystemExit(f"backup: {e}")
     elif a.cmd == "seedlink":
         import json as _json
         from . import seedlink as _L

{gea_program-0.17.1 → gea_program-0.19.0}/gea/acceptance_tests.py

@@ -5719,6 +5719,283 @@ def section_bk_seedlink(tmp: str) -> None:
        "names the simulator to start; the help page says a gap is counted, never bridged"
        + (f" [failed: {', '.join(failed)}; row={json.dumps({k: row.get(k) for k in ('status', 'protocol', 'records', 'latency_p95_s', 'last_error')})}]" if failed else ""))
 
+
+def section_bl_backup(tmp: str) -> None:
+    """Section BL - the site copied off the machine: the archive and its manifest, verify, a tampered archive named,
+    restore onto an empty folder and the workspace that comes back, the refusals, the doctor's line, the page's
+    card, the job and the daily schedule."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import zipfile
+    from . import backup as B
+    from . import doctor as D
+    from . import helplib as H
+    from .telemetry import TelemetryRecorder, TelemetryConfig
+    from .downhole_engine import DownholeEngine, SimulatorConfig
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bl"); d.mkdir()
+    hist = str(d / "hist.csv")
+    TelemetryRecorder(engine=DownholeEngine(SimulatorConfig()), config=TelemetryConfig(duration_hours=0.5, seed=5)).run().export_csv(hist)
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w = ws.add_well_file(hist, display="SWD 1", actor="tester")
+    users = Users(str(Path(wsp, "users.json"))); users.add("op", "operator-pass-1", "operator"); users.add("adm", "admin-pass-1", "admin")
+    (Path(wsp) / "jobs" / "run-0001").mkdir(parents=True); (Path(wsp) / "jobs" / "run-0001" / "log.txt").write_text("a finished run")
+    (Path(wsp) / "jobs" / "_uploads").mkdir(); (Path(wsp) / "jobs" / "_uploads" / "x.bin").write_bytes(b"scratch")
+    (Path(wsp) / "jobs" / "schedule.json").write_text(json.dumps({"entries": []}))
+
+    # -- make, verify, status, restore; the refusals; the pruning ---------------------------------------------------
+    never = B.status(wsp)
+    out = str(d / "off-disk")
+    r1 = B.make(wsp, out, "tester", keep=2, label="first")
+    v1 = B.verify(r1["path"])
+    side1 = os.path.isfile(r1["path"] + ".sha256")           # before the later --keep prunes this first archive and its hash file
+    st1 = B.status(wsp)
+    with zipfile.ZipFile(r1["path"]) as z:
+        names = z.namelist(); man = json.loads(z.read("MANIFEST.json"))
+    inside_refused = None
+    try:
+        B.make(wsp, os.path.join(wsp, "records", "bk"), "tester")
+    except ValueError as e:
+        inside_refused = str(e)
+    rr = B.restore(r1["path"], str(d / "restored"), "tester")
+    ws2 = Workspace(str(d / "restored"))
+    nonempty_refused = None
+    try:
+        B.restore(r1["path"], str(d / "restored"), "tester")
+    except ValueError as e:
+        nonempty_refused = str(e)
+    # tamper: rewrite one member in a copy; verify names it and restore refuses it
+    bad = str(d / "tampered.zip")
+    with zipfile.ZipFile(r1["path"]) as zin, zipfile.ZipFile(bad, "w") as zout:
+        for info in zin.infolist():
+            data = zin.read(info.filename)
+            if info.filename == "workspace.json":
+                data = data.replace(b"Pad 3", b"Pad 4")
+            zout.writestr(info, data)
+    vbad = B.verify(bad)
+    tampered_refused = None
+    try:
+        B.restore(bad, str(d / "restored2"), "tester")
+    except ValueError as e:
+        tampered_refused = str(e)
+    r2 = B.make(wsp, out, "tester", keep=2); r3 = B.make(wsp, out, "tester", keep=2)
+    left = sorted(n for n in os.listdir(out) if n.endswith(".zip"))
+    rec_files = [n for n in names if n.startswith(f"wells/{w['id']}/")]
+    c1 = {
+        "never_then_current": never["never"] and never["stale"] and st1["never"] is False and st1["stale"] is False and st1["present"] is True and st1["count"] == 1,
+        "manifest": r1["n_files"] == man["n_files"] and man["protocol"] == "gea.backup/1" and man["site"] == "Pad 3" and man["wells"] == [w["id"]] and man["users_json"] is True,
+        "members": "users.json" in names and "records/audit.jsonl" in names and "workspace.json" in names and "jobs/schedule.json" in names and bool(rec_files)
+                   and not any(n.startswith("jobs/run-") or "_uploads" in n for n in names),
+        "verify_ok": v1["status"] == "OK" and v1["n_files"] == r1["n_files"] and v1["archive_sha256_matches"] is True and side1,
+        "inside_refused": bool(inside_refused) and "inside the workspace" in inside_refused,
+        "restored_site": rr["site"] == "Pad 3" and rr["wells"] == [w["id"]] and rr["users_json"] is True and ws2.manifest["name"] == "Pad 3" and ws2.wells()[0]["id"] == w["id"],
+        "restored_note_audit": os.path.isfile(d / "restored" / "restored_from.json") and any(a["action"] == "backup.restore" for a in ws2.audit_log()),
+        "restored_accounts": Users(str(d / "restored" / "users.json")).check("op", "operator-pass-1") is not None,
+        "nonempty_refused": bool(nonempty_refused) and "empty folder" in nonempty_refused,
+        "tampered": vbad["status"] == "FAIL" and vbad["mismatched"] == ["workspace.json"] and bool(tampered_refused) and "does not verify" in tampered_refused,
+        "pruned": len(left) == 2 and os.path.basename(r3["path"]) in left and os.path.basename(r1["path"]) not in left and r3["pruned"] == [os.path.basename(r1["path"])],
+        "audited": any(a["action"] == "backup.make" for a in ws.audit_log()),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "BL1 the site copied off the machine: one dated archive carrying every well's source and records, users.json, the audit log, the manifest "
+       "and the schedule - never the job run folders or the upload scratch - with MANIFEST.json (site, version, every file's SHA-256) inside and the "
+       "archive's own hash beside it; verify reads OK; status turns from NEVER to current; a folder inside the workspace is refused; the archive "
+       "restored onto an empty folder opens as the same site with the same well, the same accounts and a restored_from note, and a second restore "
+       "onto it is refused; a tampered archive fails verify naming the file and is refused by restore; --keep prunes the oldest; both in the audit"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- the doctor, the service, the page, the CLI ------------------------------------------------------------------
+    wsp2 = str(d / "ws2"); ws3 = Workspace.create(wsp2, "Pad 3", actor="tester")
+    users3 = Users(str(Path(wsp2, "users.json"))); users3.add("adm", "admin-pass-1", "admin"); users3.add("op", "operator-pass-1", "operator")
+    f_never = [x for x in D.check_workspace(wsp2, port=0) if "backup" in x["what"]]
+    svc = Service(wsp2, port=0, scheduler=False).start()
+    base = 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 + 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 opener.open(req, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        call("POST", "/api/login", {"name": "op", "password": "operator-pass-1"})
+        st_op = call("GET", "/api/backup")[0]
+        call("POST", "/api/login", {"name": "adm", "password": "admin-pass-1"})
+        st_v0, v0 = call("GET", "/api/backup")
+        st_run0 = call("POST", "/api/backup/run", {})[0]
+        st_in = call("POST", "/api/backup/config", {"out_dir": os.path.join(wsp2, "records", "bk")})[0]
+        st_bad_t = call("POST", "/api/backup/config", {"out_dir": str(d / "off2"), "daily_at": "2:30"})[0]
+        st_cfg, cfg = call("POST", "/api/backup/config", {"out_dir": str(d / "off2"), "keep": 7, "daily_at": "02:30"})
+        st_run, job = call("POST", "/api/backup/run", {})
+        done = svc.app.runner.wait(job["id"], 120)
+        st_v1, v1s = call("GET", "/api/backup")
+        st_sch, sch = call("POST", "/api/backup/schedule", {})
+        st_v2, v2s = call("GET", "/api/backup")
+    finally:
+        svc.stop()
+    f_after = [x for x in D.check_workspace(wsp2, port=0) if "backup" in x["what"]]
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_md = (pkg / "help" / "backup.md").read_text(encoding="utf-8")
+    r_st0 = _sp.run([sys.executable, "-m", "gea", "backup", "--workspace", str(d / "ws3-none"), "--status"], capture_output=True, text=True)
+    r_st = _sp.run([sys.executable, "-m", "gea", "backup", "--workspace", wsp2, "--status"], capture_output=True, text=True)
+    r_v = _sp.run([sys.executable, "-m", "gea", "backup", "--verify", v1s["status"]["last"]["path"]], capture_output=True, text=True)
+    r_vbad = _sp.run([sys.executable, "-m", "gea", "backup", "--verify", bad], capture_output=True, text=True)
+    r_rs = _sp.run([sys.executable, "-m", "gea", "backup", "--restore", v1s["status"]["last"]["path"], "--to", str(d / "restored3")], capture_output=True, text=True)
+    c2 = {
+        "doctor_never": len(f_never) == 1 and f_never[0]["level"] == "warn" and "no backup has ever been taken" in f_never[0]["what"] and "gea backup" in f_never[0]["fix"],
+        "api_admin_only_and_empty": st_op == 403 and st_v0 == 200 and v0["status"]["never"] is True and v0["schedule"] is None and v0["config"]["out_dir"] == "",
+        "config_refusals": st_run0 == 400 and st_in == 400 and st_bad_t == 400 and st_cfg == 200 and cfg["keep"] == 7,
+        "job_ran": st_run == 200 and done["status"] == "DONE" and st_v1 == 200 and v1s["status"]["never"] is False and v1s["status"]["present"] is True
+                   and os.path.isfile(v1s["status"]["last"]["path"]) and v1s["status"]["last"]["actor"] == "adm",
+        "scheduled": st_sch == 200 and sch["name"] == "backup-daily" and sch["daily_at"] == "02:30" and sch["args"][0] == "backup" and "--keep" in sch["args"]
+                     and v2s["schedule"] is not None and v2s["schedule"]["name"] == "backup-daily",
+        "doctor_after": len(f_after) == 1 and f_after[0]["level"] == "ok" and "last backup" in f_after[0]["what"],
+        "page": "The backup" in page_src and "/api/backup/run" in page_src and "/api/backup/schedule" in page_src,
+        "cli_status": r_st0.returncode == 1 and "NEVER" in r_st0.stdout and r_st.returncode == 0 and "current" in r_st.stdout,
+        "cli_verify": r_v.returncode == 0 and "OK" in r_v.stdout and r_vbad.returncode == 1 and "workspace.json" in r_vbad.stdout,
+        "cli_restore": r_rs.returncode == 0 and "users.json present" in r_rs.stdout,
+        "help": any(t["topic"] == "backup" for t in H.topics()) and not H.check("backup") and "never restored" in help_md.split("will not call a measurement")[1],
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "BL2 the doctor warns NEVER until a backup exists and says when the last one was afterwards; the Audit / Update page's backup card (admin only) "
+       "refuses a folder inside the workspace and a malformed hour, saves the folder and the keep count, runs the backup as a job that the status then "
+       "shows with its actor, and schedules it daily as the `backup-daily` entry; `gea backup --status` exits 1 on NEVER and 0 when current, "
+       "`--verify` says OK or names the tampered file, `--restore` brings the accounts back; the help page says a backup never restored is a hope"
+       + (f" [failed: {', '.join(failed2)}; r_st0={r_st0.stdout[-120:]!r} {r_st0.stderr[-120:]!r}]" if failed2 else ""))
+
+
+def section_bm_month_end(tmp: str) -> None:
+    """Section BM - the month-end packet: the refresh for the period, every report collected with INCLUDED or NOT
+    AVAILABLE and the reason, the index and the manifest, the archive, the records; the page, the job and the
+    monthly schedule."""
+    import http.cookiejar
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import zipfile
+    from . import month_end as ME
+    from . import helplib as H
+    from .telemetry import TelemetryRecorder, TelemetryConfig
+    from .downhole_engine import DownholeEngine, SimulatorConfig
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bm"); d.mkdir()
+    hist = str(d / "hist.csv")
+    TelemetryRecorder(engine=DownholeEngine(SimulatorConfig()), config=TelemetryConfig(duration_hours=2.0, seed=5)).run().export_csv(hist)
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w = ws.add_well_file(hist, display="SWD 1", actor="tester")
+    site = ws.add_site("Pad 3 site", wells=[w["id"]], actor="tester")
+    bad_period = None
+    try:
+        ME.period_bounds("2026-9")
+    except ValueError as e:
+        bad_period = str(e)
+    pb = ME.period_bounds("2026-02")
+    rec = ME.assemble(ws, "2026-09", actor="tester")
+    idx = json.loads((Path(rec["folder"]) / "INDEX.json").read_text(encoding="utf-8"))
+    man = json.loads((Path(rec["folder"]) / "MANIFEST.json").read_text(encoding="utf-8"))
+    by_name = {i["name"]: i for i in idx["items"]}
+    v_folder = ME.verify(rec["folder"]); v_zip = ME.verify(rec["archive"])
+    with zipfile.ZipFile(rec["archive"]) as z:
+        znames = set(z.namelist())
+    # a second assembly of the same period rebuilds whole; a future month is OPEN
+    rec2 = ME.assemble(ws, "2026-09", actor="tester", refresh=False)
+    from datetime import datetime as _dt, timezone as _tz
+    now = _dt.now(_tz.utc)
+    cur = f"{now.year:04d}-{now.month:02d}"
+    rec3 = ME.assemble(ws, cur, actor="tester", refresh=False)
+    pk = ME.packets(ws)
+    audit = [a["action"] for a in ws.audit_log()]
+    c1 = {
+        "period_checked": bool(bad_period) and "YYYY-MM" in bad_period and pb["days"] == 28 and pb["start"] == "2026-02-01T00:00:00Z" and pb["end"] == "2026-02-28T23:59:59Z" and pb["closed"] is True,
+        "included": by_name["SWD 1: gauge drift report"]["status"] == "INCLUDED" and by_name["SWD 1: alarm event report"]["status"] == "INCLUDED"
+                    and by_name["SLA month 2026-09"]["status"] == "INCLUDED" and by_name["Accuracy statement"]["status"] == "INCLUDED"
+                    and by_name["Pad 3 site: site report"]["status"] == "INCLUDED" and by_name["Model cards and SBOM"]["status"] == "INCLUDED",
+        "not_available_with_reason": by_name["SWD 1: machine vibration"]["status"] == "NOT AVAILABLE" and "no machine record" in by_name["SWD 1: machine vibration"]["reason"]
+                    and by_name["Pad 3 site: SRA packet for 2026-09"]["status"] == "NOT AVAILABLE" and "no Seismicity Response Area" in by_name["Pad 3 site: SRA packet for 2026-09"]["reason"]
+                    and "no certificate register" in by_name["SWD 1: certificate conformity (ISO/IEC 17025 7.8)"]["reason"],
+        "files_hashed": all(f["sha256"] and f["bytes"] > 0 for i in idx["items"] for f in i["files"]) and man["n_files"] == len(man["files"]) and man["n_files"] >= 20
+                    and "wells/SWD-1/gauge_drift_report.html" in man["files"] and "site/sla_report_2026-09.html" in man["files"] and "INDEX.html" in man["files"],
+        "record": rec["included"] == len([i for i in idx["items"] if i["status"] == "INCLUDED"]) and rec["closed"] is True and rec["errors"] == [] and os.path.isfile(rec["archive"])
+                    and os.path.isfile(rec["archive"] + "") and rec["archive"].endswith("month_end_Pad-3_2026-09.zip"),
+        "verify": v_folder["status"] == "OK" and v_zip["status"] == "OK" and v_zip["n_files"] == man["n_files"] and "MANIFEST.json" in znames and "INDEX.html" in znames,
+        "rebuilt_whole_and_open": rec2["generated_utc"] >= rec["generated_utc"] and rec2["refresh"] is False and rec3["closed"] is False and "OPEN" in (Path(rec3["folder"]) / "INDEX.md").read_text(encoding="utf-8")
+                    and len(pk) == 3 and all(p["present"] for p in pk) and pk[-1]["period"] == cur,
+        "audited": audit.count("month_end.assemble") == 3 and "dashboard.refresh" in audit and "site.report" in audit,
+        "not_a_measurement": "does not call a measurement" in (Path(rec["folder"]) / "INDEX.md").read_text(encoding="utf-8"),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "BM1 the month-end packet: the period checked (YYYY-MM; February's 28 days; a past month closed), the refresh run for it, every report "
+       "collected - the well's drift and alarm reports, the SLA month, the accuracy statement, the site report, the model cards - INCLUDED with "
+       "hashed files, and the vibration report, the SRA packet and the certificate conformity NOT AVAILABLE with the reason that names what the "
+       "site lacks; INDEX and MANIFEST written, the archive verifies against the manifest, a second assembly rebuilds the period whole, the "
+       "current month is marked OPEN, every packet on record, every assembly in the audit"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- the page, the job, the schedule, the CLI, the help --------------------------------------------------------
+    users = Users(str(Path(wsp, "users.json"))); users.add("op", "operator-pass-1", "operator"); users.add("adm", "admin-pass-1", "admin")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base = 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 + 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 opener.open(req, timeout=300) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        call("POST", "/api/login", {"name": "op", "password": "operator-pass-1"})
+        st_l, lst = call("GET", "/api/month-end")
+        st_bad = call("POST", "/api/month-end/run", {"period": "Sept 2026"})[0]
+        st_sched_op = call("POST", "/api/month-end/schedule", {"day": 1, "at": "03:00"})[0]
+        st_run, job = call("POST", "/api/month-end/run", {"period": "2026-08", "no_refresh": True})
+        done = svc.app.runner.wait(job["id"], 300)
+        st_l2, lst2 = call("GET", "/api/month-end")
+        req = urllib.request.Request(base + "/reports/month_end/2026-08/INDEX.html"); req.add_header("X-GEA-Action", "1")
+        with opener.open(req, timeout=60) as rr_:
+            html_ok = rr_.status == 200 and b"Month-End Packet" in rr_.read()
+        call("POST", "/api/login", {"name": "adm", "password": "admin-pass-1"})
+        st_sched_bad = call("POST", "/api/month-end/schedule", {"day": 31, "at": "03:00"})[0]
+        st_sched, sch = call("POST", "/api/month-end/schedule", {"day": 2, "at": "03:15"})
+        st_l3, lst3 = call("GET", "/api/month-end")
+    finally:
+        svc.stop()
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_md = (pkg / "help" / "month-end.md").read_text(encoding="utf-8")
+    r_cli = _sp.run([sys.executable, "-m", "gea", "workspace", "--path", wsp, "--action", "month-end", "--period", "2026-07", "--no-refresh"], capture_output=True, text=True)
+    r_prev = _sp.run([sys.executable, "-m", "gea", "workspace", "--path", wsp, "--action", "month-end", "--no-refresh"], capture_output=True, text=True)
+    c2 = {
+        "list": st_l == 200 and len(lst["packets"]) == 3 and lst["previous"] == ME.previous_period() and lst["schedule"] is None,
+        "refusals": st_bad == 400 and st_sched_op == 403 and st_sched_bad == 400,
+        "job": st_run == 200 and done["status"] == "DONE" and st_l2 == 200 and any(p["period"] == "2026-08" and p["present"] for p in lst2["packets"]) and html_ok,
+        "schedule": st_sched == 200 and sch["name"] == "month-end-monthly" and sch["monthly_day"] == 2 and sch["daily_at"] == "03:15" and "previous" in sch["args"]
+                    and st_l3 == 200 and lst3["schedule"]["name"] == "month-end-monthly",
+        "page": "Month-end packet" in page_src and "/api/month-end/run" in page_src and "/api/month-end/schedule" in page_src,
+        "cli": r_cli.returncode == 0 and "month-end 2026-07 (closed)" in r_cli.stdout and r_prev.returncode == 0 and f"month-end {ME.previous_period()} (closed)" in r_prev.stdout,
+        "help": any(t["topic"] == "month-end" for t in H.topics()) and not H.check("month-end") and "does not recompute" in help_md.split("will not call a measurement")[1],
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "BM2 the Reports page carries the packet card: the packets on record with their index and archive, the period defaulting to the last closed "
+       "month, Assemble as a job (a malformed period refused) whose INDEX the page then serves, Schedule monthly for an administrator only (day 1..28) "
+       "as the `month-end-monthly` entry for the previous month; `gea workspace --action month-end` with a period or with 'previous'; the help page "
+       "says the index collects and does not recompute"
+       + (f" [failed: {', '.join(failed2)}; cli={r_cli.stdout[-200:]!r} {r_cli.stderr[-200:]!r}]" if failed2 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:
@@ -5785,6 +6062,8 @@ def main() -> int:
         section_bi_conformance(tmp)
         section_bj_etp(tmp)
         section_bk_seedlink(tmp)
+        section_bl_backup(tmp)
+        section_bm_month_end(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS: