prevent duplicate follows per lexicon

netlify/functions/batch-follow-users.ts

···
 import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
 import { SessionManager } from "./session-manager";
+import { getDbClient } from "./db";
 import cookie from "cookie";
 
 export const handler: Handler = async (
···
     const { agent, did: userDid } =
       await SessionManager.getAgentForSession(sessionId);
 
+    // Check existing follows before attempting to follow
+    const alreadyFollowing = new Set<string>();
+    try {
+      let cursor: string | undefined = undefined;
+      let hasMore = true;
+      const didsSet = new Set(dids);
+
+      while (hasMore && didsSet.size > 0) {
+        const response = await agent.api.com.atproto.repo.listRecords({
+          repo: userDid,
+          collection: followLexicon,
+          limit: 100,
+          cursor,
+        });
+
+        for (const record of response.data.records) {
+          const followRecord = record.value as any;
+          if (followRecord?.subject && didsSet.has(followRecord.subject)) {
+            alreadyFollowing.add(followRecord.subject);
+            didsSet.delete(followRecord.subject);
+          }
+        }
+
+        cursor = response.data.cursor;
+        hasMore = !!cursor;
+
+        if (didsSet.size === 0) {
+          break;
+        }
+      }
+    } catch (error) {
+      console.error("Error checking existing follows:", error);
+      // Continue - we'll handle duplicates in the follow loop
+    }
+
     // Follow all users
     const results = [];
     let consecutiveErrors = 0;
     const MAX_CONSECUTIVE_ERRORS = 3;
+    const sql = getDbClient();
 
     for (const did of dids) {
+      // Skip if already following
+      if (alreadyFollowing.has(did)) {
+        results.push({
+          did,
+          success: true,
+          alreadyFollowing: true,
+          error: null,
+        });
+
+        // Update database follow status
+        try {
+          await sql`
+            UPDATE atproto_matches
+            SET follow_status = follow_status || jsonb_build_object(${followLexicon}, true),
+                last_follow_check = NOW()
+            WHERE atproto_did = ${did}
+          `;
+        } catch (dbError) {
+          console.error("Failed to update follow status in DB:", dbError);
+        }
+
+        continue;
+      }
+
       try {
         await agent.api.com.atproto.repo.createRecord({
           repo: userDid,
···
         results.push({
           did,
           success: true,
+          alreadyFollowing: false,
           error: null,
         });
 
+        // Update database follow status
+        try {
+          await sql`
+            UPDATE atproto_matches
+            SET follow_status = follow_status || jsonb_build_object(${followLexicon}, true),
+                last_follow_check = NOW()
+            WHERE atproto_did = ${did}
+          `;
+        } catch (dbError) {
+          console.error("Failed to update follow status in DB:", dbError);
+        }
+
         // Reset error counter on success
         consecutiveErrors = 0;
       } catch (error) {
···
         results.push({
           did,
           success: false,
+          alreadyFollowing: false,
           error: error instanceof Error ? error.message : "Follow failed",
         });
 
···
 
     const successCount = results.filter((r) => r.success).length;
     const failCount = results.filter((r) => !r.success).length;
+    const alreadyFollowingCount = results.filter(
+      (r) => r.alreadyFollowing,
+    ).length;
 
     return {
       statusCode: 200,
···
         total: dids.length,
         succeeded: successCount,
         failed: failCount,
+        alreadyFollowing: alreadyFollowingCount,
         results,
       }),
     };

netlify/functions/batch-search-actors.ts

···
       });
     }
 
