From ff84299a431b00a51215a6be3ed66a4a9dee27ca Mon Sep 17 00:00:00 2001
From: KazeKaze93 <kvintas93@gmail.com>
Date: Sun, 12 Jul 2026 09:01:04 +0400
Subject: [PATCH 1/2] fix: advance sync cursor only after complete pagination

Keep partial post commits, but write lastPostId/lastChecked only when
pagination ends naturally. Mark unfinished runs with lastSyncIncomplete
and rethrow axios failures as ProviderSearchError(network).

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 README.md                                     |   2 +-
 docs/api-guide.md                             |   1 +
 docs/architecture.md                          |   4 +-
 docs/database.md                              |   3 +
 docs/glossary.md                              |   4 +-
 docs/roadmap.md                               |   7 +-
 docs/user-guide.md                            |   2 +-
 .../0030_add_artists_last_sync_incomplete.sql |   1 +
 drizzle/meta/_journal.json                    |   7 +
 src/main/db/queries/artists.ts                |   1 +
 src/main/db/schema.ts                         |   4 +
 src/main/services/sync-service.ts             |  95 ++++--
 .../integration/services/SyncService.test.ts  | 289 +++++++++++++++++-
 13 files changed, 376 insertions(+), 44 deletions(-)
 create mode 100644 drizzle/0030_add_artists_last_sync_incomplete.sql

