`979a1f3`

test(pack): unit matrix — format validation, integrity, migrations, packer F21, unpacker gates (14)

Authored by

espadonne 3 weeks ago

SHA: 979a1f3c73c89845f0490a1e42a8dc725d002a5a
Parents: e24f07b
Tree: 1a818df

6 changed files

Status	File	+
A	`tests/unit/pack/__init__.py`	0
A	`tests/unit/pack/test_format.py`	86
A	`tests/unit/pack/test_integrity.py`	124
A	`tests/unit/pack/test_migrations.py`	101
A	`tests/unit/pack/test_packer.py`	171
A	`tests/unit/pack/test_unpacker.py`	221

tests/unit/pack/__init__.pyadded

tests/unit/pack/test_format.pyadded

 +"""`PackHeader` + `PackManifest` validation (Sprint 14)."""
++
 +from __future__ import annotations
++
 +from datetime import datetime
++
 +import pytest
++
 +from dlm.pack.format import CURRENT_PACK_FORMAT_VERSION, PackHeader, PackManifest
++
++
 +def _valid_header_kwargs() -> dict[str, object]:
 +    return {
 +        "pack_format_version": 1,
 +        "created_at": datetime(2026, 4, 19, 12, 0, 0),
 +        "tool_version": "0.1.0",
 +        "content_type": "minimal",
 +        "platform_hint": "linux",
 +    }
++
++
 +class TestPackHeader:
 +    def test_minimal_accepted(self) -> None:
 +        h = PackHeader.model_validate(_valid_header_kwargs())
 +        assert h.pack_format_version == 1
 +        assert h.licensee_acceptance_url is None
++
 +    def test_version_must_be_positive(self) -> None:
 +        kwargs = _valid_header_kwargs() | {"pack_format_version": 0}
 +        with pytest.raises(ValueError):
 +            PackHeader.model_validate(kwargs)
++
 +    def test_content_type_must_match_literal(self) -> None:
 +        kwargs = _valid_header_kwargs() | {"content_type": "mystery"}
 +        with pytest.raises(ValueError):
 +            PackHeader.model_validate(kwargs)
++
 +    def test_extra_forbidden(self) -> None:
 +        kwargs = _valid_header_kwargs() | {"new_field": "oops"}
 +        with pytest.raises(ValueError):
 +            PackHeader.model_validate(kwargs)
++
 +    def test_licensee_url_round_trips(self) -> None:
 +        kwargs = _valid_header_kwargs() | {"licensee_acceptance_url": "https://example.com/accept"}
 +        h = PackHeader.model_validate(kwargs)
 +        assert h.licensee_acceptance_url == "https://example.com/accept"
++
 +    def test_frozen_forbids_mutation(self) -> None:
 +        h = PackHeader.model_validate(_valid_header_kwargs())
 +        with pytest.raises((ValueError, TypeError)):
 +            h.tool_version = "0.2.0"  # type: ignore[misc]
++
 +    def test_current_version_present(self) -> None:
 +        assert CURRENT_PACK_FORMAT_VERSION >= 1
++
++
 +class TestPackManifest:
 +    def test_minimal_accepted(self) -> None:
 +        m = PackManifest(
 +            dlm_id="01TEST",
 +            base_model="smollm2-135m",
 +            adapter_version=0,
 +            entries={},
 +            content_sha256="0" * 64,
 +        )
 +        assert m.adapter_version == 0
++
 +    def test_content_sha256_must_be_64_hex(self) -> None:
 +        with pytest.raises(ValueError):
 +            PackManifest(
 +                dlm_id="x",
 +                base_model="x",
 +                adapter_version=0,
 +                entries={},
 +                content_sha256="too-short",
 +            )
++
 +    def test_adapter_version_non_negative(self) -> None:
 +        with pytest.raises(ValueError):
 +            PackManifest(
 +                dlm_id="x",
 +                base_model="x",
 +                adapter_version=-1,
 +                entries={},
 +                content_sha256="0" * 64,
 +            )

tests/unit/pack/test_integrity.pyadded

 +"""`write_checksums` / `verify_checksums` / rollup_sha256 (Sprint 14)."""
++
 +from __future__ import annotations
++
 +import hashlib
 +from pathlib import Path
++
 +import pytest
