diff --git a/migrations/0007_post_removal.sql b/migrations/0007_post_removal.sql
new file mode 100644
index 0000000..b5971a7
--- /dev/null
+++ b/migrations/0007_post_removal.sql
@@ -0,0 +1,20 @@
+-- Soft-delete column for moderator-removed posts. Gets stamped by
+-- `markPostRemoved` when a community creator clicks "Remove post" in
+-- the community page's popover menu. All feed queries
+-- (`getRecentPostsForCommunity`, `getCombinedFeed`, `getPostByUri`,
+-- and the metric-refresh picker in `getPostsDueForRefresh`) filter on
+-- `removed_at IS NULL`, so a removed post vanishes from every surface
+-- immediately without touching indexes.
+--
+-- Important: `hasSubmission` is deliberately NOT updated to filter
+-- removed rows. Keeping removed entries visible to the dedup check
+-- means a submitter can't bypass a mod decision by re-DMing /
+-- re-mentioning / re-submitting the same post — the unique
+-- `(community_did, quoted_post_uri)` index still matches.
+--
+-- This column is orthogonal to `missing_since`. That one tracks
+-- "underlying bsky post was deleted upstream" and feeds the
+-- sweepDeletedPosts grace-period cleanup. `removed_at` tracks
+-- "community mod actively removed this." A post can legitimately
+-- have both stamped.
+ALTER TABLE posts ADD COLUMN removed_at TEXT;
diff --git a/src/lib/reddit/RedditPostCard.svelte b/src/lib/reddit/RedditPostCard.svelte
index 3fed44c..da82626 100644
--- a/src/lib/reddit/RedditPostCard.svelte
+++ b/src/lib/reddit/RedditPostCard.svelte
@@ -1,8 +1,8 @@
 <script lang="ts">
 	/* eslint-disable svelte/no-navigation-without-resolve */
 	import { goto } from '$app/navigation';
-	import { Avatar } from '@foxui/core';
-	import { Heart, MessageCircle, Repeat2 } from '@lucide/svelte';
+	import { Avatar, Button, Popover } from '@foxui/core';
+	import { Ellipsis, Heart, MessageCircle, Repeat2, Trash2 } from '@lucide/svelte';
 	import { wireEmbedClicks } from '$lib/components/embed';
 	import { blueskyPostToPostData, numberToHumanReadable } from '$lib/components';
 	import { Post } from '$lib/components';
@@ -145,15 +145,45 @@
 		accentColor: accentColorProp,
 		/** Resolved profile of the user who submitted this post via DM.
 		  * Caller is responsible for fetching the handle by `row.author_did`. */
-		submitter
+		submitter,
+		/** When true, the card renders a popover "more actions" menu
+		  * with a "Remove post" action. The parent is responsible for
+		  * actually doing the removal via the `onRemove` callback and
+		  * for gating `canModerate` on whatever moderator rule applies
+		  * (currently `user.did === community.creator`). */
+		canModerate = false,
+		/** Called when the mod clicks "Remove post" in the popover.
+		  * The parent typically calls the `removePost` remote command
+		  * and then removes the row from its local state. */
+		onRemove
 	}: {
 		row: CardRow;
 		quoted?: PostView | null;
 		showCommunity?: boolean;
 		accentColor?: string | null;
 		submitter?: { handle: string; displayName: string | null } | null;
+		canModerate?: boolean;
+		onRemove?: () => Promise<void> | void;
 	} = $props();
 
+	// Popover + remove-in-flight state. Local to each card instance
+	// so opening the menu on one post doesn't affect the others.
+	let menuOpen = $state(false);
+	let removeBusy = $state(false);
+
+	async function handleRemoveClick() {
+		if (!onRemove || removeBusy) return;
+		removeBusy = true;
+		menuOpen = false;
+		try {
+			await onRemove();
+		} catch (err) {
+			console.error('[RedditPostCard] remove failed', err);
+		} finally {
+			removeBusy = false;
+		}
+	}
+
 	const communityHandle = $derived(
 		'community_handle' in row ? (row as PostWithCommunity).community_handle : undefined
 	);
@@ -308,6 +338,35 @@
 				@{submitter.handle}
 			</a>
 		{/if}
