try another approach

bundle/manager.go

···
 		afterTime = lastBundle.EndTime.Format(time.RFC3339Nano)
 		prevBundleHash = lastBundle.Hash
 
+		// ALWAYS get boundaries from last bundle initially
 		prevBundle, err := m.LoadBundle(ctx, lastBundle.BundleNumber)
 		if err == nil {
 			_, prevBoundaryCIDs = m.operations.GetBoundaryCIDs(prevBundle.Operations)
 			if !quiet {
-				m.logger.Printf("Previous bundle %06d has %d boundary CIDs at %s",
-					lastBundle.BundleNumber, len(prevBoundaryCIDs), lastBundle.EndTime.Format(time.RFC3339))
+				m.logger.Printf("Loaded %d boundary CIDs from bundle %06d (at %s)",
+					len(prevBoundaryCIDs), lastBundle.BundleNumber,
+					lastBundle.EndTime.Format(time.RFC3339)[:19])
 			}
 		}
 	}
 
-	// Use mempool's last time if available
+	// If mempool has operations, update cursor but KEEP boundaries from bundle
+	// (mempool operations already had boundary dedup applied when they were added)
 	if m.mempool.Count() > 0 {
 		mempoolLastTime := m.mempool.GetLastTime()
 		if mempoolLastTime != "" {
 			if !quiet {
-				m.logger.Printf("Mempool has %d ops, last at %s", m.mempool.Count(), mempoolLastTime)
+				m.logger.Printf("Mempool has %d ops, resuming from %s",
+					m.mempool.Count(), mempoolLastTime[:19])
 			}
 			afterTime = mempoolLastTime
+
+			// Calculate boundaries from MEMPOOL for next fetch
+			mempoolOps, _ := m.GetMempoolOperations()
+			if len(mempoolOps) > 0 {
+				_, mempoolBoundaries := m.operations.GetBoundaryCIDs(mempoolOps)
+				prevBoundaryCIDs = mempoolBoundaries
+				if !quiet {
+					m.logger.Printf("Using %d boundary CIDs from mempool", len(prevBoundaryCIDs))
+				}
+			}
 		}
 	}
 

internal/sync/fetcher.go

···
 
 	seenCIDs := make(map[string]bool)
 
