Adds previews for timelapses.

CLAUDE.md

@@ -269,12 +269,17 @@ Neither blocks the ETL. They improve dataset metadata.
 ```
 .python-version                # 3.13
 pyproject.toml                 # pyarrow, polars, imageio[ffmpeg], pillow, numpy
-.gitattributes                 # *.parquet, *.mp4 → LFS
+.gitattributes                 # *.parquet, *.mp4, *.gif → LFS
 
 scripts/
   _lib.py                      # sibling-repo paths + JSONL streaming
-  ticks/01_extract.py          # the single ETL — wide-pivot + asof + burst + embed
-  previews/01_render.py        # per-build MP4 previews from data/ticks/
+  ticks/
+    00_recover_spool41.py      # one-off: recover build 41 from NVMe spool (DB was wiped)
+    00_export_new_db.py        # one-off: export new-DB builds with ID offset (old_id:new_id)
+    01_extract.py              # the single ETL — wide-pivot + asof + burst + embed
+  previews/
+    01_render.py               # per-build MP4 previews from data/ticks/
+    02_timelapse.py            # per-build timelapse GIFs, one frame per print layer
 
 data/
   ticks/{build_id:03d}.parquet # LFS; e.g. 001.parquet, 026.parquet
@@ -285,6 +290,10 @@ previews/
     thermal.mp4                # LFS; IR matrix
     galvo.mp4                  # LFS; scan-mirror trace
     composite.mp4              # LFS; 1×3 panel: chamber | thermal | galvo
+    timelapse_chamber.gif      # LFS; layer-by-layer GIF, 25 fps, ≤ 12 s
+    timelapse_thermal.gif      # LFS
+    timelapse_galvo.gif        # LFS
+    timelapse_composite.gif    # LFS; 1×3 panel GIF
 ```
 
 There is no `source/` (raw data lives in the sibling recorder repo's `data/exports/`).
@@ -375,20 +384,45 @@ If `expand()` in the recorder ever changes, all of those column names change wit
 
 ## Current state
 
-- `ticks` config: implemented with embedded frame bytes. 12 parquet files, ~47 GB total, across builds 1, 2, 12, 13, 14, 16, 17, 25, 26, 28, 29, 30. Builds 29 and 30 were added 2026-06-28; the first 10 still carry a stale `print_profile_id` column from before the dep-drop and will lose it on next regen.
+- `ticks` config: 24 parquet files across builds 001–043 (plus 040). Build 041 was recovered from the NVMe spool after the Postgres DB was wiped. Builds 042–043 are from the new DB (which restarted its BIGSERIAL at 1); see "Build ID offset" below.
 - `print_profile_name` is preserved on every row; the `print_profile_id` UUID is *not* materialized here (see the architectural decision above).
 - `events` and `plotter_commands` not surfaced as configs.
 - **Forward-fill semantics deferred.** Current attach is "fresh frame within 100 ms of tick or null." Carrying the latest captured frame forward to fill null rows is left to consumers (one-line groupby + ffill); baking it into the dataset would destroy the fresh-vs-stale signal that's the whole point of keeping nulls.
-- `previews/` MP4s: scaffolded 2026-06-28; first full render in progress (see "Preview videos" below).
+- `previews/` MP4s and timelapse GIFs: MP4s for builds 001–043 rendered; GIFs for 012 confirmed, full GIF render pending.
+
+## Build ID offset (post-DB-reset builds)
+
+The recorder's Postgres DB was wiped between build 040 and the next print (2026-07-09). The new DB restarted its `builds_id_seq` at 1. To avoid collision with the existing dataset files (001.parquet and 002.parquet correspond to the original Hex Coasters runs), new-DB builds are offset:
+
+| New DB id | Dataset id | Job name |
+|---|---|---|
+| — (spool only) | 041 | Unknown 2026_07_09 (~3h45m; DB wiped before import) |
+| 1 | 042 | Nameplates 2026_07_09 (~5h40m) |
+| 2 | 043 | D790 and D638 and Nameplate 2026_07_10 (~10h30m) |
+| 3 | 044 | D790 and D638 and Other 2026_07_11 (in progress at time of writing) |
+
+**To add a new build from the new DB**, use `00_export_new_db.py` with the appropriate offset instead of `export.py`:
+```sh
+uv run --with psycopg2-binary scripts/ticks/00_export_new_db.py 3:44
+uv run scripts/ticks/01_extract.py 44
+uv run scripts/previews/01_render.py 44
+uv run scripts/previews/02_timelapse.py 44
+```
+
+The long-term fix (resetting the DB sequence or adding a global build registry) is deferred. Frame files for new-DB builds live in subdirectories named after the *original* DB id (e.g. `data/frames/1/`, `data/frames/2/`), but the paths stored in `frames.jsonl` reference those original names — the ETL reads them correctly without any renaming.
 
 ## Adding a build — recipe
 
+**If the recorder DB is healthy (sequence hasn't reset):**
 1. New build runs in the recorder, produces telemetry / frames / position_hf in Postgres + on disk.
 2. Run `scripts/export.py` in the recorder repo to refresh `data/exports/`. Pass `--builds N` to scope to one build if you don't want to re-export everything.
-3. (Optional, but recommended) edit `Agentic-…-Optimization/data/exports/build_to_inova_session.csv` to fill in the `inova_session_id` UUID for the new build, then commit there.
-4. Run `uv run scripts/ticks/01_extract.py N` here to write `data/ticks/NNN.parquet` (zero-padded — e.g. build 7 → `007.parquet`, build 142 → `142.parquet`).
-5. Run `uv run scripts/previews/01_render.py N` to generate the four preview MP4s under `previews/NNN/`. See "Preview videos" below for cost.
-6. `git add data/ticks/NNN.parquet previews/NNN/` (LFS) and commit.
+3. (Optional) edit `Agentic-…-Optimization/data/exports/build_to_inova_session.csv` for the `inova_session_id` UUID.
+4. `uv run scripts/ticks/01_extract.py N` → `data/ticks/NNN.parquet`
+5. `uv run scripts/previews/01_render.py N` → four MP4s under `previews/NNN/`
+6. `uv run scripts/previews/02_timelapse.py N` → four timelapse GIFs under `previews/NNN/`
+7. `git add data/ticks/NNN.parquet previews/NNN/` (LFS) and commit.
+
+**If the recorder DB was reset (new sequence starting at 1):** use `00_export_new_db.py` with an `old_id:new_id` mapping instead of step 2. See "Build ID offset" above.
 
 ## Regenerate everything
 
@@ -399,7 +433,9 @@ uv run scripts/ticks/01_extract.py
 
 Takes ~2 hours, produces ~30 GB. The IO is the bottleneck; the Polars pivot and asof joins are fast.
 
-## Preview videos
+## Preview videos and timelapse GIFs
+
+### MP4 previews (`01_render.py`)
 
 `scripts/previews/01_render.py` walks `data/ticks/*.parquet` and emits four MP4s per build under `previews/{build_id:03d}/`:
 
@@ -408,19 +444,35 @@ Takes ~2 hours, produces ~30 GB. The IO is the bottleneck; the Polars pivot and
 - `galvo.mp4` — scan-mirror trace, from `frame_galvo`
 - `composite.mp4` — 1×3 panel (chamber | thermal | galvo)
 
-Design choices baked in:
-- **Source is this dataset's own parquet, not the recorder's raw frame files.** Means previews are self-contained (no recorder repo needed at render time) but only see the per-tick-attached subset (~36% chamber / ~37% galvo / ~16% thermal of ticks have a frame).
-- **Real-time playback at 10 fps** — output duration matches build wall-clock. Build 26 (~9h54m) → ~9h54m of video. Null cells are forward-filled so the picture keeps moving through long heating stretches (this is a *viewing* convenience and does NOT contradict the no-forward-fill rule on the dataset itself — videos are not training data).
-- **Letterbox-fit into a canvas locked by the first non-null frame.** Some builds have a thermal config change mid-run that produces a different source aspect ratio (e.g. build 13 has 2,215 frames at 960×720 and 2 at 852×852); the lock-and-letterbox approach keeps ffmpeg happy.
-- **Streamed row-group iteration via pyarrow** (`BATCH_ROWS=1000`) so the whole parquet never lives in memory — necessary for the 11 GB files.
+Design choices:
+- **Real-time playback at 10 fps** — output duration matches build wall-clock. Null cells are forward-filled (viewing convenience only; not training data).
+- **Letterbox-fit into a canvas locked by the first non-null frame** (handles thermal dim drift).
+- **Streamed row-group iteration** (`BATCH_ROWS=1000`) — necessary for 11+ GB parquets.
+- **NVENC encode** (`h264_nvenc`, K620 GPUs) with libx264 fallback (`RENDER_CPU=1`).
 
-Cost is non-trivial: full render of all 12 builds is ~25 GB of LFS, ~9.7 h of encode (libx264 with imageio-ffmpeg). The long-build MP4s dominate; the tiny failed-heating builds (2, 14, 16, 17, 25) cost seconds and sub-MB each.
+```sh
+uv run scripts/previews/01_render.py            # all builds
+uv run scripts/previews/01_render.py 13 26      # specific builds
+uv run scripts/previews/01_render.py 26 --kinds chamber,composite
+```
+
+### Timelapse GIFs (`02_timelapse.py`)
+
+`scripts/previews/02_timelapse.py` emits four animated GIFs per build:
 
-### Regenerate previews
+- `timelapse_chamber.gif`, `timelapse_thermal.gif`, `timelapse_galvo.gif`
+- `timelapse_composite.gif` — 1×3 panel
+
+**Layer detection:** `positions.position.z2` is quantized in 100 µm buckets. Only z2 > 0 rows are used — z2 stays at 0 during pre-print heating, so this naturally excludes non-printing ticks. The *last* non-null frame in each z2 bucket is the representative (most-recent view of the layer just before recoating).
+
+**Playback:** 25 fps, capped at 300 frames (max 12 s GIF). Builds with fewer than 300 detected layers are not padded. Null-frame levels are forward-filled within the GIF. Canvas height 240 px (half the MP4 height) to keep file sizes web-friendly.
+
+**Composite pass:** does a single parquet stream reading all three frame columns at once (not three separate passes).
 
 ```sh
-uv run scripts/previews/01_render.py            # all builds with parquet
-uv run scripts/previews/01_render.py 13 26      # specific builds
+uv run scripts/previews/02_timelapse.py            # all builds
+uv run scripts/previews/02_timelapse.py 26 28      # specific builds
+uv run scripts/previews/02_timelapse.py 26 --kinds chamber,composite
 ```
 
-Always overwrites existing previews (no skip-if-exists). For incremental work, name the build IDs.
+Always overwrites. For incremental work, name the build IDs.

README.md

@@ -25,99 +25,196 @@ dataset_info:
 
 # Inova-Mk1-Telemetry
 
-Time-aligned printer-state recordings from Inova Mk1 SLS print runs. One row per 10 Hz **tick** of the recorder's `/state/snapshot` poll, with the full sensor state (~64 columns: temperatures, position, power, lights) on every row, the nearest camera frame paths attached when one fell in the prior 100 ms window, and any 1 kHz position-stream samples from that window collected as a nested list.
+Time-aligned printer-state recordings from Inova Mk1 SLS 3D print runs. One row per 10 Hz **tick** — the recorder's `/state/snapshot` poll — with the full sensor state snapshot (~64 columns: temperatures, position, power, lights) on every row, the nearest camera frame embedded inline when one fell within the prior 100 ms window, and any 1 kHz position-stream samples from that window collected as a nested list.
 
-Builds are denormalized into every row, so each parquet file is self-sufficient for ML — no joins needed for build context. The `print_profile_name` string the printer was running is preserved on every row; consumers who want the matching UUID from [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database) can resolve it themselves (one-liner shown below) — this dataset deliberately doesn't bake that join in, so it has no cross-dataset dependency at load time.
+25 parquet files across builds spanning 2026-05 through 2026-07. Build metadata (job name, profile, start/end time) is denormalized into every row, so each file is self-sufficient for ML — no joins needed.
 
 ```python
 from datasets import load_dataset
-ticks = load_dataset("ppak10/Inova-Mk1-Telemetry", split="train")
-row = ticks[0]
-# row["frame_chamber"]   → PIL.Image.Image (or None)
-# row["frame_thermal"]   → PIL.Image.Image (or None)
-# row["powderBed.temp.current"] → float (°C)
-# row["position_hf_burst"]      → list of {ts_offset_ms, x, y, z1, z2, r, has_homed}
+ds = load_dataset("ppak10/Inova-Mk1-Telemetry", split="train")
+row = ds[0]
+# row["frame_chamber"]            → PIL.Image.Image (or None)
+# row["frame_thermal"]            → PIL.Image.Image (or None)
+# row["powderBed.temp.current"]   → float (°C)
+# row["positions.position.z2"]    → float (µm)
+# row["position_hf_burst"]        → list of {ts_offset_ms, x, y, z1, z2, r, has_homed}
 ```
 
-The full image bytes ship inside each row — no separate frame download required. Filter to rows that have a particular frame kind with `ticks.filter(lambda r: r["frame_chamber"] is not None)`.
+Full image bytes are embedded in each row — no separate frame download. Filter to rows with a particular frame kind:
+
+```python
+with_chamber = ds.filter(lambda r: r["frame_chamber"] is not None)
+```
+
+---
+
+## Timelapse previews
+
+Per-build layer-by-layer timelapse GIFs (one frame per detected print layer, 25 fps, ≤ 12 s). Below is the composite (chamber | thermal | galvo) for build 012, the first full Layers-phase run:
+
+![Build 012 galvo timelapse — laser scan trace per layer](previews/012/timelapse_galvo.gif)
+
+<sub>Galvo (scan-mirror) trace for build 012 — Hex Coasters, 221 layers. Each frame is the last captured view of one print layer just before the next powder spread. Full composite (chamber | thermal | galvo) at `previews/012/timelapse_composite.gif`.</sub>
+
+Individual-kind GIFs (`timelapse_chamber.gif`, `timelapse_thermal.gif`) and full-speed MP4 previews are also available under `previews/{build_id:03d}/`. See the **Previews** section below.
 
 ---
 
 ## Row shape
 
-Each row is one moment in time (a single 10 Hz tick). 80+ columns:
+Each row is one moment in time (a single 10 Hz tick). ~80 columns:
 
 | Group | Columns | Notes |
 |---|---|---|
-| **Build context** (denormalized) | `build_id`, `job_name`, `started_at`, `ended_at`, `phase`, `print_profile_name`, `inova_session_id` | Same value on every row in a given parquet file. `inova_session_id` is null until the upstream `build_to_inova_session.csv` is filled in by hand. |
-| **Tick timestamp** | `ts` (`timestamp[us, UTC]`) | The `respondedAt` field on the `/state/snapshot` frame. |
-| **Position (10 Hz)** | `positions.position.{x,y,z1,z2,r}` | Stage position at the tick, **microns** (firmware native; e.g. `z1 = 47272.79` is 47.27 mm). Always present. |
+| **Build context** | `build_id`, `job_name`, `started_at`, `ended_at`, `phase`, `print_profile_name`, `inova_session_id` | Denormalized — same value on every row in a given file. `inova_session_id` is null until the upstream sidecar CSV is curated by hand. |
+| **Timestamp** | `ts` (`timestamp[us, UTC]`) | `respondedAt` from `/state/snapshot`. |
+| **Position (10 Hz)** | `positions.position.{x,y,z1,z2,r}` | Stage position in **microns** (firmware native; divide by 1000 for mm). Always present. `z2` advances with each deposited layer and is used for layer detection in the timelapse scripts. |
 | **Lights** | `lights.lights.{enabled,count}` | |
-| **Power (W)** | `{laser,fanGalvo,buzzer,laserSafety,io-en,wd-en,wd-in}.power`, `powerman.power.{current,required,max}` | Per-component power draw and the overall manager state. |
-| **Temperature (°C)** | `{powderBed,printBed}.temp.{current,average,target}`, `{powderChamber1..4,printChamber1..4}.temp.{current,average,target}`, `{quadrant1..4,surface,surfaceAvg,surfaceMin,surfaceMax,testTemp1}.temp.{current,average}` | ~51 columns. All firmware temperatures in °C. |
-| **Frame images** | `frame_chamber`, `frame_galvo`, `frame_thermal` | Embedded image bytes per HF `Image` feature (struct of `{bytes, path}`). Null when no frame of that kind was captured in the 100 ms window before the tick. Loads as a `PIL.Image` via `datasets`. The `path` field inside the struct preserves the original filename for traceability. |
-| **Position burst** | `position_hf_burst` | A `list<struct<ts_offset_ms, x, y, z1, z2, r, has_homed>>`. Captures any 1 kHz position-stream events that fell in `(tick_ts - 100 ms, tick_ts]`. Empty list when no motion was happening. |
+| **Power (W)** | `{laser,fanGalvo,buzzer,laserSafety,io-en,wd-en,wd-in}.power`, `powerman.power.{current,required,max}` | Per-component draw and manager state. |
+| **Temperature (°C)** | `{powderBed,printBed}.temp.{current,average,target}`, `{powderChamber1..4,printChamber1..4}.temp.{current,average,target}`, `{quadrant1..4,surface,surfaceAvg,surfaceMin,surfaceMax,testTemp1}.temp.{current,average}` | ~51 columns. |
+| **Frame images** | `frame_chamber`, `frame_galvo`, `frame_thermal` | HF `Image` feature (struct of `{bytes, path}`). Null when no frame of that kind was captured in the 100 ms window. Loads as `PIL.Image` via `datasets`. `path` preserves the original filename for traceability. |
+| **Position burst** | `position_hf_burst` | `list<struct<ts_offset_ms, x, y, z1, z2, r, has_homed>>`. 1 kHz position events that fell in `(tick_ts − 100 ms, tick_ts]`. Empty list during heating/idle. |
+
+### Null frames
+
+`frame_*` columns are null when no frame of that kind was captured within the 100 ms tick window — this preserves the "is this image fresh?" signal. Forward-fill for display or training:
+
+```python
+import polars as pl
+df = pl.read_parquet("data/ticks/026.parquet")
+df = df.with_columns(
+    pl.col("frame_chamber").forward_fill(),
+    pl.col("frame_thermal").forward_fill(),
+    pl.col("frame_galvo").forward_fill(),
+)
+```
+
+---
+
+## Build inventory
+
+25 builds total. Very short failed-heating runs (2–24 ticks) produce a parquet but represent only seconds of recording.
+
+| build_id | job_name | ticks | date |
+|---:|---|---:|---|
+| 001 | Hex Coasters 2026_05_31 | 102,805 | 2026-05-31 |
+| 002 | Hex Coasters 2026_05_31 | 68 | 2026-05-31 |
+| 012 | Hex Coasters 2026_05_31 | 201,660 | 2026-05-31 |
+| 013 | D790 and D638 and Benchy 2026_06_02 | 13,811 | 2026-06-02 |
+| 014 | D790 and D638 and Benchy 2026_06_02 | 2 | 2026-06-02 |
+| 016 | D790 and D638 and Benchy 2026_06_02 | 14 | 2026-06-02 |
+| 017 | D790 and D638 and Benchy 2026_06_02 | 2 | 2026-06-02 |
+| 025 | D790 and D638 and Benchy 2026_06_02 | 24 | 2026-06-02 |
+| 026 | D790 and D638 and Benchy 2026_06_02 | 355,580 | 2026-06-02 |
+| 028 | D790 and D638 2026_06_07 | 340,162 | 2026-06-07 |
+| 029 | D790 and D638 and Cards 2026_06_09 | 285,092 | 2026-06-09 |
+| 030 | D790 and D638 Recycled Powder 2026_06_24 | 228,723 | 2026-06-24 |
+| 031 | D790 and D638 Recycled Powder 2026_06_25 | 161,379 | 2026-06-25 |
+| 032 | Hex Coasters and Nameplates and Benchies | 19,954 | 2026-06-27 |
+| 033 | Hex Coasters and Nameplates and Benchies | 1,559 | 2026-06-27 |
+| 034 | Hex Coasters and Nameplates and Benchies | 18,251 | 2026-06-27 |
+| 035 | D790 and D638 and other objects 2026_06_27 | 430,997 | 2026-06-27 |
+| 036 | Hex Coasters and Nameplates and Benchies | 734,064 | 2026-06-28 |
+| 037 | D790 and D638 Debug Run 2026_06_29 | 776 | 2026-06-29 |
+| 038 | D790 and D638 Debug Run 2026_06_29 | 8,294 | 2026-06-29 |
+| 039 | D790 and D638 and Nameplate 2026_06_29 | 334,454 | 2026-06-29 |
+| 040 | D790 and D638 and D256 and Benchy 2026_07_01 | 446,764 | 2026-07-01 |
+| 041 | Unknown 2026_07_09 ¹ | 134,790 | 2026-07-09 |
+| 042 | Nameplates 2026_07_09 | 203,425 | 2026-07-10 |
+| 043 | D790 and D638 and Nameplate 2026_07_10 | 373,863 | 2026-07-10 |
+| **total** | | **4,900,289** | |
+
+¹ Build 041 was recovered from the NVMe spool after the recorder's Postgres database was reset; `job_name` is a placeholder.
+
+---
 
 ## Files
 
 ```
-data/ticks/{build_id:03d}.parquet      # one file per build that had telemetry, zero-padded to 3 digits
+data/ticks/{build_id:03d}.parquet      # one file per build, zero-padded (001–043)
 
-previews/{build_id:03d}/                # per-build MP4 previews (real-time, 10 fps)
-  chamber.mp4                          # optical
+previews/{build_id:03d}/
+  chamber.mp4                          # optical — real-time 10 fps, forward-filled
   thermal.mp4                          # IR matrix
   galvo.mp4                            # scan-mirror trace
   composite.mp4                        # 1×3 panel: chamber | thermal | galvo
+  timelapse_chamber.gif                # layer-by-layer, 25 fps, ≤ 12 s
+  timelapse_thermal.gif
+  timelapse_galvo.gif
+  timelapse_composite.gif              # 1×3 panel GIF
 ```
 
-12 builds had recorded telemetry; very-short failed-heating builds (~12–38 s, no rows) produce no parquet. The HF glob `data/ticks/*.parquet` loads everything across builds. Previews are derived from the same parquet files — every build that has a parquet also has previews.
+The HF glob `data/ticks/*.parquet` loads the full dataset across all builds. Builds that never started printing (z2 = 0 throughout) produce a timelapse GIF with zero or one frame.
+
+---
+
+## Previews
+
+### Real-time MP4s
+
+Four MP4s per build under `previews/{build_id:03d}/`: `chamber.mp4`, `thermal.mp4`, `galvo.mp4`, and `composite.mp4`. Playback at 10 fps (the tick rate), so video duration equals build wall-clock time — build 026 → ~9h54m of video. Null frames are forward-filled for viewing continuity.
+
+### Timelapse GIFs
+
+Four animated GIFs per build sampled one frame per detected print layer:
+
+- **Layer detection**: `positions.position.z2` quantized in 100 µm buckets. Only z2 > 0 rows are used, so pre-print heating is automatically excluded.
+- **Representative frame**: the *last* non-null frame within each z2 bucket — the most-recent view of the layer just before recoating begins.
+- **Playback**: 25 fps, capped at 300 frames (12 s max). Null-frame levels are forward-filled within the GIF.
+- **Canvas**: 240 px height (half the MP4 canvas) for web-friendly file sizes.
+
+Both previews are sourced from this dataset's own parquet (not the recorder's raw frame files), so they see only the per-tick-attached frame subset (~36% chamber, ~37% galvo, ~16% thermal attachment rate).
+
+---
 
 ## What's lost vs the raw exporter format
 
-This dataset is **tick-anchored**, not strict-outer-join. Compared to the upstream flat exports, three things are reduced:
+This dataset is **tick-anchored**, not a strict outer join. Three things are reduced compared to the upstream flat exports:
 
-- **Position resolution between motion bursts**: the 1 kHz `position_hf` stream is preserved *during* motion (via the per-tick `position_hf_burst` list) but not as standalone rows between ticks. If you need the raw 1 kHz timeline outside the 100 ms windows, fall back to the upstream `position_hf/{build_id}.parquet`.
-- **Sparse-stream events without telemetry**: there is no row for a frame timestamp that doesn't fall near a 10 Hz tick, and no row for sparse `events` (build phase transitions, etc.). Treat this dataset as "what was the state at each tick", not "every recorded event".
-- **`plotter_commands`**: not exposed yet — historical builds predate the recorder feature, and the table is empty.
+- **Between-tick position resolution**: the 1 kHz `position_hf` stream is preserved *during* motion via `position_hf_burst`, but not as standalone rows between ticks. For the raw 1 kHz timeline fall back to the upstream `position_hf/{build_id}.parquet`.
+- **Sparse events without telemetry**: no row exists for a camera frame or `events` record that doesn't land near a 10 Hz tick. This dataset represents "state at each tick", not "every recorded event".
+- **`plotter_commands`**: not surfaced — historical builds predate this recorder feature and the table is empty.
+
+---
 
 ## Joining back to Inova-Mk1-Database
 
-Each row carries `print_profile_name` — the string the printer was running when the build started, taken straight from the `build_start` event payload. To recover the matching `PrintProfile.Id` UUID, join against the [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database) `PrintProfiles` entities:
+Each row carries `print_profile_name` — the string the printer was running when the build started, taken from the `build_start` event payload. To recover the matching `PrintProfile.Id` UUID, join against [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database):
 
 ```python
 import json
 from pathlib import Path
 
-# Wherever you've cloned/snapshotted Inova-Mk1-Database
 profiles_dir = Path("Inova-Mk1-Database/source/PrintProfiles")
 name_to_id = {
     json.load(p.open())["Name"]: json.load(p.open())["Id"]
     for p in profiles_dir.glob("*.json")
 }
-
-ticks = ticks.map(lambda r: {**r, "print_profile_id": name_to_id.get(r["print_profile_name"])})
+ds = ds.map(lambda r: {**r, "print_profile_id": name_to_id.get(r["print_profile_name"])})
 ```
 
-If `Inova-Mk1-Database` hasn't yet added the profile the build used, the lookup returns null and `print_profile_name` is still preserved as a breadcrumb.
-
-A planned authoritative `inova_session_id UUID` will replace the name-based fallback once the upstream `Agentic-Additive-Manufacturing-Process-Optimization/data/exports/build_to_inova_session.csv` has been filled in.
+---
 
 ## Upstream
 
-The raw data lives in the sibling repository [`Agentic-Additive-Manufacturing-Process-Optimization`](https://github.com/ppak10/Agentic-Additive-Manufacturing-Process-Optimization). Its `scripts/export.py` writes flat files under `data/exports/`. This dataset reads from there directly via a sibling-folder relative path — no live database connection required.
-
-## Previews
-
-Each build that has a parquet also has four MP4s under `previews/{build_id:03d}/`: separate `chamber.mp4` / `thermal.mp4` / `galvo.mp4` and a `composite.mp4` showing all three side-by-side. They play back at 10 fps — the tick rate — so each video's duration equals the build's wall-clock duration (build 26 → ~9h54m of video). Null frames are forward-filled so the picture keeps moving through long heating stretches.
+Raw data lives in [`Agentic-Additive-Manufacturing-Process-Optimization`](https://github.com/ppak10/Agentic-Additive-Manufacturing-Process-Optimization). Its `scripts/export.py` produces flat JSONL/parquet files under `data/exports/`. This dataset reads from those directly — no live database connection required.
 
-Previews are sourced from this dataset's own parquet (not the recorder's raw frames), so they see only the per-tick-attached frame subset (~36% chamber, ~37% galvo, ~16% thermal of ticks). The result is choppier than playing the recorder's raw frames at native rate, but the previews are fully self-contained.
+---
 
 ## Regenerate
 
 ```sh
-uv run scripts/ticks/01_extract.py            # all builds with telemetry
-uv run scripts/ticks/01_extract.py 13 26      # specific build ids
+# Full ETL (all builds)
+uv run scripts/ticks/01_extract.py
+
+# Specific builds only
+uv run scripts/ticks/01_extract.py 26 28
+
+# MP4 previews
+uv run scripts/previews/01_render.py          # all builds
+uv run scripts/previews/01_render.py 26 28    # specific builds
 
-uv run scripts/previews/01_render.py          # all builds with parquet
-uv run scripts/previews/01_render.py 13 26    # specific build ids
+# Timelapse GIFs
+uv run scripts/previews/02_timelapse.py          # all builds
+uv run scripts/previews/02_timelapse.py 26 28    # specific builds
 ```

previews/041/chamber.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fad4c8e7ea7d935e82a3be1c9ffe76cd270b5d972dbf4ed5431a1dd94914ad3e
-size 657741047
+oid sha256:2f348c74f7f8348399b235e409ccd536322951111a6ab5bd19039ccfb22f79cd
+size 657748358

scripts/previews/01_render.py

@@ -63,7 +63,10 @@ def _decode_raw(frame_struct, kind: str) -> Image.Image | None:
     b = frame_struct.get("bytes")
     if b is None:
         return None
-    img = Image.open(io.BytesIO(b)).convert("RGB")
+    try:
+        img = Image.open(io.BytesIO(b)).convert("RGB")
+    except Exception:
+        return None
     rot = KIND_ROTATION_CW.get(kind, 0)
     # Image.Transpose.ROTATE_N rotates N degrees CCW, so CW=N → ROTATE_(360-N).
     if rot == 90:

scripts/previews/02_timelapse.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+"""Render per-layer timelapse GIFs for each build.
+
+Reads data/ticks/{build_id:03d}.parquet and writes:
+  previews/{build_id:03d}/timelapse_chamber.gif
+  previews/{build_id:03d}/timelapse_thermal.gif
+  previews/{build_id:03d}/timelapse_galvo.gif
+  previews/{build_id:03d}/timelapse_composite.gif  (1×3 panel: chamber | thermal | galvo)
+
+Layer detection: positions.position.z2 is quantized in 100 µm buckets.
+Only z2 > 0 rows are used — z2 stays at 0 during pre-print heating so this
+naturally excludes the heating phase without needing to inspect the phase column.
+The *last* non-null frame within each z2 bucket is the representative — that's
+the most-recent view of the layer just before recoating begins.
+
+Null-frame levels are forward-filled from the most recent non-null level of the
+same kind, so the GIF never shows a blank panel mid-timelapse.
+
+Subsampled to at most MAX_FRAMES (default 300). At GIF_FPS=25 that gives
+a max 12-second GIF. Builds with fewer detected layers are not padded.
+
+Canvas is scaled to GIF_PANEL_HEIGHT=240 px (half the MP4 panel height) to
+keep file sizes web-friendly for README embedding.
+
+Usage:
+    uv run scripts/previews/02_timelapse.py            # all builds in data/ticks/
+    uv run scripts/previews/02_timelapse.py 26 28      # specific build ids
+    uv run scripts/previews/02_timelapse.py 26 --kinds chamber,composite
+"""
+import io
+import sys
+from pathlib import Path
+
+import pyarrow.parquet as pq
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from _lib import DATA_DIR
+
+OUTPUT_DIR = DATA_DIR.parent / "previews"
+TICKS_DIR  = DATA_DIR / "ticks"
+
+FRAME_KINDS        = ("chamber", "thermal", "galvo")
+KIND_ROTATION_CW   = {"chamber": 90}  # degrees; see _decode_raw
+
+GIF_FPS            = 25
+GIF_DURATION_MS    = int(1000 / GIF_FPS)   # 40 ms per frame
+MAX_FRAMES         = 300                    # subsample cap → max 12 s GIF
+LAYER_QUANTIZE_UM  = 100                    # z2 bucket size in microns
+GIF_PANEL_HEIGHT   = 240                    # panel height in pixels for GIF canvas
+BATCH_ROWS         = 1000                   # pyarrow streaming batch size
+
+
+# ---------------------------------------------------------------------------
+# Image helpers (mirrors 01_render.py exactly)
+# ---------------------------------------------------------------------------
+
+def _decode_raw(b: bytes, kind: str) -> Image.Image | None:
+    """Decode raw image bytes to PIL RGB with orientation correction."""
+    if not b:
+        return None
+    try:
+        img = Image.open(io.BytesIO(b)).convert("RGB")
+    except Exception:
+        return None
+    rot = KIND_ROTATION_CW.get(kind, 0)
+    if rot == 90:
+        img = img.transpose(Image.Transpose.ROTATE_270)
+    elif rot == 180:
+        img = img.transpose(Image.Transpose.ROTATE_180)
+    elif rot == 270:
+        img = img.transpose(Image.Transpose.ROTATE_90)
+    return img
+
+
+def _fit_to_canvas(img: Image.Image, canvas_w: int) -> Image.Image:
+    """Letterbox img into (canvas_w × GIF_PANEL_HEIGHT) with dark-gray fill."""
+    sw, sh = img.size
+    scale  = min(canvas_w / sw, GIF_PANEL_HEIGHT / sh)
+    nw     = max(1, round(sw * scale))
+    nh     = max(1, round(sh * scale))
+    fitted = img.resize((nw, nh), Image.BILINEAR)
+    canvas = Image.new("RGB", (canvas_w, GIF_PANEL_HEIGHT), (20, 20, 20))
+    canvas.paste(fitted, ((canvas_w - nw) // 2, (GIF_PANEL_HEIGHT - nh) // 2))
+    return canvas
+
+
+def _placeholder(canvas_w: int) -> Image.Image:
+    return Image.new("RGB", (canvas_w, GIF_PANEL_HEIGHT), (20, 20, 20))
+
+
+def _canvas_width_from_bytes(b: bytes, kind: str) -> int:
+    """Decode one frame to determine the locked canvas width for this kind."""
+    img = _decode_raw(b, kind)
+    if img is None:
+        return GIF_PANEL_HEIGHT  # square fallback
+    sw, sh = img.size
+    return max(2, round(sw * GIF_PANEL_HEIGHT / sh))
+
+
+# ---------------------------------------------------------------------------
+# Layer data collection
+# ---------------------------------------------------------------------------
+
+def collect_layer_bytes(parquet_path: Path, kind: str) -> dict[int, bytes]:
+    """Single-pass stream → {z2_level: last_non_null_bytes}.
+
+    Only z2 > 0 rows are included. The dict is keyed by int(z2 / LAYER_QUANTIZE_UM);
+    each entry holds the bytes of the *last* non-null frame seen at that level.
+    Reads only two parquet columns (z2 + one frame kind) for efficiency.
+    """
+    frame_col = f"frame_{kind}"
+    z2_col    = "positions.position.z2"
+    pf        = pq.ParquetFile(parquet_path)
+    present   = {f.name for f in pf.schema_arrow}
+    if frame_col not in present or z2_col not in present:
+        return {}
+
+    layer_data: dict[int, bytes] = {}
+    for batch in pf.iter_batches(columns=[z2_col, frame_col], batch_size=BATCH_ROWS):
+        z2_list    = batch.column(z2_col).to_pylist()
+        frame_list = batch.column(frame_col).to_pylist()
+        for z2, struct in zip(z2_list, frame_list):
+            if z2 is None or z2 <= 0:
+                continue
+            level = int(z2 / LAYER_QUANTIZE_UM)
+            if struct is not None:
+                b = struct.get("bytes")
+                if b:
+                    layer_data[level] = b
+    return layer_data
+
+
+def collect_all_kinds(parquet_path: Path) -> dict[str, dict[int, bytes]]:
+    """Single streaming pass collecting all three kinds simultaneously.
+
+    Used by render_timelapse_composite so we don't make three separate passes
+    through (potentially 17+ GB) parquet files. Reads four columns: z2 + the
+    three frame columns. Each kind gets its own {z2_level: bytes} dict.
+    """
+    z2_col    = "positions.position.z2"
+    pf        = pq.ParquetFile(parquet_path)
+    present   = {f.name for f in pf.schema_arrow}
+    read_cols = [c for c in ([z2_col] + [f"frame_{k}" for k in FRAME_KINDS]) if c in present]
+    if z2_col not in read_cols:
+        return {k: {} for k in FRAME_KINDS}
+
+    layer_data: dict[str, dict[int, bytes]] = {k: {} for k in FRAME_KINDS}
+    for batch in pf.iter_batches(columns=read_cols, batch_size=BATCH_ROWS):
+        z2_list = batch.column(z2_col).to_pylist()
+        for kind in FRAME_KINDS:
+            col = f"frame_{kind}"
+            if col not in read_cols:
+                continue
+            frame_list = batch.column(col).to_pylist()
+            for z2, struct in zip(z2_list, frame_list):
+                if z2 is None or z2 <= 0:
+                    continue
+                level = int(z2 / LAYER_QUANTIZE_UM)
+                if struct is not None:
+                    b = struct.get("bytes")
+                    if b:
+                        layer_data[kind][level] = b
+    return layer_data
+
+
+# ---------------------------------------------------------------------------
+# Subsampling and forward-fill
+# ---------------------------------------------------------------------------
+
+def _subsample(levels: list[int]) -> list[int]:
+    """Evenly subsample sorted levels down to at most MAX_FRAMES."""
+    if len(levels) <= MAX_FRAMES:
+        return levels
+    step = len(levels) / MAX_FRAMES
+    return [levels[round(i * step)] for i in range(MAX_FRAMES)]
+
+
+def _forward_fill(layer_bytes: dict[int, bytes],
+                  target_levels: list[int]) -> list[bytes | None]:
+    """For each target level, return the bytes at that level or the most
+    recent non-null bytes seen so far (forward-fill across gaps)."""
+    out: list[bytes | None] = []
+    last: bytes | None = None
+    for lvl in target_levels:
+        b = layer_bytes.get(lvl)
+        if b is not None:
+            last = b
+        out.append(last)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# GIF writer
+# ---------------------------------------------------------------------------
+
+def _write_gif(frames: list[Image.Image], out_path: Path) -> None:
+    """Palette-quantize and save frames as an animated GIF."""
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    palette_frames = [
+        f.quantize(colors=256, method=Image.Quantize.MEDIANCUT,
+                   dither=Image.Dither.FLOYDSTEINBERG)
+        for f in frames
+    ]
+    palette_frames[0].save(
+        out_path,
+        format="GIF",
+        save_all=True,
+        append_images=palette_frames[1:],
+        loop=0,
+        duration=GIF_DURATION_MS,
+        optimize=False,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Per-build renderers
+# ---------------------------------------------------------------------------
+
+def render_timelapse_kind(parquet_path: Path, kind: str, out_path: Path) -> int:
+    """Write timelapse_{kind}.gif. Returns number of GIF frames written."""
+    layer_bytes = collect_layer_bytes(parquet_path, kind)
+    if not layer_bytes:
+        print(f"  {kind:8s}: no printing-phase frames (z2 > 0), skipping")
+        return 0
+
+    sorted_levels  = sorted(layer_bytes)
+    target_levels  = _subsample(sorted_levels)
+    fill_bytes     = _forward_fill(layer_bytes, target_levels)
+    canvas_w       = _canvas_width_from_bytes(next(b for b in fill_bytes if b), kind)
+
+    pil_frames: list[Image.Image] = []
+    for b in fill_bytes:
+        img = _decode_raw(b, kind) if b else None
+        pil_frames.append(
+            _fit_to_canvas(img, canvas_w) if img else _placeholder(canvas_w)
+        )
+
+    _write_gif(pil_frames, out_path)
+    return len(pil_frames)
+
+
+def render_timelapse_composite(parquet_path: Path, out_path: Path) -> int:
+    """Write timelapse_composite.gif (1×3 panel). Single parquet pass."""
+    all_bytes = collect_all_kinds(parquet_path)
+
+    all_levels = sorted(set().union(*(set(d) for d in all_bytes.values())))
+    if not all_levels:
+        print("  composite: no printing-phase frames (z2 > 0), skipping")
+        return 0
+
+    target_levels = _subsample(all_levels)
+    fill_per_kind = {k: _forward_fill(all_bytes[k], target_levels) for k in FRAME_KINDS}
+
+    canvas_widths: dict[str, int] = {}
+    for kind in FRAME_KINDS:
+        first_b = next((b for b in fill_per_kind[kind] if b), None)
+        canvas_widths[kind] = (
+            _canvas_width_from_bytes(first_b, kind) if first_b else GIF_PANEL_HEIGHT
+        )
+    total_w = sum(canvas_widths.values())
+
+    pil_frames: list[Image.Image] = []
+    for i in range(len(target_levels)):
+        composite = Image.new("RGB", (total_w, GIF_PANEL_HEIGHT), (20, 20, 20))
+        x = 0
+        for kind in FRAME_KINDS:
+            b   = fill_per_kind[kind][i]
+            img = _decode_raw(b, kind) if b else None
+            panel = (
+                _fit_to_canvas(img, canvas_widths[kind])
+                if img else _placeholder(canvas_widths[kind])
+            )
+            composite.paste(panel, (x, 0))
+            x += canvas_widths[kind]
+        pil_frames.append(composite)
+
+    _write_gif(pil_frames, out_path)
+    return len(pil_frames)
+
+
+def process_build(build_id: int, kinds: set[str]) -> None:
+    parquet_path = TICKS_DIR / f"{build_id:03d}.parquet"
+    if not parquet_path.exists():
+        print(f"build {build_id:03d}: no parquet, skipping")
+        return
+
+    build_dir = OUTPUT_DIR / f"{build_id:03d}"
+    print(f"build {build_id:03d}: timelapse GIFs → {build_dir.relative_to(Path.cwd())}/")
+
+    for kind in FRAME_KINDS:
+        if kind not in kinds:
+            continue
+        out = build_dir / f"timelapse_{kind}.gif"
+        n = render_timelapse_kind(parquet_path, kind, out)
+        if out.exists():
+            size = out.stat().st_size
+            print(f"  {kind:8s}: {n:>4} frames → {out.name}  ({size:,} bytes)")
+
+    if "composite" in kinds:
+        out = build_dir / "timelapse_composite.gif"
+        n = render_timelapse_composite(parquet_path, out)
+        if out.exists():
+            size = out.stat().st_size
+            print(f"  composite: {n:>4} frames → {out.name}  ({size:,} bytes)")
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("build_ids", nargs="*", type=int,
+                        help="Build IDs to render (default: all in data/ticks/)")
+    parser.add_argument(
+        "--kinds", default="chamber,thermal,galvo,composite",
+        help="Comma-separated outputs to render. "
+             "Valid: chamber, thermal, galvo, composite. Default: all four.",
+    )
+    args   = parser.parse_args()
+    kinds  = set(args.kinds.split(","))
+    unknown = kinds - (set(FRAME_KINDS) | {"composite"})
+    if unknown:
+        parser.error(f"unknown --kinds values: {sorted(unknown)}")
+
+    targets = args.build_ids or sorted(int(p.stem) for p in TICKS_DIR.glob("*.parquet"))
+    for bid in targets:
+        process_build(bid, kinds)
+
+
+if __name__ == "__main__":
+    main()

scripts/ticks/00_export_new_db.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""Export new-DB builds into the export-format files with offset build IDs.
+
+The Postgres DB was reset after build 40, so the new DB's build IDs restart at
+1. This script exports them with remapped IDs so they don't collide with the
+existing dataset (builds 1-41 already processed).
+
+Usage:
+    uv run --with psycopg2-binary scripts/ticks/00_export_new_db.py 1:42 2:43
+    uv run --with psycopg2-binary scripts/ticks/00_export_new_db.py 3:44
+
+Each argument is old_db_id:new_dataset_id. Don't export an in-progress build
+(no ended_at in the DB) — wait for it to finish and the spool to be imported.
+
+Safe to re-run: telemetry/position_hf parquets are always overwritten; jsonl
+files are checked first and skip if the new_id is already present.
+"""
+import json
+import sys
+from pathlib import Path
+
+import psycopg2
+import psycopg2.extras
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from _lib import EXPORTS_DIR
+
+DATABASE_URL = "postgres://inova:inova@localhost:5432/inova"
+BATCH_ROWS = 100_000
+
+
+def get_conn():
+    return psycopg2.connect(DATABASE_URL, cursor_factory=psycopg2.extras.RealDictCursor)
+
+
+def export_telemetry(conn, old_id: int, new_id: int):
+    out = EXPORTS_DIR / "telemetry" / f"{new_id}.parquet"
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    schema = pa.schema([
+        pa.field("ts",        pa.timestamp("us", tz="UTC")),
+        pa.field("sensor_id", pa.string()),
+        pa.field("kind",      pa.string()),
+        pa.field("value",     pa.float64()),
+    ])
+
+    with conn.cursor() as cur:
+        cur.execute(
+            "SELECT COUNT(*) AS n FROM telemetry WHERE build_id = %s", (old_id,)
+        )
+        total = cur.fetchone()["n"]
+        if total == 0:
+            print(f"  [{old_id}→{new_id}] telemetry: 0 rows in DB, skipping")
+            return
+
+        cur.execute(
+            "SELECT ts, sensor_id, kind, value FROM telemetry WHERE build_id = %s ORDER BY ts",
+            (old_id,)
+        )
+        written = 0
+        with pq.ParquetWriter(out, schema, compression="zstd") as writer:
+            while True:
+                rows = cur.fetchmany(BATCH_ROWS)
+                if not rows:
+                    break
+                table = pa.table({
+                    "ts":        pa.array([r["ts"]        for r in rows], type=pa.timestamp("us", tz="UTC")),
+                    "sensor_id": pa.array([r["sensor_id"] for r in rows], type=pa.string()),
+                    "kind":      pa.array([r["kind"]      for r in rows], type=pa.string()),
+                    "value":     pa.array([float(r["value"]) for r in rows], type=pa.float64()),
+                }, schema=schema)
+                writer.write_table(table)
+                written += len(rows)
+                print(f"  [{old_id}→{new_id}] telemetry: {written:,}/{total:,}...", end="\r")
+        print(f"  [{old_id}→{new_id}] telemetry: {written:,} rows → {out.name}     ")
+
+
+def export_position_hf(conn, old_id: int, new_id: int):
+    out = EXPORTS_DIR / "position_hf" / f"{new_id}.parquet"
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    schema = pa.schema([
+        pa.field("ts",        pa.timestamp("us", tz="UTC")),
+        pa.field("x",         pa.float64()),
+        pa.field("y",         pa.float64()),
+        pa.field("z1",        pa.float64()),
+        pa.field("z2",        pa.float64()),
+        pa.field("r",         pa.float64()),
+        pa.field("has_homed", pa.bool_()),
+    ])
+
+    with conn.cursor() as cur:
+        cur.execute(
+            "SELECT ts, x, y, z1, z2, r, has_homed FROM position_hf WHERE build_id = %s ORDER BY ts",
+            (old_id,)
+        )
+        rows = cur.fetchall()
+
+    if not rows:
+        print(f"  [{old_id}→{new_id}] position_hf: 0 rows")
+        return
+
+    table = pa.table({
+        "ts":        pa.array([r["ts"]        for r in rows], type=pa.timestamp("us", tz="UTC")),
+        "x":         pa.array([float(r["x"])  for r in rows], type=pa.float64()),
+        "y":         pa.array([float(r["y"])  for r in rows], type=pa.float64()),
+        "z1":        pa.array([float(r["z1"]) for r in rows], type=pa.float64()),
+        "z2":        pa.array([float(r["z2"]) for r in rows], type=pa.float64()),
+        "r":         pa.array([float(r["r"])  for r in rows], type=pa.float64()),
+        "has_homed": pa.array([bool(r["has_homed"]) for r in rows], type=pa.bool_()),
+    }, schema=schema)
+    pq.write_table(table, out, compression="zstd")
+    print(f"  [{old_id}→{new_id}] position_hf: {len(rows):,} rows → {out.name}")
+
+
+def append_builds_jsonl(conn, old_id: int, new_id: int):
+    out = EXPORTS_DIR / "builds.jsonl"
+
+    if out.exists():
+        with out.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    if r.get("id") == new_id:
+                        print(f"  [{old_id}→{new_id}] builds.jsonl: id={new_id} already present, skipping")
+                        return
+                except Exception:
+                    pass
+
+    with get_conn() as c, c.cursor() as cur:
+        cur.execute("SELECT * FROM builds WHERE id = %s", (old_id,))
+        row = cur.fetchone()
+
+    if not row:
+        print(f"  [{old_id}→{new_id}] builds.jsonl: build {old_id} not in DB, skipping")
+        return
+
+    entry = {
+        "id":         new_id,
+        "job_name":   row["job_name"],
+        "started_at": row["started_at"].isoformat() if row["started_at"] else None,
+        "ended_at":   row["ended_at"].isoformat()   if row["ended_at"]   else None,
+        "phase":      row["phase"],
+        "params":     row["params"],
+        "notes":      (row["notes"] or "") + f" [originally DB id={old_id}, remapped to {new_id}]",
+    }
+    with out.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(entry) + "\n")
+    print(f"  [{old_id}→{new_id}] builds.jsonl: appended id={new_id} ({entry['job_name']})")
+
+
+def append_frames_jsonl(conn, old_id: int, new_id: int):
+    out = EXPORTS_DIR / "frames.jsonl"
+
+    if out.exists():
+        with out.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    if r.get("build_id") == new_id:
+                        print(f"  [{old_id}→{new_id}] frames.jsonl: build_id={new_id} already present, skipping")
+                        return
+                except Exception:
+                    pass
+
+    max_id = 0
+    if out.exists():
+        with out.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    max_id = max(max_id, int(r.get("id", 0)))
+                except Exception:
+                    pass
+
+    with conn.cursor() as cur:
+        cur.execute(
+            "SELECT id, ts, kind, path FROM frames WHERE build_id = %s ORDER BY ts",
+            (old_id,)
+        )
+        rows = cur.fetchall()
+
+    if not rows:
+        print(f"  [{old_id}→{new_id}] frames.jsonl: 0 frames in DB")
+        return
+
+    with out.open("a", encoding="utf-8") as f:
+        for i, r in enumerate(rows):
+            entry = {
+                "id":       max_id + i + 1,
+                "build_id": new_id,
+                "ts":       r["ts"].isoformat(),
+                "kind":     r["kind"],
+                "path":     r["path"],
+            }
+            f.write(json.dumps(entry) + "\n")
+    print(f"  [{old_id}→{new_id}] frames.jsonl: appended {len(rows):,} rows")
+
+
+def append_events_jsonl(conn, old_id: int, new_id: int):
+    """Append build_start event so load_build_to_profile_name() picks up the
+    print profile name for this build."""
+    out = EXPORTS_DIR / "events.jsonl"
+
+    if out.exists():
+        with out.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    if r.get("build_id") == new_id and r.get("kind") == "build_start":
+                        print(f"  [{old_id}→{new_id}] events.jsonl: build_start already present, skipping")
+                        return
+                except Exception:
+                    pass
+
+    with conn.cursor() as cur:
+        cur.execute(
+            "SELECT * FROM events WHERE build_id = %s AND kind = 'build_start' LIMIT 1",
+            (old_id,)
+        )
+        row = cur.fetchone()
+
+    if not row:
+        print(f"  [{old_id}→{new_id}] events.jsonl: no build_start event in DB")
+        return
+
+    entry = {
+        "id":       -(new_id),
+        "build_id": new_id,
+        "ts":       row["ts"].isoformat() if row["ts"] else None,
+        "kind":     "build_start",
+        "message":  row["message"],
+        "payload":  row["payload"],
+    }
+    with out.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(entry) + "\n")
+    print(f"  [{old_id}→{new_id}] events.jsonl: appended build_start")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(__doc__)
+        sys.exit(1)
+
+    mappings: list[tuple[int, int]] = []
+    for arg in sys.argv[1:]:
+        try:
+            old_s, new_s = arg.split(":")
+            mappings.append((int(old_s), int(new_s)))
+        except ValueError:
+            print(f"Bad argument {arg!r} — expected old_id:new_id")
+            sys.exit(1)
+
+    conn = get_conn()
+    try:
+        for old_id, new_id in mappings:
+            print(f"\nExporting DB build {old_id} → dataset build {new_id}")
+            export_telemetry(conn, old_id, new_id)
+            export_position_hf(conn, old_id, new_id)
+            append_builds_jsonl(conn, old_id, new_id)
+            append_frames_jsonl(conn, old_id, new_id)
+            append_events_jsonl(conn, old_id, new_id)
+    finally:
+        conn.close()
+
+    new_ids = " ".join(str(n) for _, n in mappings)
+    print(f"\nDone. Run:  uv run scripts/ticks/01_extract.py {new_ids}")
+
+
+if __name__ == "__main__":
+    main()

scripts/ticks/00_recover_spool41.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+"""One-off recovery: build 41 from NVMe spool into export-format files.
+
+Build 41 ran 2026-07-09 21:09 → 2026-07-10 00:55 UTC (~3h45m) but the
+Postgres DB was wiped before the spool importer could process it. This script
+reads the raw spool files directly and produces the same export-format files
+that `export.py` would have written, with build_id=41 throughout.
+
+Outputs (written into the recorder repo's data/exports/):
+  telemetry/41.parquet       — (ts, sensor_id, kind, value)
+  position_hf/41.parquet     — (ts, x, y, z1, z2, r, has_homed)
+  frames.jsonl               — appended rows with build_id=41
+  builds.jsonl               — appended row with id=41
+  events.jsonl               — appended build_start row with build_id=41
+
+Safe to re-run: telemetry and position_hf parquets are overwritten; jsonl
+files are checked first and a second run skips appending if id=41 is already
+present.
+"""
+import json
+import sys
+from pathlib import Path
+from datetime import datetime, timezone
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+def parse_ts(s: str) -> datetime:
+    """Parse ISO 8601 string (with tz offset or Z) to a UTC-aware datetime."""
+    return datetime.fromisoformat(s.replace("Z", "+00:00"))
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from _lib import EXPORTS_DIR, AGENTIC_ROOT
+
+SPOOL_DIR = Path("/home/ppak/.agentic-sls/spool/41")
+BUILD_ID = 41
+JOB_NAME = "Unknown 2026_07_09"
+
+
+def expand_snapshot(snap: dict) -> list[dict]:
+    """Mirror telemetry.ts:expand() — one JSON spool line → list of rows."""
+    ts = snap["respondedAt"]
+    s = snap["data"]
+    rows: list[dict] = []
+
+    for k in ("x", "y", "z1", "z2", "r"):
+        rows.append({"ts": ts, "sensor_id": "positions", "kind": f"position.{k}",
+                     "value": float(s["position"][k])})
+
+    rows.append({"ts": ts, "sensor_id": "lights", "kind": "lights.enabled",
+                 "value": 1.0 if s["lights"]["isEnabled"] else 0.0})
+    rows.append({"ts": ts, "sensor_id": "lights", "kind": "lights.count",
+                 "value": float(s["lights"]["lightCount"])})
+
+    for e in s["power"]["entries"]:
+        rows.append({"ts": ts, "sensor_id": e["id"], "kind": "power",
+                     "value": float(e["power"])})
+    pm = s["power"]["powerman"]
+    rows.append({"ts": ts, "sensor_id": "powerman", "kind": "power.current",
+                 "value": float(pm["currentPower"])})
+    rows.append({"ts": ts, "sensor_id": "powerman", "kind": "power.required",
+                 "value": float(pm["requiredPower"])})
+    rows.append({"ts": ts, "sensor_id": "powerman", "kind": "power.max",
+                 "value": float(pm["maxPower"])})
+
+    for e in s["temperature"]["entries"]:
+        rows.append({"ts": ts, "sensor_id": e["id"], "kind": "temp.current",
+                     "value": float(e["currentTemperature"])})
+        rows.append({"ts": ts, "sensor_id": e["id"], "kind": "temp.average",
+                     "value": float(e["averageTemperature"])})
+        tgt = e.get("targetTemperature")
+        if tgt is not None:
+            rows.append({"ts": ts, "sensor_id": e["id"], "kind": "temp.target",
+                         "value": float(tgt)})
+
+    return rows
+
+
+def build_telemetry_parquet() -> tuple[str, str]:
+    """Expand spool telemetry → data/exports/telemetry/41.parquet.
+    Returns (first_ts_str, last_ts_str) for builds.jsonl."""
+    path = SPOOL_DIR / "telemetry.ndjson"
+    out = EXPORTS_DIR / "telemetry" / f"{BUILD_ID}.parquet"
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    schema = pa.schema([
+        pa.field("ts",        pa.timestamp("us", tz="UTC")),
+        pa.field("sensor_id", pa.string()),
+        pa.field("kind",      pa.string()),
+        pa.field("value",     pa.float64()),
+    ])
+
+    BATCH = 50_000
+    first_ts = last_ts = None
+    bad = 0
+    total = 0
+
+    with pq.ParquetWriter(out, schema, compression="zstd") as writer:
+        buf: list[dict] = []
+
+        def flush():
+            nonlocal total
+            if not buf:
+                return
+            ts_arr = pa.array([parse_ts(r["ts"]) for r in buf], type=pa.timestamp("us", tz="UTC"))
+            table = pa.table({
+                "ts":        ts_arr,
+                "sensor_id": pa.array([r["sensor_id"] for r in buf], type=pa.string()),
+                "kind":      pa.array([r["kind"]      for r in buf], type=pa.string()),
+                "value":     pa.array([r["value"]     for r in buf], type=pa.float64()),
+            }, schema=schema)
+            writer.write_table(table)
+            total += len(buf)
+            buf.clear()
+
+        with path.open(encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    snap = json.loads(line)
+                except json.JSONDecodeError:
+                    bad += 1
+                    continue
+                ts = snap.get("respondedAt")
+                if first_ts is None:
+                    first_ts = ts
+                last_ts = ts
+                try:
+                    rows = expand_snapshot(snap)
+                except Exception:
+                    bad += 1
+                    continue
+                buf.extend(rows)
+                if len(buf) >= BATCH:
+                    flush()
+        flush()
+
+    print(f"  telemetry: {total:,} rows, {bad} bad lines → {out.name}")
+    return first_ts, last_ts
+
+
+def build_position_parquet():
+    path = SPOOL_DIR / "position.ndjson"
+    out = EXPORTS_DIR / "position_hf" / f"{BUILD_ID}.parquet"
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    schema = pa.schema([
+        pa.field("ts",        pa.timestamp("us", tz="UTC")),
+        pa.field("x",         pa.float64()),
+        pa.field("y",         pa.float64()),
+        pa.field("z1",        pa.float64()),
+        pa.field("z2",        pa.float64()),
+        pa.field("r",         pa.float64()),
+        pa.field("has_homed", pa.bool_()),
+    ])
+
+    rows: list[dict] = []
+    bad = 0
+    with path.open(encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rec = json.loads(line)
+                d = rec["data"]
+                rows.append({
+                    "ts":       rec["respondedAt"],
+                    "x":        float(d["x"]),
+                    "y":        float(d["y"]),
+                    "z1":       float(d["z1"]),
+                    "z2":       float(d["z2"]),
+                    "r":        float(d["r"]),
+                    "has_homed": bool(d["hasHomed"]),
+                })
+            except Exception:
+                bad += 1
+
+    if rows:
+        table = pa.table({
+            "ts":        pa.array([parse_ts(r["ts"]) for r in rows], type=pa.timestamp("us", tz="UTC")),
+            "x":         pa.array([r["x"]  for r in rows], type=pa.float64()),
+            "y":         pa.array([r["y"]  for r in rows], type=pa.float64()),
+            "z1":        pa.array([r["z1"] for r in rows], type=pa.float64()),
+            "z2":        pa.array([r["z2"] for r in rows], type=pa.float64()),
+            "r":         pa.array([r["r"]  for r in rows], type=pa.float64()),
+            "has_homed": pa.array([r["has_homed"] for r in rows], type=pa.bool_()),
+        }, schema=schema)
+        pq.write_table(table, out, compression="zstd")
+    print(f"  position_hf: {len(rows):,} rows, {bad} bad lines → {out.name}")
+
+
+def append_frames_jsonl():
+    path = SPOOL_DIR / "frames.ndjson"
+    out = EXPORTS_DIR / "frames.jsonl"
+
+    # Idempotency: skip if already appended.
+    if out.exists():
+        with out.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    if r.get("build_id") == BUILD_ID:
+                        print(f"  frames.jsonl: build {BUILD_ID} already present, skipping")
+                        return
+                except Exception:
+                    pass
+
+    # Determine the highest existing frame id so we can assign new ones.
+    max_id = 0
+    if out.exists():
+        with out.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    max_id = max(max_id, int(r.get("id", 0)))
+                except Exception:
+                    pass
+
+    rows: list[dict] = []
+    bad = 0
+    with path.open(encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rec = json.loads(line)
+                rows.append({
+                    "id":       max_id + len(rows) + 1,
+                    "build_id": BUILD_ID,
+                    "ts":       rec["respondedAt"],
+                    "kind":     rec["kind"],
+                    "path":     rec["path"],
+                })
+            except Exception:
+                bad += 1
+
+    with out.open("a", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r) + "\n")
+    print(f"  frames.jsonl: appended {len(rows):,} rows, {bad} bad lines")
+
+
+def append_builds_jsonl(started_at: str, ended_at: str):
+    out = EXPORTS_DIR / "builds.jsonl"
+
+    if out.exists():
+        with out.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    if r.get("id") == BUILD_ID:
+                        print(f"  builds.jsonl: build {BUILD_ID} already present, skipping")
+                        return
+                except Exception:
+                    pass
+
+    row = {
+        "id":         BUILD_ID,
+        "job_name":   JOB_NAME,
+        "started_at": started_at,
+        "ended_at":   ended_at,
+        "phase":      "recovered",
+        "params":     {"notes": "recovered from NVMe spool after DB reset"},
+        "notes":      "spool-only recovery; job_name is a placeholder",
+    }
+    with out.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(row) + "\n")
+    print(f"  builds.jsonl: appended build {BUILD_ID}")
+
+
+def append_events_jsonl(started_at: str):
+    """Add a build_start event so load_build_to_profile_name() can find
+    this build. Profile name is unknown; leave null."""
+    out = EXPORTS_DIR / "events.jsonl"
+
+    if out.exists():
+        with out.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    if r.get("build_id") == BUILD_ID and r.get("kind") == "build_start":
+                        print(f"  events.jsonl: build_start for {BUILD_ID} already present, skipping")
+                        return
+                except Exception:
+                    pass
+
+    row = {
+        "id":       -41,
+        "build_id": BUILD_ID,
+        "ts":       started_at,
+        "kind":     "build_start",
+        "message":  JOB_NAME,
+        "payload":  {"printProfileName": None, "notes": "recovered from spool"},
+    }
+    with out.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(row) + "\n")
+    print(f"  events.jsonl: appended build_start for build {BUILD_ID}")
+
+
+def main():
+    if not SPOOL_DIR.exists():
+        print(f"Spool dir not found: {SPOOL_DIR}")
+        sys.exit(1)
+
+    print(f"Recovering build {BUILD_ID} from spool: {SPOOL_DIR}")
+    started_at, ended_at = build_telemetry_parquet()
+    build_position_parquet()
+    append_frames_jsonl()
+    append_builds_jsonl(started_at, ended_at)
+    append_events_jsonl(started_at)
+    print("Done. Run:  uv run scripts/ticks/01_extract.py 41")
+
+
+if __name__ == "__main__":
+    main()