User experience enhancements

server/services/auto-backfill-follows.ts

···
         // Step 2: Backfill profile info for all related users
         await this.backfillProfileInfo(userDid);
 
+        // Step 3: Backfill posts from all followed users
+        await this.backfillFollowedUsersPosts(userDid);
+
         // Update last backfill timestamp
         await db
           .insert(userSettings)
···
     } catch (error) {
       console.error(
         `[AUTO_BACKFILL_FOLLOWS] Error backfilling profiles:`,
+        error
+      );
+    }
+  }
+
+  /**
+   * Backfill posts from all users that this user follows
+   * Fetches complete timeline for each followed user
+   */
+  private async backfillFollowedUsersPosts(userDid: string): Promise<void> {
+    try {
+      console.log(
+        `[AUTO_BACKFILL_FOLLOWS] Starting posts backfill for followed users of ${userDid}`
+      );
+
+      // Get all users that this user follows
+      const followedUsers = await db.execute(
+        sql`
+          SELECT DISTINCT following_did as did
+          FROM ${follows}
+          WHERE follower_did = ${userDid}
+        `
+      );
+
+      const followedDids = followedUsers.rows.map((row: any) => row.did);
+
+      if (followedDids.length === 0) {
+        console.log(
+          `[AUTO_BACKFILL_FOLLOWS] User ${userDid} doesn't follow anyone yet`
+        );
+        return;
+      }
+
+      console.log(
+        `[AUTO_BACKFILL_FOLLOWS] Backfilling posts from ${followedDids.length} followed users`
+      );
+
+      const eventProcessor = new EventProcessor(storage);
+      eventProcessor.setSkipPdsFetching(true);
+      eventProcessor.setSkipDataCollectionCheck(true);
+
+      const { didResolver } = await import('./did-resolver');
+      let totalPostsFetched = 0;
+      let usersCompleted = 0;
+      let usersFailed = 0;
+
+      // Process each followed user
+      for (const followedDid of followedDids) {
+        try {
+          // Resolve their DID to find their PDS
+          const didDoc = await didResolver.resolveDID(followedDid);
+          if (!didDoc) {
+            usersFailed++;
+            continue;
+          }
+
+          const services = (didDoc as any).service || [];
+          const pdsService = services.find(
+            (s: any) =>
+              s.type === 'AtprotoPersonalDataServer' || s.id === '#atproto_pds'
+          );
+
+          if (!pdsService?.serviceEndpoint) {
+            usersFailed++;
+            continue;
+          }
+
+          const pdsAgent = new AtpAgent({
+            service: pdsService.serviceEndpoint,
+          });
+
+          // Fetch their posts
+          let postsFetched = 0;
+          let cursor: string | undefined;
+
+          do {
+            try {
+              const response = await pdsAgent.com.atproto.repo.listRecords({
+                repo: followedDid,
+                collection: 'app.bsky.feed.post',
+                limit: 100,
+                cursor: cursor,
+              });
+
+              // Process each post
+              for (const record of response.data.records) {
+                try {
+                  const createdAt =
+                    record.value?.createdAt || new Date().toISOString();
+
+                  await eventProcessor.processCommit({
+                    repo: followedDid,
+                    ops: [
+                      {
+                        action: 'create',
+                        path: `app.bsky.feed.post/${record.uri.split('/').pop()}`,
+                        cid: record.cid,
+                        record: record.value,
+                      },
+                    ],
+                    time: createdAt,
+                    rev: '',
+                  } as any);
+
+                  postsFetched++;
+                  totalPostsFetched++;
+                } catch (error: any) {
+                  // Silently skip individual post errors (e.g., duplicates)
+                  if (error?.code !== '23505') {
+                    console.error(
+                      `[AUTO_BACKFILL_FOLLOWS] Error processing post from ${followedDid}:`,
+                      error.message
+                    );
+                  }
+                }
+              }
+
+              cursor = response.data.cursor;
+            } catch (error: any) {
+              console.error(
+                `[AUTO_BACKFILL_FOLLOWS] Error listing posts for ${followedDid}:`,
+                error.message
+              );
+              break;
+            }
+          } while (cursor);
+
+          usersCompleted++;
+          console.log(
+            `[AUTO_BACKFILL_FOLLOWS] User ${usersCompleted}/${followedDids.length}: Fetched ${postsFetched} posts from ${followedDid}`
+          );
+        } catch (error: any) {
+          console.error(
+            `[AUTO_BACKFILL_FOLLOWS] Error backfilling posts for ${followedDid}:`,
+            error.message
+          );
+          usersFailed++;
+        }
+      }
+
+      console.log(
+        `[AUTO_BACKFILL_FOLLOWS] Posts backfill complete: ${totalPostsFetched} posts from ${usersCompleted} users (${usersFailed} failed)`
+      );
+    } catch (error) {
+      console.error(
+        `[AUTO_BACKFILL_FOLLOWS] Error in backfillFollowedUsersPosts:`,
+        error
+      );
+    }
+  }
+
+  /**
+   * Backfill posts from a single user (called when following someone new)
+   */
+  async backfillNewFollowPosts(followedDid: string): Promise<void> {
+    console.log(
+      `[AUTO_BACKFILL_FOLLOWS] Backfilling posts from newly followed user: ${followedDid}`
+    );
+
+    try {
+      const eventProcessor = new EventProcessor(storage);
+      eventProcessor.setSkipPdsFetching(true);
+      eventProcessor.setSkipDataCollectionCheck(true);
+
+      const { didResolver } = await import('./did-resolver');
+
+      // Resolve their DID to find their PDS
+      const didDoc = await didResolver.resolveDID(followedDid);
+      if (!didDoc) {
+        console.error(
+          `[AUTO_BACKFILL_FOLLOWS] Could not resolve DID ${followedDid}`
+        );
+        return;
+      }
+
+      const services = (didDoc as any).service || [];
+      const pdsService = services.find(
+        (s: any) =>
+          s.type === 'AtprotoPersonalDataServer' || s.id === '#atproto_pds'
+      );
+
+      if (!pdsService?.serviceEndpoint) {
+        console.error(
+          `[AUTO_BACKFILL_FOLLOWS] No PDS endpoint found for ${followedDid}`
+        );
+        return;
+      }
+
+      const pdsAgent = new AtpAgent({
+        service: pdsService.serviceEndpoint,
+      });
+
+      // Fetch their posts
+      let postsFetched = 0;
+      let cursor: string | undefined;
+
+      do {
+        try {
+          const response = await pdsAgent.com.atproto.repo.listRecords({
+            repo: followedDid,
+            collection: 'app.bsky.feed.post',
+            limit: 100,
+            cursor: cursor,
+          });
+
+          // Process each post
+          for (const record of response.data.records) {
+            try {
+              const createdAt =
+                record.value?.createdAt || new Date().toISOString();
+
+              await eventProcessor.processCommit({
+                repo: followedDid,
+                ops: [
+                  {
+                    action: 'create',
+                    path: `app.bsky.feed.post/${record.uri.split('/').pop()}`,
+                    cid: record.cid,
+                    record: record.value,
+                  },
+                ],
+                time: createdAt,
+                rev: '',
+              } as any);
+
+              postsFetched++;
+            } catch (error: any) {
+              // Silently skip duplicates
+              if (error?.code !== '23505') {
+                console.error(
+                  `[AUTO_BACKFILL_FOLLOWS] Error processing post from ${followedDid}:`,
+                  error.message
+                );
+              }
+            }
+          }
+
+          cursor = response.data.cursor;
+        } catch (error: any) {
+          console.error(
+            `[AUTO_BACKFILL_FOLLOWS] Error listing posts for ${followedDid}:`,
+            error.message
+          );
+          break;
+        }
+      } while (cursor);
+
+      console.log(
+        `[AUTO_BACKFILL_FOLLOWS] Fetched ${postsFetched} posts from newly followed user ${followedDid}`
+      );
+    } catch (error) {
+      console.error(
+        `[AUTO_BACKFILL_FOLLOWS] Error backfilling new follow posts:`,
         error
       );
     }

server/services/event-processor.ts

···
       // Invalidate following list cache for the follower
       await cacheService.invalidateUserFollowing(followerDid);
 
+      // Trigger backfill of the followed user's posts (async, non-blocking)
+      // Only backfill for users who have logged in (have sessions)
+      this.triggerNewFollowBackfill(followerDid, followingDid);
+
       // Try to create notification if target user exists locally
       const followingUser = await this.storage.getUser(followingDid);
       if (followingUser) {
···
       .catch((error) => {
         smartConsole.error(
           `[EVENT_PROCESSOR] Failed to import feed generator discovery:`,
+          error
+        );
+      });
+  }
+
+  /**
+   * Trigger backfill of posts from a newly followed user
+   * Only backfills if the follower has ever logged in (has sessions)
+   */
+  private triggerNewFollowBackfill(
+    followerDid: string,
+    followingDid: string
+  ): void {
+    // Check if follower has ever logged in (async, non-blocking)
+    import('../../shared/schema')
+      .then(({ sessions }) => {
+        import('../db')
+          .then(({ db }) => {
+            db.query.sessions
+              .findFirst({
+                where: (s: any, { eq }: any) => eq(s.userDid, followerDid),
+              })
+              .then((session: any) => {
+                if (session) {
+                  // User has logged in, backfill the followed user's posts
+                  smartConsole.log(
+                    `[EVENT_PROCESSOR] Triggering post backfill for new follow: ${followerDid} -> ${followingDid}`
+                  );
+
+                  import('./auto-backfill-follows')
+                    .then(({ autoBackfillFollowsService }) => {
+                      autoBackfillFollowsService.backfillNewFollowPosts(
+                        followingDid
+                      );
+                    })
+                    .catch((error) => {
+                      smartConsole.error(
+                        `[EVENT_PROCESSOR] Failed to trigger follow backfill:`,
+                        error
+                      );
+                    });
+                }
+              })
+              .catch((error: any) => {
+                smartConsole.error(
+                  `[EVENT_PROCESSOR] Error checking session for follow backfill:`,
+                  error
+                );
+              });
+          })
+          .catch((error) => {
+            smartConsole.error(
+              `[EVENT_PROCESSOR] Failed to import db for follow backfill:`,
+              error
+            );
+          });
+      })
+      .catch((error) => {
+        smartConsole.error(
+          `[EVENT_PROCESSOR] Failed to import schema for follow backfill:`,
           error
         );
       });