gea-program 0.8.0__tar.gz → 0.9.0__tar.gz

{gea_program-0.8.0 → gea_program-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.8.0
+Version: 0.9.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 (302 checks)
+gea accept                     # the product gate (308 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]")
@@ -528,6 +528,29 @@ so one geophone can still say when each rig was working - and the Seismic
 Station Report and the station page carry the section, with the tracks drawn
 against time.
 
+### The Seismicity Response Area packet
+
+The Railroad Commission of Texas declares a Seismicity Response Area around a
+cluster of felt earthquakes and expects the operators inside it to run a
+response plan. The plans on file have one shape - a circle of about 9 km, a
+plan written against M 3.5, an 18-month goal, a response group meeting
+within 48 hours of a threshold event, quarterly checkpoints with Commission
+staff, disposal wells in two tiers by the base of the Wolfcamp - and the
+Commission's December 2023 Notice to Operators names the data: four daily
+parameters (maximum and average surface injection pressure, injection
+volume, maximum injection rate) and three bottomhole-pressure methods, one
+of which is a permanent downhole probe. `gea/sra.py` builds the packet to
+that shape from what the site holds. The operator declares what the program
+cannot measure (`set-well`: surface position and datum, API and UIC, depth
+tier, which channels are the pressure, the rate and the downhole gauge, the
+BHP method); `sra-define` puts the area on the site; `sra-report --catalog
+texnet.csv` writes the packet - membership by geodesic distance, the daily
+record per well rolled up by month, the catalogue's events against the plan
+with the trigger and the goal clock, the schedule, and every gap by name -
+and a daily export under the Notice's own parameter names. It will not
+invent a volume for a well with no rate channel, a tier from depth alone, or
+an aftershock: those are declarations, and the packet says so.
+
 ### Audit / Update
 
 The Audit / Update tab holds three things. The whole audit log

{gea_program-0.8.0 → gea_program-0.9.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 (302 checks)
+gea accept                     # the product gate (308 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]")
@@ -489,6 +489,29 @@ so one geophone can still say when each rig was working - and the Seismic
 Station Report and the station page carry the section, with the tracks drawn
 against time.
 
+### The Seismicity Response Area packet
+
+The Railroad Commission of Texas declares a Seismicity Response Area around a
+cluster of felt earthquakes and expects the operators inside it to run a
+response plan. The plans on file have one shape - a circle of about 9 km, a
+plan written against M 3.5, an 18-month goal, a response group meeting
+within 48 hours of a threshold event, quarterly checkpoints with Commission
+staff, disposal wells in two tiers by the base of the Wolfcamp - and the
+Commission's December 2023 Notice to Operators names the data: four daily
+parameters (maximum and average surface injection pressure, injection
+volume, maximum injection rate) and three bottomhole-pressure methods, one
+of which is a permanent downhole probe. `gea/sra.py` builds the packet to
+that shape from what the site holds. The operator declares what the program
+cannot measure (`set-well`: surface position and datum, API and UIC, depth
+tier, which channels are the pressure, the rate and the downhole gauge, the
+BHP method); `sra-define` puts the area on the site; `sra-report --catalog
+texnet.csv` writes the packet - membership by geodesic distance, the daily
+record per well rolled up by month, the catalogue's events against the plan
+with the trigger and the goal clock, the schedule, and every gap by name -
+and a daily export under the Notice's own parameter names. It will not
+invent a volume for a well with no rate channel, a tier from depth alone, or
+an aftershock: those are declarations, and the packet says so.
+
 ### Audit / Update
 
 The Audit / Update tab holds three things. The whole audit log

{gea_program-0.8.0 → gea_program-0.9.0}/gea/__init__.py

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

{gea_program-0.8.0 → gea_program-0.9.0}/gea/__main__.py

@@ -281,9 +281,33 @@ def main(argv=None) -> int:
     p_ws.add_argument("--action", type=str, default="list",
                       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"])
+                               "seismic-dataset", "seismic-field", "add-site", "sites", "site-report", "remove-site", "rename",
+                               "set-well", "sra-define", "sra-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")
+    p_ws.add_argument("--uic", type=str, default=None, help="set-well: the UIC permit number")
+    p_ws.add_argument("--depth-tier", type=str, choices=["shallow", "deep"], default=None, help="set-well: above or below the named formation base")
+    p_ws.add_argument("--formation", type=str, default=None, help="set-well: the basis of the tier, e.g. 'completed below the base of the Wolfcamp'")
+    p_ws.add_argument("--channel-pressure", type=str, default=None, help="set-well: the channel that is the surface injection pressure (psi)")
+    p_ws.add_argument("--channel-rate", type=str, default=None, help="set-well: the channel that is the injection rate")
+    p_ws.add_argument("--rate-unit", type=str, default=None, help="set-well: the rate channel's unit: bbl/min or bbl/d")
+    p_ws.add_argument("--bhp-method", type=str, choices=["calculated", "dip_in", "probe"], default=None, help="set-well: how bottomhole pressure is known")
+    p_ws.add_argument("--channel-bhp", type=str, default=None, help="set-well: the downhole gauge channel (probe method)")
+    p_ws.add_argument("--top-interval-ft", type=float, default=None, help="set-well: top of the disposal interval, ft (calculated method)")
+    p_ws.add_argument("--gradient-psi-ft", type=float, default=None, help="set-well: fluid gradient, psi/ft (calculated method)")
+    p_ws.add_argument("--radius-km", type=float, default=None, help="sra-define: the area's radius in km (Gardendale: 9.08)")
+    p_ws.add_argument("--plan-date", type=str, default=None, help="sra-define: the plan date, YYYY-MM-DD")
+    p_ws.add_argument("--threshold-m", type=float, default=3.5, help="sra-define: the magnitude the plan is written against (3.5)")
+    p_ws.add_argument("--goal-months", type=int, default=18, help="sra-define: months without a threshold event that meet the goal (18)")
+    p_ws.add_argument("--response-hours", type=int, default=48, help="sra-define: hours within which the response group meets (48)")
+    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("--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")
     p_ws.add_argument("--wells", type=str, nargs="+", default=None, help="add-site: well ids of this workspace")
     p_ws.add_argument("--seismic", type=str, nargs="+", default=None, help="add-site: seismic station ids of this workspace")
     p_ws.add_argument("--tracks", type=str, nargs="+", default=None, help="add-site: track ids of this workspace")
@@ -362,6 +386,9 @@ def main(argv=None) -> int:
     p_w0.add_argument("--seed", type=int, default=1)
     p_w0.add_argument("--connect", type=str, default=None, help="host:port - instead of listening, connect to a listening tap and push frames")
 
+    p_sra = sub.add_parser("sra", help="the Seismicity Response Area packet: the self-test on a labelled scene")
+    p_sra.add_argument("--action", choices=["selftest"], default="selftest")
+    p_sra.add_argument("--json", action="store_true")
     p_dr = sub.add_parser("doctor", help="which code is running and can it serve: Python, the package, duplicates, the page, PyPI; with --workspace also the site folder and the port")
     p_dr.add_argument("--workspace", type=str, default=None)
     p_dr.add_argument("--host", type=str, default="127.0.0.1")
@@ -1443,6 +1470,18 @@ 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 == "sra":
+        from . import sra as _SRA
+        r = _SRA.selftest()
+        if a.json:
+            print(json.dumps({k: v for k, v in r.items() if k != "packet"}, indent=1))
+        else:
+            print(f"sra selftest [{r['label']}]: {r['status']}")
+            for k, v in r["checks"].items():
+                print(f"  {'ok ' if v else 'BAD'} {k}")
+            print(f"  deep well volume {r['deep_mean_volume_bbl_day']} bbl/day; probe offset {r['probe_offset_psi']} psi")
+            print(_SRA.report_text(r["packet"]))
+        return 0 if r["status"] == "OK" else 1
     elif a.cmd == "doctor":
         from .doctor import run as _doctor
         return _doctor(a.workspace, a.host, a.port, a.json)
@@ -1630,6 +1669,34 @@ def main(argv=None) -> int:
                 if not a.site:
                     raise SystemExit("remove-site needs --site <id>")
                 ws.remove_site(a.site, actor=a.actor); print("removed (folder kept):", a.site); return 0
+            elif a.action == "set-well":
+                if not a.well:
+                    raise SystemExit("set-well needs --well <id>")
+                surface = {"lat": a.lat, "lon": a.lon, "datum": a.datum} if (a.lat is not None or a.lon is not None) else None
+                disposal = {k: v for k, v in {"api_number": a.api, "uic_number": a.uic, "depth_tier": a.depth_tier, "formation_basis": a.formation,
+                                              "channel_pressure": a.channel_pressure, "channel_rate": a.channel_rate, "rate_unit": a.rate_unit,
+                                              "bhp_method": a.bhp_method, "channel_bhp": a.channel_bhp, "top_interval_ft": a.top_interval_ft,
+                                              "gradient_psi_ft": a.gradient_psi_ft}.items() if v is not None}
+                if not surface and not disposal:
+                    raise SystemExit("set-well: nothing to declare (give --lat/--lon, or any of --api --uic --depth-tier --channel-pressure ...)")
+                w = ws.set_well(a.well, surface=surface, disposal=disposal or None, actor=a.actor)
+                print(f"well {a.well}: surface {w.get('surface')}; disposal {w.get('disposal')}"); return 0
+            elif a.action == "sra-define":
+                if not a.site or not a.name or a.lat is None or a.lon is None or a.radius_km is None or not a.plan_date:
+                    raise SystemExit("sra-define needs --site, --name, --lat, --lon, --radius-km and --plan-date")
+                sra = ws.sra_define(a.site, actor=a.actor, name=a.name, lat=a.lat, lon=a.lon, radius_km=a.radius_km, plan_date=a.plan_date,
+                                    datum=a.datum or "WGS84", threshold_m=a.threshold_m, goal_months=a.goal_months, response_hours=a.response_hours,
+                                    checkpoint_months=a.checkpoint_months, formation_boundary=a.formation_boundary,
+                                    triggering_event=a.triggering_event, note=a.note or "")
+                print(f"sra: {sra['name']} on site {a.site} - {sra['radius_km']} km around {sra['centre']['lat']}, {sra['centre']['lon']} "
+                      f"({sra['centre']['datum']}); plan {sra['plan_date']}; M {sra['threshold_m']}; goal {sra['goal_months']} months"); return 0
+            elif a.action == "sra-report":
+                from .sra import report_text as _sra_text
+                if not a.site:
+                    raise SystemExit("sra-report needs --site <id>")
+                r = ws.write_sra_packet(a.site, catalog_csv=a.catalog, aftershocks=a.aftershocks, start=a.start, end=a.end, actor=a.actor)
+                print(_sra_text(r["packet"]))
+                print("  report:", r["paths"]["html"]); print("  daily export:", r["paths"]["daily_csv"], f"({r['export_rows']} rows)"); return 0
             elif a.action == "seismic-dataset":
                 r = ws.write_seismic_dataset_report(actor=a.actor)
                 inv = r["inventory"]

{gea_program-0.8.0 → gea_program-0.9.0}/gea/acceptance_tests.py

@@ -2914,7 +2914,8 @@ def section_am_report_samples(tmp: str) -> None:
             "model_card_well_baseline.html", "model_card_well_test_detector.html", "model_card_rock_density_inventory.html",
             "model_card_strata_property_estimator.html", "gauge_drift_report_monitored_SYNTHETIC.html", "alarm_event_report_SYNTHETIC.html",
             "data_resilience_report_SYNTHETIC.html", "sla_report_SYNTHETIC.html", "sat_protocol.html", "seismic_station_report_SYNTHETIC.html", "seismic_track_report_SYNTHETIC.html",
-            "seismic_dataset_report_SYNTHETIC.html", "seismic_field_report_SYNTHETIC.html", "site_report_SYNTHETIC.html"}
+            "seismic_dataset_report_SYNTHETIC.html", "seismic_field_report_SYNTHETIC.html", "site_report_SYNTHETIC.html",
+            "sra_packet_SYNTHETIC.html"}
     have = {p.name for p in d.glob("*.html")}
     md = (d / "SAMPLES.md").read_text(encoding="utf-8") if (d / "SAMPLES.md").exists() else ""
     texts = {n: (d / n).read_text(encoding="utf-8", errors="replace") for n in sorted(have & want)}