++
 +from dlm.pack.errors import PackIntegrityError
 +from dlm.pack.integrity import (
 +    read_checksums,
 +    rollup_sha256,
 +    sha256_of_file,
 +    verify_checksums,
 +    write_checksums,
 +)
++
++
 +def _scratch_tree(tmp_path: Path) -> Path:
 +    root = tmp_path / "tree"
 +    root.mkdir()
 +    (root / "a.txt").write_text("alpha\n")
 +    (root / "b.txt").write_text("beta\n")
 +    (root / "sub").mkdir()
 +    (root / "sub" / "c.txt").write_text("gamma\n")
 +    return root
++
++
 +class TestWriteChecksums:
 +    def test_covers_all_regular_files(self, tmp_path: Path) -> None:
 +        root = _scratch_tree(tmp_path)
 +        checksums = write_checksums(root)
 +        assert set(checksums) == {"a.txt", "b.txt", "sub/c.txt"}
 +        assert (root / "CHECKSUMS.sha256").is_file()
++
 +    def test_hashes_match_hashlib(self, tmp_path: Path) -> None:
 +        root = _scratch_tree(tmp_path)
 +        checksums = write_checksums(root)
 +        expected = hashlib.sha256((root / "a.txt").read_bytes()).hexdigest()
 +        assert checksums["a.txt"] == expected
++
 +    def test_sorted_lines(self, tmp_path: Path) -> None:
 +        root = _scratch_tree(tmp_path)
 +        write_checksums(root)
 +        lines = (root / "CHECKSUMS.sha256").read_text().splitlines()
 +        relpaths = [line.split("  ", 1)[1] for line in lines]
 +        assert relpaths == sorted(relpaths)
++
 +    def test_exclude_skips_listed_paths(self, tmp_path: Path) -> None:
 +        root = _scratch_tree(tmp_path)
 +        checksums = write_checksums(root, exclude=["a.txt"])
 +        assert "a.txt" not in checksums
++
 +    def test_self_always_excluded(self, tmp_path: Path) -> None:
 +        """`CHECKSUMS.sha256` itself must never appear in the output."""
 +        root = _scratch_tree(tmp_path)
 +        checksums = write_checksums(root)
 +        assert "CHECKSUMS.sha256" not in checksums
++
++
 +class TestReadChecksums:
 +    def test_missing_file_raises(self, tmp_path: Path) -> None:
 +        with pytest.raises(PackIntegrityError):
 +            read_checksums(tmp_path)
++
 +    def test_malformed_line_raises(self, tmp_path: Path) -> None:
 +        (tmp_path / "CHECKSUMS.sha256").write_text("not a valid line\n")
 +        with pytest.raises(PackIntegrityError):
 +            read_checksums(tmp_path)
++
 +    def test_roundtrip(self, tmp_path: Path) -> None:
 +        root = _scratch_tree(tmp_path)
 +        original = write_checksums(root)
 +        parsed = read_checksums(root)
 +        assert parsed == original
++
++
 +class TestVerifyChecksums:
 +    def test_clean_tree_passes(self, tmp_path: Path) -> None:
 +        root = _scratch_tree(tmp_path)
 +        write_checksums(root)
 +        verify_checksums(root)  # no raise
++
 +    def test_corrupted_file_raises(self, tmp_path: Path) -> None:
 +        root = _scratch_tree(tmp_path)
 +        write_checksums(root)
 +        (root / "a.txt").write_text("tampered!\n")
 +        with pytest.raises(PackIntegrityError) as excinfo:
 +            verify_checksums(root)
 +        assert excinfo.value.relpath == "a.txt"
++
 +    def test_missing_file_raises(self, tmp_path: Path) -> None:
 +        root = _scratch_tree(tmp_path)
 +        write_checksums(root)
 +        (root / "b.txt").unlink()
 +        with pytest.raises(PackIntegrityError) as excinfo:
 +            verify_checksums(root)
 +        assert excinfo.value.relpath == "b.txt"
++
++
 +class TestRollup:
 +    def test_deterministic(self, tmp_path: Path) -> None:
 +        checksums = {"a": "1" * 64, "b": "2" * 64}
 +        assert rollup_sha256(checksums) == rollup_sha256(dict(checksums))
