fix(github): prevent PR cache sync from exhausting all pages (renovatebot#41462)

* fix(github): prevent PR cache sync from exhausting all pages

* refactor(github): derive cutoff from cached items, simplify reconcile

- When lastModified is missing but items exist (via updateItem()),
  derive cutoff from max(item.updated_at) instead of falling back
  to reconcile's return value. Eliminates the fallback branch.
- reconcile() now called purely for side effects; return value ignored.
- MAX_SYNC_PAGES guard checks needNextPageSync (not needNextPageFetch)
  to avoid spurious warning when cutoff already stopped the loop.
- Add test for mixed pages (Renovate + non-Renovate PRs interleaved).
- Update derived-cutoff test for caches without lastModified.

* fix(github): advance PR cache watermark from unfiltered page

* fix(github): add comment clarifying MAX_SYNC_PAGES is a safety net

Author: zharinov

lib/modules/platform/github/api-cache.spec.ts

@@ -90,7 +90,65 @@ describe('modules/platform/github/api-cache', () => {
     });
   });
 
+  describe('getLastModified', () => {
+    it('returns undefined when no lastModified in cache', () => {
+      const apiCache = new ApiCache({ items: {} });
+
+      expect(apiCache.getLastModified()).toBeUndefined();
+    });
+
+    it('returns stored value when present', () => {
+      const apiCache = new ApiCache({ items: {}, lastModified: t2 });
+
+      expect(apiCache.getLastModified()).toBe(t2);
+    });
+
+    it('returns updated value after reconcile', () => {
+      const apiCache = new ApiCache({ items: {}, lastModified: t1 });
+
+      apiCache.reconcile([{ number: 1, updated_at: t3 }]);
+
+      expect(apiCache.getLastModified()).toBe(t3);
+    });
+  });
+
+  describe('updateLastModified', () => {
+    it('sets lastModified when not present', () => {
+      const apiCache = new ApiCache({ items: {} });
+
+      apiCache.updateLastModified(t2);
+
+      expect(apiCache.getLastModified()).toBe(t2);
+    });
+
+    it('advances lastModified to newer timestamp', () => {
+      const apiCache = new ApiCache({ items: {}, lastModified: t1 });
+
+      apiCache.updateLastModified(t3);
+
+      expect(apiCache.getLastModified()).toBe(t3);
+    });
+
+    it('does not regress lastModified to older timestamp', () => {
+      const apiCache = new ApiCache({ items: {}, lastModified: t3 });
+
+      apiCache.updateLastModified(t1);
+
+      expect(apiCache.getLastModified()).toBe(t3);
+    });
+  });
+
   describe('reconcile', () => {
+    it('returns false for empty page', () => {
+      const apiCache = new ApiCache({
+        items: { 1: { number: 1, updated_at: t1 } },
+        lastModified: t1,
+      });
+
+      expect(apiCache.reconcile([])).toBeFalse();
+      expect(apiCache.getLastModified()).toBe(t1);
+    });
+
     it('appends new items', () => {
       const apiCache = new ApiCache({ items: {} });
 

lib/modules/platform/github/api-cache.ts

@@ -11,8 +11,7 @@ export class ApiCache<T extends ApiPageItem> {
   }
 
   getItems(): T[] {
-    const items = Object.values(this.cache.items);
-    return items;
+    return Object.values(this.cache.items);
   }
 
   getItem(number: number): T | null {
@@ -29,17 +28,31 @@ export class ApiCache<T extends ApiPageItem> {
     this.cache.items[item.number] = item;
   }
 
+  getLastModified(): string | undefined {
+    return this.cache.lastModified;
+  }
+
+  updateLastModified(timestamp: string): void {
+    const current = this.cache.lastModified
+      ? DateTime.fromISO(this.cache.lastModified)
+      : null;
+    const incoming = DateTime.fromISO(timestamp);
+    if (!current || incoming > current) {
+      this.cache.lastModified = timestamp;
+    }
+  }
+
   /**
-   * Copies items from `page` to `cache`.
-   * Updates internal cache timestamp.
+   * Copies items from `page` to cache and updates the internal timestamp.
    *
-   * @param cache Cache object
-   * @param page List of cacheable items, sorted by `updated_at` field
-   * starting from the most recently updated.
-   * @returns `true` when the next page is likely to contain fresh items,
-   * otherwise `false`.
+   * @param page Items sorted by `updated_at` desc (most recent first).
+   * @returns `true` when the next page is likely to contain fresh items.
    */
   reconcile(page: T[]): boolean {
+    if (page.length === 0) {
+      return false;
+    }
+
     const { items } = this.cache;
     let { lastModified } = this.cache;