beqforge 0.2.1__tar.gz → 0.2.2__tar.gz

{beqforge-0.2.1 → beqforge-0.2.2}/.github/workflows/build-device-check.yml

@@ -61,7 +61,7 @@ jobs:
             executable: beqforge-device-check
     steps:
       - uses: actions/checkout@v7
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.0
         with:
           enable-cache: true
       - name: Install Linux audio and USB libraries

{beqforge-0.2.1 → beqforge-0.2.2}/.github/workflows/build-executable.yml

@@ -25,7 +25,7 @@ jobs:
     steps:
       - name: Find successful tests for the tagged commit
         id: check
-        uses: actions/github-script@v8
+        uses: actions/github-script@v9
         with:
           script: |
             core.setOutput('reusable', 'false');
@@ -72,6 +72,8 @@ jobs:
     needs: previous_tests
     if: needs.previous_tests.outputs.reusable != 'true'
     uses: ./.github/workflows/tests.yml
+    # CODECOV_TOKEN, for the coverage upload
+    secrets: inherit
     permissions:
       contents: read
 
@@ -102,7 +104,7 @@ jobs:
       contents: read
     steps:
       - uses: actions/checkout@v7
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.0
         with:
           enable-cache: true
       - name: Build wheel and source distribution
@@ -191,7 +193,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v10.2.0
+        uses: astral-sh/setup-uv@v10.3.0
         with:
           enable-cache: true
 

{beqforge-0.2.1 → beqforge-0.2.2}/.github/workflows/tests.yml

@@ -67,7 +67,7 @@ jobs:
         run: choco install ffmpeg -y
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v10.2.0
+        uses: astral-sh/setup-uv@v10.3.0
         with:
           enable-cache: true
 
@@ -76,7 +76,17 @@ jobs:
 
       # the device-check tests run in their own job below, in parallel, with the extra installed
       - name: Run tests
-        run: uv run --extra designer pytest -n auto --durations=25 --ignore-glob='tests/test_device_check_*.py'
+        run: uv run --extra designer pytest -n auto --durations=25 --ignore-glob='tests/test_device_check_*.py' --cov --cov-report=xml
+
+      - name: Upload coverage
+        if: ${{ !cancelled() }}
+        uses: codecov/codecov-action@v7.1.1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.xml
+          disable_search: true
+          flags: designer,${{ runner.os }}
+          name: designer-${{ runner.os }}
 
   device-check:
     name: Device check (${{ matrix.os }})
@@ -90,7 +100,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v10.2.0
+        uses: astral-sh/setup-uv@v10.3.0
         with:
           enable-cache: true
 
@@ -100,7 +110,17 @@ jobs:
 
       - name: Run device-check tests
         shell: bash
-        run: uv run --extra device-check pytest -n auto --durations=25 tests/test_device_check_*.py
+        run: uv run --extra device-check pytest -n auto --durations=25 tests/test_device_check_*.py --cov --cov-report=xml
+
+      - name: Upload coverage
+        if: ${{ !cancelled() }}
+        uses: codecov/codecov-action@v7.1.1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.xml
+          disable_search: true
+          flags: device-check,${{ runner.os }}
+          name: device-check-${{ runner.os }}
 
   package-profiles:
     name: Install profile (${{ matrix.profile }})
@@ -111,7 +131,7 @@ jobs:
         profile: [base, designer, optimiser, device-check, all]
     steps:
       - uses: actions/checkout@v7
-      - uses: astral-sh/setup-uv@v10.2.0
+      - uses: astral-sh/setup-uv@v10.3.0
         with:
           enable-cache: true
       - name: Build the single distribution

{beqforge-0.2.1 → beqforge-0.2.2}/AGENTS.md

@@ -56,7 +56,9 @@ importing them; use an isolated worktree for simultaneous experiments.
 The root build configuration includes every workflow and the optimiser's bundled seed in one
 wheel and source distribution. `.github/workflows/tests.yml` checks isolated dependency
 profiles and runs the suite in parallel (`pytest -n auto`, so tests must not share mutable state
-or fixed ports). Feature branch pushes test on Linux only and a newer push cancels the branch's
+or fixed ports), with coverage (`--cov`, configured in `pyproject.toml`, `multiprocessing`
+children included) uploaded to Codecov by each test job using the `CODECOV_TOKEN` secret;
+release runs inherit it. Feature branch pushes test on Linux only and a newer push cancels the branch's
 previous run; `main`, tags and manual runs test Linux, macOS and Windows and are never cancelled. `.github/workflows/build-executable.yml` builds release executables and distributions;
 tag pushes publish to PyPI after validation and successful executable builds. Tags must match
 the shared version exactly (`vX.Y.Z`). Manual runs build artifacts without publishing.