@@ -4430,27 +4431,51 @@ def section_bb_supervisor(tmp: str) -> None:
        "happens to share a recycled process id is still reported, and a process id that is not the last start's excludes nothing")
 
     # -- the exit code reaches the launcher, and the launcher acts on it -------------------
-    spec = importlib.util.spec_from_file_location("bb_installer", str(pkg.parent / "tools" / "build_installer.py"))
-    bi = importlib.util.module_from_spec(spec); spec.loader.exec_module(bi)
-    cmd = bi.WIN_SCRIPTS["start-dashboard.cmd"]; sh = bi.LINUX_SCRIPTS["start-dashboard.sh"]
-    body = [ln for ln in cmd.strip().splitlines() if ln.strip() and not ln.strip().lower().startswith("rem ")]
-    labels = set(_re.findall(r"^:(\w+)", cmd, _re.M)); gotos = set(_re.findall(r"goto\s+(\w+)", cmd))
-    ok("title GEA - Operations Control Panel" in cmd
-       and '"%GEA_RC%"=="86"' in cmd and "goto gea_run" in cmd and not gotos - labels
-       and body[-1].lower().startswith("powershell") and "-NoExit" in body[-1] and "start-dashboard.cmd" in body[-1]
-       and "python" not in body[-1].lower().split("write-host")[0]
-       and 'rc" = "86"' in sh and "continue" in sh and sh.count("exit \"$rc\"") == 1,
-       "BB3 the Windows launcher names the window, runs the panel again when it exits with 86, resolves every label it jumps to, and ends by handing "
-       "the window to a PowerShell prompt that says how to start the panel again - it never falls back to the shell underneath, which is how an "
-       "operator was left at a Python prompt; the shell launcher does the same with a loop")
-    ok("auto_restart.flag" in cmd and "auto_restart.flag" in sh
-       and "GEA_FAILS" in cmd and "GTR 5" in cmd and "fails" in sh and "-le 5" in sh
-       and SV.AUTO_MAX == 5
-       and cmd.splitlines()[cmd.splitlines().index(":gea_read_flag") + 1].strip().startswith("set /p GEA_AUTO=<")
-       and cmd.count("set /p GEA_AUTO=<") == 1,
+    # In a checkout the launchers are the templates in tools/build_installer.py. In an installed kit there
+    # is no tools/ - the launcher under test is the one the kit installed beside its python/, found the way
+    # doctor finds it. (The v0.8.0 kit gate failed on GitHub reading tools/ from site-packages.)
+    from .doctor import check_launcher, check_workspace, kit_dir
+    cmd = sh = None
+    tools_py = pkg.parent / "tools" / "build_installer.py"
+    if (pkg.parent / "pyproject.toml").exists() and tools_py.exists():
+        spec = importlib.util.spec_from_file_location("bb_installer", str(tools_py))
+        bi = importlib.util.module_from_spec(spec); spec.loader.exec_module(bi)
+        cmd = bi.WIN_SCRIPTS["start-dashboard.cmd"]; sh = bi.LINUX_SCRIPTS["start-dashboard.sh"]; where = "the checkout's templates"
+    else:
+        kd = kit_dir(); where = f"the installed kit at {kd}"
+        if kd and os.path.isfile(os.path.join(kd, "start-dashboard.cmd")):
+            cmd = open(os.path.join(kd, "start-dashboard.cmd"), encoding="utf-8", errors="replace").read()
+        if kd and os.path.isfile(os.path.join(kd, "start-dashboard.sh")):
+            sh = open(os.path.join(kd, "start-dashboard.sh"), encoding="utf-8", errors="replace").read()
+    cmd_ok = sh_ok = True
+    if cmd is not None:
+        body = [ln for ln in cmd.strip().splitlines() if ln.strip() and not ln.strip().lower().startswith("rem ")]
+        labels = set(_re.findall(r"^:(\w+)", cmd, _re.M)); gotos = set(_re.findall(r"goto\s+(\w+)", cmd))
+        cmd_ok = ("title GEA - Operations Control Panel" in cmd
+                  and '"%GEA_RC%"=="86"' in cmd and "goto gea_run" in cmd and not gotos - labels
+                  and body[-1].lower().startswith("powershell") and "-NoExit" in body[-1] and "start-dashboard.cmd" in body[-1]
+                  and "python" not in body[-1].lower().split("write-host")[0])
+    if sh is not None:
+        sh_ok = 'rc" = "86"' in sh and "continue" in sh and sh.count("exit \"$rc\"") == 1
+    ok((cmd is not None or sh is not None) and cmd_ok and sh_ok,
+       f"BB3 the launcher ({where}): the Windows one names the window, runs the panel again when it exits with 86, resolves every label it jumps "
+       "to, and ends by handing the window to a PowerShell prompt that says how to start the panel again - it never falls back to the shell "
+       "underneath, which is how an operator was left at a Python prompt; the shell one does the same with a loop")
+    cmd_ok = sh_ok = True
+    if cmd is not None:
+        lines = cmd.splitlines()
+        cmd_ok = ("auto_restart.flag" in cmd and "GEA_FAILS" in cmd and "GTR 5" in cmd and ":gea_read_flag" in lines
+                  and lines[lines.index(":gea_read_flag") + 1].strip().startswith("set /p GEA_AUTO=<") and cmd.count("set /p GEA_AUTO=<") == 1)
+    if sh is not None:
+        sh_ok = "auto_restart.flag" in sh and "fails" in sh and "-le 5" in sh
+    ok(SV.AUTO_MAX == 5 and cmd_ok and sh_ok,
        "BB4 a code that is neither 0 nor 86 is a death, not a decision: the launcher reads the operator's answer from records/auto_restart.flag, "
        "tries at most five times in a row so a panel that crashes while starting hands over the error instead of flickering all night, and reads "
        "that file outside an if-block because a redirect inside parentheses is parsed before the block runs")
+    if cmd is None:                                  # a Linux kit: BB6 needs a Windows launcher text to build its good and bad kits from
+        cmd = ("@echo off\ntitle GEA - Operations Control Panel\n:gea_run\npython\\python.exe -m gea serve\nset GEA_RC=%ERRORLEVEL%\n"
+               "if \"%GEA_RC%\"==\"86\" goto gea_run\n:gea_read_flag\nset /p GEA_AUTO=<\"%GEA_WORKSPACE%\\records\\auto_restart.flag\"\n"
+               "powershell.exe -NoLogo -NoExit -Command \"Write-Host 'start-dashboard.cmd'\"\n")
 
     # -- the flag file: what the launcher will read, not what the manifest says ------------
     ok(SV.auto_restart(wsp) is False and SV.set_auto_restart(wsp, True) is True and SV.auto_restart(wsp) is True
@@ -4461,7 +4486,6 @@ def section_bb_supervisor(tmp: str) -> None:
        "unreadable flag reads as off, since a program does not start itself again on the strength of a file nobody can be sure about")
 
     # -- doctor reads the installed launcher ----------------------------------------------
-    from .doctor import check_launcher, check_workspace, kit_dir
     good = d / "kit_good"; (good / "python").mkdir(parents=True)
     (good / "start-dashboard.cmd").write_text(cmd, encoding="utf-8")
     bad = d / "kit_bad"; (bad / "python").mkdir(parents=True)
@@ -4570,9 +4594,139 @@ def section_bb_supervisor(tmp: str) -> None:
        "panel's own page carries the Stop and Restart controls, the authorisation step behind a popup, and the auto-restart switch")
 
 
