diff --git a/.changeset/content-list-byline-filter.md b/.changeset/content-list-byline-filter.md
new file mode 100644
index 000000000..e9643ae6f
--- /dev/null
+++ b/.changeset/content-list-byline-filter.md
@@ -0,0 +1,6 @@
+---
+"emdash": patch
+"@emdash-cms/admin": patch
+---
+
+Adds a byline filter to the admin content list. Pick one or more bylines to see entries credited to any of them, or filter to entries with no byline assigned. Bylines inferred from an entry's author are ignored unless you turn on "Include inferred bylines".
diff --git a/packages/admin/src/components/BulkBylineApply.tsx b/packages/admin/src/components/BulkBylineApply.tsx
new file mode 100644
index 000000000..376b83124
--- /dev/null
+++ b/packages/admin/src/components/BulkBylineApply.tsx
@@ -0,0 +1,124 @@
+import { Badge, Button, Checkbox, Input, Popover } from "@cloudflare/kumo";
+import { useLingui } from "@lingui/react/macro";
+import { CaretDown } from "@phosphor-icons/react";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import * as React from "react";
+
+import { fetchBylines } from "../lib/api";
+import { useDebouncedValue } from "../lib/hooks.js";
+
+/** Matches the server's cap on credits per entry. */
+const MAX_SELECTED = 25;
+
+interface BulkBylineApplyProps {
+	/** How many entries the credits will be set on. */
+	count: number;
+	disabled?: boolean;
+	/** Locale the list is showing, so the picker offers matching byline rows. */
+	locale?: string;
+	/** Receives the chosen byline row ids (not translation groups). */
+	onApply: (bylineIds: string[]) => void;
+}
+
+/**
+ * Bulk byline picker for the content list's selection toolbar. The picked
+ * bylines become each selected entry's whole credit set — an entry's existing
+ * credits are replaced, not merged into.
+ */
+export function BulkBylineApply({ count, disabled, locale, onApply }: BulkBylineApplyProps) {
+	const { t } = useLingui();
+	const [open, setOpen] = React.useState(false);
+	const [search, setSearch] = React.useState("");
+	const [selected, setSelected] = React.useState<string[]>([]);
+	const debouncedSearch = useDebouncedValue(search, 300);
+	const trimmedSearch = debouncedSearch.trim();
+
+	const { data, isLoading } = useQuery({
+		queryKey: ["bylines", "bulk-apply", locale ?? null, trimmedSearch],
+		queryFn: () => fetchBylines({ search: trimmedSearch || undefined, locale, limit: 20 }),
+		enabled: open,
+		placeholderData: keepPreviousData,
+	});
+
+	const options = data?.items ?? [];
+	const atLimit = selected.length >= MAX_SELECTED;
+
+	const toggle = (id: string) => {
+		setSelected((prev) => {
+			if (prev.includes(id)) return prev.filter((value) => value !== id);
+			if (prev.length >= MAX_SELECTED) return prev;
+			return [...prev, id];
+		});
+	};
+
+	const apply = () => {
+		if (selected.length === 0) return;
+		onApply(selected);
+		setSelected([]);
+		setSearch("");
+		setOpen(false);
+	};
+
+	return (
+		<Popover open={open} onOpenChange={setOpen}>
+			<Popover.Trigger asChild>
+				<Button size="sm" variant="secondary" disabled={disabled} className="gap-2">
+					{t`Set byline`}
+					<CaretDown className="h-4 w-4 shrink-0" aria-hidden="true" />
+				</Button>
+			</Popover.Trigger>
+
+			<Popover.Content className="w-72 p-2" align="start">
+				<Input
+					size="sm"
+					type="search"
+					aria-label={t`Search bylines`}
+					placeholder={t`Search bylines…`}
+					value={search}
+					onChange={(e) => setSearch(e.target.value)}
+				/>
+
+				<div className="mt-2 max-h-64 overflow-y-auto" role="group" aria-label={t`Bylines`}>
+					{isLoading && <p className="p-2 text-sm text-kumo-subtle">{t`Loading…`}</p>}
+
+					{!isLoading && options.length === 0 && (
+						<p className="p-2 text-sm text-kumo-subtle">{t`No bylines found`}</p>
+					)}
+
+					{options.map((byline) => {
+						const checked = selected.includes(byline.id);
+						return (
+							<div key={byline.id} className="rounded px-2 py-1 hover:bg-kumo-tint/50">
+								<Checkbox
+									checked={checked}
+									disabled={!checked && atLimit}
+									onCheckedChange={() => toggle(byline.id)}
+									label={<span className="text-sm">{byline.displayName}</span>}
+								/>
+							</div>
+						);
+					})}
+
+					{data?.nextCursor && (
+						<p className="p-2 text-sm text-kumo-subtle">{t`Search to narrow the list`}</p>
+					)}
+				</div>
+
+				{atLimit && (
+					<Badge className="mt-2" variant="warning">
+						{t`Up to ${MAX_SELECTED} bylines can be selected`}
+					</Badge>
+				)}
+
+				<div className="mt-2 flex items-center justify-between gap-2 border-t pt-2">
+					<span className="text-xs text-kumo-subtle">
+						{t`Replaces the credits on ${count} entries`}
+					</span>
+					<Button size="sm" disabled={selected.length === 0} onClick={apply}>
+						{t`Apply`}
+					</Button>
+				</div>
+			</Popover.Content>
+		</Popover>
+	);
+}
diff --git a/packages/admin/src/components/BylineFilter.tsx b/packages/admin/src/components/BylineFilter.tsx
new file mode 100644
index 000000000..d1ede2fc7
--- /dev/null
+++ b/packages/admin/src/components/BylineFilter.tsx
@@ -0,0 +1,184 @@
+import { Badge, Button, Checkbox, Input, Popover, Switch } from "@cloudflare/kumo";
+import { useLingui } from "@lingui/react/macro";
+import { CaretDown } from "@phosphor-icons/react";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import * as React from "react";
+
+import { fetchBylines, type BylineSummary } from "../lib/api";
+import { useDebouncedValue } from "../lib/hooks.js";
+
+/**
+ * Byline filter state for the content list.
+ *
+ * `bylineIds` are translation groups, so a selection matches a byline across
+ * every locale it exists in. `none` is exclusive: it matches entries with no
+ * byline rather than a particular one.
+ */
+export interface BylineFilterState {
+	bylineIds: string[];
+	none: boolean;
+	includeInferred: boolean;
+}
+
+export const EMPTY_BYLINE_FILTER: BylineFilterState = {
+	bylineIds: [],
+	none: false,
+	includeInferred: false,
+};
+
+export function isBylineFilterActive(filter: BylineFilterState): boolean {
+	return filter.none || filter.bylineIds.length > 0;
+}
+
+/** Server-side cap on how many bylines one filter may name. */
+const MAX_SELECTED = 25;
+
+/** The junction stores translation groups, so a filter matches every locale. */
+const groupOf = (byline: BylineSummary) => byline.translationGroup ?? byline.id;
+
+interface BylineFilterProps {
+	value: BylineFilterState;
+	onChange: (value: BylineFilterState) => void;
+	/** Locale the list is showing, so the picker offers matching byline rows. */
+	locale?: string;
+}
+
+/**
+ * Multi-select byline filter. Selecting several bylines matches entries
+ * credited to any of them; "No byline" matches entries with no credit at all.
+ *
+ * Bylines are searched server-side rather than listed exhaustively — the
+ * directory can be far longer than one page, and this is the one query in the
+ * feature that isn't index-served.
+ */
+export function BylineFilter({ value, onChange, locale }: BylineFilterProps) {
+	const { t } = useLingui();
+	const [open, setOpen] = React.useState(false);
+	const [search, setSearch] = React.useState("");
+	const debouncedSearch = useDebouncedValue(search, 300);
+	const trimmedSearch = debouncedSearch.trim();
+
+	const { data, isLoading } = useQuery({
+		queryKey: ["bylines", "content-filter", locale ?? null, trimmedSearch],
+		queryFn: () => fetchBylines({ search: trimmedSearch || undefined, locale, limit: 20 }),
+		enabled: open,
+		placeholderData: keepPreviousData,
+	});
+
+	const options = data?.items ?? [];
+
+	// Selected bylines are remembered by group so their names keep rendering
+	// once the search moves on and the rows are no longer in `options`.
+	const [labels, setLabels] = React.useState<Record<string, string>>({});
+	React.useEffect(() => {
+		if (options.length === 0) return;
+		setLabels((prev) => {
+			const next = { ...prev };
+			for (const byline of options) next[groupOf(byline)] = byline.displayName;
+			return next;
+		});
+	}, [options]);
+
+	const toggle = (group: string) => {
+		const selected = value.bylineIds.includes(group);
+		if (!selected && value.bylineIds.length >= MAX_SELECTED) return;
+		onChange({
+			...value,
+			// Picking a byline leaves the "no byline" mode; the two are
+			// mutually exclusive.
+			none: false,
+			bylineIds: selected
+				? value.bylineIds.filter((id) => id !== group)
+				: [...value.bylineIds, group],
+		});
+	};
+
+	const toggleNone = () => {
+		const none = !value.none;
+		onChange({ ...value, none, bylineIds: none ? [] : value.bylineIds });
+	};
+
+	const label = value.none
+		? t`No byline`
+		: value.bylineIds.length === 0
+			? t`All bylines`
+			: value.bylineIds.length === 1
+				? (labels[value.bylineIds[0]!] ?? t`1 byline`)
+				: t`${value.bylineIds.length} bylines`;
+
+	const atLimit = value.bylineIds.length >= MAX_SELECTED;
+
+	return (
+		<Popover open={open} onOpenChange={setOpen}>
+			<Popover.Trigger asChild>
+				<Button variant="secondary" size="sm" aria-label={t`Filter by byline`} className="gap-2">
+					<span className="max-w-[140px] truncate">{label}</span>
+					<CaretDown className="h-4 w-4 shrink-0" aria-hidden="true" />
+				</Button>
+			</Popover.Trigger>
+
+			<Popover.Content className="w-72 p-2" align="start">
+				<Input
+					size="sm"
+					type="search"
+					aria-label={t`Search bylines`}
+					placeholder={t`Search bylines…`}
+					value={search}
+					onChange={(e) => setSearch(e.target.value)}
+				/>
+
+				<div className="mt-2 border-b pb-2">
+					<Checkbox
+						checked={value.none}
+						onCheckedChange={toggleNone}
+						label={t`No byline assigned`}
+					/>
+				</div>
+
+				<div className="mt-2 max-h-64 overflow-y-auto" role="group" aria-label={t`Bylines`}>
+					{isLoading && <p className="p-2 text-sm text-kumo-subtle">{t`Loading…`}</p>}
+
+					{!isLoading && options.length === 0 && (
+						<p className="p-2 text-sm text-kumo-subtle">{t`No bylines found`}</p>
+					)}
+
+					{options.map((byline) => {
+						const group = groupOf(byline);
+						const checked = value.bylineIds.includes(group);
+						return (
+							<div key={byline.id} className="rounded px-2 py-1 hover:bg-kumo-tint/50">
+								<Checkbox
+									checked={checked}
+									disabled={!checked && (atLimit || value.none)}
+									onCheckedChange={() => toggle(group)}
+									label={<span className="text-sm">{byline.displayName}</span>}
+								/>
+							</div>
+						);
+					})}
+
+					{data?.nextCursor && (
+						<p className="p-2 text-sm text-kumo-subtle">{t`Search to narrow the list`}</p>
+					)}
+				</div>
+
+				{atLimit && (
+					<Badge className="mt-2" variant="warning">
+						{t`Up to ${MAX_SELECTED} bylines can be selected`}
+					</Badge>
+				)}
+
+				<div className="mt-2 border-t pt-2">
+					<Switch
+						checked={value.includeInferred}
+						onCheckedChange={(checked) => onChange({ ...value, includeInferred: checked })}
+						label={<span className="text-sm">{t`Include inferred bylines`}</span>}
+					/>
+					<p className="mt-1 text-xs text-kumo-subtle">
+						{t`Also match the byline linked to an entry's author when it has none assigned.`}
+					</p>
+				</div>
+			</Popover.Content>
+		</Popover>
+	);
+}
diff --git a/packages/admin/src/components/ContentList.tsx b/packages/admin/src/components/ContentList.tsx
index 8cecd6b37..d9328816d 100644
--- a/packages/admin/src/components/ContentList.tsx
+++ b/packages/admin/src/components/ContentList.tsx
@@ -32,6 +32,13 @@ import { useDebouncedValue } from "../lib/hooks.js";
 import { contentUrl } from "../lib/url.js";
 import { cn } from "../lib/utils";
 import { CaretNext, CaretPrev } from "./ArrowIcons.js";