+    // Check follow status for all matched DIDs in chosen lexicon
+    const followLexicon = body.followLexicon || "app.bsky.graph.follow";
+
+    if (allDids.length > 0) {
+      try {
+        let cursor: string | undefined = undefined;
+        let hasMore = true;
+        const didsSet = new Set(allDids);
+        const followedDids = new Set<string>();
+        const repoDid = await SessionManager.getDIDForSession(sessionId);
+
+        if (repoDid === null) {
+          throw new Error("Could not retrieve DID for session.");
+        }
+
+        // Query user's follow graph
+        while (hasMore && didsSet.size > 0) {
+          const response = await agent.api.com.atproto.repo.listRecords({
+            repo: repoDid,
+            collection: followLexicon,
+            limit: 100,
+            cursor,
+          });
+
+          // Check each record
+          for (const record of response.data.records) {
+            const followRecord = record.value as any;
+            if (followRecord?.subject && didsSet.has(followRecord.subject)) {
+              followedDids.add(followRecord.subject);
+            }
+          }
+
+          cursor = response.data.cursor;
+          hasMore = !!cursor;
+        }
+
+        // Add follow status to results
+        results.forEach((result) => {
+          result.actors = result.actors.map((actor: any) => ({
+            ...actor,
+            followStatus: {
+              [followLexicon]: followedDids.has(actor.did),
+            },
+          }));
+        });
+      } catch (error) {
+        console.error("Failed to check follow status during search:", error);
+        // Continue without follow status - non-critical
+      }
+    }
+
     return {
       statusCode: 200,
       headers: {

netlify/functions/check-follow-status.ts

···
+import { Handler, HandlerEvent, HandlerResponse } from "@netlify/functions";
+import { SessionManager } from "./session-manager";
+import cookie from "cookie";
+
+export const handler: Handler = async (
+  event: HandlerEvent,
+): Promise<HandlerResponse> => {
+  if (event.httpMethod !== "POST") {
+    return {
+      statusCode: 405,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ error: "Method not allowed" }),
+    };
+  }
+
+  try {
+    // Parse request body
+    const body = JSON.parse(event.body || "{}");
+    const dids: string[] = body.dids || [];
+    const followLexicon: string = body.followLexicon || "app.bsky.graph.follow";
+
+    if (!Array.isArray(dids) || dids.length === 0) {
+      return {
+        statusCode: 400,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          error: "dids array is required and must not be empty",
+        }),
+      };
+    }
+
+    // Limit batch size
+    if (dids.length > 100) {
+      return {
+        statusCode: 400,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Maximum 100 DIDs per batch" }),
+      };
+    }
+
+    // Get session from cookie
+    const cookies = event.headers.cookie
+      ? cookie.parse(event.headers.cookie)
+      : {};
+    const sessionId = cookies.atlast_session;
+
+    if (!sessionId) {
+      return {
+        statusCode: 401,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "No session cookie" }),
+      };
+    }
+
+    // Get authenticated agent using SessionManager
+    const { agent, did: userDid } =
+      await SessionManager.getAgentForSession(sessionId);
+
+    // Build follow status map
+    const followStatus: Record<string, boolean> = {};
+
+    // Initialize all as not following
+    dids.forEach((did) => {
+      followStatus[did] = false;
+    });
+
+    // Query user's follow graph for the specific lexicon
+    try {
+      let cursor: string | undefined = undefined;
+      let hasMore = true;
+      const didsSet = new Set(dids);
+
+      while (hasMore && didsSet.size > 0) {
+        const response = await agent.api.com.atproto.repo.listRecords({
+          repo: userDid,
+          collection: followLexicon,
+          limit: 100,
+          cursor,
+        });
+
+        // Check each record
+        for (const record of response.data.records) {
+          const followRecord = record.value as any;
+          if (followRecord?.subject && didsSet.has(followRecord.subject)) {
+            followStatus[followRecord.subject] = true;
+            didsSet.delete(followRecord.subject); // Found it, no need to keep checking
+          }
+        }
+
+        cursor = response.data.cursor;
+        hasMore = !!cursor;
+
+        // If we've found all DIDs, break early
+        if (didsSet.size === 0) {
+          break;
+        }
+      }
+    } catch (error) {
+      console.error("Error querying follow graph:", error);
+      // On error, return all as false (not following) - fail safe
+    }
+
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+      },
+      body: JSON.stringify({ followStatus }),
+    };
+  } catch (error) {
+    console.error("Check follow status error:", error);
+
+    // Handle authentication errors specifically
+    if (error instanceof Error && error.message.includes("session")) {
+      return {
+        statusCode: 401,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          error: "Invalid or expired session",
+          details: error.message,
+        }),
+      };
+    }
+
+    return {
+      statusCode: 500,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        error: "Failed to check follow status",
+        details: error instanceof Error ? error.message : "Unknown error",
+      }),
+    };
+  }
+};

