Python tool for aircraft Doppler audio geolocation using historical ADS-B flight data (Source-available)
Python acoustic-geolocationads-baircraft-trackingairplaneaudio-forensicsdoppler-effectdoppler-shiftgeolocationosintsignal-processing
Add real-recording metamorphic runner and full nine-arm results
Cinna Davis4fcfa01666ef
diff --cc docs/REAL_METAMORPHIC.mdindex 5f46a3d,0000000..ee1c8e0mode 100644,000000..100644--- a/docs/REAL_METAMORPHIC.md+++ b/docs/REAL_METAMORPHIC.md@@@ -1,143 -1,0 +1,234 @@@+# Real recording representation checks++Issue [#61](https://github.com/1337isnot1337/DOPPLERGEIST/issues/61) requires fresh+end-to-end runs for equivalent representations of actual recordings.+The runner in `scripts/run_real_metamorphic.py` executes these runs through the+local HTTP upload service. It accepts a recorded source, a recording-start UTC+window, and an offline operator configuration.++Each arm starts a new service and job. Intake, discovery, selection, matching,+search, refinement, decision and serialization run from the uploaded bytes.+The runner shares only frozen historical indexes and terrain. It does not+resume audio or search checkpoints. The HTTP verifier checks the actual stage+artifacts and the persisted terminal result.++## Frozen protocol++The versioned protocol is+[`verification/metamorphic_protocol_v1.json`](verification/metamorphic_protocol_v1.json).- It was committed before the development matrix ran. It has nine sequential arms:++It was committed locally before the development matrix ran. The exact executed++source tree was published afterward as++[`3094292`](https://github.com/1337isnot1337/DOPPLERGEIST/commit/309429278978adef11e29d2bdfad296dbfdf34e1).++This was not a public preregistration. The protocol has nine sequential arms:++| Arm | Change from the baseline |+| --- | --- |+| Baseline | MP3, 128 kb/s, 48 kHz, mono |+| Low bitrate | 64 kb/s |+| High bitrate | 192 kb/s |+| Sample rate | 44.1 kHz |+| Gain | −6 dB |+| Channels | Two identical channels |+| Leading silence | 17.25 seconds |+| Short discovery chunks | 60-second chunks, 30-second overlap |+| Long discovery chunks | 180-second chunks, 60-second overlap |++All encodings start from the complete source recording's arithmetic channel+mean at 48 kHz. No arm is encoded from another MP3 arm. The baseline keeps the+operator's discovery settings. The current defaults are 120/60 seconds.++Only `operator.discovery.chunk_s` and `overlap_s` are exposed chunk controls.+The protocol explicitly lists unsupported upload, decoder and detector controls.+It does not insert hooks into the source algorithms.++Each job has a 240-second runtime limit and a 300-second client deadline.+The encoding/decode command limit is 300 seconds. Pipeline time is at most+45 minutes across nine client deadlines, plus preparation and cleanup.+Different budgets can be declared at preparation, before any outcomes exist.++Tolerances are fixed in the protocol: 2 ms for duration and residual alignment,+1 second for mapped event edges and fitted clocks, 2 Hz for median ridge+frequency, and 0.05 per matched group for comparable normalized scores.+Usability also requires nonclipping decoded peaks and gain-corrected PCM+NRMSE at most 0.15. Group counts, flight associations and score units must agree.+The runner reports displacement thresholds at 100, 500 and 1,000 metres.+Accepted locations that move over 1,000 metres receive a separate serious flag.++The PCM calculation reads bounded blocks. Lag checks use twelve fixed short+windows, not full-hour correlations. A measured lag is reported; it does not+shift samples to improve the result. Native-rate decoded peaks and identical+stereo channels are checked separately from the 4 kHz analysis PCM.++## Clock mapping++If leading silence is Δ seconds, subtract Δ from **both** sample-zero UTC+window endpoints. Subtract Δ from detected audio-relative times for comparison.+Add Δ to the fitted sample-zero UTC to recover the original recording clock.++For example, 20:17:20–20:17:40 UTC becomes 20:17:02.750–20:17:22.750 UTC+after 17.25 seconds of padding. The physical time of each recorded sound stays+the same. The runner retains codec skip/discard metadata, decoded sample counts,+and residual lag checks. Container start time is not a recording clock.++## Run++Use an installed checkout with FFmpeg and the repository's dependencies.+The request must have a defensible time window. Use absolute local paths for+historical indexes and terrain, or run preparation where relative paths resolve.+Use a stopped, immutable data cache. Active job directories are not data inputs.++```bash+PYTHONPATH=src python scripts/run_real_metamorphic.py prepare \+ --audio /absolute/path/actual-recording.wav \+ --request /absolute/path/request.json \+ --operator /absolute/path/operator.json \+ --source-note 'Identify the actual recorded source and its permission/provenance' \+ --scope-note 'Describe the search scope, clock evidence and evaluation limits' \+ --output /absolute/path/new-frozen-plan++PYTHONPATH=src python scripts/run_real_metamorphic.py run \+ --plan /absolute/path/new-frozen-plan/plan.json \+ --output /absolute/path/new-matrix-run+```++Preparation writes an immutable plan before encoding. It pins source bytes,+configuration, historical inputs, terrain, source code, native binaries,+dependencies, backend environment and FFmpeg version. Runs refuse changed+inputs. Use `--frozen-input PATH` for an additional immutable local dependency.+Every output directory must be new.+++New plans also record Shapely and its GEOS runtime version. Package absence is++recorded explicitly. If Shapely is installed without an identifiable++GEOS version, preparation refuses the incomplete runtime pin.+++The runner preserves encoded inputs, exact transformation commands, actual+job artifacts and observations for every arm. It continues after an ordinary+arm failure. It preserves pending arms on interruption or changed inputs.+An unusable encoded arm still reaches the HTTP pipeline. Encoding failures+remain explicit failures.++`report.json` contains all pairwise comparisons. `report.md` gives a short+case table. Event matching uses a one-to-one assignment based on mapped time+overlap and ridge frequency. It reports unmatched ridges/groups, group splits,+group merges, and ambiguous alternatives. IDs and row positions do not define+correspondence. Retained distant modes are compared separately.++Each case includes a one-arm reproducer command. The `--case` option creates+a fresh job and records the other arms as not selected. It cannot pass the+full-matrix requirement. The `report` command compares preserved observations;+it never counts as another end-to-end run.++Exit zero requires all nine usable arms to reach the full pipeline and remain+within the declared comparison tolerances. Exit one preserves incomplete runs+or observed differences. An inconclusive scientific decision is not itself a+runner failure when the complete pipeline ran. It remains an inconclusive+location result.++The full-path count uses the verifier's stronger requirement: every stage must+be verified and at least one diagnostic candidate must survive. Empty outcomes+remain in the report. A separate count records all observed stage sequences.+Neither count requires a supported location decision.++## Scope of the development run++The affordable development control uses the whole released reference recording,+a source-informed regional box, a narrow source-informed UTC window, and+incomplete historical flight coverage. It cannot satisfy national acceptance.+It does not establish independent location accuracy.++No eligible independent truth is supplied in this protocol. Truth errors at+100/500/1,000 metres remain explicitly unevaluated. Pairwise displacement is+reported separately. A future eligible national evaluation needs its own+predeclared request, data, budgets and evaluation-only truth protocol.++Focused contract checks use archived real ridge observations and an optional+short actual recording. They do not replace any full-recording arm:++```bash+DOPPLERGEIST_REAL_METAMORPHIC_AUDIO=/absolute/path/actual-short-recording.mp3 \+ PYTHONPATH=src pytest -q tests/test_real_metamorphic_runner.py+```++++## Recorded result: 4 November 2026++++All nine fresh jobs passed HTTP and persistence verification and completed the++required pipeline. Each produced 23 diagnostic candidates. Every scientific++decision remained `inconclusive / search_incomplete`. The fixed comparison++criteria failed in 35 of 36 pairs, so the runner correctly exited with code 1.++The 192 kb/s and identical-stereo pair had no comparison flags.++++The [measured summary](verification/real_metamorphic_reference_2026-11-04.json)++records all nine outcomes, all 36 comparison flag sets, source and input hashes,++configuration, runtime pins and raw-artifact identities. The full run took++1,192.83 seconds, including encoding and preflight checks. HTTP verification++accounted for 737.92 seconds.++++The table compares each arm's leading diagnostic candidate with the declared++128 kb/s baseline. These are candidate movements, not accepted-location errors.++Clock differences are absolute differences after the prescribed mapping for++leading silence; they do not indicate which fitted clock is later.++++| Arm | Groups / ridges | Displacement (m) | Absolute clock difference (s) | HTTP time (s) | Worker high-water RSS (MiB) |++| --- | ---: | ---: | ---: | ---: | ---: |++| Baseline | 15 / 17 | 0.00 | 0.000000 | 81.16 | 409.34 |++| 64 kb/s | 16 / 18 | 177.95 | 0.474851 | 101.03 | 430.97 |++| 192 kb/s | 16 / 18 | 3.09 | 0.005837 | 93.50 | 410.20 |++| 44.1 kHz | 16 / 18 | 1,969.93 | 7.452914 | 102.04 | 452.91 |++| −6 dB | 15 / 17 | 2.67 | 0.005770 | 80.67 | 431.94 |++| Identical stereo | 16 / 18 | 1.61 | 0.005285 | 90.59 | 413.76 |++| 17.25-second leading silence | 13 / 16 | 120.24 | 0.213660 | 90.73 | 465.77 |++| 60/30-second discovery chunks | 11 / 13 | 31.78 | 0.065637 | 48.30 | 408.05 |++| 180/60-second discovery chunks | 13 / 15 | 30.88 | 0.053637 | 49.91 | 436.25 |++++All nine representations passed the declared usability checks. Duration errors++and measured residual lags were zero. Gain-corrected PCM NRMSE ranged from++0.03011 to 0.05248, below the fixed 0.15 limit. Native decoded peaks stayed++below clipping. These global checks do not prove preservation of every weak++acoustic cue.++++Both chunk variants uploaded bytes identical to the baseline. Only the actual++discovery chunk settings changed. The resulting group and ridge counts changed++from 15/17 to 11/13 and 13/15. This is a direct processing-chunk sensitivity++result for the declared recording and search configuration.++++The 44.1 kHz arm lost the baseline's 1,396.5–1,418.5-second proposal in the++75.49–93.48 Hz band. All 23 baseline candidates used that proposal, associated++with flight `aa61d2:3`. Its ordinal event ID in the variant belongs to a different++ridge, so it cannot establish correspondence.++++A five-group remnant survives at variant public rank 11 and retained-mode++rank 8. Its coordinates and mapped clock exactly equal the baseline's unrefined++parent at public rank 3. It lies 284.63 metres from the refined baseline winner,++with an absolute clock difference of 0.494912 seconds. The 1.97 km winner movement accompanies++changed detected groups and associations. It does not demonstrate accidental++deletion or reordering of an identical hypothesis.++++The report retains every `distant_mode_lost` flag. This flag means that strict++full-association correspondence failed. A changed proposal population can cause++that failure without proving that the same hypothesis was pruned. Score deltas++remain incomparable when the mapped associations differ.++++No arm produced an accepted location. Consequently, zero accepted-location pairs++were evaluated; accepted-location invariance did not pass or fail. Independent++truth errors remain unevaluated. The regional, source-informed inputs and++incomplete historical coverage leave issue #61's national gate open.++++### Memory instrumentation correction++++The original descendant-RSS sampler could not traverse this environment's++`/proc` mount. All nine original aggregate readings remain unavailable. The++table preserves the worker high-water measurements recorded at search++completion. They are not certified peaks for the whole job.++++The corrected sampler resolves the PID namespace exposed by `/proc/self`.++When thread `children` files are absent, it selects descendants through the++same mount's parent-PID relations before reading their RSS. Sampling errors and++stop timeouts remain explicit. Measurements also survive HTTP verification++exceptions.++++A separate four-second actual upload verified this correction. It measured++129.74 MiB across 16 samples, stopped normally, and returned++`needs_input / recording_time_required`. That run validates instrumentation++only; it is not a tenth scientific arm. No original matrix measurement was++replaced, and the nine-arm matrix was not rerun. Descendant RSS is a sampled++sum and can count shared pages more than once.diff --cc docs/verification/real_metamorphic_reference_2026-11-04.jsonindex 0000000,0000000..bd4af36new file mode 100644--- /dev/null+++ b/docs/verification/real_metamorphic_reference_2026-11-04.json@@@ -1,0 -1,0 +1,4544 @@@++{++ "schema_version": 1,++ "kind": "compact_summary_of_preserved_real_end_to_end_run",++ "comparison_clock_delta_semantics": "mapped_clock_delta_s is an absolute difference after the prescribed time mapping; it does not indicate which fitted clock is later.",++ "issue": "https://github.com/1337isnot1337/DOPPLERGEIST/issues/61",++ "source_note": "Complete released reference-recording.wav from the actual public reference recording; all representations derive from its arithmetic channel mean. No generated acoustic events or trajectories.",++ "scope_note": "Whole-hour source-informed regional development control: bounds [-73.545,40.865,-73.505,40.895], recording-start UTC window 2026-09-08T20:17:20Z to 20:17:40Z, incomplete historical flight coverage. This does not establish national acceptance or independent location accuracy.",++ "predeclaration": "Protocol and runner committed locally before execution. The identical frozen source tree was published remotely after execution. This was not a public preregistration.",++ "frozen_source": {++ "executed_local_commit": "863c9f47731904f2bad8ef5239eddc7f340598b0",++ "durable_archive_commit": "309429278978adef11e29d2bdfad296dbfdf34e1",++ "durable_archive_url": "https://github.com/1337isnot1337/DOPPLERGEIST/commit/309429278978adef11e29d2bdfad296dbfdf34e1",++ "numerical_source_commit": "b68719bcd8ab21e586102b6d1f052f876e04b199",++ "protocol_sha256": "f68559f64aa71303f42bbefb1d3ffe14540b31c3310319592cf3f859ae86c337",++ "plan_sha256": "b1a438921df56c3d1ac17a840c4d9fc4ff2c1d605dd8d61366343bce57e7887d"++ },++ "started_utc": "2026-11-04T03:56:21.535592Z",++ "finished_utc": "2026-11-04T04:16:14.369643Z",++ "wall_elapsed_s": 1192.834051,++ "source": {++ "path": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/source/reference-recording.wav",++ "resolved_path": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/source/reference-recording.wav",++ "bytes": 691235466,++ "sha256": "262d9c4eba1c80657813c604140ba2afbbaabed2b3aebc833cba7cafdc005e9f"++ },++ "request": {++ "schema_version": 1,++ "search": {++ "coverage": "conus",++ "bounds_wsen": [++ -73.545,++ 40.865,++ -73.505,++ 40.895++ ]++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ }++ },++ "operator": {++ "flight_indexes": [++ "/workspace/scratch/e20de6666de2/real-ledger-inputs/reference-region.sqlite"++ ],++ "offline": true,++ "terrain": {++ "rasters": [++ "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/Copernicus_DSM_COG_10_N40_00_W074_00_DEM.tif"++ ],++ "geoid_raster": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/us_nga_egm96_15.tif"++ },++ "search_budget": {++ "spacing_m": 2000,++ "tile_cells": 16,++ "top_k": 20,++ "refine_spacing_m": 500,++ "refine_finalists": 3++ },++ "refine_finalists": 3,++ "search_workers": 1++ },++ "inputs": [++ {++ "path": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/Copernicus_DSM_COG_10_N40_00_W074_00_DEM.tif",++ "resolved_path": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/Copernicus_DSM_COG_10_N40_00_W074_00_DEM.tif",++ "bytes": 15806993,++ "sha256": "6a0f4273de0bbc0709cc9db4793a89ac40c811388f59f23f644c0304b66ab94d"++ },++ {++ "path": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/us_nga_egm96_15.tif",++ "resolved_path": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/us_nga_egm96_15.tif",++ "bytes": 2710815,++ "sha256": "db493027562c9b004d7220fa881f5603adada4e1c5029b933fa7de4547b0e78d"++ },++ {++ "path": "/workspace/scratch/e20de6666de2/real-ledger-inputs/reference-region.sqlite",++ "resolved_path": "/workspace/scratch/e20de6666de2/real-ledger-inputs/reference-region.sqlite",++ "bytes": 85929984,++ "sha256": "17ab5d9b860513c86fa850b6c7e7318cf5d507339dfa1921e86611439b214c6a"++ }++ ],++ "runtime": {++ "package_files": {++ "__init__.py": "01428b7938817c1cfe7eb3cf7e186f35b3fa7bc2d85f14204d07e0aa251d2c88",++ "_native_acoustic.c": "56dbe6dcfb848da530d0266229d70fe4ec19c76e8f3eceb4585db68b6584462e",++ "_native_cpa.c": "0c520e9e10ceaa0ec3798f706aff4f524cf14381f0722efb703636e74281fb38",++ "_native_index.c": "553b901945535699e96e6b040a7958b2359efd25112f3da326aa851a92b75889",++ "_native_ridge.c": "4cb9ace18d60b47b3959796b4520637ecc45513a7a830006909b4f90e49f94f1",++ "acoustic_screen.py": "a0a479a46d6c48ab973ec539d1457868a7eb6f4b9c361a0426dc7993f84970ec",++ "audio.py": "7ae1cbd3e682057096f103d34fa5664b11cf4e7a74e25af29736ed6618cc9c6d",++ "automatic.py": "8de96b1450eb26ab33acac5d36680c743c3d2c537b4b0f7182aae9b6faf245bd",++ "batch_ridge.py": "d8187c64c3fcfb2d084fbdaa302b78791c68fa6aed33e2d61f95537058ab7f3a",++ "checkpoint_resume.py": "2c5a722c11402d5d9fc2a62946693197758583e7834d979f5820156cf3aeb553",++ "cli.py": "c0fd0f8efa7f71e4333458265fbcd1b591e159771da03d4d3887898170f01489",++ "confidence.py": "cbaff2a167bf7dddd60da2bc8a0ea3cf14127ee99575347ff130947ea4acdb44",++ "contracts.py": "602735eef7de44e6410d79336e33c47d35e2c3d00d531729a4c137995ccd1a70",++ "data_access.py": "77da0d39e1e95476fdf02e29e9a345914545af7e62227a93b4cb6786edb37a71",++ "discovery.py": "0a973a1238b7d0c344efa23383ac42a7a8d5b37a2e975b4fad9ac878cee5b2a0",++ "enf.py": "797194fa7c7ead38cc571cb5d88ee4610ddcb7008a63326a0fca35387e3115fd",++ "evaluation.py": "2186f839677883a3095a5d233921b4323d054f2c9101f7ee0c2773b10b2323fd",++ "finite_search.py": "f499ba1f298b5869ac5ae375a2eddb46aabfabcfb9f3fd0d848e362c636c0367",++ "flight_payload.py": "d74d218529d91db6397c5450a4b57f1f5efd2b3bc942120858dfabe6e69fd4e5",++ "flight_selection.py": "076c49876195ee9f6768e79a0f946ad7204c2d1030da5f7aae6d08207acacf0b",++ "geometry.py": "aff5eb70f00766a1a3ab890d1ba33f1a4989af9cf1c4b628770a8d2a7767fd13",++ "guidance.py": "7ee98832fbcdc94b6664b543885107426ca58fc7fbd9da1030365d2e493159fa",++ "index_compatibility.py": "a9aa315a3cdaf9b01bcac027bb4f7b5074864db8623402bc1afcbee24e6ecc83",++ "intake.py": "c88f51f8c7edd6abb74fca830a839d0bbce758beb9a582a7791a8a174b603781",++ "jobs.py": "40517440e0dc380898e0685b8c4bec3320e9cf121626983ee207e42729ad6ebc",++ "matching.py": "3ffc0ea3024503d41dd82b208719d990f15da330dc906957fea1d77eec0728c6",++ "native_acoustic.py": "608475fc2254e9a80549ebd0fc337ba2893d938ee8d4834f1573d0022b1b6f7f",++ "native_cpa.py": "32c02cd43f6a1a67bdaa17ee3cdaef385fd763a4781610aeada9e1d8d714566d",++ "parallel_retention.py": "2861608faa3490601aec9870647ec2a5f9268ff051548565b6d657cb1e95155f",++ "parallel_tiles.py": "3605621c3c5fd9b35008fe1680e1bea99f968ec841f69b4a5bc9e3ced3c52108",++ "pipeline.py": "62c2d268265b3fac3d02d70450dc92043b97999d41f872f82266cca217fa7103",++ "provenance.py": "b3dfda5b31f1aec195eef8ef763b08b2734265da06ce41c129daf70acce8c041",++ "resource_usage.py": "2704ff96bc9ae5a39fa29b3f4cee590e38bc5e59f3ec369e6aa28aab307f5d04",++ "ridge_overlap.py": "635e4dc065035f65df29b0e86b1e8f01015382ec3b0ddd4f97857bff89dfcfd7",++ "scoring_inputs.py": "9cbc11678ba5a555acf234945e037662b494591df6a33d21b460e726c62c3588",++ "search.py": "46a6d68bc13bdee906a34d7364194fa0a30357e5b9107bbcbdd3e5b8dd5d9b55",++ "service.py": "897eb52191ef6579097a9fce7f62d2147c902c6526da4b354aa8594dca67c3c2",++ "spectral_grid.py": "67fe613a0ee9505f1d9cfd8db468ee03ccdf8664fe1608d6df3d484ebcaad27c",++ "spectral_matching.py": "8de9273ea8090ce9e5a639c6d9fb4b88c2455afc02413643935983149fe9d2e6",++ "terrain.py": "749d6e1d526324fc3015511e9f83fde3663d31a1fc863f069bd18f56601869f8",++ "tiled_search.py": "fd1aaa139fcd28a9abf5b8867483bc20007748a940fffaeca0926ffea63dc86d",++ "tracks.py": "543f483cee756fdb9efdd69c8e8f05b32e290f19187af3523160f19d2eba90e0",++ "trial_prefix.py": "cd428883c036d52e9eb6f06cb453fa4cfa63614695ff229db21f3ca5ebfba285",++ "web/__init__.py": "3a26943e5bc40f94abe57fa96eb1dddf4709aa838d0b226053b8701e9e6ac400"++ },++ "runner_sha256": "25cdbd5a71ec3623819761332da534b10017299f57a89e2b27ae774eea18d3ff",++ "verifier_sha256": "58f59e9a986b1d574972fe55e3af3fc8e1fca2dc5b9cbcea8d10f83aca8188dc",++ "python": "3.12.14 (main, Aug 25 2026, 14:00:49) [Clang 22.1.3 ]",++ "executable": "/workspace/scratch/e20de6666de2/.venv/bin/python",++ "packages": {++ "numpy": "2.3.5",++ "scipy": "1.17.0",++ "pandas": "2.2.3",++ "pyproj": "3.8.0",++ "rasterio": "1.5.2",++ "pyarrow": "26.0.1",++ "matplotlib": "3.10.8"++ },++ "backends": {++ "ridge": "python-irls-v1",++ "acoustic": "python-acoustic-v1",++ "cpa": "python-cpa-v1",++ "index_payload": "python"++ },++ "environment": {++ "DOPPLERGEIST_ACOUSTIC_BACKEND": "python",++ "DOPPLERGEIST_CPA_BACKEND": "python",++ "DOPPLERGEIST_RIDGE_BACKEND": "python",++ "MKL_NUM_THREADS": "1",++ "OMP_NUM_THREADS": "1",++ "OPENBLAS_NUM_THREADS": "1",++ "PYTHONHASHSEED": "0"++ },++ "ffmpeg": "ffmpeg version 6.1.1-3ubuntu5 Copyright (c) 2000-2023 the FFmpeg developers",++ "ffprobe": "ffprobe version 6.1.1-3ubuntu5 Copyright (c) 2007-2023 the FFmpeg developers"++ },++ "budgets": {++ "job_max_runtime_s": 240.0,++ "http_timeout_s": 300.0,++ "encoding_timeout_s": 300.0++ },++ "historical_acquisition": {++ "flight_indexes": [++ {++ "index_version": 2,++ "sources": [++ {++ "path": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/adsb/2026-09-08/reference-region.parquet",++ "sha256": "fa4e2b82849b3ea8c22ffbe50d4f8f00b7bb3727486307feeaab4821562718a0",++ "bytes": 32823780++ }++ ],++ "coverage": {++ "bounds": [++ -74.299988,++ 40.100005,++ -72.700011,++ 41.599964++ ],++ "time_range_s": [++ 1788825600.17,++ 1788911999.6++ ],++ "all_aircraft": false,++ "source_note": "Restored historical reference-region.parquet. The listed bounds and times are observed sample extrema, not established selection coverage. Original geographic selection bounds are unknown. The original ingestion excluded known jets. This index cannot establish complete coverage.",++ "selection_bounds_known": false,++ "extent_kind": "observed_sample_extrema_only"++ },++ "normalizer_sha256": "543f483cee756fdb9efdd69c8e8f05b32e290f19187af3523160f19d2eba90e0",++ "classification_map_hash": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",++ "max_gap_s": 30.0,++ "max_flight_samples": 250000,++ "input_hash": "229d57dc810fc3f2985bae5c7fc68eb1132912cf8b95fdea2376c739d66e22a2",++ "rows": 717735,++ "invalid_rows": 0,++ "segments": 4694,++ "altitude_basis_counts": {++ "ellipsoidal": 714502,++ "ellipsoidal_interpolated": 2434,++ "barometric": 799++ },++ "jets_excluded": false,++ "unknown_types_retained": true,++ "geometry_clipped": false,++ "continuous_geometry_bounds": true,++ "prepared_tracks": {++ "version": 1,++ "builder": "177ef474f7c2ebb7a43c7f8c65d6bac8a55bafb5dda42bfa779e88ba60091fe7",++ "tracks": 4694,++ "bytes": 40986623++ }++ }++ ],++ "terrain": {++ "terrain_configuration": {++ "rasters": [++ "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/Copernicus_DSM_COG_10_N40_00_W074_00_DEM.tif"++ ],++ "geoid_raster": "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/us_nga_egm96_15.tif"++ },++ "terrain_rasters": {++ "/workspace/scratch/e20de6666de2/DOPPLERGEIST/data/terrain/Copernicus_DSM_COG_10_N40_00_W074_00_DEM.tif": "6a0f4273de0bbc0709cc9db4793a89ac40c811388f59f23f644c0304b66ab94d"++ },++ "geoid_sha256": "db493027562c9b004d7220fa881f5603adada4e1c5029b933fa7de4547b0e78d"++ }++ },++ "aggregate": {++ "run_state": "finished",++ "declared_case_count": 9,++ "finished_cases": 9,++ "verified_cases": 9,++ "complete_stage_cases": 9,++ "full_pipeline_cases": 9,++ "pairs_with_observed_differences": 35,++ "all_complete_usable_and_within_tolerances": false++ },++ "usable_cases": 9,++ "pairwise_comparison_count": 36,++ "accepted_location_count": 0,++ "accepted_location_pairs_evaluated": 0,++ "total_http_elapsed_s": 737.918059241003,++ "pairs_without_flags": [++ {++ "left": "bitrate_192",++ "right": "identical_stereo"++ }++ ],++ "cases": [++ {++ "id": "baseline",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 15,++ "ridge_count": 17,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.87528050613154,++ "lon": -73.52481091965666,++ "score": 4.171610404936489,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0006",++ "event-0007",++ "event-0010",++ "event-0011",++ "event-0011-harmonic-2",++ "event-0011-harmonic-3",++ "event-0013",++ "event-0015"++ ],++ "flight_ids": [++ "ab50b9:11",++ "a63e21:2",++ "aa61d2:3",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "ace391:3",++ "a9bd90:37"++ ],++ "recording_start_utc": "2026-09-08T20:17:29.630043Z",++ "mapped_recording_start_utc": "2026-09-08T20:17:29.630043Z",++ "matched_group_count": 6,++ "normalized_score": 0.6952684008227482,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": true++ },++ "uncertainty_radius_m": 640.002841961748,++ "mode_id": "mode-b6ce091cd94951be52e9f8ef1d18de68c1c69f84d4b2a74f466d3b3e94ccd389"++ },++ "encoding": {++ "bitrate_kbps": 128,++ "sample_rate_hz": 48000,++ "channels": 1,++ "gain_db": 0.0,++ "leading_silence_s": 0.0++ },++ "discovery": {++ "chunk_s": 120,++ "overlap_s": 60++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "baseline/input.mp3",++ "bytes": 57603885,++ "sha256": "c9cb15f40a9d64b18f66a6818d9a4f5743a8ec235a3c96330c0f8257df58ee2d"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.0503479026001506,++ "native_decode_sample_rate_hz": 48000,++ "native_decode_channels": 1,++ "native_decode_duration_s": 3600.1843125,++ "native_decode_absolute_peak": 0.05229577794671059,++ "identical_channel_max_difference": null++ },++ "http_elapsed_s": 81.15936150400012,++ "worker_high_water_at_search_completion_mib": 409.3359375,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 40,++ "refinement_points_skipped": 80,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 15,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 20.44939013900148,++ "process_peak_rss_mib": 409.3359375,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 499,++ "bounded_unknown_envelopes": 27567,++ "bounded_unknown_rejections": 11058,++ "unclassified_score_candidates": 27567,++ "unsupported_cpa_track_evaluations": 10,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": null++ },++ {++ "id": "bitrate_64",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 16,++ "ridge_count": 18,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.87665313366542,++ "lon": -73.52590021889233,++ "score": 4.680509583649809,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0006",++ "event-0007",++ "event-0010",++ "event-0011",++ "event-0011-harmonic-2",++ "event-0011-harmonic-3",++ "event-0012",++ "event-0014",++ "event-0016"++ ],++ "flight_ids": [++ "ab50b9:11",++ "a63e21:2",++ "aa61d2:3",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "a70a89:17",++ "ace391:3",++ "a9bd90:37"++ ],++ "recording_start_utc": "2026-09-08T20:17:30.104894Z",++ "mapped_recording_start_utc": "2026-09-08T20:17:30.104894Z",++ "matched_group_count": 7,++ "normalized_score": 0.668644226235687,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": true++ },++ "uncertainty_radius_m": 543.9955684918633,++ "mode_id": "mode-ef0cb97f93e5b731f4ca56cc1d49c5833222d71a50ca0dae93efe961b8730a09"++ },++ "encoding": {++ "bitrate_kbps": 64,++ "sample_rate_hz": 48000,++ "channels": 1,++ "gain_db": 0.0,++ "leading_silence_s": 0.0++ },++ "discovery": {++ "chunk_s": 120,++ "overlap_s": 60++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "bitrate_64/input.mp3",++ "bytes": 28801965,++ "sha256": "086be294865d7dc1bb3d78352cef11c76992177a81b54b068e2b6ca328c08510"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.0524758012618207,++ "native_decode_sample_rate_hz": 48000,++ "native_decode_channels": 1,++ "native_decode_duration_s": 3600.1843125,++ "native_decode_absolute_peak": 0.05212140083312988,++ "identical_channel_max_difference": null++ },++ "http_elapsed_s": 101.0311813820008,++ "worker_high_water_at_search_completion_mib": 430.97265625,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 40,++ "refinement_points_skipped": 80,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 16,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 33.04303710899876,++ "process_peak_rss_mib": 430.97265625,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 584,++ "bounded_unknown_envelopes": 51753,++ "bounded_unknown_rejections": 15561,++ "unclassified_score_candidates": 51753,++ "unsupported_cpa_track_evaluations": 13,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": {++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "associated_flights_changed",++ "distant_mode_lost"++ ],++ "diagnostic_candidate_comparison": {++ "displacement_m": 177.95093223180686,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.474851,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 543.9955684918633++ ]++ }++ }++ },++ {++ "id": "bitrate_192",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 16,++ "ridge_count": 18,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.875280044930925,++ "lon": -73.52484755356222,++ "score": 4.166530401310109,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0006",++ "event-0007",++ "event-0010",++ "event-0011",++ "event-0011-harmonic-2",++ "event-0011-harmonic-3",++ "event-0013",++ "event-0015"++ ],++ "flight_ids": [++ "ab50b9:11",++ "a63e21:2",++ "aa61d2:3",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "ace391:3",++ "a9bd90:37"++ ],++ "recording_start_utc": "2026-09-08T20:17:29.635880Z",++ "uncertainty": {++ "radius_m": 563.0868546383958,++ "method": "declared_perturbation_profiles",++ "kind": "sensitivity"++ },++ "mapped_recording_start_utc": "2026-09-08T20:17:29.635880Z",++ "matched_group_count": 6,++ "normalized_score": 0.6944217335516849,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": false++ },++ "uncertainty_radius_m": 563.0868546383958,++ "mode_id": "mode-b6ce091cd94951be52e9f8ef1d18de68c1c69f84d4b2a74f466d3b3e94ccd389"++ },++ "encoding": {++ "bitrate_kbps": 192,++ "sample_rate_hz": 48000,++ "channels": 1,++ "gain_db": 0.0,++ "leading_silence_s": 0.0++ },++ "discovery": {++ "chunk_s": 120,++ "overlap_s": 60++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "bitrate_192/input.mp3",++ "bytes": 86405805,++ "sha256": "3882a004a2261a42869b4abfd315e978a0bb1adec07383ab61995dc92566bf8d"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.03010704850065681,++ "native_decode_sample_rate_hz": 48000,++ "native_decode_channels": 1,++ "native_decode_duration_s": 3600.1843125,++ "native_decode_absolute_peak": 0.05335099995136261,++ "identical_channel_max_difference": null++ },++ "http_elapsed_s": 93.49715825900057,++ "worker_high_water_at_search_completion_mib": 410.203125,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 40,++ "refinement_points_skipped": 80,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 16,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 36.6500653639996,++ "process_peak_rss_mib": 410.203125,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 687,++ "bounded_unknown_envelopes": 50251,++ "bounded_unknown_rejections": 25441,++ "unclassified_score_candidates": 50251,++ "unsupported_cpa_track_evaluations": 20,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": {++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "uncertainty_provenance_changed",++ "retained_mode_uncertainty_provenance_changed",++ "distant_mode_lost"++ ],++ "diagnostic_candidate_comparison": {++ "displacement_m": 3.088427744321566,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.005837,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 0.0008466672710633061,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 640.002841961748,++ 563.0868546383958++ ]++ }++ }++ },++ {++ "id": "rate_44100",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 16,++ "ridge_count": 18,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.86569445065159,++ "lon": -73.50514874978012,++ "score": 3.4650575838780666,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0006",++ "event-0007",++ "event-0008",++ "event-0011",++ "event-0011-harmonic-2",++ "event-0011-harmonic-3",++ "event-0013",++ "event-0015"++ ],++ "flight_ids": [++ "ab50b9:11",++ "a63e21:2",++ "aa340e:37",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "ace391:3",++ "a9bd90:37"++ ],++ "recording_start_utc": "2026-09-08T20:17:37.082957Z",++ "mapped_recording_start_utc": "2026-09-08T20:17:37.082957Z",++ "matched_group_count": 6,++ "normalized_score": 0.5775095973130111,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": true++ },++ "uncertainty_radius_m": 515.3238214374177,++ "mode_id": "mode-2b9a89101336c5c84d7c4b97d71f86f1e7538d6c46723c51aa04d0dd4d0e95b3"++ },++ "encoding": {++ "bitrate_kbps": 128,++ "sample_rate_hz": 44100,++ "channels": 1,++ "gain_db": 0.0,++ "leading_silence_s": 0.0++ },++ "discovery": {++ "chunk_s": 120,++ "overlap_s": 60++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "rate_44100/input.mp3",++ "bytes": 57604014,++ "sha256": "cd558b15f60abd56cabc2613e70034cf5a2dd43af2e7dfe75822471ffe7e7995"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.050365732834766676,++ "native_decode_sample_rate_hz": 44100,++ "native_decode_channels": 1,++ "native_decode_duration_s": 3600.1843310657596,++ "native_decode_absolute_peak": 0.05235898494720459,++ "identical_channel_max_difference": null++ },++ "http_elapsed_s": 102.03540316600083,++ "worker_high_water_at_search_completion_mib": 452.91015625,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 41,++ "refinement_points_skipped": 70,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 16,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 29.110733892999633,++ "process_peak_rss_mib": 452.91015625,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 758,++ "bounded_unknown_envelopes": 39204,++ "bounded_unknown_rejections": 24120,++ "unclassified_score_candidates": 39204,++ "unsupported_cpa_track_evaluations": 17,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": {++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "distant_mode_lost"++ ],++ "diagnostic_candidate_comparison": {++ "displacement_m": 1969.9261974464414,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 7.452914,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 515.3238214374177++ ]++ }++ }++ },++ {++ "id": "gain_minus_6db",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 15,++ "ridge_count": 17,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.87528350581192,++ "lon": -73.5248423926746,++ "score": 4.166039445321891,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0005",++ "event-0006",++ "event-0009",++ "event-0010",++ "event-0010-harmonic-2",++ "event-0010-harmonic-3",++ "event-0012",++ "event-0014"++ ],++ "flight_ids": [++ "ab50b9:11",++ "a63e21:2",++ "aa61d2:3",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "ace391:3",++ "a9bd90:37"++ ],++ "recording_start_utc": "2026-09-08T20:17:29.635813Z",++ "mapped_recording_start_utc": "2026-09-08T20:17:29.635813Z",++ "matched_group_count": 6,++ "normalized_score": 0.6943399075536485,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": true++ },++ "uncertainty_radius_m": 591.5384979284173,++ "mode_id": "mode-81af2214443fc031dc3b3c020dfb10843b401258e4a79c6341100e7e0c284c68"++ },++ "encoding": {++ "bitrate_kbps": 128,++ "sample_rate_hz": 48000,++ "channels": 1,++ "gain_db": -6.0,++ "leading_silence_s": 0.0++ },++ "discovery": {++ "chunk_s": 120,++ "overlap_s": 60++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "gain_minus_6db/input.mp3",++ "bytes": 57603885,++ "sha256": "1353b9ab3de841d0fdc32b97a56b75032177b2a5841609c2b424b1864fab907b"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.05034018297257145,++ "native_decode_sample_rate_hz": 48000,++ "native_decode_channels": 1,++ "native_decode_duration_s": 3600.1843125,++ "native_decode_absolute_peak": 0.02619009278714657,++ "identical_channel_max_difference": null++ },++ "http_elapsed_s": 80.66737403099978,++ "worker_high_water_at_search_completion_mib": 431.9375,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 40,++ "refinement_points_skipped": 80,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 15,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 27.233806181000546,++ "process_peak_rss_mib": 431.9375,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 701,++ "bounded_unknown_envelopes": 30101,++ "bounded_unknown_rejections": 12752,++ "unclassified_score_candidates": 30101,++ "unsupported_cpa_track_evaluations": 15,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": {++ "violations": [++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "distant_mode_lost"++ ],++ "diagnostic_candidate_comparison": {++ "displacement_m": 2.673805427547985,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.00577,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 0.0009284932690997172,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 591.5384979284173++ ]++ }++ }++ },++ {++ "id": "identical_stereo",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 16,++ "ridge_count": 18,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.875266232074765,++ "lon": -73.52481429131309,++ "score": 4.176459421841993,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0006",++ "event-0007",++ "event-0010",++ "event-0011",++ "event-0011-harmonic-2",++ "event-0011-harmonic-3",++ "event-0013",++ "event-0015"++ ],++ "flight_ids": [++ "ab50b9:11",++ "a63e21:2",++ "aa61d2:3",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "ace391:3",++ "a9bd90:37"++ ],++ "recording_start_utc": "2026-09-08T20:17:29.635328Z",++ "uncertainty": {++ "radius_m": 562.6473847366728,++ "method": "declared_perturbation_profiles",++ "kind": "sensitivity"++ },++ "mapped_recording_start_utc": "2026-09-08T20:17:29.635328Z",++ "matched_group_count": 6,++ "normalized_score": 0.6960765703069988,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": false++ },++ "uncertainty_radius_m": 562.6473847366728,++ "mode_id": "mode-b6ce091cd94951be52e9f8ef1d18de68c1c69f84d4b2a74f466d3b3e94ccd389"++ },++ "encoding": {++ "bitrate_kbps": 128,++ "sample_rate_hz": 48000,++ "channels": 2,++ "gain_db": 0.0,++ "leading_silence_s": 0.0++ },++ "discovery": {++ "chunk_s": 120,++ "overlap_s": 60++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "identical_stereo/input.mp3",++ "bytes": 57603885,++ "sha256": "7078a51d1d1bab60774d35ad09ca51c74720f458f5eb7d7cbb18f8f49911d890"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.05046608208096231,++ "native_decode_sample_rate_hz": 48000,++ "native_decode_channels": 2,++ "native_decode_duration_s": 3600.1843125,++ "native_decode_absolute_peak": 0.0522184856235981,++ "identical_channel_max_difference": 0.0++ },++ "http_elapsed_s": 90.59286679599973,++ "worker_high_water_at_search_completion_mib": 413.7578125,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 40,++ "refinement_points_skipped": 80,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 16,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 34.82690319500034,++ "process_peak_rss_mib": 413.7578125,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 681,++ "bounded_unknown_envelopes": 50254,++ "bounded_unknown_rejections": 25241,++ "unclassified_score_candidates": 50254,++ "unsupported_cpa_track_evaluations": 20,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": {++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "uncertainty_provenance_changed",++ "retained_mode_uncertainty_provenance_changed",++ "distant_mode_lost"++ ],++ "diagnostic_candidate_comparison": {++ "displacement_m": 1.6104323518264563,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.005285,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 0.0008081694842505538,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 640.002841961748,++ 562.6473847366728++ ]++ }++ }++ },++ {++ "id": "leading_17_25s",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 13,++ "ridge_count": 16,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.87458127610311,++ "lon": -73.52372180984088,++ "score": 4.7619907603243,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0001",++ "event-0004",++ "event-0006",++ "event-0010",++ "event-0011",++ "event-0011-harmonic-2",++ "event-0011-harmonic-3",++ "event-0012",++ "event-0013"++ ],++ "flight_ids": [++ "a40d8f:1",++ "a1cecb:5",++ "ab50b9:11",++ "aa61d2:3",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "ace391:3",++ "ab29ff:4"++ ],++ "recording_start_utc": "2026-09-08T20:17:12.593703Z",++ "uncertainty": {++ "radius_m": 524.906058378267,++ "method": "declared_perturbation_profiles",++ "kind": "sensitivity"++ },++ "mapped_recording_start_utc": "2026-09-08T20:17:29.843703Z",++ "matched_group_count": 7,++ "normalized_score": 0.6802843943320429,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": false++ },++ "uncertainty_radius_m": 524.906058378267,++ "mode_id": "mode-204dc32de9a2ac6020398475645d5f1b54fbdb192274c0d897e33de87ec3911c"++ },++ "encoding": {++ "bitrate_kbps": 128,++ "sample_rate_hz": 48000,++ "channels": 1,++ "gain_db": 0.0,++ "leading_silence_s": 17.25++ },++ "discovery": {++ "chunk_s": 120,++ "overlap_s": 60++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:02.750000Z",++ "end_utc": "2026-09-08T20:17:22.750000Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "leading_17_25s/input.mp3",++ "bytes": 57879981,++ "sha256": "e0021632abb4d0eb0735151adc6418cc273e0048bfd36016ac0cccfd59076094"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.05035239830008654,++ "native_decode_sample_rate_hz": 48000,++ "native_decode_channels": 1,++ "native_decode_duration_s": 3617.4343125,++ "native_decode_absolute_peak": 0.05227542668581009,++ "identical_channel_max_difference": null++ },++ "http_elapsed_s": 90.7256045030008,++ "worker_high_water_at_search_completion_mib": 465.765625,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 40,++ "refinement_points_skipped": 80,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 13,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 14.560085004000939,++ "process_peak_rss_mib": 465.765625,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 434,++ "bounded_unknown_envelopes": 20943,++ "bounded_unknown_rejections": 3556,++ "unclassified_score_candidates": 20943,++ "unsupported_cpa_track_evaluations": 5,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": {++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "mapped_ridge_frequency",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ],++ "diagnostic_candidate_comparison": {++ "displacement_m": 120.24078408612776,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.21366,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 640.002841961748,++ 524.906058378267++ ]++ }++ }++ },++ {++ "id": "chunks_60_30",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 11,++ "ridge_count": 13,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.87504318887894,++ "lon": -73.52460015431907,++ "score": 2.7873362239345285,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0007",++ "event-0008",++ "event-0008-harmonic-2",++ "event-0008-harmonic-3",++ "event-0009",++ "event-0011"++ ],++ "flight_ids": [++ "aa61d2:3",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "ace391:3",++ "a6decf:19"++ ],++ "recording_start_utc": "2026-09-08T20:17:29.695680Z",++ "mapped_recording_start_utc": "2026-09-08T20:17:29.695680Z",++ "matched_group_count": 4,++ "normalized_score": 0.6968340559836321,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": true++ },++ "uncertainty_radius_m": 629.8870582331216,++ "mode_id": "mode-ea04219a25aa39ff5358939baf12d14998b58920aa1aa6ed10c69f2009051829"++ },++ "encoding": {++ "bitrate_kbps": 128,++ "sample_rate_hz": 48000,++ "channels": 1,++ "gain_db": 0.0,++ "leading_silence_s": 0.0++ },++ "discovery": {++ "chunk_s": 60.0,++ "overlap_s": 30.0++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "chunks_60_30/input.mp3",++ "bytes": 57603885,++ "sha256": "c9cb15f40a9d64b18f66a6818d9a4f5743a8ec235a3c96330c0f8257df58ee2d"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.0503479026001506,++ "native_decode_sample_rate_hz": 48000,++ "native_decode_channels": 1,++ "native_decode_duration_s": 3600.1843125,++ "native_decode_absolute_peak": 0.05229577794671059,++ "identical_channel_max_difference": null++ },++ "http_elapsed_s": 48.30245543700039,++ "worker_high_water_at_search_completion_mib": 408.0546875,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 40,++ "refinement_points_skipped": 80,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 11,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 9.143885532999775,++ "process_peak_rss_mib": 408.0546875,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 251,++ "bounded_unknown_envelopes": 11354,++ "bounded_unknown_rejections": 6940,++ "unclassified_score_candidates": 11354,++ "unsupported_cpa_track_evaluations": 7,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": {++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ],++ "diagnostic_candidate_comparison": {++ "displacement_m": 31.783549576707504,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.065637,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 629.8870582331216++ ]++ }++ }++ },++ {++ "id": "chunks_180_60",++ "state": "finished",++ "status": "inconclusive",++ "reason_code": "search_incomplete",++ "verification_passed": true,++ "full_pipeline_observed": true,++ "full_pipeline_requirements_met": true,++ "stages_verified": [++ "automatic_provenance",++ "intake",++ "discovery",++ "acquisition",++ "search",++ "refinement",++ "decision"++ ],++ "group_count": 13,++ "ridge_count": 15,++ "diagnostic_candidate_count": 23,++ "accepted_location": false,++ "leading_diagnostic_candidate": {++ "lat": 40.875028312431475,++ "lon": -73.5246566868786,++ "score": 3.3668352632530354,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "event_ids": [++ "event-0005",++ "event-0008",++ "event-0009",++ "event-0009-harmonic-2",++ "event-0009-harmonic-3",++ "event-0012",++ "event-0013"++ ],++ "flight_ids": [++ "a63e21:2",++ "aa61d2:3",++ "a1dfeb:1",++ "a1dfeb:1",++ "a1dfeb:1",++ "ace391:3",++ "a6decf:19"++ ],++ "recording_start_utc": "2026-09-08T20:17:29.683680Z",++ "mapped_recording_start_utc": "2026-09-08T20:17:29.683680Z",++ "matched_group_count": 5,++ "normalized_score": 0.673367052650607,++ "uncertainty_provenance": {++ "kind": "sensitivity",++ "method": "declared_perturbation_profiles",++ "sources": [++ "altitude",++ "clock",++ "frequency",++ "sound_speed",++ "source_frequency"++ ],++ "complete": true,++ "boundary_limited": true++ },++ "uncertainty_radius_m": 678.9789239751518,++ "mode_id": "mode-1411b3de338b324b71351c01b1700083ac512eb657fd5e0ed22cf79ebfa68016"++ },++ "encoding": {++ "bitrate_kbps": 128,++ "sample_rate_hz": 48000,++ "channels": 1,++ "gain_db": 0.0,++ "leading_silence_s": 0.0++ },++ "discovery": {++ "chunk_s": 180.0,++ "overlap_s": 60.0++ },++ "time_window": {++ "start_utc": "2026-09-08T20:17:20Z",++ "end_utc": "2026-09-08T20:17:40Z",++ "source": "user",++ "source_detail": "Existing source-informed reference development control; not independent timing or localization acceptance."++ },++ "encoded_input": {++ "file": "chunks_180_60/input.mp3",++ "bytes": 57603885,++ "sha256": "c9cb15f40a9d64b18f66a6818d9a4f5743a8ec235a3c96330c0f8257df58ee2d"++ },++ "usability": {++ "passed": true,++ "duration_error_s": 0.0,++ "maximum_absolute_lag_s": 0.0,++ "gain_corrected_nrmse": 0.0503479026001506,++ "native_decode_sample_rate_hz": 48000,++ "native_decode_channels": 1,++ "native_decode_duration_s": 3600.1843125,++ "native_decode_absolute_peak": 0.05229577794671059,++ "identical_channel_max_difference": null++ },++ "http_elapsed_s": 49.906654162999985,++ "worker_high_water_at_search_completion_mib": 436.25,++ "sampled_descendant_peak_rss_mib": null,++ "work": {++ "status": "partial",++ "tiles_total": 2,++ "tiles_completed": 2,++ "tiles_resumed": 0,++ "unsearched_tiles": 0,++ "grid_points_searched": 4,++ "refinement_points_searched": 40,++ "refinement_points_skipped": 80,++ "refinement_stages_resumed": 0,++ "model_assessment_complete": false,++ "model_support_complete": false,++ "data_scope_complete": false,++ "all_event_groups_considered": true,++ "event_groups_proposed": 13,++ "alternative_modes_exhaustively_assessed": false,++ "elapsed_s": 14.429873888999282,++ "process_peak_rss_mib": 436.25,++ "bounded_concurrency": 1++ },++ "coverage": {++ "search_complete": false,++ "data_status": "partial",++ "missing_data": [++ "historical_flight_scope_or_audible_border_region"++ ]++ },++ "finite_search": {++ "complete": false,++ "score_kind": "matched_group_support_minus_normalized_residual",++ "evaluated_modes": 505,++ "bounded_unknown_envelopes": 16021,++ "bounded_unknown_rejections": 7693,++ "unclassified_score_candidates": 16021,++ "unsupported_cpa_track_evaluations": 7,++ "discarded_bound_status": "unknown_model_or_trial_support"++ },++ "baseline_comparison": {++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ],++ "diagnostic_candidate_comparison": {++ "displacement_m": 30.87694353770974,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.053637,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 678.9789239751518++ ]++ }++ }++ }++ ],++ "pairwise": [++ {++ "left": "baseline",++ "right": "bitrate_64",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 1,++ "ridge_count_delta": 1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [],++ "unmatched_right": [++ "event-0012"++ ],++ "unmatched_left_groups": [],++ "unmatched_right_groups": [++ "harmonics-0012"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 7,++ "distant_modes_without_full_association_match": 7,++ "diagnostic_candidate_comparison": {++ "displacement_m": 177.95093223180686,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.474851,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 543.9955684918633++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "baseline",++ "right": "bitrate_192",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 1,++ "ridge_count_delta": 1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [],++ "unmatched_right": [++ "event-0016"++ ],++ "unmatched_left_groups": [],++ "unmatched_right_groups": [++ "harmonics-0016"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 17,++ "unmatched_retained_left_count": 6,++ "unmatched_retained_right_count": 6,++ "distant_modes_count": 4,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 3.088427744321566,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.005837,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 0.0008466672710633061,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 640.002841961748,++ 563.0868546383958++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "uncertainty_provenance_changed",++ "retained_mode_uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "baseline",++ "right": "rate_44100",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 1,++ "ridge_count_delta": 1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 16,++ "unmatched_left": [++ "event-0010"++ ],++ "unmatched_right": [++ "event-0010",++ "event-0016"++ ],++ "unmatched_left_groups": [++ "harmonics-0010"++ ],++ "unmatched_right_groups": [++ "harmonics-0010",++ "harmonics-0016"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 15,++ "distant_modes_without_full_association_match": 15,++ "diagnostic_candidate_comparison": {++ "displacement_m": 1969.9261974464414,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 7.452914,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 515.3238214374177++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "distant_mode_lost"++ ]++ },++ {++ "left": "baseline",++ "right": "gain_minus_6db",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 0,++ "ridge_count_delta": 0,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 16,++ "unmatched_left": [++ "event-0001"++ ],++ "unmatched_right": [++ "event-0015"++ ],++ "unmatched_left_groups": [++ "harmonics-0001"++ ],++ "unmatched_right_groups": [++ "harmonics-0015"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 17,++ "unmatched_retained_left_count": 6,++ "unmatched_retained_right_count": 6,++ "distant_modes_count": 4,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 2.673805427547985,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.00577,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 0.0009284932690997172,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 591.5384979284173++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "distant_mode_lost"++ ]++ },++ {++ "left": "baseline",++ "right": "identical_stereo",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 1,++ "ridge_count_delta": 1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [],++ "unmatched_right": [++ "event-0016"++ ],++ "unmatched_left_groups": [],++ "unmatched_right_groups": [++ "harmonics-0016"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 17,++ "unmatched_retained_left_count": 6,++ "unmatched_retained_right_count": 6,++ "distant_modes_count": 4,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 1.6104323518264563,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.005285,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 0.0008081694842505538,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 640.002841961748,++ 562.6473847366728++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "uncertainty_provenance_changed",++ "retained_mode_uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "baseline",++ "right": "leading_17_25s",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -2,++ "ridge_count_delta": -1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0001",++ "event-0005",++ "event-0007",++ "event-0012",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0003",++ "event-0004",++ "event-0007",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0005",++ "harmonics-0007",++ "harmonics-0012",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0007",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 8,++ "distant_modes_without_full_association_match": 8,++ "diagnostic_candidate_comparison": {++ "displacement_m": 120.24078408612776,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.21366,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 640.002841961748,++ 524.906058378267++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "mapped_ridge_frequency",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "baseline",++ "right": "chunks_60_30",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -4,++ "ridge_count_delta": -4,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0007",++ "event-0012",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0010",++ "event-0011"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0007",++ "harmonics-0012",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0010",++ "harmonics-0011"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 4,++ "distant_modes_without_full_association_match": 4,++ "diagnostic_candidate_comparison": {++ "displacement_m": 31.783549576707504,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.065637,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 629.8870582331216++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "baseline",++ "right": "chunks_180_60",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -2,++ "ridge_count_delta": -2,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 13,++ "unmatched_left": [++ "event-0004",++ "event-0007",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0011",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0007",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0011",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 4,++ "distant_modes_without_full_association_match": 4,++ "diagnostic_candidate_comparison": {++ "displacement_m": 30.87694353770974,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.053637,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 640.002841961748,++ 678.9789239751518++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_64",++ "right": "bitrate_192",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 0,++ "ridge_count_delta": 0,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [++ "event-0012"++ ],++ "unmatched_right": [++ "event-0016"++ ],++ "unmatched_left_groups": [++ "harmonics-0012"++ ],++ "unmatched_right_groups": [++ "harmonics-0016"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 5,++ "distant_modes_without_full_association_match": 5,++ "diagnostic_candidate_comparison": {++ "displacement_m": 176.42168764822333,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.469014,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 543.9955684918633,++ 563.0868546383958++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "ridge_correspondence_incomplete",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_64",++ "right": "rate_44100",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 0,++ "ridge_count_delta": 0,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 16,++ "unmatched_left": [++ "event-0010",++ "event-0012"++ ],++ "unmatched_right": [++ "event-0010",++ "event-0016"++ ],++ "unmatched_left_groups": [++ "harmonics-0010",++ "harmonics-0012"++ ],++ "unmatched_right_groups": [++ "harmonics-0010",++ "harmonics-0016"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 16,++ "distant_modes_without_full_association_match": 16,++ "diagnostic_candidate_comparison": {++ "displacement_m": 2131.0014278580384,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 6.978063,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 543.9955684918633,++ 515.3238214374177++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_64",++ "right": "gain_minus_6db",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -1,++ "ridge_count_delta": -1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 16,++ "unmatched_left": [++ "event-0001",++ "event-0012"++ ],++ "unmatched_right": [++ "event-0015"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0012"++ ],++ "unmatched_right_groups": [++ "harmonics-0015"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 5,++ "distant_modes_without_full_association_match": 5,++ "diagnostic_candidate_comparison": {++ "displacement_m": 176.3092166596476,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.469081,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 543.9955684918633,++ 591.5384979284173++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_64",++ "right": "identical_stereo",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 0,++ "ridge_count_delta": 0,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [++ "event-0012"++ ],++ "unmatched_right": [++ "event-0016"++ ],++ "unmatched_left_groups": [++ "harmonics-0012"++ ],++ "unmatched_right_groups": [++ "harmonics-0016"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 5,++ "distant_modes_without_full_association_match": 5,++ "diagnostic_candidate_comparison": {++ "displacement_m": 179.16527548873552,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.469566,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 543.9955684918633,++ 562.6473847366728++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "ridge_correspondence_incomplete",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_64",++ "right": "leading_17_25s",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -3,++ "ridge_count_delta": -2,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0001",++ "event-0005",++ "event-0007",++ "event-0012",++ "event-0013",++ "event-0015",++ "event-0016"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0003",++ "event-0004",++ "event-0007",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0005",++ "harmonics-0007",++ "harmonics-0012",++ "harmonics-0013",++ "harmonics-0015",++ "harmonics-0016"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0007",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 9,++ "distant_modes_without_full_association_match": 9,++ "diagnostic_candidate_comparison": {++ "displacement_m": 294.3743680862555,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.261191,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 543.9955684918633,++ 524.906058378267++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "mapped_ridge_frequency",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_64",++ "right": "chunks_60_30",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -5,++ "ridge_count_delta": -5,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0007",++ "event-0012",++ "event-0013",++ "event-0015",++ "event-0016"++ ],++ "unmatched_right": [++ "event-0010",++ "event-0011"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0007",++ "harmonics-0012",++ "harmonics-0013",++ "harmonics-0015",++ "harmonics-0016"++ ],++ "unmatched_right_groups": [++ "harmonics-0010",++ "harmonics-0011"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 5,++ "distant_modes_without_full_association_match": 5,++ "diagnostic_candidate_comparison": {++ "displacement_m": 209.69941712846025,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.409214,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 543.9955684918633,++ 629.8870582331216++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_64",++ "right": "chunks_180_60",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -3,++ "ridge_count_delta": -3,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 13,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0012",++ "event-0015",++ "event-0016"++ ],++ "unmatched_right": [++ "event-0011",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0012",++ "harmonics-0015",++ "harmonics-0016"++ ],++ "unmatched_right_groups": [++ "harmonics-0011",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 5,++ "distant_modes_without_full_association_match": 5,++ "diagnostic_candidate_comparison": {++ "displacement_m": 208.67581422179455,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.421214,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 543.9955684918633,++ 678.9789239751518++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_192",++ "right": "rate_44100",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 0,++ "ridge_count_delta": 0,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [++ "event-0010"++ ],++ "unmatched_right": [++ "event-0010"++ ],++ "unmatched_left_groups": [++ "harmonics-0010"++ ],++ "unmatched_right_groups": [++ "harmonics-0010"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 13,++ "distant_modes_without_full_association_match": 13,++ "diagnostic_candidate_comparison": {++ "displacement_m": 1972.4977294054368,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 7.447077,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 563.0868546383958,++ 515.3238214374177++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_192",++ "right": "gain_minus_6db",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -1,++ "ridge_count_delta": -1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [++ "event-0001"++ ],++ "unmatched_right": [],++ "unmatched_left_groups": [++ "harmonics-0001"++ ],++ "unmatched_right_groups": [],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 23,++ "unmatched_retained_left_count": 0,++ "unmatched_retained_right_count": 0,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 0,++ "diagnostic_candidate_comparison": {++ "displacement_m": 0.5804868638512307,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 6.7e-05,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 8.182599803641111e-05,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 563.0868546383958,++ 591.5384979284173++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "uncertainty_provenance_changed",++ "retained_mode_uncertainty_provenance_changed"++ ]++ },++ {++ "left": "bitrate_192",++ "right": "identical_stereo",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 0,++ "ridge_count_delta": 0,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 18,++ "unmatched_left": [],++ "unmatched_right": [],++ "unmatched_left_groups": [],++ "unmatched_right_groups": [],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 23,++ "unmatched_retained_left_count": 0,++ "unmatched_retained_right_count": 0,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 0,++ "diagnostic_candidate_comparison": {++ "displacement_m": 3.1959708464021874,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.000552,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 0.0016548367553138599,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 563.0868546383958,++ 562.6473847366728++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": []++ },++ {++ "left": "bitrate_192",++ "right": "leading_17_25s",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -3,++ "ridge_count_delta": -2,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0001",++ "event-0005",++ "event-0007",++ "event-0012",++ "event-0014",++ "event-0015",++ "event-0016"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0003",++ "event-0004",++ "event-0007",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0005",++ "harmonics-0007",++ "harmonics-0012",++ "harmonics-0014",++ "harmonics-0015",++ "harmonics-0016"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0007",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 6,++ "distant_modes_without_full_association_match": 6,++ "diagnostic_candidate_comparison": {++ "displacement_m": 122.58231777413928,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.207823,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 563.0868546383958,++ 524.906058378267++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "mapped_ridge_frequency",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_192",++ "right": "chunks_60_30",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -5,++ "ridge_count_delta": -5,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 12,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0007",++ "event-0012",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0010"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0007",++ "harmonics-0012",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0010"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 33.56720405193145,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.0598,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 563.0868546383958,++ 629.8870582331216++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "bitrate_192",++ "right": "chunks_180_60",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -3,++ "ridge_count_delta": -3,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 14,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0011"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0011"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 32.25443807929025,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.0478,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 563.0868546383958,++ 678.9789239751518++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "rate_44100",++ "right": "gain_minus_6db",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -1,++ "ridge_count_delta": -1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 16,++ "unmatched_left": [++ "event-0001",++ "event-0010"++ ],++ "unmatched_right": [++ "event-0009"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0010"++ ],++ "unmatched_right_groups": [++ "harmonics-0009"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 13,++ "distant_modes_without_full_association_match": 13,++ "diagnostic_candidate_comparison": {++ "displacement_m": 1972.3389175354357,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 7.447144,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 515.3238214374177,++ 591.5384979284173++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "distant_mode_lost"++ ]++ },++ {++ "left": "rate_44100",++ "right": "identical_stereo",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 0,++ "ridge_count_delta": 0,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [++ "event-0010"++ ],++ "unmatched_right": [++ "event-0010"++ ],++ "unmatched_left_groups": [++ "harmonics-0010"++ ],++ "unmatched_right_groups": [++ "harmonics-0010"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 13,++ "distant_modes_without_full_association_match": 13,++ "diagnostic_candidate_comparison": {++ "displacement_m": 1969.309446910822,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 7.447629,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 515.3238214374177,++ 562.6473847366728++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "rate_44100",++ "right": "leading_17_25s",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -3,++ "ridge_count_delta": -2,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 10,++ "unmatched_left": [++ "event-0001",++ "event-0005",++ "event-0007",++ "event-0009",++ "event-0012",++ "event-0014",++ "event-0015",++ "event-0016"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0003",++ "event-0004",++ "event-0007",++ "event-0010",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0005",++ "harmonics-0007",++ "harmonics-0009",++ "harmonics-0012",++ "harmonics-0014",++ "harmonics-0015",++ "harmonics-0016"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0007",++ "harmonics-0010",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 17,++ "distant_modes_without_full_association_match": 17,++ "diagnostic_candidate_comparison": {++ "displacement_m": 1850.786591059881,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 7.239254,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 515.3238214374177,++ 524.906058378267++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "mapped_ridge_frequency",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "rate_44100",++ "right": "chunks_60_30",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -5,++ "ridge_count_delta": -5,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0007",++ "event-0009",++ "event-0012",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0007",++ "event-0010"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0007",++ "harmonics-0009",++ "harmonics-0012",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0007",++ "harmonics-0010"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 13,++ "distant_modes_without_full_association_match": 13,++ "diagnostic_candidate_comparison": {++ "displacement_m": 1940.7778114010532,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 7.387277,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 515.3238214374177,++ 629.8870582331216++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "distant_mode_lost"++ ]++ },++ {++ "left": "rate_44100",++ "right": "chunks_180_60",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -3,++ "ridge_count_delta": -3,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 13,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0010",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0008",++ "event-0011"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0010",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0008",++ "harmonics-0011"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 13,++ "distant_modes_without_full_association_match": 13,++ "diagnostic_candidate_comparison": {++ "displacement_m": 1943.9247228712218,++ "within_threshold_m": {++ "100": false,++ "500": false,++ "1000": false++ },++ "mapped_clock_delta_s": 7.399277,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 515.3238214374177,++ 678.9789239751518++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "fitted_clock_changed",++ "diagnostic_candidate_jump",++ "distant_mode_lost"++ ]++ },++ {++ "left": "gain_minus_6db",++ "right": "identical_stereo",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 1,++ "ridge_count_delta": 1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 17,++ "unmatched_left": [],++ "unmatched_right": [++ "event-0001"++ ],++ "unmatched_left_groups": [],++ "unmatched_right_groups": [++ "harmonics-0001"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 23,++ "unmatched_retained_left_count": 0,++ "unmatched_retained_right_count": 0,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 0,++ "diagnostic_candidate_comparison": {++ "displacement_m": 3.048084987013801,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.000485,++ "associated_flights_equal": true,++ "score_units_equal": true,++ "normalized_score_comparable": true,++ "normalized_score_delta": 0.001736662753350271,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 591.5384979284173,++ 562.6473847366728++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "uncertainty_provenance_changed",++ "retained_mode_uncertainty_provenance_changed"++ ]++ },++ {++ "left": "gain_minus_6db",++ "right": "leading_17_25s",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -2,++ "ridge_count_delta": -1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0011",++ "event-0013",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0003",++ "event-0004",++ "event-0007",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0011",++ "harmonics-0013",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0007",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 6,++ "distant_modes_without_full_association_match": 6,++ "diagnostic_candidate_comparison": {++ "displacement_m": 122.49018807645596,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.20789,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 591.5384979284173,++ 524.906058378267++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "mapped_ridge_frequency",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "gain_minus_6db",++ "right": "chunks_60_30",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -4,++ "ridge_count_delta": -4,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0003",++ "event-0005",++ "event-0006",++ "event-0011",++ "event-0013",++ "event-0014"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0010"++ ],++ "unmatched_left_groups": [++ "harmonics-0003",++ "harmonics-0005",++ "harmonics-0006",++ "harmonics-0011",++ "harmonics-0013",++ "harmonics-0014"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0010"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 33.60309883689145,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.059867,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 591.5384979284173,++ 629.8870582331216++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "gain_minus_6db",++ "right": "chunks_180_60",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -2,++ "ridge_count_delta": -2,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 13,++ "unmatched_left": [++ "event-0003",++ "event-0005",++ "event-0013",++ "event-0014"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0011"++ ],++ "unmatched_left_groups": [++ "harmonics-0003",++ "harmonics-0005",++ "harmonics-0013",++ "harmonics-0014"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0011"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 32.37554428379954,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.047867,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 591.5384979284173,++ 678.9789239751518++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "identical_stereo",++ "right": "leading_17_25s",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -3,++ "ridge_count_delta": -2,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 11,++ "unmatched_left": [++ "event-0001",++ "event-0005",++ "event-0007",++ "event-0012",++ "event-0014",++ "event-0015",++ "event-0016"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0003",++ "event-0004",++ "event-0007",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0005",++ "harmonics-0007",++ "harmonics-0012",++ "harmonics-0014",++ "harmonics-0015",++ "harmonics-0016"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0007",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 6,++ "distant_modes_without_full_association_match": 6,++ "diagnostic_candidate_comparison": {++ "displacement_m": 119.44224244015248,++ "within_threshold_m": {++ "100": false,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.208375,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 562.6473847366728,++ 524.906058378267++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "mapped_ridge_frequency",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "identical_stereo",++ "right": "chunks_60_30",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -5,++ "ridge_count_delta": -5,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 12,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0007",++ "event-0012",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0010"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0007",++ "harmonics-0012",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0010"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 30.648564045631886,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.060352,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 562.6473847366728,++ 629.8870582331216++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "identical_stereo",++ "right": "chunks_180_60",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -3,++ "ridge_count_delta": -3,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 14,++ "unmatched_left": [++ "event-0004",++ "event-0006",++ "event-0014",++ "event-0015"++ ],++ "unmatched_right": [++ "event-0011"++ ],++ "unmatched_left_groups": [++ "harmonics-0004",++ "harmonics-0006",++ "harmonics-0014",++ "harmonics-0015"++ ],++ "unmatched_right_groups": [++ "harmonics-0011"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 29.573296043587717,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.048352,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 562.6473847366728,++ 678.9789239751518++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "leading_17_25s",++ "right": "chunks_60_30",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": -2,++ "ridge_count_delta": -3,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 9,++ "unmatched_left": [++ "event-0001",++ "event-0003",++ "event-0004",++ "event-0005",++ "event-0006",++ "event-0007",++ "event-0013"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0004",++ "event-0010",++ "event-0011"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0005",++ "harmonics-0006",++ "harmonics-0007",++ "harmonics-0013"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0010",++ "harmonics-0011"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 6,++ "distant_modes_without_full_association_match": 6,++ "diagnostic_candidate_comparison": {++ "displacement_m": 90.0728104195123,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.148023,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 524.906058378267,++ 629.8870582331216++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "leading_17_25s",++ "right": "chunks_180_60",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 0,++ "ridge_count_delta": -1,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 10,++ "unmatched_left": [++ "event-0001",++ "event-0003",++ "event-0004",++ "event-0005",++ "event-0007",++ "event-0013"++ ],++ "unmatched_right": [++ "event-0001",++ "event-0004",++ "event-0010",++ "event-0011",++ "event-0013"++ ],++ "unmatched_left_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0005",++ "harmonics-0007",++ "harmonics-0013"++ ],++ "unmatched_right_groups": [++ "harmonics-0001",++ "harmonics-0004",++ "harmonics-0010",++ "harmonics-0011",++ "harmonics-0013"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 6,++ "distant_modes_without_full_association_match": 6,++ "diagnostic_candidate_comparison": {++ "displacement_m": 93.1381327059274,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.160023,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": false,++ "uncertainty_radius_m": [++ 524.906058378267,++ 678.9789239751518++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "mapped_ridge_frequency",++ "associated_flights_changed",++ "uncertainty_provenance_changed",++ "distant_mode_lost"++ ]++ },++ {++ "left": "chunks_60_30",++ "right": "chunks_180_60",++ "representation_usable": true,++ "complete_pipelines": true,++ "status_transition": [++ "inconclusive",++ "inconclusive"++ ],++ "reason_transition": [++ "search_incomplete",++ "search_incomplete"++ ],++ "group_count_delta": 2,++ "ridge_count_delta": 2,++ "coverage_equal": false,++ "decision_provenance_equal": true,++ "event_correspondence": {++ "matched_count": 12,++ "unmatched_left": [++ "event-0011"++ ],++ "unmatched_right": [++ "event-0005",++ "event-0010",++ "event-0011"++ ],++ "unmatched_left_groups": [++ "harmonics-0011"++ ],++ "unmatched_right_groups": [++ "harmonics-0005",++ "harmonics-0010",++ "harmonics-0011"++ ],++ "split_groups": {},++ "merged_groups": {}++ },++ "retained_mode_correspondence_count": 0,++ "unmatched_retained_left_count": 23,++ "unmatched_retained_right_count": 23,++ "distant_modes_count": 2,++ "distant_modes_without_full_association_match": 2,++ "diagnostic_candidate_comparison": {++ "displacement_m": 5.04359288377642,++ "within_threshold_m": {++ "100": true,++ "500": true,++ "1000": true++ },++ "mapped_clock_delta_s": 0.012,++ "associated_flights_equal": false,++ "score_units_equal": true,++ "normalized_score_comparable": false,++ "normalized_score_delta": null,++ "uncertainty_provenance_equal": true,++ "uncertainty_radius_m": [++ 629.8870582331216,++ 678.9789239751518++ ]++ },++ "accepted_location_displacement_m": null,++ "serious_accepted_jump": false,++ "violations": [++ "group_count_changed",++ "ridge_correspondence_incomplete",++ "mapped_event_edges",++ "associated_flights_changed",++ "distant_mode_lost"++ ]++ }++ ],++ "chunk_inputs_byte_identical_to_baseline": true,++ "rate_44100_interpretation": {++ "missing_baseline_event": {++ "event_id": "event-0010",++ "harmonic_group_id": "harmonics-0010",++ "start_s": 1396.5,++ "end_s": 1418.5,++ "band_hz": [++ 75.49194688163698,++ 93.47661251202226++ ]++ },++ "missing_baseline_association_flight_id": "aa61d2:3",++ "baseline_candidates_using_missing_event": 23,++ "baseline_parent_public_rank": 3,++ "baseline_parent_mode_id": "mode-b6ce091cd94951be52e9f8ef1d18de68c1c69f84d4b2a74f466d3b3e94ccd389",++ "variant_reduced_remnant_public_rank": 11,++ "variant_reduced_remnant_retained_rank": 8,++ "variant_reduced_remnant_mode_id": "mode-f9e1ded22129f5cde1442693e6e9ea836d7143c52173f7c3bf6a329002d5423d",++ "remaining_group_count": 5,++ "parent_and_remnant_lat_lon": [++ 40.87348267287692,++ -73.52240429826175++ ],++ "parent_and_remnant_mapped_recording_start_utc": "2026-09-08T20:17:30.124955Z",++ "remnant_distance_from_refined_baseline_winner_m": 284.6319378756171,++ "remnant_clock_delta_from_refined_baseline_winner_s": 0.494912,++ "interpretation": "The 1969.926 m diagnostic-winner movement accompanies a changed detected population and different associations. A five-group reduced remnant survives with the exact coordinates and clock of the baseline unrefined parent. This does not demonstrate accidental deletion or reordering of an identical hypothesis."++ },++ "truth_evaluation": {++ "eligible": false,++ "evaluated": false,++ "reason": "No independent truth supplied to this protocol"++ },++ "national_gate_satisfied": false,++ "limitations": [++ "All nine scientific decisions remain inconclusive/search_incomplete. No accepted-location displacement or independent truth error was evaluated.",++ "This regional, source-informed request and incomplete historical coverage cannot satisfy the issue 61 national gate.",++ "Passing global PCM/lag/peak checks does not establish preservation of every weak narrow-band acoustic cue.",++ "distant_mode_lost is a failed strict full-association correspondence. Changed detected groups can trigger it without proving that the same hypothesis was pruned.",++ "The original aggregate descendant-RSS sampler could not traverse this proc mount. All nine original aggregate readings remain null. Worker high-water values were recorded at search completion and are not certified whole-job peaks.",++ "The compact file summarizes comparisons. Raw artifacts retain every mapped ridge, candidate, comparison, command and persisted HTTP job. Local raw-artifact paths are execution provenance, not portable download links."++ ],++ "post_run_instrumentation": {++ "correction_commit": "e35c8487d59c127e7274582ffd7ce61747411a72",++ "control": {++ "scope": "actual_short_upload_instrumentation_control",++ "declared_matrix_arm": false,++ "historical_matrix_rss_values_changed": false,++ "http_verification_passed": true,++ "status": "needs_input",++ "reason": "recording_time_required",++ "memory": {++ "sampled_descendant_peak_rss_mib": 129.7421875,++ "interval_s": 0.1,++ "samples": 16,++ "thread_error": null,++ "stop_timed_out": false,++ "partial_measurement": false,++ "skipped_process_reads": 0,++ "traversal": "ppid_snapshot",++ "unavailable_reason": null,++ "scope": "Sum of local service and worker descendant RSS; sampled lower bound, not unique physical memory"++ },++ "sampler_stopped": true,++ "runtime_pins": {++ "packages": {++ "numpy": "2.3.5",++ "scipy": "1.17.0",++ "pandas": "2.2.3",++ "pyproj": "3.8.0",++ "rasterio": "1.5.2",++ "pyarrow": "26.0.1",++ "matplotlib": "3.10.8",++ "shapely": null++ },++ "geos_version": null,++ "missing_runtime_pins": []++ },++ "runner_sha256": "af7776ef93c67c47c136021468780c064eacffdc525e5f7b6275e062e85a1d31",++ "software_error_controls": {++ "scope": "software instrumentation checks, not scientific arms",++ "unexpected_thread_error_preserved": true,++ "bounded_stop_timeout_preserved": true,++ "missing_proc_unavailable": true,++ "context_exception_stops_sampler": true,++ "stop_timeout_elapsed_s": 0.05026156999883824++ }++ },++ "historical_values_changed": false,++ "scope": "Separate short actual-upload control only; not a declared scientific arm."++ },++ "raw_artifact_root": "/workspace/scratch/e20de6666de2",++ "raw_artifacts": {++ "verification-issue61-plan/plan.json": {++ "bytes": 27269,++ "sha256": "b1a438921df56c3d1ac17a840c4d9fc4ff2c1d605dd8d61366343bce57e7887d"++ },++ "verification-issue61-matrix/report.json": {++ "bytes": 2351784,++ "sha256": "e21692595e63c32fd82827060ec6cd934c11c2b0918035536bd24b0905ba7777"++ },++ "verification-issue61-matrix/state.json": {++ "bytes": 1758985,++ "sha256": "339e7088376f4e540a0bf458160f24b4e70cc1e0fdb20ab42fdb0dc22445a667"++ }++ },++ "raw_case_artifacts": "/workspace/scratch/e20de6666de2/verification-issue61-matrix/<case-id>",++ "reproduction_note": "Use the archived frozen source and the recorded data/configuration/runtime identities for this historical comparison. Prepare a new immutable plan for a changed source, dependency set or request. No historical plan or result was rewritten after the instrumentation correction."++}diff --cc scripts/run_real_metamorphic.pyindex 598d0f8,0000000..508db22mode 100644,000000..100644--- a/scripts/run_real_metamorphic.py+++ b/scripts/run_real_metamorphic.py@@@ -1,831 -1,0 +1,923 @@@+#!/usr/bin/env python3+"""Run fresh HTTP jobs for a predeclared real-recording representation matrix.++Prepare freezes configuration, inputs and implementation before any arm runs.+Run preserves failed, inconclusive and unusable arms. Report only compares them.+"""+from __future__ import annotations++import argparse+from copy import deepcopy+from datetime import datetime, timedelta, timezone+from importlib import metadata+from importlib.machinery import EXTENSION_SUFFIXES+import inspect+import itertools+import json+import math+import os+from pathlib import Path+import shlex+import signal+import subprocess+import sys+import tempfile+import threading++import numpy as np+from pyproj import Geod+from scipy import signal as scipy_signal+from scipy.optimize import linear_sum_assignment++import dopplergeist+from dopplergeist.contracts import validate_request+from dopplergeist.discovery import DiscoverySettings+from dopplergeist.intake import IntakeRecording, intake_recording, probe_media+import verify_upload_http as http_verifier+++ROOT = Path(__file__).resolve().parents[1]+PROTOCOL = ROOT / "docs/verification/metamorphic_protocol_v1.json"+GEOD = Geod(ellps="WGS84")+++def read_json(path, default=None):+ path = Path(path)+ return json.loads(path.read_text()) if path.is_file() else default+++def write_json(path, value):+ """Atomic progress reports; immutable plans use exclusive creation."""+ path = Path(path)+ temporary = path.with_suffix(path.suffix + ".tmp")+ temporary.write_text(json.dumps(value, indent=2, allow_nan=False) + "\n")+ temporary.replace(path)+++def identity(path):+ path = Path(path).absolute()+ resolved = path.resolve(strict=True)+ return {"path": str(path), "resolved_path": str(resolved), "bytes": path.stat().st_size,+ "sha256": http_verifier.sha256(path)}+++def parse_utc(value):+ parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))+ if parsed.tzinfo is None:+ raise ValueError("UTC endpoints must include a timezone")+ return parsed.astimezone(timezone.utc)+++def format_utc(value):+ return value.isoformat().replace("+00:00", "Z")+++def shifted_request(request, silence_s):+ result = deepcopy(request)+ window = result.get("time_window")+ if not isinstance(window, dict):+ raise ValueError("The matrix needs a defensible sample-zero UTC window")+ for key in ("start_utc", "end_utc"):+ window[key] = format_utc(parse_utc(window[key]) - timedelta(seconds=silence_s))+ return result+++def implementation():+ from dopplergeist import data_access, matching, native_acoustic, native_cpa++ package = Path(dopplergeist.__file__).resolve().parent+ result = {+ "package_files": {p.relative_to(package).as_posix(): http_verifier.sha256(p)+ for p in sorted(package.rglob("*")) if p.is_file() and (+ p.suffix in {".py", ".c"} or any(p.name.endswith(suffix) for suffix in EXTENSION_SUFFIXES))},+ "runner_sha256": http_verifier.sha256(__file__),+ "verifier_sha256": http_verifier.sha256(http_verifier.__file__),+ "python": sys.version, "executable": sys.executable,+ "packages": {name: metadata.version(name) for name in+ ("numpy", "scipy", "pandas", "pyproj", "rasterio", "pyarrow", "matplotlib")},+ "backends": {"ridge": matching.RIDGE_FIT_BACKEND, "acoustic": native_acoustic.ACOUSTIC_BACKEND,+ "cpa": native_cpa.CPA_BACKEND,+ "index_payload": "native" if data_access._native_payload_columns is not None else "python"},+ "environment": {name: value for name, value in sorted(os.environ.items())+ if name in {"DOPPLERGEIST_CPA_BACKEND", "DOPPLERGEIST_ACOUSTIC_BACKEND",+ "DOPPLERGEIST_RIDGE_BACKEND",+ "OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS",+ "NUMEXPR_NUM_THREADS", "VECLIB_MAXIMUM_THREADS", "PYTHONHASHSEED"}},++ "missing_runtime_pins": [],+ }+ for name in ("ffmpeg", "ffprobe"):+ result[name] = subprocess.run([name, "-version"], check=True,+ capture_output=True, text=True, timeout=10).stdout.splitlines()[0]++ try:++ result["packages"]["shapely"] = metadata.version("shapely")++ except metadata.PackageNotFoundError:++ result["packages"]["shapely"] = None++ result["geos_version"] = None++ else:++ import shapely++ result["geos_version"] = getattr(shapely, "geos_version_string", None)++ if not isinstance(result["geos_version"], str) or not result["geos_version"]:++ result["missing_runtime_pins"].append("geos_version")+ return result+++def operator_inputs(operator, additional):+ """Pin local data named by the operator, without following active job state."""+ if operator.get("offline", True) is not True:+ raise ValueError("Use an offline operator with frozen historical data and terrain")+ paths = set()+ for value in operator.get("flight_indexes", []):+ paths.add(Path(value).resolve(strict=True))+ ground = operator.get("terrain", {})+ for value in ground.get("rasters", []):+ paths.add(Path(value).resolve(strict=True))+ if ground.get("geoid_raster"):+ paths.add(Path(ground["geoid_raster"]).resolve(strict=True))+ if operator.get("cache_root"):+ cache = Path(operator["cache_root"]).resolve(strict=True)+ paths.update(p.absolute() for p in cache.rglob("*") if p.is_file())+ paths.update(Path(p).resolve(strict=True) for p in additional)+ if not paths:+ raise ValueError("No immutable historical/terrain inputs were supplied")+ return [identity(path) for path in sorted(paths)]+++def prepare(audio, request, operator, output, *, source_note, scope_note,+ additional_inputs=(), job_max_runtime_s=None, http_timeout_s=None):+ audio = Path(audio).resolve(strict=True)+ operator = deepcopy(operator)+ for name in ("flight_indexes",):+ if name in operator:+ operator[name] = [str(Path(p).resolve(strict=True)) for p in operator[name]]+ ground = operator.get("terrain", {})+ if "rasters" in ground:+ ground["rasters"] = [str(Path(p).resolve(strict=True)) for p in ground["rasters"]]+ if ground.get("geoid_raster"):+ ground["geoid_raster"] = str(Path(ground["geoid_raster"]).resolve(strict=True))+ if operator.get("cache_root"):+ operator["cache_root"] = str(Path(operator["cache_root"]).resolve(strict=True))+ if set(operator.get("discovery", {})) - {"chunk_s", "overlap_s"}:+ raise ValueError("The upload operator exposes only discovery chunk_s and overlap_s")+ protocol = read_json(PROTOCOL)+ for key, override in (("job_max_runtime_s", job_max_runtime_s),+ ("http_timeout_s", http_timeout_s)):+ if override is not None:+ if not math.isfinite(override) or override <= 0:+ raise ValueError(f"{key} must be finite and positive")+ protocol["budgets"][key] = float(override)+ if protocol["budgets"]["job_max_runtime_s"] >= protocol["budgets"]["http_timeout_s"]:+ raise ValueError("The client deadline must exceed the job runtime limit")+ if not source_note.strip() or not scope_note.strip():+ raise ValueError("Declare the real source and the evaluation scope")+ request = dict(validate_request(dict(request, audio_path=str(audio))))+ request.pop("audio_path")+ shifted_request(request, 0)+ DiscoverySettings(**operator.get("discovery", {}))+ inputs = operator_inputs(operator, additional_inputs)+ cases = []+ for case in protocol["cases"]:+ settings = dict(protocol["baseline"], **case["changes"])+ arm_operator = deepcopy(operator)+ if "discovery" in settings:+ arm_operator["discovery"] = settings.pop("discovery")+ DiscoverySettings(**arm_operator.get("discovery", {}))+ cases.append({"id": case["id"], "encoding": settings,+ "request": shifted_request(request, settings["leading_silence_s"]),+ "operator": arm_operator})++ pinned_implementation = implementation()++ if pinned_implementation["missing_runtime_pins"]:++ raise ValueError("Cannot freeze missing runtime pins: "++ + ", ".join(pinned_implementation["missing_runtime_pins"]))+ plan = {"schema_version": 1, "prepared_utc": http_verifier.now(),+ "protocol": protocol, "protocol_sha256": http_verifier.sha256(PROTOCOL),+ "source": identity(audio), "source_note": source_note, "scope_note": scope_note,+ "request": request, "operator": operator, "inputs": inputs, "cases": cases,+ "additional_inputs": [str(Path(p).resolve(strict=True)) for p in additional_inputs],- "implementation": implementation(),++ "implementation": pinned_implementation,+ "source_commit": subprocess.run(["git", "rev-parse", "HEAD"], cwd=ROOT,+ check=True, capture_output=True, text=True).stdout.strip(),+ "truth_evaluation": {"eligible": False, "evaluated": False,+ "reason": "No independent truth supplied to this protocol"},+ "national_gate_satisfied": False}+ output = Path(output).resolve()+ output.mkdir(parents=True, exist_ok=False)+ with (output / "plan.json").open("x") as stream:+ json.dump(plan, stream, indent=2, allow_nan=False)+ stream.write("\n")+ (output / "plan.sha256").write_text(http_verifier.sha256(output / "plan.json") + "\n")+ return output / "plan.json"+++def check_frozen(plan_path, plan):+ expected = plan_path.with_name("plan.sha256").read_text().strip()+ if http_verifier.sha256(plan_path) != expected:+ raise ValueError("The frozen plan changed; prepare a new experiment")+ if implementation() != plan["implementation"]:+ raise ValueError("Implementation, runtime or backend configuration changed after preparation")+ if identity(plan["source"]["path"]) != plan["source"]:+ raise ValueError("The recorded source changed")+ if operator_inputs(plan["operator"], plan["additional_inputs"]) != plan["inputs"]:+ raise ValueError("Pinned data bytes, paths or cache file set changed")+++def run_command(command, directory, name, timeout_s, *, env=None):+ write_json(directory / f"{name}-command.json", command)+ with (directory / f"{name}.log").open("wb") as log:+ process = subprocess.Popen(command, stdout=log, stderr=subprocess.STDOUT,+ env=env, start_new_session=True)+ try:+ returncode = process.wait(timeout=timeout_s)+ if returncode:+ raise subprocess.CalledProcessError(returncode, command)+ except BaseException:+ # Intake starts FFmpeg. Stop this command's whole process group.+ try:+ os.killpg(process.pid, signal.SIGTERM)+ except ProcessLookupError:+ pass+ try:+ process.wait(timeout=2)+ except subprocess.TimeoutExpired:+ os.killpg(process.pid, signal.SIGKILL)+ process.wait()+ raise+++def preflight_decode(audio, directory, protocol):+ """Use actual intake in a bounded child; HTTP intake is still fresh."""+ command = [sys.executable, "-c",+ "import sys; from dopplergeist.intake import intake_recording; "+ "intake_recording(sys.argv[1], sys.argv[2], sample_rate_hz=int(sys.argv[3]))",+ str(audio), str(directory), str(protocol["pcm_comparison"]["sample_rate_hz"])]+ env = dict(os.environ, PYTHONPATH=str(Path(dopplergeist.__file__).resolve().parent.parent)+ + os.pathsep + os.environ.get("PYTHONPATH", ""))+ run_command(command, directory.parent, directory.name + "-decode",+ protocol["budgets"]["encoding_timeout_s"], env=env)+ return IntakeRecording(directory / "recording.f32", read_json(directory / "recording.json"),+ read_json(directory / "intake.json"))+++def make_canonical(source, directory, protocol):+ probe = probe_media(source)+ audio = next(s for s in probe["streams"] if s["codec_type"] == "audio")+ channels = int(audio["channels"])+ downmix = "pan=mono|c0=" + "+".join(f"{1/channels:.17g}*c{i}" for i in range(channels))+ path = directory / "canonical.wav"+ command = ["ffmpeg", "-nostdin", "-v", "error", "-xerror", "-i", str(source),+ "-map", "0:a:0", "-vn", "-sn", "-dn", "-af", downmix, "-ac", "1",+ "-ar", str(protocol["canonical_pcm"]["sample_rate_hz"]),+ "-c:a", "pcm_f32le", "-map_metadata", "-1", "-rf64", "auto", str(path)]+ run_command(command, directory, "canonical", protocol["budgets"]["encoding_timeout_s"])+ reference = preflight_decode(path, directory / "reference-pcm", protocol)+ return path, reference+++def encode(canonical, directory, settings, protocol):+ filters = []+ if settings["gain_db"]:+ filters.append(f"volume={10**(settings['gain_db']/20):.17g}:precision=double")+ if settings["leading_silence_s"]:+ samples = round(settings["leading_silence_s"] * protocol["canonical_pcm"]["sample_rate_hz"])+ filters.append(f"adelay={samples}S:all=1")+ if settings["channels"] == 2:+ filters.append("pan=stereo|c0=c0|c1=c0")+ path = directory / "input.mp3"+ command = ["ffmpeg", "-nostdin", "-v", "error", "-xerror", "-i", str(canonical),+ "-map", "0:a:0", "-vn", "-sn", "-dn"]+ if filters:+ command += ["-af", ",".join(filters)]+ command += ["-ac", str(settings["channels"]), "-ar", str(settings["sample_rate_hz"]),+ "-c:a", "libmp3lame", "-b:a", f"{settings['bitrate_kbps']}k",+ "-write_xing", "1", "-map_metadata", "-1", str(path)]+ run_command(command, directory, "encode", protocol["budgets"]["encoding_timeout_s"])+ return path+++def native_decode_metrics(audio, directory, protocol):+ """Scan blocks of a temporary native-rate decode; keep no second large PCM."""+ probe = probe_media(audio)+ stream = next(s for s in probe["streams"] if s["codec_type"] == "audio")+ channels = int(stream["channels"])+ command = ["ffmpeg", "-nostdin", "-v", "error", "-xerror", "-i", str(audio),+ "-map", "0:a:0", "-f", "f32le", "-c:a", "pcm_f32le", "pipe:1"]+ peak, frames, channel_difference = 0.0, 0, 0.0+ with tempfile.TemporaryFile(dir=directory) as raw, (directory / "native-decode.log").open("wb") as log:+ subprocess.run(command, stdout=raw, stderr=log, check=True,+ timeout=protocol["budgets"]["encoding_timeout_s"])+ if raw.tell() % (4 * channels):+ raise ValueError("Native decode has an incomplete audio frame")+ raw.seek(0)+ while len(block := np.fromfile(raw, dtype="<f4", count=65536 * channels)):+ if not np.isfinite(block).all():+ raise ValueError("Native decode contains nonfinite samples")+ values = block.reshape(-1, channels)+ peak = max(peak, float(np.max(np.abs(values))))+ if channels == 2:+ channel_difference = max(channel_difference, float(np.max(np.abs(values[:, 0] - values[:, 1]))))+ frames += len(values)+ packets = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "a:0",+ "-read_intervals", "%+#1", "-show_packets", "-of", "json", str(audio)],+ check=True, capture_output=True, text=True, timeout=10)+ return {"sample_rate_hz": int(stream["sample_rate"]), "channels": channels,+ "sample_count": frames, "duration_s": frames / int(stream["sample_rate"]),+ "absolute_peak": peak, "identical_channel_max_difference": channel_difference if channels == 2 else None,+ "first_packet": json.loads(packets.stdout).get("packets", [])[:1],+ "container_start_time": probe["format"].get("start_time"),+ "container_duration": probe["format"].get("duration"), "decode_command": command}+++def compare_pcm(reference_path, variant_path, settings, protocol):+ config, tol = protocol["pcm_comparison"], protocol["tolerances"]+ sr = config["sample_rate_hz"]+ left = np.memmap(reference_path, dtype="<f4", mode="r")+ right = np.memmap(variant_path, dtype="<f4", mode="r")+ padding = round(settings["leading_silence_s"] * sr)+ gain = 10 ** (settings["gain_db"] / 20)+ count = min(len(left), max(0, len(right) - padding))+ if count == 0:+ raise ValueError("No recorded samples remain after the declared padding")+ squared_error, energy = 0.0, 0.0+ for first in range(0, count, config["block_samples"]):+ last = min(count, first + config["block_samples"])+ a = np.asarray(left[first:last], dtype=np.float64)+ b = np.asarray(right[first+padding:last+padding], dtype=np.float64) / gain+ squared_error += float(np.dot(a-b, a-b))+ energy += float(np.dot(a, a))+ duration_error = (len(right) - padding - len(left)) / sr+ nrmse = math.sqrt(squared_error / energy) if energy > 0 else None+ radius = round(config["lag_search_radius_s"] * sr)+ width = min(round(config["lag_window_s"] * sr), count - 2*radius)+ lags = []+ if width > 0:+ for first in np.linspace(radius, count-radius-width, config["lag_windows"]).astype(int):+ a = np.asarray(left[first:first+width], dtype=np.float64)+ a = a - a.mean()+ if float(np.dot(a, a)) <= 1e-14:+ lags.append({"start_s": int(first)/sr, "lag_s": None, "reason": "no_alignment_energy"})+ continue+ b = np.asarray(right[first+padding-radius:first+padding+width+radius], dtype=np.float64) / gain+ values = scipy_signal.correlate(b, a, mode="valid", method="fft")+ sums, squares = np.r_[0.0, np.cumsum(b)], np.r_[0.0, np.cumsum(b*b)]+ variance = squares[width:] - squares[:-width] - (sums[width:] - sums[:-width])**2/width+ normalized = values / np.sqrt(np.maximum(variance, np.finfo(float).tiny))+ lag = (int(np.argmax(normalized)) - radius) / sr+ lags.append({"start_s": int(first)/sr, "lag_s": lag})+ measured = [abs(row["lag_s"]) for row in lags if row["lag_s"] is not None]+ max_lag = max(measured) if measured else None+ return {"reference_samples": len(left), "variant_samples": len(right),+ "compared_samples": count, "padding_samples": padding, "declared_gain": gain,+ "duration_error_s": duration_error, "gain_corrected_nrmse": nrmse,+ "fixed_window_lags": lags, "maximum_absolute_lag_s": max_lag,+ "passed": (abs(duration_error) <= tol["decoded_duration_error_s"]+ and nrmse is not None and nrmse <= tol["gain_corrected_pcm_nrmse"]+ and max_lag is not None and max_lag <= tol["residual_alignment_lag_s"])}+++class MemorySampler:+ """Sample only this runner's descendants, never another worker's jobs."""++ STOP_TIMEOUT_S = 2.0+++ def __init__(self):+ self.stop = threading.Event()+ self.peak = 0+ self.samples = 0- self.thread = threading.Thread(target=self.sample, daemon=True)++ self.thread_error = None++ self.stop_timed_out = False++ self.skipped_process_reads = 0++ try:++ # /proc can be mounted from an outer PID namespace. os.getpid()++ # then names a different entry in that proc mount.++ self.proc_root_pid = int(Path("/proc/self").resolve(strict=True).name)++ except (OSError, RuntimeError, ValueError):++ self.proc_root_pid = None++ self.traversal = ("task_children" if self.proc_root_pid is not None++ and any(Path(f"/proc/{self.proc_root_pid}/task").glob("*/children"))++ else "ppid_snapshot")++ self.thread = threading.Thread(target=self.sample_guarded, daemon=True)++++ def sample_guarded(self):++ try:++ self.sample()++ except BaseException as exc:++ # Instrumentation must preserve an HTTP result even if the sampler++ # fails after observing a positive, incomplete peak.++ self.thread_error = f"{type(exc).__name__}: {exc}"++++ @staticmethod++ def process_status(pid, *, include_rss):++ parent, rss = None, None++ with Path(f"/proc/{pid}/status").open() as status:++ for line in status:++ if line.startswith("PPid:"):++ parent = int(line.split()[1])++ if not include_rss:++ break++ elif include_rss and line.startswith("VmRSS:"):++ rss = int(line.split()[1]) * 1024++ if parent is not None and (rss is not None or not include_rss):++ break++ return parent, rss++++ def parent_snapshot(self):++ # Some proc mounts omit task/*/children. Retain only parent relations++ # during this scan; read RSS only for the selected descendant tree.++ children = {}++ for entry in Path("/proc").iterdir():++ if self.stop.is_set():++ break++ if not entry.name.isdecimal():++ continue++ try:++ parent, _ = self.process_status(int(entry.name), include_rss=False)++ if parent is not None:++ children.setdefault(parent, []).append(int(entry.name))++ except (OSError, ValueError):++ self.skipped_process_reads += 1++ return children++ def sample(self):++ if self.proc_root_pid is None:++ return+ while not self.stop.is_set():- pending, visited, total = [os.getpid()], set(), 0- while pending:- pid = pending.pop()++ snapshot = self.parent_snapshot() if self.traversal == "ppid_snapshot" else None++ pending, visited, total = [(self.proc_root_pid, None)], set(), 0++ while pending and not self.stop.is_set():++ pid, expected_parent = pending.pop()+ if pid in visited:+ continue+ visited.add(pid)+ try:- # The HTTP service can spawn a worker from a non-main thread.- for children in Path(f"/proc/{pid}/task").glob("*/children"):- pending += [int(x) for x in children.read_text().split()]- if pid != os.getpid():- for line in Path(f"/proc/{pid}/status").read_text().splitlines():- if line.startswith("VmRSS:"):- total += int(line.split()[1]) * 1024++ if pid != self.proc_root_pid:++ parent, rss = self.process_status(pid, include_rss=True)++ # A process can disappear, be reparented, or have its PID++ # reused after the snapshot. Exclude a changed relation.++ if parent != expected_parent:++ self.skipped_process_reads += 1++ continue++ total += rss or 0++ if snapshot is not None:++ pending += [(child, pid) for child in snapshot.get(pid, [])]++ else:++ # The service can spawn a worker from any of its threads.++ for children in Path(f"/proc/{pid}/task").glob("*/children"):++ if self.stop.is_set():++ break++ pending += [(int(x), pid) for x in children.read_text().split()]+ except (OSError, ValueError):- pass++ self.skipped_process_reads += 1+ self.peak = max(self.peak, total)+ self.samples += 1+ self.stop.wait(0.1)++ def __enter__(self):+ self.thread.start()+ return self++ def __exit__(self, *_):+ self.stop.set()- self.thread.join()++ self.thread.join(timeout=self.STOP_TIMEOUT_S)++ self.stop_timed_out = self.thread.is_alive()++ def result(self):+ return {"sampled_descendant_peak_rss_mib": self.peak/(1024**2) if self.peak else None,+ "interval_s": 0.1, "samples": self.samples,++ "thread_error": self.thread_error, "stop_timed_out": self.stop_timed_out,++ "partial_measurement": bool(self.thread_error or self.stop_timed_out),++ "skipped_process_reads": self.skipped_process_reads,++ "traversal": self.traversal,++ "unavailable_reason": ("sampler_error" if self.thread_error else++ "proc_self_unavailable" if self.proc_root_pid is None++ else "no_descendant_rss_observed") if not self.peak else None,+ "scope": "Sum of local service and worker descendant RSS; sampled lower bound, not unique physical memory"}+++def mapped_events(events, padding):+ result = deepcopy(events)+ for event in result:+ event["start_s"] -= padding+ event["end_s"] -= padding+ for sample in event["ridge"]:+ sample["time_s"] -= padding+ return result+++def observe_case(directory, case, receipt):+ job_id = receipt.get("job_id")+ job = directory / "http" / "jobs" / job_id if job_id else None+ final = read_json(directory / "http/result.json", {})+ if not final and job is not None:+ final = read_json(job / "result.json", {})+ discovery = read_json(job / "discovery/discovery.json", {}) if job else {}+ events = final.get("events", discovery.get("events", []))+ search = read_json(job / "search/search-report.json", {}) if job else {}+ refined = read_json(job / "refined-candidates.json", {}) if job else {}+ decision = read_json(job / "decision.json", {}) if job else {}+ evidence = read_json(directory / "http/pipeline-evidence.json", {})+ padding = case["encoding"]["leading_silence_s"]+ candidates = []+ groups = {event["event_id"]: event.get("harmonic_group_id", event["event_id"]) for event in events}+ for i, candidate in enumerate(final.get("candidates", [])):+ row = refined.get("ranked", [])[i] if i < len(refined.get("ranked", [])) else {}+ copied = deepcopy(candidate)+ copied["mapped_recording_start_utc"] = format_utc(+ parse_utc(candidate["recording_start_utc"]) + timedelta(seconds=padding))+ copied["matched_group_count"] = len({groups[e] for e in candidate["event_ids"] if e in groups})+ copied["normalized_score"] = candidate["score"] / max(1, copied["matched_group_count"])+ sensitivity = row.get("sensitivity", {})+ copied["uncertainty_provenance"] = {key: sensitivity.get(key) for key in+ ("kind", "method", "sources", "complete", "boundary_limited")}+ copied["uncertainty_radius_m"] = sensitivity.get("radius_m")+ copied["mode_id"] = row.get("mode_id")+ candidates.append(copied)+ keys = ("status", "tiles_total", "tiles_completed", "tiles_resumed", "unsearched_tiles",+ "grid_points_searched", "refinement_points_searched", "refinement_points_skipped",+ "refinement_stages_resumed", "model_assessment_complete", "model_support_complete",+ "data_scope_complete", "all_event_groups_considered", "event_groups_proposed",+ "alternative_modes_exhaustively_assessed", "elapsed_s", "process_peak_rss_mib",+ "bounded_concurrency")+ return {"job_id": job_id, "job_directory": str(job) if job else None,+ "status": final.get("status"), "reason_code": final.get("reason_code"),+ "stage": final.get("stage"), "accepted_location": final.get("status") == "succeeded",+ "verification_passed": receipt.get("verification_passed", False),+ "full_pipeline_observed": receipt.get("full_pipeline_observed", False),+ "full_pipeline_requirements_met": receipt.get("full_pipeline_requirements_met", False),+ "stages_verified": evidence.get("stages_verified", []),+ "http_elapsed_s": receipt.get("elapsed_s"), "interrupted": receipt.get("interrupted", False),+ "verification_errors": {key: receipt[key] for key in+ ("error", "finalization_error", "requirement_error", "pipeline_evidence_errors") if key in receipt},+ "mapped_events": mapped_events(events, padding),+ "ridge_count": len(events), "group_count": len(set(groups.values())),+ "candidates": candidates, "coverage": final.get("coverage"),+ "work": {key: search.get(key) for key in keys},+ "finite_search_evidence": search.get("finite_search_evidence"),+ "decision_provenance": decision.get("diagnostics"),+ "acquisition": read_json(job / "data-provenance.json", {}) if job else {}}+++def assign_pairs(left_count, right_count, eligible):+ """Maximum-cardinality, then minimum-cost one-to-one correspondence."""+ if not left_count or not right_count:+ return []+ penalty = 10 * (left_count + right_count + 1)+ costs = np.full((left_count, right_count+left_count), float(penalty))+ costs[:, :right_count] = 3 * penalty+ for (i, j), row in eligible.items():+ costs[i, j] = row["cost"]+ rows, columns = linear_sum_assignment(costs)+ return [(int(i), int(j)) for i, j in zip(rows, columns) if (i, j) in eligible]+++def event_correspondence(left, right, protocol):+ rules = protocol["event_correspondence"]+ eligible = {}+ for i, a in enumerate(left):+ for j, b in enumerate(right):+ first, last = max(a["start_s"], b["start_s"]), min(a["end_s"], b["end_s"])+ overlap = max(0.0, last-first) / min(a["end_s"]-a["start_s"], b["end_s"]-b["start_s"])+ if overlap < rules["minimum_overlap_fraction_of_shorter_event"]:+ continue+ ta, fa = np.array([(r["time_s"], r["frequency_hz"]) for r in a["ridge"]]).T+ tb, fb = np.array([(r["time_s"], r["frequency_hz"]) for r in b["ridge"]]).T+ mask = (ta >= tb[0]) & (ta <= tb[-1])+ if not mask.any():+ continue+ frequency = float(np.median(np.abs(fa[mask] - np.interp(ta[mask], tb, fb))))+ if frequency > rules["maximum_matching_median_frequency_hz"]:+ continue+ eligible[i, j] = {"left_event_id": a["event_id"], "right_event_id": b["event_id"],+ "left_group_id": a.get("harmonic_group_id", a["event_id"]),+ "right_group_id": b.get("harmonic_group_id", b["event_id"]),+ "start_delta_s": b["start_s"]-a["start_s"],+ "end_delta_s": b["end_s"]-a["end_s"],+ "overlap_fraction": overlap, "median_frequency_delta_hz": frequency,+ "compared_ridge_samples": int(mask.sum()),+ "cost": 1-overlap + frequency/rules["maximum_matching_median_frequency_hz"]}+ matches = [eligible[pair] for pair in assign_pairs(len(left), len(right), eligible)]+ left_ids = {row["left_event_id"] for row in matches}+ right_ids = {row["right_event_id"] for row in matches}+ forward, reverse, possible_forward, possible_reverse = {}, {}, {}, {}+ for rows, fwd, rev in ((matches, forward, reverse),+ (eligible.values(), possible_forward, possible_reverse)):+ for row in rows:+ fwd.setdefault(row["left_group_id"], set()).add(row["right_group_id"])+ rev.setdefault(row["right_group_id"], set()).add(row["left_group_id"])+ return {"matches": matches,+ "unmatched_left": [e["event_id"] for e in left if e["event_id"] not in left_ids],+ "unmatched_right": [e["event_id"] for e in right if e["event_id"] not in right_ids],+ "unmatched_left_groups": sorted({e.get("harmonic_group_id", e["event_id"]) for e in left} - forward.keys()),+ "unmatched_right_groups": sorted({e.get("harmonic_group_id", e["event_id"]) for e in right} - reverse.keys()),+ "split_groups": {key: sorted(value) for key, value in forward.items() if len(value) > 1},+ "merged_groups": {key: sorted(value) for key, value in reverse.items() if len(value) > 1},+ "possible_split_or_ambiguous_groups": {key: sorted(value) for key, value in possible_forward.items() if len(value) > 1},+ "possible_merge_or_ambiguous_groups": {key: sorted(value) for key, value in possible_reverse.items() if len(value) > 1}}+++def distance(a, b):+ return float(GEOD.inv(a["lon"], a["lat"], b["lon"], b["lat"])[2])+++def associations_equal(a, b, mapping):+ first = list(zip(a["event_ids"], a["flight_ids"]))+ if any(event not in mapping for event, _ in first):+ return False+ return sorted((mapping[event], flight) for event, flight in first) == sorted(zip(b["event_ids"], b["flight_ids"]))+++def compare_cases(left, right, protocol):+ a, b = left["observation"], right["observation"]+ tol = protocol["tolerances"]+ correspondence = event_correspondence(a["mapped_events"], b["mapped_events"], protocol)+ mapping = {m["left_event_id"]: m["right_event_id"] for m in correspondence["matches"]}+ result = {"left": left["id"], "right": right["id"], "event_correspondence": correspondence,+ "representation_usable": bool(left.get("usability", {}).get("passed") and right.get("usability", {}).get("passed")),+ "complete_pipelines": bool(a["full_pipeline_requirements_met"] and b["full_pipeline_requirements_met"]),+ "status_transition": [a["status"], b["status"]],+ "reason_transition": [a["reason_code"], b["reason_code"]],+ "group_count_delta": b["group_count"] - a["group_count"],+ "ridge_count_delta": b["ridge_count"] - a["ridge_count"],+ "coverage_equal": a["coverage"] == b["coverage"],+ "coverage_transition": [a["coverage"], b["coverage"]],+ "work_transition": [a["work"], b["work"]],+ "decision_provenance_equal": a["decision_provenance"] == b["decision_provenance"],+ "diagnostic_candidate_comparison": None, "accepted_location_displacement_m": None,+ "serious_accepted_jump": False, "violations": []}+ checks = {+ "status_changed": a["status"] != b["status"],+ "reason_changed": a["reason_code"] != b["reason_code"],+ "group_count_changed": a["group_count"] != b["group_count"],+ "ridge_correspondence_incomplete": bool(correspondence["unmatched_left"] or correspondence["unmatched_right"]),+ "group_split_or_merge": bool(correspondence["split_groups"] or correspondence["merged_groups"]),+ "mapped_event_edges": any(max(abs(m["start_delta_s"]), abs(m["end_delta_s"])) > tol["mapped_event_edge_s"]+ for m in correspondence["matches"]),+ "mapped_ridge_frequency": any(m["median_frequency_delta_hz"] > tol["median_ridge_frequency_hz"]+ for m in correspondence["matches"]),+ }+ if a["candidates"] and b["candidates"]:+ best_a, best_b = a["candidates"][0], b["candidates"][0]+ displacement = distance(best_a, best_b)+ clock_delta = abs((parse_utc(best_b["mapped_recording_start_utc"])+ - parse_utc(best_a["mapped_recording_start_utc"])).total_seconds())+ same_associations = associations_equal(best_a, best_b, mapping)+ same_units = best_a["score_kind"] == best_b["score_kind"]+ comparable = same_associations and same_units and best_a["matched_group_count"] == best_b["matched_group_count"]+ score_delta = abs(best_a["normalized_score"] - best_b["normalized_score"]) if comparable else None+ result["diagnostic_candidate_comparison"] = {+ "displacement_m": displacement, "within_threshold_m": {+ str(int(limit)): displacement <= limit for limit in tol["displacement_thresholds_m"]},+ "mapped_clock_delta_s": clock_delta, "associated_flights_equal": same_associations,+ "score_units_equal": same_units, "normalized_score_comparable": comparable,+ "normalized_score_delta": score_delta,+ "uncertainty_provenance_equal": best_a["uncertainty_provenance"] == best_b["uncertainty_provenance"],+ "uncertainty_radius_m": [best_a["uncertainty_radius_m"], best_b["uncertainty_radius_m"]]}+ checks.update(associated_flights_changed=not same_associations, score_units_changed=not same_units,+ normalized_score_changed=score_delta is not None and score_delta > tol["normalized_score_per_matched_group"],+ fitted_clock_changed=clock_delta > tol["mapped_clock_s"],+ diagnostic_candidate_jump=displacement > tol["accepted_jump_m"],+ uncertainty_provenance_changed=best_a["uncertainty_provenance"] != best_b["uncertainty_provenance"])+ if a["accepted_location"] and b["accepted_location"]:+ result["accepted_location_displacement_m"] = displacement+ result["serious_accepted_jump"] = displacement > tol["accepted_jump_m"]+ eligible = {}+ for i, first in enumerate(a["candidates"]):+ for j, second in enumerate(b["candidates"]):+ if associations_equal(first, second, mapping):+ separation = distance(first, second)+ clock = abs((parse_utc(first["mapped_recording_start_utc"])+ - parse_utc(second["mapped_recording_start_utc"])).total_seconds())+ same_units = first["score_kind"] == second["score_kind"]+ if separation <= tol["distant_mode_m"] and clock <= tol["mapped_clock_s"] and same_units:+ eligible[i, j] = {"cost": separation/tol["distant_mode_m"] + clock/tol["mapped_clock_s"],+ "distance_m": separation, "mapped_clock_delta_s": clock,+ "score_kind": first["score_kind"],+ "normalized_score_delta": abs(first["normalized_score"]-second["normalized_score"])+ if first["matched_group_count"] == second["matched_group_count"] else None,+ "uncertainty_provenance_equal": first["uncertainty_provenance"] == second["uncertainty_provenance"]}+ pairs = assign_pairs(len(a["candidates"]), len(b["candidates"]), eligible)+ result["retained_mode_correspondence"] = [+ dict(left_index=i, right_index=j, **{key: value for key, value in eligible[i, j].items() if key != "cost"})+ for i, j in pairs]+ result["unmatched_retained_left_indices"] = sorted(set(range(len(a["candidates"]))) - {i for i, _ in pairs})+ result["unmatched_retained_right_indices"] = sorted(set(range(len(b["candidates"]))) - {j for _, j in pairs})+ checks["retained_mode_score_changed"] = any(row["normalized_score_delta"] is not None+ and row["normalized_score_delta"] > tol["normalized_score_per_matched_group"]+ for row in result["retained_mode_correspondence"])+ checks["retained_mode_uncertainty_provenance_changed"] = any(+ not row["uncertainty_provenance_equal"] for row in result["retained_mode_correspondence"])+ distant = []+ for label, source, matched in (("left", a, {i for i, _ in pairs}),+ ("right", b, {j for _, j in pairs})):+ for index, candidate in enumerate(source["candidates"]):+ offset = distance(source["candidates"][0], candidate)+ if offset >= tol["distant_mode_m"]:+ distant.append({"side": label, "candidate_index": index,+ "distance_from_winner_m": offset, "retained_within_1000m": index in matched})+ result["distant_modes"] = distant+ checks["distant_mode_lost"] = any(not row["retained_within_1000m"] for row in distant)+ elif bool(a["candidates"]) != bool(b["candidates"]):+ checks["candidate_presence_changed"] = True+ result["violations"] = [name for name, failed in checks.items() if failed]+ return result+++def build_report(plan_path, plan, state):+ cases = state["cases"]+ observed = [row for row in cases if row.get("observation")]+ pairs = []+ for a, b in itertools.combinations(observed, 2):+ try:+ pairs.append(compare_cases(a, b, plan["protocol"]))+ except Exception as exc:+ pairs.append({"left": a["id"], "right": b["id"],+ "error": f"{type(exc).__name__}: {exc}",+ "violations": ["comparison_error"], "serious_accepted_jump": False})+ completed = [row for row in cases if row["state"] == "finished"]+ passed = [row for row in completed if row.get("observation", {}).get("verification_passed")]+ stages = [row for row in passed if row["observation"]["full_pipeline_observed"]]+ full = [row for row in passed if row["observation"]["full_pipeline_requirements_met"]]+ violations = [pair for pair in pairs if pair["violations"]]+ return {"schema_version": 1, "plan": str(plan_path), "plan_sha256": http_verifier.sha256(plan_path),+ "updated_utc": http_verifier.now(), "source_note": plan["source_note"], "scope_note": plan["scope_note"],+ "declared_case_count": len(plan["cases"]), "finished_cases": len(completed),+ "verified_cases": len(passed), "complete_stage_cases": len(stages), "full_pipeline_cases": len(full),+ "run_state": state["state"], "error": state.get("error"), "cases": cases, "pairwise": pairs,+ "pairs_with_observed_differences": len(violations),+ "serious_accepted_jumps": [p for p in pairs if p["serious_accepted_jump"]],+ "all_complete_usable_and_within_tolerances": (state["state"] == "finished"+ and len(full) == len(plan["cases"])+ and all(row.get("usability", {}).get("passed") for row in cases) and not violations),+ "truth_evaluation": plan["truth_evaluation"], "national_gate_satisfied": False,+ "interpretation": "Inconclusive decisions remain inconclusive. Pairwise agreement is not location accuracy. Early exits do not complete the pipeline requirement."}+++def save_report(plan_path, plan, state, output):+ report = build_report(plan_path, plan, state)+ write_json(output / "report.json", report)+ lines = ["# Real recording representation matrix", "", plan["scope_note"], "",+ f"Full pipeline observed in {report['full_pipeline_cases']}/{report['declared_case_count']} declared cases.",+ "No independent truth error was evaluated. National acceptance remains open.", "",+ "| Case | State | Status / reason | Groups / ridges | Usable | Full pipeline | HTTP seconds |",+ "| --- | --- | --- | --- | --- | --- | --- |"]+ for row in state["cases"]:+ obs = row.get("observation", {})+ seconds = obs.get("http_elapsed_s")+ lines.append(f"| {row['id']} | {row['state']} | {obs.get('status')} / {obs.get('reason_code')} | "+ f"{obs.get('group_count')} / {obs.get('ridge_count')} | {row.get('usability', {}).get('passed')} | "+ f"{obs.get('full_pipeline_requirements_met')} | {round(seconds, 2) if seconds is not None else 'unavailable'} |")+ lines += ["", f"Pairs with observed differences: {report['pairs_with_observed_differences']}.",+ f"Serious accepted location jumps: {len(report['serious_accepted_jumps'])}.", "",+ "The JSON report retains mapped ridges, correspondence, diagnostic candidates,",+ "coverage/work transitions, uncertainty provenance, and per-arm reproducers."]+ if state.get("error"):+ lines += ["", "Run error: " + state["error"]]+ (output / "report.md").write_text("\n".join(lines) + "\n")+ return report+++def run(plan_path, output, *, selected_case=None):+ plan_path, output = Path(plan_path).resolve(strict=True), Path(output).resolve()+ plan = read_json(plan_path)+ check_frozen(plan_path, plan)+ if "job_max_runtime_s" not in inspect.signature(http_verifier.verify_http).parameters:+ raise ValueError("This runner needs the HTTP verifier's job_max_runtime_s API")+ if selected_case and selected_case not in {case["id"] for case in plan["cases"]}:+ raise ValueError("Unknown case identifier")+ output.mkdir(parents=True, exist_ok=False)+ state = {"state": "running", "runner_pid": os.getpid(), "started_utc": http_verifier.now(),+ "cases": [{"id": case["id"], "state": "pending"} for case in plan["cases"]]}+ write_json(output / "state.json", state)+ save_report(plan_path, plan, state, output)++ def interrupted(signum, _frame):+ raise KeyboardInterrupt(f"Received {signal.Signals(signum).name}")++ previous = signal.signal(signal.SIGTERM, interrupted)+ active = None+ try:+ canonical, reference = make_canonical(plan["source"]["path"], output, plan["protocol"])+ write_json(output / "canonical.json", identity(canonical))+ for case, row in zip(plan["cases"], state["cases"]):+ if selected_case and case["id"] != selected_case:+ row["state"] = "not_selected"+ continue+ check_frozen(plan_path, plan)+ active = row+ directory = output / case["id"]+ directory.mkdir()+ row.update(state="running", directory=str(directory),+ reproducer=shlex.join([sys.executable, str(Path(__file__).resolve()), "run",+ "--plan", str(plan_path), "--output", str(directory)+"-reproducer", "--case", case["id"]]))+ write_json(output / "state.json", state)+ try:+ audio = encode(canonical, directory, case["encoding"], plan["protocol"])+ row["encoded_input"] = identity(audio)+ try:+ decoded = preflight_decode(audio, directory / "preflight", plan["protocol"])+ native = native_decode_metrics(audio, directory, plan["protocol"])+ pcm = compare_pcm(reference.samples_path, decoded.samples_path, case["encoding"], plan["protocol"])+ row["usability"] = {"pcm": pcm, "native_decode": native,+ "passed": bool(pcm["passed"] and native["absolute_peak"] < plan["protocol"]["tolerances"]["decoded_absolute_peak_exclusive"]+ and (native["channels"] != 2 or native["identical_channel_max_difference"] == 0.0))}+ except Exception as exc:+ row["usability"] = {"passed": False, "error": f"{type(exc).__name__}: {exc}"}+ baseline_input = state["cases"][0].get("encoded_input")+ if case["id"].startswith("chunks_") and baseline_input:+ same_input = row["encoded_input"]["sha256"] == baseline_input["sha256"]+ row["usability"]["chunk_input_matches_baseline"] = same_input+ row["usability"]["passed"] = bool(row["usability"]["passed"] and same_input)+ write_json(directory / "representation.json", {"encoding": case["encoding"],+ "encoded_input": row["encoded_input"], "usability": row["usability"],+ "request": case["request"], "operator": case["operator"]})+ # Failed usability checks do not remove encoded arms or cause+ # outcome-dependent settings changes. The upload remains fresh.- with MemorySampler() as memory:- receipt = http_verifier.verify_http(audio, directory / "http",- request=case["request"], operator=case["operator"], expect_status=None,- job_max_runtime_s=plan["protocol"]["budgets"]["job_max_runtime_s"],- timeout_s=plan["protocol"]["budgets"]["http_timeout_s"],- require_full_pipeline=False)- row["memory"] = memory.result()++ memory = MemorySampler()++ try:++ with memory:++ receipt = http_verifier.verify_http(audio, directory / "http",++ request=case["request"], operator=case["operator"], expect_status=None,++ job_max_runtime_s=plan["protocol"]["budgets"]["job_max_runtime_s"],++ timeout_s=plan["protocol"]["budgets"]["http_timeout_s"],++ require_full_pipeline=False)++ finally:++ row["memory"] = memory.result()+ row["observation"] = observe_case(directory, case, receipt)+ row["state"] = "finished"+ if receipt.get("interrupted"):+ raise KeyboardInterrupt("HTTP verification was interrupted")+ except Exception as exc:+ row.update(state="error", error=f"{type(exc).__name__}: {exc}")+ if (directory / "http/http-verification.json").is_file() and "observation" not in row:+ try:+ row["observation"] = observe_case(directory, case,+ read_json(directory / "http/http-verification.json"))+ except Exception as parse_error:+ row["observation_error"] = f"{type(parse_error).__name__}: {parse_error}"+ finally:+ write_json(output / "state.json", state)+ save_report(plan_path, plan, state, output)+ print(json.dumps({"case": row["id"], "state": row["state"],+ "status": row.get("observation", {}).get("status"),+ "reason": row.get("observation", {}).get("reason_code"),+ "representation_usable": row.get("usability", {}).get("passed")}), flush=True)+ active = None+ check_frozen(plan_path, plan)+ state["state"] = "finished"+ except BaseException as exc:+ state.update(state="interrupted" if isinstance(exc, KeyboardInterrupt) else "error",+ error=f"{type(exc).__name__}: {exc}")+ if active is not None and active["state"] == "running":+ active.update(state="interrupted", error=state["error"])+ finally:+ signal.signal(signal.SIGTERM, previous)+ write_json(output / "state.json", state)+ report = save_report(plan_path, plan, state, output)+ return report+++def main(argv=None):+ parser = argparse.ArgumentParser(description=__doc__)+ commands = parser.add_subparsers(dest="command", required=True)+ pre = commands.add_parser("prepare", help="Freeze a protocol before executing its cases")+ pre.add_argument("--audio", type=Path, required=True)+ pre.add_argument("--request", type=Path, required=True)+ pre.add_argument("--operator", type=Path, required=True)+ pre.add_argument("--output", type=Path, required=True)+ pre.add_argument("--source-note", required=True)+ pre.add_argument("--scope-note", required=True)+ pre.add_argument("--frozen-input", type=Path, action="append", default=[])+ pre.add_argument("--job-max-runtime-s", type=float)+ pre.add_argument("--http-timeout-s", type=float)+ execute = commands.add_parser("run", help="Execute fresh jobs; never resume old scientific work")+ execute.add_argument("--plan", type=Path, required=True)+ execute.add_argument("--output", type=Path, required=True)+ execute.add_argument("--case", help="One-arm reproducer; never counts as the full matrix")+ report = commands.add_parser("report", help="Compare preserved observations without executing the pipeline")+ report.add_argument("--plan", type=Path, required=True)+ report.add_argument("--output", type=Path, required=True)+ args = parser.parse_args(argv)+ try:+ if args.command == "prepare":+ path = prepare(args.audio, read_json(args.request), read_json(args.operator), args.output,+ source_note=args.source_note, scope_note=args.scope_note, additional_inputs=args.frozen_input,+ job_max_runtime_s=args.job_max_runtime_s, http_timeout_s=args.http_timeout_s)+ print(path)+ return 0+ if args.command == "run":+ result = run(args.plan, args.output, selected_case=args.case)+ else:+ plan_path = args.plan.resolve(strict=True)+ plan = read_json(plan_path)+ if http_verifier.sha256(plan_path) != plan_path.with_name("plan.sha256").read_text().strip():+ raise ValueError("The frozen plan changed")+ if http_verifier.sha256(__file__) != plan["implementation"]["runner_sha256"]:+ raise ValueError("Use the frozen runner to reproduce these comparisons")+ result = save_report(plan_path, plan, read_json(args.output / "state.json"), args.output)+ print(json.dumps({key: result[key] for key in+ ("run_state", "finished_cases", "full_pipeline_cases", "pairs_with_observed_differences",+ "all_complete_usable_and_within_tolerances")}))+ return 0 if result["all_complete_usable_and_within_tolerances"] else 1+ except (OSError, ValueError, TypeError, subprocess.SubprocessError) as exc:+ parser.error(str(exc))+++if __name__ == "__main__":+ raise SystemExit(main())