++
 +    def test_order_independent(self) -> None:
 +        a = rollup_sha256({"a": "1" * 64, "b": "2" * 64})
 +        b = rollup_sha256({"b": "2" * 64, "a": "1" * 64})
 +        assert a == b
++
 +    def test_different_inputs_differ(self) -> None:
 +        a = rollup_sha256({"a": "1" * 64})
 +        b = rollup_sha256({"a": "2" * 64})
 +        assert a != b
++
++
 +class TestSha256OfFile:
 +    def test_chunk_boundaries(self, tmp_path: Path) -> None:
 +        """File larger than the 1MB chunk size hashes correctly."""
 +        big = tmp_path / "big.bin"
 +        big.write_bytes(b"x" * (2 * 1024 * 1024 + 7))
 +        expected = hashlib.sha256(big.read_bytes()).hexdigest()
 +        assert sha256_of_file(big) == expected

tests/unit/pack/test_migrations.pyadded

 +"""Pack-migration registry + dispatcher + coverage enforcement (Sprint 14)."""
++
 +from __future__ import annotations
++
 +from collections.abc import Iterator
 +from pathlib import Path
++
 +import pytest
++
 +from dlm.pack.errors import PackFormatVersionError
 +from dlm.pack.format import CURRENT_PACK_FORMAT_VERSION
 +from dlm.pack.migrations import PACK_MIGRATORS, register
 +from dlm.pack.migrations.dispatch import apply_pending
++
++
 +@pytest.fixture
 +def scratch_registry() -> Iterator[None]:
 +    """Snapshot + restore PACK_MIGRATORS around mutative tests."""
 +    saved = dict(PACK_MIGRATORS)
 +    try:
 +        PACK_MIGRATORS.clear()
 +        yield
 +    finally:
 +        PACK_MIGRATORS.clear()
 +        PACK_MIGRATORS.update(saved)
++
++
 +class TestRegister:
 +    def test_duplicate_raises(self, scratch_registry: None) -> None:
 +        @register(from_version=1)
 +        def _a(root: Path) -> Path:
 +            return root
++
 +        with pytest.raises(AssertionError, match="duplicate pack migrator"):
++
 +            @register(from_version=1)
 +            def _b(root: Path) -> Path:
 +                return root
++
++
 +class TestApplyPending:
 +    def test_already_current_is_noop(self, scratch_registry: None, tmp_path: Path) -> None:
 +        root, applied = apply_pending(tmp_path, from_version=CURRENT_PACK_FORMAT_VERSION)
 +        assert root == tmp_path
 +        assert applied == []
++
 +    def test_newer_than_current_raises(self, scratch_registry: None, tmp_path: Path) -> None:
 +        with pytest.raises(PackFormatVersionError):
 +            apply_pending(tmp_path, from_version=CURRENT_PACK_FORMAT_VERSION + 1)
++
 +    def test_chain_runs(self, scratch_registry: None, tmp_path: Path) -> None:
 +        calls: list[int] = []
++
 +        @register(from_version=1)
 +        def _v1_to_v2(root: Path) -> Path:
 +            calls.append(1)
 +            return root
++
 +        @register(from_version=2)
 +        def _v2_to_v3(root: Path) -> Path:
 +            calls.append(2)
 +            return root
++
 +        # Simulate CURRENT=3 by targeting directly.
 +        # (We can't mutate CURRENT safely; just verify the chain with
 +        # a manual loop equivalent.)
 +        # Use apply_pending with a temporary bump via monkeypatch.
 +        import dlm.pack.migrations.dispatch as dispatch_module
++
 +        original = dispatch_module.CURRENT_PACK_FORMAT_VERSION
 +        dispatch_module.CURRENT_PACK_FORMAT_VERSION = 3
 +        try:
 +            apply_pending(tmp_path, from_version=1)
 +        finally:
 +            dispatch_module.CURRENT_PACK_FORMAT_VERSION = original
 +        assert calls == [1, 2]
++
 +    def test_gap_in_registry_raises(self, scratch_registry: None, tmp_path: Path) -> None:
 +        # CURRENT=2 but no v1 migrator registered → gap.
 +        import dlm.pack.migrations.dispatch as dispatch_module
