fix(connectors): rehydrate forces a full listing so containers aren't omitted

A rehydrate request set forceRehydrate but left listing incremental. For a
connector that is both incremental and rehydrateOnFullSync, an unchanged
container page that transcludes a changed page would be omitted from the
incremental listing and never re-hydrated. Force a full (non-incremental) listing
on rehydrate so every document is seen; deletion-safety guards stay armed (unlike
fullSync). No-op for Confluence, which is already non-incremental.

Author: waleedlatif1

apps/sim/lib/api/contracts/knowledge/connectors.ts

@@ -154,10 +154,10 @@ export const deleteKnowledgeConnectorContract = defineRouteContract({
 export const triggerKnowledgeConnectorSyncQuerySchema = z.object({
   /**
    * Force re-hydration: for connectors whose rendered content can drift without a
-   * hash change (e.g. Confluence transclusions), re-fetch and re-index every
-   * already-synced document rather than only hash-changed ones. Listing and
-   * deletion reconciliation are unchanged from a normal sync. Defaults to the
-   * normal hash-gated sync.
+   * hash change (e.g. Confluence transclusions), do a full listing and re-fetch +
+   * re-index every already-synced document rather than only hash-changed ones. The
+   * deletion-reconciliation safety guards stay armed. Defaults to the normal
+   * hash-gated sync.
    */
   rehydrate: booleanQueryFlagSchema.optional().default(false),
 })

apps/sim/lib/knowledge/connectors/queue.test.ts

@@ -98,6 +98,7 @@ describe('connector sync queue', () => {
       {
         connectorId: 'connector-1',
         fullSync: true,
+        rehydrate: undefined,
         requestId: 'request-1',
         billingAttribution: BILLING_ATTRIBUTION,
       },
@@ -113,6 +114,20 @@ describe('connector sync queue', () => {
     )
   })
 
+  it('carries the rehydrate flag into the queued payload', async () => {
+    await dispatchSync('connector-1', {
+      billingAttribution: BILLING_ATTRIBUTION,
+      rehydrate: true,
+      requestId: 'request-1',
+    })
+
+    expect(mockTrigger).toHaveBeenCalledWith(
+      'knowledge-connector-sync',
+      expect.objectContaining({ connectorId: 'connector-1', rehydrate: true }),
+      expect.anything()
+    )
+  })
+
   it('rejects legacy payloads without billing attribution', () => {
     expect(() =>
       assertConnectorSyncPayload({

apps/sim/lib/knowledge/connectors/queue.ts

@@ -22,8 +22,9 @@ export interface ConnectorSyncPayload {
   /**
    * Force re-hydration + re-indexing of already-synced documents for connectors
    * whose rendered content can drift without a hash change (see
-   * `ConnectorMeta.rehydrateOnFullSync`). Unlike `fullSync`, this does NOT alter
-   * listing or bypass any deletion-reconciliation safety guard.
+   * `ConnectorMeta.rehydrateOnFullSync`). Forces a full (non-incremental) listing
+   * so every document is re-hydrated, but — unlike `fullSync` — keeps every
+   * deletion-reconciliation safety guard armed.
    */
   rehydrate?: boolean
   requestId: string

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

@@ -432,11 +432,17 @@ export async function executeSync(
     let hasMore = true
     const syncContext: Record<string, unknown> = { syncRunId: generateId() }
 
-    // Determine if this sync should be incremental
+    /**
+     * Determine if this sync should be incremental. A `rehydrate` request forces a
+     * full listing too: re-hydration must see *every* document (a container page can
+     * be unchanged itself yet transclude a page that changed), and an incremental
+     * listing would omit those unchanged containers, so they'd never be re-fetched.
+     */
     const isIncremental =
       connectorConfig.supportsIncrementalSync &&
       connector.syncMode !== 'full' &&
       !options?.fullSync &&
+      !options?.rehydrate &&
       connector.lastSyncAt != null
     const lastSyncAt =
       isIncremental && connector.lastSyncAt ? new Date(connector.lastSyncAt) : undefined
@@ -445,9 +451,10 @@ export async function executeSync(
      * Re-hydrate and re-index connectors whose rendered content can drift without a
      * hash change (transclusions) — see `ConnectorMeta.rehydrateOnFullSync`. Driven
      * by the dedicated `rehydrate` request (the "Full resync" action) or implied by a
-     * true `fullSync`. This ONLY affects hydration/indexing — it does not change
-     * listing or bypass any deletion-reconciliation guard. Incremental syncs of other
-     * connectors stay hash-gated.
+     * true `fullSync`. It forces a full listing (above) and re-indexes unchanged
+     * deferred docs, but — unlike `fullSync` — it does NOT bypass any
+     * deletion-reconciliation safety guard. Incremental syncs of other connectors
+     * stay hash-gated.
      */
     const forceRehydrate = Boolean(
       (options?.rehydrate || options?.fullSync) && connectorConfig.rehydrateOnFullSync