netlify/functions/db-helpers.ts

···
   matchScore: number,
   postCount: number,
   followerCount: number,
+  followStatus?: Record<string, boolean>,
 ): Promise<number> {
   const sql = getDbClient();
   const result = await sql`
     INSERT INTO atproto_matches (
       source_account_id, atproto_did, atproto_handle,
       atproto_display_name, atproto_avatar, match_score,
-      post_count, follower_count
+      post_count, follower_count, follow_status
     )
     VALUES (
       ${sourceAccountId}, ${atprotoDid}, ${atprotoHandle},
       ${atprotoDisplayName || null}, ${atprotoAvatar || null}, ${matchScore},
-      ${postCount || 0}, ${followerCount || 0}
+      ${postCount || 0}, ${followerCount || 0}, ${JSON.stringify(followStatus || {})}
     )
     ON CONFLICT (source_account_id, atproto_did) DO UPDATE SET
       atproto_handle = ${atprotoHandle},
···
       match_score = ${matchScore},
       post_count = ${postCount},
       follower_count = ${followerCount},
+      follow_status = COALESCE(atproto_matches.follow_status, '{}'::jsonb) || ${JSON.stringify(followStatus || {})},
       last_verified = NOW()
     RETURNING id
   `;
···
     matchScore: number;
     postCount?: number;
     followerCount?: number;
+    followStatus?: Record<string, boolean>;
   }>,
 ): Promise<Map<string, number>> {
   const sql = getDbClient();
···
   const matchScore = matches.map((m) => m.matchScore);
   const postCount = matches.map((m) => m.postCount || 0);
   const followerCount = matches.map((m) => m.followerCount || 0);
+  const followStatus = matches.map((m) => JSON.stringify(m.followStatus || {}));
 
   const result = await sql`
     INSERT INTO atproto_matches (
       source_account_id, atproto_did, atproto_handle,
       atproto_display_name, atproto_avatar, atproto_description,
-      match_score, post_count, follower_count
+      match_score, post_count, follower_count, follow_status
     )
     SELECT * FROM UNNEST(
       ${sourceAccountId}::integer[],
···
       ${atprotoDescription}::text[],
       ${matchScore}::integer[],
       ${postCount}::integer[],
-      ${followerCount}::integer[]
+      ${followerCount}::integer[],
+      ${followStatus}::jsonb[]
     ) AS t(
       source_account_id, atproto_did, atproto_handle,
       atproto_display_name, atproto_avatar, match_score,
-      post_count, follower_count
+      post_count, follower_count, follow_status
     )
     ON CONFLICT (source_account_id, atproto_did) DO UPDATE SET
       atproto_handle = EXCLUDED.atproto_handle,
···
       match_score = EXCLUDED.match_score,
       post_count = EXCLUDED.post_count,
       follower_count = EXCLUDED.follower_count,
+      follow_status = COALESCE(atproto_matches.follow_status, '{}'::jsonb) || EXCLUDED.follow_status,
       last_verified = NOW()
     RETURNING id, source_account_id, atproto_did
   `;

netlify/functions/db.ts

···
       found_at TIMESTAMP DEFAULT NOW(),
       last_verified TIMESTAMP,
       is_active BOOLEAN DEFAULT TRUE,
+      follow_status JSONB DEFAULT '{}',
+      last_follow_check TIMESTAMP,
       UNIQUE(source_account_id, atproto_did)
     )
   `;
···
     )
   `;
 
-  // ==================== ENHANCED INDEXES FOR PHASE 2 ====================
-
   // Existing indexes
   await sql`CREATE INDEX IF NOT EXISTS idx_source_accounts_to_check ON source_accounts(source_platform, match_found, last_checked)`;
   await sql`CREATE INDEX IF NOT EXISTS idx_source_accounts_platform ON source_accounts(source_platform)`;