+def section_bc_sra(tmp: str) -> None:
+    """Section BC - the Seismicity Response Area packet. The Railroad Commission's operator-led response plans
+    and its Notice to Operators on disposal-well monitoring name a shape; the packet is built to it from what
+    the site holds, and names what it is missing rather than leaving a column blank."""
+    import csv as _csv
+    import subprocess as _sp
+    from datetime import datetime as _dt, timedelta as _td, timezone as _tz
+    from . import sra as SR
+    from .client_reports import forbidden_terms, sra_packet_report, write
+    from .workspace import Workspace, WorkspaceError
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bc"); d.mkdir()
+
+    # -- the self-test: the labelled scene ----------------------------------------------
+    r = SR.selftest()
+    ok(r["status"] == "OK" and all(r["checks"].values()) and r["label"] == "SIMULATION_SELF_TEST"
+       and abs(r["deep_mean_volume_bbl_day"] - 8640.0) / 8640.0 < 0.03 and abs(r["probe_offset_psi"] - 0.465 * 9800) < 15,
+       "BC1 the self-test on a labelled scene: membership by geodesic distance with a NAD27 well's shift named, the four daily parameters from "
+       "the well's own channels with the volume integrated from the rate to within 3 %, two shut-in days at zero, the probe's offset from "
+       "surface pressure recovered, the shallow well refusing a volume it has no rate channel for, the catalogue's trigger and exempt "
+       "aftershock and goal clock, the gaps named, the checkpoints from the plan date")
+
+    # -- the area: declarations, refused when not an area --------------------------------
+    sra = SR.define("Test SRA", 31.95, -102.25, 9.08, "2026-02-25", "NAD27", triggering_event="x")
+    bad = 0
+    for kw in ({"datum": "UNKNOWN"}, {"radius_km": 0}, {"plan_date": "not a date"}, {"name": "  "}):
+        try:
+            SR.define(**{**{"name": "T", "lat": 31.95, "lon": -102.25, "radius_km": 9.08, "plan_date": "2026-02-25", "datum": "WGS84"}, **kw}); 
+        except ValueError:
+            bad += 1
+    cps = SR.checkpoints(sra)
+    ok(sra["centre"]["datum"] == "NAD27" and sra["centre_wgs84"]["shift_m"] > 10 and sra["area_km2"] == 259.0 and sra["threshold_m"] == 3.5
+       and sra["goal_months"] == 18 and sra["response_hours"] == 48 and sra["checkpoint_months"] == 3 and bad == 4
+       and [c["date"] for c in cps][:2] == ["2026-05-25", "2026-08-25"] and cps[-1]["n"] == "goal" and cps[-1]["date"] == "2027-08-25"
+       and "not a measurement" in " ".join(sra["not_a_measurement"]).lower().replace("never derived here", "not a measurement"),
+       "BC2 an area is a centre on a stated datum (carried to WGS84 with its shift named), a radius, a plan date and the plan's numbers - "
+       "M 3.5, 18 months, 48 hours, quarterly - recorded as declarations; an unknown datum, a zero radius, a non-date or a blank name is refused; "
+       "the checkpoints fall every three months from the plan date and the goal date closes the list")
+
+    # -- the catalogue reader: a TexNet-shaped export ------------------------------------
+    cat = d / "texnet.csv"
+    with open(cat, "w", newline="") as f:
+        w = _csv.writer(f); w.writerow(["EventID", "Origin Date", "Origin Time", "Local Magnitude", "Latitude", "Longitude", "Depth of Hypocenter (Km)"])
+        w.writerow(["texnet2026aaaa", "2026-02-20", "04:15:10", "4.4", "31.950", "-102.250", "7.2"])      # before the plan date
+        w.writerow(["texnet2026aaab", "2026-03-05", "11:02:33", "3.7", "31.960", "-102.240", "6.8"])      # counts
+        w.writerow(["texnet2026aaac", "2026-03-06", "01:00:00", "3.6", "31.955", "-102.245", "6.5"])      # declared aftershock
+        w.writerow(["texnet2026aaad", "2026-03-09", "21:40:00", "2.0", "31.940", "-102.260", "6.1"])
+        w.writerow(["texnet2026aaae", "2026-03-12", "03:00:00", "3.9", "32.500", "-102.700", "8.0"])      # outside
+        w.writerow(["", "", "", "", "", "", ""])                                                           # a blank line is skipped, not an event
+    c = SR.read_catalog(str(cat))
+    se = SR.seismicity(sra, c, as_of=_dt(2026, 4, 1, tzinfo=_tz.utc), aftershocks=["texnet2026aaac"])
+    ok(c["n_events"] == 5 and c["n_skipped"] == 1 and c["columns"]["origin_date"] == "Origin Date" and c["columns"]["origin_time"] == "Origin Time"
+       and c["events"][0]["time"] == "2026-02-20T04:15:10Z" and c["events"][0]["depth_km"] == 7.2
+       and se["n_inside"] == 4 and se["n_at_or_above"] == 3 and se["n_counted"] == 1 and se["n_exempt"] == 1
+       and se["largest"]["event_id"] == "texnet2026aaaa" and se["trigger"]["status"] == "TRIGGERED" and se["trigger"]["event_id"] == "texnet2026aaab"
+       and se["trigger"]["respond_by"] == "2026-03-07T11:02:33Z" and se["goal"]["clock_started"] == "2026-03-05" and se["goal"]["status"] == "RUNNING"
+       and se["goal"]["goal_date"] == "2027-09-05",
+       "BC3 a TexNet-shaped export is read by its column names (date and time in separate columns, the depth under its long name), a blank line "
+       "is skipped and counted; against the plan: the M 4.4 before the plan date is the largest but does not count, the declared aftershock is "
+       "exempt, the M 3.9 outside the circle is outside, the M 3.7 triggers the 48-hour response with its deadline, and the 18-month clock "
+       "starts from it")
+
+    # -- the daily record from a stream: refused without a calendar --------------------------------
+    from .ports import LiveStream, StreamChannel
+    import numpy as _np
+    st = LiveStream(name="x", source_format="synthetic", index_kind="time_s", index=_np.arange(100) * 600.0,
+                    channels={"P": StreamChannel("P", "psi", _np.full(100, 1500.0))}, meta={})
+    rr = SR.daily_records(st, {"channel_pressure": "P"})
+    sc = SR.synthetic_scene(days=3)
+    dr = SR.daily_records(sc["streams"]["deep-1"], {**sc["wells"][0]["disposal"], "rate_unit": "furlongs"})
+    ok(rr["status"] == "REFUSED" and "calendar" in rr["detail"]
+       and dr["parameters"]["injection_volume_bbl"]["status"] == "NOT RECORDED" and "furlongs" in dr["parameters"]["injection_volume_bbl"]["why"]
+       and dr["parameters"]["max_surface_injection_pressure_psi"]["status"] == "RECORDED",
+       "BC4 a daily record needs a calendar: a stream with no start time is refused, not dated from zero; a rate in a unit the program does not "
+       "convert leaves the volume NOT RECORDED with the unit named, while the pressures are still recorded")
+
+    # -- through the workspace and the command line ----------------------------------------
+    t0 = _dt(2026, 3, 1, tzinfo=_tz.utc); n = 6 * 144
+    hist = d / "swd.csv"
+    with open(hist, "w", newline="") as f:
+        w = _csv.writer(f); w.writerow(["timestamp", "P_surf_psi", "Q_bpm", "P_bh_psi"])
+        for i in range(n):
+            w.writerow([(t0 + _td(seconds=600 * i)).strftime("%Y-%m-%dT%H:%M:%SZ"), "1500.0", "5.0", f"{1500.0 + 0.465 * 9000:.1f}"])
+    ws = Workspace.create(str(d / "ws"), "Pad 3", actor="tester")
+    w1 = ws.add_well_file(str(hist), display="SWD 1", actor="tester")
+    try:
+        ws.set_well(w1["id"], disposal={"depth_tier": "middle"}, actor="tester"); tier_bad = False
+    except WorkspaceError:
+        tier_bad = True
+    run = lambda *a: _sp.run([sys.executable, "-m", "gea", "workspace", "--path", ws.path, "--actor", "tester", *a], capture_output=True, text=True)
+    r1 = run("--action", "set-well", "--well", w1["id"], "--lat", "31.96", "--lon", "-102.24", "--datum", "NAD27", "--api", "42-329-12345", "--uic", "123456",
+             "--depth-tier", "deep", "--formation", "completed below the base of the Wolfcamp", "--channel-pressure", "P_surf_psi", "--channel-rate", "Q_bpm",
+             "--rate-unit", "bbl/min", "--bhp-method", "probe", "--channel-bhp", "P_bh_psi")
+    r2 = run("--action", "add-site", "--name", "SRA block", "--wells", w1["id"], "--client", "Acme Operating")
+    r3 = run("--action", "sra-report", "--site", "SRA-block")                                        # no area yet: refused
+    r4 = run("--action", "sra-define", "--site", "SRA-block", "--name", "Test SRA", "--lat", "31.95", "--lon", "-102.25", "--datum", "WGS84",
+             "--radius-km", "9.08", "--plan-date", "2026-02-25")
+    r5 = run("--action", "sra-report", "--site", "SRA-block", "--catalog", str(cat), "--aftershocks", "texnet2026aaac")
+    ws2 = Workspace(ws.path)
+    out = Path(ws.path, "reports", "sites", "SRA-block")
+    rows = list(_csv.DictReader(open(out / "sra_daily_export.csv", encoding="utf-8")))
+    md = (out / "sra_packet.md").read_text(encoding="utf-8")
+    audit = Path(ws.path, "records", "audit.jsonl").read_text(encoding="utf-8")
+    pkj = json.loads((out / "sra_packet.json").read_text(encoding="utf-8"))["packet"]
+    ok(tier_bad and r1.returncode == 0 and r2.returncode == 0 and r3.returncode != 0 and "sra-define" in (r3.stderr + r3.stdout)
+       and r4.returncode == 0 and r5.returncode == 0 and "COMPLETE" in r5.stdout and "TRIGGERED" in r5.stdout
+       and ws2.site("SRA-block")["sra"]["name"] == "Test SRA" and pkj["status"] == "COMPLETE" and pkj["wells"][0]["inside"] and pkj["wells"][0]["depth_tier"] == "deep"
+       and len(rows) == 6 and rows[0]["API number"] == "42-329-12345" and rows[0]["UIC permit number"] == "123456"
+       and abs(float(rows[1]["Injection volume (barrels per day)"]) - 7200.0) < 10 and rows[1]["Maximum surface injection pressure (pounds per square inch)"] == "1500.0"
+       and abs(float(rows[1]["Bottomhole pressure (pounds per square inch)"]) - (1500 + 0.465 * 9000)) < 1 and rows[1]["BHP method"] == "probe"
+       and "Maximum surface injection pressure (pounds per square inch)" in rows[0]
+       and not forbidden_terms(md) and "well.declare" in audit and "site.sra_define" in audit and "site.sra_packet" in audit,
+       "BC5 `set-well` records what the operator declares - surface position and datum, API and UIC, depth tier by the named formation, which "
+       "channels are the surface pressure, the rate and the downhole gauge, the BHP method - and refuses a tier that is not shallow or deep; "
+       "`sra-define` puts the area on the site; `sra-report` is refused until it does; then the packet is COMPLETE for a well with everything "
+       "declared, the daily export carries the Notice's parameter names with the API and UIC on every line, the volume integrates to 7,200 bbl "
+       "a day from 5 bbl/min, the probe is the bottomhole pressure, the report passes the vocabulary gate, and every step is audited")
+
+    # -- the service offers it and the page carries it ------------------------------------------
+    svc_src = (pkg / "service.py").read_text(encoding="utf-8"); page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    r6 = _sp.run([sys.executable, "-m", "gea", "sra"], capture_output=True, text=True)
+    ok("'sra_report'" in svc_src and "sra_packet.html" in svc_src and "Seismicity Response Area</th>" in page_src and "sra-define" in page_src
+       and r6.returncode == 0 and "SIMULATION_SELF_TEST" in r6.stdout and "OK" in r6.stdout
+       and (pkg / "help" / "sra.md").is_file(),
+       "BC6 the Sites page carries the area and the packet's status beside each site; `gea sra` runs the self-test from the command line and "
+       "labels it SIMULATION_SELF_TEST; the help page exists")
+
+
 def main() -> int:
     print("GEA-Program - ACCEPTANCE SUITE (the product gate)")
