[fix/stuck-sync-loop] Break endless upload loop for removed placeholder items

The sync pipeline could get stuck in an endless loop: the Status view kept
showing repeating "[CORE, Replay] Found removedItems=(…)" entries for
placeholder items (synthetic "_placeholder_" fileID/eTag) that were flagged
`removed` but still carried active upload sync records, while their filenames
accumulated ever more timestamp suffixes. Resolving the recurring Cancel/Retry
issue dialog did not break the loop.

Root cause: when an item that still had a pending/queued upload was removed,
several gaps combined into a permanent deadlock:

- OCSyncActionUpload rescheduled uploads for removed items, hit the
  "already exists" case, raised a keep-both issue and looped.
- OCSyncActionDelete left the item's pending upload records running.
- scrubItemSyncStatus skipped removed items entirely, so a removed item with
  active-but-non-existent sync record IDs was never scrubbed and never
  vacuumed (activeSyncRecordIDs.count > 0) - a state it could never leave.
- Deleting a placeholder issued a doomed server DELETE with a synthetic fileID.

Fixes:

- OCSyncActionUpload.m: scheduleWithContext: bails out early when the item has
  meanwhile been removed (looked up via retrieveCacheItemForLocalID:, which
  only returns non-removed items). It deschedules the record with
  OCErrorCancelled and returns ProcessNext instead of re-uploading. New helper
  _localItemHasBeenRemoved. This is the core loop-breaker.

- OCCore+SyncEngine.m: scrubItemSyncStatus no longer ignores removed items. The
  existing dangling-record check still protects items with live records, so
  removed items whose sync records no longer exist now get their sync activity
  cleared, letting the Vacuum item policy purge them. This drains any
  pre-existing stuck state on next launch - no account reset required.

- OCSyncActionDelete.m: preflightWithContext: cancels all pending upload sync
  records for the item (and contained items) via the new helper
  _cancelPendingUploadsForItem:excludingSyncRecordID:, dropping each cancelled
  record's reference before commit. scheduleWithContext: short-circuits
  placeholder deletions locally instead of issuing a server DELETE that would
  fail.

Verified on a physical device carrying the actual stuck state: resolving the
issue dialog once now cascades through the backlog, the lanes drain and the
leftover items are scrubbed and vacuumed. The loop no longer recurs.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Matthias-Huehne-Kiteworks

ownCloudSDK/Core/Sync/Actions/Delete/OCSyncActionDelete.m

@@ -74,6 +74,11 @@ - (void)preflightWithContext:(OCSyncContext *)syncContext
 		// Item itself
 		[itemToDelete addSyncRecordID:syncContext.syncRecord.recordID activity:OCItemSyncActivityDeleting];
 
+		// Cancel any pending upload (transfer) sync records for the item being deleted. Otherwise a queued
+		// or issue-parked upload keeps looping and - via keep-both issue resolution - recreates placeholders
+		// after the item is already gone, leaving the sync pipeline stuck forever.
+		[self _cancelPendingUploadsForItem:itemToDelete excludingSyncRecordID:syncContext.syncRecord.recordID];
+
 		syncContext.removedItems = @[ itemToDelete ];
 
 		// Contained (associated) items
@@ -87,6 +92,9 @@ - (void)preflightWithContext:(OCSyncContext *)syncContext
 				{
 					[item addSyncRecordID:syncContext.syncRecord.recordID activity:OCItemSyncActivityDeleting];
 
+					// Cancel pending uploads for contained items too
+					[self _cancelPendingUploadsForItem:item excludingSyncRecordID:syncContext.syncRecord.recordID];
+
 					OCLogDebug(@"Preflight: delete contained %@", OCLogPrivate(item.path));
 
 					[removedItems addObject:item];
@@ -108,6 +116,51 @@ - (void)preflightWithContext:(OCSyncContext *)syncContext
 	}
 }
 