{beqforge-0.2.1 → beqforge-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: beqforge
-Version: 0.2.1
+Version: 0.2.2
 Summary: Audio-derived BEQ design, published filter optimisation and DSP validation
 License-File: LICENCE.md
 Requires-Python: <3.15,>=3.13
@@ -270,8 +270,9 @@ The image's defaults, all overridable with the environment variables above:
 
 It runs as uid/gid 1000 (`--build-arg PUID=… PGID=…` to change), which must be able to write
 the shared root and the cache: the server checks both with a write at startup. Its
-`HEALTHCHECK` asks `/health`. The server answers one request at a time (its fitter forks), so a
-caller sending several at once queues them; size the caller's timeout for that.
+`HEALTHCHECK` asks `/health`, which answers while a design runs: designs run in a separate
+worker process, one at a time, so a caller sending several at once queues them; size the
+caller's timeout for that. `docker stop` stops a design in progress.
 
 Build and check it locally from the repository root:
 

{beqforge-0.2.1 → beqforge-0.2.2}/README.md

@@ -244,8 +244,9 @@ The image's defaults, all overridable with the environment variables above:
 
 It runs as uid/gid 1000 (`--build-arg PUID=… PGID=…` to change), which must be able to write
 the shared root and the cache: the server checks both with a write at startup. Its
-`HEALTHCHECK` asks `/health`. The server answers one request at a time (its fitter forks), so a
-caller sending several at once queues them; size the caller's timeout for that.
+`HEALTHCHECK` asks `/health`, which answers while a design runs: designs run in a separate
+worker process, one at a time, so a caller sending several at once queues them; size the
+caller's timeout for that. `docker stop` stops a design in progress.
 
 Build and check it locally from the repository root:
 

{beqforge-0.2.1 → beqforge-0.2.2}/beq_common/__init__.py

@@ -1,6 +1,6 @@
 """Shared filter primitives; no workflow package dependencies."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 from .types import BiquadSpec as BiquadSpec
 from .types import BiquadType as BiquadType

{beqforge-0.2.1 → beqforge-0.2.2}/beqforge/AGENTS.md

@@ -43,7 +43,7 @@ still holds: no other API, no other service, and the server is a thin transport
 | `beqforge/explain.py` | The plain-language account a designer response leads with — `found` (reference plateau, which channels carry it and which are silent, down to where there is real bass content, judged band, goal), `correction` (the cascade, then frequency by frequency what was wanted, what the content supports and before → after), `clipping` (the sub-feed peak and how far to turn the sub down, on the request's or the assumed bass management) and `alternatives` (why each other candidate lost). Reads the `Report`; measures and decides nothing. |
 | `beqforge/designer.py` | The `design(request) -> response` adapter between beqdesigner's `designer-interface.md` v1.1 and `beqforge.pipeline.run` — request/response dataclasses (1.1: every candidate the judge failed goes back in `rejected` with its failures, review only, beside the answer or the decline), wire-format (de)serialisation and the field-by-field mapping onto `Report`/`Candidate`/`Verdict`. Also `validate_response`, an independent re-implementation of beqdesigner's own §3-§5 rules (that repo isn't importable — PyQt6), called by the server before a response ever goes on the wire. Pure and independently testable; no socket. |
 | `tools/design_beq.py` | **The entry point.** One command, a filter and its reasoning. `--charts DIR` for the pictures; writes a `.run.json.gz` record beside the material unless `--no-record`. |
-| `tools/designer_server.py` | `beqforge serve-designer` — the HTTP transport (`designer-interface.md` §7.1) around `beqforge/designer.py`. Server-wide flags for device realisation/strategies/exclusions; everything per-title comes from the request. Single-threaded (`http.server.HTTPServer`, not `ThreadingHTTPServer`) on purpose: the fitter forks worker processes (`beqforge.filters.PARALLEL_FITS`) when a fit escalates past one section count, and forking a multi-threaded process risks a deadlock. Costs nothing real — the contract is one synchronous POST per `design()` call. Every response names its build (`beqforge_revision`); `--record-dir DIR` also writes each request's run record, named by a digest of the request audio, so a review-queue entry can be replayed. `--cache-dir DIR` keeps the stage cache there (`cache.DirStore`, one file per entry, atomic): a repeat request for a title skips the analysis — 110 s cold, 50 s warm on a 2-hour 8-channel title. Each request logs a timing line (read, parse, decode, design, respond); `tools/experiments/request_timing.py` reports them. `--shared-root DIR` accepts audio by reference (contract 1.2, beqdesigner's `design/designer-by-reference.md` §3): an array names a WAV relative to DIR plus the SHA-256 of its decoded column, and `beqforge/reference.py` resolves, decodes and checks it; one that cannot be honoured is a 422 naming the array, never a decline. `GET /health` reports `contract_version` and `shared_root`. |
+| `tools/designer_server.py` | `beqforge serve-designer` — the HTTP transport (`designer-interface.md` §7.1) around `beqforge/designer.py`. Server-wide flags for device realisation/strategies/exclusions; everything per-title comes from the request. A `ThreadingHTTPServer`, so `/health` answers during a design, with every design run in one long-lived worker process started with "spawn" (`_DesignWorker`): the fitter forks worker processes (`beqforge.filters.PARALLEL_FITS`) when a fit escalates past one section count, and forking a multi-threaded process risks a deadlock, so the process that forks must stay single-threaded — the worker's log records come back over a `SimpleQueue`, not a `Queue`, for that reason. One worker keeps designs serial (the contract is one synchronous POST per `design()` call); a worker that dies answers 500 and is replaced. SIGTERM shuts down like Ctrl-C, stopping the worker's process group, fit pool included. Every response names its build (`beqforge_revision`); `--record-dir DIR` also writes each request's run record, named by a digest of the request audio, so a review-queue entry can be replayed. `--cache-dir DIR` keeps the stage cache there (`cache.DirStore`, one file per entry, atomic): a repeat request for a title skips the analysis — 110 s cold, 50 s warm on a 2-hour 8-channel title. Each request logs a timing line (read, parse, decode, design, respond, queued); `tools/experiments/request_timing.py` reports them. `--shared-root DIR` accepts audio by reference (contract 1.2, beqdesigner's `design/designer-by-reference.md` §3): an array names a WAV relative to DIR plus the SHA-256 of its decoded column, and `beqforge/reference.py` resolves, decodes and checks it; one that cannot be honoured is a 422 naming the array, never a decline. `GET /health` reports `contract_version` and `shared_root`. |
 | `tools/replay.py` | Redraw charts and export to beqdesigner from a record — no rerun, no extraction. Refuses on a stale record unless `--force`. |
 | `tools/extract.py` | ffmpeg → 1 kHz per-channel `.npz`. Requires an explicit supported channel layout; preserves layout provenance. Needs no beqdesigner. |
 | `tools/summarise.py` | Sanity-check an extraction before using it. |

{beqforge-0.2.1 → beqforge-0.2.2}/beqforge/diagnose.py

@@ -618,15 +618,21 @@ def diagnose(
     constrain channel restoration and the band over which a filter is judged.
     """
     params = params or DiagnoseParams()
-    freqs, mix_db = mean_spectrum(material.mono_mix, material.fs)
-    band = (freqs >= params.band_hz[0]) & (freqs <= params.band_hz[1])
-    freqs, mix_db = freqs[band], mix_db[band]
+    spectrum_freqs, mix_spectrum = mean_spectrum(material.mono_mix, material.fs)
+    band = (spectrum_freqs >= params.band_hz[0]) & (spectrum_freqs <= params.band_hz[1])
+    freqs, mix_db = spectrum_freqs[band], mix_spectrum[band]
     spectra = {
         name: mean_spectrum(samples, material.fs)[1]
         for name, samples in material.channels.items()
     }
     shares, share_errors = coherent_shares(material)
-    _, mix_plateau = plateau_reference(mix_db, freqs, params)
+    # The mix plateau is found on the whole spectrum, exactly as `pipeline` finds it, so tracking
+    # is measured from the plateau the run judges against. The reference grid ends exactly at the
+    # band top: cut off at the last bin below it, a plateau reaching that edge loses its top point
+    # and can vanish. Diagnosis then lost the plateau `pipeline` had, measured no tracking at all
+    # and reported the band top as where tracking stopped (A Few Good Men: 150.5-200 Hz found by
+    # one, none by the other).
+    _, mix_plateau = plateau_reference(mix_spectrum, spectrum_freqs, params)
     from beqforge.extraction import ExtractionParams, extract
 
     extraction_params = extraction_params or ExtractionParams()

{beqforge-0.2.1 → beqforge-0.2.2}/plans/done-design-and-pipeline.md

@@ -748,6 +748,76 @@ beside the answer or the decline (probe unchanged; no decision touched).
     caller's; `beqforge_revision` is already in every response for it.
 
 
+## The designer server answers `/health` during a design (17 October 2026)
+
+A deployed image went unhealthy while it designed correctly. `serve-designer` was a plain
+`HTTPServer` running `design()` on its only thread, so a `GET /health` waited behind a 50-110 s
+design; the image's `HEALTHCHECK` gives up after 3 s and three failures mark the container
+unhealthy. It had been single-threaded on purpose: the fitter forks its pool, and forking a
+multi-threaded process risks a deadlock.
+
+The server is now a `ThreadingHTTPServer`, and every design runs in one long-lived worker
+process started with "spawn" (`_DesignWorker` in `tools/designer_server.py`). The worker's
+only thread runs the design, so the fitter forks from a single-threaded process as before. Its
+log records come back over a `SimpleQueue` (a `Queue` would start a feeder thread in it) and
+go through the parent's loggers, and the parent waits for a request's records before
+answering. One worker keeps designs serial. A worker that dies answers 500 and is replaced.
+SIGTERM now shuts down as Ctrl-C does (as a container's PID 1 the server used to ignore it),
+and closing stops the worker's process group, fit pool included, rather than wait for a
+design in progress. The timing line gains `queued`. Nothing under `beqforge/` changed, so the
+decision regression probe does not apply.
+
+* **Checks.** New tests: `/health` answers within 3 s while a real design runs, and a killed
+  worker gives a 500 and then a working replacement. The existing server, image and startup
+  tests now build `DesignServer` with `DesignSettings` (51 passed). Against the installed
+  `beqforge serve-designer`: `/health` took at most 16 ms during a design, and SIGTERM in the
+  middle of one exited in 0.3 s with no worker or fit-pool process left. Before the
+  process-group fix, the fit pool was orphaned and kept computing. The image built and
+  `packaging/designer/smoke.py` passed, inline and by reference. Full designer suite with
+  coverage: 741 passed, 1 skipped. The fork-from-a-threaded-process warnings in it come from
+  xdist's own worker threads and appear without these changes.
+* **Coverage.** CI now measures coverage (`pytest-cov`; `[tool.coverage.run]` in
+  `pyproject.toml`, with `concurrency = multiprocessing` so the design worker and fit pools
+  count on every platform; `patch = fork` is unsupported on Windows). Both test jobs upload
+  `coverage.xml` to Codecov with `CODECOV_TOKEN`, and the release workflow passes its secrets
+  to the tests it calls.
+
+
+## The mix plateau diagnosis tracks from is the pipeline's (17 October 2026)
+
+`diagnose` found the mix plateau on the spectrum cut off at the analysis band's top, while
+`pipeline` finds it on the whole spectrum. `plateau_reference`'s grid ends exactly at the band
+top with `right=nan`, so the cut-off copy always lost the top grid point, and a plateau reaching
+that edge could vanish. Diagnosis then took `_temporal_evidence`'s early return (no strata, the
+tracking floor set to the band top), and the pipeline's plateau blocker read that as "nothing
+below it tracks the programme (tracking stops at 200.0 Hz)". The mix plateau is now found on
+the whole spectrum, as the pipeline finds it. Channel plateaus are unchanged.
+
+* **Found in the full-library run (beqdesigner).** A Few Good Men (5.1) declined
+  `no_usable_plateau`: the pipeline's plateau was 150.5-200 Hz, diagnosis had none, and its
+  record showed no strata and a tracking floor of exactly 200.0. `band_tracking` against the
+  pipeline's plateau passes every octave band to ~13 Hz (0.53-0.62). Patched, it accepts two
+  low shelves (16.8 Hz +5.8 dB, 26.8 Hz +6.5 dB, confidence 0.91). Before the Devil Knows
+  You're Dead and Blink Twice show the same record signature.
+* **First version: every plateau on the whole spectrum, rejected.** Handing channels the whole
+  spectrum too moved channel plateaus on eight baseline titles (an extra finite top point moves
+  the 90th-percentile threshold), changed counterfactual targets on four, and in real runs
+  against HEAD flipped counterfactual verdicts on Alto Knights and Obsession. As with the
+  one-sided fallback above, the channel calls were left alone.
+* **Validation of the mix-only version**, against 7a1702f. Probe: 28 Years Later's tracking
+  floor 20.50 -> 20.30 Hz (judged band and targets by up to 0.17 dB); Dossier 137's filter
+  floor 59.3 -> 79.8 Hz and Send Help's 20.0 -> 20.8 Hz, nothing else; the other eight titles
+  unchanged. 28 Years Later's real run against a HEAD run: the winner changes `parametric` ->
+  `flatten`, both passing either way; the accepted corrections agree within 0.6 dB in every band
+  from 5 to 80 Hz (+5.8/+6.0/+6.6/+3.3/+0.6 -> +5.9/+6.6/+6.4/+3.1/+0.7 dB), the same answer.
+  Protocol, seeds 101 and 947: identical false acceptances, abstentions, selections and recovery.
+  Corpus, seeds 1-9: gated 0/45, gate pass 0.079; positives 7/9 (median recovery 1.27 dB RMS);
+  `natural_droop` 4/9 against the committed file's 5/9 (an older revision; reported, not gated).
+  Full suite: 804 passed, 2 skipped. New test in `tests/test_design_diagnose.py`: a mix
+  high-passed at 144-146 Hz, whose only plateau reaches the band top, is tracked from that
+  plateau (fails on the old code: no strata, floor at 200 Hz).
+
+
 ## Levels beside an omission, and mains-hum notches as texture (11 October 2026)
 
 Three titles from a beqdesigner run against `/media/beq` were declined in ways that should not

{beqforge-0.2.1 → beqforge-0.2.2}/pyproject.toml

@@ -30,12 +30,29 @@ all = [
 ]
 
 [dependency-groups]
-dev = ["pytest>=9.0.2", "pytest-xdist>=3.8", "ruff>=0.14.10", "scipy-stubs>=1.17.1,<1.19.0"]
+dev = [
+    "pytest>=9.0.2",
+    "pytest-cov>=7.1.0",
+    "pytest-xdist>=3.8",
+    "ruff>=0.14.10",
+    "scipy-stubs>=1.17.1,<1.19.0",
+]
 
 [tool.pytest.ini_options]
 pythonpath = ["."]
 testpaths = ["tests"]
 
+[tool.coverage.run]
+# the repository root, so every report path is the file's path in the repository
+source = ["."]
+omit = ["tests/*", ".venv/*", "build/*", "packaging/*"]
+# the designer server's design worker and the fitter's pool are `multiprocessing` processes,
+# measured too (and on every platform, unlike `patch = ["fork"]`); every process writes its
+# own data file and they are combined at the end of the run
+concurrency = ["multiprocessing", "thread"]
+patch = ["subprocess"]
+relative_files = true
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

{beqforge-0.2.1 → beqforge-0.2.2}/tests/test_design_channel_evidence.py

@@ -52,7 +52,9 @@ def test_mix_floor_is_measured_on_mix_not_walled_lfe():
     material = material_from({"L": source, "LFE": high_passed(source, 25, 10)})
     result = diagnose(material)
     params = DiagnoseParams()
-    _, plateau = plateau_reference(result.mix_db, result.freqs, params)
+    # found on the whole mix spectrum, as diagnosis and the pipeline both find it
+    freqs, mix_db = mean_spectrum(material.mono_mix, 1000)
+    _, plateau = plateau_reference(mix_db, freqs, params)
     axis, strata = stratified_response(material.mono_mix, 1000, params, plateau)
     from beqforge.diagnose import smooth_unexcluded
 

{beqforge-0.2.1 → beqforge-0.2.2}/tests/test_design_designer_server.py

@@ -6,7 +6,8 @@ Everything else about the designer binding is tested in isolation in
 `test_design_designer.py`, on purpose (see that file's docstring) — this file exists because
 none of those tests ever go through an actual HTTP request, so a bug in `_Handler` itself (a
 wrong status code, a header the client can't parse, `do_POST` never reaching `design()`) would
-be invisible to them.
+be invisible to them. Every server here runs its designs in its own spawned worker process,
+as production does.
 
 The accepted-candidate case costs a real, bounded fit — `strategies=("flatten",)` measured
 directly at ~4-8s (AGENTS.md's "40-80s a title" is for a full multi-strategy run against real,
@@ -35,17 +36,15 @@ from beqforge.designer import (
 from beqforge.harness import apply_high_pass
 from beqforge.material import LFE_GAIN
 from beqforge.pipeline import PipelineParams
-from tools.designer_server import DESIGN_PATH, HTTPServer, _Handler
+from tools.designer_server import DESIGN_PATH, DesignServer, DesignSettings
 
 
 @pytest.fixture(scope="module")
 def server():
-    """`HTTPServer`, same as production (see its fork-safety comment) — driven from a
-    background thread here only because the test itself needs the main thread free to make
-    requests; the real deployment calls `serve_forever()` from the process's only thread.
-    """
-    _Handler.params = PipelineParams(strategies=("flatten",))
-    httpd = HTTPServer(("127.0.0.1", 0), _Handler)
+    """`DesignServer`, same as production, its designs in a spawned worker process."""
+    httpd = DesignServer(
+        ("127.0.0.1", 0), DesignSettings(PipelineParams(strategies=("flatten",)))
+    )
     thread = threading.Thread(target=httpd.serve_forever, daemon=True)
     thread.start()
     try:
@@ -53,6 +52,7 @@ def server():
     finally:
         httpd.shutdown()
         thread.join(timeout=5)
+        httpd.server_close()
 
 
 DESIGN_TIMEOUT_S = 900.0
@@ -223,15 +223,61 @@ def test_accepts_a_real_injected_rolloff_over_http(server) -> None:
     validate_response(_response_from_json(body))  # must not raise
 
 
-def _serve(monkeypatch, params: PipelineParams, cache):
-    """A server of its own, with its own settings — `_Handler`'s are class attributes, so
-    these are restored when the test ends and the module's shared server is unaffected."""
+def test_health_answers_while_a_design_runs(server) -> None:
+    """The designs run in the worker process, so a health check never waits behind one."""
+    answered = []
+    designing = threading.Thread(
+        target=lambda: answered.append(
+            _request(
+                server,
+                "POST",
+                DESIGN_PATH,
+                body=_known_filter_request(),
+                timeout=DESIGN_TIMEOUT_S,
+            )
+        )
+    )
+    designing.start()
+    try:
+        status, _ = _request(server, "GET", "/health", timeout=3.0)
+        assert status == 200
+        assert designing.is_alive()
+    finally:
+        designing.join(timeout=DESIGN_TIMEOUT_S)
+    assert answered[0][0] == 200
+
+
+def test_a_dead_worker_is_a_500_and_the_next_request_gets_a_new_one() -> None:
+    httpd, thread = _serve(PipelineParams(strategies=("flatten",)), None)
+    try:
+        for process in list(httpd.worker._pool._processes.values()):
+            process.kill()
+            process.join(timeout=10)
+        status, body = _request(
+            httpd.server_address, "POST", DESIGN_PATH, _no_evidence_request()
+        )
+        assert status == 500
+        assert "worker died" in body["error"]
+        status, body = _request(
+            httpd.server_address, "POST", DESIGN_PATH, _no_evidence_request()
+        )
+        assert status == 200
+        assert body["decline_reason"] == "channel_evidence_unavailable"
+    finally:
+        _stop(httpd, thread)
+
+
+def _serve(params: PipelineParams, cache, shared_root=None):
+    """A server of its own, with its own settings and its own worker process."""
     # These tests exercise transport and cache identity/reuse, not section-budget
     # escalation. Still run the real pipeline with a bounded numerical search;
     # test_accepts_a_real_injected_rolloff_over_http retains the full budget.
-    monkeypatch.setattr(_Handler, "params", replace(params, max_sections=1))
-    monkeypatch.setattr(_Handler, "cache", cache)
-    httpd = HTTPServer(("127.0.0.1", 0), _Handler)
+    httpd = DesignServer(
+        ("127.0.0.1", 0),
+        DesignSettings(
+            replace(params, max_sections=1), cache=cache, shared_root=shared_root
+        ),
+    )
     thread = threading.Thread(target=httpd.serve_forever, daemon=True)
     thread.start()
     return httpd, thread
@@ -255,14 +301,12 @@ BOTH = ("flatten", "parametric")
 
 
 def test_a_repeat_request_reuses_every_stage_and_answers_the_same(
-    monkeypatch, tmp_path, caplog
+    tmp_path, caplog
 ) -> None:
     """R2a: `--cache-dir` — the second request for a title skips its analysis."""
     from beqforge.cache import DirStore
 
-    httpd, thread = _serve(
-        monkeypatch, PipelineParams(strategies=BOTH), DirStore(tmp_path)
-    )
+    httpd, thread = _serve(PipelineParams(strategies=BOTH), DirStore(tmp_path))
     try:
         request = _known_filter_request()
         first = _request(
@@ -280,16 +324,12 @@ def test_a_repeat_request_reuses_every_stage_and_answers_the_same(
     assert list((tmp_path / "analysis").iterdir())
 
 
-def test_another_server_setting_reuses_the_analysis_only(
-    monkeypatch, tmp_path, caplog
-) -> None:
+def test_another_server_setting_reuses_the_analysis_only(tmp_path, caplog) -> None:
     from beqforge.accept import AcceptParams
     from beqforge.cache import DirStore
 
     request = _known_filter_request()
-    httpd, thread = _serve(
-        monkeypatch, PipelineParams(strategies=BOTH), DirStore(tmp_path)
-    )
+    httpd, thread = _serve(PipelineParams(strategies=BOTH), DirStore(tmp_path))
     try:
         _request(httpd.server_address, "POST", DESIGN_PATH, request, DESIGN_TIMEOUT_S)
     finally:
@@ -297,7 +337,7 @@ def test_another_server_setting_reuses_the_analysis_only(
     tilted = PipelineParams(
         strategies=BOTH, accept=AcceptParams(target_tilt_db_per_octave=1.0)
     )
-    httpd, thread = _serve(monkeypatch, tilted, DirStore(tmp_path))
+    httpd, thread = _serve(tilted, DirStore(tmp_path))
     caplog.clear()
     try:
         with caplog.at_level(logging.INFO, logger="beqforge.cache"):
@@ -311,15 +351,11 @@ def test_another_server_setting_reuses_the_analysis_only(
     assert len(list((tmp_path / "parametric").iterdir())) == 2
 
 
-def test_bass_management_alone_reuses_the_analysis(
-    monkeypatch, tmp_path, caplog
-) -> None:
+def test_bass_management_alone_reuses_the_analysis(tmp_path, caplog) -> None:
     from beqforge.cache import DirStore
 
     request = _known_filter_request()
-    httpd, thread = _serve(
-        monkeypatch, PipelineParams(strategies=("flatten",)), DirStore(tmp_path)
-    )
+    httpd, thread = _serve(PipelineParams(strategies=("flatten",)), DirStore(tmp_path))
     try:
         _request(httpd.server_address, "POST", DESIGN_PATH, request, DESIGN_TIMEOUT_S)
         managed = {
@@ -343,8 +379,8 @@ def test_bass_management_alone_reuses_the_analysis(
     assert "analysis" in _reused(caplog)
 
 
-def test_without_a_cache_dir_nothing_is_written(monkeypatch, tmp_path) -> None:
-    httpd, thread = _serve(monkeypatch, PipelineParams(strategies=("flatten",)), None)
+def test_without_a_cache_dir_nothing_is_written(tmp_path) -> None:
+    httpd, thread = _serve(PipelineParams(strategies=("flatten",)), None)
     try:
         status, _ = _request(
             httpd.server_address, "POST", DESIGN_PATH, _no_evidence_request()
@@ -393,9 +429,8 @@ def _by_reference(request: dict, root) -> dict:
     }
 
 
-def test_health_says_whether_references_are_accepted(monkeypatch, tmp_path) -> None:
-    httpd, thread = _serve(monkeypatch, PipelineParams(strategies=("flatten",)), None)
-    monkeypatch.setattr(_Handler, "shared_root", tmp_path)
+def test_health_says_whether_references_are_accepted(tmp_path) -> None:
+    httpd, thread = _serve(PipelineParams(strategies=("flatten",)), None, tmp_path)
     try:
         status, body = _request(httpd.server_address, "GET", "/health")
     finally:
@@ -404,14 +439,13 @@ def test_health_says_whether_references_are_accepted(monkeypatch, tmp_path) -> N
     assert body == {"status": "ok", "contract_version": "1.2", "shared_root": True}
 
 
-def test_a_request_by_reference_answers_as_the_same_request_inline(
-    monkeypatch, tmp_path
-) -> None:
+def test_a_request_by_reference_answers_as_the_same_request_inline(tmp_path) -> None:
     """R2b over a real socket: same audio by path, same response."""
     inline = {**_known_filter_request(), "contract_version": "1.2"}
     by_reference = _by_reference(inline, tmp_path)
-    httpd, thread = _serve(monkeypatch, PipelineParams(strategies=("flatten",)), None)
-    monkeypatch.setattr(_Handler, "shared_root", tmp_path.resolve())
+    httpd, thread = _serve(
+        PipelineParams(strategies=("flatten",)), None, tmp_path.resolve()
+    )
     try:
         first = _request(
             httpd.server_address, "POST", DESIGN_PATH, inline, DESIGN_TIMEOUT_S
@@ -425,11 +459,9 @@ def test_a_request_by_reference_answers_as_the_same_request_inline(
     assert first[1] == second[1]
 
 
-def test_a_reference_without_a_shared_root_is_422_naming_the_array(
-    monkeypatch, tmp_path
-) -> None:
+def test_a_reference_without_a_shared_root_is_422_naming_the_array(tmp_path) -> None:
     by_reference = _by_reference(_known_filter_request(duration_s=20.0), tmp_path)
-    httpd, thread = _serve(monkeypatch, PipelineParams(strategies=("flatten",)), None)
+    httpd, thread = _serve(PipelineParams(strategies=("flatten",)), None)
     try:
         status, body = _request(httpd.server_address, "POST", DESIGN_PATH, by_reference)
     finally:
@@ -439,7 +471,7 @@ def test_a_reference_without_a_shared_root_is_422_naming_the_array(
     assert "no shared root" in body["reason"]
 
 
-def test_an_escaping_path_is_422_and_both_forms_is_400(monkeypatch, tmp_path) -> None:
+def test_an_escaping_path_is_422_and_both_forms_is_400(tmp_path) -> None:
     root = tmp_path / "root"
     root.mkdir()
     by_reference = _by_reference(_known_filter_request(duration_s=20.0), root)
@@ -456,8 +488,9 @@ def test_an_escaping_path_is_422_and_both_forms_is_400(monkeypatch, tmp_path) ->
         **by_reference,
         "mono_mix": {**by_reference["mono_mix"], "data_base64": "AAAA"},
     }
-    httpd, thread = _serve(monkeypatch, PipelineParams(strategies=("flatten",)), None)
-    monkeypatch.setattr(_Handler, "shared_root", root.resolve())
+    httpd, thread = _serve(
+        PipelineParams(strategies=("flatten",)), None, root.resolve()
+    )
     try:
         escaped = _request(httpd.server_address, "POST", DESIGN_PATH, escaping)
         doubled = _request(httpd.server_address, "POST", DESIGN_PATH, both)

{beqforge-0.2.1 → beqforge-0.2.2}/tests/test_design_diagnose.py

@@ -9,7 +9,9 @@ from beqforge.diagnose import (
     band_slope,
     band_tracking,
     diagnose,
+    mean_spectrum,
     mix_shares,
+    plateau_reference,
     steepest_slope,
     stratified_response,
 )
@@ -192,6 +194,34 @@ def test_the_plateau_reference_follows_the_channel_not_a_constant() -> None:
     )
 
 
+@pytest.mark.parametrize("corner_hz", [144.0, 145.0, 146.0])
+def test_a_plateau_reaching_the_band_top_is_the_one_the_pipeline_finds(
+    corner_hz,
+) -> None:
+    """Diagnosis measures tracking from the mix plateau the pipeline judges against.
+
+    A plateau that runs into the band's top edge was lost when the spectrum was cut off at the
+    last bin below it: diagnosis then measured no strata or tracking and reported the band top as
+    where tracking stopped, which the pipeline read as "nothing below it tracks" (A Few Good Men,
+    150.5-200 Hz).
+    """
+    rng = np.random.default_rng(0)
+    mix = signal.sosfilt(
+        signal.butter(8, corner_hz, btype="high", fs=FS, output="sos"),
+        rng.standard_normal(int(FS * DURATION_S)),
+    )
+    mix = mix + 1e-3 * rng.standard_normal(mix.size)
+    freqs, spectrum = mean_spectrum(mix, FS)
+    level, plateau = plateau_reference(spectrum, freqs, PARAMS)
+    assert np.isfinite(level) and plateau[1] == PARAMS.band_hz[1]
+
+    result = diagnose(Material("edge", FS, mix, {}, "complete_programme"), PARAMS)
+
+    assert result.stratified
+    # nothing below the high-pass tracks, so tracking stops at the plateau's lower edge
+    assert result.noise_floor_hz == pytest.approx(plateau[0])
+
+
 def test_the_plateau_reference_clears_the_knee() -> None:
     """The reference must sit above the corner, or attenuation is measured against itself."""
     material = material_from(