-    with tempfile.TemporaryDirectory() as tmp:
+    # a handle a job subprocess still holds at the end must not turn a finished gate into a traceback on Windows:
+    # the checks have already passed or failed on their own, and the folder is the temp folder
+    with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as tmp:
         section_a_cli(tmp)
         section_b_las(tmp)
         section_c_reconciler(tmp)
@@ -4625,6 +4779,7 @@ def main() -> int:
         section_az_uncertainty(tmp)
         section_ba_sites(tmp)
         section_bb_supervisor(tmp)
+        section_bc_sra(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.8.0 → gea_program-0.9.0}/gea/client_reports.py

@@ -1584,6 +1584,84 @@ def seismic_track_report(track: dict, histories: List[dict], positions: dict, ve
                           'evaluated_at_utc': now.strftime('%Y-%m-%dT%H:%M:%SZ'), '_records': [], '_catalogue_obj': None})
 
 
+def sra_packet_report(pk: dict, evaluated_at: Optional[datetime] = None, program_version: str = '') -> Document:
+    """The Seismicity Response Area packet: what an operator inside an SRA puts in front of the Railroad
+    Commission, built from what the site holds. The area and the plan as declared; which wells and stations
+    are inside it and each well's depth tier; the four daily parameters the Commission's Notice names, per
+    well, rolled up by month, with the bottomhole-pressure method; the catalogue's events against the plan -
+    the response trigger and the goal clock; the checkpoint schedule; and every gap by name."""
+    now = evaluated_at or _utc_now()
+    s = pk['sra']; site = pk.get('site') or {}; m = pk['membership']; se = pk.get('seismicity')
+    report_id = f"SRA-{str(site.get('id') or s['name']).replace('/', '-')[:24]}-{now.strftime('%Y%m%dT%H%M%SZ')}"
+    secs = []
+    secs.append(Section('1', 'The area and the plan', [
+        f"{s['name']}: a circle of {s['radius_km']:g} km ({s['area_km2']:,} km\u00b2) around {s['centre']['lat']:.5f}, {s['centre']['lon']:.5f} "
+        f"on {s['centre']['datum']}. Plan date {s['plan_date']}. The plan is written against earthquakes of magnitude {s['threshold_m']:.1f} and "
+        f"above inside the area: the goal is {s['goal_months']} months without one; the response to one is a meeting of the operator-led "
+        f"response group within {s['response_hours']} hours; the checkpoints with Commission staff fall every {s['checkpoint_months']} months. "
+        f"Disposal wells are placed in two tiers by the {s['formation_boundary']}."
+        + (f" Triggering event: {s['triggering_event']}." if s.get('triggering_event') else '')
+        + (f" {s['note']}" if s.get('note') else ''),
+        'Every number in this paragraph is a declaration copied from the plan, not a measurement.']))
+    wrows = [[w['id'], w['display'] or '-', w['api_number'] or '-', w['uic_number'] or '-',
+              ('inside' if w['inside'] else ('outside' if w['inside'] is False else 'undecided')),
+              _fmt(w['distance_km']), w['depth_tier'], (w['bhp_method'] or '-'), w.get('daily_status') or '-'] for w in pk['wells']]
+    srows = [[x['id'], x.get('display') or '-', x.get('kind') or '-', ('inside' if x['inside'] else ('outside' if x['inside'] is False else 'undecided')),
+              _fmt(x.get('distance_km'))] for x in pk['stations']]
+    secs.append(Section('2', 'What is inside the area', [
+        f"{m['n_wells_inside']} well(s) and {m['n_stations_inside']} seismic station(s) of the site fall inside the area by geodesic distance "
+        f"from the centre, with every position carried to WGS84 first; {m['n_undecided']} could not be placed."],
+        [Table(['Well', 'Name', 'API', 'UIC', 'Membership', 'Distance (km)', 'Depth tier', 'BHP method', 'Daily record'], wrows, 'Wells'),
+         Table(['Station', 'Name', 'Kind', 'Membership', 'Distance (km)'], srows, 'Seismic stations')]))
+    n = 3
+    inside_wells = [w for w in pk['wells'] if w['inside'] and w.get('months')]
+    for w in inside_wells:
+        pr = w.get('parameters', {}); bh = w.get('bhp', {})
+        paras = [f"{w['display'] or w['id']} ({w['depth_tier']}): {w.get('daily_detail') or ''}",
+                 ' '.join(f"{v['label']}: {v['status']}" + (f" from channel {v['channel']}" if v.get('channel') else '') + '.' for v in pr.values()),
+                 f"Bottomhole pressure: {bh.get('label', '-')}, reported {bh.get('reported', '-')}" + (f"; {bh['how']}" if bh.get('how') else '') + '.']
+        secs.append(Section(str(n), f"Daily record, rolled up by month: {w['display'] or w['id']}", paras,
+                            [Table(['Month', 'Days', 'Recorded', 'Missing', 'Max surface inj. pressure (psi)', 'Avg surface inj. pressure (psi)',
+                                    'Injection volume (bbl)', 'Max injection rate (bbl/min)', 'BHP (psi)'],
+                                   [[r['month'], r['days'], r['recorded'], r['missing'], _fmt(r['max_surface_injection_pressure_psi']),
+                                     _fmt(r['avg_surface_injection_pressure_psi']), _fmt(r['injection_volume_bbl']),
+                                     _fmt(r['max_injection_rate_bbl_min']), _fmt(r['bhp_psi'])] for r in w['months']])]))
+        n += 1
+    if se:
+        lg = se.get('largest')
+        paras = [f"Catalogue export of {se['catalog'].get('export_mtime_utc', '-')[:10]}: {se['n_inside']} event(s) inside the area, "
+                 f"{se['n_at_or_above']} at or above M {s['threshold_m']:.1f}, {se['n_exempt']} of those declared aftershocks and exempt."
+                 + (f" Largest inside the area: M {lg['magnitude']:.1f}, {lg['time'][:10]}, {lg['distance_km']:g} km from the centre ({lg['event_id']})." if lg else ''),
+                 f"Response: {se['trigger']['status']}. {se['trigger']['detail']}.",
+                 f"Goal: {se['goal']['status']}. {se['goal']['detail']}."]
+        ev = [[e['event_id'], e['time'][:16].replace('T', ' '), f"{e['magnitude']:.1f}", _fmt(e['distance_km']), _fmt(e.get('depth_km')),
+               ('yes' if e['after_plan'] else 'no'), ('exempt' if e['exempt'] else ('counts' if (e['at_or_above'] and e['after_plan']) else '-'))]
+              for e in se['events'] if e['at_or_above'] or e is se['events'][-1]]
+        secs.append(Section(str(n), 'Seismicity against the plan', paras,
+                            [Table(['Event', 'Origin (UTC)', 'M', 'Distance (km)', 'Depth (km)', 'After plan date', 'Standing'], ev,
+                                   'Events at or above the threshold inside the area (and the latest event)')]))
+        n += 1
+    else:
+        secs.append(Section(str(n), 'Seismicity against the plan', ['No catalogue export was handed in. This section is empty and the goal clock is not stated.']))
+        n += 1
+    secs.append(Section(str(n), 'The schedule', ['Checkpoints with Commission staff from the plan date, and the goal date.'],
+                        [Table(['#', 'Date', 'What'], [[c['n'], c['date'], c['what']] for c in pk['checkpoints']])]))
+    n += 1
+    secs.append(Section(str(n), 'What this packet is missing', pk['gaps'] or ['Nothing: every declaration is present and every parameter is recorded.']))
+    secs.append(Section(str(n + 1), 'What this packet does not call a measurement',
+                        [x.rstrip('.') + '.' for x in dict.fromkeys(pk.get('not_a_measurement') or [])]))
+    front = [['Report ID', report_id], ['Area', s['name']], ['Site', site.get('display') or '-'], ['Client', site.get('client') or '-'],
+             ['Generated (UTC)', now.strftime('%Y-%m-%dT%H:%M:%SZ')],
+             ['Program', f'{PROGRAM_NAME}' + (f' build {program_version}' if program_version else '')],
+             ['Result', f"{pk['status']}: {m['n_wells_inside']} WELL(S) INSIDE, " + (f"RESPONSE {se['trigger']['status']}, GOAL {se['goal']['status']}" if se else 'NO CATALOGUE')
+              + (f", {len(pk['gaps'])} GAP(S)" if pk['gaps'] else '')]]
+    return Document(title=f'{PROGRAM_NAME} - Seismicity Response Area Packet', report_id=report_id, front=front, sections=secs,
+                    footer=('Built to the operator-led response plans the Railroad Commission of Texas has on file and its December 2023 Notice to '
+                            'Operators on disposal-well monitoring in the Permian Basin. The daily export carries the Notice\'s parameter names; '
+                            'the mapping onto the TexNet reporting tool\'s template is the operator\'s step.'),
+                    data={'packet': pk, 'report_id': report_id, 'evaluated_at_utc': now.strftime('%Y-%m-%dT%H:%M:%SZ'), '_records': [], '_catalogue_obj': None})
+
+
 def forbidden_terms(text: str) -> List[str]:
     low = text.lower()
     return [t for t in FORBIDDEN_TERMS if t in low]

