Add unit tests for checker/scanner and validate input paths

- Add comprehensive unit tests for internal/checker (88.5% coverage)
  - Status string representations
  - NewChecker validation
  - Check operation (OK, missing, size/hash mismatch)
  - Progress reporting and context cancellation
  - FindExtraFiles functionality

- Add comprehensive unit tests for internal/scanner (80.1% coverage)
  - Constructors and options
  - File/path enumeration
  - Dotfile exclusion/inclusion
  - ToManifest with progress and cancellation
  - Non-blocking status channel sends

- Validate input paths before scanning in generate command
  - Fail fast with clear error if paths don't exist
  - Prevents confusing errors deep in enumeration

internal/cli/entry_test.go

@@ -485,6 +485,42 @@ func TestGenerateAtomicWriteCleansUpOnError(t *testing.T) {
 	assert.False(t, tmpExists, "temp file should be cleaned up after failed generation")
 }
 
+func TestGenerateValidatesInputPaths(t *testing.T) {
+	fs := afero.NewMemMapFs()
+
+	// Create one valid directory
+	require.NoError(t, fs.MkdirAll("/validdir", 0755))
+	require.NoError(t, afero.WriteFile(fs, "/validdir/file.txt", []byte("content"), 0644))
+
+	t.Run("nonexistent path fails fast", func(t *testing.T) {
+		opts := testOpts([]string{"mfer", "generate", "-q", "-o", "/output.mf", "/nonexistent"}, fs)
+		exitCode := RunWithOptions(opts)
+		assert.Equal(t, 1, exitCode)
+		stderr := opts.Stderr.(*bytes.Buffer).String()
+		assert.Contains(t, stderr, "path does not exist")
+		assert.Contains(t, stderr, "/nonexistent")
+	})
+
+	t.Run("mix of valid and invalid paths fails fast", func(t *testing.T) {
+		opts := testOpts([]string{"mfer", "generate", "-q", "-o", "/output.mf", "/validdir", "/alsononexistent"}, fs)
+		exitCode := RunWithOptions(opts)
+		assert.Equal(t, 1, exitCode)
+		stderr := opts.Stderr.(*bytes.Buffer).String()
+		assert.Contains(t, stderr, "path does not exist")
+		assert.Contains(t, stderr, "/alsononexistent")
+
+		// Output file should not have been created
+		exists, _ := afero.Exists(fs, "/output.mf")
+		assert.False(t, exists, "output file should not exist when path validation fails")
+	})
+
+	t.Run("valid paths succeed", func(t *testing.T) {
+		opts := testOpts([]string{"mfer", "generate", "-q", "-o", "/output.mf", "/validdir"}, fs)
+		exitCode := RunWithOptions(opts)
+		assert.Equal(t, 0, exitCode)
+	})
+}
+
 func TestCheckDetectsManifestCorruption(t *testing.T) {
 	fs := afero.NewMemMapFs()
 	rng := rand.New(rand.NewSource(42))

internal/cli/gen.go

@@ -54,13 +54,18 @@ func (mfa *CLIApp) generateManifestOperation(ctx *cli.Context) error {
 			return err
 		}
 	} else {
-		// Collect all paths first
+		// Collect and validate all paths first
 		paths := make([]string, 0, args.Len())
 		for i := 0; i < args.Len(); i++ {
-			ap, err := filepath.Abs(args.Get(i))
+			inputPath := args.Get(i)
+			ap, err := filepath.Abs(inputPath)
 			if err != nil {
 				return err
 			}
+			// Validate path exists before adding to list
+			if exists, _ := afero.Exists(mfa.Fs, ap); !exists {
+				return fmt.Errorf("path does not exist: %s", inputPath)
+			}
 			log.Debugf("enumerating path: %s", ap)
 			paths = append(paths, ap)
 		}