fix(connectors): keep the Bitbucket cap flag set when it skips the pull request phase

Review round 3. Fixes a regression from 622a21b.

maxItems is shared across the code and pull request phases, so a code walk that
ends with exactly maxItems documents and no next link or frontier stops
pagination before the pull request phase runs. Scoping listingCapped to "this
phase had more" left the flag unset in that case, and the engine then treated the
run as a complete enumeration and could hard-delete previously indexed pr:*
documents that were never listed.

The cap flag now asks whether anything the connector was configured to list
remains unlisted -- including a later phase the cap is about to stop us reaching.

Author: waleedlatif1

apps/sim/connectors/bitbucket/bitbucket.test.ts

@@ -372,6 +372,22 @@ describe('bitbucket maxItems cap', () => {
     expect(syncContext.listingCapped).toBeUndefined()
   })
 
+  it('flags the listing capped when the code walk ends on the cap and the pull request phase never runs', async () => {
+    mockApi([[/\/src\//, () => jsonResponse({ values: [fileEntry('a.md'), fileEntry('b.md')] })]])
+
+    const syncContext: Record<string, unknown> = {}
+    const result = await bitbucketConnector.listDocuments(
+      ACCESS_TOKEN,
+      { ...CONFIG, contentTypes: 'all', maxItems: '2' },
+      undefined,
+      syncContext
+    )
+
+    expect(result.documents).toHaveLength(2)
+    expect(result.hasMore).toBe(false)
+    expect(syncContext.listingCapped).toBe(true)
+  })
+
   it('flags the listing capped when the cap lands on a page boundary with more to come', async () => {
     mockApi([
       [

apps/sim/connectors/bitbucket/bitbucket.ts

@@ -715,19 +715,24 @@ function pendingDirectories(syncContext: Record<string, unknown> | undefined): s
  * syncContext and flagging `listingCapped` when the cap truncates the listing.
  * Skipped (oversized) documents ride along without consuming the cap.
  *
- * `sourceHasMore` is whether Bitbucket still had content beyond this page — a
- * `next` link, or directories still queued on the frontier. It is required because
- * `takeIndexableWithinCap` reports `capReached` as soon as the running total
- * *equals* maxItems, which is also true of a listing that ended at exactly that
- * count. Setting `listingCapped` there would suppress deletion reconciliation for
- * a listing that was in fact complete, leaving upstream-deleted files indexed
- * indefinitely, so the flag is set only when the cap actually withheld something.
+ * `moreToEnumerate` is whether anything the connector was configured to list
+ * remains unlisted beyond this page: a `next` link, directories still queued on
+ * the frontier, or a later phase that the cap is about to stop us reaching.
+ *
+ * It is required because `takeIndexableWithinCap` reports `capReached` as soon as
+ * the running total *equals* maxItems, which is also true of a listing that ended
+ * at exactly that count. Setting `listingCapped` unconditionally there suppresses
+ * deletion reconciliation for a complete listing; not setting it when a later
+ * phase is skipped is worse still, because the engine would treat the run as a
+ * complete enumeration and hard-delete that phase's previously indexed documents.
+ * `maxItems` is shared across phases, so the code walk ending exactly on the cap
+ * is precisely when the pull-request phase never runs.
  */
 function applyMaxItemsCap(
   documents: ExternalDocument[],
   maxItems: number,
   syncContext: Record<string, unknown> | undefined,
-  sourceHasMore: boolean
+  moreToEnumerate: boolean
 ): { documents: ExternalDocument[]; capped: boolean } {
   if (maxItems <= 0) return { documents, capped: false }
   const alreadyIndexed = (syncContext?.totalDocsFetched as number) ?? 0
@@ -743,7 +748,7 @@ function applyMaxItemsCap(
   )
   if (syncContext) {
     syncContext.totalDocsFetched = alreadyIndexed + indexableCount
-    const withheld = taken.length < documents.length || sourceHasMore
+    const withheld = taken.length < documents.length || moreToEnumerate
     if (capReached && withheld) syncContext.listingCapped = true
   }
   return { documents: taken, capped: capReached }
@@ -933,7 +938,7 @@ export const bitbucketConnector: ConnectorConfig = {
         documents,
         maxItems,
         syncContext,
-        Boolean(page.next) || frontier.length > 0
+        Boolean(page.next) || frontier.length > 0 || Boolean(nextPhase('code', choice))
       )
       if (hitLimit) return { documents: capped, hasMore: false }