+		{#if canModerate && onRemove}
+			<div class="ml-auto">
+				<Popover bind:open={menuOpen} side="bottom">
+					{#snippet child({ props })}
+						<Button
+							{...props}
+							variant="ghost"
+							size="iconSm"
+							aria-label="Post actions"
+							class="-my-1 -mr-1"
+						>
+							<Ellipsis size={14} />
+						</Button>
+					{/snippet}
+					<div class="flex min-w-32 flex-col">
+						<Button
+							variant="ghost"
+							size="sm"
+							onclick={handleRemoveClick}
+							disabled={removeBusy}
+							class="justify-start gap-2"
+						>
+							<Trash2 size={10} />
+							{removeBusy ? 'Removing…' : 'Remove post'}
+						</Button>
+					</div>
+				</Popover>
+			</div>
+		{/if}
 	</div>
 
 	{#if row.title}
diff --git a/src/lib/reddit/bot.ts b/src/lib/reddit/bot.ts
index 6ff338e..5e0ac38 100644
--- a/src/lib/reddit/bot.ts
+++ b/src/lib/reddit/bot.ts
@@ -21,6 +21,7 @@ import {
 	insertCommunity,
 	insertPost,
 	listCommunities,
+	markPostRemoved,
 	saveJetstreamCursor,
 	updateCommunityMentionsSeenAt,
 	updateCommunityProfile,
@@ -1580,6 +1581,61 @@ function parseCommunityRecordUri(
 	return { collection: m[1], rkey: m[2] };
 }
 
+/**
+ * Best-effort delete of a community-account wrapper record (quote
+ * post or repost) from the community's PDS via DPoP. For quote posts
+ * (`app.bsky.feed.post`), also deletes the paired threadgate at the
+ * same rkey (see `createSubmissionPost`).
+ *
+ * Shared between the cron's `sweepDeletedPosts` and the mod-driven
+ * `removeCommunityPost` — both paths need exactly the same sequence:
+ * parse URI → deleteRecord(wrapper) → deleteRecord(threadgate if
+ * quote). Errors are logged but not thrown so callers can always
+ * fall through to the D1-side bookkeeping; leaving a dangling wrapper
+ * on bsky is the lesser evil compared to retrying forever on a row
+ * that's no longer user-visible anyway.
+ *
+ * Returns `false` only when the URI is unparseable (caller should
+ * treat the row as nominally processed and drop it from D1). Any
+ * actual bsky-side failure still returns `true`.
+ */
+async function deleteCommunityWrapperRecord(
+	client: WelcomeMatClient,
+	communityHandle: string,
+	uri: string,
+	logPrefix: string
+): Promise<boolean> {
+	const parsed = parseCommunityRecordUri(uri);
+	if (!parsed) {
+		console.error(`[${logPrefix}] unparseable uri`, uri);
+		return false;
+	}
+	const { collection, rkey } = parsed;
+
+	// Delete the wrapper record (quote post or repost).
+	try {
+		await client.deleteRecord(collection, rkey);
+	} catch (e) {
+		console.error(
+			`[${logPrefix}] deleteRecord(${collection}/${rkey}) on ${communityHandle} failed`,
+			e
+		);
+		// Fall through — caller still proceeds with D1 bookkeeping.
+	}
+
+	// Quote posts carry a paired threadgate at the same rkey. Reposts
+	// don't. Silent on failure — probably already gone or never existed.
+	if (collection === 'app.bsky.feed.post') {
+		try {
+			await client.deleteRecord('app.bsky.feed.threadgate', rkey);
+		} catch {
+			/* non-fatal */
+		}
+	}
+
+	return true;
+}
+
 /**
  * Grace period between "first tick we saw the post missing from the
  * appview" and actually deleting it. Short enough that users don't
@@ -1659,37 +1715,17 @@ export async function sweepDeletedPosts(
 		}
 
 		for (const uri of uris) {
-			const parsed = parseCommunityRecordUri(uri);
-			if (!parsed) {
-				console.error('[sweepDeletedPosts] unparseable uri, dropping', uri);
-				drainedFromD1.push(uri);
-				deleted++;
-				continue;
-			}
-			const { collection, rkey } = parsed;
-
-			// Delete the wrapper record (quote post or repost).
-			try {
-				await client.deleteRecord(collection, rkey);
-			} catch (e) {
-				console.error(
-					`[sweepDeletedPosts] deleteRecord(${collection}/${rkey}) on ${communityRow.handle} failed`,
-					e
-				);
-				// Fall through — we still drop the D1 row below.
-			}
-
-			// Quote posts carry a paired threadgate at the same rkey
-			// (see `createSubmissionPost`). Reposts don't. Non-fatal.
-			if (collection === 'app.bsky.feed.post') {
-				try {
-					await client.deleteRecord('app.bsky.feed.threadgate', rkey);
-				} catch {
-					// Probably already gone or never existed (pre-threadgate
-					// rows). Not worth logging at error level.
-				}
-			}
-
+			await deleteCommunityWrapperRecord(
+				client,
+				communityRow.handle,
+				uri,
+				'sweepDeletedPosts'
+			);
+			// Even unparseable URIs get dropped from D1 — same as the
+			// pre-refactor behavior. The helper logs those with its
+			// `logPrefix`, and returning `false` just signals "URI
+			// parse failed." There's nothing useful the sweep can do
+			// differently in that case.
 			drainedFromD1.push(uri);
 			deleted++;
 		}
@@ -1707,6 +1743,48 @@ export async function sweepDeletedPosts(
 	return deleted;
 }
 
+// -------------------------------------------------------------------------
+// Moderator-driven post removal
+// -------------------------------------------------------------------------
+
+/**
+ * Remove a single post from a community at the direction of a
+ * community moderator (currently only the creator — gate lives in
+ * the `removePost` remote command in `communities.remote.ts`).
+ *
+ * Flow:
+ *   1. Load the community's DPoP client.
+ *   2. Delete the wrapper record (and threadgate for quotes) from
+ *      the community account's PDS via the shared helper. Errors
+ *      are logged but not fatal.
+ *   3. Stamp `removed_at` on the D1 row. The soft-delete keeps the
+ *      row visible to `hasSubmission` so the post can't be
+ *      resubmitted via DM / mention / web while also dropping it
+ *      out of every feed surface via the `removed_at IS NULL`
+ *      filters in `db.ts`.
+ *
+ * This is orthogonal to `sweepDeletedPosts` — that path handles
+ * "underlying bsky post was taken down upstream" via `missing_since`
+ * and hard-deletes the D1 row after a grace period. Mod removals
+ * stay in D1 forever (soft delete) on purpose: persistence gives us
+ * a free audit trail and blocks resubmission indefinitely.
+ */
+export async function removeCommunityPost(
+	env: App.Platform['env'],
+	db: D1Database,
+	communityRow: CommunityRow,
+	postUri: string
+): Promise<void> {
+	const client = await loadClient(env, communityRow);
+	await deleteCommunityWrapperRecord(
+		client,
+		communityRow.handle,
+		postUri,
+		'removeCommunityPost'
+	);
+	await markPostRemoved(db, postUri);
+}
+
 // -------------------------------------------------------------------------
 // Top-level cron entry point
 // -------------------------------------------------------------------------
diff --git a/src/lib/reddit/db.ts b/src/lib/reddit/db.ts
index 5240700..926f6e4 100644
--- a/src/lib/reddit/db.ts
+++ b/src/lib/reddit/db.ts
@@ -59,6 +59,15 @@ export type PostRow = {
 	 * get cleaned up.
 	 */
 	missing_since: string | null;
+	/**
+	 * ISO-8601 timestamp set by `markPostRemoved` when a community
+	 * creator actively removes a post via the community page's
+	 * popover menu. All feed queries filter on `removed_at IS NULL`,
+	 * so a removed row disappears from every surface immediately.
+	 * `hasSubmission` deliberately does NOT filter removed rows —
+	 * keeping them dedup-visible blocks re-submission attempts.
+	 */
+	removed_at: string | null;
 };
 
 export type PostWithCommunity = PostRow & {
@@ -175,6 +184,24 @@ export async function updateCommunityProfile(
 		.run();
 }
 
+/**
+ * Mark a post as removed by a community moderator. Stamps
+ * `removed_at = datetime('now')` and leaves every other column
+ * alone. Idempotent: re-running on an already-removed row is a
+ * no-op (the timestamp gets bumped but no extra state changes).
+ *
+ * Filters in the feed queries (`getRecentPostsForCommunity`,
+ * `getCombinedFeed`, `getPostsDueForRefresh`) hide the row
+ * immediately; `hasSubmission` still sees it so re-submission
+ * attempts are blocked by the existing dedup.
+ */
+export async function markPostRemoved(db: D1Database, uri: string): Promise<void> {
+	await db
+		.prepare("UPDATE posts SET removed_at = datetime('now') WHERE uri = ?")
+		.bind(uri)
+		.run();
+}
+
 /**
  * Advance the mention-notifications cursor. The cron tick passes the
  * latest `indexedAt` it observed (or `now` on first-run initialization);
@@ -210,7 +237,7 @@ export async function hasSubmission(
 
 export async function insertPost(
 	db: D1Database,
-	row: Omit<PostRow, 'last_refreshed_at' | 'missing_since'>
+	row: Omit<PostRow, 'last_refreshed_at' | 'missing_since' | 'removed_at'>
 ): Promise<boolean> {
 	try {
 		await db
@@ -314,10 +341,13 @@ export async function getRecentPostsForCommunity(
 	offset = 0
 ): Promise<PostWithCommunity[]> {
 	const { where, order } = sortClauses(sort);
-	// Hide rows currently flagged missing — between the first refresh
-	// tick that detects the underlying bsky post is gone and the sweep
-	// cleaning them up (grace period), we don't want users to see
-	// `(quoted post unavailable)` placeholders in the feed.
+	// Filter out:
+	//   - `missing_since IS NOT NULL` → the underlying bsky post is
+	//     gone/taken-down, grace-period sweep pending. Don't surface
+	//     "(quoted post unavailable)" placeholders.
+	//   - `removed_at IS NOT NULL` → a community mod removed this post.
+	//     Invisible in every feed but still visible to `hasSubmission`
+	//     so the submitter can't re-add it.
 	const res = await db
 		.prepare(
 			`SELECT p.*, c.handle AS community_handle, c.display_name AS community_display_name, c.avatar AS community_avatar, c.accent_color AS community_accent_color
@@ -325,6 +355,7 @@ export async function getRecentPostsForCommunity(
 			 JOIN communities c ON c.did = p.community_did
 			 WHERE p.community_did = ?
 			   AND p.missing_since IS NULL
+			   AND p.removed_at IS NULL
 			 ${where}
 			 ORDER BY ${order}
 			 LIMIT ? OFFSET ?`
@@ -339,6 +370,14 @@ export async function getRecentPostsForCommunity(
  * Used by the post detail page to show which community surfaced the post
  * (plus its title / timestamp / accent color).
  */
+/**
+ * Look up a single post by URI, JOINed with community metadata.
+ * Does NOT filter on `removed_at` — the `removePost` remote command
+ * uses this helper to look up posts it's about to mark removed,
+ * so filtering would hide the row it needs to act on. Callers that
+ * render to end users should check `removed_at IS NULL` themselves
+ * if they care (the post detail page is the one place this matters).
+ */
 export async function getPostByUri(
 	db: D1Database,
 	uri: string
@@ -363,18 +402,20 @@ export async function getCombinedFeed(
 	offset = 0
 ): Promise<PostWithCommunity[]> {
 	const { where, order } = sortClauses(sort);
-	// Same rationale as `getRecentPostsForCommunity`: drop rows whose
-	// underlying post is flagged as gone. `sortClauses` returns a
-	// fragment starting with `AND` (written for the community-scoped
-	// query's `WHERE p.community_did = ?` base). For the home feed we
-	// anchor on the missing_since filter so every sort's fragment
-	// stays consistent as an `AND`-prefixed addition.
+	// Same filter rationale as `getRecentPostsForCommunity`: drop
+	// rows flagged as missing (upstream post gone) OR as removed
+	// (community mod action). `sortClauses` returns a fragment
+	// starting with `AND` (written for the community-scoped query's
+	// `WHERE p.community_did = ?` base), so the missing_since +
+	// removed_at filters here provide the base `WHERE` the AND can
+	// attach to.
 	const res = await db
 		.prepare(
 			`SELECT p.*, c.handle AS community_handle, c.display_name AS community_display_name, c.avatar AS community_avatar, c.accent_color AS community_accent_color
 			 FROM posts p
 			 JOIN communities c ON c.did = p.community_did
 			 WHERE p.missing_since IS NULL
+			   AND p.removed_at IS NULL
 			 ${where}
 			 ORDER BY ${order}
 			 LIMIT ? OFFSET ?`
@@ -456,11 +497,14 @@ export async function getPostsDueForRefresh(
 					) AS rank_in_community
 				FROM posts
 				WHERE
-					(julianday('now') - julianday(indexed_at)) * 24 < 1
-					OR ((julianday('now') - julianday(indexed_at)) * 24 < 12 AND (julianday('now') - julianday(last_refreshed_at)) * 1440 >= 5)
-					OR ((julianday('now') - julianday(indexed_at)) * 24 < 24 AND (julianday('now') - julianday(last_refreshed_at)) * 1440 >= 10)
-					OR ((julianday('now') - julianday(indexed_at)) < 7 AND (julianday('now') - julianday(last_refreshed_at)) * 24 >= 1)
-					OR ((julianday('now') - julianday(indexed_at)) >= 7 AND (julianday('now') - julianday(last_refreshed_at)) >= 1)
+					removed_at IS NULL
+					AND (
+						(julianday('now') - julianday(indexed_at)) * 24 < 1
+						OR ((julianday('now') - julianday(indexed_at)) * 24 < 12 AND (julianday('now') - julianday(last_refreshed_at)) * 1440 >= 5)
+						OR ((julianday('now') - julianday(indexed_at)) * 24 < 24 AND (julianday('now') - julianday(last_refreshed_at)) * 1440 >= 10)
+						OR ((julianday('now') - julianday(indexed_at)) < 7 AND (julianday('now') - julianday(last_refreshed_at)) * 24 >= 1)
+						OR ((julianday('now') - julianday(indexed_at)) >= 7 AND (julianday('now') - julianday(last_refreshed_at)) >= 1)
+					)
 			)
 			SELECT uri, quoted_post_uri FROM due
 			ORDER BY rank_in_community ASC, last_refreshed_at ASC
diff --git a/src/lib/reddit/server/communities.remote.ts b/src/lib/reddit/server/communities.remote.ts
index f1e7626..a9eb97b 100644
--- a/src/lib/reddit/server/communities.remote.ts
+++ b/src/lib/reddit/server/communities.remote.ts
@@ -16,7 +16,8 @@ import {
 	updateCommunity,
 	fetchCommunityConfig,
 	checkCanSubmit,
-	refreshCommunityCache
+	refreshCommunityCache,
+	removeCommunityPost
 } from '../bot';
 import { getCachedSortedList, FEED_CACHE_LIMIT } from '../feed-cache';
 import { parseListUri } from '../list-uri';
@@ -356,3 +357,62 @@ export const editCommunity = command(
 		return { ok: true, did: row.did, handle: row.handle };
 	}
 );
+
+/**
+ * Mod-driven removal of a single post from a community. Currently
+ * only the community creator is allowed to remove — the gate lives
+ * on `garden.atmo.community/self`'s `creator` field (same field
+ * that gates `editCommunity`). Multi-mod support later would extend
+ * the record with a `moderators[]` field and relax this check.
+ *
+ * The post is soft-deleted: `markPostRemoved` stamps the D1 row's
+ * `removed_at`, and the bsky wrapper record is deleted best-effort
+ * from the community account's PDS. See `removeCommunityPost` in
+ * `bot.ts` for the full flow, and `0007_post_removal.sql` for the
+ * rationale behind keeping the row in D1 after removal (dedup
+ * protection against resubmission).
+ */
+export const removePost = command(
+	v.object({ uri: v.pipe(v.string(), v.maxLength(512)) }),
+	async (input) => {
+		const { platform, locals } = getRequestEvent();
+		const env = platform?.env;
+		if (!env || !env.DB) error(500, 'DB binding unavailable');
+		if (!locals.did) error(401, 'You must be signed in to remove posts');
+
+		// Look up the post first so we fail fast on a bad URI, and
+		// so we can derive the community from it instead of trusting
+		// a caller-provided community handle.
+		const postRow = await getPostByUri(env.DB, input.uri);
+		if (!postRow) error(404, 'Post not found');
+
+		const communityRow = await getCommunityByHandle(
+			env.DB,
+			postRow.community_handle
+		);
+		if (!communityRow) error(404, 'Community not found');
+
+		// Creator-only gate: re-read `garden.atmo.community/self` so
+		// the check always reflects the current on-network state
+		// (in case creator transfer is ever added). Fail closed if
+		// the record has no creator — legacy rows from before we
+		// started writing it can't be moderated via this endpoint.
+		const config = await fetchCommunityConfig(communityRow.pds, communityRow.did);
+		if (!config.creator) {
+			error(403, 'This community has no recorded creator — removal unavailable');
+		}
+		if (config.creator !== locals.did) {
+			error(403, 'Only the community creator can remove posts');
+		}
+
+		try {
+			await removeCommunityPost(env, env.DB, communityRow, input.uri);
+		} catch (e) {
+			const msg = e instanceof Error ? e.message : String(e);
+			console.error('[removePost]', e);
+			error(500, `Remove failed: ${msg}`);
+		}
+
+		return { ok: true };
+	}
+);
diff --git a/src/routes/c/[handle]/+page.svelte b/src/routes/c/[handle]/+page.svelte
index 978be1d..af03a01 100644
--- a/src/routes/c/[handle]/+page.svelte
+++ b/src/routes/c/[handle]/+page.svelte
@@ -5,7 +5,7 @@
 	import { page } from '$app/state';
 	import { Avatar, Button } from '@foxui/core';
 	import { Loader2, Check, UserPlus, Plus, Pencil } from '@lucide/svelte';
-	import { getCommunity, getCommunityPosts } from '$lib/reddit/server/communities.remote';
+	import { getCommunity, getCommunityPosts, removePost } from '$lib/reddit/server/communities.remote';
 	import { getQuotedPosts } from '$lib/reddit/server/quoted-posts.remote';
 	import { followUser, unfollowUser, getProfile, resolveProfiles } from '$lib/atproto/server/feed.remote';
 	import { user } from '$lib/atproto/auth.svelte';
@@ -48,6 +48,14 @@
 	let joinLoading = $state(false);
 	const isFollowing = $derived(followUri !== null);
 
+	// Mod state — currently just the creator. `community.creator`
+	// comes from `garden.atmo.community/self` via the remote's
+	// `fetchCommunityConfig` helper, same source of truth that gates
+	// `editCommunity` + the removePost endpoint.
+	const canModerate = $derived(
+		!!community && !!user.did && community.creator === user.did
+	);
+
 	let submitOpen = $state(false);
 
 	function onSubmitClick() {
@@ -172,6 +180,25 @@
 		loadPosts(community.handle, next);
 	}
 
+	async function handleRemove(uri: string) {
+		// Call the server-side gate + soft-delete. On success, drop
+		// the row from local state so the card disappears immediately
+		// without needing a full reload. Cached quoted-post + submitter
+		// entries can stay — they're keyed on the original bsky URI
+		// and other cards on this page may still reference them.
+		try {
+			await removePost({ uri });
+			posts = posts.filter((p) => p.uri !== uri);
+		} catch (e) {
+			console.error('[community] removePost failed', e);
+			// Surface to the user via a minimal alert for now.
+			// Could upgrade to a toast later if we add one.
+			alert(
+				'Failed to remove post: ' + (e instanceof Error ? e.message : String(e))
+			);
+		}
+	}
+
 	async function onJoinClick() {
 		if (!community) return;
 		if (!user.did) {
@@ -310,6 +337,8 @@
 						accentColor={community.accentColor}
 						submitter={p.author_did ? (submitters[p.author_did] ?? null) : null}
 						showCommunity
+						{canModerate}
+						onRemove={canModerate ? () => handleRemove(p.uri) : undefined}
 					/>
 				{/each}
 			</div>