···
   await sql`CREATE INDEX IF NOT EXISTS idx_user_match_status_did_followed ON user_match_status(did, followed)`;
   await sql`CREATE INDEX IF NOT EXISTS idx_notification_queue_pending ON notification_queue(sent, created_at) WHERE sent = false`;
 
-  // NEW: Enhanced indexes for common query patterns
+  // ======== Enhanced indexes for common query patterns =========
 
   // For sorting
   await sql`CREATE INDEX IF NOT EXISTS idx_atproto_matches_stats ON atproto_matches(source_account_id, found_at DESC, post_count DESC, follower_count DESC)`;
···
 
   // For bulk operations - normalized username lookups
   await sql`CREATE INDEX IF NOT EXISTS idx_source_accounts_normalized ON source_accounts(normalized_username, source_platform)`;
+
+  // Follow status indexes
+  await sql`CREATE INDEX IF NOT EXISTS idx_atproto_matches_follow_status ON atproto_matches USING gin(follow_status)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_atproto_matches_follow_check ON atproto_matches(last_follow_check)`;
 
   console.log("✅ Database indexes created/verified");
 }

netlify/functions/get-upload-details.ts

···
     // Fetch paginated results with optimized query
     const results = await sql`
       SELECT
-        sa.source_username,
-        sa.normalized_username,
-        usf.source_date,
-        am.atproto_did,
-        am.atproto_handle,
-        am.atproto_display_name,
-        am.atproto_avatar,
-        am.atproto_description,
-        am.match_score,
-        am.post_count,
-        am.follower_count,
-        am.found_at,
-        ums.followed,
-        ums.dismissed,
+      sa.source_username,
+      sa.normalized_username,
+      usf.source_date,
+      am.atproto_did,
+      am.atproto_handle,
+      am.atproto_display_name,
+      am.atproto_avatar,
+      am.atproto_description,
+      am.match_score,
+      am.post_count,
+      am.follower_count,
+      am.found_at,
+      am.follow_status,
+      am.last_follow_check,
+      ums.followed,
+      ums.dismissed,
         -- Calculate if this is a new match (found after upload creation)
         CASE WHEN am.found_at > uu.created_at THEN 1 ELSE 0 END as is_new_match
       FROM user_source_follows usf
···
           foundAt: row.found_at,
           followed: row.followed || false,
           dismissed: row.dismissed || false,
+          followStatus: row.follow_status || {},
         });
       }
     });

src/App.tsx

···
 import { useFileUpload } from "./hooks/useFileUpload";
 import { useTheme } from "./hooks/useTheme";
 import Firefly from "./components/Firefly";
+import { ATPROTO_APPS } from "./constants/atprotoApps";
 import { DEFAULT_SETTINGS } from "./types/settings";
 import type { UserSettings } from "./types/settings";
 
···
       setCurrentStep("loading");
 
       const uploadId = crypto.randomUUID();
+      const followLexicon =
+        ATPROTO_APPS[currentDestinationAppId]?.followLexicon;
 
       searchAllUsers(initialResults, setStatusMessage, () => {
         setCurrentStep("results");
···
             isFollowing={isFollowing}
             currentStep={currentStep}
             sourcePlatform={currentPlatform}
+            destinationAppId={currentDestinationAppId}
             reducedMotion={reducedMotion}
             isDark={isDark}
             onToggleTheme={toggleTheme}

src/components/SearchResultCard.tsx

···
   UserCheck,
 } from "lucide-react";
 import { PLATFORMS } from "../constants/platforms";
+import { ATPROTO_APPS } from "../constants/atprotoApps";
 import type { SearchResult } from "../types";
+import type { AtprotoAppId } from "../types/settings";
 
 interface SearchResultCardProps {
   result: SearchResult;
···
   onToggleExpand: () => void;
   onToggleMatchSelection: (did: string) => void;
   sourcePlatform: string;
+  destinationAppId?: AtprotoAppId;
 }
 
 export default function SearchResultCard({
···
   onToggleExpand,
   onToggleMatchSelection,
   sourcePlatform,
+  destinationAppId = "bluesky",
 }: SearchResultCardProps) {
   const displayMatches = isExpanded
     ? result.atprotoMatches
···
   const hasMoreMatches = result.atprotoMatches.length > 1;
   const platform = PLATFORMS[sourcePlatform] || PLATFORMS.tiktok;
 
+  // Get current follow lexicon
+  const currentApp = ATPROTO_APPS[destinationAppId];
+  const currentLexicon = currentApp?.followLexicon || "app.bsky.graph.follow";
+
   return (
     <div className="bg-white/50 dark:bg-slate-900/50 rounded-2xl shadow-sm overflow-hidden border-2 border-cyan-500/30 dark:border-purple-500/30">
       {/* Source User */}
···
       ) : (
         <div className="">
           {displayMatches.map((match) => {
-            const isFollowed = match.followed;
+            // Check follow status for current lexicon
+            const isFollowedInCurrentApp =
+              match.followStatus?.[currentLexicon] ?? match.followed ?? false;
             const isSelected = result.selectedMatches?.has(match.did);
+
             return (
               <div
                 key={match.did}
···
                 {/* Select/Follow Button */}
                 <button
                   onClick={() => onToggleMatchSelection(match.did)}
-                  disabled={isFollowed}
+                  disabled={isFollowedInCurrentApp}
                   className={`p-2 rounded-full font-medium transition-all flex-shrink-0 self-start ${
-                    isFollowed
-                      ? "bg-purple-100 dark:bg-slate-900 border-2 border-purple-500 dark:border-cyan-500 text-purple-950 dark:text-cyan-50 shadow-md cursor-not-allowed opacity-60"
+                    isFollowedInCurrentApp
+                      ? "bg-purple-100 dark:bg-slate-900 border-2 border-purple-500 dark:border-cyan-500 text-purple-950 dark:text-cyan-50 shadow-md cursor-not-allowed opacity-50"
                       : isSelected
                         ? "bg-purple-100 dark:bg-slate-900 border-2 border-purple-500 dark:border-cyan-500 text-purple-950 dark:text-cyan-50 shadow-md"
                         : "bg-slate-200/50 dark:bg-slate-900/50 border-2 border-cyan-500/30 dark:border-purple-500/30 text-purple-750 dark:text-cyan-250 hover:border-orange-500 dark:hover:border-amber-400"
                   }`}
                   title={
-                    isFollowed
-                      ? "Already followed"
+                    isFollowedInCurrentApp
+                      ? `Already following on ${currentApp?.name || "this app"}`
                       : isSelected
                         ? "Selected to follow"
                         : "Select to follow"
                   }
                 >
-                  {isFollowed ? (
+                  {isFollowedInCurrentApp ? (
                     <Check className="w-4 h-4" />
                   ) : isSelected ? (
                     <UserCheck className="w-4 h-4" />

src/hooks/useFollows.ts

···
   destinationAppId: AtprotoAppId,
 ) {
   const [isFollowing, setIsFollowing] = useState(false);
+  const [isCheckingFollowStatus, setIsCheckingFollowStatus] = useState(false);
 
   async function followSelectedUsers(
     onUpdate: (message: string) => void,
···
       return;
     }
 
-    // Follow users
+    // Get selected users
     const selectedUsers = searchResults.flatMap((result, resultIndex) =>
       result.atprotoMatches
         .filter((match) => result.selectedMatches?.has(match.did))
···
       return;
     }
 
+    // Check follow status before attempting to follow
+    setIsCheckingFollowStatus(true);
+    onUpdate(`Checking follow status for ${selectedUsers.length} users...`);
+
+    let followStatusMap: Record<string, boolean> = {};
+    try {
+      const dids = selectedUsers.map((u) => u.did);
+      followStatusMap = await apiClient.checkFollowStatus(dids, followLexicon);
+    } catch (error) {
+      console.error("Failed to check follow status:", error);
+      // Continue without filtering - backend will handle duplicates
+    } finally {
+      setIsCheckingFollowStatus(false);
+    }
+
+    // Filter out users already being followed
+    const usersToFollow = selectedUsers.filter(
+      (user) => !followStatusMap[user.did],
+    );
+    const alreadyFollowingCount = selectedUsers.length - usersToFollow.length;
+
+    if (alreadyFollowingCount > 0) {
+      onUpdate(
+        `${alreadyFollowingCount} user${alreadyFollowingCount > 1 ? "s" : ""} already followed. Following ${usersToFollow.length} remaining...`,
+      );
+
+      // Update UI to show already followed status
+      setSearchResults((prev) =>
+        prev.map((result) => ({
+          ...result,
+          atprotoMatches: result.atprotoMatches.map((match) => {
+            if (followStatusMap[match.did]) {
+              return {
+                ...match,
+                followStatus: {
+                  ...match.followStatus,
+                  [followLexicon]: true,
+                },
+              };
+            }
+            return match;
+          }),
+        })),
+      );
+    }
+
+    if (usersToFollow.length === 0) {
+      onUpdate("All selected users are already being followed!");
+      return;
+    }
+
     setIsFollowing(true);
     onUpdate(
-      `Following ${selectedUsers.length} users on ${destinationName}...`,
+      `Following ${usersToFollow.length} users on ${destinationName}...`,
     );
     let totalFollowed = 0;
     let totalFailed = 0;
···
     try {
       const { BATCH_SIZE } = FOLLOW_CONFIG;
 
-      for (let i = 0; i < selectedUsers.length; i += BATCH_SIZE) {
-        const batch = selectedUsers.slice(i, i + BATCH_SIZE);
+      for (let i = 0; i < usersToFollow.length; i += BATCH_SIZE) {
+        const batch = usersToFollow.slice(i, i + BATCH_SIZE);
         const dids = batch.map((user) => user.did);
 
         try {
···
                           atprotoMatches: searchResult.atprotoMatches.map(
                             (match) =>
                               match.did === result.did
-                                ? { ...match, followed: true }
+                                ? {
+                                    ...match,
+                                    followed: true, // Backward compatibility
+                                    followStatus: {
+                                      ...match.followStatus,
+                                      [followLexicon]: true,
+                                    },
+                                  }
                                 : match,
                           ),
                         }
···
           });
 
           onUpdate(
-            `Followed ${totalFollowed} of ${selectedUsers.length} users`,
+            `Followed ${totalFollowed} of ${usersToFollow.length} users`,
           );
         } catch (error) {
           totalFailed += batch.length;
···
         // Rate limit handling is in the backend
       }
 
-      const finalMsg = `Successfully followed ${totalFollowed} users${totalFailed > 0 ? `. ${totalFailed} failed.` : ""}`;
+      const finalMsg =
+        `Successfully followed ${totalFollowed} users` +
+        (alreadyFollowingCount > 0
+          ? ` (${alreadyFollowingCount} already followed)`
+          : "") +
+        (totalFailed > 0 ? `. ${totalFailed} failed.` : "");
       onUpdate(finalMsg);
     } catch (error) {
       console.error("Batch follow error:", error);
···
 
   return {
     isFollowing,
+    isCheckingFollowStatus,
     followSelectedUsers,
   };
 }

src/hooks/useSearch.ts

···
     resultsToSearch: SearchResult[],
     onProgressUpdate: (message: string) => void,
     onComplete: () => void,
+    followLexicon?: string,
   ) {
     if (!session || resultsToSearch.length === 0) return;
 
···
       );
 
       try {
-        const data = await apiClient.batchSearchActors(usernames);
+        const data = await apiClient.batchSearchActors(
+          usernames,
+          followLexicon,
+        );
 
         // Reset error counter on success
         consecutiveErrors = 0;

src/lib/apiClient/mockApiClient.ts

···
     description: `Mock profile for ${username}`,
     postCount: Math.floor(Math.random() * 1000),
     followerCount: Math.floor(Math.random() * 5000),
+    followStatus: {
+      "app.bsky.graph.follow": Math.random() < 0.3, // 30% already following
+    },
   }));
 }
 
···
     localStorage.removeItem("mock_uploads");
   },
 
+  async checkFollowStatus(
+    dids: string[],
+    followLexicon: string,
+  ): Promise<Record<string, boolean>> {
+    await delay(300);
+    console.log("[MOCK] Checking follow status for:", dids.length, "DIDs");
+
+    // Mock: 30% chance each user is already followed
+    const followStatus: Record<string, boolean> = {};
+    dids.forEach((did) => {
+      followStatus[did] = Math.random() < 0.3;
+    });
+
+    return followStatus;
+  },
+
   async getUploads(): Promise<{ uploads: any[] }> {
     await delay(300);
     console.log("[MOCK] Getting uploads");
···
 
   async batchSearchActors(
     usernames: string[],
+    followLexicon?: string,
   ): Promise<{ results: BatchSearchResult[] }> {
     await delay(800); // Simulate API delay
     console.log("[MOCK] Searching for:", usernames);

src/lib/apiClient/realApiClient.ts

···
     return { results: allResults };
   },
 
+  // NEW: Check follow status
+  async checkFollowStatus(
+    dids: string[],
+    followLexicon: string,
+  ): Promise<Record<string, boolean>> {
+    // Check cache first
+    const cacheKey = `follow-status-${followLexicon}-${dids.slice().sort().join(",")}`;
+    const cached = cache.get<Record<string, boolean>>(cacheKey, 2 * 60 * 1000); // 2 minute cache
+    if (cached) {
+      console.log("Returning cached follow status");
+      return cached;
+    }
+
+    const res = await fetch("/.netlify/functions/check-follow-status", {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ dids, followLexicon }),
+    });
+
+    if (!res.ok) {
+      throw new Error("Failed to check follow status");
+    }
+
+    const data = await res.json();
+
+    // Cache for 2 minutes
+    cache.set(cacheKey, data.followStatus, 2 * 60 * 1000);
+
+    return data.followStatus;
+  },
+
   // Search Operations
   async batchSearchActors(
     usernames: string[],
+    followLexicon?: string,
   ): Promise<{ results: BatchSearchResult[] }> {
     // Create cache key from sorted usernames (so order doesn't matter)
-    const cacheKey = `search-${usernames.slice().sort().join(",")}`;
+    const cacheKey = `search-${followLexicon || "default"}-${usernames.slice().sort().join(",")}`;
     const cached = cache.get<any>(cacheKey, 10 * 60 * 1000);
     if (cached) {
       console.log(
···
       method: "POST",
       credentials: "include",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ usernames }),
+      body: JSON.stringify({ usernames, followLexicon }),
     });
 
     if (!res.ok) {
···
     total: number;
     succeeded: number;
     failed: number;
+    alreadyFollowing: number;
     results: BatchFollowResult[];
   }> {
     const res = await fetch("/.netlify/functions/batch-follow-users", {
···
 
     const data = await res.json();
 
-    // Invalidate uploads cache after following
+    // Invalidate caches after following
     cache.invalidate("uploads");
     cache.invalidatePattern("upload-details");
+    cache.invalidatePattern("follow-status");
 
     return data;
   },

src/pages/Results.tsx

···
 import { PLATFORMS } from "../constants/platforms";
 import AppHeader from "../components/AppHeader";
 import SearchResultCard from "../components/SearchResultCard";
+import type { AtprotoAppId } from "../types/settings";
 
 interface atprotoSession {
   did: string;
···
   isFollowing: boolean;
   currentStep: string;
   sourcePlatform: string;
+  destinationAppId: AtprotoAppId;
   reducedMotion?: boolean;
   isDark?: boolean;
   onToggleTheme?: () => void;
···
   isFollowing,
   currentStep,
   sourcePlatform,
+  destinationAppId,
   reducedMotion = false,
   isDark = false,
   onToggleTheme,
···
                   onToggleMatchSelection(originalIndex, did)
                 }
                 sourcePlatform={sourcePlatform}
+                destinationAppId={destinationAppId}
               />
             );
           })}

src/types/index.ts

···
   avatar?: string;
   matchScore: number;
   description?: string;
-  followed?: boolean;
+  followed?: boolean; // DEPRECATED - kept for backward compatibility
+  followStatus?: Record<string, boolean>;
   postCount?: number;
   followerCount?: number;
   foundAt?: string;
···
 export interface BatchFollowResult {
   did: string;
   success: boolean;
+  alreadyFollowing?: boolean;
   error: string | null;
 }