Merge release/v2.3.0

Co-Authored-By: Claude Fable 5.1 <[email protected]>

.gitea/workflows/ci.yml

@@ -22,5 +22,19 @@ jobs:
         run: rustup component add rustfmt clippy
       - name: Install thumbv7em-none-eabihf target
         run: rustup target add thumbv7em-none-eabihf
+      - name: Install Python interop dependencies
+        # The interop suites used to skip silently when python3/h5py were
+        # missing, so they never ran in CI. Install them and make a missing
+        # dependency a failure (CLAWHDF5_REQUIRE_INTEROP below).
+        run: |
+          apt-get update
+          apt-get install -y --no-install-recommends python3 python3-venv
+          python3 -m venv /opt/interop
+          /opt/interop/bin/pip install --no-cache-dir h5py numpy netCDF4 xarray
+          echo "/opt/interop/bin" >> "$GITHUB_PATH"
+      - name: Show interop library versions
+        run: python3 -c "import h5py, netCDF4; print('h5py', h5py.__version__, 'HDF5', h5py.version.hdf5_version, 'netCDF4', netCDF4.__version__)"
       - name: Run CI script
+        env:
+          CLAWHDF5_REQUIRE_INTEROP: "1"
         run: bash scripts/ci-test.sh

CHANGELOG.md

@@ -1,6 +1,156 @@
 # Changelog
 
-## Unreleased
+## v2.3.0 (2026-09-19)
+
+### Upgrade Notes
+- **A memory store now has a single writer.** `HDF5Memory::create`/`open` take
+  an exclusive lock (`<store>.h5.lock`); a second open of the same store — in
+  the same or another process — returns `MemoryError::Locked`. Code that opened
+  a second handle just to read should use `HDF5Memory::open_read_only`.
+- **Unsigned array attributes arrive as `AttrValue::U64Array`**, not
+  `I64Array`, and `attrs()` may now return `AttrValue::Raw`. Exhaustive matches
+  on `AttrValue` need the two new arms.
+- **WAL header version 3 → 4.** v3 files are read and upgraded in place, but a
+  store written by 2.3.0 with a pending WAL cannot be opened by 2.2.0 or
+  earlier (it is refused, not corrupted). Checkpoint first
+  (`flush_wal`) if you need to downgrade.
+- `MemoryConfig::compression` now uses deflate unless the agent's new `zstd`
+  feature is enabled; it previously failed outright in a default build.
+- `MemoryError` gained `Locked`; `FormatError` gained `UnresolvedSharedMessage`,
+  `ExternalDataFilesUnsupported` and `ExternalLinkUnsupported`; `MessageType`
+  gained `ExternalDataFiles`.
+
+### Bug Fixes
+- `clawhdf5-format`: compound datatypes written with **default libver bounds**
+  (datatype message version 1 — what plain `h5py.File(path, 'w')` produces)
+  were mis-parsed. The v1 member layout carries 28 bytes of legacy array
+  fields after the byte offset (the parser skipped 24), and v2 pads member
+  names to 8 bytes and has no array fields at all (the parser did neither), so
+  every member after the first byte offset was read from the wrong position —
+  typically surfacing as `Overflow("compound member ...")` on read. Found by
+  adding a default-libver axis to the h5py interop tests; byte-level regression
+  tests for v1 and v2 added.
+- `clawhdf5-gpu`: `gpu_tests` could hang forever under the default parallel
+  test runner — every test created its own wgpu instance and device at once.
+  Tests now serialise GPU access, and GPU→CPU readback waits are bounded
+  (30 s) so a wedged driver returns `GpuError::BufferMap` instead of blocking.
+- `clawhdf5-agent`: `benches/bench.rs` and `benches/memory_bench.rs` no longer
+  compiled against the current `strategy`/`consolidation` APIs.
+
+### HDF5 Compatibility
+- `clawhdf5-format`/`clawhdf5`: datasets and attributes that use a **committed
+  (named) datatype** now read correctly. They store a shared-message reference;
+  the facade parsed the reference bytes as the datatype (`Time { size: 0 }`,
+  unreadable data) and silently dropped such attributes. The shared-reference
+  parser itself was wrong for real files: version 2 has no reserved bytes, and
+  the version 3 types were inverted (1 = SOHM heap, 2 = committed).
+- **Fill values are applied on read.** There was no Fill Value message parser:
+  the holes of a sparse chunked dataset read as zeros even when the fill value
+  was not zero (silently wrong data), and a dataset that was created but never
+  written failed with `NoDataAllocated` where h5py returns a filled array.
+  Messages v1–v3 and the old 0x0004 form are parsed; the fill value is written
+  into exactly the chunk-grid cells missing from the chunk index.
+- **Soft links are followed** during path resolution, in old- and new-style
+  groups (absolute/relative targets, links to groups, links through links),
+  with a depth limit so a link cycle is an error rather than a hang. A dangling
+  link reports the target it could not find.
+- Things the reader does not follow are now explicit errors instead of wrong
+  answers: an external link is `ExternalLinkUnsupported { filename,
+  object_path }` (was `PathNotFound`), and a dataset whose raw data lives in
+  external files (message 0x0007, now a known `MessageType`) is
+  `ExternalDataFilesUnsupported` (it would otherwise read as fill values).
+- **`attrs()` no longer drops attributes.** Any attribute whose datatype had
+  no `AttrValue` variant was omitted with no error — including every Python
+  `bool` (h5py stores `attrs["flag"] = True` as an enum), complex numbers,
+  compound values and object references. Now:
+  - numpy/h5py-style booleans (an enum of exactly `FALSE`=0 / `TRUE`=1) decode
+    as `I64` / `I64Array` of 0/1;
+  - new `AttrValue::U64Array` keeps unsigned arrays unsigned (they were cast to
+    `I64Array`, so values above `i64::MAX` came back negative). **Behaviour
+    change:** code matching `I64Array` for an unsigned attribute must also
+    match `U64Array` (the netCDF-4 CF helpers and Python bindings do);
+  - new `AttrValue::Raw { datatype, shape, data }` carries everything else
+    verbatim, decodable with `clawhdf5_format::data_read` against `datatype`.
+  Both new variants are writable, so an attribute can be copied between files
+  unchanged. Python receives `Raw` as `{"dtype", "shape", "data"}`.
+- All of the above are covered by h5py interop tests under both default and
+  `libver='latest'` bounds, compared against h5py's own readback.
+
+### Security
+- `clawhdf5`: virtual-dataset source file names are untrusted input but were
+  joined straight onto the opened file's directory, so a crafted file could
+  make the reader open any path the process can reach (absolute path, or `..`
+  components). Only plain relative paths inside that directory are accepted.
+
+### Durability & Integrity
+- `clawhdf5-agent`: a crash between writing a checkpoint and truncating the WAL
+  no longer **duplicates every pending entry** on the next open. Each
+  checkpoint records a `WalMark` (byte length + chained CRC of the WAL prefix it
+  folded in) in `/meta`; `open()` skips exactly that prefix when it is still
+  present. No WAL format change for this; older files behave as before.
+- `clawhdf5-agent`: checkpoints and snapshots are durable as a unit — the temp
+  file is synced before the rename and the directory after it. Individual WAL
+  appends remain unsynced by design (documented in `CLAUDE.md`).
+- `clawhdf5-agent`: `save_or_update` hits are logged as a new `Update` WAL
+  record, so replay updates in place instead of appending a duplicate. WAL
+  header version 3 → 4 (so older builds refuse the file rather than truncating
+  a record they can't parse); v3 files are read and upgraded in place.
+- `clawhdf5-agent`: loading validates every per-record dataset length (a
+  truncated store is now `MemoryError::Schema`, not a later panic), fixes the
+  `n.len() == n.len()` tautology that trusted a norms dataset of any length,
+  and rejects `embedding_dim == 0` with records present.
+- `clawhdf5-agent`: eight behavioural `MemoryConfig` fields are now persisted in
+  `/meta`. Previously they reset to defaults on every open — a compressed store
+  was rewritten uncompressed, `wal_enabled = false` flipped back to `true`.
+- `clawhdf5-agent`: `compression = true` never worked in a default build (it
+  requested Zstd without enabling the feature, so every checkpoint failed with
+  `unsupported filter: 32015`). Default builds now use deflate; Zstd is the new
+  opt-in `zstd` feature.
+- `clawhdf5-agent`: **single-writer lock** (`<store>.h5.lock`,
+  `MemoryError::Locked`) — two handles on one store used to silently destroy
+  each other's data. New `HDF5Memory::open_read_only` gives a lock-free,
+  never-writing view; the CLI's read-only subcommands use it.
+- `clawhdf5-agent`: an unreadable WAL (torn header / bad magic) is quarantined
+  (`HDF5Memory::quarantined_wal()`) instead of blocking `open()` of a healthy
+  store. A WAL from an unknown newer version still fails and is left intact.
+- `clawhdf5-agent`: provenance records are renumbered on compaction (they
+  weren't, so every later `save_or_update` raised a false High integrity
+  alert); pending anomaly alerts and tracked sessions are bounded;
+  `snapshot()` includes entries still in the WAL.
+- `clawhdf5-agent`: hybrid ranking is deterministic (index tie-breaks instead
+  of `HashMap` order); a set of identical positive scores — including a single
+  candidate — normalises to 1.0 rather than 0.0; the Hebbian boost no longer
+  reinforces zero-score filler results.
+- `clawhdf5-format`: chunked/VDS/hyperslab reads size their buffers with
+  overflow-checked arithmetic and fallible allocation, so crafted dimensions
+  are `FormatError::Overflow` instead of a wrapped size or a process abort;
+  `parallel_read` bounds checks use `checked_add`.
+- `clawhdf5`: a malformed filter-pipeline message is an error instead of being
+  treated as "no filters" (which returned compressed bytes as data);
+  `FileBuilder::write` is atomic and synced instead of truncating the
+  destination first.
+
+### CI / Testing
+- CI now lints every target (`cargo clippy --all-targets`) plus
+  `clawhdf5-format`'s optional features, compiles all benches, and tests the
+  format feature matrix. Previously test/bench code and feature-gated modules
+  were never linted; the accumulated clippy backlog is fixed.
+- CI installs python3 + h5py/numpy/netCDF4/xarray and sets
+  `CLAWHDF5_REQUIRE_INTEROP=1`, which turns a missing interop dependency into a
+  test **failure**. Until now every h5py/netCDF4 interop test silently skipped
+  in CI, which is how the HDF5 2.0 compound bug fixed in v2.2.0 reached a user.
+  The `#[ignore]`d `writer_h5py_tests` suite is run explicitly.
+- h5py-generated-file tests now cover default libver bounds as well as
+  `libver='latest'` (HDF5 2.0 raised the default low bound to 1.8).
+- `clawhdf5-agent`: WAL property tests (round trip; after any corruption the
+  entries read back are an exact prefix of what was written — 1500 seeded
+  cases), a crash-recovery matrix (an on-disk image after every operation, the
+  checkpoint window, and the WAL torn at every byte length, each reopened and
+  checked against a model), and a WAL fuzz target.
+- Optional fuzz smoke run (`CLAWHDF5_FUZZ_SECONDS=N scripts/ci-test.sh`); new
+  datatype corpus seeds for v1 compound and native complex messages.
+
+## v2.2.0 (2026-09-18)
 
 ### Security
 - `clawhdf5-format`: bounded decompression output (`MAX_DECOMPRESS_SIZE`) for
@@ -245,6 +395,16 @@
   reading compound types and — critically — every chunked/compressed dataset
   written by HDF5 2.0. Found by running the h5py interop tests against
   h5py 3.16 / HDF5 2.0.
+  Independently reported (with a patch) against the v2.1.0 tag by
+  M. Scot Breitenfeld (The HDF Group) — v2.1.0 predates this fix.
+- `clawhdf5-format`: parse HDF5 2.0 native complex datatypes (class 11,
+  datatype version 5, e.g. `H5T_COMPLEX_IEEE_F64LE`). The properties are a
+  single base floating-point datatype, not a compound-style member list; the
+  old parser read the base type's bytes as member names, producing a garbage
+  datatype, and failed with `UnexpectedEof` when a complex type was nested in
+  a compound. It is now surfaced as the equivalent `{r, i}` compound (the
+  shape h5py writes for numpy complex dtypes), with a size check against the
+  base type. Validated end-to-end against an HDF5 2.0-written file.
 
 ### Performance
 - `clawhdf5-format`: chunked writes now compress all chunks up front via

CLAUDE.md

@@ -33,7 +33,48 @@ Cargo workspace with 16 crates under `crates/` (plus `libaec-sys`, an internal F
   the approximate `clawhdf5-ann` index for the vector stage (the index mirrors
   the cache and self-heals on drift). Build the agent with
   `--no-default-features --features float16` to force the exact linear cosine scan.
-- WAL (write-ahead log) for crash-safe persistence, with a CRC32 trailer per entry so a corrupted entry stops replay cleanly instead of loading bad data
+- WAL (write-ahead log) for crash-safe persistence, with a chained CRC32
+  trailer per entry (each entry's CRC folds in the previous entry's CRC) so a
+  corrupted, reordered, duplicated, or spliced entry stops replay cleanly
+  instead of loading bad or tampered data. The pre-chaining per-entry-CRC
+  format (v2) is still fully readable; the oldest no-CRC format (v1) is only
+  reachable through the one-time migration path in `HDF5Memory::open`, not
+  through the public `WalFile::read_entries`.
+  **What the WAL guarantees:** integrity, ordering, and recovery from a
+  *process* crash at any point — including between a checkpoint and the WAL
+  truncate (each checkpoint records a `WalMark` in `/meta`, and `open()` skips
+  the WAL prefix the `.h5` already contains, so entries are never applied
+  twice). Checkpoints and snapshots are made durable as a unit (temp file
+  synced, renamed, directory synced). **What it does not guarantee:**
+  individual WAL appends are *not* fsynced (a deliberate latency trade-off), so
+  saves made since the last checkpoint can be lost on power failure or kernel
+  panic. Current header version is 4 (adds the `Update` record used by
+  `save_or_update`); v3 files are read and upgraded in place.
+- A store has a **single writer**: `HDF5Memory::create`/`open` hold an exclusive
+  advisory lock on `<store>.h5.lock` and a second opener gets
+  `MemoryError::Locked`. Use `HDF5Memory::open_read_only` for a lock-free,
+  never-writing point-in-time view (the CLI's `recall`/`stats`/`agents-md`/
+  `export` do). An unreadable WAL (torn header, bad magic) is quarantined to
+  `<store>.h5.wal.corrupt-<ts>` rather than blocking `open()`; a WAL with an
+  unknown *newer* version still fails and is left untouched.
+- `MemoryConfig::compression` uses deflate by default; enable the agent's
+  `zstd` feature to compress embeddings with Zstd instead (links libzstd).
+- `Dataset::verify_provenance()` (clawhdf5 facade, `provenance` feature, on by
+  default) recomputes a dataset's SHA-256 and compares it against the
+  `_provenance_sha256` attribute written automatically on save when
+  `DatasetBuilder::with_provenance` is used. It's opt-in per call, not run
+  automatically on open — it decodes and hashes the whole dataset. The hash
+  is unkeyed (tamper-*evident*, not tamper-*proof*): it detects accidental
+  corruption, not a deliberate actor able to modify both the data and the
+  stored hash.
+- `clawhdf5-agent`'s `HDF5Memory::save`/`save_batch`/`save_or_update` run every
+  write through an in-memory (session-scoped, not persisted to disk)
+  provenance ledger and write-anomaly detector: a content hash per record
+  (`provenance.rs`) for detecting accidental mid-session corruption, plus
+  rate-limit/injection-pattern/source-distribution checks (`anomaly.rs`).
+  Alerts never block a save — drain them with `HDF5Memory::take_anomaly_alerts`.
+  `MemorySource` for this bookkeeping is inferred from the caller-supplied
+  `source_channel` string (a heuristic, not an authenticated trust boundary).
 - GPU-accelerated batch I/O for large dataset processing
 - Python and Node.js bindings for cross-language use
 - NetCDF-4 compatibility for scientific data interop

Cargo.toml

@@ -21,10 +21,10 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 
 [workspace.dependencies]
 tempfile = "3"

crates/clawhdf5-accel/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "clawhdf5-accel"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "SIMD-accelerated operations for rustyhdf5"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "simd", "acceleration", "performance"]
 categories = ["science", "algorithms"]

crates/clawhdf5-accel/src/avx2.rs

@@ -111,7 +111,11 @@ pub unsafe fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
         }
 
         let denom = (norm_a * norm_b).sqrt();
-        if denom == 0.0 { 0.0 } else { dot / denom }
+        if denom < f32::EPSILON {
+            0.0
+        } else {
+            dot / denom
+        }
     }
 }
 

crates/clawhdf5-accel/src/avx512.rs

@@ -89,7 +89,11 @@ pub unsafe fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
         }
 
         let denom = (norm_a * norm_b).sqrt();
-        if denom == 0.0 { 0.0 } else { dot / denom }
+        if denom < f32::EPSILON {
+            0.0
+        } else {
+            dot / denom
+        }
     }
 }
 

crates/clawhdf5-accel/src/lib.rs

@@ -361,6 +361,18 @@ mod tests {
         assert!(approx_eq(cosine_similarity(&a, &b), 0.0, EPSILON));
     }
 
+    #[test]
+    fn test_cosine_near_zero_norm_clamped() {
+        // denom = 1e-4 * 1e-4 = 1e-8, comfortably below f32::EPSILON
+        // (~1.19e-7) but not exactly 0.0 — must still clamp to 0.0 so
+        // callers computing `1.0 - cosine_similarity(...)` treat these
+        // as maximally dissimilar, matching the pre-SIMD scalar guard.
+        let a = [1e-4f32];
+        let b = [1e-4f32];
+        assert_eq!(cosine_similarity(&a, &b), 0.0);
+        assert_eq!(scalar::cosine_similarity(&a, &b), 0.0);
+    }
+
     #[test]
     fn test_cosine_scalar_vs_dispatch() {
         let a: Vec<f32> = (0..384).map(|i| (i as f32).sin()).collect();

crates/clawhdf5-accel/src/neon.rs

@@ -94,7 +94,11 @@ pub unsafe fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
     }
 
     let denom = (norm_a * norm_b).sqrt();
-    if denom == 0.0 { 0.0 } else { dot / denom }
+    if denom < f32::EPSILON {
+        0.0
+    } else {
+        dot / denom
+    }
 }
 
 /// NEON L2 distance.

crates/clawhdf5-accel/src/scalar.rs

@@ -21,7 +21,11 @@ pub fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
         norm_b += y * y;
     }
     let denom = (norm_a * norm_b).sqrt();
-    if denom == 0.0 { 0.0 } else { dot / denom }
+    if denom < f32::EPSILON {
+        0.0
+    } else {
+        dot / denom
+    }
 }
 
 pub fn batch_cosine(query: &[f32], vectors: &[&[f32]], results: &mut [(usize, f32)]) {

crates/clawhdf5-agent/Cargo.toml

@@ -1,21 +1,21 @@
 [package]
 name = "clawhdf5-agent"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "HDF5-backed persistent memory store for on-device AI agents"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["agent", "memory", "hdf5", "vector-search", "embedding"]
 categories = ["database", "science", "algorithms"]
 
 [dependencies]
-clawhdf5-format = { path = "../clawhdf5-format", version = "2.1.0", features = ["parallel", "fast-checksum"] }
+clawhdf5-format = { path = "../clawhdf5-format", version = "2.3.0", features = ["parallel", "fast-checksum"] }
-clawhdf5 = { path = "../clawhdf5", version = "2.1.0" }
+clawhdf5 = { path = "../clawhdf5", version = "2.3.0" }
-clawhdf5-io = { path = "../clawhdf5-io", version = "2.1.0", features = ["mmap"] }
+clawhdf5-io = { path = "../clawhdf5-io", version = "2.3.0", features = ["mmap"] }
-clawhdf5-accel = { path = "../clawhdf5-accel", version = "2.1.0" }
+clawhdf5-accel = { path = "../clawhdf5-accel", version = "2.3.0" }
-clawhdf5-ann = { path = "../clawhdf5-ann", version = "2.1.0", optional = true }
+clawhdf5-ann = { path = "../clawhdf5-ann", version = "2.3.0", optional = true }
-clawhdf5-gpu = { path = "../clawhdf5-gpu", version = "2.1.0", optional = true, default-features = false }
+clawhdf5-gpu = { path = "../clawhdf5-gpu", version = "2.3.0", optional = true, default-features = false }
 serde = { workspace = true }
 byteorder = "1"
 half = { workspace = true, optional = true }
@@ -48,6 +48,9 @@ harness = false
 default = ["float16", "hnsw"]
 float16 = ["half"]
 parallel = ["rayon"]
+# Compress embeddings with Zstd instead of deflate when
+# `MemoryConfig::compression` is on. Off by default: it links libzstd (C).
+zstd = ["clawhdf5/zstd"]
 # HNSW approximate-nearest-neighbour acceleration for the vector stage of
 # hybrid_search. On by default; the index is rebuilt from the cache on demand
 # and stays self-consistent with the persisted memory store. Disable with

crates/clawhdf5-agent/benches/bench.rs

@@ -483,7 +483,7 @@ fn rayon_benches(c: &mut Criterion) {
                 use rayon::prelude::*;
                 let query_norm = vector_search::compute_norm(&query);
                 let num_cores = rayon::current_num_threads().max(1);
-                let chunk_size = (n + num_cores - 1) / num_cores;
+                let chunk_size = n.div_ceil(num_cores);
                 let mut results: Vec<(usize, f32)> = vectors
                     .par_chunks(chunk_size)
                     .enumerate()
@@ -537,7 +537,7 @@ fn rayon_benches(c: &mut Criterion) {
                 use rayon::prelude::*;
                 let query_norm = vector_search::compute_norm(&query);
                 let num_cores = rayon::current_num_threads().max(1);
-                let chunk_size = (n + num_cores - 1) / num_cores;
+                let chunk_size = n.div_ceil(num_cores);
                 let mut results: Vec<(usize, f32)> = vectors
                     .par_chunks(chunk_size)
                     .enumerate()
@@ -766,12 +766,22 @@ fn adaptive_benches(c: &mut Criterion) {
         .map(|v| vector_search::compute_norm(v))
         .collect();
     let tombstones = vec![0u8; n];
+    let flat: Vec<f32> = vectors.iter().flatten().copied().collect();
 
     c.bench_function("adaptive_search_10k", |b| {
         let hw = HardwareCapabilities::detect();
         let strat = strategy::auto_select_strategy(n, &hw);
         b.iter(|| {
-            strategy::search_with_metrics(&query, &vectors, &norms, &tombstones, 10, strat, None)
+            strategy::search_with_metrics(
+                &query,
+                &vectors,
+                &flat,
+                &norms,
+                &tombstones,
+                10,
+                strat,
+                None,
+            )
         });
     });
 
@@ -781,6 +791,7 @@ fn adaptive_benches(c: &mut Criterion) {
             strategy::search_with_metrics(
                 &query,
                 &vectors,
+                &flat,
                 &norms,
                 &tombstones,
                 10,
@@ -795,6 +806,7 @@ fn adaptive_benches(c: &mut Criterion) {
             strategy::search_with_metrics(
                 &query,
                 &vectors,
+                &flat,
                 &norms,
                 &tombstones,
                 10,
@@ -809,6 +821,7 @@ fn adaptive_benches(c: &mut Criterion) {
             strategy::search_with_metrics(
                 &query,
                 &vectors,
+                &flat,
                 &norms,
                 &tombstones,
                 10,

crates/clawhdf5-agent/benches/memory_bench.rs

@@ -1,6 +1,7 @@
 use clawhdf5_agent::bm25::BM25Index;
 use clawhdf5_agent::consolidation::{
     ConsolidationConfig, ConsolidationEngine, ImportanceScorer, ImportanceWeights, MemorySource,
+    UntrustedSource,
 };
 use clawhdf5_agent::hybrid::{hybrid_search, rrf_hybrid_search};
 use clawhdf5_agent::knowledge::KnowledgeCache;
@@ -285,7 +286,12 @@ fn consolidation_benches(c: &mut Criterion) {
                         for i in 0..n {
                             let embedding = make_vec(&mut rng, DIM);
                             let chunk = format!("memory record {i} with some content");
-                            engine.add_memory(chunk, embedding, MemorySource::User, now + i as f64);
+                            engine.add_memory(
+                                chunk,
+                                embedding,
+                                UntrustedSource::User,
+                                now + i as f64,
+                            );
                         }
                         engine
                     },
@@ -307,9 +313,10 @@ fn consolidation_benches(c: &mut Criterion) {
         for i in 0..50usize {
             let embedding = make_vec(&mut rng, DIM);
             let chunk = format!("existing record {i}");
-            engine.add_memory(chunk, embedding, MemorySource::User, now + i as f64);
+            engine.add_memory(chunk, embedding, UntrustedSource::User, now + i as f64);
         }
         let records = engine.records().to_vec();
+        let record_refs: Vec<&_> = records.iter().collect();
         let weights = ImportanceWeights::default();
         let query_embedding = make_vec(&mut rng, DIM);
         let sample_text =
@@ -317,7 +324,7 @@ fn consolidation_benches(c: &mut Criterion) {
 
         group.bench_function("bench_importance_scoring", |b| {
             b.iter(|| {
-                let surprise = ImportanceScorer::score_surprise(&query_embedding, &records);
+                let surprise = ImportanceScorer::score_surprise(&query_embedding, &record_refs);
                 let correction = ImportanceScorer::score_correction(&MemorySource::Correction);
                 let length = ImportanceScorer::score_length(sample_text);
                 ImportanceScorer::score_combined(surprise, correction, length, &weights)
@@ -354,7 +361,7 @@ fn temporal_benches(c: &mut Criterion) {
     // Insert benchmark: measure time to insert 10k timestamps one by one
     group.bench_function("bench_temporal_insert_10k", |b| {
         b.iter_batched(
-            || TemporalIndex::new(),
+            TemporalIndex::new,
             |mut idx| {
                 for i in 0..N {
                     // Shuffle insertion order slightly using a simple offset pattern
@@ -442,7 +449,8 @@ fn large_consolidation_benches(c: &mut Criterion) {
     let mut group = c.benchmark_group("consolidation_large");
     group.sample_size(10);
 
-    for (label, n) in [("10k", 10_000usize)] {
+    {
+        let (label, n) = ("10k", 10_000usize);
         group.bench_with_input(
             BenchmarkId::new("bench_consolidation_cycle", label),
             &n,
@@ -459,7 +467,12 @@ fn large_consolidation_benches(c: &mut Criterion) {
                         for i in 0..n {
                             let embedding = make_vec(&mut rng, DIM);
                             let chunk = format!("memory record {i} with content");
-                            engine.add_memory(chunk, embedding, MemorySource::User, now + i as f64);
+                            engine.add_memory(
+                                chunk,
+                                embedding,
+                                UntrustedSource::User,
+                                now + i as f64,
+                            );
                         }
                         engine
                     },

crates/clawhdf5-agent/fuzz/.gitignore

@@ -0,0 +1,3 @@
+target/
+artifacts/
+coverage/

crates/clawhdf5-agent/fuzz/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "clawhdf5-agent-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2024"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+tempfile = "3"
+
+[dependencies.clawhdf5-agent]
+path = ".."
+
+[workspace]
+members = ["."]
+
+[[bin]]
+name = "fuzz_wal_replay"
+path = "fuzz_targets/fuzz_wal_replay.rs"
+doc = false

crates/clawhdf5-agent/fuzz/fuzz_targets/fuzz_wal_replay.rs

@@ -0,0 +1,36 @@
+#![no_main]
+//! Arbitrary bytes as a WAL file. Reading, and opening for append (which scans
+//! the chain and truncates an unverifiable tail), must never panic, hang, or
+//! allocate without bound — and after `open` repairs the file, everything
+//! `read_entries` returned before must still be returned.
+//!
+//! The deterministic counterpart that runs in ordinary CI is
+//! `tests/wal_properties.rs`; this target explores inputs it cannot reach.
+
+use std::io::Write as _;
+
+use clawhdf5_agent::wal::WalFile;
+use libfuzzer_sys::fuzz_target;
+
+fuzz_target!(|data: &[u8]| {
+    let Ok(mut tmp) = tempfile::NamedTempFile::new() else {
+        return;
+    };
+    if tmp.write_all(data).and_then(|()| tmp.flush()).is_err() {
+        return;
+    }
+    let before = WalFile::read_entries(tmp.path()).map(|e| e.len());
+    // Only the chained formats (header versions 3 and 4) are repaired in
+    // place. `open` deliberately recreates a legacy-format file from scratch:
+    // `HDF5Memory::open` has already replayed its entries by then.
+    let chained = matches!(data.get(4), Some(3 | 4));
+    let opened = WalFile::open(tmp.path());
+    if !chained {
+        return;
+    }
+    if let (Ok(before), Ok(wal)) = (before, opened) {
+        drop(wal);
+        let after = WalFile::read_entries(tmp.path()).map(|e| e.len());
+        assert_eq!(after.ok(), Some(before), "open() changed what is replayable");
+    }
+});

crates/clawhdf5-agent/src/anomaly.rs

@@ -82,6 +82,68 @@ impl Default for AnomalyConfig {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Pattern-match normalization
+// ---------------------------------------------------------------------------
+
+/// `true` for characters used to invisibly break up text without being
+/// rendered (zero-width joiners/spacers, bidi control marks, the BOM/ZWNBSP,
+/// soft hyphen, and the invisible math operators) — a common trick for
+/// splitting a flagged word so a literal-substring check misses it while the
+/// text still displays normally.
+fn is_invisible_format_char(ch: char) -> bool {
+    matches!(
+        ch,
+        '\u{00AD}' // soft hyphen
+            | '\u{200B}' // zero width space
+            | '\u{200C}' // zero width non-joiner
+            | '\u{200D}' // zero width joiner
+            | '\u{200E}' // left-to-right mark
+            | '\u{200F}' // right-to-left mark
+            | '\u{2060}' // word joiner
+            | '\u{2061}'..='\u{2064}' // invisible times/plus/separator/function application
+            | '\u{202A}'..='\u{202E}' // bidi embedding/override controls
+            | '\u{FEFF}' // BOM / zero width no-break space
+    )
+}
+
+/// Normalize text before suspicious-pattern matching so the cheapest evasion
+/// tricks — extra whitespace, zero-width characters, or punctuation spliced
+/// between letters (e.g. `"s.y.s.t.e.m"`) — don't defeat a literal-substring
+/// check. Lowercases, drops invisible-format and control characters, drops
+/// punctuation entirely (not just collapses it, so split words rejoin), and
+/// collapses whitespace runs to a single space.
+///
+/// Does not perform Unicode NFKC normalization or confusable/homoglyph
+/// folding (see [`WriteAnomalyDetector::check_pattern_anomaly`]).
+fn normalize_for_pattern_match(text: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let mut last_was_space = true; // trims leading whitespace for free
+    for ch in text.chars() {
+        if ch.is_control() || is_invisible_format_char(ch) {
+            continue;
+        }
+        if ch.is_whitespace() {
+            if !last_was_space {
+                out.push(' ');
+                last_was_space = true;
+            }
+            continue;
+        }
+        if ch.is_ascii_punctuation() {
+            continue;
+        }
+        for lower in ch.to_lowercase() {
+            out.push(lower);
+        }
+        last_was_space = false;
+    }
+    while out.ends_with(' ') {
+        out.pop();
+    }
+    out
+}
+
 // ---------------------------------------------------------------------------
 // WriteEvent
 // ---------------------------------------------------------------------------
@@ -99,6 +161,9 @@ pub struct WriteEvent {
 // WriteAnomalyDetector
 // ---------------------------------------------------------------------------
 
+/// Upper bound on distinct session ids the detector tracks at once.
+const MAX_TRACKED_SESSIONS: usize = 4096;
+
 /// Tracks write events and raises alerts for suspicious behaviour.
 #[derive(Debug)]
 pub struct WriteAnomalyDetector {
@@ -127,6 +192,23 @@ impl WriteAnomalyDetector {
         if event.timestamp > self.last_timestamp {
             self.last_timestamp = event.timestamp;
         }
+        // Bound the per-session map: a long-lived process sees an unbounded
+        // number of distinct session ids. When it overflows, forget the
+        // sessions with the fewest writes (they are furthest from the limit
+        // this map exists to enforce); the current one is re-added below.
+        if self.session_counts.len() >= MAX_TRACKED_SESSIONS
+            && !self.session_counts.contains_key(&event.session_id)
+        {
+            let mut counts: Vec<u32> = self.session_counts.values().copied().collect();
+            let keep_from = counts.len() / 2;
+            counts.select_nth_unstable(keep_from);
+            let threshold = counts[keep_from];
+            self.session_counts.retain(|_, c| *c >= threshold);
+            if self.session_counts.len() >= MAX_TRACKED_SESSIONS {
+                // Every session had the same count: drop them all.
+                self.session_counts.clear();
+            }
+        }
         *self
             .session_counts
             .entry(event.session_id.clone())
@@ -146,6 +228,13 @@ impl WriteAnomalyDetector {
     /// Returns an alert if the number of writes in the last 60 seconds exceeds
     /// `config.max_writes_per_minute`, or if any session has exceeded
     /// `config.max_writes_per_session`.
+    ///
+    /// The 60-second window is a single shared window across all
+    /// sessions/sources, so when it trips the alert additionally names the
+    /// top-contributing session and source within that window — a session
+    /// can never account for more of the window than the aggregate count, so
+    /// this attributes the same trip to its actual offender rather than
+    /// reporting only the anonymous aggregate total.
     pub fn check_rate_anomaly(&self) -> Option<AnomalyAlert> {
         let recent = self.window.len() as u32;
         if recent > self.config.max_writes_per_minute {
@@ -156,11 +245,31 @@ impl WriteAnomalyDetector {
             } else {
                 Severity::Medium
             };
+
+            let mut per_session: std::collections::HashMap<&str, u32> =
+                std::collections::HashMap::new();
+            // MemorySource isn't Eq/Hash, so key by its Display string instead.
+            let mut per_source: std::collections::HashMap<String, u32> =
+                std::collections::HashMap::new();
+            for e in &self.window {
+                *per_session.entry(e.session_id.as_str()).or_insert(0) += 1;
+                *per_source.entry(e.source.to_string()).or_insert(0) += 1;
+            }
+            let top_session = per_session.iter().max_by_key(|&(_, &c)| c);
+            let top_source = per_source.iter().max_by_key(|&(_, &c)| c);
+
+            let attribution = match (top_session, top_source) {
+                (Some((session, s_count)), Some((source, r_count))) => format!(
+                    "; top contributor: session '{session}' with {s_count} writes, \
+                     source {source} with {r_count} writes"
+                ),
+                _ => String::new(),
+            };
             return Some(AnomalyAlert {
                 severity,
                 message: format!(
-                    "Rate limit exceeded: {} writes in last 60s (max {})",
+                    "Rate limit exceeded: {} writes in last 60s (max {}){}",
-                    recent, self.config.max_writes_per_minute
+                    recent, self.config.max_writes_per_minute, attribution
                 ),
                 timestamp: self.last_timestamp,
             });
@@ -188,11 +297,24 @@ impl WriteAnomalyDetector {
     // -----------------------------------------------------------------------
 
     /// Returns an alert if `chunk` contains any of the configured suspicious
-    /// patterns (case-insensitive).
+    /// patterns, after normalizing both sides to defeat the cheapest evasion
+    /// tricks (case, extra whitespace, punctuation between letters,
+    /// zero-width/invisible-formatting characters).
+    ///
+    /// This does not perform Unicode NFKC normalization or confusable/
+    /// homoglyph folding (e.g. Cyrillic 'а' standing in for Latin 'a') —
+    /// that needs a per-codepoint confusable table (Unicode's
+    /// `confusables.txt`) beyond what's practical to hand-roll correctly,
+    /// and no such crate is a dependency of this crate today. A determined
+    /// attacker using homoglyphs can still evade these patterns.
     pub fn check_pattern_anomaly(&self, chunk: &str) -> Option<AnomalyAlert> {
-        let lower = chunk.to_lowercase();
+        let normalized = normalize_for_pattern_match(chunk);
         for pattern in &self.config.suspicious_patterns {
-            if lower.contains(pattern.as_str()) {
+            let normalized_pattern = normalize_for_pattern_match(pattern);
+            if normalized_pattern.is_empty() {
+                continue;
+            }
+            if normalized.contains(&normalized_pattern) {
                 let severity = if pattern.contains("ignore") || pattern.contains("override") {
                     Severity::Critical
                 } else if pattern.contains("system") || pattern.contains("jailbreak") {
@@ -327,6 +449,57 @@ mod tests {
         assert!(alert.unwrap().severity >= Severity::Medium);
     }
 
+    /// A single session dominating the shared 60s window must be named in
+    /// the alert, not just the anonymous aggregate count — this is the case
+    /// the separate cumulative max_writes_per_session check doesn't cover
+    /// (the window can trip before the session's lifetime total does).
+    #[test]
+    fn rate_anomaly_names_offending_session() {
+        let mut det = WriteAnomalyDetector::new(cfg());
+        for i in 0..11 {
+            det.record_write(event(
+                1.0 + i as f64 * 0.1,
+                "flood-session",
+                MemorySource::User,
+            ));
+        }
+        let alert = det.check_rate_anomaly().unwrap();
+        assert!(
+            alert.message.contains("flood-session"),
+            "expected the offending session to be named, got: {}",
+            alert.message
+        );
+    }
+
+    /// When many distinct sessions jointly trip the shared window, the top
+    /// contributor named must actually be the one with the most writes.
+    #[test]
+    fn rate_anomaly_attributes_top_contributor_among_many_sessions() {
+        let mut det = WriteAnomalyDetector::new(cfg());
+        // 5 sessions with 1 write each (below any per-session limit)...
+        for i in 0..5 {
+            det.record_write(event(
+                1.0 + i as f64 * 0.1,
+                "minor-session",
+                MemorySource::User,
+            ));
+        }
+        // ...plus one session responsible for the majority of the flood.
+        for i in 0..8 {
+            det.record_write(event(
+                2.0 + i as f64 * 0.1,
+                "major-session",
+                MemorySource::User,
+            ));
+        }
+        let alert = det.check_rate_anomaly().unwrap();
+        assert!(
+            alert.message.contains("major-session"),
+            "expected the top contributor to be named, got: {}",
+            alert.message
+        );
+    }
+
     #[test]
     fn rate_anomaly_critical_3x() {
         let mut det = WriteAnomalyDetector::new(cfg());
@@ -395,6 +568,71 @@ mod tests {
         assert!(alert.is_some());
     }
 
+    // --- Pattern-match evasion hardening ---
+
+    #[test]
+    fn pattern_defeats_extra_whitespace() {
+        let det = WriteAnomalyDetector::new(cfg());
+        let alert = det.check_pattern_anomaly("please   ignore    previous   instructions");
+        assert!(alert.is_some(), "extra whitespace must not defeat matching");
+    }
+
+    #[test]
+    fn pattern_defeats_punctuation_splicing() {
+        let det = WriteAnomalyDetector::new(cfg());
+        let alert = det.check_pattern_anomaly("i.g.n.o.r.e p-r-e-v-i-o-u-s instructions");
+        assert!(
+            alert.is_some(),
+            "punctuation spliced between letters must not defeat matching"
+        );
+    }
+
+    #[test]
+    fn pattern_defeats_zero_width_space() {
+        let det = WriteAnomalyDetector::new(cfg());
+        // Zero-width space (U+200B) inserted mid-word.
+        let chunk = "ign\u{200B}ore previ\u{200B}ous instructions";
+        let alert = det.check_pattern_anomaly(chunk);
+        assert!(
+            alert.is_some(),
+            "zero-width space injection must not defeat matching"
+        );
+    }
+
+    #[test]
+    fn pattern_defeats_zero_width_joiner_and_bom() {
+        let det = WriteAnomalyDetector::new(cfg());
+        let chunk = "jail\u{200D}break\u{FEFF} attempt";
+        let alert = det.check_pattern_anomaly(chunk);
+        assert!(
+            alert.is_some(),
+            "ZWJ/BOM injection must not defeat matching"
+        );
+    }
+
+    #[test]
+    fn pattern_still_clean_after_normalization() {
+        let det = WriteAnomalyDetector::new(cfg());
+        // Normalization must not introduce false positives on ordinary text
+        // that merely contains punctuation and extra whitespace.
+        let alert =
+            det.check_pattern_anomaly("Well,  I think... the weather is nice today, right?");
+        assert!(alert.is_none());
+    }
+
+    #[test]
+    fn normalize_for_pattern_match_examples() {
+        assert_eq!(
+            normalize_for_pattern_match("i.g.n.o.r.e p-r-e-v-i-o-u-s"),
+            "ignore previous"
+        );
+        assert_eq!(
+            normalize_for_pattern_match("ign\u{200B}ore   previous"),
+            "ignore previous"
+        );
+        assert_eq!(normalize_for_pattern_match("SYSTEM:"), "system");
+    }
+
     #[test]
     fn pattern_jailbreak() {
         let det = WriteAnomalyDetector::new(cfg());

crates/clawhdf5-agent/src/async_memory.rs

@@ -408,6 +408,10 @@ impl AsyncHDF5Memory {
         let (tx, rx) = oneshot::channel();
         let _ = self.write_tx.send(WriteCmd::Shutdown(tx)).await;
         let _ = rx.await;
+        // The writer task has stopped, so nothing can write through this
+        // handle any more: release the single-writer lock now rather than at
+        // drop, so the store can be reopened while `self` is still in scope.
+        self.inner.lock().await.release_store_lock();
         Ok(())
     }
 }

crates/clawhdf5-agent/src/bm25.rs

@@ -8,7 +8,28 @@
 //! - Sorted posting lists by doc_id for cache-friendly access
 //! - Block-Max WAND early termination
 
-use std::collections::HashMap;
+use std::cmp::Reverse;
+use std::collections::{BinaryHeap, HashMap};
+
+/// `f32` wrapper providing a total order (via `total_cmp`) so BM25 scores can
+/// be kept in a `BinaryHeap`. Scores are always finite in practice (no NaN
+/// inputs reach this path), so `total_cmp`'s NaN ordering is never exercised.
+#[derive(Debug, Clone, Copy, PartialEq)]
+struct HeapScore(f32);
+
+impl Eq for HeapScore {}
+
+impl PartialOrd for HeapScore {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for HeapScore {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.total_cmp(&other.0)
+    }
+}
 
 /// Default BM25 term-frequency saturation parameter.
 const DEFAULT_K1: f32 = 1.2;
@@ -97,9 +118,11 @@ impl BM25Index {
 
         let total_max_contribution: f32 = max_tf_score.iter().sum();
 
-        // Threshold for WAND early termination
+        // Threshold for WAND early termination. `top_k_heap` is a min-heap of
+        // size k (worst-of-the-top-k at the head) so it can be maintained in
+        // O(log k) per update instead of re-sorting the whole buffer.
         let mut threshold = 0.0f32;
-        let mut top_k_scores: Vec<f32> = Vec::with_capacity(k);
+        let mut top_k_heap: BinaryHeap<Reverse<HeapScore>> = BinaryHeap::with_capacity(k);
 
         for (term_idx, (_, idf, postings)) in query_terms.iter().enumerate() {
             for &(doc_id, freq) in *postings {
@@ -118,24 +141,17 @@ impl BM25Index {
                 if term_idx == query_terms.len() - 1 {
                     // Last term: check if this doc beats threshold
                     let final_score = *entry;
-                    if final_score > threshold && top_k_scores.len() >= k {
+                    if top_k_heap.len() >= k {
-                        // Update threshold
+                        if final_score > threshold {
-                        top_k_scores
+                            // Replace the current worst-of-top-k.
-                            .sort_by(|a, b| b.partial_cmp(a).unwrap_or(std::cmp::Ordering::Equal));
+                            top_k_heap.pop();
-                        if final_score > top_k_scores[k - 1] {
+                            top_k_heap.push(Reverse(HeapScore(final_score)));
-                            top_k_scores[k - 1] = final_score;
+                            threshold = top_k_heap.peek().map(|Reverse(s)| s.0).unwrap_or(0.0);
-                            top_k_scores.sort_by(|a, b| {
-                                b.partial_cmp(a).unwrap_or(std::cmp::Ordering::Equal)
-                            });
-                            threshold = top_k_scores[k - 1];
                         }
-                    } else if top_k_scores.len() < k {
+                    } else {
-                        top_k_scores.push(final_score);
+                        top_k_heap.push(Reverse(HeapScore(final_score)));
-                        if top_k_scores.len() == k {
+                        if top_k_heap.len() == k {
-                            top_k_scores.sort_by(|a, b| {
+                            threshold = top_k_heap.peek().map(|Reverse(s)| s.0).unwrap_or(0.0);
-                                b.partial_cmp(a).unwrap_or(std::cmp::Ordering::Equal)
-                            });
-                            threshold = top_k_scores[k - 1];
                         }
                     }
                 }

crates/clawhdf5-agent/src/cache.rs

@@ -7,6 +7,11 @@ use crate::vector_search;
 pub struct MemoryCache {
     pub chunks: Vec<String>,
     pub embeddings: Vec<Vec<f32>>,
+    /// `embeddings` flattened into one contiguous `[N × embedding_dim]`
+    /// buffer, maintained incrementally alongside `embeddings` (push/update/
+    /// compact) so BLAS/Accelerate batch search can read it directly instead
+    /// of re-flattening the whole corpus on every query.
+    pub embeddings_flat: Vec<f32>,
     pub source_channels: Vec<String>,
     pub timestamps: Vec<f64>,
     pub session_ids: Vec<String>,
@@ -24,6 +29,7 @@ impl MemoryCache {
         Self {
             chunks: Vec::new(),
             embeddings: Vec::new(),
+            embeddings_flat: Vec::new(),
             source_channels: Vec::new(),
             timestamps: Vec::new(),
             session_ids: Vec::new(),
@@ -35,6 +41,17 @@ impl MemoryCache {
         }
     }
 
+    /// Rebuild `embeddings_flat` from `embeddings` from scratch. Callers that
+    /// populate `embeddings` directly (bulk loads) must call this afterward.
+    pub fn rebuild_flat(&mut self) {
+        self.embeddings_flat.clear();
+        self.embeddings_flat
+            .reserve(self.embeddings.len() * self.embedding_dim);
+        for emb in &self.embeddings {
+            self.embeddings_flat.extend_from_slice(emb);
+        }
+    }
+
     /// Total number of entries (including tombstoned).
     pub fn len(&self) -> usize {
         self.chunks.len()
@@ -62,6 +79,7 @@ impl MemoryCache {
         let idx = self.chunks.len();
         let norm = vector_search::compute_norm(&embedding);
         self.chunks.push(chunk);
+        self.embeddings_flat.extend_from_slice(&embedding);
         self.embeddings.push(embedding);
         self.source_channels.push(source_channel);
         self.timestamps.push(timestamp);
@@ -100,7 +118,20 @@ impl MemoryCache {
         if idx < self.chunks.len() {
             let norm = vector_search::compute_norm(&embedding);
             self.chunks[idx] = chunk;
+            let dim = self.embedding_dim;
+            let flat_start = idx * dim;
+            let matches_dim =
+                embedding.len() == dim && flat_start + dim <= self.embeddings_flat.len();
             self.embeddings[idx] = embedding;
+            if matches_dim {
+                self.embeddings_flat[flat_start..flat_start + dim]
+                    .copy_from_slice(&self.embeddings[idx]);
+            } else {
+                // Embedding length doesn't match embedding_dim (shouldn't
+                // happen in practice) — fall back to a full rebuild rather
+                // than leave embeddings_flat misaligned with embeddings.
+                self.rebuild_flat();
+            }
             self.source_channels[idx] = source_channel;
             self.timestamps[idx] = timestamp;
             self.session_ids[idx] = session_id;
@@ -173,16 +204,125 @@ impl MemoryCache {
         self.tombstones = new_tombstones;
         self.norms = new_norms;
         self.activation_weights = new_activation_weights;
+        self.rebuild_flat();
 
         (removed, index_map)
     }
 
     /// Flatten all embeddings into a single Vec<f32> for HDF5 storage.
+    /// `embeddings_flat` is already maintained incrementally, so this just
+    /// clones it — kept as a method for callers that want an owned copy.
     pub fn flat_embeddings(&self) -> Vec<f32> {
-        let mut flat = Vec::with_capacity(self.embeddings.len() * self.embedding_dim);
+        self.embeddings_flat.clone()
-        for emb in &self.embeddings {
+    }
-            flat.extend_from_slice(emb);
+}
-        }
+
-        flat
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `embeddings_flat` must always equal a from-scratch flatten of `embeddings`.
+    fn assert_flat_in_sync(cache: &MemoryCache) {
+        let expected: Vec<f32> = cache.embeddings.iter().flatten().copied().collect();
+        assert_eq!(cache.embeddings_flat, expected);
+    }
+
+    #[test]
+    fn push_keeps_flat_buffer_in_sync() {
+        let mut cache = MemoryCache::new(3);
+        cache.push(
+            "a".into(),
+            vec![1.0, 2.0, 3.0],
+            "chan".into(),
+            0.0,
+            "s1".into(),
+            String::new(),
+        );
+        cache.push(
+            "b".into(),
+            vec![4.0, 5.0, 6.0],
+            "chan".into(),
+            1.0,
+            "s1".into(),
+            String::new(),
+        );
+        assert_flat_in_sync(&cache);
+        assert_eq!(cache.embeddings_flat, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
+    }
+
+    #[test]
+    fn update_keeps_flat_buffer_in_sync() {
+        let mut cache = MemoryCache::new(3);
+        cache.push(
+            "a".into(),
+            vec![1.0, 2.0, 3.0],
+            "chan".into(),
+            0.0,
+            "s1".into(),
+            String::new(),
+        );
+        cache.push(
+            "b".into(),
+            vec![4.0, 5.0, 6.0],
+            "chan".into(),
+            1.0,
+            "s1".into(),
+            String::new(),
+        );
+        cache.update(
+            0,
+            "a2".into(),
+            vec![7.0, 8.0, 9.0],
+            "chan".into(),
+            2.0,
+            "s1".into(),
+        );
+        assert_flat_in_sync(&cache);
+        assert_eq!(
+            cache.embeddings_flat,
+            vec![7.0, 8.0, 9.0, 4.0, 5.0, 6.0],
+            "update must overwrite the correct flat slice, not just append"
+        );
+    }
+
+    #[test]
+    fn compact_keeps_flat_buffer_in_sync() {
+        let mut cache = MemoryCache::new(2);
+        cache.push(
+            "a".into(),
+            vec![1.0, 1.0],
+            "chan".into(),
+            0.0,
+            "s1".into(),
+            String::new(),
+        );
+        cache.push(
+            "b".into(),
+            vec![2.0, 2.0],
+            "chan".into(),
+            1.0,
+            "s1".into(),
+            String::new(),
+        );
+        cache.push(
+            "c".into(),
+            vec![3.0, 3.0],
+            "chan".into(),
+            2.0,
+            "s1".into(),
+            String::new(),
+        );
+        cache.mark_deleted(1);
+        cache.compact();
+        assert_flat_in_sync(&cache);
+        assert_eq!(cache.embeddings_flat, vec![1.0, 1.0, 3.0, 3.0]);
+    }
+
+    #[test]
+    fn rebuild_flat_matches_manual_flatten() {
+        let mut cache = MemoryCache::new(2);
+        cache.embeddings = vec![vec![1.0, 2.0], vec![3.0, 4.0]];
+        cache.rebuild_flat();
+        assert_eq!(cache.embeddings_flat, vec![1.0, 2.0, 3.0, 4.0]);
     }
 }

crates/clawhdf5-agent/src/consolidation.rs

@@ -16,6 +16,55 @@ pub enum MemorySource {
     Correction,
 }
 
+/// Source classification for content whose true origin is *not*
+/// independently verified by the caller of [`ConsolidationEngine::add_memory`]
+/// — arbitrary text forwarded from a user, a tool's output, or a retrieval
+/// pipeline. This is the only source set `add_memory` accepts; it cannot
+/// claim the `System`/`Correction` importance boost (see [`TrustedSource`]
+/// and [`ConsolidationEngine::add_trusted_memory`]) — a caller passing
+/// through untrusted content has no way to self-report an elevated trust
+/// level through this entry point.
+#[derive(Clone, Debug, PartialEq)]
+pub enum UntrustedSource {
+    User,
+    Tool,
+    Retrieval,
+}
+
+impl From<UntrustedSource> for MemorySource {
+    fn from(s: UntrustedSource) -> Self {
+        match s {
+            UntrustedSource::User => MemorySource::User,
+            UntrustedSource::Tool => MemorySource::Tool,
+            UntrustedSource::Retrieval => MemorySource::Retrieval,
+        }
+    }
+}
+
+/// Source classification for content whose elevated trust level has been
+/// independently verified by the caller — e.g. the library's own
+/// system-generated text, or a caller that ran its own correction-cue
+/// detection (as `memory_strategy::SaveOnUserCorrection` does) rather than
+/// forwarding a caller-supplied label verbatim. `MemorySource::System`/
+/// `Correction` get elevated importance weighting in
+/// [`ImportanceScorer::score_correction`]; only reachable through
+/// [`ConsolidationEngine::add_trusted_memory`], a distinct entry point from
+/// the one untrusted content is passed through.
+#[derive(Clone, Debug, PartialEq)]
+pub enum TrustedSource {
+    System,
+    Correction,
+}
+
+impl From<TrustedSource> for MemorySource {
+    fn from(s: TrustedSource) -> Self {
+        match s {
+            TrustedSource::System => MemorySource::System,
+            TrustedSource::Correction => MemorySource::Correction,
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum MemoryTier {
     Working,
@@ -118,7 +167,7 @@ impl ImportanceScorer {
 
     /// Novelty score: 1.0 − max cosine similarity against all existing records.
     /// Returns 1.0 when there are no existing memories.
-    pub fn score_surprise(embedding: &[f32], existing_memories: &[MemoryRecord]) -> f32 {
+    pub fn score_surprise(embedding: &[f32], existing_memories: &[&MemoryRecord]) -> f32 {
         if existing_memories.is_empty() {
             return 1.0;
         }
@@ -199,21 +248,51 @@ impl ConsolidationEngine {
         }
     }
 
-    /// Add a new memory to the Working tier.
+    /// Add a new memory to the Working tier from an untrusted/ordinary origin
+    /// (User, Tool, or Retrieval). This is the entry point for arbitrary
+    /// caller-supplied content — it cannot claim the elevated System/
+    /// Correction importance boost. Use [`Self::add_trusted_memory`] for
+    /// content whose elevated trust level the caller has independently
+    /// verified.
     ///
     /// Importance is scored against existing Working-tier records only.
     pub fn add_memory(
+        &mut self,
+        chunk: String,
+        embedding: Vec<f32>,
+        source: UntrustedSource,
+        now: f64,
+    ) -> u64 {
+        self.add_memory_with_source(chunk, embedding, source.into(), now)
+    }
+
+    /// Add a new memory tagged System or Correction, which get elevated
+    /// importance weighting in [`ImportanceScorer::score_correction`]. Only
+    /// call this from code that has independently verified the origin (the
+    /// library's own system-generated text, or a caller that ran its own
+    /// correction-cue detection) — never from a path that forwards a
+    /// caller-supplied trust label verbatim.
+    pub fn add_trusted_memory(
+        &mut self,
+        chunk: String,
+        embedding: Vec<f32>,
+        source: TrustedSource,
+        now: f64,
+    ) -> u64 {
+        self.add_memory_with_source(chunk, embedding, source.into(), now)
+    }
+
+    fn add_memory_with_source(
         &mut self,
         chunk: String,
         embedding: Vec<f32>,
         source: MemorySource,
         now: f64,
     ) -> u64 {
-        let working: Vec<MemoryRecord> = self
+        let working: Vec<&MemoryRecord> = self
             .records
             .iter()
             .filter(|r| r.tier == MemoryTier::Working)
-            .cloned()
             .collect();
 
         let surprise = ImportanceScorer::score_surprise(&embedding, &working);
@@ -281,7 +360,7 @@ impl ConsolidationEngine {
         if working_count > capacity {
             let evict_n = working_count - capacity;
             // Collect the ids of the records to evict (lowest decay = first in sorted list).
-            let evict_ids: Vec<u64> = working_indices[..evict_n]
+            let evict_ids: std::collections::HashSet<u64> = working_indices[..evict_n]
                 .iter()
                 .map(|&i| self.records[i].id)
                 .collect();
@@ -342,7 +421,7 @@ impl ConsolidationEngine {
             });
 
             let evict_n = episodic_count - episodic_capacity;
-            let evict_ids: Vec<u64> = episodic_indices[..evict_n]
+            let evict_ids: std::collections::HashSet<u64> = episodic_indices[..evict_n]
                 .iter()
                 .map(|&i| self.records[i].id)
                 .collect();
@@ -419,13 +498,44 @@ mod tests {
     // ---------------------------------------------------------------------------
     // 2. Add memory — basic
     // ---------------------------------------------------------------------------
+    /// add_trusted_memory(TrustedSource::Correction) must actually produce a
+    /// MemorySource::Correction record — the only way to reach that elevated
+    /// classification, since add_memory's UntrustedSource has no such variant.
+    #[test]
+    fn test_add_trusted_memory_sets_correction_source() {
+        let mut engine = ConsolidationEngine::new(ConsolidationConfig::default());
+        let id = engine.add_trusted_memory(
+            "verified correction".to_string(),
+            unit_vec(4, 0),
+            TrustedSource::Correction,
+            0.0,
+        );
+        let rec = engine.get_by_id(id).unwrap();
+        assert_eq!(rec.source, MemorySource::Correction);
+    }
+
+    /// add_trusted_memory(TrustedSource::System) must produce a
+    /// MemorySource::System record.
+    #[test]
+    fn test_add_trusted_memory_sets_system_source() {
+        let mut engine = ConsolidationEngine::new(ConsolidationConfig::default());
+        let id = engine.add_trusted_memory(
+            "bootstrap text".to_string(),
+            unit_vec(4, 0),
+            TrustedSource::System,
+            0.0,
+        );
+        let rec = engine.get_by_id(id).unwrap();
+        assert_eq!(rec.source, MemorySource::System);
+    }
+
     #[test]
     fn test_add_memory_basic() {
         let mut engine = ConsolidationEngine::new(ConsolidationConfig::default());
         let id = engine.add_memory(
             "Hello world".to_string(),
             unit_vec(4, 0),
-            MemorySource::User,
+            UntrustedSource::User,
             1_000_000.0,
         );
         assert_eq!(id, 0);
@@ -453,7 +563,7 @@ mod tests {
     #[test]
     fn test_importance_scorer_surprise_identical() {
         let emb = unit_vec(4, 0);
-        let existing = vec![MemoryRecord {
+        let existing = [MemoryRecord {
             id: 0,
             chunk: "existing".to_string(),
             embedding: emb.clone(),
@@ -464,7 +574,8 @@ mod tests {
             created_at: 0.0,
             source: MemorySource::User,
         }];
-        let score = ImportanceScorer::score_surprise(&emb, &existing);
+        let existing_refs: Vec<&MemoryRecord> = existing.iter().collect();
+        let score = ImportanceScorer::score_surprise(&emb, &existing_refs);
         assert!(score < 0.01, "expected ~0.0, got {score}");
     }
 
@@ -492,23 +603,20 @@ mod tests {
     fn test_importance_scorer_length() {
         assert!((ImportanceScorer::score_length("")).abs() < f32::EPSILON);
         // 50 words → 0.5
-        let fifty_words = std::iter::repeat("word")
+        let fifty_words = std::iter::repeat_n("word", 50)
-            .take(50)
             .collect::<Vec<_>>()
             .join(" ");
         let s50 = ImportanceScorer::score_length(&fifty_words);
         assert!((s50 - 0.5).abs() < 1e-5, "expected 0.5, got {s50}");
 
         // 100 words → 1.0
-        let hundred_words = std::iter::repeat("word")
+        let hundred_words = std::iter::repeat_n("word", 100)
-            .take(100)
             .collect::<Vec<_>>()
             .join(" ");
         assert_eq!(ImportanceScorer::score_length(&hundred_words), 1.0);
 
         // 200 words → still 1.0 (clamped)
-        let two_hundred = std::iter::repeat("word")
+        let two_hundred = std::iter::repeat_n("word", 200)
-            .take(200)
             .collect::<Vec<_>>()
             .join(" ");
         assert_eq!(ImportanceScorer::score_length(&two_hundred), 1.0);
@@ -582,9 +690,11 @@ mod tests {
     // ---------------------------------------------------------------------------
     #[test]
     fn test_consolidate_eviction_working() {
-        let mut cfg = ConsolidationConfig::default();
+        let cfg = ConsolidationConfig {
-        cfg.working_capacity = 3;
+            working_capacity: 3,
-        cfg.working_to_episodic_threshold = 2.0; // never promote in this test
+            working_to_episodic_threshold: 2.0, // never promote in this test
+            ..Default::default()
+        };
         let mut engine = ConsolidationEngine::new(cfg);
 
         // Add 5 records; all have very low importance so none get promoted.
@@ -592,7 +702,7 @@ mod tests {
             let id = engine.add_memory(
                 "x".to_string(),
                 unit_vec(4, i as usize),
-                MemorySource::User,
+                UntrustedSource::User,
                 i as f64,
             );
             // Force low importance so promotion threshold is not crossed.
@@ -625,10 +735,10 @@ mod tests {
         let cfg = ConsolidationConfig::default();
         let mut engine = ConsolidationEngine::new(cfg);
 
-        let id = engine.add_memory(
+        let id = engine.add_trusted_memory(
             "important memory".to_string(),
             unit_vec(4, 0),
-            MemorySource::Correction,
+            TrustedSource::Correction,
             0.0,
         );
         // Force importance above threshold.
@@ -661,7 +771,7 @@ mod tests {
         let id = engine.add_memory(
             "frequently accessed".to_string(),
             unit_vec(4, 0),
-            MemorySource::User,
+            UntrustedSource::User,
             0.0,
         );
 
@@ -689,7 +799,12 @@ mod tests {
     #[test]
     fn test_access_memory_reactivation() {
         let mut engine = ConsolidationEngine::new(ConsolidationConfig::default());
-        let id = engine.add_memory("chunk".to_string(), unit_vec(4, 0), MemorySource::User, 0.0);
+        let id = engine.add_memory(
+            "chunk".to_string(),
+            unit_vec(4, 0),
+            UntrustedSource::User,
+            0.0,
+        );
 
         engine.access_memory(id, 5000.0);
         let rec = engine.get_by_id(id).unwrap();
@@ -710,11 +825,11 @@ mod tests {
         let mut engine = ConsolidationEngine::new(ConsolidationConfig::default());
 
         // 2 Working
-        engine.add_memory("w1".to_string(), unit_vec(4, 0), MemorySource::User, 0.0);
+        engine.add_memory("w1".to_string(), unit_vec(4, 0), UntrustedSource::User, 0.0);
-        engine.add_memory("w2".to_string(), unit_vec(4, 1), MemorySource::User, 0.0);
+        engine.add_memory("w2".to_string(), unit_vec(4, 1), UntrustedSource::User, 0.0);
 
         // 1 Episodic (manually set)
-        let id_e = engine.add_memory("e1".to_string(), unit_vec(4, 2), MemorySource::User, 0.0);
+        let id_e = engine.add_memory("e1".to_string(), unit_vec(4, 2), UntrustedSource::User, 0.0);
         engine
             .records
             .iter_mut()
@@ -723,7 +838,7 @@ mod tests {
             .tier = MemoryTier::Episodic;
 
         // 1 Semantic (manually set)
-        let id_s = engine.add_memory("s1".to_string(), unit_vec(4, 3), MemorySource::User, 0.0);
+        let id_s = engine.add_memory("s1".to_string(), unit_vec(4, 3), UntrustedSource::User, 0.0);
         engine
             .records
             .iter_mut()
@@ -742,9 +857,11 @@ mod tests {
     // ---------------------------------------------------------------------------
     #[test]
     fn test_consolidate_episodic_eviction() {
-        let mut cfg = ConsolidationConfig::default();
+        let cfg = ConsolidationConfig {
-        cfg.episodic_capacity = 3;
+            episodic_capacity: 3,
-        cfg.working_to_episodic_threshold = 2.0; // never auto-promote from Working
+            working_to_episodic_threshold: 2.0, // never auto-promote from Working
+            ..Default::default()
+        };
         let mut engine = ConsolidationEngine::new(cfg);
 
         // Seed 5 records directly in Episodic.
@@ -752,7 +869,7 @@ mod tests {
             let id = engine.add_memory(
                 "episodic chunk".to_string(),
                 unit_vec(4, i as usize),
-                MemorySource::User,
+                UntrustedSource::User,
                 i as f64,
             );
             let rec = engine.records.iter_mut().find(|r| r.id == id).unwrap();

crates/clawhdf5-agent/src/entity_extract.rs

@@ -777,8 +777,10 @@ mod tests {
 
     #[test]
     fn test_tech_disabled() {
-        let mut config = ExtractorConfig::default();
+        let config = ExtractorConfig {
-        config.extract_technology = false;
+            extract_technology: false,
+            ..Default::default()
+        };
         let e = EntityExtractor::new(config);
         let entities = e.extract("We use Rust and Docker.");
         assert!(
@@ -847,8 +849,10 @@ mod tests {
 
     #[test]
     fn test_date_disabled() {
-        let mut config = ExtractorConfig::default();
+        let config = ExtractorConfig {
-        config.extract_dates = false;
+            extract_dates: false,
+            ..Default::default()
+        };
         let e = EntityExtractor::new(config);
         let entities = e.extract("Released on 2024-03-19.");
         assert!(
@@ -981,8 +985,10 @@ mod tests {
 
     #[test]
     fn test_confidence_filter() {
-        let mut config = ExtractorConfig::default();
+        let config = ExtractorConfig {
-        config.min_confidence = 0.95;
+            min_confidence: 0.95,
+            ..Default::default()
+        };
         let e = EntityExtractor::new(config);
         // Only dates (0.95) and techs (0.9) should survive; 0.9 < 0.95 filters techs.
         let entities = e.extract("We use Rust since 2024-01-01.");
@@ -1002,7 +1008,7 @@ mod tests {
     fn test_batch_dedup() {
         let e = default_extractor();
         let texts = ["We use Rust.", "Rust is fast.", "Also Rust for safety."];
-        let entities = e.extract_batch(&texts.iter().map(|s| *s).collect::<Vec<_>>());
+        let entities = e.extract_batch(&texts);
         let rust_count = entities.iter().filter(|x| x.text == "Rust").count();
         assert_eq!(rust_count, 1, "Rust should appear exactly once after dedup");
     }
@@ -1011,7 +1017,7 @@ mod tests {
     fn test_batch_multiple_types() {
         let e = default_extractor();
         let texts = ["Deploy with Docker.", "We merged last week."];
-        let entities = e.extract_batch(&texts.iter().map(|s| *s).collect::<Vec<_>>());
+        let entities = e.extract_batch(&texts);
         assert!(
             entities
                 .iter()

crates/clawhdf5-agent/src/hybrid.rs

@@ -91,14 +91,22 @@ pub fn merge_vector_keyword(
     }
 
     let mut results: Vec<(usize, f32)> = merged.into_iter().collect();
-    results.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
+    // Index tie-break: `merged` is a HashMap, so without it the ties that
+    // survive `truncate` differ from run to run.
+    results.sort_by(|a, b| {
+        b.1.partial_cmp(&a.1)
+            .unwrap_or(std::cmp::Ordering::Equal)
+            .then(a.0.cmp(&b.0))
+    });
     results.truncate(k);
     results
 }
 
 /// Normalize a set of scores to the [0, 1] range using min-max normalization.
 ///
-/// If all scores are identical, returns 0.0 for each entry.
+/// If all scores are identical there is no spread to normalise: each entry
+/// gets 1.0 when that score is positive (all equally the best match) and 0.0
+/// otherwise (nothing matched).
 fn normalize_scores(scores: &[(usize, f32)]) -> Vec<(usize, f32)> {
     if scores.is_empty() {
         return Vec::new();
@@ -112,7 +120,13 @@ fn normalize_scores(scores: &[(usize, f32)]) -> Vec<(usize, f32)> {
 
     let range = max - min;
     if range == 0.0 {
-        return scores.iter().map(|(idx, _)| (*idx, 0.0)).collect();
+        // All candidates scored the same (including the single-candidate
+        // case), so min-max has no spread to work with. They are all equally
+        // the best match if that score is positive, and all non-matches
+        // otherwise. This used to return 0.0 unconditionally, which erased a
+        // lone perfect match from the fused score.
+        let level = if max > 0.0 { 1.0 } else { 0.0 };
+        return scores.iter().map(|(idx, _)| (*idx, level)).collect();
     }
 
     scores
@@ -324,10 +338,18 @@ mod tests {
 
     #[test]
     fn normalize_scores_single() {
+        // A lone positive score is the best match there is, not a non-match.
         let result = normalize_scores(&[(0, 5.0)]);
         assert_eq!(result.len(), 1);
-        // Single score normalizes to 0.0 (range is 0)
+        assert_eq!(result[0].1, 1.0);
-        assert_eq!(result[0].1, 0.0);
+    }
+
+    #[test]
+    fn normalize_scores_all_equal() {
+        let matched = normalize_scores(&[(0, 0.4), (1, 0.4)]);
+        assert!(matched.iter().all(|(_, s)| *s == 1.0));
+        let unmatched = normalize_scores(&[(0, 0.0), (1, 0.0)]);
+        assert!(unmatched.iter().all(|(_, s)| *s == 0.0));
     }
 
     #[test]

crates/clawhdf5-agent/src/knowledge.rs

@@ -50,6 +50,9 @@ impl RelationType {
 pub struct Entity {
     pub id: u64,
     pub name: String,
+    /// Lowercased `name`, cached at construction time to avoid re-allocating
+    /// and re-lowercasing on every entity-resolution scan.
+    pub name_lower: String,
     pub entity_type: String,
     /// Index into the memory embeddings array, or -1 if none.
     pub embedding_idx: i64,
@@ -69,6 +72,7 @@ impl Default for Entity {
         Self {
             id: 0,
             name: String::new(),
+            name_lower: String::new(),
             entity_type: String::new(),
             embedding_idx: -1,
             properties: HashMap::new(),
@@ -151,6 +155,55 @@ fn levenshtein(a: &str, b: &str) -> usize {
     prev[nb]
 }
 
+// ---------------------------------------------------------------------------
+// AdjacencyIndex
+// ---------------------------------------------------------------------------
+
+/// Adjacency index over a snapshot of `entities`/`relations`: an entity-id ->
+/// entities-slice-index map, and an entity-id -> relation-indices map (edges
+/// touching that entity as either source or target).
+///
+/// Built fresh per traversal call rather than cached on `KnowledgeCache`:
+/// entities/relations are plain `pub` `Vec`s that get pushed to directly
+/// (e.g. `schema.rs`'s load path bypasses `add_entity`/`add_relation`), so a
+/// persistent index would need extra bookkeeping to avoid drifting stale. A
+/// one-off O(V+E) build per call is still a large win over the O(V·E) (BFS)
+/// / O(steps·active·E) (spreading activation) scans it replaces.
+struct AdjacencyIndex {
+    entity_index: HashMap<u64, usize>,
+    by_entity: HashMap<u64, Vec<usize>>,
+}
+
+impl AdjacencyIndex {
+    fn build(entities: &[Entity], relations: &[Relation]) -> Self {
+        let mut entity_index = HashMap::with_capacity(entities.len());
+        for (i, e) in entities.iter().enumerate() {
+            entity_index.insert(e.id, i);
+        }
+
+        let mut by_entity: HashMap<u64, Vec<usize>> = HashMap::new();
+        for (i, r) in relations.iter().enumerate() {
+            by_entity.entry(r.src).or_default().push(i);
+            if r.tgt != r.src {
+                by_entity.entry(r.tgt).or_default().push(i);
+            }
+        }
+
+        Self {
+            entity_index,
+            by_entity,
+        }
+    }
+
+    /// Indices into `relations` of every edge touching `entity_id`.
+    fn relations_touching(&self, entity_id: u64) -> &[usize] {
+        self.by_entity
+            .get(&entity_id)
+            .map(|v| v.as_slice())
+            .unwrap_or(&[])
+    }
+}
+
 // ---------------------------------------------------------------------------
 // KnowledgeCache
 // ---------------------------------------------------------------------------
@@ -198,6 +251,7 @@ impl KnowledgeCache {
         self.entities.push(Entity {
             id,
             name: name.to_owned(),
+            name_lower: name.to_lowercase(),
             entity_type: entity_type.to_owned(),
             embedding_idx,
             properties: HashMap::new(),
@@ -310,16 +364,22 @@ impl KnowledgeCache {
     ) -> (u64, bool) {
         let lower_name = name.to_lowercase();
 
-        // Search for the closest existing entity.
+        // Search for the closest existing entity, short-circuiting on an
-        let best = self
+        // exact match since no closer candidate can exist.
-            .entities
+        let mut best: Option<(u64, usize)> = None;
-            .iter()
+        for e in &self.entities {
-            .map(|e| {
+            let dist = levenshtein(&lower_name, &e.name_lower);
-                let dist = levenshtein(&lower_name, &e.name.to_lowercase());
+            if dist > max_distance {
-                (e.id, dist)
+                continue;
-            })
+            }
-            .filter(|&(_, dist)| dist <= max_distance)
+            if dist == 0 {
-            .min_by_key(|&(_, dist)| dist);
+                best = Some((e.id, dist));
+                break;
+            }
+            if best.is_none_or(|(_, best_dist)| dist < best_dist) {
+                best = Some((e.id, dist));
+            }
+        }
 
         if let Some((id, _)) = best {
             return (id, false);
@@ -329,47 +389,6 @@ impl KnowledgeCache {
         (id, true)
     }
 
-    // -----------------------------------------------------------------------
-    // Adjacency index (built fresh per traversal call — see doc comment)
-    // -----------------------------------------------------------------------
-
-    /// Build an O(V+R) adjacency index for one traversal call: an entity-id →
-    /// vec-index map for O(1) entity lookups, and an entity-id →
-    /// `(neighbour_id, relation_weight)` map (covering both outgoing and
-    /// incoming edges) for O(1) neighbour expansion. The weight is carried
-    /// alongside each neighbour so callers like `spreading_activation` that
-    /// need per-edge weight don't have to re-scan `relations`.
-    ///
-    /// This is rebuilt at the start of every `bfs_neighbors`/
-    /// `spreading_activation` call rather than cached on the struct: `entities`
-    /// and `relations` are public fields, and `schema.rs`'s deserialization
-    /// path pushes into them directly (bypassing `add_entity`/`add_relation`),
-    /// so a struct-cached index could go stale. Building it once per call
-    /// still turns an O(V·R) (or O(steps·V·R)) traversal into O(V+R) (or
-    /// O(steps·(V+E))), since the old code repeated the O(R) relation scan
-    /// once per visited node instead of once per call.
-    fn build_adjacency(&self) -> (HashMap<u64, usize>, HashMap<u64, Vec<(u64, f32)>>) {
-        let mut entity_index: HashMap<u64, usize> = HashMap::with_capacity(self.entities.len());
-        for (i, e) in self.entities.iter().enumerate() {
-            entity_index.insert(e.id, i);
-        }
-
-        // Note: a self-loop relation (src == tgt) contributes a single
-        // neighbour entry, not two, matching the if/else-if (not two
-        // independent ifs) structure this replaces — otherwise a self-loop
-        // would be double-counted by `spreading_activation`.
-        let mut adjacency: HashMap<u64, Vec<(u64, f32)>> =
-            HashMap::with_capacity(self.relations.len());
-        for r in &self.relations {
-            adjacency.entry(r.src).or_default().push((r.tgt, r.weight));
-            if r.tgt != r.src {
-                adjacency.entry(r.tgt).or_default().push((r.src, r.weight));
-            }
-        }
-
-        (entity_index, adjacency)
-    }
-
     // -----------------------------------------------------------------------
     // Graph traversal: BFS neighbors
     // -----------------------------------------------------------------------
@@ -378,8 +397,7 @@ impl KnowledgeCache {
     /// together with their discovered depth.  The seed entity itself is NOT
     /// included.  Traversal follows both outgoing and incoming relation edges.
     pub fn bfs_neighbors(&self, entity_id: u64, max_depth: usize) -> Vec<(Entity, usize)> {
-        let (entity_index, adjacency) = self.build_adjacency();
+        let idx = AdjacencyIndex::build(&self.entities, &self.relations);
-
         let mut visited: HashSet<u64> = HashSet::new();
         let mut queue: VecDeque<(u64, usize)> = VecDeque::new();
         let mut results: Vec<(Entity, usize)> = Vec::new();
@@ -392,16 +410,28 @@ impl KnowledgeCache {
                 continue;
             }
 
-            let Some(neighbours) = adjacency.get(&current_id) else {
+            // Collect neighbour IDs from outgoing and incoming edges touching
-                continue;
+            // this node only, instead of scanning every relation in the graph.
-            };
+            let neighbours: Vec<u64> = idx
+                .relations_touching(current_id)
+                .iter()
+                .filter_map(|&i| {
+                    let r = &self.relations[i];
+                    if r.src == current_id {
+                        Some(r.tgt)
+                    } else if r.tgt == current_id {
+                        Some(r.src)
+                    } else {
+                        None
+                    }
+                })
+                .collect();
 
-            for &(neighbour_id, _weight) in neighbours {
+            for neighbour_id in neighbours {
                 if visited.insert(neighbour_id)
-                    && let Some(&idx) = entity_index.get(&neighbour_id)
+                    && let Some(&entity_idx) = idx.entity_index.get(&neighbour_id)
                 {
-                    let entity = &self.entities[idx];
+                    results.push((self.entities[entity_idx].clone(), depth + 1));
-                    results.push((entity.clone(), depth + 1));
                     queue.push_back((neighbour_id, depth + 1));
                 }
             }
@@ -472,8 +502,7 @@ impl KnowledgeCache {
         min_activation: f32,
         max_steps: usize,
     ) -> Vec<(u64, f32)> {
-        let (_entity_index, adjacency) = self.build_adjacency();
+        let idx = AdjacencyIndex::build(&self.entities, &self.relations);
-
         let mut activation: HashMap<u64, f32> = HashMap::new();
 
         // Initialise seeds with activation 1.0.
@@ -496,12 +525,19 @@ impl KnowledgeCache {
             let mut any_spread = false;
 
             for (source_id, source_score) in current {
-                // Spread to all neighbours via outgoing and incoming edges.
+                // Spread only to edges touching this node, instead of
-                let Some(neighbours) = adjacency.get(&source_id) else {
+                // scanning every relation in the graph per active node.
-                    continue;
+                for &rel_idx in idx.relations_touching(source_id) {
-                };
+                    let rel = &self.relations[rel_idx];
-                for &(neighbour_id, weight) in neighbours {
+                    let neighbour_id = if rel.src == source_id {
-                    let delta = source_score * weight * decay_factor;
+                        rel.tgt
+                    } else if rel.tgt == source_id {
+                        rel.src
+                    } else {
+                        continue;
+                    };
+
+                    let delta = source_score * rel.weight * decay_factor;
                     if delta >= min_activation {
                         *activation.entry(neighbour_id).or_insert(0.0) += delta;
                         any_spread = true;
@@ -885,6 +921,19 @@ mod tests {
         assert_eq!(id, orig_id);
     }
 
+    /// An exact match must win even when a near-match with a smaller Levenshtein
+    /// distance-to-zero gap was scanned first — the early exit on dist == 0
+    /// must not skip past a later exact match.
+    #[test]
+    fn test_resolve_or_create_exact_match_beats_earlier_fuzzy_candidate() {
+        let mut cache = KnowledgeCache::new();
+        cache.add_entity("Alyce", "person", -1); // dist 1 from "Alice"
+        let exact_id = cache.add_entity("Alice", "person", -1); // dist 0
+        let (id, created) = cache.resolve_or_create("Alice", "person", -1, 2);
+        assert!(!created);
+        assert_eq!(id, exact_id);
+    }
+
     #[test]
     fn test_resolve_or_create_no_match_beyond_threshold() {
         let mut cache = KnowledgeCache::new();
@@ -1065,6 +1114,30 @@ mod tests {
         assert!(b_score.unwrap() > 0.0);
     }
 
+    /// A self-loop relation (src == tgt) must be visited exactly once by the
+    /// adjacency index, matching the pre-index behavior of iterating
+    /// `self.relations` directly (each relation processed once regardless of
+    /// how many of its endpoints match the current node).
+    #[test]
+    fn test_spreading_activation_self_loop_not_double_counted() {
+        let mut cache = KnowledgeCache::new();
+        let a = cache.add_entity("A", "node", -1);
+        cache.add_relation(a, a, "self", 1.0);
+
+        let result = cache.spreading_activation(&[a], 0.5, 0.0001, 1);
+        let a_score = result
+            .iter()
+            .find(|&&(id, _)| id == a)
+            .map(|&(_, s)| s)
+            .unwrap();
+        // Seed activation (1.0) plus exactly one spread contribution
+        // (1.0 * weight 1.0 * decay 0.5), not two.
+        assert!(
+            (a_score - 1.5).abs() < 1e-5,
+            "expected 1.5 (one self-loop contribution), got {a_score}"
+        );
+    }
+
     #[test]
     fn test_spreading_activation_decay_reduces_signal() {
         let mut cache = KnowledgeCache::new();

crates/clawhdf5-agent/src/openclaw.rs

@@ -748,6 +748,69 @@ impl MemoryBackend for ClawhdfBackend {
     }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Ephemeral tier methods on ClawhdfBackend
+// ─────────────────────────────────────────────────────────────────────────────
+
+impl ClawhdfBackend {
+    /// Enable the ephemeral (in-memory only) working memory tier.
+    pub fn enable_ephemeral(&mut self, config: crate::ephemeral::EphemeralConfig) {
+        self.memory.enable_ephemeral(config);
+    }
+
+    /// Store a text value in ephemeral memory.
+    ///
+    /// Returns an error string if the ephemeral tier has not been enabled.
+    pub fn ephemeral_set(
+        &mut self,
+        key: &str,
+        value: &str,
+        ttl_secs: Option<f64>,
+    ) -> Result<(), String> {
+        match self.memory.ephemeral_mut() {
+            Some(s) => {
+                s.set_text(key, value, ttl_secs);
+                Ok(())
+            }
+            None => Err("ephemeral tier not enabled".to_string()),
+        }
+    }
+
+    /// Retrieve a text value from ephemeral memory.
+    ///
+    /// Returns `None` if the tier is disabled, the key is absent, or the
+    /// entry has expired.
+    pub fn ephemeral_get(&mut self, key: &str) -> Option<String> {
+        self.memory
+            .ephemeral_mut()?
+            .get_text(key)
+            .map(|s| s.to_string())
+    }
+
+    /// Delete a key from ephemeral memory.
+    ///
+    /// Returns `true` if the key existed and was removed.
+    pub fn ephemeral_delete(&mut self, key: &str) -> bool {
+        self.memory.ephemeral_mut().is_some_and(|s| s.delete(key))
+    }
+
+    /// Return a snapshot of ephemeral tier statistics, or `None` if the tier
+    /// is not enabled.
+    pub fn ephemeral_stats(&self) -> Option<crate::ephemeral::EphemeralStats> {
+        self.memory.ephemeral().map(|s| s.stats())
+    }
+
+    /// Promote frequently-accessed ephemeral entries to persistent HDF5 storage.
+    ///
+    /// Entries with `access_count >= min_access_count` are moved from the
+    /// ephemeral store into the persistent cache.  Returns the count promoted.
+    pub fn promote_ephemeral(&mut self, min_access_count: u32) -> Result<usize, String> {
+        self.memory
+            .promote_ephemeral(min_access_count)
+            .map_err(|e| e.to_string())
+    }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Tests
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1333,66 +1396,3 @@ mod tests {
         assert!(out.starts_with("# Title"));
     }
 }
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Ephemeral tier methods on ClawhdfBackend
-// ─────────────────────────────────────────────────────────────────────────────
-
-impl ClawhdfBackend {
-    /// Enable the ephemeral (in-memory only) working memory tier.
-    pub fn enable_ephemeral(&mut self, config: crate::ephemeral::EphemeralConfig) {
-        self.memory.enable_ephemeral(config);
-    }
-
-    /// Store a text value in ephemeral memory.
-    ///
-    /// Returns an error string if the ephemeral tier has not been enabled.
-    pub fn ephemeral_set(
-        &mut self,
-        key: &str,
-        value: &str,
-        ttl_secs: Option<f64>,
-    ) -> Result<(), String> {
-        match self.memory.ephemeral_mut() {
-            Some(s) => {
-                s.set_text(key, value, ttl_secs);
-                Ok(())
-            }
-            None => Err("ephemeral tier not enabled".to_string()),
-        }
-    }
-
-    /// Retrieve a text value from ephemeral memory.
-    ///
-    /// Returns `None` if the tier is disabled, the key is absent, or the
-    /// entry has expired.
-    pub fn ephemeral_get(&mut self, key: &str) -> Option<String> {
-        self.memory
-            .ephemeral_mut()?
-            .get_text(key)
-            .map(|s| s.to_string())
-    }
-
-    /// Delete a key from ephemeral memory.
-    ///
-    /// Returns `true` if the key existed and was removed.
-    pub fn ephemeral_delete(&mut self, key: &str) -> bool {
-        self.memory.ephemeral_mut().is_some_and(|s| s.delete(key))
-    }
-
-    /// Return a snapshot of ephemeral tier statistics, or `None` if the tier
-    /// is not enabled.
-    pub fn ephemeral_stats(&self) -> Option<crate::ephemeral::EphemeralStats> {
-        self.memory.ephemeral().map(|s| s.stats())
-    }
-
-    /// Promote frequently-accessed ephemeral entries to persistent HDF5 storage.
-    ///
-    /// Entries with `access_count >= min_access_count` are moved from the
-    /// ephemeral store into the persistent cache.  Returns the count promoted.
-    pub fn promote_ephemeral(&mut self, min_access_count: u32) -> Result<usize, String> {
-        self.memory
-            .promote_ephemeral(min_access_count)
-            .map_err(|e| e.to_string())
-    }
-}

crates/clawhdf5-agent/src/provenance.rs

@@ -1,31 +1,31 @@
 //! Memory provenance tracking and integrity verification.
 //!
 //! Records the origin, authorship, and a content hash of every memory chunk
-//! so the system can detect content corruption and trace data lineage. The
+//! so the system can detect *accidental* corruption and trace data lineage.
-//! hash is a SHA-256 digest (see [`hash_content`]), computed via
+//! The hash is unkeyed (see [`fnv1a_64`]) — this is not a tamper-evidence or
-//! [`clawhdf5_format::provenance::sha256_hex`]. It is still **unkeyed** — an
+//! authenticity guarantee.
-//! actor able to overwrite the stored chunk can also recompute and overwrite
-//! the stored hash alongside it, so this is not an authenticity guarantee
-//! against that threat. What SHA-256 does provide over a fast non-cryptographic
-//! hash (the previous FNV-1a implementation) is collision resistance: an
-//! adversary cannot cheaply craft *different* poisoned content that matches
-//! an already-recorded legitimate hash.
 
 use std::collections::HashMap;
 
 pub use crate::consolidation::MemorySource;
 
 // ---------------------------------------------------------------------------
-// Hash helper
+// Hash helper (std-only FNV-1a 64-bit)
 // ---------------------------------------------------------------------------
 
-/// SHA-256 hex digest of `text`, used to detect content corruption/tampering.
+/// Unkeyed, non-cryptographic FNV-1a hash for detecting accidental content
-///
+/// corruption. It is trivially forgeable by anyone able to modify the stored
-/// Unkeyed: an actor able to modify the stored chunk can also recompute and
+/// data, since they can recompute and overwrite the stored hash alongside
-/// overwrite the stored hash, so a match is not proof of authenticity — only
+/// it — do not rely on this as a tamper-evidence or authenticity control.
-/// that the stored chunk and stored hash are mutually consistent.
+fn fnv1a_64(text: &str) -> u64 {
-fn hash_content(text: &str) -> String {
+    const OFFSET: u64 = 14_695_981_039_346_656_037;
-    clawhdf5_format::provenance::sha256_hex(text.as_bytes())
+    const PRIME: u64 = 1_099_511_628_211;
+    let mut hash = OFFSET;
+    for byte in text.bytes() {
+        hash ^= byte as u64;
+        hash = hash.wrapping_mul(PRIME);
+    }
+    hash
 }
 
 // ---------------------------------------------------------------------------
@@ -57,8 +57,8 @@ pub struct MemoryProvenance {
     pub created_by: String,
     /// Unix timestamp (seconds) of creation.
     pub created_at: f64,
-    /// SHA-256 hex digest of the chunk text for integrity checking.
+    /// FNV-1a 64-bit hash of the chunk text for integrity checking.
-    pub content_hash: String,
+    pub content_hash: u64,
     pub session_id: String,
     pub verified: bool,
 }
@@ -78,7 +78,7 @@ impl MemoryProvenance {
             source,
             created_by: created_by.into(),
             created_at,
-            content_hash: hash_content(chunk),
+            content_hash: fnv1a_64(chunk),
             session_id: session_id.into(),
             verified: false,
         }
@@ -105,6 +105,23 @@ impl ProvenanceStore {
         self.records.insert(provenance.record_id, provenance);
     }
 
+    /// Renumber records after the store was compacted. `index_map[old]` is
+    /// the record's new id, or `None` if it was removed. Without this, every
+    /// surviving record's hash ends up filed under some other record's id and
+    /// the next integrity check reports a bogus mismatch.
+    pub fn remap(&mut self, index_map: &[Option<usize>]) {
+        let old = std::mem::take(&mut self.records);
+        for (old_id, mut prov) in old {
+            let new_id = usize::try_from(old_id)
+                .ok()
+                .and_then(|i| index_map.get(i).copied().flatten());
+            if let Some(new_id) = new_id {
+                prov.record_id = new_id as u64;
+                self.records.insert(new_id as u64, prov);
+            }
+        }
+    }
+
     /// Retrieve by record ID.
     pub fn get(&self, record_id: u64) -> Option<&MemoryProvenance> {
         self.records.get(&record_id)
@@ -121,16 +138,13 @@ impl ProvenanceStore {
     /// Re-hash `current_chunk` and compare against the stored hash.
     /// Returns `true` if the content matches (integrity intact).
     ///
-    /// The hash is unkeyed, so an actor able to modify the stored chunk can
+    /// This only detects accidental corruption: the hash is unkeyed, so an
-    /// also recompute and overwrite the stored hash. Do not treat a `true`
+    /// actor able to modify the stored chunk can also recompute and
-    /// result as proof of authenticity against that threat — but unlike a
+    /// overwrite the stored hash. Do not treat a `true` result as proof the
-    /// non-cryptographic hash, a `false` result reliably indicates that the
+    /// data hasn't been tampered with.
-    /// content does not match what was recorded, since SHA-256 makes it
-    /// computationally infeasible to craft different content that collides
-    /// with a specific existing digest.
     pub fn verify_integrity(&self, record_id: u64, current_chunk: &str) -> bool {
         match self.records.get(&record_id) {
-            Some(p) => p.content_hash == hash_content(current_chunk),
+            Some(p) => p.content_hash == fnv1a_64(current_chunk),
             None => false,
         }
     }
@@ -244,32 +258,22 @@ mod tests {
         1_700_000_000.0
     }
 
-    // --- hash_content ---
+    // --- fnv1a_64 ---
 
     #[test]
     fn hash_deterministic() {
-        assert_eq!(hash_content("hello"), hash_content("hello"));
+        assert_eq!(fnv1a_64("hello"), fnv1a_64("hello"));
     }
 
     #[test]
     fn hash_different_inputs() {
-        assert_ne!(hash_content("hello"), hash_content("world"));
+        assert_ne!(fnv1a_64("hello"), fnv1a_64("world"));
     }
 
     #[test]
     fn hash_empty() {
-        // Should not panic, and should match the well-known SHA-256 of the empty string.
+        // Should not panic
-        assert_eq!(
+        let _ = fnv1a_64("");
-            hash_content(""),
-            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
-        );
-    }
-
-    #[test]
-    fn hash_is_sha256_hex() {
-        let h = hash_content("clawhdf5");
-        assert_eq!(h.len(), 64);
-        assert!(h.chars().all(|c| c.is_ascii_hexdigit()));
     }
 
     // --- MemorySource Display ---
@@ -288,7 +292,7 @@ mod tests {
     #[test]
     fn provenance_new_hashes_chunk() {
         let p = MemoryProvenance::new(1, MemorySource::User, "agent-1", ts(), "hello", "s1");
-        assert_eq!(p.content_hash, hash_content("hello"));
+        assert_eq!(p.content_hash, fnv1a_64("hello"));
         assert!(!p.verified);
     }
 

crates/clawhdf5-agent/src/schema.rs

@@ -12,16 +12,36 @@ use crate::MemoryError;
 use crate::cache::MemoryCache;
 use crate::knowledge::KnowledgeCache;
 use crate::session::SessionCache;
+use crate::wal::WalMark;
 
 pub const SCHEMA_VERSION: &str = "1.0";
 pub const ZEROCLAW_VERSION: &str = "0.8.0";
 
+/// `/meta` attributes holding the [`WalMark`] of the WAL prefix already folded
+/// into this file. Absent on files written before the mark existed, and when
+/// the checkpoint was taken with an empty WAL.
+const WAL_APPLIED_LEN_ATTR: &str = "wal_applied_len";
+const WAL_APPLIED_CRC_ATTR: &str = "wal_applied_crc";
+
 /// Build a complete HDF5 file from the in-memory state.
 pub fn build_hdf5_file(
     config: &MemoryConfig,
     cache: &MemoryCache,
     sessions: &SessionCache,
     knowledge: &KnowledgeCache,
+) -> Result<Vec<u8>, MemoryError> {
+    build_hdf5_file_with_mark(config, cache, sessions, knowledge, None)
+}
+
+/// [`build_hdf5_file`], recording which WAL prefix this state already
+/// contains (see [`WalMark`]) so a crash before the WAL is truncated doesn't
+/// replay those entries a second time.
+pub fn build_hdf5_file_with_mark(
+    config: &MemoryConfig,
+    cache: &MemoryCache,
+    sessions: &SessionCache,
+    knowledge: &KnowledgeCache,
+    wal_applied: Option<WalMark>,
 ) -> Result<Vec<u8>, MemoryError> {
     let mut builder = clawhdf5::FileBuilder::new();
 
@@ -34,10 +54,35 @@ pub fn build_hdf5_file(
     meta.set_attr("embedding_dim", AttrValue::I64(config.embedding_dim as i64));
     meta.set_attr("chunk_size", AttrValue::I64(config.chunk_size as i64));
     meta.set_attr("overlap", AttrValue::I64(config.overlap as i64));
+    // Behavioural settings. These used to live only in memory, so reopening a
+    // store silently reset them to defaults — e.g. a compressed store was
+    // rewritten uncompressed by the first checkpoint after a reopen. Loaders
+    // treat each one as optional so older files keep opening.
+    meta.set_attr("float16", AttrValue::I64(config.float16.into()));
+    meta.set_attr("compression", AttrValue::I64(config.compression.into()));
+    meta.set_attr(
+        "compression_level",
+        AttrValue::I64(config.compression_level.into()),
+    );
+    meta.set_attr(
+        "compact_threshold",
+        AttrValue::F64(config.compact_threshold.into()),
+    );
+    meta.set_attr("hebbian_boost", AttrValue::F64(config.hebbian_boost.into()));
+    meta.set_attr("decay_factor", AttrValue::F64(config.decay_factor.into()));
+    meta.set_attr("wal_enabled", AttrValue::I64(config.wal_enabled.into()));
+    meta.set_attr(
+        "wal_max_entries",
+        AttrValue::I64(config.wal_max_entries as i64),
+    );
     meta.set_attr(
         "edgehdf5_version",
         AttrValue::String(ZEROCLAW_VERSION.into()),
     );
+    if let Some(mark) = wal_applied.filter(|m| m.len > 0) {
+        meta.set_attr(WAL_APPLIED_LEN_ATTR, AttrValue::I64(mark.len as i64));
+        meta.set_attr(WAL_APPLIED_CRC_ATTR, AttrValue::I64(i64::from(mark.crc)));
+    }
     // Need at least one dataset in the group for it to be a proper group
     meta.create_dataset("_marker").with_u8_data(&[1]).compact();
     let finished_meta = meta.finish();
@@ -83,15 +128,33 @@ fn build_memory_group(
             let rows_per_chunk = (target_chunk_bytes / (d * 4)).max(1).min(n);
             ds.with_chunks(&[rows_per_chunk, d]);
 
-            // Compression: Zstd for embeddings — faster than deflate at same ratio.
+            // Compression. Shuffle is applied automatically (auto-shuffle
-            // Shuffle is applied automatically (auto-shuffle pre-filter).
+            // pre-filter). Zstd is faster than deflate at the same ratio but
+            // pulls in libzstd, so it is opt-in via the `zstd` feature; the
+            // default build uses deflate, which is always available. (This
+            // used to call `with_zstd` unconditionally, so without the
+            // feature every checkpoint of a compressed store failed with
+            // "unsupported filter: 32015".) Both are standard HDF5 filters;
+            // reading a zstd-compressed store needs a zstd-enabled build.
             if config.compression {
-                let level = if config.compression_level > 0 {
+                #[cfg(feature = "zstd")]
-                    config.compression_level.min(22)
+                {
-                } else {
+                    let level = if config.compression_level > 0 {
-                    3 // Zstd level 3: fast + good ratio for f32 embeddings
+                        config.compression_level.min(22)
-                };
+                    } else {
-                ds.with_zstd(level);
+                        3 // fast + good ratio for f32 embeddings
+                    };
+                    ds.with_zstd(level);
+                }
+                #[cfg(not(feature = "zstd"))]
+                {
+                    let level = if config.compression_level > 0 {
+                        config.compression_level.min(9)
+                    } else {
+                        4
+                    };
+                    ds.with_deflate(level);
+                }
             }
         }
 
@@ -309,6 +372,20 @@ fn write_string_dataset(
 }
 
 /// Validate an HDF5 file has the correct schema and load all data.
+/// Read the checkpoint's [`WalMark`] from `/meta`, if it has one.
+pub fn read_wal_mark(file: &clawhdf5::File) -> Option<WalMark> {
+    let attrs = file.group("meta").ok()?.attrs().ok()?;
+    let len = match attrs.get(WAL_APPLIED_LEN_ATTR)? {
+        AttrValue::I64(v) => u64::try_from(*v).ok()?,
+        _ => return None,
+    };
+    let crc = match attrs.get(WAL_APPLIED_CRC_ATTR)? {
+        AttrValue::I64(v) => u32::try_from(*v).ok()?,
+        _ => return None,
+    };
+    Some(WalMark { len, crc })
+}
+
 pub fn validate_and_load(
     file: &clawhdf5::File,
 ) -> Result<(MemoryConfig, MemoryCache, SessionCache, KnowledgeCache), MemoryError> {
@@ -344,15 +421,19 @@ pub fn validate_and_load(
         embedding_dim,
         chunk_size,
         overlap,
-        float16: false,
+        float16: optional_bool_attr(&attrs, "float16", false),
-        compression: false,
+        compression: optional_bool_attr(&attrs, "compression", false),
-        compression_level: 0,
+        compression_level: optional_i64_attr(&attrs, "compression_level")
-        compact_threshold: 0.3,
+            .and_then(|v| u32::try_from(v).ok())
-        hebbian_boost: 0.15,
+            .unwrap_or(0),
-        decay_factor: 0.98,
+        compact_threshold: optional_f32_attr(&attrs, "compact_threshold", 0.3),
+        hebbian_boost: optional_f32_attr(&attrs, "hebbian_boost", 0.15),
+        decay_factor: optional_f32_attr(&attrs, "decay_factor", 0.98),
         created_at,
-        wal_enabled: true,
+        wal_enabled: optional_bool_attr(&attrs, "wal_enabled", true),
-        wal_max_entries: 500,
+        wal_max_entries: optional_i64_attr(&attrs, "wal_max_entries")
+            .and_then(|v| usize::try_from(v).ok())
+            .unwrap_or(500),
     };
 
     // Load /memory group
@@ -391,20 +472,46 @@ fn load_memory_group(
     let tags = read_string_dataset_from_group(&group, "tags")?;
     let tombstones = read_u8_dataset(&group, "tombstones")?;
 
-    // Read norms if present, otherwise compute from embeddings
+    // Every per-record dataset must describe exactly `n` records. Without
-    let norms = match read_f32_dataset(&group, "norms") {
+    // this, a truncated or hand-edited file loads "successfully" and then
-        Ok(n) if n.len() == n.len() => n,
+    // panics on the first out-of-bounds index during search/delete.
-        _ => {
+    if embedding_dim == 0 {
-            // Compute norms from flat embeddings
+        return Err(MemoryError::Schema(format!(
-            flat_embeddings
+            "/memory has {n} records but embedding_dim is 0"
-                .chunks(embedding_dim)
+        )));
-                .map(|chunk| {
+    }
-                    let sq_sum: f32 = chunk.iter().map(|x| x * x).sum();
+    let expected_flat = n.checked_mul(embedding_dim).ok_or_else(|| {
-                    sq_sum.sqrt()
+        MemoryError::Schema(format!("/memory size overflow: {n} x {embedding_dim}"))
-                })
+    })?;
-                .collect()
+    let check_len = |name: &str, actual: usize, expected: usize| {
+        if actual == expected {
+            Ok(())
+        } else {
+            Err(MemoryError::Schema(format!(
+                "/memory/{name} has {actual} entries, expected {expected} \
+                 ({n} records)"
+            )))
         }
     };
+    check_len("embeddings", flat_embeddings.len(), expected_flat)?;
+    check_len("source_channel", source_channels.len(), n)?;
+    check_len("timestamps", timestamps.len(), n)?;
+    check_len("session_ids", session_ids.len(), n)?;
+    check_len("tags", tags.len(), n)?;
+    check_len("tombstones", tombstones.len(), n)?;
+
+    // Norms are derived data: use the stored ones only if they are present
+    // and the right length, otherwise recompute from the embeddings.
+    let norms = match read_f32_dataset(&group, "norms") {
+        Ok(stored) if stored.len() == n => stored,
+        _ => flat_embeddings
+            .chunks(embedding_dim)
+            .map(|chunk| {
+                let sq_sum: f32 = chunk.iter().map(|x| x * x).sum();
+                sq_sum.sqrt()
+            })
+            .collect(),
+    };
 
     // Unflatten embeddings
     let embeddings: Vec<Vec<f32>> = flat_embeddings
@@ -427,6 +534,7 @@ fn load_memory_group(
     cache.tombstones = tombstones;
     cache.norms = norms;
     cache.activation_weights = activation_weights;
+    cache.rebuild_flat();
 
     Ok(cache)
 }
@@ -480,6 +588,7 @@ fn load_knowledge_group(file: &clawhdf5::File) -> Result<KnowledgeCache, MemoryE
             cache.entities.push(crate::knowledge::Entity {
                 id: entity_ids[i] as u64,
                 name: entity_names[i].clone(),
+                name_lower: entity_names[i].to_lowercase(),
                 entity_type: entity_types[i].clone(),
                 embedding_idx: emb_idxs[i],
                 ..Default::default()
@@ -529,6 +638,27 @@ fn extract_string_attr(
     }
 }
 
+type MetaAttrs = std::collections::HashMap<String, AttrValue>;
+
+fn optional_i64_attr(attrs: &MetaAttrs, name: &str) -> Option<i64> {
+    match attrs.get(name) {
+        Some(AttrValue::I64(v)) => Some(*v),
+        _ => None,
+    }
+}
+
+fn optional_bool_attr(attrs: &MetaAttrs, name: &str, default: bool) -> bool {
+    optional_i64_attr(attrs, name).map_or(default, |v| v != 0)
+}
+
+/// Finite values only: a NaN threshold/decay would poison every comparison.
+fn optional_f32_attr(attrs: &MetaAttrs, name: &str, default: f32) -> f32 {
+    match attrs.get(name) {
+        Some(AttrValue::F64(v)) if v.is_finite() => *v as f32,
+        _ => default,
+    }
+}
+
 fn extract_i64_attr(
     attrs: &std::collections::HashMap<String, AttrValue>,
     name: &str,
@@ -614,3 +744,108 @@ fn read_u8_dataset(group: &clawhdf5::Group<'_>, name: &str) -> Result<Vec<u8>, M
         .map_err(|e| MemoryError::Hdf5(format!("cannot read u8 from {name}: {e}")))?;
     Ok(data.into_iter().map(|v| v as u8).collect())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn config() -> MemoryConfig {
+        MemoryConfig::new(std::path::PathBuf::from("unused.h5"), "agent", 4)
+    }
+
+    fn cache_with(n: usize) -> MemoryCache {
+        let mut cache = MemoryCache::new(4);
+        for i in 0..n {
+            cache.push(
+                format!("chunk {i}"),
+                vec![i as f32 + 1.0, 0.0, 0.0, 0.0],
+                "user".into(),
+                i as f64,
+                "s".into(),
+                "t".into(),
+            );
+        }
+        cache
+    }
+
+    fn roundtrip(cache: &MemoryCache) -> Result<MemoryCache, MemoryError> {
+        let bytes = build_hdf5_file(
+            &config(),
+            cache,
+            &SessionCache::new(),
+            &KnowledgeCache::new(),
+        )?;
+        let file =
+            clawhdf5::File::from_bytes(bytes).map_err(|e| MemoryError::Hdf5(e.to_string()))?;
+        validate_and_load(&file).map(|(_, cache, _, _)| cache)
+    }
+
+    #[test]
+    fn behavioural_config_survives_a_reopen() {
+        let mut cfg = config();
+        cfg.compression = true;
+        cfg.compression_level = 7;
+        cfg.compact_threshold = 0.5;
+        cfg.hebbian_boost = 0.25;
+        cfg.decay_factor = 0.9;
+        cfg.wal_enabled = false;
+        cfg.wal_max_entries = 42;
+        let bytes = build_hdf5_file(
+            &cfg,
+            &cache_with(2),
+            &SessionCache::new(),
+            &KnowledgeCache::new(),
+        )
+        .unwrap();
+        let file = clawhdf5::File::from_bytes(bytes).unwrap();
+        let (loaded, loaded_cache, ..) = validate_and_load(&file).unwrap();
+        // The compressed embeddings must also read back intact.
+        assert_eq!(loaded_cache.embeddings, cache_with(2).embeddings);
+        assert!(loaded.compression);
+        assert_eq!(loaded.compression_level, 7);
+        assert_eq!(loaded.compact_threshold, 0.5);
+        assert_eq!(loaded.hebbian_boost, 0.25);
+        assert_eq!(loaded.decay_factor, 0.9);
+        assert!(!loaded.wal_enabled);
+        assert_eq!(loaded.wal_max_entries, 42);
+    }
+
+    #[test]
+    fn consistent_store_loads() {
+        let loaded = roundtrip(&cache_with(3)).unwrap();
+        assert_eq!(loaded.chunks.len(), 3);
+        assert_eq!(loaded.norms, vec![1.0, 2.0, 3.0]);
+    }
+
+    #[test]
+    fn wrong_length_norms_are_recomputed_not_trusted() {
+        // Regression: the guard used to be `n.len() == n.len()`, so a norms
+        // dataset of any length was accepted and corrupted every cosine score.
+        let mut cache = cache_with(3);
+        cache.norms = vec![99.0];
+        let loaded = roundtrip(&cache).unwrap();
+        assert_eq!(loaded.norms, vec![1.0, 2.0, 3.0]);
+    }
+
+    #[test]
+    fn mismatched_per_record_datasets_are_schema_errors() {
+        type Corrupt = fn(&mut MemoryCache);
+        let cases: [(&str, Corrupt); 5] = [
+            ("tombstones", |c| c.tombstones.truncate(1)),
+            ("timestamps", |c| c.timestamps.truncate(1)),
+            ("tags", |c| c.tags.truncate(1)),
+            ("session_ids", |c| c.session_ids.truncate(1)),
+            ("source_channel", |c| c.source_channels.truncate(1)),
+        ];
+        for (name, corrupt) in cases {
+            let mut cache = cache_with(3);
+            corrupt(&mut cache);
+            match roundtrip(&cache) {
+                Err(MemoryError::Schema(msg)) => {
+                    assert!(msg.contains(name), "{name}: unexpected message {msg}")
+                }
+                other => panic!("{name}: expected Schema error, got {:?}", other.map(|_| ())),
+            }
+        }
+    }
+}

crates/clawhdf5-agent/src/search.rs

@@ -113,13 +113,24 @@ impl HDF5Memory {
                 }
             })
             .collect();
+        // Ties broken by index so results (and therefore which records get
+        // boosted) don't depend on HashMap iteration order upstream.
         results.sort_by(|a, b| {
             b.score
                 .partial_cmp(&a.score)
                 .unwrap_or(std::cmp::Ordering::Equal)
+                .then(a.index.cmp(&b.index))
         });
 
-        let hit_indices: Vec<usize> = results.iter().map(|r| r.index).collect();
+        // Only reinforce records that actually matched. When fewer than `k`
+        // records are relevant, the rest of the list is zero-score filler;
+        // boosting it would teach the store that arbitrary records are
+        // important just because they were nearby in iteration order.
+        let hit_indices: Vec<usize> = results
+            .iter()
+            .filter(|r| r.score > 0.0)
+            .map(|r| r.index)
+            .collect();
         self.apply_hebbian_boost(&hit_indices);
         self.flush().ok();
 

crates/clawhdf5-agent/src/storage.rs

@@ -11,6 +11,7 @@ use crate::cache::MemoryCache;
 use crate::knowledge::KnowledgeCache;
 use crate::schema;
 use crate::session::SessionCache;
+use crate::wal::WalMark;
 
 /// Write all in-memory state to an HDF5 file on disk.
 pub fn write_to_disk(
@@ -20,7 +21,20 @@ pub fn write_to_disk(
     sessions: &SessionCache,
     knowledge: &KnowledgeCache,
 ) -> Result<(), MemoryError> {
-    let bytes = schema::build_hdf5_file(config, cache, sessions, knowledge)?;
+    write_to_disk_with_mark(path, config, cache, sessions, knowledge, None)
+}
+
+/// [`write_to_disk`] for a checkpoint: `wal_applied` is the mark of the WAL
+/// prefix whose entries `cache` already contains.
+pub fn write_to_disk_with_mark(
+    path: &Path,
+    config: &MemoryConfig,
+    cache: &MemoryCache,
+    sessions: &SessionCache,
+    knowledge: &KnowledgeCache,
+    wal_applied: Option<WalMark>,
+) -> Result<(), MemoryError> {
+    let bytes = schema::build_hdf5_file_with_mark(config, cache, sessions, knowledge, wal_applied)?;
 
     if bytes.is_empty() {
         return Err(MemoryError::Hdf5("build_hdf5_file produced 0 bytes".into()));
@@ -28,9 +42,41 @@ pub fn write_to_disk(
 
     // Write to a temp file first, then rename for atomicity
     let tmp_path = path.with_extension("h5.tmp");
-    std::fs::write(&tmp_path, &bytes).map_err(MemoryError::Io)?;
+    write_synced(&tmp_path, &bytes)?;
-    std::fs::rename(&tmp_path, path).map_err(MemoryError::Io)?;
+    rename_synced(&tmp_path, path)
+}
 
+/// Write `bytes` to `path` and flush them to stable storage.
+fn write_synced(path: &Path, bytes: &[u8]) -> Result<(), MemoryError> {
+    use std::io::Write;
+    let mut f = std::fs::File::create(path).map_err(MemoryError::Io)?;
+    f.write_all(bytes).map_err(MemoryError::Io)?;
+    f.sync_all().map_err(MemoryError::Io)
+}
+
+/// Rename `from` over `to`, then sync the parent directory so the rename
+/// itself survives a power loss. `from` must already be synced: without that,
+/// the rename can reach disk before the data and leave an empty or partial
+/// file under the final name.
+///
+/// This is per-checkpoint/snapshot cost only (each is already a full file
+/// write). Individual WAL appends are deliberately not synced — see the
+/// durability notes in the crate docs.
+fn rename_synced(from: &Path, to: &Path) -> Result<(), MemoryError> {
+    std::fs::rename(from, to).map_err(MemoryError::Io)?;
+    #[cfg(unix)]
+    if let Some(dir) = to.parent() {
+        let dir = if dir.as_os_str().is_empty() {
+            Path::new(".")
+        } else {
+            dir
+        };
+        // Directory fsync is best-effort: some filesystems refuse it, and the
+        // rename has already happened.
+        if let Ok(d) = std::fs::File::open(dir) {
+            let _ = d.sync_all();
+        }
+    }
     Ok(())
 }
 
@@ -42,6 +88,15 @@ pub fn write_to_disk(
 pub fn read_from_disk(
     path: &Path,
 ) -> Result<(MemoryConfig, MemoryCache, SessionCache, KnowledgeCache), MemoryError> {
+    read_from_disk_with_mark(path).map(|(state, _mark)| state)
+}
+
+/// Everything [`read_from_disk`] returns.
+pub type StoreState = (MemoryConfig, MemoryCache, SessionCache, KnowledgeCache);
+
+/// [`read_from_disk`], plus the checkpoint's [`WalMark`] (if any) so the
+/// caller can skip WAL entries this file already contains.
+pub fn read_from_disk_with_mark(path: &Path) -> Result<(StoreState, Option<WalMark>), MemoryError> {
     let mmap = clawhdf5_io::MmapReader::open(path).map_err(MemoryError::Io)?;
 
     // Advise the OS we'll need the whole file for parsing
@@ -53,8 +108,9 @@ pub fn read_from_disk(
 
     let (mut config, cache, sessions, knowledge) = schema::validate_and_load(&file)?;
     config.path = path.to_path_buf();
+    let wal_applied = schema::read_wal_mark(&file);
 
-    Ok((config, cache, sessions, knowledge))
+    Ok(((config, cache, sessions, knowledge), wal_applied))
 }
 
 /// Copy an HDF5 file atomically to a destination.
@@ -78,7 +134,10 @@ pub fn snapshot_file(src: &Path, dest: &Path) -> Result<std::path::PathBuf, Memo
     // Atomic copy: write to temp, then rename
     let tmp_path = dest_file.with_extension("h5.tmp");
     std::fs::copy(src, &tmp_path).map_err(MemoryError::Io)?;
-    std::fs::rename(&tmp_path, &dest_file).map_err(MemoryError::Io)?;
+    std::fs::File::open(&tmp_path)
+        .and_then(|f| f.sync_all())
+        .map_err(MemoryError::Io)?;
+    rename_synced(&tmp_path, &dest_file)?;
 
     Ok(dest_file)
 }

crates/clawhdf5-agent/src/store_lock.rs

@@ -0,0 +1,79 @@
+//! Single-writer guard for a memory store.
+//!
+//! `HDF5Memory` keeps the whole store in memory and rewrites the `.h5` file at
+//! every checkpoint, so two handles on one store (two processes, or two opens
+//! in one process) silently destroy each other's data: whoever checkpoints
+//! last wins, and both append to the same WAL with independent CRC chains.
+//! The lock turns that into an immediate, explicit error.
+
+use std::fs::{File, OpenOptions, TryLockError};
+use std::path::{Path, PathBuf};
+
+use crate::MemoryError;
+
+const LOCK_RETRIES: u32 = 25;
+const LOCK_RETRY_DELAY: std::time::Duration = std::time::Duration::from_millis(10);
+
+/// An exclusive advisory lock on `<store>.h5.lock`, held for the lifetime of
+/// the owning `HDF5Memory` and released when it is dropped (or when the
+/// process dies — the OS drops the lock with the file descriptor, so a crash
+/// never leaves a stale lock behind; the empty lock file itself is harmless).
+#[derive(Debug)]
+pub(crate) struct StoreLock {
+    _file: File,
+}
+
+impl StoreLock {
+    pub(crate) fn lock_path(store: &Path) -> PathBuf {
+        store.with_extension("h5.lock")
+    }
+
+    pub(crate) fn acquire(store: &Path) -> Result<Self, MemoryError> {
+        let path = Self::lock_path(store);
+        let file = OpenOptions::new()
+            .create(true)
+            .truncate(false)
+            .write(true)
+            .open(&path)?;
+        // A previous owner may be mid-teardown (e.g. an `AsyncHDF5Memory`
+        // dropped without `shutdown()`: its background task releases the
+        // store a moment later), so give the lock a short, bounded grace
+        // period before reporting a genuine second writer.
+        let mut attempts_left = LOCK_RETRIES;
+        loop {
+            match file.try_lock() {
+                Ok(()) => return Ok(Self { _file: file }),
+                Err(TryLockError::WouldBlock) if attempts_left > 0 => {
+                    attempts_left -= 1;
+                    std::thread::sleep(LOCK_RETRY_DELAY);
+                }
+                Err(TryLockError::WouldBlock) => {
+                    return Err(MemoryError::Locked(format!(
+                        "{} is already open in this or another process (lock file {})",
+                        store.display(),
+                        path.display()
+                    )));
+                }
+                Err(TryLockError::Error(e)) => return Err(MemoryError::Io(e)),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn second_acquire_fails_until_first_is_dropped() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let store = dir.path().join("s.h5");
+        let first = StoreLock::acquire(&store).unwrap();
+        assert!(matches!(
+            StoreLock::acquire(&store),
+            Err(MemoryError::Locked(_))
+        ));
+        drop(first);
+        StoreLock::acquire(&store).unwrap();
+    }
+}

crates/clawhdf5-agent/src/strategy.rs

@@ -167,10 +167,17 @@ pub fn auto_select_strategy(num_vectors: usize, hw: &HardwareCapabilities) -> Se
 /// This dispatches to the appropriate search implementation based on the
 /// selected strategy. For IVF-PQ, an index must be provided externally
 /// (this function uses brute-force fallback if no IVF-PQ index is available).
+///
+/// `vectors_flat` is `vectors` flattened into one contiguous `[N × dim]`
+/// row-major buffer (e.g. `MemoryCache::embeddings_flat`, maintained
+/// incrementally alongside `vectors`). It's only consulted by the
+/// `Blas`/`Accelerate` strategies, which otherwise re-flatten the whole
+/// corpus on every call — passing the already-flat buffer skips that copy.
 #[allow(clippy::too_many_arguments)]
 pub fn search_with_metrics(
     query: &[f32],
     vectors: &[Vec<f32>],
+    vectors_flat: &[f32],
     norms: &[f32],
     tombstones: &[u8],
     k: usize,
@@ -178,6 +185,10 @@ pub fn search_with_metrics(
     #[cfg(feature = "gpu")] gpu_backend: Option<&crate::gpu_search::GpuSearchBackend>,
     #[cfg(not(feature = "gpu"))] _gpu_backend: Option<&()>,
 ) -> (Vec<(usize, f32)>, SearchMetrics) {
+    // Only read by the Blas/Accelerate arms below, which are themselves
+    // feature-gated — reference it unconditionally so a build with neither
+    // feature enabled doesn't warn about an unused parameter.
+    let _ = vectors_flat;
     let start = Instant::now();
     let active_count = tombstones.iter().filter(|&&t| t == 0).count();
 
@@ -197,7 +208,14 @@ pub fn search_with_metrics(
             gpu_active = false;
             #[cfg(feature = "fast-math")]
             {
-                crate::blas_search::blas_cosine_batch(query, vectors, norms, tombstones, k)
+                crate::blas_search::blas_cosine_batch_flat(
+                    query,
+                    vectors_flat,
+                    norms,
+                    tombstones,
+                    query.len(),
+                    k,
+                )
             }
             #[cfg(not(feature = "fast-math"))]
             {
@@ -211,8 +229,13 @@ pub fn search_with_metrics(
             gpu_active = false;
             #[cfg(any(feature = "accelerate", feature = "openblas"))]
             {
-                crate::accelerate_search::accelerate_cosine_batch_vecs(
+                crate::accelerate_search::accelerate_cosine_batch(
-                    query, vectors, norms, tombstones, k,
+                    query,
+                    vectors_flat,
+                    norms,
+                    tombstones,
+                    query.len(),
+                    k,
                 )
             }
             #[cfg(not(any(feature = "accelerate", feature = "openblas")))]
@@ -325,6 +348,10 @@ mod tests {
         (0..n).map(|_| (0..dim).map(|_| next()).collect()).collect()
     }
 
+    fn flatten(vectors: &[Vec<f32>]) -> Vec<f32> {
+        vectors.iter().flatten().copied().collect()
+    }
+
     // --- auto_select_strategy tests ---
 
     #[test]
@@ -490,6 +517,7 @@ mod tests {
         let (results, metrics) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             5,
@@ -520,6 +548,7 @@ mod tests {
         let (results, metrics) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             10,
@@ -545,6 +574,7 @@ mod tests {
         let (_, metrics) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             10,
@@ -570,6 +600,7 @@ mod tests {
         let (results, _) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             10,
@@ -603,6 +634,7 @@ mod tests {
         let (results, metrics) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             100,
@@ -647,6 +679,7 @@ mod tests {
         let (_, metrics) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             5,
@@ -718,6 +751,7 @@ mod tests {
         let (results, metrics) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             10,
@@ -744,6 +778,7 @@ mod tests {
         let (results, metrics) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             10,
@@ -822,6 +857,7 @@ mod tests {
         let (results, metrics) = search_with_metrics(
             &query,
             &vectors,
+            &flatten(&vectors),
             &norms,
             &tombstones,
             10,

crates/clawhdf5-agent/src/wal.rs

@@ -13,16 +13,57 @@ use crate::MemoryError;
 
 const WAL_MAGIC: [u8; 4] = [0x45, 0x48, 0x57, 0x4C]; // "EHWL"
 
-/// Current WAL format version: every entry ends with a 4-byte CRC32 trailer
+/// Bytes before the first entry: [`WAL_MAGIC`] (4) + version (1) + entry
-/// (see [`TeeReader`]) so a bit-flip is detected and replay stops there
+/// count (4). Named so the offset arithmetic in `open()` — which decides
-/// instead of silently accepting corrupted data.
+/// where an append lands, and therefore whether it is replayable — reads as
-const WAL_VERSION: u8 = 2;
+/// a header length rather than a bare 9.
+const WAL_HEADER_LEN: u64 = WAL_MAGIC.len() as u64 + 1 + 4;
 
-/// The only other WAL version this crate still knows how to *read*: no
+/// Current WAL format version: every entry's CRC32 trailer is computed over
-/// per-entry CRC trailer. Written by versions of this crate before the CRC32
+/// its own bytes *chained with the previous entry's stored CRC*
-/// hardening. `WalFile::open` migrates a legacy file to [`WAL_VERSION`] by
+/// (`crc32(entry_bytes ++ prev_crc.to_le_bytes())`, seeded with 0 for the
-/// recreating it fresh — safe because every real call site reads existing
+/// first entry after a truncation). A per-entry CRC alone only detects a
-/// entries via [`WalFile::read_entries`] before calling `open` (see
+/// bit-flip within that entry; chaining additionally detects entries being
+/// reordered, duplicated, or spliced (e.g. a Tombstone moved before/after
+/// its target Save) — the moved/inserted entry's stored CRC was computed
+/// against a different predecessor than the one now in front of it on disk,
+/// so the chain breaks at that point and replay stops there.
+const WAL_VERSION: u8 = 4;
+
+/// The chained-CRC format before [`WalEntryType::Update`] records existed.
+/// Byte-for-byte the same framing as [`WAL_VERSION`], so it is read by the
+/// same code, and `WalFile::open` upgrades it in place by rewriting the
+/// header's version byte (the header is not covered by the CRC chain).
+///
+/// The bump exists for *older binaries*: they don't know record type 0x04,
+/// would treat it as a torn tail, and would truncate it — and everything
+/// after it — away. An unknown header version makes them refuse the file
+/// with a clear error instead.
+const WAL_VERSION_CHAINED_NO_UPDATE: u8 = 3;
+
+/// The previous WAL format version: still a CRC32 per entry (so a bit-flip
+/// within one entry is caught), but not chained to the previous entry's CRC
+/// (so reordering/splicing whole entries is not detected). Written by
+/// versions of this crate before the chaining hardening. Fully supported for
+/// reading via [`WalFile::read_entries`] — not restricted like
+/// [`WAL_VERSION_LEGACY_NO_CRC`], since it still verifies each entry
+/// individually. `WalFile::open` migrates it to [`WAL_VERSION`] by
+/// recreating the file fresh, the same as the legacy-no-CRC migration below.
+const WAL_VERSION_CRC_UNCHAINED: u8 = 2;
+
+/// The oldest WAL version this crate still knows how to *read*: no
+/// per-entry CRC trailer at all, so a bit-flip anywhere is silently
+/// accepted. Written by versions of this crate before the CRC32 hardening.
+/// Because of that — unlike [`WAL_VERSION_CRC_UNCHAINED`] — this version is
+/// deliberately *not* reachable through the public [`WalFile::read_entries`]
+/// API; only [`WalFile::read_entries_for_migration`] (used exclusively by
+/// `HDF5Memory::open`'s one-time migration path) will parse it. Flipping a
+/// version byte from 2/3 down to 1 no longer silently downgrades a file to
+/// the fully-unverified parser for an arbitrary caller.
+///
+/// `WalFile::open` migrates a legacy file to [`WAL_VERSION`] by recreating
+/// it fresh — safe because every real call site reads existing entries via
+/// [`WalFile::read_entries_for_migration`] before calling `open` (see
 /// `HDF5Memory::open`), so no data is lost.
 const WAL_VERSION_LEGACY_NO_CRC: u8 = 1;
 
@@ -37,6 +78,10 @@ pub enum WalEntryType {
     Save = 0x01,
     Tombstone = 0x02,
     ActivationUpdate = 0x03,
+    /// Replace the record at `update_index` in place (`save_or_update` hit).
+    /// Logged as a plain `Save` before this existed, so replay appended a
+    /// duplicate instead of updating.
+    Update = 0x04,
 }
 
 impl WalEntryType {
@@ -45,6 +90,7 @@ impl WalEntryType {
             0x01 => Some(Self::Save),
             0x02 => Some(Self::Tombstone),
             0x03 => Some(Self::ActivationUpdate),
+            0x04 => Some(Self::Update),
             _ => None,
         }
     }
@@ -61,6 +107,8 @@ pub struct WalEntry {
     pub tags: String,
     /// For tombstone entries: the index of the entry to delete.
     pub tombstone_index: Option<usize>,
+    /// For update entries: the index of the record to replace.
+    pub update_index: Option<usize>,
 }
 
 /// How many entries to accumulate before updating the header entry_count.
@@ -77,15 +125,77 @@ pub struct WalFile {
     entry_count: u32,
     /// Entries written since the last header count update.
     pending_header_sync: u32,
+    /// CRC32 chain state: the previous entry's stored CRC (0 if this file
+    /// has no entries yet), folded into the next entry's CRC computation.
+    /// Reset to 0 by `truncate()`/`create_fresh_wal_file`, and re-derived by
+    /// scanning existing entries when `open()` attaches to a non-empty file.
+    running_crc: u32,
+    /// Bytes of verified entries after the header (the length of the chain
+    /// `running_crc` covers). Together they form the [`WalMark`].
+    chain_len: u64,
+}
+
+/// What a WAL file's 9-byte header looks like, without reading any entries.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WalHeaderStatus {
+    /// A version this build can read (current or legacy).
+    Readable,
+    /// Shorter than a header — e.g. a crash while the file was being created.
+    /// It cannot contain entries.
+    Torn,
+    /// Not a WAL file at all.
+    BadMagic,
+    /// Well-formed header from a version this build doesn't know — most
+    /// likely written by a *newer* build. Never discard this: the entries are
+    /// probably fine, this binary just can't read them.
+    UnknownVersion(u8),
+}
+
+/// Classify the header of the WAL at `path`.
+pub fn wal_header_status(path: &Path) -> std::io::Result<WalHeaderStatus> {
+    let mut header = [0u8; WAL_HEADER_LEN as usize];
+    let mut f = File::open(path)?;
+    let mut filled = 0;
+    while filled < header.len() {
+        match f.read(&mut header[filled..])? {
+            0 => return Ok(WalHeaderStatus::Torn),
+            n => filled += n,
+        }
+    }
+    if header[0..4] != WAL_MAGIC {
+        return Ok(WalHeaderStatus::BadMagic);
+    }
+    Ok(match header[4] {
+        WAL_VERSION
+        | WAL_VERSION_CHAINED_NO_UPDATE
+        | WAL_VERSION_CRC_UNCHAINED
+        | WAL_VERSION_LEGACY_NO_CRC => WalHeaderStatus::Readable,
+        v => WalHeaderStatus::UnknownVersion(v),
+    })
+}
+
+/// A position in a WAL's CRC chain: `len` bytes of entries after the header,
+/// whose chained CRC is `crc`.
+///
+/// A checkpoint stores the mark of the WAL prefix it folded into the `.h5`
+/// file. If the process dies after the new `.h5` is in place but before the
+/// WAL is truncated, the next `open()` finds that exact prefix still in the
+/// WAL and skips it instead of replaying it on top of data that already
+/// contains it (which used to duplicate every pending entry).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct WalMark {
+    pub len: u64,
+    pub crc: u32,
 }
 
 impl WalFile {
     /// Open or create a WAL file. If it exists, read the header and entry count.
     ///
-    /// A legacy (pre-CRC) WAL file is migrated to the current format by
+    /// A pre-chaining WAL file ([`WAL_VERSION_CRC_UNCHAINED`] or
-    /// recreating it fresh — see [`WAL_VERSION_LEGACY_NO_CRC`]. Callers that
+    /// [`WAL_VERSION_LEGACY_NO_CRC`]) is migrated to the current format by
-    /// need the legacy file's entries must call [`WalFile::read_entries`]
+    /// recreating it fresh. Callers that need an existing file's entries must
-    /// first, before calling `open`.
+    /// call [`WalFile::read_entries`] (or, for a legacy-no-CRC file,
+    /// [`WalFile::read_entries_for_migration`]) first, before calling `open`.
     pub fn open(path: &Path) -> Result<Self, MemoryError> {
         if path.exists() {
             // Read existing header
@@ -102,20 +212,71 @@ impl WalFile {
             let mut ver = [0u8; 1];
             f.read_exact(&mut ver)?;
             match ver[0] {
-                WAL_VERSION => {
+                WAL_VERSION | WAL_VERSION_CHAINED_NO_UPDATE => {
+                    if ver[0] == WAL_VERSION_CHAINED_NO_UPDATE {
+                        // Same framing; stamp the current version so an older
+                        // binary refuses this file rather than truncating an
+                        // Update record it can't parse. See the constant.
+                        f.seek(SeekFrom::Start(4))?;
+                        f.write_all(&[WAL_VERSION])?;
+                        f.seek(SeekFrom::Start(5))?;
+                    }
                     let mut count_buf = [0u8; 4];
                     f.read_exact(&mut count_buf)?;
-                    let entry_count = u32::from_le_bytes(count_buf);
+                    let header_count = u32::from_le_bytes(count_buf);
-                    // Seek to end for appending
+                    // Scan any existing entries to resume the CRC chain
-                    f.seek(SeekFrom::End(0))?;
+                    // correctly for further appends (the header's count may
+                    // be stale from deferred group-commit sync, same
+                    // tolerance `read_entries` already has, so the scanned
+                    // count is also the more accurate of the two).
+                    let (entries, running_crc, verified_bytes) =
+                        read_chained_entries(&mut f, 0, None);
+                    let entry_count = if entries.is_empty() {
+                        header_count
+                    } else {
+                        entries.len() as u32
+                    };
+                    // Position the append at the end of the VERIFIED prefix,
+                    // and drop anything after it.
+                    //
+                    // This used to `seek(End(0))`, which appends PAST a torn
+                    // tail — the ordinary outcome of a crash mid-append. The
+                    // new entry is then chained to the last good entry, but
+                    // sits on disk behind the garbage:
+                    //
+                    //     [1..N verified][torn bytes][N+1 chained to N]
+                    //
+                    // Replay stops at the torn bytes, so N+1 is unreachable
+                    // FOREVER even though its `append` returned Ok and synced.
+                    // That is silent data loss in the one situation a WAL
+                    // exists for. Truncating to the verified end is the
+                    // standard recovery: the torn tail was never acknowledged
+                    // to any caller, so discarding it loses nothing, and the
+                    // chain then continues from a byte offset that matches
+                    // `running_crc`.
+                    let verified_end = WAL_HEADER_LEN + verified_bytes;
+                    let file_len = f.metadata()?.len();
+                    if file_len > verified_end {
+                        eprintln!(
+                            "clawhdf5-agent: WAL {} has {} unverifiable byte(s) after entry {}; \
+                             discarding them so appends stay replayable",
+                            path.display(),
+                            file_len - verified_end,
+                            entries.len()
+                        );
+                        f.set_len(verified_end)?;
+                    }
+                    f.seek(SeekFrom::Start(verified_end))?;
                     Ok(Self {
                         path: path.to_path_buf(),
                         file: Some(f),
                         entry_count,
                         pending_header_sync: 0,
+                        running_crc,
+                        chain_len: verified_bytes,
                     })
                 }
-                WAL_VERSION_LEGACY_NO_CRC => {
+                WAL_VERSION_CRC_UNCHAINED | WAL_VERSION_LEGACY_NO_CRC => {
                     drop(f);
                     let f = create_fresh_wal_file(path)?;
                     Ok(Self {
@@ -123,6 +284,8 @@ impl WalFile {
                         file: Some(f),
                         entry_count: 0,
                         pending_header_sync: 0,
+                        running_crc: 0,
+                        chain_len: 0,
                     })
                 }
                 v => Err(MemoryError::Schema(format!("unsupported WAL version {v}"))),
@@ -134,6 +297,8 @@ impl WalFile {
                 file: Some(f),
                 entry_count: 0,
                 pending_header_sync: 0,
+                running_crc: 0,
+                chain_len: 0,
             })
         }
     }
@@ -157,8 +322,20 @@ impl WalFile {
             4 + entry.session_id.len() +
             4 + entry.tags.len(),
         );
-        buf.push(WalEntryType::Save as u8);
+        match entry.update_index {
-        buf.extend_from_slice(&entry.timestamp.to_le_bytes());
+            Some(index) => {
+                let index = u32::try_from(index).map_err(|_| {
+                    MemoryError::Schema(format!("WAL update index {index} exceeds u32"))
+                })?;
+                buf.push(WalEntryType::Update as u8);
+                buf.extend_from_slice(&entry.timestamp.to_le_bytes());
+                buf.extend_from_slice(&index.to_le_bytes());
+            }
+            None => {
+                buf.push(WalEntryType::Save as u8);
+                buf.extend_from_slice(&entry.timestamp.to_le_bytes());
+            }
+        }
         serialize_str(&mut buf, &entry.chunk);
         buf.extend_from_slice(&(emb_len as u32).to_le_bytes());
         for &val in &entry.embedding {
@@ -168,7 +345,10 @@ impl WalFile {
         serialize_str(&mut buf, &entry.session_id);
         serialize_str(&mut buf, &entry.tags);
 
-        let crc = crc32(&buf);
+        // Chain this entry's CRC to the previous one's so reordering/
+        // splicing entries (not just flipping a bit within one) is detected
+        // on replay — see WAL_VERSION's doc comment.
+        let crc = chained_crc(&buf, self.running_crc);
         buf.extend_from_slice(&crc.to_le_bytes());
 
         let f = self
@@ -176,7 +356,9 @@ impl WalFile {
             .as_mut()
             .ok_or_else(|| MemoryError::Io(std::io::Error::other("WAL file not open")))?;
         f.write_all(&buf)?;
+        self.chain_len += buf.len() as u64;
 
+        self.running_crc = crc;
         self.entry_count += 1;
         self.pending_header_sync += 1;
         if self.pending_header_sync >= GROUP_COMMIT_SIZE {
@@ -191,7 +373,7 @@ impl WalFile {
         buf[0] = WalEntryType::Tombstone as u8;
         buf[1..9].copy_from_slice(&timestamp.to_le_bytes());
         buf[9..13].copy_from_slice(&(index as u32).to_le_bytes());
-        let crc = crc32(&buf[..13]);
+        let crc = chained_crc(&buf[..13], self.running_crc);
         buf[13..17].copy_from_slice(&crc.to_le_bytes());
 
         let f = self
@@ -199,7 +381,9 @@ impl WalFile {
             .as_mut()
             .ok_or_else(|| MemoryError::Io(std::io::Error::other("WAL file not open")))?;
         f.write_all(&buf)?;
+        self.chain_len += buf.len() as u64;
 
+        self.running_crc = crc;
         self.entry_count += 1;
         self.pending_header_sync += 1;
         if self.pending_header_sync >= GROUP_COMMIT_SIZE {
@@ -214,9 +398,46 @@ impl WalFile {
     /// (and may be stale if written with deferred group-commit updates). This
     /// tolerates both truncated files (crash mid-write) and stale header counts
     /// (crash before the next group-commit header sync). On a `WAL_VERSION`
-    /// file, a CRC32 mismatch on an entry is treated the same way — replay
+    /// file, a broken CRC chain (bit-flip, or an entry reordered/duplicated/
-    /// stops there rather than accepting corrupted data.
+    /// spliced in) is treated the same way — replay stops there rather than
+    /// accepting corrupted or tampered data. `WAL_VERSION_CRC_UNCHAINED`
+    /// files are read the same way minus the chain check (each entry's own
+    /// CRC is still verified).
+    ///
+    /// Does **not** read [`WAL_VERSION_LEGACY_NO_CRC`] files — that format has
+    /// no integrity verification at all, so it's only reachable through
+    /// [`WalFile::read_entries_for_migration`], used exclusively by
+    /// `HDF5Memory::open`'s one-time migration path. Calling this on a
+    /// legacy-no-CRC file returns a typed error instead of silently
+    /// downgrading to the unverified parser.
     pub fn read_entries(path: &Path) -> Result<Vec<WalEntry>, MemoryError> {
+        Self::read_entries_impl(path, false, None)
+    }
+
+    /// Like [`WalFile::read_entries`], but also accepts
+    /// [`WAL_VERSION_LEGACY_NO_CRC`] files (no per-entry integrity check at
+    /// all). Restricted to `pub(crate)` and named accordingly: the only
+    /// legitimate caller is `HDF5Memory::open`'s one-time migration of a
+    /// pre-CRC WAL file, which immediately recreates it in the current
+    /// format afterward. Do not use this for anything else.
+    ///
+    /// `applied` is the checkpoint mark read from the `.h5` file, if any: if
+    /// the WAL's chain passes through it (same byte length, same chained
+    /// CRC), everything up to that point is already in the `.h5` and is
+    /// dropped. If it never does — the normal case, because the WAL was
+    /// truncated after the checkpoint — every entry is returned.
+    pub(crate) fn read_entries_for_migration(
+        path: &Path,
+        applied: Option<WalMark>,
+    ) -> Result<Vec<WalEntry>, MemoryError> {
+        Self::read_entries_impl(path, true, applied)
+    }
+
+    fn read_entries_impl(
+        path: &Path,
+        allow_legacy_no_crc: bool,
+        applied: Option<WalMark>,
+    ) -> Result<Vec<WalEntry>, MemoryError> {
         if !path.exists() {
             return Ok(Vec::new());
         }
@@ -229,46 +450,62 @@ impl WalFile {
         }
         // entry_count is a pre-allocation hint only — we read until EOF.
         let entry_count_hint = u32::from_le_bytes([header[5], header[6], header[7], header[8]]);
-        let mut entries = Vec::with_capacity(entry_count_hint as usize);
 
         match header[4] {
-            WAL_VERSION => loop {
+            WAL_VERSION | WAL_VERSION_CHAINED_NO_UPDATE => {
-                let raw_and_result = {
+                let (entries, _final_crc, _verified_bytes) =
-                    let mut tee = TeeReader::new(&mut f);
+                    read_chained_entries(&mut f, 0, applied);
-                    let result = read_one_entry(&mut tee);
+                Ok(entries)
-                    (tee.into_buf(), result)
-                };
-                let (raw, result) = raw_and_result;
-                let entry_opt = match result {
-                    Err(()) => break,
-                    Ok(v) => v,
-                };
-                let mut crc_buf = [0u8; 4];
-                if f.read_exact(&mut crc_buf).is_err() {
-                    break;
-                }
-                let stored_crc = u32::from_le_bytes(crc_buf);
-                if crc32(&raw) != stored_crc {
-                    // Corruption detected — stop replay here, same as a clean
-                    // truncation/EOF, rather than accepting the bad entry.
-                    break;
-                }
-                if let Some(entry) = entry_opt {
-                    entries.push(entry);
-                }
-            },
-            WAL_VERSION_LEGACY_NO_CRC => loop {
-                match read_one_entry(&mut f) {
-                    Err(()) => break,
-                    Ok(Some(entry)) => entries.push(entry),
-                    Ok(None) => {}
-                }
-            },
-            v => {
-                return Err(MemoryError::Schema(format!("unsupported WAL version {v}")));
             }
+            WAL_VERSION_CRC_UNCHAINED => {
+                let mut entries = Vec::with_capacity(entry_count_hint as usize);
+                loop {
+                    let raw_and_result = {
+                        let mut tee = TeeReader::new(&mut f);
+                        let result = read_one_entry(&mut tee);
+                        (tee.into_buf(), result)
+                    };
+                    let (raw, result) = raw_and_result;
+                    let entry_opt = match result {
+                        Err(()) => break,
+                        Ok(v) => v,
+                    };
+                    let mut crc_buf = [0u8; 4];
+                    if f.read_exact(&mut crc_buf).is_err() {
+                        break;
+                    }
+                    let stored_crc = u32::from_le_bytes(crc_buf);
+                    if crc32(&raw) != stored_crc {
+                        // Corruption detected — stop replay here, same as a
+                        // clean truncation/EOF, rather than accepting the bad
+                        // entry.
+                        break;
+                    }
+                    if let Some(entry) = entry_opt {
+                        entries.push(entry);
+                    }
+                }
+                Ok(entries)
+            }
+            WAL_VERSION_LEGACY_NO_CRC if allow_legacy_no_crc => {
+                let mut entries = Vec::with_capacity(entry_count_hint as usize);
+                loop {
+                    match read_one_entry(&mut f) {
+                        Err(()) => break,
+                        Ok(Some(entry)) => entries.push(entry),
+                        Ok(None) => {}
+                    }
+                }
+                Ok(entries)
+            }
+            WAL_VERSION_LEGACY_NO_CRC => Err(MemoryError::Schema(
+                "WAL file is in the legacy no-CRC format (version 1), which read_entries() no \
+                 longer accepts — it has no per-entry integrity verification. Only the one-time \
+                 migration path (WalFile::open) can read and upgrade it."
+                    .into(),
+            )),
+            v => Err(MemoryError::Schema(format!("unsupported WAL version {v}"))),
         }
-        Ok(entries)
     }
 
     /// Truncate the WAL (after merge into .h5).
@@ -279,9 +516,20 @@ impl WalFile {
         self.file = Some(f);
         self.entry_count = 0;
         self.pending_header_sync = 0;
+        self.running_crc = 0;
+        self.chain_len = 0;
         Ok(())
     }
 
+    /// The mark covering every entry currently in this WAL. Store it with a
+    /// checkpoint taken from the state those entries produced.
+    pub fn mark(&self) -> WalMark {
+        WalMark {
+            len: self.chain_len,
+            crc: self.running_crc,
+        }
+    }
+
     /// Number of pending entries.
     pub fn pending_count(&self) -> u32 {
         self.entry_count
@@ -321,6 +569,28 @@ pub fn replay_into_cache(entries: &[WalEntry], cache: &mut crate::cache::MemoryC
                     entry.tags.clone(),
                 );
             }
+            WalEntryType::Update => match entry.update_index {
+                // The index was valid when the record was written; if the
+                // store no longer has it, keep the data rather than drop it.
+                Some(idx) if idx < cache.len() => cache.update(
+                    idx,
+                    entry.chunk.clone(),
+                    entry.embedding.clone(),
+                    entry.source_channel.clone(),
+                    entry.timestamp,
+                    entry.session_id.clone(),
+                ),
+                _ => {
+                    cache.push(
+                        entry.chunk.clone(),
+                        entry.embedding.clone(),
+                        entry.source_channel.clone(),
+                        entry.timestamp,
+                        entry.session_id.clone(),
+                        entry.tags.clone(),
+                    );
+                }
+            },
             WalEntryType::Tombstone => {
                 if let Some(idx) = entry.tombstone_index {
                     cache.mark_deleted(idx);
@@ -373,6 +643,81 @@ fn read_embedding<R: Read>(f: &mut R) -> Result<Vec<f32>, MemoryError> {
     Ok(vals)
 }
 
+/// Compute the CRC32 trailer for a `WAL_VERSION` entry, chaining in the
+/// previous entry's stored CRC (0 for the first entry after a truncation).
+fn chained_crc(entry_bytes: &[u8], prev_crc: u32) -> u32 {
+    let mut chained = Vec::with_capacity(entry_bytes.len() + 4);
+    chained.extend_from_slice(entry_bytes);
+    chained.extend_from_slice(&prev_crc.to_le_bytes());
+    crc32(&chained)
+}
+
+/// Read and verify all entries from a `WAL_VERSION` (chained-CRC) stream
+/// starting at the reader's current position, given the chain state to
+/// resume from (0 for a stream starting at the beginning of a fresh WAL).
+///
+/// Returns the parsed entries, the final running CRC — the chain state to
+/// continue from for further appends — and the number of BYTES consumed by
+/// those verified entries. Stops (without erroring) at the first entry that
+/// fails to parse or whose stored CRC doesn't match the expected chain value
+/// — a bit-flip, truncation/EOF, or an entry having been
+/// reordered/duplicated/spliced all produce a chain mismatch at that point,
+/// and are all handled the same way: replay stops there.
+///
+/// The byte count is what lets `open()` position an append at the end of the
+/// VERIFIED prefix rather than at end-of-file. Appending past a torn tail
+/// writes entries that replay can never reach — see `open`.
+///
+/// `applied`, when given, is a checkpoint mark: once the chain reaches exactly
+/// that position, the entries collected so far are discarded (they are
+/// already in the `.h5` file). A zero-length mark matches nothing.
+fn read_chained_entries<R: Read>(
+    f: &mut R,
+    start_crc: u32,
+    applied: Option<WalMark>,
+) -> (Vec<WalEntry>, u32, u64) {
+    let applied = applied.filter(|m| m.len > 0);
+    let mut entries = Vec::new();
+    let mut running_crc = start_crc;
+    let mut verified_bytes: u64 = 0;
+    loop {
+        let raw_and_result = {
+            let mut tee = TeeReader::new(f);
+            let result = read_one_entry(&mut tee);
+            (tee.into_buf(), result)
+        };
+        let (raw, result) = raw_and_result;
+        let entry_opt = match result {
+            Err(()) => break,
+            Ok(v) => v,
+        };
+        let mut crc_buf = [0u8; 4];
+        if f.read_exact(&mut crc_buf).is_err() {
+            break;
+        }
+        let stored_crc = u32::from_le_bytes(crc_buf);
+        if chained_crc(&raw, running_crc) != stored_crc {
+            break;
+        }
+        running_crc = stored_crc;
+        // Only counted once the entry AND its CRC trailer verified, so the
+        // offset always points just past a complete, checked entry.
+        verified_bytes += raw.len() as u64 + crc_buf.len() as u64;
+        if let Some(entry) = entry_opt {
+            entries.push(entry);
+        }
+        if applied
+            == Some(WalMark {
+                len: verified_bytes,
+                crc: running_crc,
+            })
+        {
+            entries.clear();
+        }
+    }
+    (entries, running_crc, verified_bytes)
+}
+
 /// Create a fresh WAL file at `path` with the current-version header,
 /// truncating/overwriting anything already there.
 fn create_fresh_wal_file(path: &Path) -> Result<File, MemoryError> {
@@ -430,7 +775,14 @@ fn read_one_entry<R: Read>(r: &mut R) -> Result<Option<WalEntry>, ()> {
     let timestamp = f64::from_le_bytes(ts_buf);
 
     match entry_type {
-        WalEntryType::Save => {
+        WalEntryType::Save | WalEntryType::Update => {
+            let update_index = if entry_type == WalEntryType::Update {
+                let mut idx_buf = [0u8; 4];
+                r.read_exact(&mut idx_buf).map_err(|_| ())?;
+                Some(u32::from_le_bytes(idx_buf) as usize)
+            } else {
+                None
+            };
             let chunk = read_len_prefixed_str(r).map_err(|_| ())?;
             let embedding = read_embedding(r).map_err(|_| ())?;
             let source_channel = read_len_prefixed_str(r).map_err(|_| ())?;
@@ -445,6 +797,7 @@ fn read_one_entry<R: Read>(r: &mut R) -> Result<Option<WalEntry>, ()> {
                 session_id,
                 tags,
                 tombstone_index: None,
+                update_index,
             }))
         }
         WalEntryType::Tombstone => {
@@ -460,6 +813,7 @@ fn read_one_entry<R: Read>(r: &mut R) -> Result<Option<WalEntry>, ()> {
                 session_id: String::new(),
                 tags: String::new(),
                 tombstone_index: Some(idx),
+                update_index: None,
             }))
         }
         WalEntryType::ActivationUpdate => Ok(None),
@@ -483,6 +837,7 @@ mod tests {
             session_id: "sess-001".to_string(),
             tags: "tag1,tag2".to_string(),
             tombstone_index: None,
+            update_index: None,
         }
     }
 
@@ -601,7 +956,7 @@ mod tests {
         let dir = TempDir::new().unwrap();
         let wal_path = dir.path().join("test.h5.wal");
         let unicode_chunk = "Hello 世界! 🌍 émojis & ünïcödé";
-        let embedding = vec![0.1, -0.2, 3.14159, f32::MAX, f32::MIN_POSITIVE];
+        let embedding = vec![0.1, -0.2, 3.4567, f32::MAX, f32::MIN_POSITIVE];
         {
             let mut wal = WalFile::open(&wal_path).unwrap();
             let entry = WalEntry {
@@ -613,6 +968,7 @@ mod tests {
                 session_id: "sess-öö-123".to_string(),
                 tags: "α,β,γ".to_string(),
                 tombstone_index: None,
+                update_index: None,
             };
             wal.append_save(&entry).unwrap();
         }
@@ -747,6 +1103,148 @@ mod tests {
         assert!(entries.is_empty());
     }
 
+    /// Reopen `path` and return the stored chunks in order.
+    fn reopen_chunks(path: &std::path::Path) -> Vec<String> {
+        let mem = HDF5Memory::open(path).unwrap();
+        mem.cache.chunks.clone()
+    }
+
+    #[test]
+    fn crash_between_checkpoint_and_wal_truncate_does_not_duplicate() {
+        // flush() writes the new .h5 and only then truncates the WAL. Dying in
+        // between leaves BOTH a .h5 that contains the pending entries and a
+        // WAL that still lists them; replaying blindly used to double them.
+        let dir = TempDir::new().unwrap();
+        let config = make_config(&dir);
+        let h5_path = config.path.clone();
+        let wal_path = h5_path.with_extension("h5.wal");
+        let stale_wal = dir.path().join("stale.wal");
+
+        {
+            let mut mem = HDF5Memory::create(config).unwrap();
+            for name in ["a", "b", "c"] {
+                mem.save(make_entry(name, &[1.0, 0.0, 0.0, 0.0])).unwrap();
+            }
+            assert_eq!(mem.wal_pending_count(), 3);
+            std::fs::copy(&wal_path, &stale_wal).unwrap();
+            mem.flush_wal().unwrap();
+        }
+        // Undo the truncate: this is the on-disk state right after the crash.
+        std::fs::copy(&stale_wal, &wal_path).unwrap();
+        assert_eq!(WalFile::read_entries(&wal_path).unwrap().len(), 3);
+
+        assert_eq!(reopen_chunks(&h5_path), ["a", "b", "c"]);
+
+        // Entries appended to that same WAL after recovery are still replayed.
+        {
+            let mut mem = HDF5Memory::open(&h5_path).unwrap();
+            mem.save(make_entry("d", &[0.0, 1.0, 0.0, 0.0])).unwrap();
+        }
+        assert_eq!(reopen_chunks(&h5_path), ["a", "b", "c", "d"]);
+    }
+
+    #[test]
+    fn entries_written_after_a_completed_checkpoint_are_all_replayed() {
+        // Normal case: the checkpoint's mark refers to a WAL that has since
+        // been truncated, so it must not suppress anything in the new one —
+        // including when the new WAL grows past the old mark's length.
+        let dir = TempDir::new().unwrap();
+        let config = make_config(&dir);
+        let h5_path = config.path.clone();
+        {
+            let mut mem = HDF5Memory::create(config).unwrap();
+            mem.save(make_entry("a", &[1.0, 0.0, 0.0, 0.0])).unwrap();
+            mem.flush_wal().unwrap();
+            for name in ["b", "c", "d"] {
+                mem.save(make_entry(name, &[1.0, 0.0, 0.0, 0.0])).unwrap();
+            }
+        }
+        assert_eq!(reopen_chunks(&h5_path), ["a", "b", "c", "d"]);
+    }
+
+    #[test]
+    fn save_or_update_replays_as_update_not_duplicate() {
+        let dir = TempDir::new().unwrap();
+        let config = make_config(&dir);
+        let h5_path = config.path.clone();
+        {
+            let mut mem = HDF5Memory::create(config).unwrap();
+            let mut first = make_entry("v1", &[1.0, 0.0, 0.0, 0.0]);
+            first.tags = "key".into();
+            let mut second = make_entry("v2", &[0.0, 1.0, 0.0, 0.0]);
+            second.tags = "key".into();
+            let a = mem.save_or_update(first).unwrap();
+            mem.save(make_entry("other", &[0.0, 0.0, 1.0, 0.0]))
+                .unwrap();
+            let b = mem.save_or_update(second).unwrap();
+            assert_eq!(a, b);
+            assert_eq!(mem.cache.chunks, ["v2", "other"]);
+            // Dropped without a checkpoint: all three records live in the WAL.
+        }
+        let mem = HDF5Memory::open(&h5_path).unwrap();
+        assert_eq!(mem.cache.chunks, ["v2", "other"]);
+        assert_eq!(mem.cache.embeddings[0], [0.0, 1.0, 0.0, 0.0]);
+    }
+
+    #[test]
+    fn v3_wal_is_read_and_upgraded_in_place() {
+        let dir = TempDir::new().unwrap();
+        let wal_path = dir.path().join("old.wal");
+        {
+            let mut wal = WalFile::open(&wal_path).unwrap();
+            wal.append_save(&make_wal_entry("kept", &[1.0])).unwrap();
+        }
+        // Rewrite the header as the pre-Update chained format.
+        let mut bytes = std::fs::read(&wal_path).unwrap();
+        bytes[4] = WAL_VERSION_CHAINED_NO_UPDATE;
+        std::fs::write(&wal_path, &bytes).unwrap();
+
+        assert_eq!(WalFile::read_entries(&wal_path).unwrap().len(), 1);
+        {
+            let mut wal = WalFile::open(&wal_path).unwrap();
+            assert_eq!(wal.pending_count(), 1);
+            wal.append_save(&make_wal_entry("new", &[2.0])).unwrap();
+        }
+        assert_eq!(std::fs::read(&wal_path).unwrap()[4], WAL_VERSION);
+        let chunks: Vec<_> = WalFile::read_entries(&wal_path)
+            .unwrap()
+            .into_iter()
+            .map(|e| e.chunk)
+            .collect();
+        assert_eq!(chunks, ["kept", "new"]);
+    }
+
+    #[test]
+    fn mark_matching_is_exact() {
+        let dir = TempDir::new().unwrap();
+        let wal_path = dir.path().join("m.wal");
+        let mut wal = WalFile::open(&wal_path).unwrap();
+        wal.append_save(&make_wal_entry("one", &[1.0])).unwrap();
+        let after_one = wal.mark();
+        wal.append_save(&make_wal_entry("two", &[2.0])).unwrap();
+        let after_two = wal.mark();
+        drop(wal);
+
+        let read = |m| {
+            WalFile::read_entries_for_migration(&wal_path, m)
+                .unwrap()
+                .into_iter()
+                .map(|e| e.chunk)
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(read(None), ["one", "two"]);
+        assert_eq!(read(Some(after_one)), ["two"]);
+        assert!(read(Some(after_two)).is_empty());
+        // Right length, wrong CRC (a different WAL generation): skip nothing.
+        let foreign = WalMark {
+            crc: after_one.crc ^ 1,
+            ..after_one
+        };
+        assert_eq!(read(Some(foreign)), ["one", "two"]);
+        // Reopening resumes the same mark.
+        assert_eq!(WalFile::open(&wal_path).unwrap().mark(), after_two);
+    }
+
     #[test]
     fn test_wal_replay_on_open() {
         // Test WAL replay using read_entries + replay_into_cache directly,
@@ -912,16 +1410,157 @@ mod tests {
         assert_eq!(entries[0].chunk, "first");
     }
 
+    /// A crash mid-append leaves a torn final entry. Reopening the WAL must
+    /// place the next append at the end of the VERIFIED prefix, not at
+    /// end-of-file, or that append is written behind garbage the replay
+    /// scanner stops at — unreachable forever despite having returned Ok.
+    ///
+    /// This is the ordinary crash case, so getting it wrong loses
+    /// acknowledged writes in exactly the situation a WAL exists for.
     #[test]
-    fn test_wal_reads_legacy_v1_format_without_crc() {
+    fn test_wal_append_after_torn_tail_stays_replayable() {
         let dir = TempDir::new().unwrap();
-        let wal_path = dir.path().join("legacy.h5.wal");
+        let wal_path = dir.path().join("test.h5.wal");
+
+        let mut wal = WalFile::open(&wal_path).unwrap();
+        wal.append_save(&make_wal_entry("first", &[1.0, 2.0]))
+            .unwrap();
+        drop(wal);
+
+        // Simulate the crash: a partial entry appended after the good one.
+        {
+            use std::io::Write;
+            let mut f = std::fs::OpenOptions::new()
+                .append(true)
+                .open(&wal_path)
+                .unwrap();
+            f.write_all(&[0xAB, 0xCD, 0xEF, 0x01, 0x02]).unwrap();
+            f.flush().unwrap();
+        }
+
+        // Reopen and append. The torn bytes must not survive between the
+        // verified prefix and the new entry.
+        let mut wal = WalFile::open(&wal_path).unwrap();
+        wal.append_save(&make_wal_entry("second", &[3.0, 4.0]))
+            .unwrap();
+        drop(wal);
+
+        let entries = WalFile::read_entries(&wal_path).unwrap();
+        assert_eq!(
+            entries.len(),
+            2,
+            "the append after a torn tail must be replayable; got {} entr(y/ies) — \
+             the post-crash write was silently lost",
+            entries.len()
+        );
+    }
+
+    /// Reordering two entries on disk must break the CRC chain — the
+    /// second entry's stored CRC was computed against the first entry's
+    /// real CRC, not against the chain state a reader sees after swapping
+    /// them, so replay stops immediately instead of accepting the tampered
+    /// order (INT-09).
+    #[test]
+    fn test_wal_detects_reordered_entries() {
+        let dir = TempDir::new().unwrap();
+        let wal_path = dir.path().join("test.h5.wal");
+        let mut wal = WalFile::open(&wal_path).unwrap();
+        wal.append_save(&make_wal_entry("first", &[1.0, 2.0]))
+            .unwrap();
+        let len_after_first = std::fs::metadata(&wal_path).unwrap().len() as usize;
+        wal.append_save(&make_wal_entry("second", &[3.0, 4.0]))
+            .unwrap();
+        let len_after_second = std::fs::metadata(&wal_path).unwrap().len() as usize;
+        drop(wal);
+
+        let bytes = std::fs::read(&wal_path).unwrap();
+        let header_len = 9usize;
+        let entry1_bytes = bytes[header_len..len_after_first].to_vec();
+        let entry2_bytes = bytes[len_after_first..len_after_second].to_vec();
+
+        let mut spliced = bytes[..header_len].to_vec();
+        spliced.extend_from_slice(&entry2_bytes);
+        spliced.extend_from_slice(&entry1_bytes);
+        std::fs::write(&wal_path, &spliced).unwrap();
+
+        let entries = WalFile::read_entries(&wal_path).unwrap();
+        assert!(
+            entries.is_empty(),
+            "reordered entries must break the CRC chain and stop replay, got {} entries",
+            entries.len()
+        );
+    }
+
+    /// Splicing a third-party entry in between two legitimate entries (e.g.
+    /// moving a Tombstone in front of the Save it's meant to follow) must
+    /// also break the chain for everything after the splice point.
+    #[test]
+    fn test_wal_detects_spliced_entry() {
+        let dir = TempDir::new().unwrap();
+        let wal_path = dir.path().join("test.h5.wal");
+        let mut wal = WalFile::open(&wal_path).unwrap();
+        wal.append_save(&make_wal_entry("first", &[1.0])).unwrap();
+        let len_after_first = std::fs::metadata(&wal_path).unwrap().len() as usize;
+        wal.append_save(&make_wal_entry("second", &[2.0])).unwrap();
+        let len_after_second = std::fs::metadata(&wal_path).unwrap().len() as usize;
+        wal.append_save(&make_wal_entry("third", &[3.0])).unwrap();
+        drop(wal);
+
+        let bytes = std::fs::read(&wal_path).unwrap();
+        let entry2_bytes = bytes[len_after_first..len_after_second].to_vec();
+
+        // Duplicate "second" right after itself: [first][second][second][third]
+        let mut spliced = bytes[..len_after_second].to_vec();
+        spliced.extend_from_slice(&entry2_bytes);
+        spliced.extend_from_slice(&bytes[len_after_second..]);
+        std::fs::write(&wal_path, &spliced).unwrap();
+
+        let entries = WalFile::read_entries(&wal_path).unwrap();
+        assert_eq!(
+            entries.len(),
+            2,
+            "replay must stop at the spliced duplicate, keeping only the entries before it"
+        );
+        assert_eq!(entries[0].chunk, "first");
+        assert_eq!(entries[1].chunk, "second");
+    }
+
+    /// A WAL closed (without truncating) and reopened must continue the CRC
+    /// chain correctly for newly appended entries — this is the normal
+    /// crash-restart-without-flush scenario (`HDF5Memory::open` replays
+    /// existing entries, then reopens the same file for further appends
+    /// without clearing it), and must not produce a false "reordering"
+    /// detection for its own legitimately-appended entries.
+    #[test]
+    fn test_wal_chain_continues_across_reopen() {
+        let dir = TempDir::new().unwrap();
+        let wal_path = dir.path().join("test.h5.wal");
+
+        let mut wal = WalFile::open(&wal_path).unwrap();
+        wal.append_save(&make_wal_entry("first", &[1.0])).unwrap();
+        drop(wal); // simulate a restart without ever truncating the WAL
+
+        let mut wal2 = WalFile::open(&wal_path).unwrap();
+        wal2.append_save(&make_wal_entry("second", &[2.0])).unwrap();
+        drop(wal2);
+
+        let entries = WalFile::read_entries(&wal_path).unwrap();
+        assert_eq!(
+            entries.len(),
+            2,
+            "both pre- and post-reopen entries must replay cleanly"
+        );
+        assert_eq!(entries[0].chunk, "first");
+        assert_eq!(entries[1].chunk, "second");
+    }
+
+    /// Build a legacy (WAL_VERSION_LEGACY_NO_CRC) WAL file containing one
+    /// Save entry, with no trailing CRC32.
+    fn build_legacy_v1_wal_bytes() -> Vec<u8> {
         let mut buf = Vec::new();
         buf.extend_from_slice(&WAL_MAGIC);
         buf.push(WAL_VERSION_LEGACY_NO_CRC);
         buf.extend_from_slice(&1u32.to_le_bytes());
-        // One Save entry in the old format: type + timestamp + fields, with
-        // no trailing CRC32.
         buf.push(WalEntryType::Save as u8);
         buf.extend_from_slice(&42.0f64.to_le_bytes());
         serialize_str(&mut buf, "legacy-chunk");
@@ -933,14 +1572,39 @@ mod tests {
         serialize_str(&mut buf, "chan");
         serialize_str(&mut buf, "sess");
         serialize_str(&mut buf, "tags");
-        std::fs::write(&wal_path, &buf).unwrap();
+        buf
+    }
 
-        let entries = WalFile::read_entries(&wal_path).unwrap();
+    #[test]
+    fn test_wal_reads_legacy_v1_format_without_crc() {
+        let dir = TempDir::new().unwrap();
+        let wal_path = dir.path().join("legacy.h5.wal");
+        std::fs::write(&wal_path, build_legacy_v1_wal_bytes()).unwrap();
+
+        // Only the migration-only reader may read a legacy no-CRC file.
+        let entries = WalFile::read_entries_for_migration(&wal_path, None).unwrap();
         assert_eq!(entries.len(), 1);
         assert_eq!(entries[0].chunk, "legacy-chunk");
         assert_eq!(entries[0].embedding, vec![1.0, 2.0]);
     }
 
+    /// The public `read_entries` must reject a legacy no-CRC file instead of
+    /// silently downgrading to the fully-unverified parser (INT-09) — flipping
+    /// a version byte from 2/3 down to 1 must not be a way to bypass every
+    /// integrity check for an arbitrary caller of the public API.
+    #[test]
+    fn test_wal_read_entries_rejects_legacy_v1_format() {
+        let dir = TempDir::new().unwrap();
+        let wal_path = dir.path().join("legacy.h5.wal");
+        std::fs::write(&wal_path, build_legacy_v1_wal_bytes()).unwrap();
+
+        let result = WalFile::read_entries(&wal_path);
+        assert!(
+            result.is_err(),
+            "read_entries() must reject a legacy no-CRC WAL file, not silently parse it"
+        );
+    }
+
     #[test]
     fn test_wal_open_migrates_legacy_v1_to_current_version() {
         let dir = TempDir::new().unwrap();

crates/clawhdf5-agent/tests/crash_recovery.rs

@@ -0,0 +1,187 @@
+//! Crash-recovery matrix for `HDF5Memory`.
+//!
+//! A process crash leaves whatever reached the OS on disk. These tests build
+//! the on-disk images such a crash can leave behind — after every operation,
+//! inside the checkpoint window (new `.h5` in place, WAL not yet truncated),
+//! and with the WAL torn at every possible length — then reopen each image
+//! and check the recovered store against a model of what was acknowledged.
+//!
+//! Invariants:
+//! * never a duplicated or invented record;
+//! * an image taken between operations recovers *exactly* the acknowledged
+//!   state;
+//! * a torn WAL recovers the last checkpoint plus a prefix of the operations
+//!   logged since.
+
+use std::path::{Path, PathBuf};
+
+use clawhdf5_agent::{AgentMemory, HDF5Memory, MemoryConfig, MemoryEntry};
+use tempfile::TempDir;
+
+struct Rng(u64);
+
+impl Rng {
+    fn next(&mut self) -> u64 {
+        self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
+        let mut z = self.0;
+        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+        z ^ (z >> 31)
+    }
+    fn below(&mut self, n: usize) -> usize {
+        (self.next() % n.max(1) as u64) as usize
+    }
+}
+
+fn entry(chunk: &str, tags: &str) -> MemoryEntry {
+    MemoryEntry {
+        chunk: chunk.to_string(),
+        embedding: vec![1.0, 0.0, 0.0, 0.0],
+        source_channel: "test".into(),
+        timestamp: 1.0,
+        session_id: "s".into(),
+        tags: tags.to_string(),
+    }
+}
+
+fn wal_path(h5: &Path) -> PathBuf {
+    h5.with_extension("h5.wal")
+}
+
+/// Copy the store (`.h5` + WAL) into a fresh directory, as a crash image.
+fn image(h5: &Path, into: &TempDir, name: &str) -> PathBuf {
+    let dest = into.path().join(format!("{name}.h5"));
+    std::fs::copy(h5, &dest).unwrap();
+    if wal_path(h5).exists() {
+        std::fs::copy(wal_path(h5), wal_path(&dest)).unwrap();
+    }
+    dest
+}
+
+fn recovered(h5: &Path) -> Vec<String> {
+    // Read-only: the image must not be modified, and no lock is needed.
+    HDF5Memory::open_read_only(h5).unwrap().cache.chunks.clone()
+}
+
+/// Apply one random operation to the store and to the model.
+fn step(mem: &mut HDF5Memory, model: &mut Vec<String>, rng: &mut Rng, n: usize) {
+    match rng.below(6) {
+        0 => mem.flush_wal().unwrap(),
+        1 if !model.is_empty() => {
+            // Update an existing record in place, addressed by its tag.
+            let idx = rng.below(model.len());
+            let chunk = format!("u{n}");
+            assert_eq!(
+                mem.save_or_update(entry(&chunk, &format!("tag{idx}")))
+                    .unwrap(),
+                idx
+            );
+            model[idx] = chunk;
+        }
+        _ => {
+            let chunk = format!("c{n}");
+            mem.save(entry(&chunk, &format!("tag{}", model.len())))
+                .unwrap();
+            model.push(chunk);
+        }
+    }
+}
+
+#[test]
+fn image_after_every_operation_recovers_the_acknowledged_state() {
+    for seed in 0..40u64 {
+        let mut rng = Rng(seed);
+        let dir = TempDir::new().unwrap();
+        let images = TempDir::new().unwrap();
+        let mut config = MemoryConfig::new(dir.path().join("store.h5"), "agent", 4);
+        config.wal_enabled = true;
+        config.wal_max_entries = 1 + rng.below(6); // force frequent checkpoints
+        let h5 = config.path.clone();
+        let mut mem = HDF5Memory::create(config).unwrap();
+        let mut model = Vec::new();
+
+        for n in 0..30 {
+            step(&mut mem, &mut model, &mut rng, n);
+            let img = image(&h5, &images, &format!("s{seed}-{n}"));
+            assert_eq!(recovered(&img), model, "seed {seed}, after op {n}");
+        }
+    }
+}
+
+#[test]
+fn crash_inside_the_checkpoint_window_never_duplicates() {
+    for seed in 0..40u64 {
+        let mut rng = Rng(seed ^ 0xABCD);
+        let dir = TempDir::new().unwrap();
+        let images = TempDir::new().unwrap();
+        let mut config = MemoryConfig::new(dir.path().join("store.h5"), "agent", 4);
+        config.wal_enabled = true;
+        config.wal_max_entries = 1000; // checkpoints only when we ask
+        let h5 = config.path.clone();
+        let mut mem = HDF5Memory::create(config).unwrap();
+        let mut model = Vec::new();
+
+        for round in 0..4 {
+            for n in 0..(1 + rng.below(6)) {
+                step(&mut mem, &mut model, &mut rng, round * 100 + n);
+            }
+            // The WAL as it is just before the checkpoint...
+            let stale_wal = images.path().join(format!("stale-{seed}-{round}.wal"));
+            if wal_path(&h5).exists() {
+                std::fs::copy(wal_path(&h5), &stale_wal).unwrap();
+            }
+            mem.flush_wal().unwrap();
+            // ...put back next to the NEW .h5: the crash-in-the-window image.
+            let img = image(&h5, &images, &format!("w{seed}-{round}"));
+            if stale_wal.exists() {
+                std::fs::copy(&stale_wal, wal_path(&img)).unwrap();
+            }
+            assert_eq!(recovered(&img), model, "seed {seed}, round {round}");
+        }
+    }
+}
+
+#[test]
+fn torn_wal_recovers_checkpoint_plus_a_prefix() {
+    let dir = TempDir::new().unwrap();
+    let images = TempDir::new().unwrap();
+    let mut config = MemoryConfig::new(dir.path().join("store.h5"), "agent", 4);
+    config.wal_enabled = true;
+    config.wal_max_entries = 1000;
+    let h5 = config.path.clone();
+    let mut mem = HDF5Memory::create(config).unwrap();
+
+    for name in ["a", "b"] {
+        mem.save(entry(name, name)).unwrap();
+    }
+    mem.flush_wal().unwrap();
+    let checkpointed = vec!["a".to_string(), "b".to_string()];
+
+    // States the store passes through as each later op is logged.
+    let mut states = vec![checkpointed.clone()];
+    let mut model = checkpointed.clone();
+    mem.save(entry("c", "c")).unwrap();
+    model.push("c".into());
+    states.push(model.clone());
+    mem.save_or_update(entry("a2", "a")).unwrap();
+    model[0] = "a2".into();
+    states.push(model.clone());
+    mem.save(entry("d", "d")).unwrap();
+    model.push("d".into());
+    states.push(model.clone());
+
+    let full_wal = std::fs::read(wal_path(&h5)).unwrap();
+    let mut seen = std::collections::BTreeSet::new();
+    for len in 0..=full_wal.len() {
+        let img = image(&h5, &images, &format!("t{len}"));
+        std::fs::write(wal_path(&img), &full_wal[..len]).unwrap();
+        let got = recovered(&img);
+        let which = states
+            .iter()
+            .position(|s| *s == got)
+            .unwrap_or_else(|| panic!("WAL torn at {len} bytes recovered {got:?}"));
+        seen.insert(which);
+    }
+    // Every intermediate state is reachable, and the full WAL gives the last.
+    assert_eq!(seen.into_iter().collect::<Vec<_>>(), [0, 1, 2, 3]);
+}

crates/clawhdf5-agent/tests/e2e_tests.rs

@@ -196,7 +196,7 @@ fn test_migration_round_trip() {
     mem.add_relation(e1, e2, "discusses", 0.8).unwrap();
 
     // Verify all data transferred by reopening
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.count(), 500);
 
     // Verify sessions
@@ -266,7 +266,7 @@ fn test_knowledge_graph_workflow() {
     assert_eq!(entity.entity_type, "library");
 
     // Persistence
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.knowledge().entities.len(), 4);
     assert_eq!(reopened.knowledge().relations.len(), 4);
 
@@ -316,7 +316,7 @@ fn test_multi_session_workflow() {
     assert_eq!(mem.count(), 100); // 5 sessions * 20 entries
 
     // Reopen and verify sessions
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     for sess in 0..5 {
         let summary = reopened
             .get_session_summary(&format!("sess_{sess}"))
@@ -460,7 +460,7 @@ fn test_snapshot_and_continue() {
     assert_eq!(snap_mem.count(), 50);
 
     // Original should have 100
-    let orig_mem = HDF5Memory::open(&path).unwrap();
+    let orig_mem = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(orig_mem.count(), 100);
 }
 
@@ -483,7 +483,7 @@ fn test_config_persistence_across_ops() {
     mem.add_session("s1", 0, 0, "ch", "summary").unwrap();
     mem.add_entity("Entity", "type", -1).unwrap();
 
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.config().embedding_dim, 128);
     assert_eq!(reopened.config().embedder, "custom:my-embedder-v2");
     assert_eq!(reopened.config().chunk_size, 2048);
@@ -695,7 +695,7 @@ fn test_large_text_chunks() {
     mem.save_batch(entries).unwrap();
 
     // Reopen and verify
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.count(), 10);
 
     let (_, cache, _, _) = read_cache(&path);
@@ -752,7 +752,7 @@ fn test_interleaved_sessions_entries() {
     mem.flush_wal().unwrap();
 
     // Verify
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.count(), 6);
     assert_eq!(
         reopened.get_session_summary("s1").unwrap().as_deref(),
@@ -806,7 +806,7 @@ fn test_knowledge_graph_with_embeddings() {
     mem.add_relation(e_python, e_hdf5, "reads", 0.9).unwrap();
 
     // Verify entity-embedding linkage persists
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     let rust_entity = reopened.knowledge().get_entity(e_rust).unwrap();
     assert_eq!(rust_entity.embedding_idx, idx0 as i64);
 
@@ -1048,7 +1048,7 @@ fn test_gpu_l2_fallback_works() {
     let tombstones = vec![0u8; 3];
 
     let gpu = clawhdf5_agent::gpu_search::GpuSearchBackend::try_init(&vectors, &norms, 2, 1);
-    let results = gpu.search_l2(&vec![0.0, 0.0], &vectors, &tombstones, 3);
+    let results = gpu.search_l2(&[0.0, 0.0], &vectors, &tombstones, 3);
 
     assert_eq!(results.len(), 3);
     assert_eq!(results[0].0, 0);
@@ -1099,7 +1099,7 @@ fn test_mmap_reader_direct_access() {
 
     // Open via MmapReader directly
     let mmap = clawhdf5_io::MmapReader::open(&path).unwrap();
-    assert!(mmap.len() > 0);
+    assert!(!mmap.is_empty());
     // Verify we can read bytes at specific offsets
     let bytes = mmap.read_at(0, 8);
     assert!(bytes.is_some());
@@ -1144,9 +1144,11 @@ fn test_strategy_reports_backend() {
     let tombstones = vec![0u8; n];
     let query = vectors[0].clone();
 
+    let flat: Vec<f32> = vectors.iter().flatten().copied().collect();
     let (_, metrics) = strategy::search_with_metrics(
         &query,
         &vectors,
+        &flat,
         &norms,
         &tombstones,
         5,

crates/clawhdf5-agent/tests/memx_comparison.rs

@@ -137,10 +137,10 @@ fn bench_hit_at_1_1014_records() {
             0.3,
             1,
         );
-        if let Some((top_idx, _)) = results.first() {
+        if let Some((top_idx, _)) = results.first()
-            if *top_idx == target_indices[qi] {
+            && *top_idx == target_indices[qi]
-                hits += 1;
+        {
-            }
+            hits += 1;
         }
     }
 

crates/clawhdf5-agent/tests/stress_tests.rs

@@ -105,7 +105,7 @@ fn test_heavy_tombstoning() {
     assert_eq!(mem.count_active(), 5000);
 
     // Verify persistence
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.count(), 5000);
 }
 
@@ -163,7 +163,7 @@ fn test_large_embeddings_1536() {
     assert_eq!(mem.count(), 10_000);
 
     // Verify persistence
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.count(), 10_000);
 
     // Verify search works on large dims
@@ -545,7 +545,7 @@ fn test_delete_all_entries() {
     assert_eq!(mem.count(), 0);
 
     // Verify persistence
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.count(), 0);
 }
 
@@ -639,7 +639,7 @@ fn test_unicode_content() {
     ];
     mem.save_batch(entries).unwrap();
 
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.count(), 3);
 
     let (_, cache, _, _) = clawhdf5_agent::storage::read_from_disk(&path).unwrap();
@@ -685,6 +685,6 @@ fn test_rapid_save_delete_cycles() {
     assert_eq!(removed, 250);
     assert_eq!(mem.count(), 250);
 
-    let reopened = HDF5Memory::open(&path).unwrap();
+    let reopened = HDF5Memory::open_read_only(&path).unwrap();
     assert_eq!(reopened.count(), 250);
 }

crates/clawhdf5-agent/tests/wal_properties.rs

@@ -0,0 +1,213 @@
+//! Property tests for the write-ahead log.
+//!
+//! A deterministic generator (no external crates, reproducible from the seed
+//! printed on failure) drives thousands of cases through two properties:
+//!
+//! 1. **Round trip** — whatever was appended is read back, in order, intact.
+//! 2. **Prefix under corruption** — after *any* damage to the file (bit flips,
+//!    truncation, inserted or deleted bytes, duplicated or reordered regions),
+//!    reading never panics and yields an exact *prefix* of what was written.
+//!    This is the guarantee the chained CRC exists to provide: replay may stop
+//!    early, but it never returns a corrupted, reordered, or invented entry.
+
+use clawhdf5_agent::wal::{WalEntry, WalEntryType, WalFile};
+
+/// SplitMix64: tiny, well-distributed, and fully determined by its seed.
+struct Rng(u64);
+
+impl Rng {
+    fn next(&mut self) -> u64 {
+        self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
+        let mut z = self.0;
+        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+        z ^ (z >> 31)
+    }
+
+    fn below(&mut self, n: usize) -> usize {
+        (self.next() % n.max(1) as u64) as usize
+    }
+
+    fn string(&mut self, max_len: usize) -> String {
+        const ALPHABET: &[char] = &['a', 'Z', '0', ' ', '\n', '\0', 'é', '漢', '🦀', '"'];
+        (0..self.below(max_len + 1))
+            .map(|_| ALPHABET[self.below(ALPHABET.len())])
+            .collect()
+    }
+}
+
+/// What a test appended, in a form comparable with what is read back.
+#[derive(Debug, Clone, PartialEq)]
+enum Logged {
+    Save(String, Vec<u32>, String, String, String, u64),
+    Update(usize, String, Vec<u32>, u64),
+    Tombstone(usize, u64),
+}
+
+fn logged(entry: &WalEntry) -> Logged {
+    // Compare floats by bit pattern so NaN payloads and -0.0 count as intact.
+    let bits: Vec<u32> = entry.embedding.iter().map(|f| f.to_bits()).collect();
+    let ts = entry.timestamp.to_bits();
+    match entry.entry_type {
+        WalEntryType::Save => Logged::Save(
+            entry.chunk.clone(),
+            bits,
+            entry.source_channel.clone(),
+            entry.session_id.clone(),
+            entry.tags.clone(),
+            ts,
+        ),
+        WalEntryType::Update => {
+            Logged::Update(entry.update_index.unwrap(), entry.chunk.clone(), bits, ts)
+        }
+        WalEntryType::Tombstone => Logged::Tombstone(entry.tombstone_index.unwrap(), ts),
+        WalEntryType::ActivationUpdate => unreachable!("never written by these tests"),
+    }
+}
+
+/// Append a random mix of records; return what was written.
+fn write_random_wal(path: &std::path::Path, rng: &mut Rng) -> Vec<Logged> {
+    let mut wal = WalFile::open(path).unwrap();
+    let mut written = Vec::new();
+    for _ in 0..rng.below(12) {
+        let timestamp = f64::from_bits(rng.next());
+        if rng.below(5) == 0 {
+            let index = rng.below(1000);
+            wal.append_tombstone(index, timestamp).unwrap();
+            written.push(Logged::Tombstone(index, timestamp.to_bits()));
+            continue;
+        }
+        let update_index = (rng.below(4) == 0).then(|| rng.below(1000));
+        let entry = WalEntry {
+            entry_type: if update_index.is_some() {
+                WalEntryType::Update
+            } else {
+                WalEntryType::Save
+            },
+            timestamp,
+            chunk: rng.string(40),
+            embedding: (0..rng.below(9))
+                .map(|_| f32::from_bits(rng.next() as u32))
+                .collect(),
+            source_channel: rng.string(8),
+            session_id: rng.string(8),
+            tags: rng.string(8),
+            tombstone_index: None,
+            update_index,
+        };
+        wal.append_save(&entry).unwrap();
+        written.push(logged(&entry));
+    }
+    written
+}
+
+fn read_back(path: &std::path::Path) -> Option<Vec<Logged>> {
+    WalFile::read_entries(path)
+        .ok()
+        .map(|entries| entries.iter().map(logged).collect())
+}
+
+#[test]
+fn everything_appended_is_read_back_intact() {
+    let dir = tempfile::TempDir::new().unwrap();
+    for seed in 0..300u64 {
+        let path = dir.path().join(format!("rt-{seed}.wal"));
+        let written = write_random_wal(&path, &mut Rng(seed));
+        assert_eq!(read_back(&path).unwrap(), written, "seed {seed}");
+        // Reopening (which scans and repositions) must not disturb anything.
+        drop(WalFile::open(&path).unwrap());
+        assert_eq!(
+            read_back(&path).unwrap(),
+            written,
+            "seed {seed} after reopen"
+        );
+    }
+}
+
+/// Damage `bytes` in one of several ways.
+fn corrupt(bytes: &mut Vec<u8>, rng: &mut Rng) {
+    if bytes.is_empty() {
+        return;
+    }
+    match rng.below(7) {
+        0 => {
+            let i = rng.below(bytes.len());
+            bytes[i] ^= 1 << rng.below(8);
+        }
+        1 => bytes.truncate(rng.below(bytes.len())),
+        2 => {
+            let i = rng.below(bytes.len() + 1);
+            bytes.insert(i, rng.next() as u8);
+        }
+        3 => {
+            let i = rng.below(bytes.len());
+            bytes.remove(i);
+        }
+        4 => {
+            // Duplicate a region in place (a replayed/duplicated entry).
+            let a = rng.below(bytes.len());
+            let b = a + rng.below(bytes.len() - a);
+            let region = bytes[a..b].to_vec();
+            let at = rng.below(bytes.len() + 1);
+            bytes.splice(at..at, region);
+        }
+        5 => {
+            // Swap two regions (reordered entries).
+            let mid = rng.below(bytes.len());
+            bytes.rotate_left(mid);
+        }
+        _ => {
+            let i = rng.below(bytes.len());
+            let n = rng.below(bytes.len() - i + 1);
+            for b in &mut bytes[i..i + n] {
+                *b = rng.next() as u8;
+            }
+        }
+    }
+}
+
+#[test]
+fn any_corruption_yields_a_prefix_never_a_wrong_entry() {
+    let dir = tempfile::TempDir::new().unwrap();
+    let mut shortened = 0u32;
+    for seed in 0..1500u64 {
+        let mut rng = Rng(seed ^ 0xC0FF_EE00);
+        let path = dir.path().join("c.wal");
+        let _ = std::fs::remove_file(&path);
+        let written = write_random_wal(&path, &mut rng);
+
+        let mut bytes = std::fs::read(&path).unwrap();
+        for _ in 0..=rng.below(3) {
+            corrupt(&mut bytes, &mut rng);
+        }
+        std::fs::write(&path, &bytes).unwrap();
+
+        // An unreadable header is a clean error; anything else is a prefix.
+        if let Some(read) = read_back(&path) {
+            assert!(
+                read.len() <= written.len() && read[..] == written[..read.len()],
+                "seed {seed}: read {read:?}\nis not a prefix of {written:?}"
+            );
+            if read.len() < written.len() {
+                shortened += 1;
+            }
+            // Opening for append repairs the tail; what was readable stays so,
+            // and a new entry lands right after it.
+            if let Ok(mut wal) = WalFile::open(&path) {
+                wal.append_tombstone(7, 1.0).unwrap();
+                drop(wal);
+                let mut expected = read.clone();
+                expected.push(Logged::Tombstone(7, 1.0f64.to_bits()));
+                assert_eq!(
+                    read_back(&path).unwrap(),
+                    expected,
+                    "seed {seed} after repair"
+                );
+            }
+        }
+    }
+    assert!(
+        shortened > 100,
+        "corruption rarely took effect: {shortened}"
+    );
+}

crates/clawhdf5-android/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clawhdf5-android"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "Android JNI bridge for edgehdf5-memory HDF5 backend"
 license = "MIT"

crates/clawhdf5-ann/Cargo.toml

@@ -1,17 +1,18 @@
 [package]
 name = "clawhdf5-ann"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "HNSW approximate nearest neighbor index stored as HDF5"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "ann", "hnsw", "nearest-neighbor"]
 categories = ["algorithms", "science"]
 
 [dependencies]
-clawhdf5-format = { path = "../clawhdf5-format", version = "2.1.0" }
+clawhdf5-format = { path = "../clawhdf5-format", version = "2.3.0" }
-clawhdf5-io = { path = "../clawhdf5-io", version = "2.1.0" }
+clawhdf5-io = { path = "../clawhdf5-io", version = "2.3.0" }
+clawhdf5-accel = { path = "../clawhdf5-accel", version = "2.3.0" }
 rayon = { version = "1", optional = true }
 
 [features]

crates/clawhdf5-ann/src/hnsw.rs

@@ -44,32 +44,14 @@ impl DistanceMetric {
 }
 
 /// Compute distance between two vectors using the given metric.
+///
+/// Delegates to `clawhdf5-accel`'s runtime-dispatched SIMD kernels (AVX2 on
+/// x86_64, NEON on aarch64, portable scalar fallback elsewhere) — this is
+/// the hottest loop in both HNSW build and every `hybrid_search` query.
 fn compute_distance(a: &[f32], b: &[f32], metric: DistanceMetric) -> f32 {
     match metric {
-        DistanceMetric::L2 => {
+        DistanceMetric::L2 => clawhdf5_accel::l2_distance(a, b),
-            let mut sum = 0.0f32;
+        DistanceMetric::Cosine => 1.0 - clawhdf5_accel::cosine_similarity(a, b),
-            for i in 0..a.len() {
-                let d = a[i] - b[i];
-                sum += d * d;
-            }
-            sum.sqrt()
-        }
-        DistanceMetric::Cosine => {
-            let mut dot = 0.0f32;
-            let mut norm_a = 0.0f32;
-            let mut norm_b = 0.0f32;
-            for i in 0..a.len() {
-                dot += a[i] * b[i];
-                norm_a += a[i] * a[i];
-                norm_b += b[i] * b[i];
-            }
-            let denom = norm_a.sqrt() * norm_b.sqrt();
-            if denom < f32::EPSILON {
-                1.0
-            } else {
-                1.0 - (dot / denom)
-            }
-        }
     }
 }
 
@@ -1318,6 +1300,18 @@ mod tests {
         assert!((d - 1.0).abs() < 1e-6); // zero vector -> distance 1
     }
 
+    #[test]
+    fn cosine_near_zero_vector() {
+        // Tiny-but-nonzero, identical-direction vectors: denom is well
+        // below f32::EPSILON but not exactly 0.0. Must still be treated
+        // as a degenerate/unreliable direction (distance 1, "maximally
+        // dissimilar"), not as an exact match (distance 0).
+        let a = vec![1e-4, 1e-4];
+        let b = vec![1e-4, 1e-4];
+        let d = compute_distance(&a, &b, DistanceMetric::Cosine);
+        assert!((d - 1.0).abs() < 1e-6);
+    }
+
     #[test]
     fn insert_into_empty_index() {
         let mut index = HnswIndex::new(4, 16, DistanceMetric::L2);

crates/clawhdf5-bench/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clawhdf5-bench"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "Benchmark harnesses for clawhdf5-agent (Track 8)"
 license = "MIT"

crates/clawhdf5-bench/src/bin/consolidation_efficiency.rs

@@ -22,7 +22,9 @@
 use std::time::Instant;
 
 use clawhdf5_agent::bm25::BM25Index;
-use clawhdf5_agent::consolidation::{ConsolidationConfig, ConsolidationEngine, MemorySource};
+use clawhdf5_agent::consolidation::{
+    ConsolidationConfig, ConsolidationEngine, TrustedSource, UntrustedSource,
+};
 use clawhdf5_agent::hybrid::hybrid_search;
 
 const EMBEDDING_DIM: usize = 384;
@@ -232,7 +234,7 @@ fn run_quality_benchmark() {
     for i in 0..SIGNAL_KEYWORDS.len() {
         let chunk = make_signal_content(i);
         let embedding = make_embedding(i * 1000);
-        let id = engine.add_memory(chunk, embedding, MemorySource::Correction, now);
+        let id = engine.add_trusted_memory(chunk, embedding, TrustedSource::Correction, now);
         signal_ids.push(id);
     }
 
@@ -240,7 +242,12 @@ fn run_quality_benchmark() {
     for i in 0..990 {
         let chunk = make_noise_content(i);
         let embedding = make_embedding(i + 100);
-        engine.add_memory(chunk, embedding, MemorySource::System, now + i as f64 * 0.1);
+        engine.add_trusted_memory(
+            chunk,
+            embedding,
+            TrustedSource::System,
+            now + i as f64 * 0.1,
+        );
     }
 
     println!("  → Inserted {} records total", engine.records().len());
@@ -333,7 +340,7 @@ fn run_cycle_time_benchmark() {
         for i in 0..n {
             let chunk = make_noise_content(i);
             let embedding = make_embedding(i);
-            engine.add_memory(chunk, embedding, MemorySource::User, now + i as f64);
+            engine.add_memory(chunk, embedding, UntrustedSource::User, now + i as f64);
         }
 
         // Warmup
@@ -344,7 +351,7 @@ fn run_cycle_time_benchmark() {
         for i in n..(n * 2) {
             let chunk = make_noise_content(i);
             let embedding = make_embedding(i);
-            engine.add_memory(chunk, embedding, MemorySource::User, now + i as f64);
+            engine.add_memory(chunk, embedding, UntrustedSource::User, now + i as f64);
         }
 
         // Timed consolidation
@@ -410,13 +417,13 @@ fn run_memory_reduction_benchmark() {
         for i in 0..signal_count {
             let chunk = make_signal_content(i % SIGNAL_KEYWORDS.len());
             let emb = make_embedding(i * 999);
-            let id = engine.add_memory(chunk, emb, MemorySource::Correction, now);
+            let id = engine.add_trusted_memory(chunk, emb, TrustedSource::Correction, now);
             signal_ids.push(id);
         }
         for i in 0..noise_count {
             let chunk = make_noise_content(i);
             let emb = make_embedding(i + 200);
-            engine.add_memory(chunk, emb, MemorySource::System, now + i as f64 * 0.1);
+            engine.add_trusted_memory(chunk, emb, TrustedSource::System, now + i as f64 * 0.1);
         }
 
         // Access signal records heavily

crates/clawhdf5-cli/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "clawhdf5-cli"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 license = "MIT"
 description = "CLI for clawhdf5 agent memory — create, save, search, recall, stats"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 keywords = ["hdf5", "ai", "memory", "agent", "cli"]
 categories = ["command-line-utilities", "science"]
 readme = "../../README.md"
@@ -14,7 +14,7 @@ name = "clawhdf5"
 path = "src/main.rs"
 
 [dependencies]
-clawhdf5-agent = { path = "../clawhdf5-agent", version = "2.1.0" }
+clawhdf5-agent = { path = "../clawhdf5-agent", version = "2.3.0" }
 clap = { version = "4", features = ["derive", "env"] }
 serde_json = "1"
 serde = { workspace = true }

crates/clawhdf5-cli/src/main.rs

@@ -146,7 +146,7 @@ fn run(cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
         }
 
         Commands::Recall { index } => {
-            let mem = HDF5Memory::open(&cli.path)?;
+            let mem = HDF5Memory::open_read_only(&cli.path)?;
             match mem.get_chunk(index) {
                 Some(content) => {
                     let j = serde_json::json!({ "index": index, "chunk": content });
@@ -160,7 +160,7 @@ fn run(cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
         }
 
         Commands::Stats => {
-            let mem = HDF5Memory::open(&cli.path)?;
+            let mem = HDF5Memory::open_read_only(&cli.path)?;
             let cfg = mem.config();
             let j = serde_json::json!({
                 "path": cli.path.display().to_string(),
@@ -187,7 +187,7 @@ fn run(cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
         }
 
         Commands::AgentsMd { output } => {
-            let mem = HDF5Memory::open(&cli.path)?;
+            let mem = HDF5Memory::open_read_only(&cli.path)?;
             let md = mem.generate_agents_md();
             match output {
                 Some(p) => {
@@ -199,7 +199,7 @@ fn run(cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
         }
 
         Commands::Export => {
-            let mem = HDF5Memory::open(&cli.path)?;
+            let mem = HDF5Memory::open_read_only(&cli.path)?;
             for i in 0..mem.count() {
                 if let Some(chunk) = mem.get_chunk(i) {
                     let j = serde_json::json!({ "index": i, "chunk": chunk });

crates/clawhdf5-derive/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "clawhdf5-derive"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "Derive macros for rustyhdf5 HDF5 traits"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "derive", "macros", "science"]
 categories = ["development-tools::procedural-macro-helpers"]

crates/clawhdf5-filters/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "clawhdf5-filters"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "Filter and compression pipeline for clawhdf5"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "compression", "deflate", "filters"]
 categories = ["compression", "science"]

crates/clawhdf5-format/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "clawhdf5-format"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "Pure-Rust HDF5 binary format parsing and writing — no C dependencies"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "science", "data", "binary", "no-std"]
 categories = ["parser-implementations", "science", "encoding", "no-std"]
@@ -25,7 +25,7 @@ pco = { version = "1.0", optional = true }
 [dev-dependencies]
 serde_json = "1"
 criterion = { workspace = true }
-clawhdf5-derive = { path = "../clawhdf5-derive", version = "2.1.0" }
+clawhdf5-derive = { path = "../clawhdf5-derive", version = "2.3.0" }
 
 [[bench]]
 name = "bench"

crates/clawhdf5-format/src/attribute.rs

@@ -1,7 +1,9 @@
 //! HDF5 Attribute message parsing (message type 0x000C).
 
 #[cfg(not(feature = "std"))]
-use alloc::{string::String, vec::Vec};
+use alloc::{borrow::Cow, string::String, vec::Vec};
+#[cfg(feature = "std")]
+use std::borrow::Cow;
 
 use crate::attribute_info::AttributeInfoMessage;
 use crate::btree_v2::{BTreeV2Header, collect_btree_v2_records};
@@ -48,17 +50,64 @@ impl AttributeMessage {
     ///
     /// `length_size` is needed for dataspace dimension parsing.
     pub fn parse(data: &[u8], length_size: u8) -> Result<AttributeMessage, FormatError> {
+        Self::parse_impl(data, length_size, None)
+    }
+
+    /// [`AttributeMessage::parse`] with access to the rest of the file, which
+    /// is needed when the attribute's datatype or dataspace is *shared* (v2/v3
+    /// flag bits 0/1) — e.g. an attribute created with a committed datatype.
+    /// In that case the embedded bytes are a reference to the real message,
+    /// not the message. Without file access such an attribute is an error
+    /// rather than a garbage datatype.
+    pub fn parse_in_file(
+        data: &[u8],
+        file_data: &[u8],
+        offset_size: u8,
+        length_size: u8,
+    ) -> Result<AttributeMessage, FormatError> {
+        Self::parse_impl(data, length_size, Some((file_data, offset_size)))
+    }
+
+    fn parse_impl(
+        data: &[u8],
+        length_size: u8,
+        file: Option<(&[u8], u8)>,
+    ) -> Result<AttributeMessage, FormatError> {
         ensure_len(data, 0, 2)?;
         let version = data[0];
 
         match version {
             1 => Self::parse_v1(data, length_size),
-            2 => Self::parse_v2(data, length_size),
+            2 => Self::parse_v2(data, length_size, file),
-            3 => Self::parse_v3(data, length_size),
+            3 => Self::parse_v3(data, length_size, file),
             _ => Err(FormatError::InvalidAttributeVersion(version)),
         }
     }
 
+    /// The bytes of an embedded datatype/dataspace message, following the
+    /// shared-message reference when `shared` is set.
+    fn embedded_message<'a>(
+        bytes: &'a [u8],
+        shared: bool,
+        msg_type: MessageType,
+        length_size: u8,
+        file: Option<(&[u8], u8)>,
+    ) -> Result<Cow<'a, [u8]>, FormatError> {
+        if !shared {
+            return Ok(Cow::Borrowed(bytes));
+        }
+        let (file_data, offset_size) = file.ok_or(FormatError::UnresolvedSharedMessage)?;
+        let shared_ref = shared_message::parse_shared_ref(bytes, offset_size)?;
+        shared_message::resolve_shared_message(
+            file_data,
+            &shared_ref,
+            msg_type,
+            offset_size,
+            length_size,
+        )
+        .map(Cow::Owned)
+    }
+
     fn parse_v1(data: &[u8], length_size: u8) -> Result<AttributeMessage, FormatError> {
         // version(1) + reserved(1) + name_size(2) + datatype_size(2) + dataspace_size(2) = 8
         ensure_len(data, 0, 8)?;
@@ -94,7 +143,13 @@ impl AttributeMessage {
         })
     }
 
-    fn parse_v2(data: &[u8], length_size: u8) -> Result<AttributeMessage, FormatError> {
+    fn parse_v2(
+        data: &[u8],
+        length_size: u8,
+        file: Option<(&[u8], u8)>,
+    ) -> Result<AttributeMessage, FormatError> {
+        // Flags: bit 0 = datatype is shared, bit 1 = dataspace is shared.
+        let flags = data.get(1).copied().unwrap_or(0);
         // version(1) + flags(1) + name_size(2) + datatype_size(2) + dataspace_size(2) = 8
         ensure_len(data, 0, 8)?;
         let name_size = u16::from_le_bytes([data[2], data[3]]) as usize;
@@ -110,12 +165,26 @@ impl AttributeMessage {
 
         // Datatype (NO padding)
         ensure_len(data, pos, datatype_size)?;
-        let (datatype, _) = Datatype::parse(&data[pos..pos + datatype_size])?;
+        let dt_bytes = Self::embedded_message(
+            &data[pos..pos + datatype_size],
+            flags & 0x01 != 0,
+            MessageType::Datatype,
+            length_size,
+            file,
+        )?;
+        let (datatype, _) = Datatype::parse(&dt_bytes)?;
         pos += datatype_size;
 
         // Dataspace (NO padding)
         ensure_len(data, pos, dataspace_size)?;
-        let dataspace = Dataspace::parse(&data[pos..pos + dataspace_size], length_size)?;
+        let ds_bytes = Self::embedded_message(
+            &data[pos..pos + dataspace_size],
+            flags & 0x02 != 0,
+            MessageType::Dataspace,
+            length_size,
+            file,
+        )?;
+        let dataspace = Dataspace::parse(&ds_bytes, length_size)?;
         pos += dataspace_size;
 
         let raw_data = compute_raw_data(data, pos, &dataspace, &datatype);
@@ -128,7 +197,13 @@ impl AttributeMessage {
         })
     }
 
-    fn parse_v3(data: &[u8], length_size: u8) -> Result<AttributeMessage, FormatError> {
+    fn parse_v3(
+        data: &[u8],
+        length_size: u8,
+        file: Option<(&[u8], u8)>,
+    ) -> Result<AttributeMessage, FormatError> {
+        // Flags: bit 0 = datatype is shared, bit 1 = dataspace is shared.
+        let flags = data.get(1).copied().unwrap_or(0);
         // version(1) + flags(1) + name_size(2) + datatype_size(2) + dataspace_size(2) + encoding(1) = 9
         ensure_len(data, 0, 9)?;
         let name_size = u16::from_le_bytes([data[2], data[3]]) as usize;
@@ -145,12 +220,26 @@ impl AttributeMessage {
 
         // Datatype (NO padding)
         ensure_len(data, pos, datatype_size)?;
-        let (datatype, _) = Datatype::parse(&data[pos..pos + datatype_size])?;
+        let dt_bytes = Self::embedded_message(
+            &data[pos..pos + datatype_size],
+            flags & 0x01 != 0,
+            MessageType::Datatype,
+            length_size,
+            file,
+        )?;
+        let (datatype, _) = Datatype::parse(&dt_bytes)?;
         pos += datatype_size;
 
         // Dataspace (NO padding)
         ensure_len(data, pos, dataspace_size)?;
-        let dataspace = Dataspace::parse(&data[pos..pos + dataspace_size], length_size)?;
+        let ds_bytes = Self::embedded_message(
+            &data[pos..pos + dataspace_size],
+            flags & 0x02 != 0,
+            MessageType::Dataspace,
+            length_size,
+            file,
+        )?;
+        let dataspace = Dataspace::parse(&ds_bytes, length_size)?;
         pos += dataspace_size;
 
         let raw_data = compute_raw_data(data, pos, &dataspace, &datatype);
@@ -326,10 +415,20 @@ pub fn extract_attributes_full(
                     offset_size,
                     length_size,
                 )?;
-                let attr = AttributeMessage::parse(&resolved_data, length_size)?;
+                let attr = AttributeMessage::parse_in_file(
+                    &resolved_data,
+                    file_data,
+                    offset_size,
+                    length_size,
+                )?;
                 attrs.push(attr);
             } else {
-                let attr = AttributeMessage::parse(&msg.data, length_size)?;
+                let attr = AttributeMessage::parse_in_file(
+                    &msg.data,
+                    file_data,
+                    offset_size,
+                    length_size,
+                )?;
                 attrs.push(attr);
             }
         }
@@ -399,7 +498,8 @@ fn extract_dense_attributes(
         let attr_data = fh.read_managed_object(file_data, id_bytes, offset_size)?;
 
         // The data in the heap is a complete attribute message
-        let attr = AttributeMessage::parse(&attr_data, length_size)?;
+        let attr =
+            AttributeMessage::parse_in_file(&attr_data, file_data, offset_size, length_size)?;
         attrs.push(attr);
     }
 
@@ -472,14 +572,13 @@ mod tests {
 
         // Name padded to 8 bytes
         data.extend_from_slice(name);
-        while data.len() % 8 != 0 || data.len() == 8 {
+        if data.len() % 8 != 0 || data.len() == 8 {
             // Pad name to 8-byte boundary from start of name
             let name_start = 8;
             let name_padded = pad8(name_size);
             while data.len() < name_start + name_padded {
                 data.push(0);
             }
-            break;
         }
 
         // Datatype padded to 8 bytes
@@ -749,11 +848,11 @@ mod tests {
         data.extend_from_slice(name);
         data.extend_from_slice(&dt_bytes);
         data.extend_from_slice(&ds_bytes);
-        data.extend_from_slice(&3.14f64.to_le_bytes());
+        data.extend_from_slice(&3.25f64.to_le_bytes());
 
         let attr = AttributeMessage::parse(&data, 8).unwrap();
         let vals = attr.read_as_f64().unwrap();
-        assert_eq!(vals, vec![3.14]);
+        assert_eq!(vals, vec![3.25]);
     }
 
     #[test]

crates/clawhdf5-format/src/btree_v2.rs

@@ -416,6 +416,7 @@ fn header_max_total_records(max_leaf_nrec: u64, depth: u16) -> u64 {
 mod tests {
     use super::*;
 
+    #[allow(clippy::too_many_arguments)]
     fn build_btree_v2_header(
         tree_type: u8,
         node_size: u32,

crates/clawhdf5-format/src/chunked_read.rs

@@ -132,6 +132,47 @@ fn ensure_len(data: &[u8], offset: usize, needed: usize) -> Result<(), FormatErr
     Ok(())
 }
 
+/// `elements * elem_size` for sizes that come from the file. Dataspace and
+/// chunk dimensions are untrusted 64-bit fields, so a crafted file can make
+/// the plain product wrap to a small number (or to something enormous).
+pub(crate) fn checked_byte_len(elements: u64, elem_size: usize) -> Result<usize, FormatError> {
+    usize::try_from(elements)
+        .ok()
+        .and_then(|n| n.checked_mul(elem_size))
+        .ok_or_else(|| {
+            FormatError::Overflow(format!(
+                "{elements} elements of {elem_size} bytes exceeds the addressable size"
+            ))
+        })
+}
+
+/// Product of chunk dimensions times the element size, overflow-checked.
+pub(crate) fn checked_chunk_byte_len(
+    chunk_dims: &[usize],
+    elem_size: usize,
+) -> Result<usize, FormatError> {
+    chunk_dims
+        .iter()
+        .try_fold(elem_size, |acc, &d| acc.checked_mul(d))
+        .ok_or_else(|| {
+            FormatError::Overflow(format!(
+                "chunk dimensions {chunk_dims:?} x {elem_size} bytes exceeds the addressable size"
+            ))
+        })
+}
+
+/// A zero-filled output buffer of `len` bytes. `vec![0; len]` aborts the
+/// process when the allocation fails; a size taken from the file must surface
+/// as an error instead.
+pub(crate) fn alloc_output(len: usize) -> Result<Vec<u8>, FormatError> {
+    let mut out = Vec::new();
+    out.try_reserve_exact(len).map_err(|_| {
+        FormatError::Overflow(format!("cannot allocate {len} bytes for dataset output"))
+    })?;
+    out.resize(len, 0);
+    Ok(out)
+}
+
 fn read_offset(data: &[u8], pos: usize, size: u8) -> Result<u64, FormatError> {
     let s = size as usize;
     if pos.checked_add(s).is_none_or(|end| end > data.len()) {
@@ -321,15 +362,17 @@ pub fn generate_implicit_chunks(
 }
 
 /// Read a chunked dataset, decompressing chunks as needed.
-pub fn read_chunked_data(
+/// Every allocated chunk of a chunked dataset, for any supported chunk index,
+/// plus the spatial chunk dimensions. Chunks the file never allocated (sparse
+/// datasets) are simply absent from the list.
+pub fn list_chunks(
     file_data: &[u8],
     layout: &DataLayout,
     dataspace: &Dataspace,
-    datatype: &Datatype,
+    elem_size: usize,
-    pipeline: Option<&FilterPipeline>,
     offset_size: u8,
     length_size: u8,
-) -> Result<Vec<u8>, FormatError> {
+) -> Result<(Vec<ChunkInfo>, Vec<usize>), FormatError> {
     let (
         chunk_dimensions,
         version,
@@ -363,8 +406,6 @@ pub fn read_chunked_data(
     let addr = addr_opt
         .ok_or_else(|| FormatError::ChunkedReadError("no address for chunked layout".into()))?;
 
-    let elem_size = datatype.type_size() as usize;
-
     // Both v3 and v4 include element size as last dim (rank+1)
     let ndims = chunk_dimensions.len();
     let rank = ndims
@@ -393,7 +434,7 @@ pub fn read_chunked_data(
         }
         (4, Some(1)) => {
             // Single chunk — one chunk covering the entire dataset
-            let chunk_byte_size: usize = chunk_dims.iter().product::<usize>() * elem_size;
+            let chunk_byte_size = checked_chunk_byte_len(&chunk_dims, elem_size)?;
             let (csize, fmask) = if let Some(fs) = single_filtered_size {
                 (fs as u32, single_filter_mask.unwrap_or(0))
             } else {
@@ -453,10 +494,38 @@ pub fn read_chunked_data(
         }
     };
 
+    Ok((chunks, chunk_dims))
+}
+
+pub fn read_chunked_data(
+    file_data: &[u8],
+    layout: &DataLayout,
+    dataspace: &Dataspace,
+    datatype: &Datatype,
+    pipeline: Option<&FilterPipeline>,
+    offset_size: u8,
+    length_size: u8,
+) -> Result<Vec<u8>, FormatError> {
+    let elem_size = datatype.type_size() as usize;
+    let (chunks, chunk_dims) = list_chunks(
+        file_data,
+        layout,
+        dataspace,
+        elem_size,
+        offset_size,
+        length_size,
+    )?;
+    let rank = chunk_dims.len();
+    let ds_dims: Vec<usize> = dataspace.dimensions.iter().map(|&d| d as usize).collect();
+
     // Assemble output
-    let total_elements = dataspace.num_elements() as usize;
+    let total_bytes = checked_byte_len(dataspace.checked_num_elements()?, elem_size)?;
-    let total_bytes = total_elements * elem_size;
+    if total_bytes == 0 {
-    let mut output = vec![0u8; total_bytes];
+        // Also keeps the stride products below in range: with a zero-sized
+        // dimension the total is 0 even if other dimensions are huge.
+        return Ok(Vec::new());
+    }
+    let mut output = alloc_output(total_bytes)?;
 
     let mut ds_strides = vec![1usize; rank];
     for i in (0..rank.saturating_sub(1)).rev() {
@@ -468,8 +537,7 @@ pub fn read_chunked_data(
         chunk_strides[i] = chunk_strides[i + 1] * chunk_dims[i + 1];
     }
 
-    let chunk_total_elements: usize = chunk_dims.iter().product();
+    let chunk_total_bytes = checked_chunk_byte_len(&chunk_dims, elem_size)?;
-    let chunk_total_bytes = chunk_total_elements * elem_size;
 
     // Fast path: no filters — copy directly from file_data without intermediate alloc
     if pipeline.is_none() {
@@ -623,7 +691,7 @@ pub fn read_chunked_data_cached(
         let chunks = match (version, chunk_index_type) {
             (3, _) => collect_chunk_info(file_data, addr, ndims, offset_size, length_size)?,
             (4, Some(1)) => {
-                let chunk_byte_size: usize = chunk_dims.iter().product::<usize>() * elem_size;
+                let chunk_byte_size = checked_chunk_byte_len(&chunk_dims, elem_size)?;
                 let (csize, fmask) = if let Some(fs) = single_filtered_size {
                     (fs as u32, single_filter_mask.unwrap_or(0))
                 } else {
@@ -689,9 +757,13 @@ pub fn read_chunked_data_cached(
     let chunks = cache.all_indexed_chunks().unwrap_or_default();
 
     // Assemble output
-    let total_elements = dataspace.num_elements() as usize;
+    let total_bytes = checked_byte_len(dataspace.checked_num_elements()?, elem_size)?;
-    let total_bytes = total_elements * elem_size;
+    if total_bytes == 0 {
-    let mut output = vec![0u8; total_bytes];
+        // Also keeps the stride products below in range: with a zero-sized
+        // dimension the total is 0 even if other dimensions are huge.
+        return Ok(Vec::new());
+    }
+    let mut output = alloc_output(total_bytes)?;
 
     let mut ds_strides = vec![1usize; rank];
     for i in (0..rank.saturating_sub(1)).rev() {
@@ -703,8 +775,7 @@ pub fn read_chunked_data_cached(
         chunk_strides[i] = chunk_strides[i + 1] * chunk_dims[i + 1];
     }
 
-    let chunk_total_elements: usize = chunk_dims.iter().product();
+    let chunk_total_bytes = checked_chunk_byte_len(&chunk_dims, elem_size)?;
-    let chunk_total_bytes = chunk_total_elements * elem_size;
 
     for chunk_info in &chunks {
         let coord: Vec<u64> = chunk_info.offsets.iter().take(rank).copied().collect();
@@ -976,7 +1047,7 @@ pub fn read_chunked_data_sweep(
         let chunks = match (version, chunk_index_type) {
             (3, _) => collect_chunk_info(file_data, addr, ndims, offset_size, length_size)?,
             (4, Some(1)) => {
-                let chunk_byte_size: usize = chunk_dims.iter().product::<usize>() * elem_size;
+                let chunk_byte_size = checked_chunk_byte_len(&chunk_dims, elem_size)?;
                 let (csize, fmask) = if let Some(fs) = single_filtered_size {
                     (fs as u32, single_filter_mask.unwrap_or(0))
                 } else {
@@ -1042,9 +1113,13 @@ pub fn read_chunked_data_sweep(
     let chunks = cache.all_indexed_chunks().unwrap_or_default();
 
     // Assemble output
-    let total_elements = dataspace.num_elements() as usize;
+    let total_bytes = checked_byte_len(dataspace.checked_num_elements()?, elem_size)?;
-    let total_bytes = total_elements * elem_size;
+    if total_bytes == 0 {
-    let mut output = vec![0u8; total_bytes];
+        // Also keeps the stride products below in range: with a zero-sized
+        // dimension the total is 0 even if other dimensions are huge.
+        return Ok(Vec::new());
+    }
+    let mut output = alloc_output(total_bytes)?;
 
     let mut ds_strides = vec![1usize; rank];
     for i in (0..rank.saturating_sub(1)).rev() {
@@ -1056,8 +1131,7 @@ pub fn read_chunked_data_sweep(
         chunk_strides[i] = chunk_strides[i + 1] * chunk_dims[i + 1];
     }
 
-    let chunk_total_elements: usize = chunk_dims.iter().product();
+    let chunk_total_bytes = checked_chunk_byte_len(&chunk_dims, elem_size)?;
-    let chunk_total_bytes = chunk_total_elements * elem_size;
 
     for chunk_info in &chunks {
         let coord: Vec<u64> = chunk_info.offsets.iter().take(rank).copied().collect();
@@ -1199,7 +1273,7 @@ pub fn read_chunked_data_indexed(
         let chunks = match (version, chunk_index_type) {
             (3, _) => collect_chunk_info(file_data, addr, ndims, offset_size, length_size)?,
             (4, Some(1)) => {
-                let chunk_byte_size: usize = chunk_dims.iter().product::<usize>() * elem_size;
+                let chunk_byte_size = checked_chunk_byte_len(&chunk_dims, elem_size)?;
                 let (csize, fmask) = if let Some(fs) = single_filtered_size {
                     (fs as u32, single_filter_mask.unwrap_or(0))
                 } else {
@@ -1463,6 +1537,64 @@ fn copy_chunk_to_output(
 mod tests {
     use super::*;
 
+    fn simple_space(dimensions: Vec<u64>) -> Dataspace {
+        Dataspace {
+            space_type: crate::dataspace::DataspaceType::Simple,
+            rank: dimensions.len() as u8,
+            dimensions,
+            max_dimensions: None,
+        }
+    }
+
+    #[test]
+    fn crafted_dimensions_are_errors_not_wraparound() {
+        // 2^63 * 2 wraps to 0 with a plain product; 2^40 * 2^40 wraps too.
+        for dims in [
+            vec![1u64 << 63, 2],
+            vec![1 << 40, 1 << 40],
+            vec![u64::MAX, u64::MAX],
+        ] {
+            let space = simple_space(dims.clone());
+            assert!(
+                matches!(space.checked_num_elements(), Err(FormatError::Overflow(_))),
+                "{dims:?}"
+            );
+            // The infallible accessor saturates instead of wrapping.
+            assert_eq!(space.num_elements(), u64::MAX, "{dims:?}");
+        }
+        assert_eq!(simple_space(vec![3, 4]).checked_num_elements().unwrap(), 12);
+        // A zero-sized dimension makes the whole product 0, not an overflow.
+        assert_eq!(
+            simple_space(vec![0, 1 << 40, 1 << 40])
+                .checked_num_elements()
+                .unwrap(),
+            0
+        );
+    }
+
+    #[test]
+    fn byte_length_helpers_check_overflow() {
+        assert_eq!(checked_byte_len(10, 8).unwrap(), 80);
+        assert!(matches!(
+            checked_byte_len(u64::MAX, 8),
+            Err(FormatError::Overflow(_))
+        ));
+        assert_eq!(checked_chunk_byte_len(&[10, 10], 4).unwrap(), 400);
+        assert!(matches!(
+            checked_chunk_byte_len(&[usize::MAX, 2], 4),
+            Err(FormatError::Overflow(_))
+        ));
+    }
+
+    #[test]
+    fn unallocatable_output_is_an_error_not_an_abort() {
+        assert_eq!(alloc_output(16).unwrap(), vec![0u8; 16]);
+        assert!(matches!(
+            alloc_output(usize::MAX / 2),
+            Err(FormatError::Overflow(_))
+        ));
+    }
+
     fn write_offset(buf: &mut Vec<u8>, val: u64, size: u8) {
         match size {
             4 => buf.extend_from_slice(&(val as u32).to_le_bytes()),
@@ -1657,9 +1789,9 @@ mod tests {
             let chunk_bytes = chunk_size_elems * elem_size; // full chunk allocation
 
             // Write chunk data (full chunk size, padding with zeros)
-            for i in start..end {
+            for (i, value) in values.iter().enumerate().take(end).skip(start) {
                 let byte_offset = data_offset + (i - start) * elem_size;
-                file_data[byte_offset..byte_offset + 8].copy_from_slice(&values[i].to_le_bytes());
+                file_data[byte_offset..byte_offset + 8].copy_from_slice(&value.to_le_bytes());
             }
 
             chunk_infos.push(ChunkInfo {
@@ -1837,8 +1969,8 @@ mod tests {
         for chunk_idx in 0..2 {
             let start = chunk_idx * chunk_elems;
             let mut chunk_bytes = Vec::new();
-            for i in start..start + chunk_elems {
+            for value in values.iter().skip(start).take(chunk_elems) {
-                chunk_bytes.extend_from_slice(&values[i].to_le_bytes());
+                chunk_bytes.extend_from_slice(&value.to_le_bytes());
             }
             let compressed = compress_chunk(&chunk_bytes, &pipeline, elem_size as u32).unwrap();
 

crates/clawhdf5-format/src/data_read.rs

@@ -475,8 +475,10 @@ fn read_virtual_data(
     use crate::selection::Selection;
 
     let elem_size = datatype.type_size() as usize;
-    let total_elems = dataspace.num_elements() as usize;
+    let mut out = crate::chunked_read::alloc_output(crate::chunked_read::checked_byte_len(
-    let mut out = vec![0u8; total_elems.saturating_mul(elem_size)];
+        dataspace.checked_num_elements()?,
+        elem_size,
+    )?)?;
 
     let virtual_dims = &dataspace.dimensions;
 
@@ -598,7 +600,7 @@ fn read_named_dataset_raw(
 }
 
 /// Extract selected elements from a full dataset buffer.
-fn extract_selection_from_buffer(
+pub fn extract_selection_from_buffer(
     full_data: &[u8],
     dims: &[u64],
     elem_size: usize,
@@ -616,12 +618,14 @@ fn extract_selection_from_buffer(
             block,
         } => {
             let rank = dims.len();
-            let output_elements: usize = count
+            let output_elements = count
                 .iter()
                 .zip(block.iter())
-                .map(|(&c, &b)| (c * b) as usize)
+                .try_fold(1u64, |acc, (&c, &b)| acc.checked_mul(c.checked_mul(b)?))
-                .product();
+                .ok_or_else(|| FormatError::Overflow("hyperslab count x block overflows".into()))?;
-            let mut output = vec![0u8; output_elements * elem_size];
+            let mut output = crate::chunked_read::alloc_output(
+                crate::chunked_read::checked_byte_len(output_elements, elem_size)?,
+            )?;
 
             // Compute dataset strides (row-major)
             let mut ds_strides = vec![1usize; rank];
@@ -1763,11 +1767,11 @@ mod tests {
     fn f16_bits(v: f32) -> u16 {
         // Encode a few exact values used by the test.
         match v {
-            x if x == 0.0 => 0x0000,
+            0.0 => 0x0000,
-            x if x == 1.0 => 0x3c00,
+            1.0 => 0x3c00,
-            x if x == -2.0 => 0xc000,
+            -2.0 => 0xc000,
-            x if x == 0.5 => 0x3800,
+            0.5 => 0x3800,
-            x if x == 65504.0 => 0x7bff, // f16 max
+            65504.0 => 0x7bff, // f16 max
             _ => panic!("unsupported test value {v}"),
         }
     }
@@ -2186,7 +2190,7 @@ mod tests {
             ],
         };
         let mut raw = Vec::new();
-        raw.extend_from_slice(&3.14f64.to_le_bytes());
+        raw.extend_from_slice(&3.25f64.to_le_bytes());
         raw.extend_from_slice(&42i32.to_le_bytes());
 
         let field = read_compound_field(&raw, &dt, "id").unwrap();

crates/clawhdf5-format/src/dataspace.rs

@@ -1,5 +1,7 @@
 //! HDF5 Dataspace message parsing (message type 0x0001).
 
+#[cfg(not(feature = "std"))]
+use alloc::format;
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
@@ -167,6 +169,27 @@ impl Dataspace {
         }
     }
 
+    /// [`Dataspace::num_elements`] with the product overflow-checked. The
+    /// dimensions are untrusted 64-bit fields; read paths that size a buffer
+    /// from them must use this one.
+    pub fn checked_num_elements(&self) -> Result<u64, FormatError> {
+        match self.space_type {
+            DataspaceType::Null => Ok(0),
+            DataspaceType::Scalar => Ok(1),
+            DataspaceType::Simple if self.dimensions.is_empty() => Ok(0),
+            DataspaceType::Simple => self
+                .dimensions
+                .iter()
+                .try_fold(1u64, |acc, &d| acc.checked_mul(d))
+                .ok_or_else(|| {
+                    FormatError::Overflow(format!(
+                        "dataspace dimensions {:?} overflow the element count",
+                        self.dimensions
+                    ))
+                }),
+        }
+    }
+
     /// Total number of elements. Scalar = 1, Null = 0.
     pub fn num_elements(&self) -> u64 {
         match self.space_type {
@@ -176,7 +199,12 @@ impl Dataspace {
                 if self.dimensions.is_empty() {
                     0
                 } else {
-                    self.dimensions.iter().product()
+                    // Saturate rather than wrap: a wrapped product could
+                    // under-size a buffer. Size-critical callers use
+                    // `checked_num_elements`.
+                    self.dimensions
+                        .iter()
+                        .fold(1u64, |acc, &d| acc.saturating_mul(d))
                 }
             }
         }
@@ -189,11 +217,7 @@ mod tests {
 
     fn build_v1_dataspace(rank: u8, flags: u8, dims: &[u64], max_dims: Option<&[u64]>) -> Vec<u8> {
         let length_size = 8u8;
-        let mut buf = Vec::new();
+        let mut buf = vec![1, rank, flags, 0]; // version, rank, flags, reserved
-        buf.push(1); // version
-        buf.push(rank);
-        buf.push(flags);
-        buf.push(0); // reserved
         buf.extend_from_slice(&[0u8; 4]); // reserved(4)
         for &d in dims {
             buf.extend_from_slice(&d.to_le_bytes());
@@ -214,11 +238,7 @@ mod tests {
         dims: &[u64],
         max_dims: Option<&[u64]>,
     ) -> Vec<u8> {
-        let mut buf = Vec::new();
+        let mut buf = vec![2, rank, flags, type_byte]; // version, rank, flags, type
-        buf.push(2); // version
-        buf.push(rank);
-        buf.push(flags);
-        buf.push(type_byte);
         for &d in dims {
             buf.extend_from_slice(&d.to_le_bytes());
         }
@@ -298,11 +318,7 @@ mod tests {
 
     #[test]
     fn v1_with_4byte_length() {
-        let mut buf = Vec::new();
+        let mut buf = vec![1, 1, 0, 0]; // version, rank, flags, reserved
-        buf.push(1); // version
-        buf.push(1); // rank
-        buf.push(0); // flags
-        buf.push(0); // reserved
         buf.extend_from_slice(&[0u8; 4]); // reserved(4)
         buf.extend_from_slice(&10u32.to_le_bytes()); // dim with length_size=4
         let ds = Dataspace::parse(&buf, 4).unwrap();

crates/clawhdf5-format/src/datatype.rs

@@ -204,11 +204,25 @@ fn read_uint(data: &[u8], offset: usize, nbytes: usize) -> Result<u64, FormatErr
     })
 }
 
+/// Maximum recursion depth for nested datatypes (Compound/Enumeration/
+/// VariableLength/Array). A crafted file can nest a message-size-capped
+/// (65535 byte) datatype message ~8000 levels deep, which would blow the
+/// stack — especially on the project's no_std/embedded targets where
+/// available stack is a few KB.
+const MAX_DATATYPE_DEPTH: u16 = 64;
+
 impl Datatype {
     /// Parse a datatype message from raw bytes.
     ///
     /// Returns `(Datatype, bytes_consumed)` for recursive parsing.
     pub fn parse(data: &[u8]) -> Result<(Datatype, usize), FormatError> {
+        Self::parse_with_depth(data, 0)
+    }
+
+    fn parse_with_depth(data: &[u8], depth: u16) -> Result<(Datatype, usize), FormatError> {
+        if depth >= MAX_DATATYPE_DEPTH {
+            return Err(FormatError::NestingDepthExceeded);
+        }
         // Minimum header: 4 bytes (class_and_version + 3 bytes bit field) + 4 bytes size = 8
         ensure_len(data, 0, 8)?;
 
@@ -358,7 +372,8 @@ impl Datatype {
                         pos += name_len;
                         let byte_offset = read_uint(data, pos, ob)?;
                         pos += ob;
-                        let (member_dt, consumed) = Datatype::parse(&data[pos..])?;
+                        let (member_dt, consumed) =
+                            Self::parse_with_depth(&data[pos..], depth + 1)?;
                         pos += consumed;
                         members.push(CompoundMember {
                             name,
@@ -367,24 +382,29 @@ impl Datatype {
                         });
                     }
                 } else if version == 1 || version == 2 {
-                    // v1/v2: name, offset(4), dimensionality(1), reserved(3), dim_perm(4),
+                    // v1/v2: name (null-terminated, padded to a multiple of 8
-                    //         reserved_dims(up to 4*4=16), member datatype
+                    // bytes), offset(4), member datatype. v1 additionally
+                    // carries the legacy per-member array fields between the
+                    // offset and the member datatype: dimensionality(1),
+                    // reserved(3), dim_perm(4), reserved(4), 4 dim sizes(16).
+                    // v1 is what default (non-`latest`) libver bounds emit.
                     for _ in 0..num_members {
                         let (name, name_len) = read_null_terminated_string(data, pos)?;
-                        pos += name_len;
+                        let padded = name_len.checked_add(7).ok_or(FormatError::UnexpectedEof {
-                        // v1: names padded to 8-byte boundary
+                            expected: usize::MAX,
-                        if version == 1 {
+                            available: data.len(),
-                            let total_name_bytes = name_len;
+                        })? & !7;
-                            let padded = (total_name_bytes + 7) & !7;
+                        ensure_len(data, pos, padded)?;
-                            pos = pos - name_len + padded;
+                        pos += padded;
-                        }
                         ensure_len(data, pos, 4)?;
                         let byte_offset = LittleEndian::read_u32(&data[pos..pos + 4]) as u64;
                         pos += 4;
-                        // dimensionality(1) + reserved(3) + dim_perm(4) + 4 dim slots(16) = 24
+                        if version == 1 {
-                        ensure_len(data, pos, 24)?;
+                            ensure_len(data, pos, 28)?;
-                        pos += 24;
+                            pos += 28;
-                        let (member_dt, consumed) = Datatype::parse(&data[pos..])?;
+                        }
+                        let (member_dt, consumed) =
+                            Self::parse_with_depth(&data[pos..], depth + 1)?;
                         pos += consumed;
                         members.push(CompoundMember {
                             name,
@@ -415,7 +435,7 @@ impl Datatype {
                 // Enumeration
                 let num_members = (bf0 as u16) | ((bf1 as u16) << 8);
                 // Parse base type
-                let (base_type, base_consumed) = Datatype::parse(&data[pos..])?;
+                let (base_type, base_consumed) = Self::parse_with_depth(&data[pos..], depth + 1)?;
                 pos += base_consumed;
                 let base_size = base_type.type_size();
                 let mut members = Vec::with_capacity(num_members as usize);
@@ -468,7 +488,7 @@ impl Datatype {
                 } else {
                     None
                 };
-                let (base_type, consumed) = Datatype::parse(&data[pos..])?;
+                let (base_type, consumed) = Self::parse_with_depth(&data[pos..], depth + 1)?;
                 pos += consumed;
                 Ok((
                     Datatype::VariableLength {
@@ -494,7 +514,7 @@ impl Datatype {
                     }
                     // skip permutation indices
                     pos += ndims * 4;
-                    let (base_type, consumed) = Datatype::parse(&data[pos..])?;
+                    let (base_type, consumed) = Self::parse_with_depth(&data[pos..], depth + 1)?;
                     pos += consumed;
                     Ok((
                         Datatype::Array {
@@ -515,7 +535,7 @@ impl Datatype {
                         dimensions.push(LittleEndian::read_u32(&data[pos..pos + 4]));
                         pos += 4;
                     }
-                    let (base_type, consumed) = Datatype::parse(&data[pos..])?;
+                    let (base_type, consumed) = Self::parse_with_depth(&data[pos..], depth + 1)?;
                     pos += consumed;
                     Ok((
                         Datatype::Array {
@@ -532,27 +552,39 @@ impl Datatype {
                 }
             }
             11 => {
-                // Complex number — store as compound of two floats internally
+                // Complex number (HDF5 2.0, datatype version 5). The properties
-                // Parse like compound with version 3 and 2 members
+                // are a single base floating-point datatype message; an element
-                // But actually class 11 has no special properties beyond class 6 compound.
+                // is two consecutive base-type values (real, imaginary). There
-                // It's just recognized as a separate class. For now parse the 2 members
+                // is no member list. Surface it as the equivalent two-member
-                // as compound.
+                // compound `{r, i}` — the same shape h5py writes for numpy
-                let num_members = (bf0 as u16) | ((bf1 as u16) << 8);
+                // complex dtypes — so downstream compound readers work as-is.
-                let mut members = Vec::with_capacity(num_members as usize);
+                if version != 5 {
-                let ob = offset_bytes_for_size(size);
+                    return Err(FormatError::InvalidDatatypeVersion {
-                for _ in 0..num_members {
+                        class: class_id,
-                    let (name, name_len) = read_null_terminated_string(data, pos)?;
+                        version,
-                    pos += name_len;
-                    let byte_offset = read_uint(data, pos, ob)?;
-                    pos += ob;
-                    let (member_dt, consumed) = Datatype::parse(&data[pos..])?;
-                    pos += consumed;
-                    members.push(CompoundMember {
-                        name,
-                        byte_offset,
-                        datatype: member_dt,
                     });
                 }
+                let (base_type, consumed) = Self::parse_with_depth(&data[pos..], depth + 1)?;
+                pos += consumed;
+                let base_size = base_type.type_size();
+                if base_size.checked_mul(2) != Some(size) {
+                    return Err(FormatError::DataSizeMismatch {
+                        expected: (base_size as usize).saturating_mul(2),
+                        actual: size as usize,
+                    });
+                }
+                let members = vec![
+                    CompoundMember {
+                        name: String::from("r"),
+                        byte_offset: 0,
+                        datatype: base_type.clone(),
+                    },
+                    CompoundMember {
+                        name: String::from("i"),
+                        byte_offset: base_size as u64,
+                        datatype: base_type,
+                    },
+                ];
                 Ok((Datatype::Compound { size, members }, pos))
             }
             _ => Err(FormatError::InvalidDatatypeClass(class_id)),
@@ -814,6 +846,39 @@ mod tests {
         buf
     }
 
+    /// A crafted datatype message nesting Variable-Length wrappers deeper
+    /// than `MAX_DATATYPE_DEPTH` must return `NestingDepthExceeded`
+    /// instead of overflowing the stack.
+    #[test]
+    fn nested_variable_length_exceeds_depth_limit() {
+        // Each VL level is just an 8-byte header (class 9, vl_type=0 =>
+        // sequence, no padding/charset fields) immediately followed by the
+        // next level's bytes, terminated by a fixed-point base type.
+        let levels = MAX_DATATYPE_DEPTH as usize + 10;
+        let mut data = Vec::new();
+        for _ in 0..levels {
+            data.extend_from_slice(&build_dt_header(9, 3, [0, 0, 0], 0));
+        }
+        data.extend_from_slice(&build_fixed_point(4, false, false, 0, 32));
+
+        let result = Datatype::parse(&data);
+        assert!(matches!(result, Err(FormatError::NestingDepthExceeded)));
+    }
+
+    /// A datatype nested just within the depth limit must still parse fine.
+    #[test]
+    fn nested_variable_length_within_depth_limit_ok() {
+        let levels = MAX_DATATYPE_DEPTH as usize - 1;
+        let mut data = Vec::new();
+        for _ in 0..levels {
+            data.extend_from_slice(&build_dt_header(9, 3, [0, 0, 0], 0));
+        }
+        data.extend_from_slice(&build_fixed_point(4, false, false, 0, 32));
+
+        let result = Datatype::parse(&data);
+        assert!(result.is_ok());
+    }
+
     #[test]
     fn test_fixed_point_u8() {
         let data = build_fixed_point(1, false, false, 0, 8);
@@ -1079,6 +1144,156 @@ mod tests {
         }
     }
 
+    /// Real datatype message bytes emitted by h5py 3.16 / HDF5 2.0 with
+    /// *default* libver bounds for [('x','f8'),('y','f8'),('id','i4')]:
+    /// compound datatype version 1 (padded names + 28 bytes of legacy
+    /// per-member array fields).
+    fn compound_v1_bytes() -> Vec<u8> {
+        let f64le: [u8; 20] = [
+            0x11, 0x20, 0x3f, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x34, 0x0b,
+            0x00, 0x34, 0xff, 0x03, 0x00, 0x00,
+        ];
+        let i32le: [u8; 12] = [
+            0x10, 0x08, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
+        ];
+        let mut b = vec![0x16, 0x03, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00];
+        for (name, offset, dt) in [
+            (&b"x"[..], 0u32, &f64le[..]),
+            (&b"y"[..], 8, &f64le[..]),
+            (&b"id"[..], 16, &i32le[..]),
+        ] {
+            let mut padded = name.to_vec();
+            padded.resize((name.len() + 1 + 7) & !7, 0);
+            b.extend_from_slice(&padded);
+            b.extend_from_slice(&offset.to_le_bytes());
+            b.extend_from_slice(&[0u8; 28]);
+            b.extend_from_slice(dt);
+        }
+        b
+    }
+
+    fn assert_xyid_compound(dt: Datatype) {
+        match dt {
+            Datatype::Compound { size, members } => {
+                assert_eq!(size, 20);
+                let got: Vec<(&str, u64, u32)> = members
+                    .iter()
+                    .map(|m| (m.name.as_str(), m.byte_offset, m.datatype.type_size()))
+                    .collect();
+                assert_eq!(got, vec![("x", 0, 8), ("y", 8, 8), ("id", 16, 4)]);
+            }
+            other => panic!("expected Compound, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_compound_v1_default_libver() {
+        let bytes = compound_v1_bytes();
+        let (dt, consumed) = Datatype::parse(&bytes).unwrap();
+        assert_eq!(consumed, bytes.len());
+        assert_xyid_compound(dt);
+    }
+
+    #[test]
+    fn test_compound_v2_padded_names_no_array_fields() {
+        // v2 = v1 without the 28 bytes of per-member array fields; names are
+        // still padded to a multiple of 8 (matches libhdf5's H5O decoder).
+        let v1 = compound_v1_bytes();
+        let mut v2 = vec![0x26, 0x03, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00];
+        let mut pos = 8;
+        for dt_len in [20usize, 20, 12] {
+            v2.extend_from_slice(&v1[pos..pos + 8 + 4]); // padded name + offset
+            pos += 8 + 4 + 28;
+            v2.extend_from_slice(&v1[pos..pos + dt_len]);
+            pos += dt_len;
+        }
+        let (dt, consumed) = Datatype::parse(&v2).unwrap();
+        assert_eq!(consumed, v2.len());
+        assert_xyid_compound(dt);
+    }
+
+    #[test]
+    fn test_compound_v1_truncated_is_error_not_panic() {
+        let bytes = compound_v1_bytes();
+        for cut in 8..bytes.len() {
+            assert!(Datatype::parse(&bytes[..cut]).is_err(), "cut at {cut}");
+        }
+    }
+
+    /// Real datatype message bytes emitted by HDF5 2.0 for the native complex
+    /// type `H5T_COMPLEX_IEEE_F64LE`: class 11, version 5, size 16, followed by
+    /// the base IEEE f64 datatype message.
+    const COMPLEX_F64_HDF5_2_0: [u8; 28] = [
+        0x5b, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x11, 0x20, 0x3f, 0x00, 0x08, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x40, 0x00, 0x34, 0x0b, 0x00, 0x34, 0xff, 0x03, 0x00, 0x00,
+    ];
+
+    #[test]
+    fn test_complex_v5_from_hdf5_2_0() {
+        let (dt, consumed) = Datatype::parse(&COMPLEX_F64_HDF5_2_0).unwrap();
+        assert_eq!(consumed, COMPLEX_F64_HDF5_2_0.len());
+        match dt {
+            Datatype::Compound { size, members } => {
+                assert_eq!(size, 16);
+                assert_eq!(members.len(), 2);
+                assert_eq!((members[0].name.as_str(), members[0].byte_offset), ("r", 0));
+                assert_eq!((members[1].name.as_str(), members[1].byte_offset), ("i", 8));
+                for m in &members {
+                    assert!(matches!(
+                        m.datatype,
+                        Datatype::FloatingPoint { size: 8, .. }
+                    ));
+                }
+            }
+            other => panic!("expected Compound, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_compound_with_complex_member_from_hdf5_2_0() {
+        // Compound { z: complex f64 @0, k: i64 @16 } as written by HDF5 2.0.
+        // Regression guard: the complex member must consume exactly its own
+        // bytes so the following member parses.
+        let mut bytes = vec![
+            0x56, 0x02, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, b'z', 0x00, 0x00,
+        ];
+        bytes.extend_from_slice(&COMPLEX_F64_HDF5_2_0);
+        bytes.extend_from_slice(&[b'k', 0x00, 0x10]);
+        bytes.extend_from_slice(&[
+            0x10, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
+        ]);
+        let (dt, consumed) = Datatype::parse(&bytes).unwrap();
+        assert_eq!(consumed, bytes.len());
+        match dt {
+            Datatype::Compound { size, members } => {
+                assert_eq!(size, 24);
+                assert_eq!(members.len(), 2);
+                assert!(matches!(
+                    &members[0].datatype,
+                    Datatype::Compound { size: 16, members } if members.len() == 2
+                ));
+                assert_eq!(
+                    (members[1].name.as_str(), members[1].byte_offset),
+                    ("k", 16)
+                );
+            }
+            other => panic!("expected Compound, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_complex_size_mismatch_rejected() {
+        let mut bytes = COMPLEX_F64_HDF5_2_0;
+        bytes[4] = 0x0c; // claims 12 bytes, base type is 8
+        assert!(matches!(
+            Datatype::parse(&bytes),
+            Err(FormatError::DataSizeMismatch {
+                expected: 16,
+                actual: 12
+            })
+        ));
+    }
+
     #[test]
     fn test_reference_object() {
         let buf = build_dt_header(7, 1, [0, 0, 0], 8);

crates/clawhdf5-format/src/error.rs

@@ -114,6 +114,20 @@ pub enum FormatError {
     InvalidAttributeInfoVersion(u8),
     /// Invalid shared message version.
     InvalidSharedMessageVersion(u8),
+    /// A message is marked shared but was parsed without access to the file,
+    /// so the reference to the real message could not be followed.
+    UnresolvedSharedMessage,
+    /// The dataset's raw data is stored in external files (External Data
+    /// Files message), which this reader does not follow.
+    ExternalDataFilesUnsupported,
+    /// The path goes through an external link (a link into another file),
+    /// which this reader does not follow.
+    ExternalLinkUnsupported {
+        /// The file the link points into.
+        filename: String,
+        /// The object path within that file.
+        object_path: String,
+    },
     /// Invalid SOHM table version.
     InvalidSohmTableVersion(u8),
     /// Invalid SOHM table signature (expected "SMTB").
@@ -307,6 +321,22 @@ impl fmt::Display for FormatError {
             FormatError::InvalidSharedMessageVersion(v) => {
                 write!(f, "invalid shared message version: {v}")
             }
+            FormatError::ExternalLinkUnsupported {
+                filename,
+                object_path,
+            } => write!(
+                f,
+                "path goes through an external link to {object_path} in {filename}, which is \
+                 not supported"
+            ),
+            FormatError::ExternalDataFilesUnsupported => write!(
+                f,
+                "dataset raw data is stored in external file(s), which is not supported"
+            ),
+            FormatError::UnresolvedSharedMessage => write!(
+                f,
+                "message is shared but no file data was available to resolve it"
+            ),
             FormatError::InvalidSohmTableVersion(v) => {
                 write!(f, "invalid SOHM table version: {v}")
             }

crates/clawhdf5-format/src/extensible_array.rs

@@ -54,6 +54,19 @@ fn read_offset(data: &[u8], pos: usize, size: u8) -> Result<u64, FormatError> {
     })
 }
 
+fn ensure_len(data: &[u8], offset: usize, needed: usize) -> Result<(), FormatError> {
+    if offset
+        .checked_add(needed)
+        .is_none_or(|end| end > data.len())
+    {
+        return Err(FormatError::UnexpectedEof {
+            expected: offset.saturating_add(needed),
+            available: data.len(),
+        });
+    }
+    Ok(())
+}
+
 fn is_undefined_addr(addr: u64, offset_size: u8) -> bool {
     match offset_size {
         2 => addr == 0xFFFF,
@@ -98,12 +111,7 @@ impl ExtensibleArrayHeader {
         //   6 stats fields (each length_size) + index_block_address(offset_size) + checksum(4)
         let min_size =
             4 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 6 * length_size as usize + offset_size as usize + 4;
-        if offset + min_size > file_data.len() {
+        ensure_len(file_data, offset, min_size)?;
-            return Err(FormatError::UnexpectedEof {
-                expected: offset + min_size,
-                available: file_data.len(),
-            });
-        }
 
         let d = &file_data[offset..];
         if &d[0..4] != b"EAHD" {
@@ -275,12 +283,7 @@ fn read_data_block_elements(
 ) -> Result<Vec<ChunkInfo>, FormatError> {
     // AEDB: signature(4) + version(1) + client_id(1) + header_address(offset_size)
     let db_header_size = 4 + 1 + 1 + offset_size as usize;
-    if db_offset + db_header_size > file_data.len() {
+    ensure_len(file_data, db_offset, db_header_size)?;
-        return Err(FormatError::UnexpectedEof {
-            expected: db_offset + db_header_size,
-            available: file_data.len(),
-        });
-    }
 
     let d = &file_data[db_offset..];
     if &d[0..4] != b"EADB" {
@@ -427,12 +430,7 @@ pub fn read_extensible_array_chunks(
     // Parse index block (AEIB)
     let ib_offset = header.index_block_address as usize;
     let ib_header_size = 4 + 1 + 1 + offset_size as usize; // sig + ver + client + hdr_addr
-    if ib_offset + ib_header_size > file_data.len() {
+    ensure_len(file_data, ib_offset, ib_header_size)?;
-        return Err(FormatError::UnexpectedEof {
-            expected: ib_offset + ib_header_size,
-            available: file_data.len(),
-        });
-    }
 
     let ib = &file_data[ib_offset..];
     if &ib[0..4] != b"EAIB" {
@@ -628,12 +626,7 @@ fn read_super_block(
 
     // AESB: signature(4) + version(1) + client_id(1) + header_address(offset_size)
     let sb_header_size = 4 + 1 + 1 + os;
-    if sb_offset + sb_header_size > file_data.len() {
+    ensure_len(file_data, sb_offset, sb_header_size)?;
-        return Err(FormatError::UnexpectedEof {
-            expected: sb_offset + sb_header_size,
-            available: file_data.len(),
-        });
-    }
 
     if &file_data[sb_offset..sb_offset + 4] != b"EASB" {
         return Err(FormatError::ChunkedReadError(
@@ -759,6 +752,33 @@ mod tests {
         assert!(result.is_err());
     }
 
+    /// A near-`usize::MAX` offset must error cleanly, not overflow/panic.
+    #[test]
+    fn parse_rejects_offset_overflow() {
+        let buf = vec![0u8; 64];
+        let result = ExtensibleArrayHeader::parse(&buf, usize::MAX - 4, 8, 8);
+        assert!(result.is_err());
+    }
+
+    /// A near-`usize::MAX` index block address must error cleanly, not overflow/panic.
+    #[test]
+    fn read_rejects_index_block_offset_overflow() {
+        let header = ExtensibleArrayHeader {
+            client_id: 0,
+            element_size: 8,
+            max_nelmts_bits: 10,
+            idx_blk_elmts: 2,
+            min_dblk_nelmts: 4,
+            super_blk_min_nelmts: 2,
+            max_dblk_nelmts_bits: 8,
+            num_elements: 5,
+            index_block_address: (usize::MAX - 4) as u64,
+        };
+        let buf = vec![0u8; 64];
+        let r = read_extensible_array_chunks(&buf, &header, &[100], &[20], 8, 8, 8);
+        assert!(r.is_err());
+    }
+
     #[test]
     fn parse_header_invalid_version() {
         let mut buf = vec![0u8; 256];

crates/clawhdf5-format/src/fill_value.rs

@@ -0,0 +1,407 @@
+//! Fill Value messages (0x0005, and the old 0x0004) and applying them on read.
+//!
+//! HDF5 allocates storage lazily: a chunk nobody wrote to does not exist in the
+//! file, and a contiguous dataset nobody wrote to has no data address at all.
+//! Reading such a region must yield the dataset's *fill value* (zeros unless
+//! the creator chose otherwise). The readers in [`crate::chunked_read`] leave
+//! those regions zeroed; [`apply_to_unallocated_chunks`] then overwrites exactly
+//! the chunk-grid cells that are absent from the chunk index — so it can never
+//! mistake a stored zero for a hole — and is skipped entirely in the common
+//! case of a zero fill value.
+
+#[cfg(not(feature = "std"))]
+use alloc::{format, vec, vec::Vec};
+
+use crate::chunked_read::{alloc_output, checked_byte_len, list_chunks};
+use crate::data_layout::DataLayout;
+use crate::dataspace::Dataspace;
+use crate::error::FormatError;
+use crate::message_type::MessageType;
+use crate::object_header::HeaderMessage;
+
+/// Largest fill value accepted. A fill value is one element of the dataset's
+/// datatype; this only bounds the allocation driven by the message's size field.
+const MAX_FILL_VALUE_SIZE: usize = 1 << 20;
+
+/// Parse a Fill Value message, returning the user-defined fill value bytes, or
+/// `None` when the dataset uses the default (all zeros) or has the fill value
+/// explicitly undefined.
+pub fn parse_fill_value(msg: &HeaderMessage) -> Result<Option<Vec<u8>>, FormatError> {
+    let data = msg.data.as_slice();
+    let value_at = |pos: usize| -> Result<Option<Vec<u8>>, FormatError> {
+        let size_bytes = data.get(pos..pos + 4).ok_or(FormatError::UnexpectedEof {
+            expected: pos + 4,
+            available: data.len(),
+        })?;
+        let size = u32::from_le_bytes([size_bytes[0], size_bytes[1], size_bytes[2], size_bytes[3]])
+            as usize;
+        if size == 0 {
+            return Ok(None);
+        }
+        if size > MAX_FILL_VALUE_SIZE {
+            return Err(FormatError::Overflow(format!(
+                "fill value of {size} bytes exceeds the {MAX_FILL_VALUE_SIZE}-byte limit"
+            )));
+        }
+        let start = pos + 4;
+        let value =
+            data.get(start..start.saturating_add(size))
+                .ok_or(FormatError::UnexpectedEof {
+                    expected: start.saturating_add(size),
+                    available: data.len(),
+                })?;
+        Ok(Some(value.to_vec()))
+    };
+
+    match msg.msg_type {
+        // Old fill value message: size(4), value.
+        MessageType::FillValueOld => value_at(0),
+        MessageType::FillValue => {
+            let version = *data.first().ok_or(FormatError::UnexpectedEof {
+                expected: 1,
+                available: 0,
+            })?;
+            match version {
+                // version, alloc time, write time, defined, [size, value]
+                1 | 2 => {
+                    let defined = *data.get(3).ok_or(FormatError::UnexpectedEof {
+                        expected: 4,
+                        available: data.len(),
+                    })?;
+                    if version == 2 && defined == 0 {
+                        Ok(None)
+                    } else if data.len() < 8 && version == 1 {
+                        // v1 always carries a size, but tolerate its absence.
+                        Ok(None)
+                    } else {
+                        value_at(4)
+                    }
+                }
+                // version, flags (bit 4 = undefined, bit 5 = defined), [size, value]
+                3 => {
+                    let flags = *data.get(1).ok_or(FormatError::UnexpectedEof {
+                        expected: 2,
+                        available: data.len(),
+                    })?;
+                    if flags & 0x10 != 0 || flags & 0x20 == 0 {
+                        Ok(None)
+                    } else {
+                        value_at(2)
+                    }
+                }
+                v => Err(FormatError::UnsupportedVersion(v)),
+            }
+        }
+        _ => Ok(None),
+    }
+}
+
+/// The fill value that applies to a dataset given its header messages. The new
+/// message wins over the old one when both are present.
+pub fn dataset_fill_value(messages: &[HeaderMessage]) -> Result<Option<Vec<u8>>, FormatError> {
+    for wanted in [MessageType::FillValue, MessageType::FillValueOld] {
+        if let Some(msg) = messages.iter().find(|m| m.msg_type == wanted) {
+            if crate::shared_message::is_shared(msg.flags) {
+                // A shared fill value is legal but vanishingly rare; treat it
+                // as the default rather than misparsing the reference.
+                return Ok(None);
+            }
+            if let Some(value) = parse_fill_value(msg)? {
+                return Ok(Some(value));
+            }
+        }
+    }
+    Ok(None)
+}
+
+/// `true` when a fill value is absent or all zeros, i.e. identical to what the
+/// readers already produce for unallocated storage.
+pub fn is_default(fill: Option<&[u8]>) -> bool {
+    fill.is_none_or(|f| f.iter().all(|&b| b == 0))
+}
+
+/// A whole dataset's worth of fill value: what reading a dataset with no
+/// allocated storage at all must return.
+pub fn filled_dataset(
+    dataspace: &Dataspace,
+    elem_size: usize,
+    fill: Option<&[u8]>,
+) -> Result<Vec<u8>, FormatError> {
+    let total = checked_byte_len(dataspace.checked_num_elements()?, elem_size)?;
+    let mut out = alloc_output(total)?;
+    if let Some(fill) = fill.filter(|f| f.len() == elem_size && !is_default(Some(f))) {
+        for element in out.chunks_exact_mut(elem_size) {
+            element.copy_from_slice(fill);
+        }
+    }
+    Ok(out)
+}
+
+/// Whether the layout has any storage in the file at all. A dataset that was
+/// created but never written to has none.
+pub fn has_storage(layout: &DataLayout) -> bool {
+    !matches!(
+        layout,
+        DataLayout::Contiguous { address: None, .. }
+            | DataLayout::Chunked {
+                btree_address: None,
+                ..
+            }
+    )
+}
+
+/// Run a full-dataset `read`, giving unallocated storage its fill value: a
+/// dataset with no storage at all reads as entirely fill value (instead of
+/// failing), and a chunked dataset has the fill value written into every
+/// chunk the file never allocated.
+#[allow(clippy::too_many_arguments)]
+pub fn read_full_with_fill<E: From<FormatError>>(
+    messages: &[HeaderMessage],
+    file_data: &[u8],
+    layout: &DataLayout,
+    dataspace: &Dataspace,
+    elem_size: usize,
+    offset_size: u8,
+    length_size: u8,
+    read: impl FnOnce() -> Result<Vec<u8>, E>,
+) -> Result<Vec<u8>, E> {
+    // A dataset with external raw data also has no data address in this
+    // file. It is NOT unallocated — its values live elsewhere — so it must
+    // never be answered with the fill value.
+    if messages
+        .iter()
+        .any(|m| m.msg_type == MessageType::ExternalDataFiles)
+    {
+        return Err(FormatError::ExternalDataFilesUnsupported.into());
+    }
+    let fill = dataset_fill_value(messages)?;
+    if !has_storage(layout) {
+        return Ok(filled_dataset(dataspace, elem_size, fill.as_deref())?);
+    }
+    let mut output = read()?;
+    apply_to_unallocated_chunks(
+        &mut output,
+        file_data,
+        layout,
+        dataspace,
+        elem_size,
+        fill.as_deref(),
+        offset_size,
+        length_size,
+    )?;
+    Ok(output)
+}
+
+/// Overwrite, in a fully read chunked dataset `output`, every region whose
+/// chunk was never allocated with `fill`. No-op for non-chunked layouts, a
+/// default fill value, or a fill value whose size doesn't match the element.
+#[allow(clippy::too_many_arguments)]
+pub fn apply_to_unallocated_chunks(
+    output: &mut [u8],
+    file_data: &[u8],
+    layout: &DataLayout,
+    dataspace: &Dataspace,
+    elem_size: usize,
+    fill: Option<&[u8]>,
+    offset_size: u8,
+    length_size: u8,
+) -> Result<(), FormatError> {
+    let Some(fill) = fill.filter(|f| f.len() == elem_size && !is_default(Some(f))) else {
+        return Ok(());
+    };
+    if !matches!(layout, DataLayout::Chunked { .. }) || elem_size == 0 {
+        return Ok(());
+    }
+    let (chunks, chunk_dims) = list_chunks(
+        file_data,
+        layout,
+        dataspace,
+        elem_size,
+        offset_size,
+        length_size,
+    )?;
+    let rank = chunk_dims.len();
+    let ds_dims: Vec<usize> = dataspace.dimensions.iter().map(|&d| d as usize).collect();
+    if rank == 0 || ds_dims.len() != rank || chunk_dims.contains(&0) {
+        return Ok(());
+    }
+
+    // Row-major strides over the dataset and over the chunk grid.
+    let mut ds_strides = vec![1usize; rank];
+    for i in (0..rank - 1).rev() {
+        ds_strides[i] = ds_strides[i + 1].saturating_mul(ds_dims[i + 1]);
+    }
+    let grid: Vec<usize> = ds_dims
+        .iter()
+        .zip(&chunk_dims)
+        .map(|(&d, &c)| d.div_ceil(c))
+        .collect();
+    let cells = grid
+        .iter()
+        .try_fold(1usize, |acc, &g| acc.checked_mul(g))
+        .ok_or_else(|| FormatError::Overflow("chunk grid size overflows".into()))?;
+    if cells == 0 {
+        return Ok(());
+    }
+
+    let mut allocated = vec![false; cells];
+    for chunk in &chunks {
+        // Undefined address: the index has a slot for the chunk but no storage.
+        if chunk.address == u64::MAX || chunk.offsets.len() < rank {
+            continue;
+        }
+        let mut cell = 0usize;
+        let mut in_range = true;
+        for d in 0..rank {
+            let coord = chunk.offsets[d] as usize / chunk_dims[d];
+            if coord >= grid[d] {
+                in_range = false;
+                break;
+            }
+            cell = cell * grid[d] + coord;
+        }
+        if in_range {
+            allocated[cell] = true;
+        }
+    }
+
+    let mut coord = vec![0usize; rank];
+    for (cell, is_allocated) in allocated.iter().enumerate() {
+        if *is_allocated {
+            continue;
+        }
+        // Decode the cell index into grid coordinates.
+        let mut rem = cell;
+        for d in (0..rank).rev() {
+            coord[d] = rem % grid[d];
+            rem /= grid[d];
+        }
+        fill_cell(
+            output,
+            &coord,
+            &chunk_dims,
+            &ds_dims,
+            &ds_strides,
+            elem_size,
+            fill,
+        );
+    }
+    Ok(())
+}
+
+/// Fill the part of chunk-grid cell `coord` that lies inside the dataset.
+fn fill_cell(
+    output: &mut [u8],
+    coord: &[usize],
+    chunk_dims: &[usize],
+    ds_dims: &[usize],
+    ds_strides: &[usize],
+    elem_size: usize,
+    fill: &[u8],
+) {
+    let rank = coord.len();
+    let start: Vec<usize> = (0..rank).map(|d| coord[d] * chunk_dims[d]).collect();
+    let end: Vec<usize> = (0..rank)
+        .map(|d| (start[d] + chunk_dims[d]).min(ds_dims[d]))
+        .collect();
+    if (0..rank).any(|d| start[d] >= end[d]) {
+        return;
+    }
+    // Walk every row (all dims but the last) and fill the run along the last.
+    let run = end[rank - 1] - start[rank - 1];
+    let mut idx = start.clone();
+    loop {
+        let first: usize = (0..rank).map(|d| idx[d] * ds_strides[d]).sum();
+        let from = first * elem_size;
+        let to = from + run * elem_size;
+        if let Some(region) = output.get_mut(from..to) {
+            for element in region.chunks_exact_mut(elem_size) {
+                element.copy_from_slice(fill);
+            }
+        }
+        // Advance the odometer over dims 0..rank-1.
+        let mut d = rank - 1;
+        loop {
+            if d == 0 {
+                return;
+            }
+            d -= 1;
+            idx[d] += 1;
+            if idx[d] < end[d] {
+                break;
+            }
+            idx[d] = start[d];
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn msg(msg_type: MessageType, data: &[u8]) -> HeaderMessage {
+        HeaderMessage {
+            msg_type,
+            size: data.len(),
+            flags: 0,
+            creation_order: None,
+            data: data.to_vec(),
+        }
+    }
+
+    #[test]
+    fn parses_v3_defined_undefined_and_default() {
+        // Real message for h5py `fillvalue=-1` on an i4 dataset (HDF5 2.0).
+        let defined = msg(
+            MessageType::FillValue,
+            &[3, 0x2b, 4, 0, 0, 0, 0xff, 0xff, 0xff, 0xff],
+        );
+        assert_eq!(parse_fill_value(&defined).unwrap(), Some(vec![0xff; 4]));
+        let default = msg(MessageType::FillValue, &[3, 0x0a]);
+        assert_eq!(parse_fill_value(&default).unwrap(), None);
+        let undefined = msg(MessageType::FillValue, &[3, 0x19]);
+        assert_eq!(parse_fill_value(&undefined).unwrap(), None);
+    }
+
+    #[test]
+    fn parses_v2_and_old_messages() {
+        let v2 = msg(MessageType::FillValue, &[2, 2, 2, 1, 2, 0, 0, 0, 7, 0]);
+        assert_eq!(parse_fill_value(&v2).unwrap(), Some(vec![7, 0]));
+        let v2_undefined = msg(MessageType::FillValue, &[2, 2, 2, 0]);
+        assert_eq!(parse_fill_value(&v2_undefined).unwrap(), None);
+        let old = msg(MessageType::FillValueOld, &[2, 0, 0, 0, 9, 9]);
+        assert_eq!(parse_fill_value(&old).unwrap(), Some(vec![9, 9]));
+    }
+
+    #[test]
+    fn truncated_or_oversized_fill_is_an_error() {
+        let short = msg(MessageType::FillValue, &[3, 0x29, 4, 0, 0, 0, 0xff]);
+        assert!(parse_fill_value(&short).is_err());
+        let huge = msg(MessageType::FillValue, &[3, 0x29, 0xff, 0xff, 0xff, 0x7f]);
+        assert!(matches!(
+            parse_fill_value(&huge),
+            Err(FormatError::Overflow(_))
+        ));
+    }
+
+    #[test]
+    fn fill_cell_clips_edge_chunks_in_2d() {
+        // 3x5 dataset, 2x2 chunks; fill grid cell (1, 2): rows 2..3, cols 4..5.
+        let mut out = vec![0u8; 15];
+        fill_cell(&mut out, &[1, 2], &[2, 2], &[3, 5], &[5, 1], 1, &[9]);
+        let mut expected = vec![0u8; 15];
+        expected[2 * 5 + 4] = 9;
+        assert_eq!(out, expected);
+
+        // Interior cell (0, 1): rows 0..2, cols 2..4.
+        let mut out = vec![0u8; 15];
+        fill_cell(&mut out, &[0, 1], &[2, 2], &[3, 5], &[5, 1], 1, &[7]);
+        let filled: Vec<usize> = out
+            .iter()
+            .enumerate()
+            .filter(|(_, b)| **b == 7)
+            .map(|(i, _)| i)
+            .collect();
+        assert_eq!(filled, [2, 3, 7, 8]);
+    }
+}

crates/clawhdf5-format/src/filters.rs

@@ -1045,24 +1045,30 @@ fn pcodec_compress(data: &[u8], element_size: usize) -> Result<Vec<u8>, FormatEr
     match element_size {
         4 => {
             let nums: Vec<f32> = data
-                .chunks_exact(4)
+                .as_chunks::<4>()
-                .map(|b| f32::from_le_bytes(b.try_into().unwrap()))
+                .0
+                .iter()
+                .map(|b| f32::from_le_bytes(*b))
                 .collect();
             simple_compress(&nums, &config)
                 .map_err(|e| FormatError::CompressionError(format!("pco: {e}")))
         }
         8 => {
             let nums: Vec<f64> = data
-                .chunks_exact(8)
+                .as_chunks::<8>()
-                .map(|b| f64::from_le_bytes(b.try_into().unwrap()))
+                .0
+                .iter()
+                .map(|b| f64::from_le_bytes(*b))
                 .collect();
             simple_compress(&nums, &config)
                 .map_err(|e| FormatError::CompressionError(format!("pco: {e}")))
         }
         _ => {
             let nums: Vec<u32> = data
-                .chunks_exact(4)
+                .as_chunks::<4>()
-                .map(|b| u32::from_le_bytes(b.try_into().unwrap()))
+                .0
+                .iter()
+                .map(|b| u32::from_le_bytes(*b))
                 .collect();
             simple_compress(&nums, &config)
                 .map_err(|e| FormatError::CompressionError(format!("pco: {e}")))
@@ -1092,11 +1098,7 @@ fn pcodec_decompress(
     } else {
         MAX_DECOMPRESS_SIZE
     };
-    let n = if element_size != 0 {
+    let n = limit_bytes.checked_div(element_size).unwrap_or(0);
-        limit_bytes / element_size
-    } else {
-        0
-    };
     match element_size {
         4 => {
             let mut buf = vec![0f32; n];
@@ -1543,8 +1545,10 @@ mod tests {
 
     fn as_f32(bytes: &[u8]) -> Vec<f32> {
         bytes
-            .chunks_exact(4)
+            .as_chunks::<4>()
-            .map(|c| f32::from_le_bytes(c.try_into().unwrap()))
+            .0
+            .iter()
+            .map(|c| f32::from_le_bytes(*c))
             .collect()
     }
 
@@ -1578,8 +1582,10 @@ mod tests {
 
     fn as_f64(bytes: &[u8]) -> Vec<f64> {
         bytes
-            .chunks_exact(8)
+            .as_chunks::<8>()
-            .map(|c| f64::from_le_bytes(c.try_into().unwrap()))
+            .0
+            .iter()
+            .map(|c| f64::from_le_bytes(*c))
             .collect()
     }
 

crates/clawhdf5-format/src/fixed_array.rs

@@ -47,6 +47,19 @@ fn read_length(data: &[u8], pos: usize, size: u8) -> Result<u64, FormatError> {
     read_offset(data, pos, size)
 }
 
+fn ensure_len(data: &[u8], offset: usize, needed: usize) -> Result<(), FormatError> {
+    if offset
+        .checked_add(needed)
+        .is_none_or(|end| end > data.len())
+    {
+        return Err(FormatError::UnexpectedEof {
+            expected: offset.saturating_add(needed),
+            available: data.len(),
+        });
+    }
+    Ok(())
+}
+
 fn is_undefined(data: &[u8], pos: usize, size: u8) -> bool {
     let s = size as usize;
     if pos + s > data.len() {
@@ -66,12 +79,7 @@ impl FixedArrayHeader {
         // FAHD signature(4) + version(1) + client_id(1) + element_size(1) +
         // max_nelmts_bits(1) + num_elements(length_size) + data_block_addr(offset_size) + checksum(4)
         let min_size = 4 + 1 + 1 + 1 + 1 + length_size as usize + offset_size as usize + 4;
-        if offset + min_size > file_data.len() {
+        ensure_len(file_data, offset, min_size)?;
-            return Err(FormatError::UnexpectedEof {
-                expected: offset + min_size,
-                available: file_data.len(),
-            });
-        }
 
         let d = &file_data[offset..];
         if &d[0..4] != b"FAHD" {
@@ -126,12 +134,7 @@ pub fn read_fixed_array_chunks(
 
     // Parse data block header: FADB(4) + version(1) + client_id(1) + header_address(offset_size)
     let db_header_size = 4 + 1 + 1 + offset_size as usize;
-    if db_offset + db_header_size > file_data.len() {
+    ensure_len(file_data, db_offset, db_header_size)?;
-        return Err(FormatError::UnexpectedEof {
-            expected: db_offset + db_header_size,
-            available: file_data.len(),
-        });
-    }
 
     let d = &file_data[db_offset..];
     if &d[0..4] != b"FADB" {
@@ -489,6 +492,29 @@ mod tests {
         assert!(r.is_err());
     }
 
+    /// A near-`usize::MAX` offset must error cleanly, not overflow/panic.
+    #[test]
+    fn parse_rejects_offset_overflow() {
+        let buf = vec![0u8; 64];
+        let result = FixedArrayHeader::parse(&buf, usize::MAX - 4, 8, 8);
+        assert!(result.is_err());
+    }
+
+    /// A near-`usize::MAX` data block address must error cleanly, not overflow/panic.
+    #[test]
+    fn read_rejects_data_block_offset_overflow() {
+        let header = FixedArrayHeader {
+            client_id: 0,
+            element_size: 8,
+            max_nelmts_bits: 10,
+            num_elements: 1,
+            data_block_address: (usize::MAX - 4) as u64,
+        };
+        let buf = vec![0u8; 64];
+        let r = read_fixed_array_chunks(&buf, &header, &[100], &[20], 8, 8, 8);
+        assert!(r.is_err());
+    }
+
     #[test]
     fn parse_fixed_array_header_invalid_version() {
         let mut buf = vec![0u8; 256];

crates/clawhdf5-format/src/global_heap.rs

@@ -184,9 +184,7 @@ mod tests {
             buf.extend_from_slice(data);
             // Pad to 8 bytes
             let padded = pad8(data.len());
-            for _ in data.len()..padded {
+            buf.resize(buf.len() + (padded - data.len()), 0);
-                buf.push(0);
-            }
         }
 
         // Free space marker

crates/clawhdf5-format/src/group_v1.rs

@@ -60,6 +60,54 @@ pub fn resolve_v1_group_entries(
     Ok(entries)
 }
 
+/// Symbol table cache type for a soft link: the scratch pad's first four bytes
+/// are the local-heap offset of the link's target path, and the entry's object
+/// header address is undefined.
+const CACHE_TYPE_SOFT_LINK: u32 = 2;
+
+/// The target path of the soft link called `name` in a v1 group, if any.
+pub fn find_v1_soft_link(
+    file_data: &[u8],
+    sym_table_msg: &SymbolTableMessage,
+    name: &str,
+    offset_size: u8,
+    length_size: u8,
+) -> Result<Option<String>, FormatError> {
+    let heap = LocalHeap::parse(
+        file_data,
+        sym_table_msg.local_heap_address as usize,
+        offset_size,
+        length_size,
+    )?;
+    let snod_addrs = collect_symbol_table_nodes(
+        file_data,
+        sym_table_msg.btree_address,
+        offset_size,
+        length_size,
+    )?;
+    for snod_addr in snod_addrs {
+        let snod = SymbolTableNode::parse(file_data, snod_addr as usize, offset_size)?;
+        for entry in &snod.entries {
+            if entry.cache_type != CACHE_TYPE_SOFT_LINK {
+                continue;
+            }
+            if heap.read_string(file_data, entry.link_name_offset)? != name {
+                continue;
+            }
+            let value_offset = u32::from_le_bytes([
+                entry.scratch_pad[0],
+                entry.scratch_pad[1],
+                entry.scratch_pad[2],
+                entry.scratch_pad[3],
+            ]);
+            return heap
+                .read_string(file_data, u64::from(value_offset))
+                .map(Some);
+        }
+    }
+    Ok(None)
+}
+
 /// Extract the SymbolTableMessage from an object header's messages.
 fn find_symbol_table_message(
     obj_header: &ObjectHeader,

crates/clawhdf5-format/src/group_v2.rs

@@ -63,14 +63,15 @@ fn resolve_compact_entries(
     Ok(entries)
 }
 
-/// Resolve entries from dense storage (fractal heap + B-tree v2).
+/// Visit every link in dense storage (fractal heap + B-tree v2 name index).
-fn resolve_dense_entries(
+fn for_each_dense_link(
     file_data: &[u8],
     link_info: &LinkInfoMessage,
     fh_addr: u64,
     offset_size: u8,
     length_size: u8,
-) -> Result<Vec<GroupEntry>, FormatError> {
+    mut visit: impl FnMut(LinkMessage),
+) -> Result<(), FormatError> {
     // Parse fractal heap
     let fh = FractalHeapHeader::parse(file_data, fh_addr as usize, offset_size, length_size)?;
 
@@ -81,7 +82,6 @@ fn resolve_dense_entries(
     let btree_hdr = BTreeV2Header::parse(file_data, btree_addr as usize, offset_size, length_size)?;
     let records = collect_btree_v2_records(file_data, &btree_hdr, offset_size, length_size)?;
 
-    let mut entries = Vec::new();
     for record in &records {
         // For type 5 (name index): hash(4) + heap_id(heap_id_length)
         // For type 6 (creation order): creation_order(8) + heap_id(heap_id_length)
@@ -98,22 +98,94 @@ fn resolve_dense_entries(
 
         // Read managed object from fractal heap
         let link_data = fh.read_managed_object(file_data, id_bytes, offset_size)?;
+        visit(LinkMessage::parse(&link_data, offset_size)?);
+    }
+    Ok(())
+}
 
-        // Parse as Link message
+/// Resolve entries from dense storage (fractal heap + B-tree v2).
-        let link = LinkMessage::parse(&link_data, offset_size)?;
+fn resolve_dense_entries(
-        if let LinkTarget::Hard {
+    file_data: &[u8],
-            object_header_address,
+    link_info: &LinkInfoMessage,
-        } = link.link_target
+    fh_addr: u64,
-        {
+    offset_size: u8,
-            entries.push(GroupEntry {
+    length_size: u8,
-                name: link.name,
+) -> Result<Vec<GroupEntry>, FormatError> {
+    let mut entries = Vec::new();
+    for_each_dense_link(
+        file_data,
+        link_info,
+        fh_addr,
+        offset_size,
+        length_size,
+        |link| {
+            if let LinkTarget::Hard {
                 object_header_address,
-                cache_type: 0,
+            } = link.link_target
-            });
+            {
+                entries.push(GroupEntry {
+                    name: link.name,
+                    object_header_address,
+                    cache_type: 0,
+                });
+            }
+        },
+    )?;
+    Ok(entries)
+}
+
+/// The soft or external link called `name` in this group, if there is one.
+/// Hard links are what `resolve_group_entries` returns; this is consulted only
+/// when a path component isn't among them.
+fn find_symbolic_link(
+    file_data: &[u8],
+    object_header: &ObjectHeader,
+    name: &str,
+    offset_size: u8,
+    length_size: u8,
+) -> Result<Option<LinkTarget>, FormatError> {
+    if is_v1_group(object_header) {
+        let Some(sym_msg) = object_header
+            .messages
+            .iter()
+            .find(|m| m.msg_type == MessageType::SymbolTable)
+        else {
+            return Ok(None);
+        };
+        let stm = SymbolTableMessage::parse(&sym_msg.data, offset_size)?;
+        return group_v1::find_v1_soft_link(file_data, &stm, name, offset_size, length_size)
+            .map(|target| target.map(|target_path| LinkTarget::Soft { target_path }));
+    }
+    if !is_v2_group(object_header) {
+        return Ok(None);
+    }
+    let is_symbolic = |t: &LinkTarget| !matches!(t, LinkTarget::Hard { .. });
+    let link_info = find_link_info(object_header, offset_size)?;
+    let mut found = None;
+    if let Some(fh_addr) = link_info.fractal_heap_address {
+        for_each_dense_link(
+            file_data,
+            &link_info,
+            fh_addr,
+            offset_size,
+            length_size,
+            |link| {
+                if link.name == name && is_symbolic(&link.link_target) {
+                    found = Some(link.link_target);
+                }
+            },
+        )?;
+    } else {
+        for msg in &object_header.messages {
+            if msg.msg_type == MessageType::Link {
+                let link = LinkMessage::parse(&msg.data, offset_size)?;
+                if link.name == name && is_symbolic(&link.link_target) {
+                    found = Some(link.link_target);
+                }
+            }
         }
     }
-
+    Ok(found)
-    Ok(entries)
 }
 
 /// Find and parse the Link Info message from an object header.
@@ -158,6 +230,19 @@ pub fn resolve_path_any(
     file_data: &[u8],
     superblock: &Superblock,
     path: &str,
+) -> Result<u64, FormatError> {
+    resolve_path_following_links(file_data, superblock, path, 0)
+}
+
+/// Soft links followed while resolving one path. Guards against link cycles
+/// (`a -> b -> a`), which are legal to create.
+const MAX_SOFT_LINK_DEPTH: u8 = 16;
+
+fn resolve_path_following_links(
+    file_data: &[u8],
+    superblock: &Superblock,
+    path: &str,
+    depth: u8,
 ) -> Result<u64, FormatError> {
     let components: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
     if components.is_empty() {
@@ -176,7 +261,9 @@ pub fn resolve_path_any(
     for (i, component) in components.iter().enumerate() {
         let entries = resolve_group_entries(file_data, &current_header, os, ls)?;
 
-        let found = entries.iter().find(|e| e.name == *component);
+        let found = entries
+            .iter()
+            .find(|e| e.name == *component && e.object_header_address != u64::MAX);
         match found {
             Some(entry) => {
                 if i == components.len() - 1 {
@@ -186,7 +273,37 @@ pub fn resolve_path_any(
                 current_header = ObjectHeader::parse(file_data, current_addr as usize, os, ls)?;
             }
             None => {
-                return Err(FormatError::PathNotFound(String::from(*component)));
+                return match find_symbolic_link(file_data, &current_header, component, os, ls)? {
+                    Some(LinkTarget::Soft { target_path }) => {
+                        if depth >= MAX_SOFT_LINK_DEPTH {
+                            return Err(FormatError::NestingDepthExceeded);
+                        }
+                        // A relative target is relative to the group holding
+                        // the link; then the rest of the original path.
+                        let mut full = String::new();
+                        if !target_path.starts_with('/') {
+                            for parent in &components[..i] {
+                                full.push('/');
+                                full.push_str(parent);
+                            }
+                        }
+                        full.push('/');
+                        full.push_str(&target_path);
+                        for rest in &components[i + 1..] {
+                            full.push('/');
+                            full.push_str(rest);
+                        }
+                        resolve_path_following_links(file_data, superblock, &full, depth + 1)
+                    }
+                    Some(LinkTarget::External {
+                        filename,
+                        object_path,
+                    }) => Err(FormatError::ExternalLinkUnsupported {
+                        filename,
+                        object_path,
+                    }),
+                    _ => Err(FormatError::PathNotFound(String::from(*component))),
+                };
             }
         }
     }

crates/clawhdf5-format/src/lib.rs

@@ -67,6 +67,7 @@ pub mod ea_writer;
 pub mod error;
 pub mod extensible_array;
 pub mod file_writer;
+pub mod fill_value;
 pub mod filter_pipeline;
 pub mod filters;
 mod filters_szip;

crates/clawhdf5-format/src/link_message.rs

@@ -413,11 +413,8 @@ mod tests {
     #[test]
     fn soft_link() {
         let target = "/group1/dataset";
-        let mut data = Vec::new();
+        // version, flags (bit 3 = link type present, name size = 1 byte), link type = soft, name length = 4
-        data.push(1); // version
+        let mut data = vec![1, 0x08, 1, 4];
-        data.push(0x08); // flags: bit 3 = link type present, name size = 1 byte (bits 0-1 = 0)
-        data.push(1); // link type = soft
-        data.push(4); // name length = 4
         data.extend_from_slice(b"link");
         data.extend_from_slice(&(target.len() as u16).to_le_bytes());
         data.extend_from_slice(target.as_bytes());
@@ -455,12 +452,8 @@ mod tests {
 
     #[test]
     fn invalid_link_type() {
-        let mut data = Vec::new();
+        // version, flags (bit 3 = link type present), invalid link type = 99, name length = 1, name = 'x'
-        data.push(1); // version
+        let data = vec![1, 0x08, 99, 1, b'x'];
-        data.push(0x08); // flags: bit 3 = link type present
-        data.push(99); // invalid link type
-        data.push(1); // name length = 1
-        data.push(b'x');
         let err = LinkMessage::parse(&data, 8).unwrap_err();
         assert_eq!(err, FormatError::InvalidLinkType(99));
     }

crates/clawhdf5-format/src/message_type.rs

@@ -9,6 +9,9 @@ pub enum MessageType {
     Datatype,
     FillValueOld,
     FillValue,
+    /// External Data Files (0x0007): the dataset's raw data lives in other
+    /// files, listed by this message.
+    ExternalDataFiles,
     Link,
     DataLayout,
     GroupInfo,
@@ -36,6 +39,7 @@ impl MessageType {
             0x0004 => MessageType::FillValueOld,
             0x0005 => MessageType::FillValue,
             0x0006 => MessageType::Link,
+            0x0007 => MessageType::ExternalDataFiles,
             0x0008 => MessageType::DataLayout,
             0x000A => MessageType::GroupInfo,
             0x000B => MessageType::FilterPipeline,
@@ -60,6 +64,7 @@ impl MessageType {
             MessageType::Datatype => 0x0003,
             MessageType::FillValueOld => 0x0004,
             MessageType::FillValue => 0x0005,
+            MessageType::ExternalDataFiles => 0x0007,
             MessageType::Link => 0x0006,
             MessageType::DataLayout => 0x0008,
             MessageType::GroupInfo => 0x000A,
@@ -90,6 +95,7 @@ mod tests {
             (0x0003, MessageType::Datatype),
             (0x0004, MessageType::FillValueOld),
             (0x0005, MessageType::FillValue),
+            (0x0007, MessageType::ExternalDataFiles),
             (0x0006, MessageType::Link),
             (0x0008, MessageType::DataLayout),
             (0x000A, MessageType::GroupInfo),
@@ -119,8 +125,13 @@ mod tests {
 
     #[test]
     fn unknown_type_zero_gap() {
-        // 0x0007 is not a defined type
+        // 0x0009 is reserved for the library's own testing; no file uses it.
-        let mt = MessageType::from_u16(0x0007);
+        let mt = MessageType::from_u16(0x0009);
-        assert_eq!(mt, MessageType::Unknown(0x0007));
+        assert_eq!(mt, MessageType::Unknown(0x0009));
+        // 0x0007 used to be treated as unknown: it is External Data Files.
+        assert_eq!(
+            MessageType::from_u16(0x0007),
+            MessageType::ExternalDataFiles
+        );
     }
 }

crates/clawhdf5-format/src/parallel_read.rs

@@ -73,9 +73,12 @@ pub fn decompress_chunks_lane_partitioned(
                 let c_addr = chunk_info.address as usize;
                 let size = chunk_info.chunk_size as usize;
 
-                if c_addr + size > file_data.len() {
+                if c_addr
+                    .checked_add(size)
+                    .is_none_or(|end| end > file_data.len())
+                {
                     return Err(FormatError::UnexpectedEof {
-                        expected: c_addr + size,
+                        expected: c_addr.saturating_add(size),
                         available: file_data.len(),
                     });
                 }
@@ -144,9 +147,12 @@ pub fn decompress_chunks_parallel(
         .map(|(index, chunk_info)| {
             let c_addr = chunk_info.address as usize;
             let size = chunk_info.chunk_size as usize;
-            if c_addr + size > file_data.len() {
+            if c_addr
+                .checked_add(size)
+                .is_none_or(|end| end > file_data.len())
+            {
                 return Err(FormatError::UnexpectedEof {
-                    expected: c_addr + size,
+                    expected: c_addr.saturating_add(size),
                     available: file_data.len(),
                 });
             }
@@ -182,9 +188,12 @@ pub fn decompress_chunks_sequential(
     for chunk_info in chunks {
         let c_addr = chunk_info.address as usize;
         let size = chunk_info.chunk_size as usize;
-        if c_addr + size > file_data.len() {
+        if c_addr
+            .checked_add(size)
+            .is_none_or(|end| end > file_data.len())
+        {
             return Err(FormatError::UnexpectedEof {
-                expected: c_addr + size,
+                expected: c_addr.saturating_add(size),
                 available: file_data.len(),
             });
         }

crates/clawhdf5-format/src/selection.rs

@@ -509,7 +509,7 @@ mod tests {
 
     #[test]
     fn selection_slice_1d() {
-        let sel = Selection::slice(&[5..15]);
+        let sel = Selection::slice(std::slice::from_ref(&(5..15)));
         assert_eq!(sel.num_elements(&[100]), 10);
         assert_eq!(sel.output_shape(&[100]), vec![10]);
     }

crates/clawhdf5-format/src/shared_message.rs

@@ -16,8 +16,12 @@
 //! - SMLI list structure: simple list of shared message entries
 //! - B-tree v2 type 7: indexed shared message entries
 
+#[cfg(not(feature = "std"))]
+use alloc::borrow::Cow;
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
+#[cfg(feature = "std")]
+use std::borrow::Cow;
 
 use crate::btree_v2::{BTreeV2Header, collect_btree_v2_records};
 use crate::error::FormatError;
@@ -28,6 +32,14 @@ use crate::object_header::ObjectHeader;
 /// Fractal heap ID length for SOHM entries (fixed at 8 bytes).
 const FHEAP_ID_LEN: usize = 8;
 
+/// Shared-message `type` values (version 3 encoding).
+/// The message is in the file's shared-message (SOHM) fractal heap.
+const SHARE_TYPE_SOHM: u8 = 1;
+/// The message is in another object's header (a committed/named datatype).
+const SHARE_TYPE_COMMITTED: u8 = 2;
+/// The message is stored here but is sharable.
+const SHARE_TYPE_HERE: u8 = 3;
+
 /// A resolved shared message reference.
 #[derive(Debug, Clone)]
 pub struct SharedMessageRef {
@@ -35,9 +47,10 @@ pub struct SharedMessageRef {
     pub ref_type: u8,
     /// Version of the shared message encoding.
     pub version: u8,
-    /// Address of the object header containing the shared message (type 1, 3).
+    /// Address of the object header holding the message (committed). Set for
+    /// every v1/v2 reference and for v3 types 2 and 3.
     pub object_header_address: Option<u64>,
-    /// Fractal heap ID for type 2 (SOHM) references.
+    /// Fractal heap ID for a v3 SOHM (type 1) reference.
     pub heap_id: Option<[u8; FHEAP_ID_LEN]>,
 }
 
@@ -146,48 +159,39 @@ pub fn parse_shared_ref(data: &[u8], offset_size: u8) -> Result<SharedMessageRef
     let version = data[0];
     let ref_type = data[1];
 
+    // Layouts (HDF5 spec IV.A.2 "Shared Message", and libhdf5's decoder):
+    //   v1: version, type, reserved(6), address     — always "committed"
+    //   v2: version, type, address                  — always "committed"
+    //   v3: version, type, then a fractal-heap ID if type == SOHM, otherwise
+    //       an address
+    // Verified against h5py/HDF5 2.0 output, which writes `02 02 <address>`
+    // for a dataset using a committed datatype under both default and
+    // `latest` libver bounds.
+    let address_at = |pos: usize| -> Result<SharedMessageRef, FormatError> {
+        ensure_len(data, pos, offset_size as usize)?;
+        Ok(SharedMessageRef {
+            ref_type,
+            version,
+            object_header_address: Some(read_offset(data, pos, offset_size)?),
+            heap_id: None,
+        })
+    };
     match version {
-        1 | 2 => {
+        1 => address_at(2 + 6),
-            // v1/v2: reserved(6) + address(offset_size)
+        2 => address_at(2),
-            let pos = 2 + 6; // skip reserved bytes
+        3 if ref_type == SHARE_TYPE_SOHM => {
-            ensure_len(data, pos, offset_size as usize)?;
+            ensure_len(data, 2, FHEAP_ID_LEN)?;
-            let addr = read_offset(data, pos, offset_size)?;
+            let mut id = [0u8; FHEAP_ID_LEN];
+            id.copy_from_slice(&data[2..2 + FHEAP_ID_LEN]);
             Ok(SharedMessageRef {
                 ref_type,
                 version,
-                object_header_address: Some(addr),
+                object_header_address: None,
-                heap_id: None,
+                heap_id: Some(id),
             })
         }
-        3 => {
+        3 if ref_type == SHARE_TYPE_COMMITTED || ref_type == SHARE_TYPE_HERE => address_at(2),
-            match ref_type {
+        3 => Err(FormatError::InvalidSharedMessageVersion(ref_type)),
-                1 | 3 => {
-                    // type 1/3: message in another object header
-                    // v3 layout: version(1) + type(1) + address(offset_size)
-                    ensure_len(data, 2, offset_size as usize)?;
-                    let addr = read_offset(data, 2, offset_size)?;
-                    Ok(SharedMessageRef {
-                        ref_type,
-                        version,
-                        object_header_address: Some(addr),
-                        heap_id: None,
-                    })
-                }
-                2 => {
-                    // type 2: SOHM table (fractal heap ID)
-                    ensure_len(data, 2, FHEAP_ID_LEN)?;
-                    let mut id = [0u8; FHEAP_ID_LEN];
-                    id.copy_from_slice(&data[2..2 + FHEAP_ID_LEN]);
-                    Ok(SharedMessageRef {
-                        ref_type,
-                        version,
-                        object_header_address: None,
-                        heap_id: Some(id),
-                    })
-                }
-                _ => Err(FormatError::InvalidSharedMessageVersion(ref_type)),
-            }
-        }
         _ => Err(FormatError::InvalidSharedMessageVersion(version)),
     }
 }
@@ -422,6 +426,35 @@ pub fn resolve_sohm_message(
     fh_header.read_managed_object(file_data, heap_id, offset_size)
 }
 
+/// The payload of an object-header message, following the indirection if the
+/// message is *shared* (header flag bit 1).
+///
+/// A shared message's bytes are not the message itself but a reference to
+/// where it lives — e.g. a dataset created with a committed (named) datatype
+/// stores only a pointer to that datatype's object header. Every reader of a
+/// message that may be shared (datatype, dataspace, fill value, filter
+/// pipeline, attribute) must go through this; parsing the reference bytes as
+/// the message yields garbage rather than an error.
+pub fn message_data<'a>(
+    file_data: &[u8],
+    msg: &'a crate::object_header::HeaderMessage,
+    offset_size: u8,
+    length_size: u8,
+) -> Result<Cow<'a, [u8]>, FormatError> {
+    if !is_shared(msg.flags) {
+        return Ok(Cow::Borrowed(&msg.data));
+    }
+    let shared_ref = parse_shared_ref(&msg.data, offset_size)?;
+    resolve_shared_message(
+        file_data,
+        &shared_ref,
+        msg.msg_type,
+        offset_size,
+        length_size,
+    )
+    .map(Cow::Owned)
+}
+
 /// Resolve a shared message to its actual message data.
 ///
 /// For type 1/3 (shared in another object header), reads the target object header
@@ -453,14 +486,14 @@ pub fn resolve_shared_message_with_sohm(
     length_size: u8,
     sohm_table: Option<&SohmTable>,
 ) -> Result<Vec<u8>, FormatError> {
-    match shared_ref.ref_type {
+    // Dispatch on what the reference carries rather than on `ref_type`: v1/v2
-        1 | 3 => {
+    // references are always an object-header address whatever their type
-            let addr = shared_ref
+    // byte says.
-                .object_header_address
+    match (
-                .ok_or(FormatError::UnexpectedEof {
+        shared_ref.object_header_address,
-                    expected: 1,
+        shared_ref.heap_id.as_ref(),
-                    available: 0,
+    ) {
-                })?;
+        (Some(addr), _) => {
             let target_header =
                 ObjectHeader::parse(file_data, addr as usize, offset_size, length_size)?;
             for msg in &target_header.messages {
@@ -487,11 +520,7 @@ pub fn resolve_shared_message_with_sohm(
                 available: 0,
             })
         }
-        2 => {
+        (None, Some(heap_id)) => {
-            let heap_id = shared_ref
-                .heap_id
-                .as_ref()
-                .ok_or(FormatError::InvalidSharedMessageVersion(2))?;
             let table = sohm_table.ok_or(FormatError::InvalidSharedMessageVersion(2))?;
             resolve_sohm_message(
                 file_data,
@@ -502,7 +531,7 @@ pub fn resolve_shared_message_with_sohm(
                 length_size,
             )
         }
-        _ => Err(FormatError::InvalidSharedMessageVersion(
+        (None, None) => Err(FormatError::InvalidSharedMessageVersion(
             shared_ref.ref_type,
         )),
     }
@@ -522,15 +551,15 @@ mod tests {
     }
 
     #[test]
-    fn parse_v3_type1_ref() {
+    fn parse_v3_committed_ref() {
         let mut data = Vec::new();
         data.push(3); // version
-        data.push(1); // type 1 = shared in another OH
+        data.push(SHARE_TYPE_COMMITTED); // message lives in another object header
         data.extend_from_slice(&0x1234u64.to_le_bytes()); // address
 
         let shared = parse_shared_ref(&data, 8).unwrap();
         assert_eq!(shared.version, 3);
-        assert_eq!(shared.ref_type, 1);
+        assert_eq!(shared.ref_type, SHARE_TYPE_COMMITTED);
         assert_eq!(shared.object_header_address, Some(0x1234));
         assert!(shared.heap_id.is_none());
     }
@@ -539,7 +568,7 @@ mod tests {
     fn parse_v3_type3_ref() {
         let mut data = Vec::new();
         data.push(3); // version
-        data.push(3); // type 3 = shared in another OH (v3 encoding)
+        data.push(SHARE_TYPE_HERE); // stored here but sharable: an address
         data.extend_from_slice(&0xABCDu64.to_le_bytes());
 
         let shared = parse_shared_ref(&data, 8).unwrap();
@@ -563,10 +592,10 @@ mod tests {
 
     #[test]
     fn parse_v2_ref() {
+        // v2 dropped v1's six reserved bytes: the address follows the type.
         let mut data = Vec::new();
         data.push(2); // version
-        data.push(0); // type
+        data.push(SHARE_TYPE_COMMITTED);
-        data.extend_from_slice(&[0u8; 6]); // reserved
         data.extend_from_slice(&0x9000u32.to_le_bytes());
 
         let shared = parse_shared_ref(&data, 4).unwrap();
@@ -575,15 +604,26 @@ mod tests {
     }
 
     #[test]
-    fn parse_v3_type2_sohm() {
+    fn parse_v2_ref_from_hdf5_2_0() {
+        // Datatype message of a dataset created with a committed datatype,
+        // as written by h5py 3.16 / HDF5 2.0 (libver='latest'): header flags
+        // 0x03 (shared), payload `02 02 <8-byte object header address>`.
+        let data = [0x02, 0x02, 0xb3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+        let shared = parse_shared_ref(&data, 8).unwrap();
+        assert_eq!(shared.object_header_address, Some(0xb3));
+        assert!(shared.heap_id.is_none());
+    }
+
+    #[test]
+    fn parse_v3_sohm_ref() {
         let mut data = Vec::new();
         data.push(3); // version
-        data.push(2); // type 2 = SOHM heap
+        data.push(SHARE_TYPE_SOHM); // message lives in the SOHM fractal heap
         data.extend_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD, 0x11, 0x22, 0x33, 0x44]);
 
         let shared = parse_shared_ref(&data, 8).unwrap();
         assert_eq!(shared.version, 3);
-        assert_eq!(shared.ref_type, 2);
+        assert_eq!(shared.ref_type, SHARE_TYPE_SOHM);
         assert_eq!(shared.object_header_address, None);
         assert_eq!(
             shared.heap_id,
@@ -592,10 +632,10 @@ mod tests {
     }
 
     #[test]
-    fn parse_v3_type2_too_short() {
+    fn parse_v3_sohm_too_short() {
         let mut data = Vec::new();
         data.push(3); // version
-        data.push(2); // type 2 = SOHM heap
+        data.push(SHARE_TYPE_SOHM);
         data.extend_from_slice(&[0xAA, 0xBB]); // only 2 bytes, need 8
 
         let err = parse_shared_ref(&data, 8).unwrap_err();
@@ -620,7 +660,7 @@ mod tests {
     fn parse_four_byte_offsets() {
         let mut data = Vec::new();
         data.push(3); // version
-        data.push(1); // type 1
+        data.push(SHARE_TYPE_COMMITTED);
         data.extend_from_slice(&0x1000u32.to_le_bytes());
 
         let shared = parse_shared_ref(&data, 4).unwrap();

crates/clawhdf5-format/src/symbol_table.rs

@@ -80,9 +80,12 @@ impl SymbolTableNode {
         offset_size: u8,
     ) -> Result<SymbolTableNode, FormatError> {
         // signature(4) + version(1) + reserved(1) + number_of_symbols(2) = 8
-        if offset + 8 > file_data.len() {
+        if offset
+            .checked_add(8)
+            .is_none_or(|end| end > file_data.len())
+        {
             return Err(FormatError::UnexpectedEof {
-                expected: offset + 8,
+                expected: offset.saturating_add(8),
                 available: file_data.len(),
             });
         }
@@ -103,7 +106,12 @@ impl SymbolTableNode {
         // Each entry: link_name_offset(os) + obj_hdr_addr(os) + cache_type(4) + reserved(4) + scratch(16)
         let entry_size = os + os + 4 + 4 + 16;
         let entries_start = offset + 8;
-        let needed = entries_start + num_symbols * entry_size;
+        let needed = entries_start.checked_add(num_symbols * entry_size).ok_or(
+            FormatError::UnexpectedEof {
+                expected: usize::MAX,
+                available: file_data.len(),
+            },
+        )?;
         if needed > file_data.len() {
             return Err(FormatError::UnexpectedEof {
                 expected: needed,
@@ -228,4 +236,24 @@ mod tests {
         let err = SymbolTableNode::parse(&data, 0, 8).unwrap_err();
         assert_eq!(err, FormatError::InvalidSymbolTableNodeVersion(2));
     }
+
+    /// A near-`usize::MAX` SNOD offset must error cleanly, not overflow/panic.
+    #[test]
+    fn parse_snod_rejects_offset_overflow() {
+        let data = build_snod(&[], 8);
+        let result = SymbolTableNode::parse(&data, usize::MAX - 4, 8);
+        assert!(result.is_err());
+    }
+
+    /// A huge symbol count combined with a large entries_start must not
+    /// overflow the `needed` size computation.
+    #[test]
+    fn parse_snod_rejects_entries_size_overflow() {
+        let mut data = build_snod(&[], 8);
+        // num_symbols at offset 6..8 — set to max to blow up entries_start + num_symbols*entry_size
+        data[6] = 0xFF;
+        data[7] = 0xFF;
+        let result = SymbolTableNode::parse(&data, usize::MAX / 2, 8);
+        assert!(result.is_err());
+    }
 }

crates/clawhdf5-format/src/type_builders.rs

@@ -279,6 +279,43 @@ pub(crate) fn build_attr_message(name: &str, value: &AttrValue) -> AttributeMess
             dataspace: scalar_ds(),
             raw_data: v.to_le_bytes().to_vec(),
         },
+        AttrValue::U64Array(arr) => {
+            let mut raw = Vec::with_capacity(arr.len() * 8);
+            for v in arr {
+                raw.extend_from_slice(&v.to_le_bytes());
+            }
+            AttributeMessage {
+                name: name.to_string(),
+                datatype: Datatype::FixedPoint {
+                    size: 8,
+                    byte_order: DatatypeByteOrder::LittleEndian,
+                    signed: false,
+                    bit_offset: 0,
+                    bit_precision: 64,
+                },
+                dataspace: simple_1d(arr.len() as u64),
+                raw_data: raw,
+            }
+        }
+        AttrValue::Raw {
+            datatype,
+            shape,
+            data,
+        } => AttributeMessage {
+            name: name.to_string(),
+            datatype: datatype.clone(),
+            dataspace: if shape.is_empty() {
+                scalar_ds()
+            } else {
+                Dataspace {
+                    space_type: DataspaceType::Simple,
+                    rank: shape.len() as u8,
+                    dimensions: shape.clone(),
+                    max_dimensions: None,
+                }
+            },
+            raw_data: data.clone(),
+        },
         AttrValue::String(s) => {
             let bytes = s.as_bytes();
             AttributeMessage {
@@ -334,7 +371,7 @@ pub(crate) fn simple_1d(n: u64) -> Dataspace {
 
 // ---- Attribute values ----
 
-/// Convenient attribute values for the write API.
+/// Attribute values, for both the write API and what reading returns.
 #[derive(Debug, Clone)]
 pub enum AttrValue {
     F64(f64),
@@ -342,8 +379,21 @@ pub enum AttrValue {
     I64(i64),
     I64Array(Vec<i64>),
     U64(u64),
+    /// Unsigned integers, kept unsigned so values above `i64::MAX` survive.
+    U64Array(Vec<u64>),
     String(String),
     StringArray(Vec<String>),
+    /// An attribute whose datatype has no dedicated variant above (compound,
+    /// general enum, complex, reference, opaque, array, ...), carried verbatim
+    /// so it is never silently lost: the datatype, the dataspace dimensions
+    /// (empty for a scalar) and the element bytes exactly as stored. Decode
+    /// `data` with `clawhdf5_format::data_read` (e.g. `read_compound_fields`)
+    /// against `datatype`. Writing a `Raw` value stores it back unchanged.
+    Raw {
+        datatype: Datatype,
+        shape: Vec<u64>,
+        data: Vec<u8>,
+    },
 }
 
 // ---- Dataset builder ----

crates/clawhdf5-format/tests/integration_test.rs

@@ -343,7 +343,11 @@ fn attrs_h5_dataset_scale() {
     let scale_attr = find_attribute(&attrs, "scale").expect("scale attr not found");
     let vals = scale_attr.read_as_f64().unwrap();
     assert_eq!(vals.len(), 1);
-    assert!((vals[0] - 3.14).abs() < 1e-10);
+    // 3.14 here is the literal value baked into the binary fixture (fixtures/attrs.h5),
+    // not an arbitrary sample value, so it cannot be swapped for another constant.
+    #[allow(clippy::approx_constant)]
+    let expected = 3.14;
+    assert!((vals[0] - expected).abs() < 1e-10);
 }
 
 #[test]
@@ -556,8 +560,8 @@ fn chunked_deflate_read_values() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "data");
     let values = read_as_f64(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 100);
-    for i in 0..100 {
+    for (i, &v) in values.iter().enumerate() {
-        assert_eq!(values[i], i as f64, "mismatch at index {i}");
+        assert_eq!(v, i as f64, "mismatch at index {i}");
     }
 }
 
@@ -567,8 +571,8 @@ fn chunked_shuffle_deflate_read_values() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "data");
     let values = read_as_f64(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 100);
-    for i in 0..100 {
+    for (i, &v) in values.iter().enumerate() {
-        assert_eq!(values[i], i as f64, "mismatch at index {i}");
+        assert_eq!(v, i as f64, "mismatch at index {i}");
     }
 }
 
@@ -578,8 +582,8 @@ fn chunked_fletcher32_read_values() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "data");
     let values = read_as_f64(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 100);
-    for i in 0..100 {
+    for (i, &v) in values.iter().enumerate() {
-        assert_eq!(values[i], i as f64, "mismatch at index {i}");
+        assert_eq!(v, i as f64, "mismatch at index {i}");
     }
 }
 
@@ -589,11 +593,10 @@ fn chunked_2d_read_values() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "matrix");
     let values = read_as_f32(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 60);
-    for i in 0..60 {
+    for (i, &v) in values.iter().enumerate() {
         assert!(
-            (values[i] - i as f32).abs() < 1e-6,
+            (v - i as f32).abs() < 1e-6,
-            "mismatch at index {i}: got {}",
+            "mismatch at index {i}: got {v}"
-            values[i]
         );
     }
 }
@@ -604,8 +607,8 @@ fn chunked_large_read_values() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "big");
     let values = read_as_i32(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 1000);
-    for i in 0..1000 {
+    for (i, &v) in values.iter().enumerate() {
-        assert_eq!(values[i], i as i32, "mismatch at index {i}");
+        assert_eq!(v, i as i32, "mismatch at index {i}");
     }
 }
 
@@ -615,8 +618,8 @@ fn chunked_nofilter_read_values() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "raw");
     let values = read_as_f64(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 50);
-    for i in 0..50 {
+    for (i, &v) in values.iter().enumerate() {
-        assert_eq!(values[i], i as f64, "mismatch at index {i}");
+        assert_eq!(v, i as f64, "mismatch at index {i}");
     }
 }
 
@@ -646,8 +649,8 @@ fn v4_implicit_read() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "data");
     let values = read_as_f64(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 100);
-    for i in 0..100 {
+    for (i, &v) in values.iter().enumerate() {
-        assert_eq!(values[i], i as f64, "mismatch at index {i}");
+        assert_eq!(v, i as f64, "mismatch at index {i}");
     }
 }
 
@@ -657,8 +660,8 @@ fn v4_fixed_array_read() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "data");
     let values = read_as_f64(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 100);
-    for i in 0..100 {
+    for (i, &v) in values.iter().enumerate() {
-        assert_eq!(values[i], i as f64, "mismatch at index {i}");
+        assert_eq!(v, i as f64, "mismatch at index {i}");
     }
 }
 
@@ -871,11 +874,10 @@ fn v4_2d_fixed_array_read() {
     let (raw, datatype, _) = read_chunked_dataset(file_data, "matrix");
     let values = read_as_f32(&raw, &datatype).unwrap();
     assert_eq!(values.len(), 60);
-    for i in 0..60 {
+    for (i, &v) in values.iter().enumerate() {
         assert!(
-            (values[i] - i as f32).abs() < 1e-6,
+            (v - i as f32).abs() < 1e-6,
-            "mismatch at index {i}: got {}",
+            "mismatch at index {i}: got {v}"
-            values[i]
         );
     }
 }
@@ -1272,7 +1274,7 @@ fn write_roundtrip_scalar_f64_attr() {
     let mut fw = FileWriter::new();
     fw.create_dataset("data")
         .with_f64_data(&[1.0])
-        .set_attr("scale", AttrValue::F64(3.14));
+        .set_attr("scale", AttrValue::F64(3.25));
     let bytes = fw.finish().unwrap();
 
     let sig = find_signature(&bytes).unwrap();
@@ -1283,7 +1285,7 @@ fn write_roundtrip_scalar_f64_attr() {
     let scale = find_attribute(&attrs, "scale").expect("scale attr not found");
     let vals = scale.read_as_f64().unwrap();
     assert_eq!(vals.len(), 1);
-    assert!((vals[0] - 3.14).abs() < 1e-10);
+    assert!((vals[0] - 3.25).abs() < 1e-10);
 }
 
 #[test]

crates/clawhdf5-format/tests/reference_tests.rs

@@ -180,15 +180,20 @@ print('ok')
     let output = match output {
         Ok(o) if o.status.success() => o,
         _ => {
+            // CI sets CLAWHDF5_REQUIRE_INTEROP=1 so this can't silently skip.
+            assert!(
+                !std::env::var("CLAWHDF5_REQUIRE_INTEROP").is_ok_and(|v| v == "1"),
+                "CLAWHDF5_REQUIRE_INTEROP=1 but python3 with h5py is not available"
+            );
             eprintln!("skipping h5py_object_reference_roundtrip: python3+h5py not available");
             return;
         }
     };
     let stdout = String::from_utf8(output.stdout).unwrap();
-    if !stdout.trim().contains("ok") {
+    assert!(
-        eprintln!("skipping h5py_object_reference_roundtrip: h5py script failed");
+        stdout.trim().contains("ok"),
-        return;
+        "h5py reference-file generator did not report ok: {stdout}"
-    }
+    );
 
     // Read the file and parse object references
     let file_data = std::fs::read(&path).unwrap();

crates/clawhdf5-format/tests/writer_h5py_tests.rs

@@ -235,17 +235,31 @@ fn h5py_reads_our_array_dataset() {
 #[test]
 #[ignore = "requires Python h5py module"]
 fn read_h5py_generated_compound() {
-    let path = std::env::temp_dir().join("clawhdf5_h5py_compound.h5");
+    check_h5py_generated_compound("latest", ", libver='latest'");
+}
+
+/// Same file written with h5py's default format bounds. HDF5 2.0 raised the
+/// default low bound to 1.8, so "default" files exercise different on-disk
+/// structures than both `libver='latest'` and pre-2.0 defaults.
+#[test]
+#[ignore = "requires Python h5py module"]
+fn read_h5py_generated_compound_default_libver() {
+    check_h5py_generated_compound("default", "");
+}
+
+fn check_h5py_generated_compound(tag: &str, libver_kw: &str) {
+    let path = std::env::temp_dir().join(format!("clawhdf5_h5py_compound_{tag}.h5"));
     let gen_script = format!(
         r#"
 import h5py, numpy as np
 dt = np.dtype([('x', 'f8'), ('y', 'f8'), ('id', 'i4')])
 data = np.array([(1.0, 2.0, 10), (3.0, 4.0, 20)], dtype=dt)
-f = h5py.File('{}', 'w', libver='latest')
+f = h5py.File('{}', 'w'{})
 f.create_dataset('particles', data=data)
 f.close()
 "#,
-        path.display()
+        path.display(),
+        libver_kw
     );
     h5py_read(&path, &gen_script);
 
@@ -292,20 +306,102 @@ f.close()
     assert_eq!(x_vals, vec![1.0, 3.0]);
 }
 
+#[test]
+#[ignore = "requires Python h5py module"]
+fn read_h5py_generated_native_complex() {
+    // HDF5 2.0 native complex (datatype class 11, version 5), written through
+    // h5py's low-level API. Skips when the linked HDF5 predates 2.0.
+    let path = std::env::temp_dir().join("clawhdf5_h5py_native_complex.h5");
+    let gen_script = format!(
+        r#"
+import h5py, numpy as np
+from h5py import h5t, h5s, h5d, h5f, h5p
+if not getattr(h5py.get_config(), 'has_native_complex', False):
+    print('SKIP')
+else:
+    fapl = h5p.create(h5p.FILE_ACCESS)
+    fapl.set_libver_bounds(h5f.LIBVER_LATEST, h5f.LIBVER_LATEST)
+    fid = h5f.create(b'{}', h5f.ACC_TRUNC, fapl=fapl)
+    t = h5t.COMPLEX_IEEE_F64LE
+    d = h5d.create(fid, b'z', t, h5s.create_simple((2,)))
+    d.write(h5s.ALL, h5s.ALL, np.array([1+2j, 3+4j], dtype=np.complex128), mtype=t)
+    fid.close()
+"#,
+        path.display()
+    );
+    if h5py_read(&path, &gen_script) == "SKIP" {
+        eprintln!("HDF5 < 2.0: no native complex support, skipping");
+        return;
+    }
+
+    let bytes = std::fs::read(&path).unwrap();
+    let sig = clawhdf5_format::signature::find_signature(&bytes).unwrap();
+    let sb = clawhdf5_format::superblock::Superblock::parse(&bytes, sig).unwrap();
+    let addr = clawhdf5_format::group_v2::resolve_path_any(&bytes, &sb, "z").unwrap();
+    let hdr = clawhdf5_format::object_header::ObjectHeader::parse(
+        &bytes,
+        addr as usize,
+        sb.offset_size,
+        sb.length_size,
+    )
+    .unwrap();
+    let msg = |t: clawhdf5_format::message_type::MessageType| {
+        &hdr.messages.iter().find(|m| m.msg_type == t).unwrap().data
+    };
+    let (dt, _) = clawhdf5_format::datatype::Datatype::parse(msg(
+        clawhdf5_format::message_type::MessageType::Datatype,
+    ))
+    .unwrap();
+    let ds = clawhdf5_format::dataspace::Dataspace::parse(
+        msg(clawhdf5_format::message_type::MessageType::Dataspace),
+        sb.length_size,
+    )
+    .unwrap();
+    let dl = clawhdf5_format::data_layout::DataLayout::parse(
+        msg(clawhdf5_format::message_type::MessageType::DataLayout),
+        sb.offset_size,
+        sb.length_size,
+    )
+    .unwrap();
+    let raw = clawhdf5_format::data_read::read_raw_data(&bytes, &dl, &ds, &dt).unwrap();
+    let fields = clawhdf5_format::data_read::read_compound_fields(&raw, &dt).unwrap();
+    assert_eq!(fields.len(), 2);
+    let re =
+        clawhdf5_format::data_read::read_as_f64(&fields[0].raw_data, &fields[0].datatype).unwrap();
+    let im =
+        clawhdf5_format::data_read::read_as_f64(&fields[1].raw_data, &fields[1].datatype).unwrap();
+    assert_eq!((fields[0].name.as_str(), re), ("r", vec![1.0, 3.0]));
+    assert_eq!((fields[1].name.as_str(), im), ("i", vec![2.0, 4.0]));
+}
+
 #[test]
 #[ignore = "requires Python h5py module"]
 fn read_h5py_generated_enum() {
-    let path = std::env::temp_dir().join("clawhdf5_h5py_enum.h5");
+    check_h5py_generated_enum("latest", ", libver='latest'");
+}
+
+/// Same file written with h5py's default format bounds. HDF5 2.0 raised the
+/// default low bound to 1.8, so "default" files exercise different on-disk
+/// structures than both `libver='latest'` and pre-2.0 defaults.
+#[test]
+#[ignore = "requires Python h5py module"]
+fn read_h5py_generated_enum_default_libver() {
+    check_h5py_generated_enum("default", "");
+}
+
+fn check_h5py_generated_enum(tag: &str, libver_kw: &str) {
+    let path = std::env::temp_dir().join(format!("clawhdf5_h5py_enum_{tag}.h5"));
     let gen_script = format!(
         r#"
 import h5py, numpy as np
 dt = h5py.enum_dtype({{"RED": 0, "GREEN": 1, "BLUE": 2}}, basetype=np.int32)
 data = np.array([1, 0, 2, 1], dtype=np.int32)
-f = h5py.File('{}', 'w', libver='latest')
+f = h5py.File('{}', 'w'{})
 f.create_dataset('colors', data=data, dtype=dt)
 f.close()
 "#,
-        path.display()
+        path.display(),
+        libver_kw
     );
     h5py_read(&path, &gen_script);
 

crates/clawhdf5-gpu/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "clawhdf5-gpu"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "GPU-accelerated vector operations for rustyhdf5 using wgpu compute shaders"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "gpu", "wgpu", "compute"]
 categories = ["science", "graphics"]

crates/clawhdf5-gpu/src/accelerator.rs

@@ -6,6 +6,9 @@ use crate::shaders;
 use bytemuck::Pod;
 use wgpu::util::DeviceExt;
 
+/// Upper bound on a single GPU→CPU readback wait.
+const READBACK_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
+
 /// GPU-accelerated vector search engine.
 ///
 /// Upload vectors once, then run many searches against them.
@@ -1033,10 +1036,12 @@ impl GpuAccelerator {
         slice.map_async(wgpu::MapMode::Read, move |result| {
             let _ = tx.send(result);
         });
+        // Bounded wait: a wedged driver must surface as an error, not hang
+        // the caller forever.
         self.device
             .poll(wgpu::PollType::Wait {
                 submission_index: None,
-                timeout: None,
+                timeout: Some(READBACK_TIMEOUT),
             })
             .map_err(|e| GpuError::BufferMap(format!("device poll failed: {e}")))?;
         rx.recv()

crates/clawhdf5-gpu/tests/gpu_tests.rs

@@ -6,9 +6,41 @@
 mod tests {
     use clawhdf5_gpu::{GpuAccelerator, GpuError};
 
-    fn skip_if_no_gpu() -> Option<GpuAccelerator> {
+    /// Serialises GPU access across tests. The harness runs tests on many
+    /// threads; letting each create its own wgpu instance + device (with
+    /// adapter-maximum limits) at the same time can wedge the driver and hang
+    /// the whole suite, so every test holds this lock while it owns a device.
+    static GPU_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
+    fn gpu_lock() -> std::sync::MutexGuard<'static, ()> {
+        // A panicking test poisons the lock; the guarded state is `()`.
+        GPU_LOCK.lock().unwrap_or_else(|e| e.into_inner())
+    }
+
+    /// A `GpuAccelerator` plus the lock that keeps other tests off the GPU.
+    /// Field order matters: the device is dropped before the lock is released.
+    struct LockedGpu {
+        gpu: GpuAccelerator,
+        _guard: std::sync::MutexGuard<'static, ()>,
+    }
+
+    impl std::ops::Deref for LockedGpu {
+        type Target = GpuAccelerator;
+        fn deref(&self) -> &GpuAccelerator {
+            &self.gpu
+        }
+    }
+
+    impl std::ops::DerefMut for LockedGpu {
+        fn deref_mut(&mut self) -> &mut GpuAccelerator {
+            &mut self.gpu
+        }
+    }
+
+    fn skip_if_no_gpu() -> Option<LockedGpu> {
+        let guard = gpu_lock();
         match GpuAccelerator::new() {
-            Ok(gpu) => Some(gpu),
+            Ok(gpu) => Some(LockedGpu { gpu, _guard: guard }),
             Err(_) => {
                 eprintln!("SKIPPED: no GPU available");
                 None
@@ -69,6 +101,7 @@ mod tests {
     #[test]
     fn test_gpu_availability_detection() {
         // Should not panic regardless of GPU presence
+        let _guard = gpu_lock();
         let available = GpuAccelerator::is_available();
         eprintln!("GPU available: {available}");
     }
@@ -425,6 +458,7 @@ mod tests {
     #[test]
     fn test_graceful_no_gpu_fallback() {
         // This test just demonstrates the pattern — it always passes
+        let _guard = gpu_lock();
         match GpuAccelerator::new() {
             Ok(gpu) => {
                 eprintln!("GPU found: {}", gpu.device_info());

crates/clawhdf5-io/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "clawhdf5-io"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "I/O abstraction layer for rustyhdf5"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "io", "science", "data"]
 categories = ["filesystem", "science"]
 
 [dependencies]
-clawhdf5-format = { path = "../clawhdf5-format", version = "2.1.0" }
+clawhdf5-format = { path = "../clawhdf5-format", version = "2.3.0" }
 memmap2 = { version = "0.9", optional = true }
 libc = { version = "0.2", optional = true }
 tokio = { version = "1", features = ["fs", "io-util"], optional = true }

crates/clawhdf5-io/src/async_read.rs

@@ -59,11 +59,16 @@ pub trait AsyncHDF5Read: Send + Sync {
 
 /// Async file-backed reader using tokio for non-blocking I/O.
 ///
-/// Opens a file and reads it asynchronously. The file is read into memory
+/// Opens a file and reads it asynchronously. The underlying file handle is
-/// on first access, making subsequent operations fast.
+/// opened once (lazily, on first access) and cached for the lifetime of this
+/// reader, so repeated granular `read_at` calls reuse the open descriptor
+/// and cached length instead of paying an open+stat syscall pair every time.
+/// The handle is guarded by a mutex, which also correctly serializes the
+/// seek-then-read pairs of concurrent callers sharing the one file position.
 #[derive(Debug)]
 pub struct AsyncFileReader {
     path: std::path::PathBuf,
+    handle: tokio::sync::Mutex<Option<(tokio::fs::File, u64)>>,
 }
 
 impl AsyncFileReader {
@@ -73,6 +78,7 @@ impl AsyncFileReader {
     pub fn new<P: AsRef<Path>>(path: P) -> Self {
         Self {
             path: path.as_ref().to_path_buf(),
+            handle: tokio::sync::Mutex::new(None),
         }
     }
 
@@ -89,23 +95,33 @@ impl AsyncFileReader {
 
 impl AsyncHDF5Read for AsyncFileReader {
     async fn read_at(&self, offset: u64, len: usize) -> io::Result<Vec<u8>> {
-        let mut file = tokio::fs::File::open(&self.path).await?;
+        let mut guard = self.handle.lock().await;
-        let metadata = file.metadata().await?;
+        if guard.is_none() {
-        let file_len = metadata.len();
+            let file = tokio::fs::File::open(&self.path).await?;
+            let file_len = file.metadata().await?.len();
+            *guard = Some((file, file_len));
+        }
+        let (file, file_len) = guard.as_mut().expect("just populated above");
+        let file_len = *file_len;
         if offset >= file_len {
             return Ok(Vec::new());
         }
         let available = (file_len - offset) as usize;
         let to_read = len.min(available);
-        tokio::io::AsyncSeekExt::seek(&mut file, io::SeekFrom::Start(offset)).await?;
+        tokio::io::AsyncSeekExt::seek(file, io::SeekFrom::Start(offset)).await?;
         let mut buf = vec![0u8; to_read];
         file.read_exact(&mut buf).await?;
         Ok(buf)
     }
 
     async fn len(&self) -> io::Result<u64> {
-        let metadata = tokio::fs::metadata(&self.path).await?;
+        let mut guard = self.handle.lock().await;
-        Ok(metadata.len())
+        if guard.is_none() {
+            let file = tokio::fs::File::open(&self.path).await?;
+            let file_len = file.metadata().await?.len();
+            *guard = Some((file, file_len));
+        }
+        Ok(guard.as_ref().expect("just populated above").1)
     }
 }
 

crates/clawhdf5-migrate/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "clawhdf5-migrate"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "CLI to migrate SQLite agent memory databases to HDF5 format"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["sqlite", "hdf5", "migration", "agent", "memory"]
 categories = ["command-line-utilities", "database"]
@@ -14,9 +14,9 @@ name = "clawhdf5-migrate"
 path = "src/main.rs"
 
 [dependencies]
-clawhdf5-agent = { path = "../clawhdf5-agent", version = "2.1.0" }
+clawhdf5-agent = { path = "../clawhdf5-agent", version = "2.3.0" }
-clawhdf5-format = { path = "../clawhdf5-format", version = "2.1.0" }
+clawhdf5-format = { path = "../clawhdf5-format", version = "2.3.0" }
-clawhdf5 = { path = "../clawhdf5", version = "2.1.0" }
+clawhdf5 = { path = "../clawhdf5", version = "2.3.0" }
 rusqlite = { version = "0.31", features = ["bundled"] }
 clap = { version = "4", features = ["derive"] }
 half = { workspace = true }

crates/clawhdf5-migrate/src/hdf5_reader.rs

@@ -49,6 +49,10 @@ pub fn read_hdf5(path: &str) -> Result<SqliteData, BoxErr> {
         entities,
         relations,
         embedding_dim,
+        // Not a SQLite read — the caller (incremental migration) carries
+        // forward the current run's actual `source_path` from the fresh
+        // SQLite read instead of using this placeholder.
+        source_path: String::new(),
     })
 }
 

crates/clawhdf5-migrate/src/hdf5_writer.rs

@@ -20,6 +20,7 @@ pub fn write_hdf5(
     opts: &WriteOptions,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let mut builder = FileBuilder::new();
+    let timestamp = iso8601_now();
 
     // Root-level metadata attributes
     builder.set_attr("agent_id", AttrValue::String(opts.agent_id.clone()));
@@ -27,8 +28,18 @@ pub fn write_hdf5(
     builder.set_attr("embedding_dim", AttrValue::I64(data.embedding_dim as i64));
     builder.set_attr("source", AttrValue::String("sqlite-migration".into()));
     builder.set_attr("version", AttrValue::I64(1));
+    // Lineage: which SQLite database this output was migrated from and when,
+    // plus the migrator tool version — so a chain of `--incremental` runs
+    // still has an audit trail instead of every run overwriting the same
+    // static attributes (see research/03_provenance.md, INT-03).
+    builder.set_attr("source_path", AttrValue::String(data.source_path.clone()));
+    builder.set_attr("migrated_at", AttrValue::String(timestamp.clone()));
+    builder.set_attr(
+        "migrator_version",
+        AttrValue::String(env!("CARGO_PKG_VERSION").to_owned()),
+    );
 
-    write_chunks_group(&mut builder, data, opts);
+    write_chunks_group(&mut builder, data, opts, &timestamp);
     write_sessions_group(&mut builder, data);
     write_entities_group(&mut builder, data);
     write_relations_group(&mut builder, data);
@@ -37,6 +48,40 @@ pub fn write_hdf5(
     Ok(())
 }
 
+/// Current UTC time formatted as an ISO-8601 / RFC-3339 timestamp
+/// (`YYYY-MM-DDTHH:MM:SSZ`), with no external date/time dependency.
+fn iso8601_now() -> String {
+    let secs = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs();
+    let days = (secs / 86_400) as i64;
+    let time_of_day = secs % 86_400;
+    let (h, m, s) = (
+        time_of_day / 3600,
+        (time_of_day % 3600) / 60,
+        time_of_day % 60,
+    );
+    let (y, mo, d) = civil_from_days(days);
+    format!("{y:04}-{mo:02}-{d:02}T{h:02}:{m:02}:{s:02}Z")
+}
+
+/// Days-since-epoch to (year, month, day), Howard Hinnant's `civil_from_days`
+/// algorithm (proleptic Gregorian calendar, valid for the full `i64` range).
+fn civil_from_days(z: i64) -> (i64, u32, u32) {
+    let z = z + 719_468;
+    let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
+    let doe = (z - era * 146_097) as u64; // [0, 146096]
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; // [0, 399]
+    let y = yoe as i64 + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
+    let mp = (5 * doy + 2) / 153; // [0, 11]
+    let d = (doy - (153 * mp + 2) / 5 + 1) as u32; // [1, 31]
+    let m = (if mp < 10 { mp + 3 } else { mp - 9 }) as u32; // [1, 12]
+    let y = if m <= 2 { y + 1 } else { y };
+    (y, m, d)
+}
+
 /// Build a fixed-length string Datatype from the max byte length of the items.
 fn string_dtype(max_len: usize) -> Datatype {
     Datatype::String {
@@ -66,7 +111,12 @@ fn apply_compression(ds: &mut clawhdf5_format::type_builders::DatasetBuilder, op
     }
 }
 
-fn write_chunks_group(builder: &mut FileBuilder, data: &SqliteData, opts: &WriteOptions) {
+fn write_chunks_group(
+    builder: &mut FileBuilder,
+    data: &SqliteData,
+    opts: &WriteOptions,
+    timestamp: &str,
+) {
     let mut group = builder.create_group("chunks");
     let n = data.chunks.len() as u64;
 
@@ -78,6 +128,16 @@ fn write_chunks_group(builder: &mut FileBuilder, data: &SqliteData, opts: &Write
 
     group.set_attr("count", AttrValue::I64(n as i64));
 
+    // Source attribution attached directly to the content-bearing datasets
+    // (SHA-256 of the raw bytes + creator/timestamp/source), so the chunk
+    // text and embeddings each carry their own verifiable provenance
+    // (see clawhdf5_format::provenance / `Dataset::verify_provenance`).
+    let source_opt = if data.source_path.is_empty() {
+        None
+    } else {
+        Some(data.source_path.as_str())
+    };
+
     // ids
     let ids: Vec<i64> = data.chunks.iter().map(|c| c.id).collect();
     group.create_dataset("id").with_i64_data(&ids);
@@ -87,7 +147,8 @@ fn write_chunks_group(builder: &mut FileBuilder, data: &SqliteData, opts: &Write
     let (text_raw, text_len) = pack_strings(&texts);
     group
         .create_dataset("text")
-        .with_compound_data(string_dtype(text_len), text_raw, n);
+        .with_compound_data(string_dtype(text_len), text_raw, n)
+        .with_provenance("clawhdf5-migrate", timestamp, source_opt);
 
     // embeddings - flatten to [N, dim]
     let dim = data.embedding_dim;
@@ -116,7 +177,8 @@ fn write_chunks_group(builder: &mut FileBuilder, data: &SqliteData, opts: &Write
         let ds = group
             .create_dataset("embeddings")
             .with_compound_data(f16_dtype, raw, n)
-            .with_shape(&[n, dim as u64]);
+            .with_shape(&[n, dim as u64])
+            .with_provenance("clawhdf5-migrate", timestamp, source_opt);
         apply_compression(ds, opts);
     } else {
         let flat: Vec<f32> = data
@@ -127,7 +189,8 @@ fn write_chunks_group(builder: &mut FileBuilder, data: &SqliteData, opts: &Write
         let ds = group
             .create_dataset("embeddings")
             .with_f32_data(&flat)
-            .with_shape(&[n, dim as u64]);
+            .with_shape(&[n, dim as u64])
+            .with_provenance("clawhdf5-migrate", timestamp, source_opt);
         apply_compression(ds, opts);
     }
 
@@ -274,3 +337,30 @@ fn write_relations_group(builder: &mut FileBuilder, data: &SqliteData) {
 
     builder.add_group(group.finish());
 }
+
+#[cfg(test)]
+mod time_tests {
+    use super::civil_from_days;
+
+    #[test]
+    fn epoch_day_zero_is_1970_01_01() {
+        assert_eq!(civil_from_days(0), (1970, 1, 1));
+    }
+
+    #[test]
+    fn known_dates_roundtrip() {
+        // 2026-08-16 is 20,681 days after 1970-01-01.
+        assert_eq!(civil_from_days(20_681), (2026, 8, 16));
+        // 2000-02-29 (leap day itself) and 2000-03-01 (the day after).
+        assert_eq!(civil_from_days(11_016), (2000, 2, 29));
+        assert_eq!(civil_from_days(11_017), (2000, 3, 1));
+    }
+
+    #[test]
+    fn iso8601_now_has_expected_shape() {
+        let ts = super::iso8601_now();
+        assert_eq!(ts.len(), "2026-08-16T00:00:00Z".len());
+        assert!(ts.starts_with("20")); // sanity: 21st-century year
+        assert!(ts.ends_with('Z'));
+    }
+}

crates/clawhdf5-migrate/src/main.rs

@@ -154,6 +154,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             base.entities = source.entities;
             base.relations = source.relations;
             base.embedding_dim = source.embedding_dim.max(base.embedding_dim);
+            // Carry the current run's real SQLite source forward for
+            // provenance — `base` (re-read from the prior HDF5 output) has
+            // no meaningful source_path of its own.
+            base.source_path = source.source_path;
             if cli.verbose {
                 eprintln!("Incremental: appended {added} new chunks (id > {min_chunk_id})");
             }
@@ -199,6 +203,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         summary.embedding_dim,
         summary.rows_checked,
     );
+    if summary.provenance_verified {
+        eprintln!("Provenance: chunks/text and chunks/embeddings SHA-256 hashes verified.");
+    } else if cli.verbose {
+        eprintln!("Provenance: no provenance hash found to verify (older output format?).");
+    }
 
     Ok(())
 }

crates/clawhdf5-migrate/src/sqlite_reader.rs

@@ -51,6 +51,11 @@ pub struct SqliteData {
     pub entities: Vec<Entity>,
     pub relations: Vec<Relation>,
     pub embedding_dim: usize,
+    /// Filesystem path of the SQLite database this data was read from, for
+    /// provenance attribution on the HDF5 output. Empty when the data did
+    /// not come directly from a SQLite read (e.g. re-read of a prior HDF5
+    /// migration output for an incremental merge).
+    pub source_path: String,
 }
 
 /// A table name plus the ordered column names the reader maps by position.
@@ -180,8 +185,10 @@ fn detect_embedding_dim(conn: &Connection, config: &SchemaConfig) -> SqlResult<O
 
 /// Parse a raw byte BLOB into a Vec<f32>.
 fn blob_to_f32(blob: &[u8]) -> Vec<f32> {
-    blob.chunks_exact(4)
+    blob.as_chunks::<4>()
-        .map(|b| f32::from_le_bytes([b[0], b[1], b[2], b[3]]))
+        .0
+        .iter()
+        .map(|b| f32::from_le_bytes(*b))
         .collect()
 }
 
@@ -225,6 +232,7 @@ pub fn read_sqlite_filtered(
         entities,
         relations,
         embedding_dim: dim,
+        source_path: path.to_owned(),
     })
 }
 

crates/clawhdf5-migrate/src/validate.rs

@@ -1,3 +1,6 @@
+use clawhdf5::reader::File as Hdf5File;
+use clawhdf5_format::provenance::VerifyResult;
+
 use crate::hdf5_reader::read_hdf5;
 use crate::sqlite_reader::SqliteData;
 
@@ -13,6 +16,12 @@ pub struct ValidationSummary {
     pub embedding_dim: u64,
     /// Number of rows whose full content was compared against the source.
     pub rows_checked: u64,
+    /// Whether the `chunks/text` and `chunks/embeddings` SHINES provenance
+    /// hashes (written via [`crate::hdf5_writer`]) were both present and
+    /// matched their recomputed SHA-256 on read-back. `false` when either
+    /// dataset has no provenance metadata (e.g. an older output file) or
+    /// there are zero chunks to check.
+    pub provenance_verified: bool,
 }
 
 /// Validate a migrated HDF5 file against the source data.
@@ -30,6 +39,7 @@ pub fn validate_hdf5(
     float16: bool,
 ) -> Result<ValidationSummary, BoxErr> {
     let got = read_hdf5(path)?;
+    let provenance_verified = verify_chunk_provenance(path)?;
 
     // ---- Counts ----
     check_count("chunk", got.chunks.len(), source.chunks.len())?;
@@ -126,6 +136,7 @@ pub fn validate_hdf5(
         relations: got.relations.len() as u64,
         embedding_dim: got.embedding_dim as u64,
         rows_checked,
+        provenance_verified,
     })
 }
 
@@ -136,6 +147,42 @@ fn check_count(kind: &str, got: usize, expected: usize) -> Result<(), BoxErr> {
     Ok(())
 }
 
+/// Re-verify the SHA-256 provenance hash of `chunks/text` and
+/// `chunks/embeddings` against their actual stored bytes, catching
+/// post-write corruption that a plain content comparison against the
+/// in-memory source wouldn't (the source is compared against what
+/// `read_hdf5` decoded, not against the raw bytes on disk).
+///
+/// Returns `Ok(true)` only if both datasets exist and both hashes match.
+/// Returns `Ok(false)` (not an error) if a dataset has no provenance
+/// attributes at all (e.g. a file written before this check existed) or
+/// there are zero chunks. Returns an error only on an actual hash mismatch —
+/// that indicates real corruption.
+fn verify_chunk_provenance(path: &str) -> Result<bool, BoxErr> {
+    let file = Hdf5File::open(path)?;
+    let Ok(chunks) = file.group("chunks") else {
+        return Ok(false);
+    };
+    let mut all_present = true;
+    for name in ["text", "embeddings"] {
+        let Ok(ds) = chunks.dataset(name) else {
+            all_present = false;
+            continue;
+        };
+        match ds.verify_provenance()? {
+            VerifyResult::Ok => {}
+            VerifyResult::NoHash => all_present = false,
+            VerifyResult::Mismatch { stored, computed } => {
+                return Err(format!(
+                    "provenance hash mismatch on chunks/{name}: stored {stored}, recomputed {computed} — data may be corrupted"
+                )
+                .into());
+            }
+        }
+    }
+    Ok(all_present)
+}
+
 fn field_err<T: std::fmt::Display>(kind: &str, i: usize, field: &str, s: T, g: T) -> BoxErr {
     format!("{kind}[{i}].{field} mismatch: source {s}, HDF5 {g}").into()
 }
@@ -144,7 +191,8 @@ fn truncate(s: &str) -> String {
     if s.len() <= 40 {
         s.to_string()
     } else {
-        format!("{}…", &s[..40])
+        let cut = s.char_indices().nth(40).map(|(i, _)| i).unwrap_or(s.len());
+        format!("{}…", &s[..cut])
     }
 }
 
@@ -161,3 +209,31 @@ fn sample_indices(n: usize, full: bool) -> Vec<usize> {
     idx.dedup();
     idx
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn truncate_short_string_unchanged() {
+        assert_eq!(truncate("hello"), "hello");
+    }
+
+    /// A multi-byte character straddling byte offset 40 must not panic a
+    /// byte-index slice — this is arbitrary UTF-8 chunk text from an
+    /// untrusted source database, not test-only input.
+    #[test]
+    fn truncate_multibyte_char_at_boundary_does_not_panic() {
+        // 39 ASCII bytes then a 4-byte emoji straddling the byte-40 cut point.
+        let s = format!("{}{}", "a".repeat(39), "😀".repeat(5));
+        let result = truncate(&s);
+        assert!(result.ends_with('…'));
+        assert!(result.chars().count() < s.chars().count());
+    }
+
+    #[test]
+    fn truncate_exactly_at_limit_unchanged() {
+        let s = "a".repeat(40);
+        assert_eq!(truncate(&s), s);
+    }
+}

crates/clawhdf5-napi/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "clawhdf5-napi"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "Node.js native addon (napi-rs) exposing clawhdf5-agent to TypeScript/JavaScript"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 
 [lib]
 crate-type = ["cdylib"]
 
 [dependencies]
-clawhdf5-agent = { path = "../clawhdf5-agent", version = "2.1.0" }
+clawhdf5-agent = { path = "../clawhdf5-agent", version = "2.3.0" }
 napi = { version = "2", default-features = false, features = ["napi9"] }
 napi-derive = "2"
 

crates/clawhdf5-netcdf4/Cargo.toml

@@ -1,17 +1,17 @@
 [package]
 name = "clawhdf5-netcdf4"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "NetCDF-4 read support built on rustyhdf5 — pure Rust, no C dependencies"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["netcdf", "netcdf4", "hdf5", "science", "climate"]
 categories = ["parser-implementations", "science"]
 
 [dependencies]
-clawhdf5 = { path = "../clawhdf5", version = "2.1.0" }
+clawhdf5 = { path = "../clawhdf5", version = "2.3.0" }
-clawhdf5-format = { path = "../clawhdf5-format", version = "2.1.0" }
+clawhdf5-format = { path = "../clawhdf5-format", version = "2.3.0" }
 
 [dev-dependencies]
 tempfile = { workspace = true }

crates/clawhdf5-netcdf4/src/cf.rs

@@ -142,6 +142,7 @@ fn get_fill_value(attrs: &HashMap<String, AttrValue>, key: &str) -> Option<FillV
         Some(AttrValue::String(s)) => Some(FillValue::String(s.clone())),
         Some(AttrValue::F64Array(arr)) if !arr.is_empty() => Some(FillValue::Float(arr[0])),
         Some(AttrValue::I64Array(arr)) if !arr.is_empty() => Some(FillValue::Int(arr[0])),
+        Some(AttrValue::U64Array(arr)) if !arr.is_empty() => Some(FillValue::UInt(arr[0])),
         _ => None,
     }
 }
@@ -155,6 +156,10 @@ fn get_valid_range(attrs: &HashMap<String, AttrValue>) -> Option<(f64, f64)> {
         Some(AttrValue::I64Array(arr)) if arr.len() >= 2 => {
             return Some((arr[0] as f64, arr[1] as f64));
         }
+        // Unsigned variables (NC_UBYTE..NC_UINT64) carry unsigned attributes.
+        Some(AttrValue::U64Array(arr)) if arr.len() >= 2 => {
+            return Some((arr[0] as f64, arr[1] as f64));
+        }
         _ => {}
     }
 

crates/clawhdf5-netcdf4/tests/interop_tests.rs

@@ -10,6 +10,12 @@ use clawhdf5_netcdf4::{AttrValue, NetCDF4File};
 // Helpers
 // ---------------------------------------------------------------------------
 
+/// When `CLAWHDF5_REQUIRE_INTEROP=1` (set in CI), a missing Python dependency
+/// is a test failure instead of a silent skip.
+fn interop_required() -> bool {
+    std::env::var("CLAWHDF5_REQUIRE_INTEROP").is_ok_and(|v| v == "1")
+}
+
 fn netcdf4_python_available() -> bool {
     Command::new("python3")
         .args(["-c", "import netCDF4; print(netCDF4.__version__)"])
@@ -29,6 +35,10 @@ fn xarray_available() -> bool {
 macro_rules! skip_if_no_netcdf4 {
     () => {
         if !netcdf4_python_available() {
+            assert!(
+                !interop_required(),
+                "CLAWHDF5_REQUIRE_INTEROP=1 but python3 with netCDF4 is not available"
+            );
             eprintln!("SKIP: python3 with netCDF4 not available");
             return;
         }
@@ -38,6 +48,10 @@ macro_rules! skip_if_no_netcdf4 {
 macro_rules! skip_if_no_xarray {
     () => {
         if !xarray_available() {
+            assert!(
+                !interop_required(),
+                "CLAWHDF5_REQUIRE_INTEROP=1 but python3 with xarray is not available"
+            );
             eprintln!("SKIP: python3 with xarray not available");
             return;
         }

crates/clawhdf5-py/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "clawhdf5-py"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "Python bindings for rustyhdf5 — a pure-Rust HDF5 library"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "python", "bindings", "science"]
 categories = ["api-bindings", "science"]
@@ -14,8 +14,8 @@ name = "clawhdf5"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-clawhdf5_rs = { path = "../clawhdf5", version = "2.1.0", package = "clawhdf5" }
+clawhdf5_rs = { path = "../clawhdf5", version = "2.3.0", package = "clawhdf5" }
-clawhdf5-format = { path = "../clawhdf5-format", version = "2.1.0" }
+clawhdf5-format = { path = "../clawhdf5-format", version = "2.3.0" }
 pyo3 = "0.29"
 numpy = "0.29"
 

crates/clawhdf5-py/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rustyhdf5"
-version = "2.1.0"
+version = "2.3.0"
 description = "Python bindings for rustyhdf5 — a pure-Rust HDF5 library"
 requires-python = ">=3.8"
 license = { text = "MIT" }

crates/clawhdf5-py/src/lib.rs

@@ -128,10 +128,28 @@ pub(crate) fn attr_value_to_py(py: Python<'_>, val: &clawhdf5_rs::AttrValue) ->
             let list = pyo3::types::PyList::new(py, a).unwrap();
             list.into_any().unbind()
         }
+        clawhdf5_rs::AttrValue::U64Array(a) => {
+            let list = pyo3::types::PyList::new(py, a).unwrap();
+            list.into_any().unbind()
+        }
         clawhdf5_rs::AttrValue::StringArray(a) => {
             let list = pyo3::types::PyList::new(py, a).unwrap();
             list.into_any().unbind()
         }
+        // No Python-side decoding for this datatype: hand back everything
+        // needed to interpret it rather than dropping the attribute.
+        clawhdf5_rs::AttrValue::Raw {
+            datatype,
+            shape,
+            data,
+        } => {
+            let dict = pyo3::types::PyDict::new(py);
+            dict.set_item("dtype", format!("{datatype:?}")).unwrap();
+            dict.set_item("shape", shape).unwrap();
+            dict.set_item("data", pyo3::types::PyBytes::new(py, data))
+                .unwrap();
+            dict.into_any().unbind()
+        }
     }
 }
 

crates/clawhdf5/Cargo.toml

@@ -1,25 +1,25 @@
 [package]
 name = "clawhdf5"
-version = "2.1.0"
+version = "2.3.0"
 edition = "2024"
 description = "Pure-Rust HDF5 reader/writer — no C dependencies"
 license = "MIT"
-repository = "https://github.com/redclawsystems/clawhdf5"
+repository = "https://git.redclaw.dev/quantumclaw/clawhdf5"
 readme = "README.md"
 keywords = ["hdf5", "science", "data", "binary"]
 categories = ["parser-implementations", "science", "encoding"]
 
 [dependencies]
-clawhdf5-format = { path = "../clawhdf5-format", version = "2.1.0" }
+clawhdf5-format = { path = "../clawhdf5-format", version = "2.3.0" }
-clawhdf5-io = { path = "../clawhdf5-io", version = "2.1.0" }
+clawhdf5-io = { path = "../clawhdf5-io", version = "2.3.0" }
 rayon = { version = "1", optional = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }
 criterion = { workspace = true }
-clawhdf5-io = { path = "../clawhdf5-io", version = "2.1.0", features = ["mmap"] }
+clawhdf5-io = { path = "../clawhdf5-io", version = "2.3.0", features = ["mmap"] }
-clawhdf5-format = { path = "../clawhdf5-format", version = "2.1.0", features = ["parallel", "fast-checksum"] }
+clawhdf5-format = { path = "../clawhdf5-format", version = "2.3.0", features = ["parallel", "fast-checksum"] }
-clawhdf5-filters = { path = "../clawhdf5-filters", version = "2.1.0" }
+clawhdf5-filters = { path = "../clawhdf5-filters", version = "2.3.0" }
 
 [[bench]]
 name = "mmap_bench"
@@ -30,7 +30,7 @@ name = "parallel_bench"
 harness = false
 
 [features]
-default = ["mmap", "fast-deflate"]
+default = ["mmap", "fast-deflate", "provenance"]
 mmap = ["clawhdf5-io/mmap"]
 parallel = ["clawhdf5-format/parallel", "rayon"]
 fast-deflate = ["clawhdf5-format/fast-deflate"]
@@ -39,6 +39,10 @@ zstd = ["clawhdf5-format/zstd"]
 blake3_hash = ["clawhdf5-format/blake3_hash"]
 lz4 = ["clawhdf5-format/lz4"]
 pcodec = ["clawhdf5-format/pcodec"]
+# Dataset::verify_provenance() — recompute a dataset's SHA-256 and compare
+# against its stored _provenance_sha256 attribute. On by default, matching
+# clawhdf5-format's own default-on `provenance` feature.
+provenance = ["clawhdf5-format/provenance"]
 
 [package.metadata.docs.rs]
 features = ["mmap"]

crates/clawhdf5/src/lazy.rs

@@ -416,15 +416,43 @@ impl<'f, R: HDF5Read> LazyDataset<'f, R> {
         ))
     }
 
+    /// A header message's payload, resolved through the shared-message
+    /// indirection when needed (e.g. a committed datatype). See
+    /// [`clawhdf5_format::shared_message::message_data`].
+    fn message_payload(
+        &self,
+        msg_type: MessageType,
+    ) -> Result<Option<std::borrow::Cow<'_, [u8]>>, Error> {
+        self.header
+            .messages
+            .iter()
+            .find(|m| m.msg_type == msg_type)
+            .map(|msg| {
+                clawhdf5_format::shared_message::message_data(
+                    self.file.as_bytes(),
+                    msg,
+                    self.file.offset_size(),
+                    self.file.length_size(),
+                )
+                .map_err(Error::Format)
+            })
+            .transpose()
+    }
+
+    fn required_payload(&self, msg_type: MessageType) -> Result<std::borrow::Cow<'_, [u8]>, Error> {
+        self.message_payload(msg_type)?
+            .ok_or(Error::MissingMessage(msg_type))
+    }
+
     fn datatype(&self) -> Result<Datatype, Error> {
-        let msg = find_message(&self.header, MessageType::Datatype)?;
+        let data = self.required_payload(MessageType::Datatype)?;
-        let (dt, _) = Datatype::parse(&msg.data)?;
+        let (dt, _) = Datatype::parse(&data)?;
         Ok(dt)
     }
 
     fn dataspace(&self) -> Result<Dataspace, Error> {
-        let msg = find_message(&self.header, MessageType::Dataspace)?;
+        let data = self.required_payload(MessageType::Dataspace)?;
-        Ok(Dataspace::parse(&msg.data, self.file.length_size())?)
+        Ok(Dataspace::parse(&data, self.file.length_size())?)
     }
 
     fn data_layout(&self) -> Result<DataLayout, Error> {
@@ -436,29 +464,43 @@ impl<'f, R: HDF5Read> LazyDataset<'f, R> {
         )?)
     }
 
-    fn filter_pipeline(&self) -> Option<FilterPipeline> {
+    /// `Ok(None)` means the dataset has no filter pipeline. A pipeline message
-        self.header
+    /// that is present but unparseable is an error: treating it as "no
-            .messages
+    /// filters" would hand the caller the still-compressed bytes as if they
-            .iter()
+    /// were the data.
-            .find(|m| m.msg_type == MessageType::FilterPipeline)
+    fn filter_pipeline(&self) -> Result<Option<FilterPipeline>, Error> {
-            .and_then(|msg| FilterPipeline::parse(&msg.data).ok())
+        self.message_payload(MessageType::FilterPipeline)?
+            .map(|data| FilterPipeline::parse(&data).map_err(Error::Format))
+            .transpose()
     }
 
     fn read_raw(&self) -> Result<Vec<u8>, Error> {
         let dt = self.datatype()?;
         let ds = self.dataspace()?;
         let dl = self.data_layout()?;
-        let pipeline = self.filter_pipeline();
+        let pipeline = self.filter_pipeline()?;
         let data = self.file.reader.as_bytes();
-        Ok(data_read::read_raw_data_full(
+        // Unallocated storage reads as the dataset's fill value.
+        clawhdf5_format::fill_value::read_full_with_fill(
+            &self.header.messages,
             data,
             &dl,
             &ds,
-            &dt,
+            dt.type_size() as usize,
-            pipeline.as_ref(),
             self.file.offset_size(),
             self.file.length_size(),
-        )?)
+            || {
+                Ok(data_read::read_raw_data_full(
+                    data,
+                    &dl,
+                    &ds,
+                    &dt,
+                    pipeline.as_ref(),
+                    self.file.offset_size(),
+                    self.file.length_size(),
+                )?)
+            },
+        )
     }
 }
 

crates/clawhdf5/src/lib.rs

@@ -48,6 +48,8 @@ pub use clawhdf5_format::dict_encoding::{DictEncoded, DictionaryEncoder};
 pub use clawhdf5_format::property_list::{
     DatasetCreateProps, FileAccessProps, FileCreateProps, lib_version,
 };
+#[cfg(feature = "provenance")]
+pub use clawhdf5_format::provenance;
 pub use clawhdf5_format::selection::Selection;
 pub use clawhdf5_format::superblock::swmr_flags;
 pub use clawhdf5_format::type_builders::{CompoundTypeBuilder, EnumTypeBuilder, FillTime};
@@ -467,13 +469,10 @@ mod tests {
         let ds = file.dataset("data").unwrap();
 
         // Zero-copy should succeed for contiguous LE f64 on mmap
-        match ds.read_f64_zerocopy() {
+        if let Ok(slice) = ds.read_f64_zerocopy() {
-            Ok(slice) => {
+            assert_eq!(slice, &original[..]);
-                assert_eq!(slice, &original[..]);
+            assert_eq!(slice, &ds.read_f64().unwrap()[..]);
-                assert_eq!(slice, &ds.read_f64().unwrap()[..]);
+        } // else: alignment issue, acceptable
-            }
-            Err(_) => {} // alignment issue, acceptable
-        }
         assert_eq!(ds.read_f64().unwrap(), original);
 
         std::fs::remove_file(&path).ok();

crates/clawhdf5/src/mmap_file.rs

@@ -357,15 +357,43 @@ impl<'f> MmapDataset<'f> {
         ))
     }
 
+    /// A header message's payload, resolved through the shared-message
+    /// indirection when needed (e.g. a committed datatype). See
+    /// [`clawhdf5_format::shared_message::message_data`].
+    fn message_payload(
+        &self,
+        msg_type: MessageType,
+    ) -> Result<Option<std::borrow::Cow<'_, [u8]>>, Error> {
+        self.header
+            .messages
+            .iter()
+            .find(|m| m.msg_type == msg_type)
+            .map(|msg| {
+                clawhdf5_format::shared_message::message_data(
+                    self.file.as_bytes(),
+                    msg,
+                    self.file.offset_size(),
+                    self.file.length_size(),
+                )
+                .map_err(Error::Format)
+            })
+            .transpose()
+    }
+
+    fn required_payload(&self, msg_type: MessageType) -> Result<std::borrow::Cow<'_, [u8]>, Error> {
+        self.message_payload(msg_type)?
+            .ok_or(Error::MissingMessage(msg_type))
+    }
+
     fn datatype(&self) -> Result<Datatype, Error> {
-        let msg = find_message(&self.header, MessageType::Datatype)?;
+        let data = self.required_payload(MessageType::Datatype)?;
-        let (dt, _) = Datatype::parse(&msg.data)?;
+        let (dt, _) = Datatype::parse(&data)?;
         Ok(dt)
     }
 
     fn dataspace(&self) -> Result<Dataspace, Error> {
-        let msg = find_message(&self.header, MessageType::Dataspace)?;
+        let data = self.required_payload(MessageType::Dataspace)?;
-        Ok(Dataspace::parse(&msg.data, self.file.length_size())?)
+        Ok(Dataspace::parse(&data, self.file.length_size())?)
     }
 
     fn data_layout(&self) -> Result<DataLayout, Error> {
@@ -377,28 +405,42 @@ impl<'f> MmapDataset<'f> {
         )?)
     }
 
-    fn filter_pipeline(&self) -> Option<FilterPipeline> {
+    /// `Ok(None)` means the dataset has no filter pipeline. A pipeline message
-        self.header
+    /// that is present but unparseable is an error: treating it as "no
-            .messages
+    /// filters" would hand the caller the still-compressed bytes as if they
-            .iter()
+    /// were the data.
-            .find(|m| m.msg_type == MessageType::FilterPipeline)
+    fn filter_pipeline(&self) -> Result<Option<FilterPipeline>, Error> {
-            .and_then(|msg| FilterPipeline::parse(&msg.data).ok())
+        self.message_payload(MessageType::FilterPipeline)?
+            .map(|data| FilterPipeline::parse(&data).map_err(Error::Format))
+            .transpose()
     }
 
     fn read_raw(&self) -> Result<Vec<u8>, Error> {
         let dt = self.datatype()?;
         let ds = self.dataspace()?;
         let dl = self.data_layout()?;
-        let pipeline = self.filter_pipeline();
+        let pipeline = self.filter_pipeline()?;
-        Ok(data_read::read_raw_data_full(
+        // Unallocated storage reads as the dataset's fill value.
+        clawhdf5_format::fill_value::read_full_with_fill(
+            &self.header.messages,
             self.file.reader.as_bytes(),
             &dl,
             &ds,
-            &dt,
+            dt.type_size() as usize,
-            pipeline.as_ref(),
             self.file.offset_size(),
             self.file.length_size(),
-        )?)
+            || {
+                Ok(data_read::read_raw_data_full(
+                    self.file.reader.as_bytes(),
+                    &dl,
+                    &ds,
+                    &dt,
+                    pipeline.as_ref(),
+                    self.file.offset_size(),
+                    self.file.length_size(),
+                )?)
+            },
+        )
     }
 }
 

crates/clawhdf5/src/reader.rs

@@ -447,7 +447,25 @@ impl<'f> Dataset<'f> {
         let dt = self.datatype()?;
         let ds = self.dataspace()?;
         let dl = self.data_layout()?;
-        let pipeline = self.filter_pipeline();
+        let pipeline = self.filter_pipeline()?;
+        // The selection reader knows nothing about fill values. When they
+        // matter — no storage at all, or a non-zero fill on a chunked (possibly
+        // sparse) dataset — select from a fill-aware full read instead. (The
+        // selection reader currently decodes the full dataset too, so this
+        // costs nothing extra.)
+        let fill = clawhdf5_format::fill_value::dataset_fill_value(&self.header.messages)?;
+        let fill_matters = !clawhdf5_format::fill_value::has_storage(&dl)
+            || (matches!(dl, DataLayout::Chunked { .. })
+                && !clawhdf5_format::fill_value::is_default(fill.as_deref()));
+        if fill_matters {
+            let full = self.read_raw()?;
+            return Ok(data_read::extract_selection_from_buffer(
+                &full,
+                &ds.dimensions,
+                dt.type_size() as usize,
+                selection,
+            )?);
+        }
         Ok(data_read::read_raw_data_selection(
             self.file.data.as_bytes(),
             &dl,
@@ -698,15 +716,68 @@ impl<'f> Dataset<'f> {
         ))
     }
 
+    /// Verify this dataset's content against its stored provenance hash
+    /// (`_provenance_sha256`, written automatically on save when a
+    /// [`Provenance`](clawhdf5_format::provenance::Provenance) is set — see
+    /// that module's docs). Returns `VerifyResult::NoHash` if the dataset
+    /// was never written with one.
+    ///
+    /// This decodes and hashes the *entire* dataset, so unlike the other
+    /// read methods it is not run automatically on `open()`/`dataset()` —
+    /// call it explicitly where the cost of a full read is acceptable (e.g.
+    /// a periodic integrity sweep, not the hot read path).
+    ///
+    /// The hash is unkeyed and stored alongside the data it protects, so
+    /// this only detects *accidental* corruption — anyone able to modify the
+    /// dataset can also recompute and overwrite the stored hash. A `VerifyResult::Ok`
+    /// result is not a tamper-evidence or authenticity guarantee.
+    #[cfg(feature = "provenance")]
+    pub fn verify_provenance(&self) -> Result<clawhdf5_format::provenance::VerifyResult, Error> {
+        Ok(clawhdf5_format::provenance::verify_dataset(
+            self.file.as_bytes(),
+            &self.header,
+            self.file.offset_size(),
+            self.file.length_size(),
+        )?)
+    }
+
+    /// A header message's payload, resolved through the shared-message
+    /// indirection when needed (e.g. a committed datatype). See
+    /// [`clawhdf5_format::shared_message::message_data`].
+    fn message_payload(
+        &self,
+        msg_type: MessageType,
+    ) -> Result<Option<std::borrow::Cow<'_, [u8]>>, Error> {
+        self.header
+            .messages
+            .iter()
+            .find(|m| m.msg_type == msg_type)
+            .map(|msg| {
+                clawhdf5_format::shared_message::message_data(
+                    self.file.as_bytes(),
+                    msg,
+                    self.file.offset_size(),
+                    self.file.length_size(),
+                )
+                .map_err(Error::Format)
+            })
+            .transpose()
+    }
+
+    fn required_payload(&self, msg_type: MessageType) -> Result<std::borrow::Cow<'_, [u8]>, Error> {
+        self.message_payload(msg_type)?
+            .ok_or(Error::MissingMessage(msg_type))
+    }
+
     fn datatype(&self) -> Result<Datatype, Error> {
-        let msg = find_message(&self.header, MessageType::Datatype)?;
+        let data = self.required_payload(MessageType::Datatype)?;
-        let (dt, _) = Datatype::parse(&msg.data)?;
+        let (dt, _) = Datatype::parse(&data)?;
         Ok(dt)
     }
 
     fn dataspace(&self) -> Result<Dataspace, Error> {
-        let msg = find_message(&self.header, MessageType::Dataspace)?;
+        let data = self.required_payload(MessageType::Dataspace)?;
-        Ok(Dataspace::parse(&msg.data, self.file.length_size())?)
+        Ok(Dataspace::parse(&data, self.file.length_size())?)
     }
 
     fn data_layout(&self) -> Result<DataLayout, Error> {
@@ -718,19 +789,21 @@ impl<'f> Dataset<'f> {
         )?)
     }
 
-    fn filter_pipeline(&self) -> Option<FilterPipeline> {
+    /// `Ok(None)` means the dataset has no filter pipeline. A pipeline message
-        self.header
+    /// that is present but unparseable is an error: treating it as "no
-            .messages
+    /// filters" would hand the caller the still-compressed bytes as if they
-            .iter()
+    /// were the data.
-            .find(|m| m.msg_type == MessageType::FilterPipeline)
+    fn filter_pipeline(&self) -> Result<Option<FilterPipeline>, Error> {
-            .and_then(|msg| FilterPipeline::parse(&msg.data).ok())
+        self.message_payload(MessageType::FilterPipeline)?
+            .map(|data| FilterPipeline::parse(&data).map_err(Error::Format))
+            .transpose()
     }
 
     fn read_raw(&self) -> Result<Vec<u8>, Error> {
         let dt = self.datatype()?;
         let ds = self.dataspace()?;
         let dl = self.data_layout()?;
-        let pipeline = self.filter_pipeline();
+        let pipeline = self.filter_pipeline()?;
 
         // Virtual datasets are assembled from source datasets; the per-file
         // chunk cache does not apply. Route them through the resolver path so
@@ -739,7 +812,7 @@ impl<'f> Dataset<'f> {
             let base_dir = self.file.base_dir.clone();
             let resolver = move |name: &str| -> Option<Vec<u8>> {
                 let dir = base_dir.as_ref()?;
-                std::fs::read(dir.join(name)).ok()
+                std::fs::read(dir.join(sibling_file_name(name)?)).ok()
             };
             return Ok(data_read::read_raw_data_full_with_resolver(
                 self.file.data.as_bytes(),
@@ -753,16 +826,28 @@ impl<'f> Dataset<'f> {
             )?);
         }
 
-        Ok(data_read::read_raw_data_cached(
+        // Unallocated storage reads as the dataset's fill value.
+        clawhdf5_format::fill_value::read_full_with_fill(
+            &self.header.messages,
             self.file.data.as_bytes(),
             &dl,
             &ds,
-            &dt,
+            dt.type_size() as usize,
-            pipeline.as_ref(),
             self.file.offset_size(),
             self.file.length_size(),
-            &self.file.chunk_cache,
+            || {
-        )?)
+                Ok(data_read::read_raw_data_cached(
+                    self.file.data.as_bytes(),
+                    &dl,
+                    &ds,
+                    &dt,
+                    pipeline.as_ref(),
+                    self.file.offset_size(),
+                    self.file.length_size(),
+                    &self.file.chunk_cache,
+                )?)
+            },
+        )
     }
 }
 
@@ -803,6 +888,23 @@ fn datatype_byte_order(dt: &Datatype) -> DatatypeByteOrder {
     }
 }
 
+/// A source-file name taken from inside an HDF5 file, accepted only if it
+/// stays within the directory of the file that named it.
+///
+/// The name is untrusted input. Joining it blindly lets a crafted file make
+/// the reader open any path the process can reach — an absolute path replaces
+/// the base directory entirely, and `..` components climb out of it. Only
+/// plain relative paths made of normal components are allowed.
+fn sibling_file_name(name: &str) -> Option<&std::path::Path> {
+    use std::path::Component;
+    let path = std::path::Path::new(name);
+    let mut components = path.components().peekable();
+    components.peek()?;
+    components
+        .all(|c| matches!(c, Component::Normal(_) | Component::CurDir))
+        .then_some(path)
+}
+
 fn find_message(
     header: &ObjectHeader,
     msg_type: MessageType,
@@ -856,3 +958,24 @@ fn resolve_group_entries(
         Ok(Vec::new())
     }
 }
+
+#[cfg(test)]
+mod sibling_file_name_tests {
+    use super::sibling_file_name;
+
+    #[test]
+    fn only_paths_inside_the_base_directory_are_accepted() {
+        for ok in ["source.h5", "./source.h5", "sub/dir/source.h5"] {
+            assert!(sibling_file_name(ok).is_some(), "{ok}");
+        }
+        for bad in [
+            "",
+            "/etc/passwd",
+            "../secret.h5",
+            "sub/../../secret.h5",
+            "sub/../ok.h5",
+        ] {
+            assert!(sibling_file_name(bad).is_none(), "{bad}");
+        }
+    }
+}

crates/clawhdf5/src/types.rs

@@ -163,13 +163,53 @@ pub(crate) fn attrs_to_map(
 ) -> HashMap<String, AttrValue> {
     let mut map = HashMap::new();
     for attr in attrs {
-        if let Some(val) = decode_attr_value(attr, file_data, offset_size, length_size) {
+        // Every attribute is reported. One that has no dedicated `AttrValue`
-            map.insert(attr.name.clone(), val);
+        // variant, or that fails to decode as its declared type, is returned
-        }
+        // verbatim as `AttrValue::Raw` rather than dropped — a partial
+        // attribute list with no indication anything is missing is worse than
+        // an undecoded value.
+        let val =
+            decode_attr_value(attr, file_data, offset_size, length_size).unwrap_or_else(|| {
+                AttrValue::Raw {
+                    datatype: attr.datatype.clone(),
+                    shape: attr.dataspace.dimensions.clone(),
+                    data: attr.raw_data.clone(),
+                }
+            });
+        map.insert(attr.name.clone(), val);
     }
     map
 }
 
+/// `Some(values)` if `attr` is a numpy/h5py-style boolean: an enumeration over
+/// an integer base type whose members are exactly `FALSE` = 0 and `TRUE` = 1.
+/// This is how `attrs["flag"] = True` is stored. Reported as 0/1 integers.
+fn decode_bool_enum(attr: &clawhdf5_format::attribute::AttributeMessage) -> Option<Vec<i64>> {
+    use clawhdf5_format::datatype::Datatype;
+
+    let Datatype::Enumeration {
+        base_type, members, ..
+    } = &attr.datatype
+    else {
+        return None;
+    };
+    if members.len() != 2 {
+        return None;
+    }
+    let member_value = |name: &str| {
+        let m = members.iter().find(|m| m.name.eq_ignore_ascii_case(name))?;
+        clawhdf5_format::data_read::read_as_i64(&m.value, base_type)
+            .ok()?
+            .first()
+            .copied()
+    };
+    if member_value("FALSE")? != 0 || member_value("TRUE")? != 1 {
+        return None;
+    }
+    let values = clawhdf5_format::data_read::read_as_i64(&attr.raw_data, base_type).ok()?;
+    values.iter().all(|v| *v == 0 || *v == 1).then_some(values)
+}
+
 fn decode_attr_value(
     attr: &clawhdf5_format::attribute::AttributeMessage,
     file_data: &[u8],
@@ -200,12 +240,7 @@ fn decode_attr_value(
             if vals.len() == 1 {
                 Some(AttrValue::U64(vals[0]))
             } else {
-                // No U64Array variant, store as I64Array.
+                Some(AttrValue::U64Array(vals))
-                // NOTE: This cast is lossy for values > i64::MAX (bit 63 set).
-                // Those values will appear as negative i64. A dedicated U64Array
-                // variant would be needed to handle the full u64 range.
-                let i64_vals: Vec<i64> = vals.iter().map(|&v| v as i64).collect();
-                Some(AttrValue::I64Array(i64_vals))
             }
         }
         Datatype::String { .. } => {
@@ -228,6 +263,14 @@ fn decode_attr_value(
                 Some(AttrValue::StringArray(strings))
             }
         }
+        Datatype::Enumeration { .. } => {
+            let vals = decode_bool_enum(attr)?;
+            if vals.len() == 1 {
+                Some(AttrValue::I64(vals[0]))
+            } else {
+                Some(AttrValue::I64Array(vals))
+            }
+        }
         _ => None,
     }
 }

crates/clawhdf5/src/writer.rs

@@ -72,7 +72,7 @@ impl FileBuilder {
     /// Serialize and write the file to the given path.
     pub fn write<P: AsRef<std::path::Path>>(self, path: P) -> Result<(), Error> {
         let bytes = self.finish()?;
-        std::fs::write(path, bytes).map_err(Error::Io)
+        write_file_atomically(path.as_ref(), &bytes).map_err(Error::Io)
     }
 }
 
@@ -186,3 +186,86 @@ pub fn create_datasets_parallel(specs: Vec<DatasetSpec>) -> Result<Vec<u8>, Erro
     let bytes = clawhdf5_format::file_writer::finalize_parallel(blocks)?;
     Ok(bytes)
 }
+
+/// Write `bytes` to `path` so that a crash or power loss leaves either the old
+/// file or the complete new one — never a truncated mix. `std::fs::write`
+/// truncates the destination first, so dying mid-write used to destroy the
+/// existing file.
+fn write_file_atomically(path: &std::path::Path, bytes: &[u8]) -> std::io::Result<()> {
+    use std::io::Write;
+
+    // Same directory as the target, so the rename stays on one filesystem.
+    let mut tmp_name = path
+        .file_name()
+        .ok_or_else(|| {
+            std::io::Error::new(std::io::ErrorKind::InvalidInput, "path has no file name")
+        })?
+        .to_os_string();
+    tmp_name.push(format!(".tmp-{}", std::process::id()));
+    let tmp_path = path.with_file_name(tmp_name);
+
+    let result = (|| {
+        let mut f = std::fs::File::create(&tmp_path)?;
+        f.write_all(bytes)?;
+        f.sync_all()?;
+        std::fs::rename(&tmp_path, path)
+    })();
+    if result.is_err() {
+        let _ = std::fs::remove_file(&tmp_path);
+        return result;
+    }
+    // Make the rename itself durable. Best-effort: not every filesystem
+    // supports syncing a directory, and the new file is already in place.
+    #[cfg(unix)]
+    if let Some(dir) = path.parent() {
+        let dir = if dir.as_os_str().is_empty() {
+            std::path::Path::new(".")
+        } else {
+            dir
+        };
+        if let Ok(d) = std::fs::File::open(dir) {
+            let _ = d.sync_all();
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod atomic_write_tests {
+    use super::write_file_atomically;
+
+    fn entries(dir: &std::path::Path) -> Vec<String> {
+        let mut names: Vec<String> = std::fs::read_dir(dir)
+            .unwrap()
+            .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
+            .collect();
+        names.sort();
+        names
+    }
+
+    #[test]
+    fn replaces_existing_file_and_leaves_no_temp_behind() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let path = dir.path().join("out.h5");
+        std::fs::write(&path, b"old contents").unwrap();
+
+        write_file_atomically(&path, b"new").unwrap();
+
+        assert_eq!(std::fs::read(&path).unwrap(), b"new");
+        assert_eq!(entries(dir.path()), ["out.h5"]);
+    }
+
+    #[test]
+    fn failure_leaves_the_existing_file_untouched() {
+        let dir = tempfile::TempDir::new().unwrap();
+        // The target is a directory, so the final rename cannot succeed.
+        let path = dir.path().join("taken");
+        std::fs::create_dir(&path).unwrap();
+        std::fs::write(path.join("keep"), b"x").unwrap();
+
+        assert!(write_file_atomically(&path, b"new").is_err());
+
+        assert!(path.is_dir());
+        assert_eq!(entries(dir.path()), ["taken"], "temp file cleaned up");
+    }
+}