Datasets:

ppak10
/

Agentic-SLS-ASTM

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 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.

# 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

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).
git lfs add the .h5, .Traits, .xlsx files via the repo's .gitattributes (already configured).
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.
Run that one script → new files land in data/{standard}/.
Update the README's "Test sessions covered" table (and the "Current state" section here).
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:

In the matching scripts/specimens/{NN}_*.py, change (i, "SLS", None) to (i, "SLS", "<print_date>") for that batch's test_runs.
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.