diff --git a/README.md b/README.md
index 88e58b0..4c38752 100644
--- a/README.md
+++ b/README.md
@@ -266,7 +266,7 @@ The application is stable and production-ready (see **`package.json`** → `vers
 - ✅ **Provider Pattern:** Multi-booru support via `IBooruProvider` interface (Rule34, Gelbooru)
 - ✅ **Rate Limiting:** Intelligent rate limiting with 1.5s delay between artists, 0.5s between pages
 - ✅ **Anti-Bot Measures:** Shared throttling/UA strategy applied across current providers.
-- ⚠️ **Open P0:** sync `lastPostId` cursor integrity — see [Roadmap](./docs/roadmap.md#open-p0-audit--remaining). Video-cache writes are atomic (tmp+rename) with size-capped eviction.
+- ✅ **Sync integrity:** `lastPostId` advances only after complete pagination; unfinished runs set `lastSyncIncomplete`. Video-cache writes are atomic (tmp+rename) with size-capped eviction — see [Roadmap](./docs/roadmap.md).
 
 ### UI/UX
 
diff --git a/docs/api-guide.md b/docs/api-guide.md
index 9143da0..227f0b4 100644
--- a/docs/api-guide.md
+++ b/docs/api-guide.md
@@ -471,6 +471,7 @@ type Artist = {
   apiEndpoint: string;
   lastPostId: number;
   newPostsCount: number;
+  lastSyncIncomplete: boolean;
   lastChecked: number | null;
   createdAt: number;
 };
diff --git a/docs/architecture.md b/docs/architecture.md
index 2eb66e1..5055b4c 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1170,9 +1170,7 @@ sequenceDiagram
      });
    ```
 
-   g. **Updates artist** - Updates artist's `lastPostId` and `newPostsCount`.
-
-   ⚠️ **Known integrity gap (open P0):** `lastPostId` may advance mid-pagination or after a partial error commit. An interrupted sync can leave a cursor ahead of fully persisted posts and skip gaps on the next run. Do not document “cursor = fully synced watermark” until the sync-cursor integrity fix lands.
+   g. **Updates artist** - Mid-batch and error paths update `newPostsCount` (and may set `lastSyncIncomplete`) without moving `lastPostId`. After natural pagination end (`postsData.length < PAGE_SIZE`), a single commit writes `lastPostId`, `lastChecked`, and clears `lastSyncIncomplete`.
 
    h. **Progress event** - Emits IPC event: `emit('sync:progress', 'Syncing artist_name...')`
 
diff --git a/docs/database.md b/docs/database.md
index 34d37ce..5b8bd05 100644
--- a/docs/database.md
+++ b/docs/database.md
@@ -80,6 +80,9 @@ export const artists = sqliteTable(
     apiEndpoint: text("api_endpoint").notNull(),
     lastPostId: integer("last_post_id").default(0).notNull(),
     newPostsCount: integer("new_posts_count").default(0).notNull(),
+    lastSyncIncomplete: integer("last_sync_incomplete", { mode: "boolean" })
+      .notNull()
+      .default(false),
     lastChecked: integer("last_checked", { mode: "timestamp" }),
     createdAt: integer("created_at", { mode: "timestamp" })
       .notNull()
diff --git a/docs/glossary.md b/docs/glossary.md
index c8836f3..603a5e1 100644
--- a/docs/glossary.md
+++ b/docs/glossary.md
@@ -154,9 +154,9 @@ Main-process `VideoProxyServer` serves local `http://127.0.0.1` URLs for `<video
 
 ### Sync cursor (`lastPostId`)
 
-Per-artist watermark used for incremental sync. **Open P0:** advancing the cursor on incomplete pagination/error paths can skip posts. Treat as “best effort” until the integrity fix ships.
+Per-artist watermark for incremental sync (`id:>lastPostId`). Advanced **only** after pagination completes naturally (`postsData.length < PAGE_SIZE`). Mid-batch and error partial commits persist posts and `newPostsCount` but never move the cursor. Incomplete runs set `lastSyncIncomplete` so the next sync can refill gaps.
 
-**Related:** [Architecture — Sync](./architecture.md), [Roadmap — Open P0](./roadmap.md#open-p0-audit--not-yet-shipped)
+**Related:** [Architecture — Sync](./architecture.md), [Roadmap](./roadmap.md)
 
 ---
 
diff --git a/docs/roadmap.md b/docs/roadmap.md
index c73a7bd..0e0d58a 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -148,11 +148,10 @@ The short version: the core product is shipped, now we focus on parity gaps and
 
 ### Open P0 (audit — remaining)
 
-| Item | Hazard | Target branch |
-|------|--------|---------------|
-| **Sync cursor integrity** | `lastPostId` may advance on incomplete sync → skipped posts | `fix/sync-cursor-integrity` |
+None — video-cache and sync-cursor integrity shipped.
 
 - ✅ **Video cache integrity** (`fix/video-cache-integrity`): atomic tmp+rename, abort cleanup, `VIDEO_CACHE_MAX_BYTES` eviction via maintenance tick + deferred start sweep.
+- ✅ **Sync cursor integrity** (`fix/sync-cursor-integrity`): `lastPostId` / `lastChecked` only after natural pagination end; partial post commits keep data; `lastSyncIncomplete` marks unfinished runs; axios network failures rethrow as `ProviderSearchError("network")`.
 
 - ⏳ **Tooling / hygiene:** keep `validate` green; remaining shared validation consolidation as needed. Dev-only audit noise (electron-builder transitive deps) is separate from production `npm audit`.
 
@@ -193,7 +192,7 @@ Items explicitly scheduled for product/engineering (beyond small bugs).
 
 | Area | What is still open |
 |------|--------------------|
-| **P0 integrity** | Sync `lastPostId` only after complete durable batches (video-cache atomic writes shipped). |
+| **P0 integrity** | Shipped: video-cache atomic writes + sync cursor only after complete pagination (`lastSyncIncomplete` for unfinished runs). |
 | **Filters** | Keep filter scope lean (`AI`, `Media`, `Source`) and avoid reintroducing removed panel controls without product decision (**scope is already implemented; this is a guardrail**). |
 | **Search** | Continue polish/regression coverage for chip-based syntax (`-tag`, OR groups, wildcard/fuzzy). |
 | **Navigation & layout** | **Optional** polish: tooltips, item order tuning, and small-window density improvements (see [Navigation, layout, shell](#d-navigation-layout-shell)). |
diff --git a/docs/user-guide.md b/docs/user-guide.md
index dbe901e..84dd8e1 100644
--- a/docs/user-guide.md
+++ b/docs/user-guide.md
@@ -575,7 +575,7 @@ Open **Statistics** from the sidebar to see a quick health overview of your loca
 **Solutions:**
 
 1. Use **Repair** on the artist (resync from the beginning)
-2. Known limitation: `lastPostId` can advance on incomplete sync batches (open P0 — see [roadmap](./roadmap.md#open-p0-audit--not-yet-shipped))
+2. Incomplete runs set `lastSyncIncomplete` and leave `lastPostId` unchanged so the next sync can refill gaps. If gaps persist after a successful complete sync, use Repair.
 
 ### App is slow
 
diff --git a/drizzle/0030_add_artists_last_sync_incomplete.sql b/drizzle/0030_add_artists_last_sync_incomplete.sql
new file mode 100644
index 0000000..90492d4
--- /dev/null
+++ b/drizzle/0030_add_artists_last_sync_incomplete.sql
@@ -0,0 +1 @@
+ALTER TABLE artists ADD COLUMN last_sync_incomplete integer DEFAULT 0 NOT NULL;
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index 5fc7987..5b78e68 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -204,6 +204,13 @@
       "when": 1777405165438,
       "tag": "0029_sparkling_boomer",
       "breakpoints": true
+    },
+    {
+      "idx": 30,
+      "version": "6",
+      "when": 1777800000000,
+      "tag": "0030_add_artists_last_sync_incomplete",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/main/db/queries/artists.ts b/src/main/db/queries/artists.ts
index cfd0398..377bdd9 100644
--- a/src/main/db/queries/artists.ts
+++ b/src/main/db/queries/artists.ts
@@ -40,6 +40,7 @@ export function getTrackedArtistsWithStats(db: AppDatabase): TrackedArtistWithSt
       `.as("newPostsCount"),
       syncStatus: artists.syncStatus,
       lastError: artists.lastError,
+      lastSyncIncomplete: artists.lastSyncIncomplete,
       lastChecked: artists.lastChecked,
       createdAt: artists.createdAt,
       postsCount: sql<number>`COALESCE(COUNT(${posts.id}), 0)`.as("postsCount"),
diff --git a/src/main/db/schema.ts b/src/main/db/schema.ts
index af39d19..ebabbf9 100644
--- a/src/main/db/schema.ts
+++ b/src/main/db/schema.ts
@@ -49,6 +49,10 @@ export const artists = sqliteTable(
       .notNull()
       .default("idle"),
     lastError: text("last_error"),
+    /** 1 when pagination did not finish; cursor must not advance until cleared. */
+    lastSyncIncomplete: integer("last_sync_incomplete", { mode: "boolean" })
+      .notNull()
+      .default(false),
     lastChecked: integer("last_checked", { mode: "timestamp" }),
     createdAt: integer("created_at", { mode: "timestamp" })
       .notNull()
diff --git a/src/main/services/sync-service.ts b/src/main/services/sync-service.ts
index 9a0370c..96df99b 100644
--- a/src/main/services/sync-service.ts
+++ b/src/main/services/sync-service.ts
@@ -8,7 +8,10 @@ import {
 } from "../utils/decrypted-credentials";
 import { eq, sql } from "drizzle-orm";
 import axios from "axios";
-import { isProviderSearchError } from "../providers/provider-search-errors";
+import {
+  isProviderSearchError,
+  ProviderSearchError,
+} from "../providers/provider-search-errors";
 import type { Artist, NewPost } from "../db/schema";
 import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
 import * as schema from "../db/schema";
@@ -445,6 +448,7 @@ export class SyncService {
     let hasMore = true;
     let newPostsCount = 0;
     let batchHighestPostId = isInitial ? 0 : currentLastPostId;
+    let paginationCompleted = false;
     
     // Batch posts for transaction - collect multiple pages before committing
     // This reduces transaction overhead (better-sqlite3 blocks DB on write)
@@ -483,6 +487,10 @@ export class SyncService {
             artist.name
           );
 
+          if (postsData.length < PAGE_SIZE) {
+            paginationCompleted = true;
+          }
+
           // Filter posts: initial sync saves all, incremental only saves new ones
           const newPosts = isInitial 
             ? postsData 
@@ -532,7 +540,7 @@ export class SyncService {
 
           if (shouldCommitBatch && allPostsToSave.length > 0) {
             let insertedInBatch = 0;
-            // Single transaction for entire batch
+            // Mid-batch / in-loop commits never advance the sync cursor.
             db.transaction((tx) => {
               const postsCountBefore = countArtistPosts(tx, artist.id);
               bulkUpsertPosts(allPostsToSave, tx);
@@ -541,9 +549,7 @@ export class SyncService {
 
               tx.update(artists)
                 .set({
-                  lastPostId: batchHighestPostId,
                   newPostsCount: sql`${artists.newPostsCount} + ${insertedInBatch}`,
-                  lastChecked: new Date(),
                 })
                 .where(eq(artists.id, artist.id))
                 .run();
@@ -569,48 +575,63 @@ export class SyncService {
           logger.error(`Sync error for ${artist.name}`, e);
           hasMore = false;
 
-          if (allPostsToSave.length > 0) {
-            try {
-              let partialSize = 0;
-              db.transaction((tx) => {
+          try {
+            let partialSize = 0;
+            db.transaction((tx) => {
+              if (allPostsToSave.length > 0) {
                 const postsCountBefore = countArtistPosts(tx, artist.id);
                 bulkUpsertPosts(allPostsToSave, tx);
                 const postsCountAfter = countArtistPosts(tx, artist.id);
                 partialSize = Math.max(0, postsCountAfter - postsCountBefore);
+              }
 
+              if (partialSize > 0) {
                 tx.update(artists)
                   .set({
-                    lastPostId: batchHighestPostId,
                     newPostsCount: sql`${artists.newPostsCount} + ${partialSize}`,
-                    lastChecked: new Date(),
+                    lastSyncIncomplete: true,
                   })
                   .where(eq(artists.id, artist.id))
                   .run();
-              });
+              } else {
+                tx.update(artists)
+                  .set({ lastSyncIncomplete: true })
+                  .where(eq(artists.id, artist.id))
+                  .run();
+              }
+            });
 
+            if (partialSize > 0) {
               newPostsCount += partialSize;
               logger.warn(
                 `SyncService: Partial commit of ${partialSize} posts after error for ${artist.name}`
               );
-            } catch (commitErr) {
-              logger.error(
-                `SyncService: Partial commit failed for ${artist.name}`,
-                commitErr
-              );
             }
+            allPostsToSave.length = 0;
+          } catch (commitErr) {
+            logger.error(
+              `SyncService: Partial commit failed for ${artist.name}`,
+              commitErr
+            );
           }
 
           if (isProviderSearchError(e)) {
-            if (e.kind === "auth" || e.kind === "rate_limit") {
+            if (
+              e.kind === "auth" ||
+              e.kind === "rate_limit" ||
+              e.kind === "network"
+            ) {
               throw e;
             }
-          } else if (!axios.isAxiosError(e)) {
+          } else if (axios.isAxiosError(e)) {
+            throw new ProviderSearchError("network");
+          } else {
             throw e;
           }
         }
       }
       
-      // Commit any remaining posts in batch
+      // Commit any remaining posts in batch (cursor still deferred)
       if (allPostsToSave.length > 0) {
         let insertedInFinalBatch = 0;
         db.transaction((tx) => {
@@ -620,26 +641,43 @@ export class SyncService {
           insertedInFinalBatch = Math.max(0, postsCountAfter - postsCountBefore);
 
           tx.update(artists)
-            .set({
-              lastPostId: batchHighestPostId,
-              newPostsCount: sql`${artists.newPostsCount} + ${insertedInFinalBatch}`,
-              lastChecked: new Date(),
-            })
+            .set(
+              paginationCompleted
+                ? {
+                    newPostsCount: sql`${artists.newPostsCount} + ${insertedInFinalBatch}`,
+                  }
+                : {
+                    newPostsCount: sql`${artists.newPostsCount} + ${insertedInFinalBatch}`,
+                    lastSyncIncomplete: true,
+                  }
+            )
             .where(eq(artists.id, artist.id))
             .run();
         });
 
         newPostsCount += insertedInFinalBatch;
+        allPostsToSave.length = 0;
         logger.debug(
           `SyncService: ${artist.name} - Committed final batch of ${insertedInFinalBatch} new posts`
         );
       }
 
-      // Final update of lastChecked even if no new posts were found
-      if (newPostsCount === 0) {
+      // Sole cursor write path: only after natural pagination end.
+      if (paginationCompleted) {
+        db.transaction((tx) => {
+          tx.update(artists)
+            .set({
+              lastPostId: batchHighestPostId,
+              lastChecked: new Date(),
+              lastSyncIncomplete: false,
+            })
+            .where(eq(artists.id, artist.id))
+            .run();
+        });
+      } else {
         db.transaction((tx) => {
           tx.update(artists)
-            .set({ lastChecked: new Date() })
+            .set({ lastSyncIncomplete: true })
             .where(eq(artists.id, artist.id))
             .run();
         });
@@ -648,7 +686,8 @@ export class SyncService {
       const previousLastPostId = isInitial ? artist.lastPostId : currentLastPostId;
       logger.info(
         `${syncType} sync finished for ${artist.name}. Added: ${newPostsCount} posts. ` +
-        `Final lastPostId: ${batchHighestPostId} (was: ${previousLastPostId})`
+        `Final lastPostId: ${paginationCompleted ? batchHighestPostId : previousLastPostId} ` +
+        `(was: ${previousLastPostId}, paginationCompleted: ${paginationCompleted})`
       );
     } finally {
       if (isInitial) {
diff --git a/tests/integration/services/SyncService.test.ts b/tests/integration/services/SyncService.test.ts
index 32f22a2..8bc29af 100644
--- a/tests/integration/services/SyncService.test.ts
+++ b/tests/integration/services/SyncService.test.ts
@@ -382,8 +382,8 @@ describe('SyncService Integration', () => {
       ? safeStorage.decryptString(Buffer.from(settingsRecord.encryptedApiKey, 'base64'))
       : settingsRecord.encryptedApiKey || '';
 
-    // Act - Sync should handle error gracefully
-    // SyncService has retry logic, so it might not throw immediately
+    // Act - HTTP 500 becomes a provider parse/network failure after retries.
+    // Cursor must stay put; incomplete flag must be visible (no silent "success" watermark).
     await service.syncArtist(artist, {
       userId: settingsRecord.userId || '',
       apiKey,
@@ -396,6 +396,12 @@ describe('SyncService Integration', () => {
       .where(eq(posts.artistId, artist.id));
     
     expect(savedPosts).toHaveLength(0);
+
+    const updatedArtist = await mockDb.db.query.artists.findFirst({
+      where: eq(artists.id, artist.id),
+    });
+    expect(updatedArtist?.lastPostId).toBe(0);
+    expect(updatedArtist?.lastSyncIncomplete).toBe(true);
   });
 
   it('should preserve accumulated posts when a later page fails', async () => {
@@ -448,7 +454,7 @@ describe('SyncService Integration', () => {
           return createPage(101);
         }
         if (page === 2) {
-          throw new Error('Provider page 3 failure');
+          throw new ProviderSearchError('network', 'Provider page 3 failure');
         }
         return [];
       }
@@ -460,7 +466,13 @@ describe('SyncService Integration', () => {
           userId: settingsRecord.userId || '',
           apiKey,
         })
-      ).rejects.toThrow('Provider page 3 failure');
+      ).rejects.toSatisfy((error: unknown) => {
+        return (
+          error instanceof ProviderSearchError &&
+          error.kind === 'network' &&
+          error.message === 'Provider page 3 failure'
+        );
+      });
 
       const savedPosts = await mockDb.db
         .select()
@@ -473,7 +485,274 @@ describe('SyncService Integration', () => {
         where: eq(artists.id, artist.id),
       });
 
-      expect(updatedArtist?.lastPostId).toBe(200);
+      // Cursor must not advance on incomplete pagination — resume can refill gaps
+      expect(updatedArtist?.lastPostId).toBe(0);
+      expect(updatedArtist?.lastSyncIncomplete).toBe(true);
+      expect(updatedArtist?.lastChecked).toBeNull();
+    } finally {
+      fetchPostsSpy.mockRestore();
+    }
+  });
+
+  it('should not advance cursor after mid-batch commit when a later page fails', async () => {
+    const artist = await mockDb.db.query.artists.findFirst({
+      where: eq(artists.tag, 'artist_name'),
+    });
+
+    if (!artist) {
+      throw new Error('Artist setup failed');
+    }
+
+    const settingsRecord = await mockDb.db.query.settings.findFirst({
+      where: eq(settings.id, SETTINGS_ID),
+    });
+
+    if (!settingsRecord) {
+      throw new Error('Settings setup failed');
+    }
+
+    const { safeStorage } = await import('electron');
+    const apiKey = safeStorage.isEncryptionAvailable() && settingsRecord.encryptedApiKey
+      ? safeStorage.decryptString(Buffer.from(settingsRecord.encryptedApiKey, 'base64'))
+      : settingsRecord.encryptedApiKey || '';
+
+    const createPage = (startId: number): BooruPost[] =>
+      Array.from({ length: 100 }, (_, index) => {
+        const id = startId + index;
+        return {
+          id,
+          fileUrl: `https://cdn.example.com/${id}.jpg`,
+          previewUrl: `https://cdn.example.com/${id}-preview.jpg`,
+          sampleUrl: `https://cdn.example.com/${id}-sample.jpg`,
+          tags: ['artist_name', `tag_${id}`],
+          rating: 's',
+          score: 0,
+          source: '',
+          width: 1000,
+          height: 1000,
+          createdAt: new Date('2025-01-01T00:00:00.000Z'),
+        };
+      });
+
+    const provider = getProvider('rule34');
+    // 5 full pages → mid-batch commit at 500 posts; page 5 throws
+    const fetchPostsSpy = vi.spyOn(provider, 'fetchPosts').mockImplementation(
+      async (_tags, page) => {
+        if (page >= 0 && page <= 4) {
+          return createPage(page * 100 + 1);
+        }
+        if (page === 5) {
+          throw new ProviderSearchError('network', 'Provider failure after mid-batch');
+        }
+        return [];
+      }
+    );
+
+    try {
+      await expect(
+        service.syncArtist(artist, {
+          userId: settingsRecord.userId || '',
+          apiKey,
+        })
+      ).rejects.toSatisfy((error: unknown) => {
+        return (
+          error instanceof ProviderSearchError &&
+          error.message === 'Provider failure after mid-batch'
+        );
+      });
+
+      const savedPosts = await mockDb.db
+        .select()
+        .from(posts)
+        .where(eq(posts.artistId, artist.id));
+
+      expect(savedPosts).toHaveLength(500);
+
+      const updatedArtist = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+
+      expect(updatedArtist?.lastPostId).toBe(0);
+      expect(updatedArtist?.lastSyncIncomplete).toBe(true);
+      expect(updatedArtist?.newPostsCount).toBe(500);
+    } finally {
+      fetchPostsSpy.mockRestore();
+    }
+  });
+
+  it('should resume and complete pagination after a mid-run failure without skipping pages', async () => {
+    const artist = await mockDb.db.query.artists.findFirst({
+      where: eq(artists.tag, 'artist_name'),
+    });
+
+    if (!artist) {
+      throw new Error('Artist setup failed');
+    }
+
+    // Incremental path (avoids initial-sync FTS rebuild edge cases under abort+retry)
+    await mockDb.db
+      .update(artists)
+      .set({ lastPostId: 50 })
+      .where(eq(artists.id, artist.id));
+
+    const settingsRecord = await mockDb.db.query.settings.findFirst({
+      where: eq(settings.id, SETTINGS_ID),
+    });
+
+    if (!settingsRecord) {
+      throw new Error('Settings setup failed');
+    }
+
+    const { safeStorage } = await import('electron');
+    const apiKey = safeStorage.isEncryptionAvailable() && settingsRecord.encryptedApiKey
+      ? safeStorage.decryptString(Buffer.from(settingsRecord.encryptedApiKey, 'base64'))
+      : settingsRecord.encryptedApiKey || '';
+
+    const createPage = (startId: number, count = 100): BooruPost[] =>
+      Array.from({ length: count }, (_, index) => {
+        const id = startId + index;
+        return {
+          id,
+          fileUrl: `https://cdn.example.com/${id}.jpg`,
+          previewUrl: `https://cdn.example.com/${id}-preview.jpg`,
+          sampleUrl: `https://cdn.example.com/${id}-sample.jpg`,
+          tags: ['artist_name', `tag_${id}`],
+          rating: 's',
+          score: 0,
+          source: '',
+          width: 1000,
+          height: 1000,
+          createdAt: new Date('2025-01-01T00:00:00.000Z'),
+        };
+      });
+
+    const provider = getProvider('rule34');
+    let failOnce = true;
+    const fetchPostsSpy = vi.spyOn(provider, 'fetchPosts').mockImplementation(
+      async (_tags, page) => {
+        if (page === 0) {
+          return createPage(51);
+        }
+        if (page === 1 && failOnce) {
+          failOnce = false;
+          throw new ProviderSearchError('network', 'Transient page 2 failure');
+        }
+        if (page === 1) {
+          return createPage(151);
+        }
+        if (page === 2) {
+          return createPage(251, 50);
+        }
+        return [];
+      }
+    );
+
+    try {
+      const artistBefore = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+      if (!artistBefore) {
+        throw new Error('Artist missing before sync');
+      }
+
+      await expect(
+        service.syncArtist(artistBefore, {
+          userId: settingsRecord.userId || '',
+          apiKey,
+        })
+      ).rejects.toSatisfy((error: unknown) => {
+        return (
+          error instanceof ProviderSearchError &&
+          error.message === 'Transient page 2 failure'
+        );
+      });
+
+      let updatedArtist = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+      expect(updatedArtist?.lastPostId).toBe(50);
+      expect(updatedArtist?.lastSyncIncomplete).toBe(true);
+
+      const afterFailure = await mockDb.db
+        .select()
+        .from(posts)
+        .where(eq(posts.artistId, artist.id));
+      expect(afterFailure).toHaveLength(100);
+
+      updatedArtist = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+      if (!updatedArtist) {
+        throw new Error('Artist missing after failure');
+      }
+
+      await service.syncArtist(updatedArtist, {
+        userId: settingsRecord.userId || '',
+        apiKey,
+      });
+
+      const afterResume = await mockDb.db
+        .select()
+        .from(posts)
+        .where(eq(posts.artistId, artist.id));
+      expect(afterResume).toHaveLength(250);
+
+      const finalArtist = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+      expect(finalArtist?.lastPostId).toBe(300);
+      expect(finalArtist?.lastSyncIncomplete).toBe(false);
+      expect(finalArtist?.lastChecked).not.toBeNull();
+    } finally {
+      fetchPostsSpy.mockRestore();
+    }
+  });
+
+  it('should rethrow axios network errors instead of silent success', async () => {
+    const artist = await mockDb.db.query.artists.findFirst({
+      where: eq(artists.tag, 'artist_name'),
+    });
+
+    if (!artist) {
+      throw new Error('Artist setup failed');
+    }
+
+    const settingsRecord = await mockDb.db.query.settings.findFirst({
+      where: eq(settings.id, SETTINGS_ID),
+    });
+
+    if (!settingsRecord) {
+      throw new Error('Settings setup failed');
+    }
+
+    const { safeStorage } = await import('electron');
+    const apiKey = safeStorage.isEncryptionAvailable() && settingsRecord.encryptedApiKey
+      ? safeStorage.decryptString(Buffer.from(settingsRecord.encryptedApiKey, 'base64'))
+      : settingsRecord.encryptedApiKey || '';
+
+    const axios = await import('axios');
+    const provider = getProvider('rule34');
+    const fetchPostsSpy = vi.spyOn(provider, 'fetchPosts').mockImplementation(async () => {
+      throw new axios.AxiosError('Network down', 'ERR_NETWORK');
+    });
+
+    try {
+      await expect(
+        service.syncArtist(artist, {
+          userId: settingsRecord.userId || '',
+          apiKey,
+        })
+      ).rejects.toSatisfy((error: unknown) => {
+        return (
+          error instanceof ProviderSearchError && error.kind === 'network'
+        );
+      });
+
+      const updatedArtist = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+      expect(updatedArtist?.lastPostId).toBe(0);
+      expect(updatedArtist?.lastSyncIncomplete).toBe(true);
     } finally {
       fetchPostsSpy.mockRestore();
     }

From b4958bc402ab37521a637c49cb8999598c574493 Mon Sep 17 00:00:00 2001
From: KazeKaze93 <kvintas93@gmail.com>
Date: Sun, 12 Jul 2026 09:47:18 +0400
Subject: [PATCH 2/2] fix: set paginationCompleted only after successful
 iteration end

Move the completion flag off the post-fetch top-of-loop so a failure
while processing the short last page cannot advance the cursor. Treat
an empty newPosts page as completed incremental sync so idle artists
are not marked lastSyncIncomplete.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 src/main/services/sync-service.ts             |   8 +-
 .../integration/services/SyncService.test.ts  | 173 ++++++++++++++++++
 2 files changed, 176 insertions(+), 5 deletions(-)

diff --git a/src/main/services/sync-service.ts b/src/main/services/sync-service.ts
index 96df99b..39d21c0 100644
--- a/src/main/services/sync-service.ts
+++ b/src/main/services/sync-service.ts
@@ -487,17 +487,14 @@ export class SyncService {
             artist.name
           );
 
-          if (postsData.length < PAGE_SIZE) {
-            paginationCompleted = true;
-          }
-
           // Filter posts: initial sync saves all, incremental only saves new ones
           const newPosts = isInitial 
             ? postsData 
             : postsData.filter((p) => p.id > currentLastPostId);
 
-          // Stop if no new posts found
+          // Stop if no new posts found — known territory reached (incremental complete)
           if (newPosts.length === 0) {
+            paginationCompleted = true;
             hasMore = false;
             break;
           }
@@ -565,6 +562,7 @@ export class SyncService {
 
           // Continue pagination if we got a full page (PAGE_SIZE posts)
           if (postsData.length < PAGE_SIZE) {
+            paginationCompleted = true;
             hasMore = false;
             logger.debug(`SyncService: ${artist.name} - Page ${page} returned ${postsData.length} posts (< ${PAGE_SIZE}), stopping pagination`);
           } else {
diff --git a/tests/integration/services/SyncService.test.ts b/tests/integration/services/SyncService.test.ts
index 8bc29af..117250c 100644
--- a/tests/integration/services/SyncService.test.ts
+++ b/tests/integration/services/SyncService.test.ts
@@ -708,6 +708,179 @@ describe('SyncService Integration', () => {
     }
   });
 
+  it('should treat a full page of already-known posts as completed incremental sync', async () => {
+    const artist = await mockDb.db.query.artists.findFirst({
+      where: eq(artists.tag, 'artist_name'),
+    });
+
+    if (!artist) {
+      throw new Error('Artist setup failed');
+    }
+
+    await mockDb.db
+      .update(artists)
+      .set({ lastPostId: 500, lastSyncIncomplete: false, lastChecked: null })
+      .where(eq(artists.id, artist.id));
+
+    const settingsRecord = await mockDb.db.query.settings.findFirst({
+      where: eq(settings.id, SETTINGS_ID),
+    });
+
+    if (!settingsRecord) {
+      throw new Error('Settings setup failed');
+    }
+
+    const { safeStorage } = await import('electron');
+    const apiKey = safeStorage.isEncryptionAvailable() && settingsRecord.encryptedApiKey
+      ? safeStorage.decryptString(Buffer.from(settingsRecord.encryptedApiKey, 'base64'))
+      : settingsRecord.encryptedApiKey || '';
+
+    const createPage = (startId: number): BooruPost[] =>
+      Array.from({ length: 100 }, (_, index) => {
+        const id = startId + index;
+        return {
+          id,
+          fileUrl: `https://cdn.example.com/${id}.jpg`,
+          previewUrl: `https://cdn.example.com/${id}-preview.jpg`,
+          sampleUrl: `https://cdn.example.com/${id}-sample.jpg`,
+          tags: ['artist_name', `tag_${id}`],
+          rating: 's',
+          score: 0,
+          source: '',
+          width: 1000,
+          height: 1000,
+          createdAt: new Date('2025-01-01T00:00:00.000Z'),
+        };
+      });
+
+    const provider = getProvider('rule34');
+    // Full PAGE_SIZE of posts all ≤ lastPostId → newPosts empty, still completed
+    const fetchPostsSpy = vi.spyOn(provider, 'fetchPosts').mockResolvedValue(
+      createPage(401)
+    );
+
+    try {
+      const artistBefore = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+      if (!artistBefore) {
+        throw new Error('Artist missing');
+      }
+
+      await service.syncArtist(artistBefore, {
+        userId: settingsRecord.userId || '',
+        apiKey,
+      });
+
+      const updatedArtist = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+
+      expect(updatedArtist?.lastPostId).toBe(500);
+      expect(updatedArtist?.lastSyncIncomplete).toBe(false);
+      expect(updatedArtist?.lastChecked).not.toBeNull();
+    } finally {
+      fetchPostsSpy.mockRestore();
+    }
+  });
+
+  it('should not mark pagination complete if the short last page fails after fetch', async () => {
+    const artist = await mockDb.db.query.artists.findFirst({
+      where: eq(artists.tag, 'artist_name'),
+    });
+
+    if (!artist) {
+      throw new Error('Artist setup failed');
+    }
+
+    await mockDb.db
+      .update(artists)
+      .set({ lastPostId: 50 })
+      .where(eq(artists.id, artist.id));
+
+    const settingsRecord = await mockDb.db.query.settings.findFirst({
+      where: eq(settings.id, SETTINGS_ID),
+    });
+
+    if (!settingsRecord) {
+      throw new Error('Settings setup failed');
+    }
+
+    const { safeStorage } = await import('electron');
+    const apiKey = safeStorage.isEncryptionAvailable() && settingsRecord.encryptedApiKey
+      ? safeStorage.decryptString(Buffer.from(settingsRecord.encryptedApiKey, 'base64'))
+      : settingsRecord.encryptedApiKey || '';
+
+    const createPost = (id: number): BooruPost => ({
+      id,
+      fileUrl: `https://cdn.example.com/${id}.jpg`,
+      previewUrl: `https://cdn.example.com/${id}-preview.jpg`,
+      sampleUrl: `https://cdn.example.com/${id}-sample.jpg`,
+      tags: ['artist_name', `tag_${id}`],
+      rating: 's',
+      score: 0,
+      source: '',
+      width: 1000,
+      height: 1000,
+      createdAt: new Date('2025-01-01T00:00:00.000Z'),
+    });
+
+    const provider = getProvider('rule34');
+    const fetchPostsSpy = vi.spyOn(provider, 'fetchPosts').mockImplementation(
+      async (_tags, page) => {
+        if (page === 0) {
+          return Array.from({ length: 100 }, (_, index) =>
+            createPost(51 + index)
+          );
+        }
+        if (page === 1) {
+          // Short last page: fetch succeeded; processing throws before completion flag
+          const boomPost = createPost(151);
+          Object.defineProperty(boomPost, 'fileUrl', {
+            configurable: true,
+            get(): string {
+              throw new Error('Processing failure on short last page');
+            },
+          });
+          return [boomPost, createPost(152)];
+        }
+        return [];
+      }
+    );
+
+    try {
+      const artistBefore = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+      if (!artistBefore) {
+        throw new Error('Artist missing');
+      }
+
+      await expect(
+        service.syncArtist(artistBefore, {
+          userId: settingsRecord.userId || '',
+          apiKey,
+        })
+      ).rejects.toThrow('Processing failure on short last page');
+
+      const updatedArtist = await mockDb.db.query.artists.findFirst({
+        where: eq(artists.id, artist.id),
+      });
+
+      expect(updatedArtist?.lastPostId).toBe(50);
+      expect(updatedArtist?.lastSyncIncomplete).toBe(true);
+
+      const savedPosts = await mockDb.db
+        .select()
+        .from(posts)
+        .where(eq(posts.artistId, artist.id));
+      // Page 0 buffered then partial-committed; last short page never entered the batch
+      expect(savedPosts).toHaveLength(100);
+    } finally {
+      fetchPostsSpy.mockRestore();
+    }
+  });
+
   it('should rethrow axios network errors instead of silent success', async () => {
     const artist = await mockDb.db.query.artists.findFirst({
       where: eq(artists.tag, 'artist_name'),