Validate multi-output phase-candidate extension

Add output eligibility and registry files, support-stratified manual-reference validation, build scripts, and query documentation.

README.md

@@ -78,7 +78,7 @@ The repository is organized as follows:
 data/
   hdf5/                 # 14 daily HDF5 waveform files
   index/                # SQLite waveform index
-  label/                # annotations, reference tables, optional consensus and all-model catalogue
+  label/                # annotations, reference tables, optional consensus and multi-output catalogue
   response/             # instrument-response JSON for dataloader correction/simulation
   validation/           # machine-readable audits and optional phase-matching diagnostics
 notebooks/              # interactive quickstart notebook
@@ -115,11 +115,15 @@ non-standardized example outputs. Regenerate it with
 consistency and interoperability check, not a model comparison or ground truth.
 The script reads versioned C0 flags from `reference_arrivals.sqlite`, which was
 independently generated from exact NSLC intervals and finite HDF5 samples.
-The optional compressed all-model catalogue under `data/label/` retains every
+The optional compressed multi-output catalogue under `data/label/` retains every
 source pick from nine non-standardized example runs and groups station-phase
 records with a strict span below 1.5 s. It provides compact JSONL and normalized
-SQLite representations for querying output agreement; multi-model support is
-not ground truth or a relative model assessment. See
+SQLite representations for querying output agreement. The adjacent
+`output_eligibility.sqlite` records processed station-time intervals, and
+`output_registry.tsv` documents the nine source output streams. The released
+support-stratified validation table reports agreement with C0 manual references,
+not conventional precision. Output support is not ground truth or a relative
+model assessment. See
 `data/label/README_all_model_phase_picks.md` for the schema and examples.
 The quickstart notebook
 `notebooks/seismicx_cont_quickstart.ipynb` demonstrates file checks, SQLite
@@ -134,7 +138,8 @@ Current `scripts/` contents:
 | `scripts/README_event_comparison.md` | Event-comparison workflow notes and metric definitions. |
 | `scripts/README_real_association.md` | REAL association setup, inputs, outputs, and tuning notes. |
 | `scripts/build_consensus_picks_json.py` | Build consensus picker annotations from model pick outputs. |
-| `scripts/build_all_model_phase_catalog.py` | Build the compact all-model phase-candidate JSONL and SQLite products. |
+| `scripts/build_all_model_phase_catalog.py` | Build the compact multi-output phase-candidate JSONL and SQLite products. |
+| `scripts/build_output_eligibility.py` | Build processed station-time eligibility intervals and the output registry. |
 | `scripts/build_waveform_index.sh` | Build the full-release SQLite waveform index from HDF5 files. |
 | `scripts/compare_associated_events.py` | Compare associated events against catalog/reference events. |
 | `scripts/download_instrument_responses.py` | Download station instrument-response metadata. |
@@ -156,7 +161,8 @@ Current `scripts/` contents:
 | `scripts/upload_files_to_ms.py` | Upload selected full-release data files to ModelScope. |
 | `scripts/upload_restfiles_hf.py` | Upload non-bulk release files to Hugging Face. |
 | `scripts/upload_restfiles_ms.py` | Upload `scripts/` and `utils/` updates to ModelScope. |
-| `scripts/upload_all_model_phase_catalog.py` | Upload the compressed all-model catalogue and its documentation. |
+| `scripts/upload_all_model_phase_catalog.py` | Upload the compressed multi-output catalogue and its documentation. |
+| `scripts/validate_multi_output_candidates.py` | Reproduce support-stratified C0 manual-reference agreement. |
 | `scripts/verify_full_dataset.py` | Verify full-release required files and basic structure. |
 | `scripts/write_manifest.sh` | Regenerate release checksum and file-size manifests. |
 
@@ -187,9 +193,12 @@ Recommended quickstart and reproducibility order:
 6. If the optional source picker JSONL files are present, regenerate the
    multi-output agreement layer with
    `./essd_scripts/regenerate_multimodel_phase_matching.sh`.
-7. Query the optional all-model candidate catalogue after decompressing
+7. Query the optional multi-output candidate catalogue after decompressing
    `data/label/all_model_phase_picks.sqlite.zst`; schema and examples are in
    `data/label/README_all_model_phase_picks.md`.
+8. Use `data/label/output_eligibility.sqlite` for processed-domain queries and
+   `data/validation/multi_output_manual_reference_match.tsv` for the released
+   support-stratified catalogue-agreement summary.
 
 ---
 

README.zh.md

@@ -30,7 +30,7 @@ quick-start notebook，便于对发布文件进行可复现访问。
 data/
   hdf5/                 # 14 个 daily HDF5 波形文件
   index/                # SQLite 波形索引
-  label/                # annotation、reference 表、可选 consensus 与全模型候选目录
+  label/                # annotation、reference 表、可选 consensus 与多输出候选目录
   response/             # 仪器响应 JSON，用于 dataloader 去响应/仿真
   validation/           # 机器可读审计与可选多输出震相匹配诊断
 notebooks/              # 交互式 quickstart notebook
@@ -56,10 +56,13 @@ utils/                  # 可复用 HDF5 dataloader 和 waveform-index API
 与文件互操作检查，不是模型比较，也不构成 ground truth。该脚本复用
 `reference_arrivals.sqlite` 中已经由精确 NSLC 区间和有限 HDF5 样点生成的版本化
 C0 标志，避免对每个输出重复扫描完整波形归档。
-`data/label/` 下的可选全模型候选目录保留九个非标准化示例运行的全部源拾取，
+`data/label/` 下的可选多输出候选目录保留九个非标准化示例运行的全部源拾取，
 并在同一台站、同一 canonical 震相且严格小于 1.5 秒的时间跨度内聚合。
-发布格式包括压缩 JSONL 和规范化 SQLite，便于查询输出一致性；多模型支持不等同于
-ground truth，也不能用于相对模型评估。字段和查询示例见
+发布格式包括压缩 JSONL 和规范化 SQLite，便于查询输出一致性；
+`output_eligibility.sqlite` 记录各输出实际处理的台站-时间区间，
+`output_registry.tsv` 记录九组源输出的组成和处理范围。分层验证表给出与 C0
+人工参考震相的一致比例，而不是传统 precision。多输出支持不等同于 ground truth，
+也不能用于相对模型评估。字段和查询示例见
 `data/label/README_all_model_phase_picks.md`。
 `notebooks/seismicx_cont_quickstart.ipynb` 提供文件检查、SQLite 查询、HDF5 波形绘图、annotation 检查和评估命令模板。
 
@@ -71,7 +74,8 @@ ground truth，也不能用于相对模型评估。字段和查询示例见
 | `scripts/README_event_comparison.md` | 事件对比流程说明和指标定义。 |
 | `scripts/README_real_association.md` | REAL 关联的配置、输入输出和参数说明。 |
 | `scripts/build_consensus_picks_json.py` | 从多个模型拾取结果构建 consensus pick annotation。 |
-| `scripts/build_all_model_phase_catalog.py` | 构建紧凑的全模型候选 JSONL 和 SQLite 数据产品。 |
+| `scripts/build_all_model_phase_catalog.py` | 构建紧凑的多输出候选 JSONL 和 SQLite 数据产品。 |
+| `scripts/build_output_eligibility.py` | 构建输出处理区间 eligibility 数据库和 output registry。 |
 | `scripts/build_waveform_index.sh` | 从 HDF5 文件构建完整发布的 SQLite 波形索引。 |
 | `scripts/compare_associated_events.py` | 将关联事件与目录/参考事件进行对比。 |
 | `scripts/download_instrument_responses.py` | 下载台站仪器响应元数据。 |
@@ -93,7 +97,8 @@ ground truth，也不能用于相对模型评估。字段和查询示例见
 | `scripts/upload_files_to_ms.py` | 上传指定完整发布数据文件到 ModelScope。 |
 | `scripts/upload_restfiles_hf.py` | 上传非大体量发布文件到 Hugging Face。 |
 | `scripts/upload_restfiles_ms.py` | 上传 `scripts/` 和 `utils/` 更新到 ModelScope。 |
