@@ -378,11 +378,13 @@ function checkForProjectUsage(Document $project): void
     /**
      * Reconcile presences orphaned by a previous instance on this host. A hard crash
      * (SIGKILL/OOM) fires no onClose, so this host's rows linger until expiry. On a clean boot
-     * every presenceLogs row for this hostname created before boot is such an orphan; a connection
-     * that upserts while the sweep runs is created after `$since` and is left alone. Each orphan
-     * goes through the normal offline path, so usage is corrected and subscribers on other workers
-     * get the delete. CE only -- a Cloud host is shared across tenants on sharded databases, where
-     * a hostname sweep does not apply (appwrite/appwrite#14343).
+     * every presenceLogs row for this hostname not written since boot is such an orphan. The sweep
+     * runs asynchronously while new connections are already accepted, so each candidate is deleted
+     * through {@see State::deleteOrphan}, which re-checks under the row lock that nothing reconnected
+     * onto it: a socket that increments the row mid-sweep moves its `$updatedAt` past `$since` and is
+     * left alone. Real orphans go through the normal offline path, so usage is corrected and
+     * subscribers on other workers get the delete. CE only -- a Cloud host is shared across tenants
+     * on sharded databases, where a hostname sweep does not apply (appwrite/appwrite#14343).
      */
     if (System::getEnv('_APP_EDITION', 'self-hosted') === 'self-hosted') {
         go(function () use ($container): void {
@@ -408,7 +410,7 @@ function checkForProjectUsage(Document $project): void
                     while (true) {
                         $orphans = $database->getAuthorization()->skip(fn () => $database->find('presenceLogs', [
                             Query::equal('hostname', [$hostname]),
-                            Query::lessThan('$createdAt', $since),
+                            Query::lessThan('$updatedAt', $since),
                             Query::limit(100),
                         ]));
                         if (empty($orphans)) {
@@ -418,13 +420,16 @@ function checkForProjectUsage(Document $project): void
                         $removed = 0;
                         foreach ($orphans as $orphan) {
                             try {
-                                $database->getAuthorization()->skip(fn () => $database->deleteDocument('presenceLogs', $orphan->getId()));
+                                $deleted = $presences->deleteOrphan($database, $orphan->getId(), $since);
                             } catch (Throwable) {
                                 continue; // leave it for the next pass rather than abort the sweep
                             }
+                            if ($deleted === null) {
+                                continue; // reconnected since boot -- it holds a live connection now
+                            }
                             $removed++;
                             try {
-                                $presences->triggerPresenceDeleted($database, $project, (string) $orphan->getAttribute('userId'), $orphan, $publisherForUsage, getQueueForEvents(), getQueueForRealtime());
+                                $presences->triggerPresenceDeleted($database, $project, (string) $deleted->getAttribute('userId'), $deleted, $publisherForUsage, getQueueForEvents(), getQueueForRealtime());
                             } catch (Throwable) {
                                 // Row is already gone; the offline side effects are best-effort.
                             }
 
@@ -253,6 +253,40 @@ public function releaseConnectionForUser(Database $dbForProject, string $userId,
         });
     }
 
+    /**
+     * Delete a presence row orphaned by a dead instance, but only if it has not gained a live hold
+     * since `$since`. The boot sweep scans by host and runs asynchronously, so a socket can reconnect
+     * and increment the very same row while the sweep is mid-flight -- an in-place upsert that keeps
+     * the row's `$createdAt` but moves its `$updatedAt` past `$since`. Re-reading under the row lock
+     * the increment also takes, and bailing when `$updatedAt` is at or after `$since`, keeps that
+     * reconnected row from being deleted out from under its live connection. Returns the deleted row
+     * so the caller can emit the offline side effects, or null when nothing was deleted (already
+     * gone, or reused since boot).
+     */
+    public function deleteOrphan(Database $dbForProject, string $presenceId, string $since): ?Document
+    {
+        return $dbForProject->withTransaction(function () use ($dbForProject, $presenceId, $since): ?Document {
+            $current = $dbForProject->getAuthorization()->skip(
+                fn () => $dbForProject->getDocument(self::COLLECTION_ID, $presenceId, forUpdate: true)
+            );
+            if ($current->isEmpty()) {
+                return null;
+            }
+
+            // A reconnect incremented this row after boot (the upsert moves $updatedAt but not
+            // $createdAt): it holds a live connection now, so it is no longer an orphan.
+            if ($current->getUpdatedAt() >= $since) {
+                return null;
+            }
+
+            $dbForProject->getAuthorization()->skip(
+                fn () => $dbForProject->deleteDocument(self::COLLECTION_ID, $current->getId())
+            );
+
+            return $current;
+        });
+    }
+
     /**
      * After {@see releaseConnectionForUser} deletes a user's row, trigger the offline side
      * effects: purge the list cache, decrement usage (when counted) and emit the delete event.