Restore the other files when a chunk is in no blob under --skip-errors (closes #326 )

Restore planning stopped at the first file needing a chunk that no blob holds, so --skip-errors never saw that file and nothing was restored. The planner now leaves such a file out of the plan and returns it with the reason, and each one goes through handleRestoreFileError like any other failed file: skipped and counted under --skip-errors, fatal without it. The fatal error now suggests --skip-errors, as other restore failures do. The skip-errors tests now share one backup helper; the new case removes a blob from the snapshot metadata and exports it again. Model: opus-5-5
2026-10-13 12:36:01 +00:00
158 changed files with 4244 additions and 14905 deletions
@@ -1,2 +0,0 @@
 node_modules/
 yarn.lock
@@ -1,4 +0,0 @@
 {
    "tabWidth": 4,
    "proseWrap": "always"
 }
@@ -4,122 +4,127 @@ Version: 2025-06-08
 # Instructions and Contextual Information
- Be direct, robotic, expert, accurate, and professional.
+* Be direct, robotic, expert, accurate, and professional.
- Do not butter me up or kiss my ass.
+* Do not butter me up or kiss my ass.
- Come in hot with strong opinions, even if they are contrary to the direction I
+* Come in hot with strong opinions, even if they are contrary to the
-  am headed.
+  direction I am headed.
- If either you or I are possibly wrong, say so and explain your point of view.
+* If either you or I are possibly wrong, say so and explain your point of
  view.
- Point out great alternatives I haven't thought of, even when I'm not asking
+* Point out great alternatives I haven't thought of, even when I'm not
-  for them.
+  asking for them.
- Treat me like the world's leading expert in every situation and every
+* Treat me like the world's leading expert in every situation and every
  conversation, and deliver the absolute best recommendations.
- I want excellence, so always be on the lookout for divergences from good data
+* I want excellence, so always be on the lookout for divergences from good
-  model design or best practices for object oriented development.
+  data model design or best practices for object oriented development.
- IMPORTANT: This is production code, not a research or teaching exercise.
+* IMPORTANT: This is production code, not a research or teaching exercise.
  Deliver professional-level results, not prototypes.
- Please read and understand the `README.md` file in the root of the repo for
+* Please read and understand the `README.md` file in the root of the repo
-  project-specific contextual information, including development policies,
+  for project-specific contextual information, including development
-  practices, and current implementation status.
+  policies, practices, and current implementation status.
- Be proactive in suggesting improvements or refactorings in places where we
+* Be proactive in suggesting improvements or refactorings in places where we
  diverge from best practices for clean, modular, maintainable code.
 # Policies
 1. Before committing, tests must pass (`make test`), linting must pass
-   (`make lint`), and code must be formatted (`make fmt`). For go, those
+   (`make lint`), and code must be formatted (`make fmt`).  For go, those
   makefile targets should use `go fmt` and `go test -v ./...` and
-   `golangci-lint run`. Each Makefile target does exactly one thing — to run
+   `golangci-lint run`.  Each Makefile target does exactly one thing — to
-   lint + fmt-check + test together (the standard pre-commit gate), use
+   run lint + fmt-check + test together (the standard pre-commit gate),
-   `make check`.
+   use `make check`.
-2. Always write a `Makefile` with the default target being `test`, and with a
+2. Always write a `Makefile` with the default target being `test`, and with
-   `fmt` target that formats the code. The `test` target should run all tests in
+   a `fmt` target that formats the code.  The `test` target should run all
-   the project, and the `fmt` target should format the code. `test` should also
+   tests in the project, and the `fmt` target should format the code.
-   have a prerequisite target `lint` that should run any linters that are
+   `test` should also have a prerequisite target `lint` that should run any
-   configured for the project.
+   linters that are configured for the project.
-3. After each completed bugfix or feature, the code must be committed. Do all of
+3. After each completed bugfix or feature, the code must be committed.  Do
-   the pre-commit checks (test, lint, fmt) before committing, of course.
+   all of the pre-commit checks (test, lint, fmt) before committing, of
   course.
 4. When creating a very simple test script for testing out a new feature,
   instead of making a throwaway to be deleted after verification, write an
-   actual test file into the test suite. It doesn't need to be very big or
+   actual test file into the test suite.  It doesn't need to be very big or
   complex, but it should be a real test that can be run.
 5. When you are instructed to make the tests pass, DO NOT delete tests, skip
-   tests, or change the tests specifically to make them pass (unless there is a
+   tests, or change the tests specifically to make them pass (unless there
-   bug in the test). This is cheating, and it is bad. You should only be
+   is a bug in the test).  This is cheating, and it is bad.  You should only
-   modifying the test if it is incorrect or if the test is no longer relevant.
+   be modifying the test if it is incorrect or if the test is no longer
-   In almost all cases, you should be fixing the code that is being tested, or
+   relevant.  In almost all cases, you should be fixing the code that is
-   updating the tests to match a refactored implementation.
+   being tested, or updating the tests to match a refactored implementation.
 6. When dealing with dates and times or timestamps, always use, display, and
-   store UTC. Set the local timezone to UTC on startup. If the user needs to see
+   store UTC.  Set the local timezone to UTC on startup.  If the user needs
-   the time in a different timezone, store the user's timezone in a separate
+   to see the time in a different timezone, store the user's timezone in a
-   field and convert the UTC time to the user's timezone when displaying it. For
+   separate field and convert the UTC time to the user's timezone when
-   internal use and internal applications and administrative purposes, always
+   displaying it.  For internal use and internal applications and
-   display UTC.
+   administrative purposes, always display UTC.
 7. Always write tests, even if they are extremely simple and just check for
-   correct syntax (ability to compile/import). If you are writing a new feature,
+   correct syntax (ability to compile/import). If you are writing a new
-   write a test for it. You don't need to target complete coverage, but you
+   feature, write a test for it.  You don't need to target complete
-   should at least test any new functionality you add. If you are fixing a bug,
+   coverage, but you should at least test any new functionality you add.  If
-   write a test first that reproduces the bug, and then fix the bug in the code.
+   you are fixing a bug, write a test first that reproduces the bug, and
   then fix the bug in the code.
-8. When implementing new features, be aware of potential side-effects (such as
+8. When implementing new features, be aware of potential side-effects (such
-   state files on disk, data in the database, etc.) and ensure that it is
+   as state files on disk, data in the database, etc.) and ensure that it is
   possible to mock or stub these side-effects in tests.
-9. Always use structured logging. Log any relevant state/context with the
+9. Always use structured logging.  Log any relevant state/context with the
-   messages (but do not log secrets). If the log stream is not a terminal,
+   messages (but do not log secrets).  If the log stream is not a terminal,
   output the structured logs in jsonl format.
 10. Avoid using bare strings or numbers in code, especially if they appear
-    anywhere more than once. Always define a constant (usually at the top of the
+    anywhere more than once.  Always define a constant (usually at the top
-    file) and give it a descriptive name, then use that constant in the code
+    of the file) and give it a descriptive name, then use that constant in
-    instead of the bare string or number.
+    the code instead of the bare string or number.
 11. You do not need to summarize your changes in the chat after making them.
-    Making the changes and committing them is sufficient. If anything out of the
+    Making the changes and committing them is sufficient.  If anything out
-    ordinary happened, please explain it, but in the normal case where you found
+    of the ordinary happened, please explain it, but in the normal case
-    and fixed the bug, or implemented the feature, there is no need for the
+    where you found and fixed the bug, or implemented the feature, there is
-    end-of-change summary.
+    no need for the end-of-change summary.
-12. Do not create additional files in the root directory of the project without
+12. Do not create additional files in the root directory of the project
-    asking permission first. Configuration files, documentation, and build files
+    without asking permission first. Configuration files, documentation, and
-    are acceptable in the root, but source code and other files should be
+    build files are acceptable in the root, but source code and other files
-    organized in appropriate subdirectories.
+    should be organized in appropriate subdirectories.
 13. Pre-1.0: NEVER add a database migration. Migrations are supported, but
-    nothing is installed anywhere yet, so there is nothing to migrate. To change
+    nothing is installed anywhere yet, so there is nothing to migrate. To
-    the schema, edit `internal/database/schema/001.sql` (and any code that
+    change the schema, edit `internal/database/schema/001.sql` (and any
-    touches the affected tables) directly. After 1.0, each schema change is a
+    code that touches the affected tables) directly. After 1.0, each schema
-    new numbered file in that directory and a released file is never edited; an
+    change is a new numbered file in that directory and a released file is
-    existing local database is then migrated when vaultik is updated. Before
+    never edited; an existing local database is then migrated when vaultik
-    1.0, a local database left on an older schema is deleted and re-created by a
+    is updated. Before 1.0, a local database left on an older schema is
-    full backup. See [`docs/DATAMODEL.md`](docs/DATAMODEL.md#schema-migrations).
+    deleted and re-created by a full backup. See
    [`docs/DATAMODEL.md`](docs/DATAMODEL.md#schema-migrations).
-14. Never use `git add -A`. Stage only the files you intentionally changed.
+14. Never use `git add -A`.  Stage only the files you intentionally
    changed.
-15. Commit messages carry no attribution or advertising trailers for the tool
+15. Commit messages carry no attribution or advertising trailers for the
-    that helped write the code, or for its vendor: the owner is the sole author
+    tool that helped write the code, or for its vendor: the owner is the
-    of code written with a tool.
+    sole author of code written with a tool.
 16. Run the whole test suite with `make test` every time, and read its full
-    output. Never run `go test`, a single test or a single package, and never
+    output.  Never run `go test`, a single test or a single package, and
-    grep the output.
+    never grep the output.
 17. Do not stop working on a task until the definition of done given in the
    initial instruction is met: all of the work, not part or most of it.
-18. For estimates: backing up over 2.5Gbit/s ethernet to an S3 server backed by
+18. For estimates: backing up over 2.5Gbit/s ethernet to an S3 server
-    2000MB/sec SSD takes about 4 seconds per gigabyte.
+    backed by 2000MB/sec SSD takes about 4 seconds per gigabyte.
@@ -0,0 +1,392 @@
 # Vaultik Architecture
 This document describes the internal architecture of Vaultik, focusing on the data model, type instantiation, and the relationships between core modules.
 ## Overview
 Vaultik is a backup system that uses content-defined chunking for deduplication and packs chunks into large, compressed, encrypted blobs for efficient cloud storage. The system is built around dependency injection using [uber-go/fx](https://github.com/uber-go/fx).
 ## Data Flow
 ```
 Source Files
     │
     ▼
 ┌─────────────────┐
 │    Scanner      │  Walks directories, detects changed files
 └────────┬────────┘
         │
         ▼
 ┌─────────────────┐
 │    Chunker      │  Splits files into variable-size chunks (FastCDC)
 └────────┬────────┘
         │
         ▼
 ┌─────────────────┐
 │    Packer       │  Accumulates chunks, compresses (zstd), encrypts (age)
 └────────┬────────┘
         │
         ▼
 ┌─────────────────┐
 │   S3 Client     │  Uploads blobs to remote storage
 └─────────────────┘
 ```
 ## Data Model
 ### Core Entities
 The database tracks five primary entities and their relationships:
 ```
 ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
 │   Snapshot   │────▶│     File     │────▶│    Chunk     │
 └──────────────┘     └──────────────┘     └──────────────┘
       │                                         │
       │                                         │
       ▼                                         ▼
 ┌──────────────┐                          ┌──────────────┐
 │     Blob     │◀─────────────────────────│  BlobChunk   │
 └──────────────┘                          └──────────────┘
 ```
 ### Entity Descriptions
 #### File (`database.File`)
 Represents a file, directory, or symlink in the backup system. Stores metadata needed for restoration:
 - Path, mtime
 - Size, mode, ownership (uid, gid)
 - Symlink target (if applicable)
 It also stores `source_path`, the source directory the scan found it under, made absolute and with symlinks resolved. Restore does not read it.
 #### Chunk (`database.Chunk`)
 A content-addressed unit of data. Files are split into variable-size chunks using the FastCDC algorithm:
 - `ChunkHash`: SHA256 hash of chunk content (primary key)
 - `Size`: Chunk size in bytes
 Chunk sizes vary between `avgChunkSize/4` and `avgChunkSize*4` (2.5MB-40MB for the 10MB default average).
 #### FileChunk (`database.FileChunk`)
 Maps files to their constituent chunks:
 - `FileID`: Reference to the file
 - `Idx`: Position of this chunk within the file (0-indexed)
 - `ChunkHash`: Reference to the chunk
 #### Blob (`database.Blob`)
 The final storage unit uploaded to S3. Contains many compressed and encrypted chunks:
 - `ID`: UUID assigned at creation
 - `Hash`: `hex(SHA256(SHA256(uncompressed blob contents)))`, computed before compression and encryption (see [docs/REPOSTRUCTURE.md](docs/REPOSTRUCTURE.md#blobs-directory-blobs))
 - `UncompressedSize`: Total raw chunk data before compression
 - `CompressedSize`: Size after zstd compression and age encryption
 - `CreatedTS`, `FinishedTS`, `UploadedTS`: Lifecycle timestamps
 Blob creation process:
 1. Chunks are accumulated (up to MaxBlobSize, typically 10GB)
 2. As each chunk is added, its uncompressed bytes are fed to a running SHA-256
 3. Concurrently, the same bytes are compressed with zstd, then encrypted with age (recipients configured in config), and written to a temporary file
 4. On finalize, the blob's name is the double SHA-256 of the uncompressed contents — `hex(SHA256(SHA256(...)))` — not a hash of the compressed, encrypted bytes
 5. The finished file is uploaded to `blobs/{hash[0:2]}/{hash[2:4]}/{hash}` and then deleted
 A backup needs free temporary space, because each blob is written whole to a temporary file before it is uploaded (up to about `blob_size_limit`; an rclone destination that cannot stream uploads needs about twice that) and the metadata export writes copies of the local index. Temporary files go to `$TMPDIR` (default `/tmp`); with `TMPDIR` unset, SQLite writes one of those copies to `/var/tmp`.
 #### BlobChunk (`database.BlobChunk`)
 Maps chunks to their position within blobs:
 - `BlobID`: Reference to the blob
 - `ChunkHash`: Reference to the chunk
 - `Offset`: Byte offset within the uncompressed blob
 - `Length`: Chunk size
 #### Snapshot (`database.Snapshot`)
 Represents a point-in-time backup:
 - `ID`: Format is `{hostname}_{snapshot-name}_{RFC3339}` (e.g. `server1_home_2025-06-01T12:00:00Z`)
 - Tracks file count, chunk count, blob count, sizes, compression ratio
 - `CompletedAt`: Null until snapshot finishes successfully
 #### SnapshotFile / SnapshotBlob
 Join tables linking snapshots to their files and blobs.
 ### Relationship Summary
 ```
 Snapshot 1──────────▶ N SnapshotFile N ◀────────── 1 File
 Snapshot 1──────────▶ N SnapshotBlob N ◀────────── 1 Blob
 File     1──────────▶ N FileChunk    N ◀────────── 1 Chunk
 Blob     1──────────▶ N BlobChunk    N ◀────────── 1 Chunk
 ```
 ## Type Instantiation
 ### Application Startup
 The CLI uses fx for dependency injection. Here's the instantiation order:
 ```go
 // cli/app.go: NewApp()
 fx.New(
    fx.Supply(config.Path(opts.ConfigPath)),         // 1. Config path
    fx.Supply(opts.LogOptions),                      // 2. Log options
    fx.Provide(globals.New),                         // 3. Globals
    fx.Provide(log.New),                             // 4. Logger config
    config.Module,                                   // 5. Config
    database.Module,                                 // 6. Database + Repositories
    log.Module,                                      // 7. Logger initialization
    storage.Module,                                  // 8. Storage backend (S3/file/rclone)
    snapshot.Module,                                 // 9. SnapshotManager + ScannerFactory
    fx.Provide(vaultik.New),                         // 10. Vaultik orchestrator
 )
 ```
 ### Key Type Instantiation Points
 #### 1. Config (`config.Config`)
 - **Created by**: `config.Module` via `config.LoadConfig()`
 - **When**: Application startup (fx DI)
 - **Contains**: All configuration from YAML file (S3 credentials, encryption keys, paths, etc.)
 #### 2. Database (`database.DB`)
 - **Created by**: `database.Module` via `database.New()`
 - **When**: Application startup (fx DI)
 - **Contains**: SQLite connection, path reference
 #### 3. Repositories (`database.Repositories`)
 - **Created by**: `database.Module` via `database.NewRepositories()`
 - **When**: Application startup (fx DI)
 - **Contains**: All repository interfaces (Files, Chunks, Blobs, Snapshots, etc.)
 #### 4. Vaultik (`vaultik.Vaultik`)
 - **Created by**: `vaultik.New(VaultikParams)`
 - **When**: Application startup (fx DI)
 - **Contains**: All dependencies for backup operations
 ```go
 type Vaultik struct {
    Globals         *globals.Globals
    Config          *config.Config
    DB              *database.DB
    Repositories    *database.Repositories
    Storage         storage.Storer
    ScannerFactory  snapshot.ScannerFactory
    SnapshotManager *snapshot.SnapshotManager
    Shutdowner      fx.Shutdowner
    Fs              afero.Fs
    ctx             context.Context
    cancel          context.CancelFunc
 }
 ```
 #### 5. SnapshotManager (`snapshot.SnapshotManager`)
 - **Created by**: `snapshot.Module` via `snapshot.NewSnapshotManager()`
 - **When**: Application startup (fx DI)
 - **Responsibility**: Creates/completes snapshots, exports metadata to S3
 #### 6. Scanner (`snapshot.Scanner`)
 - **Created by**: `ScannerFactory(ScannerParams)`
 - **When**: Each `CreateSnapshot()` call
 - **Contains**: Chunker, Packer, progress reporter
 ```go
 // vaultik/snapshot.go: CreateSnapshot()
 scanner := v.ScannerFactory(snapshot.ScannerParams{
    EnableProgress: !opts.Cron,
    Fs:             v.Fs,
 })
 ```
 #### 7. Chunker (`chunker.Chunker`)
 - **Created by**: `chunker.NewChunker(avgChunkSize)`
 - **When**: Inside `snapshot.NewScanner()`
 - **Configuration**:
  - `avgChunkSize`: From config (default 10MB)
  - `minChunkSize`: avgChunkSize / 4
  - `maxChunkSize`: avgChunkSize * 4
 #### 8. Packer (`blob.Packer`)
 - **Created by**: `blob.NewPacker(PackerConfig)`
 - **When**: Inside `snapshot.NewScanner()`
 - **Configuration**:
  - `MaxBlobSize`: Maximum blob size before finalization (typically 10GB)
  - `CompressionLevel`: zstd level (1-19)
  - `Recipients`: age public keys for encryption
 ```go
 // snapshot/scanner.go: NewScanner()
 packerCfg := blob.PackerConfig{
    MaxBlobSize:      cfg.MaxBlobSize,
    CompressionLevel: cfg.CompressionLevel,
    Recipients:       cfg.AgeRecipients,
    Repositories:     cfg.Repositories,
    Fs:               cfg.FS,
 }
 packer, err := blob.NewPacker(packerCfg)
 ```
 ## Module Responsibilities
 ### `internal/cli`
 Entry point for fx application. Combines all modules and handles signal interrupts.
 Key functions:
 - `NewApp(AppOptions)` → Creates fx.App with all modules
 - `RunApp(ctx, app)` → Starts app, handles graceful shutdown
 - `RunWithApp(ctx, opts)` → Convenience wrapper
 ### `internal/vaultik`
 Main orchestrator containing all dependencies and command implementations.
 Key methods:
 - `New(VaultikParams)` → Constructor (fx DI)
 - `CreateSnapshot(opts)` → Main backup operation
 - `ListSnapshots(jsonOutput)` → List available snapshots
 - `VerifySnapshot(id, deep)` → Verify snapshot integrity
 - `PurgeSnapshots(...)` → Remove old snapshots
 ### `internal/chunker`
 Content-defined chunking using FastCDC algorithm.
 Key types:
 - `Chunk` → Hash, Data, Offset, Size
 - `Chunker` → avgChunkSize, minChunkSize, maxChunkSize
 Key methods:
 - `NewChunker(avgChunkSize)` → Constructor
 - `ChunkReaderStreaming(reader, callback)` → Stream chunks with callback (preferred)
 - `ChunkReader(reader)` → Return all chunks at once (memory-intensive)
 ### `internal/blob`
 Blob packing: accumulates chunks, compresses, encrypts, tracks metadata.
 Key types:
 - `Packer` → Thread-safe blob accumulator
 - `ChunkRef` → Hash + Data for adding to packer
 - `FinishedBlob` → Completed blob ready for upload
 - `BlobWithReader` → FinishedBlob + io.Reader for streaming upload
 Key methods:
 - `NewPacker(PackerConfig)` → Constructor
 - `AddChunk(ChunkRef)` → Add chunk to current blob
 - `FinalizeBlob()` → Compress, encrypt, hash current blob
 - `Flush()` → Finalize any in-progress blob
 - `SetBlobHandler(func)` → Set callback for upload
 ### `internal/snapshot`
 #### Scanner
 Orchestrates the backup process for a directory.
 Key methods:
 - `NewScanner(ScannerConfig)` → Constructor (creates Chunker + Packer)
 - `Scan(ctx, path, snapshotID)` → Main scan operation
 Scan phases:
 1. **Phase 0**: Detect deleted files from previous snapshots
 2. **Phase 1**: Walk directory, identify files needing processing
 3. **Phase 2**: Process files (chunk → pack → upload)
 #### SnapshotManager
 Manages snapshot lifecycle and metadata export.
 Key methods:
 - `CreateSnapshot(ctx, hostname, version, commit)` → Create snapshot record
 - `PopulateSnapshotBlobs(ctx, snapshotID)` → Record every blob the snapshot references
 - `ExportSnapshotMetadata(ctx, dbPath, snapshotID)` → Export to S3
 - `MarkSnapshotComplete(ctx, snapshotID)` → Record completion, only after a successful export
 - `CompleteSnapshot(ctx, snapshotID)` → Convenience: populate blobs, then mark complete (no export between)
 ### `internal/database`
 SQLite database for local index. Single-writer mode for thread safety.
 Key types:
 - `DB` → Database connection wrapper
 - `Repositories` → Collection of all repository interfaces
 Repository interfaces:
 - `FilesRepository` → CRUD for File records
 - `ChunksRepository` → CRUD for Chunk records
 - `BlobsRepository` → CRUD for Blob records
 - `SnapshotsRepository` → CRUD for Snapshot records
 - Plus join table repositories (FileChunks, BlobChunks, etc.)
 ## Snapshot Creation Flow
 ```
 CreateSnapshot(opts)
    │
    ├─► PruneDatabase()   // Critical: avoid dedup errors
    │
    ├─► SnapshotManager.CreateSnapshot()   // Create DB record
    │
    ├─► For each source directory:
    │       │
    │       ├─► scanner.Scan(ctx, path, snapshotID)
    │       │       │
    │       │       ├─► Phase 0: detectDeletedFiles()
    │       │       │
    │       │       ├─► Phase 1: scanPhase()
    │       │       │       Walk directory
    │       │       │       Check file metadata changes
    │       │       │       Build list of files to process
    │       │       │
    │       │       └─► Phase 2: processPhase()
    │       │               For each file:
    │       │                   chunker.ChunkReaderStreaming()
    │       │                   For each chunk:
    │       │                       packer.AddChunk()
    │       │                       If blob full → FinalizeBlob()
    │       │                           → handleBlobReady()
    │       │                           → s3Client.PutObjectWithProgress()
    │       │               packer.Flush()  // Final blob
    │       │
    │       └─► Accumulate statistics
    │
    ├─► SnapshotManager.PopulateSnapshotBlobs()   // record referenced blobs
    │
    ├─► SnapshotManager.UpdateSnapshotStatsExtended()
    │
    ├─► SnapshotManager.ExportSnapshotMetadata()
    │       │
    │       ├─► Copy database to temp file
    │       ├─► Clean to only current snapshot data (VACUUM)
    │       ├─► Compress binary SQLite with zstd
    │       ├─► Encrypt with age
    │       ├─► Upload db.zst.age to storage
    │       └─► Upload manifest.json.zst to storage
    │
    └─► SnapshotManager.MarkSnapshotComplete()   // only after the export succeeds
 ```
 ## Deduplication Strategy
 1. **File-level**: Files unchanged since last backup are skipped (metadata comparison: size, mtime, mode, uid, gid), unless the file lists a chunk that no uploaded blob holds; such a file is re-chunked
 2. **Chunk-level**: Chunks are content-addressed by SHA256 hash. If a chunk hash already exists in the database, the chunk data is not re-uploaded.
 3. **Blob-level**: Blobs contain only unique chunks. Duplicate chunks within a blob are skipped.
 ## Storage Layout in S3
 ```
 bucket/
 ├── blobs/
 │   └── {hash[0:2]}/
 │       └── {hash[2:4]}/
 │           └── {full-hash}          # Compressed+encrypted blob
 │
 └── metadata/
    └── {remote-key}/
        ├── db.zst.age               # Encrypted binary SQLite database
        └── manifest.json.zst        # Blob list (for pruning/verification)
 ```
 The `{remote-key}` directory name is a one-way double SHA-256 hash of the human
 snapshot ID, so the human ID (hostname, snapshot name, timestamp) is never
 written to the store as a directory name. See
 [docs/REPOSTRUCTURE.md](docs/REPOSTRUCTURE.md#remote-key-derivation) for the
 derivation and a worked example.
 ## Thread Safety
 - `Packer`: Thread-safe via mutex. Multiple goroutines can call `AddChunk()`.
 - `Scanner`: Uses `packerMu` mutex to coordinate blob finalization.
 - `Database`: Single-writer mode (`MaxOpenConns=1`) ensures SQLite thread safety.
 - `Repositories.WithTx()`: Handles transaction lifecycle automatically.
@@ -5,16 +5,7 @@
 FROM golangci/golangci-lint:v2.14.0@sha256:ad862ba6b3798cbe0fd9fd7408d498fd74fbd2623a92406b2fd3898faf0bf98f AS lint
 WORKDIR /src
 COPY go.mod go.sum ./
-# Without the time limit a stalled connection to the module proxy holds
+RUN go mod download
 # this step, and every build on the host sharing it, until the kernel
 # drops the connection, which can take an hour. The limit is well above
 # the three minutes a working download can take on a busy build host.
 RUN for attempt in 1 2 3; do \
        timeout 300 go mod download && exit 0; \
        echo "go mod download attempt $attempt failed or ran over 300s" >&2; \
    done; \
    echo "module download failed: giving up after 3 attempts" >&2; \
    exit 1
 COPY . .
 # `golangci-lint run` silently ignores an unknown top-level key in
 # .golangci.yml, such as a misspelt `linters:`; `config verify` fails on it.
@@ -27,13 +18,7 @@ RUN golangci-lint run --config .golangci.yml ./...
 FROM golang:1.26.1@sha256:cd78d88e00afadbedd272f977d375a6247455f3a4b1178f8ae8bbcb201743a8a AS test
 WORKDIR /src
 COPY go.mod go.sum ./
-# Limited and retried as in the lint phase above.
+RUN go mod download
 RUN for attempt in 1 2 3; do \
        timeout 300 go mod download && exit 0; \
        echo "go mod download attempt $attempt failed or ran over 300s" >&2; \
    done; \
    echo "module download failed: giving up after 3 attempts" >&2; \
    exit 1
 COPY . .
 RUN go test -timeout 90s -race -cover ./... || \
    { echo "--- Rerunning with -v for details ---"; \
@@ -51,13 +36,7 @@ RUN apk add --no-cache git
 RUN git config --system --add safe.directory /src
 WORKDIR /src
 COPY go.mod go.sum ./
-# Limited and retried as in the lint phase above.
+RUN go mod download
 RUN for attempt in 1 2 3; do \
        timeout 300 go mod download && exit 0; \
        echo "go mod download attempt $attempt failed or ran over 300s" >&2; \
    done; \
    echo "module download failed: giving up after 3 attempts" >&2; \
    exit 1
 COPY . .
 # The VERSION build arg when one is given, otherwise
@@ -1,45 +0,0 @@
 package main_test
 import (
 	"strings"
 	"testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 // TestDockerfileBoundsEveryModuleDownload fails unless every
 // `go mod download` in the Dockerfile runs under a time limit, is tried
 // a fixed number of times, and then fails the build with a message that
 // names the module download (issue #351). Like the version tests, this
 // parses the Dockerfile; that a stalled download really is cut off and
 // retried was checked by hand.
 func TestDockerfileBoundsEveryModuleDownload(t *testing.T) {
 	t.Parallel()
 	var downloads []string
 	for _, instruction := range instructions(t, productDockerfile) {
 		if strings.Contains(instruction, "go mod download") {
 			downloads = append(downloads, instruction)
 		}
 	}
 	require.NotEmpty(t, downloads, "%s must download modules",
 		productDockerfile)
 	for _, download := range downloads {
 		assert.Contains(t, download, "timeout 300 go mod download",
 			"%s: a module download must have a time limit: %s",
 			productDockerfile, download)
 		assert.Contains(t, download, "for attempt in 1 2 3",
 			"%s: a module download must be retried: %s",
 			productDockerfile, download)
 		assert.Contains(t, download, "module download failed",
 			"%s: a module download that never succeeds must say so: %s",
 			productDockerfile, download)
 		assert.True(t, strings.HasSuffix(download, "exit 1"),
 			"%s: a module download that never succeeds must fail the"+
 				" build: %s", productDockerfile, download)
 	}
 }
@@ -1,32 +1,16 @@
 # vaultik configuration file example
-# This file shows every configuration option. The values are examples, not
+# This file shows all available configuration options with their default values
-# defaults; where an option has a default, its comment gives it.
+# Copy this file and uncomment/modify the values you need
 # Copy this file and change the values you need
-# Age recipient public keys for encryption (age: https://age-encryption.org/)
+# Age recipient public keys for encryption
 # Backups are encrypted to these public keys. snapshot create needs at least
 # one; listing, verifying and restoring do not
-# Generate a key pair, and show its public key, with:
+# Generate with: age-keygen | grep "public key"
 #   age-keygen -o vaultik_backup_private_key.txt
 #   grep 'public key' vaultik_backup_private_key.txt
 # Keep the private key file: restoring needs it. Do not pipe age-keygen
 # straight into grep, which would discard the private key
 # Default: none
 age_recipients:
  - age1cj2k2addawy294f6k2gr2mf9gps9r3syplryxca3nvxj3daqm96qfp84tz
 # Age private key for decryption
 # Only snapshot restore and snapshot verify --deep need it. The
 # VAULTIK_AGE_SECRET_KEY environment variable overrides this setting
 # Do not set it on a machine you back up. Supply the environment variable
 # only on a machine where you run snapshot restore or snapshot verify --deep
 # Default: not set
 #age_secret_key: YOUR_AGE_PRIVATE_KEY
 # Named snapshots - each snapshot can contain multiple paths
 # Each snapshot gets its own ID and can have snapshot-specific excludes
 # Required: at least one snapshot with at least one path. Only the config
 # commands, version and completion run without one
 snapshots:
  testing:
    paths:
@@ -269,18 +253,11 @@ snapshots:
      - "**/vendor"
 # Global patterns to exclude from all backups
 # Default: none
 exclude:
  - "*.tmp"
-# Storage URL. When it is not set, the endpoint, bucket and prefix in the s3
+# Storage URL - use either this OR the s3 section below
 # section below are used instead.
 # Supports: s3://bucket/prefix, file:///path, rclone://remote/path
 # An s3:// URL also needs s3.access_key_id and s3.secret_access_key below
 # A file:// path must be absolute, and the directory must already exist:
 # vaultik never creates it
 # An rclone:// URL names an rclone remote (https://rclone.org/), a storage
 # service set up in rclone's own config (rclone config)
 storage_url: "rclone://myremote/path/to/backups"
 # S3-compatible storage configuration
@@ -306,32 +283,26 @@ storage_url: "rclone://myremote/path/to/backups"
 #  #region: us-east-1
 #
 #  # Use SSL/TLS for S3 connections
 #  # Only read when storage_url is not set and the endpoint has no scheme;
 #  # with an s3:// storage_url, use ?ssl=false in the URL instead
 #  # Default: true
 #  #use_ssl: true
 #
 #  # Part size for multipart uploads
 #  # Minimum 5MiB, maximum 5GiB; affects memory usage during upload
-#  # An object too large for 10,000 parts of this size gets larger parts
+#  # A blob too large for 10,000 parts of this size gets larger parts
 #  # Supports: 10MB, 16MiB, 100MiB, etc. (5MB is below the minimum)
 #  # Default: 5MiB
 #  #part_size: 5MiB
 # Path to local SQLite index database
 # This database tracks file state for incremental backups
 # The VAULTIK_INDEX_PATH environment variable overrides this setting
 # Both must be absolute paths; a leading ~ is expanded
 # Default: the platform data directory, e.g.
 #   macOS: ~/Library/Application Support/vaultik/index.sqlite
 #   Linux: ~/.local/share/vaultik/index.sqlite
 #index_path: /path/to/index.sqlite
-# Average size of a chunk, a piece of a file's content. Chunk boundaries
+# Average chunk size for content-defined chunking
-# depend on the file's content, not on fixed offsets
+# Smaller chunks = better deduplication but more metadata
-# Smaller chunks find more duplicate content and make the index larger
+# Supports: 10MB, 5M, 1GB, 500KB, 64MiB, etc.
 # Minimum 1MB
 # Supports: 10MB, 5M, 1GB, 64MiB, etc.
 # Default: 10MB
 #chunk_size: 10MB
@@ -339,11 +310,9 @@ storage_url: "rclone://myremote/path/to/backups"
 # Multiple chunks are packed into blobs up to this size
 # Must be at least four times chunk_size (the largest chunk the chunker can
 # emit); a smaller limit would let a single-chunk blob exceed it.
-# Chunking uses no secret (the parameters of the FastCDC chunking algorithm
+# Chunking uses no secret (the FastCDC parameters are fixed and public). At a
-# are fixed and public). A full blob at a large limit holds hundreds of
+# large limit a blob holds hundreds of chunks, so individual chunk lengths are
-# chunks, so its size does not show any one chunk's length. The last blob of
+# not visible in its size; lowering the limit toward chunk_size exposes them.
 # each configured path can hold a single chunk. Lowering the limit toward
 # chunk_size exposes chunk lengths.
 # A backup needs free temporary space, because each blob is written whole to
 # a temporary file before it is uploaded (up to about blob_size_limit; an
 # rclone destination that cannot stream uploads needs about twice that) and
@@ -358,28 +327,6 @@ storage_url: "rclone://myremote/path/to/backups"
 # Higher = better compression but slower
 # Default: 3
 compression_level: 5
 # How old a blob that no snapshot lists must be before vaultik prune deletes
 # it. Each snapshot has a directory under metadata/ at the destination, and
 # its manifest there lists the blobs it uses. This is also how old every
 # object in a directory with no manifest must be before vaultik prune deletes
 # that directory
 # A backup uploads its blobs and its encrypted database (db.zst.age) before
 # its manifest, so on a destination shared between hosts or users this must
 # be longer than the longest backup run
 # It does not protect a blob a backup reuses from an earlier run that stopped
 # before its manifest: that blob keeps the time of its first upload, so a
 # prune can delete it
 # Supports: 36h, 90m, etc.; 0s deletes such blobs and directories at once
 # Default: 24h
 #prune_grace_period: 24h
 # Hostname to use in backup metadata
 # Default: system hostname
 #hostname: myserver
 # Environment variables that vaultik sets in its own process when it loads
 # the config. Its keys are variable names
 # Default: none
 #env:
 #  NAME: value
@@ -1,418 +0,0 @@
 # vaultik architecture
 This document describes how the `vaultik` code is organised. It covers three
 things:
 - the packages
 - how they are wired together
 - what happens during a backup, a restore, a verify and a prune
 Two other documents cover the stored data:
 - [`DATAMODEL.md`](DATAMODEL.md) describes the local index.
 - [`REPOSTRUCTURE.md`](REPOSTRUCTURE.md) describes the layout of the
  destination.
 ## Terms
 - **Snapshot**: one backup of the paths listed under one name in the config.
 - **Snapshot ID**: the name of a snapshot, in the form
  `<hostname>_<snapshot-name>_<timestamp>`.
 - **Chunk**: a piece of a file's content. A chunk is named by the SHA-256 hash
  of its content.
 - **Blob**: one object at the destination. It holds many chunks, compressed and
  then encrypted.
 - **Local index**: the SQLite database on the backed-up machine.
 - **Destination**: the place the backups are stored.
 - **Marker file**: `vaultik-destination.txt` at the destination. See
  [The marker file](REPOSTRUCTURE.md#the-marker-file).
 - **Manifest**: the unencrypted list of the blobs one snapshot uses.
 - **Remote key**: a hash of the snapshot ID. It names the snapshot's directory
  at the destination.
 ## How a backup moves data
 ```
 source files
     │
     ▼
  Scanner    walks the paths and finds the files that changed
     │
     ▼
  Chunker    cuts each changed file into chunks
     │
     ▼
  Packer     packs new chunks into a blob, compressed and encrypted
     │
     ▼
  Storer     uploads the blob to the destination
 ```
 ## Packages
 - `cmd/vaultik`: the `main` function. It starts optional profiling and calls
  `cli.Entry`.
 - `internal/cli`: the commands, their flags and their help text. It builds the
  application, takes the lock and handles interrupts.
 - `internal/vaultik`: the code behind each command. `Vaultik` holds every
  dependency a command uses.
 - `internal/snapshot`: the `Scanner`, which backs up one path, and the
  `SnapshotManager`, which creates snapshot records and uploads their metadata.
 - `internal/chunker`: cuts a stream into chunks with the FastCDC algorithm.
 - `internal/blob`: the `Packer`, which collects chunks into blobs.
 - `internal/blobgen`: the writer that hashes, compresses and encrypts a blob,
  and the reader that reverses it.
 - `internal/database`: the local index. It holds the schema and the repository
  types that read and write the tables. [`DATAMODEL.md`](DATAMODEL.md#code) says
  which type serves which table.
 - `internal/storage`: the `Storer` interface and its three implementations, for
  S3, a local directory and [rclone](https://rclone.org/).
 - `internal/s3`: the S3 client that the S3 `Storer` uses.
 - `internal/config`: loads and checks the config file.
 - `internal/ui`: formats the status lines, warnings and errors a user sees.
 - `internal/log`: the logger. It writes to stderr.
 - `internal/pidlock`: the lock that `RunWithApp` takes for a command that
  changes data, so that only one runs at a time.
 - `internal/globals`: the version, commit and commit date, set when the binary
  is built.
 - `internal/types`: distinct types for IDs, hashes and paths.
 ## Wiring
 The application is assembled with [uber-go/fx](https://github.com/uber-go/fx), a
 dependency injection library. `cli.NewApp` lists the providers:
 ```go
 fx.Supply(config.Path(opts.ConfigPath)),
 fx.Supply(opts.LogOptions),
 fx.Provide(globals.New),
 fx.Provide(log.New),
 config.Module,
 database.Module,
 log.Module,
 storage.Module,
 snapshot.Module,
 fx.Provide(vaultik.New),
 fx.Invoke(setupGlobals),
 fx.NopLogger,
 ```
 Each module provides these:
 - `config.Module` provides `*config.Config`, from `config.Load`.
 - `database.Module` provides `*database.DB` and `*database.Repositories`. It
  creates the index file with mode `0600` when it does not exist.
 - `storage.Module` provides the `storage.Storer` that the config selects.
 - `snapshot.Module` provides the `snapshot.ScannerFactory` and the
  `*snapshot.SnapshotManager`.
 - `vaultik.New` provides `*vaultik.Vaultik`.
 A command runs through `cli.RunOperation`. It works like this:
 - `RunWithApp` takes the lock when the command changes data, and then starts the
  application.
 - The command's function runs in its own goroutine.
 - When the function returns, it asks the application to shut down.
 - On `SIGINT` or `SIGTERM`, the stop hook cancels the `Vaultik` context. It then
  waits for the function to return, so that its temporary files are removed.
 - The wait ends after 30 seconds at most.
 These commands do not build the application:
 - the `config` commands
 - `database delete`
 - `completion`
 - `version`
 ## Backup
 `Vaultik.CreateSnapshot` runs a backup. It does these steps in order:
 - `markDestination` checks that the local index is not bound to another
  destination. It then checks the marker file, writes it, and binds the local
  index to the configured destination.
 - `PruneDatabase` removes unfinished snapshots and unused records from the local
  index.
 - `createNamedSnapshot` runs once for each snapshot name.
 - With `--prune`, `runPostBackupPrune` removes old snapshots and unused data.
 `CreateSnapshot` calls `skipPostBackupPrune` instead of `runPostBackupPrune` in
 these cases:
 - `--skip-errors` skipped a file or directory that could not be read.
 - A configured path held nothing.
 - An earlier snapshot of the same name found a mount point that this backup did
  not find.
 `PruneDatabase` must succeed before anything is scanned. An unfinished snapshot
 left in the index would make the backup skip files that were never fully stored.
 ### One snapshot
 `createNamedSnapshot` does these steps:
 - `resolveSnapshotPaths` makes each configured path absolute and resolves
  symlinks.
 - `SnapshotManager.CreateSnapshotWithName` creates the snapshot record. The
  record is not yet marked complete.
 - `Scanner.Scan` backs up each path in turn.
 - `finalizeSnapshotMetadata` uploads the snapshot's metadata and marks the
  snapshot complete.
 A new `Scanner` is created for each snapshot, from `ScannerFactory`. It owns a
 `Chunker` and a `Packer`.
 ### Scanning one path
 `Scanner.Scan` works in these steps:
 - `repairInterruptedBlobs` deletes the records of blobs whose upload never
  finished. Their data is then stored again.
 - `loadDatabaseState` loads the known files and chunks into memory.
 - `scanPhase` walks the path. It sorts each regular file and symlink into
  changed or unchanged.
 - `detectDeletedFiles` counts the files that the previous snapshot of this name
  had and that are now gone.
 - `batchAddFilesToSnapshot` records the unchanged files in the new snapshot.
 - `recordDirectories` records every directory, and the mount points found.
 - `processPhase` reads each changed regular file and stores it. It records each
  changed symlink.
 The walk handles each kind of entry differently:
 - A regular file or a symlink is compared with its record in the index.
 - A directory is recorded with its metadata. It has no content to store.
 - A device node, a named pipe or a socket is skipped.
 - An entry that matches an exclude pattern is skipped. For a directory, so is
  everything in it.
 - The local index, its SQLite side files and the lock file `vaultik.pid` are
  skipped, whatever the exclude patterns say.
 ### Deduplication
 Data is stored once at two levels.
 - **Files.** A file is not read again when its record in the index still matches
  it.
 - **Chunks.** A chunk is named by the SHA-256 hash of its content. A chunk that
  an uploaded blob already holds, according to the index, is not stored again.
 A file's record matches when all of these are unchanged:
 - the size
 - the modification time
 - the mode
 - the owner and group
 - the link target
 One case overrides the file check. A file is read again when it lists a chunk
 that no uploaded blob holds. This happens when the only snapshot that used the
 blob holding that chunk is removed. `loadFilesToRechunk` finds these files.
 ### Chunks
 `chunker.Chunker` cuts a file with the FastCDC algorithm. The cut points depend
 on the content, so an insertion early in a file moves only nearby chunks.
 `chunk_size` sets the average chunk size. No chunk is larger than four times
 this size. Only a file's last chunk can be smaller than a quarter of it. With
 the default of 10 MB, those limits are 40 MB and 2.5 MB.
 `ChunkReaderStreaming` passes each chunk to a callback as it is found. The
 chunker buffers at most twice the largest chunk size.
 ### Blobs
 `blob.Packer` collects new chunks into a blob. For each blob it does this:
 - It gives the blob a UUID and creates a temporary file.
 - It adds each chunk's bytes to a running SHA-256 hash.
 - In the same pass it compresses the bytes with
  [zstd](https://github.com/facebook/zstd) and encrypts them with
  [age](https://age-encryption.org/). The result goes to the temporary file.
 - It records each chunk's offset and length within the blob.
 - It closes the blob when the next chunk would pass `blob_size_limit`, and at
  the end of each path.
 The blob's name is `hex(SHA256(SHA256(uncompressed contents)))`. It is computed
 from the chunk data before compression and encryption.
 [`REPOSTRUCTURE.md`](REPOSTRUCTURE.md#blobs) says what follows from that.
 When a blob is closed, `Scanner.handleBlobReady` stores it:
 - It looks the blob up at the destination. A blob that is already there is not
  uploaded again.
 - Otherwise it uploads the temporary file to
  `blobs/<hash[0:2]>/<hash[2:4]>/<hash>`.
 - It records the upload in the index and links the blob to the snapshot.
 - It deletes the temporary file.
 A file's record is written to the index only after every blob that holds its
 chunks is uploaded.
 ### Snapshot metadata
 `finalizeSnapshotMetadata` does these steps in order:
 - `PopulateSnapshotBlobs` records every blob the snapshot uses.
 - `UpdateSnapshotStatsExtended` stores the snapshot's totals.
 - `ExportSnapshotMetadata` uploads the metadata.
 - `MarkSnapshotComplete` marks the snapshot complete.
 Completion is recorded last on purpose. A backup that stops during the upload
 leaves the snapshot unfinished, and the next backup removes it and backs up its
 files again.
 `ExportSnapshotMetadata` works on a copy of the index, never on the index
 itself:
 - It copies the index into a temporary directory with `VACUUM INTO`.
 - It deletes the rows of every other snapshot from the copy. It also deletes the
  files and blobs that this snapshot does not use. It then deletes each chunk
  that no remaining file and no remaining blob uses.
 - It keeps the `local_meta` and `schema_migrations` tables as they are. The
  uploaded database therefore names the destination, and lists the migrations
  that have run.
 - It runs `VACUUM`, so that no deleted row is left in the file.
 - It compresses the copy with zstd and encrypts it with age.
 - It builds the manifest from the copy.
 - It uploads `metadata/<remote-key>/db.zst.age`, and then
  `metadata/<remote-key>/manifest.json.zst`.
 The manifest is uploaded last. A directory under `metadata/` with no manifest
 therefore marks a backup that did not finish.
 ## Restore
 `Vaultik.Restore` does these steps:
 - `restoreIdentities` parses the age private key. A missing or malformed key
  stops the restore before anything is downloaded.
 - `downloadSnapshotDB` downloads and decrypts the snapshot's database into a
  temporary directory.
 - `getFilesToRestore` selects the files, from the paths given.
 - `restoreAllFiles` downloads blobs and writes the files.
 - With `--verify`, `verifyRestoredFiles` reads each restored regular file and
  checks its chunk hashes.
 Given a snapshot ID, the restore looks it up in the local index. When it is not
 there, the restore checks the marker file and lists the snapshot's directory.
 Given a remote key, it reads the local index only to check the marker file. It
 does not read the manifest. It finds each file's chunks and blobs through the
 downloaded database.
 ### Checks on the downloaded database
 Decryption shows that a database is readable. It does not show that the database
 is honest. The restore therefore checks it:
 - `database.OpenReadOnly` opens the file read-only. It refuses a file that has a
  trigger, a view or a virtual table, or that lacks an expected table.
 - `verifySnapshotDBIdentity` checks that the snapshot in the database hashes to
  the remote key that was asked for.
 - `containedRestorePath` refuses a stored path that would leave the target
  directory. It also refuses to write through a symlink below the target.
 - A blob is not decompressed beyond the size that the database gives for it.
 - Each downloaded blob is hashed. The hash must match the blob's name.
 ### Order of work
 `restorePlan` orders the files so that few blobs are on disk at once:
 - Downloaded blobs are kept decrypted in a cache directory.
 - A file is restored once every blob it needs is in the cache.
 - When no file is ready, the restore downloads the blobs for the file that needs
  the fewest.
 - `restoreSweeper` deletes a cached blob once no remaining file needs it.
 A regular file is created with mode `0600` and gets its stored mode after its
 content is written. A directory gets its stored mode and modification time after
 the whole restore, and its owner when the command runs as root.
 ## Verify
 Without `--deep`, `Vaultik.VerifySnapshotWithOptions` checks a snapshot without
 the private key:
 - It downloads the manifest.
 - It checks that the snapshot's encrypted database is present.
 - It checks that each listed blob is present with the listed size.
 `Vaultik.RunDeepVerify` needs the private key. It does these steps:
 - It downloads the manifest and the database. It checks the database as a
  restore does.
 - `verifyManifestAgainstDatabase` checks that both list the same blobs with the
  same sizes.
 - `verifyBlobExistenceFromDB` checks that every blob is present with the
  recorded size.
 - `verifyBlob` downloads each blob, checks the hash of each chunk in it, and
  checks the hash that names the blob.
 ## Prune
 `Vaultik.Prune` calls `checkStorageBinding` and then does three steps:
 - `CleanupLocalSnapshots` drops from the local index each snapshot whose
  manifest is gone from the destination.
 - `PruneDatabase` removes unfinished snapshots and unused records from the local
  index.
 - `PruneBlobs` deletes unused data at the destination.
 `PruneBlobs` reads every manifest at the destination. It then deletes two kinds
 of object, once they are older than `prune_grace_period`:
 - a blob that no manifest lists
 - a directory under `metadata/` that has no manifest, and whose snapshot is not
  in the local index
 It deletes nothing when any manifest cannot be read.
 [`REPOSTRUCTURE.md`](REPOSTRUCTURE.md#pruning) explains why this is safe, and
 where it is not.
 ## The destination
 `storage.Storer` is the only way the code reaches the destination. It has these
 methods:
 - `Put` and `PutWithProgress` store an object.
 - `Get` reads an object.
 - `Stat` reports an object's size.
 - `Delete` removes an object.
 - `List` and `ListStream` list the objects under a prefix.
 - `DeletePartialUploads` removes what an interrupted upload left behind.
 - `Info` describes the destination.
 `storage.NewStorer` picks the implementation from `storage_url`:
 - `s3://` gives the S3 implementation.
 - `file://` gives the local directory implementation.
 - `rclone://` gives the rclone implementation.
 With no `storage_url`, it builds the S3 implementation from the `s3` settings.
 ## The marker file and the destination binding
 These checks keep the local index and the destination in step.
 - `checkDestinationMarker` looks for `vaultik-destination.txt`. It fails when
  the file is reported missing while the local index holds snapshots. It skips
  the check when the local index belongs to another destination.
 - `checkStorageBinding` fails when the local index is bound to a different
  destination from the configured one. It records nothing.
 - `EnsureStorageBinding` binds an unbound local index to the configured
  destination. Only `markDestination` calls it, after the marker file is
  written, so a backup that writes nothing leaves the local index unbound.
 Every command that takes the lock calls `checkStorageBinding` first.
 ## Concurrency
 - Each open database uses one connection, so its queries run one at a time.
 - The index runs in SQLite's write-ahead log (WAL) mode. A second process can
  therefore read it while a backup writes to it.
 - `Packer` guards its state with a mutex.
 - `Scanner` holds `packerMu` while a chunk is added to the packer and while a
  blob is closed.
 - `Repositories.WithTx` runs a function in one transaction. It commits when the
  function succeeds and rolls back when it fails.
@@ -1,450 +1,290 @@
-# vaultik data model
+# Vaultik Data Model
-`vaultik` keeps a SQLite database on the backed-up machine, called the local
+## Overview
 index. This document describes its tables, and how a backup, a restore and
 `prune` use them.
-The local index has two jobs:
+Vaultik uses a local SQLite database to track file metadata, chunk mappings, and blob associations during the backup process. This database serves as an index for incremental backups and enables efficient deduplication.
- It records which files, chunks and blobs are already stored. The next backup
+**Important Notes:**
  then does not store them again.
 - It is the source of each snapshot's own database. A backup uploads a trimmed,
  encrypted copy of the index with every snapshot.
-A restore reads no file, chunk or blob rows from the local index. It reads the
+- **Version Compatibility**: In rare cases, you may need to use the same version
-copy that was uploaded with the snapshot.
+  of Vaultik to restore a backup as was used to create it. This ensures
  compatibility with the metadata format stored in S3.
-## Terms
+## Schema Migrations
- **Snapshot**: one backup of the paths listed under one name in the config.
+Vaultik supports schema migrations. They are the numbered SQL files in
- **Snapshot ID**: the name of a snapshot, in the form
+`internal/database/schema/`, embedded in the binary: `000.sql` creates the
-  `<hostname>_<snapshot-name>_<timestamp>`.
+`schema_migrations` table, which records each migration that has run, and
- **Chunk**: a piece of a file's content, named by the SHA-256 hash of that
+`001.sql` creates the application tables. `database.New` opens a database and
-  content.
+applies, in order, every migration that database has not yet recorded.
 - **Blob**: one object at the destination. It holds many chunks, compressed and
  then encrypted.
 - **Destination**: the place the backups are stored.
 - **Marker file**: `vaultik-destination.txt` at the destination. See
  [The marker file](REPOSTRUCTURE.md#the-marker-file).
 - **Manifest**: the unencrypted list of the blobs one snapshot uses.
 - **Remote key**: a hash of the snapshot ID. It names the snapshot's directory
  at the destination.
-## Where the index is
+**Before 1.0** no migrations are added, because nothing is installed anywhere
 yet. A schema change edits `001.sql` (and the code that uses the affected
 tables) directly. A local database created before the change has already
 recorded `001.sql` as run, so it keeps the old schema and can become unusable;
 `vaultik database delete` followed by a full backup rebuilds it.
 **After 1.0** each schema change is a new numbered file, so an existing local
 database is migrated the first time an updated vaultik opens it. A file that
 has shipped in a release is never edited.
 ## Database Tables
 ### 1. `files`
 Stores metadata about files in the filesystem being backed up.
-The index is the file `index.sqlite` in the platform data directory. By default
+**Columns:**
-that is `~/.local/share/vaultik/` on Linux and
+- `id` (TEXT PRIMARY KEY) - UUID for the file record
-`~/Library/Application Support/vaultik/` on macOS. The `index_path` setting and
+- `path` (TEXT NOT NULL UNIQUE) - Absolute file path
-the `VAULTIK_INDEX_PATH` environment variable change the path. So does
+- `mtime` (INTEGER NOT NULL) - Modification time, whole seconds since the Unix epoch
-`XDG_DATA_HOME`.
+- `mtime_nsec` (INTEGER NOT NULL) - Nanoseconds within that second, 0 to 999999999
 - `size` (INTEGER NOT NULL) - File size in bytes
 - `mode` (INTEGER NOT NULL) - Unix file permissions and type
 - `uid` (INTEGER NOT NULL) - User ID of file owner
 - `gid` (INTEGER NOT NULL) - Group ID of file owner
 - `link_target` (TEXT) - Symlink target path (NULL for regular files)
-The file is readable only by its owner, because it lists every backed-up path.
+**Indexes:**
-`vaultik` sets that mode each time it opens the index.
+- `idx_files_path` on `path` for efficient lookups
 **Purpose:** Tracks file metadata to detect changes between backup runs. Used for incremental backup decisions. The UUID primary key provides stable references that don't change if files are moved.
-## Schema migrations
+### 2. `chunks`
 Stores information about content-defined chunks created from files.
-`vaultik` supports schema migrations. They are the numbered SQL files in
+**Columns:**
-`internal/database/schema/`, which are built into the binary.
+- `chunk_hash` (TEXT PRIMARY KEY) - SHA256 hash of chunk content
 - `size` (INTEGER NOT NULL) - Chunk size in bytes
- `000.sql` creates the `schema_migrations` table. That table records each
+**Purpose:** Enables deduplication by tracking unique chunks across all files.
-  migration that has run.
+
- `001.sql` creates every other table.
+### 3. `file_chunks`
 Maps files to their constituent chunks in order.
-`database.New` opens the index. It then applies, in order, every migration that
+**Columns:**
-the index has not recorded.
+- `file_id` (TEXT) - File ID (FK to files.id)
 - `idx` (INTEGER) - Chunk index within file (0-based)
 - `chunk_hash` (TEXT) - Chunk hash (FK to chunks.chunk_hash)
 - PRIMARY KEY (`file_id`, `idx`)
-Before version 1.0, no migration is added, because nothing is installed anywhere
+**Purpose:** Allows reconstruction of files from chunks during restore.
 yet. A schema change edits `001.sql` directly, with the code that uses the
 changed tables.
-This has one consequence. An index created before such a change has already
+### 4. `chunk_files`
-recorded `001.sql` as run, so it keeps the old schema and can become unusable.
+Reverse mapping showing which files contain each chunk.
 To rebuild it, run `vaultik database delete` and then a full backup.
-After version 1.0, each schema change is a new numbered file. An existing index
+**Columns:**
-is then migrated the first time an updated `vaultik` opens it. A file that was
+- `chunk_hash` (TEXT) - Chunk hash (FK to chunks.chunk_hash)
-part of a release is never edited.
+- `file_id` (TEXT) - File ID (FK to files.id)
 - `file_offset` (INTEGER) - Byte offset of chunk within file
 - `length` (INTEGER) - Length of chunk in bytes
 - PRIMARY KEY (`chunk_hash`, `file_id`)
-Migrations apply to the local index only. A snapshot's database at the
+**Purpose:** Supports efficient queries for chunk usage and deduplication statistics.
 destination is read as it was written. Each snapshot records the `vaultik`
 version that wrote it.
-## Tables
+### 5. `blobs`
 Stores information about packed, compressed, and encrypted blob files.
-Times are whole seconds since the Unix epoch, in UTC. The two exceptions are
+**Columns:**
-noted at their columns.
+- `id` (TEXT PRIMARY KEY) - UUID assigned when blob creation starts
 - `blob_hash` (TEXT UNIQUE) - `hex(SHA256(SHA256(uncompressed blob contents)))`, computed before compression and encryption (NULL until finalized); see [REPOSTRUCTURE.md](REPOSTRUCTURE.md#blobs-directory-blobs)
 - `created_ts` (INTEGER NOT NULL) - Creation timestamp
 - `finished_ts` (INTEGER) - Finalization timestamp (NULL if in progress)
 - `uncompressed_size` (INTEGER NOT NULL DEFAULT 0) - Total size of chunks before compression
 - `compressed_size` (INTEGER NOT NULL DEFAULT 0) - Size after compression and encryption
 - `uploaded_ts` (INTEGER) - Upload completion timestamp (NULL if not uploaded)
-### `files`
+**Purpose:** Tracks blob lifecycle from creation through upload. The UUID primary key allows immediate association of chunks with blobs.
-One row for each backed-up path: a regular file, a symlink or a directory.
+### 6. `blob_chunks`
 Maps chunks to the blobs that contain them.
 **Columns:**
 - `blob_id` (TEXT) - Blob ID (FK to blobs.id)
 - `chunk_hash` (TEXT) - Chunk hash (FK to chunks.chunk_hash)
 - `offset` (INTEGER) - Byte offset of chunk within blob (before compression)
 - `length` (INTEGER) - Length of chunk in bytes
 - PRIMARY KEY (`blob_id`, `chunk_hash`)
 **Purpose:** Enables chunk retrieval from blobs during restore operations.
 ### 7. `snapshots`
 Tracks backup snapshots.
 **Columns:**
 - `id` (TEXT PRIMARY KEY) - Snapshot ID (format: `hostname_name_timestamp`, e.g. `server1_home_2025-06-01T12:00:00Z`: the hostname up to its first `.`, the snapshot name, and an RFC 3339 UTC timestamp)
 - `hostname` (TEXT) - Hostname where backup was created
 - `vaultik_version` (TEXT) - Version of Vaultik used
 - `vaultik_git_revision` (TEXT) - Git revision of Vaultik used
 - `started_at` (INTEGER) - Start timestamp
 - `completed_at` (INTEGER) - Completion timestamp (NULL if in progress)
 - `file_count` (INTEGER) - Number of files in snapshot
 - `chunk_count` (INTEGER) - Number of chunks this snapshot stored that were not stored before
 - `blob_count` (INTEGER) - Number of blobs this snapshot created
 - `total_size` (INTEGER) - Total size of all files
 - `blob_size` (INTEGER) - Total compressed size of all referenced blobs
 - `blob_uncompressed_size` (INTEGER) - Total uncompressed size of all referenced blobs
 - `compression_ratio` (REAL) - Compression ratio achieved
 - `compression_level` (INTEGER) - Compression level used for this snapshot
 - `upload_bytes` (INTEGER) - Total bytes uploaded during this snapshot
 - `upload_duration_ms` (INTEGER) - Total milliseconds spent uploading to S3
- `id`: a UUID. Primary key.
+**Purpose:** Provides snapshot metadata and statistics including version tracking for compatibility.
 - `path`: the absolute path. Unique.
 - `source_path`: the configured path under which the scan found this entry, made
  absolute with symlinks resolved. A restore does not read it.
 - `mtime`: the modification time.
 - `mtime_nsec`: the nanoseconds within that second.
 - `size`: the size in bytes.
 - `mode`: the permission bits and the file type.
 - `uid`: the owner's user ID.
 - `gid`: the owner's group ID.
 - `link_target`: the target of a symlink. It is empty for other entries.
-`idx_files_path` indexes `path`.
+### 8. `snapshot_files`
 Maps snapshots to the files they contain.
 **Columns:**
 - `snapshot_id` (TEXT) - Snapshot ID (FK to snapshots.id)
 - `file_id` (TEXT) - File ID (FK to files.id)
 - PRIMARY KEY (`snapshot_id`, `file_id`)
-There is one row for each path, and it is updated when the file changes. The row
+**Purpose:** Records which files are included in each snapshot.
 is shared by every snapshot in the local index that lists the path. An older
 snapshot's own view of the file is in that snapshot's database at the
 destination.
-### `chunks`
+### 9. `snapshot_blobs`
 Maps snapshots to the blobs they reference.
-One row for each distinct chunk.
+**Columns:**
 - `snapshot_id` (TEXT) - Snapshot ID (FK to snapshots.id)
 - `blob_id` (TEXT) - Blob ID (FK to blobs.id)
 - `blob_hash` (TEXT) - Denormalized blob hash for manifest generation
 - PRIMARY KEY (`snapshot_id`, `blob_id`)
- `chunk_hash`: the SHA-256 hash of the chunk's content, in hex. Primary key.
+**Purpose:** Tracks blob dependencies for snapshots and enables manifest generation.
- `size`: the size in bytes.
+
 ### 10. `uploads`
 Tracks blob upload metrics.
 **Columns:**
 - `blob_hash` (TEXT PRIMARY KEY) - Hash of uploaded blob
 - `snapshot_id` (TEXT NOT NULL) - The snapshot that triggered this upload (FK to snapshots.id)
 - `uploaded_at` (INTEGER) - Upload timestamp
 - `size` (INTEGER) - Size of uploaded blob
 - `duration_ms` (INTEGER) - Upload duration in milliseconds
 **Purpose:** Performance monitoring and tracking which blobs were newly created (uploaded) during each snapshot.
 ## Data Flow and Operations
 ### 1. Backup Process
 1. **File Scanning**
   - `INSERT OR REPLACE INTO files` - Update file metadata
   - `SELECT * FROM files WHERE path = ?` - Check if file has changed
   - `INSERT INTO snapshot_files` - Add file to current snapshot
 2. **Chunking** (for changed files)
   - `INSERT OR IGNORE INTO chunks` - Store new chunks
   - `INSERT INTO file_chunks` - Map chunks to file
   - `INSERT INTO chunk_files` - Create reverse mapping
 3. **Blob Packing**
   - `INSERT INTO blobs` - Create blob record with UUID (blob_hash NULL)
   - `INSERT INTO blob_chunks` - Associate chunks with blob immediately
   - `UPDATE blobs SET blob_hash = ?, finished_ts = ?` - Finalize blob after packing
 4. **Upload**
   - `UPDATE blobs SET uploaded_ts = ?` - Mark blob as uploaded
   - `INSERT INTO uploads` - Record upload metrics with snapshot_id
   - `INSERT INTO snapshot_blobs` - Associate blob with snapshot
 5. **Snapshot Completion**
   - `UPDATE snapshots SET completed_at = ?, stats...` - Finalize snapshot
   - Generate and upload blob manifest from `snapshot_blobs`
 ### 2. Incremental Backup
-### `file_chunks`
+1. **Change Detection**
   - `SELECT * FROM files WHERE path = ?` - Get previous file metadata
   - Compare mtime, size, mode to detect changes
   - Re-chunk a file that lists a chunk no uploaded blob holds, even when its metadata is unchanged
   - Skip unchanged files but still add to `snapshot_files`
 2. **Chunk Reuse**
   - `SELECT * FROM blob_chunks WHERE chunk_hash = ?` - Find existing chunks
   - `INSERT INTO snapshot_blobs` - Reference existing blobs for unchanged files
 ### 3. Snapshot Metadata Export
-The chunks that make up each file, in order.
+After a snapshot is completed:
 1. Copy database to temporary file
 2. Clean temporary database to contain only current snapshot data
 3. VACUUM the trimmed database so deleted rows leave no pages behind
 4. Compress with zstd and encrypt with age
 5. Upload to S3 as `metadata/{remote-key}/db.zst.age`
 6. Generate blob manifest and upload as `metadata/{remote-key}/manifest.json.zst`
 The `{remote-key}` directory name is a one-way hash of the human snapshot ID, so the ID is never written to the store in plaintext. The hash uses no secret, so a guessed hostname and snapshot name can still be confirmed against a listing; see [REPOSTRUCTURE.md](REPOSTRUCTURE.md#remote-key-derivation) and its [Accepted Risks](REPOSTRUCTURE.md#accepted-risks).
 ### 4. Restore Process
- `file_id`: the file. References `files.id`.
+The restore process doesn't use the local database. Instead:
- `idx`: the position of the chunk within the file, counted from 0.
+1. Downloads and decrypts the snapshot's metadata database (`db.zst.age`) from S3
- `chunk_hash`: the chunk. References `chunks.chunk_hash`.
+2. Downloads the blobs holding the chunks of the files being restored, found through that database's `blob_chunks` table; the manifest is not read
 3. Reconstructs files from decrypted and decompressed chunks
-The primary key is (`file_id`, `idx`). `idx_file_chunks_chunk_hash` indexes
+### 5. Pruning
 `chunk_hash`.
-### `chunk_files`
+1. **Identify Unreferenced Blobs**
   - Query blobs not referenced by any remaining snapshot
   - Delete from S3 and local database
-The reverse of `file_chunks`: the files that contain each chunk.
+### 6. Incomplete Snapshot Cleanup
- `chunk_hash`: the chunk. References `chunks.chunk_hash`.
+Before each backup:
- `file_id`: the file. References `files.id`.
+1. Query incomplete snapshots (where `completed_at IS NULL`)
- `file_offset`: the byte offset of the chunk within the file.
+2. Delete each one and all its associations, without checking S3 for its metadata
- `length`: the length of the chunk in bytes.
+3. Clean up orphaned files, chunks, and blobs
-The primary key is (`chunk_hash`, `file_id`). `idx_chunk_files_file_id` indexes
+## Repository Pattern
 `file_id`.
-### `blobs`
+Vaultik uses a repository pattern for database access:
-One row for each blob.
+- `FileRepository` - CRUD operations for files and file metadata
 - `ChunkRepository` - CRUD operations for content chunks
 - `FileChunkRepository` - Manage file-to-chunk mappings
 - `ChunkFileRepository` - Manage chunk-to-file reverse mappings  
 - `BlobRepository` - Manage blob lifecycle (creation, finalization, upload)
 - `BlobChunkRepository` - Manage blob-to-chunk associations
 - `SnapshotRepository` - Manage snapshots and their relationships
 - `UploadRepository` - Track blob upload metrics
- `id`: a UUID, given when packing of the blob starts. Primary key.
+Each repository provides methods like:
- `blob_hash`: the name of the blob at the destination. Unique. Until the blob
+- `Create()` - Insert new record
-  is closed, it holds a placeholder that starts with `temp-placeholder-`.
+- `GetByID()` / `GetByPath()` / `GetByHash()` - Retrieve records
- `created_ts`: when packing started.
+- `Update()` - Update existing records
- `finished_ts`: when the blob was closed. It is `NULL` before that.
+- `Delete()` - Remove records
- `uncompressed_size`: the total size of the blob's chunks.
+- Specialized queries for each entity type (e.g., `DeleteOrphaned()`, `GetIncompleteByHostname()`)
 - `compressed_size`: the size after compression and encryption.
 - `uploaded_ts`: when the upload finished. It is `NULL` before that.
-`blob_hash` is `hex(SHA256(SHA256(uncompressed contents)))`. See
+## Transaction Management
 [`REPOSTRUCTURE.md`](REPOSTRUCTURE.md#blobs).
-Once a blob is uploaded, `compressed_size` is the size of the object at the
+All database operations that modify multiple tables are wrapped in transactions:
 destination. A blob that was already there can have a different size from the
 local copy. That happens when it was written with another compression level or
 other recipients.
 ### `blob_chunks`
 The chunks that each blob holds.
 - `blob_id`: the blob. References `blobs.id`.
 - `chunk_hash`: the chunk. References `chunks.chunk_hash`.
 - `offset`: the byte offset of the chunk within the uncompressed blob.
 - `length`: the length of the chunk in bytes.
 The primary key is (`blob_id`, `chunk_hash`). `idx_blob_chunks_chunk_hash`
 indexes `chunk_hash`.
 A restore finds the blob for each chunk through this table.
 ### `snapshots`
 One row for each snapshot.
 - `id`: the snapshot ID. Primary key.
 - `hostname`: the `hostname` setting of the config. When that setting is empty,
  it is the machine's hostname.
 - `vaultik_version`: the `vaultik` version that made it.
 - `vaultik_git_revision`: the git commit of that version.
 - `started_at`: when the backup started.
 - `completed_at`: when the backup finished. It is `NULL` until then.
 - `file_count`: the number of files and symlinks in the snapshot. Directories
  are not counted.
 - `chunk_count`: the number of chunks this snapshot stored that were not stored
  before.
 - `new_chunk_size`: the total size of those chunks before compression.
 - `blob_count`: the number of blobs this snapshot created.
 - `total_size`: the total size of all files in the snapshot.
 - `uncompressed_chunk_size`: the total size, before compression, of the distinct
  chunks the snapshot's files use.
 - `blob_size`: the total compressed size of the blobs the snapshot uses.
 - `blob_uncompressed_size`: the total uncompressed size of those blobs.
 - `compression_ratio`: the compression ratio of those blobs.
 - `compression_level`: the compression level the backup used.
 - `upload_bytes`: the bytes uploaded during the backup.
 - `upload_duration_ms`: the time spent uploading, in milliseconds.
 The snapshot ID has the form `<hostname>_<snapshot-name>_<timestamp>`. An
 example is `server1_home_2025-06-01T12:00:00Z`. It has three parts:
 - the hostname, up to its first `.`
 - the snapshot name
 - the start time, in UTC
 The `snapshot list` table shows `uncompressed_chunk_size` as `UNCOMPRESSED SIZE`
 and `new_chunk_size` as `NEW CHUNK SIZE`.
 A snapshot with `completed_at` set to `NULL` is unfinished. `snapshot list`
 shows it only when its manifest is at the destination, and then as remote only.
 The next backup deletes it, and so does `prune`.
 ### `snapshot_files`
 The files in each snapshot.
 - `snapshot_id`: the snapshot. References `snapshots.id`.
 - `file_id`: the file. References `files.id`.
 The primary key is (`snapshot_id`, `file_id`). `idx_snapshot_files_file_id`
 indexes `file_id`.
 ### `snapshot_blobs`
 The blobs that each snapshot uses.
 - `snapshot_id`: the snapshot. References `snapshots.id`.
 - `blob_id`: the blob. References `blobs.id`.
 - `blob_hash`: a copy of the blob's hash.
 The primary key is (`snapshot_id`, `blob_id`). `idx_snapshot_blobs_blob_id`
 indexes `blob_id`.
 The manifest is built from this table.
 ### `snapshot_mount_points`
 The mount points that a snapshot's backup found.
 - `snapshot_id`: the snapshot. References `snapshots.id`.
 - `path`: the absolute path of the directory.
 The primary key is (`snapshot_id`, `path`).
 A directory is recorded here when all of these hold:
 - It is at or below a configured path.
 - The backup found an entry in it that is not excluded.
 - It is on a different filesystem from its parent directory.
 The device number is read after the directory has been listed. An automount
 point is a directory whose volume is mounted when it is first listed, so the
 number is that of the volume. An automount point whose volume cannot be mounted
 is not recorded, because the backup finds no entry in it.
 `snapshot create --prune` reads this table. It skips the prune when an earlier
 snapshot of the same name recorded a mount point that the new backup did not
 find. That happens when the volume is not mounted.
 ### `uploads`
 One row for each blob that a backup uploaded.
 - `blob_hash`: the blob. References `blobs.blob_hash`. Primary key.
 - `snapshot_id`: the snapshot whose backup uploaded it. References
  `snapshots.id`.
 - `uploaded_at`: when the upload started. It is written as a date and time, not
  as seconds.
 - `size`: the size of the uploaded blob.
 - `duration_ms`: the duration of the upload, in milliseconds.
 `idx_uploads_snapshot_id` indexes `snapshot_id`.
 A blob that was already at the destination gets no row here.
 ### `local_meta`
 Settings that belong to this copy of the index.
 - `key`: the name of the setting. Primary key.
 - `value`: its value.
 The only key is `storage_url`. A backup sets it once it has written the marker
 file at the destination. No other command sets it. These commands refuse to run
 when the config names a different destination:
 - `snapshot create`
 - `snapshot purge`
 - `snapshot remove`
 - `prune`
 - `remote nuke`
 ### `schema_migrations`
 The migrations that have run.
 - `version`: the number of the migration. Primary key.
 - `applied_at`: when it ran. It is written as a date and time, not as seconds.
 ## How commands use the tables
 ### Backup
 A backup works on the tables in this order:
 - It saves the destination in `local_meta` when the index has none yet. It does
  so once it has written the marker file at the destination.
 - It deletes unfinished snapshots, and the rows that no snapshot uses.
 - It creates a row in `snapshots`, with `completed_at` set to `NULL`.
 - It deletes the `blobs` rows that were never uploaded.
 - It walks each path. It compares each regular file and symlink with its row in
  `files`.
 - It links each unchanged file to the snapshot in `snapshot_files`.
 - It writes a `files` row and a `snapshot_files` row for each directory.
 - It records each mount point in `snapshot_mount_points`.
 - It reads each changed regular file and stores it. See below. A changed symlink
  is recorded without being read.
 - It fills `snapshot_blobs` with every blob the snapshot uses.
 - It stores the snapshot's totals in `snapshots`.
 - It uploads the snapshot's metadata.
 - It sets `completed_at`.
 A file counts as changed when its row in `files` differs from the file on disk
 in any of these:
 - size
 - modification time
 - mode
 - owner or group
 - link target
 A file is also read again when it lists a chunk that no uploaded blob holds. A
 regular file with no row in `files` is read too.
 Storing a changed file writes these rows:
 - A row in `blobs`, when packing of a blob starts.
 - When the blob is closed, in one transaction:
    - a row in `chunks` for each chunk queued since the last blob was closed.
      When a blob is full, that includes the first chunk of the next blob.
    - the blob's rows in `blob_chunks`
    - the blob's `blob_hash`, sizes and `finished_ts`
 - When the blob is stored at the destination, in one transaction:
    - `uploaded_ts` and `compressed_size` in `blobs`
    - a row in `snapshot_blobs`
    - a row in `uploads`, unless the blob was already at the destination
 - The row in `files`, and its rows in these tables:
    - `file_chunks`
    - `chunk_files`
    - `snapshot_files`
 The row in `files` is written last. It is written only after every blob that
 holds the file's new chunks is stored.
 ### Snapshot metadata
 The metadata of a snapshot is made from a copy of the index:
 - The index is copied into a temporary directory with `VACUUM INTO`.
 - The rows of every other snapshot are deleted from the copy. So are the files
  and blobs that this snapshot does not use. A chunk is then deleted when no
  remaining file and no remaining blob uses it.
 - The `local_meta` and `schema_migrations` tables are kept as they are. The
  uploaded database therefore names the destination, and lists the migrations
  that have run.
 - `VACUUM` rewrites the copy, so that no deleted row is left in the file.
 - The copy is compressed with [zstd](https://github.com/facebook/zstd) and
  encrypted with [age](https://age-encryption.org/).
 - The manifest is built from the copy's `snapshot_blobs` table.
 - The copy is uploaded as `metadata/<remote-key>/db.zst.age`.
 - The manifest is uploaded as `metadata/<remote-key>/manifest.json.zst`.
 The copy is made through SQLite, not by copying the file. The index runs in
 SQLite's write-ahead log (WAL) mode, so rows that are already committed can
 still be in the `-wal` file beside it.
 ### Restore
 A restore reads no file, chunk or blob rows from the local index. It reads
 `snapshots` and `local_meta` there, to look up a snapshot ID and to check the
 marker file.
 - It downloads and decrypts `db.zst.age` into a temporary directory.
 - It opens that file read-only. It applies no migration to it.
 - It reads the snapshot's row in `snapshots`, to check that this is the right
  database.
 - It reads the files to restore from `files`.
 - It finds each file's chunks in `file_chunks`.
 - It finds the blob and offset of each chunk in `blob_chunks`.
 - It finds the name of each blob in `blobs`.
 - With `--verify`, it reads each chunk's size from `chunks`.
 It does not read the manifest.
 ### Prune
 `prune` saves nothing in `local_meta`. It refuses to run when `local_meta` holds
 a different destination from the configured one. It changes the local index in
 two ways:
 - It deletes each snapshot whose manifest is gone from the destination.
 - It deletes unfinished snapshots, and the rows that no snapshot uses.
 The second step removes unused rows in this order:
 - files that are in no snapshot
 - blobs that are in no snapshot
 - `blob_chunks` rows whose chunk is gone
 - chunks that no file and no blob uses
 `prune` then deletes unused data at the destination. That step reads the
 manifests, not the local index. It reads the local index only to keep a
 directory under `metadata/` whose snapshot is still recorded there.
 ## Code
 Each repository type in `internal/database` serves one or more tables:
 - `FileRepository`: `files`
 - `ChunkRepository`: `chunks`
 - `FileChunkRepository`: `file_chunks`
 - `ChunkFileRepository`: `chunk_files`
 - `BlobRepository`: `blobs`
 - `BlobChunkRepository`: `blob_chunks`
 - `SnapshotRepository`:
    - `snapshots`
    - `snapshot_files`
    - `snapshot_blobs`
    - `snapshot_mount_points`
    - `uploads`, where it deletes a snapshot's rows
 - `UploadRepository`: `uploads`
 - `LocalMetaRepository`: `local_meta`
 No repository type serves `schema_migrations`. The code that applies the
 migrations reads and writes it.
 `Repositories` holds one of each type.
 `Repositories.WithTx` runs a function in one transaction:
 ```go
 err := repos.WithTx(ctx, func(ctx context.Context, tx *sql.Tx) error {
-    // several repository calls that use tx
+    // Multiple repository operations using tx
 })
 ```
-The transaction commits when the function returns no error. Otherwise it is
+This ensures consistency, especially important for operations like:
-rolled back.
+- Creating file-chunk mappings
 - Associating chunks with blobs
 - Updating snapshot statistics
-## SQLite settings
+## Performance Considerations
- The index runs in WAL mode. A command that only reads, such as
+1. **Indexes**: 
-  `snapshot list`, can read the index while a backup writes to it.
+   - Primary keys are automatically indexed
- A connection waits up to 10 seconds for a lock before it fails.
+   - `idx_files_path` on `files(path)` for efficient file lookups
- Foreign keys are enforced.
+
- Each open database uses one connection, so its queries run one at a time.
+2. **Prepared Statements**: All queries use prepared statements for performance and security
- Queries pass their values as parameters.
+
 3. **Batch Operations**: Where possible, operations are batched within transactions
 4. **Write-Ahead Logging**: The local index runs in SQLite WAL mode with a 10-second busy timeout, so a read-only command such as `snapshot list` can read it while a backup writes to it. Committed rows can sit in the `-wal` file beside the index until a checkpoint, so the metadata export copies the index through SQLite (`VACUUM INTO`), not as a file
 ## Data Integrity
 1. **Foreign Keys**: Enforced through CASCADE DELETE and application-level repository methods
 2. **Unique Constraints**: Chunk hashes, file paths, and blob hashes are unique
 3. **Null Handling**: Nullable fields clearly indicate in-progress operations
 4. **Timestamp Tracking**: All major operations record timestamps for auditing
@@ -1,447 +1,177 @@
-# vaultik destination layout
+# Vaultik S3 Repository Structure
-This document describes what `vaultik` stores at the destination. It covers the
+This document describes the structure and organization of data stored in the S3 bucket by Vaultik.
 layout, what the layout protects, and the risks it accepts.
-The destination is the place the backups are stored. It is an S3 bucket and
+## Overview
 prefix, a local directory or an [rclone](https://rclone.org/) remote. A remote
 is a storage service set up in rclone. The layout is the same on all three.
-## Terms
+Vaultik stores all backup data in an S3-compatible object store. The repository consists of two main components:
 1. **Blobs** - The actual backup data (content-addressed, encrypted)
 2. **Metadata** - Snapshot information and manifests (partially encrypted)
- **Snapshot**: one backup of the paths listed under one name in the config.
+## Directory Structure
 - **Snapshot ID**: the name of a snapshot, in the form
  `<hostname>_<snapshot-name>_<timestamp>`.
 - **Remote key**: a hash of the snapshot ID. It names the snapshot's directory
  under `metadata/`. See [Remote keys](#remote-keys).
 - **Chunk**: a piece of a file's content, named by the SHA-256 hash of that
  content.
 - **Blob**: one object under `blobs/`. It holds many chunks.
 - **Local index**: the SQLite database on the backed-up machine.
 - **Recipient**: an [age](https://age-encryption.org/) public key that backups
  are encrypted to.
 ## Layout
 ```
-<destination>/
+<bucket>/<prefix>/
 ├── vaultik-destination.txt
 ├── blobs/
 │   └── <hash[0:2]>/
 │       └── <hash[2:4]>/
-│           └── <hash>
+│           └── <full-hash>
 └── metadata/
    └── <remote-key>/
        ├── db.zst.age
        └── manifest.json.zst
 ```
-The destination holds three things:
+The metadata subdirectory is named with the **remote key**, a one-way hash of the snapshot ID, not with the human-readable snapshot ID itself. See [Remote Key Derivation](#remote-key-derivation).
- `vaultik-destination.txt`, the marker file
+## Blobs Directory (`blobs/`)
 - `blobs/`, which holds the file contents
 - `metadata/`, which holds one directory for each snapshot
-## The marker file
+### Structure
 - **Path format**: `blobs/<first-2-chars>/<next-2-chars>/<full-hash>`
 - **Example**: `blobs/ca/fe/cafebabe1234567890abcdef1234567890abcdef1234567890abcdef12345678`
 - **Sharding**: The two-level directory structure (using the first 4 characters of the hash) prevents any single directory from containing too many objects
-Every backup writes `vaultik-destination.txt` before it uploads anything else.
+### Content
-The file holds one fixed line of text. It names no host, path or time.
+- **What it contains**: Packed collections of content-defined chunks from files
 - **Format**: Zstandard compressed, then Age encrypted
 - **Encryption**: Always encrypted with Age using the configured recipients
 - **Naming**: Content-addressed. The blob's name is `hex(SHA256(SHA256(uncompressed blob contents)))` — the double SHA-256 of the concatenated chunk data, computed before compression and encryption, not a hash of the stored (compressed, encrypted) bytes. One consequence: only a holder of the age private key can check a stored blob's integrity, because matching a blob to its name means decrypting and decompressing it first — which is what `restore` and `verify --deep` do. Implemented in `internal/blobgen` (`DoubleSHA256`). This is the canonical description of blob naming; other documents and comments point here.
-The marker tells an emptied or missing destination apart from a new one. An
+### Why Encrypted
-unplugged volume leaves an empty directory at its mount point. Without the
+Blobs contain the actual file data from backups and must be encrypted for security. The content-addressing ensures deduplication while the encryption ensures privacy.
 marker, that directory would look like a destination whose snapshots are all
 gone.
-The check applies while the local index holds snapshots and belongs to the
+## Metadata Directory (`metadata/`)
 configured destination. When the destination then answers that the marker does
 not exist, commands treat the destination as not present:
- `snapshot create` refuses to write to it.
+Each snapshot has its own subdirectory. The directory is **not** named with the human-readable snapshot ID; it is named with the remote key — a one-way hash of that ID. The human ID is never written to the destination store as a directory name (see [Remote Key Derivation](#remote-key-derivation)).
 - These commands fail:
    - `prune`
    - `snapshot purge`
    - `remote nuke`
    - `snapshot verify` and `snapshot restore`, when given a remote key, or a
      snapshot ID that is not in the local index
 - `snapshot list` shows the local index alone.
 - `snapshot remove` deletes nothing at the destination.
-The check is skipped when the look-up fails for any other reason. S3 refuses the
+### Snapshot ID Format
 look-up to credentials that can only write. A machine with such credentials
 therefore does not notice an emptied destination. Its next backup would not
 upload data that its local index says is stored. After a destination is emptied,
 run `vaultik database delete` on such a machine before it backs up again.
-`remote nuke` deletes the marker last.
+The human-readable snapshot ID is used in CLI arguments, log lines, and the local database. It is not written to the destination store.
 - **Format**: `<hostname>_<snapshot-name>_<RFC3339>` (or `<hostname>_<RFC3339>` if no
  name was specified)
 - **Example**: `laptop_home_2024-01-15T14:30:52Z`
 - **Components**:
  - Short hostname (everything before the first dot is stripped from the FQDN)
  - Snapshot name from the configured `snapshots:` map (optional)
  - RFC3339 UTC timestamp
-## Blobs
+This ID reveals the hostname, the configured snapshot name, and the backup time, so it is never used as the on-disk directory name — the remote key is used instead.
-A blob holds the content of many chunks, one after another.
+### Remote Key Derivation
- **Path**: `blobs/<first 2 characters>/<next 2 characters>/<full hash>`.
+The remote key is `hex(SHA256(SHA256("vaultik|" + snapshot-id)))`: a double SHA-256 over the snapshot ID, with a `vaultik|` domain-separation prefix. The result is a 64-character hex string. The hash is not reversible, but it uses no secret: an observer who guesses a candidate hostname and snapshot name can hash it the same way and confirm whether that snapshot is present. The remote key keeps names out of a plain listing; it does not hide them from a guess. Implemented in `internal/snapshot/remotekey.go`.
 - **Example**:
  `blobs/ca/fe/cafebabe1234567890abcdef1234567890abcdef1234567890abcdef12345678`.
 - **Format**: the chunk data, compressed with
  [zstd](https://github.com/facebook/zstd) and then encrypted with age.
 - **Recipients**: the public keys in the `age_recipients` setting when the blob
  was written.
 The two directory levels keep any one directory from holding too many objects.
 ### Blob names
 A blob's name is `hex(SHA256(SHA256(uncompressed contents)))`. The contents are
 the chunk data, joined in order, before compression and encryption. The name is
 not a hash of the stored bytes.
 This has three consequences:
 - Checking a blob against its name needs the private key. The blob must be
  decrypted and decompressed first. `snapshot restore` and
  `snapshot verify --deep` do this.
 - Without the key, only a blob's presence and size can be checked.
  `snapshot verify` does this.
 - Someone who has the whole contents of a blob can compute its name, and so see
  whether it is stored. This works for a file they have that fills blobs on its
  own.
 `blobgen.DoubleSHA256` in `internal/blobgen` computes the name.
 ### Uploads
 A backup looks a blob up by name before it uploads it. It does not upload a blob
 that is already there.
 On S3, when the destination refuses the look-up, the backup uploads the blob. An
 object with that name is then replaced by one that holds the same chunk data.
 ## Metadata
 Each snapshot has one directory under `metadata/`. The directory is named with
 the snapshot's remote key, not with its snapshot ID.
 ### Snapshot IDs
 A snapshot ID has the form `<hostname>_<snapshot-name>_<timestamp>`. An example
 is `laptop_home_2024-01-15T14:30:52Z`. It has three parts:
 - the hostname, up to its first `.`
 - the snapshot name from the config
 - the time the backup started, in UTC
 The snapshot ID is used on the command line, in log records and in the local
 index. It reveals the hostname, the snapshot name and the backup time. It is
 therefore never written to the destination without encryption.
 ### Remote keys
 The remote key is `hex(SHA256(SHA256("vaultik|" + snapshot ID)))`. It is 64 hex
 characters long. `internal/snapshot/remotekey.go` computes it.
 For example:
 Worked example:
 - Snapshot ID: `server1_home_2025-06-01T12:00:00Z`
 - Remote key: `17f97bcde958748af076b926af59823943db59e80ce7170b40f124dfa28f64aa`
- Directory:
+- Directory: `metadata/17f97bcde958748af076b926af59823943db59e80ce7170b40f124dfa28f64aa/`
  `metadata/17f97bcde958748af076b926af59823943db59e80ce7170b40f124dfa28f64aa/`
-A listing of the destination therefore shows no hostname and no snapshot name.
+A plain listing of the destination store therefore shows only these hashes, not the hostname or snapshot name of any backup — but because the hash uses no secret, a guessed hostname and snapshot name can be hashed and confirmed against the listing. The same remote key is stored in the manifest's `snapshot_id` field.
-The hash cannot be reversed, but it uses no secret. Someone who guesses a
+### Files in Each Snapshot Directory
 snapshot ID can hash it the same way and see whether that snapshot exists. The
 remote key keeps names out of a listing. It does not hide them from a guess.
-### `db.zst.age`
+#### `db.zst.age` - Encrypted Database
-
+- **What it contains**: Pruned binary SQLite database for this snapshot
-The snapshot's database. A restore needs it.
+- **Format**: Binary SQLite → Zstandard compressed → Age encrypted
-
+- **Encryption**: Encrypted with Age
- **Contents**: a SQLite database. It is a copy of the local index without the
+- **Purpose**: Contains full file metadata, chunk mappings, and all relationships
-  rows of other snapshots. It lists every file in the snapshot with its
+- **Why encrypted**: Contains sensitive metadata like file paths, permissions, and ownership
  metadata, its chunks, and the blob that holds each chunk.
 - **Format**: the database file, compressed with zstd and then encrypted with
  age.
 It is encrypted because it holds file paths, permissions and owners.
 [`DATAMODEL.md`](DATAMODEL.md) describes its tables.
 ### `manifest.json.zst`
 The list of the blobs the snapshot uses.
 - **Format**: JSON, compressed with zstd. It is not encrypted.
 #### `manifest.json.zst` - Unencrypted Blob Manifest
 - **What it contains**: JSON list of all blob hashes referenced by this snapshot
 - **Format**: JSON → Zstandard compressed (NOT encrypted)
 - **Encryption**: NOT encrypted
 - **Purpose**: Enables pruning operations without requiring decryption keys
 - **Structure**:
 ```json
 {
-    "snapshot_id": "17f97bcde958748af076b926af59823943db59e80ce7170b40f124dfa28f64aa",
+  "snapshot_id": "17f97bcde958748af076b926af59823943db59e80ce7170b40f124dfa28f64aa",
-    "timestamp": "2025-06-01T12:04:31Z",
+  "timestamp": "2025-06-01T12:00:00Z",
-    "blob_count": 2,
+  "blob_count": 42,
-    "total_compressed_size": 57344,
+  "total_compressed_size": 1048576,
-    "blobs": [
+  "blobs": [
-        {
+    { "hash": "cafebabe1234567890abcdef1234567890abcdef1234567890abcdef12345678", "compressed_size": 24576 },
-            "hash": "cafebabe1234567890abcdef1234567890abcdef1234567890abcdef12345678",
+    { "hash": "deadbeef1234567890abcdef1234567890abcdef1234567890abcdef12345678", "compressed_size": 32768 }
-            "compressed_size": 24576
+  ]
        },
        {
            "hash": "deadbeef1234567890abcdef1234567890abcdef1234567890abcdef12345678",
            "compressed_size": 32768
        }
    ]
 }
 ```
-
+`snapshot_id` is the remote key (a hash), not the human ID; `timestamp` is written in the clear.
- `snapshot_id`: the remote key, not the snapshot ID.
+
- `timestamp`: when the manifest was written, at the end of the backup.
+### Why Manifest is Unencrypted
- `blob_count`: the number of blobs.
+The manifest must be readable without the private key to enable:
- `total_compressed_size`: the total size of those blobs, in bytes.
+1. **Pruning operations** - Identifying unreferenced blobs for deletion
- `blobs`: the hash and the size of each blob.
+2. **Storage analysis** - Understanding space usage without decryption
-
+3. **Verification** - Checking blob existence without decryption
-The manifest holds no file name and no path.
+4. **Cross-snapshot deduplication analysis** - Finding shared blobs between snapshots
-
+
-The manifest is not encrypted so that these commands work without the private
+The manifest contains the remote key, the backup timestamp, the blob count and total compressed size, and each blob's hash and compressed size. It contains no file names, paths, or other decrypted metadata.
-key:
+
-
+## Security Considerations
- `prune`, which must know which blobs are still in use
+
- `snapshot verify`, which checks that each blob is present
+### What's Encrypted
- `snapshot list` and `remote info`, which report what the destination holds
+- **All file content** (in blobs)
-
+- **All file metadata** (paths, permissions, timestamps, ownership in db.zst.age)
-## What is protected
+- **File-to-chunk mappings** (in db.zst.age)
-
+
-These are encrypted:
+### What's Not Encrypted
-
+- **The remote key** — directory names and the manifest `snapshot_id`, a one-way hash of the snapshot ID (see [Remote Key Derivation](#remote-key-derivation))
- file contents, in the blobs
+- **The backup timestamp** (in manifest.json.zst)
- in `db.zst.age`:
+- **Blob hashes and their compressed sizes** (in manifest.json.zst)
-    - file names and paths
+- **Blob count and total compressed size per snapshot** (in manifest.json.zst)
-    - permissions and owners
+
-    - modification times
+### Privacy Implications
-    - which chunks make up which file
+From the unencrypted data, an observer of the destination store can determine:
-
+- **When each backup was taken** — not from the directory name, which is a one-way hash, but from the plaintext `timestamp` field in manifest.json.zst, which is published in the clear
-These are not encrypted:
+- How many blobs each snapshot references, and the total compressed size
-
+- The compressed size of each blob, and which blobs are shared between snapshots (deduplication patterns)
- the remote key of each snapshot
+- **Whether a guessed hostname and snapshot name are present** — the remote key is an unkeyed hash, so an observer holding candidate names can hash each one and match it against the directory listing. The human ID is never published, so it cannot be read off directly, but it can be confirmed by guessing.
- the time each backup finished, in the manifest
+
- the hash and the compressed size of each blob, in the manifest
+Together these give an observer a timing-and-size profile of every snapshot. This is an accepted, documented property of the format, not a defect: the manifest is unencrypted so that pruning can run without the private key, and the timing channel could not be closed by encrypting it anyway — object creation times and per-object sizes stay visible at the storage layer on both `s3://` and `file://` destinations regardless.
- the number of blobs and their total size for each snapshot, in the manifest
+
-
+An observer cannot determine:
-Someone who can read the destination therefore learns these:
+- The hostname or snapshot name of any backup by reading it off the store — the directory name and the manifest `snapshot_id` are unkeyed hashes of the human ID, so the text is never published (though a guessed name can be confirmed, as above)
-
+- File names or paths
- when each backup finished
+- File contents
- how many blobs each snapshot uses, and how large they are
+- File permissions or ownership
- which blobs two snapshots share
+- Directory structure
- whether a blob holds data they already have in full
+- Which chunks belong to which files
- whether a snapshot ID they guess exists
+
-
+### Accepted Risks
-They do not learn these:
+
-
+These are known, deliberate properties of the format and the tooling, recorded so an operator can weigh them rather than discover them.
- any hostname or snapshot name, unless they guess it
+
- file names or paths
+1. **No proof of authorship.** Restore and `verify --deep` prove that data decrypts with the age private key and matches its unkeyed content hashes. They do not prove who wrote it: anyone who knows a recipient public key and can replace objects on the destination can substitute a snapshot they built. The recipient string is not stored at the destination, but a compromised backed-up host has it. Defences live on the destination side — bucket versioning or object lock, credentials for the source host that cannot delete or overwrite existing versions, and pruning from a trusted host. Note that S3 `PutObject` overwrites an existing key, so PUT permission alone is not append-only.
- file contents
+2. **Compression reveals sizes.** Blobs and `db.zst.age` are zstd-compressed then age-encrypted; the manifest is compressed only. age does not pad, so an object's size is the exact compressed length of its contents. All new chunks packed into one blob share a single zstd stream (8 MiB window, 4 MiB at compression levels 1-2), and a blob is closed at `blob_size_limit` and at the end of each configured path. Because a stored chunk is never packed again, someone who can write into a backed-up file and watch blob sizes learns something only when their controlled data and a secret land in the same chunk of a file that keeps changing. Advice: back up any outsider-writable directory as its own snapshot.
- permissions or owners
+3. **Chunking uses no secret.** The FastCDC parameters are fixed and public. The default 10 MB average yields chunks between 2.5 MB and 40 MB, and any file of 2.5 MB or less is a single chunk. At the default 10 GB `blob_size_limit` a blob holds hundreds of chunks, so individual chunk lengths are not visible in the blob's size; lowering the limit toward the chunk size begins to expose them.
- the directory structure
+4. **Decrypted data on local disk.** Several commands stage plaintext under `$TMPDIR`: `snapshot restore` writes decrypted blobs under `vaultik-blobcache-*/` (no size cap) and the decrypted metadata database at `vaultik-restore-*/snapshot.db`; `verify --deep` writes that database at `vaultik-verify-*/snapshot.db`; `snapshot create` keeps a plaintext copy of the index at `vaultik-snapshot-*/snapshot.db`. These files are created `0600` and removed on success, but a `kill -9` or a power loss leaves them behind — delete any leftover `vaultik-*` directory under `$TMPDIR` by hand. `$TMPDIR` should be trusted to the same degree as the restore target.
- which chunks belong to which file
+5. **Store permissions differ per command.** The backed-up host needs only PUT to run `snapshot create`: it writes blobs and metadata and neither reads nor deletes them. Other commands need more — `snapshot verify`, `snapshot restore`, and `prune` list and read; `prune`, `snapshot purge`, `snapshot remove`, and `remote nuke` also delete. The recommended cron line uses `--prune`, which runs `prune` on the backed-up host, so granting that host `--prune` gives it credentials that can delete its own backups. To keep the source host to PUT only, prune from a separate trusted host instead.
-
+6. **Changing recipients does not re-encrypt existing data.** Deduplicated chunks and same-named blobs already on the destination stay encrypted to the recipients in force when they were written. A new snapshot that reuses them cannot be restored with a newly added recipient's key alone, because those reused objects were never encrypted to it. To make everything readable by a new key, run `vaultik database delete` and take a full backup to a fresh destination or prefix.
-The times and sizes could not be hidden by encrypting the manifest. The
+7. **X25519 recipients only.** vaultik rejects age ssh and plugin recipients. Long-lived ciphertext held by a third party (the destination operator) has no fallback if X25519 is ever broken: there is no second recipient type and no post-quantum option.
-destination itself shows when each object was written and how large it is.
+
-
+## Consistency Guarantees
-## Accepted risks
+
-
+1. **Blobs are immutable** - Once written, a blob is never modified
-These are known properties of the format. They are written down so that you can
+2. **Blobs are written before metadata** - A snapshot's metadata is only written after all its blobs are successfully uploaded
-weigh them.
+3. **Metadata is written atomically** - Both db.zst.age and manifest.json.zst are written as complete files
-
+4. **A snapshot is marked complete in the local DB only after its metadata is uploaded** - `finalizeSnapshotMetadata` runs `ExportSnapshotMetadata` first and records completion (`MarkSnapshotComplete`) only once the export succeeds (see the backup data flow in [ARCHITECTURE.md](../ARCHITECTURE.md)). A crash during the export therefore leaves the snapshot incomplete, so the next backup's `PruneDatabase` drops it and re-backs-up its data, rather than leaving a completed-looking row in the local index with no matching metadata on the destination store. (A crash in the brief moment after the export succeeds but before completion is recorded leaves a fully-restorable snapshot on the destination that the local index drops as incomplete on the next run; `snapshot list` then reports it honestly as remote-only, which is the safe direction: the destination copy stays restorable.)
-### No proof of who wrote the data
+
-
+## Pruning Safety
-A restore and `snapshot verify --deep` prove two things. The data decrypts with
+
-your private key, and it matches its hashes. They do not prove who wrote it.
+The prune operation is safe because:
-
+1. It keeps every blob listed in any snapshot's manifest and deletes only blobs that no manifest references
-The hashes use no secret. Someone who knows a recipient's public key and can
+2. Manifests are unencrypted and can be read without keys
-replace objects at the destination can put a snapshot of their own there. The
+3. If any manifest cannot be downloaded or decoded, prune deletes nothing and exits with an error, rather than treating that snapshot's blobs as unreferenced
-public key is not stored at the destination, but a backed-up machine that is
+4. Prune requires exclusive access to the destination: running it during a concurrent backup can race a snapshot whose manifest is not yet written, so do not prune while a backup is in progress
-broken into has it.
+
-
+## Restoration Requirements
-The defences are on the destination's side:
+
-
+To restore from a backup, you need:
- object versioning or object lock on the bucket
+1. **The Age private key** - To decrypt blobs and database
- credentials for the backed-up machine that cannot delete or overwrite
+2. **The snapshot metadata** - Both files from the snapshot's metadata directory
- running `prune` from a trusted machine
+3. **All referenced blobs** - As listed in the manifest
-
+
-An S3 `PutObject` replaces an existing object. Permission to write alone
+The restoration process:
-therefore does not stop overwrites.
+1. Download and decrypt the database dump to understand file structure
-
+2. Download and decrypt the required blobs
-### Sizes are visible
+3. Reconstruct files from their chunks
-
+4. Restore file metadata (permissions, timestamps, etc.)
 An object's size follows exactly from the size of its compressed contents.
 All the new chunks in one blob share one zstd stream. The stream looks back 8
 MiB, or 4 MiB at compression levels 1 and 2. A blob is closed at the
 `blob_size_limit` setting and at the end of each configured path. A chunk that
 the local index records as uploaded is never packed again.
 Data that an outsider writes compresses smaller when it matches a secret near it
 in the same blob, so the blob gets smaller. The blob's size therefore shows the
 outsider whether their data matched the secret.
 This works only when all of these hold:
 - The outsider can write into a backed-up file.
 - The outsider can see the blob sizes at the destination.
 - The outsider's data and the secret are in the same blob, no further apart than
  the stream looks back.
 - The file keeps changing.
 Back up a directory that outsiders can write to as a snapshot of its own.
 ### Chunk boundaries use no secret
 `vaultik` finds chunk boundaries with the FastCDC algorithm. Its parameters are
 fixed and public. `chunk_size` sets the average chunk size. No chunk is larger
 than four times this size. Only a file's last chunk can be smaller than a
 quarter of it. With the default of 10 MB, those limits are 40 MB and 2.5 MB. A
 file of 2.5 MB or less is one chunk. An empty file has no chunk.
 At the default `blob_size_limit` of 10 GB, a full blob holds hundreds of chunks.
 The size of the blob then does not show the size of any one chunk. A limit close
 to `chunk_size` begins to show chunk sizes.
 ### Decrypted data on the local disk
 These commands write unencrypted data to the temporary directory:
 - `snapshot restore` writes decrypted blobs under `vaultik-blobcache-*/`. There
  is no limit on their total size.
 - `snapshot restore` writes the decrypted database to
  `vaultik-restore-*/snapshot.db`.
 - `snapshot verify --deep` writes the decrypted database to
  `vaultik-verify-*/snapshot.db`.
 - `snapshot create` writes a copy of the local index to
  `vaultik-snapshot-*/snapshot.db`.
 These files are readable only by their owner, and are removed when the command
 ends. A `kill -9` or a power loss leaves them behind. Delete any leftover
 `vaultik-*` entry in the temporary directory yourself.
 Trust the temporary directory as much as the directory you restore into.
 ### Commands need different permissions
 `snapshot create` without `--prune` writes objects. On S3 it needs no other
 permission. Other commands need more:
 - These commands list and read:
    - `snapshot list`
    - `snapshot verify`
    - `snapshot restore`
    - `remote info`
 - These commands list and delete:
    - `snapshot purge`
    - `snapshot remove`
    - `remote nuke`
 - `prune` lists, reads and deletes.
 An rclone remote that can move objects also needs permission to read and delete.
 An upload there looks up the object it replaces and deletes it. It stops when
 the look-up is refused.
 `snapshot verify` and `snapshot restore` list only when they are given a remote
 key, or a snapshot ID that is not in the local index.
 `snapshot remove --local-only` does not reach the destination.
 `snapshot remove --dry-run` deletes nothing.
 `snapshot create --prune` runs a prune on the backed-up machine. That machine
 then holds credentials that can delete its own backups. To keep it to write-only
 credentials, run `prune` from a separate, trusted machine. `prune` there deletes
 only data that no snapshot uses. It does not remove old snapshots.
 ### New recipients cannot read old data
 Changing `age_recipients` does not re-encrypt what is already stored. A chunk
 that the local index records as uploaded is not written again, so it stays
 encrypted to the earlier recipients.
 A new snapshot that uses such chunks cannot be restored with a new recipient's
 key alone. To make everything readable by a new key, run
 `vaultik database delete` and take a full backup to a new destination.
 ### X25519 recipients only
 `vaultik` accepts age X25519 public keys only. It rejects age SSH and plugin
 recipients.
 The encrypted data is held by a third party for a long time. There is no second
 kind of recipient to fall back on if X25519 is broken, and no kind that resists
 a quantum computer.
 ## Order of writes
 A backup writes in a fixed order:
 - the marker file
 - the blobs
 - `db.zst.age`
 - `manifest.json.zst`
 A snapshot's metadata is written only after all its blobs are uploaded. The
 manifest is written last. A directory under `metadata/` that has no manifest
 therefore belongs to a backup that did not finish.
 The local index marks a snapshot complete only after both metadata files are
 uploaded. A backup that stops during that upload leaves the snapshot unfinished.
 The next backup removes it from the local index and backs up its files again.
 One short gap remains. A backup can stop after the upload and before the
 snapshot is marked complete. The destination then holds a snapshot that can be
 restored, and the local index marks it unfinished. `snapshot list` shows it as
 remote only.
 An upload that is cut off leaves no partial object under the final name on S3 or
 on a local directory. The same holds for an rclone remote that can move objects.
 An rclone remote that cannot move objects can keep a partial object.
 ## Pruning
 `prune` deletes two kinds of object at the destination:
 - a blob that no manifest lists
 - a directory under `metadata/` that has no manifest
 It reads the manifests, which are not encrypted, so it needs no private key.
 These rules keep it from deleting data that is in use:
 - It keeps every blob that any manifest lists.
 - It deletes nothing when any manifest cannot be downloaded or decoded.
 - It deletes a blob only once the blob is older than `prune_grace_period`.
 - It deletes a directory only once every object in it is that old.
 - It keeps a directory whose snapshot is in the local index.
 - It leaves alone a directory whose name is not a remote key.
 `prune_grace_period` defaults to `24h`. It protects a backup that is still
 running. Such a backup has uploaded blobs and perhaps `db.zst.age`, but not yet
 its manifest. A prune from this machine or another keeps those objects, as long
 as no backup takes longer than the grace period.
 The grace period does not protect one case. A backup does not upload a blob that
 is already at the destination, so that blob keeps the time of its first upload.
 The blob can be left over from an earlier backup that stopped before its
 manifest. A prune that runs before the new manifest is written can then delete
 that blob. The new snapshot cannot be restored afterwards.
 To avoid this case, give each machine and each user its own destination.
 `remote nuke` applies none of these rules.
 ## What a restore needs
 - the age private key
 - the snapshot's `db.zst.age`
 - the blobs that hold the files to restore
 A restore does not read the manifest, or the file, chunk and blob rows of the
 local index.
 It works in these steps:
 - It downloads and decrypts `db.zst.age`.
 - It checks that the database is the one for the snapshot that was asked for.
 - It downloads and decrypts the blobs it needs. It checks each blob against its
  name.
 - It writes each file from its chunks.
 - It sets each file's permissions and times, and its owner when it runs as root.
@@ -1,80 +0,0 @@
 # Workflow
 - branch (from `main`)
 - do the work in Next Step
 - delete Next Step from `TODO.md`
 - move the top item of Future Steps into Next Step
 - commit (`TODO.md` changes in the same commit as the work)
 - merge to `main` if the branch is not protected, otherwise open a PR
 - push
 # Status
 pre-1.0
 # Next Step
 Fix the open bugs on the issue tracker that block the release. Merging `next`
 into `main` is the owner's.
 # Future Steps
 Work planned after 1.0, loosely ordered by priority.
 ## Correctness and operability
 - **Outside security audit.** Before 1.0 the encryption and blob-generation code
  was reviewed. Every bug the review found was fixed. The risks it accepted are
  listed in [Accepted risks](REPOSTRUCTURE.md#accepted-risks). No outside audit
  has been done. age, zstd and content-defined chunking are mostly off-the-shelf
  pieces. The code that joins them needs an outside read:
    - key handling
    - recipient parsing
    - manifest trust boundary
    - restore-time identity validation
 - **Verify restored content end-to-end in CI.** The current integration test
  does this for a small synthetic snapshot but not at scale. A nightly job
  against a multi-GB representative snapshot would catch silent regressions in
  the chunker, packer, or restore planner.
 ## Performance
 - **Parallel blob downloads during restore.** A restore downloads one blob at a
  time now. With a fast S3 endpoint and a multi-core machine, restore speed is
  bound by the fetch, decryption and decompression of each blob. Fetching,
  decrypting and decompressing several blobs at once would make such a restore
  faster. The change must work with `restorePlan`, which orders the files, and
  with `restoreSweeper`, which deletes a cached blob once no remaining file
  needs it.
 - **Bandwidth limiting (`--bwlimit`).** For both upload and download. It is
  useful for backing up over a shared link. It is tricky to make work correctly
  with parallel downloads.
 - **Restart of interrupted restore.** Today a restore can be started again, and
  it then overwrites the partial output. It does not resume from where it
  stopped, and it does not skip files that are already present. A `--resume`
  mode that checks targets before fetching blobs would matter for very large
  restores.
 - **Daemon mode.** A long-running mode that watches for file changes, so that
  frequent backups, such as hourly ones, skip the full scan. It adds little for
  the usual backups from cron every 12 to 36 hours. See
  [issue #204](https://git.eeqj.de/sneak/vaultik/issues/204).
 ## Usability
 - **Man pages and richer `--help` examples.** Cobra generates basic help. Man
  pages would be a separate target.
 - **`vaultik snapshot diff <a> <b>`.** Show which files changed between two
  snapshots, without restoring either.
 - **Status reporting hook for `--cron`.** When a backup fails silently in cron,
  the user has no idea. A configurable hook on completion, for both success and
  failure, would close the loop. It could be a webhook, an email or
  `notify-send`.
 ## Infrastructure
 - **Schema migrations after 1.0.** Migrations are supported, but none are added
  before 1.0 because there is no installed base yet. After 1.0, each schema
  change is a new migration, so an existing local index is migrated when
  `vaultik` is updated. See [`DATAMODEL.md`](DATAMODEL.md#schema-migrations).
 - **Storage backend coverage tests.** S3, `file://` and `rclone://` all share
  the `Storer` interface, but the rclone path is the least exercised in CI.
@@ -22,9 +22,7 @@ require (
 	github.com/spf13/cobra v1.10.1
 	github.com/spf13/pflag v1.0.10
 	github.com/stretchr/testify v1.11.1
 	go.uber.org/dig v1.19.0
 	go.uber.org/fx v1.24.0
 	golang.org/x/mod v0.29.0
 	golang.org/x/sync v0.18.0
 	golang.org/x/sys v0.38.0
 	golang.org/x/term v0.37.0
@@ -258,6 +256,7 @@ require (
 	go.opentelemetry.io/otel/metric v1.38.0 // indirect
 	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.shabbyrobe.org/gocovmerge v0.0.0-20230507111327-fa4f82cfbf4d // indirect
 	go.uber.org/dig v1.19.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.27.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.3 // indirect
@@ -2,10 +2,8 @@ package blobgen_test
 import (
 	"bytes"
 	"errors"
 	"fmt"
 	"testing"
 	"testing/iotest"
 	"filippo.io/age"
 	"github.com/stretchr/testify/assert"
@@ -122,38 +120,6 @@ func TestNewReaderTrailingAndGarbage(t *testing.T) {
 	})
 }
 // TestNewReaderGarbageErrorQuotesNoBytes checks that lines of text in
 // place of a blob fail with ErrNotAgeStream, and that the error carries
 // none of their bytes. The lines end in a newline because age's own error
 // quotes the data's first line only when it reads a whole line.
 func TestNewReaderGarbageErrorQuotesNoBytes(t *testing.T) {
 	t.Parallel()
 	id, _ := makeIdentity(t)
 	garbage := bytes.Repeat([]byte("garbage-bytes-\n"), 100)
 	_, err := blobgen.NewReader(bytes.NewReader(garbage), id)
 	require.ErrorIs(t, err, blobgen.ErrNotAgeStream)
 	assert.NotContains(t, err.Error(), "garbage-bytes-")
 }
 // errConnectionReset stands for a storage read that fails.
 var errConnectionReset = errors.New("connection reset")
 // TestNewReaderReadFailure checks that a failed read of the age header is
 // returned as that read error, not as ErrNotAgeStream.
 func TestNewReaderReadFailure(t *testing.T) {
 	t.Parallel()
 	id, _ := makeIdentity(t)
 	_, err := blobgen.NewReader(iotest.ErrReader(errConnectionReset), id)
 	require.ErrorIs(t, err, errConnectionReset)
 	assert.NotErrorIs(t, err, blobgen.ErrNotAgeStream)
 }
 // TestNewWriterInvalidLevel covers the rejected end of issue case 9: an
 // out-of-range compression level errors and writes nothing to the destination.
 func TestNewWriterInvalidLevel(t *testing.T) {
@@ -11,11 +11,6 @@ import (
 	"github.com/klauspost/compress/zstd"
 )
 // ErrNotAgeStream is returned by NewReader when the data cannot be opened
 // as an age stream, for example because its header is malformed. It
 // replaces age's own error, which can quote the data's first bytes.
 var ErrNotAgeStream = errors.New("not a valid age stream")
 // Reader wraps decompression and decryption with SHA256 verification
 type Reader struct {
 	reader       io.Reader
@@ -29,25 +24,11 @@ type Reader struct {
 // NewReader creates a new Reader that decrypts, decompresses, and verifies
 // data. Every supplied identity is offered to age.Decrypt, so a blob
 // encrypted to any one of them can be read.
 //
 // A failure to read r is returned as that error, and a blob encrypted to
 // none of the identities as age.NoIdentityMatchError. Any other failure
 // to open the age stream is ErrNotAgeStream.
 func NewReader(r io.Reader, identities ...age.Identity) (*Reader, error) {
-	src := &readErrorRecorder{reader: r}
+	// Create decryption reader
-
+	decReader, err := age.Decrypt(r, identities...)
 	decReader, err := age.Decrypt(src, identities...)
 	if err != nil {
-		var noMatch *age.NoIdentityMatchError
+		return nil, fmt.Errorf("creating decryption reader: %w", err)
 		switch {
 		case src.err != nil:
 			return nil, fmt.Errorf("reading age header: %w", src.err)
 		case errors.As(err, &noMatch):
 			return nil, fmt.Errorf("creating decryption reader: %w", err)
 		default:
 			return nil, ErrNotAgeStream
 		}
 	}
 	// Create decompression reader
@@ -71,23 +52,6 @@ func NewReader(r io.Reader, identities ...age.Identity) (*Reader, error) {
 	}, nil
 }
 // readErrorRecorder passes reads through to reader and keeps the first
 // error other than io.EOF, so NewReader can tell a failed read from bad
 // data.
 type readErrorRecorder struct {
 	reader io.Reader
 	err    error
 }
 func (r *readErrorRecorder) Read(p []byte) (int, error) {
 	n, err := r.reader.Read(p)
 	if err != nil && !errors.Is(err, io.EOF) && r.err == nil {
 		r.err = err
 	}
 	return n, err
 }
 // Read implements io.Reader
 func (r *Reader) Read(p []byte) (int, error) {
 	n, err := r.teeReader.Read(p)
@@ -7,11 +7,13 @@ import (
 	"context"
 	"errors"
 	"fmt"
 	"path/filepath"
 	"strings"
 	"sync"
 	"time"
 	"github.com/adrg/xdg"
 	"github.com/spf13/cobra"
 	"go.uber.org/dig"
 	"go.uber.org/fx"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/database"
@@ -88,7 +90,7 @@ func setupGlobals(
 // blank line. Used both from the fx hook (for subcommand invocations) and
 // from the root cobra Run handler (for `vaultik` with no subcommand).
 func writeStartupBanner(w *ui.Writer, startTime time.Time, shortCommit string) {
-	w.Bannerf("%s %s by %s (commit %s, commit date %s) starting up at %s.",
+	w.Bannerf("%s %s by %s (commit %s, built on %s) starting up at %s.",
 		globals.Appname, globals.Version, globals.Author,
 		shortCommit, globals.CommitDate,
 		startTime.Format(time.RFC3339))
@@ -144,12 +146,16 @@ func (e *startupError) Error() string {
 //	could not build arguments for function "Y" (file:line): failed to build U:
 //	received non-nil error from function "Z" (file:line): <real error>
 //
-// Users care about the real error, not the DI plumbing. dig.RootCause,
+// Users care about the real error, not the DI plumbing. We strip everything
-// from the library fx is built on, unwraps those layers and returns the
+// up through the last "): " (which is always the close-paren of an fx
-// real error whole. Cutting the text at "): " instead would also cut a
+// function-location annotation followed by the wrapped error).
 // real error that contains it, such as the blob_size_limit one.
 func cleanStartupError(err error) error {
-	return &startupError{msg: dig.RootCause(err).Error()}
+	msg := err.Error()
 	if idx := strings.LastIndex(msg, "): "); idx >= 0 {
 		msg = msg[idx+3:]
 	}
 	return &startupError{msg: msg}
 }
 // RunApp starts the fx application, blocks until it is asked to stop, and
@@ -337,7 +343,7 @@ func runVaultikApp(
 		},
 		Mode: mode,
 	}, op, func(err error) {
-		log.Info(failMsg, "error", err)
+		log.Error(failMsg, "error", err)
 		ReportErrorf("%s: %v", failMsg, err)
 	})
 }
@@ -349,7 +355,8 @@ func runVaultikApp(
 // only one runs at a time; a read-only command runs without it and is not
 // blocked while a mutator holds the lock (opts.Mode).
 func RunWithApp(ctx context.Context, opts AppOptions) error {
-	release, err := acquireLockIfMutating(opts.Mode, pidlock.Dir())
+	release, err := acquireLockIfMutating(opts.Mode,
 		filepath.Join(xdg.DataHome, "vaultik"))
 	if err != nil {
 		return err
 	}
@@ -2,65 +2,58 @@ package cli //nolint:testpackage // needs access to unexported cleanStartupError
 import (
 	"errors"
 	"os"
 	"path/filepath"
 	"testing"
 	"go.uber.org/fx"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/pidlock"
 )
 // TestCleanStartupError starts a real fx app whose config has a
 // blob_size_limit below the minimum. fx puts annotations naming the
 // functions it was building in front of the config error; only those
 // may be removed, although the config error itself contains "): ".
 func TestCleanStartupError(t *testing.T) {
 	t.Parallel()
-	path := filepath.Join(t.TempDir(), "config.yml")
+	tests := []struct {
-
+		name string
-	err := os.WriteFile(path, []byte("snapshots:\n"+
+		in   string
-		"  test:\n"+
+		want string
-		"    paths: [/tmp/vaultik-test-source]\n"+
+	}{
-		"storage_url: file:///tmp/vaultik-test-storage\n"+
+		{
-		"chunk_size: 10MB\n"+
+			name: "real fx error chain",
-		"blob_size_limit: 30MB\n"), 0o600)
+			in: `could not build arguments for function ` +
-	if err != nil {
+				`"sneak.berlin/go/vaultik/internal/cli".newSnapshotCreateCommand.func1.1 ` +
-		t.Fatalf("write config: %v", err)
+				`(/Users/user/dev/vaultik/internal/cli/snapshot.go:71): ` +
 				`failed to build *vaultik.Vaultik: ` +
 				`could not build arguments for function ` +
 				`"sneak.berlin/go/vaultik/internal/vaultik".New ` +
 				`(/Users/user/dev/vaultik/internal/vaultik/vaultik.go:59): ` +
 				`failed to build storage.Storer: ` +
 				`received non-nil error from function ` +
 				`"sneak.berlin/go/vaultik/internal/storage".NewStorer ` +
 				`(/Users/user/dev/vaultik/internal/storage/module.go:23): ` +
 				`creating base path: mkdir /Volumes/BACKUPS: permission denied`,
 			want: `creating base path: mkdir /Volumes/BACKUPS: permission denied`,
 		},
 		{
 			name: "no fx wrapping",
 			in:   "plain error",
 			want: "plain error",
 		},
 		{
 			name: "single fx wrapping",
 			in:   `received non-nil error from function "foo" (file.go:1): underlying problem`,
 			want: "underlying problem",
 		},
 	}
-	app := fx.New(
+	for _, tt := range tests {
-		fx.NopLogger,
+		t.Run(tt.name, func(t *testing.T) {
-		fx.Supply(config.Path(path)),
+			t.Parallel()
 		config.Module,
 		fx.Invoke(func(*config.Config) {}),
 	)
-	err = app.Start(t.Context())
+			//nolint:err113 // test constructs errors from table input
-	if err == nil {
+			got := cleanStartupError(errors.New(tt.in)).Error()
-		t.Fatal("app started; want a blob_size_limit error")
+			if got != tt.want {
-	}
+				t.Errorf("got %q, want %q", got, tt.want)
-
+			}
-	want := "failed to load config: invalid config: blob_size_limit must " +
+		})
 		"be at least the largest chunk the chunker can emit (chunk_size " +
 		"times the FastCDC size spread): need at least 40000000 bytes"
 	got := cleanStartupError(err).Error()
 	if got != want {
 		t.Errorf("got %q, want %q", got, want)
 	}
 }
 // TestCleanStartupErrorNotFromFx checks that an error fx did not wrap is
 // shown unchanged.
 func TestCleanStartupErrorNotFromFx(t *testing.T) {
 	t.Parallel()
 	//nolint:err113 // a one-off error standing in for a startup failure
 	got := cleanStartupError(errors.New("plain error")).Error()
 	if got != "plain error" {
 		t.Errorf("got %q, want %q", got, "plain error")
 	}
 }
@@ -8,8 +8,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"reflect"
 	"runtime"
 	"slices"
 	"strconv"
 	"strings"
 	"unicode/utf8"
@@ -31,7 +29,7 @@ const configSetArgs = 2
 // parent config dirs (e.g. ~/.config) are conventionally traversable.
 const configDirMode = 0o755
-// configYAMLIndent matches the 2-space indentation of the default config,
+// configYAMLIndent matches the 2-space indentation of defaultConfigTemplate,
 // so `config set` writes the file back with the same indentation rather than
 // yaml.Marshal's 4-space default.
 const configYAMLIndent = 2
@@ -46,33 +44,9 @@ var (
 	errNeedNumericIndex = errors.New("key is a list; use a numeric index")
 	errIndexOutOfRange  = errors.New("index out of range")
 	errNotMapOrList     = errors.New("key is not a map or list")
 	errWouldNotLoad     = errors.New(
 		"vaultik would not load the config after this change, " +
 			"so the file was not changed")
 	errSetS3KeysFirst = errors.New(
 		"set s3.access_key_id and s3.secret_access_key first, " +
 			"then storage_url")
 )
-// storageURLKey is the config key that selects the storage backend.
+const defaultConfigTemplate = `# vaultik configuration
 const storageURLKey = "storage_url"
 // macOS is the value of runtime.GOOS on macOS.
 const macOS = "darwin"
 // defaultConfigText returns the file `config init` writes on the operating
 // system goos, named as runtime.GOOS names it. Only macOS gets the apps
 // snapshot, since /Applications exists nowhere else.
 func defaultConfigText(goos string) string {
 	if goos == macOS {
 		return defaultConfigHead + appsSnapshotConfig + defaultConfigTail
 	}
 	return defaultConfigHead + defaultConfigTail
 }
 // defaultConfigHead is the default config up to the end of the home snapshot.
 const defaultConfigHead = `# vaultik configuration
 # Documentation: https://sneak.berlin/go/vaultik
 # ─── REQUIRED ────────────────────────────────────────────────────────────────
@@ -190,10 +164,7 @@ snapshots:
      - "/Movies/ProxyMedia"
      - "/Music/iTunes/Album Artwork"
      - "/Pictures/iPod Photo Cache"
 `
 // appsSnapshotConfig is the apps snapshot of the default config.
 const appsSnapshotConfig = `
  # Third-party applications. OS-provided apps live in /System/Applications
  # on modern macOS and are never in /Applications, but Apple-installed
  # App Store apps (Safari, GarageBand, iWork, iMovie) are excluded since
@@ -214,10 +185,7 @@ const appsSnapshotConfig = `
      - "/Steam.app"
      - "/VirtualBox.app"
      - "/Utilities/Adobe Installers"
 `
 // defaultConfigTail is the default config after the snapshots.
 const defaultConfigTail = `
 # Storage backend (pick ONE of the three forms below).
 #
 # S3-compatible:
@@ -252,7 +220,7 @@ storage_url: ""
 # Average chunk size for content-defined chunking (FastCDC).
 # Smaller = better deduplication but more metadata overhead.
-# Minimum 1MB. Accepts: 1MB, 10M, 64MiB, etc.
+# Accepts: 1MB, 10M, 64KB, etc.
 # Default: 10MB
 # chunk_size: 10MB
@@ -267,23 +235,10 @@ storage_url: ""
 # Default: 3
 # compression_level: 3
 # How old a blob that no snapshot lists must be before prune deletes it,
 # and how old every object in a directory under metadata/ with no manifest
 # must be before prune deletes that directory. A backup uploads its blobs
 # and its db.zst.age before its manifest, so on a destination shared
 # between hosts or users this must be longer than the longest backup run.
 # It does not protect a blob a backup reuses from an earlier run that
 # stopped before its manifest: that blob keeps the time of its first
 # upload, so a prune can delete it.
 # Accepts: 36h, 90m, etc. 0s deletes such blobs and directories at once.
 # Default: 24h
 # prune_grace_period: 24h
 # Hostname used in snapshot IDs. Default: system hostname.
 # hostname: myserver
-# Path to the local SQLite index database. It must be an absolute path;
+# Path to the local SQLite index database.
 # ~ is expanded.
 # Default: the platform data directory, e.g.
 #   macOS: ~/Library/Application Support/vaultik/index.sqlite
 #   Linux: ~/.local/share/vaultik/index.sqlite
@@ -318,14 +273,12 @@ func newConfigInitCommand() *cobra.Command {
 		Use:   "init",
 		Short: "Write a default config file",
 		Long: `Creates a default configuration file with commented explanations
-for the settings it lists. If a config file already exists at the target
+for every setting. If a config file already exists at the target path,
-path, the command refuses to overwrite it. The file is created with mode
+the command refuses to overwrite it.
 0600, because it can hold credentials.
 The config is written to the path from --config, $VAULTIK_CONFIG, or
-config.yml in the platform default config directory
+the platform default config directory (e.g. ~/Library/Application Support/
-(~/Library/Application Support/vaultik/ on macOS, ~/.config/vaultik/ on
+on macOS, ~/.config/ on Linux, /etc/vaultik/ as root).`,
 Linux, /etc/vaultik/ as root).`,
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			path := configPathForInit()
@@ -342,8 +295,7 @@ Linux, /etc/vaultik/ as root).`,
 				return fmt.Errorf("creating config directory %s: %w", dir, err)
 			}
-			err = os.WriteFile(path, []byte(defaultConfigText(runtime.GOOS)),
+			err = os.WriteFile(path, []byte(defaultConfigTemplate), configFileMode)
 				configFileMode)
 			if err != nil {
 				return fmt.Errorf("writing config file: %w", err)
 			}
@@ -364,7 +316,7 @@ Linux, /etc/vaultik/ as root).`,
 func newConfigEditCommand() *cobra.Command {
 	return &cobra.Command{
 		Use:   "edit",
-		Short: "Open the config file in $EDITOR (vi when it is not set)",
+		Short: "Open the config file in $EDITOR",
 		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			path, err := ResolveConfigPath()
@@ -377,15 +329,8 @@ func newConfigEditCommand() *cobra.Command {
 				editor = "vi"
 			}
 			// Run $EDITOR through the shell, as git does, so a value
 			// with arguments such as "code --wait" works. The path
 			// goes in as an argument ("$@"), not into the command
 			// text, so a path with spaces or quotes arrives whole.
 			// sh -c takes the word after the command as $0, which
 			// is why editor appears twice.
 			//nolint:gosec // G204: launching the operator's own $EDITOR is the point
-			ed := exec.CommandContext(cmd.Context(),
+			ed := exec.CommandContext(cmd.Context(), editor, path)
 				"sh", "-c", editor+` "$@"`, editor, path)
 			ed.Stdin = os.Stdin
 			ed.Stdout = os.Stdout
 			ed.Stderr = os.Stderr
@@ -446,16 +391,8 @@ func newConfigSetCommand() *cobra.Command {
 		Use:   "set <key> <value>",
 		Short: "Set a config value by dotted path (e.g. compression_level 5)",
 		Long: `Sets a scalar config value addressed by dotted YAML path and writes
-the file back. Comments in the file are kept. Blank lines can be
+the file back, preserving comments and formatting. Intermediate maps
-removed. Missing keys along the path are created: as a list when the
+are created as needed.
 next path element is a number, otherwise as a map.
 If the config loads, a change after which it would not, such as
 compression_level 99, is refused and the file is left unchanged. A
 config that does not load is checked one setting at a time. Examples
 are the file config init writes before storage_url is set, and one
 with a ${ENV:...} reference to a variable not set in this shell. In
 such a config, an unknown key or a value of the wrong type is refused.
 Examples:
  vaultik config set storage_url "file:///mnt/backups"
@@ -485,21 +422,7 @@ func writeConfigSet(out *ui.Writer, path, key, value string) error {
 		return err
 	}
-	oldData, err := marshalConfigYAML(root)
+	err = yamlPathSet(root, strings.Split(key, "."), value)
 	if err != nil {
 		return fmt.Errorf("marshaling config: %w", err)
 	}
 	keys := strings.Split(key, ".")
 	if keys[0] != config.EnvSection {
 		_, err = config.SettingType(keys)
 		if err != nil {
 			return err
 		}
 	}
 	err = yamlPathSet(root, keys, value)
 	if err != nil {
 		return err
 	}
@@ -509,21 +432,6 @@ func writeConfigSet(out *ui.Writer, path, key, value string) error {
 		return fmt.Errorf("marshaling config: %w", err)
 	}
 	setting, err := yamlPathOnly(root, keys)
 	if err != nil {
 		return err
 	}
 	settingData, err := marshalConfigYAML(setting)
 	if err != nil {
 		return fmt.Errorf("marshaling config: %w", err)
 	}
 	err = checkConfigChange(oldData, data, settingData)
 	if err != nil {
 		return wouldNotLoadError(key, err)
 	}
 	err = os.WriteFile(path, data, configFileMode)
 	if err != nil {
 		return fmt.Errorf("writing config file: %w", err)
@@ -545,75 +453,8 @@ func writeConfigSet(out *ui.Writer, path, key, value string) error {
 	return nil
 }
 // wouldNotLoadError returns the refusal of a change to key that vaultik
 // would not load for reason. When storage_url moves to s3:// before the S3
 // credentials are set, it says to set them first: they can be set while
 // the old storage_url is still in place.
 func wouldNotLoadError(key string, reason error) error {
 	if key == storageURLKey &&
 		(errors.Is(reason, config.ErrS3KeyIDRequired) ||
 			errors.Is(reason, config.ErrS3SecretRequired)) {
 		return fmt.Errorf("%w: %w; %w", errWouldNotLoad, reason,
 			errSetS3KeysFirst)
 	}
 	return fmt.Errorf("%w: %w", errWouldNotLoad, reason)
 }
 // checkConfigChange returns the reason vaultik would not load newData, the
 // config after a change, if the change brings that failure in. If oldData,
 // the config before it, loads, the new one must load too. A config that
 // does not load, such as one still being filled in or one with a ${...}
 // reference that cannot be filled in here, is checked one setting at a
 // time: settingData, the changed setting on its own, must decode into the
 // config type.
 func checkConfigChange(oldData, newData, settingData []byte) error {
 	oldCfg, err := config.Parse(oldData)
 	if err == nil && oldCfg.Validate() == nil {
 		newCfg, err := config.Parse(newData)
 		if err != nil {
 			return err
 		}
 		return newCfg.Validate()
 	}
 	_, err = config.Parse(settingData)
 	return err
 }
 // yamlPathOnly returns a document holding only the value at the dotted key
 // path in root, inside the maps and lists that lead to it there.
 func yamlPathOnly(root *yaml.Node, keys []string) (*yaml.Node, error) {
 	node, err := yamlPathGet(root, keys)
 	if err != nil {
 		return nil, err
 	}
 	for i, key := range slices.Backward(keys) {
 		parent, err := yamlPathGet(root, keys[:i])
 		if err != nil {
 			return nil, err
 		}
 		if parent.Kind == yaml.SequenceNode {
 			node = &yaml.Node{
 				Kind: yaml.SequenceNode, Content: []*yaml.Node{node},
 			}
 		} else {
 			keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: key}
 			node = &yaml.Node{
 				Kind: yaml.MappingNode, Content: []*yaml.Node{keyNode, node},
 			}
 		}
 	}
 	return &yaml.Node{Kind: yaml.DocumentNode, Content: []*yaml.Node{node}}, nil
 }
 // marshalConfigYAML renders a config document tree with 2-space indentation,
-// matching the default config. yaml.Marshal defaults to 4 spaces, which
+// matching defaultConfigTemplate. yaml.Marshal defaults to 4 spaces, which
 // would reindent the whole file on the first `config set` despite the promise
 // to preserve formatting.
 func marshalConfigYAML(root *yaml.Node) ([]byte, error) {
@@ -718,8 +559,8 @@ func yamlPathGet(root *yaml.Node, keys []string) (*yaml.Node, error) {
 	return node, nil
 }
-// yamlPathSet navigates a dotted key path, creating missing keys as needed,
+// yamlPathSet navigates a dotted key path, creating intermediate maps as
-// and sets the final key to the given scalar value. Numeric path
+// needed, and sets the final key to the given scalar value. Numeric path
 // components index into sequences; an index equal to the sequence length
 // appends a new element (e.g. "age_recipients.1" on a 1-element list).
 func yamlPathSet(root *yaml.Node, keys []string, value string) error {
@@ -732,12 +573,12 @@ func yamlPathSet(root *yaml.Node, keys []string, value string) error {
 		node = node.Content[0]
 	}
-	for i := range keys {
+	for i, key := range keys {
 		last := i == len(keys)-1
 		switch node.Kind {
 		case yaml.MappingNode:
-			node = yamlSetInMapping(node, keys, i, value, last)
+			node = yamlSetInMapping(node, key, value, last)
 		case yaml.SequenceNode:
 			next, err := yamlSetInSequence(node, keys, i, value, last)
 			if err != nil {
@@ -769,23 +610,51 @@ func yamlPathSet(root *yaml.Node, keys []string, value string) error {
 }
 // configKeyIsString reports whether the dotted key names a string in
-// config.Config, as s3.access_key_id and snapshots.home.exclude.0 do.
+// config.Config, following the fields' yaml tags, as s3.access_key_id and
 // snapshots.home.exclude.0 do.
 func configKeyIsString(keys []string) bool {
-	typ, err := config.SettingType(keys)
+	typ := reflect.TypeFor[config.Config]()
-	return err == nil && typ.Kind() == reflect.String
+	for _, key := range keys {
 		switch {
 		case typ.Kind() == reflect.Map || typ.Kind() == reflect.Slice:
 			// The key is a snapshot name or a list index.
 			typ = typ.Elem()
 		case typ.Kind() == reflect.Struct:
 			field, ok := yamlField(typ, key)
 			if !ok {
 				return false
 			}
 			typ = field.Type
 		default:
 			return false
 		}
 	}
 	return typ.Kind() == reflect.String
 }
-// yamlSetInMapping resolves (creating if needed) the value node for the
+// yamlField returns the field of struct type typ whose yaml tag names key.
-// path element keys[i] within a mapping node, setting it to value when it
+func yamlField(typ reflect.Type, key string) (reflect.StructField, bool) {
-// is the final path element, and returns the node to descend into.
+	for field := range typ.Fields() {
-func yamlSetInMapping(
+		name, _, _ := strings.Cut(field.Tag.Get("yaml"), ",")
-	node *yaml.Node, keys []string, i int, value string, last bool,
+		if name == key {
-) *yaml.Node {
+			return field, true
 		}
 	}
 	return reflect.StructField{}, false
 }
 // yamlSetInMapping resolves (creating if needed) the value node for key
 // within a mapping node, setting it to value when it is the final path
 // element, and returns the node to descend into.
 func yamlSetInMapping(node *yaml.Node, key, value string, last bool) *yaml.Node {
 	var valueNode *yaml.Node
 	for j := 0; j+1 < len(node.Content); j += 2 {
-		if node.Content[j].Value == keys[i] {
+		if node.Content[j].Value == key {
 			valueNode = node.Content[j+1]
 			break
@@ -793,8 +662,13 @@ func yamlSetInMapping(
 	}
 	if valueNode == nil {
-		keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: keys[i]}
+		keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: key}
-		valueNode = newPathNode(keys, i, value)
+
 		valueNode = &yaml.Node{Kind: yaml.MappingNode}
 		if last {
 			valueNode = &yaml.Node{Kind: yaml.ScalarNode, Value: value}
 		}
 		node.Content = append(node.Content, keyNode, valueNode)
 	} else if last {
 		setScalar(valueNode, value)
@@ -822,7 +696,12 @@ func yamlSetInSequence(
 	}
 	if idx == len(node.Content) {
-		node.Content = append(node.Content, newPathNode(keys, i, value))
+		newNode := &yaml.Node{Kind: yaml.MappingNode}
 		if last {
 			newNode = &yaml.Node{Kind: yaml.ScalarNode, Value: value}
 		}
 		node.Content = append(node.Content, newNode)
 	} else if last {
 		setScalar(node.Content[idx], value)
 	}
@@ -830,22 +709,6 @@ func yamlSetInSequence(
 	return node.Content[idx], nil
 }
 // newPathNode returns the node to create for the missing path element
 // keys[i]: the value when it is the final path element, otherwise an empty
 // list when the next path element is a number and an empty map when not.
 func newPathNode(keys []string, i int, value string) *yaml.Node {
 	if i == len(keys)-1 {
 		return &yaml.Node{Kind: yaml.ScalarNode, Value: value}
 	}
 	_, err := strconv.Atoi(keys[i+1])
 	if err == nil {
 		return &yaml.Node{Kind: yaml.SequenceNode}
 	}
 	return &yaml.Node{Kind: yaml.MappingNode}
 }
 // setScalar overwrites a node in place with a plain scalar value.
 func setScalar(n *yaml.Node, value string) {
 	n.Kind = yaml.ScalarNode
@@ -2,7 +2,6 @@ package cli //nolint:testpackage // exercises unexported yamlPathGet/yamlPathSet
 import (
 	"bytes"
 	"errors"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -14,15 +13,14 @@ import (
 	"sneak.berlin/go/vaultik/internal/ui"
 )
-// TestDefaultConfigParsesOnMacOS ensures the config `config init` writes on
+// TestDefaultConfigTemplateParses ensures the init template is valid YAML
-// macOS is valid YAML that unmarshals into the Config struct with the
+// that unmarshals into the Config struct with the expected snapshots.
-// expected snapshots.
+func TestDefaultConfigTemplateParses(t *testing.T) {
 func TestDefaultConfigParsesOnMacOS(t *testing.T) {
 	t.Parallel()
 	var cfg config.Config
-	err := yaml.Unmarshal([]byte(defaultConfigText("darwin")), &cfg)
+	err := yaml.Unmarshal([]byte(defaultConfigTemplate), &cfg)
 	if err != nil {
 		t.Fatalf("default config template is not valid YAML: %v", err)
 	}
@@ -60,60 +58,24 @@ func TestDefaultConfigParsesOnMacOS(t *testing.T) {
 	}
 }
-// TestDefaultConfigOnLinux checks that the config `config init` writes on
+// TestConfigSetRecipientOnFreshConfig follows the README quickstart: on the
-// Linux loads with its home snapshot and without the apps snapshot, whose
+// file `config init` writes, `config set age_recipients.0` and
 // /Applications exists only on macOS.
 func TestDefaultConfigOnLinux(t *testing.T) {
 	t.Parallel()
 	path := filepath.Join(t.TempDir(), "config.yml")
 	err := os.WriteFile(path, []byte(defaultConfigText("linux")), configFileMode)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}
 	err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
 		path, "storage_url", "file:///mnt/backups")
 	if err != nil {
 		t.Fatalf("config set storage_url: %v", err)
 	}
 	cfg, err := config.Load(path)
 	if err != nil {
 		t.Fatalf("config.Load: %v", err)
 	}
 	if _, ok := cfg.Snapshots["home"]; !ok {
 		t.Error("expected 'home' snapshot in the Linux default config")
 	}
 	if _, ok := cfg.Snapshots["apps"]; ok {
 		t.Error("the Linux default config should have no 'apps' snapshot")
 	}
 }
 // testRecipient is a valid age public key.
 const testRecipient = "age1278m9q7dp3chsh2dcy82qk27v047zywyvtxwnj4cvt0z65jw6a7q5dqhfj"
 // TestConfigSetRecipientOnFreshConfig follows the README's getting started
 // steps: on the file `config init` writes, `config set age_recipients.0` and
 // `config set storage_url` give a config that loads with that recipient.
 // Neither is refused, although the config does not load until both are set;
 // once it loads, a recipient that is not a valid key is.
 func TestConfigSetRecipientOnFreshConfig(t *testing.T) {
 	t.Parallel()
 	const recipient = "age1278m9q7dp3chsh2dcy82qk27v047zywyvtxwnj4cvt0z65jw6a7q5dqhfj"
 	path := filepath.Join(t.TempDir(), "config.yml")
-	err := os.WriteFile(path, []byte(defaultConfigText(macOS)), configFileMode)
+	err := os.WriteFile(path, []byte(defaultConfigTemplate), configFileMode)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}
 	out := ui.NewWithColor(&bytes.Buffer{}, false)
-	err = writeConfigSet(out, path, "age_recipients.0", testRecipient)
+	err = writeConfigSet(out, path, "age_recipients.0", recipient)
 	if err != nil {
 		t.Fatalf("config set age_recipients.0: %v", err)
 	}
@@ -128,345 +90,8 @@ func TestConfigSetRecipientOnFreshConfig(t *testing.T) {
 		t.Fatalf("config.Load: %v", err)
 	}
-	if len(cfg.AgeRecipients) != 1 || cfg.AgeRecipients[0] != testRecipient {
+	if len(cfg.AgeRecipients) != 1 || cfg.AgeRecipients[0] != recipient {
-		t.Errorf("age_recipients = %v, want [%s]", cfg.AgeRecipients, testRecipient)
+		t.Errorf("age_recipients = %v, want [%s]", cfg.AgeRecipients, recipient)
 	}
 	err = writeConfigSet(out, path, "age_recipients.0", "notakey")
 	if err == nil || !strings.Contains(err.Error(), "not a valid recipient") {
 		t.Errorf("config set age_recipients.0 notakey gives error %v, "+
 			"want one saying it is not a valid recipient", err)
 	}
 	_, err = config.Load(path)
 	if err != nil {
 		t.Errorf("config.Load after the refused change: %v", err)
 	}
 }
 // configWithoutRecipients loads, but has no age_recipients key and no
 // snapshot named work.
 const configWithoutRecipients = `storage_url: file:///mnt/backups
 snapshots:
  home:
    paths:
      - "~"
 `
 // testS3URL is an S3 storage_url, which needs credentials to load.
 const testS3URL = "s3://bucket/prefix?endpoint=https://s3.example.com"
 // configWithS3Keys loads: its storage_url is testS3URL and both S3 keys are
 // set.
 const configWithS3Keys = storageURLKey + ": " + testS3URL + `
 s3:
  access_key_id: AKIAEXAMPLE
  secret_access_key: example-secret
 snapshots:
  home:
    paths:
      - "~"
 `
 // configWithUnsetReference loads only where VAULTIK_TEST_UNSET_SECRET is
 // set, as a backup job's environment might set it. No test sets it.
 const configWithUnsetReference = configWithoutRecipients + `s3:
  secret_access_key: ${ENV:VAULTIK_TEST_UNSET_SECRET}
 `
 // configWithLevelReference returns configWithoutRecipients with a ${FILE:...}
 // reference on compression_level to a file holding 9, so that the config
 // loads once the reference is filled in.
 func configWithLevelReference(t *testing.T) string {
 	t.Helper()
 	levelPath := filepath.Join(t.TempDir(), "level")
 	err := os.WriteFile(levelPath, []byte("9"), configFileMode)
 	if err != nil {
 		t.Fatalf("write level: %v", err)
 	}
 	return configWithoutRecipients +
 		"compression_level: ${FILE:" + levelPath + "}\n"
 }
 // TestConfigSetIndexUnderMissingKey checks that a list index under a key
 // the file does not have creates a list, and that the result loads.
 func TestConfigSetIndexUnderMissingKey(t *testing.T) {
 	t.Parallel()
 	tests := []struct {
 		key   string
 		value string
 		field func(cfg *config.Config) []string
 	}{
 		{"age_recipients.0", testRecipient,
 			func(cfg *config.Config) []string { return cfg.AgeRecipients }},
 		{"snapshots.work.paths.0", "/srv/work",
 			func(cfg *config.Config) []string { return cfg.Snapshots["work"].Paths }},
 	}
 	for _, tt := range tests {
 		t.Run(tt.key, func(t *testing.T) {
 			t.Parallel()
 			path := filepath.Join(t.TempDir(), "config.yml")
 			err := os.WriteFile(path, []byte(configWithoutRecipients), configFileMode)
 			if err != nil {
 				t.Fatalf("write config: %v", err)
 			}
 			err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
 				path, tt.key, tt.value)
 			if err != nil {
 				t.Fatalf("config set %s: %v", tt.key, err)
 			}
 			cfg, err := config.Load(path)
 			if err != nil {
 				t.Fatalf("config.Load: %v", err)
 			}
 			got := tt.field(cfg)
 			if len(got) != 1 || got[0] != tt.value {
 				t.Errorf("%s gives %v, want [%s]", tt.key, got, tt.value)
 			}
 		})
 	}
 }
 // TestConfigSetKeepsFileThatWouldNotLoad checks that config set refuses a
 // change after which the config would not load, with an error giving the
 // reason, and leaves the file as it was. On the file `config init` writes,
 // which does not load until storage_url is set, and on one that cannot be
 // read here, only an unknown key or a value of the wrong type is refused.
 func TestConfigSetKeepsFileThatWouldNotLoad(t *testing.T) {
 	t.Parallel()
 	levelReference := configWithLevelReference(t)
 	tests := []struct {
 		config string
 		key    string
 		value  string
 		reason string
 	}{
 		// Keys that no setting has, on a config that loads and on one
 		// that does not.
 		{configWithoutRecipients, "nosuchkey", "1",
 			`unknown config key "nosuchkey"`},
 		{configWithoutRecipients, "snapshots.home.exlude", "/tmp",
 			`unknown config key "snapshots.home.exlude"`},
 		{defaultConfigText(macOS), "compression_lvl", "9",
 			`unknown config key "compression_lvl"`},
 		// Index 1 of the empty list the missing key gives.
 		{configWithoutRecipients, "age_recipients.1", testRecipient,
 			"index out of range"},
 		// A list set to a single value.
 		{configWithoutRecipients, "snapshots.home.paths", "/srv",
 			"into []string"},
 		{configWithoutRecipients, "chunk_size", "fast",
 			`chunk_size: "fast" is not a size`},
 		// Values of the right type that fail validation.
 		{configWithoutRecipients, "compression_level", "99",
 			"compression_level must be between 1 and 19"},
 		{configWithoutRecipients, "chunk_size", "1KB",
 			"chunk_size must be at least 1MB"},
 		// An s3:// URL before its credentials names them.
 		{configWithoutRecipients, storageURLKey, testS3URL,
 			"s3.access_key_id is required for s3:// URLs; " +
 				"set s3.access_key_id and s3.secret_access_key first"},
 		{configWithoutRecipients + "s3:\n  access_key_id: AKIAEXAMPLE\n",
 			storageURLKey, testS3URL,
 			"s3.secret_access_key is required for s3:// URLs; " +
 				"set s3.access_key_id and s3.secret_access_key first"},
 		// With its reference filled in, the config loads.
 		{levelReference, "blob_size_limit", "1MB",
 			"blob_size_limit must be at least"},
 		// The type check on a config that does not load yet.
 		{defaultConfigText(macOS), "snapshots.apps.paths", "/srv",
 			"into []string"},
 		// The type check on a config that cannot be read here.
 		{configWithUnsetReference, "snapshots.home.paths", "/x",
 			"cannot unmarshal !!str `/x`"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.key+" "+tt.value, func(t *testing.T) {
 			t.Parallel()
 			path := filepath.Join(t.TempDir(), "config.yml")
 			err := os.WriteFile(path, []byte(tt.config), configFileMode)
 			if err != nil {
 				t.Fatalf("write config: %v", err)
 			}
 			err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
 				path, tt.key, tt.value)
 			if err == nil || !strings.Contains(err.Error(), tt.reason) {
 				t.Errorf("config set %s %s gives error %v, want one saying %q",
 					tt.key, tt.value, err, tt.reason)
 			}
 			data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
 			if err != nil {
 				t.Fatalf("read config: %v", err)
 			}
 			if string(data) != tt.config {
 				t.Errorf("config set %s changed the file to:\n%s",
 					tt.key, data)
 			}
 		})
 	}
 }
 // TestConfigSetRefusesOnlyItsOwnFailure checks that setting another key
 // works on a config with a ${...} reference on compression_level, which
 // loads because loading fills the reference in, on one whose
 // compression_level already fails to load, and on one with a reference
 // that cannot be filled in here.
 func TestConfigSetRefusesOnlyItsOwnFailure(t *testing.T) {
 	t.Parallel()
 	configs := map[string]string{
 		"reference":       configWithLevelReference(t),
 		"failing":         configWithoutRecipients + "compression_level: fast\n",
 		"unset reference": configWithUnsetReference,
 	}
 	for name, configYAML := range configs {
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
 			path := filepath.Join(t.TempDir(), "config.yml")
 			err := os.WriteFile(path, []byte(configYAML), configFileMode)
 			if err != nil {
 				t.Fatalf("write config: %v", err)
 			}
 			err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
 				path, "hostname", "myhost")
 			if err != nil {
 				t.Fatalf("config set hostname: %v", err)
 			}
 			data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
 			if err != nil {
 				t.Fatalf("read config: %v", err)
 			}
 			if !strings.Contains(string(data), "hostname: myhost") {
 				t.Errorf("config set hostname wrote:\n%s", data)
 			}
 		})
 	}
 }
 // TestConfigSetS3KeysBeforeStorageURL checks that the order the refusal
 // gives works on a config that loads with a file:// storage_url.
 func TestConfigSetS3KeysBeforeStorageURL(t *testing.T) {
 	t.Parallel()
 	path := filepath.Join(t.TempDir(), "config.yml")
 	err := os.WriteFile(path, []byte(configWithoutRecipients), configFileMode)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}
 	for _, set := range [][2]string{
 		{"s3.access_key_id", "AKIAEXAMPLE"},
 		{"s3.secret_access_key", "example-secret"},
 		{storageURLKey, testS3URL},
 	} {
 		err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
 			path, set[0], set[1])
 		if err != nil {
 			t.Fatalf("config set %s: %v", set[0], err)
 		}
 	}
 	data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
 	if err != nil {
 		t.Fatalf("read config: %v", err)
 	}
 	if !strings.Contains(string(data), storageURLKey+": "+testS3URL) {
 		t.Errorf("config set storage_url wrote:\n%s", data)
 	}
 }
 // TestConfigSetRefusesClearingS3Key checks that clearing s3.access_key_id on
 // a config with an s3:// storage_url is refused without saying to set the
 // S3 keys first. That advice is only for a change to storage_url.
 func TestConfigSetRefusesClearingS3Key(t *testing.T) {
 	t.Parallel()
 	const key = "s3.access_key_id"
 	path := filepath.Join(t.TempDir(), "config.yml")
 	err := os.WriteFile(path, []byte(configWithS3Keys), configFileMode)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}
 	err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false), path, key, "")
 	if !errors.Is(err, errWouldNotLoad) {
 		t.Errorf("clearing %s gives error %v, want one saying %q",
 			key, err, errWouldNotLoad)
 	}
 	if errors.Is(err, errSetS3KeysFirst) {
 		t.Errorf("clearing %s gives error %v, want one not saying %q",
 			key, err, errSetS3KeysFirst)
 	}
 	data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
 	if err != nil {
 		t.Fatalf("read config: %v", err)
 	}
 	if string(data) != configWithS3Keys {
 		t.Errorf("clearing %s changed the file to:\n%s", key, data)
 	}
 }
 // TestConfigSetWritesEnvSection checks that config set writes a key under
 // the top-level env section, whose keys are not settings, on a config that
 // loads.
 func TestConfigSetWritesEnvSection(t *testing.T) {
 	const name = "VAULTIK_TEST_CONFIG_SET_ENV"
 	// Loading the changed config sets the variable; t.Setenv restores it
 	// after the test.
 	t.Setenv(name, "")
 	path := filepath.Join(t.TempDir(), "config.yml")
 	err := os.WriteFile(path, []byte(configWithoutRecipients), configFileMode)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}
 	err = writeConfigSet(ui.NewWithColor(&bytes.Buffer{}, false),
 		path, "env."+name, "value")
 	if err != nil {
 		t.Fatalf("config set env.%s: %v", name, err)
 	}
 	data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
 	if err != nil {
 		t.Fatalf("read config: %v", err)
 	}
 	if !strings.Contains(string(data), "env:\n  "+name+": value\n") {
 		t.Errorf("config set env.%s wrote:\n%s", name, data)
 	}
 }
@@ -549,7 +174,7 @@ func loadAfterConfigSet(t *testing.T, key, value string) *config.Config {
 	path := filepath.Join(t.TempDir(), "config.yml")
-	err := os.WriteFile(path, []byte(defaultConfigText(macOS)), configFileMode)
+	err := os.WriteFile(path, []byte(defaultConfigTemplate), configFileMode)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}
@@ -816,30 +441,6 @@ func TestWriteConfigSetTightensMode(t *testing.T) {
 	}
 }
 // TestConfigEditEditorWithArgument checks that an $EDITOR carrying an
 // argument works and that a config path with a space reaches it whole.
 // The "editor" is cp with the replacement file as its argument, so the
 // config ends up with the replacement's content only if both arrived.
 func TestConfigEditEditorWithArgument(t *testing.T) {
 	dir := t.TempDir()
 	path := seedFile(t, dir, "my config.yml", "compression_level: 3\n")
 	edited := seedFile(t, dir, "edited.yml", "compression_level: 9\n")
 	setRootFlags(t, RootFlags{ConfigPath: path})
 	t.Setenv("EDITOR", "cp '"+edited+"'")
 	mustExecute(t, newConfigEditCommand())
 	data, err := os.ReadFile(path) //nolint:gosec // G304: test-controlled path
 	if err != nil {
 		t.Fatalf("reading config back: %v", err)
 	}
 	if string(data) != "compression_level: 9\n" {
 		t.Errorf("config after edit = %q, want the edited content", data)
 	}
 }
 func splitPath(s string) []string {
 	return strings.Split(s, ".")
 }
@@ -6,9 +6,7 @@ import (
 	"github.com/spf13/cobra"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/vaultik"
 )
 // NewDatabaseCommand creates the database command group
@@ -92,25 +90,27 @@ Use --force to skip the confirmation prompt.`,
 				var confirm string
-				// A failure to read the answer means no confirmation.
+				_, err = fmt.Scanln(&confirm)
 				_, err = fmt.Fscanln(cmd.InOrStdin(), &confirm)
 				if err != nil || confirm != "yes" {
 					_, _ = fmt.Fprintln(w, "Aborted.")
-					return vaultik.ErrNotConfirmed
+					//nolint:nilerr // a failed/aborted confirmation is a clean abort
 					return nil
 				}
 			}
-			// Delete the database file and its side files. A side file
+			// Delete the database file
-			// may not exist, so only failing to delete the database file
+			err = os.Remove(dbPath)
-			// is an error.
+			if err != nil {
-			for _, indexFile := range database.IndexFiles(dbPath) {
+				return fmt.Errorf("failed to delete database: %w", err)
 				err = os.Remove(indexFile)
 				if err != nil && indexFile == dbPath {
 					return fmt.Errorf("failed to delete database: %w", err)
 				}
 			}
 			// Also delete WAL and SHM files if they exist
 			walPath := dbPath + "-wal"
 			shmPath := dbPath + "-shm"
 			_ = os.Remove(walPath) // Ignore errors - files may not exist
 			_ = os.Remove(shmPath)
 			out.Infof("Local state database deleted: %s.", dbPath)
 			log.Info("Local state database deleted", "path", dbPath)
@@ -1,75 +0,0 @@
 package cli //nolint:testpackage // sets the unexported rootFlags directly
 import (
 	"bytes"
 	"errors"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/vaultik"
 )
 // TestDatabaseDeleteDeclinedIsError checks that answering anything but
 // "yes" keeps the database and returns ErrNotConfirmed, so the command
 // exits non-zero.
 //
 //nolint:paralleltest // mutates the process-global rootFlags
 func TestDatabaseDeleteDeclinedIsError(t *testing.T) {
 	dir := t.TempDir()
 	dbPath, cfgPath := seedDatabaseDeleteConfig(t, dir)
 	setRootFlags(t, RootFlags{ConfigPath: cfgPath})
 	var out bytes.Buffer
 	cmd := newDatabaseDeleteCommand()
 	cmd.SetOut(&out)
 	cmd.SetErr(io.Discard)
 	cmd.SetIn(strings.NewReader("no\n"))
 	cmd.SetArgs(nil)
 	err := cmd.Execute()
 	if !errors.Is(err, vaultik.ErrNotConfirmed) {
 		t.Errorf("declined database delete returned %v, want %v",
 			err, vaultik.ErrNotConfirmed)
 	}
 	_, err = os.Stat(dbPath)
 	if err != nil {
 		t.Errorf("declined database delete removed the file: %v", err)
 	}
 	if !strings.Contains(out.String(), "Aborted.") {
 		t.Errorf("declined database delete printed %q, want Aborted.",
 			out.String())
 	}
 }
 // TestDatabaseDeleteRemovesSideFiles checks that the side files SQLite
 // keeps beside the database file are deleted with it.
 //
 //nolint:paralleltest // mutates the process-global rootFlags
 func TestDatabaseDeleteRemovesSideFiles(t *testing.T) {
 	dir := t.TempDir()
 	dbPath, cfgPath := seedDatabaseDeleteConfig(t, dir)
 	indexFiles := database.IndexFiles(dbPath)
 	for _, indexFile := range indexFiles {
 		seedFile(t, dir, filepath.Base(indexFile), "data")
 	}
 	setRootFlags(t, RootFlags{ConfigPath: cfgPath})
 	mustExecute(t, newDatabaseDeleteCommand(), "--force")
 	for _, indexFile := range indexFiles {
 		_, err := os.Stat(indexFile)
 		if !os.IsNotExist(err) {
 			t.Errorf("database delete left %s: stat err = %v", indexFile, err)
 		}
 	}
 }
@@ -21,8 +21,6 @@ const shortCommitLen = 12
 const exitCodeInterrupted = 130
 // Entry is the main entry point for the CLI application.
 // It first calls globals.FillUnsetFromBuildInfo, which fills in the
 // version, commit and commit date that the linker flags did not set.
 // It prints the startup banner to stderr (unless a banner-suppressing
 // flag is present in os.Args — see bannerSuppressedInArgs), executes the
 // root cobra command, and routes any returned error through the
@@ -35,7 +33,6 @@ const exitCodeInterrupted = 130
 // deferred profile writers run before the process ends. See run in
 // cmd/vaultik/main.go.
 func Entry() int {
 	globals.FillUnsetFromBuildInfo()
 	emitStartupBanner(os.Args[1:], os.Stderr)
 	rootCmd := NewRootCommand()
@@ -85,10 +82,6 @@ func emitStartupBanner(args []string, w io.Writer) {
 // 🛑 ERROR: format. Use it from goroutine error paths (where returning
 // an error to cobra isn't an option) and anywhere else a CLI command
 // must surface a failure outside the normal RunE return path.
 //
 // This line is the one report of the failure. A caller that also logs
 // the failure logs it at info level, so the record appears only under
 // --verbose or --debug and the error is not printed twice.
 func ReportErrorf(format string, args ...any) {
 	ui.New(os.Stderr).Errorf(format, args...)
 }
@@ -13,7 +13,6 @@ import (
 	"github.com/adrg/xdg"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/globals"
 )
 // Command words and flags used to build argument vectors below. They are
@@ -113,35 +112,6 @@ func TestBannerStillPrintedWithoutSuppressingFlag(t *testing.T) {
 	}
 }
 // TestBannerLabelsCommitDate checks that the banner prints the commit
 // and the commit date, each after its own label. Commit and CommitDate
 // get different values, so printing the wrong one fails.
 //
 //nolint:paralleltest // sets globals.Commit and globals.CommitDate
 func TestBannerLabelsCommitDate(t *testing.T) {
 	const (
 		commit     = "abc1234"
 		commitDate = "2026-11-09"
 	)
 	previousCommit, previousCommitDate := globals.Commit, globals.CommitDate
 	t.Cleanup(func() {
 		globals.Commit = previousCommit
 		globals.CommitDate = previousCommitDate
 	})
 	globals.Commit = commit
 	globals.CommitDate = commitDate
 	var banner bytes.Buffer
 	emitStartupBanner(nil, &banner)
 	assert.Contains(t, banner.String(),
 		"(commit "+commit+", commit date "+commitDate+")")
 }
 // TestBannerSuppressedInArgs covers the suppression scan directly,
 // including the flags that suppressed the banner before --json joined
 // them, so that adding --json cannot regress them.
@@ -1,205 +0,0 @@
 package cli //nolint:testpackage // shares the fixtures and capture helpers
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 	"filippo.io/age"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/ui"
 )
 const (
 	// errorLinePrefix starts the final line that reports a failed command.
 	errorLinePrefix = "ERROR: "
 	flagVerbose = "--verbose"
 	cmdRestore  = "restore"
 	// blobsDir is the directory of a destination store that holds the
 	// blobs.
 	blobsDir = "blobs"
 )
 // TestEntryFailureIsPrintedOnce runs commands that fail after startup
 // against a destination they cannot use. `info` is not among them: it
 // cannot fail after startup.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntryFailureIsPrintedOnce(t *testing.T) {
 	for _, command := range [][]string{
 		{cmdSnapshot, cmdCreate},
 		{cmdSnapshot, cmdRemove, someSnapshotID},
 		{cmdSnapshot, cmdVerify, someSnapshotID},
 		{cmdRemote, cmdInfo},
 		{cmdPrune, flagJSON},
 	} {
 		for _, verbose := range []bool{false, true} {
 			name := fmt.Sprintf("%s verbose=%t", strings.Join(command, " "), verbose)
 			t.Run(name, func(t *testing.T) {
 				requireErrorPrintedOnce(t, verbose, append([]string{flagConfig,
 					writeUnusableDestinationConfig(t)}, command...)...)
 			})
 		}
 	}
 }
 // TestEntryBlobUploadFailureIsPrintedOnce backs up to a destination
 // whose blobs directory is a file, so the blob upload fails.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntryBlobUploadFailureIsPrintedOnce(t *testing.T) {
 	for _, verbose := range []bool{false, true} {
 		t.Run(fmt.Sprintf("verbose=%t", verbose), func(t *testing.T) {
 			configPath, storeDir := writeBackupConfig(t)
 			require.NoError(t, os.WriteFile(
 				filepath.Join(storeDir, blobsDir), nil, 0o600))
 			requireErrorPrintedOnce(t, verbose,
 				flagConfig, configPath, cmdSnapshot, cmdCreate)
 		})
 	}
 }
 // TestEntryBlobDownloadFailureIsPrintedOnce backs up, deletes the blobs
 // from the destination, and restores, so the blob download fails.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntryBlobDownloadFailureIsPrintedOnce(t *testing.T) {
 	for _, verbose := range []bool{false, true} {
 		t.Run(fmt.Sprintf("verbose=%t", verbose), func(t *testing.T) {
 			configPath, storeDir := writeBackupConfigWithPrivateKey(t)
 			code, _, _ := runEntry(t,
 				flagConfig, configPath, cmdSnapshot, cmdCreate)
 			require.Equal(t, 0, code)
 			require.NoError(t, os.RemoveAll(filepath.Join(storeDir, blobsDir)))
 			requireErrorPrintedOnce(t, verbose, flagConfig, configPath,
 				cmdSnapshot, cmdRestore, onlySnapshotID(t, configPath), t.TempDir())
 		})
 	}
 }
 // requireErrorPrintedOnce runs Entry with args, adding --verbose when
 // verbose is set. The command must fail, and stderr must carry its error
 // once, as the final ERROR: line. A log record carrying the same error
 // appears only under --verbose.
 func requireErrorPrintedOnce(t *testing.T, verbose bool, args ...string) {
 	t.Helper()
 	if verbose {
 		args = append(args, flagVerbose)
 	}
 	code, _, stderr := runEntry(t, args...)
 	require.Equal(t, 1, code)
 	errorLine, records := failureOutput(t, stderr)
 	if !verbose {
 		assert.Zero(t, records,
 			"without --verbose no log record repeats the error:\n%s", stderr)
 		return
 	}
 	assert.NotZero(t, records,
 		"--verbose must keep the log record of %q", errorLine)
 }
 // failureOutput requires stderr to hold exactly one ERROR: line and
 // returns it, with the number of log records whose error attribute is
 // the error that line reports. stderr is a pipe here, so every log
 // record is a JSON object on its own line.
 func failureOutput(t *testing.T, stderr string) (string, int) {
 	t.Helper()
 	var (
 		errorLines []string
 		records    []map[string]any
 	)
 	for line := range strings.Lines(stderr) {
 		var record map[string]any
 		if json.Unmarshal([]byte(line), &record) == nil {
 			records = append(records, record)
 			continue
 		}
 		if strings.Contains(line, errorLinePrefix) {
 			errorLines = append(errorLines, strings.TrimSpace(line))
 		}
 	}
 	require.Len(t, errorLines, 1,
 		"the error must be printed once as an ERROR: line:\n%s", stderr)
 	// An error can run over several lines; the ERROR: line holds the
 	// first of them.
 	repeats := 0
 	for _, record := range records {
 		failure, ok := record["error"].(string)
 		firstLine, _, _ := strings.Cut(failure, "\n")
 		if ok && strings.Contains(errorLines[0], firstLine) {
 			repeats++
 		}
 	}
 	return errorLines[0], repeats
 }
 // writeBackupConfigWithPrivateKey builds what writeBackupConfig builds,
 // with a generated key pair in place of its recipient. The config also
 // holds the private key, so that restore can decrypt the backup. Returns
 // the config path and the store directory.
 func writeBackupConfigWithPrivateKey(t *testing.T) (string, string) {
 	t.Helper()
 	configPath, storeDir := writeBackupConfig(t)
 	identity, err := age.GenerateX25519Identity()
 	require.NoError(t, err)
 	out := ui.NewWithColor(io.Discard, false)
 	require.NoError(t, writeConfigSet(out, configPath,
 		"age_recipients.0", identity.Recipient().String()))
 	require.NoError(t, writeConfigSet(out, configPath,
 		"age_secret_key", identity.String()))
 	return configPath, storeDir
 }
 // onlySnapshotID returns the ID of the one snapshot in the local index
 // that writeBackupConfig puts beside the config file.
 func onlySnapshotID(t *testing.T, configPath string) string {
 	t.Helper()
 	ctx := context.Background()
 	db, err := database.New(ctx,
 		filepath.Join(filepath.Dir(configPath), "index.sqlite"))
 	require.NoError(t, err)
 	defer func() { require.NoError(t, db.Close()) }()
 	backedUp, err := database.NewRepositories(db).Snapshots.GetOnlySnapshot(ctx)
 	require.NoError(t, err)
 	return backedUp.ID.String()
 }
@@ -101,8 +101,7 @@ func TestEntryPruneJSONStdoutIsExactlyOneDocument(t *testing.T) {
 // writeHermeticPruneConfig builds a config over a temp directory with an
 // empty destination directory and, if seedStale is set, creates the
 // index database up front with one snapshot record that has no
-// counterpart on the destination store, and gives the destination the
+// counterpart on the destination store. Returns the config path.
 // marker a backup writes. Returns the config path.
 func writeHermeticPruneConfig(t *testing.T, seedStale bool) string {
 	t.Helper()
@@ -132,11 +131,6 @@ func writeHermeticPruneConfig(t *testing.T, seedStale bool) string {
 	if seedStale {
 		seedStaleSnapshotRecord(t, indexPath)
 		// While the local index holds a snapshot, prune fails on a
 		// destination that answers that it has no marker.
 		require.NoError(t, os.WriteFile(
 			filepath.Join(storeDir, "vaultik-destination.txt"), nil, 0o600))
 	}
 	return configPath
@@ -1,127 +0,0 @@
 package cli //nolint:testpackage // shares runEntry and the hermetic config helpers
 import (
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 	"time"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 // flagCron is used to build the argument vectors below.
 const flagCron = "--cron"
 // plantUnreferencedBlob writes a blob that no snapshot references to the
 // destination store at storeDir, dated long before any prune grace period,
 // so that a prune deletes it. Returns its path.
 func plantUnreferencedBlob(t *testing.T, storeDir string) string {
 	t.Helper()
 	hash := strings.Repeat("b", 64)
 	path := filepath.Join(storeDir, "blobs", hash[:2], hash[2:4], hash)
 	require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o750))
 	require.NoError(t, os.WriteFile(path, []byte("unreferenced"), 0o600))
 	longAgo := time.Unix(0, 0)
 	require.NoError(t, os.Chtimes(path, longAgo, longAgo))
 	return path
 }
 // TestEntrySnapshotCreatePruneIsSilent checks that a successful
 // `snapshot create --prune` under --cron or --quiet prints nothing on
 // stdout or stderr, whether or not the prune finds a blob to delete.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotCreatePruneIsSilent(t *testing.T) {
 	for _, testCase := range []struct {
 		name      string
 		args      []string
 		plantBlob bool
 	}{
 		{
 			name: "cron, no blob to delete",
 			args: []string{cmdSnapshot, cmdCreate, flagCron, flagPrune},
 		},
 		{
 			name:      "cron, blob to delete",
 			args:      []string{cmdSnapshot, cmdCreate, flagCron, flagPrune},
 			plantBlob: true,
 		},
 		{
 			name: "cron with keep-newer-than",
 			args: []string{
 				cmdSnapshot, cmdCreate, flagCron, flagPrune,
 				flagKeepNewerThan, "4w",
 			},
 			plantBlob: true,
 		},
 		{
 			name:      "quiet",
 			args:      []string{flagQuiet, cmdSnapshot, cmdCreate, flagPrune},
 			plantBlob: true,
 		},
 	} {
 		t.Run(testCase.name, func(t *testing.T) {
 			configPath, storeDir := writeBackupConfig(t)
 			var blob string
 			if testCase.plantBlob {
 				blob = plantUnreferencedBlob(t, storeDir)
 			}
 			code, stdout, stderr := runEntry(t,
 				append([]string{flagConfig, configPath}, testCase.args...)...)
 			assert.Equal(t, 0, code)
 			assert.Empty(t, stdout)
 			assert.Empty(t, stderr)
 			if testCase.plantBlob {
 				assert.NoFileExists(t, blob, "the prune must delete the blob")
 			}
 		})
 	}
 }
 // TestEntryPruneQuietIsSilent checks that a successful `prune --force`
 // under --quiet prints nothing on stdout or stderr, both when there is
 // nothing to remove and when it removes a stale local snapshot record
 // and an unreferenced blob.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntryPruneQuietIsSilent(t *testing.T) {
 	for _, testCase := range []struct {
 		name               string
 		staleRecordAndBlob bool
 	}{
 		{name: "nothing to remove"},
 		{name: "stale record and blob to remove", staleRecordAndBlob: true},
 	} {
 		t.Run(testCase.name, func(t *testing.T) {
 			configPath := writeHermeticPruneConfig(t, testCase.staleRecordAndBlob)
 			var blob string
 			if testCase.staleRecordAndBlob {
 				// writeHermeticPruneConfig puts the store beside the config.
 				blob = plantUnreferencedBlob(t,
 					filepath.Join(filepath.Dir(configPath), "store"))
 			}
 			code, stdout, stderr := runEntry(t,
 				flagConfig, configPath, flagQuiet, cmdPrune, flagForce)
 			assert.Equal(t, 0, code)
 			assert.Empty(t, stdout)
 			assert.Empty(t, stderr)
 			if testCase.staleRecordAndBlob {
 				assert.NoFileExists(t, blob, "the prune must delete the blob")
 			}
 		})
 	}
 }
@@ -1,69 +0,0 @@
 package cli //nolint:testpackage // shares runEntry and the hermetic config helpers
 import (
 	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
 	"github.com/adrg/xdg"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 // TestEntrySnapshotCreateSkipsIndexAndLockFiles backs up a directory
 // that holds vaultik's index and PID file beside one other file, with no
 // exclude pattern set. The summary counts only the other file. See
 // https://git.eeqj.de/sneak/vaultik/issues/421.
 //
 // Not parallel: it replaces os.Args, os.Stdout, os.Stderr and the xdg
 // globals.
 func TestEntrySnapshotCreateSkipsIndexAndLockFiles(t *testing.T) {
 	for _, testCase := range []struct {
 		name string
 		// linked sets index_path to a symlink outside the backed-up
 		// directory that points to the index inside it.
 		linked bool
 	}{
 		{name: "index in the backed-up directory"},
 		{name: "index_path links into the backed-up directory", linked: true},
 	} {
 		t.Run(testCase.name, func(t *testing.T) {
 			dir := t.TempDir()
 			configPath := filepath.Join(dir, "config.yml")
 			sourceDir := filepath.Join(dir, "source")
 			storeDir := filepath.Join(dir, "store")
 			indexPath := filepath.Join(sourceDir, "index.sqlite")
 			if testCase.linked {
 				link := filepath.Join(dir, "index.sqlite")
 				require.NoError(t, os.Symlink(indexPath, link))
 				indexPath = link
 			}
 			contents := fmt.Sprintf(hermeticConfig,
 				sourceDir, storeDir, indexPath)
 			require.NoError(t,
 				os.WriteFile(configPath, []byte(contents), configFileMode))
 			require.NoError(t, os.Mkdir(storeDir, 0o750))
 			require.NoError(t, os.Mkdir(sourceDir, 0o750))
 			require.NoError(t, os.WriteFile(
 				filepath.Join(sourceDir, "file.txt"), []byte("hello"), 0o600))
 			// The PID file goes in a directory under XDG_DATA_HOME, which
 			// xdg reads at package init.
 			t.Setenv("XDG_DATA_HOME", filepath.Join(sourceDir, "data"))
 			xdg.Reload()
 			t.Cleanup(xdg.Reload)
 			code, stdout, _ := runEntry(t,
 				flagConfig, configPath, cmdSnapshot, cmdCreate)
 			require.Equal(t, 0, code)
 			assert.Contains(t, stdout,
 				"Files: 1 examined, 1 backed up, 0 unchanged.")
 		})
 	}
 }
@@ -1,7 +1,6 @@
 package cli //nolint:testpackage // shares runEntry and the hermetic config helpers
 import (
 	"context"
 	"os"
 	"path/filepath"
 	"strings"
@@ -9,7 +8,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/database"
 )
 // Flags of `snapshot create` used to build argument vectors below.
@@ -61,8 +59,8 @@ func TestEntrySnapshotCreateRejectsKeepNewerThanBeforeBackup(t *testing.T) {
 // TestEntrySnapshotCreateReportsPostBackupPruneFailure makes the
 // post-backup prune fail after a good backup, by planting a manifest
-// that cannot be decoded, and checks that the failure is reported once,
+// that cannot be decoded, and checks that the failure is reported as the
-// as the prune's and not as a failed snapshot creation.
+// prune's and not as a failed snapshot creation.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotCreateReportsPostBackupPruneFailure(t *testing.T) {
@@ -83,98 +81,12 @@ func TestEntrySnapshotCreateReportsPostBackupPruneFailure(t *testing.T) {
 	assert.Contains(t, stderr, "Backup completed, but post-backup prune failed")
 	assert.NotContains(t, stderr, "Snapshot creation failed")
 	_, repeats := failureOutput(t, stderr)
 	assert.Zero(t, repeats, "no log record may repeat the error:\n%s", stderr)
 	snapshots, err := os.ReadDir(filepath.Join(storeDir, "metadata"))
 	require.NoError(t, err)
 	assert.Len(t, snapshots, 2,
 		"the new snapshot is on the store beside the planted one")
 }
 // TestEntrySnapshotCreatePruneExitsNonZeroWhenSourceIsEmpty backs up,
 // empties the source directory, as a volume that is not mounted leaves
 // its mount point, and runs `snapshot create --prune`. The command exits
 // non-zero and reports the backup as completed, not as a failed snapshot
 // creation. The error is printed once. See
 // https://git.eeqj.de/sneak/vaultik/issues/388.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotCreatePruneExitsNonZeroWhenSourceIsEmpty(t *testing.T) {
 	configPath, storeDir := writeBackupConfig(t)
 	code, _, _ := runEntry(t, flagConfig, configPath, cmdSnapshot, cmdCreate)
 	require.Equal(t, 0, code)
 	// writeBackupConfig puts the source directory beside the config file.
 	require.NoError(t, os.Remove(
 		filepath.Join(filepath.Dir(configPath), "source", "file.txt")))
 	code, _, stderr := runEntry(t,
 		flagConfig, configPath, cmdSnapshot, cmdCreate, flagPrune)
 	assert.Equal(t, 1, code)
 	assert.Contains(t, stderr,
 		"Backup completed, but 1 source path(s) were empty")
 	assert.NotContains(t, stderr, "Snapshot creation failed")
 	_, repeats := failureOutput(t, stderr)
 	assert.Zero(t, repeats, "no log record may repeat the error:\n%s", stderr)
 	snapshots, err := os.ReadDir(filepath.Join(storeDir, "metadata"))
 	require.NoError(t, err)
 	assert.Len(t, snapshots, 2, "the older snapshot is kept")
 }
 // TestEntrySnapshotCreatePruneExitsNonZeroWhenMountPointIsMissing backs
 // up, records in the local index that this backup found the source
 // directory as a mount point, and runs `snapshot create --prune`, which
 // does not find it as one. The command exits non-zero, reports the
 // backup as completed, not as a failed snapshot creation, and keeps the
 // older snapshot. The error is printed once. See
 // https://git.eeqj.de/sneak/vaultik/issues/395.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotCreatePruneExitsNonZeroWhenMountPointIsMissing(
 	t *testing.T,
 ) {
 	configPath, storeDir := writeBackupConfig(t)
 	code, _, _ := runEntry(t, flagConfig, configPath, cmdSnapshot, cmdCreate)
 	require.Equal(t, 0, code)
 	// writeBackupConfig puts the source directory and the local index
 	// beside the config file.
 	dir := filepath.Dir(configPath)
 	ctx := context.Background()
 	db, err := database.New(ctx, filepath.Join(dir, "index.sqlite"))
 	require.NoError(t, err)
 	repos := database.NewRepositories(db)
 	backedUp, err := repos.Snapshots.GetOnlySnapshot(ctx)
 	require.NoError(t, err)
 	require.NoError(t, repos.Snapshots.AddMountPoint(ctx, nil,
 		backedUp.ID.String(), filepath.Join(dir, "source")))
 	require.NoError(t, db.Close())
 	code, _, stderr := runEntry(t,
 		flagConfig, configPath, cmdSnapshot, cmdCreate, flagPrune)
 	assert.Equal(t, 1, code)
 	assert.Contains(t, stderr, "Backup completed, but 1 mount point(s) "+
 		"an earlier snapshot recorded were not found")
 	assert.NotContains(t, stderr, "Snapshot creation failed")
 	_, repeats := failureOutput(t, stderr)
 	assert.Zero(t, repeats, "no log record may repeat the error:\n%s", stderr)
 	snapshots, err := os.ReadDir(filepath.Join(storeDir, "metadata"))
 	require.NoError(t, err)
 	assert.Len(t, snapshots, 2, "the older snapshot is kept")
 }
 // writeBackupConfig builds a hermetic config with one small file in its
 // source directory and an empty destination store directory. Returns the
 // config path and the store directory.
@@ -1,30 +0,0 @@
 package cli //nolint:testpackage // shares runEntry and the hermetic config helpers
 import (
 	"testing"
 	"github.com/stretchr/testify/assert"
 )
 // TestEntrySnapshotCreateSkipErrorsExitsNonZeroWhenItSkips backs up,
 // under --skip-errors, a source directory that does not exist, which the
 // walk skips. The command exits non-zero and reports the backup as
 // completed, not as a failed snapshot creation. See
 // https://git.eeqj.de/sneak/vaultik/issues/310.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotCreateSkipErrorsExitsNonZeroWhenItSkips(t *testing.T) {
 	// writeBackupConfig would create the source directory.
 	configPath := writeHermeticPruneConfig(t, false)
 	code, stdout, stderr := runEntry(t,
 		flagConfig, configPath, "--skip-errors", cmdSnapshot, cmdCreate)
 	assert.Equal(t, 1, code)
 	assert.Contains(t, stdout,
 		"Files: 1 examined, 0 backed up, 0 unchanged, 1 failed.")
 	assert.NotContains(t, stdout, "Finished successfully.")
 	assert.Contains(t, stderr,
 		"Backup completed, but 1 file(s) could not be read")
 	assert.NotContains(t, stderr, "Snapshot creation failed")
 }
@@ -1,75 +0,0 @@
 package cli //nolint:testpackage // shares runEntry and the hermetic config helpers
 import (
 	"context"
 	"os"
 	"path/filepath"
 	"testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/snapshot"
 )
 // Words and flags of `snapshot purge` used to build argument vectors
 // below.
 const (
 	cmdPurge      = "purge"
 	flagOlderThan = "--older-than"
 	flagForce     = "--force"
 )
 // TestEntrySnapshotPurgeKeepsMetadataWhenLocalIndexDeleteFails makes
 // the local index refuse to delete an old snapshot and checks that
 // `snapshot purge` exits non-zero and leaves that snapshot's metadata on
 // the destination store. It used to log the error, delete the metadata
 // and exit 0.
 //
 // `snapshot create --prune` runs the same purge, but cannot be driven
 // this way: the refusal also breaks the backup's metadata export, which
 // deletes the other snapshots from its copy of the local index.
 //
 //nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
 func TestEntrySnapshotPurgeKeepsMetadataWhenLocalIndexDeleteFails(t *testing.T) {
 	configPath := writeHermeticPruneConfig(t, false)
 	dir := filepath.Dir(configPath)
 	indexPath := filepath.Join(dir, "index.sqlite")
 	// seedStaleSnapshotRecord writes an old snapshot to the local index
 	// only; the manifest planted here puts it on the destination store
 	// too, so the purge selects it rather than dropping it as stale.
 	seedStaleSnapshotRecord(t, indexPath)
 	// While the local index holds a snapshot, purge fails on a
 	// destination that answers that it has no marker.
 	require.NoError(t, os.WriteFile(
 		filepath.Join(dir, "store", "vaultik-destination.txt"), nil, 0o600))
 	manifestDir := filepath.Join(dir, "store", "metadata",
 		snapshot.RemoteSnapshotKey(stalePruneSnapshotID))
 	require.NoError(t, os.MkdirAll(manifestDir, 0o750))
 	manifestPath := filepath.Join(manifestDir, "manifest.json.zst")
 	require.NoError(t, os.WriteFile(manifestPath, []byte("stub"), 0o600))
 	ctx := context.Background()
 	db, err := database.New(ctx, indexPath)
 	require.NoError(t, err)
 	_, err = db.Conn().ExecContext(ctx, `
 		CREATE TRIGGER refuse_snapshot_delete BEFORE DELETE ON snapshots
 		BEGIN SELECT RAISE(ABORT, 'simulated index error'); END`)
 	require.NoError(t, err)
 	require.NoError(t, db.Close())
 	code, _, stderr := runEntry(t, flagConfig, configPath,
 		cmdSnapshot, cmdPurge, flagOlderThan, "30d", flagForce)
 	assert.Equal(t, 1, code)
 	assert.Contains(t, stderr, "simulated index error",
 		"the purge must fail at the local-index delete")
 	assert.FileExists(t, manifestPath,
 		"the snapshot is still in the local index, so its metadata must stay")
 }
@@ -39,7 +39,7 @@ func NewInfoCommand() *cobra.Command {
 			}, func(v *vaultik.Vaultik) error {
 				return v.ShowInfo()
 			}, func(err error) {
-				log.Info("Failed to show info", "error", err)
+				log.Error("Failed to show info", "error", err)
 				ReportErrorf("Failed to show info: %v", err)
 			})
 		},
@@ -13,28 +13,14 @@ func NewPruneCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "prune",
 		Short: "Tidy local database and remote storage",
-		Long: `Removes orphaned data from the local index database, and
+		Long: `Removes orphaned data from both the local index database and
-unreferenced blobs and directories under metadata/ with no manifest
+unreferenced blobs from the backup destination store.
 from the backup destination store.
-Needs permission to list, read and delete objects on the destination
+Local cleanup drops incomplete snapshots and any files, chunks, or
 store. It does not need the age private key.
 Local cleanup drops snapshots whose manifest is gone from the
 destination store, incomplete snapshots, and any files, chunks, or
 blobs no longer referenced by a completed snapshot. Remote cleanup
 scans every snapshot manifest in the destination store, builds the
 set of still-referenced blob hashes, and deletes any blob not in that
-set that is older than prune_grace_period (default 24h). A newer one
+set.
 is kept: it may belong to a backup still running, on this host or
 another sharing the destination store, that has not yet uploaded its
 manifest. The grace period does not protect a blob such a backup
 reuses from an earlier run that stopped before its manifest: that
 blob keeps the time of its first upload, so it can be deleted.
 Remote cleanup also deletes each directory under metadata/ with no
 manifest, as a backup that stopped before its manifest leaves, once
 all its objects are older than prune_grace_period and its snapshot is
 not in the local index.
 Snapshot create --prune runs the same cleanup automatically; this
 command is the manual entry point for the same work (e.g. after a
@@ -64,7 +50,7 @@ referenced.`,
 			}, func(v *vaultik.Vaultik) error {
 				return v.Prune(opts)
 			}, func(err error) {
-				log.Info("Prune operation failed", "error", err)
+				log.Error("Prune operation failed", "error", err)
 				ReportErrorf("Prune failed: %v", err)
 			})
 		},
@@ -40,13 +40,11 @@ func newRemoteNukeCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "nuke",
 		Short: "Delete ALL snapshot metadata and blobs from the backup destination store",
-		Long: `Removes every snapshot's metadata, every blob and the destination
+		Long: `Removes every snapshot's metadata and every blob from remote
-marker from the backup destination store, and each removed snapshot from
+storage. After this command completes successfully the bucket prefix is
-the local index. After this command completes successfully the backup
+empty and the next backup starts from scratch.
 destination store is empty and the next backup starts from scratch.
-This is destructive and irreversible. Requires --force, and permission
+This is destructive and irreversible. Requires --force.`,
 to list and delete objects on the destination store.`,
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			if !force {
@@ -77,10 +75,7 @@ func newRemoteInfoCommand() *cobra.Command {
 - Size of all snapshot metadata (per snapshot and total)
 - Count and total size of all blobs
 - Count and size of referenced blobs (from all manifests)
- Count and size of orphaned blobs (not referenced by any manifest)
+- Count and size of orphaned blobs (not referenced by any manifest)`,
 Needs permission to list and read the destination store. It does not
 need the age private key.`,
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			// Use unified config resolution
@@ -103,7 +98,7 @@ need the age private key.`,
 			}, func(v *vaultik.Vaultik) error {
 				return v.RemoteInfo(jsonOutput)
 			}, func(err error) {
-				log.Info("Failed to get remote info", "error", err)
+				log.Error("Failed to get remote info", "error", err)
 				ReportErrorf("Failed to get remote info: %v", err)
 			})
 		},
@@ -35,10 +35,9 @@ func NewRootCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "vaultik",
 		Short: "Secure incremental backup tool with asymmetric encryption",
-		Long: `vaultik is an incremental backup tool that encrypts data to age public
+		Long: `vaultik is a secure incremental backup tool that encrypts data using age
-keys and uploads it to an S3-compatible object store, a local directory or
+public keys and uploads to S3-compatible storage. No private keys are needed
-an rclone remote. The backed-up machine needs no private key: only
+on the source system.`,
 'snapshot restore' and 'snapshot verify --deep' need one.`,
 		SilenceUsage: true,
 		// Bare 'vaultik' (no subcommand): print help. The banner is
 		// printed once at process startup by Entry, before cobra
@@ -51,16 +50,13 @@ an rclone remote. The backed-up machine needs no private key: only
 	// Add global flags
 	cmd.PersistentFlags().StringVar(&rootFlags.ConfigPath, "config", "",
-		"Path to config file (default: $VAULTIK_CONFIG, then the platform "+
+		"Path to config file (default: $VAULTIK_CONFIG or platform config dir)")
 			"config directory, then /etc/vaultik/config.yml)")
 	cmd.PersistentFlags().BoolVarP(&rootFlags.Verbose, "verbose", "v", false,
 		"Enable verbose output")
 	cmd.PersistentFlags().BoolVar(&rootFlags.Debug, "debug", false,
 		"Enable debug output")
 	cmd.PersistentFlags().BoolVarP(&rootFlags.Quiet, "quiet", "q", false,
-		"Leave out the banner, status lines, tables and reports (warnings, "+
+		"Suppress non-error output")
 			"errors, JSON documents, 'config get' values and confirmation "+
 			"prompts are still printed)")
 	cmd.PersistentFlags().BoolVar(&rootFlags.SkipErrors, "skip-errors", false,
 		"Skip files that cannot be read when creating a snapshot, or "+
 			"that cannot be restored when restoring, instead of aborting "+
@@ -60,22 +60,6 @@ func NewSnapshotCommand() *cobra.Command {
 	return cmd
 }
 // snapshotCreateLong is the long help text of 'snapshot create'.
 const snapshotCreateLong = `Creates new snapshots of the configured directories.
 If snapshot names are provided, only those snapshots are created.
 If no names are provided, all configured snapshots are created.
 Needs at least one public key in age_recipients, and permission to write
 objects at the backup destination store. It does not need the age private
 key. With --prune it also needs permission to list, read and delete objects
 there. An rclone remote that can move objects also needs permission to
 read and delete.
 The config is read from the path given by --config or VAULTIK_CONFIG;
 otherwise from the platform config directory (~/.config/vaultik/config.yml
 on Linux), then /etc/vaultik/config.yml.`
 // newSnapshotCreateCommand creates the 'snapshot create' subcommand
 func newSnapshotCreateCommand() *cobra.Command {
 	opts := &vaultik.SnapshotCreateOptions{}
@@ -83,8 +67,15 @@ func newSnapshotCreateCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "create [snapshot-names...]",
 		Short: "Create new snapshots",
-		Long:  snapshotCreateLong,
+		Long: `Creates new snapshots of the configured directories.
-		Args:  cobra.ArbitraryArgs,
+
 If snapshot names are provided, only those snapshots are created.
 If no names are provided, all configured snapshots are created.
 The config is read from the path given by --config or VAULTIK_CONFIG;
 otherwise from the platform config directory (~/.config/vaultik/config.yml
 on Linux), then /etc/vaultik/config.yml.`,
 		Args: cobra.ArbitraryArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			err := opts.Validate()
 			if err != nil {
@@ -118,22 +109,13 @@ func newSnapshotCreateCommand() *cobra.Command {
 				return v.CreateSnapshot(opts)
 			}, func(err error) {
 				if errors.Is(err, vaultik.ErrPostBackupPruneFailed) {
-					log.Info("Post-backup prune failed", "error", err)
+					log.Error("Post-backup prune failed", "error", err)
 					ReportErrorf("Backup completed, but %v", err)
 					return
 				}
-				if errors.Is(err, vaultik.ErrFilesUnreadable) ||
+				log.Error("Snapshot creation failed", "error", err)
 					errors.Is(err, vaultik.ErrSourcePathEmpty) ||
 					errors.Is(err, vaultik.ErrVolumeNotMounted) {
 					log.Info("Backup completed with an error", "error", err)
 					ReportErrorf("Backup completed, but %v", err)
 					return
 				}
 				log.Info("Snapshot creation failed", "error", err)
 				ReportErrorf("Snapshot creation failed: %v", err)
 			})
 		},
@@ -142,13 +124,8 @@ func newSnapshotCreateCommand() *cobra.Command {
 	cmd.Flags().BoolVar(&opts.Cron, "cron", false,
 		"Run in cron mode (silent unless warning or error)")
 	cmd.Flags().BoolVar(&opts.Prune, "prune", false,
-		"After backup, drop older snapshots of the same name, remove "+
+		"After backup, drop older snapshots of the same name and remove "+
-			"orphaned blobs older than prune_grace_period, and delete each "+
+			"orphaned blobs")
 			"directory under metadata/ with no manifest once all its "+
 			"objects are older than prune_grace_period and its snapshot is "+
 			"not in the local index (not after a backup that skipped "+
 			"unreadable files, found a configured path empty, or did not "+
 			"find a mount point an earlier snapshot found)")
 	cmd.Flags().StringVar(&opts.KeepNewerThan, "keep-newer-than", "",
 		"With --prune: keep snapshots newer than this duration "+
 			"(e.g. 30d, 4w, 6mo, 1y; m is minutes, mo is months) "+
@@ -165,15 +142,8 @@ func newSnapshotListCommand() *cobra.Command {
 		Use:     "list",
 		Aliases: []string{"ls"},
 		Short:   "List all snapshots",
-		Long: `Lists the snapshots in the local index and on the backup destination
+		Long:    "Lists all snapshots with their ID, timestamp, and compressed size",
-store, with their ID, timestamp, and sizes.
+		Args:    cobra.NoArgs,
 Needs permission to list and read the destination store. It does not need
 the age private key. A snapshot found only on the destination store is
 listed by its remote key, because its ID is stored only in the local index
 and in the snapshot's encrypted database. If the destination store cannot
 be listed, the command warns and lists the local index alone.`,
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			return runVaultikApp(cmd, readOnly, false,
 				"Failed to list snapshots",
@@ -195,19 +165,11 @@ func newSnapshotPurgeCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "purge",
 		Short: "Purge old snapshots",
-		Long: `Removes snapshots based on age or count criteria. Exactly one of
+		Long: `Removes snapshots based on age or count criteria.
 --keep-latest and --older-than is required.
-Retention is per-snapshot-name: --keep-latest keeps the latest snapshot of
+Retention is per-snapshot-name: --keep-latest keeps the latest of each
-each name, not the latest globally. Use --snapshot to restrict the
+configured snapshot name, not the latest globally. Use --snapshot to
-operation to specific snapshot names.
+restrict the operation to specific snapshot names.`,
 Only snapshots in the local index are removed. Each one is removed from
 the local index and its metadata is deleted from the backup destination
 store. Blobs are not touched: run 'vaultik prune' afterwards.
 Needs permission to list and delete objects on the destination store. If
 the destination store cannot be listed, nothing is removed.`,
 		Args: cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
 			// Validate flags
@@ -246,30 +208,14 @@ func newSnapshotVerifyCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "verify <snapshot-id>",
 		Short: "Check a snapshot's blobs are present with the listed size",
-		Long: `Checks that every blob the snapshot's manifest lists is present
+		Long: "Checks that every blob the snapshot's manifest lists is present\n" +
-in storage with the size the manifest records, and that the
+			"in storage with the size the manifest records, and that the\n" +
-snapshot's encrypted database is present. It does not read blob
+			"snapshot's encrypted database is present. It does not read blob\n" +
-contents and does not need the age private key.
+			"contents; use --deep to download, decrypt, and re-hash every blob\n" +
-
+			"to detect corruption -- integrity, not who wrote it.\n\n" +
-Needs permission to read the backup destination store, and to list it
+			"The snapshot may be named by its ID or, on a host with no local\n" +
-when given a remote key, or a snapshot ID that is not in the local
+			"index, by the remote key that 'snapshot list' prints for a\n" +
-index.
+			"remote-only snapshot (an unambiguous leading part is enough).",
 Use --deep to download, decrypt, and re-hash every blob to detect
 corruption -- integrity, not who wrote it.
 --deep requires the age private key, in the VAULTIK_AGE_SECRET_KEY
 environment variable or as age_secret_key in the config file; the
 environment variable wins. The variable may hold the whole age-keygen
 file, with its comments and all of its keys. Read the key from the
 file rather than typing it, so that it does not land in your shell
 history:
  export VAULTIK_AGE_SECRET_KEY="$(cat vaultik_backup_private_key.txt)"
 The snapshot may be named by its ID or, on a host with no local
 index, by the remote key that 'snapshot list' prints for a
 remote-only snapshot (an unambiguous leading part is enough).`,
 		Args: requireSnapshotIDArg,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			snapshotID := args[0]
@@ -298,16 +244,13 @@ remote-only snapshot (an unambiguous leading part is enough).`,
 					return
 				}
-				log.Info("Verification failed", "error", err)
+				log.Error("Verification failed", "error", err)
 				ReportErrorf("Verification failed: %v", err)
 			})
 		},
 	}
-	cmd.Flags().BoolVar(&opts.Deep, "deep", false,
+	cmd.Flags().BoolVar(&opts.Deep, "deep", false, "Download and verify blob hashes")
 		"Download, decrypt and re-hash every blob; requires the age private "+
 			"key in VAULTIK_AGE_SECRET_KEY, or as age_secret_key in the config "+
 			"file")
 	cmd.Flags().BoolVar(&opts.JSON, "json", false, "Output verification results as JSON")
 	return cmd
@@ -327,25 +270,20 @@ By default, this removes the snapshot from the local index database and
 strips the snapshot's metadata from the backup destination store. Blobs
 are NOT touched: deleting them requires reading every remaining remote
 manifest (the destination store may hold snapshots this host doesn't
-know about), which is what 'vaultik prune' does. The command prints the
+know about), which is what 'vaultik prune' does. On success the command
-'vaultik prune' invocation to run as a follow-up only when it removed the
+prints the exact 'vaultik prune' invocation to run as a follow-up.
 snapshot's metadata from the destination store, and never under --json.
-The argument must be a snapshot ID: a remote key is not accepted. An ID
+An ID that names no snapshot in the local index or on the destination
-that names no snapshot in the local index or on the destination store is
+store is an error.
 an error. Needs permission to list and delete objects on the destination
 store, unless --local-only is given.
 Use --local-only to skip the remote half (e.g. when you want to forget a
 snapshot locally without touching the destination store); the snapshot
 must then be in the local index.
-If removing the snapshot's metadata from the destination store fails (for
+If the remote is unreachable, the local-database removal still completes
-example because the remote is unreachable), the local-database removal
+and a warning is emitted; run 'vaultik snapshot remove <snapshot-id>' again
-still completes and a warning is emitted; run 'vaultik snapshot remove
+once the destination store is reachable to remove the snapshot's metadata
-<snapshot-id>' again once the destination store is reachable to remove
+from it ('vaultik prune' does not).
 the snapshot's metadata from it ('vaultik prune' does not). For a
 snapshot that is only on the destination store, that failure is an error.
 To wipe the entire destination store and start over, use 'vaultik remote
 nuke --force' — it is the single supported entry point for that.`,
@@ -363,8 +301,7 @@ nuke --force' — it is the single supported entry point for that.`,
 	cmd.Flags().BoolVarP(&opts.Force, "force", "f", false, "Skip confirmation prompt")
 	cmd.Flags().BoolVar(&opts.DryRun, "dry-run", false,
-		"Show what would be removed without removing; needs no permission "+
+		"Show what would be removed without removing")
 			"to delete")
 	cmd.Flags().BoolVar(&opts.JSON, "json", false,
 		"Output result as JSON; skips the confirmation prompt, as --force does")
 	cmd.Flags().BoolVar(&opts.LocalOnly, "local-only", false,
@@ -30,29 +30,18 @@ This command will restore files from the specified snapshot to the
 target directory.
 If no paths are specified, all files are restored.
 If paths are specified, only matching files/directories are restored.
 A path that matches nothing in the snapshot is named in a warning, and
 the command exits non-zero after restoring the paths that match.
 The snapshot may be named by its ID or, when restoring on a host with no
 local index, by the remote key that 'snapshot list' prints for a
 remote-only snapshot (an unambiguous leading part is enough).
-Each file is restored under its original absolute path inside the target
+Requires the age private key in the VAULTIK_AGE_SECRET_KEY environment
-directory. File owners are restored only when the command runs as root.
+variable. The variable may hold the whole age-keygen file (comments and
-
+all of its identities are accepted); read it from the file rather than
-Requires the age private key, in the VAULTIK_AGE_SECRET_KEY environment
+typing the key, so it does not land in your shell history:
 variable or as age_secret_key in the config file; the environment
 variable wins. The variable may hold the whole age-keygen file, with its
 comments and all of its keys. Read the key from the file rather than
 typing it, so that it does not land in your shell history:
  export VAULTIK_AGE_SECRET_KEY="$(cat vaultik_backup_private_key.txt)"
 Also needs permission to read the backup destination store, and to list
 it when given a remote key, or a snapshot ID that is not in the local
 index. It also needs free space in the temporary directory for the
 decrypted blobs.
 Examples:
  # Restore entire snapshot
  vaultik snapshot restore myhost_docs_2025-01-01T12:00:00Z /restore
@@ -113,7 +102,7 @@ func runRestore(cmd *cobra.Command, args []string, opts *RestoreOptions) error {
 			SkipErrors: rootFlags.SkipErrors,
 		})
 	}, func(err error) {
-		log.Info("Restore operation failed", "error", err)
+		log.Error("Restore operation failed", "error", err)
 		ReportErrorf("Restore failed: %v", err)
 	})
 }
@@ -37,13 +37,13 @@ func writeVersion(out *ui.Writer) {
 	w := out.Out()
 	_, _ = fmt.Fprintf(w, "vaultik %s\n", globals.Version)
-	_, _ = fmt.Fprintf(w, "  commit:      %s\n", globals.Commit)
+	_, _ = fmt.Fprintf(w, "  commit:     %s\n", globals.Commit)
-	_, _ = fmt.Fprintf(w, "  commit date: %s\n", globals.CommitDate)
+	_, _ = fmt.Fprintf(w, "  build date: %s\n", globals.CommitDate)
-	_, _ = fmt.Fprintf(w, "  go:          %s\n", runtime.Version())
+	_, _ = fmt.Fprintf(w, "  go:         %s\n", runtime.Version())
-	_, _ = fmt.Fprintf(w, "  os/arch:     %s/%s\n", runtime.GOOS, runtime.GOARCH)
+	_, _ = fmt.Fprintf(w, "  os/arch:    %s/%s\n", runtime.GOOS, runtime.GOARCH)
-	_, _ = fmt.Fprintf(w, "  author:      %s\n", globals.Author)
+	_, _ = fmt.Fprintf(w, "  author:     %s\n", globals.Author)
-	_, _ = fmt.Fprintf(w, "  homepage:    %s\n", globals.Homepage)
+	_, _ = fmt.Fprintf(w, "  homepage:   %s\n", globals.Homepage)
-	_, _ = fmt.Fprintf(w, "  license:     %s\n", globals.License)
+	_, _ = fmt.Fprintf(w, "  license:    %s\n", globals.License)
 	if globals.IsDevVersion(globals.Version) {
 		_, _ = fmt.Fprintln(w)
@@ -2,7 +2,6 @@ package cli_test
 import (
 	"bytes"
 	"runtime"
 	"strings"
 	"testing"
@@ -50,42 +49,6 @@ func TestVersionCommandReportsBuildVersion(t *testing.T) {
 	}
 }
 // TestVersionCommandReportLines checks the label, padding and value of
 // every line of the report. Commit and CommitDate get different values,
 // so a line that prints the wrong one fails.
 //
 //nolint:paralleltest // sets globals.Commit and globals.CommitDate
 func TestVersionCommandReportLines(t *testing.T) {
 	const (
 		commit     = "abc1234"
 		commitDate = "2026-11-09"
 	)
 	previousCommit, previousCommitDate := globals.Commit, globals.CommitDate
 	t.Cleanup(func() {
 		globals.Commit = previousCommit
 		globals.CommitDate = previousCommitDate
 	})
 	globals.Commit = commit
 	globals.CommitDate = commitDate
 	want := "vaultik " + globals.Version + "\n" +
 		"  commit:      " + commit + "\n" +
 		"  commit date: " + commitDate + "\n" +
 		"  go:          " + runtime.Version() + "\n" +
 		"  os/arch:     " + runtime.GOOS + "/" + runtime.GOARCH + "\n" +
 		"  author:      " + globals.Author + "\n" +
 		"  homepage:    " + globals.Homepage + "\n" +
 		"  license:     " + globals.License + "\n"
 	out := runVersionCommand(t)
 	if !strings.HasPrefix(out, want) {
 		t.Errorf("report:\n%s\nwant it to start with:\n%s", out, want)
 	}
 }
 // TestVersionCommandFlagsDevelopmentBuild is the regression test for
 // the thing this command exists to prevent: a build that is not a
 // release must say so. The notice used to be gated on the version
@@ -4,15 +4,12 @@
 package config
 import (
 	"bytes"
 	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"reflect"
 	"sort"
 	"strings"
 	"time"
 	"filippo.io/age"
 	"git.eeqj.de/sneak/smartconfig"
@@ -32,16 +29,13 @@ const appName = "vaultik"
 //nolint:gosec // G101: marker for detecting a pasted secret key, not a credential
 const secretKeyPrefix = "AGE-SECRET-KEY-"
-// Defaults and validation bounds for tunable settings. MB and GB are
+// Defaults and validation bounds for tunable settings.
 // 1000-based, as the size parser reads them; the S3 part sizes are S3's own
 // limits, which are 1024-based (MiB, GiB).
 const (
-	defaultBlobSizeLimit    = Size(10 * 1000 * 1000 * 1000) // 10GB
+	defaultBlobSizeLimit    = Size(10 * 1024 * 1024 * 1024) // 10GB
-	defaultChunkSize        = Size(10 * 1000 * 1000)        // 10MB
+	defaultChunkSize        = Size(10 * 1024 * 1024)        // 10MB
 	defaultS3PartSize       = Size(5 * 1024 * 1024)         // 5MiB
 	defaultCompressionLevel = 3
-	defaultPruneGracePeriod = 24 * time.Hour
+	minChunkSize            = 1024 * 1024 // 1MB
 	minChunkSize            = 1000 * 1000 // 1MB
 	minCompressionLevel     = 1
 	maxCompressionLevel     = 19
 	// S3 accepts a multipart upload part from 5MiB to 5GiB.
@@ -57,7 +51,7 @@ var (
 	errRecipientNotX25519 = errors.New(
 		"not a valid recipient; only X25519 age1... public keys are supported")
 	errNoSnapshots = errors.New(
-		"at least one snapshot must be configured (see configs/config.example.yml)")
+		"at least one snapshot must be configured (see config.example.yml)")
 	errSnapshotNoPaths   = errors.New("snapshot must have at least one path")
 	errChunkSizeTooSmall = errors.New("chunk_size must be at least 1MB")
 	errBlobSizeTooSmall  = errors.New(
@@ -70,22 +64,12 @@ var (
 	errFileURLNotAbsolute = errors.New(
 		"a file:// storage_url needs an absolute path, " +
 			"as in file:///path/to/backup")
 	errIndexPathNotAbsolute = errors.New(
 		"index_path and VAULTIK_INDEX_PATH need an absolute path, " +
 			"as in ~/.local/share/vaultik/index.sqlite")
 	errNegativePruneGracePeriod = errors.New(
 		"prune_grace_period must not be negative")
 	errStorageNotConfigured = errors.New(
 		"storage not configured; set storage_url or provide s3.endpoint + " +
 			"s3.bucket + credentials")
 	errS3BucketRequired = errors.New("s3.bucket is required (or set storage_url)")
-)
+	errS3KeyIDRequired  = errors.New("s3.access_key_id is required")
-
+	errS3SecretRequired = errors.New("s3.secret_access_key is required")
 // Validate returns these when S3 storage is configured without its
 // credentials.
 var (
 	ErrS3KeyIDRequired  = errors.New("s3.access_key_id is required")
 	ErrS3SecretRequired = errors.New("s3.secret_access_key is required")
 )
 // expandTilde expands ~ at the start of a path to the user's home directory.
@@ -200,15 +184,6 @@ type Config struct {
 	Snapshots        map[string]SnapshotConfig `yaml:"snapshots"`
 	CompressionLevel int                       `yaml:"compression_level"`
 	// PruneGracePeriod is how old a blob no manifest lists must be before
 	// a prune deletes it, and how old every object in a directory under
 	// metadata/ with no manifest must be before a prune deletes that
 	// directory. A backup writes its manifest only once it has uploaded
 	// all its blobs and its db.zst.age, so a younger blob or directory may
 	// belong to a backup still running, on this host or another sharing
 	// the destination store.
 	PruneGracePeriod time.Duration `yaml:"prune_grace_period"`
 	// StorageURL specifies the storage backend using a URL format.
 	// Takes precedence over S3Config if set.
 	// Supported formats:
@@ -258,83 +233,24 @@ func New(path Path) (*Config, error) {
 	return cfg, nil
 }
-// Load reads the configuration file at path, parses it with Parse, warns
+// Load reads and parses the configuration file from the specified path.
-// when others can read the file, and validates the configuration.
+// It applies default values for optional fields, performs environment variable
-// Returns an error if the file cannot be read, parsed, or if validation
+// substitution using smartconfig, and validates the configuration.
-// fails.
+// The configuration file should be in YAML format. Returns an error if the file
 // cannot be read, parsed, or if validation fails.
 func Load(path string) (*Config, error) {
 	data, err := os.ReadFile(path) //nolint:gosec // G304: config path is operator-supplied
 	if err != nil {
 		return nil, fmt.Errorf("failed to load config file: %w", err)
 	}
 	cfg, err := Parse(data)
 	if err != nil {
 		return nil, err
 	}
 	// Check config file permissions (warn if world or group readable)
 	//nolint:gosec // G703: config path is operator-supplied by design
 	info, statErr := os.Stat(path)
 	if statErr == nil {
 		mode := info.Mode().Perm()
 		if mode&0044 != 0 { // group or world readable
 			log.Warn(cfg.readableByOthersWarning(),
 				"path", path,
 				"mode", fmt.Sprintf("%04o", mode),
 				"recommendation", "chmod 600 "+path)
 		}
 	}
 	err = cfg.Validate()
 	if err != nil {
 		return nil, fmt.Errorf("invalid config: %w", err)
 	}
 	return cfg, nil
 }
 // Parse reads YAML config data as Load does, without validating it. It
 // refuses a key that no setting has and a size setting whose value is not a
 // size, naming the setting. It applies default values for optional
 // fields, fills in ${...} references using smartconfig, and expands ~ in
 // paths.
 func Parse(data []byte) (*Config, error) {
 	// smartconfig drops line numbers, so keys are checked in the data as
 	// written.
 	var root yaml.Node
 	err := yaml.Unmarshal(data, &root)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse config: %w", err)
 	}
 	err = checkKeys(&root, reflect.TypeFor[Config](), "",
 		map[*yaml.Node]bool{}, map[nodeAndType]bool{})
 	if err != nil {
 		return nil, err
 	}
 	// Load config using smartconfig for interpolation
-	sc, err := smartconfig.NewFromReader(bytes.NewReader(data))
+	sc, err := smartconfig.NewFromConfigPath(path)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load config file: %w", err)
 	}
 	// A ${...} reference can bring in keys that are not in the file, and
 	// is the value of a size setting only once it is filled in.
 	err = checkFilledConfig(sc.Data())
 	if err != nil {
 		return nil, err
 	}
 	cfg := &Config{
 		// Set defaults
 		BlobSizeLimit:    defaultBlobSizeLimit,
 		ChunkSize:        defaultChunkSize,
 		IndexPath:        filepath.Join(xdg.DataHome, appName, "index.sqlite"),
 		CompressionLevel: defaultCompressionLevel,
 		PruneGracePeriod: defaultPruneGracePeriod,
 		S3:               S3Config{PartSize: defaultS3PartSize},
 	}
@@ -386,6 +302,24 @@ func Parse(data []byte) (*Config, error) {
 		cfg.S3.Region = "us-east-1"
 	}
 	// Check config file permissions (warn if world or group readable)
 	//nolint:gosec // G703: config path is operator-supplied by design
 	info, statErr := os.Stat(path)
 	if statErr == nil {
 		mode := info.Mode().Perm()
 		if mode&0044 != 0 { // group or world readable
 			log.Warn(cfg.readableByOthersWarning(),
 				"path", path,
 				"mode", fmt.Sprintf("%04o", mode),
 				"recommendation", "chmod 600 "+path)
 		}
 	}
 	err = cfg.Validate()
 	if err != nil {
 		return nil, fmt.Errorf("invalid config: %w", err)
 	}
 	return cfg, nil
 }
@@ -397,15 +331,12 @@ func Parse(data []byte) (*Config, error) {
 //     create needs a recipient and it checks for one itself
 //   - At least one snapshot must be configured with at least one path
 //   - Storage must be configured (either storage_url or s3.* fields)
 //   - The index path must be absolute: a relative one would resolve against
 //     the working directory, so each directory would get its own index
 //   - Chunk size must be at least 1MB
 //   - Blob size limit must be at least the largest chunk the chunker can emit
 //     (chunk_size times chunker.ChunkSizeSpread), so a single-chunk blob never
 //     exceeds the configured limit
 //   - Compression level must be between 1 and 19
 //   - S3 part size must be between 5MiB and 5GiB, the part sizes S3 accepts
 //   - Prune grace period must not be negative
 //
 // Returns an error describing the first validation failure encountered.
 func (c *Config) Validate() error {
@@ -432,10 +363,6 @@ func (c *Config) Validate() error {
 		return err
 	}
 	if !filepath.IsAbs(c.IndexPath) {
 		return fmt.Errorf("%w: %q", errIndexPathNotAbsolute, c.IndexPath)
 	}
 	if c.ChunkSize.Int64() < minChunkSize {
 		return errChunkSizeTooSmall
 	}
@@ -459,10 +386,6 @@ func (c *Config) Validate() error {
 		return errBadS3PartSize
 	}
 	if c.PruneGracePeriod < 0 {
 		return errNegativePruneGracePeriod
 	}
 	return nil
 }
@@ -529,11 +452,11 @@ func (c *Config) validateStorage() error {
 	}
 	if c.S3.AccessKeyID == "" {
-		return ErrS3KeyIDRequired
+		return errS3KeyIDRequired
 	}
 	if c.S3.SecretAccessKey == "" {
-		return ErrS3SecretRequired
+		return errS3SecretRequired
 	}
 	return nil
@@ -560,11 +483,11 @@ func (c *Config) validateStorageURL() error {
 	case strings.HasPrefix(c.StorageURL, "s3://"):
 		// S3 storage needs credentials
 		if c.S3.AccessKeyID == "" {
-			return fmt.Errorf("%w for s3:// URLs", ErrS3KeyIDRequired)
+			return fmt.Errorf("%w for s3:// URLs", errS3KeyIDRequired)
 		}
 		if c.S3.SecretAccessKey == "" {
-			return fmt.Errorf("%w for s3:// URLs", ErrS3SecretRequired)
+			return fmt.Errorf("%w for s3:// URLs", errS3SecretRequired)
 		}
 		return nil
@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
 	"time"
 	"sneak.berlin/go/vaultik/internal/chunker"
 	"sneak.berlin/go/vaultik/internal/log"
@@ -90,12 +89,12 @@ func TestConfigLoad(t *testing.T) {
 }
 // TestExampleConfigIsScrubbedAndLoads checks that the shipped
-// configs/config.example.yml carries only neutral placeholders (no real
+// config.example.yml carries only neutral placeholders (no real credentials,
-// credentials, private addresses, or internal host names) and still parses.
+// private addresses, or internal host names) and still parses.
 func TestExampleConfigIsScrubbedAndLoads(t *testing.T) {
 	t.Parallel()
-	examplePath := filepath.Join("..", "..", "configs", "config.example.yml")
+	examplePath := filepath.Join("..", "..", "config.example.yml")
 	cfg, err := Load(examplePath)
 	if err != nil {
@@ -165,7 +164,6 @@ func TestValidateBlobSizeLimit(t *testing.T) {
 			AgeRecipients:    []string{testSneakAgePublicKey},
 			Snapshots:        map[string]SnapshotConfig{"test": {Paths: []string{"/tmp/src"}}},
 			StorageURL:       "file:///tmp/vaultik-test-store",
 			IndexPath:        "/tmp/vaultik-test-index.sqlite",
 			ChunkSize:        chunkSize,
 			BlobSizeLimit:    blobLimit,
 			CompressionLevel: 3,
@@ -339,149 +337,6 @@ func TestLoadS3PartSize(t *testing.T) {
 	})
 }
 // TestDocumentedSizeDefaults checks that the defaults are the documented
 // chunk_size 10MB and blob_size_limit 10GB as the parser reads those values
 // (1000-based), so writing a default out in the config file changes nothing.
 func TestDocumentedSizeDefaults(t *testing.T) {
 	t.Parallel()
 	cfg, err := Parse([]byte("chunk_size: 10MB\nblob_size_limit: 10GB\n"))
 	if err != nil {
 		t.Fatalf("Parse() unexpected error: %v", err)
 	}
 	if cfg.ChunkSize != defaultChunkSize {
 		t.Errorf("chunk_size: 10MB is %d bytes, the default is %d",
 			cfg.ChunkSize, defaultChunkSize)
 	}
 	if cfg.BlobSizeLimit != defaultBlobSizeLimit {
 		t.Errorf("blob_size_limit: 10GB is %d bytes, the default is %d",
 			cfg.BlobSizeLimit, defaultBlobSizeLimit)
 	}
 }
 // TestDocumentedSizeExamples checks the 1MB minimum chunk_size and that
 // every size the README, configs/config.example.yml and the config init template
 // list as an example is accepted.
 func TestDocumentedSizeExamples(t *testing.T) {
 	t.Parallel()
 	const withoutSizes = "snapshots:\n" +
 		"  test:\n" +
 		"    paths: [/tmp/vaultik-test-source]\n" +
 		"storage_url: file:///tmp/vaultik-test-storage\n"
 	tests := []struct {
 		setting string
 		wantErr error
 	}{
 		{"chunk_size: 1MB", nil},
 		{"chunk_size: 999999", errChunkSizeTooSmall},
 		{"chunk_size: 5M", nil},
 		{"chunk_size: 10M", nil},
 		{"chunk_size: 10MB", nil},
 		{"chunk_size: 64MiB", nil},
 		{"chunk_size: 1GB", nil},
 		// Four times the default chunk_size, the documented minimum.
 		{"blob_size_limit: 40MB", nil},
 		{"blob_size_limit: 500MB", nil},
 		{"blob_size_limit: 1GB", nil},
 		{"blob_size_limit: 1GiB", nil},
 		{"blob_size_limit: 10G", nil},
 		{"blob_size_limit: 10GB", nil},
 		{"s3: {part_size: 5MiB}", nil},
 		{"s3: {part_size: 10MB}", nil},
 		{"s3: {part_size: 16MiB}", nil},
 		{"s3: {part_size: 100MiB}", nil},
 		{"s3: {part_size: 5GiB}", nil},
 	}
 	for _, tt := range tests {
 		t.Run(tt.setting, func(t *testing.T) {
 			t.Parallel()
 			cfg, err := Parse([]byte(withoutSizes + tt.setting + "\n"))
 			if err != nil {
 				t.Fatalf("Parse() unexpected error: %v", err)
 			}
 			err = cfg.Validate()
 			if !errors.Is(err, tt.wantErr) {
 				t.Fatalf("Validate() error = %v, want %v", err, tt.wantErr)
 			}
 		})
 	}
 }
 // TestValidatePruneGracePeriod checks that a negative prune_grace_period
 // is refused rather than acting like 0s, which deletes unreferenced blobs
 // and directories under metadata/ with no manifest at once, and that 0s
 // and the documented examples are accepted.
 func TestValidatePruneGracePeriod(t *testing.T) {
 	t.Parallel()
 	const withoutGracePeriod = "snapshots:\n" +
 		"  test:\n" +
 		"    paths: [/tmp/vaultik-test-source]\n" +
 		"storage_url: file:///tmp/vaultik-test-storage\n"
 	tests := []struct {
 		setting string
 		wantErr error
 	}{
 		{"prune_grace_period: 0s", nil},
 		{"prune_grace_period: 90m", nil},
 		{"prune_grace_period: 36h", nil},
 		{"prune_grace_period: -1h", errNegativePruneGracePeriod},
 	}
 	for _, tt := range tests {
 		t.Run(tt.setting, func(t *testing.T) {
 			t.Parallel()
 			cfg, err := Parse([]byte(withoutGracePeriod + tt.setting + "\n"))
 			if err != nil {
 				t.Fatalf("Parse() unexpected error: %v", err)
 			}
 			err = cfg.Validate()
 			if !errors.Is(err, tt.wantErr) {
 				t.Fatalf("Validate() error = %v, want %v", err, tt.wantErr)
 			}
 		})
 	}
 }
 // TestLoadPruneGracePeriod checks that a config file without
 // prune_grace_period loads with the documented 24h. The value is written out
 // here rather than taken from defaultPruneGracePeriod, so that a change of the
 // default fails this test.
 func TestLoadPruneGracePeriod(t *testing.T) {
 	t.Parallel()
 	const withoutGracePeriod = "snapshots:\n" +
 		"  test:\n" +
 		"    paths: [/tmp/vaultik-test-source]\n" +
 		"storage_url: file:///tmp/vaultik-test-storage\n"
 	path := filepath.Join(t.TempDir(), "config.yml")
 	err := os.WriteFile(path, []byte(withoutGracePeriod), 0o600)
 	if err != nil {
 		t.Fatalf("write config: %v", err)
 	}
 	cfg, err := Load(path)
 	if err != nil {
 		t.Fatalf("Load() unexpected error: %v", err)
 	}
 	if cfg.PruneGracePeriod != 24*time.Hour {
 		t.Errorf("prune_grace_period = %s, want 24h", cfg.PruneGracePeriod)
 	}
 }
 // TestLoadRejectsRelativeFileURL checks that a file:// storage_url with a
 // relative path fails at load. Accepted, it would resolve against the
 // working directory, so a backup run from another directory would write
@@ -511,65 +366,6 @@ func TestLoadRejectsRelativeFileURL(t *testing.T) {
 	}
 }
 // TestLoadIndexPath checks that a relative index_path fails at load, naming
 // the value. Accepted, it would resolve against the working directory, so a
 // backup run from another directory would start from an empty index. A path
 // starting with ~ is expanded and loads.
 func TestLoadIndexPath(t *testing.T) {
 	t.Parallel()
 	home, err := os.UserHomeDir()
 	if err != nil {
 		t.Fatalf("home directory: %v", err)
 	}
 	load := func(t *testing.T, indexPath string) (*Config, error) {
 		t.Helper()
 		data := "snapshots:\n" +
 			"  test:\n" +
 			"    paths: [/tmp/vaultik-test-source]\n" +
 			"storage_url: file:///tmp/vaultik-test-storage\n" +
 			"index_path: " + indexPath + "\n"
 		path := filepath.Join(t.TempDir(), "config.yml")
 		err := os.WriteFile(path, []byte(data), 0o600)
 		if err != nil {
 			t.Fatalf("write config: %v", err)
 		}
 		return Load(path)
 	}
 	t.Run("relative path is rejected", func(t *testing.T) {
 		t.Parallel()
 		_, err := load(t, "relative/index.sqlite")
 		if !errors.Is(err, errIndexPathNotAbsolute) {
 			t.Fatalf("Load() error = %v, want errIndexPathNotAbsolute", err)
 		}
 		if !strings.Contains(err.Error(), `"relative/index.sqlite"`) {
 			t.Errorf("error %q does not name the value", err.Error())
 		}
 	})
 	t.Run("path starting with ~ is expanded", func(t *testing.T) {
 		t.Parallel()
 		cfg, err := load(t, "~/vaultik/index.sqlite")
 		if err != nil {
 			t.Fatalf("Load() unexpected error: %v", err)
 		}
 		want := filepath.Join(home, "vaultik", "index.sqlite")
 		if cfg.IndexPath != want {
 			t.Errorf("IndexPath = %q, want %q", cfg.IndexPath, want)
 		}
 	})
 }
 // TestValidateAgeRecipients checks that recipients are parsed at config load
 // (a bad entry fails immediately, not mid-backup) and that no invalid entry —
 // least of all a pasted secret key — is echoed in the error. An empty list
@@ -582,7 +378,6 @@ func TestValidateAgeRecipients(t *testing.T) {
 			AgeRecipients:    recipients,
 			Snapshots:        map[string]SnapshotConfig{"test": {Paths: []string{"/tmp/src"}}},
 			StorageURL:       "file:///tmp/vaultik-test-store",
 			IndexPath:        "/tmp/vaultik-test-index.sqlite",
 			ChunkSize:        Size(10 * 1024 * 1024),
 			BlobSizeLimit:    Size(10 * 1024 * 1024 * 1024),
 			CompressionLevel: 3,
@@ -1,220 +0,0 @@
 package config
 import (
 	"errors"
 	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
 	"gopkg.in/yaml.v3"
 )
 // yamlMergeTag is the tag YAML gives a merge key (<<), which adds the keys
 // of the map it names to the map it sits in.
 const yamlMergeTag = "!!merge"
 // EnvSection is the top-level key of a map of environment variables that
 // smartconfig sets while it loads the config. It is not a vaultik setting,
 // so its keys are not checked.
 const EnvSection = "env"
 var (
 	errUnknownKey           = errors.New("unknown config key")
 	errAnchorContainsItself = errors.New("anchor contains itself")
 )
 // nodeAndType is a node of a parsed config and the setting type it is
 // checked against.
 type nodeAndType struct {
 	node *yaml.Node
 	typ  reflect.Type
 }
 // SettingType returns the type of the setting that the dotted key names in
 // Config, following the fields' yaml tags, as for s3.bucket or
 // snapshots.home.exclude.0. A snapshot name or a list index may be any
 // word. It returns an unknown key error when no setting has that key.
 func SettingType(keys []string) (reflect.Type, error) {
 	typ := reflect.TypeFor[Config]()
 	for _, key := range keys {
 		switch {
 		case typ.Kind() == reflect.Map || typ.Kind() == reflect.Slice:
 			typ = typ.Elem()
 		case typ.Kind() == reflect.Struct:
 			field, ok := yamlField(typ, key)
 			if !ok {
 				return nil, fmt.Errorf("%w %q", errUnknownKey, strings.Join(keys, "."))
 			}
 			typ = field.Type
 		default:
 			return nil, fmt.Errorf("%w %q", errUnknownKey, strings.Join(keys, "."))
 		}
 	}
 	return typ, nil
 }
 // yamlField returns the field of struct type typ whose yaml tag names key.
 func yamlField(typ reflect.Type, key string) (reflect.StructField, bool) {
 	for field := range typ.Fields() {
 		name, _, _ := strings.Cut(field.Tag.Get("yaml"), ",")
 		if name == key && name != "-" {
 			return field, true
 		}
 	}
 	return reflect.StructField{}, false
 }
 // checkKeys returns an error naming the first key in node, a parsed config
 // or part of one at the dotted path, that no setting in typ has. The error
 // gives the key's line in the file, when it has one. A value of the wrong
 // type is left for the YAML decoder to report. following holds the aliases
 // the walk is inside. Meeting one of them again means its anchor contains
 // itself, which is an error. checked holds each anchored node the walk has
 // checked completely, with the type it was checked against. An alias to
 // that node is not followed again for that type.
 func checkKeys(node *yaml.Node, typ reflect.Type, path string,
 	following map[*yaml.Node]bool, checked map[nodeAndType]bool,
 ) error {
 	switch node.Kind {
 	case yaml.DocumentNode:
 		for _, child := range node.Content {
 			err := checkKeys(child, typ, path, following, checked)
 			if err != nil {
 				return err
 			}
 		}
 	case yaml.AliasNode:
 		if following[node] {
 			return fmt.Errorf("%w: %q on line %d",
 				errAnchorContainsItself, node.Value, node.Line)
 		}
 		target := nodeAndType{node.Alias, typ}
 		if checked[target] {
 			return nil
 		}
 		following[node] = true
 		defer delete(following, node)
 		err := checkKeys(node.Alias, typ, path, following, checked)
 		if err != nil {
 			return err
 		}
 		checked[target] = true
 	case yaml.SequenceNode:
 		if typ.Kind() != reflect.Slice {
 			return nil
 		}
 		for i, child := range node.Content {
 			err := checkKeys(child, typ.Elem(), joinKey(path, strconv.Itoa(i)),
 				following, checked)
 			if err != nil {
 				return err
 			}
 		}
 	case yaml.MappingNode:
 		return checkMappingKeys(node, typ, path, following, checked)
 	case yaml.ScalarNode:
 		// A scalar has no keys.
 	}
 	return nil
 }
 // checkFilledConfig checks data, the config after smartconfig has filled in
 // its ${...} references: its keys with checkKeys, then its size settings
 // with checkSizes. A key that a reference brings in is not in the file, and
 // the copy that Encode makes has no line numbers.
 func checkFilledConfig(data map[string]any) error {
 	var filled yaml.Node
 	err := filled.Encode(data)
 	if err != nil {
 		return fmt.Errorf("failed to marshal config data: %w", err)
 	}
 	err = checkKeys(&filled, reflect.TypeFor[Config](), "",
 		map[*yaml.Node]bool{}, map[nodeAndType]bool{})
 	if err != nil {
 		return err
 	}
 	return checkSizes(&filled, nil)
 }
 // checkMappingKeys is checkKeys for a map.
 func checkMappingKeys(node *yaml.Node, typ reflect.Type, path string,
 	following map[*yaml.Node]bool, checked map[nodeAndType]bool,
 ) error {
 	for i := 0; i+1 < len(node.Content); i += 2 {
 		key, value := node.Content[i], node.Content[i+1]
 		if key.Tag == yamlMergeTag {
 			// The value is one map or a list of maps.
 			merged := []*yaml.Node{value}
 			if value.Kind == yaml.SequenceNode {
 				merged = value.Content
 			}
 			for _, m := range merged {
 				err := checkKeys(m, typ, path, following, checked)
 				if err != nil {
 					return err
 				}
 			}
 			continue
 		}
 		keyPath := joinKey(path, key.Value)
 		if keyPath == EnvSection {
 			continue
 		}
 		var valueType reflect.Type
 		switch {
 		case typ.Kind() == reflect.Map:
 			valueType = typ.Elem()
 		case typ.Kind() == reflect.Struct:
 			field, ok := yamlField(typ, key.Value)
 			if !ok && key.Line == 0 {
 				// A key that a ${...} reference brought in has no line.
 				return fmt.Errorf("%w %q", errUnknownKey, keyPath)
 			}
 			if !ok {
 				return fmt.Errorf("%w %q on line %d",
 					errUnknownKey, keyPath, key.Line)
 			}
 			valueType = field.Type
 		default:
 			return nil
 		}
 		err := checkKeys(value, valueType, keyPath, following, checked)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 // joinKey appends key to the dotted path.
 func joinKey(path, key string) string {
 	if path == "" {
 		return key
 	}
 	return path + "." + key
 }
@@ -1,163 +0,0 @@
 package config //nolint:testpackage // checks the unexported errUnknownKey
 import (
 	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"slices"
 	"strconv"
 	"strings"
 	"testing"
 )
 // keysTestConfig loads; each case below adds one line to it.
 const keysTestConfig = "storage_url: file:///tmp/vaultik-test-storage\n" +
 	"s3:\n" +
 	"  region: us-east-1\n" +
 	"snapshots:\n" +
 	"  test:\n" +
 	"    paths: [/tmp/vaultik-test-source]\n"
 // TestParseRefusesUnknownKey checks that a key no setting has, at any
 // depth, fails the parse with an error naming the key and its line. A key
 // that a ${...} reference brings in is not in the file, so its error gives
 // no line.
 func TestParseRefusesUnknownKey(t *testing.T) {
 	t.Parallel()
 	snapshotPath := filepath.Join(t.TempDir(), "snapshot.yml")
 	err := os.WriteFile(snapshotPath, []byte("other:\n"+
 		"  paths: [/tmp/vaultik-test-source]\n"+
 		"  exlude: [/tmp/cache]\n"), 0o600)
 	if err != nil {
 		t.Fatalf("write snapshot: %v", err)
 	}
 	tests := []struct {
 		name string
 		yaml string
 		want string
 	}{
 		{"top level", keysTestConfig + "compression_lvl: 9\n",
 			`unknown config key "compression_lvl" on line 7`},
 		{"in a snapshot", keysTestConfig + "    exlude: [/tmp/cache]\n",
 			`unknown config key "snapshots.test.exlude" on line 7`},
 		{"in s3", strings.Replace(keysTestConfig, "  region:",
 			"  bukcet: b\n  region:", 1),
 			`unknown config key "s3.bukcet" on line 3`},
 		{"from a reference",
 			keysTestConfig + "  other: ${YAML:" + snapshotPath + ":other}\n",
 			`unknown config key "snapshots.other.exlude"`},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			_, err := Parse([]byte(tt.yaml))
 			if !errors.Is(err, errUnknownKey) {
 				t.Fatalf("Parse() error = %v, want errUnknownKey", err)
 			}
 			if err.Error() != tt.want {
 				t.Errorf("Parse() error = %q, want %q", err.Error(), tt.want)
 			}
 		})
 	}
 }
 // TestParseRefusesAnchorThatContainsItself checks that a YAML merge key (<<)
 // naming the anchor of the map it sits in fails the parse with an error.
 func TestParseRefusesAnchorThatContainsItself(t *testing.T) {
 	t.Parallel()
 	data := strings.Replace(keysTestConfig, "  test:", "  test: &test", 1) +
 		"    <<: *test\n"
 	_, err := Parse([]byte(data))
 	if !errors.Is(err, errAnchorContainsItself) {
 		t.Fatalf("Parse() error = %v, want errAnchorContainsItself", err)
 	}
 	want := `anchor contains itself: "test" on line 7`
 	if err.Error() != want {
 		t.Errorf("Parse() error = %q, want %q", err.Error(), want)
 	}
 }
 // TestParseRefusesExcessiveAliasing checks that Parse returns an error for
 // a file whose merge keys (<<) fan out. Each of eight snapshots merges the
 // one before it ten times. A key check that followed every alias would walk
 // the first snapshot over 10^8 times and run past the package's test
 // timeout.
 func TestParseRefusesExcessiveAliasing(t *testing.T) {
 	t.Parallel()
 	const snapshots, merges = 8, 10
 	var data strings.Builder
 	data.WriteString(strings.Replace(keysTestConfig, "  test:", "  test: &s0", 1))
 	for i := 1; i <= snapshots; i++ {
 		aliases := slices.Repeat([]string{"*s" + strconv.Itoa(i-1)}, merges)
 		fmt.Fprintf(&data, "  s%d: &s%d\n    <<: [%s]\n",
 			i, i, strings.Join(aliases, ", "))
 	}
 	_, err := Parse([]byte(data.String()))
 	if err == nil {
 		t.Fatal("Parse() returned no error")
 	}
 }
 // TestParseAcceptsKnownKeys checks that a config with a ${...} reference
 // and a YAML merge key (<<) still parses.
 func TestParseAcceptsKnownKeys(t *testing.T) {
 	t.Parallel()
 	levelPath := filepath.Join(t.TempDir(), "level")
 	err := os.WriteFile(levelPath, []byte("9"), 0o600)
 	if err != nil {
 		t.Fatalf("write level: %v", err)
 	}
 	data := strings.Replace(keysTestConfig, "  test:", "  test: &test", 1) +
 		"  other:\n" +
 		"    <<: *test\n" +
 		"    exclude: [/tmp/vaultik-test-source/cache]\n" +
 		"compression_level: ${FILE:" + levelPath + "}\n"
 	cfg, err := Parse([]byte(data))
 	if err != nil {
 		t.Fatalf("Parse() unexpected error: %v", err)
 	}
 	if cfg.CompressionLevel != 9 {
 		t.Errorf("compression_level = %d, want 9", cfg.CompressionLevel)
 	}
 	other := cfg.Snapshots["other"]
 	if len(other.Paths) != 1 || len(other.Exclude) != 1 {
 		t.Errorf("snapshot other = %+v, want the paths of test and one exclude",
 			other)
 	}
 }
 // TestParseAcceptsEnvSection checks that a config with a top-level env
 // section still parses. smartconfig sets the environment variables it
 // lists, so its keys are not settings.
 func TestParseAcceptsEnvSection(t *testing.T) {
 	const name = "VAULTIK_TEST_ENV_SECTION"
 	// Parse sets the variable; t.Setenv restores it after the test.
 	t.Setenv(name, "")
 	_, err := Parse([]byte(keysTestConfig + "env:\n  " + name + ": set\n"))
 	if err != nil {
 		t.Fatalf("Parse() unexpected error: %v", err)
 	}
 }
@@ -4,20 +4,13 @@ import (
 	"errors"
 	"fmt"
 	"math"
 	"reflect"
 	"slices"
 	"strconv"
 	"strings"
 	"github.com/dustin/go-humanize"
 	"gopkg.in/yaml.v3"
 )
 var (
 	errSizeType     = errors.New("size must be a number or string")
 	errSizeTooLarge = errors.New("size exceeds maximum supported value")
 	errNotASize     = errors.New(
 		"is not a size; use a number of bytes or a unit such as 10MB")
 )
 // Size represents a byte size that can be specified in configuration files.
@@ -39,15 +32,6 @@ func (s *Size) UnmarshalYAML(unmarshal func(any) error) error {
 		return nil
 	}
 	// A number too large for an int64 decodes as a float64. Its text can be
 	// 1e+20, which is not a size string.
 	var floatVal float64
 	err = unmarshal(&floatVal)
 	if err == nil && floatVal > math.MaxInt64 {
 		return errSizeTooLarge
 	}
 	// Try to unmarshal as string
 	var strVal string
@@ -56,66 +40,17 @@ func (s *Size) UnmarshalYAML(unmarshal func(any) error) error {
 		return errSizeType
 	}
-	size, err := ParseSize(strVal)
+	// Parse the string using go-humanize
 	bytes, err := humanize.ParseBytes(strVal)
 	if err != nil {
-		return err
+		return fmt.Errorf("invalid size format: %w", err)
 	}
-	*s = size
+	if bytes > math.MaxInt64 {
-
+		return fmt.Errorf("%w: %s", errSizeTooLarge, strVal)
 	return nil
 }
 // checkSizes returns an error naming the first size setting in node whose
 // value is not a size. node is the config, or the part of it at the dotted
 // keys, after smartconfig has filled in its ${...} references.
 func checkSizes(node *yaml.Node, keys []string) error {
 	typ, err := SettingType(keys)
 	if err != nil {
 		// Unknown keys are refused before this check, so keys is in one of
 		// two places. The env section holds no settings. A value of the
 		// wrong shape, such as a map given for hostname or inside exclude,
 		// is reported later by the YAML decoder.
 		return nil //nolint:nilerr // not an error here
 	}
-	if typ == reflect.TypeFor[Size]() {
+	*s = Size(bytes)
 		var size Size
 		err = node.Decode(&size)
 		if err != nil {
 			return fmt.Errorf("%s: %w", strings.Join(keys, "."), err)
 		}
 		return nil
 	}
 	switch node.Kind {
 	case yaml.DocumentNode:
 		for _, child := range node.Content {
 			err = checkSizes(child, keys)
 			if err != nil {
 				return err
 			}
 		}
 	case yaml.MappingNode:
 		for i := 0; i+1 < len(node.Content); i += 2 {
 			err = checkSizes(node.Content[i+1],
 				slices.Concat(keys, []string{node.Content[i].Value}))
 			if err != nil {
 				return err
 			}
 		}
 	case yaml.SequenceNode:
 		for i, child := range node.Content {
 			err = checkSizes(child, slices.Concat(keys, []string{strconv.Itoa(i)}))
 			if err != nil {
 				return err
 			}
 		}
 	case yaml.ScalarNode, yaml.AliasNode:
 		// A scalar holds no settings, and the filled config has no aliases.
 	}
 	return nil
 }
@@ -135,17 +70,16 @@ func (s Size) String() string {
 	return humanize.Bytes(uint64(s))
 }
-// ParseSize parses a size string, such as "10MB", into a Size value. An
+// ParseSize parses a size string into a Size value
 // error quotes s.
 func ParseSize(s string) (Size, error) {
-	bytes, err := humanize.ParseBigBytes(s)
+	bytes, err := humanize.ParseBytes(s)
 	if err != nil {
-		return 0, fmt.Errorf("%q %w", s, errNotASize)
+		return 0, fmt.Errorf("invalid size format: %w", err)
 	}
-	if !bytes.IsInt64() {
+	if bytes > math.MaxInt64 {
 		return 0, fmt.Errorf("%w: %s", errSizeTooLarge, s)
 	}
-	return Size(bytes.Int64()), nil
+	return Size(bytes), nil
 }
@@ -1,120 +0,0 @@
 package config //nolint:testpackage // checks errNotASize and errSizeTooLarge
 import (
 	"errors"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 )
 // TestParseRefusesValueThatIsNotASize checks that a size setting whose
 // value is not a size fails the parse with an error naming the setting and
 // quoting the value, also when a ${...} reference fills the value in.
 func TestParseRefusesValueThatIsNotASize(t *testing.T) {
 	t.Parallel()
 	sizePath := filepath.Join(t.TempDir(), "size")
 	err := os.WriteFile(sizePath, []byte("lots"), 0o600)
 	if err != nil {
 		t.Fatalf("write size: %v", err)
 	}
 	tests := []struct {
 		name string
 		yaml string
 		want string
 	}{
 		{"chunk_size", keysTestConfig + "chunk_size: banana\n",
 			`chunk_size: "banana" is not a size; ` +
 				"use a number of bytes or a unit such as 10MB"},
 		{"blob_size_limit", keysTestConfig + "blob_size_limit: 10XB\n",
 			`blob_size_limit: "10XB" is not a size; ` +
 				"use a number of bytes or a unit such as 10MB"},
 		{"s3.part_size", strings.Replace(keysTestConfig, "  region:",
 			"  part_size: big\n  region:", 1),
 			`s3.part_size: "big" is not a size; ` +
 				"use a number of bytes or a unit such as 10MB"},
 		{"from a reference",
 			keysTestConfig + "chunk_size: ${FILE:" + sizePath + "}\n",
 			`chunk_size: "lots" is not a size; ` +
 				"use a number of bytes or a unit such as 10MB"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			_, err := Parse([]byte(tt.yaml))
 			if !errors.Is(err, errNotASize) {
 				t.Fatalf("Parse() error = %v, want errNotASize", err)
 			}
 			if err.Error() != tt.want {
 				t.Errorf("Parse() error = %q, want %q", err.Error(), tt.want)
 			}
 		})
 	}
 }
 // TestParseRefusesSizeTooLarge checks that a size setting whose value is
 // too large for a size fails the parse with an error naming the setting.
 // YAML reads the second value as a float.
 func TestParseRefusesSizeTooLarge(t *testing.T) {
 	t.Parallel()
 	tests := []struct {
 		value string
 		want  string
 	}{
 		{"100EB", "chunk_size: size exceeds maximum supported value: 100EB"},
 		{"99999999999999999999",
 			"chunk_size: size exceeds maximum supported value"},
 	}
 	for _, tt := range tests {
 		t.Run(tt.value, func(t *testing.T) {
 			t.Parallel()
 			_, err := Parse([]byte(keysTestConfig + "chunk_size: " + tt.value + "\n"))
 			if !errors.Is(err, errSizeTooLarge) {
 				t.Fatalf("Parse() error = %v, want errSizeTooLarge", err)
 			}
 			if err.Error() != tt.want {
 				t.Errorf("Parse() error = %q, want %q", err.Error(), tt.want)
 			}
 		})
 	}
 }
 // TestParseAcceptsSizes checks that size settings given as a number of
 // bytes, as a unit, and through a ${...} reference still parse.
 func TestParseAcceptsSizes(t *testing.T) {
 	t.Parallel()
 	sizePath := filepath.Join(t.TempDir(), "size")
 	err := os.WriteFile(sizePath, []byte("20MB"), 0o600)
 	if err != nil {
 		t.Fatalf("write size: %v", err)
 	}
 	data := strings.Replace(keysTestConfig, "  region:",
 		"  part_size: 6000000\n  region:", 1) +
 		"chunk_size: ${FILE:" + sizePath + "}\n" +
 		"blob_size_limit: 1GB\n"
 	cfg, err := Parse([]byte(data))
 	if err != nil {
 		t.Fatalf("Parse() unexpected error: %v", err)
 	}
 	if cfg.ChunkSize != 20_000_000 || cfg.BlobSizeLimit != 1_000_000_000 ||
 		cfg.S3.PartSize != 6_000_000 {
 		t.Errorf("chunk_size, blob_size_limit, s3.part_size = %d, %d, %d, "+
 			"want 20000000, 1000000000, 6000000",
 			cfg.ChunkSize, cfg.BlobSizeLimit, cfg.S3.PartSize)
 	}
 }
@@ -58,7 +58,12 @@ func (r *BlobChunkRepository) GetByBlobID(
 		return nil, fmt.Errorf("querying blob chunks: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	var blobChunks []*BlobChunk
@@ -83,7 +83,12 @@ func (r *BlobRepository) GetAll(ctx context.Context) (map[string]*Blob, error) {
 		return nil, fmt.Errorf("querying blobs: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	out := make(map[string]*Blob)
@@ -154,16 +159,13 @@ func (r *BlobRepository) UpdateFinished(
 	return nil
 }
-// UpdateUploaded marks a blob as uploaded and records the size of the
+// UpdateUploaded marks a blob as uploaded
 // stored object as its compressed size. That size can differ from the
 // local copy's when an identical blob was already stored with another
 // compression level or other recipients.
 func (r *BlobRepository) UpdateUploaded(
-	ctx context.Context, tx *sql.Tx, id string, storedSize int64,
+	ctx context.Context, tx *sql.Tx, id string,
 ) error {
 	query := `
 		UPDATE blobs 
-		SET uploaded_ts = ?, compressed_size = ?
+		SET uploaded_ts = ?
 		WHERE id = ?
 	`
@@ -171,9 +173,9 @@ func (r *BlobRepository) UpdateUploaded(
 	var err error
 	if tx != nil {
-		_, err = tx.ExecContext(ctx, query, now, storedSize, id)
+		_, err = tx.ExecContext(ctx, query, now, id)
 	} else {
-		_, err = r.db.ExecWithLog(ctx, query, now, storedSize, id)
+		_, err = r.db.ExecWithLog(ctx, query, now, id)
 	}
 	if err != nil {
@@ -122,8 +122,8 @@ func TestBlobRepositoryUpdates(t *testing.T) {
 		t.Errorf("expected compressed size 500, got %d", updated.CompressedSize)
 	}
-	// Test UpdateUploaded, with a stored object larger than the local copy
+	// Test UpdateUploaded
-	err = repo.UpdateUploaded(ctx, nil, blob.ID.String(), 600)
+	err = repo.UpdateUploaded(ctx, nil, blob.ID.String())
 	if err != nil {
 		t.Fatalf("failed to update blob as uploaded: %v", err)
 	}
@@ -141,10 +141,6 @@ func TestBlobRepositoryUpdates(t *testing.T) {
 	if uploaded.UploadedTS.Before(now.Add(-1 * time.Second)) {
 		t.Error("uploaded timestamp should be around test time")
 	}
 	if uploaded.CompressedSize != 600 {
 		t.Errorf("expected the stored size 600, got %d", uploaded.CompressedSize)
 	}
 }
 func TestBlobRepositoryDuplicate(t *testing.T) {
@@ -61,7 +61,12 @@ func (r *ChunkFileRepository) GetByChunkHash(
 		return nil, fmt.Errorf("querying chunk files: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	return r.scanChunkFiles(rows)
 }
@@ -82,7 +87,12 @@ func (r *ChunkFileRepository) GetByFilePath(
 		return nil, fmt.Errorf("querying chunk files: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	return r.scanChunkFiles(rows)
 }
@@ -102,7 +112,12 @@ func (r *ChunkFileRepository) GetByFileID(
 		return nil, fmt.Errorf("querying chunk files: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	return r.scanChunkFiles(rows)
 }
@@ -107,7 +107,12 @@ func (r *ChunkRepository) GetByHashes(
 		return nil, fmt.Errorf("querying chunks: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	var chunks []*Chunk
@@ -147,7 +152,12 @@ func (r *ChunkRepository) ListUnpacked(
 		return nil, fmt.Errorf("querying unpacked chunks: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	var chunks []*Chunk
@@ -38,7 +38,12 @@ func (r *ChunkRepository) list(ctx context.Context, query string) ([]*Chunk, err
 		return nil, fmt.Errorf("querying chunks: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	var chunks []*Chunk
@@ -0,0 +1,12 @@
 package database
 import (
 	"fmt"
 	"os"
 )
 // Fatalf prints an error message to stderr and exits with status 1
 func Fatalf(format string, args ...any) {
 	fmt.Fprintf(os.Stderr, "FATAL: "+format+"\n", args...)
 	os.Exit(1)
 }
@@ -62,7 +62,12 @@ func (r *FileChunkRepository) GetByPath(
 		return nil, fmt.Errorf("querying file chunks: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	return r.scanFileChunks(rows)
 }
@@ -83,7 +88,12 @@ func (r *FileChunkRepository) GetByFileID(
 		return nil, fmt.Errorf("querying file chunks: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	return r.scanFileChunks(rows)
 }
@@ -107,7 +117,12 @@ func (r *FileChunkRepository) GetByPathTx(
 		return nil, fmt.Errorf("querying file chunks: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	fileChunks, err := r.scanFileChunks(rows)
 	LogSQL("GetByPathTx", "Complete", path, "count", len(fileChunks))
@@ -175,7 +175,12 @@ func (r *FileRepository) ListModifiedSince(
 		return nil, fmt.Errorf("querying files: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	var files []*File
@@ -251,46 +256,12 @@ func (r *FileRepository) ListUnderPath(
 		return nil, fmt.Errorf("querying files: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
-
+		err := rows.Close()
 	var files []*File
 	for rows.Next() {
 		file, err := r.scanFileRows(rows)
 		if err != nil {
-			return nil, fmt.Errorf("scanning file: %w", err)
+			Fatalf("failed to close rows: %v", err)
 		}
-
+	}()
 		files = append(files, file)
 	}
 	return files, rows.Err()
 }
 // ListUnderPathInSnapshot returns the files that ListUnderPath returns
 // for path and that the snapshot lists, in no particular order.
 func (r *FileRepository) ListUnderPathInSnapshot(
 	ctx context.Context, path, snapshotID string,
 ) ([]*File, error) {
 	path = strings.TrimRight(path, "/")
 	dirPrefix := path + "/"
 	query := `
 		SELECT f.id, f.path, f.source_path, f.mtime, f.mtime_nsec, f.size,
 			f.mode, f.uid, f.gid, f.link_target
 		FROM files f
 		JOIN snapshot_files sf ON sf.file_id = f.id
 		WHERE sf.snapshot_id = ?
 		  AND (f.path = ? OR substr(f.path, 1, length(?)) = ?)
 	`
 	rows, err := r.db.conn.QueryContext(ctx, query,
 		snapshotID, path, dirPrefix, dirPrefix)
 	if err != nil {
 		return nil, fmt.Errorf("querying files: %w", err)
 	}
 	defer func() { _ = rows.Close() }()
 	var files []*File
@@ -333,7 +304,12 @@ func (r *FileRepository) ListIDsWithChunksNotInUploadedBlobs(
 		return nil, fmt.Errorf("querying files: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	var ids []types.FileID
@@ -364,7 +340,12 @@ func (r *FileRepository) ListAll(ctx context.Context) ([]*File, error) {
 		return nil, fmt.Errorf("querying files: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	var files []*File
@@ -212,65 +212,6 @@ func TestFileRepositoryListUnderPath(t *testing.T) {
 	}
 }
 // ListUnderPathInSnapshot leaves out files outside path and files the
 // snapshot does not list, though another snapshot lists them.
 func TestFileRepositoryListUnderPathInSnapshot(t *testing.T) {
 	t.Parallel()
 	db, cleanup := setupTestDB(t)
 	defer cleanup()
 	ctx := context.Background()
 	files := database.NewFileRepository(db)
 	snapshots := database.NewSnapshotRepository(db)
 	listed := map[string][]string{
 		"one": {"/src/a.txt", "/src2/c.txt"},
 		"two": {"/src/b.txt"},
 	}
 	for snapshotID, paths := range listed {
 		err := snapshots.Create(ctx, nil, &database.Snapshot{
 			ID:        types.SnapshotID(snapshotID),
 			Hostname:  "host",
 			StartedAt: time.Now(),
 		})
 		if err != nil {
 			t.Fatalf("failed to create snapshot %s: %v", snapshotID, err)
 		}
 		for _, path := range paths {
 			err := files.Create(ctx, nil, &database.File{
 				Path:  types.FilePath(path),
 				MTime: time.Now().Truncate(time.Second),
 				Mode:  0644,
 			})
 			if err != nil {
 				t.Fatalf("failed to create %s: %v", path, err)
 			}
 			err = snapshots.AddFile(ctx, nil, snapshotID, path)
 			if err != nil {
 				t.Fatalf("failed to add %s to %s: %v", path, snapshotID, err)
 			}
 		}
 	}
 	found, err := files.ListUnderPathInSnapshot(ctx, "/src", "one")
 	if err != nil {
 		t.Fatalf("failed to list files: %v", err)
 	}
 	got := make([]string, 0, len(found))
 	for _, f := range found {
 		got = append(got, f.Path.String())
 	}
 	if !slices.Equal(got, []string{"/src/a.txt"}) {
 		t.Errorf("got %q, want only /src/a.txt", got)
 	}
 }
 func TestFileRepositorySymlink(t *testing.T) {
 	t.Parallel()
@@ -20,17 +20,6 @@ const indexDirPerm = 0o700
 // backed-up path and chunk hash and must stay private.
 const indexFilePerm = 0o600
 // IndexFiles returns the path of the index at indexPath and the paths of
 // the side files SQLite keeps beside it while it writes.
 func IndexFiles(indexPath string) []string {
 	return []string{
 		indexPath,
 		indexPath + "-wal",
 		indexPath + "-shm",
 		indexPath + "-journal",
 	}
 }
 // ensureIndexFileMode makes the index file owner-only before the SQLite
 // driver opens it: it creates the file 0600 if absent, or chmods an existing
 // one to 0600. Doing this first matters because SQLite creates its -wal and
@@ -3,7 +3,6 @@ package database
 import (
 	"context"
 	"database/sql"
 	"errors"
 	"fmt"
 )
@@ -61,24 +60,22 @@ func (r *Repositories) WithTx(ctx context.Context, fn TxFunc) error {
 	defer func() {
 		if p := recover(); p != nil {
-			// The panic is the failure to report, so a rollback error
+			rollbackErr := tx.Rollback()
-			// is dropped.
+			if rollbackErr != nil {
-			_ = tx.Rollback()
+				Fatalf("failed to rollback transaction: %v", rollbackErr)
 			}
 			panic(p)
 		} else if err != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
 				Fatalf("failed to rollback transaction: %v", rollbackErr)
 			}
 		}
 	}()
 	err = fn(ctx, tx)
 	if err != nil {
 		// Once ctx is cancelled, database/sql rolls the transaction
 		// back itself and Rollback returns sql.ErrTxDone.
 		rollbackErr := tx.Rollback()
 		if rollbackErr != nil && !errors.Is(rollbackErr, sql.ErrTxDone) {
 			return fmt.Errorf("%w; rolling back transaction: %w",
 				err, rollbackErr)
 		}
 		return err
 	}
@@ -106,24 +103,22 @@ func (r *Repositories) WithReadTx(ctx context.Context, fn TxFunc) error {
 	defer func() {
 		if p := recover(); p != nil {
-			// The panic is the failure to report, so a rollback error
+			rollbackErr := tx.Rollback()
-			// is dropped.
+			if rollbackErr != nil {
-			_ = tx.Rollback()
+				Fatalf("failed to rollback transaction: %v", rollbackErr)
 			}
 			panic(p)
 		} else if err != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
 				Fatalf("failed to rollback transaction: %v", rollbackErr)
 			}
 		}
 	}()
 	err = fn(ctx, tx)
 	if err != nil {
 		// Once ctx is cancelled, database/sql rolls the transaction
 		// back itself and Rollback returns sql.ErrTxDone.
 		rollbackErr := tx.Rollback()
 		if rollbackErr != nil && !errors.Is(rollbackErr, sql.ErrTxDone) {
 			return fmt.Errorf("%w; rolling back transaction: %w",
 				err, rollbackErr)
 		}
 		return err
 	}
@@ -4,7 +4,6 @@ import (
 	"context"
 	"database/sql"
 	"errors"
 	"strings"
 	"testing"
 	"time"
@@ -236,125 +235,6 @@ func TestRepositoriesTransactionRollback(t *testing.T) {
 	}
 }
 // When the context is cancelled during the body, database/sql rolls the
 // transaction back itself, so WithTx's own rollback finds it already
 // done. WithTx must return the body's error alone, without that rollback.
 func TestRepositoriesTransactionContextCancelled(t *testing.T) {
 	t.Parallel()
 	db, cleanup := setupTestDB(t)
 	defer cleanup()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	repos := database.NewRepositories(db)
 	err := repos.WithTx(ctx, func(ctx context.Context, tx *sql.Tx) error {
 		file := &database.File{
 			Path:  "/test/cancelled_file.txt",
 			MTime: time.Now().Truncate(time.Second),
 			Size:  1024,
 			Mode:  0644,
 			UID:   1000,
 			GID:   1000,
 		}
 		err := repos.Files.Create(ctx, tx, file)
 		if err != nil {
 			return err
 		}
 		cancel()
 		// database/sql rolls back from a goroutine of its own; wait
 		// until it has, so the test does not depend on that race.
 		for {
 			_, err = tx.ExecContext(context.WithoutCancel(ctx), "SELECT 1")
 			if errors.Is(err, sql.ErrTxDone) {
 				return ctx.Err()
 			}
 			time.Sleep(time.Millisecond)
 		}
 	})
 	if !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected context.Canceled, got: %v", err)
 	}
 	if errors.Is(err, sql.ErrTxDone) {
 		t.Fatalf("the already-done rollback was reported: %v", err)
 	}
 	file, err := repos.Files.GetByPath(
 		context.Background(), "/test/cancelled_file.txt",
 	)
 	if err != nil {
 		t.Fatalf("error checking for file: %v", err)
 	}
 	if file != nil {
 		t.Error("file should not exist after the cancelled transaction")
 	}
 }
 // A body that ends the transaction itself with ROLLBACK makes WithTx's
 // own rollback fail. WithTx must return that failure together with the
 // body's error.
 func TestRepositoriesTransactionRollbackFails(t *testing.T) {
 	t.Parallel()
 	db, cleanup := setupTestDB(t)
 	defer cleanup()
 	ctx := context.Background()
 	repos := database.NewRepositories(db)
 	err := repos.WithTx(ctx, func(ctx context.Context, tx *sql.Tx) error {
 		_, err := tx.ExecContext(ctx, "ROLLBACK")
 		if err != nil {
 			return err
 		}
 		return errIntentionalRollback
 	})
 	if !errors.Is(err, errIntentionalRollback) {
 		t.Fatalf("expected the body's error, got: %v", err)
 	}
 	if !strings.Contains(err.Error(), "rolling back transaction") {
 		t.Errorf("expected the failed rollback in the error, got: %v", err)
 	}
 }
 // When the body ends the transaction itself with ROLLBACK and then
 // panics, WithTx's own rollback fails; the panic must still reach the
 // caller.
 func TestRepositoriesTransactionPanicRollbackFails(t *testing.T) {
 	t.Parallel()
 	db, cleanup := setupTestDB(t)
 	defer cleanup()
 	ctx := context.Background()
 	repos := database.NewRepositories(db)
 	defer func() {
 		if recover() == nil {
 			t.Error("expected the body's panic to reach the caller")
 		}
 	}()
 	_ = repos.WithTx(ctx, func(ctx context.Context, tx *sql.Tx) error {
 		_, err := tx.ExecContext(ctx, "ROLLBACK")
 		if err != nil {
 			return err
 		}
 		panic(errIntentionalRollback)
 	})
 }
 func TestRepositoriesReadTransaction(t *testing.T) {
 	t.Parallel()
@@ -411,41 +291,3 @@ func TestRepositoriesReadTransaction(t *testing.T) {
 		t.Error("expected to retrieve file in read transaction")
 	}
 }
 // When the context is cancelled during a read transaction's body,
 // database/sql rolls the transaction back itself, so WithReadTx's own
 // rollback finds it already done. WithReadTx must return the body's error
 // alone, without that rollback.
 func TestRepositoriesReadTransactionContextCancelled(t *testing.T) {
 	t.Parallel()
 	db, cleanup := setupTestDB(t)
 	defer cleanup()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	repos := database.NewRepositories(db)
 	err := repos.WithReadTx(ctx, func(ctx context.Context, tx *sql.Tx) error {
 		cancel()
 		// database/sql rolls back from a goroutine of its own; wait
 		// until it has, so the test does not depend on that race.
 		for {
 			_, err := tx.ExecContext(context.WithoutCancel(ctx), "SELECT 1")
 			if errors.Is(err, sql.ErrTxDone) {
 				return ctx.Err()
 			}
 			time.Sleep(time.Millisecond)
 		}
 	})
 	if !errors.Is(err, context.Canceled) {
 		t.Fatalf("expected context.Canceled, got: %v", err)
 	}
 	if errors.Is(err, sql.ErrTxDone) {
 		t.Fatalf("the already-done rollback was reported: %v", err)
 	}
 }
@@ -86,10 +86,8 @@ CREATE TABLE IF NOT EXISTS snapshots (
    completed_at INTEGER,
    file_count INTEGER NOT NULL DEFAULT 0,
    chunk_count INTEGER NOT NULL DEFAULT 0,
    new_chunk_size INTEGER NOT NULL DEFAULT 0,
    blob_count INTEGER NOT NULL DEFAULT 0,
    total_size INTEGER NOT NULL DEFAULT 0,
    uncompressed_chunk_size INTEGER NOT NULL DEFAULT 0,
    blob_size INTEGER NOT NULL DEFAULT 0,
    blob_uncompressed_size INTEGER NOT NULL DEFAULT 0,
    compression_ratio REAL NOT NULL DEFAULT 1.0,
@@ -123,16 +121,6 @@ CREATE TABLE IF NOT EXISTS snapshot_blobs (
 -- Index for efficient blob lookups (used in orphan detection)
 CREATE INDEX IF NOT EXISTS idx_snapshot_blobs_blob_id ON snapshot_blobs(blob_id);
 -- Snapshot mount points table: the directories at or below a configured
 -- path that the snapshot's backup found on a different filesystem from
 -- their parent directory, as a mount point is, and found an entry in
 CREATE TABLE IF NOT EXISTS snapshot_mount_points (
    snapshot_id TEXT NOT NULL,
    path TEXT NOT NULL,
    PRIMARY KEY (snapshot_id, path),
    FOREIGN KEY (snapshot_id) REFERENCES snapshots(id) ON DELETE CASCADE
 );
 -- Uploads table: tracks blob upload metrics
 CREATE TABLE IF NOT EXISTS uploads (
    blob_hash TEXT PRIMARY KEY,
@@ -24,8 +24,7 @@ var (
 )
 // SnapshotRepository provides access to the snapshots table and its
-// snapshot_files / snapshot_blobs association tables, and to the mount
+// snapshot_files / snapshot_blobs association tables.
 // points each snapshot's backup found (snapshot_mount_points).
 type SnapshotRepository struct {
 	db *DB
 }
@@ -121,11 +120,7 @@ func (r *SnapshotRepository) UpdateCounts(
 	return nil
 }
-// UpdateExtendedStats updates extended statistics for a snapshot. It also
+// UpdateExtendedStats updates extended statistics for a snapshot
 // records the total plaintext size of the distinct chunks the snapshot's
 // files reference. Only the snapshot's own backup can take that total: a
 // file's row is shared by every snapshot that lists it, and a later
 // backup of a changed file rewrites the row with the new chunks.
 func (r *SnapshotRepository) UpdateExtendedStats(
 	ctx context.Context,
 	tx *sql.Tx,
@@ -134,7 +129,6 @@ func (r *SnapshotRepository) UpdateExtendedStats(
 	compressionLevel int,
 	uploadBytes int64,
 	uploadDurationMs int64,
 	newChunkSize int64,
 ) error {
 	compressionRatio, err := r.extendedCompressionRatio(
 		ctx, tx, snapshotID, blobUncompressedSize,
@@ -149,29 +143,18 @@ func (r *SnapshotRepository) UpdateExtendedStats(
 		    compression_ratio = ?,
 		    compression_level = ?,
 		    upload_bytes = ?,
-		    upload_duration_ms = ?,
+		    upload_duration_ms = ?
 		    new_chunk_size = ?,
 		    uncompressed_chunk_size = (
 		        SELECT COALESCE(SUM(c.size), 0)
 		        FROM (
 		            SELECT DISTINCT fc.chunk_hash
 		            FROM snapshot_files sf
 		            JOIN file_chunks fc ON sf.file_id = fc.file_id
 		            WHERE sf.snapshot_id = snapshots.id
 		        ) sc
 		        JOIN chunks c ON sc.chunk_hash = c.chunk_hash
 		    )
 		WHERE id = ?
 	`
 	if tx != nil {
 		_, err = tx.ExecContext(ctx, query,
 			blobUncompressedSize, compressionRatio, compressionLevel,
-			uploadBytes, uploadDurationMs, newChunkSize, snapshotID)
+			uploadBytes, uploadDurationMs, snapshotID)
 	} else {
 		_, err = r.db.ExecWithLog(ctx, query,
 			blobUncompressedSize, compressionRatio, compressionLevel,
-			uploadBytes, uploadDurationMs, newChunkSize, snapshotID)
+			uploadBytes, uploadDurationMs, snapshotID)
 	}
 	if err != nil {
@@ -256,7 +239,12 @@ func (r *SnapshotRepository) GetOnlySnapshot(ctx context.Context) (*Snapshot, er
 		return nil, fmt.Errorf("querying snapshots: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	snapshots, err := r.scanSnapshotRows(rows)
 	if err != nil {
@@ -291,7 +279,12 @@ func (r *SnapshotRepository) ListRecent(
 		return nil, fmt.Errorf("querying snapshots: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	return r.scanSnapshotRows(rows)
 }
@@ -501,57 +494,32 @@ func (r *SnapshotRepository) GetBlobHashes(
 		ORDER BY sb.blob_hash
 	`
-	blobs, err := r.queryStrings(ctx, query, snapshotID)
+	rows, err := r.db.conn.QueryContext(ctx, query, snapshotID)
 	if err != nil {
 		return nil, fmt.Errorf("querying blob hashes: %w", err)
 	}
-	return blobs, nil
+	defer func() {
-}
+		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
-// AddMountPoint records dir as a directory that the backup of a snapshot
+	var blobs []string
 // found on a different filesystem from its parent directory, as a mount
 // point is, using tx when non-nil.
 func (r *SnapshotRepository) AddMountPoint(
 	ctx context.Context, tx *sql.Tx, snapshotID string, dir string,
 ) error {
 	query := `
 		INSERT OR IGNORE INTO snapshot_mount_points (snapshot_id, path)
 		VALUES (?, ?)
 	`
-	var err error
+	for rows.Next() {
-	if tx != nil {
+		var blobHash string
-		_, err = tx.ExecContext(ctx, query, snapshotID, dir)
+
-	} else {
+		err := rows.Scan(&blobHash)
-		_, err = r.db.ExecWithLog(ctx, query, snapshotID, dir)
+		if err != nil {
 			return nil, fmt.Errorf("scanning blob hash: %w", err)
 		}
 		blobs = append(blobs, blobHash)
 	}
-	if err != nil {
+	return blobs, rows.Err()
 		return fmt.Errorf("adding mount point to snapshot: %w", err)
 	}
 	return nil
 }
 // GetMountPoints returns the directories AddMountPoint recorded for a
 // snapshot, sorted.
 func (r *SnapshotRepository) GetMountPoints(
 	ctx context.Context, snapshotID string,
 ) ([]string, error) {
 	query := `
 		SELECT path
 		FROM snapshot_mount_points
 		WHERE snapshot_id = ?
 		ORDER BY path
 	`
 	dirs, err := r.queryStrings(ctx, query, snapshotID)
 	if err != nil {
 		return nil, fmt.Errorf("querying mount points: %w", err)
 	}
 	return dirs, nil
 }
 // GetSnapshotTotalCompressedSize returns the total compressed size of all
@@ -600,42 +568,71 @@ func (r *SnapshotRepository) GetSnapshotBlobSizes(
 	return compressed, uncompressed, nil
 }
-// GetSnapshotUncompressedChunkSize returns the total plaintext size of the
+// GetSnapshotUncompressedChunkSize returns the sum of plaintext sizes of all unique
-// distinct chunks the snapshot's files reference, as the snapshot's backup
+// chunks referenced by a snapshot (via snapshot_files → file_chunks → chunks).
 // recorded it (see UpdateExtendedStats).
 func (r *SnapshotRepository) GetSnapshotUncompressedChunkSize(
 	ctx context.Context, snapshotID string,
 ) (int64, error) {
-	query := `SELECT uncompressed_chunk_size FROM snapshots WHERE id = ?`
+	query := `
 		SELECT COALESCE(SUM(c.size), 0)
 		FROM (
 			SELECT DISTINCT fc.chunk_hash
 			FROM snapshot_files sf
 			JOIN file_chunks fc ON sf.file_id = fc.file_id
 			WHERE sf.snapshot_id = ?
 		) sc
 		JOIN chunks c ON sc.chunk_hash = c.chunk_hash
 	`
-	var uncompressedChunkSize int64
+	var totalSize int64
-	err := r.db.conn.QueryRowContext(ctx, query, snapshotID).Scan(&uncompressedChunkSize)
+	err := r.db.conn.QueryRowContext(ctx, query, snapshotID).Scan(&totalSize)
 	if err != nil {
 		return 0, fmt.Errorf("querying uncompressed chunk size: %w", err)
 	}
-	return uncompressedChunkSize, nil
+	return totalSize, nil
 }
-// GetSnapshotNewChunkSize returns the total plaintext size of the chunks the
+// GetSnapshotNewChunkSize returns the sum of plaintext sizes of chunks that are
-// snapshot's backup stored that were not stored before, as the backup
+// referenced by this snapshot but not by any earlier completed snapshot known to
-// recorded it. It is not derived from the snapshot's files: a file's row is
+// the local database. The result is the marginal uncompressed data this snapshot
-// shared by every snapshot that lists it and is rewritten when the file
+// added to the dedup pool — i.e., the delta from prior snapshots.
 // changes, so it shows only the file's latest chunks.
 func (r *SnapshotRepository) GetSnapshotNewChunkSize(
 	ctx context.Context, snapshotID string,
 ) (int64, error) {
-	query := `SELECT new_chunk_size FROM snapshots WHERE id = ?`
+	query := `
 		WITH this_snap_chunks AS (
 			SELECT DISTINCT fc.chunk_hash
 			FROM snapshot_files sf
 			JOIN file_chunks fc ON sf.file_id = fc.file_id
 			WHERE sf.snapshot_id = ?
 		),
 		prior_chunks AS (
 			SELECT DISTINCT fc.chunk_hash
 			FROM snapshots s
 			JOIN snapshot_files sf ON sf.snapshot_id = s.id
 			JOIN file_chunks fc ON fc.file_id = sf.file_id
 			WHERE s.completed_at IS NOT NULL
 			  AND s.id != ?
 			  AND s.started_at < (SELECT started_at FROM snapshots WHERE id = ?)
 		)
 		SELECT COALESCE(SUM(c.size), 0)
 		FROM chunks c
 		JOIN this_snap_chunks t ON c.chunk_hash = t.chunk_hash
 		WHERE c.chunk_hash NOT IN (SELECT chunk_hash FROM prior_chunks)
 	`
-	var newChunkSize int64
+	var totalSize int64
-	err := r.db.conn.QueryRowContext(ctx, query, snapshotID).Scan(&newChunkSize)
+	err := r.db.conn.QueryRowContext(
 		ctx, query, snapshotID, snapshotID, snapshotID,
 	).Scan(&totalSize)
 	if err != nil {
 		return 0, fmt.Errorf("querying new chunk size: %w", err)
 	}
-	return newChunkSize, nil
+	return totalSize, nil
 }
 // GetIncompleteSnapshots returns all snapshots that haven't been completed
@@ -656,7 +653,12 @@ func (r *SnapshotRepository) GetIncompleteSnapshots(
 		return nil, fmt.Errorf("querying incomplete snapshots: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	return r.scanSnapshotRows(rows)
 }
@@ -679,7 +681,12 @@ func (r *SnapshotRepository) GetIncompleteByHostname(
 		return nil, fmt.Errorf("querying incomplete snapshots: %w", err)
 	}
-	defer func() { _ = rows.Close() }()
+	defer func() {
 		err := rows.Close()
 		if err != nil {
 			Fatalf("failed to close rows: %v", err)
 		}
 	}()
 	// Same column set as every other multi-row snapshot query, so the
 	// shared scanner applies — including its timestamp normalization.
@@ -740,34 +747,6 @@ func (r *SnapshotRepository) DeleteSnapshotUploads(
 	return nil
 }
 // queryStrings runs query, which selects one text column, and returns
 // its values in the order of the rows.
 func (r *SnapshotRepository) queryStrings(
 	ctx context.Context, query string, args ...any,
 ) ([]string, error) {
 	rows, err := r.db.conn.QueryContext(ctx, query, args...)
 	if err != nil {
 		return nil, err
 	}
 	defer func() { _ = rows.Close() }()
 	var values []string
 	for rows.Next() {
 		var value string
 		err := rows.Scan(&value)
 		if err != nil {
 			return nil, err
 		}
 		values = append(values, value)
 	}
 	return values, rows.Err()
 }
 // extendedCompressionRatio computes the compression ratio for a snapshot
 // from its stored blob_size and the given uncompressed size. Returns 1.0
 // when the uncompressed size is zero.
@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"math"
 	"slices"
 	"testing"
 	"time"
@@ -423,52 +422,3 @@ func TestSnapshotRepositoryDuplicate(t *testing.T) {
 		t.Error("expected error for duplicate snapshot")
 	}
 }
 // Deleting a snapshot from the local index deletes the mount points its
 // backup recorded, and no other snapshot's. See
 // https://git.eeqj.de/sneak/vaultik/issues/395.
 func TestSnapshotRepositoryDeleteRemovesMountPoints(t *testing.T) {
 	t.Parallel()
 	db, cleanup := setupTestDB(t)
 	defer cleanup()
 	ctx := context.Background()
 	repo := database.NewSnapshotRepository(db)
 	for _, id := range []types.SnapshotID{"kept", "deleted"} {
 		err := repo.Create(ctx, nil, &database.Snapshot{
 			ID:             id,
 			Hostname:       testHostname,
 			VaultikVersion: testVersion,
 			StartedAt:      time.Now().Truncate(time.Second),
 		})
 		if err != nil {
 			t.Fatalf("failed to create snapshot: %v", err)
 		}
 		err = repo.AddMountPoint(ctx, nil, id.String(), "/data/nas")
 		if err != nil {
 			t.Fatalf("failed to add mount point: %v", err)
 		}
 	}
 	err := repo.Delete(ctx, "deleted")
 	if err != nil {
 		t.Fatalf("failed to delete snapshot: %v", err)
 	}
 	for id, want := range map[string][]string{
 		"kept":    {"/data/nas"},
 		"deleted": nil,
 	} {
 		got, err := repo.GetMountPoints(ctx, id)
 		if err != nil {
 			t.Fatalf("failed to read mount points: %v", err)
 		}
 		if !slices.Equal(got, want) {
 			t.Errorf("mount points of %s: got %v, want %v", id, got, want)
 		}
 	}
 }
@@ -1,24 +1,19 @@
 // Package globals holds application-wide metadata (name, version,
-// commit) that is populated at build time via linker flags, or from the
+// commit) that is populated at build time via linker flags.
 // build info Go records in the binary when the linker flags set none.
 package globals
 import (
 	"regexp"
 	"runtime/debug"
 	"strings"
 	"time"
 	"golang.org/x/mod/module"
 )
 // Appname is the application name, populated from main().
 var Appname = "vaultik" //nolint:gochecknoglobals // set via -ldflags at build time
 // DevVersion is the version a binary reports when it was built without
-// git metadata: script/version emits it outside a git checkout, and a
+// git metadata: script/version emits it outside a git checkout, and an
-// binary keeps it when neither its linker flags nor its Go build info
+// unstamped `go build` keeps it. goreleaser's snapshot template stamps
 // name a version. goreleaser's snapshot template stamps
 // it followed by "-" and the commit it was built from. It is
 // deliberately not a number.
 const DevVersion = "dev"
@@ -37,54 +32,6 @@ var Commit = Unknown //nolint:gochecknoglobals // set via -ldflags at build time
 // CommitDate is the ISO-8601 date of the commit, populated from main().
 var CommitDate = Unknown //nolint:gochecknoglobals // set via -ldflags at build time
 // develVersion is the main module version Go records when it cannot
 // tell which version it built.
 const develVersion = "(devel)"
 // FillUnsetFromBuildInfo applies FillUnset to Version, Commit and
 // CommitDate, with the build info of the running binary.
 func FillUnsetFromBuildInfo() {
 	info, ok := debug.ReadBuildInfo()
 	if !ok {
 		return
 	}
 	Version, Commit, CommitDate = FillUnset(
 		info, Version, Commit, CommitDate)
 }
 // FillUnset returns version, commit and commitDate. Each one that
 // still holds its default ("dev" or empty for the version, "unknown"
 // for the others) is replaced by the value Go recorded in info. A
 // `go install` of a tag sets no linker flags, but Go records the tag
 // as the main module's version. Go records the commit and its time
 // only when it builds from a git checkout. The time is cut to a date,
 // as the Makefile stamps it.
 func FillUnset(
 	info *debug.BuildInfo, version, commit, commitDate string,
 ) (string, string, string) {
 	if (version == "" || version == DevVersion) &&
 		info.Main.Version != "" && info.Main.Version != develVersion {
 		version = info.Main.Version
 	}
 	for _, s := range info.Settings {
 		switch s.Key {
 		case "vcs.revision":
 			if commit == Unknown {
 				commit = s.Value
 			}
 		case "vcs.time":
 			t, err := time.Parse(time.RFC3339, s.Value)
 			if commitDate == Unknown && err == nil {
 				commitDate = t.UTC().Format(time.DateOnly)
 			}
 		}
 	}
 	return version, commit, commitDate
 }
 // Author identifies the upstream author of vaultik.
 const Author = "Jeffrey Paul <sneak@sneak.berlin>"
@@ -121,10 +68,8 @@ func New() (*Globals, error) {
 // a release. "dev" and goreleaser's snapshot "dev-<sha>" count, and so
 // does what `git describe --tags --always --dirty` gives a make or
 // docker build of an untagged commit: the bare short commit, or
-// tag-N-gHASH on a commit after a tag. A Go pseudo-version counts: Go
+// tag-N-gHASH on a commit after a tag. Any version ending in "-dirty"
-// records one for a build of an untagged commit without linker flags.
+// counts, a modified checkout of a tag ("v1.0.0-dirty") included.
 // Any version ending in "-dirty" or "+dirty" counts, a modified
 // checkout of a tag ("v1.0.0-dirty", "v1.0.0+dirty") included.
 // A plain tag such as "v1.0.0" or "1.0.0" is a release.
 //
 // The empty string counts too. Nothing that knows its version reports
@@ -137,8 +82,7 @@ func New() (*Globals, error) {
 func IsDevVersion(v string) bool {
 	if v == "" || v == Unknown || v == DevVersion ||
 		strings.HasPrefix(v, DevVersion+"-") ||
-		strings.HasSuffix(v, "-dirty") || strings.HasSuffix(v, "+dirty") ||
+		strings.HasSuffix(v, "-dirty") {
 		module.IsPseudoVersion(v) {
 		return true
 	}
@@ -1,7 +1,6 @@
 package globals_test
 import (
 	"runtime/debug"
 	"testing"
 	"sneak.berlin/go/vaultik/internal/globals"
@@ -60,20 +59,12 @@ func TestIsDevVersion(t *testing.T) {
 		{"1.0.0-rc.1-12-g877eb2f", true},
 		// A tagged commit with uncommitted changes is not that tag.
 		{"v1.0.0-dirty", true},
 		// What Go records for a build without linker flags: a
 		// pseudo-version for an untagged commit, "+dirty" for a
 		// modified checkout.
 		{"v1.0.0-rc3.0.20261111001226-abcdefabcdef", true},
 		{"v0.0.0-20261111001226-abcdefabcdef", true},
 		{"v1.0.1-0.20261111001226-abcdefabcdef", true},
 		{"v1.0.0+dirty", true},
 		// What a tagged build produces (goreleaser's .Version strips
 		// the leading "v"; script/version keeps it).
 		{"1.0.0", false},
 		{"0.1.0", false},
 		{"1.0.0-rc.1", false},
 		{"v1.0.0", false},
 		{"v1.0.0-rc3", false},
 		// A release must not be mistaken for a dev build just because
 		// the string happens to contain "dev".
 		{"1.0.0-dev", false},
@@ -95,9 +86,10 @@ func TestIsDevVersion(t *testing.T) {
 	}
 }
-// TestDefaultVersionIsDev pins the default: a binary whose linker flags
+// TestDefaultVersionIsDev pins the linker-flag contract: an unstamped
-// and build info name no version must report itself as a development
+// binary (no -ldflags at all, which is what `go build ./...` and `go
-// build rather than as some default release number.
+// install` produce) must report itself as a development build rather
 // than as some default release number.
 func TestDefaultVersionIsDev(t *testing.T) {
 	t.Parallel()
@@ -106,104 +98,3 @@ func TestDefaultVersionIsDev(t *testing.T) {
 			globals.DevVersion)
 	}
 }
 // buildInfo returns build info with the given main module version and,
 // when revision is not empty, the commit settings Go records for a
 // build from a git checkout.
 func buildInfo(version, revision string) *debug.BuildInfo {
 	info := &debug.BuildInfo{
 		Main: debug.Module{Path: "sneak.berlin/go/vaultik", Version: version},
 	}
 	if revision != "" {
 		info.Settings = []debug.BuildSetting{
 			{Key: "vcs.revision", Value: revision},
 			{Key: "vcs.time", Value: "2026-11-10T23:12:26Z"},
 		}
 	}
 	return info
 }
 // TestFillUnset covers a binary from `go install` of a tag, which
 // carries no linker flags: it must report the tag. Values the linker
 // flags set are kept.
 func TestFillUnset(t *testing.T) {
 	t.Parallel()
 	const (
 		tag = "v1.0.0-rc3"
 		rev = "0123456789abcdef0123456789abcdef01234567"
 	)
 	cases := []struct {
 		name                    string
 		info                    *debug.BuildInfo
 		version, commit, date   string
 		wantVersion, wantCommit string
 		wantDate                string
 	}{
 		{
 			name:        "go install of a tag",
 			info:        buildInfo(tag, ""),
 			version:     globals.DevVersion,
 			commit:      globals.Unknown,
 			date:        globals.Unknown,
 			wantVersion: tag,
 			wantCommit:  globals.Unknown,
 			wantDate:    globals.Unknown,
 		},
 		{
 			name:        "empty version",
 			info:        buildInfo(tag, ""),
 			version:     "",
 			commit:      globals.Unknown,
 			date:        globals.Unknown,
 			wantVersion: tag,
 			wantCommit:  globals.Unknown,
 			wantDate:    globals.Unknown,
 		},
 		{
 			name:        "go build in a git checkout",
 			info:        buildInfo(tag, rev),
 			version:     globals.DevVersion,
 			commit:      globals.Unknown,
 			date:        globals.Unknown,
 			wantVersion: tag,
 			wantCommit:  rev,
 			wantDate:    "2026-11-10",
 		},
 		{
 			name:        "Go could not tell the version",
 			info:        buildInfo("(devel)", ""),
 			version:     globals.DevVersion,
 			commit:      globals.Unknown,
 			date:        globals.Unknown,
 			wantVersion: globals.DevVersion,
 			wantCommit:  globals.Unknown,
 			wantDate:    globals.Unknown,
 		},
 		{
 			name:        "linker flags set",
 			info:        buildInfo(tag, rev),
 			version:     "v1.0.0-rc2-4-gabcdef1",
 			commit:      "abcdef1",
 			date:        "2026-11-01",
 			wantVersion: "v1.0.0-rc2-4-gabcdef1",
 			wantCommit:  "abcdef1",
 			wantDate:    "2026-11-01",
 		},
 	}
 	for _, tc := range cases {
 		version, commit, date := globals.FillUnset(
 			tc.info, tc.version, tc.commit, tc.date)
 		if version != tc.wantVersion || commit != tc.wantCommit ||
 			date != tc.wantDate {
 			t.Errorf("%s: got %q, %q, %q; want %q, %q, %q", tc.name,
 				version, commit, date,
 				tc.wantVersion, tc.wantCommit, tc.wantDate)
 		}
 	}
 }
@@ -10,8 +10,6 @@ import (
 	"sync"
 	"time"
 	"unicode"
 	"github.com/dustin/go-humanize"
 )
 // groupSeparator joins an open group path to an attribute key. This
@@ -306,13 +304,18 @@ func formatDuration(d time.Duration) string {
 	}
 }
-// formatBytes formats a byte count with humanize.Bytes, as every command
+// formatBytes formats bytes in a human-readable way
 // prints one. humanize.Bytes takes no negative count, so one is printed
 // as it is.
 func formatBytes(b int64) string {
-	if b < 0 {
+	const unit = 1024
 	if b < unit {
 		return fmt.Sprintf("%d B", b)
 	}
-	return humanize.Bytes(uint64(b))
+	div, exp := int64(unit), 0
 	for n := b / unit; n >= unit; n /= unit {
 		div *= unit
 		exp++
 	}
 	return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "KMGTPE"[exp])
 }
@@ -200,8 +200,7 @@ func TestTTYHandlerWithGroupQualifiesKeys(t *testing.T) {
 func TestTTYHandlerByteFormattingSurvivesGrouping(t *testing.T) {
 	t.Parallel()
-	// Printed as "1.0 MB", in powers of 1000 like every other byte count.
+	const oneAndAHalfKiB = 1536
 	const oneMegabyte = 1_000_000
 	for name, testCase := range map[string]struct {
 		derive func(*slog.Logger) *slog.Logger
@@ -224,13 +223,13 @@ func TestTTYHandlerByteFormattingSurvivesGrouping(t *testing.T) {
 			var buf bytes.Buffer
 			logger := slog.New(log.NewTTYHandler(&buf, debugHandlerOptions()))
-			testCase.derive(logger).Info("uploaded", "bytes", oneMegabyte)
+			testCase.derive(logger).Info("uploaded", "bytes", oneAndAHalfKiB)
 			line := ansiEscape.ReplaceAllString(buf.String(), "")
-			assert.Contains(t, line, testCase.key+"=1.0 MB",
+			assert.Contains(t, line, testCase.key+"=1.5 KB",
 				"a byte count must be human-readable however it is qualified")
-			assert.NotContains(t, line, strconv.Itoa(oneMegabyte),
+			assert.NotContains(t, line, strconv.Itoa(oneAndAHalfKiB),
 				"the raw number must not survive the formatting")
 		})
 	}
@@ -11,7 +11,6 @@ import (
 	"strconv"
 	"strings"
 	"github.com/adrg/xdg"
 	"golang.org/x/sys/unix"
 )
@@ -30,20 +29,8 @@ const (
 	lockDirPerm = 0o700
 	// pidFilePerm is the mode for the PID file (owner-only).
 	pidFilePerm = 0o600
 	// pidFileName is the name of the PID file in the lock directory.
 	pidFileName = "vaultik.pid"
 )
 // Dir returns the directory that holds vaultik's PID file.
 func Dir() string {
 	return filepath.Join(xdg.DataHome, "vaultik")
 }
 // Path returns the path of the PID file that Acquire uses in lockDir.
 func Path(lockDir string) string {
 	return filepath.Join(lockDir, pidFileName)
 }
 // Acquire attempts to acquire a PID lock in the specified directory.
 // If another process holds the lock, it returns ErrAlreadyRunning with
 // that process's PID. On success, it writes the current PID to the lock
@@ -55,7 +42,7 @@ func Acquire(lockDir string) (*Lock, error) {
 		return nil, fmt.Errorf("creating lock directory: %w", err)
 	}
-	lockPath := Path(lockDir)
+	lockPath := filepath.Join(lockDir, "vaultik.pid")
 	// No O_TRUNC: the file may hold the PID of the process that has the
 	// lock, which the error below reports.
@@ -8,7 +8,6 @@ import (
 	"io"
 	"strings"
 	"sync/atomic"
 	"time"
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/config"
@@ -19,13 +18,6 @@ import (
 	"github.com/aws/smithy-go/logging"
 )
 // ErrNoContinuationToken is returned by ListObjects and ListObjectsStream
 // when the server marks a page of a listing truncated but sends no
 // continuation token to fetch the rest with, as a server answering V2
 // listings V1-style does.
 var ErrNoContinuationToken = errors.New(
 	"server marked the listing truncated but sent no continuation token")
 // Client wraps the AWS S3 client for vaultik operations.
 // It provides a simplified interface for S3 operations with automatic
 // prefix handling and connection management. All operations are performed
@@ -222,7 +214,7 @@ func (c *Client) ListObjects(ctx context.Context, prefix string) ([]string, erro
 	})
 	for paginator.HasMorePages() {
-		page, err := nextListPage(ctx, paginator)
+		page, err := paginator.NextPage(ctx)
 		if err != nil {
 			return nil, err
 		}
@@ -243,26 +235,6 @@ func (c *Client) ListObjects(ctx context.Context, prefix string) ([]string, erro
 	return keys, nil
 }
 // nextListPage fetches the next page of a listing. The SDK paginator takes
 // a page marked truncated without a continuation token for the last page
 // and stops without an error, so such a page is ErrNoContinuationToken
 // here instead.
 func nextListPage(
 	ctx context.Context, paginator *s3.ListObjectsV2Paginator,
 ) (*s3.ListObjectsV2Output, error) {
 	page, err := paginator.NextPage(ctx)
 	if err != nil {
 		return nil, err
 	}
 	truncated := aws.ToBool(page.IsTruncated)
 	if truncated && aws.ToString(page.NextContinuationToken) == "" {
 		return nil, ErrNoContinuationToken
 	}
 	return page, nil
 }
 // HeadObject checks if an object exists in S3.
 // Returns true if the object exists, false otherwise.
 // The key is automatically prefixed with the configured prefix.
@@ -303,10 +275,7 @@ func IsNotFound(err error) bool {
 type ObjectInfo struct {
 	Key  string
 	Size int64
-	// ModTime is the object's LastModified time. Only ListObjectsStream
+	Err  error
 	// sets it.
 	ModTime time.Time
 	Err     error
 }
 // ListObjectsStream lists objects with the given prefix and returns a channel.
@@ -331,7 +300,7 @@ func (c *Client) ListObjectsStream(
 		})
 		for paginator.HasMorePages() {
-			page, err := nextListPage(ctx, paginator)
+			page, err := paginator.NextPage(ctx)
 			if err != nil {
 				ch <- ObjectInfo{Err: err}
@@ -347,9 +316,8 @@ func (c *Client) ListObjectsStream(
 					}
 					ch <- ObjectInfo{
-						Key:     key,
+						Key:  key,
-						Size:    *obj.Size,
+						Size: *obj.Size,
 						ModTime: aws.ToTime(obj.LastModified),
 					}
 				}
 			}
@@ -1,62 +0,0 @@
 //nolint:testpackage // exercises the unexported cleanupBlobTempFile
 package snapshot
 import (
 	"errors"
 	"os"
 	"testing"
 	"github.com/spf13/afero"
 	"sneak.berlin/go/vaultik/internal/blob"
 )
 // A blob temp file that cannot be closed or removed must make the cleanup
 // return an error, not end the process.
 func TestCleanupBlobTempFileReturnsErrors(t *testing.T) {
 	t.Parallel()
 	fs := afero.NewOsFs()
 	s := &Scanner{fs: fs}
 	tests := []struct {
 		name string
 		// prepare runs before the cleanup and makes its close or remove
 		// fail.
 		prepare func(tempFile afero.File) error
 		want    error
 	}{
 		{
 			name:    "close fails",
 			prepare: func(tempFile afero.File) error { return tempFile.Close() },
 			want:    os.ErrClosed,
 		},
 		{
 			name: "remove fails",
 			prepare: func(tempFile afero.File) error {
 				return fs.Remove(tempFile.Name())
 			},
 			want: os.ErrNotExist,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			tempFile, err := afero.TempFile(fs, t.TempDir(), "blob-*.tmp")
 			if err != nil {
 				t.Fatal(err)
 			}
 			err = tt.prepare(tempFile)
 			if err != nil {
 				t.Fatal(err)
 			}
 			err = s.cleanupBlobTempFile(&blob.WithReader{TempFile: tempFile})
 			if !errors.Is(err, tt.want) {
 				t.Fatalf("expected an error wrapping %v, got: %v", tt.want, err)
 			}
 		})
 	}
 }
@@ -1,40 +0,0 @@
 //nolint:testpackage // exercises the unexported deviceNumberFromStat
 package snapshot
 import (
 	"os"
 	"path/filepath"
 	"testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 // The device number a real backup reads is the same for a directory and
 // a file in it, and differs between the temp directory and /dev.
 // Without it no mount point is ever found. See
 // https://git.eeqj.de/sneak/vaultik/issues/395.
 func TestDeviceNumberFromStat(t *testing.T) {
 	t.Parallel()
 	dir := t.TempDir()
 	file := filepath.Join(dir, "file.txt")
 	require.NoError(t, os.WriteFile(file, nil, 0o600))
 	deviceOf := func(path string) uint64 {
 		t.Helper()
 		info, err := os.Stat(path)
 		require.NoError(t, err)
 		device, ok := deviceNumberFromStat(info)
 		require.True(t, ok, "no device number read for %s", path)
 		return device
 	}
 	assert.Equal(t, deviceOf(dir), deviceOf(file))
 	// /dev is a different filesystem from the temp dir on Linux, macOS and in Docker.
 	assert.NotEqual(t, deviceOf(dir), deviceOf("/dev"))
 }
@@ -578,54 +578,3 @@ func TestExcludePatterns_DoubleStarFileAtEveryDepth(t *testing.T) {
 	require.Equal(t, 1, result.FilesScanned,
 		"**/ file pattern should match at the top level and nested")
 }
 func TestExcludePatterns_AnchoredDoubleStarAtEveryDepth(t *testing.T) {
 	t.Parallel()
 	// As in gitignore, /**/ also matches directly under the source dir
 	fs := setupAnchoredTestFS(t)
 	scanner, repos, cleanup := createTestScanner(t, fs, []string{"/**/projectname"})
 	defer cleanup()
 	ctx := context.Background()
 	createSnapshotRecord(ctx, t, repos, "test-snapshot")
 	result, err := scanner.Scan(ctx, "/backup", "test-snapshot")
 	require.NoError(t, err)
 	// /**/projectname should exclude BOTH:
 	// - /backup/projectname/file.txt
 	// - /backup/otherproject/projectname/file.txt
 	// Total files: 4, excluded: 2
 	require.Equal(t, 2, result.FilesScanned,
 		"/**/ pattern should match at the top level and nested")
 }
 func TestExcludePatterns_DoubleStarInMiddleMatchesZeroDirectories(t *testing.T) {
 	t.Parallel()
 	// As in gitignore, a/**/b matches a/b as well as a/c/b. The last part
 	// is a glob: with a plain name the glob library already matched a/b.
 	fs := &afero.MemMapFs{}
 	files := []string{"/backup/a/x.log", "/backup/a/c/y.log", "/backup/a/c/kept.txt"}
 	for _, path := range files {
 		require.NoError(t, fs.MkdirAll(filepath.Dir(path), 0755))
 		require.NoError(t, afero.WriteFile(fs, path, []byte(path), 0644))
 	}
 	scanner, repos, cleanup := createTestScanner(t, fs, []string{"a/**/*.log"})
 	defer cleanup()
 	ctx := context.Background()
 	createSnapshotRecord(ctx, t, repos, "test-snapshot")
 	result, err := scanner.Scan(ctx, "/backup", "test-snapshot")
 	require.NoError(t, err)
 	// a/**/*.log should exclude /backup/a/x.log and /backup/a/c/y.log
 	// Total files: 3, excluded: 2
 	require.Equal(t, 1, result.FilesScanned,
 		"a/**/*.log should match a/x.log as well as a/c/y.log")
 }
@@ -1,65 +0,0 @@
 package snapshot_test
 import (
 	"context"
 	"testing"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/snapshot"
 )
 // A backup of the directory that holds vaultik's index and PID file
 // stores neither, with no exclude pattern set, and still stores the
 // files beside them. See https://git.eeqj.de/sneak/vaultik/issues/421.
 func TestScanSkipsIndexAndLockFiles(t *testing.T) {
 	t.Parallel()
 	const dataDir = "/home/user/.local/share/vaultik"
 	indexAndLockFiles := append(database.IndexFiles(dataDir+"/index.sqlite"),
 		dataDir+"/vaultik.pid")
 	fs := afero.NewMemMapFs()
 	for _, p := range append(indexAndLockFiles, dataDir+"/notes.txt") {
 		require.NoError(t, afero.WriteFile(fs, p, []byte("data"), 0o600))
 	}
 	db, err := database.NewTestDB()
 	require.NoError(t, err)
 	defer func() { _ = db.Close() }()
 	repos := database.NewRepositories(db)
 	scanner := snapshot.NewScanner(snapshot.ScannerConfig{
 		FS:               fs,
 		ChunkSize:        64 * 1024,
 		Repositories:     repos,
 		MaxBlobSize:      1024 * 1024,
 		CompressionLevel: 3,
 		AgeRecipients: []string{
 			"age1ql3z7hjy54pw3hyww5ayyfg7zqgvc7w3j2elw8zmrj2kg5sfn9aqmcac8p"},
 		IndexAndLockFiles: indexAndLockFiles,
 	})
 	require.NotNil(t, scanner)
 	ctx := context.Background()
 	createSnapshotRecord(ctx, t, repos, "test-snapshot")
 	result, err := scanner.Scan(ctx, "/home/user", "test-snapshot")
 	require.NoError(t, err)
 	require.Equal(t, 1, result.FilesScanned)
 	stored, err := repos.Files.GetByPath(ctx, dataDir+"/notes.txt")
 	require.NoError(t, err)
 	require.NotNil(t, stored, "a file beside the index is stored")
 	for _, p := range indexAndLockFiles {
 		f, err := repos.Files.GetByPath(ctx, p)
 		require.NoError(t, err)
 		require.Nil(t, f, "%s is not stored", p)
 	}
 }
@@ -1,14 +1,10 @@
 package snapshot
 import (
 	"os"
 	"path/filepath"
 	"github.com/spf13/afero"
 	"go.uber.org/fx"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/pidlock"
 	"sneak.berlin/go/vaultik/internal/storage"
 	"sneak.berlin/go/vaultik/internal/ui"
 )
@@ -20,12 +16,6 @@ type ScannerParams struct {
 	Fs             afero.Fs
 	Exclude        []string // Exclude patterns (combined global + snapshot-specific)
 	SkipErrors     bool     // Skip file read errors (log loudly but continue)
 	// PreviousSnapshotID is the most recent completed snapshot of the
 	// same name, "" for none.
 	PreviousSnapshotID string
 	// DeviceNumber is ScannerConfig.DeviceNumber; nil reads it from the
 	// file's stat.
 	DeviceNumber func(info os.FileInfo) (uint64, bool)
 }
 // Module exports backup functionality as an fx module.
@@ -54,62 +44,17 @@ func provideScannerFactory(
 		}
 		return NewScanner(ScannerConfig{
-			FS:                 params.Fs,
+			FS:               params.Fs,
-			ChunkSize:          cfg.ChunkSize.Int64(),
+			ChunkSize:        cfg.ChunkSize.Int64(),
-			Repositories:       repos,
+			Repositories:     repos,
-			Storage:            storer,
+			Storage:          storer,
-			MaxBlobSize:        cfg.BlobSizeLimit.Int64(),
+			MaxBlobSize:      cfg.BlobSizeLimit.Int64(),
-			CompressionLevel:   cfg.CompressionLevel,
+			CompressionLevel: cfg.CompressionLevel,
-			AgeRecipients:      cfg.AgeRecipients,
+			AgeRecipients:    cfg.AgeRecipients,
-			EnableProgress:     params.EnableProgress,
+			EnableProgress:   params.EnableProgress,
-			UI:                 params.UI,
+			UI:               params.UI,
-			Exclude:            excludes,
+			Exclude:          excludes,
-			IndexAndLockFiles:  indexAndLockFiles(cfg.IndexPath, pidlock.Dir()),
+			SkipErrors:       params.SkipErrors,
 			SkipErrors:         params.SkipErrors,
 			PreviousSnapshotID: params.PreviousSnapshotID,
 			DeviceNumber:       params.DeviceNumber,
 		})
 	}
 }
 // indexAndLockFiles returns the paths of the index at indexPath, its side
 // files and the PID file in lockDir. Symlinks in their directories are
 // resolved, as they are in the snapshot's source paths, so the scan finds
 // them under the same names. If indexPath is a symlink, the file it points
 // to and that file's side files are returned too.
 func indexAndLockFiles(indexPath, lockDir string) []string {
 	paths := append(database.IndexFiles(indexPath), pidlock.Path(lockDir))
 	for i, p := range paths {
 		paths[i] = resolveParentDir(p)
 	}
 	// SQLite writes the file a symlinked index points to and keeps the
 	// side files beside that file. The database package creates the index
 	// before the scanner is built, so the link resolves.
 	index := resolveParentDir(indexPath)
 	target, err := filepath.EvalSymlinks(index)
 	if err == nil && target != index {
 		paths = append(paths, database.IndexFiles(target)...)
 	}
 	return paths
 }
 // resolveParentDir returns the absolute form of path with the symlinks in
 // its parent directory resolved. If the parent directory cannot be
 // resolved, it returns the absolute form unresolved. If path has no
 // absolute form, it returns path.
 func resolveParentDir(path string) string {
 	abs, err := filepath.Abs(path)
 	if err != nil {
 		return path
 	}
 	dir, err := filepath.EvalSymlinks(filepath.Dir(abs))
 	if err != nil {
 		return abs
 	}
 	return filepath.Join(dir, filepath.Base(abs))
 }
@@ -1,32 +0,0 @@
 //nolint:testpackage // exercises the unexported indexAndLockFiles helper
 package snapshot
 import (
 	"os"
 	"path/filepath"
 	"testing"
 	"github.com/stretchr/testify/require"
 )
 // The scan walks source paths with symlinks resolved, so vaultik's own
 // files are named the same way, or a symlinked home would back them up.
 func TestIndexAndLockFilesResolvesSymlinkedDirectory(t *testing.T) {
 	t.Parallel()
 	realDir, err := filepath.EvalSymlinks(t.TempDir())
 	require.NoError(t, err)
 	link := filepath.Join(t.TempDir(), "link")
 	require.NoError(t, os.Symlink(realDir, link))
 	paths := indexAndLockFiles(filepath.Join(link, "index.sqlite"), link)
 	require.Equal(t, []string{
 		filepath.Join(realDir, "index.sqlite"),
 		filepath.Join(realDir, "index.sqlite-wal"),
 		filepath.Join(realDir, "index.sqlite-shm"),
 		filepath.Join(realDir, "index.sqlite-journal"),
 		filepath.Join(realDir, "vaultik.pid"),
 	}, paths)
 }
@@ -1,245 +0,0 @@
 package snapshot_test
 import (
 	"context"
 	"os"
 	"path/filepath"
 	"slices"
 	"strings"
 	"syscall"
 	"testing"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/snapshot"
 )
 // A scan records with the snapshot each directory on a different device
 // from its parent directory that the walk found an entry in, as a mount
 // point is, the scanned path included. A filesystem that gives no device
 // numbers, as the in-memory one, records none. See
 // https://git.eeqj.de/sneak/vaultik/issues/395.
 func TestScanRecordsMountPoints(t *testing.T) {
 	t.Parallel()
 	const (
 		scannedPath = "/data/source"
 		snapshotID  = "mount-points"
 	)
 	tests := []struct {
 		name string
 		// onVolume names the directories on the volume's device; every
 		// other directory is on another one. nil leaves the device
 		// numbers to the in-memory filesystem, which has none.
 		onVolume []string
 		want     []string
 	}{
 		{
 			name:     "volume below the scanned path",
 			onVolume: []string{"nas"},
 			want:     []string{scannedPath + "/nas"},
 		},
 		{
 			name:     "volume at the scanned path",
 			onVolume: []string{"source", "nas"},
 			want:     []string{scannedPath},
 		},
 		{name: "no device numbers", want: nil},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			ctx := context.Background()
 			fs := afero.NewMemMapFs()
 			for _, path := range []string{
 				scannedPath + "/notes.txt", scannedPath + "/nas/a.txt",
 			} {
 				require.NoError(t, fs.MkdirAll(filepath.Dir(path), 0o755))
 				require.NoError(t, afero.WriteFile(fs, path, []byte(path), 0o644))
 			}
 			db, err := database.NewTestDB()
 			require.NoError(t, err)
 			t.Cleanup(func() { _ = db.Close() })
 			repos := database.NewRepositories(db)
 			createTestSnapshotRecord(ctx, t, repos, snapshotID)
 			cfg := snapshot.ScannerConfig{
 				FS:               fs,
 				ChunkSize:        int64(1024 * 16),
 				Repositories:     repos,
 				MaxBlobSize:      int64(1024 * 1024),
 				CompressionLevel: 3,
 				AgeRecipients:    []string{testAgePublicKey},
 			}
 			if tt.onVolume != nil {
 				cfg.DeviceNumber = func(info os.FileInfo) (uint64, bool) {
 					if slices.Contains(tt.onVolume, info.Name()) {
 						return 2, true
 					}
 					return 1, true
 				}
 			}
 			_, err = snapshot.NewScanner(cfg).Scan(ctx, scannedPath, snapshotID)
 			require.NoError(t, err)
 			got, err := repos.Snapshots.GetMountPoints(ctx, snapshotID)
 			require.NoError(t, err)
 			assert.Equal(t, tt.want, got)
 		})
 	}
 }
 // automountFs is an in-memory filesystem with a volume at mountPoint
 // that is mounted on first access: opening mountPoint to list it mounts
 // the volume or, if it cannot be mounted, fails with "no such file or
 // directory", as with the autofs daemon. Stat records the device an
 // entry is on at that moment, as a real stat does: unmountedDevice for
 // mountPoint until the volume is mounted; the volume's, 2, for
 // mountPoint once it is and for everything in it; 1 for everything else.
 type automountFs struct {
 	afero.Fs
 	mountPoint      string
 	unmountedDevice uint64
 	canMount        bool
 	mounted         bool
 }
 //nolint:ireturn // afero.Fs.Open is defined to return the interface.
 func (fs *automountFs) Open(name string) (afero.File, error) {
 	if name == fs.mountPoint && !fs.canMount {
 		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
 	}
 	if name == fs.mountPoint {
 		fs.mounted = true
 	}
 	return fs.Fs.Open(name)
 }
 func (fs *automountFs) Stat(name string) (os.FileInfo, error) {
 	info, err := fs.Fs.Stat(name)
 	if err != nil {
 		return nil, err
 	}
 	device := uint64(1)
 	switch {
 	case name == fs.mountPoint && !fs.mounted:
 		device = fs.unmountedDevice
 	case name == fs.mountPoint || strings.HasPrefix(name, fs.mountPoint+"/"):
 		device = 2
 	}
 	return statWithDevice{FileInfo: info, device: device}, nil
 }
 // statWithDevice is an entry automountFs.Stat looked up, with the device
 // it was on then.
 type statWithDevice struct {
 	os.FileInfo
 	device uint64
 }
 // deviceAtLookup returns the device automountFs.Stat recorded for info.
 func deviceAtLookup(info os.FileInfo) (uint64, bool) {
 	stat, ok := info.(statWithDevice)
 	return stat.device, ok
 }
 // A volume mounted on first access is mounted when the walk lists its
 // mount point. Until then the mount point is on the automounter's own
 // device (a systemd automount) or on its parent's (an autofs map that
 // shows its mount points before mounting them). Either way only the
 // mount point is recorded, by the backup that mounts the volume and by a
 // later one that finds it mounted. Listing an automount point whose
 // volume cannot be mounted fails; it is not recorded, because the walk
 // finds no entry in it. See https://git.eeqj.de/sneak/vaultik/issues/395.
 func TestScanRecordsOnlyTheMountPointOfAnAutomountedVolume(t *testing.T) {
 	t.Parallel()
 	const scannedPath = "/data/source"
 	mountPoint := scannedPath + "/nas"
 	tests := []struct {
 		name            string
 		unmountedDevice uint64
 		canMount        bool
 		want            []string
 	}{
 		{
 			name:            "on the automounter's device until listed",
 			unmountedDevice: 3, canMount: true, want: []string{mountPoint},
 		},
 		{
 			name:            "on its parent's device until listed",
 			unmountedDevice: 1, canMount: true, want: []string{mountPoint},
 		},
 		{
 			name:            "volume that cannot be mounted",
 			unmountedDevice: 1, canMount: false, want: nil,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			ctx := context.Background()
 			fs := &automountFs{
 				Fs: afero.NewMemMapFs(), mountPoint: mountPoint,
 				unmountedDevice: tt.unmountedDevice, canMount: tt.canMount,
 			}
 			require.NoError(t, fs.MkdirAll(mountPoint+"/photos", 0o755))
 			for _, path := range []string{
 				scannedPath + "/notes.txt", mountPoint + "/photos/a.jpg",
 			} {
 				require.NoError(t, afero.WriteFile(fs, path, []byte(path), 0o644))
 			}
 			db, err := database.NewTestDB()
 			require.NoError(t, err)
 			t.Cleanup(func() { _ = db.Close() })
 			repos := database.NewRepositories(db)
 			for _, snapshotID := range []string{"first", "later"} {
 				createTestSnapshotRecord(ctx, t, repos, snapshotID)
 				scanner := snapshot.NewScanner(snapshot.ScannerConfig{
 					FS:               fs,
 					ChunkSize:        int64(1024 * 16),
 					Repositories:     repos,
 					MaxBlobSize:      int64(1024 * 1024),
 					CompressionLevel: 3,
 					AgeRecipients:    []string{testAgePublicKey},
 					DeviceNumber:     deviceAtLookup,
 				})
 				_, err = scanner.Scan(ctx, scannedPath, snapshotID)
 				require.NoError(t, err)
 				got, err := repos.Snapshots.GetMountPoints(ctx, snapshotID)
 				require.NoError(t, err)
 				assert.Equal(t, tt.want, got, "mount points of the %s backup", snapshotID)
 			}
 		})
 	}
 }
@@ -78,7 +78,8 @@ func TestProgressPercentWithSecondPathSmaller(t *testing.T) {
 	stats := progress.GetStats()
-	// With both paths counted, the percentage must not exceed 100%.
+	// Directories count toward the total size but produce no chunks, so
 	// the percentage ends just under 100%.
 	percent := float64(stats.BytesProcessed.Load()) /
 		float64(stats.TotalSize.Load()) * 100
 	if percent > 100 {
@@ -1,28 +0,0 @@
 //nolint:testpackage // exercises the unexported countNonDirectories helper
 package snapshot
 import (
 	"os"
 	"testing"
 	"sneak.berlin/go/vaultik/internal/database"
 )
 // The walk counts regular files and symlinks, not directories, so the
 // estimate of its count made from the local index's records leaves the
 // directories out. See https://git.eeqj.de/sneak/vaultik/issues/305.
 func TestCountNonDirectories(t *testing.T) {
 	t.Parallel()
 	known := map[string]*database.File{
 		"/src":       {Mode: uint32(os.ModeDir | 0o755)},
 		"/src/sub":   {Mode: uint32(os.ModeDir | 0o755)},
 		"/src/a.txt": {Mode: 0o644},
 		"/src/link":  {Mode: uint32(os.ModeSymlink | 0o777), LinkTarget: "a.txt"},
 	}
 	got := countNonDirectories(known)
 	if got != 2 {
 		t.Errorf("countNonDirectories = %d, want 2", got)
 	}
 }
@@ -199,7 +199,6 @@ func (sm *SnapshotManager) UpdateSnapshotStatsExtended(
 			stats.CompressionLevel,
 			stats.BytesUploaded,
 			stats.UploadDurationMs,
 			stats.NewChunkSize,
 		)
 	})
 }
@@ -271,18 +270,16 @@ func (sm *SnapshotManager) CompleteSnapshot(
 	return sm.MarkSnapshotComplete(ctx, snapshotID)
 }
-// ExportSnapshotMetadata exports snapshot metadata to the backup destination store
+// ExportSnapshotMetadata exports snapshot metadata to S3
 //
 // This method executes the complete snapshot metadata export process:
 // 1. Creates a temporary directory for working files
 // 2. Copies the main database to preserve its state
 // 3. Cleans the copy to contain only current snapshot data
-// 4. Vacuums the copy to remove the deleted data
+// 4. Dumps the cleaned database to SQL
-// 5. Compresses the copy with zstd
+// 5. Compresses the SQL dump with zstd
-// 6. Encrypts the compressed copy with age (always; recipients are required)
+// 6. Encrypts the compressed data with age (always; recipients are required)
-// 7. Builds the blob manifest from the copy, compressed but not encrypted
+// 7. Uploads to S3 at: snapshots/{snapshot-id}.sql.zst[.age]
 // 8. Uploads the database to metadata/{remote-key}/db.zst.age
 // 9. Uploads the manifest to metadata/{remote-key}/manifest.json.zst
 //
 // The only caller (finalizeSnapshotMetadata) does not close the main database
 // before calling this method: the index is copied at dbPath while it is still
@@ -520,8 +517,8 @@ type CleanupStats struct {
 //
 // The cleanup is performed in a specific order to maintain referential integrity:
 //  1. Delete other snapshots
-//  2. Delete orphaned snapshot associations (snapshot_files, snapshot_blobs,
+//  2. Delete orphaned snapshot associations (snapshot_files, snapshot_blobs)
-//     snapshot_mount_points) for deleted snapshots
+//     for deleted snapshots
 //  3. Delete orphaned files (not in the current snapshot)
 //  4. Delete orphaned chunk-to-file mappings (references to deleted files)
 //  5. Delete orphaned blobs (not in the current snapshot)
@@ -909,7 +906,6 @@ type ExtendedBackupStats struct {
 	BlobUncompressedSize int64 // Total uncompressed size of all referenced blobs
 	CompressionLevel     int   // Compression level used for this snapshot
 	UploadDurationMs     int64 // Total milliseconds spent uploading to S3
 	NewChunkSize         int64 // Total size of the chunks counted in ChunksCreated
 }
 // deleteOtherSnapshots deletes all snapshots except the current one
@@ -950,8 +946,8 @@ func (sm *SnapshotManager) deleteOtherSnapshots(
 	return nil
 }
-// deleteOrphanedSnapshotAssociations deletes snapshot_files,
+// deleteOrphanedSnapshotAssociations deletes snapshot_files and
-// snapshot_blobs and snapshot_mount_points for deleted snapshots
+// snapshot_blobs for deleted snapshots
 func (sm *SnapshotManager) deleteOrphanedSnapshotAssociations(
 	ctx context.Context, tx *sql.Tx, currentSnapshotID string,
 ) error {
@@ -985,19 +981,6 @@ func (sm *SnapshotManager) deleteOrphanedSnapshotAssociations(
 	log.Debug("[Temp DB Cleanup] Deleted snapshot_blobs associations",
 		"count", rowsAffected)
 	// Delete the mount points other snapshots recorded
 	query := "DELETE FROM snapshot_mount_points WHERE snapshot_id != ?"
 	database.LogSQL("Execute", query, currentSnapshotID)
 	result, err = tx.ExecContext(ctx, query, currentSnapshotID)
 	if err != nil {
 		return fmt.Errorf("deleting orphaned snapshot_mount_points: %w", err)
 	}
 	rowsAffected, _ = result.RowsAffected()
 	log.Debug("[Temp DB Cleanup] Deleted snapshot_mount_points rows",
 		"count", rowsAffected)
 	return nil
 }
@@ -7,14 +7,12 @@ import (
 	"database/sql"
 	"io"
 	"path/filepath"
 	"slices"
 	"testing"
 	"github.com/spf13/afero"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/types"
 )
 const (
@@ -389,77 +387,6 @@ func TestCleanSnapshotDBNonExistentSnapshot(t *testing.T) {
 	}
 }
 // The exported metadata database keeps only the mount points that the
 // exported snapshot recorded. See
 // https://git.eeqj.de/sneak/vaultik/issues/395.
 func TestCleanSnapshotDBKeepsOnlyTheSnapshotsMountPoints(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	dbPath := filepath.Join(t.TempDir(), "export.db")
 	db, err := database.New(ctx, dbPath)
 	if err != nil {
 		t.Fatalf("failed to create database: %v", err)
 	}
 	repos := database.NewRepositories(db)
 	for _, id := range []types.SnapshotID{"exported", "other"} {
 		err = repos.Snapshots.Create(ctx, nil, &database.Snapshot{ID: id})
 		if err != nil {
 			t.Fatalf("failed to create snapshot: %v", err)
 		}
 		err = repos.Snapshots.AddMountPoint(ctx, nil, id.String(), "/data/"+id.String())
 		if err != nil {
 			t.Fatalf("failed to add mount point: %v", err)
 		}
 	}
 	err = db.Close()
 	if err != nil {
 		t.Fatalf("failed to close database: %v", err)
 	}
 	sm := &SnapshotManager{
 		config: &config.Config{
 			CompressionLevel: 3,
 			AgeRecipients:    []string{testAgeRecipient},
 		},
 		fs: afero.NewOsFs(),
 	}
 	_, err = sm.cleanSnapshotDB(ctx, dbPath, "exported")
 	if err != nil {
 		t.Fatalf("failed to clean snapshot database: %v", err)
 	}
 	cleaned, err := database.New(ctx, dbPath)
 	if err != nil {
 		t.Fatalf("failed to open cleaned database: %v", err)
 	}
 	defer func() { _ = cleaned.Close() }()
 	cleanedRepos := database.NewRepositories(cleaned)
 	for id, want := range map[string][]string{
 		"exported": {"/data/exported"},
 		"other":    nil,
 	} {
 		got, err := cleanedRepos.Snapshots.GetMountPoints(ctx, id)
 		if err != nil {
 			t.Fatalf("failed to read mount points: %v", err)
 		}
 		if !slices.Equal(got, want) {
 			t.Errorf("mount points of %s: got %v, want %v", id, got, want)
 		}
 	}
 }
 // Two creates of one snapshot name back to back start within one second,
 // the resolution of the timestamp in a snapshot ID. See
 // https://git.eeqj.de/sneak/vaultik/issues/270.
@@ -1,135 +0,0 @@
 //nolint:testpackage // exercises the unexported uploadBlobIfNeeded
 package snapshot
 import (
 	"bytes"
 	"context"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 	"time"
 	"sneak.berlin/go/vaultik/internal/blob"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/storage"
 	"sneak.berlin/go/vaultik/internal/storage/faultstore"
 	"sneak.berlin/go/vaultik/internal/ui"
 )
 const uploadFailedLogMessage = "Failed to upload blob"
 // uploadTestBlob uploads a small blob through store.
 func uploadTestBlob(ctx context.Context, store storage.Storer) error {
 	data := []byte("blob data")
 	s := &Scanner{storage: store, ui: ui.NewWithColor(io.Discard, false)}
 	_, _, err := s.uploadBlobIfNeeded(ctx, "blobs/test", &blob.WithReader{
 		FinishedBlob: &blob.FinishedBlob{
 			Hash:       "test",
 			Compressed: int64(len(data)),
 		},
 		Reader: bytes.NewReader(data),
 	}, time.Now(), &ScanResult{})
 	return err
 }
 // captureLog runs fn and returns what the logger wrote to stderr
 // meanwhile, at the --verbose level. The logger writes to the os.Stderr
 // it finds when it is initialized, so os.Stderr is pointed at a file
 // first. Not parallel-safe: os.Stderr and the logger are process-global.
 func captureLog(t *testing.T, fn func()) string {
 	t.Helper()
 	stderrPath := filepath.Join(t.TempDir(), "stderr")
 	stderrFile, err := os.Create(stderrPath) //nolint:gosec // G304: test temp path
 	if err != nil {
 		t.Fatalf("creating stderr file: %v", err)
 	}
 	previous := os.Stderr
 	os.Stderr = stderrFile
 	log.Initialize(log.Config{Verbose: true})
 	fn()
 	os.Stderr = previous
 	log.Initialize(log.Config{})
 	_ = stderrFile.Close()
 	captured, err := os.ReadFile(stderrPath) //nolint:gosec // G304: test temp path
 	if err != nil {
 		t.Fatalf("reading stderr file: %v", err)
 	}
 	return string(captured)
 }
 // An upload stopped by Ctrl-C or SIGTERM is not logged as an error; the
 // interrupted message is all the user sees. See
 // https://git.eeqj.de/sneak/vaultik/issues/434.
 //
 //nolint:paralleltest // captureLog replaces os.Stderr
 func TestInterruptedUploadIsNotLoggedAsError(t *testing.T) {
 	inner, err := storage.NewFileStorer(t.TempDir())
 	if err != nil {
 		t.Fatal(err)
 	}
 	ctx, cancel := context.WithCancel(context.Background())
 	t.Cleanup(cancel)
 	// The user interrupts mid-upload. The injected error does not wrap
 	// context.Canceled, so only ctx shows why the upload failed.
 	store := faultstore.New(inner)
 	store.OnPut = func(string) faultstore.PutAction {
 		cancel()
 		return faultstore.PutFail
 	}
 	var uploadErr error
 	stderr := captureLog(t, func() { uploadErr = uploadTestBlob(ctx, store) })
 	if uploadErr == nil {
 		t.Fatal("expected the upload to fail")
 	}
 	if strings.Contains(stderr, uploadFailedLogMessage) {
 		t.Errorf("interrupted upload logged as a failure: %q", stderr)
 	}
 }
 // An upload that fails for any other reason is still logged.
 //
 //nolint:paralleltest // captureLog replaces os.Stderr
 func TestFailedUploadIsLogged(t *testing.T) {
 	inner, err := storage.NewFileStorer(t.TempDir())
 	if err != nil {
 		t.Fatal(err)
 	}
 	store := faultstore.New(inner)
 	store.OnPut = func(string) faultstore.PutAction { return faultstore.PutFail }
 	var uploadErr error
 	stderr := captureLog(t, func() {
 		uploadErr = uploadTestBlob(context.Background(), store)
 	})
 	if uploadErr == nil {
 		t.Fatal("expected the upload to fail")
 	}
 	if !strings.Contains(stderr, uploadFailedLogMessage) {
 		t.Errorf("failed upload not logged: %q", stderr)
 	}
 }
@@ -8,7 +8,6 @@ import (
 	"reflect"
 	"sort"
 	"testing"
 	"time"
 	"sneak.berlin/go/vaultik/internal/storage"
 )
@@ -20,17 +19,15 @@ import (
 // constructor, so the contract is defined once.
 //
 // It exercises the public Storer interface: round-trip, stat, list with
-// prefix filtering, the modification time ListStream reports, overwrite,
+// prefix filtering, overwrite, delete, delete-of-missing, and not-found on
-// delete, delete-of-missing, and not-found on Get and Stat. Each section
+// Get and Stat. Each section takes its own fresh backend instance, so the
-// takes its own fresh backend instance, so the order of sections never
+// order of sections never matters and no section sees another's objects.
 // matters and no section sees another's objects.
 func runStorerConformance(t *testing.T, newStorer func(*testing.T) storage.Storer) {
 	t.Helper()
 	conformanceRoundTrip(t, newStorer(t))
 	conformanceOverwrite(t, newStorer(t))
 	conformanceList(t, newStorer(t))
 	conformanceListStreamModTime(t, newStorer(t))
 	conformanceDelete(t, newStorer(t))
 	conformanceNotFound(t, newStorer(t))
 }
@@ -121,35 +118,6 @@ func conformanceList(t *testing.T, s storage.Storer) {
 	}
 }
 // conformanceListStreamModTime checks that ListStream gives an object
 // just written a modification time of about now, which prune compares
 // with its grace period.
 func conformanceListStreamModTime(t *testing.T, s storage.Storer) {
 	t.Helper()
 	ctx := context.Background()
 	err := s.Put(ctx, "blobs/dd/written-now", bytes.NewReader([]byte("data")))
 	if err != nil {
 		t.Fatalf("Put: %v", err)
 	}
 	var listed []storage.ObjectInfo
 	for info := range s.ListStream(ctx, "blobs/") {
 		listed = append(listed, info)
 	}
 	if len(listed) != 1 || listed[0].Err != nil {
 		t.Fatalf("ListStream(\"blobs/\") = %v, want the one object", listed)
 	}
 	if time.Since(listed[0].ModTime).Abs() > time.Minute {
 		t.Errorf("ListStream ModTime = %v, want within a minute of now",
 			listed[0].ModTime)
 	}
 }
 // conformanceDelete checks that Delete removes an object and that deleting
 // a missing key is not an error.
 func conformanceDelete(t *testing.T, s storage.Storer) {
@@ -1,18 +1,15 @@
 // Package faultstore provides a storage.Storer wrapper that injects
 // faults on demand, so tests can reproduce the failure modes a real
 // backend exhibits: an upload that fails partway, a backend that reports
-// success while storing nothing, reads that return corrupt or truncated
+// success while storing nothing, and reads that return corrupt or
-// bytes, and a delete or a stat the backend refuses. It is the seam
+// truncated bytes. It is the seam called for by the fault-injection
-// called for by the fault-injection tests (sneak/vaultik issue 72) and
+// tests (sneak/vaultik issue 72) and is meant to be reused by future
-// is meant to be reused by future tests rather than re-implemented per
+// tests rather than re-implemented per case.
 // case.
 //
-// The wrapper delegates every method to the inner Storer. Four hooks
+// The wrapper delegates every method to the inner Storer. Two hooks
-// change that: OnPut decides the fate of each write, OnGet decides how
+// change that: OnPut decides the fate of each write, and OnGet decides
-// each read's bytes are returned, OnDelete decides whether each delete
+// how each read's bytes are returned. Both are keyed by the object key,
-// fails, and OnStat whether each stat fails. All are keyed by the object
+// so a test can fault only blobs, only metadata, or a single object.
 // key, so a test can fault only blobs, only metadata, or a single
 // object.
 package faultstore
 import (
@@ -28,15 +25,6 @@ import (
 // ErrInjectedUpload is returned by a Put the OnPut hook chose to fail.
 var ErrInjectedUpload = errors.New("faultstore: injected upload failure")
 // ErrInjectedDelete is returned by a Delete the OnDelete hook chose to
 // fail.
 var ErrInjectedDelete = errors.New("faultstore: injected delete failure")
 // ErrInjectedStat is returned by a Stat the OnStat hook chose to fail.
 // It is not storage.ErrNotFound: the backend refused the request, as S3
 // refuses a HEAD to credentials that allow only PUT.
 var ErrInjectedStat = errors.New("faultstore: injected stat failure")
 // PutAction is the disposition OnPut assigns to a write.
 type PutAction int
@@ -78,15 +66,6 @@ type Storer struct {
 	// OnGet, when set, is consulted for every Get with the object key
 	// and damages the returned bytes accordingly.
 	OnGet func(key string) GetFault
 	// OnDelete, when set, is consulted before every Delete with the
 	// object key. Returning true fails the delete and leaves the object
 	// in place.
 	OnDelete func(key string) bool
 	// OnStat, when set, is consulted before every Stat with the object
 	// key. Returning true fails the stat with ErrInjectedStat.
 	OnStat func(key string) bool
 }
 // New wraps inner. inner must be non-nil.
@@ -170,21 +149,13 @@ func damage(fault GetFault, data []byte) []byte {
 	return out
 }
-// Stat returns the object's info unless OnStat fails the stat.
+// Stat delegates unchanged.
 func (f *Storer) Stat(ctx context.Context, key string) (*storage.ObjectInfo, error) {
 	if f.OnStat != nil && f.OnStat(key) {
 		return nil, fmt.Errorf("%w for %q", ErrInjectedStat, key)
 	}
 	return f.inner.Stat(ctx, key)
 }
-// Delete removes the object unless OnDelete fails the delete.
+// Delete delegates unchanged.
 func (f *Storer) Delete(ctx context.Context, key string) error {
 	if f.OnDelete != nil && f.OnDelete(key) {
 		return fmt.Errorf("%w for %q", ErrInjectedDelete, key)
 	}
 	return f.inner.Delete(ctx, key)
 }
@@ -21,13 +21,9 @@ type FileStorer struct {
 // NewFileStorer creates a new filesystem storage backend.
 //
 // Construction is intentionally cheap and does not touch the filesystem.
-// The backend never creates basePath: the user does, so that when
+// The basePath is recorded; the directory is created lazily on first
-// basePath is a directory on an unplugged volume, a write fails instead
+// write. Write operations (Put/PutWithProgress) call MkdirAll for the
-// of landing on the disk under the mount point. This does not hold when
+// per-blob parent directory, which also covers basePath on first use.
 // basePath is the mount point itself, which stays behind when its volume
 // is unplugged.
 // Put and PutWithProgress fail on a missing basePath and create the
 // directories below it as needed.
 // Get and Stat report a key under a missing basePath as ErrNotFound.
 // List and ListStream fail on a missing basePath, because listing it as
 // an empty store would make `prune` drop every local snapshot record.
@@ -124,10 +120,9 @@ func (f *FileStorer) Delete(_ context.Context, key string) error {
 	return nil
 }
-// List returns all keys with the given prefix, reading through symlinked
+// List returns all keys with the given prefix. It fails when the
-// directories. It fails when the destination directory is missing, or
+// destination directory is missing; a missing prefix under it is an
-// when the prefix or a directory above it is a symlink whose target is
+// empty listing.
 // missing; a prefix that is truly missing is an empty listing.
 func (f *FileStorer) List(ctx context.Context, prefix string) ([]string, error) {
 	var keys []string
@@ -138,7 +133,8 @@ func (f *FileStorer) List(ctx context.Context, prefix string) ([]string, error)
 	basePath := f.fullPath(prefix)
-	exists, err := f.prefixExists(prefix)
+	// Check if the prefix exists
 	exists, err := afero.Exists(f.fs, basePath)
 	if err != nil {
 		return nil, fmt.Errorf("checking path: %w", err)
 	}
@@ -147,7 +143,7 @@ func (f *FileStorer) List(ctx context.Context, prefix string) ([]string, error)
 		return keys, nil // Empty list for non-existent prefix
 	}
-	err = f.walk(basePath, func(path string, info os.FileInfo, err error) error {
+	err = afero.Walk(f.fs, basePath, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}
@@ -180,9 +176,7 @@ func (f *FileStorer) List(ctx context.Context, prefix string) ([]string, error)
 }
 // ListStream returns a channel of ObjectInfo for large result sets. Like
-// List, it reads through symlinked directories and sends an error when
+// List, it sends an error when the destination directory is missing.
 // the destination directory is missing, or when the prefix or a directory
 // above it is a symlink whose target is missing.
 func (f *FileStorer) ListStream(ctx context.Context, prefix string) <-chan ObjectInfo {
 	ch := make(chan ObjectInfo)
@@ -198,7 +192,8 @@ func (f *FileStorer) ListStream(ctx context.Context, prefix string) <-chan Objec
 		basePath := f.fullPath(prefix)
-		exists, err := f.prefixExists(prefix)
+		// Check if the prefix exists
 		exists, err := afero.Exists(f.fs, basePath)
 		if err != nil {
 			ch <- ObjectInfo{Err: fmt.Errorf("checking path: %w", err)}
@@ -209,7 +204,7 @@ func (f *FileStorer) ListStream(ctx context.Context, prefix string) <-chan Objec
 			return // Empty channel for non-existent prefix
 		}
-		_ = f.walk(basePath, func(path string, info os.FileInfo, err error) error {
+		_ = afero.Walk(f.fs, basePath, func(path string, info os.FileInfo, err error) error {
 			// Check context cancellation
 			select {
 			case <-ctx.Done():
@@ -235,9 +230,8 @@ func (f *FileStorer) ListStream(ctx context.Context, prefix string) <-chan Objec
 				// Normalize path separators
 				relPath = strings.ReplaceAll(relPath, string(filepath.Separator), "/")
 				ch <- ObjectInfo{
-					Key:     relPath,
+					Key:  relPath,
-					Size:    info.Size(),
+					Size: info.Size(),
 					ModTime: info.ModTime(),
 				}
 			}
@@ -249,12 +243,11 @@ func (f *FileStorer) ListStream(ctx context.Context, prefix string) <-chan Objec
 }
 // DeletePartialUploads removes every file under prefix whose name ends in
-// tempSuffix. Like List, it reads through symlinked directories and fails
+// tempSuffix. A missing prefix has none to remove.
 // on one whose target is missing. A missing prefix has none to remove.
 func (f *FileStorer) DeletePartialUploads(ctx context.Context, prefix string) error {
 	basePath := f.fullPath(prefix)
-	exists, err := f.prefixExists(prefix)
+	exists, err := afero.Exists(f.fs, basePath)
 	if err != nil {
 		return fmt.Errorf("checking path: %w", err)
 	}
@@ -263,7 +256,7 @@ func (f *FileStorer) DeletePartialUploads(ctx context.Context, prefix string) er
 		return nil
 	}
-	err = f.walk(basePath, func(path string, info os.FileInfo, err error) error {
+	err = afero.Walk(f.fs, basePath, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}
@@ -304,19 +297,7 @@ func (f *FileStorer) writeAtomic(
 	path := f.fullPath(key)
 	dir := filepath.Dir(path)
-	// Checked on every write, so a destination that disappears part-way
+	err := f.fs.MkdirAll(dir, storageDirPerm)
 	// through a backup fails it rather than being recreated by MkdirAll.
 	_, err := f.fs.Stat(f.basePath)
 	if os.IsNotExist(err) {
 		return fmt.Errorf("destination directory does not exist; "+
 			"create it, or mount the volume it is on: %w", err)
 	}
 	if err != nil {
 		return fmt.Errorf("checking destination directory: %w", err)
 	}
 	err = f.fs.MkdirAll(dir, storageDirPerm)
 	if err != nil {
 		return fmt.Errorf("creating directories: %w", err)
 	}
@@ -371,54 +352,6 @@ func (f *FileStorer) writeAtomic(
 	return nil
 }
 // walk is afero.Walk, except that it reads through a symlinked directory
 // the way Get and Stat do, where afero.Walk reports the link as one file.
 // afero.Walk uses Lstat, which does not follow a link, whenever the
 // filesystem has one; the struct below carries only the afero.Fs methods,
 // so the walk uses Stat instead. A link back up the tree is followed until
 // the operating system refuses the path for too many levels of links, and
 // the walk then fails.
 func (f *FileStorer) walk(root string, fn filepath.WalkFunc) error {
 	return afero.Walk(struct{ afero.Fs }{f.fs}, root, fn)
 }
 // prefixExists reports whether prefix exists under the destination
 // directory. It checks each directory on the way down to prefix in turn,
 // and the first one Stat cannot find decides: if it is not there at all,
 // prefix is missing; if it is a symlink whose target is missing, such as
 // a link to a volume that is not mounted, prefixExists fails, since
 // listing it as empty would let prune delete every blob.
 func (f *FileStorer) prefixExists(prefix string) (bool, error) {
 	lstater, canLstat := f.fs.(afero.Lstater)
 	path := f.basePath
 	for name := range strings.SplitSeq(prefix, "/") {
 		path = filepath.Join(path, name)
 		_, err := f.fs.Stat(path)
 		if err == nil {
 			continue
 		}
 		if !os.IsNotExist(err) {
 			return false, err
 		}
 		// Lstat does not follow a symlink at path, so it finds the link
 		// that Stat could not follow.
 		if canLstat {
 			_, _, lstatErr := lstater.LstatIfPossible(path)
 			if lstatErr == nil {
 				return false, err
 			}
 		}
 		return false, nil
 	}
 	return true, nil
 }
 // fullPath returns the full filesystem path for a key.
 func (f *FileStorer) fullPath(key string) string {
 	return filepath.Join(f.basePath, key)
@@ -4,10 +4,7 @@ import (
 	"context"
 	"errors"
 	"io/fs"
 	"os"
 	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
 	"sneak.berlin/go/vaultik/internal/storage"
@@ -63,272 +60,3 @@ func TestFileStorerListMissingDestination(t *testing.T) {
 		t.Errorf("ListStream error = %v, want a not-exist error", streamErr)
 	}
 }
 // The two directories at the top of a destination, either of which the
 // tests below replace with a symlink.
 const (
 	metadataDir = "metadata"
 	blobsDir    = "blobs"
 )
 // moveBehindSymlink moves base/dir to a directory elsewhere and puts a
 // symlink to it in its place.
 func moveBehindSymlink(t *testing.T, base, dir string) {
 	t.Helper()
 	linkPath := filepath.Join(base, dir)
 	movedPath := filepath.Join(t.TempDir(), dir)
 	err := os.Rename(linkPath, movedPath)
 	if err != nil {
 		t.Fatalf("moving %s away: %v", dir, err)
 	}
 	err = os.Symlink(movedPath, linkPath)
 	if err != nil {
 		t.Fatalf("linking %s: %v", dir, err)
 	}
 }
 // TestFileStorerListsThroughSymlinkedDirectory checks that List and
 // ListStream read through a symlinked metadata/ or blobs/ directory, as Get
 // and Stat do, instead of listing the link as one key. Listing the whole
 // destination meets the link part-way through the walk; listing its prefix
 // starts the walk at the link. A prefix missing behind the link lists as
 // empty.
 func TestFileStorerListsThroughSymlinkedDirectory(t *testing.T) {
 	t.Parallel()
 	for _, dir := range []string{metadataDir, blobsDir} {
 		t.Run(dir, func(t *testing.T) {
 			t.Parallel()
 			base := t.TempDir()
 			key := dir + "/aa/bb/object"
 			s, err := storage.NewFileStorer(base)
 			if err != nil {
 				t.Fatalf("NewFileStorer: %v", err)
 			}
 			err = s.Put(context.Background(), key, strings.NewReader("data"))
 			if err != nil {
 				t.Fatalf("Put: %v", err)
 			}
 			moveBehindSymlink(t, base, dir)
 			want := []string{key}
 			for _, prefix := range []string{"", dir + "/"} {
 				got := listSorted(t, s, prefix)
 				if !reflect.DeepEqual(got, want) {
 					t.Errorf("List(%q) = %v, want %v", prefix, got, want)
 				}
 				got = listStreamKeys(t, s, prefix)
 				if !reflect.DeepEqual(got, want) {
 					t.Errorf("ListStream(%q) = %v, want %v", prefix, got, want)
 				}
 			}
 			absent := dir + "/absent/"
 			if got := listSorted(t, s, absent); len(got) != 0 {
 				t.Errorf("List(%q) = %v, want empty", absent, got)
 			}
 			if got := listStreamKeys(t, s, absent); len(got) != 0 {
 				t.Errorf("ListStream(%q) = %v, want empty", absent, got)
 			}
 		})
 	}
 }
 // TestFileStorerListFailsOnSymlinkWithMissingTarget checks that List and
 // ListStream fail on a symlinked metadata/ or blobs/ directory whose target
 // is missing, such as a link to a volume that is not mounted, as they do on
 // a missing destination directory, instead of listing it as empty. That
 // holds for a prefix below the link too.
 func TestFileStorerListFailsOnSymlinkWithMissingTarget(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
 	for _, dir := range []string{metadataDir, blobsDir} {
 		t.Run(dir, func(t *testing.T) {
 			t.Parallel()
 			base := t.TempDir()
 			s, err := storage.NewFileStorer(base)
 			if err != nil {
 				t.Fatalf("NewFileStorer: %v", err)
 			}
 			unmounted := filepath.Join(t.TempDir(), "unmounted")
 			err = os.Symlink(unmounted, filepath.Join(base, dir))
 			if err != nil {
 				t.Fatalf("Symlink: %v", err)
 			}
 			for _, prefix := range []string{"", dir + "/", dir + "/aa/"} {
 				keys, err := s.List(ctx, prefix)
 				if !errors.Is(err, fs.ErrNotExist) {
 					t.Errorf("List(%q) = %v, %v; want a not-exist error",
 						prefix, keys, err)
 				}
 				var streamErr error
 				for object := range s.ListStream(ctx, prefix) {
 					if object.Err != nil {
 						streamErr = object.Err
 					}
 				}
 				if !errors.Is(streamErr, fs.ErrNotExist) {
 					t.Errorf("ListStream(%q) error = %v, want a not-exist error",
 						prefix, streamErr)
 				}
 			}
 		})
 	}
 }
 // TestFileStorerListFailsOnSymlinkLoop checks that a symlink pointing back
 // at the destination makes List and ListStream fail instead of walking it
 // forever.
 func TestFileStorerListFailsOnSymlinkLoop(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
 	base := t.TempDir()
 	s, err := storage.NewFileStorer(base)
 	if err != nil {
 		t.Fatalf("NewFileStorer: %v", err)
 	}
 	err = s.Put(ctx, testBlobKey, strings.NewReader("data"))
 	if err != nil {
 		t.Fatalf("Put: %v", err)
 	}
 	err = os.Symlink(base, filepath.Join(base, "blobs", "loop"))
 	if err != nil {
 		t.Fatalf("Symlink: %v", err)
 	}
 	keys, err := s.List(ctx, "blobs/")
 	if err == nil {
 		t.Errorf("List = %d keys and no error, want an error", len(keys))
 	}
 	var streamErr error
 	for object := range s.ListStream(ctx, "blobs/") {
 		if object.Err != nil {
 			streamErr = object.Err
 		}
 	}
 	if streamErr == nil {
 		t.Error("ListStream sent no error, want one")
 	}
 }
 // TestFileStorerDeletePartialUploadsThroughSymlinkedDirectory checks that
 // DeletePartialUploads, which remote nuke uses, removes a leftover temp
 // file behind a symlinked metadata/ or blobs/ directory and keeps the
 // object at the real key.
 func TestFileStorerDeletePartialUploadsThroughSymlinkedDirectory(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
 	for _, dir := range []string{metadataDir, blobsDir} {
 		t.Run(dir, func(t *testing.T) {
 			t.Parallel()
 			base := t.TempDir()
 			key := dir + "/aa/bb/object"
 			s, err := storage.NewFileStorer(base)
 			if err != nil {
 				t.Fatalf("NewFileStorer: %v", err)
 			}
 			err = s.Put(ctx, key, strings.NewReader("data"))
 			if err != nil {
 				t.Fatalf("Put: %v", err)
 			}
 			leftover := filepath.Join(base, key+"-123456.partial")
 			err = os.WriteFile(leftover, []byte("half"), 0o600)
 			if err != nil {
 				t.Fatalf("writing leftover temp file: %v", err)
 			}
 			moveBehindSymlink(t, base, dir)
 			err = s.DeletePartialUploads(ctx, dir+"/")
 			if err != nil {
 				t.Fatalf("DeletePartialUploads: %v", err)
 			}
 			// leftover runs through the link.
 			_, err = os.Stat(leftover)
 			if !os.IsNotExist(err) {
 				t.Errorf("leftover temp file was not removed: %v", err)
 			}
 			_, err = s.Stat(ctx, key)
 			if err != nil {
 				t.Errorf("Stat of the real key: %v", err)
 			}
 		})
 	}
 }
 // TestFileStorerPutMissingDestination checks that a write fails when the
 // destination directory has gone, even after earlier writes to it
 // succeeded, and that it does not create the directory again.
 func TestFileStorerPutMissingDestination(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
 	base := filepath.Join(t.TempDir(), "usbstick")
 	err := os.Mkdir(base, 0o750)
 	if err != nil {
 		t.Fatalf("Mkdir: %v", err)
 	}
 	s, err := storage.NewFileStorer(base)
 	if err != nil {
 		t.Fatalf("NewFileStorer: %v", err)
 	}
 	err = s.Put(ctx, "blobs/aa/bb/first", strings.NewReader("first"))
 	if err != nil {
 		t.Fatalf("first Put: %v", err)
 	}
 	err = os.Rename(base, base+"-unplugged")
 	if err != nil {
 		t.Fatalf("Rename: %v", err)
 	}
 	err = s.Put(ctx, "blobs/aa/bb/second", strings.NewReader("second"))
 	if !errors.Is(err, fs.ErrNotExist) {
 		t.Errorf("Put = %v, want a not-exist error", err)
 	}
 	_, err = os.Stat(base)
 	if !errors.Is(err, fs.ErrNotExist) {
 		t.Errorf("Put created the destination directory again (Stat = %v)", err)
 	}
 }
@@ -7,12 +7,10 @@ import (
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"strings"
 	"time"
 	"github.com/rclone/rclone/fs"
 	"github.com/rclone/rclone/fs/config"
 	"github.com/rclone/rclone/fs/config/configfile"
 	"github.com/rclone/rclone/fs/operations"
@@ -35,15 +33,6 @@ type RcloneStorer struct {
 // The remote parameter is the rclone remote name (as configured via `rclone config`).
 // The path parameter is the path within the remote.
 func NewRcloneStorer(ctx context.Context, remote, path string) (*RcloneStorer, error) {
 	// rclone reads RCLONE_CONFIG only as the value of its --config flag,
 	// which vaultik does not have, so it is applied here as that flag would.
 	if configPath, ok := os.LookupEnv("RCLONE_CONFIG"); ok {
 		err := config.SetConfigPath(configPath)
 		if err != nil {
 			return nil, fmt.Errorf("using RCLONE_CONFIG %q: %w", configPath, err)
 		}
 	}
 	// Install the default config file handler
 	configfile.Install()
@@ -53,14 +42,6 @@ func NewRcloneStorer(ctx context.Context, remote, path string) (*RcloneStorer, e
 		rclonePath += path
 	}
 	// On S3, Swift and some other remotes rclone keeps a time of its own in
 	// each object's metadata, which costs one request per object to read.
 	// rclone's use_server_modtime setting makes ModTime the time the
 	// listing gives instead: when the object was stored, which is what
 	// prune compares with prune_grace_period.
 	ctx, ci := fs.AddConfig(ctx)
 	ci.UseServerModTime = true
 	// Create the rclone filesystem
 	fsys, err := fs.NewFs(ctx, rclonePath)
 	if err != nil {
@@ -219,9 +200,8 @@ func (r *RcloneStorer) ListStream(
 			if prefix == "" || strings.HasPrefix(key, prefix) {
 				ch <- ObjectInfo{
-					Key:     key,
+					Key:  key,
-					Size:    obj.Size(),
+					Size: obj.Size(),
 					ModTime: obj.ModTime(ctx),
 				}
 			}
 		})
@@ -5,19 +5,12 @@ import (
 	"context"
 	"errors"
 	"io"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strings"
 	"sync/atomic"
 	"testing"
 	"time"
 	"github.com/johannesboyne/gofakes3"
 	"github.com/johannesboyne/gofakes3/backend/s3mem"
 	"github.com/rclone/rclone/fs"
 	"github.com/rclone/rclone/fs/config"
 	"github.com/rclone/rclone/fs/config/configmap"
 	"sneak.berlin/go/vaultik/internal/storage"
 )
@@ -397,110 +390,3 @@ func TestNewRcloneStorerUnknownRemote(t *testing.T) {
 		t.Errorf("NewRcloneStorer error = %v, want ErrRemoteNotFound", err)
 	}
 }
 // TestNewRcloneStorerReadsRcloneConfigEnv checks that a remote defined only
 // in the file RCLONE_CONFIG names is found and written to, as rclone itself
 // would.
 func TestNewRcloneStorerReadsRcloneConfigEnv(t *testing.T) {
 	// rclone keeps the config file path in a process-global variable, which
 	// NewRcloneStorer leaves pointing at this test's file.
 	previous := config.GetConfigPath()
 	t.Cleanup(func() { _ = config.SetConfigPath(previous) })
 	confFile := filepath.Join(t.TempDir(), "rclone.conf")
 	err := os.WriteFile(confFile, []byte("[loc]\ntype = local\n"), 0o600)
 	if err != nil {
 		t.Fatalf("writing rclone config: %v", err)
 	}
 	t.Setenv("RCLONE_CONFIG", confFile)
 	dir := t.TempDir()
 	ctx := context.Background()
 	s, err := storage.NewRcloneStorer(ctx, "loc", dir)
 	if err != nil {
 		t.Fatalf("NewRcloneStorer: %v", err)
 	}
 	err = s.Put(ctx, testBlobKey, strings.NewReader("blob-bytes"))
 	if err != nil {
 		t.Fatalf("Put: %v", err)
 	}
 	_, err = os.Stat(filepath.Join(dir, testBlobKey))
 	if err != nil {
 		t.Errorf("object is not in the remote's directory: %v", err)
 	}
 }
 // TestRcloneListStreamOnS3MakesNoRequestPerObject checks that listing an
 // rclone S3 remote takes each object's time from the listing itself. By
 // default rclone reads the time it keeps in each object's metadata, one
 // request per object, and every command that lists the destination store
 // would slow down as it grows.
 //
 //nolint:paralleltest // NewRcloneStorer installs the process-global rclone config
 func TestRcloneListStreamOnS3MakesNoRequestPerObject(t *testing.T) {
 	backend := s3mem.New()
 	err := backend.CreateBucket(s3TestBucket)
 	if err != nil {
 		t.Fatalf("create bucket: %v", err)
 	}
 	const body = "blob-bytes"
 	_, err = backend.PutObject(s3TestBucket, testBlobKey, nil,
 		strings.NewReader(body), int64(len(body)))
 	if err != nil {
 		t.Fatalf("seed object: %v", err)
 	}
 	var headRequests atomic.Int64
 	fakeS3 := gofakes3.New(backend).Server()
 	srv := httptest.NewServer(http.HandlerFunc(
 		func(w http.ResponseWriter, r *http.Request) {
 			if r.Method == http.MethodHead {
 				headRequests.Add(1)
 			}
 			fakeS3.ServeHTTP(w, r)
 		}))
 	t.Cleanup(srv.Close)
 	remote := ":s3,provider=Other" +
 		",access_key_id=" + s3TestAccessKeyID +
 		",secret_access_key=" + s3TestSecretAccessKey +
 		",endpoint='" + srv.URL + "'"
 	ctx := context.Background()
 	s, err := storage.NewRcloneStorer(ctx, remote, s3TestBucket)
 	if err != nil {
 		t.Fatalf("NewRcloneStorer: %v", err)
 	}
 	headRequests.Store(0)
 	var listed []storage.ObjectInfo
 	for info := range s.ListStream(ctx, "blobs/") {
 		listed = append(listed, info)
 	}
 	if len(listed) != 1 || listed[0].Err != nil {
 		t.Fatalf("ListStream(\"blobs/\") = %v, want the one object", listed)
 	}
 	if time.Since(listed[0].ModTime).Abs() > time.Minute {
 		t.Errorf("ListStream ModTime = %v, want within a minute of now",
 			listed[0].ModTime)
 	}
 	if n := headRequests.Load(); n != 0 {
 		t.Errorf("ListStream made %d HEAD request(s), want none", n)
 	}
 }
@@ -89,10 +89,9 @@ func (s *S3Storer) ListStream(ctx context.Context, prefix string) <-chan ObjectI
 		for info := range s.client.ListObjectsStream(ctx, prefix, false) {
 			ch <- ObjectInfo{
-				Key:     info.Key,
+				Key:  info.Key,
-				Size:    info.Size,
+				Size: info.Size,
-				ModTime: info.ModTime,
+				Err:  info.Err,
 				Err:     info.Err,
 			}
 		}
 	}()
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"errors"
 	"io"
 	"net/http"
 	"net/http/httptest"
 	"slices"
@@ -23,16 +22,13 @@ import (
 // s3TestBucket is the bucket created for each in-process S3 server.
 const s3TestBucket = "test-bucket"
-// Credentials for the tests' S3 clients. The test servers accept any.
+// Credentials for the tests that build a storer from a config.Config. The
 // in-process S3 server accepts any.
 const (
 	s3TestAccessKeyID     = "key"
 	s3TestSecretAccessKey = "secret"
 )
 // s3TestRegion is the region of the S3 clients built here with
 // s3.NewClient. The test servers ignore it.
 const s3TestRegion = "us-east-1"
 // newS3Storer builds an s3:// backend backed by a fresh in-process
 // S3 server. It reuses the same in-memory S3 harness (gofakes3 + s3mem
 // over httptest) that internal/s3 and the not-found regression test use,
@@ -59,7 +55,7 @@ func newS3Storer(t *testing.T) storage.Storer {
 		Bucket:          s3TestBucket,
 		AccessKeyID:     "test",
 		SecretAccessKey: "test",
-		Region:          s3TestRegion,
+		Region:          "us-east-1",
 	})
 	if err != nil {
 		t.Fatalf("new client: %v", err)
@@ -97,71 +93,8 @@ func TestS3StorerMissingKeyMapsToErrNotFound(t *testing.T) {
 	}
 }
 // TestS3ListingCutShortIsAnError checks that List and ListStream fail on a
 // listing page marked truncated that carries no continuation token, as a
 // server answering V2 listings V1-style sends it. Taken as the last page,
 // it would hide every later key: prune would treat the blobs of the
 // snapshots listed there as unreferenced, and a directory under metadata/
 // whose manifest is listed there as one with no manifest.
 func TestS3ListingCutShortIsAnError(t *testing.T) {
 	t.Parallel()
 	const (
 		prefix        = "metadata/"
 		truncatedPage = `<?xml version="1.0" encoding="UTF-8"?>
 <ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <Name>test-bucket</Name>
  <Prefix>metadata/</Prefix>
  <KeyCount>1</KeyCount>
  <MaxKeys>1</MaxKeys>
  <IsTruncated>true</IsTruncated>
  <Contents>
    <Key>metadata/snap/manifest.json.zst</Key>
    <Size>8</Size>
  </Contents>
 </ListBucketResult>`
 	)
 	srv := httptest.NewServer(http.HandlerFunc(
 		func(w http.ResponseWriter, _ *http.Request) {
 			_, _ = io.WriteString(w, truncatedPage)
 		}))
 	t.Cleanup(srv.Close)
 	client, err := s3.NewClient(context.Background(), s3.Config{
 		Endpoint:        srv.URL,
 		Bucket:          s3TestBucket,
 		AccessKeyID:     s3TestAccessKeyID,
 		SecretAccessKey: s3TestSecretAccessKey,
 		Region:          s3TestRegion,
 	})
 	if err != nil {
 		t.Fatalf("new client: %v", err)
 	}
 	storer := storage.NewS3Storer(client)
 	ctx := context.Background()
 	keys, err := storer.List(ctx, prefix)
 	if !errors.Is(err, s3.ErrNoContinuationToken) {
 		t.Errorf("List = %q, %v; want ErrNoContinuationToken", keys, err)
 	}
 	var streamErr error
 	for obj := range storer.ListStream(ctx, prefix) {
 		if obj.Err != nil {
 			streamErr = obj.Err
 		}
 	}
 	if !errors.Is(streamErr, s3.ErrNoContinuationToken) {
 		t.Errorf("ListStream error = %v, want ErrNoContinuationToken", streamErr)
 	}
 }
 // TestS3URLPrefixKeyLayout pins the bucket keys an s3:// URL reads and
-// writes: the layout in docs/REPOSTRUCTURE.md, with the prefix joined to
+// writes: the README's remote storage layout, with the prefix joined to
 // each key by one "/". s3://b/p and s3://b/p/ must be the same
 // destination, or a host that writes the URL the other way finds no
 // snapshots. The listed object is put straight into the bucket, as
@@ -14,7 +14,6 @@ import (
 	"context"
 	"errors"
 	"io"
 	"time"
 )
 // ErrNotFound is returned when an object does not exist.
@@ -28,10 +27,7 @@ type ProgressCallback func(bytesTransferred int64) error
 type ObjectInfo struct {
 	Key  string // Object key/path
 	Size int64  // Size in bytes
-	// ModTime is when the object was written, as the store reports it.
+	Err  error  // Error for streaming results (nil on success)
 	// Only ListStream sets it; Stat leaves it zero.
 	ModTime time.Time
 	Err     error // Error for streaming results (nil on success)
 }
 // Info provides human-readable storage configuration.
@@ -45,8 +41,7 @@ type Info struct {
 // directory for filesystem).
 type Storer interface {
 	// Put stores data at the specified key.
-	// The filesystem backend fails when its destination directory does
+	// Parent directories are created automatically for filesystem backends.
 	// not exist, and creates the directories below it as needed.
 	Put(ctx context.Context, key string, data io.Reader) error
 	// PutWithProgress stores data with progress reporting.
@@ -71,8 +66,7 @@ type Storer interface {
 	// For large result sets, prefer ListStream.
 	List(ctx context.Context, prefix string) ([]string, error)
-	// ListStream returns a channel of ObjectInfo, with each object's key,
+	// ListStream returns a channel of ObjectInfo for large result sets.
 	// size and modification time, for large result sets.
 	// The channel is closed when listing completes.
 	// If an error occurs during listing, the final item will have Err set.
 	ListStream(ctx context.Context, prefix string) <-chan ObjectInfo
@@ -30,12 +30,6 @@ var (
 		"storage URL must not carry credentials; " +
 			"set s3.access_key_id and s3.secret_access_key in the config instead")
 	ErrURLUnknownParam = errors.New("unknown query parameter in storage URL")
 	ErrURLBadQuery     = errors.New(
 		"storage URL query cannot be decoded; " +
 			"check it for a ; or a % not followed by two hex digits")
 	ErrRcloneRemoteParams = errors.New(
 		"rclone URL must not carry parameters in the remote name; " +
 			"set them on the remote with rclone config instead")
 )
 // URL represents a parsed storage URL.
@@ -96,9 +90,8 @@ func parseFileURL(rawPath string) (*URL, error) {
 }
 // parseS3URL parses an s3://bucket/prefix URL. It rejects credentials in
-// the userinfo or in the endpoint parameter's userinfo, a query that
+// the userinfo and any query parameter other than endpoint, region and
-// cannot be decoded, and any query parameter other than endpoint, region
+// ssl, so a credential-bearing URL is never stored or echoed.
 // and ssl, so a credential-bearing URL is never stored or echoed.
 func parseS3URL(rawURL string) (*URL, error) {
 	u, err := url.Parse(rawURL)
 	if err != nil {
@@ -114,26 +107,13 @@ func parseS3URL(rawURL string) (*URL, error) {
 		return nil, ErrMissingBucket
 	}
-	// u.Query() would silently drop a part it cannot decode, endpoint
+	query := u.Query()
 	// included. The decode error is not wrapped: it can quote the value.
 	query, err := url.ParseQuery(u.RawQuery)
 	if err != nil {
 		return nil, ErrURLBadQuery
 	}
 	err = rejectUnknownParams(query, "endpoint", "region", "ssl")
 	if err != nil {
 		return nil, err
 	}
 	// A host name never contains "@", so one in an endpoint, with or
 	// without a scheme, can only introduce userinfo.
 	for _, endpoint := range query["endpoint"] {
 		if strings.Contains(endpoint, "@") {
 			return nil, ErrURLCredentials
 		}
 	}
 	return &URL{
 		Scheme:   schemeS3,
 		Bucket:   bucket,
@@ -145,23 +125,9 @@ func parseS3URL(rawURL string) (*URL, error) {
 }
 // parseRcloneURL parses an rclone://remote/path URL. rclone:// takes no
-// query parameters, so credentials in the userinfo, parameters in the
+// query parameters, so credentials in the userinfo and any parameter at
 // remote name, a query that cannot be decoded and any query parameter at
 // all are rejected rather than silently ignored.
 func parseRcloneURL(rawURL string) (*URL, error) {
 	// The remote name runs up to the first "/", "?" or "#". It never
 	// contains a comma; one starts rclone's remote,param=value form,
 	// whose values can be credentials. This is checked before url.Parse,
 	// whose error for such a name can print part of it.
 	remote := strings.TrimPrefix(rawURL, "rclone://")
 	if end := strings.IndexAny(remote, "/?#"); end >= 0 {
 		remote = remote[:end]
 	}
 	if strings.Contains(remote, ",") {
 		return nil, ErrRcloneRemoteParams
 	}
 	u, err := url.Parse(rawURL)
 	if err != nil {
 		return nil, wrapParseError(err)
@@ -171,19 +137,12 @@ func parseRcloneURL(rawURL string) (*URL, error) {
 		return nil, ErrURLCredentials
 	}
-	remote = u.Host
+	remote := u.Host
 	if remote == "" {
 		return nil, ErrMissingRemote
 	}
-	// As in parseS3URL: u.Query() would drop a part it cannot decode, and
+	err = rejectUnknownParams(u.Query())
 	// the decode error can quote the value.
 	query, err := url.ParseQuery(u.RawQuery)
 	if err != nil {
 		return nil, ErrURLBadQuery
 	}
 	err = rejectUnknownParams(query)
 	if err != nil {
 		return nil, err
 	}
@@ -150,19 +150,6 @@ func TestParseStorageURLRejectsCredentials(t *testing.T) {
 			wantErr: storage.ErrURLCredentials,
 			secrets: []string{key, secret, "mybucket"},
 		},
 		{
 			name: "s3 userinfo in endpoint",
 			raw: "s3://mybucket?endpoint=https://" +
 				key + ":" + secret + "@minio.example.com",
 			wantErr: storage.ErrURLCredentials,
 			secrets: []string{key, secret},
 		},
 		{
 			name:    "s3 userinfo in endpoint without scheme",
 			raw:     "s3://mybucket?endpoint=" + key + ":" + secret + "@minio.example.com",
 			wantErr: storage.ErrURLCredentials,
 			secrets: []string{key, secret},
 		},
 		{
 			name:    "s3 unknown query param",
 			raw:     "s3://mybucket?access_key=" + key + "&secret=" + secret,
@@ -216,112 +203,6 @@ func TestParseStorageURLRejectsCredentials(t *testing.T) {
 	}
 }
 // TestParseStorageURLRejectsRcloneRemoteParams checks that an rclone
 // remote name carrying parameters (rclone's "remote,param=value" form,
 // which can hold a credential) is rejected without echoing the value,
 // including the URLs that url.Parse itself refuses.
 func TestParseStorageURLRejectsRcloneRemoteParams(t *testing.T) {
 	t.Parallel()
 	cases := []struct {
 		name    string
 		raw     string
 		secrets []string // must not appear in the error message
 	}{
 		{
 			name:    "configured remote",
 			raw:     "rclone://gdrive,client_secret=topsecret/backups",
 			secrets: []string{"topsecret"},
 		},
 		{
 			name:    "remote defined inline",
 			raw:     "rclone://:s3,access_key_id=KEY,secret_access_key=SECRET/bucket",
 			secrets: []string{"KEY", "SECRET"},
 		},
 		{
 			name:    "colon in a parameter value",
 			raw:     "rclone://gdrive,client_secret=ab:cd/backups",
 			secrets: []string{"cd"},
 		},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			_, err := storage.ParseStorageURL(tc.raw)
 			if !errors.Is(err, storage.ErrRcloneRemoteParams) {
 				t.Fatalf("ParseStorageURL(%q) error = %v, want %v",
 					tc.raw, err, storage.ErrRcloneRemoteParams)
 			}
 			for _, secret := range tc.secrets {
 				if strings.Contains(err.Error(), secret) {
 					t.Errorf("error message leaked %q: %v", secret, err.Error())
 				}
 			}
 		})
 	}
 }
 // TestParseStorageURLRejectsUndecodableQuery checks that an s3 or rclone
 // URL whose query cannot be decoded is rejected, not read with that part
 // of the query left out, and that the error does not echo it.
 func TestParseStorageURLRejectsUndecodableQuery(t *testing.T) {
 	t.Parallel()
 	const (
 		key    = "AKIAKEY"
 		secret = "topsecret"
 	)
 	cases := []struct {
 		name string
 		raw  string
 	}{
 		{
 			name: "semicolon",
 			raw: "s3://mybucket/prefix?endpoint=https://" + key + ":" + secret +
 				"@minio.example.com:9000;region=us-east-1",
 		},
 		{
 			name: "bad percent escape",
 			raw: "s3://mybucket/prefix?endpoint=https://" + key + ":" + secret +
 				"%zz@minio.example.com:9000",
 		},
 		{
 			name: "rclone semicolon",
 			raw:  "rclone://gdrive/backups?token=" + secret + ";x=1",
 		},
 		{
 			name: "rclone bad percent escape",
 			raw:  "rclone://gdrive/backups?token=" + secret + "%zz",
 		},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			_, err := storage.ParseStorageURL(tc.raw)
 			if err == nil {
 				t.Fatalf("ParseStorageURL(%q) returned no error", tc.raw)
 			}
 			if !errors.Is(err, storage.ErrURLBadQuery) {
 				t.Errorf("ParseStorageURL(%q) error = %v, want %v",
 					tc.raw, err, storage.ErrURLBadQuery)
 			}
 			for _, s := range []string{key, secret, "minio.example.com"} {
 				if strings.Contains(err.Error(), s) {
 					t.Errorf("error message leaked %q: %v", s, err.Error())
 				}
 			}
 		})
 	}
 }
 // TestParseStorageURLParseFailureHidesURL checks that when url.Parse
 // itself fails, the wrapped error carries only the inner cause, not the
 // *url.Error whose text embeds the raw (possibly credential-bearing) URL.
@@ -22,10 +22,6 @@ var errBlobHashMismatch = errors.New("blob hash mismatch")
 var errBlobNotFullyRead = errors.New(
 	"blob closed before fully read; hash not verified")
 // errWrongPrivateKeyForBlob is returned when the configured key parses
 // but is not one of the keys a blob was encrypted to.
 var errWrongPrivateKeyForBlob = errors.New("cannot decrypt this blob")
 // hashVerifyReader wraps a blobgen.Reader and verifies the double-SHA-256 hash
 // of decrypted plaintext when Close is called. It reuses the hash that
 // blobgen.Reader already computes internally via its TeeReader, avoiding
@@ -91,14 +87,10 @@ func (v *Vaultik) FetchAndDecryptBlob(
 		return nil, err
 	}
-	reader, err := v.newBlobReader(rc, identities)
+	reader, err := blobgen.NewReader(rc, identities...)
 	if err != nil {
 		_ = rc.Close()
 		if errors.Is(err, errWrongPrivateKeyForBlob) {
 			return nil, err
 		}
 		return nil, fmt.Errorf("creating blob reader: %w", err)
 	}
@@ -110,32 +102,7 @@ func (v *Vaultik) FetchAndDecryptBlob(
 	}, nil
 }
 // newBlobReader opens the decrypting reader for a blob. When none of the
 // identities can decrypt it, the error says in plain words that the
 // configured private key is not one of the keys the blob was encrypted
 // to and names where the key was configured.
 func (v *Vaultik) newBlobReader(
 	r io.Reader, identities []age.Identity,
 ) (*blobgen.Reader, error) {
 	blobReader, err := blobgen.NewReader(r, identities...)
 	if _, ok := errors.AsType[*age.NoIdentityMatchError](err); ok {
 		return nil, fmt.Errorf(
 			"%w: the private key in %s is not one of the keys the blob was encrypted to",
 			errWrongPrivateKeyForBlob, v.Config.AgeSecretKeySourceName())
 	}
 	if err != nil {
 		return nil, err
 	}
 	return blobReader, nil
 }
 // FetchBlob downloads a blob and returns a reader for the encrypted data.
 // The reader is closed as soon as ctx is cancelled, which ends a read
 // blocked inside it. A storage error is returned as is: restore and deep
 // verify name the blob in their own errors.
 func (v *Vaultik) FetchBlob(
 	ctx context.Context, blobHash string,
 ) (io.ReadCloser, error) {
@@ -150,50 +117,8 @@ func (v *Vaultik) FetchBlob(
 	rc, err := v.Storage.Get(ctx, blobPath)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("downloading blob %s: %w", shortHash(blobHash), err)
 	}
-	return newCloseOnCancelReader(ctx, rc), nil
+	return rc, nil
 }
 // closeOnCancelReader closes the reader it wraps when ctx is cancelled.
 // Not every backend's reader stops on cancel by itself (the file
 // backend's does not), and a read stalled on a slow or hung source would
 // otherwise outlast the shutdown timeout, so the process would exit
 // before restore or deep verify removed its decrypted temporary files.
 type closeOnCancelReader struct {
 	io.ReadCloser
 	ctx  context.Context //nolint:containedctx // Read reports its error
 	stop func() bool
 }
 func newCloseOnCancelReader(
 	ctx context.Context, rc io.ReadCloser,
 ) *closeOnCancelReader {
 	return &closeOnCancelReader{
 		ReadCloser: rc,
 		ctx:        ctx,
 		stop:       context.AfterFunc(ctx, func() { _ = rc.Close() }),
 	}
 }
 // Read returns the context's error, not the closed reader's, once ctx
 // has been cancelled.
 func (r *closeOnCancelReader) Read(p []byte) (int, error) {
 	n, err := r.ReadCloser.Read(p)
 	if err != nil && r.ctx.Err() != nil {
 		return n, r.ctx.Err()
 	}
 	return n, err
 }
 // Close closes the wrapped reader, unless the cancel already closed it.
 func (r *closeOnCancelReader) Close() error {
 	if !r.stop() {
 		return nil
 	}
 	return r.ReadCloser.Close()
 }
@@ -39,9 +39,9 @@ type blobDiskCacheEntry struct {
 // internally and will fall back to LRU eviction if curBytes exceeds
 // maxBytes. Restore passes math.MaxInt64 as maxBytes and drives
 // eviction itself via Delete() through restoreSweeper, which deletes
-// each blob once no file still to be restored in this run needs it.
+// each blob the moment every file that references its chunks has been
-// LRU never fires under that configuration; it is kept as a safety net
+// written. LRU never fires under that configuration; it is kept as a
-// for callers that don't manage eviction themselves.
+// safety net for callers that don't manage eviction themselves.
 //
 // Get/ReadAt/peak-Len counters are debugging instrumentation used by
 // tests to assert that the restore code path uses ReadAt rather than
@@ -137,7 +137,7 @@ func TestBackupAfterRemovingNewestSnapshotRestoresChangedFile(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	changedPath := filepath.Join(dataDir, "appended.bin")
@@ -184,7 +184,7 @@ func TestBackupAfterInterruptedRunRestoresChangedFile(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	changedPath := filepath.Join(dataDir, "appended.bin")
@@ -1,20 +1,15 @@
 package vaultik_test
 import (
 	"bytes"
 	"context"
 	"crypto/rand"
 	"io"
 	"os"
 	"path"
 	"path/filepath"
 	"testing"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/storage"
 	"sneak.berlin/go/vaultik/internal/ui"
 	"sneak.berlin/go/vaultik/internal/vaultik"
 )
@@ -35,7 +30,7 @@ func TestDeepVerifyAcceptsHealthyAndRejectsCorruptBlob(t *testing.T) {
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	chunkSize := int64(64 * 1024)
@@ -82,180 +77,6 @@ func TestDeepVerifyAcceptsHealthyAndRejectsCorruptBlob(t *testing.T) {
 		"deep verify should fail on a corrupted blob")
 }
 // TestDeepVerifyJSONCountsBlobs checks the verified and missing counts
 // that deep verify reports under --json: on a healthy snapshot, with a
 // damaged blob, and with missing blobs. Deep verify stops at the first
 // damaged blob, so the blobs read before it are the ones verified; when
 // blobs are missing it reads no blob contents, but counts every missing
 // blob.
 func TestDeepVerifyJSONCountsBlobs(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	fs := afero.NewOsFs()
 	ctx := context.Background()
 	storeDir := t.TempDir()
 	cfg, storer, snapshotID, keys := backUpSeveralBlobs(ctx, t, storeDir)
 	healthy, err := deepVerifyJSON(ctx, t, cfg, storer, snapshotID)
 	require.NoError(t, err)
 	require.Equal(t, "ok", healthy.Status)
 	require.Len(t, keys, healthy.BlobCount)
 	require.Equal(t, healthy.BlobCount, healthy.Verified)
 	require.Zero(t, healthy.Missing)
 	// Damage the last blob read, keeping its length, so every blob before
 	// it is read and passes first.
 	lastPath := filepath.Join(storeDir, keys[len(keys)-1])
 	blob, err := afero.ReadFile(fs, lastPath)
 	require.NoError(t, err)
 	blob[len(blob)/2] ^= 0xff
 	require.NoError(t, afero.WriteFile(fs, lastPath, blob, 0o600))
 	got, err := deepVerifyJSON(ctx, t, cfg, storer, snapshotID)
 	require.Error(t, err)
 	require.Equal(t, "failed", got.Status)
 	require.Equal(t, healthy.BlobCount-1, got.Verified)
 	require.Zero(t, got.Missing)
 	// Delete the first blob and the damaged last one: both must be
 	// counted as missing, not only the first one found.
 	var deletedSize int64
 	for _, key := range []string{keys[0], keys[len(keys)-1]} {
 		info, statErr := storer.Stat(ctx, key)
 		require.NoError(t, statErr)
 		deletedSize += info.Size
 		require.NoError(t, storer.Delete(ctx, key))
 	}
 	got, err = deepVerifyJSON(ctx, t, cfg, storer, snapshotID)
 	require.Error(t, err)
 	require.Equal(t, "failed", got.Status)
 	require.Equal(t, 2, got.Missing)
 	require.Equal(t, deletedSize, got.MissingSize)
 	require.Zero(t, got.Verified)
 }
 // TestDeepVerifyJSONCountsWrongSizeBlob checks that under --deep --json a
 // blob of the wrong size is counted in mismatched and fails the run, and
 // that the check goes on past it to count a missing blob after it. The
 // store is on disk, so the message must not call it S3.
 func TestDeepVerifyJSONCountsWrongSizeBlob(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	fs := afero.NewOsFs()
 	ctx := context.Background()
 	storeDir := t.TempDir()
 	cfg, storer, snapshotID, keys := backUpSeveralBlobs(ctx, t, storeDir)
 	// Make the first blob checked longer, and delete the last one.
 	firstPath := filepath.Join(storeDir, keys[0])
 	blob, err := afero.ReadFile(fs, firstPath)
 	require.NoError(t, err)
 	blob = append(blob, []byte("extra")...)
 	require.NoError(t, afero.WriteFile(fs, firstPath, blob, 0o600))
 	require.NoError(t, storer.Delete(ctx, keys[len(keys)-1]))
 	got, err := deepVerifyJSON(ctx, t, cfg, storer, snapshotID)
 	require.Error(t, err)
 	require.Equal(t, "failed", got.Status)
 	require.Equal(t, 1, got.Mismatched)
 	require.Equal(t, 1, got.Missing)
 	require.Zero(t, got.Verified)
 	require.Contains(t, got.ErrorMessage, "with the wrong size")
 	require.NotContains(t, got.ErrorMessage, "S3")
 }
 // TestDeepVerifyStopsOnBlobThatCannotBeChecked checks that a blob that is
 // present in storage but cannot be checked is not counted as missing:
 // deep verify stops and fails, saying it could not check the blob, with
 // the storage error.
 func TestDeepVerifyStopsOnBlobThatCannotBeChecked(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	storeDir := t.TempDir()
 	cfg, storer, snapshotID, keys := backUpSeveralBlobs(ctx, t, storeDir)
 	failing := statFailingStorer{Storer: storer, failKeys: []string{keys[0]}}
 	got, err := deepVerifyJSON(ctx, t, cfg, failing, snapshotID)
 	require.Error(t, err)
 	require.Equal(t, "failed", got.Status)
 	require.Zero(t, got.Missing)
 	require.Contains(t, got.ErrorMessage,
 		"could not check blob "+path.Base(keys[0]))
 	require.Contains(t, got.ErrorMessage, errStatDenied.Error())
 }
 // backUpSeveralBlobs backs up random data, which does not compress or
 // deduplicate, so it fills at least three blobs in a store on disk at
 // storeDir. It returns the blobs' storage keys sorted, which is hash
 // order, the order deep verify reads them in.
 func backUpSeveralBlobs(
 	ctx context.Context, t *testing.T, storeDir string,
 ) (*config.Config, *storage.FileStorer, string, []string) {
 	t.Helper()
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "source")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	chunkSize := int64(32 * 1024)
 	maxBlobSize := int64(128 * 1024)
 	data := make([]byte, maxBlobSize*4)
 	_, err := rand.Read(data)
 	require.NoError(t, err)
 	require.NoError(t, fs.MkdirAll(dataDir, 0o755))
 	require.NoError(t, afero.WriteFile(fs,
 		filepath.Join(dataDir, "data.bin"), data, 0o644))
 	cfg, storer, snapshotID := runFileStorageBackup(
 		ctx, t, fs, dataDir, storeDir, dbPath, chunkSize, maxBlobSize)
 	keys := storedBlobKeys(t, storeDir)
 	require.GreaterOrEqual(t, len(keys), 3)
 	return cfg, storer, snapshotID, keys
 }
 // deepVerifyJSON runs deep verify with --json on snapshotID and returns
 // the decoded result and the error RunDeepVerify returned.
 func deepVerifyJSON(
 	ctx context.Context, t *testing.T,
 	cfg *config.Config, storer storage.Storer, snapshotID string,
 ) (vaultik.VerifyResult, error) {
 	t.Helper()
 	var out bytes.Buffer
 	v := &vaultik.Vaultik{
 		Config:  cfg,
 		Storage: storer,
 		Fs:      afero.NewOsFs(),
 		Stdout:  &out,
 		Stderr:  io.Discard,
 		UI:      ui.NewWithColor(io.Discard, false),
 	}
 	v.SetContext(ctx)
 	err := v.RunDeepVerify(snapshotID,
 		&vaultik.VerifyOptions{Deep: true, JSON: true})
 	return decodeVerifyResult(t, out.Bytes()), err
 }
 // corruptOneBlob flips a middle byte of the first blob file found under
 // blobsDir, leaving the file length unchanged.
 func corruptOneBlob(t *testing.T, fs afero.Fs, blobsDir string) {
@@ -1,111 +0,0 @@
 package vaultik
 import (
 	"errors"
 	"fmt"
 	"strings"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/storage"
 )
 // destinationMarkerKey is the object every backup writes at the root of
 // the backup destination store. While the local index holds a snapshot
 // stored there, a destination that answers a look-up of it with not
 // found is treated as not present: an unplugged volume leaves an empty
 // directory at its mount point, which would otherwise read as a store
 // whose snapshots are all gone.
 const destinationMarkerKey = "vaultik-destination.txt"
 // destinationMarkerText is the whole content of the marker. It names no
 // host, path or time.
 const destinationMarkerText = "This is a vaultik backup destination store.\n"
 // errDestinationNotPresent is returned when the local index holds a
 // snapshot stored on the backup destination store and the store answers
 // that it has no marker.
 var errDestinationNotPresent = errors.New("backup destination store is not present")
 // checkDestinationMarker returns errDestinationNotPresent when the local
 // index holds a snapshot stored on the backup destination store and the
 // store answers that it has no marker. With no snapshot in the local
 // index, as on a first backup or on another machine, there is nothing to
 // check; nor when the local index is bound to a different destination
 // than the configured one, since its snapshots are stored there.
 //
 // A look-up of the marker that fails for any other reason than not
 // found is logged and otherwise ignored, because the check could not be
 // made: S3 refuses it to credentials that allow only PUT, which is all
 // a backup needs. The check exists for a file:// volume's empty mount
 // point, which always answers not found, and a destination that cannot
 // be reached fails on the next request made to it, such as the backup's
 // PUT of the marker.
 func (v *Vaultik) checkDestinationMarker() error {
 	ids, err := v.localSnapshotIDs()
 	if err != nil {
 		return fmt.Errorf("listing local snapshots: %w", err)
 	}
 	if len(ids) == 0 {
 		return nil
 	}
 	// Config is nil only in tests, which then record no binding (see
 	// checkStorageBinding).
 	if v.Config != nil {
 		stored, configured, err := v.storageBinding()
 		if err != nil {
 			return err
 		}
 		if stored != "" && stored != configured {
 			return nil
 		}
 	}
 	_, err = v.Storage.Stat(v.ctx, destinationMarkerKey)
 	if errors.Is(err, storage.ErrNotFound) {
 		return fmt.Errorf("%w: %s has no %s, but the local index holds "+
 			"snapshots stored there; mount the volume if it is removable, "+
 			"or if the destination was emptied on purpose, run "+
 			"'vaultik database delete' and back up again",
 			errDestinationNotPresent, v.Storage.Info().Location,
 			destinationMarkerKey)
 	}
 	// Info, not a warning: --cron must stay silent on a successful
 	// backup from a host whose credentials allow only PUT.
 	if err != nil {
 		log.Info("Could not check the backup destination store for its marker",
 			"key", destinationMarkerKey, "error", err)
 	}
 	return nil
 }
 // markDestination refuses a local index bound to a different
 // destination, checks the backup destination store for its marker,
 // writes the marker, and then records the binding. A first backup marks
 // its destination and a later one writes the same text again. The
 // binding is recorded last, so a first backup that cannot write to the
 // destination leaves the local index unbound.
 func (v *Vaultik) markDestination() error {
 	err := v.checkStorageBinding()
 	if err != nil {
 		return err
 	}
 	err = v.checkDestinationMarker()
 	if err != nil {
 		return err
 	}
 	err = v.Storage.Put(v.ctx, destinationMarkerKey,
 		strings.NewReader(destinationMarkerText))
 	if err != nil {
 		return fmt.Errorf("writing %s to the backup destination store: %w",
 			destinationMarkerKey, err)
 	}
 	return v.EnsureStorageBinding()
 }
@@ -1,331 +0,0 @@
 package vaultik_test
 import (
 	"bytes"
 	"context"
 	"os"
 	"path/filepath"
 	"testing"
 	"time"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/log"
 	"sneak.berlin/go/vaultik/internal/storage"
 	"sneak.berlin/go/vaultik/internal/storage/faultstore"
 	"sneak.berlin/go/vaultik/internal/vaultik"
 )
 // These tests cover https://git.eeqj.de/sneak/vaultik/issues/239: a
 // file:// destination at a volume's mount point leaves an empty directory
 // behind when the volume is unplugged. While the local index holds
 // snapshots, a destination that answers that it has no
 // vaultik-destination.txt is not present, so no command may write to it
 // or conclude from it that the local snapshots are gone.
 // markerFile is the name of the file a backup writes at the root of the
 // destination.
 const markerFile = "vaultik-destination.txt"
 // backUpThenUnplugMountPoint backs up to a file:// destination, then
 // moves the destination directory away and leaves an empty directory in
 // its place, as unplugging a volume mounted there would. It returns the
 // path of that empty directory.
 func backUpThenUnplugMountPoint(
 	ctx context.Context, t *testing.T,
 ) (*vaultik.Vaultik, *database.Repositories, *bytes.Buffer, string) {
 	t.Helper()
 	storeDir := filepath.Join(t.TempDir(), "mnt")
 	v, repos, out := backUpToFileDestination(ctx, t, storeDir)
 	require.NoError(t, os.Rename(storeDir, storeDir+"-unplugged"))
 	require.NoError(t, os.Mkdir(storeDir, 0o750))
 	return v, repos, out, storeDir
 }
 // assertUntouched checks that the local index still holds its one
 // snapshot and that nothing was written to the empty mount point.
 func assertUntouched(
 	ctx context.Context, t *testing.T,
 	repos *database.Repositories, storeDir string,
 ) {
 	t.Helper()
 	snapshots, err := repos.Snapshots.ListRecent(ctx, listRecentTestLimit)
 	require.NoError(t, err)
 	assert.Len(t, snapshots, 1, "no local snapshot record may be deleted")
 	entries, err := os.ReadDir(storeDir)
 	require.NoError(t, err)
 	assert.Empty(t, entries, "nothing may be written to the empty mount point")
 }
 // TestFirstBackupWritesMarker checks that a backup writes the marker
 // file at the root of the destination.
 func TestFirstBackupWritesMarker(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	storeDir := t.TempDir()
 	backUpToFileDestination(context.Background(), t, storeDir)
 	assert.FileExists(t, filepath.Join(storeDir, markerFile))
 }
 // TestBackupRefusesDestinationWithoutMarker checks that snapshot create
 // --prune writes nothing and drops no local snapshot record when the
 // destination has no marker.
 func TestBackupRefusesDestinationWithoutMarker(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	v, repos, _, storeDir := backUpThenUnplugMountPoint(ctx, t)
 	err := v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
 		Cron:  true,
 		Prune: true,
 	})
 	require.ErrorContains(t, err, markerFile)
 	assertUntouched(ctx, t, repos, storeDir)
 }
 // TestBackupGoesOnWhenMarkerCannotBeChecked checks that a backup goes on
 // and writes the marker when looking it up fails with an error other
 // than not found, as S3 answers credentials that allow only PUT
 // (https://git.eeqj.de/sneak/vaultik/issues/389), and that a marker
 // that is not found still stops it.
 func TestBackupGoesOnWhenMarkerCannotBeChecked(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	storeDir := t.TempDir()
 	v, repos, _ := backUpToFileDestination(ctx, t, storeDir)
 	// Removed so the test sees the backup write it again: with the
 	// look-up failing, the backup cannot tell that it is gone.
 	markerPath := filepath.Join(storeDir, markerFile)
 	require.NoError(t, os.Remove(markerPath))
 	store := faultstore.New(v.Storage)
 	store.OnStat = func(key string) bool { return key == markerFile }
 	v.Storage = store
 	require.NoError(t, backUp(v, "second"))
 	localSnapshotID(ctx, t, repos, "second")
 	assert.FileExists(t, markerPath)
 	require.NoError(t, os.Remove(markerPath))
 	store.OnStat = nil
 	require.ErrorContains(t, backUp(v, "third"), markerFile)
 }
 // TestBackupChecksMarkerBeforeDroppingIncompleteSnapshots checks that
 // snapshot create writes nothing when the local index holds only an
 // incomplete snapshot and the destination has no marker. The backup drops
 // incomplete snapshots before it scans; checked after that, the local
 // index would hold none and nothing would be checked.
 func TestBackupChecksMarkerBeforeDroppingIncompleteSnapshots(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	storeDir := t.TempDir()
 	v, repos := newFileDestinationVaultik(ctx, t, storeDir)
 	require.NoError(t, repos.Snapshots.Create(ctx, nil, &database.Snapshot{
 		ID:        "host_first_2026-01-02T03:04:05Z",
 		Hostname:  "host",
 		StartedAt: time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC),
 	}))
 	err := backUp(v, "first")
 	require.ErrorContains(t, err, markerFile)
 	assertUntouched(ctx, t, repos, storeDir)
 }
 // TestPruneRefusesDestinationWithoutMarker checks that prune fails and
 // deletes no local snapshot record when the destination has no marker.
 func TestPruneRefusesDestinationWithoutMarker(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	v, repos, _, storeDir := backUpThenUnplugMountPoint(ctx, t)
 	err := v.Prune(&vaultik.PruneOptions{Force: true})
 	require.ErrorContains(t, err, markerFile)
 	assertUntouched(ctx, t, repos, storeDir)
 }
 // TestPurgeRefusesDestinationWithoutMarker checks that snapshot purge
 // fails and deletes no local snapshot record when the destination has no
 // marker.
 func TestPurgeRefusesDestinationWithoutMarker(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	v, repos, _, storeDir := backUpThenUnplugMountPoint(ctx, t)
 	err := v.PurgeSnapshotsWithOptions(&vaultik.SnapshotPurgeOptions{
 		KeepLatest: true,
 		Force:      true,
 	})
 	require.ErrorContains(t, err, markerFile)
 	assertUntouched(ctx, t, repos, storeDir)
 }
 // TestNukeRemoteRefusesDestinationWithoutMarker checks that remote nuke
 // fails, deletes no local snapshot record, and neither reports the
 // destination empty nor advises running nuke again when the destination
 // has no marker.
 func TestNukeRemoteRefusesDestinationWithoutMarker(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	v, repos, out, storeDir := backUpThenUnplugMountPoint(ctx, t)
 	err := v.NukeRemote(true)
 	require.ErrorContains(t, err, markerFile)
 	assert.NotContains(t, out.String(), "now empty")
 	assert.NotContains(t, out.String(), "vaultik remote nuke --force")
 	assertUntouched(ctx, t, repos, storeDir)
 }
 // TestRemoveSnapshotWarnsWhenDestinationHasNoMarker checks that snapshot
 // remove warns that the metadata could not be removed from a destination
 // without a marker, instead of reporting that it was.
 func TestRemoveSnapshotWarnsWhenDestinationHasNoMarker(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	v, repos, out, _ := backUpThenUnplugMountPoint(ctx, t)
 	result, err := v.RemoveSnapshot(localSnapshotID(ctx, t, repos, "first"),
 		&vaultik.RemoveOptions{Force: true})
 	require.NoError(t, err)
 	assert.False(t, result.RemoteRemoved)
 	assert.Contains(t, out.String(),
 		"Could not remove snapshot metadata from remote")
 	assert.Contains(t, out.String(), markerFile)
 	assert.NotContains(t, out.String(),
 		"Removed snapshot metadata from remote storage")
 }
 // TestRemoveSnapshotOnlyOnDestinationFailsWithoutMarker checks that
 // snapshot remove, for a snapshot that is only on the destination, fails
 // saying the destination is not present when it has no marker, instead
 // of saying the snapshot does not exist.
 func TestRemoveSnapshotOnlyOnDestinationFailsWithoutMarker(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	storeDir := filepath.Join(t.TempDir(), "mnt")
 	v, repos, _ := backUpToFileDestination(ctx, t, storeDir)
 	require.NoError(t, backUp(v, "second"))
 	id := localSnapshotID(ctx, t, repos, "first")
 	_, err := v.RemoveSnapshot(id,
 		&vaultik.RemoveOptions{Force: true, LocalOnly: true})
 	require.NoError(t, err)
 	// Unplug the volume: an empty directory stays at its mount point.
 	require.NoError(t, os.Rename(storeDir, storeDir+"-unplugged"))
 	require.NoError(t, os.Mkdir(storeDir, 0o750))
 	_, err = v.RemoveSnapshot(id, &vaultik.RemoveOptions{Force: true})
 	require.ErrorContains(t, err, markerFile)
 	require.ErrorContains(t, err, "mount the volume")
 	assertUntouched(ctx, t, repos, storeDir)
 }
 // TestListSnapshotsWarnsWhenDestinationHasNoMarker checks that snapshot
 // list warns and shows the local index alone when the destination has no
 // marker, without reporting the local snapshot as missing from it.
 func TestListSnapshotsWarnsWhenDestinationHasNoMarker(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	v, repos, out, _ := backUpThenUnplugMountPoint(ctx, t)
 	id := localSnapshotID(ctx, t, repos, "first")
 	require.NoError(t, v.ListSnapshots(false))
 	assert.Contains(t, out.String(), "Could not list backup destination store")
 	assert.Contains(t, out.String(), markerFile)
 	assert.Contains(t, out.String(), id)
 	assert.NotContains(t, out.String(), "not found in backup destination store")
 }
 // TestListSnapshotsAfterStorageURLChangeToEmptyDirectory checks that
 // snapshot list, after storage_url is changed to an empty directory,
 // warns only that the local index is bound to a different destination:
 // the local snapshots are stored at the old one, so the new one's lack
 // of a marker says nothing. With --json the local row is not on the new
 // destination, so remote_present is false, not unknown.
 func TestListSnapshotsAfterStorageURLChangeToEmptyDirectory(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	ctx := context.Background()
 	v, repos, out := backUpToFileDestination(ctx, t, t.TempDir())
 	id := localSnapshotID(ctx, t, repos, "first")
 	newDir := t.TempDir()
 	store, err := storage.NewFileStorer(newDir)
 	require.NoError(t, err)
 	v.Storage = store
 	v.Config.StorageURL = "file://" + newDir
 	require.NoError(t, v.ListSnapshots(false))
 	assert.Contains(t, out.String(), id)
 	assert.Contains(t, out.String(),
 		"local index is bound to a different backup destination")
 	assert.NotContains(t, out.String(), "Could not list backup destination store")
 	assert.NotContains(t, out.String(), markerFile)
 	out.Reset()
 	require.NoError(t, v.ListSnapshots(true))
 	rows := decodeListJSON(t, out.String())
 	require.Len(t, rows, 1)
 	require.NotNil(t, rows[0].RemotePresent)
 	assert.False(t, *rows[0].RemotePresent)
 }
 // TestBackupAfterNukeRemoteSucceeds checks that remote nuke leaves the
 // destination ready for a new first backup, which writes the marker
 // again.
 func TestBackupAfterNukeRemoteSucceeds(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 	storeDir := t.TempDir()
 	v, _, _ := backUpToFileDestination(context.Background(), t, storeDir)
 	require.NoError(t, v.NukeRemote(true))
 	assert.NoFileExists(t, filepath.Join(storeDir, markerFile))
 	require.NoError(t, backUp(v, "second"))
 	assert.FileExists(t, filepath.Join(storeDir, markerFile))
 }
@@ -161,14 +161,13 @@ func TestVerifyManifestBlobsRejectsShortHash(t *testing.T) {
 		Blobs: []snapshot.BlobInfo{{Hash: "abc", CompressedSize: 1}},
 	}
-	verified, missing, mismatched, missingSize, unchecked, err :=
+	verified, missing, mismatched, missingSize, err :=
 		v.verifyManifestBlobs(manifest, &VerifyOptions{JSON: true})
 	require.ErrorIs(t, err, errInvalidBlobHash)
 	require.Zero(t, verified)
 	require.Zero(t, missing)
 	require.Zero(t, mismatched)
 	require.Zero(t, missingSize)
 	require.Empty(t, unchecked)
 }
 // TestVerifyBlobChunksRejectsNegativeLength proves a blob_chunks row with a
@@ -192,7 +192,7 @@ func assertRestoreRejectsDamagedBlob(
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
@@ -238,7 +238,7 @@ func TestDeepVerifyCatchesLyingBackend(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	ctx := context.Background()
@@ -290,7 +290,7 @@ func TestInterruptedBlobUploadRecordsNoUploadedBlob(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	ctx := context.Background()
@@ -298,6 +298,10 @@ func TestInterruptedBlobUploadRecordsNoUploadedBlob(t *testing.T) {
 	writeFaultSourceTree(t, fs, dataDir)
 	// No upload succeeds, so nothing creates the destination directory.
 	// It must exist for the listing below to show that no blob survived.
 	require.NoError(t, os.Mkdir(storeDir, 0o750))
 	inner, err := storage.NewFileStorer(storeDir)
 	require.NoError(t, err)
@@ -361,7 +365,7 @@ func TestBackupRetryAfterInterruptedUploadIsRestorable(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
@@ -425,7 +429,7 @@ func TestBackupSurvivesMetadataExportInterruption(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	ctx := context.Background()
@@ -441,10 +445,6 @@ func TestBackupSurvivesMetadataExportInterruption(t *testing.T) {
 	repos := database.NewRepositories(db)
 	// snapshot create writes the marker; this backup runs its steps one
 	// by one, so the marker is written here.
 	require.NoError(t, inner.Put(ctx, markerFile, strings.NewReader("")))
 	// Back up and complete with a working backend.
 	sm := newFaultSnapshotManager(fs, inner, cfg, repos)
 	scanner := newFaultScanner(fs, inner, cfg, repos)
@@ -493,14 +493,8 @@ func TestBackupSurvivesMetadataExportInterruption(t *testing.T) {
 		"shallow verify must report the missing manifest")
 	// snapshot list must not crash on the partial snapshot.
 	var listOut strings.Builder
 	reader.UI = ui.NewWithColor(&listOut, false)
 	require.NoError(t, reader.ListSnapshots(false),
 		"snapshot list must tolerate a partially-exported snapshot")
 	assert.NotContains(t, listOut.String(),
 		"Could not list backup destination store",
 		"snapshot list must read the partial snapshot from the destination")
 }
 // Scenario 2, repair: the process dies during the metadata export of a
@@ -517,7 +511,7 @@ func TestBackupCompletesOnlyAfterMetadataExport(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
@@ -667,19 +661,17 @@ func faultScannerFactory(
 ) snapshot.ScannerFactory {
 	return func(params snapshot.ScannerParams) *snapshot.Scanner {
 		return snapshot.NewScanner(snapshot.ScannerConfig{
-			FS:                 params.Fs,
+			FS:               params.Fs,
-			Storage:            storer,
+			Storage:          storer,
-			ChunkSize:          faultChunkSize,
+			ChunkSize:        faultChunkSize,
-			MaxBlobSize:        faultMaxBlobSize,
+			MaxBlobSize:      faultMaxBlobSize,
-			CompressionLevel:   cfg.CompressionLevel,
+			CompressionLevel: cfg.CompressionLevel,
-			AgeRecipients:      cfg.AgeRecipients,
+			AgeRecipients:    cfg.AgeRecipients,
-			Repositories:       repos,
+			Repositories:     repos,
-			EnableProgress:     params.EnableProgress,
+			EnableProgress:   params.EnableProgress,
-			UI:                 params.UI,
+			UI:               params.UI,
-			Exclude:            params.Exclude,
+			Exclude:          params.Exclude,
-			SkipErrors:         params.SkipErrors,
+			SkipErrors:       params.SkipErrors,
 			PreviousSnapshotID: params.PreviousSnapshotID,
 			DeviceNumber:       params.DeviceNumber,
 		})
 	}
 }
@@ -694,7 +686,7 @@ func TestRestoreReportsDiskFull(t *testing.T) {
 	osFS := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := t.TempDir()
+	storeDir := filepath.Join(tempDir, "remote")
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
@@ -89,6 +89,22 @@ type SnapshotInfo struct {
 	RemotePresent    *bool            `json:"remote_present"`
 }
 // formatBytes formats bytes in a human-readable format
 func formatBytes(bytes int64) string {
 	const unit = 1024
 	if bytes < unit {
 		return fmt.Sprintf("%d B", bytes)
 	}
 	div, exp := int64(unit), 0
 	for n := bytes / unit; n >= unit; n /= unit {
 		div *= unit
 		exp++
 	}
 	return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
 }
 // parseSnapshotTimestamp extracts the timestamp from a snapshot ID
 // Format: hostname_snapshotname_2026-01-12T14:41:15Z
 func parseSnapshotTimestamp(snapshotID string) (time.Time, error) {