-| `scripts/upload_all_model_phase_catalog.py` | 上传压缩的全模型候选目录及其说明。 |
+| `scripts/upload_all_model_phase_catalog.py` | 上传压缩的多输出候选目录及其说明。 |
+| `scripts/validate_multi_output_candidates.py` | 复现按支持层级划分的 C0 人工参考一致性统计。 |
 | `scripts/verify_full_dataset.py` | 检查完整发布的必需文件和基本结构。 |
 | `scripts/write_manifest.sh` | 重新生成发布 checksum 和 file-size manifest。 |
 
@@ -119,8 +124,10 @@ ground truth，也不能用于相对模型评估。字段和查询示例见
 5. 用 `./essd_scripts/reproduce_manuscript_outputs.sh` 一键复现 ESSD 论文表格和图。
 6. 如已下载可选的 picker JSONL 源文件，用
    `./essd_scripts/regenerate_multimodel_phase_matching.sh` 重建多输出匹配诊断层。
-7. 解压 `data/label/all_model_phase_picks.sqlite.zst` 后查询可选全模型候选目录；
+7. 解压 `data/label/all_model_phase_picks.sqlite.zst` 后查询可选多输出候选目录；
    字段和示例见 `data/label/README_all_model_phase_picks.md`。
+8. 使用 `data/label/output_eligibility.sqlite` 查询各输出的实际处理域，并用
+   `data/validation/multi_output_manual_reference_match.tsv` 检查发布的支持分层结果。
 
 ---
 

data/label/README_all_model_phase_picks.md

@@ -1,4 +1,4 @@
-# All-model phase-candidate catalogue
+# Multi-output phase-candidate catalogue
 
 This optional layer combines all released automatic-pick streams into a compact,
 queryable candidate catalogue. It is intended for output inspection,
@@ -12,10 +12,17 @@ ground truth, or a standardized comparison of the contributing pickers.
 - `all_model_phase_picks.sqlite.zst`: the same candidates and all contributing
   source records in a normalized SQLite database;
 - `all_model_phase_picks.metadata.json`: schema, model dictionary, build policy,
-  source counts, and output sizes; and
+  source counts, and output sizes;
+- `output_eligibility.sqlite`: processed station-location/time intervals for
+  each source output;
+- `output_registry.tsv`: output family/checkpoint fields, processing scope, and
+  pick counts; and
 - `../preview/all_model_phase_picks.preview.jsonl`: 100 uncompressed example
   records.
 
+Support-stratified matching to C0 manual references is released as
+`../validation/multi_output_manual_reference_match.json` and `.tsv`.
+
 The current build contains 49,689,373 candidates from 124,403,181 source picks
 produced by nine non-standardized picker runs. Of these candidates, 35,638,688
 have one contributing model and 14,050,685 have at least two. These support
@@ -33,12 +40,46 @@ model additional weight. All source records are retained. The model-support
 count is the number of unique contributing models, and single-model candidates
 are retained explicitly.
 
+Here a "model" field identifies a source output stream. It is not necessarily a
+statistically independent architecture or model family. Use
+`output_registry.tsv` when family-level interpretation is needed.
+
 The contributing runs used different checkpoints, preprocessing, channel
 choices, thresholds, training domains, and inference settings. The catalogue
 must therefore not be used as a picker leaderboard or as evidence of relative
 model performance. Catalogue-unmatched picks are likewise not confirmed false
 detections.
 
+## Output eligibility
+
+Raw candidate support is directly available as JSONL key `n` or SQLite column
+`n_models`. Normalizing support requires the number of external outputs that
+actually processed the same station-location and time. The
+`output_eligibility.sqlite` database supplies those intervals; eligibility is
+derived from a processed sample record, never from the absence of a pick.
+
+```sql
+SELECT COUNT(DISTINCT output_id) AS n_eligible_outputs
+FROM output_eligibility
+WHERE station_id = 'BK.BDM.00'
+  AND processed_start_us <= 1561999764604538
+  AND processed_end_us >= 1561999764604538
+  AND valid_input = 1
+  AND (phase_mask & 1) != 0;  -- P=1, S=2
+```
+
+The eligibility intervals document channel family and components but cannot
+recover undocumented internal preprocessing or training-data overlap. When an
+assessed workflow contributed to the catalogue, remove its members and rebuild
+the affected candidate groups before calculating leave-one-output-out support.
+
+## Manual-reference agreement
+
+Run `scripts/validate_multi_output_candidates.py` to reproduce the 0.5 s,
+one-to-one matches to C0-covered manual reference arrivals. The released table
+reports `manual_reference_match_fraction`, not precision: the event catalogue
+is not an exhaustive truth set for continuous signals.
+
 ## Compact JSONL schema
 
 Each decompressed line has the following keys:
@@ -92,6 +133,9 @@ WHERE c.n_models >= 3
 ORDER BY c.time_us;
 ```
 
-Regenerate the layer with `scripts/run_all_model_phase_catalog.sh`. The build is
+Regenerate the layer with `scripts/run_all_model_phase_catalog.sh`, construct
+eligibility intervals with `scripts/build_output_eligibility.py`, and regenerate
+manual-reference agreement with `scripts/validate_multi_output_candidates.py`.
+The candidate build is
 resumable and records legacy non-standard JSON constants found in ancillary
 source diagnostic fields without discarding otherwise valid phase picks.

data/label/output_eligibility.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d14b19914f75ebff6c60afca93d61a661bc86583685f4647696a9f27071481d8
+size 73695232

data/label/output_registry.tsv

@@ -0,0 +1,10 @@
+output_id	output_name	model_workflow_family	checkpoint	training_domain	possible_evaluation_overlap	threshold	phase_classes	channel_families	processed_intervals	processed_station_location_keys	processed_station_hours	source_pick_count
+0	lppnm	LPPNM	not documented	not documented	not documented	not documented	P,S	HN,BH,HH,EH	21200	994	245641.129	4628109
+1	phasenet	PhaseNet	not documented	not documented	not documented	not documented	P,S	BH,HH,HN,EH	20884	993	238245.223	41503939
+2	pnsn_v1	PNSN	v1 (from output identifier)	not documented	not documented	not documented	P,S	BH,HH,HN,EH	21200	994	243937.369	6783670
+3	pnsn_v3_5120	PNSN	v3_5120 (from output identifier)	not documented	not documented	not documented	P,S	BH,HH,HN,EH	21200	994	242308.583	17933533
+4	pnsn.v3.diff	PNSN	v3.diff (from output identifier)	not documented	not documented	not documented	P,S	BH,HH,HN,EH	21200	994	242794.026	17805916
+5	seismicxm.01	SeismicXM	01 (from output identifier)	not documented	not documented	not documented	P,S	HH,HN,BH,EH	21200	994	241676.952	17309291
+6	seist	SeisT	not documented	not documented	not documented	not documented	P,S	BH,HN,EH,HH	21200	994	241588.796	13027713
+7	skynet	SkyNet	not documented	not documented	not documented	not documented	P,S	HN,BH,HH,EH	21200	994	248646.072	4302639
+8	ustc_sc	USTC-SC	not documented	not documented	not documented	not documented	P,S	BH,HH,HN,EH	289	111	2664.0	1108371

data/preview/seismicx_cont_file_index.csv

@@ -17,8 +17,12 @@ index,coverage,coverage,"CI;NC;BK",data/index/waveform_index.sqlite,SQLite wavef
 metadata,annotations,annotations,"CI;NC;BK",data/label/,metadata,Annotation station and consensus-pick metadata tables
 metadata,response,response,"CI;NC;BK",data/response/instrument_responses.json,metadata,Instrument-response metadata used for response removal and simulation
 validation,phase_matching,phase_matching,"CI;NC;BK",data/validation/multimodel_phase_matching/,validation,Optional non-standardized one-to-one phase-agreement and interoperability records
-optional_output,all_model_phases,all_model_phases,"CI;NC;BK",data/label/all_model_phase_picks.jsonl.zst,Zstandard JSONL,Compact all-model phase candidates with one candidate per decompressed line
-optional_output,all_model_phases,all_model_phases,"CI;NC;BK",data/label/all_model_phase_picks.sqlite.zst,Zstandard SQLite,Queryable all-model phase candidates and contributing source picks
+optional_output,multi_output_phases,multi_output_phases,"CI;NC;BK",data/label/all_model_phase_picks.jsonl.zst,Zstandard JSONL,Compact multi-output phase candidates with one candidate per decompressed line
+optional_output,multi_output_phases,multi_output_phases,"CI;NC;BK",data/label/all_model_phase_picks.sqlite.zst,Zstandard SQLite,Queryable multi-output phase candidates and contributing source picks
+optional_output,output_eligibility,output_eligibility,"CI;NC;BK",data/label/output_eligibility.sqlite,SQLite eligibility index,Processed station-location and time intervals for each contributing output
+optional_output,output_registry,output_registry,"CI;NC;BK",data/label/output_registry.tsv,TSV registry,Output family checkpoint processing-scope and source-pick registry
+validation,multi_output_manual_match,multi_output_manual_match,"CI;NC;BK",data/validation/multi_output_manual_reference_match.tsv,TSV validation,Support-stratified one-to-one agreement with C0 manual reference arrivals
+validation,output_eligibility_summary,output_eligibility_summary,"CI;NC;BK",data/validation/output_eligibility_summary.json,JSON validation,Machine-readable eligibility database build and count summary
 documentation,docs,docs,"CI;NC;BK",README.md,documentation,Dataset documentation and usage instructions
 code,scripts,scripts,"CI;NC;BK",scripts/,code,Conversion indexing validation picker association and upload scripts
 code,utils,utils,"CI;NC;BK",utils/,code,Reusable HDF5 dataloader and waveform-index APIs

data/validation/multi_output_manual_reference_match.json

@@ -0,0 +1,155 @@
+{
+  "candidate_file": "data/label/all_model_phase_picks.jsonl.zst",
+  "candidate_records_checked": 49689373,
+  "interpretation": "Manual-reference match fraction is a catalogue-agreement diagnostic, not conventional precision; source annotations are not exhaustive.",
+  "matching": {
+    "canonical_phase_exact": true,
+    "objective": "maximize matches, then minimize total absolute residual",
+    "one_to_one": true,
+    "station_location_exact": true,
+    "tolerance_s": 0.5
+  },
+  "outside_selected_period_count": 2,
+  "outside_selected_period_examples": [
+    {
+      "candidate_id": 1763169,
+      "phase": "P",
+      "station_id": "BK.KARE.00",
+      "support": 1,
+      "time_us": 1562544015200000
+    },
+    {
+      "candidate_id": 43730351,
+      "phase": "P",
+      "station_id": "NC.MDPB.--",
+      "support": 1,
+      "time_us": 1636934415245000
+    }
+  ],
+  "reference_definition": "C0-covered manual_primary_reference arrivals",
+  "reference_file": "data/label/reference_arrivals.sqlite",
+  "rows": [
+    {
+      "c0_manual_reference_count": 89345,
+      "candidate_count": 13040519,
+      "manual_reference_match_fraction": 0.0002525973084353468,
+      "matched_candidate_count": 3294,
+      "median_absolute_residual_s": 0.0687,
+      "period": "2019",
+      "phase": "P",
+      "support_stratum": "support_1"
+    },
+    {
+      "c0_manual_reference_count": 89345,
+      "candidate_count": 3587802,
+      "manual_reference_match_fraction": 0.01940603188247289,
+      "matched_candidate_count": 69625,
+      "median_absolute_residual_s": 0.0377,
+      "period": "2019",
+      "phase": "P",
+      "support_stratum": "support_ge_2"
+    },
+    {
+      "c0_manual_reference_count": 89345,
+      "candidate_count": 1781088,
+      "manual_reference_match_fraction": 0.03775894284841625,
+      "matched_candidate_count": 67252,
+      "median_absolute_residual_s": 0.037336,
+      "period": "2019",
+      "phase": "P",
+      "support_stratum": "support_ge_3"
+    },
+    {
+      "c0_manual_reference_count": 106193,
+      "candidate_count": 7817926,
+      "manual_reference_match_fraction": 0.0006651380430052677,
+      "matched_candidate_count": 5200,
+      "median_absolute_residual_s": 0.0791,
+      "period": "2019",
+      "phase": "S",
+      "support_stratum": "support_1"
+    },
+    {
+      "c0_manual_reference_count": 106193,
+      "candidate_count": 5014983,
+      "manual_reference_match_fraction": 0.016275229646840278,
+      "matched_candidate_count": 81620,
+      "median_absolute_residual_s": 0.083992,
+      "period": "2019",
+      "phase": "S",
+      "support_stratum": "support_ge_2"
+    },
+    {
+      "c0_manual_reference_count": 106193,
+      "candidate_count": 2816294,
+      "manual_reference_match_fraction": 0.02757489097374067,
+      "matched_candidate_count": 77659,
+      "median_absolute_residual_s": 0.083921,
+      "period": "2019",
+      "phase": "S",
+      "support_stratum": "support_ge_3"
+    },
+    {
+      "c0_manual_reference_count": 1128,
+      "candidate_count": 9039351,
+      "manual_reference_match_fraction": 3.318822335807073e-07,
+      "matched_candidate_count": 3,
+      "median_absolute_residual_s": 0.0587,
+      "period": "2021",
+      "phase": "P",
+      "support_stratum": "support_1"
+    },
+    {
+      "c0_manual_reference_count": 1128,
+      "candidate_count": 2108343,
+      "manual_reference_match_fraction": 0.0004548595745568914,
+      "matched_candidate_count": 959,
+      "median_absolute_residual_s": 0.03616,
+      "period": "2021",
+      "phase": "P",
+      "support_stratum": "support_ge_2"
+    },
+    {
+      "c0_manual_reference_count": 1128,
+      "candidate_count": 916423,
+      "manual_reference_match_fraction": 0.0010453687871212311,
+      "matched_candidate_count": 958,
+      "median_absolute_residual_s": 0.036173,
+      "period": "2021",
+      "phase": "P",
+      "support_stratum": "support_ge_3"
+    },
+    {
+      "c0_manual_reference_count": 1246,
+      "candidate_count": 5740890,
+      "manual_reference_match_fraction": 8.709450973629525e-07,
+      "matched_candidate_count": 5,
+      "median_absolute_residual_s": 0.2997,
+      "period": "2021",
+      "phase": "S",
+      "support_stratum": "support_1"
+    },
+    {
+      "c0_manual_reference_count": 1246,
+      "candidate_count": 3339557,
+      "manual_reference_match_fraction": 0.00031411351864932984,
+      "matched_candidate_count": 1049,
+      "median_absolute_residual_s": 0.08141,
+      "period": "2021",
+      "phase": "S",
+      "support_stratum": "support_ge_2"
+    },
+    {
+      "c0_manual_reference_count": 1246,
+      "candidate_count": 1716295,
+      "manual_reference_match_fraction": 0.0006094523377391416,
+      "matched_candidate_count": 1046,
+      "median_absolute_residual_s": 0.081398,
+      "period": "2021",
+      "phase": "S",
+      "support_stratum": "support_ge_3"
+    }
+  ],
+  "schema": "seismicx-cont-multi-output-manual-match-v1",
+  "selected_period_candidate_records": 49689371
+}

data/validation/multi_output_manual_reference_match.tsv

@@ -0,0 +1,13 @@
+period	phase	support_stratum	candidate_count	c0_manual_reference_count	matched_candidate_count	manual_reference_match_fraction	median_absolute_residual_s
+2019	P	support_1	13040519	89345	3294	0.0002525973084353468	0.0687
+2019	P	support_ge_2	3587802	89345	69625	0.01940603188247289	0.0377
+2019	P	support_ge_3	1781088	89345	67252	0.03775894284841625	0.037336
+2019	S	support_1	7817926	106193	5200	0.0006651380430052677	0.0791
+2019	S	support_ge_2	5014983	106193	81620	0.016275229646840278	0.083992
+2019	S	support_ge_3	2816294	106193	77659	0.02757489097374067	0.083921
+2021	P	support_1	9039351	1128	3	3.318822335807073e-07	0.0587
+2021	P	support_ge_2	2108343	1128	959	0.0004548595745568914	0.03616
+2021	P	support_ge_3	916423	1128	958	0.0010453687871212311	0.036173
+2021	S	support_1	5740890	1246	5	8.709450973629525e-07	0.2997
+2021	S	support_ge_2	3339557	1246	1049	0.00031411351864932984	0.08141
+2021	S	support_ge_3	1716295	1246	1046	0.0006094523377391416	0.081398

data/validation/output_eligibility_summary.json

@@ -0,0 +1,146 @@
+{
+  "database": "data/label/output_eligibility.sqlite",
+  "definition": "An interval is eligible when the source output contains a processed sample record for the station-location and time. Absence of a pick is not used to infer eligibility.",
+  "eligibility_intervals": 169573,
+  "outputs": 9,
+  "quick_check": "ok",
+  "registry": "data/label/output_registry.tsv",
+  "rows": [
+    {
+      "channel_families": "HN,BH,HH,EH",
+      "checkpoint": "not documented",
+      "model_workflow_family": "LPPNM",
+      "output_id": 0,
+      "output_name": "lppnm",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 21200,
+      "processed_station_hours": 245641.129,
+      "processed_station_location_keys": 994,
+      "source_pick_count": 4628109,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    },
+    {
+      "channel_families": "BH,HH,HN,EH",
+      "checkpoint": "not documented",
+      "model_workflow_family": "PhaseNet",
+      "output_id": 1,
+      "output_name": "phasenet",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 20884,
+      "processed_station_hours": 238245.223,
+      "processed_station_location_keys": 993,
+      "source_pick_count": 41503939,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    },
+    {
+      "channel_families": "BH,HH,HN,EH",
+      "checkpoint": "v1 (from output identifier)",
+      "model_workflow_family": "PNSN",
+      "output_id": 2,
+      "output_name": "pnsn_v1",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 21200,
+      "processed_station_hours": 243937.369,
+      "processed_station_location_keys": 994,
+      "source_pick_count": 6783670,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    },
+    {
+      "channel_families": "BH,HH,HN,EH",
+      "checkpoint": "v3_5120 (from output identifier)",
+      "model_workflow_family": "PNSN",
+      "output_id": 3,
+      "output_name": "pnsn_v3_5120",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 21200,
+      "processed_station_hours": 242308.583,
+      "processed_station_location_keys": 994,
+      "source_pick_count": 17933533,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    },
+    {
+      "channel_families": "BH,HH,HN,EH",
+      "checkpoint": "v3.diff (from output identifier)",
+      "model_workflow_family": "PNSN",
+      "output_id": 4,
+      "output_name": "pnsn.v3.diff",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 21200,
+      "processed_station_hours": 242794.026,
+      "processed_station_location_keys": 994,
+      "source_pick_count": 17805916,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    },
+    {
+      "channel_families": "HH,HN,BH,EH",
+      "checkpoint": "01 (from output identifier)",
+      "model_workflow_family": "SeismicXM",
+      "output_id": 5,
+      "output_name": "seismicxm.01",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 21200,
+      "processed_station_hours": 241676.952,
+      "processed_station_location_keys": 994,
+      "source_pick_count": 17309291,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    },
+    {
+      "channel_families": "BH,HN,EH,HH",
+      "checkpoint": "not documented",
+      "model_workflow_family": "SeisT",
+      "output_id": 6,
+      "output_name": "seist",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 21200,
+      "processed_station_hours": 241588.796,
+      "processed_station_location_keys": 994,
+      "source_pick_count": 13027713,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    },
+    {
+      "channel_families": "HN,BH,HH,EH",
+      "checkpoint": "not documented",
+      "model_workflow_family": "SkyNet",
+      "output_id": 7,
+      "output_name": "skynet",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 21200,
+      "processed_station_hours": 248646.072,
+      "processed_station_location_keys": 994,
+      "source_pick_count": 4302639,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    },
+    {
+      "channel_families": "BH,HH,HN,EH",
+      "checkpoint": "not documented",
+      "model_workflow_family": "USTC-SC",
+      "output_id": 8,
+      "output_name": "ustc_sc",
+      "phase_classes": "P,S",
+      "possible_evaluation_overlap": "not documented",
+      "processed_intervals": 289,
+      "processed_station_hours": 2664.0,
+      "processed_station_location_keys": 111,
+      "source_pick_count": 1108371,
+      "threshold": "not documented",
+      "training_domain": "not documented"
+    }
+  ],
+  "schema": "seismicx-cont-output-eligibility-v1"
+}

scripts/build_output_eligibility.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""Build output processing-eligibility intervals and a compact registry.
+
+The source picker JSONL files contain one or more records for every processed
+station-day input. Phase-pick records retain exact sample geometry; ``no_pick``
+records retain a pipe-delimited sample key. This script converts those records
+into auditable output/station/time intervals. It does not infer eligibility from
+the absence of picks.
+"""
+
+from __future__ import annotations
+
+import argparse
+import calendar
+import csv
+import json
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+try:
+    import orjson
+except ImportError:  # pragma: no cover - slower portability fallback
+    orjson = None
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_METADATA = ROOT / "data/label/all_model_phase_picks.metadata.json"
+DEFAULT_DB = ROOT / "data/label/output_eligibility.sqlite"
+DEFAULT_REGISTRY = ROOT / "data/label/output_registry.tsv"
+DEFAULT_SUMMARY = ROOT / "data/validation/output_eligibility_summary.json"
+
+OUTPUT_REGISTRY = {
+    "lppnm": ("LPPNM", "not documented"),
+    "phasenet": ("PhaseNet", "not documented"),
+    "pnsn_v1": ("PNSN", "v1 (from output identifier)"),
+    "pnsn_v3_5120": ("PNSN", "v3_5120 (from output identifier)"),
+    "pnsn.v3.diff": ("PNSN", "v3.diff (from output identifier)"),
+    "seismicxm.01": ("SeismicXM", "01 (from output identifier)"),
+    "seist": ("SeisT", "not documented"),
+    "skynet": ("SkyNet", "not documented"),
+    "ustc_sc": ("USTC-SC", "not documented"),
+}
+
+
+def release_path(path: Path) -> str:
+    try:
+        return path.resolve().relative_to(ROOT).as_posix()
+    except ValueError:
+        return str(path.resolve())
+
+
+def parse_json(line: bytes) -> dict[str, Any]:
+    if orjson is not None:
+        try:
+            return orjson.loads(line)
+        except orjson.JSONDecodeError:
+            pass
+    return json.loads(line)
+
+
+def iso_to_us(value: str) -> int:
+    text = str(value)
+    if len(text) >= 19 and text[4] == "-" and text[10] == "T":
+        y = int(text[0:4])
+        m = int(text[5:7])
+        d = int(text[8:10])
+        hh = int(text[11:13])
+        mm = int(text[14:16])
+        ss = int(text[17:19])
+        fraction = 0
+        if len(text) > 19 and text[19] == ".":
+            digits = []
+            for char in text[20:]:
+                if not char.isdigit():
+                    break
+                digits.append(char)
+                if len(digits) == 6:
+                    break
+            fraction = int("".join(digits).ljust(6, "0")) if digits else 0
+        return (
+            calendar.timegm((y, m, d, hh, mm, ss)) * 1_000_000 + fraction
+        )
+    iso = text[:-1] + "+00:00" if text.endswith("Z") else text
+    dt = datetime.fromisoformat(iso)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return int(round(dt.timestamp() * 1_000_000))
+
+
+def station_identifier(record: dict[str, Any]) -> str:
+    direct = record.get("station_id")
+    info = record.get("station_info") or {}
+    value = direct or info.get("station_id")
+    if not value:
+        network = info.get("network")
+        station = info.get("station")
+        location = info.get("location") or "--"
+        if not network or not station:
+            raise ValueError("record has no station identifier")
+        value = f"{network}.{station}.{location}"
+    parts = str(value).split(".")
+    if len(parts) >= 3 and not parts[2]:
+        parts[2] = "--"
+    return ".".join(parts[:3]) if len(parts) >= 3 else str(value)
+
+
+def phase_pick_sample(record: dict[str, Any]) -> dict[str, Any]:
+    station = station_identifier(record)
+    h5_file = str(record["h5_file"])
+    day_id = str(record["day_id"])
+    family = str(record.get("channel_family") or "--")
+    channels = tuple(str(item) for item in (record.get("channels") or []))
+    sample_key = "|".join((h5_file, day_id, station, family, ",".join(channels)))
+    phase_time_us = iso_to_us(str(record["phase_time"]))
+    relative_us = int(round(float(record["phase_relative_time"]) * 1_000_000))
+    start_us = phase_time_us - relative_us
+    shape = record.get("waveform_shape") or []
+    sample_rate = float(record.get("sampling_rate") or 0.0)
+    if not shape or sample_rate <= 0:
+        raise ValueError("phase-pick record has no valid sample geometry")
+    end_us = start_us + int(round((int(shape[0]) - 1) * 1_000_000 / sample_rate))
+    return {
+        "sample_key": sample_key,
+        "station_id": station,
+        "start_us": start_us,
+        "end_us": end_us,
+        "channel_family": family,
+        "channels": ",".join(channels),
+        "h5_file": h5_file,
+        "day_id": day_id,
+        "interval_source": "sample_geometry",
+    }
+
+
+def no_pick_sample(record: dict[str, Any]) -> dict[str, Any]:
+    value = str(record["sample_key"])
+    parts = value.split("|")
+    if len(parts) != 6:
+        raise ValueError(f"unexpected no_pick sample key: {value}")
+    h5_file, _year_id, day_id, station, family, channels = parts
+    start_us = iso_to_us(day_id)
+    return {
+        "sample_key": value,
+        "station_id": station,
+        "start_us": start_us,
+        "end_us": start_us + 86_400_000_000 - 1,
+        "channel_family": family,
+        "channels": channels,
+        "h5_file": h5_file,
+        "day_id": day_id,
+        "interval_source": "day_identifier_fallback",
+    }
+
+
+def iter_samples(path: Path) -> Iterable[dict[str, Any]]:
+    current: dict[str, Any] | None = None
+    with path.open("rb") as stream:
+        for line_number, line in enumerate(stream, 1):
+            if not line.strip():
+                continue
+            record = parse_json(line)
+            record_type = record.get("record_type")
+            if record_type == "phase_pick":
+                sample = phase_pick_sample(record)
+            elif record_type == "no_pick":
+                sample = no_pick_sample(record)
+            else:
+                continue
+            if current is not None and sample["sample_key"] == current["sample_key"]:
+                current["start_us"] = min(current["start_us"], sample["start_us"])
+                current["end_us"] = max(current["end_us"], sample["end_us"])
+                continue
+            if current is not None:
+                yield current
+            current = sample
+    if current is not None:
+        yield current
+
+
+def create_database(path: Path) -> sqlite3.Connection:
+    if path.exists():
+        path.unlink()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    con = sqlite3.connect(path)
+    con.executescript(
+        """
+        PRAGMA page_size=32768;
+        PRAGMA journal_mode=WAL;
+        PRAGMA synchronous=NORMAL;
+        CREATE TABLE outputs (
+            output_id INTEGER PRIMARY KEY,
+            output_name TEXT NOT NULL UNIQUE,
+            model_workflow_family TEXT NOT NULL,
+            checkpoint TEXT NOT NULL,
+            training_domain TEXT NOT NULL,
+            possible_evaluation_overlap TEXT NOT NULL,
+            threshold TEXT NOT NULL,
+            phase_classes TEXT NOT NULL,
+            source_file TEXT NOT NULL,
+            source_pick_count INTEGER NOT NULL
+        );
+        CREATE TABLE eligibility_intervals (
+            interval_id INTEGER PRIMARY KEY,
+            output_id INTEGER NOT NULL REFERENCES outputs(output_id),
+            sample_key TEXT NOT NULL,
+            station_id TEXT NOT NULL,
+            processed_start_us INTEGER NOT NULL,
+            processed_end_us INTEGER NOT NULL,
+            phase_mask INTEGER NOT NULL,
+            channel_family TEXT NOT NULL,
+            channels TEXT NOT NULL,
+            h5_file TEXT NOT NULL,
+            day_id TEXT NOT NULL,
+            valid_input INTEGER NOT NULL,
+            interval_source TEXT NOT NULL,
+            UNIQUE(output_id, sample_key)
+        );
+        """
+    )
+    return con
+
+
+def union_hours(con: sqlite3.Connection, output_id: int) -> float:
+    rows = con.execute(
+        """
+        SELECT station_id, processed_start_us, processed_end_us
+        FROM eligibility_intervals
+        WHERE output_id=? AND valid_input=1
+        ORDER BY station_id, processed_start_us, processed_end_us
+        """,
+        (output_id,),
+    )
+    total_us = 0
+    current_station = None
+    start = end = None
+    for station, left, right in rows:
+        if station != current_station or start is None or left > end + 1:
+            if start is not None:
+                total_us += end - start + 1
+            current_station = station
+            start, end = int(left), int(right)
+        else:
+            end = max(end, int(right))
+    if start is not None:
+        total_us += end - start + 1
+    return total_us / 3_600_000_000
+
+
+def build(args: argparse.Namespace) -> None:
+    metadata = json.loads(args.metadata.read_text())
+    model_names = {int(key): value for key, value in metadata["models"].items()}
+    source_by_model = {
+        int(item["model_id"]): (ROOT / item["source_file"], int(item["counts"]["phase_picks"]))
+        for item in metadata["source_summaries"]
+    }
+    con = create_database(args.output_db)
+    registry_rows = []
+    for output_id in sorted(model_names):
+        name = model_names[output_id]
+        family, checkpoint = OUTPUT_REGISTRY.get(name, (name, "not documented"))
+        source, pick_count = source_by_model[output_id]
+        con.execute(
+            "INSERT INTO outputs VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                output_id,
+                name,
+                family,
+                checkpoint,
+                "not documented",
+                "not documented",
+                "not documented",
+                "P,S",
+                release_path(source),
+                pick_count,
+            ),
+        )
+        batch = []
+        for sample in iter_samples(source):
+            batch.append(
+                (
+                    output_id,
+                    sample["sample_key"],
+                    sample["station_id"],
+                    sample["start_us"],
+                    sample["end_us"],
+                    3,
+                    sample["channel_family"],
+                    sample["channels"],
+                    sample["h5_file"],
+                    sample["day_id"],
+                    1,
+                    sample["interval_source"],
+                )
+            )
+            if len(batch) >= 10_000:
+                con.executemany(
+                    """
+                    INSERT INTO eligibility_intervals(
+                        output_id, sample_key, station_id, processed_start_us,
+                        processed_end_us, phase_mask, channel_family, channels,
+                        h5_file, day_id, valid_input, interval_source
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(output_id, sample_key) DO UPDATE SET
+                        processed_start_us=min(processed_start_us, excluded.processed_start_us),
+                        processed_end_us=max(processed_end_us, excluded.processed_end_us)
+                    """,
+                    batch,
+                )
+                batch.clear()
+        if batch:
+            con.executemany(
+                """
+                INSERT INTO eligibility_intervals(
+                    output_id, sample_key, station_id, processed_start_us,
+                    processed_end_us, phase_mask, channel_family, channels,
+                    h5_file, day_id, valid_input, interval_source
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(output_id, sample_key) DO UPDATE SET
+                    processed_start_us=min(processed_start_us, excluded.processed_start_us),
+                    processed_end_us=max(processed_end_us, excluded.processed_end_us)
+                """,
+                batch,
+            )
+        con.commit()
+        stats = con.execute(
+            """
+            SELECT COUNT(*), COUNT(DISTINCT station_id), MIN(processed_start_us),
+                   MAX(processed_end_us), GROUP_CONCAT(DISTINCT channel_family)
+            FROM eligibility_intervals WHERE output_id=?
+            """,
+            (output_id,),
+        ).fetchone()
+        registry_rows.append(
+            {
+                "output_id": output_id,
+                "output_name": name,
+                "model_workflow_family": family,
+                "checkpoint": checkpoint,
+                "training_domain": "not documented",
+                "possible_evaluation_overlap": "not documented",
+                "threshold": "not documented",
+                "phase_classes": "P,S",
+                "channel_families": stats[4] or "",
+                "processed_intervals": int(stats[0]),
+                "processed_station_location_keys": int(stats[1]),
+                "processed_station_hours": round(union_hours(con, output_id), 3),
+                "source_pick_count": pick_count,
+            }
+        )
+
+    con.executescript(
+        """
+        CREATE INDEX idx_eligibility_station_time
+          ON eligibility_intervals(station_id, processed_start_us, processed_end_us);
+        CREATE INDEX idx_eligibility_output_station_time
+          ON eligibility_intervals(output_id, station_id, processed_start_us, processed_end_us);
+        CREATE VIEW output_eligibility AS
+          SELECT e.interval_id, o.output_id, o.output_name,
+                 o.model_workflow_family, e.station_id,
+                 e.processed_start_us, e.processed_end_us,
+                 e.phase_mask, e.channel_family, e.channels,
+                 e.valid_input, e.interval_source, e.h5_file, e.day_id
+          FROM eligibility_intervals AS e JOIN outputs AS o USING (output_id);
+        """
+    )
+    quick_check = con.execute("PRAGMA quick_check").fetchone()[0]
+    interval_count = con.execute("SELECT COUNT(*) FROM eligibility_intervals").fetchone()[0]
+    con.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+    con.execute("PRAGMA journal_mode=DELETE")
+    con.execute("VACUUM")
+    con.close()
+
+    args.registry.parent.mkdir(parents=True, exist_ok=True)
+    with args.registry.open("w", newline="") as stream:
+        writer = csv.DictWriter(stream, fieldnames=list(registry_rows[0]), delimiter="\t")
+        writer.writeheader()
+        writer.writerows(registry_rows)
+    summary = {
+        "schema": "seismicx-cont-output-eligibility-v1",
+        "definition": (
+            "An interval is eligible when the source output contains a processed "
+            "sample record for the station-location and time. Absence of a pick is "
+            "not used to infer eligibility."
+        ),
+        "outputs": len(registry_rows),
+        "eligibility_intervals": int(interval_count),
+        "database": release_path(args.output_db),
+        "registry": release_path(args.registry),
+        "quick_check": quick_check,
+        "rows": registry_rows,
+    }
+    args.summary.parent.mkdir(parents=True, exist_ok=True)
+    args.summary.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n")
+    print(json.dumps(summary, indent=2, sort_keys=True))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--metadata", type=Path, default=DEFAULT_METADATA)
+    parser.add_argument("--output-db", type=Path, default=DEFAULT_DB)
+    parser.add_argument("--registry", type=Path, default=DEFAULT_REGISTRY)
+    parser.add_argument("--summary", type=Path, default=DEFAULT_SUMMARY)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    build(parse_args())

scripts/upload_all_model_phase_catalog.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Upload the compressed all-model phase catalogue to HF and ModelScope."""
+"""Upload the optional multi-output phase catalogue to HF and ModelScope."""
 
 from __future__ import annotations
 
@@ -17,18 +17,30 @@ ASSETS = (
     "data/label/all_model_phase_picks.sqlite.zst",
     "data/label/all_model_phase_picks.metadata.json",
     "data/label/README_all_model_phase_picks.md",
+    "data/label/output_eligibility.sqlite",
+    "data/label/output_registry.tsv",
     "data/preview/all_model_phase_picks.preview.jsonl",
     "data/preview/seismicx_cont_file_index.csv",
+    "data/validation/multi_output_manual_reference_match.json",
+    "data/validation/multi_output_manual_reference_match.tsv",
+    "data/validation/output_eligibility_summary.json",
     "scripts/build_all_model_phase_catalog.py",
+    "scripts/build_output_eligibility.py",
     "scripts/run_all_model_phase_catalog.sh",
     "scripts/upload_all_model_phase_catalog.py",
     "scripts/upload_restfiles_hf.py",
     "scripts/upload_restfiles_ms.py",
+    "scripts/validate_multi_output_candidates.py",
     "scripts/verify_full_dataset.py",
     "README.md",
     "README.zh.md",
 )
 
+BULK_IMMUTABLE_ASSETS = {
+    "data/label/all_model_phase_picks.jsonl.zst",
+    "data/label/all_model_phase_picks.sqlite.zst",
+}
+
 
 def validate_assets() -> list[tuple[Path, str]]:
     assets = [(ROOT / rel, rel) for rel in ASSETS]
@@ -58,17 +70,33 @@ def upload_huggingface(repo_id: str, assets: list[tuple[Path, str]]) -> str:
     from huggingface_hub import CommitOperationAdd, HfApi
 
     api = HfApi()
+    remote_before = {
+        item.path: item.size
+        for item in api.get_paths_info(
+            repo_id=repo_id,
+            repo_type="dataset",
+            paths=sorted(BULK_IMMUTABLE_ASSETS),
+        )
+    }
+    upload_assets = [
+        (path, rel)
+        for path, rel in assets
+        if rel not in BULK_IMMUTABLE_ASSETS
+        or remote_before.get(rel) != path.stat().st_size
+    ]
+    skipped = len(assets) - len(upload_assets)
+    print(f"Hugging Face upload files: {len(upload_assets)}; unchanged bulk files: {skipped}")
     info = api.create_commit(
         repo_id=repo_id,
         repo_type="dataset",
         operations=[
             CommitOperationAdd(path_in_repo=rel, path_or_fileobj=str(path))
-            for path, rel in assets
+            for path, rel in upload_assets
         ],
-        commit_message="Add compact all-model phase-candidate catalogue",
+        commit_message="Validate multi-output phase-candidate extension",
         commit_description=(
-            "Add compressed JSONL and SQLite products, machine-readable schema, "
-            "preview, build scripts, and query documentation."
+            "Add output eligibility and registry files, support-stratified "
+            "manual-reference validation, build scripts, and query documentation."
         ),
         num_threads=4,
     )
@@ -91,8 +119,33 @@ def upload_modelscope(repo_id: str, assets: list[tuple[Path, str]]) -> list[str]
     from modelscope.hub.api import HubApi
 
     api = HubApi()
+    remote: dict[str, int] = {}
+    page = 1
+    while True:
+        batch = api.get_dataset_files(
+            repo_id,
+            revision="master",
+            recursive=True,
+            page_number=page,
+            page_size=100,
+        )
+        if not isinstance(batch, list):
+            raise RuntimeError(f"unexpected ModelScope file-list response: {type(batch)}")
+        for item in batch:
+            if item.get("Type") == "blob":
+                remote[str(item.get("Path"))] = int(item.get("Size") or 0)
+        if len(batch) < 100:
+            break
+        page += 1
+    upload_assets = [
+        (path, rel)
+        for path, rel in assets
+        if rel not in BULK_IMMUTABLE_ASSETS or remote.get(rel) != path.stat().st_size
+    ]
+    skipped = len(assets) - len(upload_assets)
+    print(f"ModelScope upload files: {len(upload_assets)}; unchanged bulk files: {skipped}")
     revisions = []
-    for path, rel in assets:
+    for path, rel in upload_assets:
         info = api.upload_file(
             path_or_fileobj=str(path),
             path_in_repo=rel,
@@ -103,7 +156,7 @@ def upload_modelscope(repo_id: str, assets: list[tuple[Path, str]]) -> list[str]
             commit_message=f"Update {rel}",
         )
         revisions.append(str(getattr(info, "commit_url", info)))
-    remote: dict[str, int] = {}
+    remote = {}
     page = 1
     while True:
         batch = api.get_dataset_files(

scripts/upload_restfiles_hf.py

@@ -41,7 +41,12 @@ additional_release_paths = {
     "data/label/all_model_phase_picks.sqlite.zst",
     "data/label/all_model_phase_picks.metadata.json",
     "data/label/README_all_model_phase_picks.md",
+    "data/label/output_eligibility.sqlite",
+    "data/label/output_registry.tsv",
     "data/preview/all_model_phase_picks.preview.jsonl",
+    "data/validation/multi_output_manual_reference_match.json",
+    "data/validation/multi_output_manual_reference_match.tsv",
+    "data/validation/output_eligibility_summary.json",
 }
 # =========================
 

scripts/upload_restfiles_ms.py

@@ -35,7 +35,12 @@ additional_release_paths = {
     "data/label/all_model_phase_picks.sqlite.zst",
     "data/label/all_model_phase_picks.metadata.json",
     "data/label/README_all_model_phase_picks.md",
+    "data/label/output_eligibility.sqlite",
+    "data/label/output_registry.tsv",
     "data/preview/all_model_phase_picks.preview.jsonl",
+    "data/validation/multi_output_manual_reference_match.json",
+    "data/validation/multi_output_manual_reference_match.tsv",
+    "data/validation/output_eligibility_summary.json",
 }
 # =========================
 

scripts/validate_multi_output_candidates.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+"""Validate multi-output support strata against C0 manual references.
+
+Each support stratum is matched independently with deterministic, time-ordered
+one-to-one station/phase assignment. The objective first maximizes matches
+within the declared tolerance and then minimizes total absolute residual.
+"""
+
+from __future__ import annotations
+
+import argparse
+import bisect
+import csv
+import io
+import json
+import math
+import sqlite3
+from dataclasses import dataclass
+from pathlib import Path
+from statistics import median
+from typing import Any
+
+import orjson
+import zstandard as zstd
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_CANDIDATES = ROOT / "data/label/all_model_phase_picks.jsonl.zst"
+DEFAULT_REFERENCES = ROOT / "data/label/reference_arrivals.sqlite"
+DEFAULT_JSON = ROOT / "data/validation/multi_output_manual_reference_match.json"
+DEFAULT_TSV = ROOT / "data/validation/multi_output_manual_reference_match.tsv"
+
+PERIODS = {
+    "2019": (1_561_939_200_000_000, 1_562_544_000_000_000),
+    "2021": (1_636_329_600_000_000, 1_636_934_400_000_000),
+}
+STRATA = {
+    "support_1": lambda value: value == 1,
+    "support_ge_2": lambda value: value >= 2,
+    "support_ge_3": lambda value: value >= 3,
+}
+
+
+@dataclass
+class MatchState:
+    count: int
+    cost_us: int
+    parent: int
+    reference_index: int
+    candidate_index: int
+
+
+def match_one_to_one(
+    references: list[int], candidates: list[int], tolerance_us: int
+) -> list[int]:
+    """Return signed residuals for a maximum-cardinality minimum-cost match."""
+    if not references or not candidates:
+        return []
+    states = [MatchState(0, 0, -1, -1, -1)]
+    fenwick = [0] * (len(candidates) + 1)
+
+    def better(left_id: int, right_id: int) -> int:
+        left = states[left_id]
+        right = states[right_id]
+        left_key = (left.count, -left.cost_us)
+        right_key = (right.count, -right.cost_us)
+        if left_key != right_key:
+            return left_id if left_key > right_key else right_id
+        left_tie = (left.candidate_index, left.reference_index, left_id)
+        right_tie = (right.candidate_index, right.reference_index, right_id)
+        return left_id if left_tie < right_tie else right_id
+
+    def query(candidate_index_exclusive: int) -> int:
+        best_id = 0
+        index = candidate_index_exclusive
+        while index > 0:
+            best_id = better(best_id, fenwick[index])
+            index -= index & -index
+        return best_id
+
+    def update(candidate_index: int, state_id: int) -> None:
+        index = candidate_index + 1
+        while index < len(fenwick):
+            fenwick[index] = better(fenwick[index], state_id)
+            index += index & -index
+
+    for reference_index, reference_time in enumerate(references):
+        left = bisect.bisect_left(candidates, reference_time - tolerance_us)
+        right = bisect.bisect_right(candidates, reference_time + tolerance_us)
+        pending = []
+        for candidate_index in range(left, right):
+            previous_id = query(candidate_index)
+            previous = states[previous_id]
+            residual = candidates[candidate_index] - reference_time
+            state_id = len(states)
+            states.append(
+                MatchState(
+                    previous.count + 1,
+                    previous.cost_us + abs(residual),
+                    previous_id,
+                    reference_index,
+                    candidate_index,
+                )
+            )
+            pending.append((candidate_index, state_id))
+        for candidate_index, state_id in pending:
+            update(candidate_index, state_id)
+
+    residuals = []
+    state_id = query(len(candidates))
+    while state_id:
+        state = states[state_id]
+        residuals.append(
+            candidates[state.candidate_index] - references[state.reference_index]
+        )
+        state_id = state.parent
+    residuals.reverse()
+    return residuals
+
+
+def load_references(path: Path) -> tuple[dict[tuple[str, str, str], list[int]], dict[tuple[str, str], int]]:
+    con = sqlite3.connect(path)
+    rows = con.execute(
+        """
+        SELECT period, station_id, phase, pick_time_epoch
+        FROM reference_arrivals
+        WHERE c0_point_covered=1 AND manual_primary_reference=1
+        ORDER BY period, station_id, phase, pick_time_epoch, arrival_id
+        """
+    )
+    grouped: dict[tuple[str, str, str], list[int]] = {}
+    totals: dict[tuple[str, str], int] = {}
+    for period, station, phase, epoch in rows:
+        grouped.setdefault((str(period), str(station), str(phase)), []).append(
+            int(round(float(epoch) * 1_000_000))
+        )
+        key = (str(period), str(phase))
+        totals[key] = totals.get(key, 0) + 1
+    con.close()
+    return grouped, totals
+
+
+def period_for_time(time_us: int) -> str | None:
+    for period, (left, right) in PERIODS.items():
+        if left <= time_us < right:
+            return period
+    return None
+
+
+def validate(args: argparse.Namespace) -> None:
+    references, reference_totals = load_references(args.references)
+    accumulator: dict[tuple[str, str, str], dict[str, Any]] = {}
+    for period in PERIODS:
+        for phase in ("P", "S"):
+            for stratum in STRATA:
+                accumulator[(period, phase, stratum)] = {
+                    "candidate_count": 0,
+                    "residuals_us": [],
+                }
+
+    def process_group(station: str | None, phase: str | None, values: list[tuple[int, int]]) -> None:
+        if station is None or phase is None or not values:
+            return
+        for period, (left, right) in PERIODS.items():
+            period_values = [(time_us, support) for time_us, support in values if left <= time_us < right]
+            if not period_values:
+                continue
+            period_references = references.get((period, station, phase), [])
+            for stratum, predicate in STRATA.items():
+                candidate_times = [time_us for time_us, support in period_values if predicate(support)]
+                target = accumulator[(period, phase, stratum)]
+                target["candidate_count"] += len(candidate_times)
+                if period_references and candidate_times:
+                    target["residuals_us"].extend(
+                        match_one_to_one(period_references, candidate_times, args.tolerance_us)
+                    )
+
+    current_station = None
+    current_phase = None
+    values: list[tuple[int, int]] = []
+    record_count = 0
+    outside_period_count = 0
+    outside_period_examples = []
+    with args.candidates.open("rb") as raw:
+        decompressor = zstd.ZstdDecompressor()
+        with decompressor.stream_reader(raw, read_across_frames=True) as reader:
+            stream = io.BufferedReader(reader, buffer_size=16 * 1024 * 1024)
+            for line in stream:
+                if not line.strip():
+                    continue
+                record = orjson.loads(line)
+                station = str(record["s"])
+                phase = str(record["p"])
+                if current_station is None:
+                    current_station, current_phase = station, phase
+                elif station != current_station or phase != current_phase:
+                    process_group(current_station, current_phase, values)
+                    current_station, current_phase = station, phase
+                    values = []
+                values.append((int(record["t"]), int(record["n"])))
+                if period_for_time(int(record["t"])) is None:
+                    outside_period_count += 1
+                    if len(outside_period_examples) < 10:
+                        outside_period_examples.append(
+                            {
+                                "candidate_id": int(record["id"]),
+                                "station_id": station,
+                                "phase": phase,
+                                "time_us": int(record["t"]),
+                                "support": int(record["n"]),
+                            }
+                        )
+                record_count += 1
+    process_group(current_station, current_phase, values)
+
+    rows = []
+    for period in PERIODS:
+        for phase in ("P", "S"):
+            for stratum in STRATA:
+                item = accumulator[(period, phase, stratum)]
+                residuals = item.pop("residuals_us")
+                candidate_count = int(item["candidate_count"])
+                matched_count = len(residuals)
+                absolute = [abs(value) / 1_000_000 for value in residuals]
+                rows.append(
+                    {
+                        "period": period,
+                        "phase": phase,
+                        "support_stratum": stratum,
+                        "candidate_count": candidate_count,
+                        "c0_manual_reference_count": reference_totals.get((period, phase), 0),
+                        "matched_candidate_count": matched_count,
+                        "manual_reference_match_fraction": (
+                            matched_count / candidate_count if candidate_count else None
+                        ),
+                        "median_absolute_residual_s": median(absolute) if absolute else None,
+                    }
+                )
+
+    expected = 49_689_373
+    phase_total = sum(
+        row["candidate_count"]
+        for row in rows
+        if row["support_stratum"] == "support_1"
+    ) + sum(
+        row["candidate_count"]
+        for row in rows
+        if row["support_stratum"] == "support_ge_2"
+    )
+    if record_count != expected or phase_total + outside_period_count != expected:
+        raise RuntimeError(
+            "candidate-count mismatch: "
+            f"streamed={record_count}, selected_strata={phase_total}, "
+            f"outside={outside_period_count}, expected={expected}"
+        )
+
+    payload = {
+        "schema": "seismicx-cont-multi-output-manual-match-v1",
+        "candidate_file": str(args.candidates.relative_to(ROOT)),
+        "reference_file": str(args.references.relative_to(ROOT)),
+        "reference_definition": "C0-covered manual_primary_reference arrivals",
+        "matching": {
+            "station_location_exact": True,
+            "canonical_phase_exact": True,
+            "one_to_one": True,
+            "objective": "maximize matches, then minimize total absolute residual",
+            "tolerance_s": args.tolerance_us / 1_000_000,
+        },
+        "candidate_records_checked": record_count,
+        "selected_period_candidate_records": phase_total,
+        "outside_selected_period_count": outside_period_count,
+        "outside_selected_period_examples": outside_period_examples,
+        "rows": rows,
+        "interpretation": (
+            "Manual-reference match fraction is a catalogue-agreement diagnostic, "
+            "not conventional precision; source annotations are not exhaustive."
+        ),
+    }
+    args.output_json.parent.mkdir(parents=True, exist_ok=True)
+    args.output_json.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
+    with args.output_tsv.open("w", newline="") as stream:
+        writer = csv.DictWriter(stream, fieldnames=list(rows[0]), delimiter="\t")
+        writer.writeheader()
+        writer.writerows(rows)
+    print(json.dumps(payload, indent=2, sort_keys=True))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--candidates", type=Path, default=DEFAULT_CANDIDATES)
+    parser.add_argument("--references", type=Path, default=DEFAULT_REFERENCES)
+    parser.add_argument("--tolerance-s", type=float, default=0.5)
+    parser.add_argument("--output-json", type=Path, default=DEFAULT_JSON)
+    parser.add_argument("--output-tsv", type=Path, default=DEFAULT_TSV)
+    args = parser.parse_args()
+    if args.tolerance_s <= 0:
+        parser.error("--tolerance-s must be positive")
+    args.tolerance_us = int(round(args.tolerance_s * 1_000_000))
+    return args
+
+
+if __name__ == "__main__":
+    validate(parse_args())

scripts/verify_full_dataset.py

@@ -147,6 +147,87 @@ def main() -> None:
         if mismatches:
             raise RuntimeError("all-model phase-catalogue file-size validation failed")
 
+    eligibility_db = root / "data" / "label" / "output_eligibility.sqlite"
+    registry_path = root / "data" / "label" / "output_registry.tsv"
+    agreement_path = (
+        root / "data" / "validation" / "multi_output_manual_reference_match.tsv"
+    )
+    if eligibility_db.is_file() or registry_path.is_file() or agreement_path.is_file():
+        required = (eligibility_db, registry_path, agreement_path)
+        missing = [str(path.relative_to(root)) for path in required if not path.is_file()]
+        if missing:
+            raise RuntimeError(
+                "incomplete multi-output validation extension: " + ", ".join(missing)
+            )
+
+        output_db = sqlite3.connect(eligibility_db)
+        eligibility_check = output_db.execute("PRAGMA quick_check").fetchone()[0]
+        n_outputs = output_db.execute("SELECT COUNT(*) FROM outputs").fetchone()[0]
+        n_intervals = output_db.execute(
+            "SELECT COUNT(*) FROM eligibility_intervals"
+        ).fetchone()[0]
+        bad_intervals = output_db.execute(
+            """
+            SELECT COUNT(*) FROM eligibility_intervals
+            WHERE processed_end_us < processed_start_us
+               OR valid_input NOT IN (0, 1)
+               OR phase_mask <= 0
+            """
+        ).fetchone()[0]
+        output_db.close()
+
+        with registry_path.open(newline="", encoding="utf-8") as handle:
+            registry = list(csv.DictReader(handle, delimiter="\t"))
+        source_picks = sum(int(row["source_pick_count"]) for row in registry)
+
+        with agreement_path.open(newline="", encoding="utf-8") as handle:
+            agreement = list(csv.DictReader(handle, delimiter="\t"))
+        grouped: dict[tuple[str, str], dict[str, float]] = {}
+        for row in agreement:
+            grouped.setdefault((row["period"], row["phase"]), {})[
+                row["support_stratum"]
+            ] = float(row["manual_reference_match_fraction"])
+        non_monotonic = []
+        for key, values in grouped.items():
+            ordered = [
+                values.get("support_1"),
+                values.get("support_ge_2"),
+                values.get("support_ge_3"),
+            ]
+            if any(value is None for value in ordered) or not (
+                ordered[0] <= ordered[1] <= ordered[2]
+            ):
+                non_monotonic.append(key)
+
+        print("Optional multi-output eligibility and validation extension:")
+        print(
+            "  quick_check={}, outputs={}, intervals={:,}, registry_rows={}, "
+            "source_picks={:,}, agreement_rows={}, non_monotonic_groups={}".format(
+                eligibility_check,
+                n_outputs,
+                n_intervals,
+                len(registry),
+                source_picks,
+                len(agreement),
+                len(non_monotonic),
+            )
+        )
+        if eligibility_check != "ok" or bad_intervals:
+            raise RuntimeError("output-eligibility SQLite integrity validation failed")
+        if (n_outputs, n_intervals, len(registry), source_picks, len(agreement)) != (
+            9,
+            169_573,
+            9,
+            124_403_181,
+            12,
+        ):
+            raise RuntimeError("multi-output extension count validation failed")
+        if non_monotonic:
+            raise RuntimeError(
+                "manual-reference match fractions are not monotonic for "
+                + ", ".join(f"{period}/{phase}" for period, phase in non_monotonic)
+            )
+
 
 if __name__ == "__main__":
     main()