-	// Mark previous boundary CIDs as seen
-	for cid := range prevBoundaryCIDs {
+	// ✅ Initialize current boundaries from previous bundle (or empty if first fetch)
+	currentBoundaryCIDs := prevBoundaryCIDs
+	if currentBoundaryCIDs == nil {
+		currentBoundaryCIDs = make(map[string]bool)
+	}
+
+	// Mark boundary CIDs as seen to prevent re-inclusion
+	for cid := range currentBoundaryCIDs {
 		seenCIDs[cid] = true
 	}
 
-	if !quiet && len(prevBoundaryCIDs) > 0 {
-		f.logger.Printf("  Tracking %d boundary CIDs from previous bundle", len(prevBoundaryCIDs))
+	if !quiet && len(currentBoundaryCIDs) > 0 {
+		f.logger.Printf("  Starting with %d boundary CIDs from previous bundle", len(currentBoundaryCIDs))
 	}
 
 	currentAfter := afterTime
···
 		originalBatchSize := len(batch)
 		totalReceived += originalBatchSize
 
-		// ✨ FIX: Collect new ops first (don't mark as seen yet)
+		// ✅ CRITICAL: Strip boundary duplicates using current boundaries
+		batch = f.operations.StripBoundaryDuplicates(
+			batch,
+			currentAfter,
+			currentBoundaryCIDs,
+		)
+
+		afterStripSize := len(batch)
+		strippedCount := originalBatchSize - afterStripSize
+
+		if !quiet && strippedCount > 0 {
+			f.logger.Printf("  Stripped %d boundary duplicates from fetch", strippedCount)
+		}
+
+		// Collect new ops (not in seenCIDs)
 		beforeDedup := len(allNewOps)
 		var batchNewOps []plcclient.PLCOperation
 
 		for _, op := range batch {
 			if !seenCIDs[op.CID] {
-				// Collect but don't mark as seen yet
 				batchNewOps = append(batchNewOps, op)
 			}
 		}
 
 		uniqueInBatch := len(batchNewOps)
-		dupesFiltered := originalBatchSize - uniqueInBatch
-		totalDupes += dupesFiltered
+		dupesFiltered := afterStripSize - uniqueInBatch
+		totalDupes += dupesFiltered + strippedCount
 
-		// ✨ FIX: Try to add to mempool BEFORE marking as seen
+		// Try to add to mempool
 		if uniqueInBatch > 0 && mempool != nil {
-			added, addErr := mempool.Add(batchNewOps)
+			_, addErr := mempool.Add(batchNewOps)
 
 			if addErr != nil {
-				// ✨ CRITICAL: Add failed - don't mark as seen!
+				// Add failed - don't mark as seen
 				if !quiet {
 					f.logger.Printf("  ❌ Mempool add failed: %v", addErr)
-					f.logger.Printf("  → %d operations NOT marked as seen (will retry on next sync)", uniqueInBatch)
 				}
-
-				// Save what we successfully added so far
 				mempool.Save()
-				return allNewOps, fetchesMade, fmt.Errorf("mempool add failed for %d operations: %w", uniqueInBatch, addErr)
+				return allNewOps, fetchesMade, fmt.Errorf("mempool add failed: %w", addErr)
 			}
 
-			// ✨ SUCCESS: Add succeeded, NOW mark as seen and add to result
-			if added != uniqueInBatch {
-				// Mempool deduplicated some - this is OK, just log
-				if !quiet {
-					f.logger.Printf("  ℹ️  Mempool deduplicated %d operations (already present)", uniqueInBatch-added)
-				}
-			}
-
-			// Mark successfully added ops as seen
+			// Success - mark as seen
 			for _, op := range batchNewOps {
 				seenCIDs[op.CID] = true
 			}
···
 
 			uniqueAdded := len(allNewOps) - beforeDedup
 
-			// Show fetch result with running totals
 			if !quiet {
 				opsPerSec := float64(originalBatchSize) / fetchDuration.Seconds()
-
-				if dupesFiltered > 0 {
-					f.logger.Printf("  → +%d unique (%d dupes) in %s • Running: %d/%d (%.0f ops/sec)",
-						uniqueAdded, dupesFiltered, fetchDuration, len(allNewOps), target, opsPerSec)
+				if dupesFiltered+strippedCount > 0 {
+					f.logger.Printf("  → +%d unique (%d dupes, %d boundary) in %s • Running: %d/%d (%.0f ops/sec)",
+						uniqueAdded, dupesFiltered, strippedCount, fetchDuration, len(allNewOps), target, opsPerSec)
 				} else {
 					f.logger.Printf("  → +%d unique in %s • Running: %d/%d (%.0f ops/sec)",
 						uniqueAdded, fetchDuration, len(allNewOps), target, opsPerSec)
 				}
 			}
 
-			// ✨ Save only if threshold met
+			// ✅ CRITICAL: Calculate NEW boundary CIDs from this fetch for next iteration
+			if len(batch) > 0 {
+				boundaryTime, newBoundaryCIDs := f.operations.GetBoundaryCIDs(batch)
+				currentBoundaryCIDs = newBoundaryCIDs
+				currentAfter = boundaryTime.Format(time.RFC3339Nano)
+
+				if !quiet && len(newBoundaryCIDs) > 1 {
+					f.logger.Printf("  Updated boundaries: %d CIDs at %s",
+						len(newBoundaryCIDs), currentAfter[:19])
+				}
+			}
+
+			// Save if threshold met
 			if err := mempool.SaveIfNeeded(); err != nil {
 				f.logger.Printf("  Warning: failed to save mempool: %v", err)
 			}
 
-			if !quiet && added > 0 {
-				cursor := mempool.GetLastTime()
-				f.logger.Printf("  Added to mempool: %d ops (total: %d, cursor: %s)",
-					added, mempool.Count(), cursor[:19])
-			}
 		} else if uniqueInBatch > 0 {
-			// No mempool provided - just collect
+			// No mempool - just collect
 			for _, op := range batchNewOps {
 				seenCIDs[op.CID] = true
 			}
 			allNewOps = append(allNewOps, batchNewOps...)
-		}
 
-		// Update cursor for next fetch
-		if len(batch) > 0 {
-			currentAfter = batch[len(batch)-1].CreatedAt.Format(time.RFC3339Nano)
+			// ✅ Still update boundaries even without mempool
+			if len(batch) > 0 {
+				boundaryTime, newBoundaryCIDs := f.operations.GetBoundaryCIDs(batch)
+				currentBoundaryCIDs = newBoundaryCIDs
+				currentAfter = boundaryTime.Format(time.RFC3339Nano)
+			}
 		}
 
-		// Check completeness
+		// Check if incomplete batch (caught up)
 		if originalBatchSize < batchSize {
 			if !quiet {
 				f.logger.Printf("  Incomplete batch (%d/%d) → caught up", originalBatchSize, batchSize)