diff --git a/app/admin/dashboard/feed/page.tsx b/app/admin/dashboard/feed/page.tsx
index 452ddb9..35130d5 100644
--- a/app/admin/dashboard/feed/page.tsx
+++ b/app/admin/dashboard/feed/page.tsx
@@ -4,7 +4,7 @@ import { useEffect, useState } from 'react';
 import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
 import { Button } from '@/components/ui/button';
 import { Badge } from '@/components/ui/badge';
-import { CheckCircle, EyeOff, ExternalLink, Loader2, Search, Trash2 } from 'lucide-react';
+import { CheckCircle, EyeOff, ExternalLink, Loader2, Search, ShieldCheck, Trash2 } from 'lucide-react';
 
 interface FeedPost {
   _id: string;
@@ -17,6 +17,8 @@ interface FeedPost {
   postedAt?: string;
   source: 'seed' | 'olostep-search-index' | 'community-submission' | 'admin-import';
   status: 'approved' | 'pending' | 'hidden';
+  /** Set when the automatic check hid the post */
+  hiddenReason?: string;
   createdAt: string;
 }
 
@@ -40,6 +42,14 @@ const SEARCHES_PER_REQUEST = 40;
 /** Topic searches in lib/linkedin-feed.ts; one search per member is added on top */
 const TOPIC_SEARCH_COUNT = 40;
 
+/** What a search run found, in words */
+function foundSummary(added: number, rejected: number, needsReview: number) {
+  const parts = [`${added} new posts live`];
+  if (needsReview) parts.push(`${needsReview} waiting for review (LinkedIn didn't load them)`);
+  if (rejected) parts.push(`${rejected} skipped (no Dev Weekends mention or deleted)`);
+  return `${parts.join(', ')}.`;
+}
+
 export default function AdminFeedPage() {
   const [posts, setPosts] = useState<FeedPost[]>([]);
   const [loading, setLoading] = useState(true);
@@ -47,6 +57,8 @@ export default function AdminFeedPage() {
   const [processingId, setProcessingId] = useState<string | null>(null);
   const [collecting, setCollecting] = useState(false);
   const [collectMessage, setCollectMessage] = useState('');
+  const [checking, setChecking] = useState(false);
+  const [checkMessage, setCheckMessage] = useState('');
   const [importText, setImportText] = useState('');
   const [importing, setImporting] = useState(false);
   const [importMessage, setImportMessage] = useState('');
@@ -113,7 +125,8 @@ export default function AdminFeedPage() {
         return;
       }
       setCollectMessage(
-        `Ran ${data.queries} of ${data.searchListSize} searches${data.failedQueries ? ` (${data.failedQueries} failed)` : ''}: ${data.added} new posts, ${data.enriched} updated.`
+        `Ran ${data.queries} of ${data.searchListSize} searches${data.failedQueries ? ` (${data.failedQueries} failed)` : ''}: ` +
+          foundSummary(data.added, data.rejected, data.needsReview)
       );
       await fetchPosts();
     } catch {
@@ -148,7 +161,8 @@ export default function AdminFeedPage() {
     let total = estimate;
     let done = 0;
     let added = 0;
-    let enriched = 0;
+    let rejected = 0;
+    let needsReview = 0;
     let failed = 0;
     try {
       while (done < total) {
@@ -162,7 +176,8 @@ export default function AdminFeedPage() {
         if (done === 0) total = data.searchListSize;
         done += data.queries;
         added += data.added;
-        enriched += data.enriched;
+        rejected += data.rejected;
+        needsReview += data.needsReview;
         failed += data.failedQueries;
         if (data.failedQueries === data.queries) {
           setCollectMessage(`Stopped: every search in the last batch failed (check Olostep credits). ${added} new posts found.`);
@@ -171,7 +186,7 @@ export default function AdminFeedPage() {
         setCollectMessage(`Searching… ${done} of ${total} done, ${added} new posts so far.`);
       }
       setCollectMessage(
-        `Searched everything: ${done} searches${failed ? ` (${failed} failed)` : ''}, ${added} new posts, ${enriched} updated.`
+        `Searched everything: ${done} searches${failed ? ` (${failed} failed)` : ''}. ${foundSummary(added, rejected, needsReview)}`
       );
     } catch {
       setCollectMessage(`Stopped after ${done} searches with ${added} new posts.`);
@@ -181,6 +196,62 @@ export default function AdminFeedPage() {
     }
   };
 
+  /**
+   * Checks every live post from the starter list and search against its LinkedIn
+   * page, in batches, and hides the ones that don't mention Dev Weekends or were deleted.
+   */
+  const checkLivePosts = async () => {
+    if (
+      !confirm(
+        'Check every live post found by search against its LinkedIn page, and hide the ones whose text ' +
+          "doesn't mention Dev Weekends? Hidden posts can be approved again. No Olostep credits are used."
+      )
+    ) {
+      return;
+    }
+    setChecking(true);
+    setCheckMessage('');
+    let after: string | undefined;
+    let checked = 0;
+    let hidden = 0;
+    let unknown = 0;
+    try {
+      for (;;) {
+        const res = await fetch('/api/admin/feed', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ action: 'recheck', after }),
+        });
+        const data = await res.json();
+        if (!res.ok) {
+          setCheckMessage(`${data.error ?? 'Check failed.'} Stopped after ${checked} posts, ${hidden} hidden.`);
+          return;
+        }
+        checked += data.checked;
+        hidden += data.hidden.length;
+        unknown += data.unknown;
+        if (data.checked > 0 && data.unknown === data.checked) {
+          setCheckMessage(`Stopped: LinkedIn didn't show any post in the last batch. Try again later. ${hidden} hidden so far.`);
+          return;
+        }
+        if (!data.lastId || data.remaining === 0) break;
+        after = data.lastId;
+        setCheckMessage(`Checking… ${checked} done, ${data.remaining} left, ${hidden} hidden so far.`);
+      }
+      setCheckMessage(
+        checked === 0
+          ? 'Every live post has been checked already.'
+          : `Checked ${checked} posts: ${hidden} hidden (see the Hidden tab)` +
+              (unknown ? `, ${unknown} couldn't be loaded and stay live; run it again later to retry them.` : '.')
+      );
+    } catch {
+      setCheckMessage(`Stopped after ${checked} posts, ${hidden} hidden.`);
+    } finally {
+      setChecking(false);
+      await fetchPosts();
+    }
+  };
+
   const importLinks = async () => {
     setImporting(true);
     setImportMessage('');
@@ -229,19 +300,24 @@ export default function AdminFeedPage() {
         </div>
         <div className="max-w-sm text-right">
           <div className="flex flex-wrap justify-end gap-2">
-            <Button variant="outline" onClick={collect} disabled={collecting}>
+            <Button variant="outline" onClick={checkLivePosts} disabled={checking || collecting}>
+              {checking ? <Loader2 className="h-4 w-4 animate-spin" /> : <ShieldCheck className="h-4 w-4" />}
+              Check live posts
+            </Button>
+            <Button variant="outline" onClick={collect} disabled={collecting || checking}>
               Find new posts
             </Button>
-            <Button onClick={searchEverything} disabled={collecting}>
+            <Button onClick={searchEverything} disabled={collecting || checking}>
               {collecting ? <Loader2 className="h-4 w-4 animate-spin" /> : <Search className="h-4 w-4" />}
               Search everything
             </Button>
           </div>
           <p className="mt-1 text-xs text-muted-foreground">
             Find new posts runs 5 searches. Search everything runs the whole list once. Each search uses about{' '}
-            {CREDITS_PER_SEARCH} Olostep credits.
+            {CREDITS_PER_SEARCH} Olostep credits. A found post goes live only if its text on LinkedIn mentions Dev Weekends.
           </p>
           {collectMessage && <p className="mt-2 text-sm">{collectMessage}</p>}
+          {checkMessage && <p className="mt-2 text-sm">{checkMessage}</p>}
         </div>
       </div>
 
@@ -306,6 +382,9 @@ export default function AdminFeedPage() {
                 </div>
               </CardHeader>
               <CardContent className="space-y-4">
+                {post.status === 'hidden' && post.hiddenReason && (
+                  <p className="text-sm text-muted-foreground">Hidden automatically: {post.hiddenReason}.</p>
+                )}
                 {post.excerpt && <p className="text-sm">{post.excerpt}</p>}
                 <div className="flex flex-wrap gap-2">
                   <Button asChild variant="outline" size="sm">
diff --git a/app/api/admin/feed/[id]/route.ts b/app/api/admin/feed/[id]/route.ts
index ea1e6cd..fd2f707 100644
--- a/app/api/admin/feed/[id]/route.ts
+++ b/app/api/admin/feed/[id]/route.ts
@@ -37,7 +37,10 @@ export async function PATCH(request: Request, { params }: { params: Promise<{ id
     }
 
     await connectDB();
-    const post = await LinkedInPost.findByIdAndUpdate(id, { status: data.status }, { new: true });
+    // An admin's approval stands: the automatic check won't hide the post again
+    const update =
+      data.status === 'approved' ? { status: data.status, checkedAt: new Date(), hiddenReason: '' } : { status: data.status };
+    const post = await LinkedInPost.findByIdAndUpdate(id, update, { new: true });
     if (!post) {
       return NextResponse.json({ error: 'Post not found' }, { status: 404 });
     }
diff --git a/app/api/admin/feed/route.ts b/app/api/admin/feed/route.ts
index e15287f..3454dc9 100644
--- a/app/api/admin/feed/route.ts
+++ b/app/api/admin/feed/route.ts
@@ -3,8 +3,9 @@ import { cookies } from 'next/headers';
 import { revalidatePath } from 'next/cache';
 import { verify } from 'jsonwebtoken';
 import connectDB from '@/lib/db';
-import { collectFromOlostep, importPostUrls } from '@/lib/linkedin-feed';
+import { collectFromOlostep, importPostUrls, recheckLivePosts } from '@/lib/linkedin-feed';
 import { LinkedInPost } from '@/models/LinkedInPost';
+import { ActivityLog } from '@/models/ActivityLog';
 
 export const maxDuration = 300;
 
@@ -32,7 +33,7 @@ export async function GET() {
 
     await connectDB();
     const posts = await LinkedInPost.find()
-      .select('activityId url author title excerpt topic postedAt source status createdAt')
+      .select('activityId url author title excerpt topic postedAt source status hiddenReason createdAt')
       .sort({ createdAt: -1 })
       .lean();
     return NextResponse.json(posts);
@@ -47,17 +48,36 @@ const MAX_SEARCHES_PER_REQUEST = 60;
 
 /**
  * Admin actions on the feed:
- * - `{ action: "collect", searches?: number }` runs Olostep searches ("Find new posts", "Deep search")
+ * - `{ action: "collect", searches?: number }` runs Olostep searches ("Find new posts", "Search everything")
  * - `{ action: "import", urls: string }` adds pasted LinkedIn post links, live straight away
+ * - `{ action: "recheck", after?: string }` checks the next batch of live posts against LinkedIn
+ *   and hides the ones that don't mention Dev Weekends ("Check live posts")
  */
 export async function POST(request: Request) {
   try {
-    if (!(await getAdminUser())) {
+    const adminUsername = await getAdminUser();
+    if (!adminUsername) {
       return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
     }
 
     const body = await request.json().catch(() => ({}));
 
+    if (body.action === 'recheck') {
+      const after = typeof body.after === 'string' && /^[0-9a-f]{24}$/.test(body.after) ? body.after : undefined;
+      const result = await recheckLivePosts(after);
+      if (result.hidden.length > 0) {
+        await ActivityLog.create({
+          entityType: 'LinkedInPost',
+          entityId: 'feed-check',
+          action: 'hide',
+          adminUsername,
+          details: { hidden: result.hidden },
+        });
+        revalidatePath('/feed');
+      }
+      return NextResponse.json(result);
+    }
+
     if (body.action === 'import') {
       if (typeof body.urls !== 'string' || !body.urls.trim()) {
         return NextResponse.json({ error: 'Paste at least one LinkedIn post link.' }, { status: 400 });
diff --git a/data/linkedin-posts.json b/data/linkedin-posts.json
index 79dd09b..c963068 100644
--- a/data/linkedin-posts.json
+++ b/data/linkedin-posts.json
@@ -83,24 +83,6 @@
     "source": "olostep-search-index",
     "submitted": false
   },
-  {
-    "id": "7512945322910863360",
-    "url": "https://www.linkedin.com/posts/arslanchoudhary_github-arslan-choudharyredis-series-activity-7512945322910863360-cP_2",
-    "author": "Arslan Choudhary",
-    "handle": "arslanchoudhary",
-    "title": "Github · Arslan · Choudharyredis",
-    "excerpt": "",
-    "topic": "open-source",
-    "tags": [
-      "github",
-      "arslan",
-      "choudharyredis",
-      "series"
-    ],
-    "postedAt": "2026-10-05T18:42:28+00:00",
-    "source": "olostep-search-index",
-    "submitted": false
-  },
   {
     "id": "7512911399573180416",
     "url": "https://www.linkedin.com/posts/muhammad-danish-khattak_devweekends-dsa-datastructures-activity-7512911399573180416-ZczL",
@@ -580,23 +562,6 @@
     "source": "olostep-search-index",
     "submitted": false
   },
-  {
-    "id": "7488018612931252224",
-    "url": "https://www.linkedin.com/posts/hussain-jamal-b5a76531a_looplearn-mern-backenddevelopment-activity-7488018612931252224-fQzw",
-    "author": "Hussain Jamal",
-    "handle": "hussain-jamal-b5a76531a",
-    "title": "Looplearn · Mern · Backenddevelopment",
-    "excerpt": "",
-    "topic": "engineering",
-    "tags": [
-      "looplearn",
-      "mern",
-      "backenddevelopment"
-    ],
-    "postedAt": "2026-07-28T23:52:37+00:00",
-    "source": "olostep-search-index",
-    "submitted": false
-  },
   {
     "id": "7487348659353800704",
     "url": "https://www.linkedin.com/posts/devweekends_devweekends-fellowship2026-dsa-activity-7487348659353800704-WMzr",
@@ -699,24 +664,6 @@
     "source": "olostep-search-index",
     "submitted": false
   },
-  {
-    "id": "7480099269060993024",
-    "url": "https://www.linkedin.com/posts/haad-majeed_httpslnkdine4dqea-b-just-a-usual-day-activity-7480099269060993024-AQ33",
-    "author": "Haad Majeed",
-    "handle": "haad-majeed",
-    "title": "Httpslnkdine4Dqea · Just · Usual",
-    "excerpt": "",
-    "topic": "engineering",
-    "tags": [
-      "httpslnkdine4dqea",
-      "just",
-      "usual",
-      "day"
-    ],
-    "postedAt": "2026-07-07T03:23:59+00:00",
-    "source": "olostep-search-index",
-    "submitted": false
-  },
   {
     "id": "7479818183089078272",
     "url": "https://www.linkedin.com/posts/devweekends_data-structure-algorithm-dsa-linked-activity-7479818183089078272-r5Av",
diff --git a/lib/linkedin-feed.ts b/lib/linkedin-feed.ts
index d90da65..b1bb6a0 100644
--- a/lib/linkedin-feed.ts
+++ b/lib/linkedin-feed.ts
@@ -1,16 +1,16 @@
 /**
  * Server-side logic for the /feed LinkedIn wall: validating LinkedIn post URLs,
- * discovering #DevWeekends posts through the Olostep Search API, and reading and
- * writing them in MongoDB.
+ * discovering #DevWeekends posts through the Olostep Search API, checking them
+ * against LinkedIn's public embed, and reading and writing them in MongoDB.
  *
- * Only public search results are used: no LinkedIn login, private API or
- * scraping. Excerpts are search snippets, not full post content.
+ * Only public pages are used: no LinkedIn login or private API. Excerpts are
+ * search snippets, not full post content.
  */
 import connectDB from '@/lib/db'
 import { FeedCollectorState } from '@/models/FeedCollectorState'
 import { LinkedInPost, type LinkedInPostSource, type LinkedInPostStatus } from '@/models/LinkedInPost'
 import starterPosts from '@/data/linkedin-posts.json'
-import { OFFICIAL_HANDLES, type FeedPost } from './linkedin-feed-shared'
+import { OFFICIAL_HANDLES, linkedInEmbedUrl, type FeedPost } from './linkedin-feed-shared'
 
 const ACTIVITY_RE = /(?:^|[-_/])activity-(\d{16,21})(?:-|$)/
 
@@ -37,6 +37,13 @@ const KNOWN_AUTHORS: Record<string, string> = {
 /** Results per Olostep search; 25 is the API maximum */
 const RESULTS_PER_SEARCH = 25
 const SEARCHES_IN_PARALLEL = 8
+/** LinkedIn pages fetched at once when checking posts */
+const CHECKS_IN_PARALLEL = 6
+/** Most new posts one collection run checks; the rest wait in "Pending review" */
+const MAX_CHECKS_PER_RUN = 120
+
+export const HIDDEN_NO_MENTION = 'The post text does not mention Dev Weekends'
+export const HIDDEN_GONE = 'The post was deleted on LinkedIn'
 
 /** Searches about programs, topics and years. Member searches are added on top (see searchQueries). */
 const TOPIC_SEARCHES = [
@@ -148,6 +155,13 @@ interface PostInput {
   source: LinkedInPostSource
 }
 
+/** A post ready to insert, with the status (and check result) it should get */
+interface NewPost extends PostInput {
+  status: LinkedInPostStatus
+  checkedAt?: Date
+  hiddenReason?: string
+}
+
 /** Builds a post record from a LinkedIn post URL and optional search title and snippet */
 export function makePost(url: string, title = '', description = '', source: LinkedInPostSource): PostInput | null {
   const parsed = canonicalize(url)
@@ -188,7 +202,11 @@ interface OlostepLink {
   snippet?: string
 }
 
-/** Search engines can surface unrelated posts, so keep only results that clearly mention Dev Weekends */
+/**
+ * Cheap first filter on search results. Snippets can quote text from around the
+ * post (comments, the author's headline, "more posts" boxes), so a match here is
+ * only a lead; checkPost decides.
+ */
 function mentionsDevWeekends(hit: OlostepLink) {
   const link = String(hit.url ?? hit.link ?? '').toLowerCase()
   const text = [hit.title, hit.description, hit.snippet].join(' ').toLowerCase()
@@ -213,6 +231,72 @@ async function searchOlostep(apiKey: string, query: string): Promise<OlostepLink
   return data?.result?.links ?? []
 }
 
+const MENTION_RE = /dev\s*-?\s*weekends/i
+const POST_TEXT_RE = /class="[^"]*attributed-text-segment-list__content[^"]*"[^>]*>([\s\S]*?)<\/p>/g
+const META_TEXT_RE = /<meta (?:property|name)="(?:og|twitter):(?:title|description)" content="([^"]*)"/g
+
+function decodeEntities(text: string) {
+  return text
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec)))
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+}
+
+/**
+ * The post's own words from its embed page: the post body and the title and
+ * description LinkedIn puts in the page meta. Leaves out the author's headline
+ * and everything else around the post. Empty when the page has no post on it.
+ */
+export function postTextFromEmbed(page: string) {
+  const parts = [...page.matchAll(POST_TEXT_RE), ...page.matchAll(META_TEXT_RE)].map((match) => match[1])
+  return decodeEntities(parts.join(' ').replace(/<[^>]+>/g, ' ')).replace(/\s+/g, ' ').trim()
+}
+
+/**
+ * - `mentions`: the post's own text mentions Dev Weekends (or it's the official page)
+ * - `no-mention`: the post loaded and doesn't mention Dev Weekends
+ * - `gone`: LinkedIn says the post no longer exists
+ * - `unknown`: LinkedIn didn't show the post (rate limit, login wall, network error), so nothing can be said
+ */
+export type PostCheck = 'mentions' | 'no-mention' | 'gone' | 'unknown'
+
+/** Checks one post against its public LinkedIn embed, the same page /feed shows */
+export async function checkPost(activityId: string, handle: string): Promise<PostCheck> {
+  if (OFFICIAL_HANDLES.has(handle)) return 'mentions'
+  let response: Response
+  try {
+    response = await fetch(linkedInEmbedUrl(activityId), {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36',
+        'Accept-Language': 'en-US,en;q=0.9',
+      },
+      signal: AbortSignal.timeout(20_000),
+      cache: 'no-store',
+    })
+  } catch {
+    return 'unknown'
+  }
+  if (response.status === 404 || response.status === 410) return 'gone'
+  if (!response.ok) return 'unknown'
+  const text = postTextFromEmbed(await response.text().catch(() => ''))
+  if (!text) return 'unknown'
+  return MENTION_RE.test(text) ? 'mentions' : 'no-mention'
+}
+
+/** Checks posts a few at a time; results line up with the input */
+async function checkPosts(posts: { activityId: string; handle: string }[]) {
+  const results: PostCheck[] = []
+  for (let i = 0; i < posts.length; i += CHECKS_IN_PARALLEL) {
+    const batch = posts.slice(i, i + CHECKS_IN_PARALLEL)
+    results.push(...(await Promise.all(batch.map((post) => checkPost(post.activityId, post.handle)))))
+  }
+  return results
+}
+
 /**
  * Runs the next `maxQueries` searches from the search list and saves new posts.
  * Remembers where it stopped, so consecutive runs (daily cron, admin buttons)
@@ -248,25 +332,134 @@ export async function collectFromOlostep(apiKey: string, maxQueries = 5) {
     )
   }
 
-  const posts = results
+  const found = results
     .flatMap((r) => (r.status === 'fulfilled' ? r.value : []))
     .filter(mentionsDevWeekends)
     .map((hit) =>
       makePost(hit.url ?? hit.link ?? '', hit.title, hit.description ?? hit.snippet ?? '', 'olostep-search-index')
     )
     .filter((post): post is PostInput => post !== null)
+  // The same post often comes back from several searches; keep the copy with a snippet
+  const posts = [
+    ...found.reduce((byId, post) => {
+      if (!byId.get(post.activityId)?.excerpt) byId.set(post.activityId, post)
+      return byId
+    }, new Map<string, PostInput>()).values(),
+  ]
+
+  await connectDB()
+  const known = new Set<string>(
+    await LinkedInPost.distinct('activityId', { activityId: { $in: posts.map((post) => post.activityId) } })
+  )
+  const fresh = posts.filter((post) => !known.has(post.activityId))
+
+  // A search hit is only a lead: a post goes live when its own text on LinkedIn mentions Dev Weekends
+  const toCheck = fresh.slice(0, MAX_CHECKS_PER_RUN)
+  const checks = await checkPosts(toCheck)
+  const now = new Date()
+  const verdicts = new Map(toCheck.map((post, i) => [post.activityId, checks[i]]))
+  const newPosts: NewPost[] = []
+  let skipped = 0
+  for (const post of fresh) {
+    const check = verdicts.get(post.activityId) ?? 'unknown'
+    if (check === 'mentions') newPosts.push({ ...post, status: 'approved', checkedAt: now })
+    // Kept as hidden so the same post isn't fetched again on every search
+    else if (check === 'no-mention') newPosts.push({ ...post, status: 'hidden', checkedAt: now, hiddenReason: HIDDEN_NO_MENTION })
+    else if (check === 'gone') skipped++
+    // Couldn't check it: an admin decides
+    else newPosts.push({ ...post, status: 'pending' })
+  }
 
-  // Search results are trusted enough to publish directly; visitor submissions are not
-  const saved = await savePosts(posts, 'approved')
+  const enriched = await enrichExcerpts(posts.filter((post) => known.has(post.activityId)))
+  await LinkedInPost.insertMany(newPosts, { ordered: false }).catch(ignoreDuplicates)
+  const countWith = (status: LinkedInPostStatus) => newPosts.filter((post) => post.status === status).length
   return {
     queries: queries.length,
     failedQueries: failed,
     candidates: posts.length,
-    ...saved,
+    added: countWith('approved'),
+    rejected: countWith('hidden') + skipped,
+    needsReview: countWith('pending'),
+    enriched,
     searchListSize: allQueries.length,
   }
 }
 
+/** Another request may have inserted the same post in the meantime; that's fine */
+function ignoreDuplicates(error: { code?: number; writeErrors?: { code?: number }[] }) {
+  const errors = error.writeErrors ?? [error]
+  if (!errors.every((e) => e.code === 11000)) throw error
+}
+
+/** Fills in missing excerpts on posts already in the database */
+async function enrichExcerpts(posts: PostInput[]) {
+  let enriched = 0
+  for (const post of posts) {
+    if (!post.excerpt) continue
+    const result = await LinkedInPost.updateOne(
+      { activityId: post.activityId, excerpt: { $in: ['', null] } },
+      { excerpt: post.excerpt }
+    )
+    enriched += result.modifiedCount
+  }
+  return enriched
+}
+
+/** Live posts from the starter list and search that haven't been checked against LinkedIn yet */
+const UNCHECKED_LIVE = {
+  status: 'approved',
+  source: { $in: ['seed', 'olostep-search-index'] },
+  checkedAt: { $exists: false },
+}
+
+/**
+ * Checks the next `limit` live posts after `after` (a post _id) against LinkedIn
+ * and hides the ones whose text doesn't mention Dev Weekends or that were
+ * deleted. Hiding is reversible from the admin. Posts LinkedIn wouldn't show are
+ * left alone. Admin-added and approved posts are never touched.
+ */
+export async function recheckLivePosts(after: string | undefined, limit = 40) {
+  await connectDB()
+  const filter = after ? { ...UNCHECKED_LIVE, _id: { $gt: after } } : UNCHECKED_LIVE
+  const posts = await LinkedInPost.find(filter)
+    .sort({ _id: 1 })
+    .limit(limit)
+    .select('_id activityId handle author url')
+    .lean<{ _id: { toString(): string }; activityId: string; handle: string; author: string; url: string }[]>()
+  const checks = await checkPosts(posts)
+  const now = new Date()
+
+  const hidden: { author: string; url: string; reason: string }[] = []
+  let unknown = 0
+  for (const [i, post] of posts.entries()) {
+    const check = checks[i]
+    if (check === 'unknown') {
+      unknown++
+      continue
+    }
+    if (check === 'mentions') {
+      await LinkedInPost.updateOne({ _id: post._id }, { checkedAt: now })
+      continue
+    }
+    const reason = check === 'gone' ? HIDDEN_GONE : HIDDEN_NO_MENTION
+    // Only if it's still live and unchecked, so an admin's decision in the meantime wins
+    const result = await LinkedInPost.updateOne(
+      { _id: post._id, status: 'approved', checkedAt: { $exists: false } },
+      { status: 'hidden', hiddenReason: reason, checkedAt: now }
+    )
+    if (result.modifiedCount) hidden.push({ author: post.author, url: post.url, reason })
+  }
+
+  const last = posts.at(-1)?._id.toString()
+  return {
+    checked: posts.length,
+    hidden,
+    unknown,
+    lastId: last,
+    remaining: last ? await LinkedInPost.countDocuments({ ...UNCHECKED_LIVE, _id: { $gt: last } }) : 0,
+  }
+}
+
 /** Adds LinkedIn post links pasted by an admin. Admins are trusted, so the posts go live straight away. */
 export async function importPostUrls(text: string) {
   const urls = text.split(/[\s,]+/).filter(Boolean)
@@ -274,12 +467,15 @@ export async function importPostUrls(text: string) {
     .map((url) => makePost(url, '', '', 'admin-import'))
     .filter((post): post is PostInput => post !== null)
   const unique = [...new Map(posts.map((post) => [post.activityId, post])).values()]
-  const saved = await savePosts(unique, 'approved')
+  const saved = await savePosts(unique, 'approved', new Date())
   return { links: urls.length, invalid: urls.length - posts.length, ...saved, alreadyThere: unique.length - saved.added }
 }
 
-/** Inserts new posts and fills in missing excerpts. Never overwrites a post's status or curated fields. */
-export async function savePosts(posts: PostInput[], status: LinkedInPostStatus) {
+/**
+ * Inserts new posts and fills in missing excerpts. Never overwrites a post's status or curated fields.
+ * Pass `checkedAt` when a person chose these posts, so the automatic check leaves them alone.
+ */
+export async function savePosts(posts: PostInput[], status: LinkedInPostStatus, checkedAt?: Date) {
   await connectDB()
   let added = 0
   let enriched = 0
@@ -293,7 +489,7 @@ export async function savePosts(posts: PostInput[], status: LinkedInPostStatus)
       }
       continue
     }
-    await LinkedInPost.create({ ...post, status })
+    await LinkedInPost.create(checkedAt ? { ...post, status, checkedAt } : { ...post, status })
     added++
   }
   return { added, enriched }
diff --git a/models/LinkedInPost.ts b/models/LinkedInPost.ts
index 4d44fd6..fecd2cb 100644
--- a/models/LinkedInPost.ts
+++ b/models/LinkedInPost.ts
@@ -18,6 +18,10 @@ export interface ILinkedInPost extends Document {
   postedAt?: Date;
   source: LinkedInPostSource;
   status: LinkedInPostStatus;
+  /** When the post's own LinkedIn text was checked for a Dev Weekends mention, or an admin approved it by hand */
+  checkedAt?: Date;
+  /** Why the post was hidden automatically, shown in the admin */
+  hiddenReason: string;
   createdAt: Date;
   updatedAt: Date;
 }
@@ -44,6 +48,8 @@ const LinkedInPostSchema = new Schema<ILinkedInPost>(
       default: 'pending',
       index: true,
     },
+    checkedAt: { type: Date },
+    hiddenReason: { type: String, trim: true, default: '' },
   },
   { timestamps: true }
 );