++
 +        original = dispatch_module.CURRENT_PACK_FORMAT_VERSION
 +        dispatch_module.CURRENT_PACK_FORMAT_VERSION = 2
 +        try:
 +            with pytest.raises(PackFormatVersionError):
 +                apply_pending(tmp_path, from_version=1)
 +        finally:
 +            dispatch_module.CURRENT_PACK_FORMAT_VERSION = original
++
++
 +class TestCoverageEnforcement:
 +    """A PR that bumps `CURRENT_PACK_FORMAT_VERSION` without registering a
 +    migrator fails this test. At v1 the expected range is empty."""
++
 +    def test_migrators_span_required_range(self) -> None:
 +        expected = set(range(1, CURRENT_PACK_FORMAT_VERSION))
 +        assert set(PACK_MIGRATORS.keys()) == expected, (
 +            f"PACK_MIGRATORS keys {sorted(PACK_MIGRATORS)!r} do not match "
 +            f"expected range [1, {CURRENT_PACK_FORMAT_VERSION}). Register a "
 +            "migrator under src/dlm/pack/migrations/ when bumping the version."
 +        )

tests/unit/pack/test_packer.pyadded

 +"""`dlm.pack.packer` — pack creation + content-type labelling + F21 gate (Sprint 14)."""
++
 +from __future__ import annotations
++
 +import tarfile
 +from pathlib import Path
 +from typing import Any
++
 +import pytest
 +from typer.testing import CliRunner
++
 +from dlm.cli.app import app
 +from dlm.pack.errors import BaseLicenseRefusedError
 +from dlm.pack.packer import pack
++
++
 +def _scaffold_doc_and_store(tmp_path: Path, *, base: str = "smollm2-135m") -> Path:
 +    """Create a .dlm + its ensure_layout'd store with a valid manifest."""
 +    from dlm.doc.parser import parse_file
 +    from dlm.store.manifest import Manifest, save_manifest
 +    from dlm.store.paths import for_dlm
++
 +    runner = CliRunner()
 +    doc = tmp_path / "doc.dlm"
 +    # Gated bases (e.g. llama-3.2) require --i-accept-license in non-interactive runs.
 +    result = runner.invoke(
 +        app,
 +        [
 +            "--home",
 +            str(tmp_path / "dlm-home"),
 +            "init",
 +            str(doc),
 +            "--base",
 +            base,
 +            "--i-accept-license",
 +        ],
 +    )
 +    assert result.exit_code == 0, result.output
++
 +    parsed = parse_file(doc)
 +    import os
++
 +    os.environ["DLM_HOME"] = str(tmp_path / "dlm-home")
 +    store = for_dlm(parsed.frontmatter.dlm_id)
 +    store.ensure_layout()
 +    save_manifest(store.manifest, Manifest(dlm_id=parsed.frontmatter.dlm_id, base_model=base))
 +    return doc
++
++
 +def _tar_members(pack_path: Path) -> list[tuple[str, int]]:
 +    import zstandard as zstd
++
 +    dctx = zstd.ZstdDecompressor()
 +    with pack_path.open("rb") as fh, dctx.stream_reader(fh) as reader:
 +        with tarfile.open(fileobj=reader, mode="r|") as tar:
 +            return [(m.name, m.size) for m in tar]
++
++
 +class TestPackShape:
 +    def test_contains_required_entries(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path)
 +        result = pack(doc)
++
 +        names = {name for name, _size in _tar_members(result.path)}
 +        assert "PACK_HEADER.json" in names
 +        assert "manifest.json" in names
 +        assert "CHECKSUMS.sha256" in names
 +        assert f"dlm/{doc.name}" in names
 +        assert "store/manifest.json" in names
++
 +    def test_default_out_path_next_to_dlm(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path)
 +        result = pack(doc)
 +        assert result.path == doc.with_suffix(doc.suffix + ".pack")
 +        assert result.path.is_file()
++
 +    def test_explicit_out_path(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path)
 +        custom = tmp_path / "sub" / "custom.pack"
 +        result = pack(doc, out=custom)
 +        assert result.path == custom
 +        assert custom.is_file()
++
++
 +class TestContentTypeLabel:
 +    def test_minimal_default(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path)
 +        result = pack(doc)
 +        assert result.content_type == "minimal"
++
 +    def test_include_exports_flips_to_no_base(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path)
 +        result = pack(doc, include_exports=True)
 +        assert result.content_type == "no-base"
++
 +    def test_include_base_flips_to_no_exports(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path)
 +        result = pack(doc, include_base=True)
 +        assert result.content_type == "no-exports"
++
 +    def test_both_flags_equal_full(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path)
 +        result = pack(doc, include_base=True, include_exports=True)
 +        assert result.content_type == "full"
++
++
 +class TestRedistributionGate:
 +    """Audit F21: --include-base on non-redistributable spec refuses unless licensee URL."""
++
 +    def test_refuses_without_licensee_url(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path, base="llama-3.2-1b")
 +        with pytest.raises(BaseLicenseRefusedError) as excinfo:
 +            pack(doc, include_base=True)
 +        assert excinfo.value.base_key == "llama-3.2-1b"
++
 +    def test_accepts_with_licensee_url(self, tmp_path: Path) -> None:
 +        doc = _scaffold_doc_and_store(tmp_path, base="llama-3.2-1b")
 +        result = pack(
 +            doc,
 +            include_base=True,
 +            licensee_acceptance_url="https://example.com/accept",
 +        )
 +        assert result.applied_licensee_url == "https://example.com/accept"
 +        # Header records the URL.
 +        import json
++
 +        import zstandard as zstd
++
 +        dctx = zstd.ZstdDecompressor()
 +        with result.path.open("rb") as fh, dctx.stream_reader(fh) as reader:
 +            with tarfile.open(fileobj=reader, mode="r|") as tar:
 +                for member in tar:
 +                    if member.name == "PACK_HEADER.json":
 +                        extracted = tar.extractfile(member)
 +                        assert extracted is not None
 +                        header = json.loads(extracted.read())
 +                        assert header["licensee_acceptance_url"] == "https://example.com/accept"
 +                        return
 +        pytest.fail("PACK_HEADER.json not found in tar")
++
 +    def test_redistributable_base_needs_no_licensee(self, tmp_path: Path) -> None:
 +        """Apache-licensed bases like smollm2 don't gate on the URL."""
 +        doc = _scaffold_doc_and_store(tmp_path, base="smollm2-135m")
 +        result = pack(doc, include_base=True)  # no licensee url
 +        assert result.content_type == "no-exports"
++
++
 +class TestStoreLock:
 +    def test_acquires_lock_during_pack(
 +        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 +    ) -> None:
 +        """The store exclusive lock must be held for the duration of the copy."""
 +        doc = _scaffold_doc_and_store(tmp_path)
++
 +        from dlm.doc.parser import parse_file
 +        from dlm.store.paths import for_dlm
++
 +        parsed = parse_file(doc)
 +        store = for_dlm(parsed.frontmatter.dlm_id)
++
 +        seen_lock_state: dict[str, bool] = {}
++
 +        original_copytree = __import__("shutil").copytree
++
 +        def watcher(*args: Any, **kwargs: Any) -> Any:
 +            seen_lock_state["locked"] = store.lock.exists()
 +            return original_copytree(*args, **kwargs)
++
 +        monkeypatch.setattr("shutil.copytree", watcher)
 +        pack(doc)
 +        assert seen_lock_state.get("locked") is True

tests/unit/pack/test_unpacker.pyadded

 +"""`dlm.pack.unpacker` — extract + verify + header gate + install (Sprint 14)."""
++
 +from __future__ import annotations
++
 +import json
 +import tarfile
 +import tempfile
 +from pathlib import Path
++
 +import pytest
 +import zstandard as zstd
++
 +from dlm.pack.errors import (
 +    PackFormatVersionError,
 +    PackIntegrityError,
 +    PackLayoutError,
 +)
 +from dlm.pack.integrity import rollup_sha256, write_checksums
 +from dlm.pack.layout import (
 +    HEADER_FILENAME,
 +    MANIFEST_FILENAME,
 +    SHA256_FILENAME,
 +)
 +from dlm.pack.unpacker import unpack
++
++
 +def _synth_pack(
 +    tmp_path: Path,
 +    *,
 +    pack_format_version: int = 1,
 +    content_override: bytes | None = None,
 +    skip_entry: str | None = None,
 +) -> Path:
 +    """Hand-assemble a tarball/zstd pack with full control over shape.
++
 +    Used to exercise the unpacker's header/layout/checksum gates
 +    without running the real packer (which always produces valid
 +    output).
 +    """
 +    staging = tmp_path / "stage"
 +    staging.mkdir()
 +    dlm_dir = staging / "dlm"
 +    dlm_dir.mkdir()
 +    (dlm_dir / "mydoc.dlm").write_text("---\ndlm_id: 01TEST\nbase_model: smollm2-135m\n---\n")
++
 +    store_dir = staging / "store"
 +    store_dir.mkdir()
 +    (store_dir / "manifest.json").write_text(
 +        json.dumps({"dlm_id": "01TEST", "base_model": "smollm2-135m"})
 +    )
++
 +    header = {
 +        "pack_format_version": pack_format_version,
 +        "created_at": "2026-04-19T12:00:00",
 +        "tool_version": "0.1.0",
 +        "content_type": "minimal",
 +        "platform_hint": "linux",
 +        "licensee_acceptance_url": None,
 +    }
 +    (staging / HEADER_FILENAME).write_text(json.dumps(header))
++
 +    checksums = write_checksums(staging, exclude=(SHA256_FILENAME, MANIFEST_FILENAME))
 +    pack_manifest = {
 +        "dlm_id": "01TEST",
 +        "base_model": "smollm2-135m",
 +        "base_model_revision": None,
 +        "base_model_sha256": None,
 +        "adapter_version": 0,
 +        "entries": {rel: (staging / rel).stat().st_size for rel in checksums},
 +        "content_sha256": rollup_sha256(checksums),
 +    }
 +    (staging / MANIFEST_FILENAME).write_text(json.dumps(pack_manifest))
++
 +    # Optional post-write mutations for negative tests.
 +    if content_override is not None:
 +        (staging / "dlm" / "mydoc.dlm").write_bytes(content_override)
 +    if skip_entry is not None:
 +        (staging / skip_entry).unlink()
++
 +    out = tmp_path / "synth.pack"
 +    cctx = zstd.ZstdCompressor(level=1)
 +    with out.open("wb") as fh, cctx.stream_writer(fh) as compressor:
 +        with tarfile.open(fileobj=compressor, mode="w|") as tar:
 +            for path in sorted(staging.rglob("*")):
 +                if path.is_file():
 +                    tar.add(path, arcname=path.relative_to(staging).as_posix())
 +    return out
++
++
 +class TestHappyPath:
 +    def test_unpacks_into_dlm_home(self, tmp_path: Path) -> None:
 +        pack_path = _synth_pack(tmp_path)
 +        result = unpack(pack_path, home=tmp_path / "home", out_dir=tmp_path / "out")
 +        assert result.dlm_id == "01TEST"
 +        assert result.store_path == tmp_path / "home" / "store" / "01TEST"
 +        assert (result.store_path / "manifest.json").exists()
 +        assert result.dlm_path == tmp_path / "out" / "mydoc.dlm"
 +        assert result.dlm_path.read_text().startswith("---")
++
++
 +class TestVersionGate:
 +    def test_newer_than_current_refused(self, tmp_path: Path) -> None:
 +        pack_path = _synth_pack(tmp_path, pack_format_version=999)
 +        with pytest.raises(PackFormatVersionError):
 +            unpack(pack_path, home=tmp_path / "home")
++
++
 +class TestIntegrity:
 +    def test_corrupted_pack_refused(self, tmp_path: Path) -> None:
 +        """Build a pack whose .dlm content disagrees with the recorded checksum."""
 +        staging = tmp_path / "stage"
 +        staging.mkdir()
 +        (staging / "dlm").mkdir()
 +        (staging / "dlm" / "x.dlm").write_text("original")
 +        (staging / "store").mkdir()
 +        (staging / "store" / "manifest.json").write_text("{}")
 +        (staging / HEADER_FILENAME).write_text(
 +            json.dumps(
 +                {
 +                    "pack_format_version": 1,
 +                    "created_at": "2026-04-19T12:00:00",
 +                    "tool_version": "0.1.0",
 +                    "content_type": "minimal",
 +                    "platform_hint": "linux",
 +                    "licensee_acceptance_url": None,
 +                }
 +            )
 +        )
++
 +        # Freeze checksums against the original content, then tamper.
 +        write_checksums(staging, exclude=(SHA256_FILENAME, MANIFEST_FILENAME))
 +        (staging / "dlm" / "x.dlm").write_text("TAMPERED!")