gea_program-0.9.0/gea/help/sra.md

@@ -0,0 +1,15 @@
+# The Seismicity Response Area
+
+> What an operator inside a Railroad Commission Seismicity Response Area puts in front of the Commission, built from what the site holds.
+
+**The command**: declare each disposal well once - `gea workspace --path C:\site --action set-well --well <id> --lat LAT --lon LON --datum NAD27 --api 42-329-12345 --uic 123456 --depth-tier deep --formation "completed below the base of the Wolfcamp" --channel-pressure P_surf_psi --channel-rate Q_bpm --rate-unit bbl/min --bhp-method probe --channel-bhp P_bh_psi`; define the area on the site once - `--action sra-define --site <id> --name "Gardendale SRA" --lat 31.95 --lon -102.25 --datum WGS84 --radius-km 9.08 --plan-date 2022-12-16 --triggering-event texnet2022yxab`; then every month - `--action sra-report --site <id> --catalog texnet_export.csv [--aftershocks id1 id2] [--start 2026-03-01 --end 2026-03-31]`. `gea sra` runs the self-test on a labelled scene.
+
+**What it writes**: `reports/sites/<site>/sra_packet.html` (and `.md`, `.json`) - the area and the plan as declared, what is inside it with each well's depth tier, the daily record per well rolled up by month, the seismicity against the plan, the checkpoint schedule, and every gap by name; and `sra_daily_export.csv` - one line per well per day under the Notice's own parameter names (maximum surface injection pressure, average surface injection pressure, injection volume, maximum injection rate), the bottomhole pressure and its method, and the well's API and UIC numbers. Every declaration and every packet is in `records/audit.jsonl`.
+
+**The number to check**: `Response:` in section "Seismicity against the plan" - TRIGGERED names the event, its magnitude and the deadline for the response group's meeting; NOT TRIGGERED names why. `Goal:` gives the days without a threshold event and the date the plan's goal falls on. The packet's front says COMPLETE or INCOMPLETE with the count of gaps.
+
+**What this page will not call a measurement**: which earthquakes are aftershocks - the operator declares them with `--aftershocks` and they are shown as exempt, never decided here. A volume read off a pressure gauge - a well with no rate channel has no volume and no maximum rate, and the packet says NOT RECORDED. A depth tier from depth alone - the tier is stratigraphic, above or below the named formation base, and is declared. The TexNet reporting tool's own upload template - the export carries the Notice's parameter names and the mapping is the operator's step. A catalogue nobody handed in - the catalogue is a file the operator exports from TexNet, and its export date is on the packet.
+
+The shape is the Commission's: the operator-led response plans on file (Gardendale, Northern Culberson-Reeves, Stanton) - a circle of about 9 km, a plan written against M 3.5, an 18-month goal, a response group meeting within 48 hours of a threshold event, quarterly checkpoints with Commission staff, and disposal wells in two tiers by the base of the Wolfcamp - and the December 2023 Notice to Operators on disposal-well monitoring and reporting in the Permian Basin, which names the four daily parameters and the three bottomhole-pressure methods. A downhole gauge this program monitors is the Notice's permanent probe.
+
+Related: `gea help sites`, `gea help seismic`, `gea help data-in`.