+import { BulkBylineApply } from "./BulkBylineApply.js";
+import {
+	BylineFilter,
+	EMPTY_BYLINE_FILTER,
+	isBylineFilterActive,
+	type BylineFilterState,
+} from "./BylineFilter.js";
 import { LocaleSwitcher } from "./LocaleSwitcher";
 import { RouterLinkButton } from "./RouterLinkButton.js";
 
@@ -121,6 +128,9 @@ export interface ContentListProps {
 	/** Controlled date-range filter state. */
 	dateFilter?: ContentDateFilter;
 	onDateFilterChange?: (filter: ContentDateFilter) => void;
+	/** Controlled byline filter state. */
+	bylineFilter?: BylineFilterState;
+	onBylineFilterChange?: (filter: BylineFilterState) => void;
 	/**
 	 * Bulk actions. Each is opt-in: the selection checkboxes only appear when at
 	 * least one bulk handler is provided, and each toolbar button renders only
@@ -131,6 +141,8 @@ export interface ContentListProps {
 	onBulkPublish?: BulkActionHandler;
 	onBulkUnpublish?: BulkActionHandler;
 	onBulkDelete?: BulkActionHandler;
+	/** Replaces every selected entry's credits with the picked bylines (row ids). */
+	onBulkSetBylines?: (ids: string[], bylineIds: string[]) => Promise<string[]>;
 }
 
 type BulkActionHandler = (ids: string[]) => Promise<string[]>;