+- (void)_cancelPendingUploadsForItem:(OCItem *)item excludingSyncRecordID:(OCSyncRecordID)excludedSyncRecordID
+{
+	// Cancels all pending upload (transfer) sync records referencing the given item. Runs inside the
+	// (already protected) preflight sync block, so the internal _descheduleSyncRecord: is used directly.
+
+	// Enumerate the *current* sync record IDs from the database (self.localItem can be stale and miss
+	// records that were added after it was fetched). Falls back to the item's own list if unavailable.
+	__block NSArray<OCSyncRecordID> *activeSyncRecordIDs = item.activeSyncRecordIDs;
+
+	if (item.localID != nil)
+	{
+		[self.core.vault.database retrieveCacheItemForLocalID:item.localID completionHandler:^(OCDatabase *db, NSError *error, OCSyncAnchor syncAnchor, OCItem *currentItem) {
+			if (currentItem.activeSyncRecordIDs != nil)
+			{
+				activeSyncRecordIDs = currentItem.activeSyncRecordIDs;
+			}
+		}];
+	}
+
+	if ((activeSyncRecordIDs = [activeSyncRecordIDs copy]) == nil) { return; }
+
+	for (OCSyncRecordID syncRecordID in activeSyncRecordIDs)
+	{
+		if ((excludedSyncRecordID != nil) && [syncRecordID isEqual:excludedSyncRecordID]) { continue; }
+
+		__block OCSyncRecord *syncRecord = nil;
+
+		[self.core.vault.database retrieveSyncRecordForID:syncRecordID completionHandler:^(OCDatabase *db, NSError *error, OCSyncRecord *record) {
+			syncRecord = record;
+		}];
+
+		if ([syncRecord.actionIdentifier isEqual:OCSyncActionIdentifierUpload])
+		{
+			OCLogWarning(@"Cancelling pending upload (record %@) because item %@ is being deleted", syncRecord.recordID, OCLogPrivate(item.path));
+
+			// Drop the reference from this item instance *before* the delete's own item update is committed,
+			// so no dangling sync record ID for the just-cancelled upload is persisted. (Fix B scrubs any
+			// that might still slip through, e.g. on other item instances.)
+			[item removeSyncRecordID:syncRecordID activity:OCItemSyncActivityUploading];
+
+			[self.core _descheduleSyncRecord:syncRecord completeWithError:OCError(OCErrorCancelled) parameter:nil];
+		}
+	}
+}
+
 - (void)descheduleWithContext:(OCSyncContext *)syncContext
 {
 	OCItem *itemToRestore;
@@ -161,6 +214,29 @@ - (OCCoreSyncInstruction)scheduleWithContext:(OCSyncContext *)syncContext
 
 	if ((item = self.archivedServerItem) != nil)
 	{
+		// Placeholder items exist only locally (they were never uploaded to the server). There is nothing
+		// to delete remotely - and issuing a server DELETE with a synthetic "_placeholder_" fileID would
+		// just fail (and could get stuck on a delete issue). Complete the deletion locally instead.
+		if (item.isPlaceholder)
+		{
+			OCLogDebug(@"Completing deletion of placeholder item %@ locally (never existed on the server)", OCLogPrivate(self.localItem.path));
+
+			// Notify the caller / result handler that the (local) deletion succeeded (mirrors the server-result path)
+			[syncContext completeWithError:nil core:self.core item:self.localItem parameter:self.localItem];
+
+			[self.localItem removeSyncRecordID:syncContext.syncRecord.recordID activity:OCItemSyncActivityDeleting];
+			syncContext.removedItems = @[ self.localItem ];
+
+			// Remove file(s) locally
+			[self.core deleteDirectoryForItem:self.localItem];
+
+			// Action complete and can be removed (any contained/associated items were already soft-removed
+			// during preflight; their dangling delete record references are cleaned up by sync status scrubbing)
+			[syncContext transitionToState:OCSyncRecordStateCompleted withWaitConditions:nil];
+
+			return (OCCoreSyncInstructionDeleteLast);
+		}
+
 		OCProgress *progress;
 
 		if ((progress = [self.core.connection deleteItem:item requireMatch:self.requireMatch resultTarget:[self.core _eventTargetWithSyncRecord:syncContext.syncRecord]]) != nil)

ownCloudSDK/Core/Sync/Actions/Upload/OCSyncActionUpload.m

@@ -157,6 +157,19 @@ - (OCCoreSyncInstruction)scheduleWithContext:(OCSyncContext *)syncContext
 	OCItem *parentItem, *uploadItem;
 	NSURL *uploadURL;
 
+	// Loop-breaker: if the item to upload has meanwhile been removed (f.ex. deleted locally while the
+	// upload was still queued or parked on an issue), there is nothing left to upload. Re-uploading it
+	// would recreate a placeholder and - via keep-both issue resolution - spin up an endless sync loop.
+	// Cancel the record instead and move on.
+	if ([self _localItemHasBeenRemoved])
+	{
+		OCLogWarning(@"Cancelling upload of removed item (name=%@, localID=%@): item no longer exists in cache", self.localItem.name, self.localItem.localID);
+
+		[self.core _descheduleSyncRecord:syncContext.syncRecord completeWithError:OCError(OCErrorCancelled) parameter:nil];
+
+		return (OCCoreSyncInstructionProcessNext);
+	}
+
 	if (((remoteFileName = self.filename) != nil) &&
 	    ((parentItem = self.parentItem) != nil) &&
 	    ((uploadItem = self.localItem) != nil) &&
@@ -406,6 +419,25 @@ - (OCCoreSyncInstruction)handleResultWithContext:(OCSyncContext *)syncContext
 	return (resultInstruction);
 }
 
+#pragma mark - Removal check
+- (BOOL)_localItemHasBeenRemoved
+{
+	// Determine the current state of the item to upload from the database (rather than the archived,
+	// possibly stale self.localItem). retrieveCacheItemForLocalID: only returns non-removed items, so a
+	// nil result means the item has been removed (or hard-deleted) in the meantime.
+	__block BOOL removed = NO;
+	OCLocalID localItemLocalID;
+
+	if ((localItemLocalID = self.localItem.localID) != nil)
+	{
+		[self.core.vault.database retrieveCacheItemForLocalID:localItemLocalID completionHandler:^(OCDatabase *db, NSError *error, OCSyncAnchor syncAnchor, OCItem *item) {
+			removed = ((item == nil) || item.removed);
+		}];
+	}
+
+	return (removed);
+}
+
 #pragma mark - Issue resolution
 - (OCItem *)_preExistingItem
 {

ownCloudSDK/Core/Sync/OCCore+SyncEngine.m

@@ -2077,21 +2077,22 @@ - (void)scrubItemSyncStatus
 					{
 						for (OCItem *item in items)
 						{
-							// Ignore removed items
-							if (!item.removed)
+							// Check if item has any sync record ID of an actually existing sync record
+							if (![syncRecordIDs intersectsSet:[NSSet setWithArray:item.activeSyncRecordIDs]])
 							{
-								// Check if item has any sync record ID of an actually existing sync record
-								if (![syncRecordIDs intersectsSet:[NSSet setWithArray:item.activeSyncRecordIDs]])
-								{
-									// No valid sync record IDs
-									OCLogWarning(@"Resetting sync information for %@ (live sync records: %@)", item, syncRecordIDs);
-
-									item.activeSyncRecordIDs = nil;
-									item.syncActivityCounts = nil;
-									item.syncActivity = OCItemSyncActivityNone;
-
-									[updateItems addObject:item];
-								}
+								// No valid sync record IDs => the sync records referenced by this item no longer exist.
+								// This also covers removed items that still carry dangling sync record IDs: previously
+								// they were ignored here, so a removed item with active-but-non-existent sync records was
+								// never scrubbed AND never vacuumed (activeSyncRecordIDs.count > 0) - a permanent deadlock
+								// that keeps the sync pipeline busy. Clearing the sync activity here lets the Vacuum item
+								// policy purge such removed items.
+								OCLogWarning(@"Resetting sync information for %@ (removed=%d, live sync records: %@)", item, item.removed, syncRecordIDs);
+
+								item.activeSyncRecordIDs = nil;
+								item.syncActivityCounts = nil;
+								item.syncActivity = OCItemSyncActivityNone;
+
+								[updateItems addObject:item];
 							}
 						}
 					}