Datasets:

ppak10
/

Agentic-SLS-ASTM

	# CLAUDE.md

	Context for continuing work on this dataset. Captures the design decisions and conventions worked out so far.

	## What this dataset is

	`Agentic-SLS-ASTM` is the ML-facing mechanical-test dataset: one row per ASTM specimen (D638 tensile, D790 flex), with the mechanical response (curves + scalars) and the printer state that produced the part embedded inline as a snapshot. Domain-aligned with `Agentic-SLS-Database`, which is the canonical graph of printer entities.

	Default to embedding snapshots over relying on cross-joins — consumers training models should be able to load this one config and have everything they need on each row.

	## Open notes (as of 2026-06-24)

	The dataset grew faster than the docs. Some of the architectural claims below
	are now drifting from reality — flagging here so future-you doesn't trust
	this file uncritically.

	- Specimen counts in the README and "Current state" section below are stale. Real counts as of 2026-06-24: 38 D638 + 32 D790 = 70 specimens, across 9 scripts. Includes a new PA12GF_FL Formlabs PA12 GF control series (5 tensile + 5 flex, from `2026_06_16/`). The README configs table still claims `22 SLS + 3 PLA + 3 PETG = 28` for D638.
	- `batch_label` no longer cleanly identifies a print run. Batch D (5 D638, tested 6/08) and Batch E (5 D638, tested 6/10) come from the same 2026-06-07 print job — so `batch_label` is now closer to "test cohort" than "print batch identity". This contradicts the architectural decision below. Pick a side: either rename to `test_cohort` and update docs, or split E off and use a different scheme to encode "tested twice from same print".
	- Missing flex script for 2026-06-08. `source/2026_06_08/TST2.Test/` has 6 TestRun folders + `flex_testing_6.8.xlsx`, but only the TST1.Test tensile side is wired up in `04_2026_06_08_tensile.py`. Needs a paired `04_2026_06_08_flex.py` (or similar).
	- Numbering collision in `scripts/specimens/`. Two scripts share the `04_` prefix (`04_2026_06_08_tensile.py` and `04_2026_06_10_tensile.py`). Harmless functionally; the ordering convention from earlier in this file no longer holds.
	- Backfilling-Batch-E recipe below is wrong now. The Batch E in D638 is no longer the orphan-print case (it has FKs from the 2026-06-07 print). Only D790 Batch E is still the "print not in Database" case. The recipe needs to be re-scoped to "D790 Batch E only".
	- `notes` field on rows is new (see `_lib.py:223`). Currently only the Formlabs tensile session sets it ("Printed vertically."); other rows get empty string. Not documented in the "Row shape" section below.
	- PA12GF_FL material class is new and not documented. `material_class` enum below mentions only SLS/PLA/PETG; `PA12GF_FL` (Formlabs PA12 GF reference prints) should be added.

	The figures in `assets/` were regenerated and do reflect the current data — the Formlabs PA12 GF reference in particular reveals that the Inova Mk1 SLS specimens hit only ~10 MPa tensile vs Formlabs PA12 GF's ~25 MPa for the same nominal material, which is the comparison study these controls were added to enable. (Note: the plots section below has since been rewritten — the old overlaid "composite" figures were replaced by the batch-cluster overview + per-batch detail figures; see the `scripts/plots/` decision.)

	## Ecosystem

	- Upstream graph dataset: `ppak10/Agentic-SLS-Database` — canonical print jobs, sessions, profiles, objects (see its CLAUDE.md). This dataset reads `Agentic-SLS-Database/data/jobs.jsonl` and `Agentic-SLS-Database/source/PrintProfiles/*.json` directly via a sibling-folder relative path (both repos live side by side under the recorder repo's `datasets/` as submodules).
	- Sibling domain dataset: `Agentic-SLS-Telemetry` — 10 Hz build telemetry.
	- Raw mechanical-test source: TestWorks 4.1 (MTS Insight EM Tension / 3-pt Flex) — per-session folders dropped under `source/{YYYY_MM_DD}/`. LFS-tracked.

	## Architectural decisions

	- One row per specimen. Granularity = a single TestRun. `specimen_id` (= `"{session_folder}/TSR{n}"`, or `"{session_folder}/{test_folder}/TSR{n}"` when a session_folder holds more than one Test project — see Batch H/I tensile) is the path-style unique key; `sample_id` (= `"{batch_label}{seq}"`, e.g. `"C7"`) is the human-friendly handle.
	- One HF config per ASTM standard. Tensile (D638) and flex (D790) live in `data/D638.jsonl` and `data/D790.jsonl` and load as separate configs (`load_dataset("ppak10/Agentic-SLS-ASTM", "D790")`). The schema is identical across configs; only the `astm.standard` value and the metric coverage differ.
	- Snapshot + reference for SLS rows. Each SLS row carries both the FK ids (`job_id`, `print_profile_id`, `object_hash`) AND the full `print_profile_snapshot` JSON. The PrintProfile is the load-bearing feature set for ML; the job snapshot is not embedded (job_id is enough — consumers can join if they need the full job metadata).
	- Batch labels are a property of the print batch, not the test session. `batch_label` (A through I so far) identifies the print run the specimen came from, so the same batch can appear in both configs (e.g. Batch C produced both tensile and flex specimens from the same 06/02 print). `sample_id` numbering is per-config-per-batch, so `C1` in D638 ≠ `C1` in D790 (different physical specimens, same batch).
	- PLA / PETG / FormLabs control rows live alongside SLS rows in each config. They carry the same mechanical-result fields with `material_class != "SLS"`, null Database FKs, and null `sample_id`/`batch_label` (they didn't come from an SLS print batch). They're benchtop comparison material printed elsewhere and tested on the same Instron.
	- One script per source session folder, plus a shared `_lib.py`. Each `scripts/specimens/{NN}_.py` declares one `SESSION` dict (session_folder, xlsx_name, astm, batch_label, test_runs) and calls `_lib.process_session(SESSION)`. Reader/joiner/builder logic lives in `_lib.py`. Auto-inference of "test the day after print" is not* safe — 2026-06-10 mixes 3 materials in one session and Batch C flex was tested 8 days after print, so the session→print-job mapping has to be declared per script.
	- A session_folder can hold more than one Test project. Batch H and I tensile were both run under `source/2026_06_30/Tensile/`, as `TST1.Test` and `TST2.Test` respectively (confirmed by matching each project's `persistent.h5` Modulus values against its xlsx export sheet-by-sheet, since neither the TestRun.Traits names nor xlsx sheet names disambiguate them). Two scripts, same `session_folder`, different `test_folder` + `batch_label` + `xlsx_name`.
	- `xlsx_only` sessions for specimens whose raw h5 didn't survive. Batch H's 5 flex specimens (`2026_06_30/Flex 6-30/`) have no matching TestRuns folder — it looks like TestWorks overwrote it when the Batch I project reused the same default `TST1.Test` name in the same directory. `_lib.build_row_from_xlsx` (used when a `SESSION` dict sets `"xlsx_only": True`) reads the raw load/extension curve straight from xlsx cols A-B and whatever scalar metrics that export happened to include, converting units via `convert_unit()`. Curves/metrics not present in that export (full strain/stress arrays, modulus, yield — they need the support span) stay null/empty rather than being approximated. Prefer fixing the underlying data (re-export from TestWorks) over reusing this path if it happens again; it's a fallback, not the default.
	- `notes` is a free-text per-row field for exceptions that don't fit elsewhere in the schema (e.g. "printed vertically" for FormLabs, or the xlsx-only sourcing caveat for Batch H flex). Empty string when there's nothing to flag.
	- One JSONL file per specimen. Outputs land under `data/{standard}/{sample_id}.jsonl` (or `data/D638/{material_class}_TSR{n}.jsonl` for non-SLS controls without a sample_id). HF configs glob these via `path: data/D638/*.jsonl`. This keeps git diffs scoped to a single specimen when a row is regenerated and makes it easy to delete or replace individual rows.
	- Domain dependencies, not stdlib-only. Unlike `Agentic-SLS-Database` (stdlib only), the ETL here needs `h5py`, `openpyxl`, `matplotlib`, and `numpy` (the latter two for `scripts/plots/`). They're declared in `pyproject.toml`. Python 3.13.
	- `scripts/plots/` follows the same shared-lib pattern as `scripts/specimens/`. `_lib.py` holds the house style (`apply_house_style()`/`style_axes()`/`save_figure()` — DM Sans from `scripts/plots/fonts/`, framed heavy spines, inward ticks, light dashed grid, dual PNG@1200 + PDF export; ported from the [`AdditiveLLM2-OA`](https://huggingface.co/datasets/ppak10/AdditiveLLM2-OA) figures), the palette (`BATCH_COLORS` = an ordered orange ramp gold→deep-brown built around `ACCENT`=`#F97415`, sampled per print chronology from `ORDERED_BATCHES`; `FORMLABS_COLOR` = contrasting blue for the PA12GF reference so it reads as the external benchmark; `MATERIAL_COLORS` for the other controls), and the shared `load_specimen`/`load_standard` readers. Four plot scripts:
	- `01_controls.py` — the broken-out PLA/PETG, FormLabs Nylon 12 White, and Batch M Type IV figures (materials/geometries that don't belong on the batch comparison; `render_type_iv` lives here).
	- `02_batch_averages.py` — per-batch mean ± 1 SD bands (SLS + FormLabs PA12GF). Each specimen is trimmed at its stress peak in `group_average` before interpolation so the fracture branch doesn't spike the band (this superseded the old per-Nylon `truncate_at_peak` special-case — it's now universal). `render_bands()`/`grouped_specs()` also target a single group for the Nylon 12 White `{standard}_nylon12white_average.png`.
	- `03_batch_clusters.py` — the canonical across-batch overview (replaced the old overlaid composite, which was unreadable at 76–80 curves). One peak point per specimen `(strain@peak, ultimate strength)` — peak = `max(stress)` over the saved curve, robust to TestWorks' null `PeakStress` — with a covariance-based ±1 SD confidence ellipse per batch (`confidence_ellipse`; groups with n<3 draw a segment/marker instead).
	- `04_batch_details.py` — one uncluttered stress-strain figure per batch under `assets/batches/{standard}_{batch}.png`, each specimen individually colored (tab10) and `sample_id`-keyed, for reading a single batch's curves without cross-batch clutter.

	## Directory layout

	```
	source/
	{YYYY_MM_DD}/ # one folder per test date
	[sublabel/] # e.g. "Tensile Testing", "Batch C 3pt test"
	*.tsproj # TestWorks project pointer
	*.xlsx # human-readable export, one sheet per TSR
	TST1.Test/
	TestRuns/TSR{n}.TestRun/
	Data/DaqTaskActivity1.h5 # raw DAQ scans (10 Hz): ext_m, load_N, time_s
	AnalysisRuns/ANR1.AnalysisRun/
	persistent.h5 # analyzed scalars + StressArray/StrainArray
	TestRun.Traits # small XML — Name, Date, UniqueId
	TestRun.1.Traits # ~20k lines, mostly base64 .NET ExecutionState — SKIP

	scripts/specimens/
	_lib.py # shared readers, Database lookup, build_row(_from_xlsx), process_session
	01_2026_05_26.py # Batch A tensile
	02_2026_06_01.py # Batch B tensile
	03_2026_06_03.py # Batch C tensile
	04_2026_06_08_tensile.py # Batch D tensile
	04_2026_06_10_tensile.py # Batch E tensile + PLA/PETG controls
	05_2026_06_10_batch_c.py # Batch C flex
	06_2026_06_10_batch_d.py # Batch D flex
	07_2026_06_10_batch_e.py # Batch E flex (no Database FK yet)
	08_2026_06_16_tensile_formlabs.py # FormLabs PA12GF tensile control
	09_2026_06_16_flex_formlabs.py # FormLabs PA12GF flex control
	10_2026_06_25_tensile.py # Batch F tensile
	11_2026_06_25_flex.py # Batch F flex
	12_2026_06_26_tensile.py # Batch G tensile
	13_2026_06_26_flex.py # Batch G flex
	14_2026_06_30_tensile_h.py # Batch H tensile (TST1.Test)
	15_2026_06_30_tensile_i.py # Batch I tensile (TST2.Test, same session_folder as H)
	16_2026_06_30_flex_i.py # Batch I flex
	17_2026_06_30_flex_h.py # Batch H flex — xlsx_only, no TestRuns folder
	18_2026_07_06_tensile_j.py # Batch J tensile (not media blasted)
	19_2026_07_06_flex_j.py # Batch J flex (not media blasted)
	20_2026_07_08_tensile_j_mb.py # Batch J_MB tensile (media blasted, same print as J)
	21_2026_07_08_flex_j_mb.py # Batch J_MB flex (media blasted, same print as J)
	22_2026_07_15_tensile_k.py # Batch K tensile — xlsx_only, no h5 handed off
	23_2026_07_15_tensile_l.py # Batch L tensile — xlsx_only
	24_2026_07_15_flex_k.py # Batch K flex — xlsx_only
	25_2026_07_15_flex_l.py # Batch L flex — xlsx_only
	26_2026_07_21_tensile_m.py # Batch M tensile, Type I (M1-M5) — xlsx_only
	27_2026_07_21_tensile_m_type4.py # Batch M tensile, Type IV (M6-M17, seq_start=5) — xlsx_only
	28_2026_07_21_flex_m.py # Batch M flex — xlsx_only
	29_2026_07_23_tensile_n.py # Batch N tensile — xlsx_only
	30_2026_07_23_flex_n.py # Batch N flex — xlsx_only
	31_2026_07_23_tensile_nylon12white_fl.py # FormLabs Nylon 12 White tensile control — xlsx_only
	32_2026_07_23_flex_nylon12white_fl.py # FormLabs Nylon 12 White flex control — xlsx_only

	data/
	D638/ # one JSONL per specimen (HF glob: data/D638/*.jsonl)
	A1.jsonl ... N5.jsonl # SLS specimens, named by sample_id
	PLA_TSR6.jsonl ... NYLON12_WHITE_FL_Sheet5.jsonl # non-SLS controls (no sample_id)
	D790/
	C1.jsonl ... N5.jsonl # SLS specimens, named by sample_id
	```

	## File format notes — TestWorks 4.1 output

	- `Data/DaqTaskActivity1.h5`: HDF5 with one `Session{16-digit}` group. `Scans` is `(N, 3) float64` of `[extension_m, load_N, time_s]` per the `Signals` dataset. `Triggers` records DAQ config (sample rate is in there as e.g. `Frequency=10`).
	- `AnalysisRuns/ANR1.AnalysisRun/persistent.h5`: HDF5 with a single dataset `Values` of shape `(1,)` containing a giant compound record. All scalar metrics (Modulus, PeakStress, StressAtBreak, Yield, Slope, etc.) are `<f8` fields; stress-strain curves are `object`-dtype fields (`StressArray`, `StrainArray`, `_TimeArray`, etc.) that decode to variable-length numpy arrays.
	- xlsx export: cols A-B = curve, row 1 = TestRun name, row 2 = units, cols D-I = `(DisplayName, Value, Unit, Reset Value, Original Value, Description)` per scalar metric. Specimen `Width` and `Thickness` only live here — not in any tidy field in the h5 files (the h5 only has the derived `Area` and `AdjGage`).
	- `TestRun.1.Traits` and `Test.1.Traits` etc. are mostly opaque .NET binary serialization (base64-encoded inside an `<ExecutionState>` element). Don't try to parse — re-derive from the h5 / xlsx instead.

	## Row shape

	See `README.md` for the full schema. Key envelope fields:
	- `sample_id` = `"{batch_label}{seq}"` (e.g. `"A1"`, `"C7"`, `"E10"`); null for non-SLS controls.
	- `batch_label` ∈ `{"A".."I"}`; null for non-SLS controls.
	- `specimen_id` = `"{session_folder}/TSR{n}"` (or `"{session_folder}/{test_folder}/TSR{n}"` when disambiguating multiple Test projects in one session_folder) — fully qualified unique key (use this if you need to disambiguate across configs).
	- `material_class` ∈ `{"SLS", "PLA", "PETG", …}` — only `"SLS"` rows have populated Database FKs and `print_profile_snapshot`.
	- `astm` = `{standard, type, year}` object — structured (not a flat string) so ISO equivalents can be added later without breaking schema.
	- `curves` carries both analyzed (`stress_pa`, `strain`) and raw DAQ (`time_s`, `extension_m`, `load_n`) — lossless.

	### IMPORTANT — TestWorks analysis often fails to detect peak/break for tensile

	Many D638 TSRs have `Peak = LongMax (9223372036854775807)` in persistent.h5, which leaves `PeakLoad`, `PeakStress`, `StressAtBreak`, `EnergyToBreak`, `StrnAtBreak` etc. all `NaN` despite a real break occurring. Our extract surfaces these as `null`. The full stress-strain curve is still saved, so consumers can re-derive peak/break with their own criteria. D790 flex rows have these populated more consistently. Don't filter rows based on null metrics; they may still be perfectly valid trials.

	### IMPORTANT — field-name divergence between tensile and flex persistent.h5

	Same TestWorks framework, different schema. Notable renames you have to handle:
	- `StrnAtPeak` (tensile) ↔ `StrainAtPeak` (flex)
	- `StrnAtBreak` (tensile) ↔ `BreakStrain` (flex)
	- `StrnAtYield` (tensile) ↔ `StrainAtYield` (flex)
	- `Slope` (tensile, single) ↔ `Slope1`/`Slope2` (flex)
	- `AdjGage` (tensile only — flex has no analogous field, gauge_length_mm is always null for D790)

	`get_either(d, "tensile_name", "flex_name")` in `_lib.py` handles this. If you add new scalars, check both files and use `get_either` rather than picking one name.

	## Current state

	- `D638` config — 103 rows: 87 SLS across batches A-N (batch counts: A5 B5 C7 D5 E5 F5 G5 H3 I5 J4 J_MB5 K5 L6 M17 N5) + 3 PLA + 3 PETG + 5 FormLabs PA12GF + 5 FormLabs Nylon 12 White.
	- `D790` config — 81 rows: 71 SLS across batches C-N (batch counts: C9 D8 E10 F9 G4 H5 I5 J2 J_MB2 K3 L4 M5 N5) + 5 FormLabs PA12GF + 5 FormLabs Nylon 12 White.
	- Batches K-N have `db_print_date=None` (print jobs not yet backfilled into Database) — SLS rows through J/J_MB have Database FKs (2026-07-12 backfill: E ← 2026-06-07 (same as D), F ← 2026-06-13, G ← 2026-06-09, H ← 2026-06-24, I ← 2026-06-25, J/J_MB ← 2026-06-27 (`D790 and D638 and other objects`)); K, L, M, N still need the same treatment once their print jobs land.
	- `_lib.py` disambiguates same-date jobs by STL content. Two 2026-06-27 prints share a date in Database; `resolve_database_fk` picks the one whose object list contains the standard's STL needle (`d638` / `d790`). Same fix will apply to any future same-date collision (e.g. 06-29 already has two jobs, though no ASTM specimens map there yet).
	- Total: 184 specimens, produced by 32 per-session scripts (some date folders — 2026_06_10, 2026_06_30, 2026_07_21 — contain more than one Test project/batch/specimen type).
	- Batch I flex is missing TSR4 (excluded: `test_end_reason` is "Test Stopped", not a detected break) — sample_ids I1-I5 map to TSR{1,2,3,5,6}.
	- Batch H's 5 flex rows are `xlsx_only` (no raw TestRuns folder survived — see architectural decisions above); Batches K, L, M, N are `xlsx_only` too (no TestRuns/h5 handed off for those sessions at all, not just one project overwriting another) — every other row has full h5-derived curves.
	- Batch J / J_MB (2026-07-06 print, tested 07/06 and 07/08) is the first split-batch label. Both are the same physical print batch; `J` specimens were tested as-printed, `J_MB` specimens were media blasted post-print before testing. This deviates from the single-letter `batch_label` convention (see architectural decisions above) — deliberately, per user instruction, to keep the surface-treatment distinction visible without adding a new schema field. If more media-blast-vs-not comparisons get added, consider promoting this to a real `surface_treatment` field instead of continuing to overload `batch_label`.
	- Batch M tensile (D638) is the first batch mixing two ASTM specimen types. 5 Type I dogbones (`tensile_m.xlsx`, sample_ids M1-M5) plus 12 Type IV narrow-section specimens from the same print (`tensile_m_t4.xlsx`, M6-M17, `astm.type = "Type IV"`) — see `26_2026_07_21_tensile_m.py` / `27_2026_07_21_tensile_m_type4.py`, which share `batch_label="M"` and continue sample numbering via `process_session`'s `seq_start`. Per user instruction the Type IV specimens get their own figure (`assets/D638_type_iv.png`) rather than sharing the cluster/batch-averages/detail figures with the rest of Batch M — `TYPE_LINESTYLES` in `scripts/plots/_lib.py` flags which ASTM types get this treatment, and `02_batch_averages.py`/`03_batch_clusters.py`/`04_batch_details.py` all exclude them accordingly (different gauge geometry, not comparable to Type I). Within that dedicated figure, each of the 12 specimens gets its own labeled curve (`render_type_iv` in `01_controls.py`) rather than one grouped legend entry — ordered by `specimen_index` (= xlsx sheet order = physical test order) and labeled per `TYPE_IV_LABELS = [1,2,3,4,5,6,8,9,10,11,13,14]`, a user-supplied numbering with intentional gaps at 7 and 12 (specimen numbers that exist in the lab's own record-keeping but aren't part of this xlsx export).
	- `NYLON12_WHITE_FL` is a new `material_class` (FormLabs Nylon 12 White SLS control, tested 2026-07-23, no `batch_label`/`sample_id`, no Database FK) — a second FormLabs reference material alongside `PA12GF_FL`, unfilled/white nylon rather than glass-filled. Per user instruction it's excluded from the cluster/batch-averages figures and rendered on its own (`{standard}_nylon12white_control.png`, see `scripts/plots/_lib.py`'s `NYLON_CONTROLS`). D638 (tensile) `tensile_nylon12white_fl.xlsx` is a raw load/extension export with no gauge-length scalar in the file — unlike D790 there's no chord-formula fallback for tensile, so strain/stress can't be derived from geometry alone. User confirmed the test used a 25mm-starting-length extensometer, so `31_2026_07_23_tensile_nylon12white_fl.py` sets `gauge_length_mm: 25` explicitly and `build_row_from_xlsx` derives strain = extension/gauge_length, stress = load/area from that (see the `gauge_length_mm` session key, added for this case — `geometry.gauge_length_mm` on xlsx_only rows is null unless a session declares it). D790 (flex) rows derive normally since flexural strain/stress only need width/thickness. The D638 curves are cut at their stress peak for plotting only (`VERTICAL_BREAK_MATERIALS` in `scripts/plots/_lib.py`) — past peak, the raw trace continues as extension keeps increasing after the specimen separates while load reads ~0, and with few points sampled through the break itself this drew as a misleading diagonal line back to zero rather than the near-vertical drop a real break shows. Per user instruction, each figure applies this differently: `01_controls.py`'s raw-curve Nylon 12 White figure uses `vertical_break_at_peak` (cuts at peak, appends a point at zero stress/same strain so it plots as a vertical drop, matching the other SLS batches' visual convention); `02_batch_averages.py`'s mean ± SD figure now trims every specimen at its peak inside `group_average` (via `truncate_at_peak`) so no fracture branch — Nylon's included — reaches the averaging grid (this replaced the old per-Nylon special-case). Both `vertical_break_at_peak` and `truncate_at_peak` are applied by the calling code, not baked into `load_standard`, since the figures need different treatments. Either way this only affects what gets plotted — the underlying JSONL `curves.strain`/`curves.stress_pa` arrays are untouched (full raw trace still there for anyone querying the dataset directly). D790 Nylon 12 White isn't affected — its curves don't show this artifact.

	## Running the extract

	Each per-session script is independently runnable; output is per-specimen JSONL.

	```bash
	# All sessions:
	for f in scripts/specimens/0*.py; do uv run "$f"; done

	# Just one session (e.g. when re-extracting after a fix):
	uv run scripts/specimens/01_2026_05_26.py
	```

	## Adding a new session — recipe

	1. Drop the TestWorks session folder under `source/{YYYY_MM_DD}/` (or `source/{YYYY_MM_DD}/{label}/` for multiple sessions per day, as 2026_06_10 already does).
	2. `git lfs add` the `.h5`, `.Traits`, `.xlsx` files via the repo's `.gitattributes` (already configured).
	3. Add a new `scripts/specimens/{NN}_{slug}.py` (number it after the existing scripts). Use any of the existing scripts as a template — they're ~15 lines each. Declare:
	- `session_folder`, `test_folder` (almost always `"TST1.Test"`), `xlsx_name`
	- `astm` block (`standard` routes the output to `data/D638/` vs `data/D790/`)
	- `batch_label` (single letter)
	- `test_runs`: list of `(tsr_index, material_class, db_print_date \| None)`. For SLS rows pick the source print job from `Agentic-SLS-Database/data/jobs.jsonl` by `print_date`. For non-SLS and SLS-without-Database-job, pass `None`.
	- If the same session_folder holds more than one Test project (e.g. two batches printed the same day sharing a parent folder), give each batch its own script with a different `test_folder` (`TST1.Test`, `TST2.Test`, ...) — don't guess which TSRs belong to which batch from folder structure alone; cross-check a scalar like Modulus or PeakLoad between each project's `persistent.h5` and each candidate xlsx export.
	- If a TestRuns folder is missing/overwritten and only an xlsx export survives, set `"xlsx_only": True` instead of `test_folder` — this is a fallback (see architectural decisions above), not something to reach for by default.
	4. Run that one script → new files land in `data/{standard}/`.
	5. Update the README's "Test sessions covered" table (and the "Current state" section here).
	6. Regenerate the figures: `for f in scripts/plots/0*.py; do uv run "$f"; done` (runs `01_controls.py`, `02_batch_averages.py`, `03_batch_clusters.py`, `04_batch_details.py`). If it's a new batch letter, add it to `ORDERED_BATCHES` in `scripts/plots/_lib.py` first — `BATCH_COLORS` is sampled from the orange ramp by that list's order, so no manual color pick is needed.

	## Backfilling batches E–I, J, J_MB

	Batches E (D790 only), F, G, H, I, J, and J_MB all currently pass `db_print_date=None` because their print jobs aren't in `Agentic-SLS-Database/data/jobs.jsonl` yet. J and J_MB share the same 2026-07-06 print job, so both batches' scripts get the same `db_print_date` once it's backfilled. When one lands:
	1. In the matching `scripts/specimens/{NN}_*.py`, change `(i, "SLS", None)` to `(i, "SLS", "<print_date>")` for that batch's `test_runs`.
	2. Re-run that one script. Its JSONLs get FKs and `print_profile_snapshot` filled in. No schema change needed.

	Note: Batch H's flex script (`17_2026_06_30_flex_h.py`) is `xlsx_only` — backfilling its FK doesn't change the fact that its curves/metrics are xlsx-derived only (see architectural decisions above).

	## Scope note

	Mirrors the `Agentic-SLS-Database` scope: ASTM-subset only. If the parent Database is later broadened to cover all SLS prints, the `MANIFEST` here doesn't need to change — only the specimens whose source print job is now in Database will get FKs filled in.