{gea_program-0.8.0 → gea_program-0.9.0}/gea/helplib.py

@@ -38,6 +38,7 @@ INDEX: List[tuple] = [
     ('patches', 'Patches', 'supervised live connections, their states and records'),
     ('files', 'Files', 'import and export roots, detection by content, the evidence pack'),
     ('notifications', 'Notifications', 'rules, channels, the delivery log'),
+    ('sra', 'The Seismicity Response Area', 'the packet an operator inside an SRA puts in front of the Commission'),
     ('doctor', 'Which code is running', 'gea doctor and the serve start-up gate'),
     ('audit-update', 'Audit / Update', 'the whole audit log with filters, the program against PyPI, every report against its source'),
     ('upkeep', 'Upkeep', 'housekeeping, sessions, the TLS proxy, the load test'),

{gea_program-0.8.0 → gea_program-0.9.0}/gea/jobs.py

@@ -62,17 +62,24 @@ class JobRunner:
     def _dir(self, job_id: str) -> str:
         return os.path.join(self.ws.jobs_dir, job_id)
 
-    def _read(self, job_id: str) -> dict:
-        p = os.path.join(self._dir(job_id), 'job.json')
-        for attempt in range(40):                        # a writer may be mid-replace; the file is never half-written (see _write)
+    @staticmethod
+    def _read_json(p: str, attempts: int = 40) -> dict:
+        """Read a job file that a writer may be mid-replace on. The file is never half-written (see _write), but
+        on Windows a read during os.replace is refused with PermissionError, and the v0.7.0 kit run #8 and the
+        v0.9.0 ship both fell over on exactly that - the first in _read, the second in list(), which had its own
+        open() and none of this. Every read of a job file goes through here now."""
+        for attempt in range(attempts):
             try:
                 with open(p, encoding='utf-8') as f:
                     return json.load(f)
             except (json.JSONDecodeError, FileNotFoundError, PermissionError):
-                time.sleep(0.05)                          # PermissionError: Windows refuses a read during os.replace (the v0.7.0 kit run #8)
+                time.sleep(0.05)
         with open(p, encoding='utf-8') as f:
             return json.load(f)
 
+    def _read(self, job_id: str) -> dict:
+        return self._read_json(os.path.join(self._dir(job_id), 'job.json'))
+
     def _write(self, job: dict) -> None:
         p = os.path.join(self._dir(job['id']), 'job.json')
         tmp = p + '.tmp'
@@ -119,8 +126,10 @@ class JobRunner:
         for name in sorted(os.listdir(self.ws.jobs_dir), reverse=True):
             p = os.path.join(self.ws.jobs_dir, name, 'job.json')
             if os.path.isfile(p):
-                with open(p, encoding='utf-8') as f:
-                    j = json.load(f)
+                try:
+                    j = self._read_json(p)
+                except (OSError, json.JSONDecodeError):
+                    continue                              # a job whose file cannot be read right now is left out of this listing, not a crash
                 if status is None or j['status'] == status:
                     out.append(j)
             if len(out) >= limit: