Record the defect-hunt fixes in TODO.md Completed Steps (closes #334 )

Adds a Completed Steps entry, newest first, for every issue from the defect hunt (#288) that a merged fix closed and that had none: the hunt's own issues, those filed while fixing them, and the owner's ruling on #239. Each entry says in one or two sentences what was wrong and what changed; the detail is in each fix's commit. Next Step now says the hunt's fixes have landed. Judgement call: #332, closed as covered by the fix for #296, is named in that entry rather than given its own. Judgement call: #351, a Docker build fix filed while gating these fixes, gets an entry. Model: opus-5-5
Do not prune after a backup that skipped unreadable files (closes #382 )
2026-10-14 09:18:09 +02:00 · 2026-10-14 07:44:50 +02:00 · 2026-10-14 07:13:48 +02:00 · 2026-10-14 06:47:38 +02:00 · 2026-10-14 06:46:45 +02:00 · 2026-10-14 05:46:42 +02:00
59 changed files with 2541 additions and 327 deletions
@@ -279,8 +279,8 @@ Key methods:
 - `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
+1. **Phase 1**: Walk directory, identify files needing processing
+2. **Phase 1b**: Count as deleted the files that the previous snapshot of the same name lists, the walk did not find, and are gone from disk; a file that is excluded, or inside an excluded directory, is not counted
 3. **Phase 2**: Process files (chunk → pack → upload)

 #### SnapshotManager
@@ -311,6 +311,8 @@ Repository interfaces:

 ```
 CreateSnapshot(opts)
+    │
+    ├─► markDestination()   // Refuse a destination without the marker, then write it
    │
    ├─► PruneDatabase()   // Critical: avoid dedup errors
    │
@@ -320,13 +322,13 @@ CreateSnapshot(opts)
    │       │
    │       ├─► scanner.Scan(ctx, path, snapshotID)
    │       │       │
-    │       │       ├─► Phase 0: detectDeletedFiles()
-    │       │       │
    │       │       ├─► Phase 1: scanPhase()
    │       │       │       Walk directory
    │       │       │       Check file metadata changes
    │       │       │       Build list of files to process
    │       │       │
+    │       │       ├─► Phase 1b: detectDeletedFiles()
+    │       │       │
    │       │       └─► Phase 2: processPhase()
    │       │               For each file:
    │       │                   chunker.ChunkReaderStreaming()
@@ -357,7 +359,7 @@ CreateSnapshot(opts)

 ## 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
+1. **File-level**: Files and symlinks unchanged since last backup are skipped (metadata comparison: size, mtime, mode, uid, gid, and a symlink's target), 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.

@@ -367,6 +369,8 @@ CreateSnapshot(opts)

 ```
 bucket/
+├── vaultik-destination.txt          # Marker written by every backup
+│
 ├── blobs/
 │   └── {hash[0:2]}/
 │       └── {hash[2:4]}/
@@ -378,6 +382,16 @@ bucket/
        └── manifest.json.zst        # Blob list (for pruning/verification)
 ```

+A destination without `vaultik-destination.txt` is treated as not present
+while the local index holds snapshots stored there (`checkDestinationMarker`
+in `internal/vaultik/destination_marker.go`): `snapshot create` refuses to
+write to it, `prune`, `snapshot purge` and `remote nuke` fail, and
+`snapshot list` and `snapshot remove` behave as for a destination that cannot
+be listed. This keeps those commands from taking an unplugged volume's empty
+mount point for a destination whose snapshots are all gone. The `file://`
+backend never creates its destination directory, so a write to a missing one
+fails.
+
 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
@@ -24,6 +24,10 @@ grep 'public key' vaultik_backup_private_key.txt
 vaultik config set age_recipients.0 age1YOUR_PUBLIC_KEY_HERE
 vaultik config set storage_url "file:///Volumes/usbstick/mybackup"

+# create the destination directory; vaultik never creates it, so a backup
+# to a volume that is not plugged in fails instead of filling the disk
+mkdir /Volumes/usbstick/mybackup
+
 # macOS only: grant your terminal app Full Disk Access first
 # (System Settings → Privacy & Security → Full Disk Access), otherwise
 # the backup will abort with a permission error on protected directories
@@ -178,7 +182,7 @@ vaultik version
 * `--verbose`, `-v`: Enable verbose output (on stderr — see below)
 * `--debug`: Enable debug output (on stderr — see below)
 * `--quiet`, `-q`: Suppress non-error output (also suppresses startup banner)
-* `--skip-errors`: Skip files that cannot be read when creating a snapshot, or that cannot be restored when restoring, instead of aborting. Packing and storage errors while creating a snapshot (which would leave a chunk recorded but not stored) still abort the run.
+* `--skip-errors`: Skip files that cannot be read when creating a snapshot, or that cannot be restored when restoring, instead of aborting. Packing and storage errors while creating a snapshot (which would leave a chunk recorded but not stored) still abort the run. A run that skipped anything still finishes but exits non-zero: `snapshot create` keeps the snapshot and counts each file or directory it skipped as failed. A file removed during the backup is also counted as failed but does not change the exit status.

 ### locking

@@ -293,11 +297,19 @@ value where a list belongs or a word where a number belongs), is refused.
  (for crontab)
 * `--prune`: After backup, drop older snapshots of each backed-up name and
  remove orphaned blobs from remote storage. By default keeps only the latest
-  snapshot per name; use `--keep-newer-than` for a rolling window.
+  snapshot per name; use `--keep-newer-than` for a rolling window. When
+  `--skip-errors` skipped a file or directory it could not read or list, the
+  prune does not run and every older snapshot is kept, since one of them may
+  be the only one that holds what was skipped; the command says so and exits
+  non-zero. A file removed during the backup does not stop the prune.
 * `--keep-newer-than <duration>`: With `--prune`, keep snapshots newer than
  this duration instead of only the latest (e.g. `4w`, `30d`, `6mo`, `1y`).
  Without `--prune`, or with a value that is not a valid duration, the
  command fails before the backup starts.
+* Fails before it writes anything when a `file://` destination directory
+  does not exist, or when the local index holds snapshots and the
+  destination has no `vaultik-destination.txt` (see
+  [remote storage layout](#remote-storage-layout))

 **`snapshot list`**: Show every snapshot known to this host — the union
 of the local index and the backup destination store — with timestamps
@@ -331,7 +343,10 @@ gives: revert the configuration, or run `vaultik database delete`.

 If the destination store cannot be listed (unmounted volume,
 permission denied, network down), the command warns, falls back to the
-local index alone, and still exits zero.
+local index alone, and still exits zero. It does the same when the
+destination has no `vaultik-destination.txt` while the local index
+holds snapshots stored there, as when a volume mounted at the
+destination is unplugged and leaves its empty mount point behind.
 * `--json`: Output in JSON format. Each entry carries `locally_tracked`
  (whether the snapshot is in the local index), `remote_key` (the full
  64-character storage key), and `remote_present` (whether it was seen
@@ -373,13 +388,14 @@ snapshot in the local index or on the destination store is an error;
 with `--local-only`, the snapshot must be in the local index. Local row
 cleanup (files, chunks, blobs the snapshot was the last referrer for)
 runs automatically. If removing the snapshot's metadata from the
-destination store fails (for example because the store is unreachable),
-the local-DB removal still completes and a warning is emitted; run
-`vaultik snapshot remove <snapshot-id>` again once the store is reachable
-to remove 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 everything on the destination in one go, use `vaultik
-remote nuke --force`.
+destination store fails (for example because the store is unreachable,
+or the local index holds snapshots and the destination has no
+`vaultik-destination.txt`), the local-DB removal still completes and a
+warning is emitted; run `vaultik snapshot remove <snapshot-id>` again
+once the store is reachable to remove 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 everything on the
+destination in one go, use `vaultik remote nuke --force`.
 * `--local-only`: Skip remote cleanup; only touch the local index
 * `--dry-run`: Show what would be deleted without deleting
 * `--force`: Skip confirmation prompt
@@ -410,8 +426,12 @@ manifest on the destination store to compute the still-referenced blob
 set and delete any blob not in that set. Step (3) reads all remote
 manifests — network cost scales with the number of snapshots. `snapshot
 create --prune` runs the same cleanup automatically; this is the
-manual entry point for the same work. If a blob cannot be deleted, the
-command (and `snapshot create --prune`) exits non-zero.
+manual entry point for the same work. If the destination store cannot
+be listed, or the local index holds snapshots and the destination has
+no `vaultik-destination.txt` (an unplugged volume's empty mount point),
+prune fails and deletes nothing. `snapshot purge` does the same. If a
+blob cannot be deleted, the command (and `snapshot create --prune`)
+exits non-zero.
 * `--force`: Skip confirmation prompt
 * `--json`: Output stats as JSON. Also skips the confirmation prompt, as
  `--force` does. A blob that cannot be deleted is counted in
@@ -435,11 +455,17 @@ since `prune` never deletes it.
 * `--json`: Output as JSON

 **`remote nuke`**: Delete every object under `metadata/` and `blobs/` on
-the backup destination store, whatever its name, leaving the bucket prefix
-empty. Destructive and irreversible. This is the single supported way to
-wipe the entire destination store. If a listing afterwards still finds
-anything there, the command names each object left and exits non-zero;
-running it again deletes what is left.
+the backup destination store, whatever its name, and then
+`vaultik-destination.txt`, leaving the bucket prefix empty. Destructive
+and irreversible. This is the single supported way to wipe the entire
+destination store. A snapshot is removed from the local index only once
+its metadata is deleted from the destination store. If the destination
+store cannot be listed, or the local index holds snapshots and the
+destination has no `vaultik-destination.txt` (an unplugged volume's
+empty mount point), the command fails before it removes anything. If a
+listing afterwards still finds anything under `metadata/` or `blobs/`,
+the command names each object left and exits non-zero; running it again
+deletes what is left.
 * `--force`: Required to confirm destruction.

 **`database delete`**: Delete the local SQLite state database file
@@ -464,7 +490,12 @@ object store. Credentials are read from `s3.access_key_id` and
 a local or mounted filesystem. Useful for testing or backing up to a NAS. The
 path must be absolute; a relative one is refused when the config loads.
 Percent-escapes in the path are decoded, so `my%20stick` and `my stick` name
-the same directory.
+the same directory. The directory must exist before the first backup: vaultik
+never creates it. A directory on a removable volume is gone while the volume is
+not mounted, so a backup then fails instead of writing to the disk under the
+mount point. The mount point itself stays behind when the volume is unplugged:
+there only `vaultik-destination.txt` stops such a backup, and only while the
+local index holds snapshots.

 **Rclone** (`rclone://remote/path`): Uses rclone's 70+ supported cloud
 providers. Requires rclone to be configured separately (`rclone config`).
@@ -495,6 +526,7 @@ For an implementation-level view of the internals — the data model, the

 ```
 <bucket>/<prefix>/
+├── vaultik-destination.txt     # Marker written by every backup
 ├── blobs/
 │   └── <aa>/<bb>/<full_blob_hash>
 └── metadata/
@@ -503,6 +535,16 @@ For an implementation-level view of the internals — the data model, the
        └── manifest.json.zst   # Unencrypted blob list (for pruning)
 ```

+* `vaultik-destination.txt` holds one fixed line of text, with no host
+  name, path or time. A destination without it is treated as not
+  present while the local index holds snapshots stored there:
+  `snapshot create` refuses to write to it, `prune`, `snapshot purge`
+  and `remote nuke` fail, and `snapshot list` and `snapshot remove`
+  behave as for a destination that cannot be listed. This keeps an
+  unplugged volume's empty mount point from being taken for a
+  destination whose snapshots are all gone. Mount
+  the volume if it is removable; if the destination was emptied on
+  purpose, run `vaultik database delete` and back up again.
 * Blobs are two-level directory sharded using the first 4 hex chars of the blob hash
 * `db.zst.age` is a binary SQLite database (zstd compressed, age encrypted)
  containing all file metadata, chunk mappings, and relationships for the snapshot
@@ -15,13 +15,229 @@ pre-1.0
 # Next Step

 The 1.0 work is complete on `next`: the scope settled on
-[issue #125](https://git.eeqj.de/sneak/vaultik/issues/125) was the work
-already planned for 1.0, and all of it has landed. The mechanism to cut
-the tag exists and is exercised; what is left is merging `next` to
-`main` and tagging, both the owner's.
+[issue #125](https://git.eeqj.de/sneak/vaultik/issues/125) has landed,
+and so has every fix from the defect hunt before the release candidate
+([issue #288](https://git.eeqj.de/sneak/vaultik/issues/288)). What is
+left is merging `next` to `main` and tagging the release, both the
+owner's; a `v*` tag runs the release build in
+`.gitea/workflows/release.yml`.

 # Completed Steps

+- 2026-10-14: Stopped `snapshot create --prune` pruning after a backup
+  that skipped files it could not read
+  ([issue #382](https://git.eeqj.de/sneak/vaultik/issues/382)). Such a
+  prune could delete the only snapshot still holding those files.
+
+- 2026-10-14: Made `snapshot create --skip-errors` exit non-zero,
+  instead of 0, when it skips anything it cannot read
+  ([issue #310](https://git.eeqj.de/sneak/vaultik/issues/310)).
+
+- 2026-10-14: Kept the local index when `remote nuke` cannot list or
+  find the destination store
+  ([issue #292](https://git.eeqj.de/sneak/vaultik/issues/292)). Nuke
+  had cleared the local snapshot records anyway; it now fails before
+  removing anything.
+
+- 2026-10-14: Stopped counting directories and unchanged symlinks as
+  files to back up
+  ([issue #305](https://git.eeqj.de/sneak/vaultik/issues/305)).
+
+- 2026-10-14: Refused a backup destination that an unplugged volume
+  left empty, as the owner ruled
+  ([issue #239](https://git.eeqj.de/sneak/vaultik/issues/239)). Every
+  backup now writes `vaultik-destination.txt` at the destination root,
+  and while the local index holds snapshots stored there, a destination
+  without it is treated as not present.
+
+- 2026-10-14: Warned about restored ownership only when an entry's
+  owner or group differs from the recorded one
+  ([issue #316](https://git.eeqj.de/sneak/vaultik/issues/316)); a
+  restore by a non-root user had warned even when none did.
+
+- 2026-10-14: Made `snapshot list` report a changed destination instead
+  of advising `prune`, which refuses in that case
+  ([issue #317](https://git.eeqj.de/sneak/vaultik/issues/317)).
+
+- 2026-10-14: Counted a file as deleted by a backup only if the
+  previous snapshot of the same name listed it
+  ([issue #304](https://git.eeqj.de/sneak/vaultik/issues/304)); files
+  that snapshot did not list had been counted too.
+
+- 2026-10-14: Named each prefix once in restore, verify and purge
+  errors, some of which repeated it
+  ([issue #327](https://git.eeqj.de/sneak/vaultik/issues/327)). A deep
+  verify log line that named S3 whatever the destination now names
+  storage.
+
+- 2026-10-14: Refused credentials in a storage URL's endpoint or rclone
+  remote name, which were accepted and could then be printed
+  ([issue #322](https://git.eeqj.de/sneak/vaultik/issues/322)).
+
+- 2026-10-14: Ran `$EDITOR` through the shell in `config edit`, so a
+  value with arguments, such as `code --wait`, no longer fails
+  ([issue #315](https://git.eeqj.de/sneak/vaultik/issues/315)).
+
+- 2026-10-14: Made `snapshot remove` fail, instead of exiting 0, when
+  it cannot delete the metadata of a snapshot that is only on the
+  destination store
+  ([issue #340](https://git.eeqj.de/sneak/vaultik/issues/340)). The
+  README and the help now say when it prints the `vaultik prune`
+  follow-up.
+
+- 2026-10-14: Labelled the totals in the local index cleanup before
+  each backup as totals
+  ([issue #306](https://git.eeqj.de/sneak/vaultik/issues/306)). Each
+  was shown as `(N remain)`, which read as rows left to clean up.
+
+- 2026-10-13: Freed a cached blob once no file still to restore needs
+  it ([issue #324](https://git.eeqj.de/sneak/vaultik/issues/324)); one
+  also used by a file outside the selected paths had stayed in the
+  temporary cache until the restore ended.
+
+- 2026-10-13: Kept the whole startup error when it contains `): `
+  ([issue #320](https://git.eeqj.de/sneak/vaultik/issues/320)). Such
+  an error was cut at its last `): `, so the `blob_size_limit` one lost
+  the setting's name.
+
+- 2026-10-13: Silenced the status lines of `prune` and snapshot removal
+  under `--cron` and `--quiet`
+  ([issue #294](https://git.eeqj.de/sneak/vaultik/issues/294)).
+
+- 2026-10-13: Read the rclone config file that `RCLONE_CONFIG` names
+  ([issue #321](https://git.eeqj.de/sneak/vaultik/issues/321)); a
+  remote defined only there had been reported as not found.
+
+- 2026-10-13: Made `/**/` in an exclude pattern match zero directories,
+  as in gitignore
+  ([issue #338](https://git.eeqj.de/sneak/vaultik/issues/338));
+  `a/**/*.log` had missed `a/x.log`.
+
+- 2026-10-13: Made the `chunk_size` and `blob_size_limit` defaults and
+  the `chunk_size` minimum 1000-based, like the size parser and the
+  docs ([issue #313](https://git.eeqj.de/sneak/vaultik/issues/313)).
+
+- 2026-10-13: Kept a snapshot's remote metadata when `snapshot purge`
+  cannot remove it from the local index
+  ([issue #337](https://git.eeqj.de/sneak/vaultik/issues/337)); the
+  purge had deleted the metadata anyway and exited 0.
+
+- 2026-10-13: Made `snapshot restore` fail for a requested path that
+  matches nothing, which it had ignored
+  ([issue #309](https://git.eeqj.de/sneak/vaultik/issues/309)).
+
+- 2026-10-13: Made `remote nuke` delete every object under `metadata/`
+  and `blobs/`
+  ([issue #291](https://git.eeqj.de/sneak/vaultik/issues/291)); it had
+  left some, such as a stray `.DS_Store`, while reporting the store
+  empty.
+
+- 2026-10-13: Made `config set` create a list for an index under a
+  missing key
+  ([issue #308](https://git.eeqj.de/sneak/vaultik/issues/308)); it had
+  written a map, after which no command could load the config.
+
+- 2026-10-13: Listed a `file://` destination through a symlinked
+  `metadata/` or `blobs/`, which had listed as empty
+  ([issue #296](https://git.eeqj.de/sneak/vaultik/issues/296)). A link
+  to a missing target now fails the listing
+  ([issue #332](https://git.eeqj.de/sneak/vaultik/issues/332)).
+
+- 2026-10-13: Made `snapshot verify --deep --json` report its blob
+  counts ([issue #314](https://git.eeqj.de/sneak/vaultik/issues/314));
+  a failed run had reported 0 missing and 0 verified.
+
+- 2026-10-13: Limited and retried the module download in the Docker
+  build ([issue #351](https://git.eeqj.de/sneak/vaultik/issues/351)),
+  which had hung for as long as a stalled connection to the module
+  proxy lasted.
+
+- 2026-10-13: Recorded each snapshot's uncompressed size when its
+  backup runs
+  ([issue #360](https://git.eeqj.de/sneak/vaultik/issues/360)). A later
+  backup could change an older snapshot's UNCOMPRESSED SIZE in
+  `snapshot list`.
+
+- 2026-10-13: Stopped `snapshot restore --skip-errors --verify`
+  reporting a file that failed to restore again as a checksum failure
+  ([issue #323](https://git.eeqj.de/sneak/vaultik/issues/323)).
+
+- 2026-10-13: Recorded the stored size of a blob a backup finds already
+  stored, not the size of its local copy, which can differ, so
+  `snapshot verify` could fail on a good snapshot
+  ([issue #300](https://git.eeqj.de/sneak/vaultik/issues/300)).
+
+- 2026-10-13: Stopped the local index and the blob upload step ending
+  the process on a failed close of query results or a failed temp file
+  cleanup ([issue #345](https://git.eeqj.de/sneak/vaultik/issues/345));
+  both are now returned as errors.
+
+- 2026-10-13: Closed the snapshot database's storage reader too when
+  restore or deep verify is interrupted
+  ([issue #356](https://git.eeqj.de/sneak/vaultik/issues/356)).
+
+- 2026-10-13: Made `prune` and `remote nuke` fail when a delete on the
+  backup destination store fails
+  ([issue #290](https://git.eeqj.de/sneak/vaultik/issues/290)).
+
+- 2026-10-13: Made an S3 listing that the server cuts short an error
+  ([issue #297](https://git.eeqj.de/sneak/vaultik/issues/297)); `prune`
+  had taken it as complete and could delete blobs still in use.
+
+- 2026-10-13: Made shallow `snapshot verify` report a blob it could not
+  check apart from a missing one
+  ([issue #318](https://git.eeqj.de/sneak/vaultik/issues/318)); any
+  error checking a blob had counted as missing, its cause dropped.
+
+- 2026-10-13: Restored the other files when a file's chunk is in no
+  blob under `--skip-errors`
+  ([issue #326](https://git.eeqj.de/sneak/vaultik/issues/326)); that
+  file had stopped the restore before anything was restored.
+
+- 2026-10-13: Recorded each snapshot's new chunk size when its backup
+  runs ([issue #311](https://git.eeqj.de/sneak/vaultik/issues/311)).
+  `snapshot list` could show a NEW CHUNK SIZE of 0 B for a snapshot
+  whose change was a modified file.
+
+- 2026-10-13: Made a backup interrupted during a local index write exit
+  as interrupted
+  ([issue #301](https://git.eeqj.de/sneak/vaultik/issues/301)); it could
+  end with `FATAL: failed to rollback transaction` and exit 1 instead of
+  130.
+
+- 2026-10-13: Printed `snapshot list` and `snapshot purge` sizes like
+  every other command
+  ([issue #312](https://git.eeqj.de/sneak/vaultik/issues/312)). They,
+  and the `bytes` value in terminal log lines, were 1024-based but
+  labelled KB or MB, and now use 1000-based units.
+
+- 2026-10-13: Closed each blob's storage reader when restore or deep
+  verify is interrupted, which ends a stalled read unless it is stuck in
+  the kernel ([issue #325](https://git.eeqj.de/sneak/vaultik/issues/325)).
+
+- 2026-10-13: Made a mistyped subcommand under `snapshot`, `config`,
+  `remote`, `database` or `completion` an error
+  ([issue #319](https://git.eeqj.de/sneak/vaultik/issues/319)); each had
+  printed its help and exited 0.
+
+- 2026-10-13: Made an exclude pattern starting with `**/` match
+  directly under the snapshot path too, as in gitignore
+  ([issue #303](https://git.eeqj.de/sneak/vaultik/issues/303)).
+
+- 2026-10-13: Refused a relative `file://` storage URL and decoded its
+  percent-escapes
+  ([issue #299](https://git.eeqj.de/sneak/vaultik/issues/299)); a
+  relative path had moved with the working directory.
+
+- 2026-10-13: Removed the blob temp file when a backup stops part-way
+  ([issue #302](https://git.eeqj.de/sneak/vaultik/issues/302)); the
+  half-written blob had stayed in `$TMPDIR`.
+
+- 2026-10-13: Checked `--keep-newer-than` before a backup starts
+  ([issue #307](https://git.eeqj.de/sneak/vaultik/issues/307)); an
+  invalid value had been read only by the prune after the backup, so
+  retention never ran.
+
 - 2026-10-13: Stopped `remote info` counting a file under `blobs/` that
  is not a blob as an orphaned blob
  ([issue #295](https://git.eeqj.de/sneak/vaultik/issues/295)). A stray
@@ -4,7 +4,7 @@ This document describes the structure and organization of data stored in the S3

 ## Overview

-Vaultik stores all backup data in an S3-compatible object store. The repository consists of two main components:
+Vaultik stores all backup data in an S3-compatible object store. The repository consists of two main components, plus a marker file:
 1. **Blobs** - The actual backup data (content-addressed, encrypted)
 2. **Metadata** - Snapshot information and manifests (partially encrypted)

@@ -12,6 +12,7 @@ Vaultik stores all backup data in an S3-compatible object store. The repository

 ```
 <bucket>/<prefix>/
+├── vaultik-destination.txt
 ├── blobs/
 │   └── <hash[0:2]>/
 │       └── <hash[2:4]>/
@@ -24,6 +25,10 @@ Vaultik stores all backup data in an S3-compatible object store. The repository

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

+## Marker File (`vaultik-destination.txt`)
+
+Every backup writes this file at the root before it uploads anything. It holds one fixed line of plain text and names no host, path or time. A destination without it is treated as not present while the local index holds snapshots stored there: `snapshot create` refuses to write to it, and `prune`, `snapshot purge`, `snapshot remove`, `snapshot list` and `remote nuke` behave as for a destination that cannot be listed. An unplugged volume leaves an empty directory at its mount point, and without the marker that directory would read as a destination whose snapshots are all gone. `remote nuke` deletes the marker last.
+
 ## Blobs Directory (`blobs/`)

 ### Structure
@@ -101,7 +101,8 @@ 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. Returns the config path.
+// counterpart on the destination store, and gives the destination the
+// marker a backup writes. Returns the config path.
 func writeHermeticPruneConfig(t *testing.T, seedStale bool) string {
 	t.Helper()

@@ -131,6 +132,11 @@ 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 without the marker a backup writes.
+		require.NoError(t, os.WriteFile(
+			filepath.Join(storeDir, "vaultik-destination.txt"), nil, 0o600))
 	}

 	return configPath
@@ -0,0 +1,30 @@
+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")
+}
@@ -41,6 +41,11 @@ func TestEntrySnapshotPurgeKeepsMetadataWhenLocalIndexDeleteFails(t *testing.T)
 	// 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 without the marker a backup writes.
+	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))
@@ -59,10 +64,12 @@ func TestEntrySnapshotPurgeKeepsMetadataWhenLocalIndexDeleteFails(t *testing.T)
 	require.NoError(t, err)
 	require.NoError(t, db.Close())

-	code, _, _ := runEntry(t, flagConfig, configPath,
+	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")
 }
@@ -115,6 +115,13 @@ on Linux), then /etc/vaultik/config.yml.`,
 					return
 				}

+				if errors.Is(err, vaultik.ErrFilesUnreadable) {
+					log.Error("Backup completed with unreadable files", "error", err)
+					ReportErrorf("Backup completed, but %v", err)
+
+					return
+				}
+
 				log.Error("Snapshot creation failed", "error", err)
 				ReportErrorf("Snapshot creation failed: %v", err)
 			})
@@ -125,7 +132,8 @@ on Linux), then /etc/vaultik/config.yml.`,
 		"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 and remove "+
-			"orphaned blobs")
+			"orphaned blobs (not after a backup that skipped unreadable "+
+			"files)")
 	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) "+
@@ -267,6 +267,45 @@ func (r *FileRepository) ListUnderPath(
 	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
+
+	for rows.Next() {
+		file, err := r.scanFileRows(rows)
+		if err != nil {
+			return nil, fmt.Errorf("scanning file: %w", err)
+		}
+
+		files = append(files, file)
+	}
+
+	return files, rows.Err()
+}
+
 // ListIDsWithChunksNotInUploadedBlobs returns the IDs of the files whose
 // path starts with prefix and that list at least one chunk held by no
 // blob whose upload has completed (uploaded_ts set). A new snapshot
@@ -212,6 +212,65 @@ 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()

@@ -16,6 +16,9 @@ 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
 }

 // Module exports backup functionality as an fx module.
@@ -44,17 +47,18 @@ func provideScannerFactory(
 		}

 		return NewScanner(ScannerConfig{
-			FS:               params.Fs,
-			ChunkSize:        cfg.ChunkSize.Int64(),
-			Repositories:     repos,
-			Storage:          storer,
-			MaxBlobSize:      cfg.BlobSizeLimit.Int64(),
-			CompressionLevel: cfg.CompressionLevel,
-			AgeRecipients:    cfg.AgeRecipients,
-			EnableProgress:   params.EnableProgress,
-			UI:               params.UI,
-			Exclude:          excludes,
-			SkipErrors:       params.SkipErrors,
+			FS:                 params.Fs,
+			ChunkSize:          cfg.ChunkSize.Int64(),
+			Repositories:       repos,
+			Storage:            storer,
+			MaxBlobSize:        cfg.BlobSizeLimit.Int64(),
+			CompressionLevel:   cfg.CompressionLevel,
+			AgeRecipients:      cfg.AgeRecipients,
+			EnableProgress:     params.EnableProgress,
+			UI:                 params.UI,
+			Exclude:            excludes,
+			SkipErrors:         params.SkipErrors,
+			PreviousSnapshotID: params.PreviousSnapshotID,
 		})
 	}
 }
@@ -78,8 +78,7 @@ func TestProgressPercentWithSecondPathSmaller(t *testing.T) {

 	stats := progress.GetStats()

-	// Directories count toward the total size but produce no chunks, so
-	// the percentage ends just under 100%.
+	// With both paths counted, the percentage must not exceed 100%.
 	percent := float64(stats.BytesProcessed.Load()) /
 		float64(stats.TotalSize.Load()) * 100
 	if percent > 100 {
@@ -58,6 +58,10 @@ type Scanner struct {
 	compressionLevel int
 	ageRecipient     string
 	snapshotID       string // Current snapshot being processed
+	// previousSnapshotID is the most recent completed snapshot of the
+	// same name, "" for none. Only a file it lists can be counted as
+	// deleted.
+	previousSnapshotID string
 	// currentSourcePath is the source directory being scanned, stored with
 	// each file record.
 	currentSourcePath string
@@ -129,15 +133,20 @@ type ScannerConfig struct {
 	// SkipErrors skips files that cannot be opened or read (log loudly but
 	// continue); packer, database, encryption, and upload errors still abort.
 	SkipErrors bool
+	// PreviousSnapshotID is the most recent completed snapshot of the
+	// same name, "" for none.
+	PreviousSnapshotID string
 }

 // ScanResult contains the results of a scan operation. Files and bytes
 // are counted per file: BytesScanned is the size of the new and changed
 // files, BytesSkipped that of the unchanged ones. FilesFailed counts the
-// new and changed files that phase 2 could not store; FilesScanned
-// includes them and BytesScanned does not. ChunksCreated counts the
-// chunks that were not already stored, and NewChunkSize is their total
-// size.
+// new and changed files that phase 2 could not store, each entry removed
+// after the walk listed its directory and, under --skip-errors, each
+// entry the walk could not read, such as a directory it could not list;
+// FilesScanned includes them and BytesScanned does not. ChunksCreated
+// counts the chunks that were not already stored, and NewChunkSize is
+// their total size.
 type ScanResult struct {
 	FilesScanned   int
 	FilesSkipped   int
@@ -154,6 +163,11 @@ type ScanResult struct {
 	UploadDuration time.Duration
 	StartTime      time.Time
 	EndTime        time.Time
+
+	// FilesUnreadable is the part of FilesFailed that --skip-errors
+	// skipped because it could not be read or listed; the rest are files
+	// removed after the walk listed them.
+	FilesUnreadable int
 }

 // NewScanner creates a new scanner instance
@@ -207,6 +221,7 @@ func NewScanner(cfg ScannerConfig) *Scanner {
 		compiledExclude:    compiledExclude,
 		progress:           progress,
 		skipErrors:         cfg.SkipErrors,
+		previousSnapshotID: cfg.PreviousSnapshotID,
 		ui:                 uiw,
 		pendingChunkHashes: make(map[string]struct{}),
 	}
@@ -258,8 +273,9 @@ func (s *Scanner) Scan(

 	filesToProcess := scanResult.FilesToProcess

-	// Phase 1b: Detect deleted files by comparing DB against scanned files
-	err = s.detectDeletedFilesFromMap(ctx, knownFiles, existingFiles, result)
+	// Phase 1b: Detect deleted files by comparing the previous snapshot
+	// of this name against scanned files
+	err = s.detectDeletedFiles(ctx, path, existingFiles, result)
 	if err != nil {
 		return nil, fmt.Errorf("detecting deleted files: %w", err)
 	}
@@ -275,6 +291,11 @@ func (s *Scanner) Scan(
 		}
 	}

+	err = s.recordDirectories(ctx, scanResult.Directories)
+	if err != nil {
+		return nil, err
+	}
+
 	// Summarize scan phase results and update progress
 	s.summarizeScanPhase(result, filesToProcess)

@@ -439,9 +460,8 @@ func (s *Scanner) summarizeScanPhase(
 }

 // loadKnownFiles loads the known files at and beneath path from the
-// database into a map for fast lookup. Every loaded file the scan does
-// not find is counted as deleted. This avoids per-file database queries
-// during the scan phase.
+// database into a map for fast lookup. This avoids per-file database
+// queries during the scan phase.
 func (s *Scanner) loadKnownFiles(
 	ctx context.Context, path string,
 ) (map[string]*database.File, error) {
@@ -847,14 +867,15 @@ func (s *Scanner) batchInsertFileData(
 // ScanPhaseResult contains the results of the scan phase
 type ScanPhaseResult struct {
 	FilesToProcess   []*FileToProcess
-	UnchangedFileIDs []types.FileID // IDs of unchanged files to associate with snapshot
+	UnchangedFileIDs []types.FileID   // IDs of unchanged files to associate with snapshot
+	Directories      []*FileToProcess // Every directory found, to record
 }

 // scanPhase performs the initial directory scan to identify files to process
 // It uses the pre-loaded knownFiles map for fast change detection without DB
 // queries. It also populates existingFiles map for deletion detection.
-// Returns files needing processing and IDs of unchanged files for snapshot
-// association.
+// Returns files needing processing, IDs of unchanged files for snapshot
+// association, and the directories found.
 func (s *Scanner) scanPhase(
 	ctx context.Context,
 	path string,
@@ -862,8 +883,10 @@ func (s *Scanner) scanPhase(
 	existingFiles map[string]struct{},
 	knownFiles map[string]*database.File,
 ) (*ScanPhaseResult, error) {
-	// Use known file count as estimate for progress (accurate for subsequent backups)
-	estimatedTotal := int64(len(knownFiles))
+	// Use known file count as estimate for progress (accurate for
+	// subsequent backups). The walk does not count directories, so the
+	// estimate leaves them out.
+	estimatedTotal := countNonDirectories(knownFiles)

 	collector := &scanCollector{}

@@ -874,8 +897,28 @@ func (s *Scanner) scanPhase(
 	log.Debug("Starting directory walk", "path", path)

 	walkFn := func(filePath string, info os.FileInfo, err error) error {
+		// Check exclude patterns first, so an excluded entry that is gone
+		// or cannot be looked up is neither counted nor reported. For
+		// directories, skip the entire subtree. info is nil when the
+		// walk could not look the entry up.
+		if s.shouldExclude(filePath, path) {
+			if info != nil && info.IsDir() {
+				return filepath.SkipDir
+			}
+
+			return nil
+		}
+
+		// The source path is in no directory listing, so its absence is
+		// an error rather than a removal.
+		if errors.Is(err, os.ErrNotExist) && filePath != path {
+			countRemovedDuringWalk(filePath, existingFiles, result)
+
+			return nil
+		}
+
 		if err != nil {
-			return s.handleWalkError(filePath, err)
+			return s.handleWalkError(filePath, err, result)
 		}

 		// Check context cancellation
@@ -885,18 +928,9 @@ func (s *Scanner) scanPhase(
 		default:
 		}

-		// Check exclude patterns - for directories, skip the entire subtree
-		if s.shouldExclude(filePath, path) {
-			if info.IsDir() {
-				return filepath.SkipDir
-			}
-
-			return nil
-		}
-
 		// Handle symlinks and directories
 		handled, err := s.recordSpecialEntry(
-			filePath, info, existingFiles, collector, result)
+			filePath, info, existingFiles, knownFiles, collector, result)
 		if handled {
 			return err
 		}
@@ -910,9 +944,10 @@ func (s *Scanner) scanPhase(
 		existingFiles[filePath] = struct{}{}

 		// Check file against in-memory map (no DB query!)
-		file, needsProcessing := s.checkFileInMemory(filePath, info, knownFiles)
+		file := s.buildRegularFileEntry(filePath, info)
+		needsProcessing := s.checkFileInMemory(file, knownFiles)

-		filesScanned, changedCount := collector.recordRegularFile(
+		filesScanned, changedCount := collector.recordFile(
 			filePath, info, file, needsProcessing)

 		// Update result stats
@@ -936,27 +971,45 @@ func (s *Scanner) scanPhase(
 	return &ScanPhaseResult{
 		FilesToProcess:   collector.filesToProcess,
 		UnchangedFileIDs: collector.unchangedFileIDs,
+		Directories:      collector.directories,
 	}, nil
 }

+// countNonDirectories returns how many of files are not directories.
+func countNonDirectories(files map[string]*database.File) int64 {
+	var count int64
+
+	for _, f := range files {
+		if f.Mode&uint32(os.ModeDir) == 0 {
+			count++
+		}
+	}
+
+	return count
+}
+
 // recordSpecialEntry records symlinks and directories (which have no
-// data to chunk) and reports whether it handled the entry. For a symlink
-// whose target cannot be read it returns handleWalkError's result.
+// data to chunk) and reports whether it handled the entry. A symlink is
+// counted and checked for changes as a regular file is; a directory is
+// set aside to be recorded and is not counted. For a symlink whose
+// target cannot be read it returns handleWalkError's result.
 func (s *Scanner) recordSpecialEntry(
 	filePath string, info os.FileInfo,
 	existingFiles map[string]struct{},
+	knownFiles map[string]*database.File,
 	collector *scanCollector, result *ScanResult,
 ) (bool, error) {
 	// Handle symlinks
 	if info.Mode()&os.ModeSymlink != 0 {
 		file, err := s.buildSymlinkEntry(filePath, info)
 		if err != nil {
-			return true, s.handleWalkError(filePath, err)
+			return true, s.handleWalkError(filePath, err, result)
 		}

 		existingFiles[filePath] = struct{}{}
-		collector.addToProcess(filePath, info, file)
-		s.updateScanEntryStats(result, true, info)
+		needsProcessing := s.checkFileInMemory(file, knownFiles)
+		collector.recordFile(filePath, info, file, needsProcessing)
+		s.updateScanEntryStats(result, needsProcessing, info)

 		return true, nil
 	}
@@ -966,7 +1019,7 @@ func (s *Scanner) recordSpecialEntry(
 	if info.IsDir() {
 		file := s.buildDirectoryEntry(filePath, info)
 		existingFiles[filePath] = struct{}{}
-		collector.addToProcess(filePath, info, file)
+		collector.addDirectory(filePath, info, file)

 		return true, nil
 	}
@@ -974,15 +1027,38 @@ func (s *Scanner) recordSpecialEntry(
 	return false, nil
 }

+// countRemovedDuringWalk counts an entry that was in its directory's
+// listing but was gone when the walk looked it up, like a file removed
+// before phase 2 reads it: as examined and failed, and not as an error,
+// with or without --skip-errors.
+func countRemovedDuringWalk(
+	filePath string, existingFiles map[string]struct{}, result *ScanResult,
+) {
+	log.Warn("File was deleted during the directory walk, skipping",
+		"path", filePath)
+
+	// The walk found it, so it is not also counted as deleted.
+	existingFiles[filePath] = struct{}{}
+	result.FilesScanned++
+	result.FilesFailed++
+}
+
 // handleWalkError deals with a filesystem error surfaced by the walk:
-// skipped (with a UI notice) under --skip-errors, fatal otherwise.
-func (s *Scanner) handleWalkError(filePath string, err error) error {
+// under --skip-errors the entry is skipped with a UI notice and counted
+// as examined, failed and unreadable, otherwise the error is fatal.
+func (s *Scanner) handleWalkError(
+	filePath string, err error, result *ScanResult,
+) error {
 	if s.skipErrors {
 		log.Error("Failed to access file (skipping due to --skip-errors)",
 			"path", filePath, "error", err)
 		s.ui.Errorf("Failed to access %s: %v. Skipping (--skip-errors).",
 			s.ui.Path(filePath), err)

+		result.FilesScanned++
+		result.FilesFailed++
+		result.FilesUnreadable++
+
 		return nil // Continue scanning
 	}

@@ -996,28 +1072,29 @@ type scanCollector struct {
 	mu               sync.Mutex
 	filesToProcess   []*FileToProcess
 	unchangedFileIDs []types.FileID // Just IDs - no new records needed
+	directories      []*FileToProcess
 	filesScanned     int64
 }

-// addToProcess queues a file entry for processing.
-func (c *scanCollector) addToProcess(
+// addDirectory sets a directory aside to be recorded. It is not counted
+// as a file.
+func (c *scanCollector) addDirectory(
 	path string, info os.FileInfo, file *database.File,
 ) {
 	c.mu.Lock()
 	defer c.mu.Unlock()

-	c.filesToProcess = append(c.filesToProcess, &FileToProcess{
+	c.directories = append(c.directories, &FileToProcess{
 		Path:     path,
 		FileInfo: info,
 		File:     file,
 	})
-	c.filesScanned++
 }

-// recordRegularFile records a regular file as changed (to process) or
-// unchanged (snapshot association only) and returns the running scanned
-// and changed counts.
-func (c *scanCollector) recordRegularFile(
+// recordFile records a regular file or symlink as changed (to process)
+// or unchanged (snapshot association only) and returns the running
+// scanned and changed counts.
+func (c *scanCollector) recordFile(
 	path string, info os.FileInfo, file *database.File, needsProcessing bool,
 ) (int64, int) {
 	c.mu.Lock()
@@ -1120,7 +1197,28 @@ func (s *Scanner) printScanProgressLine(
 	}
 }

-// buildSymlinkEntry creates a File record for a symlink.
+// buildRegularFileEntry creates a File record for a regular file, with
+// no ID: checkFileInMemory sets it.
+func (s *Scanner) buildRegularFileEntry(path string, info os.FileInfo) *database.File {
+	var uid, gid uint32
+	if stat, ok := info.Sys().(*syscall.Stat_t); ok {
+		uid = stat.Uid
+		gid = stat.Gid
+	}
+
+	return &database.File{
+		Path:       types.FilePath(path),
+		SourcePath: types.SourcePath(s.currentSourcePath),
+		MTime:      info.ModTime(),
+		Size:       info.Size(),
+		Mode:       uint32(info.Mode()),
+		UID:        uid,
+		GID:        gid,
+	}
+}
+
+// buildSymlinkEntry creates a File record for a symlink, with no ID:
+// checkFileInMemory sets it.
 func (s *Scanner) buildSymlinkEntry(
 	path string, info os.FileInfo,
 ) (*database.File, error) {
@@ -1136,7 +1234,6 @@ func (s *Scanner) buildSymlinkEntry(
 	}

 	return &database.File{
-		ID:         types.NewFileID(),
 		Path:       types.FilePath(path),
 		SourcePath: types.SourcePath(s.currentSourcePath),
 		MTime:      info.ModTime(),
@@ -1168,6 +1265,22 @@ func (s *Scanner) buildDirectoryEntry(path string, info os.FileInfo) *database.F
 	}
 }

+// recordDirectories records every directory the walk found. A directory
+// has no data to back up, so it is not among the files counted and
+// backed up.
+func (s *Scanner) recordDirectories(
+	ctx context.Context, directories []*FileToProcess,
+) error {
+	for _, dir := range directories {
+		err := s.recordNonRegularFile(ctx, dir)
+		if err != nil {
+			return fmt.Errorf("recording directory %s: %w", dir.Path, err)
+		}
+	}
+
+	return nil
+}
+
 // recordNonRegularFile writes a symlink or directory entry to the database
 // and associates it with the current snapshot. No chunking is performed.
 func (s *Scanner) recordNonRegularFile(ctx context.Context, ftp *FileToProcess) error {
@@ -1181,62 +1294,36 @@ func (s *Scanner) recordNonRegularFile(ctx context.Context, ftp *FileToProcess)
 	})
 }

-// checkFileInMemory checks if a file needs processing using the in-memory map
+// checkFileInMemory reports whether a regular file or symlink needs
+// processing, and gives file the ID of its known record, or a new ID for
+// a new path.
 // No database access is performed - this is purely CPU/memory work
 func (s *Scanner) checkFileInMemory(
-	path string, info os.FileInfo, knownFiles map[string]*database.File,
-) (*database.File, bool) {
-	var uid, gid uint32
-	if stat, ok := info.Sys().(*syscall.Stat_t); ok {
-		uid = stat.Uid
-		gid = stat.Gid
-	}
-
-	// Check against in-memory map first to get existing ID if available
-	existingFile, exists := knownFiles[path]
-
-	// Create file record with ID set upfront
-	// For new files, generate UUID immediately so it's available for chunk associations
-	// For existing files, reuse the existing ID
-	var fileID types.FileID
-	if exists {
-		fileID = existingFile.ID
-	} else {
-		fileID = types.NewFileID()
-	}
-
-	file := &database.File{
-		ID:         fileID,
-		Path:       types.FilePath(path),
-		SourcePath: types.SourcePath(s.currentSourcePath),
-		MTime:      info.ModTime(),
-		Size:       info.Size(),
-		Mode:       uint32(info.Mode()),
-		UID:        uid,
-		GID:        gid,
-	}
+	file *database.File, knownFiles map[string]*database.File,
+) bool {
+	existingFile, exists := knownFiles[file.Path.String()]

 	// New file - needs processing
 	if !exists {
-		return file, true
+		file.ID = types.NewFileID()
+
+		return true
 	}

+	file.ID = existingFile.ID
+
 	// No uploaded blob holds one of its chunks (see loadFilesToRechunk)
-	if _, rechunk := s.filesToRechunk[fileID]; rechunk {
-		return file, true
+	if _, rechunk := s.filesToRechunk[file.ID]; rechunk {
+		return true
 	}

 	// Check if file has changed
-	if existingFile.Size != file.Size ||
+	return existingFile.Size != file.Size ||
 		!existingFile.MTime.Equal(file.MTime) ||
 		existingFile.Mode != file.Mode ||
 		existingFile.UID != file.UID ||
-		existingFile.GID != file.GID {
-		return file, true
-	}
-
-	// File unchanged
-	return file, false
+		existingFile.GID != file.GID ||
+		existingFile.LinkTarget != file.LinkTarget
 }

 // batchAddFilesToSnapshot adds existing file IDs to the snapshot association table
@@ -1363,17 +1450,16 @@ func (s *Scanner) processPhase(
 	return s.finalizeProcessPhase(ctx, result)
 }

-// processFileWithErrorHandling records a directory or symlink, or wraps
+// processFileWithErrorHandling records a symlink, or wraps
 // processFileStreaming for a regular file with error recovery for deleted
 // files and skip-errors mode. Returns (skipped, error).
 func (s *Scanner) processFileWithErrorHandling(
 	ctx context.Context, fileToProcess *FileToProcess, result *ScanResult,
 ) (bool, error) {
-	// A directory or symlink has no data to open or read; it is only
-	// recorded in the local index. An error recording it stops the run
-	// even under --skip-errors, or the snapshot would complete without it.
-	mode := os.FileMode(fileToProcess.File.Mode)
-	if mode&os.ModeSymlink != 0 || mode.IsDir() {
+	// A symlink has no data to open or read; it is only recorded in the
+	// local index. An error recording it stops the run even under
+	// --skip-errors, or the snapshot would complete without it.
+	if os.FileMode(fileToProcess.File.Mode)&os.ModeSymlink != 0 {
 		err := s.recordNonRegularFile(ctx, fileToProcess)
 		if err != nil {
 			return false, fmt.Errorf("processing file %s: %w", fileToProcess.Path, err)
@@ -1414,6 +1500,7 @@ func (s *Scanner) processFileWithErrorHandling(
 				s.ui.Path(fileToProcess.Path), err)

 			countFailedFile(fileToProcess, result)
+			result.FilesUnreadable++

 			return true, nil
 		}
@@ -1954,21 +2041,29 @@ func (s *Scanner) queueFileForBatchInsert(
 	})
 }

-// detectDeletedFilesFromMap finds files that existed in previous snapshots
-// but no longer exist. Uses pre-loaded maps to avoid any filesystem or
-// database access.
-func (s *Scanner) detectDeletedFilesFromMap(
+// detectDeletedFiles counts as deleted each file at or beneath path that
+// the previous snapshot of this name lists, the walk did not find, and
+// is gone from disk. A file that is excluded, or inside an excluded
+// directory, is not counted: the walk skips it whether or not it is
+// still on disk.
+func (s *Scanner) detectDeletedFiles(
 	ctx context.Context,
-	knownFiles map[string]*database.File,
+	path string,
 	existingFiles map[string]struct{},
 	result *ScanResult,
 ) error {
-	if len(knownFiles) == 0 {
+	if s.previousSnapshotID == "" {
 		return nil
 	}

-	// Check each known file against the enumerated set (no filesystem access needed)
-	for path, file := range knownFiles {
+	previousFiles, err := s.repos.Files.ListUnderPathInSnapshot(
+		ctx, path, s.previousSnapshotID)
+	if err != nil {
+		return fmt.Errorf("listing files of snapshot %s: %w",
+			s.previousSnapshotID, err)
+	}
+
+	for _, file := range previousFiles {
 		// Check context cancellation periodically
 		select {
 		case <-ctx.Done():
@@ -1976,13 +2071,22 @@ func (s *Scanner) detectDeletedFilesFromMap(
 		default:
 		}

-		// Check if the file exists in our enumerated set
-		if _, exists := existingFiles[path]; !exists {
-			// File has been deleted
-			result.FilesDeleted++
-			result.BytesDeleted += file.Size
-			log.Debug("Detected deleted file", "path", path, "size", file.Size)
+		filePath := file.Path.String()
+
+		_, exists := existingFiles[filePath]
+		if exists || s.excludedOrInExcludedDir(filePath, path) {
+			continue
 		}
+
+		// Under --skip-errors the walk also misses what it cannot reach,
+		// such as the files in a directory it cannot open.
+		if !s.goneFromDisk(filePath) {
+			continue
+		}
+
+		result.FilesDeleted++
+		result.BytesDeleted += file.Size
+		log.Debug("Detected deleted file", "path", filePath, "size", file.Size)
 	}

 	if result.FilesDeleted > 0 {
@@ -1993,6 +2097,36 @@ func (s *Scanner) detectDeletedFilesFromMap(
 	return nil
 }

+// excludedOrInExcludedDir reports whether filePath, which is at or
+// beneath rootPath, or any directory between rootPath and it, matches an
+// exclude pattern. A pattern such as */.local/share/Trash matches the
+// directory but not the files inside it, which the walk skips too.
+func (s *Scanner) excludedOrInExcludedDir(filePath, rootPath string) bool {
+	for p := filePath; len(p) > len(rootPath); p = filepath.Dir(p) {
+		if s.shouldExclude(p, rootPath) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// goneFromDisk reports whether looking filePath up on disk finds that
+// it does not exist. Like the walk, it does not follow a symlink, so a
+// symlink whose target is gone is still on disk. A file whose directory
+// was replaced by a regular file is gone too, though the lookup reports
+// "not a directory".
+func (s *Scanner) goneFromDisk(filePath string) bool {
+	var err error
+	if lstater, ok := s.fs.(afero.Lstater); ok {
+		_, _, err = lstater.LstatIfPossible(filePath)
+	} else {
+		_, err = s.fs.Stat(filePath)
+	}
+
+	return errors.Is(err, os.ErrNotExist) || errors.Is(err, syscall.ENOTDIR)
+}
+
 // wrapPermissionError augments permission errors with platform-specific
 // remediation instructions. On macOS, TCC-protected directories (Calendars,
 // Reminders, Photos, etc.) return EPERM unless the running application has
@@ -0,0 +1,28 @@
+//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)
+	}
+}
@@ -21,9 +21,13 @@ type FileStorer struct {
 // NewFileStorer creates a new filesystem storage backend.
 //
 // Construction is intentionally cheap and does not touch the filesystem.
-// The basePath is recorded; the directory is created lazily on first
-// write. Write operations (Put/PutWithProgress) call MkdirAll for the
-// per-blob parent directory, which also covers basePath on first use.
+// The backend never creates basePath: the user does, so that when
+// basePath is a directory on an unplugged volume, a write fails instead
+// of landing on the disk under the mount point. This does not hold when
+// 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.
@@ -299,7 +303,19 @@ func (f *FileStorer) writeAtomic(
 	path := f.fullPath(key)
 	dir := filepath.Dir(path)

-	err := f.fs.MkdirAll(dir, storageDirPerm)
+	// Checked on every write, so a destination that disappears part-way
+	// 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)
 	}
@@ -292,3 +292,43 @@ func TestFileStorerDeletePartialUploadsThroughSymlinkedDirectory(t *testing.T) {
 		})
 	}
 }
+
+// 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)
+	}
+}
@@ -41,7 +41,8 @@ type Info struct {
 // directory for filesystem).
 type Storer interface {
 	// Put stores data at the specified key.
-	// Parent directories are created automatically for filesystem backends.
+	// The filesystem backend fails when its destination directory does
+	// 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.
@@ -30,6 +30,12 @@ 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.
@@ -90,8 +96,9 @@ func parseFileURL(rawPath string) (*URL, error) {
 }

 // parseS3URL parses an s3://bucket/prefix URL. It rejects credentials in
-// the userinfo and any query parameter other than endpoint, region and
-// ssl, so a credential-bearing URL is never stored or echoed.
+// the userinfo or in the endpoint parameter's userinfo, a query that
+// cannot be decoded, and any query parameter other than endpoint, region
+// 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 {
@@ -107,13 +114,26 @@ func parseS3URL(rawURL string) (*URL, error) {
 		return nil, ErrMissingBucket
 	}

-	query := u.Query()
+	// u.Query() would silently drop a part it cannot decode, endpoint
+	// 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,
@@ -125,9 +145,23 @@ func parseS3URL(rawURL string) (*URL, error) {
 }

 // parseRcloneURL parses an rclone://remote/path URL. rclone:// takes no
-// query parameters, so credentials in the userinfo and any parameter at
+// query parameters, so credentials in the userinfo, parameters in the
+// 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)
@@ -137,12 +171,19 @@ func parseRcloneURL(rawURL string) (*URL, error) {
 		return nil, ErrURLCredentials
 	}

-	remote := u.Host
+	remote = u.Host
 	if remote == "" {
 		return nil, ErrMissingRemote
 	}

-	err = rejectUnknownParams(u.Query())
+	// As in parseS3URL: u.Query() would drop a part it cannot decode, and
+	// 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,6 +150,19 @@ 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,
@@ -203,6 +216,112 @@ 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.
@@ -104,7 +104,8 @@ func (v *Vaultik) FetchAndDecryptBlob(

 // 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.
+// 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) {
@@ -119,7 +120,7 @@ func (v *Vaultik) FetchBlob(

 	rc, err := v.Storage.Get(ctx, blobPath)
 	if err != nil {
-		return nil, fmt.Errorf("downloading blob %s: %w", shortHash(blobHash), err)
+		return nil, err
 	}

 	return newCloseOnCancelReader(ctx, rc), nil
@@ -137,7 +137,7 @@ func TestBackupAfterRemovingNewestSnapshotRestoresChangedFile(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	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 := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	changedPath := filepath.Join(dataDir, "appended.bin")
@@ -6,6 +6,7 @@ import (
 	"crypto/rand"
 	"io"
 	"os"
+	"path"
 	"path/filepath"
 	"testing"

@@ -34,7 +35,7 @@ func TestDeepVerifyAcceptsHealthyAndRejectsCorruptBlob(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	chunkSize := int64(64 * 1024)
@@ -93,7 +94,7 @@ func TestDeepVerifyJSONCountsBlobs(t *testing.T) {

 	fs := afero.NewOsFs()
 	ctx := context.Background()
-	storeDir := filepath.Join(t.TempDir(), "remote")
+	storeDir := t.TempDir()

 	cfg, storer, snapshotID, keys := backUpSeveralBlobs(ctx, t, storeDir)

@@ -142,14 +143,15 @@ func TestDeepVerifyJSONCountsBlobs(t *testing.T) {

 // 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.
+// 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 := filepath.Join(t.TempDir(), "remote")
+	storeDir := t.TempDir()

 	cfg, storer, snapshotID, keys := backUpSeveralBlobs(ctx, t, storeDir)

@@ -168,17 +170,20 @@ func TestDeepVerifyJSONCountsWrongSizeBlob(t *testing.T) {
 	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 with the storage error.
+// 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 := filepath.Join(t.TempDir(), "remote")
+	storeDir := t.TempDir()

 	cfg, storer, snapshotID, keys := backUpSeveralBlobs(ctx, t, storeDir)
 	failing := statFailingStorer{Storer: storer, failKeys: []string{keys[0]}}
@@ -187,6 +192,8 @@ func TestDeepVerifyStopsOnBlobThatCannotBeChecked(t *testing.T) {
 	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())
 }

@@ -0,0 +1,90 @@
+package vaultik
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"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 without it 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 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 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.
+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
+	// EnsureStorageBinding).
+	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)
+	}
+
+	if err != nil {
+		return fmt.Errorf("checking for %s: %w", destinationMarkerKey, err)
+	}
+
+	return nil
+}
+
+// markDestination checks the backup destination store with
+// checkDestinationMarker and then writes the marker, so a first backup
+// marks its destination and a later one writes the same text again.
+func (v *Vaultik) markDestination() error {
+	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 nil
+}
@@ -0,0 +1,297 @@
+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/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 without 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)
+}
+
+// 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))
+}
@@ -192,7 +192,7 @@ func assertRestoreRejectsDamagedBlob(
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	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 := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	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 := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	ctx := context.Background()
@@ -298,10 +298,6 @@ 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)

@@ -365,7 +361,7 @@ func TestBackupRetryAfterInterruptedUploadIsRestorable(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -429,7 +425,7 @@ func TestBackupSurvivesMetadataExportInterruption(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	ctx := context.Background()
@@ -445,6 +441,10 @@ 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,8 +493,14 @@ 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
@@ -511,7 +517,7 @@ func TestBackupCompletesOnlyAfterMetadataExport(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -661,17 +667,18 @@ func faultScannerFactory(
 ) snapshot.ScannerFactory {
 	return func(params snapshot.ScannerParams) *snapshot.Scanner {
 		return snapshot.NewScanner(snapshot.ScannerConfig{
-			FS:               params.Fs,
-			Storage:          storer,
-			ChunkSize:        faultChunkSize,
-			MaxBlobSize:      faultMaxBlobSize,
-			CompressionLevel: cfg.CompressionLevel,
-			AgeRecipients:    cfg.AgeRecipients,
-			Repositories:     repos,
-			EnableProgress:   params.EnableProgress,
-			UI:               params.UI,
-			Exclude:          params.Exclude,
-			SkipErrors:       params.SkipErrors,
+			FS:                 params.Fs,
+			Storage:            storer,
+			ChunkSize:          faultChunkSize,
+			MaxBlobSize:        faultMaxBlobSize,
+			CompressionLevel:   cfg.CompressionLevel,
+			AgeRecipients:      cfg.AgeRecipients,
+			Repositories:       repos,
+			EnableProgress:     params.EnableProgress,
+			UI:                 params.UI,
+			Exclude:            params.Exclude,
+			SkipErrors:         params.SkipErrors,
+			PreviousSnapshotID: params.PreviousSnapshotID,
 		})
 	}
 }
@@ -686,7 +693,7 @@ func TestRestoreReportsDiskFull(t *testing.T) {
 	osFS := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -771,7 +771,7 @@ func TestEndToEndFileStorage(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -964,7 +964,7 @@ func TestDedupOnlySnapshotRestores(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -24,13 +24,11 @@ import (
 // that is not plugged in, cannot be listed. It is not an empty store, so
 // no command may conclude from it that the local snapshots are gone.

-// backUpToFileDestination backs up the snapshot named "first" to a
-// file:// destination at storeDir, which need not exist yet. Everything
-// the returned Vaultik prints after the backup goes to the returned
-// buffer.
-func backUpToFileDestination(
+// newFileDestinationVaultik returns a Vaultik that backs up the
+// snapshot named "first" to a file:// destination at storeDir.
+func newFileDestinationVaultik(
 	ctx context.Context, t *testing.T, storeDir string,
-) (*vaultik.Vaultik, *database.Repositories, *bytes.Buffer) {
+) (*vaultik.Vaultik, *database.Repositories) {
 	t.Helper()

 	osFs := afero.NewOsFs()
@@ -49,8 +47,22 @@ func backUpToFileDestination(

 	repos := database.NewRepositories(db)
 	cfg := changedFileConfig(dataDir, dbPath)
-	v := newBackupVaultik(ctx, cfg, store, repos, db, osFs)

+	return newBackupVaultik(ctx, cfg, store, repos, db, osFs), repos
+}
+
+// backUpToFileDestination creates the directory storeDir, as a user must
+// before the first backup, and backs up the snapshot named "first" to a
+// file:// destination there. Everything the returned Vaultik prints
+// after the backup goes to the returned buffer.
+func backUpToFileDestination(
+	ctx context.Context, t *testing.T, storeDir string,
+) (*vaultik.Vaultik, *database.Repositories, *bytes.Buffer) {
+	t.Helper()
+
+	require.NoError(t, os.MkdirAll(storeDir, 0o750))
+
+	v, repos := newFileDestinationVaultik(ctx, t, storeDir)
 	require.NoError(t, backUp(v, "first"))

 	out := &bytes.Buffer{}
@@ -75,21 +87,28 @@ func backUpThenUnplug(
 	return v, repos, out
 }

-// TestFirstBackupCreatesDestinationDirectory checks that a first backup
-// to a destination directory that does not exist yet creates it, and
-// that the destination can be listed afterwards.
-func TestFirstBackupCreatesDestinationDirectory(t *testing.T) {
+// TestBackupFailsWhenDestinationDirectoryMissing checks that a backup to
+// a file:// destination whose directory does not exist fails before it
+// records a snapshot, and does not create the directory.
+func TestBackupFailsWhenDestinationDirectoryMissing(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()

 	ctx := context.Background()
-	storeDir := filepath.Join(t.TempDir(), "volume", "backup")
-	v, _, out := backUpToFileDestination(ctx, t, storeDir)
+	volume := filepath.Join(t.TempDir(), "volume")
+	v, repos := newFileDestinationVaultik(ctx, t, filepath.Join(volume, "backup"))

-	require.NoError(t, v.ListSnapshots(false))
+	err := backUp(v, "first")
+	require.ErrorIs(t, err, fs.ErrNotExist)
+	require.ErrorContains(t, err, "create it, or mount the volume it is on")

-	assert.NotContains(t, out.String(), "Could not list backup destination store")
-	assert.NotContains(t, out.String(), "not found in backup destination store")
+	_, err = os.Stat(volume)
+	require.ErrorIs(t, err, fs.ErrNotExist,
+		"the backup must not create the destination directory")
+
+	snapshots, err := repos.Snapshots.ListRecent(ctx, listRecentTestLimit)
+	require.NoError(t, err)
+	assert.Empty(t, snapshots)
 }

 // TestListSnapshotsWarnsWhenDestinationMissing checks that snapshot list
@@ -169,3 +188,41 @@ func TestPurgeSaysListingFailedOnceWhenDestinationMissing(t *testing.T) {
 	assert.Equal(t, 1, strings.Count(err.Error(), "listing remote snapshots"),
 		err.Error())
 }
+
+// TestNukeRemoteKeepsLocalIndexWhenDestinationMissing checks that remote
+// nuke fails on a destination it cannot list, leaves the local index
+// unchanged, and neither reports the destination empty nor advises
+// running nuke again.
+func TestNukeRemoteKeepsLocalIndexWhenDestinationMissing(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	ctx := context.Background()
+	v, repos, out := backUpThenUnplug(ctx, t)
+
+	filesBefore, err := repos.Files.ListAll(ctx)
+	require.NoError(t, err)
+	require.NotEmpty(t, filesBefore)
+
+	blobsBefore, err := repos.Blobs.GetAll(ctx)
+	require.NoError(t, err)
+	require.NotEmpty(t, blobsBefore)
+
+	err = v.NukeRemote(true)
+	require.ErrorIs(t, err, fs.ErrNotExist)
+	require.ErrorContains(t, err, "listing remote snapshots")
+	assert.NotContains(t, out.String(), "now empty")
+	assert.NotContains(t, out.String(), "vaultik remote nuke --force")
+
+	snapshots, err := repos.Snapshots.ListRecent(ctx, listRecentTestLimit)
+	require.NoError(t, err)
+	assert.Len(t, snapshots, 1, "nuke must delete no local snapshot record")
+
+	files, err := repos.Files.ListAll(ctx)
+	require.NoError(t, err)
+	assert.Len(t, files, len(filesBefore), "nuke must delete no local file record")
+
+	blobs, err := repos.Blobs.GetAll(ctx)
+	require.NoError(t, err)
+	assert.Len(t, blobs, len(blobsBefore), "nuke must delete no local blob record")
+}
@@ -39,7 +39,7 @@ func TestNewChunkSizeOfChangedFileStaysFixed(t *testing.T) {

 	appendRandomBytes(t, fs, files, changedPath, appendedFileSize)

-	store, err := storage.NewFileStorer(filepath.Join(tempDir, "remote"))
+	store, err := storage.NewFileStorer(t.TempDir())
 	require.NoError(t, err)

 	db, err := database.New(ctx, dbPath)
@@ -104,6 +104,32 @@ func TestNukeRemoteFailsWhenADeleteFails(t *testing.T) {
 	}
 }

+// TestNukeRemoteKeepsLocalSnapshotWhoseMetadataIsNotDeleted checks that
+// remote nuke keeps a snapshot in the local index while its metadata
+// cannot be deleted from the destination store: dropped from the local
+// index, it would be left there as a remote-only snapshot without its
+// name.
+func TestNukeRemoteKeepsLocalSnapshotWhoseMetadataIsNotDeleted(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	ctx := context.Background()
+	storeDir := filepath.Join(t.TempDir(), "store")
+	v, repos, _ := backUpToFileDestination(ctx, t, storeDir)
+
+	store := faultstore.New(v.Storage)
+	store.OnDelete = func(key string) bool {
+		return strings.HasPrefix(key, "metadata/")
+	}
+	v.Storage = store
+
+	require.Error(t, v.NukeRemote(true))
+
+	snapshots, err := repos.Snapshots.ListRecent(ctx, listRecentTestLimit)
+	require.NoError(t, err)
+	assert.Len(t, snapshots, 1)
+}
+
 // TestNukeRemoteNamesWhatIsLeft checks that remote nuke, when an object
 // it does not recognise cannot be deleted, does not report the store
 // empty but names that object and fails.
@@ -154,8 +180,7 @@ func TestNukeRemoteRefusesAnotherDestinationWithoutRetryAdvice(t *testing.T) {

 // TestNukeRemoteFailsWhenALocalSnapshotCannotBeRemoved checks that a
 // snapshot remote nuke cannot remove from the local index fails the
-// run: nuke then leaves that snapshot's metadata on the destination
-// store.
+// run, and that nuke then does not report the destination store empty.
 func TestNukeRemoteFailsWhenALocalSnapshotCannotBeRemoved(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
@@ -42,9 +42,10 @@ const blobKeyParts = 4

 // NukeRemote deletes every object under metadata/ and blobs/ in remote
 // storage, whatever its name, along with any object an upload cut off
-// part-way left under a temporary `.partial` name. It returns
-// successfully only when a listing afterwards finds nothing left there,
-// and the next backup then starts from scratch.
+// part-way left under a temporary `.partial` name, and last the
+// destination marker. It returns successfully only when a listing
+// afterwards finds nothing left under metadata/ and blobs/, and the next
+// backup then starts from scratch.
 //
 // Refuses to run unless force is true. The caller is responsible for
 // confirming with the user.
@@ -54,12 +55,19 @@ func (v *Vaultik) NukeRemote(force bool) error {
 	}

 	// Checked before anything is deleted: running nuke again would fail
-	// the same way, so the advice below must not follow this error.
+	// the same way, so the advice below must not follow these errors.
+	// The listing also fails on a destination without the marker while
+	// the local index holds snapshots.
 	err := v.EnsureStorageBinding()
 	if err != nil {
 		return err
 	}

+	_, err = v.listAllRemoteSnapshotKeys()
+	if err != nil {
+		return err
+	}
+
 	err = v.emptyDestinationStore()
 	if err != nil {
 		v.UI.Warningf("Run '%s' again to delete what is left on the "+
@@ -105,6 +113,13 @@ func (v *Vaultik) emptyDestinationStore() error {
 		return fmt.Errorf("%d %w", len(left), errObjectsLeft)
 	}

+	// Last, once the local snapshot records are gone: the next backup
+	// then has none and writes the marker again.
+	err = v.Storage.Delete(v.ctx, destinationMarkerKey)
+	if err != nil {
+		return fmt.Errorf("deleting %s: %w", destinationMarkerKey, err)
+	}
+
 	return nil
 }

@@ -35,6 +35,9 @@ func setupConsistencyTest(
 	repos := database.NewRepositories(db)
 	mockStorage := NewMockStorer()

+	// A backup wrote to this destination, so it carries the marker.
+	require.NoError(t, mockStorage.Put(ctx, markerFile, strings.NewReader("")))
+
 	for _, id := range snapshotIDs {
 		parts := strings.Split(id, "_")
 		startedAt, err := time.Parse(time.RFC3339, parts[len(parts)-1])
@@ -45,6 +45,9 @@ func setupPurgeTest(
 	repos := database.NewRepositories(db)
 	mockStorage := NewMockStorer()

+	// A backup wrote to this destination, so it carries the marker.
+	require.NoError(t, mockStorage.Put(ctx, markerFile, strings.NewReader("")))
+
 	// Insert each snapshot into the DB and create remote metadata stubs.
 	// Use timestamps parsed from snapshot IDs for realistic ordering.
 	for _, id := range snapshotIDs {
@@ -281,7 +284,8 @@ func TestPurgeOlderThan_TooLargeDeletesNothing(t *testing.T) {
 		OlderThan: "1000y",
 		Force:     true,
 	})
-	require.Error(t, err)
+	require.EqualError(t, err,
+		`invalid duration: "1000y" is longer than about 292 years`)

 	err = v.PurgeSnapshotsWithOptions(&vaultik.SnapshotPurgeOptions{
 		OlderThan: "292y",
@@ -96,6 +96,10 @@ func TestRemoveSnapshot_QuietSuppressesReport(t *testing.T) {
 		store := newTestStorer()
 		addManifest(t, store, "snapshot-001", nil)

+		// A backup wrote to this destination, so it carries the marker.
+		require.NoError(t, store.Put(context.Background(), markerFile,
+			bytes.NewReader(nil)))
+
 		tv := vaultik.NewForTesting(store)
 		tv.Repositories = newLocalIndex(t, "snapshot-001")
 		tv.UI.SetQuiet(true)
@@ -304,6 +304,10 @@ func TestRemoveSnapshot_DefaultRemovesMetadataNotBlobs(t *testing.T) {
 	addBlob(t, store, blobUnique)
 	addBlob(t, store, blobShared)

+	// A backup wrote to this destination, so it carries the marker.
+	require.NoError(t, store.Put(context.Background(), markerFile,
+		bytes.NewReader(nil)))
+
 	tv := vaultik.NewForTesting(store)
 	tv.Repositories = newLocalIndex(t, "snapshot-001", "snapshot-002")

@@ -373,6 +377,10 @@ func TestRemoveSnapshot_UnknownIDIsError(t *testing.T) {
 			store := newTestStorer()
 			addManifest(t, store, "snapshot-001", nil)

+			// A backup wrote to this destination, so it carries the marker.
+			require.NoError(t, store.Put(context.Background(), markerFile,
+				bytes.NewReader(nil)))
+
 			tv := vaultik.NewForTesting(store)
 			tv.Repositories = newLocalIndex(t, "snapshot-001")

@@ -393,7 +401,12 @@ func TestRemoveSnapshot_NoMetadataOnDestination(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()

-	tv := vaultik.NewForTesting(newTestStorer())
+	// A backup wrote to this destination, so it carries the marker.
+	store := newTestStorer()
+	require.NoError(t, store.Put(context.Background(), markerFile,
+		bytes.NewReader(nil)))
+
+	tv := vaultik.NewForTesting(store)
 	tv.Repositories = newLocalIndex(t, "snapshot-001")

 	result, err := tv.RemoveSnapshot("snapshot-001",
@@ -12,6 +12,7 @@ import (
 	"path/filepath"
 	"slices"
 	"strings"
+	"syscall"
 	"time"

 	"filippo.io/age"
@@ -219,9 +220,7 @@ func (v *Vaultik) finishRestore(
 	)

 	if os.Geteuid() != 0 {
-		v.UI.Warningf("Restore did not preserve file ownership: chown(2) " +
-			"requires root. Re-run as root (e.g. with sudo) if you need " +
-			"original UID/GID preserved.")
+		v.warnIfOwnershipNotPreserved(files, opts.TargetDir)
 	}

 	if result.FilesFailed > 0 {
@@ -247,6 +246,43 @@ func (v *Vaultik) finishRestore(
 	return unmatchedErr
 }

+// warnIfOwnershipNotPreserved warns once if some entry restored under
+// targetDir has another owner or group on disk than the snapshot
+// records. It is meant for a restore by a normal user, which changes no
+// owner or group: a new entry is owned by that user, and its group is
+// that user's, or the group of the directory it is created in on macOS
+// and in a setgid directory on Linux. An entry that is not on disk, or
+// whose filesystem reports no owner, is skipped.
+func (v *Vaultik) warnIfOwnershipNotPreserved(
+	files []*database.File, targetDir string,
+) {
+	for _, file := range files {
+		targetPath, err := containedRestorePath(
+			v.Fs, targetDir, file.Path.String())
+		if err != nil {
+			continue
+		}
+
+		info, err := lstatIfPossible(v.Fs, targetPath)
+		if err != nil {
+			continue
+		}
+
+		owner, ok := info.Sys().(*syscall.Stat_t)
+		if !ok {
+			continue
+		}
+
+		if owner.Uid != file.UID || owner.Gid != file.GID {
+			v.UI.Warningf("Restore did not preserve file ownership: chown(2) " +
+				"requires root. Re-run as root (e.g. with sudo) if you need " +
+				"original UID/GID preserved.")
+
+			return
+		}
+	}
+}
+
 // reportUnmatchedPaths warns, by name, about each requested path that
 // matched nothing in the snapshot, and returns an error counting them,
 // or nil when there are none.
@@ -965,8 +1001,9 @@ type restoreSession struct {
 	// root can chown a file to an arbitrary UID/GID — non-root chown
 	// always fails with EPERM. Attempting it anyway produces N
 	// guaranteed-failed syscalls + N noisy debug lines, so we skip
-	// the call entirely as non-root and emit one warning at the end
-	// of the restore explaining that ownership was not preserved.
+	// the call entirely as non-root; warnIfOwnershipNotPreserved warns
+	// once at the end of the restore if that left any owner or group
+	// other than recorded.
 	runningAsRoot bool
 	// directories holds every restored directory, for
 	// applyDirectoryMetadata to finish after the restore loop.
@@ -42,7 +42,7 @@ func TestRestoreOnAnotherMachine(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -65,7 +65,7 @@ func TestRestoreCleansTempDirOnInterrupt(t *testing.T) {
 	root := t.TempDir()

 	dataDir := filepath.Join(root, "source")
-	storeDir := filepath.Join(root, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(root, "restored")
 	dbPath := filepath.Join(root, "index.sqlite")

@@ -201,7 +201,7 @@ func TestRestoreLocalityAndReadAt(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -0,0 +1,131 @@
+package vaultik //nolint:testpackage // calls the unexported ownership check
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"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/log"
+	"sneak.berlin/go/vaultik/internal/ui"
+)
+
+// These tests cover https://git.eeqj.de/sneak/vaultik/issues/316: a
+// restore by a normal user warns that ownership was not preserved only
+// when some restored entry has another owner or group on disk than the
+// snapshot records.
+
+const ownershipWarning = "did not preserve file ownership"
+
+// TestOwnershipWarningSilentWhenEntriesMatch checks that a restore whose
+// entries all end up with their recorded owner and group prints no
+// warning.
+func TestOwnershipWarningSilentWhenEntriesMatch(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	targetDir := t.TempDir()
+	owner := ownerOf(t, targetDir)
+
+	out := restoreAsNormalUser(t, targetDir, []*database.File{
+		{Path: "/a", Mode: plainFileMode, UID: owner.Uid, GID: owner.Gid},
+		{Path: "/b", Mode: plainFileMode, UID: owner.Uid, GID: owner.Gid},
+	})
+
+	assert.Empty(t, out)
+}
+
+// TestOwnershipWarningWhenOwnerDiffers checks that the warning is printed
+// when an entry recorded with another owner is restored owned by the
+// restoring user, even though its group matches the recorded one.
+func TestOwnershipWarningWhenOwnerDiffers(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	targetDir := t.TempDir()
+	owner := ownerOf(t, targetDir)
+
+	out := restoreAsNormalUser(t, targetDir, []*database.File{
+		{Path: "/a", Mode: plainFileMode, UID: otherOwnerID, GID: owner.Gid},
+	})
+
+	assert.Equal(t, 1, strings.Count(out, ownershipWarning), out)
+}
+
+// TestOwnershipWarningWhenDirectoryGivesItsGroup checks that the warning
+// is printed, once, when entries recorded with the restoring user's
+// owner and group take another group from the setgid directory they are
+// restored into, as every new entry takes its directory's group on
+// macOS.
+func TestOwnershipWarningWhenDirectoryGivesItsGroup(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	if os.Geteuid() != 0 {
+		t.Skip("giving a directory to another group needs root")
+	}
+
+	targetDir := t.TempDir()
+	user := ownerOf(t, targetDir)
+
+	require.NoError(t, os.Chown(targetDir, -1, int(otherOwnerID)))
+	require.NoError(t, os.Chmod(targetDir, os.ModeSetgid|writableTestMode))
+
+	out := restoreAsNormalUser(t, targetDir, []*database.File{
+		{Path: "/a", Mode: plainFileMode, UID: user.Uid, GID: user.Gid},
+		{Path: "/b", Mode: plainFileMode, UID: user.Uid, GID: user.Gid},
+	})
+
+	assert.Equal(t, 1, strings.Count(out, ownershipWarning), out)
+}
+
+// ownerOf returns the owner and group path has on disk.
+func ownerOf(t *testing.T, path string) *syscall.Stat_t {
+	t.Helper()
+
+	info, err := os.Lstat(path)
+	require.NoError(t, err)
+
+	owner, ok := info.Sys().(*syscall.Stat_t)
+	require.True(t, ok)
+
+	return owner
+}
+
+// restoreAsNormalUser restores rows, all empty regular files, into
+// targetDir without changing any owner or group, as restore does for a
+// normal user, and returns what warnIfOwnershipNotPreserved prints.
+func restoreAsNormalUser(
+	t *testing.T, targetDir string, rows []*database.File,
+) string {
+	t.Helper()
+
+	ctx := context.Background()
+	rows, repos := makeFiles(ctx, t, rows)
+
+	var out bytes.Buffer
+
+	v := newContainmentVaultik(ctx, afero.NewOsFs())
+	v.UI = ui.NewWithColor(&out, false)
+
+	session := &restoreSession{
+		v:      v,
+		ctx:    ctx,
+		repos:  repos,
+		opts:   &RestoreOptions{TargetDir: targetDir},
+		result: &RestoreResult{},
+	}
+	for _, row := range rows {
+		require.NoError(t, session.restoreFile(row))
+	}
+
+	v.warnIfOwnershipNotPreserved(rows, targetDir)
+
+	return out.String()
+}
@@ -107,7 +107,7 @@ func backupOneFile(
 	require.NoError(t, afero.WriteFile(fs, srcPath, content, mode))
 	require.NoError(t, fs.Chmod(srcPath, mode))

-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	storer, err := storage.NewFileStorer(storeDir)
@@ -231,7 +231,8 @@ func (f trailingByteFile) Close() error {
 }

 // TestRestoreMissingBlobAbortsWithoutSkipErrors checks that a deleted blob
-// still ends the restore with an error when SkipErrors is not set.
+// still ends the restore with an error when SkipErrors is not set, and
+// that the error names the blob once.
 func TestRestoreMissingBlobAbortsWithoutSkipErrors(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
@@ -247,6 +248,8 @@ func TestRestoreMissingBlobAbortsWithoutSkipErrors(t *testing.T) {
 	})

 	require.ErrorIs(t, err, storage.ErrNotFound)
+	assert.Equal(t, 1, strings.Count(err.Error(), "downloading blob"),
+		err.Error())
 }

 // TestRestoreChunkInNoBlobAbortsWithoutSkipErrors checks that a chunk held
@@ -345,7 +348,7 @@ func backupSingleChunkFiles(
 		require.NoError(t, afero.WriteFile(fs, path, files[path], 0o644))
 	}

-	storer, err := storage.NewFileStorer(filepath.Join(tempDir, "remote"))
+	storer, err := storage.NewFileStorer(t.TempDir())
 	require.NoError(t, err)

 	db, err := database.New(ctx, dbPath)
@@ -29,7 +29,7 @@ func TestRestoreAndDeepVerifyRejectSwappedDatabase(t *testing.T) {

 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()

 	chunkSize := int64(64 * 1024)

@@ -100,7 +100,7 @@ func TestDeepVerifyRejectsSwappedDatabaseWithEmptyManifest(t *testing.T) {

 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()

 	chunkSize := int64(64 * 1024)

@@ -186,7 +186,7 @@ func TestRestoreSweeperEvictsBlobs(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -34,7 +34,7 @@ func TestRestoreFreesBlobsNoPendingFileNeeds(t *testing.T) {
 	dataDir := filepath.Join(tempDir, "source")
 	originalsDir := filepath.Join(dataDir, "originals")
 	copiesDir := filepath.Join(dataDir, "copies")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	originals := writeFilesWithCopies(t, fs, originalsDir, copiesDir, fileBytes)
@@ -33,7 +33,7 @@ func TestRestoreRejectsTruncatedMetadataDB(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -32,7 +32,7 @@ func TestRestoreNamesUnmatchedPathAndRestoresTheMatchingOne(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -89,7 +89,7 @@ func TestRestoreNamesEveryPathWhenNothingMatches(t *testing.T) {
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
 	linkDir := filepath.Join(tempDir, "srclink")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -152,7 +152,7 @@ func TestRestoreNamesUnmatchedPathWhenADamagedBlobStopsIt(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -28,7 +28,7 @@ func TestVerifyPassesWhenBackupReusesStoredBlob(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	secondDBPath := filepath.Join(tempDir, "second.sqlite")

 	chunkSize := int64(64 * 1024)
@@ -25,7 +25,7 @@ func TestBackupOfSameSecondRewriteRestoresNewContent(t *testing.T) {
 	fs := afero.NewOsFs()
 	tempDir := t.TempDir()
 	dataDir := filepath.Join(tempDir, "src")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")
 	rewrittenPath := filepath.Join(dataDir, "small.txt")
@@ -27,7 +27,7 @@ import (
 // then grows one stored blob so its size no longer matches the manifest.
 // Shallow verify must then fail, count the grown blob as a size mismatch,
 // and drop it from the verified count rather than continuing to report it
-// as checked.
+// as checked, and its error must not repeat the cli layer's prefix.
 func TestShallowVerifyDetectsWrongBlobSize(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
@@ -36,7 +36,7 @@ func TestShallowVerifyDetectsWrongBlobSize(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	chunkSize := int64(32 * 1024)
@@ -96,6 +96,12 @@ func TestShallowVerifyDetectsWrongBlobSize(t *testing.T) {
 	require.Equal(t, 1, bad.Mismatched)
 	require.Equal(t, healthy.BlobCount-1, bad.Verified,
 		"the wrong-sized blob must not be counted as verified")
+
+	// The cli layer prints this error after its own "Verification failed:".
+	err = newVerifier(io.Discard).VerifySnapshotWithOptions(
+		snapshotID, &vaultik.VerifyOptions{})
+	require.EqualError(t, err,
+		"problems found in storage: 1 blobs have the wrong size")
 }

 // TestShallowVerifyDetectsMissingDatabase backs up a real snapshot,
@@ -110,7 +116,7 @@ func TestShallowVerifyDetectsMissingDatabase(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	chunkSize := int64(32 * 1024)
@@ -193,7 +199,7 @@ func TestShallowVerifyReportsStatErrorsApartFromMissing(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	chunkSize := int64(32 * 1024)
@@ -282,7 +288,7 @@ func TestShallowVerifyQuietFailsOnStatErrorAlone(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	chunkSize := int64(32 * 1024)
@@ -23,6 +23,7 @@ var (
 	errSnapshotNotInConfig  = errors.New("snapshot not found in config")
 	errNoSnapshotsInConfig  = errors.New("no snapshots configured")
 	errSnapshotVerifyFailed = errors.New("verification failed")
+	errProblemsInStorage    = errors.New("problems found in storage")
 	errRemoveAllNeedsForce  = errors.New("--all requires --force")
 	errSnapshotNotFound     = errors.New("snapshot not found")
 	errSnapshotRemoveFailed = errors.New("snapshot(s) could not be removed")
@@ -38,6 +39,11 @@ var (
 // caller can report it apart from a failed backup.
 var ErrPostBackupPruneFailed = errors.New("post-backup prune failed")

+// ErrFilesUnreadable is returned when --skip-errors skipped files or
+// directories it could not read or list. The snapshot is complete and
+// kept, so the caller can report it apart from a failed backup.
+var ErrFilesUnreadable = errors.New("file(s) could not be read")
+
 // listRecentLimit caps how many snapshot rows are fetched from the
 // local index for listing and purge operations.
 const listRecentLimit = 10000
@@ -94,6 +100,13 @@ func (v *Vaultik) CreateSnapshot(opts *SnapshotCreateOptions) error {
 		return err
 	}

+	// Before PruneDatabase: it drops incomplete snapshots, which could
+	// leave the local index without one and so skip the marker check.
+	err = v.markDestination()
+	if err != nil {
+		return err
+	}
+
 	// Clean up incomplete snapshots FIRST, before any scanning.
 	// This is critical for data safety; PruneDatabase below does it.
 	hostname := v.Config.Hostname
@@ -116,30 +129,22 @@ func (v *Vaultik) CreateSnapshot(opts *SnapshotCreateOptions) error {
 		return fmt.Errorf("prune database: %w", err)
 	}

-	// Determine which snapshots to process
-	snapshotNames := opts.Snapshots
-	if len(snapshotNames) == 0 {
-		snapshotNames = v.Config.SnapshotNames()
-	} else {
-		// Validate requested snapshot names exist
-		for _, name := range snapshotNames {
-			if _, ok := v.Config.Snapshots[name]; !ok {
-				return fmt.Errorf("%w: %q", errSnapshotNotInConfig, name)
-			}
-		}
-	}
-
-	if len(snapshotNames) == 0 {
-		return errNoSnapshotsInConfig
+	snapshotNames, err := v.snapshotNamesToCreate(opts.Snapshots)
+	if err != nil {
+		return err
 	}

 	// Process each named snapshot
+	filesUnreadable := 0
+
 	for snapIdx, snapName := range snapshotNames {
-		err = v.createNamedSnapshot(
+		unreadable, err := v.createNamedSnapshot(
 			opts, hostname, snapName, snapIdx+1, len(snapshotNames))
 		if err != nil {
 			return err
 		}
+
+		filesUnreadable += unreadable
 	}

 	// Print overall summary if multiple snapshots
@@ -148,13 +153,34 @@ func (v *Vaultik) CreateSnapshot(opts *SnapshotCreateOptions) error {
 			len(snapshotNames), v.UI.Duration(time.Since(overallStartTime)))
 	}

-	if opts.Prune {
+	switch {
+	case opts.Prune && filesUnreadable > 0:
+		// An older snapshot may be the only one that still holds a file
+		// this run could not read.
+		log.Warn("Skipping post-backup prune",
+			"files_unreadable", filesUnreadable)
+		v.UI.Warningf("Skipped the post-backup prune because %d file(s) "+
+			"could not be read; older snapshots are kept.", filesUnreadable)
+	case opts.Prune:
 		err = v.runPostBackupPrune(snapshotNames, opts.KeepNewerThan)
 		if err != nil {
 			return fmt.Errorf("%w: %w", ErrPostBackupPruneFailed, err)
 		}
 	}

+	return v.finishCreateSnapshot(filesUnreadable)
+}
+
+// finishCreateSnapshot ends a run whose snapshots are all complete and
+// kept. Like finishRestore, it returns an error when --skip-errors
+// skipped anything it could not read or list; otherwise it prints the
+// closing line. A file removed during the run is counted as failed in
+// the summary but is not an error, with or without --skip-errors.
+func (v *Vaultik) finishCreateSnapshot(filesUnreadable int) error {
+	if filesUnreadable > 0 {
+		return fmt.Errorf("%d %w", filesUnreadable, ErrFilesUnreadable)
+	}
+
 	// Terminus must obey the --cron invariant: silent on total
 	// success only. UI.Complete is dropped in cron/quiet mode (that's
 	// the success path), but if any warnings fired during the run we
@@ -170,6 +196,28 @@ func (v *Vaultik) CreateSnapshot(opts *SnapshotCreateOptions) error {
 	return nil
 }

+// snapshotNamesToCreate returns the requested snapshot names, each checked
+// against the config, or every configured name when none was requested.
+func (v *Vaultik) snapshotNamesToCreate(requested []string) ([]string, error) {
+	snapshotNames := requested
+	if len(snapshotNames) == 0 {
+		snapshotNames = v.Config.SnapshotNames()
+	} else {
+		// Validate requested snapshot names exist
+		for _, name := range snapshotNames {
+			if _, ok := v.Config.Snapshots[name]; !ok {
+				return nil, fmt.Errorf("%w: %q", errSnapshotNotInConfig, name)
+			}
+		}
+	}
+
+	if len(snapshotNames) == 0 {
+		return nil, errNoSnapshotsInConfig
+	}
+
+	return snapshotNames, nil
+}
+
 // runPostBackupPrune drops older snapshots of the given names and removes
 // orphan blobs from remote storage. If keepNewerThan is set (e.g. "4w"),
 // snapshots newer than that duration are kept. Otherwise only the latest
@@ -222,16 +270,22 @@ type snapshotStats struct {
 	totalBlobsUploaded int
 	uploadDuration     time.Duration

+	// The part of totalFilesFailed that --skip-errors skipped because it
+	// could not be read or listed.
+	totalFilesUnreadable int
+
 	// The sizes of all blobs the snapshot references, set by
 	// finalizeSnapshotMetadata once snapshot_blobs is populated.
 	blobSize             int64
 	blobUncompressedSize int64
 }

-// createNamedSnapshot creates a single named snapshot
+// createNamedSnapshot creates a single named snapshot and returns the
+// number of entries --skip-errors skipped because it could not read or
+// list them.
 func (v *Vaultik) createNamedSnapshot(
 	opts *SnapshotCreateOptions, hostname, snapName string, idx, total int,
-) error {
+) (int, error) {
 	snapshotStartTime := time.Now()

 	if total > 1 {
@@ -240,21 +294,27 @@ func (v *Vaultik) createNamedSnapshot(

 	resolvedDirs, err := v.resolveSnapshotPaths(snapName)
 	if err != nil {
-		return err
+		return 0, err
+	}
+
+	previousSnapshotID, err := v.previousSnapshotID(snapName)
+	if err != nil {
+		return 0, err
 	}

 	scanner := v.ScannerFactory(snapshot.ScannerParams{
-		EnableProgress: !opts.Cron,
-		UI:             v.UI,
-		Fs:             v.Fs,
-		Exclude:        v.Config.GetExcludes(snapName),
-		SkipErrors:     opts.SkipErrors,
+		EnableProgress:     !opts.Cron,
+		UI:                 v.UI,
+		Fs:                 v.Fs,
+		Exclude:            v.Config.GetExcludes(snapName),
+		SkipErrors:         opts.SkipErrors,
+		PreviousSnapshotID: previousSnapshotID,
 	})

 	snapshotID, err := v.SnapshotManager.CreateSnapshotWithName(
 		v.ctx, hostname, snapName, v.Globals.Version, v.Globals.Commit)
 	if err != nil {
-		return fmt.Errorf("creating snapshot: %w", err)
+		return 0, fmt.Errorf("creating snapshot: %w", err)
 	}

 	log.Info("Beginning snapshot", "snapshot_id", snapshotID, "name", snapName)
@@ -262,12 +322,12 @@ func (v *Vaultik) createNamedSnapshot(

 	stats, err := v.scanAllDirectories(scanner, resolvedDirs, snapshotID)
 	if err != nil {
-		return err
+		return 0, err
 	}

 	err = v.finalizeSnapshotMetadata(snapshotID, stats)
 	if err != nil {
-		return err
+		return 0, err
 	}

 	log.Info("Snapshot complete",
@@ -280,7 +340,25 @@ func (v *Vaultik) createNamedSnapshot(

 	v.printSnapshotSummary(snapshotID, snapshotStartTime, stats)

-	return nil
+	return stats.totalFilesUnreadable, nil
+}
+
+// previousSnapshotID returns the ID of the most recent completed snapshot
+// named snapName in the local index, or "" when there is none.
+func (v *Vaultik) previousSnapshotID(snapName string) (string, error) {
+	snapshots, err := v.Repositories.Snapshots.ListRecent(v.ctx, listRecentLimit)
+	if err != nil {
+		return "", fmt.Errorf("listing snapshots: %w", err)
+	}
+
+	for _, s := range snapshots {
+		if s.CompletedAt != nil &&
+			parseSnapshotName(s.ID.String(), s.Hostname.String()) == snapName {
+			return s.ID.String(), nil
+		}
+	}
+
+	return "", nil
 }

 // resolveSnapshotPaths resolves source directories to absolute paths
@@ -348,6 +426,7 @@ func (v *Vaultik) scanAllDirectories(
 		stats.totalBlobs += result.BlobsCreated
 		stats.totalFilesSkipped += result.FilesSkipped
 		stats.totalFilesFailed += result.FilesFailed
+		stats.totalFilesUnreadable += result.FilesUnreadable
 		stats.totalBytesSkipped += result.BytesSkipped
 		stats.totalFilesDeleted += result.FilesDeleted
 		stats.totalBytesDeleted += result.BytesDeleted
@@ -612,7 +691,7 @@ func selectSnapshotsToPurge(
 	case opts.OlderThan != "":
 		duration, err := parseDuration(opts.OlderThan)
 		if err != nil {
-			return nil, fmt.Errorf("invalid duration: %w", err)
+			return nil, err
 		}

 		cutoff := time.Now().UTC().Add(-duration)
@@ -941,8 +1020,10 @@ func (v *Vaultik) formatVerifyResult(
 		v.printVerifySummary(result, failure)
 	}

+	// Not errSnapshotVerifyFailed: the cli layer prints this after its own
+	// "Verification failed:".
 	if failure != "" {
-		return fmt.Errorf("%w: %s", errSnapshotVerifyFailed, failure)
+		return fmt.Errorf("%w: %s", errProblemsInStorage, failure)
 	}

 	return nil
@@ -1254,10 +1335,18 @@ func (v *Vaultik) RemoveSnapshot(
 		return v.removeSnapshotDryRun(result, snapshotID, opts)
 	}

-	if !opts.Force && !opts.JSON && !v.confirmRemoveSnapshot(snapshotID, opts) {
+	if !v.confirmRemoveSnapshot(snapshotID, opts) {
 		return result, nil
 	}

+	// Checked before the local record is deleted: it may be the last
+	// snapshot in the local index, and the check applies only while the
+	// local index holds one.
+	var markerErr error
+	if !opts.LocalOnly {
+		markerErr = v.checkDestinationMarker()
+	}
+
 	if inLocalIndex {
 		log.Info("Removing snapshot from local database", "snapshot_id", snapshotID)

@@ -1268,7 +1357,7 @@ func (v *Vaultik) RemoveSnapshot(
 	}

 	result.RemoteRemoved, err = v.removeSnapshotRemote(
-		snapshotID, inLocalIndex, opts)
+		snapshotID, inLocalIndex, markerErr, opts)
 	if err != nil {
 		return result, err
 	}
@@ -1305,7 +1394,9 @@ func (v *Vaultik) RemoveSnapshot(
 // remove: no row and, unless LocalOnly is set, no metadata on the
 // destination store either. The destination store is consulted only
 // when the local index has no row, so a snapshot in the local index can
-// still be removed from it while the destination store is unreachable.
+// still be removed from it while the destination store is unreachable,
+// and only after checkDestinationMarker passes, so an unplugged volume's
+// empty mount point is not taken for a store without the snapshot.
 func (v *Vaultik) findSnapshotToRemove(
 	snapshotID string, opts *RemoveOptions,
 ) (bool, error) {
@@ -1325,6 +1416,11 @@ func (v *Vaultik) findSnapshotToRemove(
 			errSnapshotNotFound, snapshotID)
 	}

+	err := v.checkDestinationMarker()
+	if err != nil {
+		return false, err
+	}
+
 	objects, err := v.remoteSnapshotObjects(snapshot.RemoteSnapshotKey(snapshotID))
 	if err != nil {
 		return false, fmt.Errorf("looking up snapshot on destination store: %w", err)
@@ -1363,11 +1459,15 @@ func (v *Vaultik) removeSnapshotDryRun(
 }

 // confirmRemoveSnapshot prompts for confirmation before removing a
-// snapshot. Returns false (treating EOF/read errors as "no") unless the
-// user answers "y". The prompt and its answer bypass the UI: they are an
-// interactive exchange the operator must see, so --quiet does not
-// silence them.
+// snapshot, unless --force or --json is set. Returns false (treating
+// EOF/read errors as "no") unless the user answers "y". The prompt and
+// its answer bypass the UI: they are an interactive exchange the
+// operator must see, so --quiet does not silence them.
 func (v *Vaultik) confirmRemoveSnapshot(snapshotID string, opts *RemoveOptions) bool {
+	if opts.Force || opts.JSON {
+		return true
+	}
+
 	if opts.LocalOnly {
 		v.stdoutf("Remove snapshot '%s' from local database "+
 			"(remote untouched)? [y/N] ", snapshotID)
@@ -1397,15 +1497,17 @@ func (v *Vaultik) confirmRemoveSnapshot(snapshotID string, opts *RemoveOptions)
 // removeSnapshotRemote strips the snapshot's metadata from the
 // destination store. It returns true only when the delete finished
 // without an error and removed at least one object; under LocalOnly it
-// does nothing. When the snapshot is only on the destination store, a
-// failure is returned as an error, because that removal is all the
-// command does. When the snapshot was in the local index, its removal
-// there has already happened, so a failure is only a warning telling the
-// user to run `vaultik snapshot remove` for the snapshot again once the
-// destination store is reachable (`vaultik prune` never removes snapshot
-// metadata).
+// does nothing. markerErr is the result of checkDestinationMarker; when
+// it is set, nothing is deleted and it is the failure. When the snapshot
+// is only on the destination store, a failure is returned as an error,
+// because that removal is all the command does. When the snapshot was in
+// the local index, its removal there has already happened, so a failure
+// is only a warning telling the user to run `vaultik snapshot remove`
+// for the snapshot again once the destination store is reachable
+// (`vaultik prune` never removes snapshot metadata).
 func (v *Vaultik) removeSnapshotRemote(
-	snapshotID string, inLocalIndex bool, opts *RemoveOptions,
+	snapshotID string, inLocalIndex bool, markerErr error,
+	opts *RemoveOptions,
 ) (bool, error) {
 	if opts.LocalOnly {
 		return false, nil
@@ -1414,9 +1516,14 @@ func (v *Vaultik) removeSnapshotRemote(
 	log.Info("Removing snapshot metadata from remote storage",
 		"snapshot_id", snapshotID)

-	remoteKey := snapshot.RemoteSnapshotKey(snapshotID)
+	var deleted int
+
+	err := markerErr
+	if err == nil {
+		deleted, err = v.deleteRemoteSnapshotByKey(
+			snapshot.RemoteSnapshotKey(snapshotID))
+	}

-	deleted, err := v.deleteRemoteSnapshotByKey(remoteKey)
 	if err != nil && !inLocalIndex {
 		return false, fmt.Errorf(
 			"removing snapshot metadata from destination store: %w", err)
@@ -1446,7 +1553,9 @@ func (v *Vaultik) removeSnapshotRemote(
 // database from the local index, and (with --remote) every snapshot
 // metadata directory in remote storage. Both sides are processed so a
 // "remove --all" leaves nothing behind, even when the local DB and
-// remote storage have diverged.
+// remote storage have diverged. Unless LocalOnly is set, it fails
+// before it removes anything when the destination store cannot be
+// listed or is not present by checkDestinationMarker.
 func (v *Vaultik) RemoveAllSnapshots(opts *RemoveOptions) (*RemoveResult, error) {
 	err := v.EnsureStorageBinding()
 	if err != nil {
@@ -1459,11 +1568,15 @@ func (v *Vaultik) RemoveAllSnapshots(opts *RemoveOptions) (*RemoveResult, error)
 	}

 	// remoteKeys is the set of metadata/<key>/ subdirectories on the
-	// destination store; failures are downgraded to a warning so a
-	// permission-denied or unreachable remote can't block a local-only
-	// remove.
+	// destination store. Only for a local-only remove is a failure
+	// downgraded to a warning, so a permission-denied or unreachable
+	// remote can't block it.
 	remoteKeys, remoteErr := v.listAllRemoteSnapshotKeys()
 	if remoteErr != nil {
+		if !opts.LocalOnly {
+			return nil, remoteErr
+		}
+
 		log.Warn("Could not list remote snapshots", "error", remoteErr)
 		v.UI.Warningf("Could not list remote snapshots: %v.", remoteErr)
 	}
@@ -1525,8 +1638,7 @@ func (v *Vaultik) localSnapshotIDs() ([]string, error) {
 // listAllRemoteSnapshotKeys collects the hashed remote keys
 // (subdirectories under metadata/) currently present in the
 // destination store. Returns (nil, err) when the store cannot be
-// listed; callers must treat that as "no remote info available," not
-// fatal.
+// listed, or is not present by checkDestinationMarker.
 func (v *Vaultik) listAllRemoteSnapshotKeys() ([]string, error) {
 	log.Info("Listing all remote snapshots")

@@ -1575,6 +1687,11 @@ func (v *Vaultik) listAllRemoteSnapshotKeys() ([]string, error) {
 		}
 	}

+	err := v.checkDestinationMarker()
+	if err != nil {
+		return nil, err
+	}
+
 	return keys, nil
 }

@@ -1705,10 +1822,12 @@ func (v *Vaultik) deleteIncompleteSnapshot(snapshotIDStr string, id any) bool {
 	return true
 }

-// removeAllLocalSnapshots removes each known local snapshot (and, unless
-// --local-only, its remote metadata), returning the number of snapshots
-// it could not remove. A snapshot left in the local index keeps its
-// remote metadata too, since it is not an orphan remote key.
+// removeAllLocalSnapshots removes each known local snapshot's remote
+// metadata, unless --local-only, and then its local record, returning
+// the number of snapshots it could not remove. The local record goes
+// only once the metadata is deleted: dropped first, it would leave that
+// metadata on the destination store as a remote-only snapshot whose name
+// is lost.
 func (v *Vaultik) removeAllLocalSnapshots(
 	localSnaps []string, opts *RemoveOptions, result *RemoveResult,
 ) int {
@@ -1717,6 +1836,19 @@ func (v *Vaultik) removeAllLocalSnapshots(
 	for _, snapshotID := range localSnaps {
 		log.Info("Removing snapshot", "snapshot_id", snapshotID)

+		if !opts.LocalOnly {
+			_, err := v.deleteRemoteSnapshotByKey(
+				snapshot.RemoteSnapshotKey(snapshotID))
+			if err != nil {
+				log.Warn("Failed to remove snapshot metadata from remote",
+					"snapshot_id", snapshotID, "error", err)
+
+				failures++
+
+				continue
+			}
+		}
+
 		err := v.deleteSnapshotFromLocalDB(snapshotID)
 		if err != nil {
 			log.Error("Failed to remove from local database",
@@ -1727,17 +1859,6 @@ func (v *Vaultik) removeAllLocalSnapshots(
 			continue
 		}

-		if !opts.LocalOnly {
-			_, err = v.deleteRemoteSnapshotByKey(
-				snapshot.RemoteSnapshotKey(snapshotID))
-			if err != nil {
-				log.Warn("Failed to remove snapshot metadata from remote",
-					"snapshot_id", snapshotID, "error", err)
-
-				failures++
-			}
-		}
-
 		result.SnapshotsRemoved = append(result.SnapshotsRemoved, snapshotID)
 	}

@@ -0,0 +1,251 @@
+package vaultik_test
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/spf13/afero"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/vaultik/internal/config"
+	"sneak.berlin/go/vaultik/internal/database"
+	"sneak.berlin/go/vaultik/internal/log"
+	"sneak.berlin/go/vaultik/internal/storage"
+	"sneak.berlin/go/vaultik/internal/ui"
+	"sneak.berlin/go/vaultik/internal/vaultik"
+)
+
+// These tests cover https://git.eeqj.de/sneak/vaultik/issues/304: a
+// backup counts a file as deleted only when the previous snapshot of
+// the same name had it and it is gone, and never counts an excluded
+// file.
+
+// deletedCountEnv is a backup setup over the source directory src whose
+// user-facing output is kept in out. Each test configures its snapshots
+// with setSnapshot.
+type deletedCountEnv struct {
+	v   *vaultik.Vaultik
+	out *bytes.Buffer
+	src string
+}
+
+// newDeletedCountEnv writes files, keyed by path relative to src.
+func newDeletedCountEnv(t *testing.T, files map[string][]byte) *deletedCountEnv {
+	t.Helper()
+
+	ctx := context.Background()
+	fs := afero.NewOsFs()
+	tempDir := t.TempDir()
+	srcDir := filepath.Join(tempDir, "src")
+
+	for rel, content := range files {
+		path := filepath.Join(srcDir, rel)
+		require.NoError(t, fs.MkdirAll(filepath.Dir(path), 0o755))
+		require.NoError(t, afero.WriteFile(fs, path, content, 0o644))
+	}
+
+	cfg := faultTestConfig()
+	cfg.IndexPath = filepath.Join(tempDir, "index.sqlite")
+	cfg.Snapshots = map[string]config.SnapshotConfig{}
+
+	store, err := storage.NewFileStorer(t.TempDir())
+	require.NoError(t, err)
+
+	db, err := database.New(ctx, cfg.IndexPath)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = db.Close() })
+
+	repos := database.NewRepositories(db)
+	out := &bytes.Buffer{}
+	v := newBackupVaultik(ctx, cfg, store, repos, db, fs)
+	v.UI = ui.NewWithColor(out, false)
+
+	return &deletedCountEnv{v: v, out: out, src: srcDir}
+}
+
+// setSnapshot configures the snapshot name to back up the path rel
+// beneath src, with the given excludes.
+func (e *deletedCountEnv) setSnapshot(name, rel string, exclude ...string) {
+	e.v.Config.Snapshots[name] = config.SnapshotConfig{
+		Paths:   []string{filepath.Join(e.src, rel)},
+		Exclude: exclude,
+	}
+}
+
+// backUp runs a backup of the named snapshot and returns its output.
+func (e *deletedCountEnv) backUp(t *testing.T, name string) string {
+	t.Helper()
+
+	e.out.Reset()
+	require.NoError(t, e.v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
+		Snapshots: []string{name},
+	}))
+
+	return e.out.String()
+}
+
+// A file this snapshot excludes is not counted as deleted: neither one
+// that another snapshot backs up, nor one that the previous snapshot of
+// this name had before the exclude was added.
+func TestBackupDoesNotCountExcludedFileAsDeleted(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"top.txt":       []byte("top"),
+		"cache/tmp.bin": []byte("cache"),
+		"photos/a.jpg":  []byte("photo a"),
+		"photos/b.jpg":  []byte("photo b"),
+		"photos/c.jpg":  []byte("photo c"),
+	})
+	env.setSnapshot("photos", "photos")
+	env.setSnapshot("home", "", "/photos")
+
+	env.backUp(t, "photos")
+	assert.Contains(t, env.backUp(t, "home"), filesLine(2, 2, 0))
+
+	env.setSnapshot("home", "", "/photos", "/cache")
+	assert.Contains(t, env.backUp(t, "home"), filesLine(1, 0, 1))
+}
+
+// A file inside a directory that an exclude added after a backup
+// matches is not counted as deleted, though the pattern matches only the
+// directory and the directory is gone from disk.
+func TestBackupDoesNotCountFileInExcludedDirectoryAsDeleted(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"top.txt":                         []byte("top"),
+		"user/.local/share/Trash/old.txt": []byte("old"),
+	})
+	env.setSnapshot("home", "")
+
+	assert.Contains(t, env.backUp(t, "home"), filesLine(2, 2, 0))
+
+	require.NoError(t, os.RemoveAll(
+		filepath.Join(env.src, "user/.local/share/Trash")))
+
+	env.setSnapshot("home", "", "*/.local/share/Trash")
+	assert.Contains(t, env.backUp(t, "home"), filesLine(1, 0, 1))
+}
+
+// A file whose directory was replaced by a regular file of the same name
+// is counted as deleted.
+func TestBackupCountsFileInDirectoryReplacedByFileAsDeleted(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"dir/inside.txt": []byte("inside"),
+	})
+	env.setSnapshot("home", "")
+
+	assert.Contains(t, env.backUp(t, "home"), filesLine(1, 1, 0))
+
+	dir := filepath.Join(env.src, "dir")
+	require.NoError(t, os.RemoveAll(dir))
+	require.NoError(t, os.WriteFile(dir, []byte("now a file"), 0o600))
+
+	assert.Contains(t, env.backUp(t, "home"),
+		"Files: 1 examined, 1 backed up, 0 unchanged, 1 deleted.")
+}
+
+// Under --skip-errors a file inside a directory that the walk cannot
+// open is not counted as deleted: it is still on disk.
+func TestBackupDoesNotCountFileInUnopenableDirectoryAsDeleted(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"open.txt":          []byte("open"),
+		"locked/inside.txt": []byte("inside"),
+	})
+	env.setSnapshot("work", "")
+
+	assert.Contains(t, env.backUp(t, "work"), filesLine(2, 2, 0))
+
+	// A directory's mode does not lock out root, who runs the tests, so
+	// opening the directory is made to fail instead.
+	env.v.Fs = &openFailFs{
+		path: filepath.Join(env.src, "locked"),
+		err:  os.ErrPermission,
+	}
+
+	env.out.Reset()
+	err := env.v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
+		SkipErrors: true,
+		Snapshots:  []string{"work"},
+	})
+	require.ErrorIs(t, err, vaultik.ErrFilesUnreadable)
+	assert.Contains(t, env.out.String(),
+		"Files: 2 examined, 0 backed up, 1 unchanged, 1 failed.")
+}
+
+// A backup counts only files that the previous snapshot of its own name
+// had, not one that a later snapshot of another name over the same path
+// had and that is since removed.
+func TestBackupIgnoresSnapshotOfAnotherName(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"kept.txt": []byte("kept"),
+	})
+	env.setSnapshot("home", "")
+	env.setSnapshot("other", "")
+
+	env.backUp(t, "home")
+
+	// Snapshot start times are kept in whole seconds: wait so that other's
+	// snapshot is strictly the most recent.
+	time.Sleep(time.Second)
+
+	extra := filepath.Join(env.src, "extra.txt")
+	require.NoError(t, os.WriteFile(extra, []byte("extra"), 0o600))
+	env.backUp(t, "other")
+	require.NoError(t, os.Remove(extra))
+
+	assert.Contains(t, env.backUp(t, "home"), filesLine(1, 0, 1))
+}
+
+// A file removed from disk is counted as deleted by the next backup of
+// the snapshot that had it, and not by any later backup of that
+// snapshot, nor by the first backup of another name over the same path.
+func TestBackupCountsDeletedFileOnce(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	aContent := bytes.Repeat([]byte("a"), 1000)
+	bContent := bytes.Repeat([]byte("b"), 2000)
+	keptContent := bytes.Repeat([]byte("k"), 500)
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"a.txt":    aContent,
+		"b.txt":    bContent,
+		"kept.txt": keptContent,
+	})
+	env.setSnapshot("home", "")
+	env.setSnapshot("other", "")
+
+	assert.Contains(t, env.backUp(t, "home"), filesLine(3, 3, 0))
+
+	require.NoError(t, os.Remove(filepath.Join(env.src, "a.txt")))
+	require.NoError(t, os.Remove(filepath.Join(env.src, "b.txt")))
+
+	summary := env.backUp(t, "home")
+	assert.Contains(t, summary,
+		"Files: 1 examined, 0 backed up, 1 unchanged, 2 deleted.")
+	assert.Contains(t, summary,
+		fmt.Sprintf("Data: %s total (%s backed up), %s deleted.",
+			env.v.UI.Size(int64(len(keptContent))), env.v.UI.Size(0),
+			env.v.UI.Size(int64(len(aContent)+len(bContent)))))
+
+	assert.Contains(t, env.backUp(t, "home"), filesLine(1, 0, 1))
+	assert.Contains(t, env.backUp(t, "other"), filesLine(1, 0, 1))
+}
@@ -49,13 +49,19 @@ func TestSnapshotSummaryCountsFileNotStoredAsFailed(t *testing.T) {
 		name       string
 		openErr    error
 		skipErrors bool
+		wantErr    error // nil for none
 	}{
 		// What a normal user gets opening a file with mode 000.
 		{name: "unopenable under skip-errors",
-			openErr: os.ErrPermission, skipErrors: true},
+			openErr: os.ErrPermission, skipErrors: true,
+			wantErr: vaultik.ErrFilesUnreadable},
 		// What opening a file removed after phase 1 gives.
 		{name: "removed between the phases",
 			openErr: os.ErrNotExist, skipErrors: false},
+		// A removal is not an error, so --skip-errors does not make the
+		// run fail. See https://git.eeqj.de/sneak/vaultik/issues/310.
+		{name: "removed between the phases under skip-errors",
+			openErr: os.ErrNotExist, skipErrors: true},
 	}

 	for _, tt := range tests {
@@ -87,7 +93,7 @@ func TestSnapshotSummaryCountsFileNotStoredAsFailed(t *testing.T) {
 				"src": {Paths: []string{srcDir}},
 			}

-			store, err := storage.NewFileStorer(filepath.Join(tempDir, "remote"))
+			store, err := storage.NewFileStorer(t.TempDir())
 			require.NoError(t, err)

 			db, err := database.New(ctx, cfg.IndexPath)
@@ -99,10 +105,11 @@ func TestSnapshotSummaryCountsFileNotStoredAsFailed(t *testing.T) {
 			v := newBackupVaultik(ctx, cfg, store, repos, db, fs)
 			v.UI = ui.NewWithColor(out, false)

-			require.NoError(t, v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
+			err = v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
 				SkipErrors: tt.skipErrors,
 				Snapshots:  []string{"src"},
-			}))
+			})
+			require.ErrorIs(t, err, tt.wantErr)

 			summary := out.String()
 			assert.Contains(t, summary,
@@ -122,6 +122,9 @@ func newListEnv(t *testing.T) *listEnv {
 	store := newObservingStorer()
 	stdout := &bytes.Buffer{}

+	// A backup wrote to this destination, so it carries the marker.
+	require.NoError(t, store.Put(ctx, markerFile, strings.NewReader("")))
+
 	v := &vaultik.Vaultik{
 		Config: &config.Config{
 			AgeSecretKey: "",
@@ -3,6 +3,7 @@ package vaultik_test
 import (
 	"context"
 	"fmt"
+	"os"
 	"path/filepath"
 	"testing"

@@ -45,7 +46,7 @@ func TestSkipErrorsBackupStopsOnIndexErrorRecordingDirectory(t *testing.T) {
 		"tree": {Paths: []string{srcDir}},
 	}

-	store, err := storage.NewFileStorer(filepath.Join(tempDir, "remote"))
+	store, err := storage.NewFileStorer(t.TempDir())
 	require.NoError(t, err)

 	db, err := database.New(ctx, cfg.IndexPath)
@@ -73,3 +74,210 @@ func TestSkipErrorsBackupStopsOnIndexErrorRecordingDirectory(t *testing.T) {
 	require.Len(t, snapshots, 1)
 	assert.Nil(t, snapshots[0].CompletedAt)
 }
+
+// A backup under --skip-errors that skips a file it cannot open, or a
+// directory it cannot list, keeps the snapshot, counts what it skipped
+// as failed and returns an error instead of finishing successfully. See
+// https://git.eeqj.de/sneak/vaultik/issues/310.
+func TestSkipErrorsBackupKeepsSnapshotAndFailsWhenItSkips(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		skipped string // relative to the source directory
+	}{
+		{name: "file it cannot open", skipped: "skipdir/file.txt"},
+		{name: "directory it cannot list", skipped: "skipdir"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			env := newDeletedCountEnv(t, map[string][]byte{
+				"stored.txt":       []byte("stored"),
+				"skipdir/file.txt": []byte("in skipdir"),
+			})
+			env.setSnapshot("work", "")
+
+			// A mode does not lock out root, who runs the tests, so
+			// opening the skipped path is made to fail instead.
+			env.v.Fs = &openFailFs{
+				path: filepath.Join(env.src, tt.skipped),
+				err:  os.ErrPermission,
+			}
+
+			err := env.v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
+				SkipErrors: true,
+				Snapshots:  []string{"work"},
+			})
+			require.ErrorIs(t, err, vaultik.ErrFilesUnreadable)
+
+			assert.Contains(t, env.out.String(),
+				"Files: 2 examined, 1 backed up, 0 unchanged, 1 failed.")
+			assert.NotContains(t, env.out.String(), "Finished successfully.")
+
+			snapshots, err := env.v.Repositories.Snapshots.ListRecent(
+				context.Background(), listRecentTestLimit)
+			require.NoError(t, err)
+			require.Len(t, snapshots, 1)
+			assert.NotNil(t, snapshots[0].CompletedAt, "the snapshot is kept")
+		})
+	}
+}
+
+// removeOnLookupFs is the real filesystem, except that path is removed
+// just before it is looked up. The walk looks an entry up after listing
+// its directory, so path is listed but gone when the walk reaches it.
+type removeOnLookupFs struct {
+	afero.OsFs
+
+	path string
+}
+
+func (f *removeOnLookupFs) LstatIfPossible(
+	name string,
+) (os.FileInfo, bool, error) {
+	if name == f.path {
+		_ = os.Remove(name)
+	}
+
+	return f.OsFs.LstatIfPossible(name)
+}
+
+// A file removed before the walk reaches it is counted once, as failed,
+// like a file removed before its data is read, and the backup finishes
+// successfully, with or without --skip-errors. See
+// https://git.eeqj.de/sneak/vaultik/issues/310.
+func TestBackupCountsFileRemovedBeforeWalkReachesItAsFailed(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		skipErrors bool
+	}{
+		{name: "under skip-errors", skipErrors: true},
+		{name: "without skip-errors", skipErrors: false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			env := newDeletedCountEnv(t, map[string][]byte{
+				"stays.txt":   []byte("stays"),
+				"removed.txt": []byte("removed"),
+			})
+			env.setSnapshot("walk", "")
+
+			// The previous snapshot has the file, so a removal the walk
+			// also counted as deleted would show.
+			env.backUp(t, "walk")
+
+			env.v.Fs = &removeOnLookupFs{
+				path: filepath.Join(env.src, "removed.txt"),
+			}
+
+			env.out.Reset()
+			require.NoError(t, env.v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
+				SkipErrors: tt.skipErrors,
+				Snapshots:  []string{"walk"},
+			}))
+			assert.Contains(t, env.out.String(),
+				"Files: 2 examined, 0 backed up, 1 unchanged, 1 failed.")
+			assert.Contains(t, env.out.String(), "Finished successfully.")
+		})
+	}
+}
+
+// A file an exclude pattern matches is not counted when it is removed
+// before the walk reaches it. See
+// https://git.eeqj.de/sneak/vaultik/issues/310.
+func TestBackupIgnoresExcludedFileRemovedBeforeWalkReachesIt(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"stays.txt":   []byte("stays"),
+		"removed.tmp": []byte("removed"),
+	})
+	env.setSnapshot("walk", "", "*.tmp")
+	env.v.Fs = &removeOnLookupFs{
+		path: filepath.Join(env.src, "removed.tmp"),
+	}
+
+	require.NoError(t, env.v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
+		SkipErrors: true,
+		Snapshots:  []string{"walk"},
+	}))
+	assert.Contains(t, env.out.String(), filesLine(1, 1, 0))
+	assert.Contains(t, env.out.String(), "Finished successfully.")
+}
+
+// A backup under --skip-errors --prune that skipped a file it could not
+// read does not prune: the previous snapshot, the only one that holds
+// the file, is kept, and the output says the prune was skipped. See
+// https://git.eeqj.de/sneak/vaultik/issues/382.
+func TestSkipErrorsBackupDoesNotPruneWhenItSkips(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"other.txt":   []byte("other"),
+		"skipped.txt": []byte("skipped"),
+	})
+	env.setSnapshot("photos", "")
+	env.backUp(t, "photos")
+
+	// An unchanged file is not read again, so the file is changed before
+	// it becomes unreadable.
+	skipped := filepath.Join(env.src, "skipped.txt")
+	require.NoError(t, os.WriteFile(skipped, []byte("changed"), 0o600))
+	env.v.Fs = &openFailFs{path: skipped, err: os.ErrPermission}
+
+	env.out.Reset()
+	err := env.v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
+		Prune:      true,
+		SkipErrors: true,
+		Snapshots:  []string{"photos"},
+	})
+	require.ErrorIs(t, err, vaultik.ErrFilesUnreadable)
+	assert.Contains(t, env.out.String(),
+		"Skipped the post-backup prune because 1 file(s) could not be read")
+	assert.NotContains(t, env.out.String(), "Running post-backup prune.")
+
+	snapshots, err := env.v.Repositories.Snapshots.ListRecent(
+		context.Background(), listRecentTestLimit)
+	require.NoError(t, err)
+	assert.Len(t, snapshots, 2, "the previous snapshot is kept")
+}
+
+// A file removed during a backup under --skip-errors --prune is not a
+// skipped file, so the backup prunes as usual. See
+// https://git.eeqj.de/sneak/vaultik/issues/382.
+func TestSkipErrorsBackupPrunesWhenAFileIsRemovedDuringIt(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newDeletedCountEnv(t, map[string][]byte{
+		"other.txt":   []byte("other"),
+		"removed.txt": []byte("removed"),
+	})
+	env.setSnapshot("photos", "")
+	env.backUp(t, "photos")
+
+	env.v.Fs = &removeOnLookupFs{path: filepath.Join(env.src, "removed.txt")}
+
+	require.NoError(t, env.v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
+		Prune:      true,
+		SkipErrors: true,
+		Snapshots:  []string{"photos"},
+	}))
+
+	snapshots, err := env.v.Repositories.Snapshots.ListRecent(
+		context.Background(), listRecentTestLimit)
+	require.NoError(t, err)
+	assert.Len(t, snapshots, 1, "the previous snapshot is pruned")
+}
@@ -13,6 +13,7 @@ import (
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"golang.org/x/sys/unix"
 	"sneak.berlin/go/vaultik/internal/config"
 	"sneak.berlin/go/vaultik/internal/database"
 	"sneak.berlin/go/vaultik/internal/log"
@@ -84,7 +85,7 @@ func newSummaryEnv(t *testing.T) *summaryEnv {
 		"split":  {Paths: []string{dirOne, dirTwo}},
 	}

-	inner, err := storage.NewFileStorer(filepath.Join(tempDir, "remote"))
+	inner, err := storage.NewFileStorer(t.TempDir())
 	require.NoError(t, err)

 	store := faultstore.New(inner)
@@ -188,6 +189,42 @@ func (e *summaryEnv) dataLine(total, backedUp int64) string {
 		e.v.UI.Size(total), e.v.UI.Size(backedUp))
 }

+// enumeratedLine returns the line printed when the walk of a source path
+// ends.
+func (e *summaryEnv) enumeratedLine(
+	files int, total int64, toBackUp int, toBackUpSize int64,
+) string {
+	return fmt.Sprintf(
+		"Enumerated %d snapshot source files (%s total), %d to back up (%s).",
+		files, e.v.UI.Size(total), toBackUp, e.v.UI.Size(toBackUpSize))
+}
+
+// snapshotPaths returns the paths the snapshot lists, sorted.
+func (e *summaryEnv) snapshotPaths(t *testing.T, snapshotID string) []string {
+	t.Helper()
+
+	rows, err := e.db.Conn().QueryContext(context.Background(), `
+		SELECT f.path FROM snapshot_files sf JOIN files f ON f.id = sf.file_id
+		WHERE sf.snapshot_id = ? ORDER BY f.path`, snapshotID)
+	require.NoError(t, err)
+
+	defer func() { _ = rows.Close() }()
+
+	var paths []string
+
+	for rows.Next() {
+		var path string
+
+		require.NoError(t, rows.Scan(&path))
+
+		paths = append(paths, path)
+	}
+
+	require.NoError(t, rows.Err())
+
+	return paths
+}
+
 // A first backup stores copy.bin's chunks while backing up a.bin, so
 // copy.bin's chunks are deduplicated within the run. Each file and byte
 // is still counted once.
@@ -248,6 +285,85 @@ func TestSnapshotSummaryIncrementalRunWithDeduplicatedChunks(t *testing.T) {
 	assert.Equal(t, uncompressed, snap.BlobUncompressedSize)
 }

+// A backup of a tree with directories and a symlink, none of which
+// changed since the last backup, backs up nothing, and the snapshot
+// still lists every one of them. Both sides of the line that ends the
+// walk count the same entries, the files and the symlink, and no
+// directory's size. See https://git.eeqj.de/sneak/vaultik/issues/305.
+func TestSnapshotSummaryUnchangedRunWithDirectoriesAndSymlink(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newSummaryEnv(t)
+
+	const linkTarget = "a.bin"
+
+	require.NoError(t, os.Symlink(linkTarget,
+		filepath.Join(filepath.Dir(env.aPath), "link")))
+
+	// A symlink's size is the length of its target.
+	total := env.totalSize + int64(len(linkTarget))
+
+	first := env.backUp(t, "first", false)
+	assert.Contains(t, first, env.enumeratedLine(4, total, 4, total))
+	assert.Contains(t, first, filesLine(4, 4, 0))
+
+	second := env.backUp(t, "second", false)
+	assert.Contains(t, second, env.enumeratedLine(4, total, 0, 0))
+	assert.Contains(t, second, filesLine(4, 0, 4))
+	assert.Contains(t, second, env.dataLine(total, 0))
+
+	assert.Equal(t,
+		env.snapshotPaths(t, env.snapshot(t, "first").ID.String()),
+		env.snapshotPaths(t, env.snapshot(t, "second").ID.String()))
+}
+
+// A directory whose mtime changed and a symlink whose target changed are
+// recorded again by the next backup, which counts only the symlink as
+// backed up.
+func TestSnapshotSummaryChangedDirectoryAndSymlink(t *testing.T) {
+	log.Initialize(log.Config{})
+	t.Parallel()
+
+	env := newSummaryEnv(t)
+
+	// The local index keeps paths with symlinks resolved.
+	dir, err := filepath.EvalSymlinks(filepath.Dir(env.aPath))
+	require.NoError(t, err)
+
+	// The new link gets the old one's mtime, and a target, which need not
+	// exist, of the old target's length, a symlink's size: only the
+	// target differs.
+	linkTime := unix.NsecToTimeval(
+		time.Date(2029, time.March, 4, 5, 6, 7, 0, time.UTC).UnixNano())
+	link := filepath.Join(dir, "link")
+	require.NoError(t, os.Symlink("a.bin", link))
+	require.NoError(t, unix.Lutimes(link, []unix.Timeval{linkTime, linkTime}))
+
+	env.backUp(t, "first", false)
+
+	require.NoError(t, os.Remove(link))
+	require.NoError(t, os.Symlink("b.bin", link))
+	require.NoError(t, unix.Lutimes(link, []unix.Timeval{linkTime, linkTime}))
+
+	mtime := time.Date(2030, time.January, 2, 3, 4, 5, 0, time.UTC)
+	require.NoError(t, os.Chtimes(dir, mtime, mtime))
+
+	assert.Contains(t, env.backUp(t, "second", false), filesLine(4, 1, 3))
+
+	ctx := context.Background()
+
+	dirRow, err := env.repos.Files.GetByPath(ctx, dir)
+	require.NoError(t, err)
+	require.NotNil(t, dirRow)
+	assert.Equal(t, mtime.Unix(), dirRow.MTime.Unix())
+
+	linkRow, err := env.repos.Files.GetByPath(ctx, link)
+	require.NoError(t, err)
+	require.NotNil(t, linkRow)
+	assert.Equal(t, "b.bin", linkRow.LinkTarget.String())
+}
+
 // Under --cron the progress reporter is off; the upload figures must
 // still reach the summary and the snapshots row. The snapshot has two
 // paths, each backed up by its own scan.
@@ -28,7 +28,7 @@ func TestBackupWithoutCronOfTwoPathSnapshotRestoresBothPaths(t *testing.T) {
 	tempDir := t.TempDir()
 	firstDir := filepath.Join(tempDir, "first")
 	secondDir := filepath.Join(tempDir, "second")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	restoreDir := filepath.Join(tempDir, "restored")
 	dbPath := filepath.Join(tempDir, "index.sqlite")

@@ -36,7 +36,7 @@ func TestUncompressedSizeOfChangedFileStaysFixed(t *testing.T) {

 	appendRandomBytes(t, fs, files, changedPath, appendedFileSize)

-	store, err := storage.NewFileStorer(filepath.Join(tempDir, "remote"))
+	store, err := storage.NewFileStorer(t.TempDir())
 	require.NoError(t, err)

 	db, err := database.New(ctx, dbPath)
@@ -680,7 +680,7 @@ func (v *Vaultik) verifyManifestAgainstDatabase(
 func (v *Vaultik) verifyBlobExistenceFromDB(
 	blobs []snapshot.BlobInfo, result *VerifyResult,
 ) error {
-	log.Info("Verifying blob existence in S3", "blob_count", len(blobs))
+	log.Info("Verifying blob existence in storage", "blob_count", len(blobs))

 	for i, blob := range blobs {
 		// The hash is read from the snapshot database, which is not
@@ -700,7 +700,7 @@ func (v *Vaultik) verifyBlobExistenceFromDB(
 			result.Missing++
 			result.MissingSize += blob.CompressedSize
 		case err != nil:
-			return fmt.Errorf("checking blob %s in storage: %w",
+			return fmt.Errorf("could not check blob %s in storage: %w",
 				blob.Hash, err)
 		case stat.Size != blob.CompressedSize:
 			log.Warn("Blob has the wrong size in storage",
@@ -28,7 +28,7 @@ func TestVerify_QuietSuppressesReport(t *testing.T) {
 	tempDir := t.TempDir()

 	dataDir := filepath.Join(tempDir, "source")
-	storeDir := filepath.Join(tempDir, "remote")
+	storeDir := t.TempDir()
 	dbPath := filepath.Join(tempDir, "index.sqlite")

 	chunkSize := int64(32 * 1024)
Author	SHA1	Message	Date
clawbot	2590f49583	Record the defect-hunt fixes in TODO.md Completed Steps (closes #334 ) check / check (push) Waiting to run Details release / release (push) Waiting to run Details Adds a Completed Steps entry, newest first, for every issue from the defect hunt (#288) that a merged fix closed and that had none: the hunt's own issues, those filed while fixing them, and the owner's ruling on #239. Each entry says in one or two sentences what was wrong and what changed; the detail is in each fix's commit. Next Step now says the hunt's fixes have landed. Judgement call: #332, closed as covered by the fix for #296, is named in that entry rather than given its own. Judgement call: #351, a Docker build fix filed while gating these fixes, gets an entry. Model: opus-5-5	2026-10-14 09:18:09 +02:00
clawbot	5b8d84e38a	Do not prune after a backup that skipped unreadable files (closes #382 ) check / check (push) Waiting to run Details snapshot create --skip-errors --prune pruned even when files were skipped, so by default it deleted the previous snapshot of that name, the only one still holding a file that had become unreadable, along with blobs only that snapshot referenced. The prune is now skipped exactly when the run exits non-zero for entries --skip-errors could not read or list: older snapshots are kept, a warning says why, and the run still exits non-zero. A file removed during the run does not count, so such a run still prunes. The README's --prune text and the flag's help say so. Model: opus-5-5	2026-10-14 07:44:50 +02:00
clawbot	7a950ea2aa	Exit non-zero when snapshot create --skip-errors skips anything it cannot read (closes #310 ) check / check (push) Waiting to run Details A backup under --skip-errors printed its skip errors, then "Finished successfully.", and exited 0, so a cron wrapper could not tell it from a complete backup. Each skipped entry, including a directory the walk could not list, is now counted as examined and failed. If --skip-errors skipped anything it could not read or list, the run still keeps its snapshots and prunes as before, then fails with "Backup completed, but N file(s) could not be read". A file removed during the run, even before the walk reaches it, counts once as failed and leaves the exit status alone; without the flag it no longer stops the backup. Excluded entries are never counted. Model: opus-5-5	2026-10-14 07:13:48 +02:00
clawbot	16b03dfda5	Keep the local index when remote nuke cannot list or find the destination (closes #292 ) check / check (push) Waiting to run Details `remote nuke` took a destination store it could not list, or one without `vaultik-destination.txt` while the local index held snapshots, as a warning: it then cleared the local snapshot records, and for an unplugged volume's empty mount point reported the store empty and exited zero. Nuke now fails on either before it removes anything, without its advice to run it again, which would fail the same way. The bulk remove it runs fails on either too; only a local-only remove still goes on with a warning. Nuke also deletes each snapshot's remote metadata before its local record, so a failed delete keeps the snapshot in the local index rather than leaving it on the store as a remote-only snapshot. Model: opus-5-5	2026-10-14 06:47:38 +02:00
clawbot	2125a9d451	Stop counting directories and unchanged symlinks as files to back up (closes #305 ) check / check (push) Waiting to run Details Every backup queued every directory and symlink for the second phase. The line ending the walk counted directories, and their stat sizes, as files to back up while its enumerated count left them out, and a symlink was counted as backed up on every run, its target length as data. The walk now sets directories aside: they are recorded before the files are backed up and never counted as files or data, and the walk's progress estimate leaves out the directories the local index knows. A symlink is checked against its record like a regular file, its target included, so an unchanged one counts as unchanged. Judgement call: every directory is still written to the local index on every backup, as before; no report shows it. Model: opus-5-5	2026-10-14 06:46:45 +02:00
clawbot	a0de8bfdb7	Refuse a backup destination an unplugged volume left empty (closes #239 ) check / check (push) Waiting to run Details Every backup writes vaultik-destination.txt at the destination root. While the local index holds snapshots stored there, a destination without it is not present: snapshot create refuses before writing, prune and snapshot purge fail, and snapshot list and snapshot remove act as for a destination that cannot be listed. snapshot create and snapshot remove check it first. remote nuke deletes the marker last. The file:// backend never creates its destination directory, which protects a directory on a removable volume, not a mount point. Tests back up into directories that exist; fixtures for a written destination carry the marker. Judgement call: the marker is rewritten on every backup. Deviation: for the complexity limit, two blocks moved, unchanged, into snapshotNamesToCreate and confirmRemoveSnapshot. Model: opus-5-5	2026-10-14 05:46:42 +02:00
clawbot	291c39174f	Warn about restored ownership only when an entry's owner or group differs (closes #316 ) check / check (push) Waiting to run Details A restore by a normal user always warned that file ownership was not preserved, even when every entry came out with its recorded owner and group. The owner and group each restored entry has on disk are now compared with the recorded ones, and the warning is printed once if any differ. The comparison is made on disk because on macOS, and in a setgid directory on Linux, a new entry takes the group of its directory, not the user's. Judgement call: an entry that is not on disk after the restore is not compared. Unverified: not run on a Mac; the directory-group test runs only as root. Model: opus-5-5	2026-10-14 05:39:27 +02:00
clawbot	65036bba1b	Make snapshot list report a changed destination instead of advising prune (closes #317 ) check / check (push) Waiting to run Details When the local index is bound to a different destination than the configured one, snapshot list now gives the warning prune, snapshot purge and snapshot remove refuse with: both destinations and the two ways out (revert the configuration, or run vaultik database delete). Below the table it replaces the local-only note and its prune advice. With --json it goes to stderr through the logger, so stdout stays the document, whose local rows show remote_present false. Reading the binding moves out of EnsureStorageBinding into storageBinding, which records nothing, so the read-only list can call it without binding a fresh index. Model: opus-5-5	2026-10-14 04:29:36 +02:00
clawbot	54ad279dd6	Count a file as deleted only if the previous snapshot of its name had it (closes #304 ) check / check (push) Waiting to run Details A backup counted as deleted every file in the local index under the source path that the walk did not find: files the snapshot excludes but another snapshot backs up, and files removed long ago, which every later backup, and the first backup of another name over the same path, reported as deleted again. The backup now counts only files that the latest completed snapshot of the same name lists, the walk did not find, and are gone from disk, including a file whose directory became a regular file. Excluded files and files the walk could not reach under --skip-errors are not counted. Only the backup's output changes; the snapshots row stores no deleted figure. Model: opus-5-5	2026-10-14 04:24:30 +02:00
clawbot	d156a02c49	Name each prefix once in restore, verify and purge errors (closes #327 ) check / check (push) Waiting to run Details A missing blob during restore, a failed shallow verify and an invalid purge duration each printed their prefix twice. FetchBlob now returns the storage error as is, since restore and deep verify name the blob themselves; purge returns the duration parser's error unchanged; and a failed shallow verify wraps "problems found in storage" instead of "verification failed", which the command already prints. Deep verify words a storage error other than not found as a blob it could not check, and its log line no longer says S3. Already fixed for #314: the deep verify size message naming S3 and other errors called missing; tests now check both. Not tested: the log line. Model: opus-5-5	2026-10-14 04:04:14 +02:00
clawbot	aeac897805	Refuse credentials in a storage URL's endpoint or rclone remote name (closes #322 ) check / check (push) Waiting to run Details storage_url refused only the outer URL's userinfo and unknown query parameters. Userinfo inside the s3 endpoint= value, and rclone's remote,param=value parameters in the remote name, were accepted and then printed by info, remote info and snapshot create. Both are now refused without echoing the value: a host name never contains "@", and an rclone remote name never contains a comma. An s3 or rclone query that cannot be decoded (a ";" or a bad "%" escape) is refused too, because decoding drops that part before it can be checked. The comma is checked before url.Parse, whose error for such a name prints part of it. The rclone remote name case has its own error pointing at rclone config. Model: opus-5-5	2026-10-14 03:26:02 +02:00