fix(googlephotos): properly transition discovered assets to discarded state

Assets discovered during Google Photos takeout processing were being left
in PENDING state when they should have been transitioned to DISCARDED.

Two scenarios were affected:

1. Duplicate files in the same directory: When a file with the same base
   name was found in a directory, RecordAssetDiscardedImmediately was
   being called. However, the asset was already discovered and in PENDING
   state, so RecordAssetDiscarded should be used instead to properly
   transition it.

2. Files without JSON metadata: When --include-unmatched is false, files
   without matching JSON metadata were not being transitioned to DISCARDED
   state, leaving them stuck in PENDING.

This resulted in assets being reported as "pending" at the end of upload,
even though they were correctly identified as duplicates or filtered.

Author: rwwiv

adapters/googlePhotos/googlephotos.go

@@ -229,7 +229,8 @@ func (toc *TakeoutCmd) passOneFsWalk(ctx context.Context, w fs.FS) error {
 				toc.fileTracker.Store(key, tracking) // to.fileTracker[key] = tracking
 
 				if _, ok := dirCatalog.unMatchedFiles[base]; ok {
-					toc.processor.RecordAssetDiscardedImmediately(ctx, fshelper.FSName(w, name), finfo.Size(), fileevent.DiscardedLocalDuplicate, "duplicated in the directory")
+					// Asset was already discovered above, so transition from pending to discarded
+					toc.processor.RecordAssetDiscarded(ctx, fshelper.FSName(w, name), finfo.Size(), fileevent.DiscardedLocalDuplicate, "duplicated in the directory")
 					return nil
 				}
 
@@ -323,8 +324,11 @@ func (toc *TakeoutCmd) solvePuzzle(ctx context.Context) error {
 				if toc.KeepJSONLess {
 					a := toc.makeAsset(ctx, dir, i, nil)
 					cat.matchedFiles[f] = a
-					delete(cat.unMatchedFiles, f)
+				} else {
+					// Asset was discovered but has no JSON metadata and --include-unmatched is not set
+					toc.processor.RecordAssetDiscarded(ctx, fshelper.FSName(i.fsys, path.Join(dir, i.base)), int64(i.length), fileevent.DiscardedFiltered, "no matching JSON metadata (use --include-unmatched to import)")
 				}
+				delete(cat.unMatchedFiles, f)
 			}
 		}
 	}

internal/fileprocessor/processor_test.go

@@ -435,6 +435,124 @@ func TestSummary(t *testing.T) {
 	}
 }
 
