promptcase 1.0.7 → 1.0.8

package/dist/services/claude-capture.js

@@ -289,21 +289,20 @@ export class ClaudeCaptureService {
      * Get all prompts from all sources (project transcripts + history),
      * deduplicated by SHA-256 content hash.
      *
-     * Sort order depends on whether this is a backfill or an incremental sync:
+     * Two modes:
      *
-     * - **Backfill** (`since` is undefined): the daemon's first sync, with no
-     *   prior cursor. We sort **OLDEST FIRST** so that the server inserts
-     *   prompts in chronological order. Since the server's `created_at`
-     *   column defaults to insert time and the dashboard sorts `created_at
-     *   DESC`, the *most recent* prompt in the batch ends up at the top of
-     *   the dashboard — matching the user's intuition that "latest shows
-     *   first."
+     * 1. **Initial backfill** (no `since` cursor): fetch the **latest** N
+     *    prompts and sort them **newest first**. The user sees their
+     *    recent work immediately on the dashboard. We deliberately do NOT
+     *    walk backwards through older prompts — that would push the user's
+     *    whole history onto the server on first install, which is
+     *    unnecessary work and can blow past the per-batch payload limit.
+     *    Anything older than the 100 newest stays local; subsequent
+     *    syncs only pick up NEW prompts.
      *
-     * - **Incremental** (`since` is a date): the daemon's subsequent syncs
-     *   pick up only prompts newer than the cursor. We sort **NEWEST FIRST**
-     *   so that when the cursor advances we always send the freshest
-     *   prompts first (and the new cursor lands on the actual latest
-     *   prompt, not a few-batch-behind one).
+     * 2. **Incremental** (`since` is a date): fetch prompts newer than
+     *    the cursor, sorted **newest first** so the cursor advances to
+     *    the actual latest prompt.
      */
     async getAllPrompts(since, limit = 100) {
         const sessions = await this.getSessions();
@@ -342,14 +341,10 @@ export class ClaudeCaptureService {
             seenHashes.add(prompt.hash);
             allPrompts.push(prompt);
         }
-        // Backfill: oldest first (so newest ends up at top of dashboard).
-        // Incremental: newest first (so the cursor advances to actual latest).
-        if (since) {
-            allPrompts.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-        }
-        else {
-            allPrompts.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-        }
+        // Sort: newest first in both modes — ensures the cursor advances
+        // to the actual latest prompt and the server's `created_at` DESC
+        // sort puts the latest prompt at the top of the dashboard.
+        allPrompts.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
         return allPrompts.slice(0, limit);
     }
     /**

package/dist/services/daemon.js

@@ -345,9 +345,18 @@ export class DaemonService {
             return this.status;
         }
         try {
-            // Get prompts from Claude. Use a timestamp cursor to skip prompts older
-            // than the last successful sync (server dedups, but skipping locally
-            // saves bandwidth on subsequent syncs).
+            // Get prompts from Claude. The cursor controls which prompts we fetch:
+            //
+            // - First-ever run (no cursor yet): sync the LATEST 100 prompts so
+            //   the user sees their recent work immediately. We deliberately
+            //   do NOT walk backwards through older prompts — that would push
+            //   the user's whole history onto the server on first install,
+            //   which is unnecessary work and can blow past the per-batch
+            //   payload limit. Anything older than the 100 newest stays local.
+            //
+            // - Subsequent runs (cursor set): fetch prompts newer than the
+            //   cursor. This is normal incremental mode — only the latest
+            //   new prompts get synced.
             const cursorIso = await this.configService.getLastSyncCursor();
             const since = cursorIso ? new Date(cursorIso) : undefined;
             const prompts = await this.captureService.getAllPrompts(since, MAX_PROMPTS_PER_SYNC);
@@ -379,12 +388,16 @@ export class DaemonService {
             const result = await this.apiService.syncPrompts(apiPrompts);
             this.status.lastSyncAt = new Date();
             this.status.promptsSynced += result.synced;
-            // Persist the cursor at the newest prompt we ATTEMPTED to sync (not
-            // just newly-synced ones). The server's content_hash dedup means we'll
-            // see `result.synced: 0` on subsequent runs even though the prompts
-            // are already saved — that's normal. We want the cursor to advance
-            // so the next run only fetches prompts newer than the newest one we've
-            // seen, regardless of whether they were already on the server.
+            // Advance the cursor to the NEWEST prompt in the synced batch. This
+            // is correct in both modes:
+            //
+            // - First backfill: cursor = newest of the 100 batched → next
+            //   cycle only picks up prompts strictly newer than that.
+            // - Incremental: cursor = newest of the new batch.
+            //
+            // The server's content_hash dedup means we never re-insert a
+            // prompt; advancing the cursor just means we don't re-fetch
+            // what we already have.
             if (prompts.length > 0) {
                 const newest = prompts[0].timestamp;
                 await this.configService.setLastSyncCursor(newest.toISOString());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptcase",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "CLI daemon to capture and sync AI prompts to PromptCase web app",
   "main": "dist/index.js",
   "bin": {