fix(knowledge): exclude fulfilled-but-unverified hydration outcomes from resurrection too

Both bots independently found a third instance of the same bug class:
when deferred hydration for an update fulfills but has no usable
content (skipped as oversized, or an empty re-fetch), the code falls
back to keeping the stored content as last-known-good and counts it
unchanged — correct for an already-visible document, but for a
tombstoned one it means content was never actually verified as
current. That fallback wasn't added to failedExternalIds, so
reconciliation still resurrected it with stale pre-tombstone content
despite hydration never actually confirming anything.

Fixed by adding both fallback branches to failedExternalIds, same as
the rejected-promise cases. Verified across every connector's
skippedReason call site that this only ever happens inside
getDocument (the deferred hydration path already covered here) —
no connector sets skippedReason directly in listDocuments, so there's
no equivalent listing-time gap to fix.

Author: waleedlatif1

apps/sim/lib/knowledge/connectors/sync-engine.ts

@@ -619,11 +619,15 @@ export async function executeSync(
 
     const seenExternalIds = new Set<string>()
     /**
-     * externalIds whose content update was attempted but failed (hydration
-     * error, or the write itself rejected) — as opposed to `docsFailed` counts
-     * elsewhere, this specifically excludes them from resurrection below: a
-     * tombstoned document whose refresh failed must stay tombstoned rather
-     * than come back visible while still serving stale pre-tombstone content.
+     * externalIds whose content was never verified as current: a hydration
+     * error, a rejected write, or a fulfilled-but-unusable hydration (skipped
+     * as oversized, or an empty re-fetch) that falls back to keeping the
+     * stored content as last-known-good. That fallback is fine for an
+     * already-visible document, but for a tombstoned one it means we still
+     * don't have confirmed-current content — so this excludes them from
+     * resurrection below: a tombstoned document whose refresh didn't actually
+     * land must stay tombstoned rather than come back visible while still
+     * serving stale pre-tombstone content.
      */
     const failedExternalIds = new Set<string>()
 
@@ -710,15 +714,21 @@ export async function executeSync(
                 })
               } else if (op.type === 'update') {
                 // Already-indexed file is kept as last-known-good (not downgraded), so it
-                // counts as unchanged rather than slipping past every result counter.
+                // counts as unchanged rather than slipping past every result counter. Not a
+                // verified refresh, though — see failedExternalIds below.
                 result.docsUnchanged++
+                failedExternalIds.add(op.extDoc.externalId)
               }
               return null
             }
             if (!fullDoc?.content.trim()) {
               // An empty re-fetch leaves an already-indexed update as last-known-good; count
-              // it as unchanged so the totals still reconcile with documents seen.
-              if (op.type === 'update') result.docsUnchanged++
+              // it as unchanged so the totals still reconcile with documents seen. Not a
+              // verified refresh, though — see failedExternalIds below.
+              if (op.type === 'update') {
+                result.docsUnchanged++
+                failedExternalIds.add(op.extDoc.externalId)
+              }
               return null
             }
             const hydratedHash = fullDoc.contentHash ?? op.extDoc.contentHash