Refuse a backup destination an unplugged volume left empty (closes #239)

Every backup writes vaultik-destination.txt at the destination root.
While the local index holds snapshots, 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 checks before it
drops incomplete snapshots, snapshot remove before it looks on the
destination. remote nuke deletes the marker last. The file:// backend
never creates its destination directory; that 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

internal/vaultik/destination_marker_test.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -91,6 +92,31 @@ func TestBackupRefusesDestinationWithoutMarker(t *testing.T) {
 	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) {
@@ -147,6 +173,35 @@ func TestRemoveSnapshotWarnsWhenDestinationHasNoMarker(t *testing.T) {
 		"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.

internal/vaultik/snapshot.go

@@ -1330,7 +1330,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) {
@@ -1350,6 +1352,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)