v2.6 dataset

README.md

@@ -37,8 +37,13 @@ All measurements are synthetic. DRMHB is not field data and is not a substitute
 for validation on real machinery.
 
 The current fixture was generated with VibSynth orchestration script 2.5.0,
-serialized as VibFrame 0.2.0, and validated with
-[`vibframe-anndata==0.2.2`](https://413hq.github.io/vibframe-anndata-docs/latest/).
+serialized as VibFrame 0.2.0. The conversion examples now use
+[`vibframe-anndata==0.3.0`](https://413hq.github.io/vibframe-anndata-docs/0.3.0/)
+with complete evaluation preservation. The raw ZIP is unchanged: this is the
+published 2.5.0 fixture, not a newly generated compact-controls campaign.
+
+**Start here:** [dataset report](docs/DRMHB.pdf), [conversion examples](examples/README.md)
+and [complete ground-truth guide](docs/GROUND_TRUTH.md).
 
 ## The challenge
 
@@ -167,97 +172,116 @@ thermal history and structural transfer.
 
 ## Ground truth and leakage prevention
 
-The source VibFrame keeps evaluation information in partitioned sidecars. During
-conversion, `vibframe-anndata` 0.2.2 can align snapshot truth one-to-one with
-observations and store it at:
-
-```python
-adata.obsm["ground_truth"]
-```
-
-The current aligned table has shape `(46907, 42)`. It includes regime,
-transition route and progress, acquisition kind, elapsed time, true process
-states, nuisance metadata, OOD status, fault types, severities and serialized
-physical states.
-
-Ground truth is colocated for reproducible evaluation, not for learning. Do not
-use `split`, `fault_*`, physical states, `ood_operational`, nuisance labels or
-other truth fields as unsupervised model inputs. The feature matrix `X` contains
-only explicitly materialized signal-derived features.
+The source VibFrame keeps evaluation information in separate sidecars. The
+0.3.0 workflow preserves both supported observation-aligned views and the
+original files, without automatically exposing targets to a model:
+
+| AnnData location | Information |
+|---|---|
+| `obsm["ground_truth"]` | Snapshot truth, aligned with `obs_names` |
+| `obsm["waveform_ground_truth"]` | Per-waveform annotations with explicit raw-channel bindings |
+| `uns["vibframe_evaluation"]` | Byte-exact original annotation files and source/path/size/SHA-256 manifest |
+| `uns["vibframe_anndata"]` | Conversion, raw-channel and feature provenance |
+| `obsm["raw_*_capture_t"]` and `*_capture_t_known` | Actual capture times and explicit/fallback flags |
+
+This includes construction labels, crop offsets and durations, quantization and
+hashes, machine parameters, scenario configuration and DiagGT documents/tables.
+All regular files under `evaluation/`, `ground-truth/` and `ground_truth/` are
+preserved, plus root JSON/YAML and machine JSON context. Unknown annotation
+fields are retained; the original Parquet schema can be recovered.
+
+Snapshot joins use **source, machine and integer UTC-microsecond `snap_t`**, not
+row order. Per-waveform joins also identify the raw channel. Capture `t` can be
+later than `snap_t` because of cropping; it is not a different snapshot.
+
+The reference snapshot view had 42 columns. Code must inspect actual fields
+instead of hard-coding a fixed schema. Do not use `split`, `fault_*`, severity,
+physical states, `ood_operational`, nuisance labels or DiagGT as unsupervised
+model inputs. Operational-state knowledge must be an explicitly declared
+experimental condition. The package never adds these fields to `X` implicitly.
+
+**Preservation is not automatic labelling:** DiagGT intervals, consolidated
+observations and findings retain their original semantics. No nearest-time
+join is invented, and absence of a diagnosis does not mean healthy. The original
+archive remains dataset-wide when AnnData observations are sliced.
 
 ## Distribution and local AnnData workflow
 
-The canonical public artifact is:
-
-```text
-data/DRMHB.vibframe.zip
-```
-
-AnnData files are derived locally so that the raw VibFrame remains the single
-canonical representation. Run from the repository root:
+The single canonical public signal artifact is `data/DRMHB.vibframe.zip`.
+H5ADs are local derivatives, not a second public source of truth.
 
 ```bash
-python -m pip install "vibframe-anndata==0.2.2" "anndata>=0.10,<0.13"
+python -m pip install -r examples/requirements.txt
 
 python examples/01_create_featureless_anndata.py \
-    data/DRMHB.vibframe.zip \
-    derived/DRMHB.float32.h5ad
+    data/DRMHB.vibframe.zip derived/DRMHB.v0.3.0.raw.h5ad
 
 python examples/02_inspect_anndata.py \
-    derived/DRMHB.float32.h5ad
+    derived/DRMHB.v0.3.0.raw.h5ad --waveform-details
 
 python examples/03_add_features.py \
-    derived/DRMHB.float32.h5ad \
-    derived/DRMHB.float32.eda-features.h5ad
+    derived/DRMHB.v0.3.0.raw.h5ad derived/DRMHB.v0.3.0.features.h5ad
+
+python examples/05_read_evaluation.py derived/DRMHB.v0.3.0.features.h5ad
 ```
 
-The base H5AD is intentionally featureless:
+Example 01 explicitly enables `ground_truth.scope="all"`, stores numerical
+values as `float32`, and ingests in raw-data blocks of 8 MiB. The featureless base
+has `X.shape == (46907, 0)` for the published fixture. The unchanged reference
+feature requests materialized 468 machine/source-scoped columns in the reference
+EDA, with structural missing values for other machines. They are not 468 dense
+fleet-wide descriptors; the notebook explains the logical-column alignment.
 
-```text
-X.shape == (46907, 0)
-```
+Example 03 calculates features only from the raw H5AD and checks that original
+annotations and raw coverage are preserved. Example 02 reads HDF5 metadata and
+public annotation APIs selectively; it does not assume AnnData backed mode
+keeps `obsm` or the evaluation archive out of RAM.
 
-It retains raw spectra, ragged waveforms, tachometer arrays, provenance and
-aligned evaluation truth in `obsm`. The reference feature example produces:
+For an existing 0.2.x H5AD, preserve the original source identities and run:
 
-```text
-X.shape == (46907, 468)
+```bash
+python examples/04_add_complete_ground_truth.py \
+    derived/DRMHB.float32.eda-features.h5ad data/DRMHB.vibframe.zip \
+    derived/DRMHB.v0.3.0.features.h5ad
 ```
 
-Features are calculated exclusively from raw arrays in the base H5AD; the
-original VibFrame is not reopened. See [examples/README.md](examples/README.md)
-for detailed commands, validation output and storage notes.
+This adds annotations without recalculating `X`, `var` or raw samples. A
+transactional temporary copy needs roughly one additional H5AD of free disk.
+Legacy capture-time companion arrays are not retroactively recovered by this
+operation; new raw imports populate them. Crop information is still retained
+in waveform truth.
 
-Validated local sizes with uncompressed raw arrays are approximately:
+### Storage and memory
 
-| Artifact | Size |
-|---|---:|
-| Canonical VibFrame ZIP | 8.36 GiB |
-| Featureless float32 H5AD | 9.35 GiB |
-| Reference-feature float32 H5AD | 9.44 GiB |
+The canonical ZIP is **8,972,153,939 bytes (8.356 GiB)**. The reference 0.2.2
+run measured about 9.35 GiB for its featureless H5AD and 9.44 GiB after reference
+features. Those are historical snapshot-only sizes, **not measured 0.3.0 sizes**.
+Full annotations add original sidecar bytes, aligned views and capture-time
+matrices. Examples report their actual output size rather than extrapolating.
+
+The default 512 MiB sidecar budget covers original encoded annotation files,
+not decoded tables or total process RAM. Inspect exact archived sizes with
+`list_evaluation_files()`. Raw-array compression remains `none`, as in the
+existing examples; no compression benchmark is rerun. Ground-truth conversion
+does not modify the VibFrame ZIP.
 
 ## AnnData layout
 
 ```text
-obs
-|- snapshot identity, timestamp, machine, speed and availability flags
-
-X
-|- initially (46907, 0); signal-derived features after materialization
-
-var
-|- feature provenance and channel metadata
-
-obsm
-|- raw_spectra and lengths/positions/speed
-|- raw_waveforms and lengths/positions/speed
-|- raw_waveforms_tacho_rising / raw_waveforms_tacho_falling
-`- ground_truth (evaluation only)
-
-uns
-`- VibFrame, channel and conversion provenance
+obs   : snapshot identity, snap_t, machine, source, speed and availability
+X     : n_snapshots × n_materialized_features (initially zero columns)
+var   : feature descriptors, units, channel identity and provenance
+obsm  : ragged raw spectra/waveforms + lengths/positions/speed
+        tachometer edges + capture_t/known companions
+        ground_truth + waveform_ground_truth (evaluation only)
+uns   : vibframe_anndata (package/raw/feature provenance)
+        vibframe_evaluation (original sidecar bytes and manifest)
 ```
 
+See [examples/README.md](examples/README.md) for precise commands and
+[docs/GROUND_TRUTH.md](docs/GROUND_TRUTH.md) for target selection, source identity,
+original DiagGT access and missing-data semantics.
+
 ## Recommended evaluation protocol
 
 1. Fit preprocessing and models only on `calibration`.
@@ -277,6 +301,10 @@ hours; an observation gap longer than 4.5 hours breaks the run.
 
 ## Compact reference baseline
 
+The values below come from the immutable [published EDA run](notebooks/reference/DRMHB_EDA_published_2_5_0.ipynb)
+for the 2.5.0 fixture with converter 0.2.2. Updating the annotation API does not
+constitute rerunning those experiments.
+
 The reference notebook fits four deliberately small unsupervised baselines.
 Thresholds are the 99th percentile of normal-holdout scores.
 
@@ -299,18 +327,29 @@ respectively, and the TwoNN intrinsic-dimension estimate is approximately 8.80.
 
 ```text
 DRMHB/
-|- data/                 canonical VibFrame and local derived artifacts
-|- examples/             conversion, inspection and feature scripts
-|- notebooks/DRMHB_EDA.ipynb
-|- latexdocs/            LaTeX source, compiled PDF and EDA figures/tables
-|- generator.py          reproducible scenario generator
-`- LICENSE.md
+|- data/DRMHB.vibframe.zip         canonical published 2.5.0 signal dataset
+|- derived/                      local H5ADs (not versioned)
+|- examples/                     import, inspect, features, retrofit, evaluation readers
+|- notebooks/DRMHB_EDA.ipynb       editable 0.3.0 EDA workflow, outputs cleared
+|- notebooks/reference/          immutable executed source of published EDA results
+|- docs/DRMHB.tex                 editable report source
+|- docs/DRMHB.pdf                 compiled dataset report
+|- docs/figures/                  EDA images and editable vector diagrams
+|- docs/provenance/               figure/table and source identities
+|- tools/                        report build and reference-asset recovery
+`- tests/                        small, synthetic example-integration checks
 ```
 
-The [explanatory PDF](latexdocs/DRMHB.pdf) describes the simulated plant,
-acquisition policy, physical fault mechanisms and evaluation challenge. The
-notebook is the executable EDA and exports reusable figures and baseline tables
-to `latexdocs/`.
+The [report](docs/DRMHB.pdf) explains the installation, daily/weekly state
+schedule, acquisitions, degradation, evaluation and complete AnnData workflow.
+Build it with `python tools/build_report.py` once a LaTeX distribution with
+`latexmk` and TikZ is installed. The report's 37 EDA figures and two baseline
+tables are recovered from the original executed notebook, not redrawn from
+invented data. Their [manifest](docs/provenance/eda_assets.json) records source
+cells and hashes. The updated notebook exports new plots/tables to
+`derived/eda_v0.3.0/`, separately from the report reference assets. Review and
+promote a complete new run together with its numerical narrative and provenance;
+partial execution cannot silently replace published figures.
 
 ## Limitations
 

data/{DRMHB.vibframe.zip → DRMHB-compact-controls.vibframe.zip}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2f4ceef65242719134771a321199542ad794cb72c76c93b6c4b15da608a9affa
-size 8972153939
+oid sha256:b193177effafaf17089f753e57cd94b5ad969873d7cedfdceaab81171fdee128
+size 185975818

data/DRMHB-compact.vibframe.zip

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

docs/DRMHB.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a74abeab5b4b4e5673368b0ef826db5026b136c4963963b68a6e1e176c598761
-size 3716343
+oid sha256:c7433c2b4c8baddb72cc7c4cc49291217edbd04d486b517ec5b419ac273de370
+size 4506090

docs/GROUND_TRUTH.md

@@ -0,0 +1,117 @@
+# Ground truth for DRMHB researchers
+
+## Four different kinds of information
+
+**Measured input** is raw acceleration/velocity information and measurement
+context: units, sample rate/frequency grid, point, mode, speed and timing.
+**Construction truth** records the simulator's process, health and nuisance
+states. **Waveform truth** explains how a captured source became a stored crop.
+**Diagnostic truth (DiagGT)** carries diagnostic documents, observations,
+findings and materialization rules. These are complementary, not interchangeable.
+
+| Where | Use |
+|---|---|
+| `obs` | Snapshot identity and measurement context |
+| `X`, `var` | Explicit signal-derived feature values and definitions |
+| `obsm['raw_waveforms']`, `raw_spectra` and companions | Reusable raw signals, real lengths, positions, speeds and tachometer edges |
+| `obsm['ground_truth']` | Snapshot-aligned construction labels |
+| `obsm['waveform_ground_truth']` | Per-snapshot `records_json` with zero or more channel-bound waveform labels |
+| `uns['vibframe_evaluation']` | Original evaluation files, byte-exact, with source/path/size/SHA-256 |
+| `uns['vibframe_anndata']` | Source, conversion, alignment, channel and feature provenance |
+
+## Import all the information
+
+```python
+from vibframe_anndata import import_raw_to_h5ad
+base = import_raw_to_h5ad(
+    "data/DRMHB.vibframe.zip", "derived/DRMHB.v0.3.0.raw.h5ad",
+    config={
+        "version": 1,
+        "raw_import": {"on_missing_signal": "nan"},
+        "ground_truth": {"enabled": True, "scope": "all",
+                         "on_missing": "error", "max_sidecar_mib": 512},
+        "output": {"dtype": "float32", "raw_compression": "none"},
+    }, block_size_mib=8,
+)
+```
+
+Full scope retains regular files under `evaluation/`, `ground-truth/` and
+`ground_truth/`, root JSON/YAML documents and machine JSON context. This includes
+unknown future annotation fields and files. Files outside those locations are
+not indiscriminately copied. The evaluation archive is not a duplicate waveform
+archive. Raw `trends.parquet` is never a source of production feature values.
+
+## Identity and time
+
+Use `(source, machine_id, snap_t)` for snapshot labels. Times are integer
+microseconds since Unix epoch, UTC. Never infer the unit from the magnitude.
+Waveform labels additionally bind point and available mode/definition/config
+identifiers. Missing identity, duplicated bindings and ambiguous modes must not
+be fixed by row-order or nearest-time guessing.
+
+A source acquisition starts at `snap_t`; a stored crop starts at `t`:
+
+```text
+t = snap_t + crop offset
+```
+
+New imports retain `raw_waveforms_capture_t`, `raw_spectra_capture_t` and the
+corresponding `*_known` matrices on the channel axis. Always check real lengths
+and the known flags: an absent capture is not a date, and a legacy fallback is
+not an explicitly measured time. Tachometer edges are relative to the stored crop.
+
+## Read labels without loading signals
+
+```python
+from vibframe_anndata import (
+    get_snapshot_ground_truth, get_waveform_ground_truth, list_evaluation_files,
+    read_evaluation_table, read_evaluation_json,
+)
+path = "derived/DRMHB.v0.3.0.features.h5ad"
+snapshot = get_snapshot_ground_truth(path)
+waveform = get_waveform_ground_truth(path, point_id="pump_DE_H", proc_mode_id="ACC_10K")
+files = list_evaluation_files(path)
+# Pick an exact source/path from files before calling a reader.
+rows = files.loc[files["path"].str.endswith("observations.parquet")]
+if not rows.empty:
+    item = rows.iloc[0]
+    diagnostics = read_evaluation_table(path, item["path"], source=item["source"])
+```
+
+Convenience views can stringify nested fields for HDF5 compatibility. The table
+reader recovers the original Arrow schema; the byte reader verifies the original
+hash by default. A selected table is materialized, but unrelated raw buffers are
+not loaded. Avoid reading the entire `uns` group just to inspect metadata.
+
+## Protocol decisions remain explicit
+
+Normality training must not automatically consume fault identity, severity,
+physical state, nuisance/OOD flags, simulation seeds or future labels. A known
+operating state is an oracle input only under an explicitly declared experiment.
+Do not infer health from missing DiagGT. Consolidated diagnoses and intervals
+must be interpreted using their original document/materialization semantics.
+
+The aligned views follow observation slicing, but the original archive remains
+dataset-wide. Features added/recalculated/removed by the package preserve both.
+Keep independently generated paired controls out of the longitudinal training
+and evaluation splits; use a separate H5AD/source and pair identities.
+
+## Existing H5ADs
+
+Example 04 wraps `add_ground_truth_to_h5ad()`. It adds originals and aligned
+annotations to an existing file without recomputing features or source raw
+signals. Keep `obs.source`, `obs.machine`, `obs.snap_t` and the original source
+set. The transactional copy requires additional disk space. It does not recreate
+legacy capture-time companion arrays; new raw imports do. Original waveform
+truth still provides offsets/durations for audit.
+
+## Resource accounting
+
+The H5AD grows by original sidecar bytes, aligned labels, the manifest and timing
+companions. `list_evaluation_files()` reports exact original sizes. The 512 MiB
+budget refers to encoded sidecars, not total RAM. No raw compression is changed.
+The published ZIP remains 8,972,153,939 bytes; full-annotation H5AD sizes must be
+measured after conversion rather than reusing the older snapshot-only sizes.
+
+Authoritative API and full coverage rules:
+https://413hq.github.io/vibframe-anndata-docs/0.3.0/guides/ground-truth/

examples/01_create_featureless_anndata.py

@@ -1,151 +1,51 @@
 #!/usr/bin/env python3
-"""
-Create a featureless DRMHB AnnData from the distributed VibFrame archive.
-
-Validated with:
-    vibframe-anndata==0.2.2
-
-DRMHB is distributed canonically as VibFrame. This script demonstrates the
-recommended out-of-core conversion into a reusable featureless H5AD.
-
-The 0.2.2 release can also ingest DRMHB snapshot-level evaluation truth from
-evaluation/snapshot_truth/ and store it in obsm["ground_truth"] without exposing
-those labels as model features.
-
-Install:
-    python -m pip install "vibframe-anndata==0.2.2"
-
-Usage:
-    python examples/01_create_featureless_anndata.py \
-        data/DRMHB.vibframe.zip \
-        derived/DRMHB.float32.h5ad
-"""
+"""Import a DRMHB ZIP or directory with full ground truth (no features)."""
 
 from __future__ import annotations
 
 import argparse
 from pathlib import Path
 
-from vibframe_anndata import (
-    __version__ as vibframe_anndata_version,
-    import_raw_to_h5ad,
-    validate_streamed_h5ad,
-)
-
-EXPECTED_VERSION = "0.2.2"
+from drmhb_workflow import create_base, positive_int
+from vibframe_anndata import validate_streamed_h5ad
 
 
 def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Convert DRMHB VibFrame into a featureless AnnData."
-    )
-    parser.add_argument(
-        "vibframe",
-        type=Path,
-        help="Path to the DRMHB VibFrame ZIP archive.",
-    )
-    parser.add_argument(
-        "output",
-        type=Path,
-        help="Destination .h5ad path.",
-    )
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("vibframe", type=Path)
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--block-size-mib", type=positive_int, default=8)
+    parser.add_argument("--dtype", choices=("float32", "float64"), default="float32")
     parser.add_argument(
-        "--block-size-mib",
-        type=int,
-        default=32,
-        help="Approximate raw-ingest block size in MiB (default: 32).",
+        "--ground-truth-scope", choices=("all", "snapshot", "none"), default="all"
     )
     parser.add_argument(
-        "--dtype",
-        choices=("float32", "float64"),
-        default="float32",
-        help="Numerical storage dtype (default: float32).",
-    )
-    parser.add_argument(
-        "--without-ground-truth",
-        action="store_true",
-        help=(
-            "Do not ingest evaluation/snapshot_truth into obsm['ground_truth']. "
-            "By default DRMHB ground truth is imported explicitly for evaluation."
-        ),
+        "--without-ground-truth", action="store_true", help="Alias for scope=none"
     )
+    parser.add_argument("--max-sidecar-mib", type=positive_int, default=512)
+    parser.add_argument("--overwrite", action="store_true")
     return parser.parse_args()
 
 
 def main() -> None:
     args = parse_args()
-
-    if vibframe_anndata_version != EXPECTED_VERSION:
-        raise RuntimeError(
-            f"This example is validated for vibframe-anndata=={EXPECTED_VERSION}; "
-            f"active version: {vibframe_anndata_version!r}"
-        )
-
-    if not args.vibframe.is_file():
-        raise FileNotFoundError(args.vibframe)
-
-    args.output.parent.mkdir(parents=True, exist_ok=True)
-
-    config = {
-        "version": 1,
-        "raw_import": {
-            "waveforms": True,
-            "spectra": True,
-            "on_missing_signal": "nan",
-        },
-        "ground_truth": {
-            "enabled": not args.without_ground_truth,
-            "on_missing": "error",
-        },
-        "output": {
-            "dtype": args.dtype,
-            # Explicitly use the 0.2.2 default. Compression is lossless but the
-            # package benchmark shows that compressed raw payloads materially
-            # slow later feature enrichment for this DRMHB-sized workload.
-            "raw_compression": "none",
-        },
-        # Empty by design: the base AnnData contains raw reusable signals only.
-        "features": [],
-        "obs": {
-            "include": [
-                "snapshot_id",
-                "timestamp",
-                "snap_t",
-                "source",
-                "machine",
-                "speed_hz",
-                "has_waveform",
-                "has_spectrum",
-            ],
-        },
-    }
-
-    output = import_raw_to_h5ad(
+    scope = "none" if args.without_ground_truth else args.ground_truth_scope
+    output = create_base(
         args.vibframe,
         args.output,
-        config=config,
+        scope=scope,
+        dtype=args.dtype,
         block_size_mib=args.block_size_mib,
+        max_sidecar_mib=args.max_sidecar_mib,
+        overwrite=args.overwrite,
     )
-
-    validation = validate_streamed_h5ad(output)
-
-    if int(validation["n_vars"]) != 0:
-        raise RuntimeError("The base AnnData must remain featureless (n_vars = 0).")
-    if not args.without_ground_truth and int(validation["ground_truth_rows"]) != int(
-        validation["n_obs"]
-    ):
-        raise RuntimeError("Ground truth is not aligned one-to-one with observations.")
-
     print(f"Created: {output}")
-    print(f"Observations: {validation['n_obs']:,}")
-    print(f"Variables/features: {validation['n_vars']:,}")
-    print("Expected featureless base: n_vars = 0")
+    for key, value in validate_streamed_h5ad(output).items():
+        print(f"{key}: {value}")
     print(
-        "Ground truth:",
-        "disabled" if args.without_ground_truth else "stored in obsm['ground_truth']",
+        f"File size: {output.stat().st_size / 1024**3:.3f} GiB; ground truth scope: {scope}"
     )
-    print(f"Waveform signals: {validation['waveform_signals']:,}")
-    print(f"Spectrum signals: {validation['spectrum_signals']:,}")
+    print("Evaluation is outside X/obs. block-size-mib is not a total RAM limit.")
 
 
 if __name__ == "__main__":

examples/02_inspect_anndata.py

@@ -1,121 +1,85 @@
 #!/usr/bin/env python3
-"""
-Inspect a DRMHB AnnData generated with vibframe-anndata 0.2.2.
-
-The H5AD is opened in backed read-only mode, so the multi-gigabyte raw signal
-payload is not loaded into RAM.
-
-Install:
-    python -m pip install "vibframe-anndata==0.2.2" "anndata>=0.10,<0.13"
-
-Usage:
-    python examples/02_inspect_anndata.py DRMHB.float32.h5ad
-"""
+"""Inspect HDF5 groups and evaluation metadata without loading raw obsm buffers."""
 
 from __future__ import annotations
 
 import argparse
 from pathlib import Path
-import warnings
-
-import anndata as ad
 
+from drmhb_workflow import check_version, inventory_or_empty, read_metadata
 from vibframe_anndata import (
-    __version__ as vibframe_anndata_version,
+    get_snapshot_ground_truth,
+    get_waveform_ground_truth,
+    read_evaluation_file,
     validate_streamed_h5ad,
 )
 
-EXPECTED_VERSION = "0.2.2"
-
-warnings.filterwarnings(
-    "ignore",
-    message=r"Support for Awkward Arrays is currently experimental.*",
-)
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Inspect a locally generated DRMHB AnnData."
-    )
-    parser.add_argument("h5ad", type=Path, help="Path to a generated DRMHB .h5ad.")
-    return parser.parse_args()
-
 
 def main() -> None:
-    args = parse_args()
-
-    if vibframe_anndata_version != EXPECTED_VERSION:
-        raise RuntimeError(
-            f"This example is validated for vibframe-anndata=={EXPECTED_VERSION}; "
-            f"active version: {vibframe_anndata_version!r}"
-        )
-
-    if not args.h5ad.is_file():
-        raise FileNotFoundError(args.h5ad)
-
-    validation = validate_streamed_h5ad(args.h5ad)
-    print("Streamed-H5AD validation:")
-    for key in (
-        "n_obs",
-        "n_vars",
-        "machines",
-        "ground_truth_rows",
-        "ground_truth_columns",
-        "waveform_signals",
-        "waveform_samples",
-        "spectrum_signals",
-        "spectrum_samples",
-    ):
-        print(f" - {key}: {validation.get(key):,}")
-    print()
-
-    adata = ad.read_h5ad(args.h5ad, backed="r")
-
-    try:
-        print(adata)
-        print()
-        print("X shape:", adata.shape)
-
-        print("\nobs columns:")
-        for column in adata.obs.columns:
-            print(" -", column)
-
-        print("\nobsm keys:")
-        for key in adata.obsm.keys():
-            print(" -", key)
-
-        print("\nuns keys:")
-        for key in adata.uns.keys():
-            print(" -", key)
-
-        print("\nFirst observations:")
-        print(adata.obs.head())
-
-        if "ground_truth" in adata.obsm:
-            gt = adata.obsm["ground_truth"]
-            print("\nGround truth:")
-            print(" - location: obsm['ground_truth']")
-            print(" - shape:", gt.shape)
-            print(" - columns:", ", ".join(map(str, gt.columns)))
-            print(
-                " - note: evaluation-only metadata; do not include it "
-                "automatically in unsupervised model inputs"
-            )
-        else:
-            print(
-                "\nGround truth was not imported. Recreate the H5AD without "
-                "--without-ground-truth if evaluation labels are required."
-            )
-
-        if adata.n_vars == 0:
-            print(
-                "\nThis is a featureless base AnnData. "
-                "Use examples/03_add_features.py to derive features from the "
-                "raw signals already stored in the H5AD."
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("h5ad", type=Path)
+    parser.add_argument(
+        "--waveform-details",
+        action="store_true",
+        help="Decode aligned waveform metadata, not waveform samples",
+    )
+    parser.add_argument(
+        "--verify-hashes",
+        action="store_true",
+        help="Read and hash each annotation file one at a time",
+    )
+    args = parser.parse_args()
+    check_version()
+    report = validate_streamed_h5ad(args.h5ad)
+    for key, value in report.items():
+        print(f"{key}: {value}")
+    meta = read_metadata(args.h5ad)
+    print("\nX shape:", meta["shape"])
+    print("obs columns:", list(meta["obs"].columns))
+    print("obsm keys:", meta["obsm_keys"])
+    print("uns keys:", meta["uns_keys"])
+    print(meta["obs"].head().to_string())
+    if "ground_truth" in meta["obsm_keys"]:
+        truth = get_snapshot_ground_truth(args.h5ad)
+        print("\nSnapshot truth shape:", truth.shape)
+        print("Evaluation columns:", list(truth.columns))
+    if args.waveform_details and "waveform_ground_truth" in meta["obsm_keys"]:
+        wave = get_waveform_ground_truth(args.h5ad)
+        print("\nWaveform truth shape:", wave.shape)
+        if not wave.empty:
+            print(wave["vfta_alignment_status"].value_counts().to_string())
+            cols = [
+                c
+                for c in (
+                    "vfta_snapshot_id",
+                    "point_id",
+                    "waveform_duration_s",
+                    "waveform_start_offset_s",
+                    "vfta_alignment_status",
+                )
+                if c in wave
+            ]
+            print(wave[cols].head().to_string(index=False))
+    inventory = inventory_or_empty(args.h5ad)
+    if not inventory.empty:
+        print("\nArchived original annotations:")
+        print(
+            inventory.groupby("kind").agg(
+                files=("path", "size"), bytes=("size_bytes", "sum")
             )
-    finally:
-        if getattr(adata, "file", None) is not None:
-            adata.file.close()
+        )
+        print(f"Original annotation bytes: {inventory.size_bytes.sum():,}")
+        if args.verify_hashes:
+            for row in inventory.itertuples():
+                read_evaluation_file(
+                    args.h5ad, row.path, source=row.source, verify=True
+                )
+            print("All archived annotation SHA-256 checks passed.")
+    else:
+        print("\nNo complete archive. Use example 04 to enrich an existing H5AD.")
+    print(
+        "\nGround truth is evaluation-only. Archive scope remains dataset-wide after slicing."
+    )
 
 
 if __name__ == "__main__":

examples/03_add_features.py

@@ -1,130 +1,37 @@
 #!/usr/bin/env python3
-"""
-Materialize the compact feature set used by the DRMHB reference EDA.
-
-Validated with:
-    vibframe-anndata==0.2.2
-
-This step works exclusively from raw signals already persisted in the H5AD and
-does not reopen the original VibFrame archive.
-
-Install:
-    python -m pip install "vibframe-anndata==0.2.2"
-
-Usage:
-    python examples/03_add_features.py \
-        derived/DRMHB.float32.h5ad \
-        derived/DRMHB.float32.eda-features.h5ad
-
-Documentation:
-    https://413hq.github.io/vibframe-anndata-docs/latest/
-"""
+"""Materialize the reference EDA features without reopening the VibFrame."""
 
 from __future__ import annotations
 
 import argparse
 from pathlib import Path
 
-from vibframe_anndata import (
-    __version__ as vibframe_anndata_version,
-    add_features_to_h5ad,
-    validate_streamed_h5ad,
-)
-
-EXPECTED_VERSION = "0.2.2"
+from drmhb_workflow import add_reference_features, positive_int
+from vibframe_anndata import validate_streamed_h5ad
 
 
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Add the compact DRMHB EDA feature set to a base AnnData."
-    )
-    parser.add_argument(
-        "source",
-        type=Path,
-        help="Featureless DRMHB .h5ad generated from the VibFrame archive.",
-    )
-    parser.add_argument(
-        "output",
-        type=Path,
-        help="Destination enriched .h5ad.",
-    )
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("source", type=Path)
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--block-rows", type=positive_int, default=256)
     parser.add_argument(
-        "--block-rows",
-        type=int,
-        default=256,
-        help="Observation block size (default: 256).",
+        "--features-config", type=Path, help="Optional package-format YAML"
     )
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-
-    if vibframe_anndata_version != EXPECTED_VERSION:
-        raise RuntimeError(
-            f"This example is validated for vibframe-anndata=={EXPECTED_VERSION}; "
-            f"active version: {vibframe_anndata_version!r}"
-        )
-
-    if not args.source.is_file():
-        raise FileNotFoundError(args.source)
-
-    if args.source.resolve() == args.output.resolve():
-        raise ValueError("Source and output must be different files.")
-
-    args.output.parent.mkdir(parents=True, exist_ok=True)
-
-    source_validation = validate_streamed_h5ad(args.source)
-    if int(source_validation["n_vars"]) != 0:
-        raise RuntimeError(
-            "This example expects the featureless H5AD created by example 01."
-        )
-
-    config = {
-        "version": 1,
-        "output": {"dtype": "float32"},
-        "feature_policy": {
-            "on_conflict": "error",
-            "on_error": "nan",
-        },
-        "features": [
-            {"name": "vel_overall_rms", "source": "spectrum"},
-            {"name": "acc_overall_rms", "source": "spectrum"},
-            {"name": "band_subsync_rms", "source": "spectrum"},
-            {"name": "band_1X_rms", "source": "spectrum"},
-            {"name": "band_harmonics_low_rms", "source": "spectrum"},
-            {"name": "amp_1X", "source": "spectrum"},
-            {"name": "amp_2X", "source": "spectrum"},
-            {"name": "amp_BPFO", "source": "spectrum"},
-            {"name": "amp_BPFI", "source": "spectrum"},
-            {"name": "family_rms_VPF", "source": "spectrum"},
-            {"name": "rms", "source": "waveform"},
-            {"name": "crest_factor", "source": "waveform"},
-            {"name": "kurtosis", "source": "waveform"},
-        ],
-    }
-
-    output = add_features_to_h5ad(
+    parser.add_argument("--overwrite", action="store_true")
+    args = parser.parse_args()
+    output = add_reference_features(
         args.source,
-        config,
-        output=args.output,
+        args.output,
         block_rows=args.block_rows,
+        config=args.features_config,
+        overwrite=args.overwrite,
     )
-
-    validation = validate_streamed_h5ad(output)
-
-    if int(validation["n_vars"]) == 0:
-        raise RuntimeError("Feature materialization produced an empty X matrix.")
-    if int(source_validation.get("ground_truth_rows", 0)):
-        if int(validation["ground_truth_rows"]) != int(validation["n_obs"]):
-            raise RuntimeError("Ground truth was not preserved in the enriched H5AD.")
-
-    print(f"Created: {output}")
-    print(f"Observations: {validation['n_obs']:,}")
-    print(f"Variables/features: {validation['n_vars']:,}")
+    report = validate_streamed_h5ad(output)
+    print(f"Created: {output}\nX shape: ({report['n_obs']}, {report['n_vars']})")
+    print("Raw coverage and archived-annotation identities are unchanged.")
     print(
-        "If ground truth was present in the source base H5AD, it remains "
-        "evaluation metadata rather than an X feature."
+        "Published reference: 468 source/machine-scoped columns, not 468 dense fleet-wide variables."
     )
 
 

examples/04_add_complete_ground_truth.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Enrich an existing H5AD with full annotations without recalculating X or raw arrays."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from drmhb_workflow import enrich_existing, positive_int
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("source", type=Path, help="Existing package-generated H5AD")
+    parser.add_argument(
+        "vibframe", type=Path, help="The original matching VibFrame ZIP/directory"
+    )
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--max-sidecar-mib", type=positive_int, default=512)
+    parser.add_argument("--overwrite", action="store_true")
+    args = parser.parse_args()
+    print("A transactional copy needs about one additional H5AD of free disk space.")
+    result = enrich_existing(
+        args.source,
+        args.vibframe,
+        args.output,
+        max_sidecar_mib=args.max_sidecar_mib,
+        overwrite=args.overwrite,
+    )
+    print(f"Created: {result}")
+    print(
+        "Source identities must match. Legacy capture_t companions are not retroactively added."
+    )
+
+
+if __name__ == "__main__":
+    main()

examples/05_read_evaluation.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""List/read/export original evaluation sidecars directly from H5AD, without raw arrays."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from drmhb_workflow import check_version
+from vibframe_anndata import (
+    export_evaluation_files,
+    list_evaluation_files,
+    read_evaluation_json,
+    read_evaluation_table,
+)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("h5ad", type=Path)
+    parser.add_argument("--path", help="Exact relative path from the inventory")
+    parser.add_argument(
+        "--source", help="Exact source ID; required for ambiguous paths"
+    )
+    parser.add_argument(
+        "--export", type=Path, help="Recover all original sidecars (refuses overwrites)"
+    )
+    args = parser.parse_args()
+    check_version()
+    inventory = list_evaluation_files(args.h5ad)
+    print(inventory[["source", "path", "kind", "size_bytes"]].to_string(index=False))
+    if args.path:
+        if args.path.endswith(".parquet"):
+            table = read_evaluation_table(args.h5ad, args.path, source=args.source)
+            print("\nArrow schema:\n", table.schema)
+            print(table.slice(0, 5).to_pandas().to_string(index=False))
+        elif args.path.endswith(".json"):
+            print(
+                json.dumps(
+                    read_evaluation_json(args.h5ad, args.path, source=args.source),
+                    indent=2,
+                )
+            )
+        else:
+            parser.error(
+                "--path must be .parquet or .json; use export for other byte-exact formats"
+            )
+    if args.export:
+        paths = export_evaluation_files(args.h5ad, args.export, source=args.source)
+        print(
+            f"Exported {len(paths)} original files. Dataset-wide scope, not a relabelled subset."
+        )
+
+
+if __name__ == "__main__":
+    main()

examples/README.md

@@ -1,125 +1,138 @@
-# DRMHB examples
+# DRMHB conversion and evaluation examples
 
-DRMHB is distributed canonically as a VibFrame archive. These scripts show the
-supported local conversion to AnnData, inspection of the result, and subsequent
-feature materialization without reopening the VibFrame.
+Use Python 3.12 and `vibframe-anndata==0.3.0`. Run from the repository root.
+These examples explicitly request complete annotations; the package itself
+keeps ground-truth import disabled by default.
 
-They are validated against:
-
-```text
-vibframe-anndata==0.2.2
+```bash
+python -m pip install -r examples/requirements.txt
+python examples/01_create_featureless_anndata.py data/DRMHB.vibframe.zip derived/DRMHB.v0.3.0.raw.h5ad
+python examples/02_inspect_anndata.py derived/DRMHB.v0.3.0.raw.h5ad --waveform-details
+python examples/03_add_features.py derived/DRMHB.v0.3.0.raw.h5ad derived/DRMHB.v0.3.0.features.h5ad
 ```
 
-Run all commands from the repository root. A small virtual environment is
-recommended:
+## 01 — Import once
 
-```bash
-python -m venv .venv
-source .venv/bin/activate
-python -m pip install "vibframe-anndata==0.2.2" "anndata>=0.10,<0.13"
-```
+Accepts a ZIP or extracted VibFrame. The base is featureless: `X` has zero
+columns; raw waveforms, spectra, tachometers, identities and metadata remain
+available for later features. The default is `float32`, 8 MiB raw blocks,
+`scope=all`, strict missing truth and unchanged uncompressed raw HDF5 arrays.
 
-The examples below write derived files to `derived/`, which is intentionally
-separate from the canonical archive under `data/`.
+`--ground-truth-scope snapshot` selects the legacy footprint; `none` (or
+`--without-ground-truth`) excludes evaluation labels. `--max-sidecar-mib 512`
+limits original encoded sidecars, not total memory. `--block-size-mib` and
+`--dtype` are explicit. Existing destinations require `--overwrite`; inputs
+cannot be used as outputs.
 
-## 1. Create the featureless base AnnData
+No feature is computed from `trends.parquet` or from construction/diagnostic
+labels. The published dataset itself contains no scalar trends.
 
-```bash
-python examples/01_create_featureless_anndata.py \
-    data/DRMHB.vibframe.zip \
-    derived/DRMHB.float32.h5ad
-```
+## 02 — Inspect without loading multi-GiB raw signals
 
-The conversion is streamed and out of core. For the current fixture, validation
-should report:
+The inspector uses `h5py` group metadata, small `obs`/`var`/package metadata and
+public ground-truth accessors. It never calls `anndata.read_h5ad(backed="r")`
+as a blanket out-of-core solution: that mode does not make all `obsm`/`uns`
+objects lazy. `--waveform-details` expands annotations only. `--verify-hashes`
+reads one original annotation file at a time and checks its SHA-256.
 
-- 46,907 observations from 12 machines;
-- zero variables in `X`;
-- 281,442 spectral signals;
-- 140,721 waveform signals;
-- 46,907 rows and 42 columns in `obsm["ground_truth"]`.
+## 03 — Add the reference features
 
-Snapshot-level evaluation truth is imported by default from
-`evaluation/snapshot_truth/` and aligned one-to-one with `obs`:
+The thirteen feature requests remain the same as in the published EDA:
+velocity/acceleration RMS, subsynchronous/1X/low-harmonic bands, 1X/2X/BPFO/BPFI
+amplitudes, VPF-family RMS, and waveform RMS/crest factor/kurtosis.
 
-```python
-adata.obsm["ground_truth"]
-```
+For the reference fleet they materialized 468 machine/source-scoped columns.
+Each machine populates its relevant descriptors; structural NaNs are not zeros.
+The EDA constructs a common logical descriptor matrix without averaging different
+machines. Preserve `var` units, processing mode, point and algorithm/options
+when aligning columns. Do not match columns by short display name alone.
 
-It remains separate from both `X` and `obs`; its presence does not make it a
-valid model input. To create a learning-only representation without evaluation
-truth, add `--without-ground-truth`.
+`--block-rows 256` controls feature block size. `--features-config FILE.yaml`
+accepts an alternative package feature configuration. The original VibFrame
+is not reopened. Dimension counts and original-annotation manifest identities
+are compared before and after feature generation.
 
-The example explicitly uses lossless uncompressed raw arrays:
+## 04 — Upgrade existing H5ADs
 
-```yaml
-output:
-  dtype: float32
-  raw_compression: none
+```bash
+python examples/04_add_complete_ground_truth.py \
+  derived/DRMHB.float32.eda-features.h5ad data/DRMHB.vibframe.zip \
+  derived/DRMHB.v0.3.0.features.h5ad
 ```
 
-This is the package default and is recommended when the same base H5AD will be
-read repeatedly for feature experiments. The validated base occupies about
-9.35 GiB, so allow ample space for both the base and enriched outputs.
+Uses `add_ground_truth_to_h5ad`. It preserves signals and features and creates a
+transactional disk copy. Supply the matching source set and retain `obs.source`,
+`obs.machine` and integer `obs.snap_t`. Roughly one extra H5AD of free disk is
+needed temporarily. Source-name/path collisions must not be repaired by guessing.
+Legacy capture-time companions are not populated retrospectively: reimport raw
+signals to obtain those arrays. Per-waveform crop offsets remain available from
+original and aligned waveform truth.
 
-## 2. Inspect an AnnData without loading raw arrays into RAM
+## 05 — Read originals and DiagGT
 
 ```bash
-python examples/02_inspect_anndata.py \
-    derived/DRMHB.float32.h5ad
+python examples/05_read_evaluation.py derived/DRMHB.v0.3.0.features.h5ad
+python examples/05_read_evaluation.py derived/DRMHB.v0.3.0.features.h5ad \
+  --path ground-truth/observations.parquet
+python examples/05_read_evaluation.py derived/DRMHB.v0.3.0.features.h5ad \
+  --export derived/recovered-evaluation
 ```
 
-The file is opened in backed read-only mode. The script reports:
+Use the exact path from the printed inventory; the layout is not assumed.
+Use `--source SOURCE_ID` when a relative path occurs in several sources.
+`read_evaluation_table()` returns Arrow types; `read_evaluation_json()` returns
+parsed JSON; `read_evaluation_file()` returns the exact original bytes.
+Export refuses overwrites and retains dataset-wide originals, even for a sliced
+AnnData. No implicit DiagGT interval-to-snapshot labelling is performed.
 
-- streamed-H5AD validation counts;
-- `obs`, `obsm` and `uns` structure;
-- feature geometry;
-- the location, shape and columns of aligned ground truth.
+## Complete information and model input
 
-The raw spectra and variable-length waveforms stay on disk during this
-inspection.
+`obsm['ground_truth']` and `obsm['waveform_ground_truth']` follow `obs_names`.
+The byte archive in `uns['vibframe_evaluation']` is dataset-wide. `snap_t` is the
+snapshot key in integer microseconds UTC; raw capture `t` may include a crop
+offset. Waveform bindings include source/machine/point and supplied mode identity.
+Unknown sidecars/fields are retained instead of silently discarded.
 
-## 3. Materialize the reference EDA features
+For normality learning, fit scaling, missing-value rules and models only on
+calibration. Set thresholds on normal holdout. Evaluate on the future stream
+using timestamps. Faults, severities, OOD, nuisance and latent physical state
+are targets/audit fields, not automatic inputs. Declare explicitly any use of
+regime or RPM. Keep a separately generated controls dataset in a separate H5AD;
+controls are not part of the published 2.5.0 longitudinal ZIP.
+
+## Resources and verification
+
+No raw compression settings or VibFrame bytes are changed. Historical 0.2.2
+H5AD sizes are not estimates of the full-annotation 0.3.0 outputs: measure the
+actual results. Metadata decoding also consumes RAM, so the raw block size and
+512 MiB encoded-sidecar budget are not process-memory caps.
+
+Run the small synthetic integration suite with:
 
 ```bash
-python examples/03_add_features.py \
-    derived/DRMHB.float32.h5ad \
-    derived/DRMHB.float32.eda-features.h5ad
+python -m pip install pytest
+python -m pytest tests -q
 ```
 
-This second stage reads only the base H5AD. It does not reopen
-`DRMHB.vibframe.zip`.
-
-The example matches the compact feature catalogue used by the reference EDA:
-
-- spectral: overall velocity and acceleration RMS, subsynchronous, 1X and
-  low-harmonic bands, 1X, 2X, BPFO, BPFI and VPF-family amplitudes;
-- waveform: RMS, crest factor and kurtosis.
-
-Metrics are expanded across applicable machines, channels and processing
-modes. On the current 12-machine fixture this produces `X.shape == (46907,
-468)`. The enriched file retains the raw arrays, observation identity,
-provenance and `obsm["ground_truth"]` from the source.
-
-Choose a new output path or remove an earlier output before rerunning the
-feature example. Source and output must be different files.
-
-## Execution order
-
-```text
-data/DRMHB.vibframe.zip
-        |
-        | 01_create_featureless_anndata.py
-        v
-derived/DRMHB.float32.h5ad              X: (46907, 0)
-        |
-        | 02_inspect_anndata.py          read-only inspection
-        |
-        | 03_add_features.py
-        v
-derived/DRMHB.float32.eda-features.h5ad X: (46907, 468)
+The tests cover ZIP/directory import, complete/legacy/disabled truth, selective
+metadata reads, preservation through feature engineering, retrofit, export and
+CLI safety. They do not regenerate the 180-day campaign.
+
+Package documentation: https://413hq.github.io/vibframe-anndata-docs/0.3.0/
+Ground truth guide: https://413hq.github.io/vibframe-anndata-docs/0.3.0/guides/ground-truth/
+
+## Regression tests
+
+The public scripts have a small deterministic fixture suite. It does not need
+VibSynth or the 8.36 GiB campaign download:
+
+```bash
+python -m pip install -r examples/requirements.txt 'pytest>=8,<10'
+python -m pytest tests -q
 ```
 
-For configuration semantics, supported metrics, compression trade-offs and the
-ground-truth contract, see the
-[`vibframe-anndata` documentation](https://413hq.github.io/vibframe-anndata-docs/latest/).
+It checks ZIP/directory ingestion, all/snapshot/disabled ground truth, exact
+source bytes and large integers, feature and metadata preservation, selective
+inspection, legacy enrichment, CLI exports and the modified notebook's metadata
+and waveform-audit cells. Published EDA image/table hashes are also checked.
+It is not a substitute for executing the full EDA on the complete campaign.

examples/drmhb_workflow.py

@@ -0,0 +1,288 @@
+"""Shared, bounded-raw-memory DRMHB examples for vibframe-anndata 0.3.0.
+
+Evaluation is explicitly requested, never copied into X or obs. Compressed
+VibFrame inputs are not modified. No scalar ground-truth value becomes a feature.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import h5py
+import pandas as pd
+from vibframe_anndata import (
+    __version__,
+    add_features_to_h5ad,
+    add_ground_truth_to_h5ad,
+    get_snapshot_ground_truth,
+    get_waveform_ground_truth,
+    import_raw_to_h5ad,
+    list_evaluation_files,
+    validate_streamed_h5ad,
+)
+
+try:
+    from anndata.io import read_elem
+except ImportError:
+    from anndata.experimental import read_elem
+
+EXPECTED_VERSION = "0.3.0"
+SPECTRAL_FEATURES = (
+    "vel_overall_rms",
+    "acc_overall_rms",
+    "band_subsync_rms",
+    "band_1X_rms",
+    "band_harmonics_low_rms",
+    "amp_1X",
+    "amp_2X",
+    "amp_BPFO",
+    "amp_BPFI",
+    "family_rms_VPF",
+)
+WAVEFORM_FEATURES = ("rms", "crest_factor", "kurtosis")
+REFERENCE_FEATURE_CONFIG = {
+    "version": 1,
+    "output": {"dtype": "float32"},
+    "feature_policy": {"on_conflict": "error", "on_error": "nan"},
+    "features": (
+        [{"name": name, "source": "spectrum"} for name in SPECTRAL_FEATURES]
+        + [{"name": name, "source": "waveform"} for name in WAVEFORM_FEATURES]
+    ),
+}
+
+
+def check_version() -> None:
+    """Pin semantics rather than silently using an untested API version."""
+    if __version__ != EXPECTED_VERSION:
+        raise RuntimeError(
+            f"Install vibframe-anndata=={EXPECTED_VERSION}; found {__version__}"
+        )
+
+
+def positive_int(value: str) -> int:
+    """Reject non-positive block sizes and metadata budgets before opening files."""
+    import argparse
+
+    try:
+        number = int(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("Expected a positive integer") from exc
+    if number <= 0:
+        raise argparse.ArgumentTypeError("Expected a positive integer")
+    return number
+
+
+def prepare_output(output: Path, *inputs: Path, overwrite: bool = False) -> Path:
+    """Prevent accidental clobbering and input/output aliases."""
+    result = output.expanduser().resolve()
+    if result.suffix.lower() != ".h5ad":
+        raise ValueError("Output must have the .h5ad extension")
+    if any(result == item.expanduser().resolve() for item in inputs):
+        raise ValueError("Input and output must be different files")
+    if result.exists() and not overwrite:
+        raise FileExistsError(
+            f"{result} exists; use a new output or --overwrite explicitly"
+        )
+    result.parent.mkdir(parents=True, exist_ok=True)
+    return result
+
+
+def raw_config(
+    *, scope: str = "all", dtype: str = "float32", max_sidecar_mib: int = 512
+) -> dict[str, Any]:
+    """The full annotation contract is opt-in at package level, explicit here."""
+    if scope not in {"all", "snapshot", "none"}:
+        raise ValueError("scope must be all, snapshot or none")
+    if max_sidecar_mib <= 0:
+        raise ValueError("max_sidecar_mib must be positive")
+    return {
+        "version": 1,
+        "raw_import": {"waveforms": True, "spectra": True, "on_missing_signal": "nan"},
+        "ground_truth": {
+            "enabled": scope != "none",
+            "scope": "all" if scope == "none" else scope,
+            "on_missing": "error",
+            "max_sidecar_mib": max_sidecar_mib,
+        },
+        "output": {"dtype": dtype, "raw_compression": "none"},
+        "features": [],
+        "obs": {
+            "include": [
+                "snapshot_id",
+                "timestamp",
+                "snap_t",
+                "source",
+                "machine",
+                "speed_hz",
+                "has_waveform",
+                "has_spectrum",
+            ]
+        },
+    }
+
+
+def read_metadata(path: Path) -> dict[str, Any]:
+    """Read only obs/var and package metadata; do not decode uns or raw obsm wholesale.
+
+    AnnData backed mode is not a promise that obsm/uns stay on disk. In 0.3.0,
+    uns also contains byte buffers for the complete evaluation archive.
+    """
+    with h5py.File(path, "r") as handle:
+        return {
+            "obs": read_elem(handle["obs"]),
+            "var": read_elem(handle["var"]),
+            "uns": {"vibframe_anndata": read_elem(handle["uns"]["vibframe_anndata"])},
+            "shape": tuple(handle["X"].shape),
+            "obsm_keys": list(handle["obsm"].keys()),
+            "uns_keys": list(handle["uns"].keys()),
+        }
+
+
+def inventory_or_empty(path: Path) -> pd.DataFrame:
+    """Absence is explicit; errors in an existing archive must not be swallowed."""
+    with h5py.File(path, "r") as handle:
+        present = "vibframe_evaluation" in handle["uns"]
+    if not present:
+        return pd.DataFrame(columns=["source", "path", "kind", "size_bytes", "sha256"])
+    return list_evaluation_files(path)
+
+
+def require_complete_drmhb(path: Path) -> dict[str, Any]:
+    """Require construction snapshot/waveform truth and originals for DRMHB EDA."""
+    result = validate_streamed_h5ad(path)
+    if result.get("ground_truth_rows", 0) != result["n_obs"]:
+        raise RuntimeError(
+            "No complete snapshot truth; run example 04 or recreate with scope=all"
+        )
+    if result.get("waveform_ground_truth_snapshots", 0) != result["n_obs"]:
+        raise RuntimeError(
+            "No waveform truth; run example 04 or recreate with scope=all"
+        )
+    if result.get("evaluation_files", 0) == 0:
+        raise RuntimeError(
+            "No archived originals; run example 04 or recreate with scope=all"
+        )
+    return result
+
+
+def preservation_signature(path: Path) -> tuple[dict[str, Any], pd.DataFrame]:
+    """Small signature for numerical dimensions and original annotation identities."""
+    report = validate_streamed_h5ad(path)
+    keys = (
+        "n_obs",
+        "waveform_signals",
+        "waveform_samples",
+        "spectrum_signals",
+        "spectrum_samples",
+        "ground_truth_rows",
+        "waveform_ground_truth_snapshots",
+    )
+    counts = {key: report.get(key, 0) for key in keys}
+    files = inventory_or_empty(path)
+    cols = ["source", "path", "size_bytes", "sha256"]
+    return counts, files[cols].sort_values(["source", "path"]).reset_index(drop=True)
+
+
+def assert_preserved(before: tuple, output: Path) -> None:
+    """Check dimensions and lossless archive identity after feature engineering."""
+    after = preservation_signature(output)
+    if before[0] != after[0] or not before[1].equals(after[1]):
+        raise RuntimeError("Signal/annotation coverage or archived originals changed")
+
+
+def create_base(
+    source: Path,
+    output: Path,
+    *,
+    scope: str = "all",
+    dtype: str = "float32",
+    block_size_mib: int = 8,
+    max_sidecar_mib: int = 512,
+    overwrite: bool = False,
+) -> Path:
+    """Import a ZIP or extracted VibFrame with no calculated features."""
+    check_version()
+    if not source.exists():
+        raise FileNotFoundError(source)
+    if block_size_mib <= 0:
+        raise ValueError("block_size_mib must be positive")
+    output = prepare_output(output, source, overwrite=overwrite)
+    result = import_raw_to_h5ad(
+        source,
+        output,
+        config=raw_config(scope=scope, dtype=dtype, max_sidecar_mib=max_sidecar_mib),
+        block_size_mib=block_size_mib,
+    )
+    report = validate_streamed_h5ad(result)
+    if report["n_vars"] != 0:
+        raise RuntimeError("Featureless base must have zero features")
+    if scope == "all":
+        require_complete_drmhb(result)
+    elif scope == "snapshot" and report.get("ground_truth_rows", 0) != report["n_obs"]:
+        raise RuntimeError("Incomplete snapshot annotation coverage")
+    return result
+
+
+def add_reference_features(
+    source: Path,
+    output: Path,
+    *,
+    block_rows: int = 256,
+    config: Any = None,
+    overwrite: bool = False,
+) -> Path:
+    """Compute unchanged reference features; keep raw signals and all annotations."""
+    check_version()
+    output = prepare_output(output, source, overwrite=overwrite)
+    if block_rows <= 0:
+        raise ValueError("block_rows must be positive")
+    if validate_streamed_h5ad(source)["n_vars"] != 0:
+        raise ValueError("This example expects a featureless base")
+    before = preservation_signature(source)
+    result = add_features_to_h5ad(
+        source, config or REFERENCE_FEATURE_CONFIG, output=output, block_rows=block_rows
+    )
+    assert_preserved(before, result)
+    if validate_streamed_h5ad(result)["n_vars"] == 0:
+        raise RuntimeError("Feature calculation returned zero variables")
+    return result
+
+
+def enrich_existing(
+    source: Path,
+    vibframe: Path,
+    output: Path,
+    *,
+    max_sidecar_mib: int = 512,
+    overwrite: bool = False,
+) -> Path:
+    """Add original annotations to a legacy file, without numerical recomputation."""
+    check_version()
+    output = prepare_output(output, source, vibframe, overwrite=overwrite)
+    if not vibframe.exists():
+        raise FileNotFoundError(vibframe)
+    before = validate_streamed_h5ad(source)
+    result = add_ground_truth_to_h5ad(
+        source,
+        vibframe,
+        config=raw_config(max_sidecar_mib=max_sidecar_mib),
+        output=output,
+    )
+    after = require_complete_drmhb(result)
+    for key in (
+        "n_obs",
+        "n_vars",
+        "waveform_signals",
+        "waveform_samples",
+        "spectrum_signals",
+        "spectrum_samples",
+    ):
+        if before.get(key) != after.get(key):
+            raise RuntimeError(f"Existing numerical dimensions changed: {key}")
+    return result
+
+
+def read_truth(path: Path) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Convenience labels are for evaluation; never place these frames in X."""
+    return get_snapshot_ground_truth(path), get_waveform_ground_truth(path)

examples/requirements.txt

@@ -0,0 +1,2 @@
+vibframe-anndata==0.3.0
+h5py>=3.10,<4

notebooks/pyproject.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 description = "EDA environment for the DRMHB dataset."
 requires-python = ">=3.12,<3.13"
 dependencies = [
-    "vibframe-anndata==0.2.2",
+    "vibframe-anndata==0.3.0",
     "anndata>=0.10,<0.13",
     "awkward>=2.5,<3",
     "h5py>=3.10,<4",

tests/conftest.py

@@ -0,0 +1,6 @@
+"""Expose standalone examples during regression testing."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "examples"))

tests/test_workflow.py

@@ -0,0 +1,418 @@
+"""Offline regression fixtures for the public DRMHB workflow, not a new campaign."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import runpy
+import sys
+import zipfile
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pytest
+from drmhb_workflow import (
+    REFERENCE_FEATURE_CONFIG,
+    add_reference_features,
+    create_base,
+    enrich_existing,
+    inventory_or_empty,
+    positive_int,
+    prepare_output,
+    read_metadata,
+    require_complete_drmhb,
+)
+from vibframe_anndata import (
+    get_snapshot_ground_truth,
+    get_waveform_ground_truth,
+    read_evaluation_file,
+    read_evaluation_table,
+    validate_streamed_h5ad,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+
+POINTS = ("pump_DE_H", "pump_DE_V", "pump_DE_A")
+TIMES = (1767225600000000, 1767232800000000)
+CUSTOM_FEATURES = {
+    "version": 1,
+    "output": {"dtype": "float32"},
+    "feature_policy": {"on_error": "nan"},
+    "features": [{"name": "rms", "source": "waveform"}],
+}
+
+
+@pytest.fixture
+def source(tmp_path: Path) -> Path:
+    root = tmp_path / "fixture.vibframe"
+    machine = root / "machine=M01"
+    machine.mkdir(parents=True)
+    (root / "dataset.json").write_text('{"name":"tiny-DRMHB-workflow-fixture"}')
+    (machine / "machine.json").write_text('{"machine":{"id":"M01"}}')
+    (root / "scenario_config.json").write_text(
+        '{"script_version":"test-fixture","not_a_campaign":true}'
+    )
+    waves, spectra, wtruth, truth = [], [], [], []
+    for i, t in enumerate(TIMES):
+        offset_us = (400000, 200000)[i]
+        truth.append(
+            {
+                "machine_id": "M01",
+                "timestamp": t,
+                "split": ("calibration", "future_stream")[i],
+                "regime_id": ("R1", "R2")[i],
+                "is_transition": False,
+                "fault_1_type": (None, "IMBALANCE")[i],
+                "fault_1_severity": i * 0.2,
+                "fault_1_physical_state_json": json.dumps({"damage": i * 0.2}),
+            }
+        )
+        for point in POINTS:
+            samples = np.asarray([i + 1.0, -i - 1.0], dtype=np.float32)
+            common = {
+                "snap_t": t,
+                "point_id": point,
+                "config_id": "cfg0",
+                "speed_hz": 25.0,
+            }
+            waves.append(
+                {
+                    **common,
+                    "t": t + offset_us,
+                    "proc_mode_id": "ACC_10K",
+                    "mode_definition_id": "wave-def",
+                    "unit": "K40",
+                    "signal_family": "acceleration",
+                    "data": samples,
+                    "sample_rate_hz": 1000.0,
+                    "n_samples": 2,
+                    "sync": True,
+                    "tacho_rising": [0.0005],
+                    "tacho_falling": [0.001],
+                }
+            )
+            wtruth.append(
+                {
+                    "machine_id": "M01",
+                    "snap_t": t,
+                    "point_id": point,
+                    "proc_mode_id": "ACC_10K",
+                    "waveform_n_samples": 2,
+                    "waveform_duration_s": 0.002,
+                    "waveform_start_offset_s": offset_us / 1e6,
+                    "stored_sample_rate_hz": 1000.0,
+                    "is_anchor": False,
+                    "waveform_storage_mode": "test_window",
+                    "stored_waveform_sha256": hashlib.sha256(
+                        samples.tobytes()
+                    ).hexdigest(),
+                    "future_nested": [{"value": i + 1}],
+                    "nullable": None,
+                }
+            )
+            for mode, family, unit, fmax in [
+                ("ACC_10K", "acceleration", "K40", 10000.0),
+                ("VEL_1K", "velocity", "C16", 1000.0),
+            ]:
+                spectra.append(
+                    {
+                        **common,
+                        "t": t,
+                        "proc_mode_id": mode,
+                        "mode_definition_id": "spec-" + mode,
+                        "signal_family": family,
+                        "unit": unit,
+                        "data": np.asarray([0.0, 2.0, 1.0], np.float32),
+                        "fmin_hz": 0.0,
+                        "fmax_hz": fmax,
+                        "lines": 3,
+                        "window": "hann",
+                        "averages": 1,
+                        "spectrum_detector": "peak",
+                        "power": False,
+                    }
+                )
+    pd.DataFrame(waves[::-1]).to_parquet(machine / "waves.parquet", index=False)
+    pd.DataFrame(spectra[::-1]).to_parquet(machine / "spectra.parquet", index=False)
+    for family, rows in [("snapshot_truth", truth), ("waveform_truth", wtruth)]:
+        folder = root / "evaluation" / family / "machine=M01"
+        folder.mkdir(parents=True)
+        pd.DataFrame(rows[::-1]).to_parquet(folder / "part.parquet", index=False)
+    diag = root / "ground-truth"
+    diag.mkdir()
+    (diag / "tiny.diaggt.json").write_text(
+        '{"notice":"opaque fixture; not a diagnostic prediction","optional":null}'
+    )
+    (diag / "materialization.json").write_text(
+        '{"policy":"test-original-preservation"}'
+    )
+    table = pa.table(
+        {
+            "large_integer": pa.array([2**60 + 7, None], pa.int64()),
+            "nested": [[{"fault": "bearing"}], None],
+        }
+    )
+    pq.write_table(table, diag / "observations.parquet")
+    return root
+
+
+@pytest.mark.parametrize("zipped", [False, True])
+@pytest.mark.parametrize("scope", ["all", "snapshot", "none"])
+def test_import_scopes_and_archive(tmp_path, source, zipped, scope):
+    incoming = source
+    if zipped:
+        incoming = tmp_path / "fixture.vibframe.zip"
+        with zipfile.ZipFile(incoming, "w") as archive:
+            for file in source.rglob("*"):
+                if file.is_file():
+                    archive.write(
+                        file, source.name + "/" + file.relative_to(source).as_posix()
+                    )
+    output = create_base(
+        incoming, tmp_path / "base.h5ad", scope=scope, block_size_mib=1
+    )
+    meta = read_metadata(output)
+    assert meta["shape"] == (2, 0)
+    assert meta["obs"].snap_t.tolist() == list(TIMES)
+    assert not any(
+        "fault" in column or "severity" in column for column in meta["obs"].columns
+    )
+    inventory = inventory_or_empty(output)
+    assert bool(len(inventory)) == (scope == "all")
+    assert ("ground_truth" in meta["obsm_keys"]) == (scope != "none")
+    if scope == "all":
+        require_complete_drmhb(output)
+        gt = get_snapshot_ground_truth(output)
+        assert gt.index.equals(meta["obs"].index)
+        wave = get_waveform_ground_truth(output)
+        assert len(wave) == 6 and set(wave.vfta_alignment_status) == {"matched"}
+        for row in inventory.itertuples():
+            assert (
+                read_evaluation_file(output, row.path, source=row.source)
+                == (source / row.path).read_bytes()
+            )
+        table = read_evaluation_table(output, "ground-truth/observations.parquet")
+        assert table["large_integer"].to_pylist() == [2**60 + 7, None]
+        with h5py.File(output) as h:
+            actual = h["obsm/raw_waveforms_capture_t"][:]
+            assert np.array_equal(
+                actual,
+                np.array(TIMES)[:, None]
+                + np.array([400000, 200000])[:, None]
+                + np.zeros((2, 3), int),
+            )
+            assert h["obsm/raw_waveforms_capture_t_known"][:].all()
+
+
+def test_features_and_enrichment_preserve_samples_and_labels(tmp_path, source):
+    base = create_base(source, tmp_path / "base.h5ad", scope="none", block_size_mib=1)
+    feature = add_reference_features(
+        base, tmp_path / "features.h5ad", config=CUSTOM_FEATURES, block_rows=1
+    )
+    complete = enrich_existing(feature, source, tmp_path / "complete.h5ad")
+    assert validate_streamed_h5ad(complete)["n_vars"] == 3
+    with h5py.File(feature) as old, h5py.File(complete) as new:
+        np.testing.assert_array_equal(old["X"][:], new["X"][:])
+        for family in ("raw_waveforms", "raw_spectra"):
+            np.testing.assert_array_equal(
+                old[f"obsm/{family}/node2-data"][:], new[f"obsm/{family}/node2-data"][:]
+            )
+    fullbase = create_base(source, tmp_path / "fullbase.h5ad", block_size_mib=1)
+    fullfeat = add_reference_features(
+        fullbase, tmp_path / "fullfeat.h5ad", config=CUSTOM_FEATURES, block_rows=1
+    )
+    pd.testing.assert_frame_equal(
+        get_snapshot_ground_truth(fullbase), get_snapshot_ground_truth(fullfeat)
+    )
+    pd.testing.assert_frame_equal(
+        inventory_or_empty(fullbase), inventory_or_empty(fullfeat)
+    )
+    with h5py.File(fullfeat) as h:
+        np.testing.assert_allclose(h["X"][:], [[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]])
+
+
+@pytest.mark.parametrize("scope", ["all", "snapshot", "none"])
+def test_inspector_does_not_read_raw_buffers(
+    tmp_path, source, scope, monkeypatch, capsys
+):
+    path = create_base(source, tmp_path / "inspect.h5ad", scope=scope, block_size_mib=1)
+    original = h5py.Dataset.__getitem__
+
+    def guarded(self, key):
+        if "/raw_waveforms/" in self.name or "/raw_spectra/" in self.name:
+            if self.name.endswith("node2-data"):
+                raise AssertionError(f"Read of raw sample payload: {self.name}")
+        return original(self, key)
+
+    monkeypatch.setattr(h5py.Dataset, "__getitem__", guarded)
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        ["02_inspect_anndata.py", str(path), "--waveform-details", "--verify-hashes"],
+    )
+    runpy.run_path(str(ROOT / "examples/02_inspect_anndata.py"), run_name="__main__")
+    assert "X shape: (2, 0)" in capsys.readouterr().out
+
+
+@pytest.mark.parametrize(
+    "number",
+    [
+        "01_create_featureless_anndata.py",
+        "02_inspect_anndata.py",
+        "03_add_features.py",
+        "04_add_complete_ground_truth.py",
+        "05_read_evaluation.py",
+    ],
+)
+def test_help(number, monkeypatch):
+    monkeypatch.setattr(sys, "argv", [number, "--help"])
+    with pytest.raises(SystemExit) as exc:
+        runpy.run_path(str(ROOT / "examples" / number), run_name="__main__")
+    assert exc.value.code == 0
+
+
+def test_safety_guards(tmp_path, source):
+    output = create_base(source, tmp_path / "base.h5ad", block_size_mib=1)
+    old_hash = hashlib.sha256(output.read_bytes()).hexdigest()
+    with pytest.raises(FileExistsError):
+        create_base(source, output)
+    with pytest.raises(ValueError, match="different"):
+        prepare_output(output, output, overwrite=True)
+    with pytest.raises(ValueError, match="positive"):
+        create_base(source, tmp_path / "other.h5ad", block_size_mib=0)
+    with pytest.raises(ValueError, match="positive"):
+        add_reference_features(output, tmp_path / "other.h5ad", block_rows=0)
+    assert old_hash == hashlib.sha256(output.read_bytes()).hexdigest()
+
+
+@pytest.mark.parametrize("bad", ["0", "-1", "zero", "0.5"])
+def test_positive_int(bad):
+    import argparse
+
+    with pytest.raises(argparse.ArgumentTypeError):
+        positive_int(bad)
+
+
+def test_reference_requests_unchanged():
+    assert [x["name"] for x in REFERENCE_FEATURE_CONFIG["features"]] == [
+        "vel_overall_rms",
+        "acc_overall_rms",
+        "band_subsync_rms",
+        "band_1X_rms",
+        "band_harmonics_low_rms",
+        "amp_1X",
+        "amp_2X",
+        "amp_BPFO",
+        "amp_BPFI",
+        "family_rms_VPF",
+        "rms",
+        "crest_factor",
+        "kurtosis",
+    ]
+
+
+def test_notebook_code_and_archived_evidence():
+    notebook = json.loads((ROOT / "notebooks/DRMHB_EDA.ipynb").read_text())
+    for i, cell in enumerate(notebook["cells"]):
+        if cell["cell_type"] == "code":
+            code = "".join(cell["source"])
+            compile(code, f"EDA-cell-{i}", "exec")
+            assert cell.get("outputs", []) == []
+            assert cell.get("execution_count") is None
+    archived = ROOT / "notebooks/reference/DRMHB_EDA_published_2_5_0.ipynb"
+    assert (
+        hashlib.sha256(archived.read_bytes()).hexdigest()
+        == "39b66eec8427fc1b6b8a5a48b09278a167dd976ea9acaec1122821853d237fad"
+    )
+    manifest = json.loads((ROOT / "docs/provenance/eda_assets.json").read_text())
+    assert len([a for a in manifest["assets"] if a["kind"] == "figure"]) == 37
+    for asset in manifest["assets"]:
+        path = ROOT / asset["path"]
+        assert hashlib.sha256(path.read_bytes()).hexdigest() == asset["sha256"]
+
+
+def test_notebook_metadata_and_waveform_audit_cells(tmp_path, source):
+    """Execute the modified EDA joins/audit, independently of full-campaign models."""
+    path = source / "machine=M01/waves.parquet"
+    frame = pd.read_parquet(path)
+    frame["data"] = [
+        np.tile(np.asarray([1.0, -1.0], np.float32), 250) for _ in range(len(frame))
+    ]
+    frame["n_samples"] = 500
+    frame.to_parquet(path, index=False)
+    path = source / "evaluation/waveform_truth/machine=M01/part.parquet"
+    frame = pd.read_parquet(path)
+    frame["waveform_n_samples"] = 500
+    frame["waveform_duration_s"] = 0.5
+    frame.to_parquet(path, index=False)
+    path = source / "evaluation/snapshot_truth/machine=M01/part.parquet"
+    frame = pd.read_parquet(path)
+    frame["acquisition_kind"] = "steady"
+    frame["local_transient"] = False
+    frame["electromechanical_transient"] = False
+    frame.to_parquet(path, index=False)
+    output = create_base(source, tmp_path / "eda.h5ad", block_size_mib=1)
+    from vibframe_anndata import list_evaluation_files, read_evaluation_json
+
+    environment = dict(
+        Path=Path,
+        json=json,
+        np=np,
+        pd=pd,
+        h5py=h5py,
+        read_metadata=read_metadata,
+        get_snapshot_ground_truth=get_snapshot_ground_truth,
+        get_waveform_ground_truth=get_waveform_ground_truth,
+        list_evaluation_files=list_evaluation_files,
+        read_evaluation_json=read_evaluation_json,
+        display=lambda *_: None,
+        SOURCE_H5AD=output,
+    )
+    notebook = json.loads((ROOT / "notebooks/DRMHB_EDA.ipynb").read_text())
+    for i in (8, 11):
+        exec(
+            compile("".join(notebook["cells"][i]["source"]), f"EDA-cell-{i}", "exec"),
+            environment,
+        )
+    assert environment["waveform_audit"]["storage_mode"].tolist() == ["test_window"] * 2
+    np.testing.assert_allclose(environment["waveform_audit"]["duration_s"], 0.5)
+
+
+def test_original_reader_and_safe_export_cli(tmp_path, source, monkeypatch, capsys):
+    output = create_base(source, tmp_path / "base.h5ad", block_size_mib=1)
+    script = ROOT / "examples/05_read_evaluation.py"
+    monkeypatch.setattr(
+        sys, "argv", [str(script), str(output), "--path", "scenario_config.json"]
+    )
+    runpy.run_path(str(script), run_name="__main__")
+    assert "test-fixture" in capsys.readouterr().out
+    monkeypatch.setattr(
+        sys, "argv", [str(script), str(output), "--export", str(tmp_path / "export")]
+    )
+    runpy.run_path(str(script), run_name="__main__")
+    files = list((tmp_path / "export").glob("*/scenario_config.json"))
+    assert (
+        len(files) == 1
+        and files[0].read_bytes() == (source / "scenario_config.json").read_bytes()
+    )
+    with pytest.raises(FileExistsError):
+        runpy.run_path(str(script), run_name="__main__")
+
+
+def test_retrofit_preserves_legacy_absent_capture_companions(tmp_path, source):
+    legacy = create_base(
+        source, tmp_path / "legacy.h5ad", scope="snapshot", block_size_mib=1
+    )
+    with h5py.File(legacy, "r+") as h:
+        for family in ("waveforms", "spectra"):
+            del h[f"obsm/raw_{family}_capture_t"]
+            del h[f"obsm/raw_{family}_capture_t_known"]
+    result = enrich_existing(legacy, source, tmp_path / "enriched.h5ad")
+    require_complete_drmhb(result)
+    with h5py.File(result) as h:
+        assert "raw_waveforms_capture_t" not in h["obsm"]
+        assert "raw_spectra_capture_t" not in h["obsm"]

tools/build_report.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Build the self-contained English report, without executing the EDA notebook."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+def check_assets(docs: Path) -> None:
+    """Fail before TeX if a referenced archived figure or diagram is absent."""
+    text = (docs / "DRMHB.tex").read_text(encoding="utf-8")
+    paths = [docs / "anndata_workflow.tex", docs / "figures/skeleton.png"]
+    for slug in re.findall(r"\\edaplot\{[^}]+\}\{([^}]+)\}", text):
+        base = docs / "figures/eda" / slug
+        if not any(base.with_suffix(ext).is_file() for ext in (".pdf", ".png")):
+            raise FileNotFoundError(f"EDA figure not found: {base}")
+    sources = text + (docs / "anndata_workflow.tex").read_text(encoding="utf-8")
+    paths += [docs / item for item in re.findall(r"\\input\{([^}]+)\}", sources)]
+    for path in paths:
+        if not path.is_file():
+            raise FileNotFoundError(path)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, help="Default: docs/DRMHB.pdf")
+    parser.add_argument(
+        "--build-dir", type=Path, help="Keep TeX logs/auxiliary files here"
+    )
+    args = parser.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    docs = root / "docs"
+    output = (args.output or docs / "DRMHB.pdf").resolve()
+    if output.suffix.lower() != ".pdf":
+        parser.error("--output must be a PDF path")
+    if not shutil.which("latexmk") or not shutil.which("pdflatex"):
+        raise SystemExit(
+            "Install latexmk and a TeX distribution including TikZ and the packages in docs/DRMHB.tex"
+        )
+    check_assets(docs)
+    with tempfile.TemporaryDirectory(prefix="drmhb-report-") as temp:
+        build = args.build_dir.resolve() if args.build_dir else Path(temp)
+        build.mkdir(parents=True, exist_ok=True)
+        command = [
+            "latexmk",
+            "-pdf",
+            "-interaction=nonstopmode",
+            "-halt-on-error",
+            "-file-line-error",
+            f"-outdir={build}",
+            "DRMHB.tex",
+        ]
+        run = subprocess.run(
+            command,
+            cwd=docs,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            check=False,
+        )
+        (build / "build.log").write_text(run.stdout, encoding="utf-8")
+        print(run.stdout[-4000:])
+        if run.returncode:
+            raise SystemExit(f"LaTeX failed ({run.returncode}); log directory: {build}")
+        log = (build / "DRMHB.log").read_text(encoding="utf-8", errors="replace")
+        summary = {
+            "engine": "pdflatex",
+            "eda_executed": False,
+            "overfull_boxes": re.findall(r"Overfull[^\n]+", log),
+            "unresolved_references": "There were undefined references" in log,
+            "source": "docs/DRMHB.tex",
+        }
+        (build / "build_summary.json").write_text(json.dumps(summary, indent=2) + "\n")
+        if summary["overfull_boxes"] or summary["unresolved_references"]:
+            raise SystemExit(
+                f"Layout/reference errors remain; see {build / 'build_summary.json'}"
+            )
+        output.parent.mkdir(parents=True, exist_ok=True)
+        staged = output.with_name(output.name + ".tmp")
+        shutil.copy2(build / "DRMHB.pdf", staged)
+        staged.replace(output)
+        print(f"Report: {output} ({output.stat().st_size:,} bytes)")
+
+
+if __name__ == "__main__":
+    main()

tools/recover_reference_assets.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""Recover document assets from the immutable executed EDA, without rerunning models.
+
+The manifest binds every image/table to its cell/output and byte hash. Figures
+are the original embedded PNG bytes, not recreated or statistically altered.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import hashlib
+import json
+import re
+from pathlib import Path
+
+
+def recover(root: Path) -> dict:
+    notebook = root / "notebooks/reference/DRMHB_EDA_published_2_5_0.ipynb"
+    nb = json.loads(notebook.read_text(encoding="utf-8"))
+    target = root / "docs/figures/eda"
+    target.mkdir(parents=True, exist_ok=True)
+    entries = []
+    for index, cell in enumerate(nb["cells"]):
+        source = "".join(cell.get("source", []))
+        if "publish_figure(" not in source or "def publish_figure" in source:
+            continue
+        names = re.findall(r'publish_figure\(fig,\s*"([^"]+)"', source)
+        if index == 29:
+            names = [
+                f"transition_portrait_off_r{regime}_{variable}"
+                for variable in ("flow", "load")
+                for regime in (1, 2, 3)
+            ]
+        elif index == 58:
+            names = [
+                f"fault_chronology_{fault}"
+                for fault in (
+                    "bearing_inner",
+                    "bearing_outer",
+                    "imbalance",
+                    "looseness",
+                    "misalignment_angular",
+                    "resonance",
+                )
+            ]
+        outputs = [
+            (i, item)
+            for i, item in enumerate(cell.get("outputs", []))
+            if "image/png" in item.get("data", {})
+        ]
+        if len(names) != len(outputs):
+            raise RuntimeError(
+                f"Cell {index}: {len(names)} names for {len(outputs)} plots"
+            )
+        for name, (output_index, output) in zip(names, outputs):
+            encoded = output["data"]["image/png"]
+            payload = base64.b64decode(
+                "".join(encoded) if isinstance(encoded, list) else encoded
+            )
+            path = target / f"{name}.png"
+            path.write_bytes(payload)
+            entries.append(
+                {
+                    "slug": name,
+                    "kind": "figure",
+                    "path": str(path.relative_to(root)),
+                    "cell_index": index,
+                    "output_index": output_index,
+                    "execution_count": cell.get("execution_count"),
+                    "sha256": hashlib.sha256(payload).hexdigest(),
+                    "format": "original embedded PNG",
+                }
+            )
+    for index, name in [(77, "baseline_ml_summary"), (78, "baseline_detection_delay")]:
+        cell = nb["cells"][index]
+        output = "".join(
+            "".join(item.get("text", [])) for item in cell.get("outputs", [])
+        )
+        match = re.search(r"\\begin\{table\}.*?\\end\{table\}", output, re.S)
+        if match is None:
+            raise RuntimeError(f"No original LaTeX table in cell {index}")
+        original = root / "docs/provenance" / f"{name}.original.tex"
+        original.parent.mkdir(parents=True, exist_ok=True)
+        original.write_text(match.group(0) + "\n", encoding="utf-8")
+        # Only presentation changes: sizes/centering/line breaks. Numeric tokens unchanged.
+        text = match.group(0).replace("[htbp]", "[H]")
+        text = text.replace(
+            r"\begin{table}[H]",
+            r"\begin{table}[H]" + "\n" + r"\centering\small\setlength{\tabcolsep}{4pt}",
+        )
+        if name == "baseline_ml_summary":
+            text = text.replace("Healthy FPR [\\%]", r"\shortstack{Healthy\\FPR [\%]}")
+            text = text.replace(
+                "Transition FPR [\\%]", r"\shortstack{Transition\\FPR [\%]}"
+            )
+            text = text.replace("OOD FPR [\\%]", r"\shortstack{OOD\\FPR [\%]}")
+            text = text.replace("Median delay [d]", r"\shortstack{Median\\delay [d]}")
+        path = root / "docs" / f"{name}.tex"
+        path.write_text(text + "\n", encoding="utf-8")
+        entries.append(
+            {
+                "slug": name,
+                "kind": "table",
+                "cell_index": index,
+                "execution_count": cell.get("execution_count"),
+                "path": str(path.relative_to(root)),
+                "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
+                "original_sha256": hashlib.sha256(original.read_bytes()).hexdigest(),
+                "format": "original printed LaTeX table; layout-only formatting",
+            }
+        )
+    manifest = {
+        "repo_id": "AlejandroGZ/DRMHB",
+        "source_revision": "d218f6e1dc7505d7c92c0b23fc1d27808a26c107",
+        "dataset_generator_version": "2.5.0",
+        "executed_conversion_version": "0.2.2",
+        "notebook": str(notebook.relative_to(root)),
+        "notebook_sha256": hashlib.sha256(notebook.read_bytes()).hexdigest(),
+        "recomputed": False,
+        "assets": entries,
+    }
+    (root / "docs/provenance/eda_assets.json").write_text(
+        json.dumps(manifest, indent=2) + "\n"
+    )
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--root", type=Path, default=Path(__file__).resolve().parents[1]
+    )
+    args = parser.parse_args()
+    print(json.dumps({"recovered_assets": len(recover(args.root)["assets"])}, indent=2))
+
+
+if __name__ == "__main__":
+    main()