+// TestDiscoverThenDiscardTransition verifies that assets discovered and later
+// determined to be discardable (e.g., duplicates found during processing, files
+// without required metadata) are properly transitioned from PENDING to DISCARDED.
+//
+// This test documents a bug fix where assets were being discovered but not
+// properly transitioned to a final state when discarded during later processing
+// stages, leaving them stuck in PENDING state.
+//
+// The key insight is:
+//   - RecordAssetDiscardedImmediately: For assets discarded AT discovery time
+//     (before being added to pending)
+//   - RecordAssetDiscarded: For assets already discovered that are discarded
+//     during later processing (must transition from PENDING to DISCARDED)
+func TestDiscoverThenDiscardTransition(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelError}))
+	tracker := assettracker.New()
+	recorder := fileevent.NewRecorder(logger)
+	fp := New(tracker, recorder)
+
+	ctx := context.Background()
+
+	// Scenario 1: Duplicate file found during processing
+	// In Google Photos takeout, the same image can appear in multiple zip parts
+	// with different paths. Both are discovered, then one is detected as duplicate.
+	file1 := newTestFile("/photos/album/image.jpg")
+	fp.RecordAssetDiscovered(ctx, file1, 1024, fileevent.DiscoveredImage)
+
+	// Same image in a different location (e.g., year folder) - different full path
+	file1InYear := newTestFile("/photos/2023/image.jpg")
+	fp.RecordAssetDiscovered(ctx, file1InYear, 1024, fileevent.DiscoveredImage)
+
+	// The year folder copy is detected as duplicate during processing
+	// Must use RecordAssetDiscarded (NOT RecordAssetDiscardedImmediately)
+	// because the asset was already discovered and is in PENDING state
+	fp.RecordAssetDiscarded(ctx, file1InYear, 1024, fileevent.DiscardedLocalDuplicate, "duplicate in directory")
+
+	// Scenario 2: File discovered but later filtered (e.g., no JSON metadata)
+	fileNoMeta := newTestFile("/photos/year/orphan.jpg")
+	fp.RecordAssetDiscovered(ctx, fileNoMeta, 2048, fileevent.DiscoveredImage)
+
+	// During puzzle solving, file has no matching JSON and --include-unmatched is false
+	// Must use RecordAssetDiscarded to properly transition from PENDING
+	fp.RecordAssetDiscarded(ctx, fileNoMeta, 2048, fileevent.DiscardedFiltered, "no matching JSON metadata")
+
+	// Process the first (non-duplicate) file normally
+	fp.RecordAssetProcessed(ctx, file1, 1024, fileevent.ProcessedUploadSuccess)
+
+	// Verify final state - NO assets should be pending
+	counters := fp.GetAssetCounters()
+	if counters.Pending != 0 {
+		t.Errorf("Expected 0 pending assets, got %d - assets not properly transitioned", counters.Pending)
+	}
+	if counters.Processed != 1 {
+		t.Errorf("Expected 1 processed asset, got %d", counters.Processed)
+	}
+	if counters.Discarded != 2 {
+		t.Errorf("Expected 2 discarded assets, got %d", counters.Discarded)
+	}
+
+	// Finalize should succeed with no pending assets
+	err := fp.Finalize(ctx)
+	if err != nil {
+		t.Errorf("Finalize should succeed when all assets reach final state, got error: %v", err)
+	}
+}
+
+// TestDiscardedImmediatelyVsDiscarded clarifies the difference between
+// RecordAssetDiscardedImmediately and RecordAssetDiscarded.
+func TestDiscardedImmediatelyVsDiscarded(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelError}))
+	tracker := assettracker.New()
+	recorder := fileevent.NewRecorder(logger)
+	fp := New(tracker, recorder)
+
+	ctx := context.Background()
+
+	// RecordAssetDiscardedImmediately: Asset is rejected at discovery time
+	// (e.g., banned filename pattern, excluded extension)
+	// This creates the asset directly in DISCARDED state
+	bannedFile := newTestFile("/photos/.DS_Store.jpg")
+	fp.RecordAssetDiscardedImmediately(ctx, bannedFile, 100, fileevent.DiscardedBanned, "banned filename")
+
+	// Verify it went directly to discarded, never pending
+	counters := fp.GetAssetCounters()
+	if counters.Pending != 0 {
+		t.Errorf("Immediately discarded asset should not be pending, got %d pending", counters.Pending)
+	}
+	if counters.Discarded != 1 {
+		t.Errorf("Expected 1 discarded, got %d", counters.Discarded)
+	}
+
+	// RecordAssetDiscarded: Asset was discovered, then later discarded during processing
+	// First it must be discovered (goes to PENDING)
+	laterDiscarded := newTestFile("/photos/image.jpg")
+	fp.RecordAssetDiscovered(ctx, laterDiscarded, 512, fileevent.DiscoveredImage)
+
+	counters = fp.GetAssetCounters()
+	if counters.Pending != 1 {
+		t.Errorf("Discovered asset should be pending, got %d", counters.Pending)
+	}
+
+	// Then it's discarded (transitions PENDING -> DISCARDED)
+	fp.RecordAssetDiscarded(ctx, laterDiscarded, 512, fileevent.DiscardedLocalDuplicate, "duplicate")
+
+	counters = fp.GetAssetCounters()
+	if counters.Pending != 0 {
+		t.Errorf("After RecordAssetDiscarded, asset should not be pending, got %d", counters.Pending)
+	}
+	if counters.Discarded != 2 {
+		t.Errorf("Expected 2 discarded (immediate + later), got %d", counters.Discarded)
+	}
+
+	// Verify finalization succeeds
+	if err := fp.Finalize(ctx); err != nil {
+		t.Errorf("Finalize should succeed: %v", err)
+	}
+}
+
 func TestCompleteWorkflow(t *testing.T) {
 	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelError}))
 	tracker := assettracker.New()