Exit non-zero when snapshot create --skip-errors skips anything it cannot read (closes #310)

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

internal/snapshot/scanner.go

@@ -141,10 +141,12 @@ type ScannerConfig struct {
 // 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
@@ -161,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
@@ -890,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
@@ -901,15 +928,6 @@ 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, knownFiles, collector, result)
@@ -985,7 +1003,7 @@ func (s *Scanner) recordSpecialEntry(
 	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{}{}
@@ -1009,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
 	}
 
@@ -1459,6 +1500,7 @@ func (s *Scanner) processFileWithErrorHandling(
 				s.ui.Path(fileToProcess.Path), err)
 
 			countFailedFile(fileToProcess, result)
+			result.FilesUnreadable++
 
 			return true, nil
 		}