@@ -184,9 +196,12 @@ export function ContentList({
 	onAuthorFilterChange,
 	dateFilter = EMPTY_DATE_FILTER,
 	onDateFilterChange,
+	bylineFilter = EMPTY_BYLINE_FILTER,
+	onBylineFilterChange,
 	onBulkPublish,
 	onBulkUnpublish,
 	onBulkDelete,
+	onBulkSetBylines,
 }: ContentListProps) {
 	const { t } = useLingui();
 	const [activeTab, setActiveTab] = React.useState<ViewTab>("all");
@@ -196,7 +211,7 @@ export function ContentList({
 
 	// Bulk selection is opt-in: the checkbox column + toolbar only render when
 	// the parent wired at least one bulk handler.
-	const bulkEnabled = !!(onBulkPublish || onBulkUnpublish || onBulkDelete);
+	const bulkEnabled = !!(onBulkPublish || onBulkUnpublish || onBulkDelete || onBulkSetBylines);
 
 	// Server-side search mode: the caller refetches based on the (debounced)
 	// query, so `items`/`total` already reflect the filter and we must not
@@ -393,6 +408,9 @@ export function ContentList({
 							onAuthorFilterChange={onAuthorFilterChange}
 							dateFilter={dateFilter}
 							onDateFilterChange={onDateFilterChange}
+							bylineFilter={bylineFilter}
+							onBylineFilterChange={onBylineFilterChange}
+							locale={activeLocale ?? undefined}
 						/>
 					)}
 
@@ -425,6 +443,14 @@ export function ContentList({
 										{t`Set to draft`}
 									</Button>
 								)}
+								{onBulkSetBylines && (
+									<BulkBylineApply
+										count={selectedCount}
+										disabled={bulkBusy}
+										locale={activeLocale ?? undefined}
+										onApply={(bylineIds) => runBulk((ids) => onBulkSetBylines(ids, bylineIds))}
+									/>
+								)}
 								{onBulkDelete && (
 									<Dialog.Root disablePointerDismissal>
 										<Dialog.Trigger
@@ -702,13 +728,18 @@ interface FilterBarProps {
 	onAuthorFilterChange?: (authorId: string) => void;
 	dateFilter: ContentDateFilter;
 	onDateFilterChange?: (filter: ContentDateFilter) => void;
+	bylineFilter: BylineFilterState;
+	onBylineFilterChange?: (filter: BylineFilterState) => void;
+	/** Locale the list is showing, so the byline picker offers matching rows. */
+	locale?: string;
 }
 
 /**
- * Filter controls for the content list: status, author, and a date range over
- * a chosen timestamp column (#1288). All controls report changes to the
- * parent, which owns the state and refetches. Filtering happens server-side,
- * so it works across the whole collection rather than the loaded page.
+ * Filter controls for the content list: status, author, byline, and a date
+ * range over a chosen timestamp column (#1288). All controls report changes to
+ * the parent, which owns the state and refetches. Filtering happens
+ * server-side, so it works across the whole collection rather than the loaded
+ * page.
  */
 function FilterBar({
 	statusFilter,
@@ -718,6 +749,9 @@ function FilterBar({
 	onAuthorFilterChange,
 	dateFilter,
 	onDateFilterChange,
+	bylineFilter,
+	onBylineFilterChange,
+	locale,
 }: FilterBarProps) {
 	const { t } = useLingui();
 
@@ -739,12 +773,22 @@ function FilterBar({
 	};
 
 	const hasActiveFilter =
-		statusFilter !== "all" || authorFilter !== "" || !!dateFilter.from || !!dateFilter.to;
+		statusFilter !== "all" ||
+		authorFilter !== "" ||
+		!!dateFilter.from ||
+		!!dateFilter.to ||
+		isBylineFilterActive(bylineFilter);
 
 	const handleClear = () => {
 		onStatusFilterChange("all");
 		onAuthorFilterChange?.("");
 		onDateFilterChange?.(EMPTY_DATE_FILTER);
+		// Clearing drops the selection but keeps the inferred-byline
+		// preference, which is a display choice rather than an active filter.
+		onBylineFilterChange?.({
+			...EMPTY_BYLINE_FILTER,
+			includeInferred: bylineFilter.includeInferred,
+		});
 	};
 
 	return (
@@ -783,6 +827,10 @@ function FilterBar({
 				</Select>
 			)}
 
+			{onBylineFilterChange && (
+				<BylineFilter value={bylineFilter} onChange={onBylineFilterChange} locale={locale} />
+			)}
+
 			{showDateFilter && (
 				<div className="flex flex-wrap items-end gap-2">
 					<Select
diff --git a/packages/admin/src/lib/api/content.ts b/packages/admin/src/lib/api/content.ts
index 23030c2e9..f3b92803f 100644
--- a/packages/admin/src/lib/api/content.ts
+++ b/packages/admin/src/lib/api/content.ts
@@ -156,6 +156,18 @@ export async function fetchContentList(
 		dateFrom?: string;
 		/** Inclusive upper bound (ISO date or datetime). Requires `dateField`. */
 		dateTo?: string;
+		/**
+		 * Byline ids (translation groups) to match; an entry matches if it is
+		 * credited to any of them. Ignored when `bylinesNone` is set.
+		 */
+		bylines?: string[];
+		/** Match entries with no byline instead of a specific one. */
+		bylinesNone?: boolean;
+		/**
+		 * Count the byline inferred from an entry's author when it has no
+		 * explicit credit. Off by default: the filter matches real credits.
+		 */
+		includeInferredBylines?: boolean;
 	},
 ): Promise<FindManyResult<ContentItem>> {
 	const params = new URLSearchParams();
@@ -174,6 +186,16 @@ export async function fetchContentList(
 		if (options.dateFrom) params.set("dateFrom", options.dateFrom);
 		if (options.dateTo) params.set("dateTo", options.dateTo);
 	}
+	// `none` is the server's sentinel for "no byline assigned"; it takes
+	// precedence over a stale selection so the two can't be sent together.
+	if (options?.bylinesNone) {
+		params.set("bylines", "none");
+	} else if (options?.bylines && options.bylines.length > 0) {
+		params.set("bylines", options.bylines.join(","));
+	}
+	if (options?.includeInferredBylines && (options.bylinesNone || options.bylines?.length)) {
+		params.set("includeInferredBylines", "1");
+	}
 
 	const url = `${API_BASE}/content/${collection}${params.toString() ? `?${params}` : ""}`;
 	const response = await apiFetch(url);
diff --git a/packages/admin/src/router.tsx b/packages/admin/src/router.tsx
index dba723fc9..8a34f4a2d 100644
--- a/packages/admin/src/router.tsx
+++ b/packages/admin/src/router.tsx
@@ -21,6 +21,7 @@ import {
 } from "@tanstack/react-router";
 import * as React from "react";
 
+import { EMPTY_BYLINE_FILTER, type BylineFilterState } from "./components/BylineFilter";
 import { CommentInbox } from "./components/comments/CommentInbox";
 import { ContentEditor } from "./components/ContentEditor";
 import {
@@ -352,6 +353,18 @@ function ContentListPage() {
 	const [statusFilter, setStatusFilter] = React.useState<ContentStatusFilter>("all");
 	const [authorFilter, setAuthorFilter] = React.useState("");
 	const [dateFilter, setDateFilter] = React.useState<ContentDateFilter>(EMPTY_DATE_FILTER);
+	const [bylineFilter, setBylineFilter] = React.useState<BylineFilterState>(EMPTY_BYLINE_FILTER);
+
+	// Only the parts that change the result set belong in the query key —
+	// `includeInferred` alone, with nothing selected, filters nothing.
+	const bylineApiParams = React.useMemo(() => {
+		if (!bylineFilter.none && bylineFilter.bylineIds.length === 0) return undefined;
+		return {
+			bylines: bylineFilter.none ? undefined : bylineFilter.bylineIds,
+			bylinesNone: bylineFilter.none,
+			includeInferredBylines: bylineFilter.includeInferred,
+		};
+	}, [bylineFilter]);
 
 	// The date inputs yield calendar dates; widen them to UTC day boundaries so
 	// the inclusive `dateTo` covers the whole day (timestamps are stored in UTC).
@@ -386,6 +399,7 @@ function ContentListPage() {
 					status: statusFilter,
 					author: authorFilter,
 					date: dateApiParams,
+					byline: bylineApiParams,
 				},
 			],
 			queryFn: ({ pageParam }) =>
@@ -399,6 +413,7 @@ function ContentListPage() {
 					status: statusFilter === "all" ? undefined : statusFilter,
 					authorId: authorFilter || undefined,
 					...dateApiParams,
+					...bylineApiParams,
 				}),
 			initialPageParam: undefined as string | undefined,
 			getNextPageParam: (lastPage) => lastPage.nextCursor,
@@ -547,6 +562,35 @@ function ContentListPage() {
 		return data?.pages.flatMap((page) => page.items) || [];
 	}, [data]);
 
+	// Bulk byline apply: temporary tooling for exercising the byline filter, not
+	// part of the shipped feature. The picked bylines replace each entry's whole
+	// credit set — merging client-side isn't sound, because list items hydrate
+	// credits with strict locale matching and an entry whose byline has no row
+	// in its locale comes back with an empty `bylines` array.
+	const bulkSetBylinesMutation = useMutation({
+		mutationFn: async ({ ids, bylineIds }: { ids: string[]; bylineIds: string[] }) => {
+			const bylines = bylineIds.map((bylineId) => ({ bylineId }));
+			const { failedIds } = await runBulkAction(ids, (id) =>
+				updateContent(collection, id, { bylines }, { locale: activeLocale }),
+			);
+			return { total: ids.length, failedIds };
+		},
+		onSuccess: ({ total, failedIds }) => {
+			if (failedIds.length === 0) {
+				toastManager.add({ title: t`Updated bylines on ${total} items`, type: "success" });
+			} else {
+				toastManager.add({
+					title: t`Failed to update bylines`,
+					description: t`${failedIds.length} of ${total} could not be updated`,
+					type: "error",
+				});
+			}
+		},
+		onSettled: () => {
+			void queryClient.invalidateQueries({ queryKey: ["content", collection] });
+		},
+	});
+
 	// Server returns `total` on every page; the first page is authoritative
 	// because filters don't change within a fetch cycle. Fall back to the
 	// loaded count so old servers (pre-total) still render a denominator.
@@ -610,9 +654,14 @@ function ContentListPage() {
 			onAuthorFilterChange={setAuthorFilter}
 			dateFilter={dateFilter}
 			onDateFilterChange={setDateFilter}
+			bylineFilter={bylineFilter}
+			onBylineFilterChange={setBylineFilter}
 			onBulkPublish={(ids) => bulkPublishMutation.mutateAsync(ids).then((r) => r.failedIds)}
 			onBulkUnpublish={(ids) => bulkUnpublishMutation.mutateAsync(ids).then((r) => r.failedIds)}
 			onBulkDelete={(ids) => bulkDeleteMutation.mutateAsync(ids).then((r) => r.failedIds)}
+			onBulkSetBylines={(ids, bylineIds) =>
+				bulkSetBylinesMutation.mutateAsync({ ids, bylineIds }).then((r) => r.failedIds)
+			}
 		/>
 	);
 }
diff --git a/packages/core/src/api/handlers/content.ts b/packages/core/src/api/handlers/content.ts
index db0f4a0a6..9e2ea8360 100644
--- a/packages/core/src/api/handlers/content.ts
+++ b/packages/core/src/api/handlers/content.ts
@@ -20,6 +20,7 @@ import {
 	InvalidCursorError,
 	type BylineSummary,
 	type ContentBylineCredit,
+	type ContentBylineFilter,
 	type ContentDateField,
 	type ContentItem,
 	type ContentSeo,
@@ -411,6 +412,43 @@ function normalizeDateBound(value: string | undefined, edge: "start" | "end"): s
 	return edge === "start" ? `${value}T00:00:00.000Z` : `${value}T23:59:59.999Z`;
 }
 
+/**
+ * Build the repository's byline filter from the wire params, resolving the
+ * users behind the selected bylines when inferred credits are opted in.
+ *
+ * The extra lookup runs only for `includeInferredBylines`, so the default
+ * explicit-only filter costs no additional query.
+ */
+async function resolveBylineFilter(
+	db: Kysely<Database>,
+	params: { bylines?: string[]; bylinesNone?: boolean; includeInferredBylines?: boolean },
+): Promise<ContentBylineFilter | undefined> {
+	const includeInferred = params.includeInferredBylines === true;
+
+	if (params.bylinesNone) return { mode: "none", includeInferred };
+
+	const bylineIds = params.bylines ?? [];
+	if (bylineIds.length === 0) return undefined;
+
+	const filter: ContentBylineFilter = { mode: "any", bylineIds, includeInferred };
+	if (!includeInferred) return filter;
+
+	// A byline's `user_id` is shared across its locale siblings, so selecting
+	// by translation_group and de-duplicating gives every user whose implicit
+	// credit should match.
+	const rows = await db
+		.selectFrom("_emdash_bylines")
+		.select("user_id")
+		.where("translation_group", "in", bylineIds)
+		.where("user_id", "is not", null)
+		.execute();
+	filter.inferredAuthorIds = [
+		...new Set(rows.map((row) => row.user_id).filter((id): id is string => id !== null)),
+	];
+
+	return filter;
+}
+
 /**
  * Create content list handler
  */
@@ -429,6 +467,9 @@ export async function handleContentList(
 		dateField?: ContentDateField;
 		dateFrom?: string;
 		dateTo?: string;
+		bylines?: string[];
+		bylinesNone?: boolean;
+		includeInferredBylines?: boolean;
 	},
 ): Promise<ApiResult<ContentListResponse>> {
 	try {
@@ -438,6 +479,9 @@ export async function handleContentList(
 		if (params.locale) where.locale = resolveConfiguredLocale(params.locale);
 		if (params.authorId) where.authorId = params.authorId;
 
+		const bylineFilter = await resolveBylineFilter(db, params);
+		if (bylineFilter) where.bylineFilter = bylineFilter;
+
 		// A date range requires a target column; ignore stray from/to without
 		// a field so a half-specified filter doesn't silently drop all rows.
 		if (params.dateField && (params.dateFrom || params.dateTo)) {
diff --git a/packages/core/src/api/schemas/content.ts b/packages/core/src/api/schemas/content.ts
index fafab339b..cf8088d33 100644
--- a/packages/core/src/api/schemas/content.ts
+++ b/packages/core/src/api/schemas/content.ts
@@ -26,6 +26,40 @@ const contentDateBound = z
 	])
 	.optional();
 
+/**
+ * Byline ids for the content-list filter: either the literal `none` or a
+ * comma-separated list, parsed into an array.
+ *
+ * The 25-id cap keeps the `IN (...)` clause clear of D1's bound-parameter
+ * ceiling once the rest of the list query's placeholders are counted
+ * (`SQL_BATCH_SIZE` is 50 for a query binding nothing else).
+ */
+const bylineFilterParam = z
+	.string()
+	.trim()
+	.min(1)
+	.max(2000)
+	.optional()
+	.transform((value) =>
+		value === undefined
+			? undefined
+			: value === "none"
+				? ("none" as const)
+				: [...new Set(value.split(",").map((id) => id.trim()))].filter((id) => id.length > 0),
+	)
+	.refine((value) => value === undefined || value === "none" || value.length <= 25, {
+		message: "at most 25 bylines may be selected",
+	})
+	.refine((value) => value === undefined || value === "none" || value.length > 0, {
+		message: "must contain at least one byline id",
+	});
+
+/** Query-string boolean. Explicit values only — `z.coerce.boolean()` reads "false" as true. */
+const booleanParam = z
+	.enum(["1", "0", "true", "false"])
+	.optional()
+	.transform((value) => value === "1" || value === "true");
+
 export const contentListQuery = cursorPaginationQuery
 	.extend({
 		status: z.string().optional(),
@@ -42,7 +76,23 @@ export const contentListQuery = cursorPaginationQuery
 		dateFrom: contentDateBound,
 		/** Inclusive upper bound for the date range. Requires `dateField`. */
 		dateTo: contentDateBound,
+		/**
+		 * Comma-separated byline ids; an entry matches if it is credited to any
+		 * of them. The literal `none` (alone) matches entries with no byline.
+		 */
+		bylines: bylineFilterParam,
+		/**
+		 * Also match the byline inferred from an entry's author when it has no
+		 * explicit credit — i.e. filter on the byline the list renders rather
+		 * than on the credits stored against the entry. Off by default.
+		 */
+		includeInferredBylines: booleanParam,
 	})
+	.transform(({ bylines, ...rest }) => ({
+		...rest,
+		bylinesNone: bylines === "none",
+		bylines: bylines === "none" ? undefined : bylines,
+	}))
 	.meta({ id: "ContentListQuery" });
 
 /** ISO 8601 datetime for `publishedAt` / `createdAt`. Routes gate writes behind `content:publish_any`. */
diff --git a/packages/core/src/astro/types.ts b/packages/core/src/astro/types.ts
index 042313ece..d006c31f1 100644
--- a/packages/core/src/astro/types.ts
+++ b/packages/core/src/astro/types.ts
@@ -240,6 +240,9 @@ export interface EmDashHandlers {
 			dateField?: "createdAt" | "updatedAt" | "publishedAt";
 			dateFrom?: string;
 			dateTo?: string;
+			bylines?: string[];
+			bylinesNone?: boolean;
+			includeInferredBylines?: boolean;
 		},
 	) => Promise<HandlerResponse>;
 
diff --git a/packages/core/src/database/repositories/content.ts b/packages/core/src/database/repositories/content.ts
index 351a49538..fb70c36e4 100644
--- a/packages/core/src/database/repositories/content.ts
+++ b/packages/core/src/database/repositories/content.ts
@@ -16,6 +16,7 @@ import type {
 	FindManyResult,
 	ContentItem,
 	ContentDateField,
+	ContentBylineFilter,
 } from "./types.js";
 import {
 	EmDashValidationError,
@@ -528,6 +529,7 @@ export class ContentRepository {
 
 		query = this.applySearchFilter(query, options.where, type);
 		query = this.applyDateFilter(query, options.where);
+		query = this.applyBylineFilter(query, options.where, type);
 
 		// Handle cursor pagination — decodeCursor throws InvalidCursorError
 		// on malformed input; let it propagate so handlers surface a
@@ -935,6 +937,92 @@ export class ContentRepository {
 		return next;
 	}
 
+	/**
+	 * Apply the optional byline filter as a correlated (NOT) EXISTS against
+	 * `_emdash_content_bylines`.
+	 *
+	 * The shape is load-bearing. Correlating from the content table lets the
+	 * outer query keep its sort-ordered composite index — so `LIMIT` still
+	 * short-circuits — while each probe is an index-only seek on the
+	 * `(collection_slug, content_id, byline_id)` unique index. Driving the
+	 * other way (`FROM _emdash_content_bylines JOIN ec_*`) cannot use that
+	 * index for the byline and forces a temp B-tree for the ORDER BY.
+	 *
+	 * `mode: "none"` tests the junction rather than `primary_byline_id`. The
+	 * two agree — both junction write paths stamp the column in the same call
+	 * — but they are not written atomically (D1 has no transactions), so the
+	 * junction stays authoritative, as migration 051 treats the denormalized
+	 * taxonomy columns.
+	 */
+	private applyBylineFilter<QB extends { where: (cb: (eb: any) => unknown) => QB }>(
+		query: QB,
+		where: { bylineFilter?: ContentBylineFilter } | undefined,
+		type: string,
+	): QB {
+		const filter = where?.bylineFilter;
+		if (!filter) return query;
+		const tableName = getTableName(type);
+		const idColumn = `${tableName}.id`;
+		const authorColumn = `${tableName}.author_id`;
+		const localeColumn = `${tableName}.locale`;
+
+		const credited = (eb: any, bylineIds?: string[]) => {
+			let sub = eb
+				.selectFrom("_emdash_content_bylines as cb")
+				.select("cb.id")
+				.where("cb.collection_slug", "=", type)
+				.whereRef("cb.content_id", "=", idColumn);
+			if (bylineIds) sub = sub.where("cb.byline_id", "in", bylineIds);
+			return eb.exists(sub);
+		};
+
+		// The entry's author owns a byline row at the entry's own locale —
+		// the same strict-locale rule `hydrateBylinesMany` applies before it
+		// renders an inferred credit.
+		const authorHasByline = (eb: any) =>
+			eb.exists(
+				eb
+					.selectFrom("_emdash_bylines as b")
+					.select("b.id")
+					.whereRef("b.user_id", "=", authorColumn)
+					.whereRef("b.locale", "=", localeColumn),
+			);
+
+		if (filter.mode === "none") {
+			return query.where((eb: any) => {
+				const uncredited = eb.not(credited(eb));
+				// With inference on, "no byline" means none is rendered, so an
+				// entry whose author resolves to a byline is excluded too.
+				return filter.includeInferred
+					? eb.and([uncredited, eb.not(authorHasByline(eb))])
+					: uncredited;
+			});
+		}
+
+		const bylineIds = filter.bylineIds ?? [];
+		const inferredAuthorIds = filter.includeInferred ? (filter.inferredAuthorIds ?? []) : [];
+		if (bylineIds.length === 0 && inferredAuthorIds.length === 0) {
+			// A filter that resolved to no ids must match nothing rather than
+			// silently degrade to "no filter" and return the whole collection.
+			// `1 = 0` rather than a bound `false`: better-sqlite3 refuses to
+			// bind JS booleans.
+			return query.where(() => sql<boolean>`1 = 0`);
+		}
+
+		return query.where((eb: any) => {
+			const branches = [];
+			if (bylineIds.length > 0) branches.push(credited(eb, bylineIds));
+			if (inferredAuthorIds.length > 0) {
+				// Inference applies only where no explicit credit exists, so an
+				// entry credited to someone else never matches on its author.
+				branches.push(
+					eb.and([eb.not(credited(eb)), eb(authorColumn as any, "in", inferredAuthorIds)]),
+				);
+			}
+			return branches.length === 1 ? branches[0] : eb.or(branches);
+		});
+	}
+
 	/**
 	 * Count content items
 	 */
@@ -960,6 +1048,7 @@ export class ContentRepository {
 
 		query = this.applySearchFilter(query, where, type);
 		query = this.applyDateFilter(query, where);
+		query = this.applyBylineFilter(query, where, type);
 
 		const result = await query.executeTakeFirst();
 		return Number(result?.count || 0);
diff --git a/packages/core/src/database/repositories/types.ts b/packages/core/src/database/repositories/types.ts
index 5d7bc1d46..240ba2061 100644
--- a/packages/core/src/database/repositories/types.ts
+++ b/packages/core/src/database/repositories/types.ts
@@ -145,6 +145,35 @@ export interface ContentDateFilter {
 	to?: string;
 }
 
+/**
+ * Byline filter for a content list.
+ *
+ * `mode: "any"` matches entries credited to at least one of `bylineIds`;
+ * `mode: "none"` matches entries with no credit at all.
+ *
+ * `bylineIds` are `translation_group` values — what
+ * `_emdash_content_bylines.byline_id` stores since migration 040 — so a filter
+ * matches a byline across every locale variant.
+ *
+ * By default only explicit credits count. `includeInferred` widens the filter
+ * to the byline the list actually renders, which for an entry with no credits
+ * is the one linked to its `author_id` (see `hydrateBylinesMany`). It is off by
+ * default because filtering usually means "who is credited", not "whose name
+ * happens to show".
+ */
+export interface ContentBylineFilter {
+	mode: "any" | "none";
+	/** Ignored when `mode` is `"none"`. An empty list matches nothing. */
+	bylineIds?: string[];
+	includeInferred?: boolean;
+	/**
+	 * Users whose linked byline falls in `bylineIds`, resolved by the handler
+	 * so the repository stays free of byline lookups. Only read when
+	 * `includeInferred` is set and `mode` is `"any"`.
+	 */
+	inferredAuthorIds?: string[];
+}
+
 export interface FindManyOptions {
 	where?: {
 		status?: string;
@@ -168,6 +197,8 @@ export interface FindManyOptions {
 		useFts?: boolean;
 		/** Inclusive date range over a whitelisted timestamp column. */
 		dateFilter?: ContentDateFilter;
+		/** Restrict to entries by their byline credits. */
+		bylineFilter?: ContentBylineFilter;
 	};
 	orderBy?: {
 		field: string;
diff --git a/packages/core/src/emdash-runtime.ts b/packages/core/src/emdash-runtime.ts
index 5e4a24725..59f1785bf 100644
--- a/packages/core/src/emdash-runtime.ts
+++ b/packages/core/src/emdash-runtime.ts
@@ -2610,6 +2610,9 @@ export class EmDashRuntime {
 			dateField?: ContentDateField;
 			dateFrom?: string;
 			dateTo?: string;
+			bylines?: string[];
+			bylinesNone?: boolean;
+			includeInferredBylines?: boolean;
 		},
 	) {
 		return handleContentList(this.db, collection, params);
diff --git a/packages/core/tests/integration/content/content-list-byline-filter.test.ts b/packages/core/tests/integration/content/content-list-byline-filter.test.ts
new file mode 100644
index 000000000..61390bb67
--- /dev/null
+++ b/packages/core/tests/integration/content/content-list-byline-filter.test.ts
@@ -0,0 +1,179 @@
+import { beforeEach, afterEach, expect, it } from "vitest";
+
+import { handleContentCreate, handleContentList } from "../../../src/api/handlers/content.js";
+import { BylineRepository } from "../../../src/database/repositories/byline.js";
+import { ContentRepository } from "../../../src/database/repositories/content.js";
+import { UserRepository } from "../../../src/database/repositories/user.js";
+import { SchemaRegistry } from "../../../src/schema/registry.js";
+import {
+	describeEachDialect,
+	setupForDialect,
+	teardownForDialect,
+	type DialectTestContext,
+} from "../../utils/test-db.js";
+
+// Byline filtering in the admin content list: match entries credited to any of
+// the selected bylines, or entries with no byline at all. Credits inferred from
+// an entry's author are excluded unless explicitly opted into.
+describeEachDialect("content list byline filter", (dialect) => {
+	let ctx: DialectTestContext;
+	// `_emdash_content_bylines.byline_id` stores translation_groups, so the
+	// filter takes groups rather than row ids.
+	let adaGroup: string;
+	let graceGroup: string;
+	let turingGroup: string;
+
+	beforeEach(async () => {
+		ctx = await setupForDialect(dialect);
+		const registry = new SchemaRegistry(ctx.db);
+		await registry.createCollection({ slug: "posts", label: "Posts", labelSingular: "Post" });
+		await registry.createField("posts", { slug: "title", label: "Title", type: "string" });
+
+		const users = new UserRepository(ctx.db);
+		const turingUser = await users.create({ email: "turing@example.com", name: "Turing" });
+
+		const bylines = new BylineRepository(ctx.db);
+		const ada = await bylines.create({ slug: "ada", displayName: "Ada Lovelace" });
+		const grace = await bylines.create({ slug: "grace", displayName: "Grace Hopper" });
+		// Linked to a CMS user, so entries authored by that user get an
+		// inferred credit when they carry no explicit one.
+		const turing = await bylines.create({
+			slug: "turing",
+			displayName: "Alan Turing",
+			userId: turingUser.id,
+		});
+		adaGroup = ada.translationGroup ?? ada.id;
+		graceGroup = grace.translationGroup ?? grace.id;
+		turingGroup = turing.translationGroup ?? turing.id;
+
+		const seed = [
+			{ slug: "ada-only", title: "Ada only", bylines: [ada.id] },
+			{ slug: "grace-only", title: "Grace only", bylines: [grace.id] },
+			{ slug: "both", title: "Both", bylines: [ada.id, grace.id] },
+			{ slug: "uncredited", title: "Uncredited", bylines: [] },
+			// No explicit credit, but its author owns the Turing byline — the
+			// list renders "Alan Turing" against it by inference.
+			{ slug: "inferred", title: "Inferred", bylines: [], authorId: turingUser.id },
+		];
+		for (const s of seed) {
+			const created = await handleContentCreate(ctx.db, "posts", {
+				slug: s.slug,
+				data: { title: s.title },
+				authorId: s.authorId,
+				bylines: s.bylines.map((bylineId) => ({ bylineId })),
+			});
+			if (!created.success) throw new Error(`seed ${s.slug} failed`);
+		}
+	});
+
+	afterEach(async () => {
+		await teardownForDialect(ctx);
+	});
+
+	function slugsOf(result: {
+		success: boolean;
+		data?: { items: { slug: string | null }[] };
+	}): string[] {
+		if (!result.success || !result.data) throw new Error("list failed");
+		return result.data.items.map((i) => i.slug ?? "").toSorted();
+	}
+
+	it("matches entries credited to the selected byline", async () => {
+		const result = await handleContentList(ctx.db, "posts", { bylines: [adaGroup] });
+		expect(slugsOf(result)).toEqual(["ada-only", "both"]);
+	});
+
+	it("matches entries credited to any of several bylines", async () => {
+		const result = await handleContentList(ctx.db, "posts", {
+			bylines: [adaGroup, graceGroup],
+		});
+		expect(slugsOf(result)).toEqual(["ada-only", "both", "grace-only"]);
+	});
+
+	it("reports a total that reflects the byline filter", async () => {
+		const result = await handleContentList(ctx.db, "posts", { bylines: [adaGroup] });
+		if (!result.success) throw new Error("list failed");
+		expect(result.data.total).toBe(2);
+	});
+
+	it("matches entries with no byline credit", async () => {
+		const result = await handleContentList(ctx.db, "posts", { bylinesNone: true });
+		// `inferred` has no credit of its own, so it belongs here until
+		// inference is opted into.
+		expect(slugsOf(result)).toEqual(["inferred", "uncredited"]);
+	});
+
+	it("ignores bylines inferred from the author by default", async () => {
+		const result = await handleContentList(ctx.db, "posts", { bylines: [turingGroup] });
+		expect(slugsOf(result)).toEqual([]);
+	});
+
+	it("matches inferred bylines when opted in", async () => {
+		const result = await handleContentList(ctx.db, "posts", {
+			bylines: [turingGroup],
+			includeInferredBylines: true,
+		});
+		expect(slugsOf(result)).toEqual(["inferred"]);
+	});
+
+	it("excludes entries with an inferred byline from the no-byline filter when opted in", async () => {
+		const result = await handleContentList(ctx.db, "posts", {
+			bylinesNone: true,
+			includeInferredBylines: true,
+		});
+		expect(slugsOf(result)).toEqual(["uncredited"]);
+	});
+
+	it("does not infer a credit for an entry that already has one", async () => {
+		// `ada-only` is authored by nobody, but the guard matters generally:
+		// an explicit credit must suppress the author fallback, mirroring
+		// `hydrateBylinesMany`. Credit `inferred` to Ada and it should stop
+		// matching Turing even with inference on.
+		const bylines = new BylineRepository(ctx.db);
+		const ada = await bylines.findBySlug("ada");
+		if (!ada) throw new Error("ada byline missing");
+		await bylines.setContentBylines("posts", await idOfSlug("inferred"), [{ bylineId: ada.id }]);
+
+		const result = await handleContentList(ctx.db, "posts", {
+			bylines: [turingGroup],
+			includeInferredBylines: true,
+		});
+		expect(slugsOf(result)).toEqual([]);
+	});
+
+	it("composes with the status filter", async () => {
+		const result = await handleContentList(ctx.db, "posts", {
+			bylines: [adaGroup, graceGroup],
+			status: "published",
+		});
+		// Seeded entries are drafts, so the intersection is empty — the byline
+		// filter must not override the status filter.
+		expect(slugsOf(result)).toEqual([]);
+	});
+
+	it("matches nothing when the selected byline has no entries", async () => {
+		const result = await handleContentList(ctx.db, "posts", {
+			bylines: ["01ARZ3NDEKTSV4RRFFQ69G5FAV"],
+		});
+		expect(slugsOf(result)).toEqual([]);
+	});
+
+	it("matches nothing when a repository caller passes an empty byline list", async () => {
+		// The handler never builds this, but a filter that resolved to no ids
+		// must not degrade into "no filter" and return the whole collection.
+		const repo = new ContentRepository(ctx.db);
+		const result = await repo.findMany("posts", {
+			where: { bylineFilter: { mode: "any", bylineIds: [] } },
+		});
+		expect(result.items).toEqual([]);
+		expect(result.total).toBe(0);
+	});
+
+	async function idOfSlug(slug: string): Promise<string> {
+		const list = await handleContentList(ctx.db, "posts", {});
+		if (!list.success) throw new Error("list failed");
+		const item = list.data.items.find((i) => i.slug === slug);
+		if (!item) throw new Error(`no entry with slug ${slug}`);
+		return item.id;
+	}
+});