++
 +        # Manifest is required for layout but its content_sha256 isn't
 +        # rechecked at unpack (integrity gate catches the tamper first).
 +        (staging / MANIFEST_FILENAME).write_text(
 +            json.dumps(
 +                {
 +                    "dlm_id": "01TEST",
 +                    "base_model": "smollm2-135m",
 +                    "base_model_revision": None,
 +                    "base_model_sha256": None,
 +                    "adapter_version": 0,
 +                    "entries": {},
 +                    "content_sha256": "0" * 64,
 +                }
 +            )
 +        )
++
 +        out = tmp_path / "tampered.pack"
 +        cctx = zstd.ZstdCompressor(level=1)
 +        with out.open("wb") as fh, cctx.stream_writer(fh) as compressor:
 +            with tarfile.open(fileobj=compressor, mode="w|") as tar:
 +                for path in sorted(staging.rglob("*")):
 +                    if path.is_file():
 +                        tar.add(path, arcname=path.relative_to(staging).as_posix())
++
 +        with pytest.raises(PackIntegrityError):
 +            unpack(out, home=tmp_path / "home")
++
++
 +class TestLayoutGate:
 +    def test_missing_header_refused(self, tmp_path: Path) -> None:
 +        # Build a tarball without PACK_HEADER.json.
 +        staging = tmp_path / "stage"
 +        staging.mkdir()
 +        (staging / "dlm").mkdir()
 +        (staging / "dlm" / "x.dlm").write_text("x")
 +        (staging / "store").mkdir()
 +        (staging / "store" / "manifest.json").write_text("{}")
 +        (staging / MANIFEST_FILENAME).write_text("{}")
 +        write_checksums(staging, exclude=(SHA256_FILENAME, MANIFEST_FILENAME))
 +        out = tmp_path / "no-header.pack"
 +        cctx = zstd.ZstdCompressor(level=1)
 +        with out.open("wb") as fh, cctx.stream_writer(fh) as compressor:
 +            with tarfile.open(fileobj=compressor, mode="w|") as tar:
 +                for path in sorted(staging.rglob("*")):
 +                    if path.is_file():
 +                        tar.add(path, arcname=path.relative_to(staging).as_posix())
 +        with pytest.raises(PackLayoutError):
 +            unpack(out, home=tmp_path / "home")
++
 +    def test_unsafe_tar_entry_refused(self, tmp_path: Path) -> None:
 +        """An entry whose path escapes the extraction root is rejected."""
 +        staging = tmp_path / "s"
 +        staging.mkdir()
 +        evil = staging / "evil"
 +        evil.write_text("x")
 +        out = tmp_path / "evil.pack"
 +        cctx = zstd.ZstdCompressor(level=1)
 +        with out.open("wb") as fh, cctx.stream_writer(fh) as compressor:
 +            with tarfile.open(fileobj=compressor, mode="w|") as tar:
 +                info = tar.gettarinfo(evil, arcname="../escape")
 +                with evil.open("rb") as src:
 +                    tar.addfile(info, src)
 +        with pytest.raises(PackLayoutError):
 +            unpack(out, home=tmp_path / "home")
++
++
 +class TestForce:
 +    def test_existing_store_refused_without_force(self, tmp_path: Path) -> None:
 +        pack_path = _synth_pack(tmp_path)
 +        home = tmp_path / "home"
 +        unpack(pack_path, home=home, out_dir=tmp_path / "out1")
 +        # Second unpack without force fails because the store exists.
 +        with pytest.raises(PackIntegrityError):
 +            unpack(pack_path, home=home, out_dir=tmp_path / "out2")
++
 +    def test_force_replaces_existing_store(self, tmp_path: Path) -> None:
 +        pack_path = _synth_pack(tmp_path)
 +        home = tmp_path / "home"
 +        unpack(pack_path, home=home, out_dir=tmp_path / "out1")
 +        # Add a marker to the prior store; --force should wipe it.
 +        marker = home / "store" / "01TEST" / "marker.txt"
 +        marker.write_text("prior")
 +        unpack(pack_path, home=home, force=True, out_dir=tmp_path / "out2")
 +        assert not marker.exists()
++
++
 +# Keep tempfile import reachable for downstream contributors extending this file.
 +_ = tempfile