diff --git a/.changeset/fast-media-usage-backfill.md b/.changeset/fast-media-usage-backfill.md
new file mode 100644
index 0000000000..b413543137
--- /dev/null
+++ b/.changeset/fast-media-usage-backfill.md
@@ -0,0 +1,6 @@
+---
+"emdash": patch
+"@emdash-cms/cloudflare": patch
+---
+
+Speeds up initial Media Usage indexing on Cloudflare Workers and Node.js.
diff --git a/.changeset/media-usage-activation-ui.md b/.changeset/media-usage-activation-ui.md
new file mode 100644
index 0000000000..3daf08cfd2
--- /dev/null
+++ b/.changeset/media-usage-activation-ui.md
@@ -0,0 +1,7 @@
+---
+"emdash": minor
+"@emdash-cms/admin": minor
+"@emdash-cms/cloudflare": minor
+---
+
+Adds an admin setup flow for Media Usage. Administrators can enable it from Settings with one confirmation and follow setup and indexing progress until it is ready.
diff --git a/.changeset/media-usage-progress-locale.md b/.changeset/media-usage-progress-locale.md
new file mode 100644
index 0000000000..c865c1ee61
--- /dev/null
+++ b/.changeset/media-usage-progress-locale.md
@@ -0,0 +1,5 @@
+---
+"@emdash-cms/admin": patch
+---
+
+Fixes Media Usage progress counts showing raw plural syntax instead of readable text.
diff --git a/.changeset/remove-media-usage-scheduled-recovery.md b/.changeset/remove-media-usage-scheduled-recovery.md
new file mode 100644
index 0000000000..efd35dfaf5
--- /dev/null
+++ b/.changeset/remove-media-usage-scheduled-recovery.md
@@ -0,0 +1,12 @@
+---
+"emdash": minor
+"@emdash-cms/cloudflare": minor
+---
+
+Removes scheduled Media Usage recovery APIs. Media Usage now starts when an administrator enables it and continues through the Cloudflare Queue or Node.js scheduler. This is a breaking change for Cloudflare deployments that configure `mediaUsageCron` and Node.js integrations that provide a custom `CronScheduler`.
+
+#### What should I do?
+
+On Cloudflare, remove the dedicated Media Usage Cron and the `mediaUsageCron` option. Configure `createMediaUsageFetchHandler()` and `createMediaUsageQueueHandler()` to start and continue indexing.
+
+If you provide a custom Node.js scheduler, replace `setMediaUsageMaintenance()` with `setContinuousMediaUsageMaintenance()` and `wakeMediaUsageMaintenance()`. Keep the Queue consumer or Node.js process running until Media Usage shows **Ready**; the general Cron no longer restarts interrupted indexing.
diff --git a/demos/cloudflare/src/worker.ts b/demos/cloudflare/src/worker.ts
index d154c752d9..8843215f7f 100644
--- a/demos/cloudflare/src/worker.ts
+++ b/demos/cloudflare/src/worker.ts
@@ -7,11 +7,21 @@
  */
 
 import handler from "@astrojs/cloudflare/entrypoints/server";
-import { createScheduledHandler, PluginBridge } from "@emdash-cms/cloudflare/worker";
+import {
+	createMediaUsageQueueHandler,
+	createMediaUsageFetchHandler,
+	createScheduledHandler,
+	type MediaUsageWakeMessage,
+	PluginBridge,
+} from "@emdash-cms/cloudflare/worker";
 
 export { PluginBridge };
 
+const resolveMediaUsageQueue = (env: Env) => env.MEDIA_USAGE_QUEUE;
+
 export default {
 	...handler,
+	fetch: createMediaUsageFetchHandler(handler, resolveMediaUsageQueue),
 	scheduled: createScheduledHandler(),
-} satisfies ExportedHandler<Env>;
+	queue: createMediaUsageQueueHandler(resolveMediaUsageQueue),
+} satisfies ExportedHandler<Env, MediaUsageWakeMessage>;
diff --git a/demos/cloudflare/worker-configuration.d.ts b/demos/cloudflare/worker-configuration.d.ts
index 6603007357..6dc5705216 100644
--- a/demos/cloudflare/worker-configuration.d.ts
+++ b/demos/cloudflare/worker-configuration.d.ts
@@ -8,6 +8,7 @@ declare namespace Cloudflare {
 	interface Env {
 		MEDIA: R2Bucket;
 		DB: D1Database;
+		MEDIA_USAGE_QUEUE: Queue;
 		LOADER: WorkerLoader;
 		AI_SEARCH: AiSearchNamespace;
 	}
diff --git a/demos/cloudflare/wrangler.jsonc b/demos/cloudflare/wrangler.jsonc
index 71bbfb825c..f6814b5c0b 100644
--- a/demos/cloudflare/wrangler.jsonc
+++ b/demos/cloudflare/wrangler.jsonc
@@ -34,9 +34,29 @@
 			"bucket_name": "emdash-media",
 		},
 	],
-	// Cron trigger drives the AI Search reindex queue flush.
+	"queues": {
+		"producers": [
+			{
+				"binding": "MEDIA_USAGE_QUEUE",
+				"queue": "emdash-demo-media-usage",
+			},
+		],
+		"consumers": [
+			{
+				"queue": "emdash-demo-media-usage",
+				"max_batch_size": 1,
+				"max_batch_timeout": 0,
+				"max_retries": 3,
+				"max_concurrency": 1,
+			},
+		],
+	},
+	"limits": {
+		"cpu_ms": 300000,
+	},
+	// Cron triggers drive general maintenance.
 	"triggers": {
-		"crons": ["* * * * *", "*/2 * * * *"],
+		"crons": ["* * * * *"],
 	},
 	// Observability
 	"observability": {
diff --git a/docs/src/content/docs/deployment/cloudflare.mdx b/docs/src/content/docs/deployment/cloudflare.mdx
index 8e52d3650f..da6b7c5174 100644
--- a/docs/src/content/docs/deployment/cloudflare.mdx
+++ b/docs/src/content/docs/deployment/cloudflare.mdx
@@ -10,7 +10,8 @@ Cloudflare Workers provides a fast, globally distributed runtime for EmDash. Thi
 ## Prerequisites
 
 - A Cloudflare account
-- Wrangler CLI installed (`npm install -g wrangler`)
+- Workers Paid when activating automatic Media Usage indexing
+- Wrangler 4.123 or newer (`npx wrangler@latest`)
 - Authenticated with Cloudflare (`wrangler login`)
 
 ## Configure Bindings
@@ -94,46 +95,84 @@ If the database is empty (no collections) and the setup wizard hasn't been compl
 
 To change the schema or content model of a site that is already deployed, see [Evolving a Deployed Site](/deployment/schema-evolution/).
 
-## Scheduled Publishing
+## Scheduled tasks and Media Usage
 
-On Cloudflare Workers, scheduled publishing, plugin cron, and maintenance tasks run from Worker Cron Triggers. New Cloudflare templates include both required schedules automatically. When updating an existing project, configure distinct general and Media Usage lanes:
+Cloudflare runs scheduled publishing, plugin tasks, and general maintenance from one Cron Trigger. Media Usage uses a Queue so indexing starts when an administrator enables it and continues after the browser closes.
+
+New Cloudflare templates include this configuration. When updating an existing project, add the Media Usage handlers to the Worker entry point:
 
 ```ts title="src/worker.ts"
 import handler, {
+	createMediaUsageFetchHandler,
+	createMediaUsageQueueHandler,
 	createScheduledHandler,
+	type MediaUsageWakeMessage,
 	PluginBridge,
 } from "@emdash-cms/cloudflare/worker";
 
 export { PluginBridge };
 
+const resolveMediaUsageQueue = (env: Env) => env.MEDIA_USAGE_QUEUE;
+
 export default {
 	...handler,
+	fetch: createMediaUsageFetchHandler(handler, resolveMediaUsageQueue),
 	scheduled: createScheduledHandler(),
-} satisfies ExportedHandler;
+	queue: createMediaUsageQueueHandler(resolveMediaUsageQueue),
+} satisfies ExportedHandler<Env, MediaUsageWakeMessage>;
 ```
 
-By default, `*/2 * * * *` runs Media Usage maintenance and every other expression runs general maintenance. Then add both Cron Triggers to `wrangler.jsonc`:
+Configure one Cron Trigger for general maintenance and one Queue for Media Usage in `wrangler.jsonc`:
 
 ```jsonc title="wrangler.jsonc"
 {
 	"triggers": {
-		"crons": ["* * * * *", "*/2 * * * *"],
+		"crons": ["* * * * *"],
+	},
+	"limits": {
+		"cpu_ms": 300000,
+	},
+	"queues": {
+		"producers": [
+			{
+				"binding": "MEDIA_USAGE_QUEUE",
+				"queue": "my-emdash-site-media-usage",
+			},
+		],
+		"consumers": [
+			{
+				"queue": "my-emdash-site-media-usage",
+				"max_batch_size": 1,
+				"max_batch_timeout": 0,
+				"max_retries": 3,
+				"max_concurrency": 1,
+			},
+		],
 	},
 }
 ```
 
-To use different schedules, set the corresponding `generalCron` or `mediaUsageCron` option in `createScheduledHandler()` and use the same expression in `wrangler.jsonc`.
+Run `wrangler types` after changing the bindings so `Env.MEDIA_USAGE_QUEUE` is available to TypeScript.
+
+The fetch handler sends the first Queue message after Media Usage is enabled. The consumer indexes up to 1,000 entries at a time and sends another message while work remains. Keep `max_concurrency` at `1` because D1 processes writes sequentially.
+
+To use a different general maintenance schedule, set `generalCron` in `createScheduledHandler()` and
+use the same expression in `wrangler.jsonc`.
 
 <Aside type="caution">
-	Without the general trigger, scheduled publishing and plugin cron do not run. Without the dedicated Media Usage trigger, automatic historical reconciliation cannot progress. Local `astro dev` still uses the in-process scheduler.
+	Keep the Media Usage Queue configured and running until setup reaches **Ready**. The general Cron does not restart interrupted Media Usage indexing.
 </Aside>
 
-### Enable automatic media usage indexing
+### Enable Media Usage
+
+1. If another application writes directly to D1, pause it before setup.
+2. Open **Settings → Media Usage**, select **Enable Media Usage**, then select **Turn on**.
+3. Keep the Worker and Queue running until the page shows **Ready**. You can close the page while indexing continues.
+4. Resume direct D1 writers when the page shows **Starting indexing**, **Indexing existing content**, or **Ready**.
+
+EmDash may briefly pause editing while the page shows **Setting up**. If the page shows **Needs attention**, fix the reported server problem and select **Retry setup**.
 
-Keep `mediaUsageCron` running while you enable automatic media usage indexing. Pause all application
-and direct database writes, follow [Enable automatic media usage
-indexing](/reference/rest-api/#enable-automatic-media-usage-indexing), then resume writes when the
-endpoint returns `active`. Existing content is indexed in the background.
+API operators can use the [Media Usage activation endpoints](/reference/rest-api/#enable-automatic-media-usage-indexing).
 
 ## Deploy
 
diff --git a/docs/src/content/docs/deployment/nodejs.mdx b/docs/src/content/docs/deployment/nodejs.mdx
index 89b8196815..0b60804f73 100644
--- a/docs/src/content/docs/deployment/nodejs.mdx
+++ b/docs/src/content/docs/deployment/nodejs.mdx
@@ -53,20 +53,26 @@ export default defineConfig({
 
 The server runs on `http://localhost:4321` by default. Migrations are applied on the first request. If the database is empty and setup hasn't been completed, your seed file (or the built-in default if you don't have one) is also applied on that first request.
 
-## Scheduled Tasks
+## Scheduled tasks
 
-The built-in scheduler runs only while a Node process is running. It handles scheduled publishing,
-plugin tasks, and background media indexing.
+The built-in scheduler runs only while a Node.js process is running. It handles scheduled publishing, plugin tasks, and background Media Usage indexing.
 
-Keep at least one Node process running continuously in production. If all processes stop or sleep,
-scheduled tasks pause.
+The scheduler continues indexing until Media Usage catches up. It yields between batches so the server can keep handling requests.
 
-### Enable automatic media usage indexing
+Keep at least one Node.js process running continuously in production. Scheduled tasks pause when every process stops or sleeps.
 
-Keep at least one Node process running while you enable automatic media usage indexing. Pause all
-application and direct database writes, follow [Enable automatic media usage
-indexing](/reference/rest-api/#enable-automatic-media-usage-indexing), then resume writes when the
-endpoint returns `active`. Existing content is indexed in the background.
+### Enable Media Usage
+
+1. If another application writes directly to the SQLite database, pause it before setup.
+2. Open **Settings → Media Usage**, select **Enable Media Usage**, then select **Turn on**.
+3. Keep the Node.js process running until the page shows **Ready**. You can close the page while indexing continues.
+4. Resume direct database writers when the page shows **Starting indexing**, **Indexing existing content**, or **Ready**.
+
+EmDash may briefly pause editing while the page shows **Setting up**. If the page shows **Needs attention**, fix the reported server problem and select **Retry setup**.
+
+An interrupted Node.js process does not restart Media Usage indexing from the general scheduler. Keep the process running until setup reaches **Ready**.
+
+API operators can use the [Media Usage activation endpoints](/reference/rest-api/#enable-automatic-media-usage-indexing).
 
 ## Production Storage
 
diff --git a/docs/src/content/docs/guides/media-library.mdx b/docs/src/content/docs/guides/media-library.mdx
index dafefed4da..ed4f2d0e91 100644
--- a/docs/src/content/docs/guides/media-library.mdx
+++ b/docs/src/content/docs/guides/media-library.mdx
@@ -14,6 +14,17 @@ Open the media library from the admin sidebar by clicking **Media**. The library
 
 <img src={mediaLibraryImg.src} alt="EmDash media library showing image grid with upload button" />
 
+## Used in
+
+Open a local media item's details to see which EmDash-managed entries reference it. References that EmDash has already found remain visible while existing content is still indexing.
+
+Administrators see a setup notice until Media Usage is enabled. Open **Settings → Media Usage**, select **Enable Media Usage**, then select **Turn on**. Indexing continues in the background if you leave the page, and the Settings page shows its progress.
+
+<Aside type="caution">
+	Used in results are advisory. They do not prove that a media item is universally unused or safe to
+	delete.
+</Aside>
+
 ## Uploading Files
 
 ### From the Media Library
diff --git a/docs/src/content/docs/reference/rest-api.mdx b/docs/src/content/docs/reference/rest-api.mdx
index 607e52587f..39644f27f4 100644
--- a/docs/src/content/docs/reference/rest-api.mdx
+++ b/docs/src/content/docs/reference/rest-api.mdx
@@ -366,11 +366,14 @@ DELETE /_emdash/api/media/:id
 
 ### Enable automatic media usage indexing
 
-Automatic media usage indexing must be enabled once for each production site. Writes must be
-paused while EmDash prepares each collection so that no changes are missed.
+Automatic media usage indexing must be enabled once for each production site. Pause direct database writes while EmDash prepares each collection. EmDash temporarily blocks its own content and schema writes during this step.
 
 Both endpoints require `schema:manage`. Bearer tokens also require the `admin` scope.
 
+Administrators can run the same procedure from **Settings → Media Usage** by selecting **Enable Media Usage**, then **Turn on**. The page sends one POST and displays the server-owned setup and indexing progress.
+
+Before using either flow, confirm that the Cloudflare Queue consumer or Node.js process is running.
+
 #### Check the current state
 
 ```http
@@ -385,7 +388,7 @@ This request does not change anything. It returns one of these states:
 
 Status responses do not include internal lock data or raw database errors.
 
-#### Prepare the next collection
+#### Start activation
 
 ```http
 POST /_emdash/api/admin/media-usage/activation
@@ -398,28 +401,33 @@ X-EmDash-Request: 1
 }
 ```
 
-Each request prepares one collection. Send one request at a time until the state becomes `active`.
+The request prepares at most one collection and wakes the configured Cloudflare Queue or Node.js scheduler. These standard drivers continue with bounded batches after the response, including when the client disconnects. Use `GET` to observe the stored state. With a standard driver, do not send another POST unless the stored status reports a failure that you have fixed.
+
+Custom integrations that do not wire the standard Cloudflare Queue or Node continuation can continue
+sending one POST at a time. This compatibility path retains the same collection bound.
 
 Set both fields to `true`:
 
 - `writersDrained`: Application and direct database writes have stopped, and any writes already in
   progress have finished.
-- `maintenanceReady`: Scheduled background tasks are running through `mediaUsageCron` on Cloudflare
-  or the built-in scheduler on Node.js.
+- `maintenanceReady`: The Media Usage Queue consumer is running on Cloudflare, or the built-in scheduler is running on Node.js.
 
 #### Enable indexing in production
 
-1. Confirm that scheduled background tasks are running: `mediaUsageCron` on Cloudflare, or the
-   built-in scheduler on Node.js.
-2. Stop all application and direct database writes. Wait for writes already in progress to finish.
+1. Confirm that the Media Usage Queue consumer is running on Cloudflare, or that the built-in
+   scheduler is running on Node.js.
+2. Stop all direct database writers. Wait for writes already in progress to finish. EmDash fences its own writes during setup.
 3. Call `GET` to check the current state.
-4. Call `POST` one request at a time until the state becomes `active`.
-5. Resume writes.
-6. Keep scheduled background tasks running while EmDash indexes existing content.
+4. With the standard Queue or Node driver, call `POST` once, then use `GET` until the state becomes
+   `active`. With a custom integration that does not continue activation, alternate one `POST` with
+   `GET` until the state becomes `active`.
+5. Resume writes after the state becomes `active`.
+6. Keep the Queue consumer or Node process running while EmDash indexes existing content.
 
-If `POST` times out or returns `409` or `500`, call `GET` before sending another request. If
-`lastErrorCode` is set, keep writes stopped, check the application logs, fix the problem, and try
-again. Do not edit EmDash's internal database tables.
+If `POST` times out or returns `409` or `500`, call `GET` before deciding what to do. If the state is
+still `activating` without `lastErrorCode`, the server is continuing or another worker owns the
+current batch. If `lastErrorCode` is set, keep writes stopped, check the application logs, fix the
+problem, and send one confirmed POST to retry. Do not edit EmDash's internal database tables.
 
 <Aside type="caution">
 	After this process starts, it cannot be cancelled or reset. Test it in a staging environment and
@@ -429,6 +437,18 @@ again. Do not edit EmDash's internal database tables.
 When the state is `active`, EmDash tracks changes to media references in content. Existing content
 may still be indexing in the background.
 
+#### Check historical indexing progress
+
+```http
+GET /_emdash/api/admin/media-usage/progress
+```
+
+After activation is active, this returns `indexing`, `ready`, or `needs_attention` together with the
+number of ready and total current content types. The optional `indexingStarted` field is `false`
+between activation finishing and the first current reconciliation starting. Older responses may omit
+it. The endpoint does not inspect content rows or return work-item details. It requires
+`schema:manage`; bearer tokens also require the `admin` scope.
+
 ### List Media Usage Work
 
 ```http
@@ -494,8 +514,8 @@ replaces newer work or exposes its lease token.
 The list returns only known durable work. Retry can create work for the supplied identity in an
 active collection even when no work row exists, but it does not scan for historical gaps. Use
 collection-scoped Media Usage repair after imports or direct database writes.
-When scheduled maintenance is disabled, failed jobs remain visible and manually retryable, but no
-automatic freshness deadline is promised.
+When the Media Usage Queue or Node continuation is unavailable, failed jobs remain visible and
+manually retryable, but no automatic freshness deadline is promised.
 
 ### Recover Collection Deletion
 
diff --git a/packages/admin/src/components/ConfirmDialog.tsx b/packages/admin/src/components/ConfirmDialog.tsx
index 25d370b6f9..9a29894c9b 100644
--- a/packages/admin/src/components/ConfirmDialog.tsx
+++ b/packages/admin/src/components/ConfirmDialog.tsx
@@ -23,7 +23,10 @@ export interface ConfirmDialogProps {
 	pendingLabel: string;
 	/** Button variant — defaults to "destructive" */
 	variant?: "destructive" | "primary";
+	/** Use tighter Kumo spacing for short, focused confirmations. */
+	compact?: boolean;
 	isPending: boolean;
+	disabled?: boolean;
 	/** Error from a mutation — pass mutation.error directly */
 	error: unknown;
 	onConfirm: () => void;
@@ -39,7 +42,9 @@ export function ConfirmDialog({
 	confirmLabel,
 	pendingLabel,
 	variant = "destructive",
+	compact = false,
 	isPending,
+	disabled = false,
 	error,
 	onConfirm,
 	children,
@@ -47,16 +52,28 @@ export function ConfirmDialog({
 	const { t } = useLingui();
 	return (
 		<Dialog.Root open={open} onOpenChange={(o) => !o && onClose()} disablePointerDismissal>
-			<Dialog className="p-6" size="sm">
-				<Dialog.Title className="text-lg font-semibold">{title}</Dialog.Title>
-				<Dialog.Description className="text-kumo-subtle">{description}</Dialog.Description>
+			<Dialog className={compact ? "max-w-md px-5 pt-5 pb-4" : "p-6"} size="sm">
+				<div className={compact ? "grid gap-1.5" : undefined}>
+					<Dialog.Title
+						className={compact ? "text-lg font-semibold leading-6" : "text-lg font-semibold"}
+					>
+						{title}
+					</Dialog.Title>
+					<Dialog.Description
+						className={
+							compact ? "text-sm leading-5 text-pretty text-kumo-subtle" : "text-kumo-subtle"
+						}
+					>
+						{description}
+					</Dialog.Description>
+				</div>
 				{children}
 				<DialogError message={getMutationError(error)} className="mt-3" />
-				<div className="mt-6 flex justify-end gap-2">
+				<div className={`${compact ? "mt-5" : "mt-6"} flex justify-end gap-2`}>
 					<Button variant="secondary" onClick={onClose}>
 						{t`Cancel`}
 					</Button>
-					<Button variant={variant} disabled={isPending} onClick={onConfirm}>
+					<Button variant={variant} disabled={disabled || isPending} onClick={onConfirm}>
 						{isPending ? pendingLabel : confirmLabel}
 					</Button>
 				</div>
diff --git a/packages/admin/src/components/MediaLibrary.tsx b/packages/admin/src/components/MediaLibrary.tsx
index d1f6f859a8..37e28ed285 100644
--- a/packages/admin/src/components/MediaLibrary.tsx
+++ b/packages/admin/src/components/MediaLibrary.tsx
@@ -1,4 +1,4 @@
-import { Button, Input, Loader, Select, Tabs } from "@cloudflare/kumo";
+import { Banner, Button, Input, Loader, Select, Tabs } from "@cloudflare/kumo";
 import { plural } from "@lingui/core/macro";
 import { useLingui } from "@lingui/react/macro";
 import { Upload, Images, SquaresFour, List, MagnifyingGlass } from "@phosphor-icons/react";
@@ -15,6 +15,11 @@ import {
 	fetchProviderMedia,
 	uploadToProvider,
 } from "../lib/api";
+import { useCurrentUser } from "../lib/api/current-user.js";
+import {
+	MEDIA_USAGE_ACTIVATION_QUERY_KEY,
+	fetchMediaUsageActivationStatus,
+} from "../lib/api/media-usage-activation.js";
 import { useDebouncedValue } from "../lib/hooks.js";
 import {
 	providerItemToMediaItem,
@@ -27,6 +32,7 @@ import {
 import { cn } from "../lib/utils";
 import { MediaDetailPanel } from "./MediaDetailPanel";
 import { LOCAL_MEDIA_UPLOAD_ACCEPT, MediaUploadDialog } from "./MediaUploadDialog.js";
+import { RouterLinkButton } from "./RouterLinkButton.js";
 
 /** Maps a coarse type-filter choice to the media list's `mimeType` filter. */
 function mimeForTypeFilter(value: string): string | string[] | undefined {
@@ -74,6 +80,17 @@ export function MediaLibrary({
 	onLocalMimeFilterChange,
 }: MediaLibraryProps) {
 	const { t } = useLingui();
+	const isAdmin = (useCurrentUser().data?.role ?? 0) >= 50;
+	const activationQuery = useQuery({
+		queryKey: MEDIA_USAGE_ACTIVATION_QUERY_KEY,
+		queryFn: fetchMediaUsageActivationStatus,
+		enabled: isAdmin,
+		retry: false,
+		staleTime: 60_000,
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false,
+	});
+	const setupStatus = isAdmin && !activationQuery.isError ? activationQuery.data : undefined;
 	const [viewMode, setViewMode] = React.useState<"grid" | "list">("grid");
 	const [detailItem, setDetailItem] = React.useState<MediaItem | null>(null);
 	const [isDetailOpen, setIsDetailOpen] = React.useState(false);
@@ -331,6 +348,22 @@ export function MediaLibrary({
 					)}
 				</div>
 			</div>
+			{activeProvider === "local" && setupStatus && setupStatus.state !== "active" ? (
+				<Banner
+					variant="alert"
+					title={
+						setupStatus.state === "activating"
+							? t`Media Usage is setting up`
+							: t`Set up Media Usage`
+					}
+					description={t`Index existing content and keep Used in results up to date.`}
+					action={
+						<RouterLinkButton to="/settings/media-usage" size="sm" variant="secondary">
+							{setupStatus.state === "activating" ? t`View setup` : t`Open setup`}
+						</RouterLinkButton>
+					}
+				/>
+			) : null}
 
 			{/* Provider tabs (only when an external provider is configured) */}
 			{providerTabs.length > 1 && (
diff --git a/packages/admin/src/components/Settings.tsx b/packages/admin/src/components/Settings.tsx
index 872614c2b7..6b8b6299fb 100644
--- a/packages/admin/src/components/Settings.tsx
+++ b/packages/admin/src/components/Settings.tsx
@@ -11,11 +11,13 @@ import {
 	Envelope,
 	DownloadSimple,
 	CaretDown,
+	ChartLineUp,
 } from "@phosphor-icons/react";
 import { useQuery } from "@tanstack/react-query";
 import * as React from "react";
 
 import { fetchManifest } from "../lib/api";
+import { useCurrentUser } from "../lib/api/current-user.js";
 import { SUPPORTED_LOCALES } from "../locales/index.js";
 import { useLocale } from "../locales/useLocale.js";
 import { SettingsNavRow, SettingsSection } from "./settings/SettingsLayout.js";
@@ -24,6 +26,7 @@ import { SettingsNavRow, SettingsSection } from "./settings/SettingsLayout.js";
  * Settings hub page — links to all settings sub-pages.
  */
 export function Settings() {
+	const { data: currentUser } = useCurrentUser();
 	const { data: manifest } = useQuery({
 		queryKey: ["manifest"],
 		queryFn: fetchManifest,
@@ -32,6 +35,7 @@ export function Settings() {
 	const { t } = useLingui();
 	const { locale, setLocale } = useLocale();
 	const showSecuritySettings = manifest?.authMode === "passkey";
+	const showMediaUsageSettings = (currentUser?.role ?? 0) >= 50;
 	const selectedLocale = SUPPORTED_LOCALES.find((option) => option.code === locale) ?? null;
 
 	return (
@@ -62,6 +66,17 @@ export function Settings() {
 					/>
 				</SettingsSection>
 
+				{showMediaUsageSettings ? (
+					<SettingsSection title={t`Media`}>
+						<SettingsNavRow
+							to="/settings/media-usage"
+							icon={<ChartLineUp className="h-5 w-5" />}
+							title={t`Media Usage`}
+							description={t`Track where media is used across your content`}
+						/>
+					</SettingsSection>
+				) : null}
+
 				{showSecuritySettings && (
 					<SettingsSection title={t`Security Settings`}>
 						<SettingsNavRow
diff --git a/packages/admin/src/components/settings/MediaUsageSettings.tsx b/packages/admin/src/components/settings/MediaUsageSettings.tsx
new file mode 100644
index 0000000000..9baa4327ec
--- /dev/null
+++ b/packages/admin/src/components/settings/MediaUsageSettings.tsx
@@ -0,0 +1,479 @@
+import { Badge, Banner, Button, Loader } from "@cloudflare/kumo";
+import { plural } from "@lingui/core/macro";
+import { useLingui } from "@lingui/react/macro";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import * as React from "react";
+
+import { useCurrentUser } from "../../lib/api/current-user.js";
+import {
+	MEDIA_USAGE_ACTIVATION_QUERY_KEY,
+	MediaUsageActivationRequestError,
+	advanceMediaUsageActivation,
+	fetchMediaUsageActivationStatus,
+	fetchMediaUsageProgress,
+	type MediaUsageActivationStatus,
+	type MediaUsageProgress,
+} from "../../lib/api/media-usage-activation.js";
+import { ConfirmDialog } from "../ConfirmDialog.js";
+import { SettingRow, SettingsFrame, SettingsSection } from "./SettingsLayout.js";
+
+const ROLE_ADMIN = 50;
+
+type Notice = "unconfirmed" | "version" | "validation" | "denied" | null;
+
+export function MediaUsageSettings() {
+	const { t } = useLingui();
+	const queryClient = useQueryClient();
+	const { data: currentUser, isLoading: userLoading } = useCurrentUser();
+	const isAdmin = !!currentUser && currentUser.role >= ROLE_ADMIN;
+	const [dialogOpen, setDialogOpen] = React.useState(false);
+	const [notice, setNotice] = React.useState<Notice>(null);
+	const [pageVisible, setPageVisible] = React.useState(
+		() => typeof document === "undefined" || document.visibilityState !== "hidden",
+	);
+	const submittingRef = React.useRef(false);
+	const focusAfterActionRef = React.useRef(false);
+	const stateHeadingRef = React.useRef<HTMLHeadingElement>(null);
+	const wasHiddenRef = React.useRef(false);
+
+	const activationQuery = useQuery({
+		queryKey: MEDIA_USAGE_ACTIVATION_QUERY_KEY,
+		queryFn: fetchMediaUsageActivationStatus,
+		enabled: isAdmin,
+		retry: false,
+		refetchOnMount: "always",
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false,
+		refetchInterval: (query) => {
+			const activation = query.state.data;
+			return pageVisible &&
+				query.state.status !== "error" &&
+				activation?.state === "activating" &&
+				activation.lastErrorCode === null
+				? 2_000
+				: false;
+		},
+		refetchIntervalInBackground: false,
+	});
+	const progressQuery = useQuery({
+		queryKey: ["media-usage-progress"],
+		queryFn: fetchMediaUsageProgress,
+		enabled: isAdmin && activationQuery.data?.state === "active" && !activationQuery.isError,
+		retry: false,
+		refetchInterval: (query) =>
+			pageVisible && query.state.status !== "error" && query.state.data?.status === "indexing"
+				? 2_000
+				: false,
+		refetchIntervalInBackground: false,
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false,
+	});
+
+	const closeDialog = React.useCallback(() => {
+		setDialogOpen(false);
+	}, []);
+	const refreshStatus = React.useCallback(
+		async (uncertain = false) => {
+			if (submittingRef.current) return;
+			if (uncertain) {
+				setNotice("unconfirmed");
+				closeDialog();
+			}
+			const result = await activationQuery.refetch({ cancelRefetch: false });
+			if (!result.isSuccess) return;
+			setNotice((current) => (current === "validation" || current === "version" ? current : null));
+		},
+		[activationQuery, closeDialog],
+	);
+
+	React.useEffect(() => {
+		if (!isAdmin) return;
+		const visibilityChanged = () => {
+			const visible = document.visibilityState !== "hidden";
+			setPageVisible(visible);
+			if (!visible) {
+				wasHiddenRef.current = true;
+				closeDialog();
+				return;
+			}
+			if (!wasHiddenRef.current) return;
+			wasHiddenRef.current = false;
+			const activation = activationQuery.data;
+			if (
+				activation?.state === "activating" &&
+				activation.lastErrorCode === null &&
+				!activationQuery.isError
+			) {
+				void activationQuery.refetch({ cancelRefetch: false });
+			} else if (
+				activation?.state === "active" &&
+				progressQuery.data?.status === "indexing" &&
+				!progressQuery.isError
+			) {
+				void progressQuery.refetch({ cancelRefetch: false });
+			}
+		};
+		document.addEventListener("visibilitychange", visibilityChanged);
+		return () => {
+			document.removeEventListener("visibilitychange", visibilityChanged);
+		};
+	}, [activationQuery, closeDialog, isAdmin, progressQuery]);
+
+	const advanceMutation = useMutation({
+		mutationFn: async () => {
+			await queryClient.cancelQueries({ queryKey: MEDIA_USAGE_ACTIVATION_QUERY_KEY });
+			return advanceMediaUsageActivation({ writersDrained: true, maintenanceReady: true });
+		},
+		retry: false,
+		onSuccess: (result) => {
+			queryClient.setQueryData(MEDIA_USAGE_ACTIVATION_QUERY_KEY, result.activation);
+			setNotice(null);
+			closeDialog();
+		},
+		onError: (caught) => {
+			submittingRef.current = false;
+			void handleAdvanceError(caught);
+		},
+		onSettled: () => {
+			submittingRef.current = false;
+		},
+	});
+
+	const handleAdvanceError = async (caught: unknown) => {
+		const error =
+			caught instanceof MediaUsageActivationRequestError
+				? caught
+				: new MediaUsageActivationRequestError("unknown", null);
+		closeDialog();
+		if (error.kind === "denied") return setNotice("denied");
+		if (error.kind === "version_mismatch") return setNotice("version");
+		if (error.kind === "validation") return setNotice("validation");
+		await refreshStatus(true);
+	};
+
+	const activation = activationQuery.data;
+	const active = activation?.state === "active";
+	React.useEffect(() => {
+		const heading = stateHeadingRef.current;
+		if (
+			!focusAfterActionRef.current ||
+			!pageVisible ||
+			dialogOpen ||
+			advanceMutation.isPending ||
+			!activation ||
+			!heading
+		)
+			return;
+		focusAfterActionRef.current = false;
+		heading.focus();
+	}, [activation, advanceMutation.isPending, dialogOpen, pageVisible]);
+
+	const title = t`Media Usage`;
+	const description = t`Track where media is used across your content.`;
+	if (userLoading) return <LoadingPage title={title} description={description} />;
+	if (!isAdmin || isActivationError(activationQuery.error, "denied") || notice === "denied") {
+		return (
+			<MessagePage
+				title={t`Access denied`}
+				description={t`You need Admin permissions to manage Media Usage.`}
+				message={t`Ask an administrator to complete this setup.`}
+			/>
+		);
+	}
+	if (isActivationError(activationQuery.error, "version_mismatch") || notice === "version") {
+		return (
+			<MessagePage
+				title={title}
+				description={description}
+				message={t`Keep editing paused and deploy a compatible EmDash version before continuing.`}
+			/>
+		);
+	}
+	if (notice === "validation") {
+		return (
+			<MessagePage
+				title={title}
+				description={description}
+				message={t`Reload after updating EmDash before trying again.`}
+			/>
+		);
+	}
+	if (notice === "unconfirmed") {
+		return (
+			<MessagePage
+				title={title}
+				description={description}
+				message={t`Activation cannot be confirmed. Keep editing paused and refresh the status.`}
+				action={
+					<Button size="sm" variant="secondary" onClick={() => void refreshStatus()}>
+						{t`Refresh status`}
+					</Button>
+				}
+			/>
+		);
+	}
+	const activationReadError = activationQuery.isError || activationQuery.isRefetchError;
+	if (activationReadError && !activation) {
+		return (
+			<MessagePage
+				title={title}
+				description={description}
+				message={t`Couldn’t load Media Usage settings.`}
+				action={
+					<Button size="sm" variant="secondary" onClick={() => void refreshStatus()}>
+						{t`Try again`}
+					</Button>
+				}
+			/>
+		);
+	}
+	if (activationQuery.isPending || !activation) {
+		return <LoadingPage title={title} description={description} />;
+	}
+
+	const storedFailure = activation.state === "activating" && activation.lastErrorCode !== null;
+	const canMutate = !activationReadError && (activation.state === "expanded" || storedFailure);
+	const submit = () => {
+		if (submittingRef.current) return;
+		submittingRef.current = true;
+		focusAfterActionRef.current = true;
+		advanceMutation.mutate();
+	};
+
+	return (
+		<SettingsFrame title={title} description={description}>
+			<SettingsSection
+				title={t`Automatic indexing`}
+				actions={
+					activationReadError ? (
+						<Button size="sm" variant="secondary" onClick={() => void refreshStatus()}>
+							{t`Try again`}
+						</Button>
+					) : active && progressQuery.isError ? (
+						<Button
+							size="sm"
+							variant="secondary"
+							onClick={() => void progressQuery.refetch({ cancelRefetch: false })}
+						>
+							{t`Try again`}
+						</Button>
+					) : undefined
+				}
+			>
+				<StatusRow
+					activation={activation}
+					progress={progressQuery.isError ? undefined : progressQuery.data}
+					progressError={progressQuery.isError}
+					activationError={activationReadError}
+					stateHeadingRef={stateHeadingRef}
+				/>
+				{canMutate ? (
+					<SettingRow className="flex justify-end">
+						<Button
+							className="w-full sm:w-auto"
+							disabled={advanceMutation.isPending}
+							icon={advanceMutation.isPending ? <Loader size="sm" /> : undefined}
+							onClick={() => setDialogOpen(true)}
+						>
+							{storedFailure ? t`Retry setup` : t`Enable Media Usage`}
+						</Button>
+					</SettingRow>
+				) : null}
+			</SettingsSection>
+
+			<ConfirmationDialog
+				open={dialogOpen}
+				retry={storedFailure}
+				pending={advanceMutation.isPending}
+				onOpenChange={setDialogOpen}
+				onConfirm={submit}
+			/>
+		</SettingsFrame>
+	);
+}
+
+function StatusRow({
+	activation,
+	progress,
+	progressError,
+	activationError,
+	stateHeadingRef,
+}: {
+	activation: MediaUsageActivationStatus;
+	progress: MediaUsageProgress | undefined;
+	progressError: boolean;
+	activationError: boolean;
+	stateHeadingRef: React.RefObject<HTMLHeadingElement | null>;
+}) {
+	const { t } = useLingui();
+	const active = activation.state === "active";
+	const settingUp = activation.state === "activating";
+	const storedFailure = activation.state === "activating" && activation.lastErrorCode !== null;
+	const starting =
+		active &&
+		!progressError &&
+		(!progress || (progress.status === "indexing" && progress.indexingStarted === false));
+	let heading = t`Automatic indexing is off`;
+	let detail = t`Enable Media Usage to index existing content and keep references up to date.`;
+	let badge = t`Off`;
+	let variant: "neutral" | "warning" | "success" | "error" = "neutral";
+	if (settingUp) {
+		heading = storedFailure ? t`Needs attention` : t`Setting up`;
+		detail = storedFailure
+			? t`Keep editing paused, fix the server issue, then retry setup.`
+			: t`Capture is being prepared. Keep editing paused until setup is complete.`;
+		badge = storedFailure ? t`Needs attention` : t`Setting up`;
+		variant = storedFailure ? "error" : "warning";
+	}
+	if (active) {
+		heading = progressError
+			? t`Needs attention`
+			: starting
+				? t`Starting indexing`
+				: progress?.finalizing
+					? t`Finishing setup`
+					: progress?.status === "ready"
+						? t`Ready`
+						: progress?.status === "needs_attention"
+							? t`Needs attention`
+							: t`Indexing existing content`;
+		detail = progressError
+			? t`New changes are still tracked automatically.`
+			: starting
+				? t`Background indexing is starting.`
+				: progress?.finalizing
+					? t`All existing content is indexed. Checking that Media Usage is ready.`
+					: progress
+						? plural(progress.totalCollections, {
+								one: `${progress.readyCollections} of # content type ready`,
+								other: `${progress.readyCollections} of # content types ready`,
+							})
+						: t`Background indexing is starting.`;
+		badge = progressError ? t`Needs attention` : heading;
+		variant = progressError
+			? "error"
+			: progress?.status === "ready"
+				? "success"
+				: progress?.status === "needs_attention"
+					? "error"
+					: "warning";
+	}
+	if (activationError) {
+		const lastState =
+			activation.state === "activating"
+				? t`Setting up`
+				: activation.state === "active"
+					? t`Active`
+					: t`Off`;
+		heading = t`Needs attention`;
+		detail = t`The last confirmed state was ${lastState}. Refresh status before continuing.`;
+		badge = t`Needs attention`;
+		variant = "error";
+	}
+	const progressing =
+		!activationError &&
+		((settingUp && !storedFailure) ||
+			(active && !progressError && (!progress || progress.status === "indexing")));
+	return (
+		<SettingRow>
+			<div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
+				<div className="min-w-0" role={storedFailure ? "alert" : undefined}>
+					<div className="flex items-center gap-2">
+						{progressing ? <Loader size="sm" /> : null}
+						<h3
+							ref={stateHeadingRef}
+							tabIndex={-1}
+							aria-live={storedFailure ? "off" : "polite"}
+							aria-atomic="true"
+							className="text-sm font-medium leading-5"
+						>
+							{heading}
+						</h3>
+					</div>
+					<p className="mt-0.5 max-w-2xl text-sm leading-5 text-kumo-subtle">{detail}</p>
+				</div>
+				<Badge variant={variant} className="shrink-0">
+					{badge}
+				</Badge>
+			</div>
+		</SettingRow>
+	);
+}
+
+function ConfirmationDialog({
+	open,
+	retry,
+	pending,
+	onOpenChange,
+	onConfirm,
+}: {
+	open: boolean;
+	retry: boolean;
+	pending: boolean;
+	onOpenChange: (open: boolean) => void;
+	onConfirm: () => void;
+}) {
+	const { t } = useLingui();
+	return (
+		<ConfirmDialog
+			open={open}
+			onClose={() => onOpenChange(false)}
+			title={retry ? t`Retry setup?` : t`Turn on Media Usage?`}
+			description={
+				retry
+					? t`EmDash will continue setup and resume scanning existing content. Editing may briefly pause.`
+					: t`EmDash will scan existing content to show where media is used. Setup may briefly pause editing. Once enabled, it can’t be turned off.`
+			}
+			confirmLabel={retry ? t`Retry setup` : t`Turn on`}
+			pendingLabel={retry ? t`Retrying…` : t`Turning on…`}
+			variant="primary"
+			compact
+			isPending={pending}
+			error={null}
+			onConfirm={onConfirm}
+		/>
+	);
+}
+
+function LoadingPage({ title, description }: { title: string; description: string }) {
+	const { t } = useLingui();
+	return (
+		<SettingsFrame title={title} description={description}>
+			<SettingsSection title={t`Automatic indexing`}>
+				<SettingRow>
+					<div className="flex items-center gap-2 text-sm text-kumo-subtle" role="status">
+						<Loader size="sm" />
+						{t`Loading Media Usage settings…`}
+					</div>
+				</SettingRow>
+			</SettingsSection>
+		</SettingsFrame>
+	);
+}
+
+function MessagePage({
+	title,
+	description,
+	message,
+	action,
+}: {
+	title: string;
+	description: string;
+	message: string;
+	action?: React.ReactNode;
+}) {
+	const { t } = useLingui();
+	return (
+		<SettingsFrame title={title} description={description}>
+			<SettingsSection title={t`Automatic indexing`}>
+				<SettingRow>
+					<Banner variant="error" role="alert" title={message} action={action} />
+				</SettingRow>
+			</SettingsSection>
+		</SettingsFrame>
+	);
+}
+
+function isActivationError(error: unknown, kind: MediaUsageActivationRequestError["kind"]) {
+	return error instanceof MediaUsageActivationRequestError && error.kind === kind;
+}
diff --git a/packages/admin/src/lib/api/media-usage-activation.ts b/packages/admin/src/lib/api/media-usage-activation.ts
new file mode 100644
index 0000000000..e67223ec3e
--- /dev/null
+++ b/packages/admin/src/lib/api/media-usage-activation.ts
@@ -0,0 +1,202 @@
+import { API_BASE, apiFetch } from "./client.js";
+
+const ACTIVATION_URL = `${API_BASE}/admin/media-usage/activation`;
+
+export const MEDIA_USAGE_ACTIVATION_QUERY_KEY = ["media-usage-activation"] as const;
+
+export interface MediaUsageActivationStatus {
+	state: "expanded" | "activating" | "active";
+	collectionCursor: string | null;
+	attemptCount: number;
+	drainConfirmedAt: string | null;
+	lastAttemptedAt: string | null;
+	lastErrorCode: "MEDIA_USAGE_ACTIVATION_FAILED" | null;
+	leaseExpiresAt: string | null;
+	activatedAt: string | null;
+	updatedAt: string;
+}
+
+export interface MediaUsageActivationAdvanceResponse {
+	outcome: "activating" | "active";
+	processedCollections: number;
+	activation: MediaUsageActivationStatus;
+}
+
+export interface MediaUsageProgress {
+	status: "indexing" | "ready" | "needs_attention";
+	readyCollections: number;
+	totalCollections: number;
+	indexingStarted?: boolean;
+	finalizing?: true;
+}
+
+export type MediaUsageActivationErrorKind =
+	| "busy"
+	| "ownership_conflict"
+	| "version_mismatch"
+	| "denied"
+	| "validation"
+	| "read_failure"
+	| "advance_failure"
+	| "unknown";
+
+export class MediaUsageActivationRequestError extends Error {
+	constructor(
+		readonly kind: MediaUsageActivationErrorKind,
+		readonly status: number | null,
+	) {
+		super("Media usage activation request failed");
+		this.name = "MediaUsageActivationRequestError";
+	}
+}
+
+export async function fetchMediaUsageActivationStatus(): Promise<MediaUsageActivationStatus> {
+	const response = await activationFetch(ACTIVATION_URL);
+	if (!response.ok) throw await parseActivationError(response);
+	const data = await readSuccessData(response);
+	if (!isActivationStatus(data)) throw unknownResponse(response.status);
+	return data;
+}
+
+export async function fetchMediaUsageProgress(): Promise<MediaUsageProgress> {
+	const response = await activationFetch(`${API_BASE}/admin/media-usage/progress`);
+	if (!response.ok) throw await parseActivationError(response);
+	const data = await readSuccessData(response);
+	if (!isMediaUsageProgress(data)) throw unknownResponse(response.status);
+	return data;
+}
+
+export async function advanceMediaUsageActivation(input: {
+	writersDrained: true;
+	maintenanceReady: true;
+}): Promise<MediaUsageActivationAdvanceResponse> {
+	const response = await activationFetch(ACTIVATION_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			writersDrained: input.writersDrained,
+			maintenanceReady: input.maintenanceReady,
+		}),
+	});
+	if (!response.ok) throw await parseActivationError(response);
+	const data = await readSuccessData(response);
+	if (!isAdvanceResponse(data)) throw unknownResponse(response.status);
+	return data;
+}
+
+async function activationFetch(input: string, init?: RequestInit): Promise<Response> {
+	try {
+		return await apiFetch(input, init);
+	} catch {
+		throw unknownResponse(null);
+	}
+}
+
+async function parseActivationError(response: Response): Promise<MediaUsageActivationRequestError> {
+	if (response.status === 401 || response.status === 403) {
+		return new MediaUsageActivationRequestError("denied", response.status);
+	}
+
+	const body = await readJson(response);
+	const error = isRecord(body) && isRecord(body.error) ? body.error : null;
+	const code = error && typeof error.code === "string" ? error.code : null;
+
+	switch (code) {
+		case "MEDIA_USAGE_ACTIVATION_BUSY":
+			return new MediaUsageActivationRequestError("busy", response.status);
+		case "MEDIA_USAGE_ACTIVATION_CONFLICT":
+			return new MediaUsageActivationRequestError("ownership_conflict", response.status);
+		case "MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH":
+			return new MediaUsageActivationRequestError("version_mismatch", response.status);
+		case "UNAUTHORIZED":
+		case "FORBIDDEN":
+		case "INSUFFICIENT_SCOPE":
+			return new MediaUsageActivationRequestError("denied", response.status);
+		case "VALIDATION_ERROR":
+			return new MediaUsageActivationRequestError("validation", response.status);
+		case "MEDIA_USAGE_ACTIVATION_READ_ERROR":
+			return new MediaUsageActivationRequestError("read_failure", response.status);
+		case "MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR":
+			return new MediaUsageActivationRequestError("advance_failure", response.status);
+		default:
+			return unknownResponse(response.status);
+	}
+}
+
+function unknownResponse(status: number | null): MediaUsageActivationRequestError {
+	return new MediaUsageActivationRequestError("unknown", status);
+}
+
+async function readSuccessData(response: Response): Promise<unknown> {
+	const body = await readJson(response);
+	if (!isRecord(body) || body.success !== true || !("data" in body)) return undefined;
+	return body.data;
+}
+
+async function readJson(response: Response): Promise<unknown> {
+	return response.json().catch(() => undefined);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function isNullableString(value: unknown): value is string | null {
+	return value === null || typeof value === "string";
+}
+
+function isActivationStatus(value: unknown): value is MediaUsageActivationStatus {
+	if (!isRecord(value)) return false;
+	return (
+		(value.state === "expanded" || value.state === "activating" || value.state === "active") &&
+		isNullableString(value.collectionCursor) &&
+		Number.isInteger(value.attemptCount) &&
+		typeof value.attemptCount === "number" &&
+		value.attemptCount >= 0 &&
+		isNullableString(value.drainConfirmedAt) &&
+		isNullableString(value.lastAttemptedAt) &&
+		(value.lastErrorCode === null || value.lastErrorCode === "MEDIA_USAGE_ACTIVATION_FAILED") &&
+		isNullableString(value.leaseExpiresAt) &&
+		isNullableString(value.activatedAt) &&
+		typeof value.updatedAt === "string"
+	);
+}
+
+function isAdvanceResponse(value: unknown): value is MediaUsageActivationAdvanceResponse {
+	if (!isRecord(value) || !isActivationStatus(value.activation)) return false;
+	return (
+		(value.outcome === "activating" || value.outcome === "active") &&
+		value.activation.state === value.outcome &&
+		typeof value.processedCollections === "number" &&
+		Number.isInteger(value.processedCollections) &&
+		value.processedCollections >= 0 &&
+		value.processedCollections <= 1
+	);
+}
+
+function isMediaUsageProgress(value: unknown): value is MediaUsageProgress {
+	if (
+		!isRecord(value) ||
+		(value.status !== "indexing" && value.status !== "ready" && value.status !== "needs_attention")
+	)
+		return false;
+	const ready = value.readyCollections;
+	const total = value.totalCollections;
+	const indexingStarted = value.indexingStarted;
+	const finalizing = value.finalizing;
+	if (
+		typeof ready !== "number" ||
+		!Number.isSafeInteger(ready) ||
+		ready < 0 ||
+		typeof total !== "number" ||
+		!Number.isSafeInteger(total) ||
+		total < ready ||
+		(indexingStarted !== undefined && typeof indexingStarted !== "boolean") ||
+		(indexingStarted === false && ready !== 0) ||
+		(finalizing !== undefined && finalizing !== true) ||
+		(finalizing === true &&
+			(value.status !== "indexing" || indexingStarted !== true || ready >= total))
+	)
+		return false;
+	return value.status === "needs_attention" || (value.status === "ready") === (ready === total);
+}
diff --git a/packages/admin/src/locales/en/messages.po b/packages/admin/src/locales/en/messages.po
index ba7e48494d..f5a6aa9602 100644
--- a/packages/admin/src/locales/en/messages.po
+++ b/packages/admin/src/locales/en/messages.po
@@ -203,6 +203,13 @@ msgstr "{0, plural, one {Media file} other {Media files}}"
 msgid "{0, plural, one {User} other {Users}}"
 msgstr "{0, plural, one {User} other {Users}}"
 
+#. placeholder {0}: progress.totalCollections
+#. placeholder {1}: progress.readyCollections
+#. placeholder {2}: progress.readyCollections
+#: packages/admin/src/components/settings/MediaUsageSettings.tsx:374
+msgid "{0, plural, one {{1} of # content type ready} other {{2} of # content types ready}}"
+msgstr "{0, plural, one {{1} of # content type ready} other {{2} of # content types ready}}"
+
 #. placeholder {0}: envLabel(m.key)
 #. placeholder {1}: m.required
 #. placeholder {2}: m.host
diff --git a/packages/admin/src/locales/loadMessages.ts b/packages/admin/src/locales/loadMessages.ts
index aa16230b53..1398cb56dd 100644
--- a/packages/admin/src/locales/loadMessages.ts
+++ b/packages/admin/src/locales/loadMessages.ts
@@ -7,12 +7,17 @@ const LOCALE_LOADERS = import.meta.glob<{ messages: Messages }>("./**/messages.m
 export async function loadMessages(locale: string): Promise<Messages> {
 	const key = `./${locale}/messages.mjs`;
 	const fallbackKey = `./${DEFAULT_LOCALE}/messages.mjs`;
-	const loader = LOCALE_LOADERS[key] ?? LOCALE_LOADERS[fallbackKey];
-	if (!loader) {
+	const fallbackLoader = LOCALE_LOADERS[fallbackKey];
+	if (!fallbackLoader) {
 		throw new Error(
 			`No locale catalog found for "${locale}" or "${DEFAULT_LOCALE}". Run \`pnpm locale:compile\` to generate catalogs.`,
 		);
 	}
-	const { messages } = await loader();
-	return messages;
+	const loader = LOCALE_LOADERS[key] ?? fallbackLoader;
+	if (loader === fallbackLoader) return (await loader()).messages;
+	const [{ messages: fallbackMessages }, { messages }] = await Promise.all([
+		fallbackLoader(),
+		loader(),
+	]);
+	return { ...fallbackMessages, ...messages };
 }
diff --git a/packages/admin/src/router.tsx b/packages/admin/src/router.tsx
index 5e5bf38568..55ed361661 100644
--- a/packages/admin/src/router.tsx
+++ b/packages/admin/src/router.tsx
@@ -56,6 +56,7 @@ import { ApiTokenSettings } from "./components/settings/ApiTokenSettings";
 import { BackupSettings } from "./components/settings/BackupSettings";
 import { EmailSettings } from "./components/settings/EmailSettings";
 import { GeneralSettings } from "./components/settings/GeneralSettings";
+import { MediaUsageSettings } from "./components/settings/MediaUsageSettings";
 import { SecuritySettings } from "./components/settings/SecuritySettings";
 import { SeoSettings } from "./components/settings/SeoSettings";
 import { SocialSettings } from "./components/settings/SocialSettings";
@@ -1599,6 +1600,12 @@ const settingsRoute = createRoute({
 	component: Settings,
 });
 
+const mediaUsageSettingsRoute = createRoute({
+	getParentRoute: () => adminLayoutRoute,
+	path: "/settings/media-usage",
+	component: MediaUsageSettings,
+});
+
 // Security settings route
 const securitySettingsRoute = createRoute({
 	getParentRoute: () => adminLayoutRoute,
@@ -2181,6 +2188,7 @@ const adminRoutes = adminLayoutRoute.addChildren([
 	bylineSchemaRoute,
 	widgetsRoute,
 	settingsRoute,
+	mediaUsageSettingsRoute,
 	generalSettingsRoute,
 	socialSettingsRoute,
 	seoSettingsRoute,
diff --git a/packages/admin/tests/components/MediaLibrary.test.tsx b/packages/admin/tests/components/MediaLibrary.test.tsx
index 8c28ea21b7..ab917516f9 100644
--- a/packages/admin/tests/components/MediaLibrary.test.tsx
+++ b/packages/admin/tests/components/MediaLibrary.test.tsx
@@ -14,6 +14,24 @@ import { render } from "../utils/render.tsx";
 const UPLOAD_CTA_PATTERN = /Upload images, videos, and documents to keep reusable assets/;
 const UPLOAD_TO_LIBRARY_PATTERN = /Upload to Library/;
 const UPLOAD_FILES_PATTERN = /Upload Files/;
+const setupMocks = vi.hoisted(() => ({ fetchStatus: vi.fn(), role: 40 }));
+
+vi.mock("../../src/lib/api/media-usage-activation.js", async () => {
+	const actual = await vi.importActual<
+		typeof import("../../src/lib/api/media-usage-activation.js")
+	>("../../src/lib/api/media-usage-activation.js");
+	return { ...actual, fetchMediaUsageActivationStatus: setupMocks.fetchStatus };
+});
+
+vi.mock("../../src/lib/api/current-user.js", () => ({
+	useCurrentUser: () => ({ data: { id: "user-1", role: setupMocks.role } }),
+}));
+
+vi.mock("../../src/components/RouterLinkButton.js", () => ({
+	RouterLinkButton: ({ to, children }: { to: string; children: React.ReactNode }) => (
+		<a href={to}>{children}</a>
+	),
+}));
 
 function setInputFiles(input: HTMLInputElement, files: File[]) {
 	const transfer = new DataTransfer();
@@ -81,6 +99,45 @@ function makeMediaItem(overrides: Partial<MediaItem> = {}): MediaItem {
 describe("MediaLibrary", () => {
 	beforeEach(() => {
 		vi.clearAllMocks();
+		setupMocks.role = 40;
+		setupMocks.fetchStatus.mockResolvedValue({ state: "active" });
+	});
+
+	describe("Media Usage setup discovery", () => {
+		it("shows an administrator one setup action while activation is off", async () => {
+			setupMocks.role = 50;
+			setupMocks.fetchStatus.mockResolvedValue({ state: "expanded" });
+
+			const screen = await renderLibrary();
+
+			await expect.element(screen.getByText("Set up Media Usage")).toBeInTheDocument();
+			await expect.element(screen.getByRole("link", { name: "Open setup" })).toBeInTheDocument();
+		});
+
+		it("links to the automatic setup status while activation is running", async () => {
+			setupMocks.role = 50;
+			setupMocks.fetchStatus.mockResolvedValue({ state: "activating" });
+
+			const screen = await renderLibrary();
+
+			await expect.element(screen.getByText("Media Usage is setting up")).toBeInTheDocument();
+			await expect.element(screen.getByRole("link", { name: "View setup" })).toBeInTheDocument();
+		});
+
+		it("keeps the library usable when optional setup discovery fails", async () => {
+			setupMocks.role = 50;
+			setupMocks.fetchStatus.mockRejectedValue(new Error("status unavailable"));
+
+			const screen = await renderLibrary({
+				items: [makeMediaItem({ id: "1", filename: "still-usable.jpg" })],
+			});
+
+			await expect.element(screen.getByAltText("still-usable.jpg")).toBeInTheDocument();
+			await expect
+				.element(screen.getByRole("button", { name: UPLOAD_TO_LIBRARY_PATTERN }))
+				.toBeInTheDocument();
+			expect(screen.getByText("Set up Media Usage").query()).toBeNull();
+		});
 	});
 
 	describe("rendering items", () => {
diff --git a/packages/admin/tests/components/Settings.test.tsx b/packages/admin/tests/components/Settings.test.tsx
index 317f98dd28..04a3b7e9d8 100644
--- a/packages/admin/tests/components/Settings.test.tsx
+++ b/packages/admin/tests/components/Settings.test.tsx
@@ -22,6 +22,7 @@ vi.mock("@tanstack/react-router", async () => {
 
 const mockFetchManifest = vi.fn<() => Promise<AdminManifest>>();
 const mockSetLocale = vi.fn<(locale: string) => void>();
+const currentUser = vi.hoisted(() => ({ role: 50 }));
 
 vi.mock("../../src/lib/api", async () => {
 	const actual = await vi.importActual("../../src/lib/api");
@@ -35,6 +36,13 @@ vi.mock("../../src/locales/useLocale.js", () => ({
 	useLocale: () => ({ locale: "en", setLocale: mockSetLocale }),
 }));
 
+vi.mock("../../src/lib/api/current-user.js", () => ({
+	useCurrentUser: () => ({
+		data: { id: "user-1", email: "admin@example.com", role: currentUser.role },
+		isLoading: false,
+	}),
+}));
+
 // Import after mocks
 const { Settings } = await import("../../src/components/Settings");
 
@@ -57,6 +65,7 @@ function Wrapper({ children }: { children: React.ReactNode }) {
 describe("Settings", () => {
 	beforeEach(() => {
 		vi.clearAllMocks();
+		currentUser.role = 50;
 		mockFetchManifest.mockResolvedValue(defaultManifest);
 	});
 
@@ -92,6 +101,23 @@ describe("Settings", () => {
 		await expect.element(screen.getByText("Email", { exact: true })).toBeInTheDocument();
 	});
 
+	it("shows Media Usage setup only to administrators", async () => {
+		const admin = await render(
+			<Wrapper>
+				<Settings />
+			</Wrapper>,
+		);
+		await expect.element(admin.getByRole("link", { name: /Media Usage/ })).toBeInTheDocument();
+
+		currentUser.role = 40;
+		const editor = await render(
+			<Wrapper>
+				<Settings />
+			</Wrapper>,
+		);
+		expect(editor.getByRole("link", { name: /Media Usage/ }).query()).toBeNull();
+	});
+
 	it("groups settings into clear semantic sections", async () => {
 		const screen = await render(
 			<Wrapper>
diff --git a/packages/admin/tests/components/settings/MediaUsageSettings.test.tsx b/packages/admin/tests/components/settings/MediaUsageSettings.test.tsx
new file mode 100644
index 0000000000..0b3483d9bf
--- /dev/null
+++ b/packages/admin/tests/components/settings/MediaUsageSettings.test.tsx
@@ -0,0 +1,532 @@
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import * as React from "react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { userEvent } from "vitest/browser";
+
+import { render } from "../../utils/render.tsx";
+
+const activationMocks = vi.hoisted(() => ({
+	fetchStatus: vi.fn(),
+	fetchProgress: vi.fn(),
+	advance: vi.fn(),
+}));
+const currentUserMock = vi.hoisted(() => vi.fn());
+
+vi.mock("../../../src/lib/api/media-usage-activation.js", async () => {
+	const actual = await vi.importActual<
+		typeof import("../../../src/lib/api/media-usage-activation.js")
+	>("../../../src/lib/api/media-usage-activation.js");
+	return {
+		...actual,
+		fetchMediaUsageActivationStatus: activationMocks.fetchStatus,
+		fetchMediaUsageProgress: activationMocks.fetchProgress,
+		advanceMediaUsageActivation: activationMocks.advance,
+	};
+});
+
+vi.mock("../../../src/lib/api/current-user.js", () => ({
+	useCurrentUser: currentUserMock,
+}));
+
+vi.mock("../../../src/components/settings/BackToSettingsLink.js", () => ({
+	BackToSettingsLink: () => <a href="/settings">Back to Settings</a>,
+}));
+
+const { MEDIA_USAGE_ACTIVATION_QUERY_KEY, MediaUsageActivationRequestError } =
+	await import("../../../src/lib/api/media-usage-activation.js");
+const { MediaUsageSettings } =
+	await import("../../../src/components/settings/MediaUsageSettings.js");
+
+type ActivationState = "expanded" | "activating" | "active";
+
+function status(state: ActivationState, options: { failed?: boolean } = {}) {
+	return {
+		state,
+		collectionCursor: state === "activating" ? "posts" : null,
+		attemptCount: state === "expanded" ? 0 : 1,
+		drainConfirmedAt: state === "expanded" ? null : "2026-08-16T09:00:00.000Z",
+		lastAttemptedAt: state === "expanded" ? null : "2026-08-16T09:00:00.000Z",
+		lastErrorCode: options.failed ? ("MEDIA_USAGE_ACTIVATION_FAILED" as const) : null,
+		leaseExpiresAt: null,
+		activatedAt: state === "active" ? "2026-08-16T09:00:01.000Z" : null,
+		updatedAt: "2026-08-16T09:00:01.000Z",
+	};
+}
+
+function setCurrentUser(role: number | null, isLoading = false) {
+	currentUserMock.mockReturnValue({
+		data: role === null ? null : { id: "user-1", email: "admin@example.com", role },
+		isLoading,
+	});
+}
+
+async function renderPage() {
+	const queryClient = new QueryClient({
+		defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+	});
+	const screen = await render(
+		<QueryClientProvider client={queryClient}>
+			<MediaUsageSettings />
+		</QueryClientProvider>,
+	);
+	return { queryClient, screen };
+}
+
+async function openConfirmation(screen: Awaited<ReturnType<typeof renderPage>>["screen"]) {
+	await userEvent.click(screen.getByRole("button", { name: "Enable Media Usage" }));
+	await expect.element(screen.getByRole("dialog", { name: "Turn on Media Usage?" })).toBeVisible();
+	await expect
+		.element(
+			screen.getByText(
+				"EmDash will scan existing content to show where media is used. Setup may briefly pause editing. Once enabled, it can’t be turned off.",
+			),
+		)
+		.toBeVisible();
+}
+
+async function submitConfirmation(screen: Awaited<ReturnType<typeof renderPage>>["screen"]) {
+	const confirm = screen.getByRole("dialog", { name: "Turn on Media Usage?" }).getByRole("button", {
+		name: "Turn on",
+	});
+	confirm.element().focus();
+	await userEvent.keyboard("{Enter}");
+}
+
+describe("MediaUsageSettings", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		setCurrentUser(50);
+		activationMocks.fetchStatus.mockResolvedValue(status("expanded"));
+		activationMocks.fetchProgress.mockResolvedValue({
+			status: "indexing",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+		vi.restoreAllMocks();
+	});
+
+	it("denies a direct Editor visit before requesting activation status", async () => {
+		setCurrentUser(40);
+
+		const { screen } = await renderPage();
+
+		await expect
+			.element(screen.getByRole("heading", { name: "Access denied" }))
+			.toBeInTheDocument();
+		expect(activationMocks.fetchStatus).not.toHaveBeenCalled();
+		expect(screen.getByRole("button", { name: "Enable Media Usage" }).query()).toBeNull();
+	});
+
+	it("uses one native confirmation before enabling Media Usage", async () => {
+		const activating = status("activating");
+		activationMocks.advance.mockResolvedValue({
+			outcome: "activating",
+			processedCollections: 1,
+			activation: activating,
+		});
+		const { queryClient, screen } = await renderPage();
+
+		await expect.element(screen.getByText("Automatic indexing is off")).toBeInTheDocument();
+		expect(screen.getByRole("checkbox").query()).toBeNull();
+		await openConfirmation(screen);
+		const confirm = screen
+			.getByRole("dialog", { name: "Turn on Media Usage?" })
+			.getByRole("button", { name: "Turn on" });
+		await expect.element(confirm).toBeEnabled();
+		expect(screen.getByRole("checkbox").query()).toBeNull();
+		confirm.element().focus();
+		await userEvent.keyboard("{Enter}");
+
+		await expect.element(screen.getByRole("heading", { name: "Setting up" })).toBeInTheDocument();
+		expect(screen.getByRole("button", { name: /setup/i }).query()).toBeNull();
+		expect(screen.getByRole("dialog").query()).toBeNull();
+		expect(activationMocks.advance).toHaveBeenCalledOnce();
+		expect(activationMocks.advance).toHaveBeenCalledWith({
+			writersDrained: true,
+			maintenanceReady: true,
+		});
+		expect(activationMocks.fetchStatus).toHaveBeenCalledOnce();
+		expect(queryClient.getQueryData(MEDIA_USAGE_ACTIVATION_QUERY_KEY)).toEqual(activating);
+	});
+
+	it("blocks duplicate activation and renders the confirmed active state", async () => {
+		let resolveAdvance!: (value: unknown) => void;
+		activationMocks.advance.mockImplementation(
+			() => new Promise((resolve) => (resolveAdvance = resolve)),
+		);
+		const { screen } = await renderPage();
+		await openConfirmation(screen);
+
+		await submitConfirmation(screen);
+		const pending = screen.getByRole("button", { name: "Turning on…" });
+		await expect.element(pending).toBeDisabled();
+		pending.element().click();
+		expect(activationMocks.advance).toHaveBeenCalledOnce();
+		window.dispatchEvent(new PageTransitionEvent("pagehide"));
+		window.dispatchEvent(new PageTransitionEvent("pageshow"));
+		expect(activationMocks.fetchStatus).toHaveBeenCalledOnce();
+
+		resolveAdvance({ outcome: "active", processedCollections: 1, activation: status("active") });
+		await expect
+			.element(screen.getByRole("heading", { name: "Indexing existing content" }))
+			.toBeInTheDocument();
+		expect(screen.getByRole("button", { name: /setup/i }).query()).toBeNull();
+	});
+
+	it("returns focus to the enable action when the dialog is cancelled", async () => {
+		const { screen } = await renderPage();
+		const trigger = screen.getByRole("button", { name: "Enable Media Usage" });
+		await expect.element(trigger).toBeVisible();
+		trigger.element().focus();
+		await userEvent.keyboard("{Enter}");
+		await expect
+			.element(screen.getByRole("dialog", { name: "Turn on Media Usage?" }))
+			.toBeVisible();
+		const cancel = screen.getByRole("button", { name: "Cancel" });
+		cancel.element().focus();
+		await userEvent.keyboard("{Enter}");
+
+		await expect.element(screen.getByRole("dialog")).not.toBeInTheDocument();
+		expect(document.activeElement).toBe(trigger.element());
+	});
+
+	it("closes the confirmation when the page is hidden", async () => {
+		let visibility: DocumentVisibilityState = "visible";
+		vi.spyOn(document, "visibilityState", "get").mockImplementation(() => visibility);
+		const { screen } = await renderPage();
+		await openConfirmation(screen);
+
+		visibility = "hidden";
+		document.dispatchEvent(new Event("visibilitychange"));
+		await expect.element(screen.getByRole("dialog")).not.toBeInTheDocument();
+	});
+
+	it("recovers an ambiguous activation response with one status read", async () => {
+		activationMocks.advance.mockRejectedValue(
+			new MediaUsageActivationRequestError("advance_failure", 500),
+		);
+		const { screen } = await renderPage();
+		await openConfirmation(screen);
+		activationMocks.fetchStatus.mockResolvedValue(status("active"));
+
+		await submitConfirmation(screen);
+
+		await expect
+			.element(screen.getByRole("heading", { name: "Indexing existing content" }))
+			.toBeInTheDocument();
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(2);
+		expect(activationMocks.advance).toHaveBeenCalledOnce();
+	});
+
+	it("keeps writers paused when an ambiguous response cannot be confirmed", async () => {
+		activationMocks.advance.mockRejectedValue(
+			new MediaUsageActivationRequestError("advance_failure", 500),
+		);
+		const { screen } = await renderPage();
+		await openConfirmation(screen);
+		activationMocks.fetchStatus.mockRejectedValue(
+			new MediaUsageActivationRequestError("read_failure", 500),
+		);
+
+		await submitConfirmation(screen);
+
+		await expect
+			.element(
+				screen.getByText(
+					"Activation cannot be confirmed. Keep editing paused and refresh the status.",
+				),
+			)
+			.toBeInTheDocument();
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(2);
+	});
+
+	it("keeps validation blocking after leaving and returning", async () => {
+		activationMocks.advance.mockRejectedValue(
+			new MediaUsageActivationRequestError("validation", 400),
+		);
+		const { screen } = await renderPage();
+		await openConfirmation(screen);
+		await submitConfirmation(screen);
+		await expect
+			.element(screen.getByText("Reload after updating EmDash before trying again."))
+			.toBeInTheDocument();
+
+		activationMocks.fetchStatus.mockResolvedValue(status("activating"));
+		window.dispatchEvent(new PageTransitionEvent("pagehide"));
+		window.dispatchEvent(new PageTransitionEvent("pageshow"));
+
+		await expect
+			.element(screen.getByText("Reload after updating EmDash before trying again."))
+			.toBeInTheDocument();
+		expect(activationMocks.advance).toHaveBeenCalledOnce();
+	});
+
+	it("does not move focus when an already-active page first loads", async () => {
+		activationMocks.fetchStatus.mockResolvedValue(status("active"));
+
+		const { screen } = await renderPage();
+		const heading = screen.getByRole("heading", { name: "Indexing existing content" });
+		await expect.element(heading).toBeInTheDocument();
+		expect(document.activeElement).not.toBe(heading.element());
+	});
+
+	it.each([
+		["indexing", "Indexing existing content", "1 of 2 content types ready"],
+		["ready", "Ready", "2 of 2 content types ready"],
+		["needs_attention", "Needs attention", "1 of 2 content types ready"],
+	] as const)("shows %s progress after activation", async (progressStatus, heading, summary) => {
+		activationMocks.fetchStatus.mockResolvedValue(status("active"));
+		activationMocks.fetchProgress.mockResolvedValue({
+			status: progressStatus,
+			readyCollections: progressStatus === "ready" ? 2 : 1,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+
+		const { screen } = await renderPage();
+
+		await expect.element(screen.getByRole("heading", { name: heading })).toBeInTheDocument();
+		await expect.element(screen.getByText(summary)).toBeInTheDocument();
+		expect(activationMocks.fetchProgress).toHaveBeenCalledOnce();
+		if (progressStatus === "needs_attention") {
+			expect(screen.getByRole("button", { name: "Retry setup" }).query()).toBeNull();
+		}
+	});
+
+	it("shows finalization after existing content is indexed", async () => {
+		activationMocks.fetchStatus.mockResolvedValue(status("active"));
+		activationMocks.fetchProgress.mockResolvedValue({
+			status: "indexing",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+			finalizing: true,
+		});
+
+		const { screen } = await renderPage();
+
+		await expect.element(screen.getByRole("heading", { name: "Finishing setup" })).toBeVisible();
+		await expect
+			.element(
+				screen.getByText("All existing content is indexed. Checking that Media Usage is ready."),
+			)
+			.toBeVisible();
+	});
+
+	it("shows startup before historical reconciliation begins", async () => {
+		activationMocks.fetchStatus.mockResolvedValue(status("active"));
+		activationMocks.fetchProgress.mockResolvedValue({
+			status: "indexing",
+			readyCollections: 0,
+			totalCollections: 2,
+			indexingStarted: false,
+		});
+
+		const { screen } = await renderPage();
+
+		await expect.element(screen.getByRole("heading", { name: "Starting indexing" })).toBeVisible();
+	});
+
+	it("treats an older progress response as indexing rather than startup", async () => {
+		activationMocks.fetchStatus.mockResolvedValue(status("active"));
+		activationMocks.fetchProgress.mockResolvedValue({
+			status: "indexing",
+			readyCollections: 0,
+			totalCollections: 2,
+		});
+
+		const { screen } = await renderPage();
+
+		await expect
+			.element(screen.getByRole("heading", { name: "Indexing existing content" }))
+			.toBeVisible();
+	});
+
+	it("shows Retry setup only for a stored activation failure", async () => {
+		activationMocks.fetchStatus.mockResolvedValue(status("activating", { failed: true }));
+
+		const { screen } = await renderPage();
+
+		await expect.element(screen.getByRole("heading", { name: "Needs attention" })).toBeVisible();
+		await userEvent.click(screen.getByRole("button", { name: "Retry setup" }));
+		const dialog = screen.getByRole("dialog", { name: "Retry setup?" });
+		await expect.element(dialog).toBeVisible();
+		await expect.element(dialog.getByRole("button", { name: "Retry setup" })).toBeEnabled();
+		expect(dialog.getByRole("checkbox").query()).toBeNull();
+	});
+
+	it("shows no mutation action while ordinary activation is progressing", async () => {
+		activationMocks.fetchStatus.mockResolvedValue(status("activating"));
+
+		const { screen } = await renderPage();
+
+		await expect.element(screen.getByRole("heading", { name: "Setting up" })).toBeVisible();
+		expect(screen.getByRole("button", { name: /setup/i }).query()).toBeNull();
+	});
+
+	it("keeps active setup visible when progress cannot be loaded", async () => {
+		activationMocks.fetchStatus.mockResolvedValue(status("active"));
+		activationMocks.fetchProgress.mockRejectedValue(
+			new MediaUsageActivationRequestError("read_failure", 500),
+		);
+
+		const { screen } = await renderPage();
+
+		await expect.element(screen.getByRole("heading", { name: "Needs attention" })).toBeVisible();
+		await expect.element(screen.getByRole("button", { name: "Try again" })).toBeInTheDocument();
+		expect(screen.getByRole("button", { name: /setup/i }).query()).toBeNull();
+	});
+
+	it("follows another owner after a busy response without another mutation", async () => {
+		activationMocks.advance.mockRejectedValue(new MediaUsageActivationRequestError("busy", 409));
+		activationMocks.fetchStatus
+			.mockResolvedValueOnce(status("expanded"))
+			.mockResolvedValue(status("activating"));
+		const { screen } = await renderPage();
+		await openConfirmation(screen);
+		await submitConfirmation(screen);
+
+		await expect.element(screen.getByRole("heading", { name: "Setting up" })).toBeVisible();
+		expect(screen.getByRole("button", { name: "Retry setup" }).query()).toBeNull();
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(2);
+		expect(activationMocks.advance).toHaveBeenCalledOnce();
+	});
+
+	it("moves focus to the recovered state after a slow busy status read", async () => {
+		activationMocks.advance.mockRejectedValue(new MediaUsageActivationRequestError("busy", 409));
+		let finishStatus!: (value: ReturnType<typeof status>) => void;
+		activationMocks.fetchStatus
+			.mockResolvedValueOnce(status("expanded"))
+			.mockImplementation(() => new Promise((resolve) => (finishStatus = resolve)));
+		const { screen } = await renderPage();
+		await openConfirmation(screen);
+		await submitConfirmation(screen);
+		await expect.element(screen.getByRole("button", { name: "Refresh status" })).toBeVisible();
+
+		finishStatus(status("activating"));
+		const heading = screen.getByRole("heading", { name: "Setting up" });
+		await expect.element(heading).toBeVisible();
+		expect(document.activeElement).toBe(heading.element());
+	});
+
+	it("polls activation every two seconds and stops after it becomes active", async () => {
+		vi.useFakeTimers();
+		let current = status("activating");
+		activationMocks.fetchStatus.mockImplementation(async () => current);
+		const { screen } = await renderPage();
+		await expect.element(screen.getByRole("heading", { name: "Setting up" })).toBeVisible();
+		expect(activationMocks.fetchStatus).toHaveBeenCalledOnce();
+
+		await vi.advanceTimersByTimeAsync(2_000);
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(2);
+		current = status("active");
+		await vi.advanceTimersByTimeAsync(2_000);
+		await expect
+			.element(screen.getByRole("heading", { name: "Indexing existing content" }))
+			.toBeVisible();
+		const completedCalls = activationMocks.fetchStatus.mock.calls.length;
+
+		await vi.advanceTimersByTimeAsync(4_000);
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(completedCalls);
+	});
+
+	it("polls indexing every two seconds and stops when it is ready", async () => {
+		vi.useFakeTimers();
+		activationMocks.fetchStatus.mockResolvedValue(status("active"));
+		let progress: {
+			status: "indexing" | "ready";
+			readyCollections: number;
+			totalCollections: number;
+			indexingStarted: boolean;
+		} = {
+			status: "indexing",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+		};
+		activationMocks.fetchProgress.mockImplementation(async () => progress);
+		const { screen } = await renderPage();
+		await expect
+			.element(screen.getByRole("heading", { name: "Indexing existing content" }))
+			.toBeVisible();
+
+		progress = {
+			status: "ready",
+			readyCollections: 2,
+			totalCollections: 2,
+			indexingStarted: true,
+		};
+		await vi.advanceTimersByTimeAsync(2_000);
+		await expect.element(screen.getByRole("heading", { name: "Ready" })).toBeVisible();
+		const completedCalls = activationMocks.fetchProgress.mock.calls.length;
+
+		await vi.advanceTimersByTimeAsync(4_000);
+		expect(activationMocks.fetchProgress).toHaveBeenCalledTimes(completedCalls);
+	});
+
+	it("pauses polling while hidden and refreshes immediately on return", async () => {
+		vi.useFakeTimers();
+		let visibility: DocumentVisibilityState = "visible";
+		vi.spyOn(document, "visibilityState", "get").mockImplementation(() => visibility);
+		activationMocks.fetchStatus.mockResolvedValue(status("activating"));
+		const { screen } = await renderPage();
+		await expect.element(screen.getByRole("heading", { name: "Setting up" })).toBeVisible();
+
+		visibility = "hidden";
+		document.dispatchEvent(new Event("visibilitychange"));
+		await vi.advanceTimersByTimeAsync(4_000);
+		expect(activationMocks.fetchStatus).toHaveBeenCalledOnce();
+
+		visibility = "visible";
+		document.dispatchEvent(new Event("visibilitychange"));
+		await vi.advanceTimersByTimeAsync(0);
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(2);
+	});
+
+	it("does not duplicate a slow poll when visibility returns", async () => {
+		vi.useFakeTimers();
+		let visibility: DocumentVisibilityState = "visible";
+		vi.spyOn(document, "visibilityState", "get").mockImplementation(() => visibility);
+		let finishPoll!: (value: ReturnType<typeof status>) => void;
+		activationMocks.fetchStatus
+			.mockResolvedValueOnce(status("activating"))
+			.mockImplementation(() => new Promise((resolve) => (finishPoll = resolve)));
+		const { screen } = await renderPage();
+		await expect.element(screen.getByRole("heading", { name: "Setting up" })).toBeVisible();
+
+		await vi.advanceTimersByTimeAsync(2_000);
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(2);
+		visibility = "hidden";
+		document.dispatchEvent(new Event("visibilitychange"));
+		visibility = "visible";
+		document.dispatchEvent(new Event("visibilitychange"));
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(2);
+		finishPoll(status("activating"));
+		await vi.advanceTimersByTimeAsync(0);
+	});
+
+	it("keeps the confirmed activation context when a poll fails", async () => {
+		vi.useFakeTimers();
+		activationMocks.fetchStatus
+			.mockResolvedValueOnce(status("activating"))
+			.mockRejectedValue(new MediaUsageActivationRequestError("read_failure", 500));
+		const { screen } = await renderPage();
+		await expect.element(screen.getByRole("heading", { name: "Setting up" })).toBeVisible();
+
+		await vi.advanceTimersByTimeAsync(2_000);
+
+		await expect.element(screen.getByRole("heading", { name: "Needs attention" })).toBeVisible();
+		await expect.element(screen.getByText(/last confirmed state was Setting up/)).toBeVisible();
+		await expect.element(screen.getByRole("button", { name: "Try again" })).toBeVisible();
+		const failedCalls = activationMocks.fetchStatus.mock.calls.length;
+		await vi.advanceTimersByTimeAsync(4_000);
+		expect(activationMocks.fetchStatus).toHaveBeenCalledTimes(failedCalls);
+	});
+});
diff --git a/packages/admin/tests/lib/locales.test.ts b/packages/admin/tests/lib/locales.test.ts
index 25ff7241ed..7af1756a37 100644
--- a/packages/admin/tests/lib/locales.test.ts
+++ b/packages/admin/tests/lib/locales.test.ts
@@ -1,3 +1,4 @@
+import { setupI18n } from "@lingui/core";
 import { describe, expect, test } from "vitest";
 
 import {
@@ -22,6 +23,25 @@ test("loadMessages falls back to English for unknown locale", async () => {
 	expect(fallback).toEqual(english);
 });
 
+test("formats the Media Usage progress plural from the production English catalog", async () => {
+	const catalog = await loadMessages("en");
+	expect(catalog.zRXzWv).toBeDefined();
+	expect(Array.isArray(catalog.zRXzWv)).toBe(true);
+	const germanCatalog = await loadMessages("de");
+	expect(germanCatalog.zRXzWv).toEqual(catalog.zRXzWv);
+	const productionI18n = setupI18n();
+	productionI18n.loadAndActivate({ locale: "en", messages: catalog });
+
+	expect(
+		productionI18n._({
+			id: "zRXzWv",
+			message:
+				"{0, plural, one {{1} of # content type ready} other {{2} of # content types ready}}",
+			values: { 0: 2, 1: 1, 2: 1 },
+		}),
+	).toBe("1 of 2 content types ready");
+});
+
 // -- getLocaleDir ----------------------------------------------------------
 
 describe("getLocaleDir", () => {
diff --git a/packages/admin/tests/lib/media-usage-activation-api.test.ts b/packages/admin/tests/lib/media-usage-activation-api.test.ts
new file mode 100644
index 0000000000..d25ca4e681
--- /dev/null
+++ b/packages/admin/tests/lib/media-usage-activation-api.test.ts
@@ -0,0 +1,297 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+	MediaUsageActivationRequestError,
+	advanceMediaUsageActivation,
+	fetchMediaUsageActivationStatus,
+	fetchMediaUsageProgress,
+} from "../../src/lib/api/media-usage-activation.js";
+
+const activationUrl = "/_emdash/api/admin/media-usage/activation";
+const progressUrl = "/_emdash/api/admin/media-usage/progress";
+
+function activationStatus(state: "expanded" | "activating" | "active" = "expanded") {
+	return {
+		state,
+		collectionCursor: state === "activating" ? "posts" : null,
+		attemptCount: state === "expanded" ? 0 : 1,
+		drainConfirmedAt: state === "expanded" ? null : "2026-08-16T09:00:00.000Z",
+		lastAttemptedAt: state === "expanded" ? null : "2026-08-16T09:00:00.000Z",
+		lastErrorCode: null,
+		leaseExpiresAt: null,
+		activatedAt: state === "active" ? "2026-08-16T09:00:01.000Z" : null,
+		updatedAt: "2026-08-16T09:00:01.000Z",
+	} as const;
+}
+
+function success(data: unknown): Response {
+	return Response.json({ success: true, data });
+}
+
+function failure(status: number, code: string, details?: unknown): Response {
+	return Response.json(
+		{
+			success: false,
+			error: { code, message: "private server detail", ...(details ? { details } : {}) },
+		},
+		{ status },
+	);
+}
+
+async function caught(run: () => Promise<unknown>): Promise<MediaUsageActivationRequestError> {
+	const error = await run().catch((value: unknown) => value);
+	expect(error).toBeInstanceOf(MediaUsageActivationRequestError);
+	return error as MediaUsageActivationRequestError;
+}
+
+describe("media usage activation admin API", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("reads and validates every public activation status field", async () => {
+		const data = activationStatus("activating");
+		const fetch = vi.spyOn(globalThis, "fetch").mockResolvedValue(success(data));
+
+		await expect(fetchMediaUsageActivationStatus()).resolves.toEqual(data);
+		expect(fetch).toHaveBeenCalledOnce();
+		expect(fetch.mock.calls[0]?.[0]).toBe(activationUrl);
+		const headers = new Headers(fetch.mock.calls[0]?.[1]?.headers);
+		expect(headers.get("X-EmDash-Request")).toBe("1");
+	});
+
+	it("reads validated aggregate indexing progress", async () => {
+		const data = {
+			status: "indexing",
+			readyCollections: 0,
+			totalCollections: 2,
+			indexingStarted: false,
+		} as const;
+		const fetch = vi.spyOn(globalThis, "fetch").mockResolvedValue(success(data));
+
+		await expect(fetchMediaUsageProgress()).resolves.toEqual(data);
+		expect(fetch.mock.calls[0]?.[0]).toBe(progressUrl);
+	});
+
+	it("accepts an older progress response without the startup signal", async () => {
+		const data = { status: "indexing", readyCollections: 1, totalCollections: 2 } as const;
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(success(data));
+
+		await expect(fetchMediaUsageProgress()).resolves.toEqual(data);
+	});
+
+	it("reads a finalizing progress snapshot", async () => {
+		const data = {
+			status: "indexing",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+			finalizing: true,
+		} as const;
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(success(data));
+
+		await expect(fetchMediaUsageProgress()).resolves.toEqual(data);
+	});
+
+	it.each([
+		[
+			"false signal",
+			{ status: "indexing", readyCollections: 1, totalCollections: 2, finalizing: false },
+		],
+		[
+			"ready state",
+			{ status: "ready", readyCollections: 2, totalCollections: 2, finalizing: true },
+		],
+		[
+			"not started",
+			{
+				status: "indexing",
+				readyCollections: 0,
+				totalCollections: 2,
+				indexingStarted: false,
+				finalizing: true,
+			},
+		],
+	] as const)("rejects a contradictory finalizing %s", async (_label, data) => {
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(success(data));
+
+		await expect(caught(() => fetchMediaUsageProgress())).resolves.toMatchObject({
+			kind: "unknown",
+		});
+	});
+
+	it("rejects a malformed progress startup signal", async () => {
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(
+			success({
+				status: "indexing",
+				readyCollections: 1,
+				totalCollections: 2,
+				indexingStarted: "yes",
+			}),
+		);
+
+		await expect(caught(() => fetchMediaUsageProgress())).resolves.toMatchObject({
+			kind: "unknown",
+		});
+	});
+
+	it("rejects progress that claims indexing has not started after a collection is ready", async () => {
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(
+			success({
+				status: "indexing",
+				readyCollections: 1,
+				totalCollections: 2,
+				indexingStarted: false,
+			}),
+		);
+
+		await expect(caught(() => fetchMediaUsageProgress())).resolves.toMatchObject({
+			kind: "unknown",
+		});
+	});
+
+	it("rejects contradictory aggregate progress", async () => {
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(
+			success({ status: "ready", readyCollections: 2, totalCollections: 1 }),
+		);
+
+		await expect(caught(() => fetchMediaUsageProgress())).resolves.toMatchObject({
+			kind: "unknown",
+		});
+	});
+
+	it("accepts attention when every remaining content type is ready", async () => {
+		const data = { status: "needs_attention", readyCollections: 1, totalCollections: 1 } as const;
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(success(data));
+
+		await expect(fetchMediaUsageProgress()).resolves.toEqual(data);
+	});
+
+	it("advances once with only the two backend confirmations", async () => {
+		const activation = activationStatus("activating");
+		const data = { outcome: "activating", processedCollections: 1, activation };
+		const fetch = vi.spyOn(globalThis, "fetch").mockResolvedValue(success(data));
+		const input = {
+			writersDrained: true,
+			maintenanceReady: true,
+			extra: "must not cross the API boundary",
+		} as const;
+
+		await expect(advanceMediaUsageActivation(input)).resolves.toEqual(data);
+		expect(fetch).toHaveBeenCalledOnce();
+		const [url, init] = fetch.mock.calls[0]!;
+		expect(url).toBe(activationUrl);
+		expect(init?.method).toBe("POST");
+		const headers = new Headers(init?.headers);
+		expect(headers.get("Content-Type")).toBe("application/json");
+		expect(headers.get("X-EmDash-Request")).toBe("1");
+		expect(typeof init?.body).toBe("string");
+		const requestBody = typeof init?.body === "string" ? init.body : "";
+		expect(JSON.parse(requestBody)).toEqual({
+			writersDrained: true,
+			maintenanceReady: true,
+		});
+	});
+
+	it.each([
+		["MEDIA_USAGE_ACTIVATION_CONFLICT", "ownership_conflict"],
+		["MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH", "version_mismatch"],
+		["VALIDATION_ERROR", "validation"],
+		["MEDIA_USAGE_ACTIVATION_READ_ERROR", "read_failure"],
+		["MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR", "advance_failure"],
+	] as const)("maps %s to %s without retaining the server message", async (code, kind) => {
+		const status = code === "VALIDATION_ERROR" ? 400 : code.includes("ERROR") ? 500 : 409;
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(failure(status, code));
+
+		const error = await caught(() => fetchMediaUsageActivationStatus());
+
+		expect(error).toMatchObject({ kind, status });
+		expect(error.message).not.toContain("private server detail");
+	});
+
+	it.each([401, 403])("maps a malformed %s response to denied before parsing", async (status) => {
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(
+			new Response("not json", { status, statusText: "private detail" }),
+		);
+
+		await expect(caught(() => fetchMediaUsageActivationStatus())).resolves.toMatchObject({
+			kind: "denied",
+			status,
+		});
+	});
+
+	it.each(["UNAUTHORIZED", "FORBIDDEN", "INSUFFICIENT_SCOPE"])(
+		"maps %s to denied",
+		async (code) => {
+			vi.spyOn(globalThis, "fetch").mockResolvedValue(failure(500, code));
+
+			await expect(caught(() => fetchMediaUsageActivationStatus())).resolves.toMatchObject({
+				kind: "denied",
+			});
+		},
+	);
+
+	it("maps a busy response without retaining server details", async () => {
+		vi.spyOn(globalThis, "fetch")
+			.mockResolvedValueOnce(
+				failure(409, "MEDIA_USAGE_ACTIVATION_BUSY", {
+					leaseExpiresAt: "2026-08-16T09:05:00.000Z",
+				}),
+			)
+			.mockResolvedValueOnce(failure(409, "MEDIA_USAGE_ACTIVATION_BUSY", { leaseExpiresAt: 123 }));
+
+		await expect(caught(() => fetchMediaUsageActivationStatus())).resolves.toMatchObject({
+			kind: "busy",
+			status: 409,
+		});
+		const malformed = await caught(() => fetchMediaUsageActivationStatus());
+		expect(malformed.kind).toBe("busy");
+		expect(malformed).not.toHaveProperty("leaseExpiresAt");
+	});
+
+	it.each([
+		["invalid state", { ...activationStatus(), state: "invalid" }],
+		["negative attempts", { ...activationStatus(), attemptCount: -1 }],
+		["unknown error", failure(418, "UNKNOWN_CODE")],
+		["malformed JSON", new Response("not json")],
+	] as const)("rejects %s as an unknown read error", async (_label, value) => {
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(
+			value instanceof Response ? value : success(value),
+		);
+
+		await expect(caught(() => fetchMediaUsageActivationStatus())).resolves.toMatchObject({
+			kind: "unknown",
+		});
+	});
+
+	it("wraps network failures without retaining their message", async () => {
+		vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("secret upstream hostname"));
+
+		const error = await caught(() => fetchMediaUsageActivationStatus());
+
+		expect(error).toMatchObject({ kind: "unknown", status: null });
+		expect(error.message).not.toContain("secret upstream hostname");
+	});
+
+	it.each([
+		["negative count", { outcome: "activating", processedCollections: -1 }],
+		["count above limit", { outcome: "activating", processedCollections: 2 }],
+		["fractional count", { outcome: "activating", processedCollections: 0.5 }],
+		["outcome mismatch", { outcome: "active", processedCollections: 1 }],
+		["nested expanded", { outcome: "activating", processedCollections: 0, state: "expanded" }],
+	] as const)("treats malformed POST success (%s) as unknown", async (_label, shape) => {
+		const state =
+			"state" in shape ? shape.state : shape.outcome === "active" ? "activating" : shape.outcome;
+		vi.spyOn(globalThis, "fetch").mockResolvedValue(
+			success({
+				outcome: shape.outcome,
+				processedCollections: shape.processedCollections,
+				activation: activationStatus(state as "expanded" | "activating" | "active"),
+			}),
+		);
+
+		await expect(
+			caught(() => advanceMediaUsageActivation({ writersDrained: true, maintenanceReady: true })),
+		).resolves.toMatchObject({ kind: "unknown", status: 200 });
+	});
+});
diff --git a/packages/cloudflare/src/worker.ts b/packages/cloudflare/src/worker.ts
index d2272d38a3..43c39d5957 100644
--- a/packages/cloudflare/src/worker.ts
+++ b/packages/cloudflare/src/worker.ts
@@ -1,10 +1,9 @@
 /**
  * Cloudflare Worker entry for EmDash sites.
  *
- * Wraps the Astro Cloudflare server handler with a `scheduled()` handler so a
- * Cron Triggers drive general maintenance and the separately bounded Media
- * Usage lane without request side effects. Re-exports the `PluginBridge`
- * Durable Object so the sandbox binding resolves against the entry module.
+ * Wraps the Astro Cloudflare server handler with a `scheduled()` handler for
+ * general maintenance. Re-exports the `PluginBridge` Durable Object so the
+ * sandbox binding resolves against the entry module.
  *
  * The `@astrojs/cloudflare/entrypoints/server` import is resolved by the
  * consuming app's Astro build (it pulls the build-time `virtual:astro:app`
@@ -14,7 +13,7 @@
 // @ts-ignore - resolved against the consuming app's Astro build
 import astroHandler from "@astrojs/cloudflare/entrypoints/server";
 import { createApp } from "astro/app/entrypoint";
-import { runScheduledMediaUsageTasks, runScheduledTasks } from "emdash/middleware";
+import { runMediaUsageMaintenanceSlice, runScheduledTasks } from "emdash/middleware";
 
 export { PluginBridge } from "./sandbox/index.js";
 
@@ -40,63 +39,120 @@ async function invalidatePublishedTags(
 }
 
 /**
- * Build a Worker `scheduled()` handler. By default the every-two-minutes
- * expression runs Media Usage maintenance and every other expression runs
- * general maintenance. Configuring a general expression changes that lane
- * from catch-all to exact.
+ * Build a Worker `scheduled()` handler for general maintenance.
  */
+export interface MediaUsageWakeMessage {
+	version: 1;
+}
+
+export type OptionalMediaUsageQueueResolver<Env> = (
+	env: Env,
+) => Queue<MediaUsageWakeMessage> | undefined;
+
+export type MediaUsageQueueResolver<Env> = (env: Env) => Queue<MediaUsageWakeMessage>;
+
 export interface ScheduledHandlerOptions {
 	generalCron?: string;
-	mediaUsageCron?: string;
 }
 
-const DEFAULT_MEDIA_USAGE_CRON = "*/2 * * * *";
-
-export function createScheduledHandler(
+export function createScheduledHandler<Env = unknown>(
 	options?: ScheduledHandlerOptions,
-): ExportedHandlerScheduledHandler {
+): ExportedHandlerScheduledHandler<Env> {
 	const generalCron = options?.generalCron?.trim();
-	const mediaUsageCron = options?.mediaUsageCron?.trim() ?? DEFAULT_MEDIA_USAGE_CRON;
-	if ((options?.generalCron !== undefined && !generalCron) || !mediaUsageCron) {
+	if (options?.generalCron !== undefined && !generalCron) {
 		throw new Error("Configured scheduled-handler expressions must be non-empty");
 	}
-	if (generalCron === mediaUsageCron) {
-		throw new Error("General and Media Usage Cron expressions must differ");
-	}
 
 	return (controller, _env, ctx) => {
-		if (controller.cron === mediaUsageCron) {
-			ctx.waitUntil(
-				runScheduledMediaUsageTasks().catch((error: unknown) => {
-					console.error("[scheduled] Media Usage maintenance failed:", error);
-				}),
-			);
-			return;
-		}
 		if (generalCron !== undefined && controller.cron !== generalCron) {
 			console.warn(`[scheduled] Ignoring unexpected Cron expression: ${controller.cron}`);
 			return;
 		}
+
 		ctx.waitUntil(
-			// Invalidate incrementally as each collection batch publishes, so a
-			// scheduled() invocation killed mid-sweep (CPU/wall-clock limits on a
-			// large backlog) still purged the cache tags for everything it managed
-			// to publish — not just whatever completed before a single end-of-sweep
-			// purge that may never run.
-			runScheduledTasks({ onPublished: invalidatePublishedTags })
-				.then(({ published }) => {
+			(async () => {
+				try {
+					// Invalidate incrementally as each collection batch publishes, so a
+					// scheduled() invocation killed mid-sweep (CPU/wall-clock limits on a
+					// large backlog) still purged the cache tags for everything it managed
+					// to publish — not just whatever completed before a single end-of-sweep
+					// purge that may never run.
+					const { published } = await runScheduledTasks({
+						onPublished: invalidatePublishedTags,
+					});
 					if (published.length > 0) {
 						console.log(`[scheduled] Published ${published.length} scheduled item(s)`);
 					}
-					return undefined;
-				})
-				.catch((error: unknown) => {
+				} catch (error) {
 					console.error("[scheduled] runScheduledTasks failed:", error);
-				}),
+				}
+			})(),
 		);
 	};
 }
 
+export function createMediaUsageFetchHandler<Env>(
+	handler: ExportedHandler<Env>,
+	resolveMediaUsageQueue: OptionalMediaUsageQueueResolver<Env>,
+): ExportedHandlerFetchHandler<Env> {
+	if (!handler.fetch) throw new Error("Worker fetch handler is unavailable");
+	const fetch = handler.fetch;
+	return async (request, env, ctx) => {
+		const shouldWake =
+			request.method === "POST" &&
+			new URL(request.url).pathname === "/_emdash/api/admin/media-usage/activation";
+		const response = await Reflect.apply(fetch, handler, [request, env, ctx]);
+		if (!shouldWake || !response.ok) return response;
+
+		let reported = false;
+		const reportWakeFailure = () => {
+			if (reported) return;
+			reported = true;
+			console.error("[activation] Failed to queue Media Usage maintenance wake");
+		};
+		try {
+			const queue = resolveMediaUsageQueue(env);
+			if (!queue) return response;
+			ctx.waitUntil(queue.send({ version: 1 }).catch(reportWakeFailure));
+		} catch {
+			reportWakeFailure();
+		}
+		return response;
+	};
+}
+
+export function createMediaUsageQueueHandler<Env>(
+	resolveMediaUsageQueue: MediaUsageQueueResolver<Env>,
+): ExportedHandlerQueueHandler<Env, MediaUsageWakeMessage> {
+	return async (batch, env) => {
+		let hasValidWake = false;
+		for (const message of batch.messages) {
+			if (isMediaUsageWakeMessage(message.body)) {
+				hasValidWake = true;
+			} else {
+				message.ack();
+				console.warn("[queue] Ignoring invalid Media Usage wake");
+			}
+		}
+		if (!hasValidWake) return;
+
+		const queue = resolveMediaUsageQueue(env);
+		if (!queue) throw new Error("Media Usage Queue binding is unavailable");
+
+		const continuation = await runMediaUsageMaintenanceSlice();
+		if (continuation.kind === "none") return;
+		if (continuation.kind === "delayed") {
+			await queue.send({ version: 1 }, { delaySeconds: continuation.delaySeconds });
+			return;
+		}
+		await queue.send({ version: 1 });
+	};
+}
+
+function isMediaUsageWakeMessage(value: unknown): value is MediaUsageWakeMessage {
+	return typeof value === "object" && value !== null && "version" in value && value.version === 1;
+}
+
 // eslint-disable-next-line typescript/no-unsafe-type-assertion -- astroHandler is the adapter's { fetch } worker object; resolved at app-build time
 const handler = astroHandler as ExportedHandler;
 
diff --git a/packages/cloudflare/tests/worker-scheduled.test.ts b/packages/cloudflare/tests/worker-scheduled.test.ts
index 034844f207..51f3a65af8 100644
--- a/packages/cloudflare/tests/worker-scheduled.test.ts
+++ b/packages/cloudflare/tests/worker-scheduled.test.ts
@@ -1,107 +1,265 @@
 import { beforeEach, expect, it, vi } from "vitest";
 
-const scheduled = vi.hoisted(() => ({
-	general: vi.fn(async () => ({ published: [] })),
-	mediaUsage: vi.fn(async () => ({ outcome: "inactive", taskClass: null, turn: null })),
-}));
+type MaintenanceContinuation =
+	| { kind: "none" }
+	| { kind: "immediate" }
+	| { kind: "delayed"; delaySeconds: 30 };
 
-vi.mock("@astrojs/cloudflare/entrypoints/server", () => ({ default: { fetch: vi.fn() } }));
+const scheduled = vi.hoisted(() => {
+	const general = vi.fn(async (_options?: unknown) => ({ published: [] }));
+	const mediaUsageSlice = vi.fn<() => Promise<MaintenanceContinuation>>(async () => ({
+		kind: "none",
+	}));
+	return {
+		general,
+		mediaUsageSlice,
+	};
+});
+const astro = vi.hoisted(() => ({ fetch: vi.fn() }));
+
+vi.mock("@astrojs/cloudflare/entrypoints/server", () => ({ default: { fetch: astro.fetch } }));
 vi.mock("astro/app/entrypoint", () => ({
 	createApp: () => ({ pipeline: { getCacheProvider: async () => null } }),
 }));
 vi.mock("emdash/middleware", () => ({
 	runScheduledTasks: scheduled.general,
-	runScheduledMediaUsageTasks: scheduled.mediaUsage,
+	runMediaUsageMaintenanceSlice: scheduled.mediaUsageSlice,
 }));
 vi.mock("../src/sandbox/index.js", () => ({ PluginBridge: vi.fn() }));
 
-import { createScheduledHandler } from "../src/worker.js";
+import {
+	createMediaUsageFetchHandler,
+	createMediaUsageQueueHandler,
+	createScheduledHandler,
+	type MediaUsageWakeMessage,
+} from "../src/worker.js";
 
 beforeEach(() => {
+	vi.restoreAllMocks();
+	astro.fetch.mockReset();
+	astro.fetch.mockResolvedValue(new Response(null, { status: 204 }));
 	scheduled.general.mockClear();
-	scheduled.mediaUsage.mockClear();
+	scheduled.mediaUsageSlice.mockClear();
+	scheduled.mediaUsageSlice.mockResolvedValue({ kind: "none" });
+});
+
+it("runs general maintenance for the configured Cron", async () => {
+	const handler = createScheduledHandler({ generalCron: "* * * * *" });
+
+	await invoke(handler, "* * * * *");
+
+	expect(scheduled.general).toHaveBeenCalledOnce();
+	expect(scheduled.mediaUsageSlice).not.toHaveBeenCalled();
 });
 
-it("uses the default Media Usage expression and treats every other expression as general", async () => {
+it("ignores unexpected Cron expressions", async () => {
+	const warning = vi.spyOn(console, "warn").mockImplementation(() => {});
+	const handler = createScheduledHandler({ generalCron: "* * * * *" });
+
+	await invoke(handler, "0 * * * *");
+
+	expect(scheduled.general).not.toHaveBeenCalled();
+	expect(scheduled.mediaUsageSlice).not.toHaveBeenCalled();
+	expect(warning).toHaveBeenCalledExactlyOnceWith(
+		"[scheduled] Ignoring unexpected Cron expression: 0 * * * *",
+	);
+});
+
+it("runs any configured trigger when no expression is specified", async () => {
 	const handler = createScheduledHandler();
 
 	await invoke(handler, "custom expression");
 	expect(scheduled.general).toHaveBeenCalledOnce();
-	expect(scheduled.mediaUsage).not.toHaveBeenCalled();
+	expect(scheduled.mediaUsageSlice).not.toHaveBeenCalled();
+});
 
-	scheduled.general.mockClear();
-	await invoke(handler, "*/2 * * * *");
-	expect(scheduled.general).not.toHaveBeenCalled();
-	expect(scheduled.mediaUsage).toHaveBeenCalledOnce();
+it("rejects an empty configured expression", () => {
+	expect(() => createScheduledHandler({ generalCron: "" })).toThrow(/non-empty/i);
+	expect(createScheduledHandler({ generalCron: " * * * * * " })).toBeTypeOf("function");
+});
+
+it("queues one immediate wake after a successful activation response", async () => {
+	const send = vi.fn(async () => {});
+	const handler = createMediaUsageFetchHandler({ fetch: astro.fetch }, () => queueBinding(send));
+
+	await invokeFetch(
+		handler,
+		new Request("https://example.com/_emdash/api/admin/media-usage/activation", {
+			method: "POST",
+		}),
+		{},
+	);
+
+	expect(send).toHaveBeenCalledExactlyOnceWith({ version: 1 });
+});
+
+it("does not queue activation wakes for another route or an unsuccessful response", async () => {
+	const send = vi.fn(async () => {});
+	const handler = createMediaUsageFetchHandler({ fetch: astro.fetch }, () => queueBinding(send));
+
+	await invokeFetch(handler, new Request("https://example.com/_emdash/api/content"), {});
+	astro.fetch.mockResolvedValueOnce(new Response(null, { status: 409 }));
+	await invokeFetch(
+		handler,
+		new Request("https://example.com/_emdash/api/admin/media-usage/activation", {
+			method: "POST",
+		}),
+		{},
+	);
+
+	expect(send).not.toHaveBeenCalled();
 });
 
-it("dispatches distinct configured cron expressions to exactly one lane", async () => {
-	const handler = createScheduledHandler({
-		generalCron: "* * * * *",
-		mediaUsageCron: "*/2 * * * *",
+it("redacts an activation wake failure without changing the successful response", async () => {
+	const send = vi.fn(async () => {
+		throw new Error("private queue detail");
 	});
+	const error = vi.spyOn(console, "error").mockImplementation(() => {});
+	const handler = createMediaUsageFetchHandler({ fetch: astro.fetch }, () => queueBinding(send));
 
-	await invoke(handler, "* * * * *");
-	expect(scheduled.general).toHaveBeenCalledOnce();
-	expect(scheduled.mediaUsage).not.toHaveBeenCalled();
+	const response = await invokeFetch(
+		handler,
+		new Request("https://example.com/_emdash/api/admin/media-usage/activation", {
+			method: "POST",
+		}),
+		{},
+	);
 
-	scheduled.general.mockClear();
-	await invoke(handler, "*/2 * * * *");
-	expect(scheduled.general).not.toHaveBeenCalled();
-	expect(scheduled.mediaUsage).toHaveBeenCalledOnce();
+	expect(response.status).toBe(204);
+	expect(error).toHaveBeenCalledExactlyOnceWith(
+		"[activation] Failed to queue Media Usage maintenance wake",
+	);
+	expect(JSON.stringify(error.mock.calls)).not.toContain("private queue detail");
+});
 
-	scheduled.mediaUsage.mockClear();
-	await invoke(handler, "0 0 * * *");
-	expect(scheduled.general).not.toHaveBeenCalled();
-	expect(scheduled.mediaUsage).not.toHaveBeenCalled();
+it("coalesces a delivered batch into one slice and one successor", async () => {
+	const send = vi.fn(async () => {});
+	const handler = createMediaUsageQueueHandler(() => queueBinding(send));
+	scheduled.mediaUsageSlice.mockResolvedValue({ kind: "immediate" });
+
+	await invokeQueue(handler, [wakeMessage(), wakeMessage()], {});
+
+	expect(scheduled.mediaUsageSlice).toHaveBeenCalledOnce();
+	expect(send).toHaveBeenCalledExactlyOnceWith({ version: 1 });
 });
 
-it("allows either default expression to be overridden independently", async () => {
-	const customMedia = createScheduledHandler({ mediaUsageCron: "*/5 * * * *" });
-	await invoke(customMedia, "*/5 * * * *");
-	expect(scheduled.mediaUsage).toHaveBeenCalledOnce();
-	expect(scheduled.general).not.toHaveBeenCalled();
+it("lets the Queue drain when the durable database is idle", async () => {
+	const send = vi.fn(async () => {});
+	const handler = createMediaUsageQueueHandler(() => queueBinding(send));
 
-	scheduled.mediaUsage.mockClear();
-	await invoke(customMedia, "15 * * * *");
-	expect(scheduled.mediaUsage).not.toHaveBeenCalled();
-	expect(scheduled.general).toHaveBeenCalledOnce();
+	await invokeQueue(handler, [wakeMessage()], {});
 
-	scheduled.general.mockClear();
-	const customGeneral = createScheduledHandler({ generalCron: "0 * * * *" });
-	await invoke(customGeneral, "*/2 * * * *");
-	expect(scheduled.mediaUsage).toHaveBeenCalledOnce();
-	expect(scheduled.general).not.toHaveBeenCalled();
+	expect(scheduled.mediaUsageSlice).toHaveBeenCalledOnce();
+	expect(send).not.toHaveBeenCalled();
+});
 
-	scheduled.mediaUsage.mockClear();
-	await invoke(customGeneral, "0 * * * *");
-	expect(scheduled.mediaUsage).not.toHaveBeenCalled();
-	expect(scheduled.general).toHaveBeenCalledOnce();
+it("acknowledges invalid wakes without logging their body or running work", async () => {
+	const send = vi.fn(async () => {});
+	const handler = createMediaUsageQueueHandler(() => queueBinding(send));
+	const invalid = wakeMessage({ version: 2, secret: "do-not-log" });
+	const warning = vi.spyOn(console, "warn").mockImplementation(() => {});
 
-	scheduled.general.mockClear();
-	await invoke(customGeneral, "15 * * * *");
-	expect(scheduled.mediaUsage).not.toHaveBeenCalled();
-	expect(scheduled.general).not.toHaveBeenCalled();
+	await invokeQueue(handler, [invalid], {});
+
+	expect(invalid.ack).toHaveBeenCalledOnce();
+	expect(warning).toHaveBeenCalledWith("[queue] Ignoring invalid Media Usage wake");
+	expect(JSON.stringify(warning.mock.calls)).not.toContain("do-not-log");
+	expect(scheduled.mediaUsageSlice).not.toHaveBeenCalled();
+	expect(send).not.toHaveBeenCalled();
 });
 
-it("rejects empty or aliased configured expressions", () => {
-	expect(() =>
-		createScheduledHandler({ generalCron: "* * * * *", mediaUsageCron: "* * * * *" }),
-	).toThrow(/must differ/i);
-	expect(() => createScheduledHandler({ generalCron: "", mediaUsageCron: "*/2 * * * *" })).toThrow(
-		/non-empty/i,
-	);
-	expect(() => createScheduledHandler({ mediaUsageCron: " " })).toThrow(/non-empty/i);
-	expect(() => createScheduledHandler({ generalCron: " */2 * * * * " })).toThrow(/must differ/i);
+it("retries valid wakes if a delayed successor cannot be sent", async () => {
+	const send = vi.fn(async () => {
+		throw new Error("send failed");
+	});
+	const handler = createMediaUsageQueueHandler(() => queueBinding(send));
+	const invalid = wakeMessage({ version: 9 });
+	const valid = wakeMessage();
+	scheduled.mediaUsageSlice.mockResolvedValue({ kind: "delayed", delaySeconds: 30 });
+	vi.spyOn(console, "warn").mockImplementation(() => {});
+
+	await expect(invokeQueue(handler, [invalid, valid], {})).rejects.toThrow("send failed");
+
+	expect(invalid.ack).toHaveBeenCalledOnce();
+	expect(valid.ack).not.toHaveBeenCalled();
+	expect(send).toHaveBeenCalledExactlyOnceWith({ version: 1 }, { delaySeconds: 30 });
+});
+
+it("fails before database work when the required Queue binding is missing", async () => {
+	type MissingQueueEnv = { MEDIA_USAGE_QUEUE?: Queue<MediaUsageWakeMessage> };
+	const handler = createMediaUsageQueueHandler<MissingQueueEnv>((env) => env.MEDIA_USAGE_QUEUE!);
+	const invalid = wakeMessage({ version: 4 });
+	const valid = wakeMessage();
+	vi.spyOn(console, "warn").mockImplementation(() => {});
+
+	await expect(invokeQueue(handler, [invalid, valid], {})).rejects.toThrow(/binding/i);
+	expect(invalid.ack).toHaveBeenCalledOnce();
+	expect(valid.ack).not.toHaveBeenCalled();
+	expect(scheduled.mediaUsageSlice).not.toHaveBeenCalled();
 });
 
-async function invoke(handler: ExportedHandlerScheduledHandler, cron: string): Promise<void> {
+async function invoke<Env>(
+	handler: ExportedHandlerScheduledHandler<Env>,
+	cron: string,
+	env: Env,
+): Promise<void>;
+async function invoke(handler: ExportedHandlerScheduledHandler, cron: string): Promise<void>;
+async function invoke(
+	handler: ExportedHandlerScheduledHandler,
+	cron: string,
+	env: unknown = {},
+): Promise<void> {
+	const pending: Promise<unknown>[] = [];
+	const context = {
+		waitUntil(promise: Promise<unknown>) {
+			pending.push(promise);
+		},
+	};
+	Reflect.apply(handler, undefined, [{ cron }, env, context]);
+	await Promise.all(pending);
+}
+
+async function invokeQueue<Env>(
+	handler: ExportedHandlerQueueHandler<Env, MediaUsageWakeMessage>,
+	messages: Message[],
+	env: Env,
+): Promise<void> {
+	const batch: MessageBatch = {
+		messages,
+		queue: "media-usage",
+		retryAll: vi.fn(),
+		ackAll: vi.fn(),
+	};
+	await Reflect.apply(handler, undefined, [batch, env, {}]);
+}
+
+async function invokeFetch<Env>(
+	handler: ExportedHandlerFetchHandler<Env>,
+	request: Request,
+	env: Env,
+): Promise<Response> {
 	const pending: Promise<unknown>[] = [];
 	const context = {
 		waitUntil(promise: Promise<unknown>) {
 			pending.push(promise);
 		},
 	};
-	Reflect.apply(handler, undefined, [{ cron }, {}, context]);
+	const response = await Reflect.apply(handler, undefined, [request, env, context]);
 	await Promise.all(pending);
+	return response;
+}
+
+function wakeMessage(body: unknown = { version: 1 }): Message {
+	return {
+		id: crypto.randomUUID(),
+		timestamp: new Date(),
+		body,
+		attempts: 1,
+		retry: vi.fn(),
+		ack: vi.fn(),
+	};
+}
+
+function queueBinding(send: Queue<MediaUsageWakeMessage>["send"]): Queue<MediaUsageWakeMessage> {
+	return { send, sendBatch: vi.fn(async () => {}) };
 }
diff --git a/packages/core/src/api/errors.ts b/packages/core/src/api/errors.ts
index fefbbb3cbd..de2f20f178 100644
--- a/packages/core/src/api/errors.ts
+++ b/packages/core/src/api/errors.ts
@@ -88,6 +88,8 @@ export const ErrorCode = {
 	MEDIA_DELETE_ERROR: "MEDIA_DELETE_ERROR",
 	MEDIA_USAGE_READ_ERROR: "MEDIA_USAGE_READ_ERROR",
 	MEDIA_USAGE_REPAIR_ERROR: "MEDIA_USAGE_REPAIR_ERROR",
+	MEDIA_USAGE_PROGRESS_READ_ERROR: "MEDIA_USAGE_PROGRESS_READ_ERROR",
+	MEDIA_USAGE_PROGRESS_NOT_ACTIVE: "MEDIA_USAGE_PROGRESS_NOT_ACTIVE",
 	MEDIA_USAGE_WORK_LIST_ERROR: "MEDIA_USAGE_WORK_LIST_ERROR",
 	MEDIA_USAGE_WORK_RETRY_ERROR: "MEDIA_USAGE_WORK_RETRY_ERROR",
 	MEDIA_USAGE_COLLECTION_DELETION_LIST_ERROR: "MEDIA_USAGE_COLLECTION_DELETION_LIST_ERROR",
@@ -469,6 +471,7 @@ export function mapErrorStatus(code: string | undefined): number {
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH:
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_BUSY:
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_CONFLICT:
+		case ErrorCode.MEDIA_USAGE_PROGRESS_NOT_ACTIVE:
 			return 409;
 
 		// 410 Gone
diff --git a/packages/core/src/api/handlers/index.ts b/packages/core/src/api/handlers/index.ts
index a18426d839..746472bbe7 100644
--- a/packages/core/src/api/handlers/index.ts
+++ b/packages/core/src/api/handlers/index.ts
@@ -64,6 +64,7 @@ export {
 export {
 	aggregateMediaUsageCoverageStatus,
 	handleMediaUsageDetails,
+	handleMediaUsageProgress,
 	handleMediaUsageSummaries,
 	handleMediaUsageRepair,
 	toMediaUsageRepairResponse,
@@ -72,6 +73,7 @@ export {
 	type MediaUsageDetailsResponse,
 	type MediaUsageEntryDetail,
 	type MediaUsageOccurrenceDetail,
+	type MediaUsageProgress,
 	type MediaUsageRepairResponse,
 	type MediaUsageSourceDetail,
 	type MediaUsageSummary,
diff --git a/packages/core/src/api/handlers/media-usage.ts b/packages/core/src/api/handlers/media-usage.ts
index 7e2bd98547..67a3017c17 100644
--- a/packages/core/src/api/handlers/media-usage.ts
+++ b/packages/core/src/api/handlers/media-usage.ts
@@ -8,6 +8,7 @@ import {
 import { MediaRepository } from "../../database/repositories/media.js";
 import { InvalidCursorError } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
+import { MediaUsageActivationVersionMismatchError } from "../../media/usage/activation.js";
 import {
 	CONTENT_MEDIA_USAGE_ADAPTER_ID,
 	CONTENT_MEDIA_USAGE_COLLECTION_SCOPE,
@@ -26,6 +27,7 @@ import type {
 	MediaUsageDetailsResponse,
 	MediaUsageEntryDetail,
 	MediaUsageOccurrenceDetail,
+	MediaUsageProgress,
 	MediaUsageRepairRequest,
 	MediaUsageRepairResponse,
 	MediaUsageSummary,
@@ -38,6 +40,7 @@ export type {
 	MediaUsageDetailsResponse,
 	MediaUsageEntryDetail,
 	MediaUsageOccurrenceDetail,
+	MediaUsageProgress,
 	MediaUsageSourceDetail,
 	MediaUsageRepairRequest,
 	MediaUsageRepairResponse,
@@ -48,6 +51,42 @@ type ContentMediaUsageRepairResult =
 	| ContentMediaUsageRepairCollectionResult
 	| ContentMediaUsageRepairAllResult;
 
+export async function handleMediaUsageProgress(
+	db: Kysely<Database>,
+): Promise<ApiResult<MediaUsageProgress>> {
+	try {
+		const progress = await new MediaUsageRepository(db).findCollectionProgress();
+		if (!progress) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_PROGRESS_NOT_ACTIVE,
+					message: "Media Usage is not active",
+				},
+			};
+		}
+		return { success: true, data: progress };
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH,
+					message: "Media Usage activation version does not match this runtime",
+				},
+			};
+		}
+		console.error("[media-usage] progress read failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_PROGRESS_READ_ERROR,
+				message: "Failed to read media usage progress",
+			},
+		};
+	}
+}
+
 export function aggregateMediaUsageCoverageStatus(
 	scopes: readonly MediaUsageCollectionIndexStatusScope[],
 ): MediaUsageCoverageStatus {
diff --git a/packages/core/src/api/openapi/document.ts b/packages/core/src/api/openapi/document.ts
index 37a0125000..a005ee1200 100644
--- a/packages/core/src/api/openapi/document.ts
+++ b/packages/core/src/api/openapi/document.ts
@@ -40,6 +40,7 @@ import {
 import {
 	mediaUsageDetailsQuery,
 	mediaUsageDetailsResponseSchema,
+	mediaUsageProgressSchema,
 	mediaUsageCollectionDeletionListQuery,
 	mediaUsageCollectionDeletionListResponseSchema,
 	mediaUsageCollectionDeletionRetryBody,
@@ -806,6 +807,26 @@ function buildMediaPaths(maxUploadSize: number) {
 				},
 			},
 		},
+		"/_emdash/api/admin/media-usage/progress": {
+			get: {
+				operationId: "getMediaUsageProgress",
+				summary: "Get media usage indexing progress",
+				description:
+					"Returns aggregate indexing readiness for current content collections after controlled activation is active. Requires `schema:manage`; bearer tokens also require the `admin` scope.",
+				tags: ["Media"],
+				responses: {
+					"200": {
+						description: "Aggregate media usage indexing progress",
+						content: {
+							[JSON_CONTENT]: { schema: successEnvelope(mediaUsageProgressSchema) },
+						},
+					},
+					...authErrors,
+					...standardErrors(409),
+					...standardErrors(500),
+				},
+			},
+		},
 		"/_emdash/api/admin/media-usage/work": {
 			get: {
 				operationId: "listMediaUsageWork",
diff --git a/packages/core/src/api/schemas/media-usage.ts b/packages/core/src/api/schemas/media-usage.ts
index d09345fb34..b604bad22d 100644
--- a/packages/core/src/api/schemas/media-usage.ts
+++ b/packages/core/src/api/schemas/media-usage.ts
@@ -13,6 +13,16 @@ export const mediaUsageCoverageSchema = z
 	})
 	.meta({ id: "MediaUsageCoverage" });
 
+export const mediaUsageProgressSchema = z
+	.object({
+		status: z.enum(["indexing", "ready", "needs_attention"]),
+		readyCollections: z.number().int().min(0),
+		totalCollections: z.number().int().min(0),
+		indexingStarted: z.boolean().optional(),
+		finalizing: z.literal(true).optional(),
+	})
+	.meta({ id: "MediaUsageProgress" });
+
 export const mediaUsageSummarySchema = z
 	.object({
 		count: z.number().int().min(0).nullable(),
@@ -280,6 +290,7 @@ export const mediaUsageCollectionDeletionRetryResponseSchema = z
 
 export type MediaUsageRepairRequest = z.infer<typeof mediaUsageRepairBody>;
 export type MediaUsageRepairResponse = z.infer<typeof mediaUsageRepairResponseSchema>;
+export type MediaUsageProgress = z.infer<typeof mediaUsageProgressSchema>;
 export type MediaUsageWorkListQuery = z.infer<typeof mediaUsageWorkListQuery>;
 export type MediaUsageWorkItem = z.infer<typeof mediaUsageWorkItemSchema>;
 export type MediaUsageWorkListResponse = z.infer<typeof mediaUsageWorkListResponseSchema>;
diff --git a/packages/core/src/astro/integration/routes.ts b/packages/core/src/astro/integration/routes.ts
index 9dc1db9957..2870a3ddda 100644
--- a/packages/core/src/astro/integration/routes.ts
+++ b/packages/core/src/astro/integration/routes.ts
@@ -262,6 +262,10 @@ export function injectCoreRoutes(
 		pattern: "/_emdash/api/admin/media-usage/activation",
 		entrypoint: resolveRoute("api/admin/media-usage/activation.ts"),
 	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/progress",
+		entrypoint: resolveRoute("api/admin/media-usage/progress.ts"),
+	});
 	injectRoute({
 		pattern: "/_emdash/api/admin/media-usage/collection-deletions",
 		entrypoint: resolveRoute("api/admin/media-usage/collection-deletions/index.ts"),
diff --git a/packages/core/src/astro/middleware.ts b/packages/core/src/astro/middleware.ts
index a9b9cc9085..e333403e37 100644
--- a/packages/core/src/astro/middleware.ts
+++ b/packages/core/src/astro/middleware.ts
@@ -48,7 +48,7 @@ import { createDeferredTaskTracker } from "../deferred-tasks.js";
 import {
 	DB_INIT_DEADLINE_MS,
 	EmDashRuntime,
-	type MediaUsageMaintenanceResult,
+	type MediaUsageMaintenanceContinuation,
 	type RuntimeDependencies,
 	type SandboxedPluginEntry,
 	type MediaProviderEntry,
@@ -300,10 +300,10 @@ export async function runScheduledTasks(
 	return runOutsideRequest(config, (runtime) => runtime.runScheduledTasks(options));
 }
 
-export async function runScheduledMediaUsageTasks(): Promise<MediaUsageMaintenanceResult> {
+export async function runMediaUsageMaintenanceSlice(): Promise<MediaUsageMaintenanceContinuation> {
 	const config = getConfig();
-	if (!config) return { outcome: "inactive", taskClass: null, turn: null };
-	return runOutsideRequest(config, (runtime) => runtime.runScheduledMediaUsageTasks());
+	if (!config) return { kind: "none" };
+	return runOutsideRequest(config, (runtime) => runtime.runMediaUsageMaintenanceSlice());
 }
 
 /**
@@ -989,6 +989,7 @@ export const onRequest = defineMiddleware(async (context, next) => {
 
 					// Update plugin enabled/disabled status and rebuild hook pipeline
 					setPluginStatus: runtime.setPluginStatus.bind(runtime),
+					wakeMediaUsageMaintenance: runtime.wakeMediaUsageMaintenance.bind(runtime),
 				};
 			} catch (error) {
 				if (error instanceof PendingMigrationsError) {
diff --git a/packages/core/src/astro/routes/api/admin/media-usage/activation.ts b/packages/core/src/astro/routes/api/admin/media-usage/activation.ts
index 2170e277a6..d3b2550f8c 100644
--- a/packages/core/src/astro/routes/api/admin/media-usage/activation.ts
+++ b/packages/core/src/astro/routes/api/admin/media-usage/activation.ts
@@ -38,5 +38,13 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	const body = await parseBody(request, mediaUsageActivationAdvanceBody);
 	if (isParseError(body)) return body;
 
-	return unwrapResult(await handleMediaUsageActivationAdvance(emdash.db, body));
+	const result = await handleMediaUsageActivationAdvance(emdash.db, body);
+	if (result.success) {
+		try {
+			emdash.wakeMediaUsageMaintenance();
+		} catch {
+			console.error("[media-usage:activation] Failed to wake background maintenance");
+		}
+	}
+	return unwrapResult(result);
 };
diff --git a/packages/core/src/astro/routes/api/admin/media-usage/progress.ts b/packages/core/src/astro/routes/api/admin/media-usage/progress.ts
new file mode 100644
index 0000000000..4edd4b1ec5
--- /dev/null
+++ b/packages/core/src/astro/routes/api/admin/media-usage/progress.ts
@@ -0,0 +1,21 @@
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleMediaUsageProgress } from "#api/handlers/media-usage.js";
+import { requireScope } from "#auth/scopes.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ locals }) => {
+	const { emdash, user } = locals;
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+	const scopeDenied = requireScope(locals, "admin");
+	if (scopeDenied) return scopeDenied;
+
+	return unwrapResult(await handleMediaUsageProgress(emdash.db));
+};
diff --git a/packages/core/src/client/index.ts b/packages/core/src/client/index.ts
index 7a10ea3407..78aeb50b81 100644
--- a/packages/core/src/client/index.ts
+++ b/packages/core/src/client/index.ts
@@ -229,6 +229,14 @@ export interface MediaUsageRepairResponse {
 	collections: MediaUsageRepairCollectionSummary[];
 }
 
+export interface MediaUsageProgress {
+	status: "indexing" | "ready" | "needs_attention";
+	readyCollections: number;
+	totalCollections: number;
+	indexingStarted?: boolean;
+	finalizing?: true;
+}
+
 /** Durable media usage entry-work state */
 export type MediaUsageWorkState = "pending" | "retry" | "leased" | "failed";
 
@@ -917,6 +925,11 @@ export class EmDashClient {
 		return this.request<MediaUsageRepairResponse>("POST", "/admin/media-usage/repair", input);
 	}
 
+	/** Read aggregate Media Usage indexing progress */
+	async mediaGetUsageProgress(): Promise<MediaUsageProgress> {
+		return this.request<MediaUsageProgress>("GET", "/admin/media-usage/progress");
+	}
+
 	/** Read the redacted controlled-activation status */
 	async mediaGetUsageActivation(): Promise<MediaUsageActivationStatus> {
 		return this.request<MediaUsageActivationStatus>("GET", "/admin/media-usage/activation");
diff --git a/packages/core/src/database/json-recordset.ts b/packages/core/src/database/json-recordset.ts
new file mode 100644
index 0000000000..6680bc6640
--- /dev/null
+++ b/packages/core/src/database/json-recordset.ts
@@ -0,0 +1,16 @@
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import { isPostgres } from "./dialect-helpers.js";
+import type { Database } from "./types.js";
+
+export function jsonTextValues(
+	db: Kysely<Database>,
+	values: readonly string[],
+): RawBuilder<{ value: string }> {
+	const payload = JSON.stringify([...new Set(values)]);
+	return isPostgres(db)
+		? sql<{
+				value: string;
+			}>`SELECT value::text AS value FROM jsonb_array_elements_text(${payload}::jsonb) AS value`
+		: sql<{ value: string }>`SELECT value AS value FROM json_each(${payload})`;
+}
diff --git a/packages/core/src/database/repositories/media-usage-work.ts b/packages/core/src/database/repositories/media-usage-work.ts
index 115967a4ab..ba93905b32 100644
--- a/packages/core/src/database/repositories/media-usage-work.ts
+++ b/packages/core/src/database/repositories/media-usage-work.ts
@@ -8,14 +8,14 @@ import { decodeCursor, encodeCursor, type FindManyResult } from "./types.js";
 export type MediaUsageWorkState = "pending" | "retry" | "leased" | "failed";
 export type MediaUsageWorkVersion = number | string;
 const MAX_PORTABLE_DURATION_SECONDS = 365 * 24 * 60 * 60;
-const MAX_WORK_SELECTION_LIMIT = 100;
+const MAX_WORK_SELECTION_LIMIT = 1_000;
 const NON_NEGATIVE_DECIMAL_PATTERN = /^(?:0|[1-9][0-9]*)$/;
 const POSITIVE_DECIMAL_PATTERN = /^[1-9][0-9]*$/;
 const STABLE_ERROR_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
 
 export const MEDIA_USAGE_WORK_OPERATOR_DEFAULT_LIMIT = 50;
 export const MEDIA_USAGE_WORK_OPERATOR_MAX_LIMIT = 100;
-export const MEDIA_USAGE_RECONCILIATION_PAGE_LIMIT = 50;
+export const MEDIA_USAGE_RECONCILIATION_PAGE_LIMIT = 1_000;
 const MEDIA_USAGE_WORK_STATES = ["pending", "retry", "leased", "failed"] as const;
 
 export interface MediaUsageWorkIdentity {
@@ -79,18 +79,18 @@ export class MediaUsageWorkRepository {
 		assertNonNegativeDecimal(input.changeEpoch, "change epoch");
 		const contentIds = [...new Set(input.contentIds)];
 		if (contentIds.length < 1 || contentIds.length > MEDIA_USAGE_RECONCILIATION_PAGE_LIMIT) {
-			throw new Error("Reconciliation enqueue requires from 1 to 50 content IDs");
+			throw new Error("Reconciliation enqueue requires from 1 to 1000 content IDs");
 		}
 		if (contentIds.some((contentId) => !contentId)) {
 			throw new Error("Reconciliation enqueue content IDs must not be empty");
 		}
 		const now = this.timestampOffset(0);
-		const pageValues = sql.join(
-			contentIds.map((contentId) => sql`(${contentId})`),
-			sql`, `,
-		);
+		const contentIdsJson = JSON.stringify(contentIds);
+		const page = isPostgres(this.db)
+			? sql`SELECT value::text AS content_id FROM jsonb_array_elements_text(${contentIdsJson}::jsonb) AS value`
+			: sql`SELECT value AS content_id FROM json_each(${contentIdsJson})`;
 		await sql`
-			WITH page(content_id) AS (VALUES ${pageValues})
+			WITH page(content_id) AS (${page})
 			INSERT INTO _emdash_media_usage_work (
 				collection_id, collection_slug, content_id, change_epoch, work_version,
 				state, attempt_count, next_attempt_at, lease_token, lease_expires_at,
@@ -508,42 +508,101 @@ export class MediaUsageWorkRepository {
 		return row?.lease_expires_at ?? null;
 	}
 
-	async findDueWork(limit: number): Promise<MediaUsageWorkRecord[]> {
-		if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_WORK_SELECTION_LIMIT) {
+	async claimDueWorkBatch(input: {
+		limit: number;
+		leaseDurationSeconds: number;
+	}): Promise<MediaUsageWorkRecord[]> {
+		if (
+			!Number.isSafeInteger(input.limit) ||
+			input.limit < 1 ||
+			input.limit > MAX_WORK_SELECTION_LIMIT
+		) {
 			throw new Error(
 				`Media usage due-work limit must be a whole number from 1 to ${MAX_WORK_SELECTION_LIMIT}`,
 			);
 		}
+		const leaseDurationSeconds = durationSeconds(
+			input.leaseDurationSeconds,
+			"lease duration",
+			false,
+		);
+		const leaseToken = ulid();
+		const now = this.timestampOffset(0);
+		let candidates = this.db
+			.selectFrom("_emdash_media_usage_work as due")
+			.select(["due.collection_id", "due.content_id", "due.work_version"])
+			.where((eb) =>
+				eb.or([
+					eb.and([
+						eb("due.state", "in", ["pending", "retry"]),
+						this.timestampIsDue("due.next_attempt_at"),
+					]),
+					eb.and([
+						eb("due.state", "=", "leased"),
+						eb("due.lease_expires_at", "is not", null),
+						this.timestampIsDue("due.lease_expires_at"),
+					]),
+				]),
+			)
+			.orderBy(
+				sql<string>`CASE
+					WHEN due.state = 'leased' THEN due.lease_expires_at
+					ELSE due.next_attempt_at
+				END`,
+				"asc",
+			)
+			.orderBy("due.updated_at", "asc")
+			.orderBy("due.collection_id", "asc")
+			.orderBy("due.content_id", "asc")
+			.limit(input.limit);
+		if (isPostgres(this.db)) candidates = candidates.forUpdate().skipLocked();
+		const rows = await this.db
+			.with("due_media_usage_work", () => candidates)
+			.updateTable("_emdash_media_usage_work")
+			.set({
+				state: "leased",
+				lease_token: leaseToken,
+				lease_expires_at: this.timestampOffset(leaseDurationSeconds),
+				last_attempted_at: now,
+				updated_at: now,
+			})
+			.where((eb) =>
+				eb.and([
+					eb.exists(
+						eb
+							.selectFrom("due_media_usage_work as due")
+							.select("due.content_id")
+							.whereRef("due.collection_id", "=", "_emdash_media_usage_work.collection_id")
+							.whereRef("due.content_id", "=", "_emdash_media_usage_work.content_id")
+							.whereRef("due.work_version", "=", "_emdash_media_usage_work.work_version"),
+					),
+					eb.or([
+						eb.and([
+							eb("state", "in", ["pending", "retry"]),
+							this.timestampIsDue("next_attempt_at"),
+						]),
+						eb.and([
+							eb("state", "=", "leased"),
+							eb("lease_expires_at", "is not", null),
+							this.timestampIsDue("lease_expires_at"),
+						]),
+					]),
+				]),
+			)
+			.returningAll()
+			.execute();
 
-		const pendingRows = await this.findDueRows("pending", "next_attempt_at", limit);
-		const retryRows = await this.findDueRows("retry", "next_attempt_at", limit);
-		const leasedRows = await this.findDueRows("leased", "lease_expires_at", limit);
-
-		return [...pendingRows, ...retryRows, ...leasedRows]
-			.map(rowToWork)
-			.toSorted(compareDueWork)
-			.slice(0, limit);
+		return rows.map(rowToWork);
 	}
 
-	private async findDueRows(
-		state: "pending" | "retry" | "leased",
-		timestampColumn: "next_attempt_at" | "lease_expires_at",
-		limit: number,
-	): Promise<Selectable<MediaUsageWorkTable>[]> {
-		let query = this.db
+	async hasNonterminalWork(): Promise<boolean> {
+		const row = await this.db
 			.selectFrom("_emdash_media_usage_work")
-			.selectAll()
-			.where("state", "=", state)
-			.where(this.timestampIsDue(timestampColumn))
-			.orderBy(timestampColumn, "asc");
-		if (timestampColumn === "next_attempt_at") {
-			query = query.orderBy("updated_at", "asc");
-		}
-		return query
-			.orderBy("collection_id", "asc")
-			.orderBy("content_id", "asc")
-			.limit(limit)
-			.execute();
+			.select("content_id")
+			.where("state", "in", ["pending", "retry", "leased"])
+			.limit(1)
+			.executeTakeFirst();
+		return row !== undefined;
 	}
 
 	async findWorkForContent(
@@ -608,18 +667,230 @@ export class MediaUsageWorkRepository {
 		return row ? rowToWork(row) : null;
 	}
 
-	async completeWork(input: MediaUsageWorkLease): Promise<boolean> {
-		assertLease(input);
-		const result = await this.db
-			.deleteFrom("_emdash_media_usage_work")
-			.where("collection_id", "=", input.collectionId)
-			.where("content_id", "=", input.contentId)
-			.where("work_version", "=", input.workVersion)
-			.where("state", "=", "leased")
-			.where("lease_token", "=", input.leaseToken)
-			.where(this.leaseIsLive())
-			.executeTakeFirst();
-		return Number(result.numDeletedRows ?? 0) > 0;
+	async completeWorkBatch(inputs: readonly MediaUsageWorkLease[]): Promise<Set<string>> {
+		const unique = [
+			...new Map(
+				inputs.map((input) => {
+					assertLease(input);
+					return [workIdentityKey(input), input] as const;
+				}),
+			).values(),
+		];
+		const completed = new Set<string>();
+		if (unique.length === 0) return completed;
+		const payload = JSON.stringify(
+			unique.map((input) => ({
+				collection_id: input.collectionId,
+				content_id: input.contentId,
+				work_version: String(input.workVersion),
+				lease_token: input.leaseToken,
+			})),
+		);
+		const claimed = this.claimedWorkBatchInput(payload);
+		const result = await sql<{
+			collection_id: string;
+			content_id: string;
+			work_version: MediaUsageWorkVersion;
+		}>`
+			WITH claimed AS (${claimed})
+			DELETE FROM _emdash_media_usage_work AS work
+			WHERE work.state = 'leased'
+				AND ${this.qualifiedLeaseIsLive("work.lease_expires_at")}
+				AND EXISTS (
+					SELECT 1
+					FROM claimed
+					WHERE claimed.collection_id = work.collection_id
+						AND claimed.content_id = work.content_id
+						AND claimed.work_version = work.work_version
+						AND claimed.lease_token = work.lease_token
+				)
+			RETURNING collection_id, content_id, work_version
+		`.execute(this.db);
+		for (const row of result.rows) {
+			completed.add(
+				workIdentityKey({
+					collectionId: row.collection_id,
+					contentId: row.content_id,
+					workVersion: row.work_version,
+				}),
+			);
+		}
+		return completed;
+	}
+
+	async lockClaimedWorkBatch(inputs: readonly MediaUsageWorkLease[]): Promise<Set<string>> {
+		const unique = [
+			...new Map(
+				inputs.map((input) => {
+					assertLease(input);
+					return [workIdentityKey(input), input] as const;
+				}),
+			).values(),
+		].toSorted((left, right) => workIdentityKey(left).localeCompare(workIdentityKey(right)));
+		if (!isPostgres(this.db)) return new Set(unique.map(workIdentityKey));
+		if (unique.length === 0) return new Set();
+		const payload = JSON.stringify(
+			unique.map((input) => ({
+				collection_id: input.collectionId,
+				content_id: input.contentId,
+				work_version: String(input.workVersion),
+				lease_token: input.leaseToken,
+			})),
+		);
+		const claimed = this.claimedWorkBatchInput(payload);
+		const result = await sql<{
+			collection_id: string;
+			content_id: string;
+			work_version: MediaUsageWorkVersion;
+		}>`
+			WITH claimed AS (${claimed})
+			SELECT work.collection_id, work.content_id, work.work_version
+			FROM _emdash_media_usage_work AS work
+			INNER JOIN claimed
+				ON claimed.collection_id = work.collection_id
+				AND claimed.content_id = work.content_id
+				AND claimed.work_version = work.work_version
+				AND claimed.lease_token = work.lease_token
+			WHERE work.state = 'leased'
+				AND ${this.qualifiedLeaseIsLive("work.lease_expires_at")}
+			ORDER BY work.collection_id, work.content_id
+			FOR UPDATE
+		`.execute(this.db);
+		return new Set(
+			result.rows.map((row) =>
+				workIdentityKey({
+					collectionId: row.collection_id,
+					contentId: row.content_id,
+					workVersion: row.work_version,
+				}),
+			),
+		);
+	}
+
+	async retryClaimedWorkBatch(input: {
+		work: readonly MediaUsageWorkLease[];
+		errorCode: string;
+		retryDelaySeconds: number;
+		maxAttempts: number;
+	}): Promise<Map<string, "retry" | "failed">> {
+		assertErrorCode(input.errorCode);
+		const retryDelaySeconds = durationSeconds(input.retryDelaySeconds, "retry delay", true);
+		if (!Number.isSafeInteger(input.maxAttempts) || input.maxAttempts < 1) {
+			throw new Error("Media usage work max attempts must be a positive whole number");
+		}
+		const unique = [
+			...new Map(
+				input.work.map((work) => {
+					assertLease(work);
+					return [workIdentityKey(work), work] as const;
+				}),
+			).values(),
+		];
+		const transitioned = new Map<string, "retry" | "failed">();
+		if (unique.length === 0) return transitioned;
+		const payload = JSON.stringify(
+			unique.map((work) => ({
+				collection_id: work.collectionId,
+				content_id: work.contentId,
+				work_version: String(work.workVersion),
+				lease_token: work.leaseToken,
+			})),
+		);
+		const claimed = this.claimedWorkBatchInput(payload);
+		const result = await sql<{
+			collection_id: string;
+			content_id: string;
+			work_version: MediaUsageWorkVersion;
+			state: "retry" | "failed";
+		}>`
+			WITH claimed AS (${claimed})
+			UPDATE _emdash_media_usage_work AS work
+			SET state = CASE WHEN work.attempt_count + 1 >= ${input.maxAttempts} THEN 'failed' ELSE 'retry' END,
+				attempt_count = work.attempt_count + 1,
+				next_attempt_at = ${this.timestampOffset(retryDelaySeconds)},
+				lease_token = NULL,
+				lease_expires_at = NULL,
+				last_error_code = ${input.errorCode},
+				updated_at = ${this.timestampOffset(0)}
+			WHERE work.state = 'leased'
+				AND ${this.qualifiedLeaseIsLive("work.lease_expires_at")}
+				AND EXISTS (
+					SELECT 1
+					FROM claimed
+					WHERE claimed.collection_id = work.collection_id
+						AND claimed.content_id = work.content_id
+						AND claimed.work_version = work.work_version
+						AND claimed.lease_token = work.lease_token
+				)
+			RETURNING collection_id, content_id, work_version, state
+		`.execute(this.db);
+		for (const row of result.rows) {
+			transitioned.set(
+				workIdentityKey({
+					collectionId: row.collection_id,
+					contentId: row.content_id,
+					workVersion: row.work_version,
+				}),
+				row.state,
+			);
+		}
+		return transitioned;
+	}
+
+	async releaseClaimedWorkBatch(inputs: readonly MediaUsageWorkLease[]): Promise<Set<string>> {
+		const unique = [
+			...new Map(
+				inputs.map((input) => {
+					assertLease(input);
+					return [workIdentityKey(input), input] as const;
+				}),
+			).values(),
+		];
+		const released = new Set<string>();
+		if (unique.length === 0) return released;
+		const payload = JSON.stringify(
+			unique.map((input) => ({
+				collection_id: input.collectionId,
+				content_id: input.contentId,
+				work_version: String(input.workVersion),
+				lease_token: input.leaseToken,
+			})),
+		);
+		const claimed = this.claimedWorkBatchInput(payload);
+		const result = await sql<{
+			collection_id: string;
+			content_id: string;
+			work_version: MediaUsageWorkVersion;
+		}>`
+			WITH claimed AS (${claimed})
+			UPDATE _emdash_media_usage_work AS work
+			SET state = 'pending',
+				next_attempt_at = ${this.timestampOffset(0)},
+				lease_token = NULL,
+				lease_expires_at = NULL,
+				updated_at = ${this.timestampOffset(0)}
+			WHERE work.state = 'leased'
+				AND ${this.qualifiedLeaseIsLive("work.lease_expires_at")}
+				AND EXISTS (
+					SELECT 1
+					FROM claimed
+					WHERE claimed.collection_id = work.collection_id
+						AND claimed.content_id = work.content_id
+						AND claimed.work_version = work.work_version
+						AND claimed.lease_token = work.lease_token
+				)
+			RETURNING collection_id, content_id, work_version
+		`.execute(this.db);
+		for (const row of result.rows) {
+			released.add(
+				workIdentityKey({
+					collectionId: row.collection_id,
+					contentId: row.content_id,
+					workVersion: row.work_version,
+				}),
+			);
+		}
+		return released;
 	}
 
 	async deleteWorkThroughEpoch(
@@ -636,53 +907,49 @@ export class MediaUsageWorkRepository {
 		return Number(result.numDeletedRows ?? 0);
 	}
 
-	async retryWork(
-		input: MediaUsageWorkLease & {
-			retryDelaySeconds: number;
-			errorCode: string;
-		},
-	): Promise<boolean> {
-		const retryDelaySeconds = durationSeconds(input.retryDelaySeconds, "retry delay", true);
-		assertErrorCode(input.errorCode);
-		return this.transitionFailure(input, "retry", {
-			next_attempt_at: this.timestampOffset(retryDelaySeconds),
-		});
-	}
-
-	async failWork(
-		input: MediaUsageWorkLease & {
-			errorCode: string;
-		},
-	): Promise<boolean> {
-		assertErrorCode(input.errorCode);
-		return this.transitionFailure(input, "failed");
-	}
-
-	private async transitionFailure(
-		input: MediaUsageWorkLease & { errorCode: string },
-		state: "retry" | "failed",
-		extra: { next_attempt_at?: RawBuilder<string> } = {},
-	): Promise<boolean> {
-		assertLease(input);
+	async deleteObsoleteReconciliationWork(input: {
+		collectionId: string;
+		collectionSlug: string;
+		runToken: string;
+		leaseToken: string;
+		targetEpoch: number | string;
+	}): Promise<number> {
+		assertNonNegativeDecimal(input.targetEpoch, "target epoch");
 		const result = await this.db
-			.updateTable("_emdash_media_usage_work")
-			.set({
-				state,
-				attempt_count: sql<number>`attempt_count + 1`,
-				lease_token: null,
-				lease_expires_at: null,
-				last_error_code: input.errorCode,
-				updated_at: this.timestampOffset(0),
-				...extra,
-			})
-			.where("collection_id", "=", input.collectionId)
-			.where("content_id", "=", input.contentId)
-			.where("work_version", "=", input.workVersion)
-			.where("state", "=", "leased")
-			.where("lease_token", "=", input.leaseToken)
-			.where(this.leaseIsLive())
+			.deleteFrom("_emdash_media_usage_work as work")
+			.where("work.collection_id", "=", input.collectionId)
+			.where("work.change_epoch", "<", input.targetEpoch)
+			.where((eb) =>
+				eb.exists(
+					eb
+						.selectFrom("_emdash_media_usage_reconciliations as reconciliation")
+						.innerJoin("_emdash_media_usage_index_status as status", (join) =>
+							join
+								.onRef("status.collection_id", "=", "reconciliation.collection_id")
+								.onRef("status.scope_key", "=", "reconciliation.collection_slug"),
+						)
+						.innerJoin("_emdash_collections as collection", (join) =>
+							join
+								.onRef("collection.id", "=", "reconciliation.collection_id")
+								.onRef("collection.slug", "=", "reconciliation.collection_slug"),
+						)
+						.select("reconciliation.collection_id")
+						.where("reconciliation.collection_id", "=", input.collectionId)
+						.where("reconciliation.collection_slug", "=", input.collectionSlug)
+						.where("reconciliation.run_token", "=", input.runToken)
+						.where("reconciliation.target_epoch", "=", input.targetEpoch)
+						.where("reconciliation.state", "=", "leased")
+						.where("reconciliation.lease_token", "=", input.leaseToken)
+						.where(this.qualifiedLeaseIsLive("reconciliation.lease_expires_at"))
+						.where("status.capture_state", "=", "active")
+						.where("status.reconciliation_required", "=", 1)
+						.where("status.status", "=", "running")
+						.where("status.cursor", "=", input.runToken)
+						.where("status.change_epoch", "=", input.targetEpoch),
+				),
+			)
 			.executeTakeFirst();
-		return Number(result.numUpdatedRows ?? 0) > 0;
+		return Number(result.numDeletedRows ?? 0);
 	}
 
 	private leaseIsLive(): RawBuilder<boolean> {
@@ -699,7 +966,13 @@ export class MediaUsageWorkRepository {
 	}
 
 	private timestampIsDue(
-		column: "next_attempt_at" | "lease_expires_at" | "work.lease_expires_at",
+		column:
+			| "next_attempt_at"
+			| "lease_expires_at"
+			| "work.lease_expires_at"
+			| "work.next_attempt_at"
+			| "due.next_attempt_at"
+			| "due.lease_expires_at",
 	): RawBuilder<boolean> {
 		return isPostgres(this.db)
 			? sql<boolean>`${sql.ref(column)} <= to_char(
@@ -722,6 +995,31 @@ export class MediaUsageWorkRepository {
 			${`${offsetSeconds >= 0 ? "+" : ""}${offsetSeconds} seconds`}
 		)`;
 	}
+
+	private claimedWorkBatchInput(payload: string): RawBuilder<unknown> {
+		if (isPostgres(this.db)) {
+			return sql`
+				SELECT
+					entry.value ->> 'collection_id' AS collection_id,
+					entry.value ->> 'content_id' AS content_id,
+					CAST(entry.value ->> 'work_version' AS bigint) AS work_version,
+					entry.value ->> 'lease_token' AS lease_token
+				FROM jsonb_array_elements(${payload}::jsonb) AS entry(value)
+			`;
+		}
+		return sql`
+			SELECT
+				json_extract(entry.value, '$.collection_id') AS collection_id,
+				json_extract(entry.value, '$.content_id') AS content_id,
+				CAST(json_extract(entry.value, '$.work_version') AS integer) AS work_version,
+				json_extract(entry.value, '$.lease_token') AS lease_token
+			FROM json_each(${payload}) AS entry
+		`;
+	}
+}
+
+function workIdentityKey(input: MediaUsageWorkIdentity): string {
+	return `${input.collectionId}\u0000${input.contentId}\u0000${String(input.workVersion)}`;
 }
 
 function operatorLimit(value: number | undefined): number {
@@ -827,22 +1125,7 @@ function isMediaUsageWorkState(value: string): value is MediaUsageWorkState {
 	return value === "pending" || value === "retry" || value === "leased" || value === "failed";
 }
 
-function compareDueWork(a: MediaUsageWorkRecord, b: MediaUsageWorkRecord): number {
-	const eligibility = dueTimestamp(a).localeCompare(dueTimestamp(b));
-	if (eligibility !== 0) return eligibility;
-	const updated = a.updatedAt.localeCompare(b.updatedAt);
-	if (updated !== 0) return updated;
-	const collection = a.collectionId.localeCompare(b.collectionId);
-	return collection !== 0 ? collection : a.contentId.localeCompare(b.contentId);
-}
-
 function compareOperatorWork(a: MediaUsageOperatorWorkItem, b: MediaUsageOperatorWorkItem): number {
 	const updated = b.updatedAt.localeCompare(a.updatedAt);
 	return updated !== 0 ? updated : b.contentId.localeCompare(a.contentId);
 }
-
-function dueTimestamp(work: MediaUsageWorkRecord): string {
-	if (work.state !== "leased") return work.nextAttemptAt;
-	if (!work.leaseExpiresAt) throw new Error("Due leased media usage work must have a lease expiry");
-	return work.leaseExpiresAt;
-}
diff --git a/packages/core/src/database/repositories/media-usage.ts b/packages/core/src/database/repositories/media-usage.ts
index 49ccb3f6f4..77a77bcf8a 100644
--- a/packages/core/src/database/repositories/media-usage.ts
+++ b/packages/core/src/database/repositories/media-usage.ts
@@ -9,11 +9,20 @@ import {
 } from "kysely";
 import { ulid } from "ulidx";
 
+import {
+	MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION,
+	MediaUsageActivationVersionMismatchError,
+} from "../../media/usage/activation.js";
 import { isMediaUsageProjectionFingerprint } from "../../media/usage/projection-fingerprint.js";
 import type { MediaUsageContentSourceVariant } from "../../media/usage/source-key.js";
-import type { MediaKind, MediaUsageReferenceType } from "../../media/usage/types.js";
+import {
+	CONTENT_SOURCE_SCHEMA_VERSION,
+	type MediaKind,
+	type MediaUsageReferenceType,
+} from "../../media/usage/types.js";
 import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { isPostgres } from "../dialect-helpers.js";
+import { jsonTextValues } from "../json-recordset.js";
 import { withTransaction } from "../transaction.js";
 import type {
 	Database,
@@ -33,11 +42,30 @@ type MediaUsageSourceNullableStringColumn =
 	| "updated_at"
 	| "last_attempted_at"
 	| "last_error_code";
+type BatchSourceExpectedColumn =
+	| "source.collection_id"
+	| "source.source_fingerprint"
+	| "source.source_updated_at"
+	| "source.source_version"
+	| "source.identity_version"
+	| "source.revision_id"
+	| "source.last_attempted_at"
+	| "source.last_error_code";
+type BatchInputExpectedColumn =
+	| "input.expected_collection_id"
+	| "input.expected_source_fingerprint"
+	| "input.expected_source_updated_at"
+	| "input.expected_source_version"
+	| "input.expected_identity_version"
+	| "input.expected_revision_id"
+	| "input.expected_last_attempted_at"
+	| "input.expected_last_error_code";
 const OCCURRENCE_BIND_COLUMNS = 13;
+const D1_MAX_BOUND_PARAMETERS = 100;
 export const MEDIA_USAGE_GENERATION_WRITE_LEASE_MS = 60 * 60 * 1000;
 const OCCURRENCE_INSERT_BATCH_SIZE = Math.max(
 	1,
-	Math.floor(SQL_BATCH_SIZE / OCCURRENCE_BIND_COLUMNS),
+	Math.floor(D1_MAX_BOUND_PARAMETERS / OCCURRENCE_BIND_COLUMNS),
 );
 
 function cleanupDeleteBatchSize(cleanupLease: MediaUsageCleanupLease | undefined): number {
@@ -48,6 +76,39 @@ function canIssueCleanupStatement(canIssueStatement: (() => boolean) | undefined
 	return canIssueStatement?.() ?? true;
 }
 
+function nullableRefMatch(
+	left: "content.live_revision_id" | "content.draft_revision_id",
+	right: "input.revision_id",
+): RawBuilder<boolean> {
+	const leftRef = sql.ref(left);
+	const rightRef = sql.ref(right);
+	return sql<boolean>`(
+		(${leftRef} IS NULL AND ${rightRef} IS NULL)
+		OR ${leftRef} = ${rightRef}
+	)`;
+}
+
+const MAX_JSON_BIND_BYTES = 1_900_000;
+
+function chunkJsonRows<T>(rows: readonly T[]): T[][] {
+	const batches: T[][] = [];
+	let batch: T[] = [];
+	let batchBytes = 2;
+	for (const row of rows) {
+		const rowBytes =
+			new TextEncoder().encode(JSON.stringify(row)).byteLength + (batch.length > 0 ? 1 : 0);
+		if (batch.length > 0 && batchBytes + rowBytes > MAX_JSON_BIND_BYTES) {
+			batches.push(batch);
+			batch = [];
+			batchBytes = 2;
+		}
+		batch.push(row);
+		batchBytes += rowBytes;
+	}
+	if (batch.length > 0) batches.push(batch);
+	return batches;
+}
+
 function cleanupDurationSeconds(value: number): number {
 	if (!Number.isSafeInteger(value) || value < 0) {
 		throw new Error("Media usage cleanup duration must be a non-negative whole number of seconds");
@@ -168,6 +229,15 @@ export interface MediaUsageGuardedReplaceResult {
 	source: MediaUsageSource | null;
 }
 
+export interface MediaUsageNewSourceProjection {
+	source: MediaUsageSourceInput;
+	occurrences: readonly MediaUsageOccurrenceInput[];
+}
+
+export interface MediaUsageExistingSourceProjection extends MediaUsageNewSourceProjection {
+	expectedSource: MediaUsageSource;
+}
+
 export interface MediaUsageGuardedDeleteResult {
 	deleted: boolean;
 	source: MediaUsageSource | null;
@@ -340,6 +410,14 @@ export interface MediaUsageCollectionIndexStatusScope {
 	reconciliationRequired: boolean;
 }
 
+export interface MediaUsageCollectionProgress {
+	status: "indexing" | "ready" | "needs_attention";
+	readyCollections: number;
+	totalCollections: number;
+	indexingStarted: boolean;
+	finalizing?: true;
+}
+
 export interface MediaUsageEntrySource {
 	source: MediaUsageSource;
 	occurrences: MediaUsageOccurrence[];
@@ -537,14 +615,15 @@ export class MediaUsageRepository {
 		const uniqueSourceKeys = [...new Set(sourceKeys)];
 		const sources = new Map<string, MediaUsageSource>();
 		if (uniqueSourceKeys.length === 0) return sources;
-
-		for (const sourceKeyBatch of chunks(uniqueSourceKeys, SQL_BATCH_SIZE)) {
-			const rows = await this.db
-				.selectFrom("_emdash_media_usage_sources")
-				.selectAll()
-				.where("source_key", "in", sourceKeyBatch)
-				.execute();
-			for (const row of rows) {
+		for (const sourceKeyBatch of chunkJsonRows(uniqueSourceKeys)) {
+			const input = jsonTextValues(this.db, sourceKeyBatch);
+			const result = await sql<Selectable<MediaUsageSourceTable>>`
+				WITH requested AS (${input})
+				SELECT source.*
+				FROM _emdash_media_usage_sources AS source
+				INNER JOIN requested ON requested.value = source.source_key
+			`.execute(this.db);
+			for (const row of result.rows) {
 				const source = rowToSource(row);
 				sources.set(source.sourceKey, source);
 			}
@@ -619,6 +698,411 @@ export class MediaUsageRepository {
 		};
 	}
 
+	async replaceNewSourcesBatch(
+		projections: readonly MediaUsageNewSourceProjection[],
+	): Promise<Set<string>> {
+		const unique = [
+			...new Map(
+				projections.map((projection) => [projection.source.sourceKey, projection]),
+			).values(),
+		];
+		if (unique.length === 0) return new Set();
+		const collectionSlug = unique[0]?.source.collectionSlug;
+		const collectionId = unique[0]?.source.collectionId;
+		if (!collectionSlug || !collectionId) {
+			throw new Error("Canonical media usage batch requires collection identity");
+		}
+		validateIdentifier(collectionSlug, "collection slug");
+		if (
+			unique.some(
+				(projection) =>
+					projection.source.collectionSlug !== collectionSlug ||
+					projection.source.collectionId !== collectionId,
+			)
+		) {
+			throw new Error("Canonical media usage batch must contain one collection");
+		}
+
+		const now = new Date().toISOString();
+		const expiresAt = new Date(Date.now() + MEDIA_USAGE_GENERATION_WRITE_LEASE_MS).toISOString();
+		const prepared = unique.map((projection) => {
+			const generation = ulid();
+			return {
+				projection,
+				generation,
+				leaseToken: ulid(),
+				row: this.buildSourceRow(projection.source, generation, now),
+			};
+		});
+
+		const leasesPayload = JSON.stringify(
+			prepared.map((item) => ({
+				source_key: item.row.source_key,
+				collection_id: item.row.collection_id,
+				collection_slug: item.row.collection_slug,
+				generation: item.generation,
+				lease_token: item.leaseToken,
+				expires_at: expiresAt,
+				created_at: now,
+			})),
+		);
+		const leases = this.generationWriteBatchInput(leasesPayload);
+		await sql`
+			WITH input AS (${leases})
+			INSERT INTO _emdash_media_usage_generation_writes (
+				source_key, generation, lease_token, expires_at, created_at
+			)
+			SELECT source_key, generation, lease_token, expires_at, created_at
+			FROM input
+			WHERE EXISTS (
+				SELECT 1
+				FROM _emdash_collections AS collection
+				INNER JOIN _emdash_media_usage_index_status AS status
+					ON status.collection_id = collection.id
+					AND status.scope_key = collection.slug
+				WHERE collection.id = input.collection_id
+					AND collection.slug = input.collection_slug
+					AND status.adapter_id = 'content-media'
+					AND status.scope_type = 'collection'
+					AND status.capture_state = 'active'
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+						WHERE deletion.collection_id = input.collection_id
+					)
+			)
+		`.execute(this.db);
+
+		try {
+			await this.insertBatchOccurrences(prepared, now);
+			const tableName = `ec_${collectionSlug}`;
+			validateIdentifier(tableName, "content table");
+			const inserted = new Set<string>();
+			const sourceRows = prepared.map((item) => ({
+				...item.row,
+				lease_token: item.leaseToken,
+			}));
+			for (const sourceRowBatch of chunkJsonRows(sourceRows)) {
+				const input = this.sourceBatchInput(JSON.stringify(sourceRowBatch));
+				const result = await sql<{ source_key: string }>`
+					WITH input AS (${input})
+					INSERT INTO _emdash_media_usage_sources (
+						source_key, source_type, collection_id, collection_slug, content_id,
+						source_variant, locale, translation_group, content_slug, content_title,
+						content_status, content_scheduled_at, content_deleted_at, revision_id,
+						current_generation, schema_version, source_updated_at, source_version,
+						source_fingerprint, identity_version, source_completeness,
+						last_attempted_at, last_error_code, indexed_at, updated_at
+					)
+					SELECT
+						input.source_key, input.source_type, input.collection_id, input.collection_slug,
+						input.content_id, input.source_variant, input.locale, input.translation_group,
+						input.content_slug, input.content_title, input.content_status,
+						input.content_scheduled_at, input.content_deleted_at, input.revision_id,
+						input.current_generation, input.schema_version, input.source_updated_at,
+						input.source_version, input.source_fingerprint, input.identity_version,
+						input.source_completeness, input.last_attempted_at, input.last_error_code,
+						input.indexed_at, input.updated_at
+					FROM input
+					WHERE EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_generation_writes AS writer
+						WHERE writer.source_key = input.source_key
+							AND writer.generation = input.current_generation
+							AND writer.lease_token = input.lease_token
+							AND ${this.generationWriteLeaseExpiryIsInFuture("writer.expires_at")}
+					)
+					AND EXISTS (
+						SELECT 1
+						FROM _emdash_collections AS collection
+						INNER JOIN _emdash_media_usage_index_status AS status
+							ON status.collection_id = collection.id
+							AND status.scope_key = collection.slug
+						WHERE collection.id = input.collection_id
+							AND collection.slug = input.collection_slug
+							AND status.adapter_id = 'content-media'
+							AND status.scope_type = 'collection'
+							AND status.capture_state = 'active'
+							AND NOT EXISTS (
+								SELECT 1
+								FROM _emdash_media_usage_collection_deletions AS deletion
+								WHERE deletion.collection_id = input.collection_id
+							)
+					)
+					AND EXISTS (
+						SELECT 1
+						FROM ${sql.ref(tableName)} AS content
+						WHERE content.id = input.content_id
+							AND content.version = input.source_version
+							AND content.updated_at = input.source_updated_at
+							AND (
+								(input.source_variant = 'columns' AND ${nullableRefMatch("content.live_revision_id", "input.revision_id")})
+								OR
+								(input.source_variant = 'draft_overlay' AND ${nullableRefMatch("content.draft_revision_id", "input.revision_id")})
+							)
+					)
+					ON CONFLICT (source_key) DO NOTHING
+					RETURNING source_key
+				`.execute(this.db);
+				for (const row of result.rows) inserted.add(row.source_key);
+			}
+			return inserted;
+		} finally {
+			await sql`
+				WITH input AS (${leases})
+				DELETE FROM _emdash_media_usage_generation_writes AS writer
+				WHERE EXISTS (
+					SELECT 1
+					FROM input
+					WHERE input.source_key = writer.source_key
+						AND input.generation = writer.generation
+						AND input.lease_token = writer.lease_token
+				)
+			`.execute(this.db);
+		}
+	}
+
+	async replaceExistingSourcesBatch(
+		projections: readonly MediaUsageExistingSourceProjection[],
+	): Promise<Set<string>> {
+		const unique = [
+			...new Map(
+				projections.map((projection) => [projection.source.sourceKey, projection]),
+			).values(),
+		];
+		if (unique.length === 0) return new Set();
+		const collectionSlug = unique[0]?.source.collectionSlug;
+		const collectionId = unique[0]?.source.collectionId;
+		if (!collectionSlug || !collectionId) {
+			throw new Error("Canonical media usage batch requires collection identity");
+		}
+		validateIdentifier(collectionSlug, "collection slug");
+		if (
+			unique.some(
+				(projection) =>
+					projection.source.collectionSlug !== collectionSlug ||
+					projection.source.collectionId !== collectionId,
+			)
+		) {
+			throw new Error("Canonical media usage batch must contain one collection");
+		}
+
+		const now = new Date().toISOString();
+		const expiresAt = new Date(Date.now() + MEDIA_USAGE_GENERATION_WRITE_LEASE_MS).toISOString();
+		const prepared = unique.map((projection) => {
+			const generation = ulid();
+			return {
+				projection,
+				generation,
+				leaseToken: ulid(),
+				row: this.buildSourceRow(projection.source, generation, now),
+			};
+		});
+		const leasesPayload = JSON.stringify(
+			prepared.map((item) => ({
+				source_key: item.row.source_key,
+				collection_id: item.row.collection_id,
+				collection_slug: item.row.collection_slug,
+				generation: item.generation,
+				lease_token: item.leaseToken,
+				expires_at: expiresAt,
+				created_at: now,
+			})),
+		);
+		const leases = this.generationWriteBatchInput(leasesPayload);
+		await sql`
+			WITH input AS (${leases})
+			INSERT INTO _emdash_media_usage_generation_writes (
+				source_key, generation, lease_token, expires_at, created_at
+			)
+			SELECT source_key, generation, lease_token, expires_at, created_at
+			FROM input
+			WHERE EXISTS (
+				SELECT 1
+				FROM _emdash_collections AS collection
+				INNER JOIN _emdash_media_usage_index_status AS status
+					ON status.collection_id = collection.id
+					AND status.scope_key = collection.slug
+				WHERE collection.id = input.collection_id
+					AND collection.slug = input.collection_slug
+					AND status.adapter_id = 'content-media'
+					AND status.scope_type = 'collection'
+					AND status.capture_state = 'active'
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+						WHERE deletion.collection_id = input.collection_id
+					)
+			)
+		`.execute(this.db);
+
+		try {
+			await this.insertBatchOccurrences(prepared, now);
+			const tableName = `ec_${collectionSlug}`;
+			validateIdentifier(tableName, "content table");
+			const replaced = new Set<string>();
+			const sourceRows = prepared.map((item) => ({
+				...item.row,
+				lease_token: item.leaseToken,
+				expected_generation: item.projection.expectedSource.currentGeneration,
+				expected_collection_id: item.projection.expectedSource.collectionId,
+				expected_updated_at: item.projection.expectedSource.updatedAt,
+				expected_source_fingerprint: item.projection.expectedSource.sourceFingerprint,
+				expected_source_updated_at: item.projection.expectedSource.sourceUpdatedAt,
+				expected_source_version: item.projection.expectedSource.sourceVersion,
+				expected_identity_version: item.projection.expectedSource.identityVersion,
+				expected_revision_id: item.projection.expectedSource.revisionId,
+				expected_source_completeness: item.projection.expectedSource.sourceCompleteness,
+				expected_last_attempted_at: item.projection.expectedSource.lastAttemptedAt,
+				expected_last_error_code: item.projection.expectedSource.lastErrorCode,
+			}));
+			for (const sourceRowBatch of chunkJsonRows(sourceRows)) {
+				const input = this.sourceBatchInput(JSON.stringify(sourceRowBatch));
+				const result = await sql<{ source_key: string }>`
+					WITH input AS (${input})
+					UPDATE _emdash_media_usage_sources AS source
+					SET source_type = input.source_type,
+						collection_id = input.collection_id,
+						collection_slug = input.collection_slug,
+						content_id = input.content_id,
+						source_variant = input.source_variant,
+						locale = input.locale,
+						translation_group = input.translation_group,
+						content_slug = input.content_slug,
+						content_title = input.content_title,
+						content_status = input.content_status,
+						content_scheduled_at = input.content_scheduled_at,
+						content_deleted_at = input.content_deleted_at,
+						revision_id = input.revision_id,
+						current_generation = input.current_generation,
+						schema_version = input.schema_version,
+						source_updated_at = input.source_updated_at,
+						source_version = input.source_version,
+						source_fingerprint = input.source_fingerprint,
+						identity_version = input.identity_version,
+						source_completeness = input.source_completeness,
+						last_attempted_at = input.last_attempted_at,
+						last_error_code = input.last_error_code,
+						indexed_at = input.indexed_at,
+						updated_at = input.updated_at
+					FROM input
+					WHERE source.source_key = input.source_key
+						AND source.current_generation = input.expected_generation
+						AND ${this.batchRefsMatch("source.collection_id", "input.expected_collection_id")}
+						AND source.updated_at = input.expected_updated_at
+						AND ${this.batchRefsMatch("source.source_fingerprint", "input.expected_source_fingerprint")}
+						AND ${this.batchRefsMatch("source.source_updated_at", "input.expected_source_updated_at")}
+						AND ${this.batchRefsMatch("source.source_version", "input.expected_source_version")}
+						AND ${this.batchRefsMatch("source.identity_version", "input.expected_identity_version")}
+						AND ${this.batchRefsMatch("source.revision_id", "input.expected_revision_id")}
+						AND source.source_completeness = input.expected_source_completeness
+						AND ${this.batchRefsMatch("source.last_attempted_at", "input.expected_last_attempted_at")}
+						AND ${this.batchRefsMatch("source.last_error_code", "input.expected_last_error_code")}
+						AND EXISTS (
+							SELECT 1
+							FROM _emdash_media_usage_generation_writes AS writer
+							WHERE writer.source_key = input.source_key
+								AND writer.generation = input.current_generation
+								AND writer.lease_token = input.lease_token
+								AND ${this.generationWriteLeaseExpiryIsInFuture("writer.expires_at")}
+						)
+						AND EXISTS (
+							SELECT 1
+							FROM _emdash_collections AS collection
+							INNER JOIN _emdash_media_usage_index_status AS status
+								ON status.collection_id = collection.id
+								AND status.scope_key = collection.slug
+							WHERE collection.id = input.collection_id
+								AND collection.slug = input.collection_slug
+								AND status.adapter_id = 'content-media'
+								AND status.scope_type = 'collection'
+								AND status.capture_state = 'active'
+								AND NOT EXISTS (
+									SELECT 1
+									FROM _emdash_media_usage_collection_deletions AS deletion
+									WHERE deletion.collection_id = input.collection_id
+								)
+						)
+						AND EXISTS (
+							SELECT 1
+							FROM ${sql.ref(tableName)} AS content
+							WHERE content.id = input.content_id
+								AND content.version = input.source_version
+								AND content.updated_at = input.source_updated_at
+								AND (
+									(input.source_variant = 'columns' AND ${nullableRefMatch("content.live_revision_id", "input.revision_id")})
+									OR
+									(input.source_variant = 'draft_overlay' AND ${nullableRefMatch("content.draft_revision_id", "input.revision_id")})
+								)
+						)
+					RETURNING ${isPostgres(this.db) ? sql`source.source_key` : sql`source_key`} AS source_key
+				`.execute(this.db);
+				for (const row of result.rows) replaced.add(row.source_key);
+			}
+			return replaced;
+		} finally {
+			await sql`
+				WITH input AS (${leases})
+				DELETE FROM _emdash_media_usage_generation_writes AS writer
+				WHERE EXISTS (
+					SELECT 1
+					FROM input
+					WHERE input.source_key = writer.source_key
+						AND input.generation = writer.generation
+						AND input.lease_token = writer.lease_token
+				)
+			`.execute(this.db);
+		}
+	}
+
+	async matchingExistingSourcesBatch(
+		projections: readonly MediaUsageExistingSourceProjection[],
+	): Promise<Set<string>> {
+		if (projections.length === 0) return new Set();
+		const now = new Date().toISOString();
+		const rows = projections.map((projection) => ({
+			...this.buildSourceRow(projection.source, projection.expectedSource.currentGeneration, now),
+			expected_generation: projection.expectedSource.currentGeneration,
+			expected_collection_id: projection.expectedSource.collectionId,
+			expected_updated_at: projection.expectedSource.updatedAt,
+			expected_source_fingerprint: projection.expectedSource.sourceFingerprint,
+			expected_source_updated_at: projection.expectedSource.sourceUpdatedAt,
+			expected_source_version: projection.expectedSource.sourceVersion,
+			expected_identity_version: projection.expectedSource.identityVersion,
+			expected_revision_id: projection.expectedSource.revisionId,
+			expected_source_completeness: projection.expectedSource.sourceCompleteness,
+			expected_last_attempted_at: projection.expectedSource.lastAttemptedAt,
+			expected_last_error_code: projection.expectedSource.lastErrorCode,
+		}));
+		const matched = new Set<string>();
+		for (const batch of chunkJsonRows(rows)) {
+			const input = this.sourceBatchInput(JSON.stringify(batch));
+			const result = await sql<{ source_key: string }>`
+				WITH input AS (${input})
+				SELECT source.source_key
+				FROM _emdash_media_usage_sources AS source
+				INNER JOIN input ON input.source_key = source.source_key
+				WHERE source.current_generation = input.expected_generation
+					AND ${this.batchRefsMatch("source.collection_id", "input.expected_collection_id")}
+					AND source.updated_at = input.expected_updated_at
+					AND ${this.batchRefsMatch("source.source_fingerprint", "input.expected_source_fingerprint")}
+					AND ${this.batchRefsMatch("source.source_updated_at", "input.expected_source_updated_at")}
+					AND ${this.batchRefsMatch("source.source_version", "input.expected_source_version")}
+					AND ${this.batchRefsMatch("source.identity_version", "input.expected_identity_version")}
+					AND ${this.batchRefsMatch("source.revision_id", "input.expected_revision_id")}
+					AND source.source_completeness = input.expected_source_completeness
+					AND ${this.batchRefsMatch("source.last_attempted_at", "input.expected_last_attempted_at")}
+					AND ${this.batchRefsMatch("source.last_error_code", "input.expected_last_error_code")}
+					AND EXISTS (
+						SELECT 1
+						FROM _emdash_collections AS collection
+						WHERE collection.id = source.collection_id
+							AND collection.slug = source.collection_slug
+					)
+			`.execute(this.db);
+			for (const row of result.rows) matched.add(row.source_key);
+		}
+		return matched;
+	}
+
 	async markSourceAttempted(source: MediaUsageSourceInput): Promise<MediaUsageSource> {
 		if (source.collectionId !== undefined && source.collectionId !== null) {
 			const expectedSource = await this.findSource(source.sourceKey);
@@ -762,6 +1246,155 @@ export class MediaUsageRepository {
 		}));
 	}
 
+	async findCollectionProgress(): Promise<MediaUsageCollectionProgress | null> {
+		const result = await sql<{
+			activation_active: boolean | number;
+			activation_generation: number | string | null;
+			needs_attention: boolean | number;
+			ready_collections: number | string;
+			total_collections: number | string;
+			indexing_started: boolean | number;
+			finalizing: boolean | number;
+		}>`
+			WITH collection_progress AS (
+				SELECT
+					CASE WHEN status.status = 'complete'
+						AND status.schema_version = ${CONTENT_SOURCE_SCHEMA_VERSION}
+						AND status.reconciliation_required = 0
+						AND status.capture_state = 'active'
+						AND NOT EXISTS (
+							SELECT 1 FROM _emdash_media_usage_work AS work
+							WHERE work.collection_id = collection.id
+								AND work.collection_slug = collection.slug
+						)
+					THEN 1 ELSE 0 END AS is_ready,
+						CASE WHEN status.reconciliation_required = 1 AND EXISTS (
+						SELECT 1 FROM _emdash_media_usage_reconciliations AS reconciliation
+						WHERE reconciliation.collection_id = collection.id
+								AND reconciliation.collection_slug = collection.slug
+						) THEN 1 ELSE 0 END AS reconciliation_started,
+						CASE WHEN status.status = 'running'
+							AND status.reconciliation_required = 1
+							AND NOT EXISTS (
+								SELECT 1 FROM _emdash_media_usage_work AS work
+								WHERE work.collection_id = collection.id
+									AND work.collection_slug = collection.slug
+							)
+							AND EXISTS (
+								SELECT 1 FROM _emdash_media_usage_reconciliations AS reconciliation
+								WHERE reconciliation.collection_id = collection.id
+									AND reconciliation.collection_slug = collection.slug
+									AND reconciliation.run_token = status.cursor
+									AND reconciliation.target_epoch = status.change_epoch
+									AND reconciliation.phase = 'sources'
+									AND reconciliation.state IN ('pending', 'leased')
+							)
+						THEN 1 ELSE 0 END AS is_finalizing,
+					CASE WHEN status.collection_id IS NULL
+						OR COALESCE(status.capture_state, '') <> 'active'
+						OR status.status NOT IN ('complete', 'never', 'running', 'partial', 'failed', 'stale')
+						OR status.status = 'failed'
+						OR (
+							status.reconciliation_required = 0
+							AND (
+								status.status <> 'complete'
+								OR COALESCE(status.schema_version, -1) <> ${CONTENT_SOURCE_SCHEMA_VERSION}
+							)
+							AND NOT EXISTS (
+								SELECT 1 FROM _emdash_media_usage_work AS work
+								WHERE work.collection_id = collection.id
+									AND work.collection_slug = collection.slug
+							)
+						)
+						OR EXISTS (
+							SELECT 1 FROM _emdash_media_usage_work AS work
+							WHERE work.collection_id = collection.id
+								AND work.collection_slug = collection.slug
+								AND work.state = 'failed'
+						)
+						OR EXISTS (
+							SELECT 1 FROM _emdash_media_usage_reconciliations AS reconciliation
+							WHERE reconciliation.collection_id = collection.id
+								AND reconciliation.collection_slug = collection.slug
+								AND reconciliation.state = 'failed'
+								AND status.reconciliation_required = 1
+						)
+					THEN 1 ELSE 0 END AS needs_attention
+				FROM _emdash_collections AS collection
+				LEFT JOIN _emdash_media_usage_index_status AS status
+					ON status.adapter_id = 'content-media'
+					AND status.scope_type = 'collection'
+					AND status.collection_id = collection.id
+					AND status.scope_key = collection.slug
+				WHERE NOT EXISTS (
+					SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.collection_id = collection.id
+						AND deletion.collection_slug = collection.slug
+				)
+			)
+			SELECT
+				(
+					SELECT activation.runtime_generation
+					FROM _emdash_media_usage_activation AS activation
+					WHERE activation.task_key = 'incremental_capture'
+				) AS activation_generation,
+				EXISTS (
+					SELECT 1 FROM _emdash_media_usage_activation AS activation
+					WHERE activation.task_key = 'incremental_capture'
+						AND activation.state = 'active'
+				) AS activation_active,
+				COUNT(*) AS total_collections,
+				COALESCE(SUM(is_ready), 0) AS ready_collections,
+					CASE WHEN COALESCE(MAX(is_ready), 0) = 1
+					OR COALESCE(MAX(reconciliation_started), 0) = 1
+					THEN 1 ELSE 0 END AS indexing_started,
+					CASE WHEN COUNT(*) > COALESCE(SUM(is_ready), 0)
+						AND COALESCE(SUM(CASE WHEN is_ready = 1 OR is_finalizing = 1 THEN 1 ELSE 0 END), 0)
+							= COUNT(*)
+					THEN 1 ELSE 0 END AS finalizing,
+				CASE WHEN COALESCE(MAX(needs_attention), 0) = 1 OR EXISTS (
+					SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.state = 'failed'
+				) THEN 1 ELSE 0 END AS needs_attention
+			FROM collection_progress
+		`.execute(this.db);
+		const row = result.rows[0];
+		if (!row) throw new Error("Media usage progress query returned no result");
+		if (!row.activation_active) return null;
+		if (Number(row.activation_generation) !== MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION) {
+			throw new MediaUsageActivationVersionMismatchError(
+				"Media usage activation runtime generation is incompatible",
+			);
+		}
+		const readyCollections = Number(row.ready_collections);
+		const totalCollections = Number(row.total_collections);
+		const indexingStarted = Number(row.indexing_started);
+		const finalizing = Number(row.finalizing);
+		const needsAttention = Number(row.needs_attention);
+		if (
+			!Number.isSafeInteger(readyCollections) ||
+			!Number.isSafeInteger(totalCollections) ||
+			readyCollections < 0 ||
+			totalCollections < readyCollections ||
+			(indexingStarted !== 0 && indexingStarted !== 1) ||
+			(finalizing !== 0 && finalizing !== 1) ||
+			(needsAttention !== 0 && needsAttention !== 1)
+		) {
+			throw new Error("Media usage progress query returned invalid counts");
+		}
+		return {
+			status: needsAttention
+				? "needs_attention"
+				: readyCollections === totalCollections
+					? "ready"
+					: "indexing",
+			readyCollections,
+			totalCollections,
+			indexingStarted: indexingStarted === 1,
+			...(needsAttention === 0 && finalizing === 1 ? { finalizing: true as const } : {}),
+		};
+	}
+
 	async findCurrentEntryUsagePageByMediaId(
 		mediaId: string,
 		options: FindMediaUsageOptions = {},
@@ -1694,6 +2327,7 @@ export class MediaUsageRepository {
 				last_error_code: sql<
 					string | null
 				>`CASE WHEN ${canComplete} THEN NULL ELSE last_error_code END`,
+				cursor: sql<string | null>`CASE WHEN ${canComplete} THEN NULL ELSE cursor END`,
 				last_incremental_success_at: now,
 				updated_at: now,
 			})
@@ -1715,6 +2349,94 @@ export class MediaUsageRepository {
 		return Number(result.numUpdatedRows ?? 0) > 0;
 	}
 
+	async prepareIncrementalFinalization(
+		input: MediaUsageIncrementalStatusIdentity,
+	): Promise<
+		{ outcome: "marked"; marker: string } | { outcome: "not_required" } | { outcome: "lost" }
+	> {
+		const observed = await this.db
+			.selectFrom("_emdash_media_usage_index_status")
+			.select(["change_epoch", "reconciliation_required"])
+			.where("adapter_id", "=", "content-media")
+			.where("scope_type", "=", "collection")
+			.where("scope_key", "=", input.collectionSlug)
+			.where("collection_id", "=", input.collectionId)
+			.where("capture_state", "=", "active")
+			.executeTakeFirst();
+		if (!observed) return { outcome: "lost" };
+		if (observed.reconciliation_required !== 0) return { outcome: "not_required" };
+		const marker = `incremental-finalize:${String(observed.change_epoch)}:${ulid()}`;
+		const result = await this.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ cursor: marker, updated_at: this.sortableUtcTimestamp() })
+			.where("adapter_id", "=", "content-media")
+			.where("scope_type", "=", "collection")
+			.where("scope_key", "=", input.collectionSlug)
+			.where("collection_id", "=", input.collectionId)
+			.where("capture_state", "=", "active")
+			.where("reconciliation_required", "=", 0)
+			.where("change_epoch", "=", observed.change_epoch)
+			.where(
+				sql<boolean>`EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = ${input.collectionId}
+						AND collection.slug = ${input.collectionSlug}
+				)`,
+			)
+			.where(
+				sql<boolean>`NOT EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.collection_id = ${input.collectionId}
+				)`,
+			)
+			.executeTakeFirst();
+		return Number(result.numUpdatedRows ?? 0) > 0
+			? { outcome: "marked", marker }
+			: { outcome: "lost" };
+	}
+
+	async recoverIncrementalFinalizations(): Promise<number> {
+		const markerMatchesEpoch = isPostgres(this.db)
+			? sql<boolean>`status.cursor LIKE ('incremental-finalize:' || status.change_epoch::text || ':%')`
+			: sql<boolean>`status.cursor LIKE ('incremental-finalize:' || CAST(status.change_epoch AS text) || ':%')`;
+		const now = new Date().toISOString();
+		const result = await sql<{ collection_id: string }>`
+			UPDATE _emdash_media_usage_index_status AS status
+			SET status = 'complete',
+				completed_at = ${now},
+				cursor = NULL,
+				last_error_code = NULL,
+				last_incremental_success_at = ${now},
+				updated_at = ${now}
+			WHERE status.adapter_id = 'content-media'
+				AND status.scope_type = 'collection'
+				AND status.capture_state = 'active'
+				AND status.reconciliation_required = 0
+				AND status.cursor IS NOT NULL
+				AND ${markerMatchesEpoch}
+				AND EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = status.collection_id
+						AND collection.slug = status.scope_key
+				)
+				AND NOT EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_collection_deletions AS deletion
+					WHERE deletion.collection_id = status.collection_id
+				)
+				AND NOT EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_work AS work
+					WHERE work.collection_id = status.collection_id
+				)
+			RETURNING collection_id
+		`.execute(this.db);
+		return result.rows.length;
+	}
+
 	async recordIncrementalFailure(
 		input: MediaUsageIncrementalStatusIdentity & {
 			contentId: string;
@@ -1778,6 +2500,71 @@ export class MediaUsageRepository {
 		return Number(result.numUpdatedRows ?? 0) > 0;
 	}
 
+	async recordIncrementalFailuresByCollection(input: {
+		collectionIds: readonly string[];
+		errorCode: string;
+	}): Promise<Set<string>> {
+		const collectionIds = [...new Set(input.collectionIds)];
+		if (collectionIds.length === 0) return new Set();
+		const collections = jsonTextValues(this.db, collectionIds);
+		const now = new Date().toISOString();
+		const result = await sql<{ collection_id: string }>`
+			WITH failed_collections AS (${collections})
+			UPDATE _emdash_media_usage_index_status AS status
+			SET status = CASE
+					WHEN EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_reconciliations AS reconciliation
+						WHERE reconciliation.collection_id = status.collection_id
+							AND reconciliation.run_token = status.cursor
+					) THEN status.status
+					WHEN status.reconciliation_required = 0 THEN 'partial'
+					WHEN status.status = 'running' THEN 'stale'
+					ELSE status.status
+				END,
+				completed_at = CASE
+					WHEN EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_reconciliations AS reconciliation
+						WHERE reconciliation.collection_id = status.collection_id
+							AND reconciliation.run_token = status.cursor
+					) THEN status.completed_at
+					WHEN status.reconciliation_required = 0 OR status.status = 'running' THEN NULL
+					ELSE status.completed_at
+				END,
+				cursor = CASE
+					WHEN EXISTS (
+						SELECT 1
+						FROM _emdash_media_usage_reconciliations AS reconciliation
+						WHERE reconciliation.collection_id = status.collection_id
+							AND reconciliation.run_token = status.cursor
+					) THEN status.cursor
+					WHEN status.status = 'running' THEN NULL
+					ELSE status.cursor
+				END,
+				last_error_code = ${input.errorCode},
+				updated_at = ${now}
+			WHERE status.adapter_id = 'content-media'
+				AND status.scope_type = 'collection'
+				AND status.collection_id IN (SELECT value FROM failed_collections)
+				AND EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_work AS work
+					WHERE work.collection_id = status.collection_id
+						AND work.state = 'failed'
+						AND work.last_error_code = ${input.errorCode}
+				)
+				AND EXISTS (
+					SELECT 1
+					FROM _emdash_collections AS collection
+					WHERE collection.id = status.collection_id
+						AND collection.slug = status.scope_key
+				)
+			RETURNING collection_id
+		`.execute(this.db);
+		return new Set(result.rows.map((row) => row.collection_id));
+	}
+
 	async findIndexStatus(
 		identity: MediaUsageIndexStatusIdentity,
 	): Promise<MediaUsageIndexStatus | null> {
@@ -2204,6 +2991,225 @@ export class MediaUsageRepository {
 		}
 	}
 
+	private async insertBatchOccurrences(
+		prepared: readonly {
+			projection: MediaUsageNewSourceProjection;
+			generation: string;
+			leaseToken: string;
+			row: { source_key: string };
+		}[],
+		now: string,
+	): Promise<void> {
+		const rows = prepared.flatMap((item) =>
+			item.projection.occurrences.map((occurrence) => ({
+				id: ulid(),
+				source_key: item.row.source_key,
+				generation: item.generation,
+				field_slug: occurrence.fieldSlug,
+				field_path: occurrence.fieldPath,
+				occurrence_index: occurrence.occurrenceIndex ?? 0,
+				reference_type: occurrence.referenceType,
+				media_id: occurrence.mediaId,
+				provider: occurrence.provider,
+				provider_asset_id: occurrence.providerAssetId,
+				media_kind: occurrence.mediaKind ?? null,
+				mime_type: occurrence.mimeType ?? null,
+				created_at: now,
+				lease_token: item.leaseToken,
+			})),
+		);
+		for (const rowBatch of chunkJsonRows(rows)) {
+			const input = this.occurrenceBatchInput(JSON.stringify(rowBatch));
+			await sql`
+				WITH input AS (${input})
+				INSERT INTO _emdash_media_usage (
+					id, source_key, generation, field_slug, field_path, occurrence_index,
+					reference_type, media_id, provider, provider_asset_id, media_kind,
+					mime_type, created_at
+				)
+				SELECT
+					id, source_key, generation, field_slug, field_path, occurrence_index,
+					reference_type, media_id, provider, provider_asset_id, media_kind,
+					mime_type, created_at
+				FROM input
+				WHERE EXISTS (
+					SELECT 1
+					FROM _emdash_media_usage_generation_writes AS writer
+					WHERE writer.source_key = input.source_key
+						AND writer.generation = input.generation
+						AND writer.lease_token = input.lease_token
+						AND ${this.generationWriteLeaseExpiryIsInFuture("writer.expires_at")}
+				)
+			`.execute(this.db);
+		}
+	}
+
+	private occurrenceBatchInput(payload: string): RawBuilder<unknown> {
+		if (isPostgres(this.db)) {
+			return sql`
+				SELECT
+					entry.value ->> 'id' AS id,
+					entry.value ->> 'source_key' AS source_key,
+					entry.value ->> 'generation' AS generation,
+					entry.value ->> 'field_slug' AS field_slug,
+					entry.value ->> 'field_path' AS field_path,
+					CAST(entry.value ->> 'occurrence_index' AS integer) AS occurrence_index,
+					entry.value ->> 'reference_type' AS reference_type,
+					entry.value ->> 'media_id' AS media_id,
+					entry.value ->> 'provider' AS provider,
+					entry.value ->> 'provider_asset_id' AS provider_asset_id,
+					entry.value ->> 'media_kind' AS media_kind,
+					entry.value ->> 'mime_type' AS mime_type,
+					entry.value ->> 'created_at' AS created_at,
+					entry.value ->> 'lease_token' AS lease_token
+				FROM jsonb_array_elements(${payload}::jsonb) AS entry(value)
+			`;
+		}
+		return sql`
+			SELECT
+				json_extract(entry.value, '$.id') AS id,
+				json_extract(entry.value, '$.source_key') AS source_key,
+				json_extract(entry.value, '$.generation') AS generation,
+				json_extract(entry.value, '$.field_slug') AS field_slug,
+				json_extract(entry.value, '$.field_path') AS field_path,
+				CAST(json_extract(entry.value, '$.occurrence_index') AS integer) AS occurrence_index,
+				json_extract(entry.value, '$.reference_type') AS reference_type,
+				json_extract(entry.value, '$.media_id') AS media_id,
+				json_extract(entry.value, '$.provider') AS provider,
+				json_extract(entry.value, '$.provider_asset_id') AS provider_asset_id,
+				json_extract(entry.value, '$.media_kind') AS media_kind,
+				json_extract(entry.value, '$.mime_type') AS mime_type,
+				json_extract(entry.value, '$.created_at') AS created_at,
+				json_extract(entry.value, '$.lease_token') AS lease_token
+			FROM json_each(${payload}) AS entry
+		`;
+	}
+
+	private sourceBatchInput(payload: string): RawBuilder<unknown> {
+		if (isPostgres(this.db)) {
+			return sql`
+				SELECT
+					entry.value ->> 'source_key' AS source_key,
+					entry.value ->> 'source_type' AS source_type,
+					entry.value ->> 'collection_id' AS collection_id,
+					entry.value ->> 'collection_slug' AS collection_slug,
+					entry.value ->> 'content_id' AS content_id,
+					entry.value ->> 'source_variant' AS source_variant,
+					entry.value ->> 'locale' AS locale,
+					entry.value ->> 'translation_group' AS translation_group,
+					entry.value ->> 'content_slug' AS content_slug,
+					entry.value ->> 'content_title' AS content_title,
+					entry.value ->> 'content_status' AS content_status,
+					entry.value ->> 'content_scheduled_at' AS content_scheduled_at,
+					entry.value ->> 'content_deleted_at' AS content_deleted_at,
+					entry.value ->> 'revision_id' AS revision_id,
+					entry.value ->> 'current_generation' AS current_generation,
+					CAST(entry.value ->> 'schema_version' AS integer) AS schema_version,
+					entry.value ->> 'source_updated_at' AS source_updated_at,
+					CAST(entry.value ->> 'source_version' AS bigint) AS source_version,
+					entry.value ->> 'source_fingerprint' AS source_fingerprint,
+					CAST(entry.value ->> 'identity_version' AS integer) AS identity_version,
+					entry.value ->> 'source_completeness' AS source_completeness,
+					entry.value ->> 'last_attempted_at' AS last_attempted_at,
+					entry.value ->> 'last_error_code' AS last_error_code,
+					entry.value ->> 'indexed_at' AS indexed_at,
+					entry.value ->> 'updated_at' AS updated_at,
+					entry.value ->> 'lease_token' AS lease_token,
+					entry.value ->> 'expected_generation' AS expected_generation,
+					entry.value ->> 'expected_collection_id' AS expected_collection_id,
+					entry.value ->> 'expected_updated_at' AS expected_updated_at,
+					entry.value ->> 'expected_source_fingerprint' AS expected_source_fingerprint,
+					entry.value ->> 'expected_source_updated_at' AS expected_source_updated_at,
+					CAST(entry.value ->> 'expected_source_version' AS bigint) AS expected_source_version,
+					CAST(entry.value ->> 'expected_identity_version' AS integer) AS expected_identity_version,
+					entry.value ->> 'expected_revision_id' AS expected_revision_id,
+					entry.value ->> 'expected_source_completeness' AS expected_source_completeness,
+					entry.value ->> 'expected_last_attempted_at' AS expected_last_attempted_at,
+					entry.value ->> 'expected_last_error_code' AS expected_last_error_code
+				FROM jsonb_array_elements(${payload}::jsonb) AS entry(value)
+			`;
+		}
+		return sql`
+			SELECT
+				json_extract(entry.value, '$.source_key') AS source_key,
+				json_extract(entry.value, '$.source_type') AS source_type,
+				json_extract(entry.value, '$.collection_id') AS collection_id,
+				json_extract(entry.value, '$.collection_slug') AS collection_slug,
+				json_extract(entry.value, '$.content_id') AS content_id,
+				json_extract(entry.value, '$.source_variant') AS source_variant,
+				json_extract(entry.value, '$.locale') AS locale,
+				json_extract(entry.value, '$.translation_group') AS translation_group,
+				json_extract(entry.value, '$.content_slug') AS content_slug,
+				json_extract(entry.value, '$.content_title') AS content_title,
+				json_extract(entry.value, '$.content_status') AS content_status,
+				json_extract(entry.value, '$.content_scheduled_at') AS content_scheduled_at,
+				json_extract(entry.value, '$.content_deleted_at') AS content_deleted_at,
+				json_extract(entry.value, '$.revision_id') AS revision_id,
+				json_extract(entry.value, '$.current_generation') AS current_generation,
+				CAST(json_extract(entry.value, '$.schema_version') AS integer) AS schema_version,
+				json_extract(entry.value, '$.source_updated_at') AS source_updated_at,
+				CAST(json_extract(entry.value, '$.source_version') AS integer) AS source_version,
+				json_extract(entry.value, '$.source_fingerprint') AS source_fingerprint,
+				CAST(json_extract(entry.value, '$.identity_version') AS integer) AS identity_version,
+				json_extract(entry.value, '$.source_completeness') AS source_completeness,
+				json_extract(entry.value, '$.last_attempted_at') AS last_attempted_at,
+				json_extract(entry.value, '$.last_error_code') AS last_error_code,
+				json_extract(entry.value, '$.indexed_at') AS indexed_at,
+				json_extract(entry.value, '$.updated_at') AS updated_at,
+				json_extract(entry.value, '$.lease_token') AS lease_token,
+				json_extract(entry.value, '$.expected_generation') AS expected_generation,
+				json_extract(entry.value, '$.expected_collection_id') AS expected_collection_id,
+				json_extract(entry.value, '$.expected_updated_at') AS expected_updated_at,
+				json_extract(entry.value, '$.expected_source_fingerprint') AS expected_source_fingerprint,
+				json_extract(entry.value, '$.expected_source_updated_at') AS expected_source_updated_at,
+				CAST(json_extract(entry.value, '$.expected_source_version') AS integer) AS expected_source_version,
+				CAST(json_extract(entry.value, '$.expected_identity_version') AS integer) AS expected_identity_version,
+				json_extract(entry.value, '$.expected_revision_id') AS expected_revision_id,
+				json_extract(entry.value, '$.expected_source_completeness') AS expected_source_completeness,
+				json_extract(entry.value, '$.expected_last_attempted_at') AS expected_last_attempted_at,
+				json_extract(entry.value, '$.expected_last_error_code') AS expected_last_error_code
+			FROM json_each(${payload}) AS entry
+		`;
+	}
+
+	private generationWriteBatchInput(payload: string): RawBuilder<unknown> {
+		if (isPostgres(this.db)) {
+			return sql`
+				SELECT
+					entry.value ->> 'source_key' AS source_key,
+					entry.value ->> 'collection_id' AS collection_id,
+					entry.value ->> 'collection_slug' AS collection_slug,
+					entry.value ->> 'generation' AS generation,
+					entry.value ->> 'lease_token' AS lease_token,
+					entry.value ->> 'expires_at' AS expires_at,
+					entry.value ->> 'created_at' AS created_at
+				FROM jsonb_array_elements(${payload}::jsonb) AS entry(value)
+			`;
+		}
+		return sql`
+			SELECT
+				json_extract(entry.value, '$.source_key') AS source_key,
+				json_extract(entry.value, '$.collection_id') AS collection_id,
+				json_extract(entry.value, '$.collection_slug') AS collection_slug,
+				json_extract(entry.value, '$.generation') AS generation,
+				json_extract(entry.value, '$.lease_token') AS lease_token,
+				json_extract(entry.value, '$.expires_at') AS expires_at,
+				json_extract(entry.value, '$.created_at') AS created_at
+			FROM json_each(${payload}) AS entry
+		`;
+	}
+
+	private batchRefsMatch(
+		left: BatchSourceExpectedColumn,
+		right: BatchInputExpectedColumn,
+	): RawBuilder<boolean> {
+		const leftRef = sql.ref(left);
+		const rightRef = sql.ref(right);
+		return isPostgres(this.db)
+			? sql<boolean>`${leftRef} IS NOT DISTINCT FROM ${rightRef}`
+			: sql<boolean>`${leftRef} IS ${rightRef}`;
+	}
+
 	private async lockCanonicalSourceCollection(
 		db: DatabaseExecutor,
 		source: MediaUsageSourceInput,
diff --git a/packages/core/src/database/transaction.ts b/packages/core/src/database/transaction.ts
index 238d586dcc..ebd60a051b 100644
--- a/packages/core/src/database/transaction.ts
+++ b/packages/core/src/database/transaction.ts
@@ -29,6 +29,7 @@ export async function withTransaction<DB, T>(
 	db: Kysely<DB>,
 	fn: (trx: Kysely<DB> | Transaction<DB>) => Promise<T>,
 ): Promise<T> {
+	if (db.isTransaction) return fn(db);
 	// Fast path: we already know transactions work
 	if (transactionsSupported === true) {
 		return db.transaction().execute(fn);
diff --git a/packages/core/src/emdash-runtime.ts b/packages/core/src/emdash-runtime.ts
index 8490cc7004..0c57bd80f9 100644
--- a/packages/core/src/emdash-runtime.ts
+++ b/packages/core/src/emdash-runtime.ts
@@ -9,7 +9,7 @@
 
 import { Permissions } from "@emdash-cms/auth";
 import type { Element } from "@emdash-cms/blocks";
-import { Kysely, sql, type Dialect } from "kysely";
+import { Kysely, type Dialect } from "kysely";
 import virtualConfig from "virtual:emdash/config";
 import { z } from "zod";
 
@@ -48,10 +48,6 @@ import { repairLocaleCasing } from "./i18n/repair-locale-casing.js";
 import { warnAboutUnconfiguredTaxonomyLocales } from "./i18n/taxonomy-locale-diagnostic.js";
 import { normalizeMediaValue } from "./media/normalize.js";
 import type { MediaProvider, MediaProviderCapabilities } from "./media/types.js";
-import {
-	MEDIA_USAGE_COLLECTION_DELETION_LIMITS,
-	processDueMediaUsageCollectionDeletions,
-} from "./media/usage/collection-deletion-processor.js";
 import {
 	deleteContentMediaUsage,
 	findNonTranslatableSiblingContentIds,
@@ -59,14 +55,12 @@ import {
 	refreshContentMediaUsageAfterWrite,
 } from "./media/usage/content-refresh.js";
 import {
-	MEDIA_USAGE_RECONCILIATION_LIMITS,
-	processDueMediaUsageReconciliation,
-} from "./media/usage/reconciliation-processor.js";
-import {
-	MEDIA_USAGE_WORK_PROCESSING_LIMITS,
-	processDueMediaUsageWork,
-	processMediaUsageWorkAfterWrite,
-} from "./media/usage/work-processor.js";
+	runMediaUsageMaintenanceSlice,
+	runMediaUsageMaintenanceStep,
+	type MediaUsageMaintenanceContinuation,
+	type MediaUsageMaintenanceStepResult,
+} from "./media/usage/maintenance-engine.js";
+import { processMediaUsageWorkAfterWrite } from "./media/usage/work-processor.js";
 import { createSandboxRunnerOptions } from "./plugins/sandbox/runner-options.js";
 import { getSandboxRouteErrorDetails } from "./plugins/sandbox/types.js";
 import type {
@@ -232,7 +226,7 @@ import { PluginStateRepository } from "./plugins/state.js";
 import { syncDeclaredStorageIndexes } from "./plugins/storage-indexes.js";
 import { normalizeRegistryConfig } from "./registry/config.js";
 import { requestCached } from "./request-cache.js";
-import { getRequestContext } from "./request-context.js";
+import { getRequestContext, runWithContext } from "./request-context.js";
 import { publishDueContent, type PublishedRef } from "./scheduled-publish.js";
 import { FTSManager } from "./search/fts-manager.js";
 import { invalidateSiteSettingsCache } from "./settings/index.js";
@@ -553,61 +547,10 @@ const marketplaceManifestCache = new Map<
 const sandboxedRouteMetaCache = new Map<string, Map<string, RouteMeta>>();
 let sandboxRunner: SandboxRunner | null = null;
 
-export const MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS = Object.freeze({
-	entryWork: MEDIA_USAGE_WORK_PROCESSING_LIMITS.ordinaryStatementsPerJob,
-	collectionDeletion: MEDIA_USAGE_COLLECTION_DELETION_LIMITS.maxQueriesPerTick,
-	reconciliation: MEDIA_USAGE_RECONCILIATION_LIMITS.maxQueriesPerTick,
-	maxClassQueries: Math.max(
-		MEDIA_USAGE_WORK_PROCESSING_LIMITS.ordinaryStatementsPerJob,
-		MEDIA_USAGE_COLLECTION_DELETION_LIMITS.maxQueriesPerTick,
-		MEDIA_USAGE_RECONCILIATION_LIMITS.maxQueriesPerTick,
-	),
-	eventCeiling: 40,
-});
-
-export type MediaUsageMaintenanceTaskClass =
-	| "entry_work"
-	| "collection_deletion"
-	| "reconciliation";
-
-export type MediaUsageMaintenanceResult =
-	| { outcome: "inactive" | "admission_closed"; taskClass: null; turn: null }
-	| { outcome: "processed"; taskClass: MediaUsageMaintenanceTaskClass; turn: number };
-
-async function runScheduledMediaUsageLane(
-	db: Kysely<Database>,
-): Promise<MediaUsageMaintenanceResult> {
-	const queriesAlreadySpent = getRequestContext()?.metrics?.dbCount ?? 0;
-	if (
-		queriesAlreadySpent + 1 + MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS.maxClassQueries >
-		MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS.eventCeiling
-	) {
-		return { outcome: "admission_closed", taskClass: null, turn: null };
-	}
-
-	const activation = await db
-		.updateTable("_emdash_media_usage_activation")
-		.set({
-			media_usage_maintenance_turn: sql<number>`(media_usage_maintenance_turn + 1) % 3`,
-		})
-		.where("task_key", "=", "incremental_capture")
-		.where("state", "=", "active")
-		.returning("media_usage_maintenance_turn")
-		.executeTakeFirst();
-	if (!activation) return { outcome: "inactive", taskClass: null, turn: null };
-
-	const turn = activation.media_usage_maintenance_turn;
-	if (turn === 0) {
-		await processDueMediaUsageWork(db);
-		return { outcome: "processed", taskClass: "entry_work", turn };
-	}
-	if (turn === 1) {
-		await processDueMediaUsageCollectionDeletions(db);
-		return { outcome: "processed", taskClass: "collection_deletion", turn };
-	}
-	await processDueMediaUsageReconciliation(db);
-	return { outcome: "processed", taskClass: "reconciliation", turn };
-}
+export type {
+	MediaUsageMaintenanceContinuation,
+	MediaUsageMaintenanceStepResult,
+} from "./media/usage/maintenance-engine.js";
 
 /**
  * EmDashRuntime - singleton per worker
@@ -814,8 +757,16 @@ export class EmDashRuntime {
 		return { published };
 	}
 
-	async runScheduledMediaUsageTasks(): Promise<MediaUsageMaintenanceResult> {
-		return runScheduledMediaUsageLane(this.db);
+	async runMediaUsageMaintenanceStep(): Promise<MediaUsageMaintenanceStepResult> {
+		return runMediaUsageMaintenanceStep(this.db);
+	}
+
+	async runMediaUsageMaintenanceSlice(): Promise<MediaUsageMaintenanceContinuation> {
+		return runMediaUsageMaintenanceSlice(this.db);
+	}
+
+	wakeMediaUsageMaintenance(): void {
+		this.cronScheduler?.wakeMediaUsageMaintenance();
 	}
 
 	/**
@@ -1756,14 +1707,14 @@ export class EmDashRuntime {
 				if (deps.createScheduler) {
 					const scheduler = deps.createScheduler(cronExecutor);
 					cronScheduler = scheduler;
-					const runMediaUsageMaintenance = async () => {
-						const runtime = runtimeRef.current;
-						if (runtime) {
-							await runtime.runScheduledMediaUsageTasks();
-						} else {
-							await runScheduledMediaUsageLane(db);
-						}
-					};
+					const runContinuousMediaUsageMaintenance = () =>
+						runWithContext({ editMode: false }, async () => {
+							const runtime = runtimeRef.current;
+							const result = runtime
+								? await runtime.runMediaUsageMaintenanceStep()
+								: await runMediaUsageMaintenanceStep(db);
+							return result.continuation;
+						});
 
 					// Run scheduled publishing and system cleanup alongside each tick.
 					// Pass storage so cleanupPendingUploads can delete orphaned files.
@@ -1797,15 +1748,8 @@ export class EmDashRuntime {
 						// Never throws; no-op unless scheduled backups are enabled and due.
 						await maybeRunScheduledBackup(db, storage ?? undefined);
 						await recordSchedulerHeartbeatSafely(db);
-						if (!scheduler.setMediaUsageMaintenance) {
-							try {
-								await runMediaUsageMaintenance();
-							} catch (error) {
-								console.error("[media-usage] Scheduled maintenance failed:", error);
-							}
-						}
 					});
-					scheduler.setMediaUsageMaintenance?.(runMediaUsageMaintenance);
+					scheduler.setContinuousMediaUsageMaintenance(runContinuousMediaUsageMaintenance);
 
 					// start() is void on the timer scheduler but the interface
 					// allows a promise (alarm-backed schedulers); we don't block on it.
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 4936d04156..301da46696 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -311,6 +311,7 @@ export type {
 
 	// Scheduler types
 	CronScheduler,
+	MediaUsageContinuationFn,
 	SystemCleanupFn,
 
 	// Sandbox runtime types
diff --git a/packages/core/src/media/usage/activation.ts b/packages/core/src/media/usage/activation.ts
index 993cea8285..a4f1eb4086 100644
--- a/packages/core/src/media/usage/activation.ts
+++ b/packages/core/src/media/usage/activation.ts
@@ -41,6 +41,12 @@ export type MediaUsageActivationResult =
 	| { outcome: "lease_active"; leaseExpiresAt: string }
 	| { outcome: "conflict"; processedCollections: number };
 
+export type MediaUsageActivationContinuationResult =
+	| MediaUsageActivationResult
+	| { outcome: "inactive" | "failed" };
+
+type MediaUsageActivationClaimMode = "confirmed" | "background";
+
 export interface MediaUsageCollectionCapturePreparation {
 	captureRequired: boolean;
 	collectionId: string;
@@ -274,16 +280,45 @@ export async function activateMediaUsageCapture(
 	if (input.writersDrained !== true) {
 		throw new Error("Media usage activation requires confirmation that writers are drained");
 	}
+	return advanceMediaUsageActivation(db, "confirmed");
+}
 
+export async function continueMediaUsageActivation(
+	db: Kysely<Database>,
+): Promise<MediaUsageActivationContinuationResult> {
+	return advanceMediaUsageActivation(db, "background");
+}
+
+async function advanceMediaUsageActivation(
+	db: Kysely<Database>,
+	mode: "confirmed",
+): Promise<MediaUsageActivationResult>;
+async function advanceMediaUsageActivation(
+	db: Kysely<Database>,
+	mode: "background",
+): Promise<MediaUsageActivationContinuationResult>;
+async function advanceMediaUsageActivation(
+	db: Kysely<Database>,
+	mode: MediaUsageActivationClaimMode,
+): Promise<MediaUsageActivationContinuationResult> {
 	const before = await findActivation(db);
 	assertRuntimeGeneration(before);
 	if (before.state === "active") {
 		return { outcome: "active", processedCollections: 0 };
 	}
+	if (mode === "background") {
+		if (before.state === "expanded" || before.drain_confirmed_at === null) {
+			return { outcome: "inactive" };
+		}
+		if (before.state !== "activating") {
+			throw new Error("Invalid media usage activation state");
+		}
+		if (before.last_error_code !== null) return { outcome: "failed" };
+	}
 
 	const leaseToken = ulid();
-	const lease = await claimActivation(db, leaseToken);
-	if (!lease) return activationClaimLoss(db);
+	const lease = await claimActivation(db, leaseToken, mode);
+	if (!lease) return activationClaimLoss(db, mode);
 
 	let processedCollections = 0;
 	try {
@@ -377,47 +412,76 @@ function assertRuntimeGeneration(activation: { runtime_generation: number }): vo
 async function claimActivation(
 	db: Kysely<Database>,
 	leaseToken: string,
+	mode: MediaUsageActivationClaimMode,
 ): Promise<Selectable<MediaUsageActivationTable> | null> {
 	const now = timestampOffset(db, 0);
-	return (
-		(await db
-			.updateTable("_emdash_media_usage_activation")
-			.set({
-				state: "activating",
-				drain_confirmed_at: now,
-				lease_token: leaseToken,
-				lease_expires_at: timestampOffset(db, MEDIA_USAGE_ACTIVATION_LIMITS.leaseDurationSeconds),
-				attempt_count: sql<number>`attempt_count + 1`,
-				last_attempted_at: now,
-				last_error_code: null,
-				updated_at: now,
-			})
-			.where("task_key", "=", ACTIVATION_KEY)
-			.where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION)
-			.where((eb) =>
-				eb.or([
-					eb("state", "=", "expanded"),
-					eb.and([
-						eb("state", "=", "activating"),
-						eb.or([
-							eb("lease_token", "is", null),
-							eb.and([
-								eb("lease_expires_at", "is not", null),
-								timestampIsDue(db, "lease_expires_at"),
-							]),
+	const claimValues = {
+		lease_token: leaseToken,
+		lease_expires_at: timestampOffset(db, MEDIA_USAGE_ACTIVATION_LIMITS.leaseDurationSeconds),
+		attempt_count: sql<number>`attempt_count + 1`,
+		last_attempted_at: now,
+		updated_at: now,
+	};
+	let claim = db
+		.updateTable("_emdash_media_usage_activation")
+		.set(
+			mode === "confirmed"
+				? {
+						...claimValues,
+						state: "activating",
+						drain_confirmed_at: now,
+						last_error_code: null,
+					}
+				: claimValues,
+		)
+		.where("task_key", "=", ACTIVATION_KEY)
+		.where("runtime_generation", "=", MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION);
+	if (mode === "confirmed") {
+		claim = claim.where((eb) =>
+			eb.or([
+				eb("state", "=", "expanded"),
+				eb.and([
+					eb("state", "=", "activating"),
+					eb.or([
+						eb("lease_token", "is", null),
+						eb.and([
+							eb("lease_expires_at", "is not", null),
+							timestampIsDue(db, "lease_expires_at"),
 						]),
 					]),
 				]),
-			)
-			.returningAll()
-			.executeTakeFirst()) ?? null
-	);
+			]),
+		);
+	} else {
+		claim = claim
+			.where("state", "=", "activating")
+			.where("drain_confirmed_at", "is not", null)
+			.where("last_error_code", "is", null)
+			.where((eb) =>
+				eb.or([
+					eb("lease_token", "is", null),
+					eb.and([eb("lease_expires_at", "is not", null), timestampIsDue(db, "lease_expires_at")]),
+				]),
+			);
+	}
+	return (await claim.returningAll().executeTakeFirst()) ?? null;
 }
 
-async function activationClaimLoss(db: Kysely<Database>): Promise<MediaUsageActivationResult> {
+async function activationClaimLoss(
+	db: Kysely<Database>,
+	mode: MediaUsageActivationClaimMode,
+): Promise<MediaUsageActivationContinuationResult> {
 	const current = await findActivation(db);
 	assertRuntimeGeneration(current);
 	if (current.state === "active") return { outcome: "active", processedCollections: 0 };
+	if (mode === "background") {
+		if (current.state === "expanded" || current.drain_confirmed_at === null) {
+			return { outcome: "inactive" };
+		}
+		if (current.state === "activating" && current.last_error_code !== null) {
+			return { outcome: "failed" };
+		}
+	}
 	if (
 		current.state === "activating" &&
 		current.lease_token &&
@@ -426,6 +490,9 @@ async function activationClaimLoss(db: Kysely<Database>): Promise<MediaUsageActi
 	) {
 		return { outcome: "lease_active", leaseExpiresAt: current.lease_expires_at };
 	}
+	if (mode === "background" && current.state === "activating") {
+		return { outcome: "conflict", processedCollections: 0 };
+	}
 	throw new Error("Media usage activation state is not claimable");
 }
 
diff --git a/packages/core/src/media/usage/capture-triggers.ts b/packages/core/src/media/usage/capture-triggers.ts
index 0eb557fc89..620065f385 100644
--- a/packages/core/src/media/usage/capture-triggers.ts
+++ b/packages/core/src/media/usage/capture-triggers.ts
@@ -8,6 +8,7 @@ const POSTGRES_TRIGGER_FUNCTION = "emdash_media_usage_capture_work";
 const POSTGRES_IDENTIFIER_LIMIT = 63;
 const CAPTURE_TRIGGER_VERSION = 1;
 const OWNED_TRIGGER_PREFIX = "emdash_mu_";
+const MAX_OWNED_CAPTURE_TRIGGERS = 100;
 const WHITESPACE_PATTERN = /\s+/g;
 const TRAILING_SEMICOLON_PATTERN = /;$/;
 
@@ -25,7 +26,14 @@ export async function installMediaUsageCaptureTriggers(
 ): Promise<void> {
 	const identifiers = await captureIdentifiers(identity);
 	if (isPostgres(db)) await installPostgresFunction(db);
-	const installedNames = await listOwnedCaptureTriggers(db, identifiers.tableName);
+	const installedNames = await listOwnedCaptureTriggers(
+		db,
+		identifiers.tableName,
+		MAX_OWNED_CAPTURE_TRIGGERS + 1,
+	);
+	if (installedNames.length > MAX_OWNED_CAPTURE_TRIGGERS) {
+		throw new Error("Media usage capture trigger set exceeds the activation limit");
+	}
 	if (await hasExactCaptureTriggers(db, identifiers, identity, installedNames)) {
 		return;
 	}
@@ -77,7 +85,7 @@ export async function verifyMediaUsageCaptureTriggers(
 		db,
 		identifiers,
 		identity,
-		await listOwnedCaptureTriggers(db, identifiers.tableName),
+		await listOwnedCaptureTriggers(db, identifiers.tableName, MAX_OWNED_CAPTURE_TRIGGERS + 1),
 	);
 }
 
@@ -150,7 +158,9 @@ async function removeCaptureTriggers(
 async function listOwnedCaptureTriggers(
 	db: Kysely<Database>,
 	tableName: string,
+	limit?: number,
 ): Promise<string[]> {
+	const limitClause = limit === undefined ? sql`` : sql`LIMIT ${limit}`;
 	if (isPostgres(db)) {
 		const result = await sql<{ name: string }>`
 			SELECT trigger.tgname AS name
@@ -161,6 +171,7 @@ async function listOwnedCaptureTriggers(
 				AND relation.relname = ${tableName}
 				AND NOT trigger.tgisinternal
 				AND left(trigger.tgname, 10) = ${OWNED_TRIGGER_PREFIX}
+			${limitClause}
 		`.execute(db);
 		return result.rows.map((row) => row.name);
 	}
@@ -171,6 +182,7 @@ async function listOwnedCaptureTriggers(
 		WHERE type = 'trigger'
 			AND tbl_name = ${tableName}
 			AND substr(name, 1, 10) = ${OWNED_TRIGGER_PREFIX}
+		${limitClause}
 	`.execute(db);
 	return result.rows.map((row) => row.name);
 }
@@ -307,7 +319,11 @@ async function assertExpectedTriggerSet(
 	},
 	identity: MediaUsageCaptureIdentity,
 ): Promise<void> {
-	const actual = await listOwnedCaptureTriggers(db, identifiers.tableName);
+	const actual = await listOwnedCaptureTriggers(
+		db,
+		identifiers.tableName,
+		MAX_OWNED_CAPTURE_TRIGGERS + 1,
+	);
 	if (!(await hasExactCaptureTriggers(db, identifiers, identity, actual))) {
 		throw new Error("Media usage capture trigger installation is incomplete");
 	}
diff --git a/packages/core/src/media/usage/collection-deletion-processor.ts b/packages/core/src/media/usage/collection-deletion-processor.ts
index f0adb7ce98..cbc506f436 100644
--- a/packages/core/src/media/usage/collection-deletion-processor.ts
+++ b/packages/core/src/media/usage/collection-deletion-processor.ts
@@ -12,13 +12,11 @@ import {
 
 export const MEDIA_USAGE_COLLECTION_DELETION_LIMITS = Object.freeze({
 	candidatesPerTick: 4,
-	deletionsPerTick: 1,
 	rowsPerBatch: 50,
 	leaseDurationSeconds: 5 * 60,
 	maxAttempts: 5,
 	retryBaseSeconds: 30,
 	retryMaxSeconds: 15 * 60,
-	maxQueriesPerTick: 30,
 });
 
 export interface MediaUsageCollectionDeletionTickResult {
diff --git a/packages/core/src/media/usage/content-refresh.ts b/packages/core/src/media/usage/content-refresh.ts
index 6f648c425d..7dc40a61ba 100644
--- a/packages/core/src/media/usage/content-refresh.ts
+++ b/packages/core/src/media/usage/content-refresh.ts
@@ -2,17 +2,24 @@ import { sql, type Kysely } from "kysely";
 
 import { tableExists } from "../../database/dialect-helpers.js";
 import {
+	type MediaUsageExistingSourceProjection,
 	MediaUsageRepository,
+	type MediaUsageNewSourceProjection,
 	type MediaUsageSource,
 } from "../../database/repositories/media-usage.js";
 import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
 import { isI18nEnabled } from "../../i18n/config.js";
-import { loadContentMediaUsageFields } from "./content-fields.js";
+import {
+	loadContentMediaUsageFields,
+	type ContentMediaUsageFieldDiscovery,
+} from "./content-fields.js";
 import {
 	CONTENT_SOURCE_SCHEMA_VERSION,
 	loadContentMediaUsageSnapshots,
+	loadContentMediaUsageSnapshotsBatch,
 	type ContentMediaUsageSnapshot,
+	type LoadContentMediaUsageSnapshotsResult,
 } from "./content-snapshots.js";
 import {
 	buildContentMediaUsageSourceKey,
@@ -27,8 +34,9 @@ const CONTENT_USAGE_COLLECTION_LOCKS_KEY = Symbol.for("emdash.mediaUsage.collect
 const CONTENT_USAGE_REFRESH_MAX_ATTEMPTS = 2;
 
 export const MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS = Object.freeze({
-	maxOccurrenceMutationUnitsPerClaim: 12,
-	maxProjectionMutationBytesPerClaim: 512 * 1024,
+	maxOccurrenceMutationUnitsPerClaim: 500,
+	maxProjectionMutationBytesPerVariant: 2_000_000,
+	maxProjectionMutationBytesPerClaim: 4_000_000,
 });
 
 export interface ContentMediaUsageAdmissionBudget {
@@ -66,6 +74,9 @@ interface ContentMediaUsageRefreshOptions {
 	collectionId?: string;
 	durableWork?: boolean;
 	admissionBudget?: ContentMediaUsageAdmissionBudget;
+	fieldDiscovery?: ContentMediaUsageFieldDiscovery;
+	observedSources?: ReadonlyMap<string, MediaUsageSource>;
+	snapshotsResult?: LoadContentMediaUsageSnapshotsResult;
 }
 
 export interface ContentMediaUsageRefreshResult {
@@ -107,6 +118,7 @@ export async function planContentMediaUsageProjectionAdmission(
 		.filter((source): source is MediaUsageSource => source !== undefined);
 	let deletionOccurrenceUnits = 0;
 	let deletionBytes = 0;
+	let largestDeletionBytes = 0;
 	for (const source of absentSources) {
 		const measurement = await repo.measureSourceGenerationDeletion(
 			source.sourceKey,
@@ -119,7 +131,10 @@ export async function planContentMediaUsageProjectionAdmission(
 				: { outcome: "intrinsic_resource_limit" };
 		}
 		deletionOccurrenceUnits += measurement.occurrenceCount;
-		deletionBytes += storedMediaUsageSourceByteLength(source) + measurement.occurrenceBytes * 2;
+		const sourceDeletionBytes =
+			storedMediaUsageSourceByteLength(source) + measurement.occurrenceBytes * 2;
+		deletionBytes += sourceDeletionBytes;
+		largestDeletionBytes = Math.max(largestDeletionBytes, sourceDeletionBytes);
 	}
 
 	const noOpSourceKeys = new Set<string>();
@@ -128,6 +143,7 @@ export async function planContentMediaUsageProjectionAdmission(
 		noOpSourceKeys,
 		deletionOccurrenceUnits,
 		deletionBytes,
+		largestDeletionBytes,
 	);
 	if (exceedsProjectionAdmissionLimits(cost)) {
 		for (const snapshot of snapshots) {
@@ -144,6 +160,7 @@ export async function planContentMediaUsageProjectionAdmission(
 			noOpSourceKeys,
 			deletionOccurrenceUnits,
 			deletionBytes,
+			largestDeletionBytes,
 		);
 	}
 
@@ -175,6 +192,7 @@ export async function planContentMediaUsageProjectionAdmission(
 interface ProjectionAdmissionCost {
 	occurrenceMutationUnits: number;
 	projectionMutationBytes: number;
+	largestProjectionMutationBytes: number;
 }
 
 function projectionAdmissionCost(
@@ -182,17 +200,23 @@ function projectionAdmissionCost(
 	noOpSourceKeys: ReadonlySet<string>,
 	deletionOccurrenceUnits: number,
 	deletionBytes: number,
+	largestDeletionBytes: number,
 ): ProjectionAdmissionCost {
 	return snapshots.reduce<ProjectionAdmissionCost>(
 		(cost, snapshot) => {
 			if (noOpSourceKeys.has(snapshot.source.sourceKey)) return cost;
 			cost.occurrenceMutationUnits += snapshot.occurrences.length;
 			cost.projectionMutationBytes += snapshot.projectionByteLength;
+			cost.largestProjectionMutationBytes = Math.max(
+				cost.largestProjectionMutationBytes,
+				snapshot.projectionByteLength,
+			);
 			return cost;
 		},
 		{
 			occurrenceMutationUnits: deletionOccurrenceUnits,
 			projectionMutationBytes: deletionBytes,
+			largestProjectionMutationBytes: largestDeletionBytes,
 		},
 	);
 }
@@ -201,6 +225,8 @@ function exceedsProjectionAdmissionLimits(cost: ProjectionAdmissionCost): boolea
 	return (
 		cost.occurrenceMutationUnits >
 			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxOccurrenceMutationUnitsPerClaim ||
+		cost.largestProjectionMutationBytes >
+			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerVariant ||
 		cost.projectionMutationBytes >
 			MEDIA_USAGE_PROJECTION_ADMISSION_LIMITS.maxProjectionMutationBytesPerClaim
 	);
@@ -223,22 +249,196 @@ export async function refreshContentMediaUsage(
 	);
 }
 
-export async function refreshContentMediaUsageForWork(
+export interface ContentMediaUsageWorkRefreshInput {
+	collectionId: string;
+	collectionSlug: string;
+	contentId: string;
+}
+
+export interface ContentMediaUsageWorkBatchOptions {
+	shouldContinue?: () => boolean;
+}
+
+export async function refreshContentMediaUsageForWorkBatch(
 	db: Kysely<Database>,
-	collectionId: string,
-	collectionSlug: string,
-	contentId: string,
-): Promise<ContentMediaUsageRefreshResult> {
-	validateIdentifier(collectionSlug, "collection slug");
-	if (!collectionId) throw new Error("Durable media usage work requires a collection identity");
-	return withContentUsageCollectionLock(collectionSlug, () =>
-		withContentUsageLock(collectionSlug, contentId, () =>
-			refreshContentMediaUsageUnlocked(db, collectionSlug, contentId, {
-				collectionId,
-				durableWork: true,
-			}),
-		),
-	);
+	items: readonly ContentMediaUsageWorkRefreshInput[],
+	options: ContentMediaUsageWorkBatchOptions = {},
+): Promise<Map<string, ContentMediaUsageRefreshResult>> {
+	const results = new Map<string, ContentMediaUsageRefreshResult>();
+	const collections = new Map<string, ContentMediaUsageWorkRefreshInput[]>();
+	for (const item of items) {
+		const key = `${item.collectionId}\u0000${item.collectionSlug}`;
+		const collectionItems = collections.get(key) ?? [];
+		collectionItems.push(item);
+		collections.set(key, collectionItems);
+	}
+	for (const collectionItems of collections.values()) {
+		if (options.shouldContinue && !options.shouldContinue()) break;
+		const first = collectionItems[0];
+		if (!first) continue;
+		validateIdentifier(first.collectionSlug, "collection slug");
+		if (!first.collectionId)
+			throw new Error("Durable media usage work requires a collection identity");
+		await withContentUsageCollectionLock(first.collectionSlug, async () => {
+			const fieldDiscovery = await loadContentMediaUsageFields(
+				db,
+				first.collectionSlug,
+				first.collectionId,
+			);
+			const sourceKeys = collectionItems.flatMap((item) =>
+				contentSourceKeys(item.collectionSlug, item.contentId, item.collectionId),
+			);
+			const repo = new MediaUsageRepository(db);
+			const observedSources = await repo.findSources(sourceKeys);
+			const snapshots = await loadContentMediaUsageSnapshotsBatch(
+				db,
+				first.collectionSlug,
+				collectionItems.map((item) => item.contentId),
+				fieldDiscovery,
+				{ collectionId: first.collectionId, identityVersion: 1 },
+				{ shouldContinue: options.shouldContinue },
+			);
+			const newSourceProjections: MediaUsageNewSourceProjection[] = [];
+			const newSourceKeys = new Map<string, string[]>();
+			const existingSourceProjections: MediaUsageExistingSourceProjection[] = [];
+			const unchangedSourceProjections: MediaUsageExistingSourceProjection[] = [];
+			const existingSourceKeys = new Map<
+				string,
+				{ allCount: number; changed: string[]; unchanged: string[] }
+			>();
+			for (const item of collectionItems) {
+				if (options.shouldContinue && !options.shouldContinue()) break;
+				const snapshotsResult = snapshots.get(item.contentId);
+				const itemSourceKeys = contentSourceKeys(
+					item.collectionSlug,
+					item.contentId,
+					item.collectionId,
+				);
+				if (!snapshotsResult?.success) {
+					continue;
+				}
+				const snapshotsByKey = new Map(
+					snapshotsResult.snapshots.map(
+						(snapshot) => [snapshot.source.sourceKey, snapshot] as const,
+					),
+				);
+				const existing = itemSourceKeys
+					.map((sourceKey) => observedSources.get(sourceKey))
+					.filter((source): source is MediaUsageSource => source !== undefined);
+				const allNew = existing.length === 0;
+				const allExisting =
+					existing.length === snapshotsResult.snapshots.length &&
+					existing.every((source) => snapshotsByKey.has(source.sourceKey));
+				if (!allNew && !allExisting) continue;
+				const admission = await planContentMediaUsageProjectionAdmission(
+					repo,
+					snapshotsResult.snapshots,
+					observedSources,
+					itemSourceKeys,
+					createContentMediaUsageAdmissionBudget(),
+				);
+				if (admission.outcome !== "admitted") {
+					results.set(
+						contentRefreshKey(item.collectionId, item.contentId),
+						admissionFailureResult(admission.outcome),
+					);
+					continue;
+				}
+				const key = contentRefreshKey(item.collectionId, item.contentId);
+				if (allNew) {
+					newSourceProjections.push(
+						...snapshotsResult.snapshots.map((snapshot) => ({
+							source: snapshot.source,
+							occurrences: snapshot.occurrences,
+						})),
+					);
+					newSourceKeys.set(
+						key,
+						snapshotsResult.snapshots.map((snapshot) => snapshot.source.sourceKey),
+					);
+					continue;
+				}
+				const changed: string[] = [];
+				const unchanged: string[] = [];
+				for (const snapshot of snapshotsResult.snapshots) {
+					const expectedSource = observedSources.get(snapshot.source.sourceKey);
+					if (!expectedSource) continue;
+					if (
+						expectedSource.sourceFingerprint === snapshot.source.sourceFingerprint &&
+						expectedSource.sourceCompleteness ===
+							(snapshot.source.sourceCompleteness ?? "complete") &&
+						expectedSource.lastErrorCode === null
+					) {
+						unchanged.push(snapshot.source.sourceKey);
+						unchangedSourceProjections.push({
+							source: snapshot.source,
+							occurrences: snapshot.occurrences,
+							expectedSource,
+						});
+						continue;
+					}
+					changed.push(snapshot.source.sourceKey);
+					existingSourceProjections.push({
+						source: snapshot.source,
+						occurrences: snapshot.occurrences,
+						expectedSource,
+					});
+				}
+				existingSourceKeys.set(key, {
+					allCount: snapshotsResult.snapshots.length,
+					changed,
+					unchanged,
+				});
+			}
+			const insertedSourceKeys = await repo.replaceNewSourcesBatch(newSourceProjections);
+			const replacedSourceKeys = await repo.replaceExistingSourcesBatch(existingSourceProjections);
+			const matchedSourceKeys = await repo.matchingExistingSourcesBatch(unchangedSourceProjections);
+			for (const [key, expectedSourceKeys] of newSourceKeys) {
+				results.set(
+					key,
+					expectedSourceKeys.every((sourceKey) => insertedSourceKeys.has(sourceKey))
+						? {
+								success: true,
+								refreshedSourceCount: expectedSourceKeys.length,
+								deletedSourceCount: 0,
+								failedSourceCount: 0,
+							}
+						: generationConflictResult({ refreshedSourceCount: 0, deletedSourceCount: 0 }),
+				);
+			}
+			for (const [key, expected] of existingSourceKeys) {
+				results.set(
+					key,
+					expected.changed.every((sourceKey) => replacedSourceKeys.has(sourceKey)) &&
+						expected.unchanged.every((sourceKey) => matchedSourceKeys.has(sourceKey))
+						? {
+								success: true,
+								refreshedSourceCount: expected.allCount,
+								deletedSourceCount: 0,
+								failedSourceCount: 0,
+							}
+						: generationConflictResult({ refreshedSourceCount: 0, deletedSourceCount: 0 }),
+				);
+			}
+			for (const item of collectionItems) {
+				if (options.shouldContinue && !options.shouldContinue()) break;
+				const key = contentRefreshKey(item.collectionId, item.contentId);
+				if (!snapshots.has(item.contentId)) continue;
+				if (results.has(key)) continue;
+				const result = await withContentUsageLock(item.collectionSlug, item.contentId, () =>
+					refreshContentMediaUsageUnlocked(db, item.collectionSlug, item.contentId, {
+						collectionId: item.collectionId,
+						durableWork: true,
+						fieldDiscovery,
+						observedSources,
+						snapshotsResult: snapshots.get(item.contentId),
+					}),
+				);
+				results.set(key, result);
+			}
+		});
+	}
+	return results;
 }
 
 async function refreshContentMediaUsageUnlocked(
@@ -294,19 +494,18 @@ async function refreshContentMediaUsageAttempt(
 ): Promise<ContentMediaUsageRefreshResult> {
 	const repo = new MediaUsageRepository(db);
 	const canonicalSourceKeys = contentSourceKeys(collectionSlug, contentId, options.collectionId);
-	const observedSources = await repo.findSources(canonicalSourceKeys);
-	const snapshotsResult = await loadContentMediaUsageSnapshots(
-		db,
-		collectionSlug,
-		contentId,
-		undefined,
-		options.collectionId ? { collectionId: options.collectionId, identityVersion: 1 } : undefined,
-	);
+	const observedSources = options.observedSources ?? (await repo.findSources(canonicalSourceKeys));
+	const snapshotsResult =
+		options.snapshotsResult ??
+		(await loadContentMediaUsageSnapshots(
+			db,
+			collectionSlug,
+			contentId,
+			options.fieldDiscovery,
+			options.collectionId ? { collectionId: options.collectionId, identityVersion: 1 } : undefined,
+		));
 	if (!snapshotsResult.success) {
 		if (snapshotsResult.error === "CONTENT_NOT_FOUND" && options.collectionId) {
-			if (!(await contentCollectionExists(db, collectionSlug, options.collectionId))) {
-				return generationConflictResult({ refreshedSourceCount: 0, deletedSourceCount: 0 });
-			}
 			if (!options.admissionBudget)
 				throw new Error("Durable media usage work requires an admission budget");
 			const admission = await planContentMediaUsageProjectionAdmission(
@@ -336,10 +535,7 @@ async function refreshContentMediaUsageAttempt(
 			: markSnapshotFailure(db, collectionSlug, snapshotsResult);
 	}
 
-	if (!(await contentCollectionExists(db, collectionSlug, options.collectionId))) {
-		if (options.collectionId) {
-			return generationConflictResult({ refreshedSourceCount: 0, deletedSourceCount: 0 });
-		}
+	if (!options.collectionId && !(await contentCollectionExists(db, collectionSlug))) {
 		const deletedSourceCount = await repo.deleteContentSources(collectionSlug, contentId);
 		return { ...ZERO_RESULT, deletedSourceCount };
 	}
@@ -381,10 +577,7 @@ async function refreshContentMediaUsageAttempt(
 		}
 		refreshedSourceCount++;
 	}
-	if (!(await contentCollectionExists(db, collectionSlug, options.collectionId))) {
-		if (options.collectionId) {
-			return generationConflictResult({ refreshedSourceCount, deletedSourceCount: 0 });
-		}
+	if (!options.collectionId && !(await contentCollectionExists(db, collectionSlug))) {
 		const deletedSourceCount = await repo.deleteContentSources(collectionSlug, contentId);
 		return { ...ZERO_RESULT, deletedSourceCount };
 	}
@@ -422,6 +615,10 @@ async function refreshContentMediaUsageAttempt(
 	};
 }
 
+export function contentRefreshKey(collectionId: string, contentId: string): string {
+	return `${collectionId}\u0000${contentId}`;
+}
+
 function contentSourceKeys(
 	collectionSlug: string,
 	contentId: string,
diff --git a/packages/core/src/media/usage/content-snapshots.ts b/packages/core/src/media/usage/content-snapshots.ts
index 6757a3375c..125a84a987 100644
--- a/packages/core/src/media/usage/content-snapshots.ts
+++ b/packages/core/src/media/usage/content-snapshots.ts
@@ -1,5 +1,6 @@
 import { sql, type Kysely } from "kysely";
 
+import { jsonTextValues } from "../../database/json-recordset.js";
 import type {
 	MediaUsageOccurrenceInput,
 	MediaUsageSourceInput,
@@ -63,6 +64,10 @@ export interface LoadContentMediaUsageSnapshotsOptions {
 	identityVersion?: number;
 }
 
+export interface LoadContentMediaUsageSnapshotsBatchControl {
+	shouldContinue?: () => boolean;
+}
+
 export async function loadContentMediaUsageSnapshots(
 	db: Kysely<Database>,
 	collectionSlug: string,
@@ -70,20 +75,64 @@ export async function loadContentMediaUsageSnapshots(
 	fieldDiscovery?: ContentMediaUsageFieldDiscovery,
 	options: LoadContentMediaUsageSnapshotsOptions = {},
 ): Promise<LoadContentMediaUsageSnapshotsResult> {
+	const results = await loadContentMediaUsageSnapshotsBatch(
+		db,
+		collectionSlug,
+		[contentId],
+		fieldDiscovery,
+		options,
+	);
+	return results.get(contentId) ?? { success: false, error: "CONTENT_NOT_FOUND" };
+}
+
+export async function loadContentMediaUsageSnapshotsBatch(
+	db: Kysely<Database>,
+	collectionSlug: string,
+	contentIds: readonly string[],
+	fieldDiscovery?: ContentMediaUsageFieldDiscovery,
+	options: LoadContentMediaUsageSnapshotsOptions = {},
+	control: LoadContentMediaUsageSnapshotsBatchControl = {},
+): Promise<Map<string, LoadContentMediaUsageSnapshotsResult>> {
 	validateIdentifier(collectionSlug, "collection slug");
 	if (options.identityVersion !== undefined && !options.collectionId) {
 		throw new Error("Canonical media usage snapshots require a collection identity");
 	}
 	const discovery = fieldDiscovery ?? (await loadContentMediaUsageFields(db, collectionSlug));
-	const row = await loadContentRow(
+	const rows = await loadContentRows(
 		db,
 		collectionSlug,
-		contentId,
+		contentIds,
 		[...discovery.extractionFields.map((field) => field.slug), ...discovery.displayFieldSlugs],
 		options.collectionId,
 	);
+	const revisionIds = Array.from(rows.values(), (row) =>
+		readNullableString(row.draft_revision_id),
+	).filter((revisionId): revisionId is string => revisionId !== null);
+	const revisions = await loadRevisionRows(db, revisionIds);
+	const results = new Map<string, LoadContentMediaUsageSnapshotsResult>();
+	for (const contentId of new Set(contentIds)) {
+		if (control.shouldContinue && !control.shouldContinue()) break;
+		const row = rows.get(contentId);
+		results.set(
+			contentId,
+			row
+				? await buildContentMediaUsageSnapshots(row, collectionSlug, discovery, options, revisions)
+				: { success: false, error: "CONTENT_NOT_FOUND" },
+		);
+	}
+	return results;
+}
 
-	if (!row) return { success: false, error: "CONTENT_NOT_FOUND" };
+async function buildContentMediaUsageSnapshots(
+	row: Record<string, unknown>,
+	collectionSlug: string,
+	discovery: ContentMediaUsageFieldDiscovery,
+	options: LoadContentMediaUsageSnapshotsOptions,
+	revisions: ReadonlyMap<
+		string,
+		{ success: true; revision: RevisionSnapshotRow } | { success: false }
+	>,
+): Promise<LoadContentMediaUsageSnapshotsResult> {
 	const collectionId = readString(row[CONTENT_COLLECTION_ID_RESULT]);
 	if (!collectionId) {
 		throw new Error("Media usage snapshot query did not return a collection identity");
@@ -135,7 +184,7 @@ export async function loadContentMediaUsageSnapshots(
 			sourceVariant: "draft_overlay",
 			revisionId: draftRevisionId,
 		});
-		const revisionResult = await loadRevisionRow(db, draftRevisionId);
+		const revisionResult = revisions.get(draftRevisionId);
 		if (!revisionResult) {
 			return {
 				success: false,
@@ -212,52 +261,78 @@ interface RevisionSnapshotRow {
 	data: Record<string, unknown>;
 }
 
-async function loadContentRow(
+async function loadContentRows(
 	db: Kysely<Database>,
 	collectionSlug: string,
-	contentId: string,
+	contentIds: readonly string[],
 	fieldSlugs: readonly string[],
 	expectedCollectionId?: string,
-): Promise<Record<string, unknown> | null> {
+): Promise<Map<string, Record<string, unknown>>> {
 	const tableName = getContentTableName(collectionSlug);
 	const columns = uniqueColumns([...CONTENT_SYSTEM_COLUMNS, ...fieldSlugs]);
 	const columnRefs = columns.map((column) => sql.ref(`content.${column}`));
+	const rows = new Map<string, Record<string, unknown>>();
+	const uniqueContentIds = [...new Set(contentIds)];
+	if (uniqueContentIds.length === 0) return rows;
+	const contentIdInput = jsonTextValues(db, uniqueContentIds);
 	const result = await sql<Record<string, unknown>>`
+		WITH requested AS (${contentIdInput})
 		SELECT
 			${sql.join(columnRefs, sql`, `)},
 			collection.id AS __emdash_media_usage_collection_id
 		FROM ${sql.ref(tableName)} AS content
+		INNER JOIN requested ON requested.value = content.id
 		INNER JOIN _emdash_collections AS collection
 			ON collection.slug = ${collectionSlug}
 			${expectedCollectionId ? sql`AND collection.id = ${expectedCollectionId}` : sql``}
-		WHERE content.id = ${contentId}
-		LIMIT 1
 	`.execute(db);
-
-	return result.rows[0] ?? null;
+	for (const row of result.rows) {
+		const contentId = readString(row.id);
+		if (contentId) rows.set(contentId, row);
+	}
+	return rows;
 }
 
-async function loadRevisionRow(
+async function loadRevisionRows(
 	db: Kysely<Database>,
-	revisionId: string,
-): Promise<{ success: true; revision: RevisionSnapshotRow } | { success: false } | null> {
-	const row = await db
-		.selectFrom("revisions")
-		.select(["id", "collection", "entry_id", "data"])
-		.where("id", "=", revisionId)
-		.executeTakeFirst();
-	if (!row) return null;
-	const data = parseRevisionData(row.data);
-	if (!data) return { success: false };
-	return {
-		success: true,
-		revision: {
-			id: row.id,
-			collection: row.collection,
-			entryId: row.entry_id,
-			data,
-		},
-	};
+	revisionIds: readonly string[],
+): Promise<Map<string, { success: true; revision: RevisionSnapshotRow } | { success: false }>> {
+	const revisions = new Map<
+		string,
+		{ success: true; revision: RevisionSnapshotRow } | { success: false }
+	>();
+	const uniqueRevisionIds = [...new Set(revisionIds)];
+	if (uniqueRevisionIds.length === 0) return revisions;
+	const revisionIdInput = jsonTextValues(db, uniqueRevisionIds);
+	const rows = await sql<{
+		id: string;
+		collection: string;
+		entry_id: string;
+		data: unknown;
+	}>`
+		WITH requested AS (${revisionIdInput})
+		SELECT revision.id, revision.collection, revision.entry_id, revision.data
+		FROM revisions AS revision
+		INNER JOIN requested ON requested.value = revision.id
+	`.execute(db);
+	for (const row of rows.rows) {
+		const data = parseRevisionData(row.data);
+		revisions.set(
+			row.id,
+			data
+				? {
+						success: true,
+						revision: {
+							id: row.id,
+							collection: row.collection,
+							entryId: row.entry_id,
+							data,
+						},
+					}
+				: { success: false },
+		);
+	}
+	return revisions;
 }
 
 function buildContentSource(input: {
diff --git a/packages/core/src/media/usage/maintenance-engine.ts b/packages/core/src/media/usage/maintenance-engine.ts
new file mode 100644
index 0000000000..db6011ba4e
--- /dev/null
+++ b/packages/core/src/media/usage/maintenance-engine.ts
@@ -0,0 +1,226 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../../database/types.js";
+import { getRequestContext } from "../../request-context.js";
+import {
+	continueMediaUsageActivation,
+	MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION,
+	MediaUsageActivationVersionMismatchError,
+} from "./activation.js";
+import { processDueMediaUsageCollectionDeletions } from "./collection-deletion-processor.js";
+import { processDueMediaUsageReconciliationDetailed } from "./reconciliation-processor.js";
+import { MediaUsageReconciliationRepository } from "./reconciliation.js";
+import { processDueMediaUsageWork } from "./work-processor.js";
+
+type MediaUsageMaintenanceTaskClass = "entry_work" | "collection_deletion" | "reconciliation";
+
+export type MediaUsageMaintenanceContinuation =
+	| { kind: "none" }
+	| { kind: "immediate" }
+	| { kind: "delayed"; delaySeconds: 30 };
+
+export interface MediaUsageMaintenanceStepResult {
+	state: "inactive" | "idle" | "blocked" | "progress";
+	continuation: MediaUsageMaintenanceContinuation;
+}
+
+export const MEDIA_USAGE_MAINTENANCE_LIMITS = Object.freeze({
+	eventQueryCeiling: 900,
+	maxStepQueries: 150,
+	stepStartDeadlineMs: 12 * 60_000,
+});
+
+const TASK_CLASSES: readonly MediaUsageMaintenanceTaskClass[] = [
+	"collection_deletion",
+	"entry_work",
+	"reconciliation",
+];
+
+interface MediaUsageMaintenanceSliceState {
+	activationActive: boolean;
+	idleTaskClasses: Set<MediaUsageMaintenanceTaskClass>;
+	recoveredIncrementalFinalizations: boolean;
+}
+
+export async function runMediaUsageMaintenanceStep(
+	db: Kysely<Database>,
+): Promise<MediaUsageMaintenanceStepResult> {
+	return runMediaUsageMaintenanceStepWithState(db);
+}
+
+async function runMediaUsageMaintenanceStepWithState(
+	db: Kysely<Database>,
+	sliceState?: MediaUsageMaintenanceSliceState,
+): Promise<MediaUsageMaintenanceStepResult> {
+	const activation = sliceState?.activationActive
+		? { state: "active", runtime_generation: MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION }
+		: await db
+				.selectFrom("_emdash_media_usage_activation")
+				.select(["state", "runtime_generation"])
+				.where("task_key", "=", "incremental_capture")
+				.executeTakeFirst();
+	if (
+		activation?.state !== "active" ||
+		activation.runtime_generation !== MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION
+	) {
+		return runActivationStep(db);
+	}
+	if (sliceState) sliceState.activationActive = true;
+
+	let blocked = false;
+	let blockedReconciliation = false;
+	let madeProgress = false;
+
+	for (const taskClass of TASK_CLASSES) {
+		if (sliceState?.idleTaskClasses.has(taskClass)) continue;
+		const metrics = getRequestContext()?.metrics;
+		if (metrics && !canStartMediaUsageMaintenanceStep(metrics)) {
+			return madeProgress
+				? {
+						state: "progress",
+						continuation: { kind: "immediate" },
+					}
+				: {
+						state: "blocked",
+						continuation: { kind: "immediate" },
+					};
+		}
+		const outcome = await runTaskClass(db, taskClass, sliceState);
+		if (outcome === "inactive") return inactiveResult();
+		if (sliceState) {
+			if (outcome === "idle") sliceState.idleTaskClasses.add(taskClass);
+			else sliceState.idleTaskClasses.delete(taskClass);
+			if (outcome === "progress" && taskClass === "entry_work") {
+				sliceState.idleTaskClasses.delete("reconciliation");
+			}
+			if (outcome === "progress" && taskClass === "reconciliation") {
+				sliceState.idleTaskClasses.delete("entry_work");
+			}
+		}
+		if (outcome === "progress") madeProgress = true;
+		if (outcome === "blocked") {
+			blocked = true;
+			if (taskClass === "reconciliation") blockedReconciliation = true;
+		}
+	}
+	if (madeProgress) {
+		return {
+			state: "progress",
+			continuation: { kind: "immediate" },
+		};
+	}
+
+	if (
+		blockedReconciliation &&
+		(await new MediaUsageReconciliationRepository(db).wakeDrainedBarrierCandidate())
+	) {
+		return {
+			state: "progress",
+			continuation: { kind: "immediate" },
+		};
+	}
+
+	if (blocked) {
+		return {
+			state: "blocked",
+			continuation: { kind: "delayed", delaySeconds: 30 },
+		};
+	}
+
+	return {
+		state: "idle",
+		continuation: { kind: "none" },
+	};
+}
+
+async function runActivationStep(db: Kysely<Database>): Promise<MediaUsageMaintenanceStepResult> {
+	try {
+		const result = await continueMediaUsageActivation(db);
+		if (result.outcome === "activating" || result.outcome === "active") {
+			return {
+				state: "progress",
+				continuation: { kind: "immediate" },
+			};
+		}
+		if (result.outcome === "lease_active" || result.outcome === "conflict") {
+			return {
+				state: "blocked",
+				continuation: { kind: "delayed", delaySeconds: 30 },
+			};
+		}
+		return inactiveResult();
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) return inactiveResult();
+		throw error;
+	}
+}
+
+export async function runMediaUsageMaintenanceSlice(
+	db: Kysely<Database>,
+): Promise<MediaUsageMaintenanceContinuation> {
+	const metrics = getRequestContext()?.metrics;
+	if (!metrics) return (await runMediaUsageMaintenanceStep(db)).continuation;
+
+	const sliceState: MediaUsageMaintenanceSliceState = {
+		activationActive: false,
+		idleTaskClasses: new Set(),
+		recoveredIncrementalFinalizations: false,
+	};
+	let madeProgress = false;
+	let recordedDbCount = metrics.dbCount;
+	while (canStartMediaUsageMaintenanceStep(metrics)) {
+		const result = await runMediaUsageMaintenanceStepWithState(db, sliceState);
+		if (result.continuation.kind !== "immediate") return result.continuation;
+		madeProgress = true;
+		if (metrics.dbCount === recordedDbCount) return { kind: "immediate" };
+		recordedDbCount = metrics.dbCount;
+	}
+
+	return madeProgress ? { kind: "immediate" } : { kind: "none" };
+}
+
+async function runTaskClass(
+	db: Kysely<Database>,
+	taskClass: MediaUsageMaintenanceTaskClass,
+	sliceState?: MediaUsageMaintenanceSliceState,
+): Promise<"inactive" | "idle" | "blocked" | "progress"> {
+	if (taskClass === "entry_work") {
+		const recoverIncrementalFinalizations = !sliceState?.recoveredIncrementalFinalizations;
+		const result = await processDueMediaUsageWork(db, {
+			activationKnownActive: true,
+			recoverIncrementalFinalizations,
+		});
+		if (sliceState && recoverIncrementalFinalizations) {
+			sliceState.recoveredIncrementalFinalizations = true;
+		}
+		if (result.claimedCount > 0) return "progress";
+		return result.candidateCount > 0 ? "blocked" : "idle";
+	}
+	if (taskClass === "collection_deletion") {
+		const result = await processDueMediaUsageCollectionDeletions(db);
+		if (result.claimedCount > 0) return "progress";
+		return result.candidateCount > 0 ? "blocked" : "idle";
+	}
+
+	const result = await processDueMediaUsageReconciliationDetailed(db, {
+		activationKnownActive: true,
+	});
+	if (result.outcome === "inactive") return "inactive";
+	if (result.consumedUnit) return "progress";
+	return result.outcome === "claim_lost" || result.hasDeferredCandidate ? "blocked" : "idle";
+}
+
+function inactiveResult(): MediaUsageMaintenanceStepResult {
+	return {
+		state: "inactive",
+		continuation: { kind: "none" },
+	};
+}
+
+function canStartMediaUsageMaintenanceStep(metrics: { start: number; dbCount: number }): boolean {
+	return (
+		metrics.dbCount + MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries <=
+			MEDIA_USAGE_MAINTENANCE_LIMITS.eventQueryCeiling &&
+		performance.now() - metrics.start < MEDIA_USAGE_MAINTENANCE_LIMITS.stepStartDeadlineMs
+	);
+}
diff --git a/packages/core/src/media/usage/reconciliation-processor.ts b/packages/core/src/media/usage/reconciliation-processor.ts
index 3bf944f437..0f54c5d7d1 100644
--- a/packages/core/src/media/usage/reconciliation-processor.ts
+++ b/packages/core/src/media/usage/reconciliation-processor.ts
@@ -15,13 +15,13 @@ import { CONTENT_SOURCE_SCHEMA_VERSION } from "./types.js";
 
 export const MEDIA_USAGE_RECONCILIATION_LIMITS = Object.freeze({
 	candidatesPerTick: 4,
-	pageSize: 50,
+	scanPageSize: 1_000,
+	sourcePageSize: 1_000,
 	leaseDurationSeconds: 60,
 	maxAttempts: 5,
 	retryBaseSeconds: 30,
 	retryMaxSeconds: 15 * 60,
 	retryJitterRatio: 0.25,
-	maxQueriesPerTick: 20,
 });
 
 export type MediaUsageReconciliationOutcome =
@@ -34,6 +34,16 @@ export type MediaUsageReconciliationOutcome =
 	| "retry"
 	| "failed";
 
+export interface MediaUsageReconciliationDetailedResult {
+	outcome: MediaUsageReconciliationOutcome;
+	consumedUnit: boolean;
+	hasDeferredCandidate: boolean;
+}
+
+export interface ProcessDueMediaUsageReconciliationOptions {
+	activationKnownActive?: boolean;
+}
+
 export type MediaUsageReconciliationScanOutcome =
 	| "advanced"
 	| "exhausted"
@@ -43,24 +53,39 @@ export type MediaUsageReconciliationScanOutcome =
 export async function processDueMediaUsageReconciliation(
 	db: Kysely<Database>,
 ): Promise<MediaUsageReconciliationOutcome> {
-	const activation = await db
-		.selectFrom("_emdash_media_usage_activation")
-		.select("state")
-		.where("task_key", "=", "incremental_capture")
-		.executeTakeFirst();
-	if (activation?.state !== "active") return "inactive";
+	return (await processDueMediaUsageReconciliationDetailed(db)).outcome;
+}
+
+export async function processDueMediaUsageReconciliationDetailed(
+	db: Kysely<Database>,
+	options: ProcessDueMediaUsageReconciliationOptions = {},
+): Promise<MediaUsageReconciliationDetailedResult> {
+	if (!options.activationKnownActive) {
+		const activation = await db
+			.selectFrom("_emdash_media_usage_activation")
+			.select("state")
+			.where("task_key", "=", "incremental_capture")
+			.executeTakeFirst();
+		if (activation?.state !== "active") {
+			return { outcome: "inactive", consumedUnit: false, hasDeferredCandidate: false };
+		}
+	}
 
 	const reconciliation = new MediaUsageReconciliationRepository(db);
-	if (await reconciliation.deleteOneObsolete()) return "completed";
+	if (await reconciliation.deleteOneObsolete()) {
+		return { outcome: "completed", consumedUnit: true, hasDeferredCandidate: false };
+	}
 	const [failed] = await reconciliation.findFailed(1);
 	if (failed) {
 		if (await reconciliation.finishFailedCoverage(failed.collectionId, failed.runToken)) {
-			return "failed";
+			return { outcome: "failed", consumedUnit: true, hasDeferredCandidate: false };
+		}
+		if (await reconciliation.resetFailedForNewEpoch(failed)) {
+			return { outcome: "advanced", consumedUnit: true, hasDeferredCandidate: false };
 		}
-		if (await reconciliation.resetFailedForNewEpoch(failed)) return "advanced";
 	}
 
-	await reconciliation.seedNextCandidate();
+	const seeded = await reconciliation.seedNextCandidate();
 	const candidates = await reconciliation.findDue(
 		MEDIA_USAGE_RECONCILIATION_LIMITS.candidatesPerTick,
 	);
@@ -73,10 +98,21 @@ export async function processDueMediaUsageReconciliation(
 		});
 		if (claim) break;
 	}
-	if (!claim) return candidates.length === 0 ? "not_due" : "claim_lost";
+	if (!claim) {
+		return {
+			outcome: candidates.length === 0 ? "not_due" : "claim_lost",
+			consumedUnit: seeded,
+			hasDeferredCandidate:
+				candidates.length === 0 && (await reconciliation.hasDeferredCandidate()),
+		};
+	}
 
 	try {
-		return await processClaimedReconciliation(db, claim);
+		return {
+			outcome: await processClaimedReconciliation(db, claim),
+			consumedUnit: true,
+			hasDeferredCandidate: false,
+		};
 	} catch (error) {
 		const terminal = claim.attemptCount + 1 >= MEDIA_USAGE_RECONCILIATION_LIMITS.maxAttempts;
 		const recorded = await reconciliation.recordFailure({
@@ -87,10 +123,16 @@ export async function processDueMediaUsageReconciliation(
 			retryDelaySeconds: retryDelaySeconds(claim.attemptCount),
 			terminal,
 		});
-		if (!recorded) return "claim_lost";
+		if (!recorded) {
+			return { outcome: "claim_lost", consumedUnit: true, hasDeferredCandidate: false };
+		}
 		if (terminal) await reconciliation.finishFailedCoverage(claim.collectionId, claim.runToken);
 		console.error("[media-usage:reconciliation] Processing failed:", error);
-		return terminal ? "failed" : "retry";
+		return {
+			outcome: terminal ? "failed" : "retry",
+			consumedUnit: true,
+			hasDeferredCandidate: false,
+		};
 	}
 }
 
@@ -98,9 +140,11 @@ export async function processClaimedMediaUsageReconciliationScan(
 	db: Kysely<Database>,
 	claim: MediaUsageReconciliationClaim,
 	options: { releaseOnExhausted?: boolean } = {},
+	knownCurrent?: MediaUsageReconciliationRecord,
 ): Promise<MediaUsageReconciliationScanOutcome> {
 	const reconciliation = new MediaUsageReconciliationRepository(db);
-	let current = await reconciliation.findByIdentity(claim.collectionId, claim.runToken);
+	let current =
+		knownCurrent ?? (await reconciliation.findByIdentity(claim.collectionId, claim.runToken));
 	if (!current || current.leaseToken !== claim.leaseToken || current.phase !== "scan") {
 		return "deferred";
 	}
@@ -127,8 +171,15 @@ export async function processClaimedMediaUsageReconciliationScan(
 		) {
 			return "deferred";
 		}
-		current = await reconciliation.findByIdentity(claim.collectionId, claim.runToken);
-		if (!current) return "deferred";
+		current = {
+			...current,
+			targetEpoch,
+			fieldFingerprint,
+			scanCursor: null,
+			scanUpperId,
+			sourceCursor: null,
+			sourceUpperKey: null,
+		};
 	} else {
 		fields = await loadContentMediaUsageFields(db, claim.collectionSlug, claim.collectionId);
 		fieldFingerprint = await buildContentMediaUsageFieldFingerprint(fields);
@@ -137,7 +188,10 @@ export async function processClaimedMediaUsageReconciliationScan(
 	if (current.fieldFingerprint !== fieldFingerprint || current.targetEpoch === null) {
 		return "restart_required";
 	}
-	const contentIds = await reconciliation.findScanPage(current, 50);
+	const contentIds = await reconciliation.findScanPage(
+		current,
+		MEDIA_USAGE_RECONCILIATION_LIMITS.scanPageSize,
+	);
 	if (contentIds.length === 0) {
 		if (options.releaseOnExhausted ?? true) {
 			await reconciliation.release({ ...claim, delaySeconds: 30 });
@@ -175,23 +229,39 @@ async function processClaimedReconciliation(
 	claim: MediaUsageReconciliationClaim,
 ): Promise<MediaUsageReconciliationOutcome> {
 	const reconciliation = new MediaUsageReconciliationRepository(db);
-	let current = await reconciliation.findByIdentity(claim.collectionId, claim.runToken);
-	if (!current || current.leaseToken !== claim.leaseToken) return "claim_lost";
+	let current: MediaUsageReconciliationRecord = claim;
 	if (current.targetEpoch !== null && !(await reconciliation.ownsRun(claim, current.targetEpoch))) {
 		return restartReconciliation(db, reconciliation, claim, current);
 	}
+	if (current.targetEpoch !== null) {
+		await new MediaUsageWorkRepository(db).deleteObsoleteReconciliationWork({
+			collectionId: claim.collectionId,
+			collectionSlug: claim.collectionSlug,
+			runToken: claim.runToken,
+			leaseToken: claim.leaseToken,
+			targetEpoch: current.targetEpoch,
+		});
+	}
 
 	if (current.phase === "scan") {
-		const outcome = await processClaimedMediaUsageReconciliationScan(db, claim, {
-			releaseOnExhausted: false,
-		});
+		const outcome = await processClaimedMediaUsageReconciliationScan(
+			db,
+			claim,
+			{
+				releaseOnExhausted: false,
+			},
+			current,
+		);
 		if (outcome === "restart_required") {
 			current =
 				(await reconciliation.findByIdentity(claim.collectionId, claim.runToken)) ?? current;
 			return restartReconciliation(db, reconciliation, claim, current);
 		}
 		if (outcome !== "exhausted") return outcome;
-		current = (await reconciliation.findByIdentity(claim.collectionId, claim.runToken)) ?? current;
+		if (current.targetEpoch === null || current.fieldFingerprint === null) {
+			current =
+				(await reconciliation.findByIdentity(claim.collectionId, claim.runToken)) ?? current;
+		}
 		const barrier = await reconciliation.findWorkBarrier(claim.collectionId);
 		if (barrier.state === "failed") {
 			return failReconciliation(reconciliation, claim, barrier.errorCode, true);
@@ -234,9 +304,10 @@ async function processSourcePhase(
 
 	const page = await reconciliation.findSourcePage(
 		current,
-		MEDIA_USAGE_RECONCILIATION_LIMITS.pageSize,
+		MEDIA_USAGE_RECONCILIATION_LIMITS.sourcePageSize,
 	);
 	if (page.length > 0) {
+		let enqueuedMissingContent = false;
 		const malformed = page.some(
 			(source) =>
 				!source.contentId ||
@@ -265,6 +336,7 @@ async function processSourcePhase(
 				phase: "sources",
 				contentIds: enqueueIds,
 			});
+			enqueuedMissingContent = true;
 		}
 		if (
 			!(await reconciliation.checkpointSources({
@@ -276,8 +348,13 @@ async function processSourcePhase(
 		) {
 			return "claim_lost";
 		}
-		if (!(await reconciliation.release({ ...claim, delaySeconds: 0 }))) return "claim_lost";
-		return "advanced";
+		if (
+			enqueuedMissingContent ||
+			page.length === MEDIA_USAGE_RECONCILIATION_LIMITS.sourcePageSize
+		) {
+			if (!(await reconciliation.release({ ...claim, delaySeconds: 0 }))) return "claim_lost";
+			return "advanced";
+		}
 	}
 
 	const barrier = await reconciliation.findWorkBarrier(claim.collectionId);
diff --git a/packages/core/src/media/usage/reconciliation.ts b/packages/core/src/media/usage/reconciliation.ts
index 2fc7bcddcc..c83afe7bc6 100644
--- a/packages/core/src/media/usage/reconciliation.ts
+++ b/packages/core/src/media/usage/reconciliation.ts
@@ -2,6 +2,7 @@ import { sql, type Kysely, type RawBuilder, type Selectable } from "kysely";
 import { ulid } from "ulidx";
 
 import { isPostgres } from "../../database/dialect-helpers.js";
+import { jsonTextValues } from "../../database/json-recordset.js";
 import type { Database, MediaUsageReconciliationTable } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
 
@@ -147,8 +148,8 @@ export class MediaUsageReconciliationRepository {
 		reconciliation: MediaUsageReconciliationRecord,
 		limit: number,
 	): Promise<string[]> {
-		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50) {
-			throw new Error("Reconciliation scan page limit must be from 1 to 50");
+		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1_000) {
+			throw new Error("Reconciliation scan page limit must be from 1 to 1000");
 		}
 		if (!reconciliation.leaseToken || reconciliation.targetEpoch === null) return [];
 		const tableName = contentTableName(reconciliation.collectionSlug);
@@ -366,8 +367,8 @@ export class MediaUsageReconciliationRepository {
 		reconciliation: MediaUsageReconciliationRecord,
 		limit: number,
 	): Promise<MediaUsageReconciliationSourceCandidate[]> {
-		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50) {
-			throw new Error("Reconciliation source page limit must be from 1 to 50");
+		if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1_000) {
+			throw new Error("Reconciliation source page limit must be from 1 to 1000");
 		}
 		if (!reconciliation.leaseToken || reconciliation.targetEpoch === null) return [];
 		let query = this.db
@@ -400,12 +401,16 @@ export class MediaUsageReconciliationRepository {
 	): Promise<string[]> {
 		const unique = [...new Set(contentIds)];
 		if (unique.length === 0) return [];
-		if (unique.length > 50 || unique.some((contentId) => !contentId)) {
+		if (unique.length > 1_000 || unique.some((contentId) => !contentId)) {
 			throw new Error("Reconciliation source page has invalid content identity");
 		}
 		const tableName = contentTableName(collectionSlug);
+		const requested = jsonTextValues(this.db, unique);
 		const existing = await sql<{ id: string }>`
-			SELECT id FROM ${sql.ref(tableName)} WHERE id IN (${sql.join(unique)})
+			WITH requested AS (${requested})
+			SELECT content.id
+			FROM ${sql.ref(tableName)} AS content
+			INNER JOIN requested ON requested.value = content.id
 		`.execute(this.db);
 		const present = new Set(existing.rows.map((row) => row.id));
 		return unique.filter((contentId) => !present.has(contentId));
@@ -751,6 +756,70 @@ export class MediaUsageReconciliationRepository {
 		return result.rows.map(rowToRecord);
 	}
 
+	async hasDeferredCandidate(): Promise<boolean> {
+		const row = await this.db
+			.selectFrom("_emdash_media_usage_reconciliations")
+			.select("collection_id")
+			.where("state", "in", ["pending", "retry", "leased"])
+			.limit(1)
+			.executeTakeFirst();
+		return row !== undefined;
+	}
+
+	async wakeDrainedBarrierCandidate(): Promise<boolean> {
+		const now = timestampOffset(this.db, 0);
+		const candidateIsDue = timestampIsDue(this.db, "reconciliation.next_attempt_at");
+		const targetIsDue = timestampIsDue(
+			this.db,
+			"_emdash_media_usage_reconciliations.next_attempt_at",
+		);
+		const result = await sql<{ collection_id: string }>`
+			UPDATE _emdash_media_usage_reconciliations
+			SET next_attempt_at = ${now}, updated_at = ${now}
+			WHERE collection_id = (
+				SELECT reconciliation.collection_id
+				FROM _emdash_media_usage_reconciliations AS reconciliation
+				INNER JOIN _emdash_media_usage_index_status AS status
+					ON status.collection_id = reconciliation.collection_id
+					AND status.scope_key = reconciliation.collection_slug
+				WHERE reconciliation.state = 'pending'
+					AND reconciliation.target_epoch IS NOT NULL
+					AND NOT ${candidateIsDue}
+					AND status.adapter_id = ${CONTENT_ADAPTER_ID}
+					AND status.scope_type = ${COLLECTION_SCOPE}
+					AND status.capture_state = 'active'
+					AND status.reconciliation_required = 1
+					AND status.status = 'running'
+					AND status.cursor = reconciliation.run_token
+					AND status.change_epoch = reconciliation.target_epoch
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_work AS work
+						WHERE work.collection_id = reconciliation.collection_id
+					)
+					AND NOT EXISTS (
+						SELECT 1 FROM _emdash_media_usage_collection_deletions AS deletion
+						WHERE deletion.collection_id = reconciliation.collection_id
+					)
+				ORDER BY reconciliation.next_attempt_at, reconciliation.updated_at,
+					reconciliation.collection_id
+				LIMIT 1
+			)
+			AND state = 'pending'
+			AND NOT ${targetIsDue}
+			AND EXISTS (
+				SELECT 1 FROM _emdash_media_usage_activation AS activation
+				WHERE activation.task_key = ${ACTIVATION_KEY}
+					AND activation.state = 'active'
+			)
+			AND NOT EXISTS (
+				SELECT 1 FROM _emdash_media_usage_work AS work
+				WHERE work.collection_id = _emdash_media_usage_reconciliations.collection_id
+			)
+			RETURNING collection_id
+		`.execute(this.db);
+		return result.rows.length === 1;
+	}
+
 	async findFailed(limit: number): Promise<MediaUsageReconciliationRecord[]> {
 		assertLimit(limit);
 		const rows = await this.db
diff --git a/packages/core/src/media/usage/work-processor.ts b/packages/core/src/media/usage/work-processor.ts
index 6ef62480c3..4f6ebcfed8 100644
--- a/packages/core/src/media/usage/work-processor.ts
+++ b/packages/core/src/media/usage/work-processor.ts
@@ -1,26 +1,29 @@
 import type { Kysely } from "kysely";
 
+import { isPostgres } from "../../database/dialect-helpers.js";
 import {
 	MediaUsageWorkRepository,
 	type MediaUsageWorkRecord,
 } from "../../database/repositories/media-usage-work.js";
 import { MediaUsageRepository } from "../../database/repositories/media-usage.js";
+import { withTransaction } from "../../database/transaction.js";
 import type { Database } from "../../database/types.js";
+import { getRequestContext } from "../../request-context.js";
 import {
-	refreshContentMediaUsageForWork,
+	contentRefreshKey,
+	refreshContentMediaUsageForWorkBatch,
+	type ContentMediaUsageRefreshResult,
 	type ContentMediaUsageRefreshErrorCode,
 } from "./content-refresh.js";
 
 export const MEDIA_USAGE_WORK_PROCESSING_LIMITS = Object.freeze({
-	candidatesPerTick: 4,
-	jobsPerTick: 1,
-	maxTickDurationMs: 5_000,
-	leaseDurationSeconds: 60,
+	candidatesPerTick: 1_000,
+	maxTickDurationMs: 12 * 60_000,
+	leaseDurationSeconds: 20 * 60,
 	maxAttempts: 5,
 	retryBaseSeconds: 30,
 	retryMaxSeconds: 15 * 60,
 	retryJitterRatio: 0.25,
-	ordinaryStatementsPerJob: 20,
 });
 
 export type MediaUsageWorkProcessingOutcome =
@@ -50,23 +53,60 @@ export interface MediaUsageWorkTickResult {
 	admissionClosed: boolean;
 }
 
+export interface ProcessDueMediaUsageWorkOptions {
+	activationKnownActive?: boolean;
+	recoverIncrementalFinalizations?: boolean;
+}
+
 export async function processMediaUsageWorkAfterWrite(
 	db: Kysely<Database>,
 	collectionSlug: string,
 	contentId: string,
 ): Promise<MediaUsageWorkProcessingResult> {
+	const startedAt = Date.now();
 	if (!(await isIncrementalCaptureActive(db))) {
 		return { outcome: "inactive", claimed: false };
 	}
 
+	await new MediaUsageRepository(db).recoverIncrementalFinalizations();
 	const repo = new MediaUsageWorkRepository(db);
 	const work = await repo.findWorkForContent(collectionSlug, contentId);
 	if (!work) return { outcome: "not_due", claimed: false };
-	return processCandidate(db, repo, work);
+	const claimed = await repo.claimWork({
+		collectionId: work.collectionId,
+		contentId: work.contentId,
+		workVersion: work.workVersion,
+		leaseDurationSeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.leaseDurationSeconds,
+	});
+	if (!claimed) return { outcome: "claim_lost", claimed: false };
+	try {
+		const processed = await runClaimedBatch(db, [claimed], bulkDeadlineMs(startedAt));
+		return processed.get(workResultKey(claimed)) ?? { outcome: "claim_lost", claimed: false };
+	} catch (error) {
+		const transitioned = await repo.retryClaimedWorkBatch({
+			work: [workLease(claimed)],
+			errorCode: "MEDIA_USAGE_PROCESSING_FAILED",
+			retryDelaySeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryBaseSeconds,
+			maxAttempts: MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts,
+		});
+		const outcome = transitioned.get(workIdentityKey(claimed)) ?? "superseded";
+		if (outcome === "failed") {
+			await new MediaUsageRepository(db).recordIncrementalFailure({
+				collectionId: claimed.collectionId,
+				collectionSlug: claimed.collectionSlug,
+				contentId: claimed.contentId,
+				workVersion: claimed.workVersion,
+				errorCode: "MEDIA_USAGE_PROCESSING_FAILED",
+			});
+		}
+		console.error("[media-usage:work] Immediate processing failed:", error);
+		return { outcome, claimed: true };
+	}
 }
 
 export async function processDueMediaUsageWork(
 	db: Kysely<Database>,
+	options: ProcessDueMediaUsageWorkOptions = {},
 ): Promise<MediaUsageWorkTickResult> {
 	const startedAt = Date.now();
 	const result: MediaUsageWorkTickResult = {
@@ -81,25 +121,54 @@ export async function processDueMediaUsageWork(
 		admissionClosed: false,
 	};
 
-	if (!(await isIncrementalCaptureActive(db))) {
+	if (!options.activationKnownActive && !(await isIncrementalCaptureActive(db))) {
 		result.durationMs = Date.now() - startedAt;
 		return result;
 	}
 
+	if (options.recoverIncrementalFinalizations ?? true) {
+		await new MediaUsageRepository(db).recoverIncrementalFinalizations();
+	}
 	const repo = new MediaUsageWorkRepository(db);
-	const candidates = await repo.findDueWork(MEDIA_USAGE_WORK_PROCESSING_LIMITS.candidatesPerTick);
-	result.candidateCount = candidates.length;
+	const candidates = await repo.claimDueWorkBatch({
+		limit: MEDIA_USAGE_WORK_PROCESSING_LIMITS.candidatesPerTick,
+		leaseDurationSeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.leaseDurationSeconds,
+	});
+	result.candidateCount =
+		candidates.length > 0 || !(await repo.hasNonterminalWork()) ? candidates.length : 1;
 
-	for (const candidate of candidates) {
-		if (
-			result.claimedCount >= MEDIA_USAGE_WORK_PROCESSING_LIMITS.jobsPerTick ||
-			Date.now() - startedAt >= MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxTickDurationMs
-		) {
-			result.admissionClosed = true;
-			break;
+	let processedBatch: Map<string, MediaUsageWorkProcessingResult>;
+	try {
+		processedBatch = await runClaimedBatch(db, candidates, bulkDeadlineMs(startedAt));
+	} catch (error) {
+		const transitioned = await repo.retryClaimedWorkBatch({
+			work: candidates.map(workLease),
+			errorCode: "MEDIA_USAGE_PROCESSING_FAILED",
+			retryDelaySeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryBaseSeconds,
+			maxAttempts: MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts,
+		});
+		processedBatch = new Map();
+		const usage = new MediaUsageRepository(db);
+		const failedCollectionIds = new Set<string>();
+		for (const candidate of candidates) {
+			const state = transitioned.get(workIdentityKey(candidate));
+			if (state === "failed") failedCollectionIds.add(candidate.collectionId);
+			processedBatch.set(workResultKey(candidate), {
+				outcome: state ?? "superseded",
+				claimed: true,
+			});
 		}
-
-		const processed = await processCandidate(db, repo, candidate);
+		await usage.recordIncrementalFailuresByCollection({
+			collectionIds: [...failedCollectionIds],
+			errorCode: "MEDIA_USAGE_PROCESSING_FAILED",
+		});
+		console.error("[media-usage:work] Bulk processing failed:", error);
+	}
+	for (const candidate of candidates) {
+		const processed = processedBatch.get(workResultKey(candidate)) ?? {
+			outcome: "claim_lost" as const,
+			claimed: false,
+		};
 		if (processed.claimed) result.claimedCount++;
 		if (processed.outcome === "completed") result.completedCount++;
 		if (processed.outcome === "retry") result.retryCount++;
@@ -112,92 +181,267 @@ export async function processDueMediaUsageWork(
 	return result;
 }
 
-async function processCandidate(
+async function runClaimedBatch(
+	db: Kysely<Database>,
+	candidates: readonly MediaUsageWorkRecord[],
+	deadlineMs: number,
+): Promise<Map<string, MediaUsageWorkProcessingResult>> {
+	return isPostgres(db)
+		? withTransaction(db, (trx) =>
+				processClaimedBatch(trx, new MediaUsageWorkRepository(trx), candidates, deadlineMs),
+			)
+		: processClaimedBatch(db, new MediaUsageWorkRepository(db), candidates, deadlineMs);
+}
+
+async function processClaimedBatch(
 	db: Kysely<Database>,
 	repo: MediaUsageWorkRepository,
-	candidate: MediaUsageWorkRecord,
-): Promise<MediaUsageWorkProcessingResult> {
-	const claimed = await repo.claimWork({
-		collectionId: candidate.collectionId,
-		contentId: candidate.contentId,
-		workVersion: candidate.workVersion,
-		leaseDurationSeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.leaseDurationSeconds,
-	});
-	if (!claimed?.leaseToken) return { outcome: "claim_lost", claimed: false };
+	candidates: readonly MediaUsageWorkRecord[],
+	deadlineMs: number,
+): Promise<Map<string, MediaUsageWorkProcessingResult>> {
+	const results = new Map<string, MediaUsageWorkProcessingResult>();
+	const locked = await repo.lockClaimedWorkBatch(candidates.map(workLease));
+	const owned: MediaUsageWorkRecord[] = [];
+	for (const candidate of candidates) {
+		if (locked.has(workIdentityKey(candidate))) owned.push(candidate);
+		else {
+			results.set(workResultKey(candidate), { outcome: "superseded", claimed: true });
+		}
+	}
+	const currentCollections = await findCurrentCollectionIdentities(db, owned);
+	const current: MediaUsageWorkRecord[] = [];
+	const obsolete: MediaUsageWorkRecord[] = [];
+	for (const candidate of owned) {
+		if (currentCollections.has(collectionResultKey(candidate))) current.push(candidate);
+		else obsolete.push(candidate);
+	}
 
-	const lease = {
-		collectionId: claimed.collectionId,
-		contentId: claimed.contentId,
-		workVersion: claimed.workVersion,
-		leaseToken: claimed.leaseToken,
-	};
-	if (!(await collectionIdentityIsCurrent(db, claimed.collectionId, claimed.collectionSlug))) {
-		return {
-			outcome: (await repo.completeWork(lease)) ? "obsolete" : "superseded",
+	const obsoleteCompleted = await repo.completeWorkBatch(obsolete.map(workLease));
+	for (const candidate of obsolete) {
+		results.set(workResultKey(candidate), {
+			outcome: obsoleteCompleted.has(workIdentityKey(candidate)) ? "obsolete" : "superseded",
 			claimed: true,
-		};
+		});
 	}
+	if (current.length === 0) return results;
 
-	const refresh = await refreshContentMediaUsageForWork(
-		db,
-		claimed.collectionId,
-		claimed.collectionSlug,
-		claimed.contentId,
-	);
-	if (refresh.success) {
-		const completed = await repo.completeWork(lease);
-		if (completed) {
-			await new MediaUsageRepository(db).recordIncrementalSuccess({
-				collectionId: claimed.collectionId,
-				collectionSlug: claimed.collectionSlug,
-			});
+	const refreshes = await refreshContentMediaUsageForWorkBatch(db, current, {
+		shouldContinue: () => canContinueBulkWork(deadlineMs),
+	});
+	const successful: MediaUsageWorkRecord[] = [];
+	const unstarted: MediaUsageWorkRecord[] = [];
+	const failedRefreshes: Array<{
+		candidate: MediaUsageWorkRecord;
+		refresh: ContentMediaUsageRefreshResult;
+	}> = [];
+	for (const candidate of current) {
+		const refresh = refreshes.get(contentRefreshKey(candidate.collectionId, candidate.contentId));
+		if (refresh?.success) successful.push(candidate);
+		else if (!refresh) unstarted.push(candidate);
+		else failedRefreshes.push({ candidate, refresh });
+	}
+	const terminalFailureCollections = new Map<string, Set<string>>();
+	const failureGroups = new Map<
+		string,
+		{
+			errorCode: string;
+			retryDelaySeconds: number;
+			terminal: boolean;
+			candidates: MediaUsageWorkRecord[];
 		}
-		return {
-			outcome: completed ? "completed" : "superseded",
-			claimed: true,
+	>();
+	for (const failure of failedRefreshes) {
+		const errorCode = processingErrorCode(failure.refresh.errorCode);
+		const terminal =
+			errorCode === "MEDIA_USAGE_RESOURCE_LIMIT" ||
+			failure.candidate.attemptCount + 1 >= MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts;
+		const delay = retryDelaySeconds(failure.candidate.attemptCount);
+		const key = `${errorCode}\u0000${terminal ? "terminal" : String(delay)}`;
+		const group = failureGroups.get(key) ?? {
+			errorCode,
+			retryDelaySeconds: delay,
+			terminal,
+			candidates: [],
 		};
+		group.candidates.push(failure.candidate);
+		failureGroups.set(key, group);
 	}
-
-	if (!(await collectionIdentityIsCurrent(db, claimed.collectionId, claimed.collectionSlug))) {
-		return {
-			outcome: (await repo.completeWork(lease)) ? "obsolete" : "superseded",
+	for (const group of failureGroups.values()) {
+		const transitioned = await repo.retryClaimedWorkBatch({
+			work: group.candidates.map(workLease),
+			errorCode: group.errorCode,
+			retryDelaySeconds: group.retryDelaySeconds,
+			maxAttempts: group.terminal ? 1 : MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts,
+		});
+		for (const candidate of group.candidates) {
+			const state = transitioned.get(workIdentityKey(candidate));
+			if (state === "failed") {
+				const collections = terminalFailureCollections.get(group.errorCode) ?? new Set<string>();
+				collections.add(candidate.collectionId);
+				terminalFailureCollections.set(group.errorCode, collections);
+			}
+			results.set(workResultKey(candidate), {
+				outcome: state ?? "superseded",
+				claimed: true,
+			});
+		}
+	}
+	for (const [errorCode, collectionIds] of terminalFailureCollections) {
+		await new MediaUsageRepository(db).recordIncrementalFailuresByCollection({
+			collectionIds: [...collectionIds],
+			errorCode,
+		});
+	}
+	const released = await repo.releaseClaimedWorkBatch(unstarted.map(workLease));
+	for (const candidate of unstarted) {
+		results.set(workResultKey(candidate), {
+			outcome: released.has(workIdentityKey(candidate)) ? "not_due" : "superseded",
 			claimed: true,
-		};
+		});
 	}
 
-	const errorCode = processingErrorCode(refresh.errorCode);
-	const terminal =
-		errorCode === "MEDIA_USAGE_RESOURCE_LIMIT" ||
-		claimed.attemptCount + 1 >= MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts;
-	if (terminal) {
-		const failed = await repo.failWork({ ...lease, errorCode });
-		if (failed) {
-			await new MediaUsageRepository(db).recordIncrementalFailure({
-				collectionId: claimed.collectionId,
-				collectionSlug: claimed.collectionSlug,
-				contentId: claimed.contentId,
-				workVersion: claimed.workVersion,
-				errorCode,
-			});
+	const usage = new MediaUsageRepository(db);
+	const successfulByCollection = new Map<string, MediaUsageWorkRecord[]>();
+	for (const candidate of successful) {
+		const key = collectionResultKey(candidate);
+		const collection = successfulByCollection.get(key) ?? [];
+		collection.push(candidate);
+		successfulByCollection.set(key, collection);
+	}
+	const readyToComplete: MediaUsageWorkRecord[] = [];
+	const deferredCompletion: MediaUsageWorkRecord[] = [];
+	const lostFinalization: MediaUsageWorkRecord[] = [];
+	let pendingFinalizationQueries = 2;
+	for (const collection of successfulByCollection.values()) {
+		const first = collection[0];
+		if (!first) continue;
+		const metrics = getRequestContext()?.metrics;
+		if (metrics && metrics.dbCount + pendingFinalizationQueries + 4 > 900) {
+			deferredCompletion.push(...collection);
+			continue;
+		}
+		const finalization = await usage.prepareIncrementalFinalization({
+			collectionId: first.collectionId,
+			collectionSlug: first.collectionSlug,
+		});
+		if (finalization.outcome !== "lost") {
+			readyToComplete.push(...collection);
+			pendingFinalizationQueries += 2;
+			continue;
 		}
-		return {
-			outcome: failed ? "failed" : "superseded",
+		lostFinalization.push(...collection);
+		pendingFinalizationQueries += 2;
+	}
+	const lostTransitions = await repo.retryClaimedWorkBatch({
+		work: lostFinalization.map(workLease),
+		errorCode: "MEDIA_USAGE_GENERATION_CONFLICT",
+		retryDelaySeconds: MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryBaseSeconds,
+		maxAttempts: MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts,
+	});
+	const lostFailedCollections = new Set<string>();
+	for (const candidate of lostFinalization) {
+		const state = lostTransitions.get(workIdentityKey(candidate));
+		if (state === "failed") lostFailedCollections.add(candidate.collectionId);
+		results.set(workResultKey(candidate), {
+			outcome: state ?? "superseded",
 			claimed: true,
-		};
+		});
+	}
+	await usage.recordIncrementalFailuresByCollection({
+		collectionIds: [...lostFailedCollections],
+		errorCode: "MEDIA_USAGE_GENERATION_CONFLICT",
+	});
+	const deferred = await repo.releaseClaimedWorkBatch(deferredCompletion.map(workLease));
+	for (const candidate of deferredCompletion) {
+		results.set(workResultKey(candidate), {
+			outcome: deferred.has(workIdentityKey(candidate)) ? "not_due" : "superseded",
+			claimed: true,
+		});
 	}
+	const completed = await repo.completeWorkBatch(readyToComplete.map(workLease));
+	const completedCollections = new Map<string, MediaUsageWorkRecord>();
+	for (const candidate of readyToComplete) {
+		const didComplete = completed.has(workIdentityKey(candidate));
+		results.set(workResultKey(candidate), {
+			outcome: didComplete ? "completed" : "superseded",
+			claimed: true,
+		});
+		if (didComplete) completedCollections.set(collectionResultKey(candidate), candidate);
+	}
+	for (const collection of completedCollections.values()) {
+		await usage.recordIncrementalSuccess({
+			collectionId: collection.collectionId,
+			collectionSlug: collection.collectionSlug,
+		});
+	}
+	return results;
+}
 
+async function findCurrentCollectionIdentities(
+	db: Kysely<Database>,
+	candidates: readonly MediaUsageWorkRecord[],
+): Promise<Set<string>> {
+	const identities = new Map(
+		candidates.map((candidate) => [collectionResultKey(candidate), candidate] as const),
+	);
+	const current = new Set<string>();
+	for (const batch of chunkCollectionIds(
+		Array.from(identities.values(), (item) => item.collectionId),
+	)) {
+		const rows = await db
+			.selectFrom("_emdash_collections")
+			.select(["id", "slug"])
+			.where("id", "in", batch)
+			.execute();
+		for (const row of rows) current.add(`${row.id}\u0000${row.slug}`);
+	}
+	return current;
+}
+
+function workLease(work: MediaUsageWorkRecord) {
+	if (!work.leaseToken) throw new Error("Claimed media usage work requires a lease token");
 	return {
-		outcome: (await repo.retryWork({
-			...lease,
-			errorCode,
-			retryDelaySeconds: retryDelaySeconds(claimed.attemptCount),
-		}))
-			? "retry"
-			: "superseded",
-		claimed: true,
+		collectionId: work.collectionId,
+		contentId: work.contentId,
+		workVersion: work.workVersion,
+		leaseToken: work.leaseToken,
 	};
 }
 
+function workIdentityKey(work: MediaUsageWorkRecord): string {
+	return `${work.collectionId}\u0000${work.contentId}\u0000${String(work.workVersion)}`;
+}
+
+function workResultKey(work: MediaUsageWorkRecord): string {
+	return workIdentityKey(work);
+}
+
+function collectionResultKey(work: Pick<MediaUsageWorkRecord, "collectionId" | "collectionSlug">) {
+	return `${work.collectionId}\u0000${work.collectionSlug}`;
+}
+
+function chunkCollectionIds(ids: readonly string[]): string[][] {
+	const unique = [...new Set(ids)];
+	const batches: string[][] = [];
+	for (let index = 0; index < unique.length; index += 50) {
+		batches.push(unique.slice(index, index + 50));
+	}
+	return batches;
+}
+
+function canContinueBulkWork(deadlineMs: number): boolean {
+	if (Date.now() >= deadlineMs) return false;
+	const metrics = getRequestContext()?.metrics;
+	return !metrics || metrics.dbCount + 150 <= 900;
+}
+
+function bulkDeadlineMs(startedAt: number): number {
+	const metrics = getRequestContext()?.metrics;
+	if (!metrics) return startedAt + MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxTickDurationMs;
+	const elapsedMs = Math.max(0, performance.now() - metrics.start);
+	return Date.now() + Math.max(0, MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxTickDurationMs - elapsedMs);
+}
+
 async function isIncrementalCaptureActive(db: Kysely<Database>): Promise<boolean> {
 	const row = await db
 		.selectFrom("_emdash_media_usage_activation")
@@ -207,20 +451,6 @@ async function isIncrementalCaptureActive(db: Kysely<Database>): Promise<boolean
 	return row?.state === "active";
 }
 
-async function collectionIdentityIsCurrent(
-	db: Kysely<Database>,
-	collectionId: string,
-	collectionSlug: string,
-): Promise<boolean> {
-	const row = await db
-		.selectFrom("_emdash_collections")
-		.select("id")
-		.where("id", "=", collectionId)
-		.where("slug", "=", collectionSlug)
-		.executeTakeFirst();
-	return row !== undefined;
-}
-
 function retryDelaySeconds(attemptCount: number): number {
 	const exponential = Math.min(
 		MEDIA_USAGE_WORK_PROCESSING_LIMITS.retryMaxSeconds,
diff --git a/packages/core/src/plugins/index.ts b/packages/core/src/plugins/index.ts
index fdb4816d00..07d6d2df1f 100644
--- a/packages/core/src/plugins/index.ts
+++ b/packages/core/src/plugins/index.ts
@@ -66,7 +66,11 @@ export type { PluginManagerOptions, PluginState } from "./manager.js";
 // Scheduler (Node timer-based heartbeat; consumed by the generated
 // virtual:emdash/scheduler module on non-serverless adapters)
 export { NodeCronScheduler } from "./scheduler/node.js";
-export type { CronScheduler, SystemCleanupFn } from "./scheduler/types.js";
+export type {
+	CronScheduler,
+	MediaUsageContinuationFn,
+	SystemCleanupFn,
+} from "./scheduler/types.js";
 
 // Sandbox
 export {
diff --git a/packages/core/src/plugins/scheduler/node.ts b/packages/core/src/plugins/scheduler/node.ts
index 32e63d9ded..c185e0f781 100644
--- a/packages/core/src/plugins/scheduler/node.ts
+++ b/packages/core/src/plugins/scheduler/node.ts
@@ -10,7 +10,7 @@
  */
 
 import type { CronExecutor } from "../cron.js";
-import type { CronScheduler, SystemCleanupFn } from "./types.js";
+import type { CronScheduler, MediaUsageContinuationFn, SystemCleanupFn } from "./types.js";
 
 /** Minimum polling interval (ms) — prevents tight loops if next_run_at is in the past */
 const MIN_INTERVAL_MS = 1000;
@@ -29,7 +29,11 @@ export class NodeCronScheduler implements CronScheduler {
 	private timer: ReturnType<typeof setTimeout> | null = null;
 	private running = false;
 	private systemCleanup: SystemCleanupFn | null = null;
-	private mediaUsageMaintenance: SystemCleanupFn | null = null;
+	private continuousMediaUsageMaintenance: MediaUsageContinuationFn | null = null;
+	private mediaUsageTimer: ReturnType<typeof setTimeout> | null = null;
+	private mediaUsageInFlight = false;
+	private mediaUsageWakePending = false;
+	private mediaUsageGeneration = 0;
 
 	constructor(private executor: CronExecutor) {}
 
@@ -37,8 +41,21 @@ export class NodeCronScheduler implements CronScheduler {
 		this.systemCleanup = fn;
 	}
 
-	setMediaUsageMaintenance(fn: SystemCleanupFn): void {
-		this.mediaUsageMaintenance = fn;
+	setContinuousMediaUsageMaintenance(fn: MediaUsageContinuationFn): void {
+		this.continuousMediaUsageMaintenance = fn;
+	}
+
+	wakeMediaUsageMaintenance(): void {
+		if (!this.running || !this.continuousMediaUsageMaintenance) return;
+		if (this.mediaUsageInFlight) {
+			this.mediaUsageWakePending = true;
+			return;
+		}
+		if (this.mediaUsageTimer) {
+			clearTimeout(this.mediaUsageTimer);
+			this.mediaUsageTimer = null;
+		}
+		this.armMediaUsageTimer(0);
 	}
 
 	start(): void {
@@ -52,6 +69,12 @@ export class NodeCronScheduler implements CronScheduler {
 			clearTimeout(this.timer);
 			this.timer = null;
 		}
+		if (this.mediaUsageTimer) {
+			clearTimeout(this.mediaUsageTimer);
+			this.mediaUsageTimer = null;
+		}
+		this.mediaUsageWakePending = false;
+		this.mediaUsageGeneration++;
 	}
 
 	reschedule(): void {
@@ -117,19 +140,12 @@ export class NodeCronScheduler implements CronScheduler {
 		}
 
 		void Promise.allSettled(tasks)
-			.then(async (results) => {
+			.then((results) => {
 				for (const r of results) {
 					if (r.status === "rejected") {
 						console.error("[cron:node] Tick task failed:", r.reason);
 					}
 				}
-				if (this.mediaUsageMaintenance) {
-					try {
-						await this.mediaUsageMaintenance();
-					} catch (error) {
-						console.error("[cron:node] Media Usage maintenance failed:", error);
-					}
-				}
 				return undefined;
 			})
 			.finally(() => {
@@ -138,4 +154,55 @@ export class NodeCronScheduler implements CronScheduler {
 				}
 			});
 	}
+
+	private armMediaUsageTimer(delayMs: number): void {
+		if (!this.running || !this.continuousMediaUsageMaintenance) return;
+		this.mediaUsageTimer = setTimeout(() => {
+			this.mediaUsageTimer = null;
+			void this.executeContinuousMediaUsageMaintenance();
+		}, delayMs);
+		if (
+			this.mediaUsageTimer &&
+			typeof this.mediaUsageTimer === "object" &&
+			"unref" in this.mediaUsageTimer
+		) {
+			this.mediaUsageTimer.unref();
+		}
+	}
+
+	private async executeContinuousMediaUsageMaintenance(): Promise<void> {
+		if (!this.running || !this.continuousMediaUsageMaintenance) return;
+		if (this.mediaUsageInFlight) {
+			this.mediaUsageWakePending = true;
+			return;
+		}
+
+		const generation = this.mediaUsageGeneration;
+		this.mediaUsageInFlight = true;
+		let continuation: Awaited<ReturnType<MediaUsageContinuationFn>> | null = null;
+		try {
+			continuation = await this.continuousMediaUsageMaintenance();
+		} catch (error) {
+			console.error("[cron:node] Media Usage maintenance failed:", error);
+		} finally {
+			this.mediaUsageInFlight = false;
+		}
+
+		if (!this.running || generation !== this.mediaUsageGeneration) return;
+		const wakePending = this.mediaUsageWakePending;
+		this.mediaUsageWakePending = false;
+		if (wakePending) {
+			this.armMediaUsageTimer(0);
+			return;
+		}
+		if (!continuation) return;
+		if (continuation.kind === "immediate") {
+			this.armMediaUsageTimer(0);
+			return;
+		}
+		if (continuation.kind === "delayed") {
+			this.armMediaUsageTimer(continuation.delaySeconds * 1_000);
+			return;
+		}
+	}
 }
diff --git a/packages/core/src/plugins/scheduler/types.ts b/packages/core/src/plugins/scheduler/types.ts
index f4ee58afbb..66f226fe85 100644
--- a/packages/core/src/plugins/scheduler/types.ts
+++ b/packages/core/src/plugins/scheduler/types.ts
@@ -9,6 +9,10 @@
  *
  */
 
+import type { MediaUsageMaintenanceContinuation } from "../../media/usage/maintenance-engine.js";
+
+export type MediaUsageContinuationFn = () => Promise<MediaUsageMaintenanceContinuation>;
+
 export interface CronScheduler {
 	/** Start the scheduler. */
 	start(): void | Promise<void>;
@@ -18,8 +22,10 @@ export interface CronScheduler {
 	reschedule(): void;
 	/** Register a system cleanup function to run alongside each tick. */
 	setSystemCleanup(fn: SystemCleanupFn): void;
-	/** Register bounded Media Usage maintenance to run after the general tick settles. */
-	setMediaUsageMaintenance?(fn: SystemCleanupFn): void;
+	/** Register continuation-capable Media Usage maintenance. */
+	setContinuousMediaUsageMaintenance(fn: MediaUsageContinuationFn): void;
+	/** Request Media Usage maintenance without waiting for the next heartbeat. */
+	wakeMediaUsageMaintenance(): void;
 }
 
 /**
diff --git a/packages/core/tests/integration/database/media-usage-activation.test.ts b/packages/core/tests/integration/database/media-usage-activation.test.ts
index dd6d9e6f16..f149915b94 100644
--- a/packages/core/tests/integration/database/media-usage-activation.test.ts
+++ b/packages/core/tests/integration/database/media-usage-activation.test.ts
@@ -623,6 +623,41 @@ describeEachDialect("media usage production activation", (dialect) => {
 		);
 	});
 
+	it("rejects an excessive owned trigger set before changing trigger DDL", async () => {
+		if (dialect !== "sqlite") return;
+		const registry = new SchemaRegistry(ctx.db);
+		await registry.createCollection({ slug: "trigger_limit", label: "Trigger limit" });
+		for (let index = 0; index < 150; index++) {
+			const triggerName = `emdash_mu_extra_${String(index).padStart(3, "0")}`;
+			await sql`
+				CREATE TRIGGER ${sql.ref(triggerName)}
+				AFTER INSERT ON ${sql.ref("ec_trigger_limit")}
+				BEGIN
+					SELECT 1;
+				END
+			`.execute(ctx.db);
+		}
+
+		await expect(activateMediaUsageCapture(ctx.db, { writersDrained: true })).rejects.toThrow(
+			/activation failed/i,
+		);
+
+		const triggers = await sql<{ name: string }>`
+			SELECT name FROM sqlite_master
+			WHERE type = 'trigger'
+				AND tbl_name = 'ec_trigger_limit'
+				AND substr(name, 1, 10) = 'emdash_mu_'
+		`.execute(ctx.db);
+		expect(triggers.rows).toHaveLength(150);
+		expect(await activationRow()).toEqual(
+			expect.objectContaining({
+				state: "activating",
+				lease_token: null,
+				last_error_code: "MEDIA_USAGE_ACTIVATION_FAILED",
+			}),
+		);
+	});
+
 	it("refuses a runtime generation mismatch without changing activation state", async () => {
 		await ctx.db
 			.updateTable("_emdash_media_usage_activation")
diff --git a/packages/core/tests/integration/database/media-usage-progress-plan.test.ts b/packages/core/tests/integration/database/media-usage-progress-plan.test.ts
new file mode 100644
index 0000000000..7e52de93f9
--- /dev/null
+++ b/packages/core/tests/integration/database/media-usage-progress-plan.test.ts
@@ -0,0 +1,95 @@
+import Database from "better-sqlite3";
+import { Kysely, SqliteDialect } from "kysely";
+import { afterEach, beforeEach, expect, it } from "vitest";
+
+import { runMigrations } from "../../../src/database/migrations/runner.js";
+import { MediaUsageRepository } from "../../../src/database/repositories/media-usage.js";
+import type { Database as DatabaseSchema } from "../../../src/database/types.js";
+
+interface CapturedQuery {
+	sql: string;
+	parameters: readonly unknown[];
+}
+
+let sqlite: Database.Database;
+let db: Kysely<DatabaseSchema>;
+let repo: MediaUsageRepository;
+let captured: CapturedQuery[];
+
+beforeEach(async () => {
+	captured = [];
+	sqlite = new Database(":memory:");
+	db = new Kysely<DatabaseSchema>({
+		dialect: new SqliteDialect({ database: sqlite }),
+		log(event) {
+			if (event.level === "query") {
+				captured.push({ sql: event.query.sql, parameters: event.query.parameters });
+			}
+		},
+	});
+	await runMigrations(db);
+	repo = new MediaUsageRepository(db);
+});
+
+afterEach(async () => {
+	await db.destroy();
+});
+
+it("keeps aggregate progress to one indexed metadata statement as collections grow", async () => {
+	for (let offset = 0; offset < 1_000; offset += 50) {
+		const collections = Array.from({ length: 50 }, (_, index) => {
+			const suffix = String(offset + index).padStart(4, "0");
+			return {
+				id: `collection-${suffix}`,
+				slug: `collection_${suffix}`,
+				label: `Collection ${suffix}`,
+				has_seo: 0,
+			};
+		});
+		await db.insertInto("_emdash_collections").values(collections).execute();
+		await db
+			.insertInto("_emdash_media_usage_index_status")
+			.values(
+				collections.map((collection) => ({
+					adapter_id: "content-media",
+					scope_type: "collection",
+					scope_key: collection.slug,
+					status: "complete",
+					schema_version: 1,
+					collection_id: collection.id,
+					reconciliation_required: 0,
+					capture_state: "active",
+				})),
+			)
+			.execute();
+	}
+	await db
+		.updateTable("_emdash_media_usage_activation")
+		.set({ state: "active" })
+		.where("task_key", "=", "incremental_capture")
+		.execute();
+	captured = [];
+
+	await expect(repo.findCollectionProgress()).resolves.toEqual({
+		status: "ready",
+		readyCollections: 1_000,
+		totalCollections: 1_000,
+		indexingStarted: true,
+	});
+
+	expect(captured).toHaveLength(1);
+	const query = captured[0]!;
+	expect(query.parameters.length).toBeLessThan(10);
+	expect(query.sql).not.toContain("ec_");
+	expect(query.sql).not.toContain("_emdash_media_usage_sources");
+	expect(query.sql).not.toMatch(/FROM ["`]?_emdash_media_usage["`]?\s/i);
+	const plan = sqlite
+		.prepare(`EXPLAIN QUERY PLAN ${query.sql}`)
+		.all(...query.parameters)
+		.map((row) => (row as { detail: string }).detail)
+		.join("\n");
+	expect(plan).toContain("idx__emdash_media_usage_status_collection");
+	expect(plan).toContain("idx__emdash_media_usage_work_operator");
+	expect(plan).toMatch(/SEARCH reconciliation USING INDEX .*reconciliations/);
+	expect(plan).not.toContain("USE TEMP B-TREE");
+});
diff --git a/packages/core/tests/integration/database/media-usage-projection-admission-measurement.test.ts b/packages/core/tests/integration/database/media-usage-projection-admission-measurement.test.ts
index 5b34c9724e..9413ff54f5 100644
--- a/packages/core/tests/integration/database/media-usage-projection-admission-measurement.test.ts
+++ b/packages/core/tests/integration/database/media-usage-projection-admission-measurement.test.ts
@@ -70,7 +70,7 @@ afterAll(async () => {
 	await db.destroy();
 });
 
-it("reports current projection costs at occurrence and byte boundaries", async () => {
+it("reports representative projection costs below the approved boundary", async () => {
 	const rows: MeasurementRow[] = [];
 	for (const totalOccurrences of [0, 1, 3, 4, 6, 9, 12, 15, 18, 21, 24, 27, 30]) {
 		for (const [liveOccurrences, draftOccurrences] of candidateSplits(totalOccurrences)) {
@@ -83,8 +83,7 @@ it("reports current projection costs at occurrence and byte boundaries", async (
 			const result = await measure(() =>
 				processMediaUsageWorkAfterWrite(db, fixture.collectionSlug, contentId),
 			);
-			const expectedOutcome = totalOccurrences <= 12 ? "completed" : "failed";
-			expect(result.value.outcome).toBe(expectedOutcome);
+			expect(result.value.outcome).toBe("completed");
 			rows.push({
 				path: "processor",
 				totalOccurrences,
@@ -102,8 +101,7 @@ it("reports current projection costs at occurrence and byte boundaries", async (
 		const result = await measure(() =>
 			processMediaUsageWorkAfterWrite(db, fixture.collectionSlug, contentId),
 		);
-		const expectedOutcome = payloadBytes < 512 * 1024 ? "completed" : "failed";
-		expect(result.value.outcome).toBe(expectedOutcome);
+		expect(result.value.outcome).toBe("completed");
 		rows.push({
 			path: "processor-bytes",
 			totalOccurrences: 0,
@@ -127,7 +125,7 @@ it("reports current projection costs at occurrence and byte boundaries", async (
 		expect(created.value.success).toBe(true);
 		if (!created.value.success) throw new Error(created.value.error.message);
 		const createOutcome = await workOutcome(created.value.data.item.id);
-		expect(createOutcome).toBe(totalOccurrences <= 12 ? "completed" : "failed");
+		expect(createOutcome).toBe("completed");
 		rows.push({
 			path: "runtime-create",
 			totalOccurrences,
@@ -154,9 +152,7 @@ it("reports current projection costs at occurrence and byte boundaries", async (
 			);
 			expect(updated.value.success).toBe(true);
 			const updateOutcome = await workOutcome(initial.data.item.id);
-			expect(updateOutcome).toBe(
-				liveOccurrences <= 12 && draftOccurrences <= 12 ? "completed" : "failed",
-			);
+			expect(updateOutcome).toBe("completed");
 			rows.push({
 				path: "runtime-update",
 				totalOccurrences,
diff --git a/packages/core/tests/integration/database/media-usage-projection-admission-runtime.test.ts b/packages/core/tests/integration/database/media-usage-projection-admission-runtime.test.ts
index e26fa81e6d..096e5da165 100644
--- a/packages/core/tests/integration/database/media-usage-projection-admission-runtime.test.ts
+++ b/packages/core/tests/integration/database/media-usage-projection-admission-runtime.test.ts
@@ -12,6 +12,7 @@ import { afterEach, beforeEach, expect, it } from "vitest";
 import { MediaUsageRepository } from "../../../src/database/repositories/media-usage.js";
 import { refreshContentMediaUsage } from "../../../src/media/usage/content-refresh.js";
 import { loadContentMediaUsageSnapshots } from "../../../src/media/usage/content-snapshots.js";
+import { MEDIA_USAGE_MAINTENANCE_LIMITS } from "../../../src/media/usage/maintenance-engine.js";
 import { buildContentMediaUsageSourceKey } from "../../../src/media/usage/source-key.js";
 import { processMediaUsageWorkAfterWrite } from "../../../src/media/usage/work-processor.js";
 import {
@@ -43,12 +44,12 @@ describeEachDialect("media usage projection admission runtime", (dialect) => {
 	});
 
 	it("terminally rejects an oversized replacement before publishing either variant", async () => {
-		await insertEntry("oversized-variants", 6);
+		await insertEntry("oversized-variants", 250);
 		await addMediaUsageMeasurementDraft(
 			ctx.db,
 			fixture,
 			"oversized-variants",
-			mediaUsageMeasurementData(7, "oversized-draft"),
+			mediaUsageMeasurementData(251, "oversized-draft"),
 		);
 
 		const result = await processMediaUsageWorkAfterWrite(
@@ -76,13 +77,13 @@ describeEachDialect("media usage projection admission runtime", (dialect) => {
 	});
 
 	it("admits the occurrence boundary and keeps an oversized exact projection as a no-op", async () => {
-		await insertEntry("boundary", 12);
+		await insertEntry("boundary", 500);
 		expect(
 			(await processMediaUsageWorkAfterWrite(ctx.db, fixture.collectionSlug, "boundary")).outcome,
 		).toBe("completed");
-		expect(await currentOccurrenceCount("boundary", "columns")).toBe(12);
+		expect(await currentOccurrenceCount("boundary", "columns")).toBe(500);
 
-		await insertEntry("oversized-no-op", 13);
+		await insertEntry("oversized-no-op", 501);
 		const snapshots = await loadSnapshots("oversized-no-op");
 		const snapshot = snapshots.find((candidate) => candidate.source.sourceVariant === "columns");
 		if (!snapshot) throw new Error("Missing columns snapshot");
@@ -98,7 +99,7 @@ describeEachDialect("media usage projection admission runtime", (dialect) => {
 		expect((await repo.findSource(snapshot.source.sourceKey))?.currentGeneration).toBe(
 			stored.currentGeneration,
 		);
-		expect(await currentOccurrenceCount("oversized-no-op", "columns")).toBe(13);
+		expect(await currentOccurrenceCount("oversized-no-op", "columns")).toBe(501);
 	});
 
 	it("rejects oversized source bytes without mutation", async () => {
@@ -107,7 +108,7 @@ describeEachDialect("media usage projection admission runtime", (dialect) => {
 			fixture,
 			"oversized-bytes",
 			mediaUsageMeasurementData(0, "oversized-bytes"),
-			"é".repeat(300_000),
+			"é".repeat(1_050_000),
 		);
 		expect(
 			(await processMediaUsageWorkAfterWrite(ctx.db, fixture.collectionSlug, "oversized-bytes"))
@@ -117,7 +118,7 @@ describeEachDialect("media usage projection admission runtime", (dialect) => {
 	});
 
 	it("rejects oversized absent-source cleanup without mutation", async () => {
-		await insertEntry("oversized-delete", 13);
+		await insertEntry("oversized-delete", 501);
 		const snapshots = await loadSnapshots("oversized-delete");
 		const snapshot = snapshots.find((candidate) => candidate.source.sourceVariant === "columns");
 		if (!snapshot) throw new Error("Missing columns snapshot");
@@ -137,7 +138,7 @@ describeEachDialect("media usage projection admission runtime", (dialect) => {
 		expect((await repo.findSource(snapshot.source.sourceKey))?.currentGeneration).toBe(
 			stored.currentGeneration,
 		);
-		expect(await currentOccurrenceCount("oversized-delete", "columns")).toBe(13);
+		expect(await currentOccurrenceCount("oversized-delete", "columns")).toBe(501);
 	});
 
 	it("leaves synchronous backwards-compatible refresh outside admission", async () => {
@@ -154,7 +155,7 @@ describeEachDialect("media usage projection admission runtime", (dialect) => {
 		expect(Number(count.count)).toBe(13);
 	});
 
-	it("defers immediately after a reserved conflict inside the 40-query envelope", async () => {
+	it("defers immediately after a reserved conflict inside the shared step reservation", async () => {
 		await insertEntry("conflict", 0);
 		await addMediaUsageMeasurementDraft(
 			ctx.db,
@@ -186,7 +187,7 @@ describeEachDialect("media usage projection admission runtime", (dialect) => {
 				"conflict",
 			);
 			expect(result.outcome).toBe("retry");
-			expect(counter.count).toBeLessThanOrEqual(40);
+			expect(counter.count).toBeLessThanOrEqual(MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries);
 			expect(
 				(await occurrenceCountForSource(sourceKey("conflict", "draft_overlay"))) - draftRowsBefore,
 			).toBe(12);
diff --git a/packages/core/tests/integration/database/media-usage-projection-admission.test.ts b/packages/core/tests/integration/database/media-usage-projection-admission.test.ts
index e98b744ff0..8fd57ca08b 100644
--- a/packages/core/tests/integration/database/media-usage-projection-admission.test.ts
+++ b/packages/core/tests/integration/database/media-usage-projection-admission.test.ts
@@ -54,24 +54,34 @@ describeEachDialect("content media usage projection admission", (dialect) => {
 		await teardownForDialect(ctx);
 	});
 
-	it("admits a whole entry only when the combined variant plan fits", async () => {
+	it("admits 500 occurrences across both variants and rejects the next occurrence", async () => {
 		const withinBudget = await plan([
-			await snapshot("combined-12", "columns", 6),
-			await snapshot("combined-12", "draft_overlay", 6),
+			await snapshot("combined-500", "columns", 250),
+			await snapshot("combined-500", "draft_overlay", 250),
 		]);
 		const overBudget = await plan([
-			await snapshot("combined-13", "columns", 6),
-			await snapshot("combined-13", "draft_overlay", 7),
+			await snapshot("combined-501", "columns", 250),
+			await snapshot("combined-501", "draft_overlay", 251),
 		]);
 
 		expect(withinBudget.outcome).toBe("admitted");
 		expect(overBudget.outcome).toBe("intrinsic_resource_limit");
 	});
 
+	it("rejects one oversized variant before the whole claim can be admitted", async () => {
+		const atBoundary = await snapshot("bytes-at-boundary", "columns", 0);
+		atBoundary.projectionByteLength = 2_000_000;
+		const aboveBoundary = await snapshot("bytes-above-boundary", "columns", 0);
+		aboveBoundary.projectionByteLength = 2_000_001;
+
+		expect((await plan([atBoundary])).outcome).toBe("admitted");
+		expect((await plan([aboveBoundary])).outcome).toBe("intrinsic_resource_limit");
+	});
+
 	it("recomputes an oversized mixed plan after proving its replacement is unchanged", async () => {
 		const contentId = "mixed-no-op-delete";
 		await insertContentIdentity(ctx, contentId, true);
-		const unchangedColumns = await snapshot(contentId, "columns", 0, "é".repeat(270_000));
+		const unchangedColumns = await snapshot(contentId, "columns", 0, "é".repeat(1_050_000));
 		const absentDraft = await snapshot(contentId, "draft_overlay", 1, "Small draft");
 		await repo.replaceSource(unchangedColumns.source, unchangedColumns.occurrences);
 		await repo.replaceSource(absentDraft.source, absentDraft.occurrences);
@@ -101,7 +111,7 @@ describeEachDialect("content media usage projection admission", (dialect) => {
 	it("rejects deletion when the stored source row alone exceeds the byte limit", async () => {
 		const contentId = "oversized-source-delete";
 		await insertContentIdentity(ctx, contentId, true);
-		const absentDraft = await snapshot(contentId, "draft_overlay", 0, "é".repeat(300_000));
+		const absentDraft = await snapshot(contentId, "draft_overlay", 0, "é".repeat(1_050_000));
 		await repo.replaceSource(absentDraft.source, []);
 		const observedSources = await repo.findSources(canonicalSourceKeys(contentId));
 		const budget = createContentMediaUsageAdmissionBudget();
@@ -127,7 +137,7 @@ describeEachDialect("content media usage projection admission", (dialect) => {
 			canonicalSourceKeys("reserved-small"),
 			budget,
 		);
-		const oversized = [await snapshot("reserved-large", "columns", 13)];
+		const oversized = [await snapshot("reserved-large", "columns", 501)];
 		const deferred = await planContentMediaUsageProjectionAdmission(
 			repo,
 			oversized,
@@ -145,7 +155,7 @@ describeEachDialect("content media usage projection admission", (dialect) => {
 
 		expect(first.outcome).toBe("admitted");
 		expect(budget.hasReservedMutation).toBe(true);
-		expect(budget.remainingOccurrenceMutationUnits).toBe(11);
+		expect(budget.remainingOccurrenceMutationUnits).toBe(499);
 		expect(deferred.outcome).toBe("claim_budget_deferred");
 		expect(freshClaim.outcome).toBe("intrinsic_resource_limit");
 	});
diff --git a/packages/core/tests/integration/database/media-usage-read-repository.test.ts b/packages/core/tests/integration/database/media-usage-read-repository.test.ts
index 51503d836b..30f402237c 100644
--- a/packages/core/tests/integration/database/media-usage-read-repository.test.ts
+++ b/packages/core/tests/integration/database/media-usage-read-repository.test.ts
@@ -357,6 +357,186 @@ describeEachDialect("MediaUsageRepository reads", (dialect) => {
 		]);
 	});
 
+	it("summarizes current collection indexing progress and terminal work", async () => {
+		await registerCollection(ctx, "pages");
+		await registerCollection(ctx, "posts");
+		await insertCollectionStatus(ctx, "pages", "complete", 0);
+		await insertCollectionStatus(ctx, "posts", "stale", 1);
+
+		const progress = () => repo.findCollectionProgress();
+		await expect(progress()).resolves.toBeNull();
+		await ctx.db
+			.updateTable("_emdash_media_usage_activation")
+			.set({ state: "active" })
+			.where("task_key", "=", "incremental_capture")
+			.execute();
+
+		await expect(progress()).resolves.toEqual({
+			status: "indexing",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+		await ctx.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ status: "running", cursor: "finalizing-run", change_epoch: 1 })
+			.where("collection_id", "=", "collection-posts")
+			.execute();
+		await ctx.db
+			.insertInto("_emdash_media_usage_reconciliations")
+			.values({
+				collection_id: "collection-posts",
+				collection_slug: "posts",
+				run_token: "finalizing-run",
+				target_epoch: 1,
+				state: "pending",
+				phase: "sources",
+				next_attempt_at: "2026-08-16T00:00:00.000Z",
+			})
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "indexing",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+			finalizing: true,
+		});
+		await ctx.db
+			.updateTable("_emdash_media_usage_reconciliations")
+			.set({ state: "retry" })
+			.where("collection_id", "=", "collection-posts")
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "indexing",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+		await ctx.db
+			.updateTable("_emdash_media_usage_reconciliations")
+			.set({ state: "pending" })
+			.where("collection_id", "=", "collection-posts")
+			.execute();
+
+		await ctx.db
+			.insertInto("_emdash_media_usage_work")
+			.values({
+				collection_id: "collection-posts",
+				collection_slug: "posts",
+				content_id: "remaining-entry",
+				change_epoch: 1,
+				state: "pending",
+				next_attempt_at: "2026-08-16T00:00:00.000Z",
+			})
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "indexing",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+		await ctx.db
+			.updateTable("_emdash_media_usage_work")
+			.set({ state: "failed", last_error_code: "MEDIA_USAGE_PROCESSING_FAILED" })
+			.where("collection_id", "=", "collection-posts")
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "needs_attention",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+
+		await ctx.db.deleteFrom("_emdash_media_usage_work").execute();
+		await ctx.db.deleteFrom("_emdash_media_usage_reconciliations").execute();
+		await ctx.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ status: "complete", reconciliation_required: 0 })
+			.where("collection_id", "=", "collection-posts")
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "ready",
+			readyCollections: 2,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+
+		await ctx.db
+			.insertInto("_emdash_media_usage_reconciliations")
+			.values({
+				collection_id: "collection-posts",
+				collection_slug: "posts",
+				run_token: "obsolete-failed-run",
+				state: "failed",
+				next_attempt_at: "2026-08-16T00:00:00.000Z",
+				last_error_code: "MEDIA_USAGE_RECONCILIATION_FAILED",
+			})
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "ready",
+			readyCollections: 2,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+
+		await ctx.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ capture_state: null })
+			.where("collection_id", "=", "collection-pages")
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "needs_attention",
+			readyCollections: 1,
+			totalCollections: 2,
+			indexingStarted: true,
+		});
+
+		await ctx.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ capture_state: "active" })
+			.where("collection_id", "=", "collection-pages")
+			.execute();
+		await ctx.db
+			.insertInto("_emdash_media_usage_collection_deletions")
+			.values({
+				collection_id: "collection-posts",
+				collection_slug: "posts",
+				force_delete: 0,
+				state: "pending",
+				next_attempt_at: "2026-08-16T00:00:00.000Z",
+			})
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "ready",
+			readyCollections: 1,
+			totalCollections: 1,
+			indexingStarted: true,
+		});
+		await ctx.db
+			.updateTable("_emdash_media_usage_collection_deletions")
+			.set({ state: "failed" })
+			.where("collection_id", "=", "collection-posts")
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "needs_attention",
+			readyCollections: 1,
+			totalCollections: 1,
+			indexingStarted: true,
+		});
+
+		await ctx.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ schema_version: 0 })
+			.where("collection_id", "=", "collection-pages")
+			.execute();
+		await expect(progress()).resolves.toEqual({
+			status: "needs_attention",
+			readyCollections: 0,
+			totalCollections: 1,
+			indexingStarted: false,
+		});
+	});
+
 	it("paginates complete entry groups with nested sources and occurrences", async () => {
 		await registerCollection(ctx, "pages");
 		await registerCollection(ctx, "posts");
@@ -499,6 +679,27 @@ async function registerCollection(ctx: DialectTestContext, slug: string): Promis
 		.execute();
 }
 
+async function insertCollectionStatus(
+	ctx: DialectTestContext,
+	slug: string,
+	status: string,
+	reconciliationRequired: number,
+): Promise<void> {
+	await ctx.db
+		.insertInto("_emdash_media_usage_index_status")
+		.values({
+			adapter_id: "content-media",
+			scope_type: "collection",
+			scope_key: slug,
+			status,
+			schema_version: 1,
+			collection_id: `collection-${slug}`,
+			reconciliation_required: reconciliationRequired,
+			capture_state: "active",
+		})
+		.execute();
+}
+
 async function installCanonicalContentFixture(
 	ctx: DialectTestContext,
 	collectionSlug: string,
diff --git a/packages/core/tests/integration/database/media-usage-reconciliation-finalization.test.ts b/packages/core/tests/integration/database/media-usage-reconciliation-finalization.test.ts
index c3ae649d77..31e6452b6d 100644
--- a/packages/core/tests/integration/database/media-usage-reconciliation-finalization.test.ts
+++ b/packages/core/tests/integration/database/media-usage-reconciliation-finalization.test.ts
@@ -4,7 +4,10 @@ import { afterEach, beforeEach, expect, it } from "vitest";
 import { MediaUsageRepository } from "../../../src/database/repositories/media-usage.js";
 import { processDueMediaUsageCollectionDeletions } from "../../../src/media/usage/collection-deletion-processor.js";
 import { loadContentMediaUsageSnapshots } from "../../../src/media/usage/content-snapshots.js";
-import { processDueMediaUsageReconciliation } from "../../../src/media/usage/reconciliation-processor.js";
+import {
+	processDueMediaUsageReconciliation,
+	processDueMediaUsageReconciliationDetailed,
+} from "../../../src/media/usage/reconciliation-processor.js";
 import { MediaUsageReconciliationRepository } from "../../../src/media/usage/reconciliation.js";
 import { buildContentMediaUsageSourceKey } from "../../../src/media/usage/source-key.js";
 import { processDueMediaUsageWork } from "../../../src/media/usage/work-processor.js";
@@ -103,6 +106,52 @@ describeEachDialect("media usage reconciliation finalization", (dialect) => {
 		expect(await usage.findSource(quarantinedSourceKey)).not.toBeNull();
 	});
 
+	it("reports a seeded or claimed reconciliation unit as consumed", async () => {
+		const collection = await createCollection(ctx, "consumed_reconciliation", true);
+		await activateCollection(ctx, collection);
+
+		await expect(processDueMediaUsageReconciliationDetailed(ctx.db)).resolves.toMatchObject({
+			consumedUnit: true,
+			outcome: "advanced",
+		});
+	});
+
+	it("sweeps a full bulk batch of current sources in one reconciliation unit", async () => {
+		const collection = await createCollection(ctx, "bulk_sources", true);
+		for (let offset = 0; offset < 500; offset += 100) {
+			await ctx.db
+				.insertInto("ec_bulk_sources")
+				.values(
+					Array.from({ length: 100 }, (_, index) => {
+						const id = `entry-${String(offset + index).padStart(3, "0")}`;
+						return { id, slug: id };
+					}),
+				)
+				.execute();
+		}
+		await activateCollection(ctx, collection);
+
+		await expect(processDueMediaUsageReconciliation(ctx.db)).resolves.toBe("advanced");
+		await expect(processDueMediaUsageWork(ctx.db)).resolves.toMatchObject({ completedCount: 500 });
+		await expect(processDueMediaUsageReconciliation(ctx.db)).resolves.toBe("advanced");
+		await expect(processDueMediaUsageReconciliation(ctx.db)).resolves.toBe("completed");
+
+		expect(
+			await ctx.db
+				.selectFrom("_emdash_media_usage_reconciliations")
+				.select("collection_id")
+				.where("collection_id", "=", collection.id)
+				.executeTakeFirst(),
+		).toBeUndefined();
+		expect(
+			await ctx.db
+				.selectFrom("_emdash_media_usage_index_status")
+				.select(["status", "reconciliation_required"])
+				.where("collection_id", "=", collection.id)
+				.executeTakeFirstOrThrow(),
+		).toEqual({ status: "complete", reconciliation_required: 0 });
+	});
+
 	it("preserves automatic ownership until failed work reaches terminal coverage", async () => {
 		const collection = await createCollection(ctx, "articles", true);
 		await sql`
diff --git a/packages/core/tests/integration/database/media-usage-reconciliation-scan.test.ts b/packages/core/tests/integration/database/media-usage-reconciliation-scan.test.ts
index f5b98de0cf..9499304000 100644
--- a/packages/core/tests/integration/database/media-usage-reconciliation-scan.test.ts
+++ b/packages/core/tests/integration/database/media-usage-reconciliation-scan.test.ts
@@ -58,7 +58,7 @@ describeEachDialect("media usage reconciliation scan", (dialect) => {
 		expect(Number(coordinator.target_epoch)).toBe(1);
 		expect(coordinator).toMatchObject({
 			scan_upper_id: "entry-050",
-			scan_cursor: "entry-049",
+			scan_cursor: "entry-050",
 		});
 		expect(coordinator.field_fingerprint).toMatch(/^media-usage-fields:v1:sha256:[a-f0-9]{64}$/);
 		const workCount = await ctx.db
@@ -66,7 +66,7 @@ describeEachDialect("media usage reconciliation scan", (dialect) => {
 			.select((eb) => eb.fn.countAll<number>().as("count"))
 			.where("collection_id", "=", collection.id)
 			.executeTakeFirstOrThrow();
-		expect(Number(workCount.count)).toBe(50);
+		expect(Number(workCount.count)).toBe(51);
 		expect(await workState(ctx, collection.id, "entry-001")).toMatchObject({
 			change_epoch: 1,
 			work_version: 2,
@@ -89,7 +89,7 @@ describeEachDialect("media usage reconciliation scan", (dialect) => {
 		await expect(claimAndScan(ctx)).resolves.toBe("advanced");
 		expect(await workVersions(ctx, collection.id)).toEqual(versionsBeforeReplay);
 
-		await expect(claimAndScan(ctx)).resolves.toBe("advanced");
+		await expect(claimAndScan(ctx)).resolves.toBe("exhausted");
 		expect(
 			await ctx.db
 				.selectFrom("_emdash_media_usage_reconciliations")
@@ -97,7 +97,6 @@ describeEachDialect("media usage reconciliation scan", (dialect) => {
 				.where("collection_id", "=", collection.id)
 				.executeTakeFirstOrThrow(),
 		).toEqual({ scan_cursor: "entry-050" });
-		expect(await claimAndScan(ctx)).toBe("exhausted");
 	});
 
 	it("invalidates stale canonical publication after deletion or a newer version", async () => {
diff --git a/packages/core/tests/integration/database/media-usage-work-processor.test.ts b/packages/core/tests/integration/database/media-usage-work-processor.test.ts
index c0e4bfa314..06dc8117d8 100644
--- a/packages/core/tests/integration/database/media-usage-work-processor.test.ts
+++ b/packages/core/tests/integration/database/media-usage-work-processor.test.ts
@@ -8,11 +8,13 @@ import type {
 	UnknownRow,
 } from "kysely";
 import { sql } from "kysely";
-import { afterEach, beforeEach, expect, it } from "vitest";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
 
+import { MediaUsageWorkRepository } from "../../../src/database/repositories/media-usage-work.js";
 import { MediaUsageRepository } from "../../../src/database/repositories/media-usage.js";
 import type { Database } from "../../../src/database/types.js";
 import { installMediaUsageCaptureTriggers } from "../../../src/media/usage/capture-triggers.js";
+import { MEDIA_USAGE_MAINTENANCE_LIMITS } from "../../../src/media/usage/maintenance-engine.js";
 import {
 	MEDIA_USAGE_WORK_PROCESSING_LIMITS,
 	processDueMediaUsageWork,
@@ -131,7 +133,7 @@ describeEachDialect("media usage durable work processing", (dialect) => {
 		);
 	});
 
-	it("bounds each scheduled tick and leaves the backlog durable", async () => {
+	it("processes all available work in one bulk batch", async () => {
 		const fixture = await createActiveFixture(ctx, "articles");
 		for (let index = 0; index < 3; index++) {
 			await insertEntry(ctx, fixture, `entry-${index}`, `media-${index}`);
@@ -140,18 +142,203 @@ describeEachDialect("media usage durable work processing", (dialect) => {
 		const result = await processDueMediaUsageWork(ctx.db);
 
 		expect(result.candidateCount).toBe(3);
-		expect(result.claimedCount).toBe(MEDIA_USAGE_WORK_PROCESSING_LIMITS.jobsPerTick);
-		expect(result.completedCount).toBe(MEDIA_USAGE_WORK_PROCESSING_LIMITS.jobsPerTick);
-		expect(await countWork(ctx.db)).toBe(3 - MEDIA_USAGE_WORK_PROCESSING_LIMITS.jobsPerTick);
+		expect(result.claimedCount).toBe(3);
+		expect(result.completedCount).toBe(3);
+		expect(await countWork(ctx.db)).toBe(0);
 		expect(await findCoverageStatus(ctx.db, fixture.collectionId)).toEqual(
-			expect.objectContaining({ status: "stale" }),
+			expect.objectContaining({ status: "complete" }),
 		);
+	});
 
+	it("does not repeat the full projection query sequence per entry", async () => {
+		const fixture = await createActiveFixture(ctx, "bulk_articles");
+		for (let index = 0; index < 10; index++) {
+			await insertEntry(ctx, fixture, `entry-${index}`, `media-${index}`);
+		}
+		const counter = new QueryCountingPlugin();
+
+		const result = await processDueMediaUsageWork(ctx.db.withPlugin(counter));
+
+		expect(result.completedCount).toBe(10);
+		expect(counter.count).toBeLessThan(50);
+		expect(await countWork(ctx.db)).toBe(0);
+	});
+
+	it("processes at most one thousand entries per bulk batch", async () => {
+		const fixture = await createActiveFixture(ctx, "large_batch");
+		for (let index = 0; index < 1_001; index++) {
+			await insertEntry(
+				ctx,
+				fixture,
+				`entry-${String(index).padStart(4, "0")}`,
+				`media-${index}`,
+				7,
+			);
+		}
+		const counter = new QueryCountingPlugin();
+
+		const result = await processDueMediaUsageWork(ctx.db.withPlugin(counter));
+
+		expect(result.claimedCount).toBe(1_000);
+		expect(result.completedCount).toBe(1_000);
+		expect(counter.count).toBeLessThan(50);
+		expect(await countWork(ctx.db)).toBe(1);
+	});
+
+	it("updates existing projections without one query sequence per entry", async () => {
+		const fixture = await createActiveFixture(ctx, "existing_batch");
+		for (let index = 0; index < 100; index++) {
+			await insertEntry(ctx, fixture, `entry-${String(index).padStart(3, "0")}`, `media-${index}`);
+		}
 		await processDueMediaUsageWork(ctx.db);
-		await processDueMediaUsageWork(ctx.db);
+		await sql`
+			UPDATE ${sql.ref(fixture.tableName)}
+			SET hero = ${JSON.stringify({ id: "updated-media", provider: "local", mimeType: "image/webp" })},
+				version = version + 1,
+				updated_at = '2026-08-20T00:00:00.000Z'
+		`.execute(ctx.db);
+		const counter = new QueryCountingPlugin();
+
+		const result = await processDueMediaUsageWork(ctx.db.withPlugin(counter));
+
+		expect(result.completedCount).toBe(100);
+		expect(counter.count).toBeLessThan(50);
 		expect(await countWork(ctx.db)).toBe(0);
+	});
+
+	it("lets only one overlapping bulk processor own each work row", async () => {
+		const fixture = await createActiveFixture(ctx, "overlapping_bulk");
+		for (let index = 0; index < 4; index++) {
+			await insertEntry(ctx, fixture, `entry-${index}`, `media-${index}`);
+		}
+
+		const results = await Promise.all([
+			processDueMediaUsageWork(ctx.db),
+			processDueMediaUsageWork(ctx.db),
+		]);
+
+		expect(results.reduce((total, result) => total + result.completedCount, 0)).toBe(4);
+		expect(await countWork(ctx.db)).toBe(0);
+	});
+
+	it("releases a claimed batch when its processing deadline is exhausted", async () => {
+		const fixture = await createActiveFixture(ctx, "deadline_release");
+		await insertEntry(ctx, fixture, "entry-1", "media-1");
+		const now = vi
+			.spyOn(Date, "now")
+			.mockReturnValueOnce(0)
+			.mockReturnValue(MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxTickDurationMs + 1);
+
+		const result = await processDueMediaUsageWork(ctx.db);
+		now.mockRestore();
+
+		expect(result.completedCount).toBe(0);
+		expect(await findWork(ctx.db)).toEqual(
+			expect.objectContaining({ state: "pending", attempt_count: 0, lease_token: null }),
+		);
+	});
+
+	it("retries every incomplete row after a bulk publication failure", async () => {
+		const fixture = await createActiveFixture(ctx, "bulk_failure");
+		await insertEntry(ctx, fixture, "entry-1", "media-1");
+		await insertEntry(ctx, fixture, "entry-2", "media-2");
+		await installProjectionFailureTrigger(ctx);
+
+		const result = await processDueMediaUsageWork(ctx.db);
+		await removeProjectionFailureTrigger(ctx);
+
+		expect(result.retryCount).toBe(2);
+		expect(
+			await ctx.db
+				.selectFrom("_emdash_media_usage_work")
+				.select(["state", "attempt_count", "last_error_code"])
+				.orderBy("content_id")
+				.execute(),
+		).toEqual([
+			{ state: "retry", attempt_count: 1, last_error_code: "MEDIA_USAGE_PROCESSING_FAILED" },
+			{ state: "retry", attempt_count: 1, last_error_code: "MEDIA_USAGE_PROCESSING_FAILED" },
+		]);
+
+		await ctx.db
+			.updateTable("_emdash_media_usage_work")
+			.set({
+				state: "pending",
+				attempt_count: MEDIA_USAGE_WORK_PROCESSING_LIMITS.maxAttempts - 1,
+				next_attempt_at: "2000-01-01T00:00:00.000Z",
+			})
+			.execute();
+		await installProjectionFailureTrigger(ctx);
+		const terminal = await processDueMediaUsageWork(ctx.db);
+		await removeProjectionFailureTrigger(ctx);
+
+		expect(terminal.failedCount).toBe(2);
 		expect(await findCoverageStatus(ctx.db, fixture.collectionId)).toEqual(
-			expect.objectContaining({ status: "complete" }),
+			expect.objectContaining({
+				status: "partial",
+				last_error_code: "MEDIA_USAGE_PROCESSING_FAILED",
+			}),
+		);
+	});
+
+	it("recovers coverage when work deletion committed before its status update", async () => {
+		const fixture = await createActiveFixture(ctx, "finalization_recovery");
+		await insertEntry(ctx, fixture, "entry-1", "media-1");
+		const pending = await findWork(ctx.db);
+		const work = new MediaUsageWorkRepository(ctx.db);
+		const claimed = await work.claimWork({
+			collectionId: fixture.collectionId,
+			contentId: "entry-1",
+			workVersion: pending.work_version,
+			leaseDurationSeconds: 60,
+		});
+		if (!claimed?.leaseToken) throw new Error("Expected claimed work");
+		const usage = new MediaUsageRepository(ctx.db);
+		const marker = await usage.prepareIncrementalFinalization({
+			collectionId: fixture.collectionId,
+			collectionSlug: fixture.collectionSlug,
+		});
+		expect(marker.outcome).toBe("marked");
+		expect(
+			await work.completeWorkBatch([
+				{
+					collectionId: fixture.collectionId,
+					contentId: "entry-1",
+					workVersion: claimed.workVersion,
+					leaseToken: claimed.leaseToken,
+				},
+			]),
+		).toEqual(
+			new Set([`${fixture.collectionId}\u0000entry-1\u0000${String(claimed.workVersion)}`]),
+		);
+		expect(
+			await ctx.db
+				.selectFrom("_emdash_media_usage_index_status")
+				.select("collection_id")
+				.where("collection_id", "=", fixture.collectionId)
+				.where(
+					sql<boolean>`cursor LIKE ('incremental-finalize:' || CAST(change_epoch AS text) || ':%')`,
+				)
+				.executeTakeFirst(),
+		).toBeDefined();
+		await processDueMediaUsageWork(ctx.db);
+
+		expect(await findCoverageStatus(ctx.db, fixture.collectionId)).toEqual(
+			expect.objectContaining({ status: "complete", cursor: null }),
+		);
+	});
+
+	it("does not complete an unmarked stale collection with no work", async () => {
+		const fixture = await createActiveFixture(ctx, "unmarked_stale");
+		await ctx.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ status: "stale", completed_at: null, cursor: null })
+			.where("collection_id", "=", fixture.collectionId)
+			.execute();
+
+		await processDueMediaUsageWork(ctx.db);
+
+		expect(await findCoverageStatus(ctx.db, fixture.collectionId)).toEqual(
+			expect.objectContaining({ status: "stale", completed_at: null, cursor: null }),
 		);
 	});
 
@@ -285,7 +472,7 @@ describeEachDialect("media usage durable work processing", (dialect) => {
 		).toBeNull();
 	});
 
-	it("keeps an ordinary job inside the exported statement envelope", async () => {
+	it("keeps an ordinary job inside the shared step reservation", async () => {
 		const fixture = await createActiveFixture(ctx, "measured");
 		await insertEntry(ctx, fixture, "entry-1", "media-1");
 		const counter = new QueryCountingPlugin();
@@ -298,9 +485,7 @@ describeEachDialect("media usage durable work processing", (dialect) => {
 
 		expect(result.outcome).toBe("completed");
 		expect(counter.count).toBeGreaterThan(0);
-		expect(counter.count).toBeLessThanOrEqual(
-			MEDIA_USAGE_WORK_PROCESSING_LIMITS.ordinaryStatementsPerJob,
-		);
+		expect(counter.count).toBeLessThanOrEqual(MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries);
 	});
 });
 
@@ -322,6 +507,7 @@ async function createActiveFixture(ctx: DialectTestContext, collectionSlug: stri
 	await registry.createCollection({ slug: collectionSlug, label: collectionSlug });
 	await registry.createField(collectionSlug, { slug: "title", label: "Title", type: "string" });
 	await registry.createField(collectionSlug, { slug: "hero", label: "Hero", type: "image" });
+	await registry.createField(collectionSlug, { slug: "body", label: "Body", type: "portableText" });
 	const collection = await registry.getCollection(collectionSlug);
 	if (!collection) throw new Error(`Expected ${collectionSlug} collection`);
 
@@ -364,15 +550,21 @@ async function insertEntry(
 	fixture: Awaited<ReturnType<typeof createActiveFixture>>,
 	contentId: string,
 	mediaId: string,
+	referenceCount = 1,
 ): Promise<void> {
+	const body = Array.from({ length: Math.max(0, referenceCount - 1) }, (_, index) => ({
+		_type: "image",
+		asset: { _ref: `${mediaId}-body-${index}` },
+	}));
 	await sql`
-		INSERT INTO ${sql.ref(fixture.tableName)} (id, slug, status, title, hero)
+		INSERT INTO ${sql.ref(fixture.tableName)} (id, slug, status, title, hero, body)
 		VALUES (
 			${contentId},
 			${contentId},
 			'published',
 			${contentId},
-			${JSON.stringify({ id: mediaId, provider: "local", mimeType: "image/webp" })}
+			${JSON.stringify({ id: mediaId, provider: "local", mimeType: "image/webp" })},
+			${JSON.stringify(body)}
 		)
 	`.execute(ctx.db);
 }
@@ -462,3 +654,43 @@ async function removeProjectionSupersessionTrigger(ctx: DialectTestContext): Pro
 	}
 	await sql`DROP TRIGGER emdash_test_supersede_media_usage_work`.execute(ctx.db);
 }
+
+async function installProjectionFailureTrigger(ctx: DialectTestContext): Promise<void> {
+	if (ctx.dialect === "postgres") {
+		await sql`
+			CREATE OR REPLACE FUNCTION emdash_test_fail_media_usage_projection()
+			RETURNS trigger
+			LANGUAGE plpgsql
+			AS $$
+			BEGIN
+				RAISE EXCEPTION 'forced media usage projection failure';
+			END;
+			$$
+		`.execute(ctx.db);
+		await sql`
+			CREATE TRIGGER emdash_test_fail_media_usage_projection
+			BEFORE INSERT ON _emdash_media_usage_sources
+			FOR EACH ROW EXECUTE FUNCTION emdash_test_fail_media_usage_projection()
+		`.execute(ctx.db);
+		return;
+	}
+	await sql`
+		CREATE TRIGGER emdash_test_fail_media_usage_projection
+		BEFORE INSERT ON _emdash_media_usage_sources
+		BEGIN
+			SELECT RAISE(ABORT, 'forced media usage projection failure');
+		END
+	`.execute(ctx.db);
+}
+
+async function removeProjectionFailureTrigger(ctx: DialectTestContext): Promise<void> {
+	if (ctx.dialect === "postgres") {
+		await sql`
+			DROP TRIGGER emdash_test_fail_media_usage_projection
+			ON _emdash_media_usage_sources
+		`.execute(ctx.db);
+		await sql`DROP FUNCTION emdash_test_fail_media_usage_projection()`.execute(ctx.db);
+		return;
+	}
+	await sql`DROP TRIGGER emdash_test_fail_media_usage_projection`.execute(ctx.db);
+}
diff --git a/packages/core/tests/integration/database/media-usage-work-repository.test.ts b/packages/core/tests/integration/database/media-usage-work-repository.test.ts
index 5ac94fdc72..74462c7332 100644
--- a/packages/core/tests/integration/database/media-usage-work-repository.test.ts
+++ b/packages/core/tests/integration/database/media-usage-work-repository.test.ts
@@ -84,21 +84,14 @@ describeEachDialect("media usage work repository", (dialect) => {
 		const replacement = await claimWork(repo, 1);
 		expect(replacement?.leaseToken).toBeTruthy();
 		expect(replacement?.leaseToken).not.toBe("old-owner");
-		expect(await repo.completeWork(lease("old-owner", 1))).toBe(false);
+		expect(await completeClaim(repo, lease("old-owner", 1))).toBe(false);
 		expect(
-			await repo.retryWork({
-				...lease("old-owner", 1),
-				retryDelaySeconds: 1,
-				errorCode: "TRANSIENT_DATABASE_FAILURE",
-			}),
-		).toBe(false);
+			await transitionClaim(repo, lease("old-owner", 1), "TRANSIENT_DATABASE_FAILURE"),
+		).toBeUndefined();
 		expect(
-			await repo.failWork({
-				...lease("old-owner", 1),
-				errorCode: "INVARIANT_FAILURE",
-			}),
-		).toBe(false);
-		expect(await repo.completeWork(lease(replacement!.leaseToken!, 1))).toBe(true);
+			await transitionClaim(repo, lease("old-owner", 1), "INVARIANT_FAILURE", 1, 0),
+		).toBeUndefined();
+		expect(await completeClaim(repo, lease(replacement!.leaseToken!, 1))).toBe(true);
 		expect(await readWork(ctx)).toBeUndefined();
 	});
 
@@ -121,20 +114,13 @@ describeEachDialect("media usage work repository", (dialect) => {
 			})
 			.execute();
 
-		expect(await repo.completeWork(lease(staleClaim!.leaseToken!, 1))).toBe(false);
+		expect(await completeClaim(repo, lease(staleClaim!.leaseToken!, 1))).toBe(false);
 		expect(
-			await repo.retryWork({
-				...lease(staleClaim!.leaseToken!, 1),
-				retryDelaySeconds: 1,
-				errorCode: "TRANSIENT_DATABASE_FAILURE",
-			}),
-		).toBe(false);
+			await transitionClaim(repo, lease(staleClaim!.leaseToken!, 1), "TRANSIENT_DATABASE_FAILURE"),
+		).toBeUndefined();
 		expect(
-			await repo.failWork({
-				...lease(staleClaim!.leaseToken!, 1),
-				errorCode: "INVARIANT_FAILURE",
-			}),
-		).toBe(false);
+			await transitionClaim(repo, lease(staleClaim!.leaseToken!, 1), "INVARIANT_FAILURE", 1, 0),
+		).toBeUndefined();
 		expect(await readWork(ctx)).toEqual(
 			expect.objectContaining({
 				work_version: expect.toSatisfy((value) => Number(value) === 2),
@@ -152,12 +138,8 @@ describeEachDialect("media usage work repository", (dialect) => {
 		expect(retryClaim).not.toBeNull();
 
 		expect(
-			await repo.retryWork({
-				...lease(retryClaim!.leaseToken!, 1),
-				retryDelaySeconds: 60,
-				errorCode: "SNAPSHOT_FAILURE",
-			}),
-		).toBe(true);
+			await transitionClaim(repo, lease(retryClaim!.leaseToken!, 1), "SNAPSHOT_FAILURE", 5, 60),
+		).toBe("retry");
 		const retry = await readWork(ctx);
 		expect(retry).toEqual(
 			expect.objectContaining({
@@ -178,11 +160,8 @@ describeEachDialect("media usage work repository", (dialect) => {
 		const failureClaim = await claimWork(repo, 1);
 		expect(failureClaim).not.toBeNull();
 		expect(
-			await repo.failWork({
-				...lease(failureClaim!.leaseToken!, 1),
-				errorCode: "RESOURCE_LIMIT",
-			}),
-		).toBe(true);
+			await transitionClaim(repo, lease(failureClaim!.leaseToken!, 1), "RESOURCE_LIMIT", 1, 0),
+		).toBe("failed");
 		expect(await readWork(ctx)).toEqual(
 			expect.objectContaining({
 				state: "failed",
@@ -205,15 +184,9 @@ describeEachDialect("media usage work repository", (dialect) => {
 			.execute();
 
 		const expiredLease = lease(expiredClaim!.leaseToken!, 1);
-		expect(await repo.completeWork(expiredLease)).toBe(false);
-		expect(
-			await repo.retryWork({
-				...expiredLease,
-				retryDelaySeconds: 1,
-				errorCode: "TRANSIENT_DATABASE_FAILURE",
-			}),
-		).toBe(false);
-		expect(await repo.failWork({ ...expiredLease, errorCode: "INVARIANT_FAILURE" })).toBe(false);
+		expect(await completeClaim(repo, expiredLease)).toBe(false);
+		expect(await transitionClaim(repo, expiredLease, "TRANSIENT_DATABASE_FAILURE")).toBeUndefined();
+		expect(await transitionClaim(repo, expiredLease, "INVARIANT_FAILURE", 1, 0)).toBeUndefined();
 		expect(await readWork(ctx)).toEqual(
 			expect.objectContaining({ state: "leased", lease_token: expiredClaim!.leaseToken }),
 		);
@@ -250,11 +223,11 @@ describeEachDialect("media usage work repository", (dialect) => {
 		expect(workClaim).not.toBeNull();
 
 		await expect(
-			repo.retryWork({
-				...lease(workClaim!.leaseToken!, 1),
-				retryDelaySeconds: 1,
-				errorCode: "database connection failed for customer data",
-			}),
+			transitionClaim(
+				repo,
+				lease(workClaim!.leaseToken!, 1),
+				"database connection failed for customer data",
+			),
 		).rejects.toThrow(/stable SCREAMING_SNAKE_CASE/i);
 		expect(await readWork(ctx)).toEqual(
 			expect.objectContaining({
@@ -314,13 +287,10 @@ describeEachDialect("media usage work repository", (dialect) => {
 			nextAttemptAt: "1998-01-01T00:00:00.000Z",
 		});
 
-		const due = await repo.findDueWork(10);
-
-		expect(due.map((work) => work.contentId)).toEqual([
-			"lease-expired",
-			"retry-due",
-			"pending-due",
-		]);
+		const first = await repo.claimDueWorkBatch({ limit: 2, leaseDurationSeconds: 60 });
+		expect(first.map((work) => work.contentId).toSorted()).toEqual(["lease-expired", "retry-due"]);
+		const second = await repo.claimDueWorkBatch({ limit: 10, leaseDurationSeconds: 60 });
+		expect(second.map((work) => work.contentId)).toEqual(["pending-due"]);
 	});
 });
 
@@ -342,6 +312,34 @@ function lease(leaseToken: string, workVersion: number) {
 	};
 }
 
+async function completeClaim(
+	repo: MediaUsageWorkRepository,
+	work: ReturnType<typeof lease>,
+): Promise<boolean> {
+	return (await repo.completeWorkBatch([work])).has(workIdentityKey(work));
+}
+
+async function transitionClaim(
+	repo: MediaUsageWorkRepository,
+	work: ReturnType<typeof lease>,
+	errorCode: string,
+	maxAttempts = 5,
+	retryDelaySeconds = 1,
+) {
+	return (
+		await repo.retryClaimedWorkBatch({
+			work: [work],
+			errorCode,
+			maxAttempts,
+			retryDelaySeconds,
+		})
+	).get(workIdentityKey(work));
+}
+
+function workIdentityKey(work: ReturnType<typeof lease>): string {
+	return `${work.collectionId}\u0000${work.contentId}\u0000${String(work.workVersion)}`;
+}
+
 async function insertWork(
 	ctx: DialectTestContext,
 	input: {
diff --git a/packages/core/tests/integration/runtime/media-usage-scheduled-driver.test.ts b/packages/core/tests/integration/runtime/media-usage-scheduled-driver.test.ts
index f58c1f43d5..630969d546 100644
--- a/packages/core/tests/integration/runtime/media-usage-scheduled-driver.test.ts
+++ b/packages/core/tests/integration/runtime/media-usage-scheduled-driver.test.ts
@@ -1,18 +1,34 @@
 import { randomUUID } from "node:crypto";
 
 import Database from "better-sqlite3";
-import { sql, SqliteDialect } from "kysely";
+import {
+	sql,
+	SqliteDialect,
+	type KyselyPlugin,
+	type PluginTransformQueryArgs,
+	type PluginTransformResultArgs,
+	type QueryResult,
+	type RootOperationNode,
+	type UnknownRow,
+} from "kysely";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { MediaUsageRepository } from "../../../src/database/repositories/media-usage.js";
 import { OptionsRepository } from "../../../src/database/repositories/options.js";
-import {
-	EmDashRuntime,
-	MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS,
-	type RuntimeDependencies,
-} from "../../../src/emdash-runtime.js";
+import { EmDashRuntime, type RuntimeDependencies } from "../../../src/emdash-runtime.js";
+import { activateMediaUsageCapture } from "../../../src/media/usage/activation.js";
 import { installMediaUsageCaptureTriggers } from "../../../src/media/usage/capture-triggers.js";
-import type { CronScheduler, SystemCleanupFn } from "../../../src/plugins/scheduler/types.js";
+import {
+	MEDIA_USAGE_MAINTENANCE_LIMITS,
+	runMediaUsageMaintenanceSlice,
+} from "../../../src/media/usage/maintenance-engine.js";
+import { processDueMediaUsageReconciliation } from "../../../src/media/usage/reconciliation-processor.js";
+import { processDueMediaUsageWork } from "../../../src/media/usage/work-processor.js";
+import type {
+	CronScheduler,
+	MediaUsageContinuationFn,
+	SystemCleanupFn,
+} from "../../../src/plugins/scheduler/types.js";
 import { createRequestMetrics, runWithContext } from "../../../src/request-context.js";
 import { SCHEDULER_HEARTBEAT_OPTION } from "../../../src/scheduler-health.js";
 
@@ -24,44 +40,176 @@ describe("media usage scheduled drivers", () => {
 		runtime = null;
 	});
 
-	it("keeps general maintenance unchanged and drains work from the dedicated lane", async () => {
+	it("skips idle maintenance classes and processes due entry work", async () => {
 		runtime = await EmDashRuntime.create(createDeps(null));
-		const fixture = await activateCollection(runtime, "cloudflare_posts");
+		const fixture = await activateCollection(runtime, "work_conserving_posts");
 		await insertEntry(runtime, fixture.tableName, "entry-1");
 
-		await runtime.runScheduledTasks();
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toEqual({
+			state: "progress",
+			continuation: { kind: "immediate" },
+		});
+		expect(await countWork(runtime)).toBe(0);
+	});
+
+	it("delays one continuation when every visible claim is blocked", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const fixture = await activateCollection(runtime, "blocked_claim_posts");
+		await insertEntry(runtime, fixture.tableName, "entry-1");
+		await sql`
+			CREATE TRIGGER block_media_usage_work_claim
+			BEFORE UPDATE OF state ON _emdash_media_usage_work
+			WHEN NEW.state = 'leased'
+			BEGIN
+				SELECT RAISE(IGNORE);
+			END
+		`.execute(runtime.db);
+
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toEqual({
+			state: "blocked",
+			continuation: { kind: "delayed", delaySeconds: 30 },
+		});
 		expect(await countWork(runtime)).toBe(1);
-		await expect(runtime.runScheduledMediaUsageTasks()).resolves.toMatchObject({
-			outcome: "processed",
-			taskClass: "entry_work",
+	});
+
+	it("keeps a delayed continuation while retry work is waiting", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const fixture = await activateCollection(runtime, "delayed_retry_posts");
+		await insertEntry(runtime, fixture.tableName, "entry-1");
+		await runtime.db
+			.updateTable("_emdash_media_usage_work")
+			.set({ state: "retry", next_attempt_at: "2100-01-01T00:00:00.000Z" })
+			.execute();
+
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toEqual({
+			state: "blocked",
+			continuation: { kind: "delayed", delaySeconds: 30 },
 		});
+		expect(await countWork(runtime)).toBe(1);
+	});
 
+	it("continues useful entry work after a reconciliation claim is lost", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const work = await activateCollection(runtime, "seed_claim_work");
+		await insertEntry(runtime, work.tableName, "entry-1");
+		const reconciliation = await activateCollection(runtime, "seed_claim_reconciliation");
+		await runtime.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ status: "stale", reconciliation_required: 1 })
+			.where("collection_id", "=", reconciliation.collectionId)
+			.execute();
+		await sql`
+			CREATE TRIGGER block_media_usage_reconciliation_claim
+			BEFORE UPDATE OF state ON _emdash_media_usage_reconciliations
+			WHEN NEW.state = 'leased'
+			BEGIN
+				SELECT RAISE(IGNORE);
+			END
+		`.execute(runtime.db);
+
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toEqual({
+			state: "progress",
+			continuation: { kind: "immediate" },
+		});
 		expect(await countWork(runtime)).toBe(0);
-		expect(
-			await new MediaUsageRepository(runtime.db).findSource(
-				canonicalSourceKey(fixture.collectionId, "entry-1"),
-			),
-		).not.toBeNull();
 	});
 
-	it("drains bounded work from the Node timer maintenance callback", async () => {
-		const scheduler = new CapturingScheduler();
-		runtime = await EmDashRuntime.create(createDeps(() => scheduler));
-		const fixture = await activateCollection(runtime, "node_posts");
-		await insertEntry(runtime, fixture.tableName, "entry-1");
+	it("keeps a blocked due reconciliation on its delayed continuation", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const fixture = await activateCollection(runtime, "blocked_due_reconciliation");
+		const runToken = "blocked-due-run";
+		await runtime.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({
+				status: "running",
+				cursor: runToken,
+				change_epoch: 1,
+				reconciliation_required: 1,
+			})
+			.where("collection_id", "=", fixture.collectionId)
+			.execute();
+		await runtime.db
+			.insertInto("_emdash_media_usage_reconciliations")
+			.values({
+				collection_id: fixture.collectionId,
+				collection_slug: "blocked_due_reconciliation",
+				run_token: runToken,
+				target_epoch: 1,
+				field_fingerprint: "blocked-due-fields",
+				state: "pending",
+				phase: "sources",
+				next_attempt_at: "2000-01-01T00:00:00.000Z",
+			})
+			.execute();
+		await sql`
+			CREATE TRIGGER block_due_reconciliation_claim
+			BEFORE UPDATE OF state ON _emdash_media_usage_reconciliations
+			WHEN NEW.state = 'leased'
+			BEGIN
+				SELECT RAISE(IGNORE);
+			END
+		`.execute(runtime.db);
 
-		await scheduler.runMaintenance();
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toMatchObject({
+			state: "blocked",
+			continuation: { kind: "delayed", delaySeconds: 30 },
+		});
+	});
+
+	it("stops continuation only after a full idle maintenance pass", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		await activateCollection(runtime, "idle_posts");
 
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toEqual({
+			state: "idle",
+			continuation: { kind: "none" },
+		});
+	});
+
+	it("continues reconciliation immediately after entry work drains", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		await runtime.schemaRegistry.createCollection({
+			slug: "deferred_reconciliation",
+			label: "Deferred reconciliation",
+		});
+		await runtime.schemaRegistry.createField("deferred_reconciliation", {
+			slug: "title",
+			label: "Title",
+			type: "string",
+		});
+		await runtime.schemaRegistry.createField("deferred_reconciliation", {
+			slug: "image",
+			label: "Image",
+			type: "image",
+		});
+		await sql`
+			INSERT INTO ${sql.ref("ec_deferred_reconciliation")} (id, slug, status, title)
+			VALUES
+				('entry-1', 'entry-1', 'published', 'Entry 1'),
+				('entry-2', 'entry-2', 'published', 'Entry 2')
+		`.execute(runtime.db);
+		await expect(activateMediaUsageCapture(runtime.db, { writersDrained: true })).resolves.toEqual({
+			outcome: "active",
+			processedCollections: 1,
+		});
+
+		await expect(processDueMediaUsageReconciliation(runtime.db)).resolves.toBe("advanced");
+		await expect(processDueMediaUsageReconciliation(runtime.db)).resolves.toBe("deferred");
+		await processDueMediaUsageWork(runtime.db);
+		await processDueMediaUsageWork(runtime.db);
 		expect(await countWork(runtime)).toBe(0);
 		expect(
-			await new MediaUsageRepository(runtime.db).findSource(
-				canonicalSourceKey(fixture.collectionId, "entry-1"),
-			),
-		).not.toBeNull();
+			await runtime.db.selectFrom("_emdash_media_usage_reconciliations").select("state").execute(),
+		).toEqual([expect.objectContaining({ state: "pending" })]);
+
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toMatchObject({
+			state: "progress",
+			continuation: { kind: "immediate" },
+		});
 	});
 
 	it("records a heartbeat from the Node timer maintenance callback", async () => {
-		const scheduler = new CapturingScheduler();
+		const scheduler = new ContinuousCapturingScheduler();
 		runtime = await EmDashRuntime.create(createDeps(() => scheduler));
 
 		await scheduler.runMaintenance();
@@ -74,7 +222,7 @@ describe("media usage scheduled drivers", () => {
 	});
 
 	it("does not fail Node maintenance when the heartbeat write fails", async () => {
-		const scheduler = new CapturingScheduler();
+		const scheduler = new ContinuousCapturingScheduler();
 		runtime = await EmDashRuntime.create(createDeps(() => scheduler));
 		await new OptionsRepository(runtime.db).set(
 			SCHEDULER_HEARTBEAT_OPTION,
@@ -97,42 +245,274 @@ describe("media usage scheduled drivers", () => {
 		);
 	});
 
-	it("drains bounded work through a legacy Node scheduler cleanup callback", async () => {
-		const scheduler = new LegacyCapturingScheduler();
+	it("offers every due maintenance class one opportunity per cycle", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const work = await activateCollection(runtime, "fair_engine_work");
+		await insertEntry(runtime, work.tableName, "entry-1");
+		const deletion = await activateCollection(runtime, "fair_engine_delete");
+		await runtime.schemaRegistry.deleteCollection("fair_engine_delete", { force: true });
+		const reconciliation = await activateCollection(runtime, "fair_engine_reconciliation");
+		await runtime.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ status: "stale", reconciliation_required: 1 })
+			.where("collection_id", "=", reconciliation.collectionId)
+			.execute();
+
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toMatchObject({
+			state: "progress",
+			continuation: { kind: "immediate" },
+		});
+		expect(await countWork(runtime)).toBe(0);
+		expect(await deletionPhase(runtime, deletion.collectionId)).toBe("sources");
+		expect(
+			await runtime.db
+				.selectFrom("_emdash_media_usage_reconciliations")
+				.select("collection_id")
+				.where("collection_id", "=", reconciliation.collectionId)
+				.executeTakeFirst(),
+		).toBeDefined();
+	});
+
+	it("drains work after an explicit Node wake", async () => {
+		const scheduler = new ContinuousCapturingScheduler();
 		runtime = await EmDashRuntime.create(createDeps(() => scheduler));
-		const fixture = await activateCollection(runtime, "legacy_node_posts");
+		const fixture = await activateCollection(runtime, "continuous_node_posts");
 		await insertEntry(runtime, fixture.tableName, "entry-1");
+		await insertEntry(runtime, fixture.tableName, "entry-2");
 
-		await scheduler.runMaintenance();
+		runtime.wakeMediaUsageMaintenance();
+		expect(scheduler.wakeCount).toBe(1);
+		await expect(scheduler.runContinuation()).resolves.toEqual({ kind: "immediate" });
+		expect(await countWork(runtime)).toBe(0);
+		await expect(scheduler.runContinuation()).resolves.toEqual({ kind: "none" });
+	});
 
+	it("drains several durable units inside one Cloudflare maintenance slice", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const fixture = await activateCollection(runtime, "slice_posts");
+		await insertEntry(runtime, fixture.tableName, "entry-1");
+		await insertEntry(runtime, fixture.tableName, "entry-2");
+		await insertEntry(runtime, fixture.tableName, "entry-3");
+		const metrics = createRequestMetrics(performance.now());
+
+		const continuation = await runWithContext({ editMode: false, metrics }, () =>
+			runtime!.runMediaUsageMaintenanceSlice(),
+		);
+
+		expect(continuation).toEqual({ kind: "none" });
 		expect(await countWork(runtime)).toBe(0);
-		expect(
-			await new MediaUsageRepository(runtime.db).findSource(
-				canonicalSourceKey(fixture.collectionId, "entry-1"),
+	});
+
+	it("does not re-probe idle classes while draining historical coverage", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		await runtime.schemaRegistry.createCollection({ slug: "bulk_history", label: "Bulk history" });
+		await runtime.schemaRegistry.createField("bulk_history", {
+			slug: "hero",
+			label: "Hero",
+			type: "image",
+		});
+		await sql`
+			WITH RECURSIVE sequence(value) AS (
+				VALUES (0)
+				UNION ALL
+				SELECT value + 1 FROM sequence WHERE value < 499
+			)
+			INSERT INTO ${sql.ref("ec_bulk_history")} (id, slug, status, hero)
+			SELECT
+				printf('entry-%03d', value),
+				printf('entry-%03d', value),
+				'published',
+				json_object('id', printf('media-%03d', value), 'provider', 'local')
+			FROM sequence
+		`.execute(runtime.db);
+		await expect(
+			activateMediaUsageCapture(runtime.db, { writersDrained: true }),
+		).resolves.toMatchObject({ outcome: "active" });
+		const counter = new QueryCountingPlugin();
+		const metrics = createRequestMetrics(performance.now());
+
+		await expect(
+			runWithContext({ editMode: false, metrics }, () =>
+				runMediaUsageMaintenanceSlice(runtime!.db.withPlugin(counter)),
 			),
-		).not.toBeNull();
+		).resolves.toEqual({ kind: "none" });
+
+		expect(counter.count).toBeLessThan(75);
+	});
+
+	it("runs one complete batch when a direct slice caller has no query metrics", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const fixture = await activateCollection(runtime, "unmetered_slice_posts");
+		await insertEntry(runtime, fixture.tableName, "entry-1");
+		await insertEntry(runtime, fixture.tableName, "entry-2");
+
+		await expect(runtime.runMediaUsageMaintenanceSlice()).resolves.toEqual({ kind: "immediate" });
+		expect(await countWork(runtime)).toBe(0);
 	});
 
-	it("advances bounded collection deletion from the Cloudflare scheduled entry point", async () => {
+	it("stops before another unit when the remaining query budget is reserved", async () => {
 		runtime = await EmDashRuntime.create(createDeps(null));
-		const fixture = await activateCollection(runtime, "cloudflare_delete");
-		await runtime.schemaRegistry.deleteCollection("cloudflare_delete", { force: true });
-		await runtime.runScheduledMediaUsageTasks();
-		await runtime.runScheduledMediaUsageTasks();
+		const fixture = await activateCollection(runtime, "query_bound_slice_posts");
+		await insertEntry(runtime, fixture.tableName, "entry-1");
+		await insertEntry(runtime, fixture.tableName, "entry-2");
+		const metrics = createRequestMetrics(performance.now());
+		metrics.dbCount =
+			MEDIA_USAGE_MAINTENANCE_LIMITS.eventQueryCeiling -
+			MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries -
+			10;
+
+		const continuation = await runWithContext({ editMode: false, metrics }, () =>
+			runtime!.runMediaUsageMaintenanceSlice(),
+		);
 
-		expect(await deletionPhase(runtime, fixture.collectionId)).toBe("sources");
+		expect(continuation).toEqual({ kind: "immediate" });
+		expect(await countWork(runtime)).toBe(0);
+	});
+
+	it("rechecks the event query budget between due maintenance classes", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const work = await activateCollection(runtime, "bounded_cycle_work");
+		await insertEntry(runtime, work.tableName, "entry-1");
+		const deletion = await activateCollection(runtime, "bounded_cycle_delete");
+		await runtime.schemaRegistry.deleteCollection("bounded_cycle_delete", { force: true });
+		const reconciliation = await activateCollection(runtime, "bounded_cycle_reconciliation");
+		await runtime.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({ status: "stale", reconciliation_required: 1 })
+			.where("collection_id", "=", reconciliation.collectionId)
+			.execute();
+		const metrics = createRequestMetrics(performance.now());
+		metrics.dbCount =
+			MEDIA_USAGE_MAINTENANCE_LIMITS.eventQueryCeiling -
+			MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries -
+			1;
+
+		await expect(
+			runWithContext({ editMode: false, metrics }, () => runtime!.runMediaUsageMaintenanceStep()),
+		).resolves.toMatchObject({
+			state: "progress",
+			continuation: { kind: "immediate" },
+		});
+		expect(await deletionPhase(runtime, deletion.collectionId)).toBe("sources");
+		expect(await countWork(runtime)).toBe(1);
+		expect(
+			await runtime.db
+				.selectFrom("_emdash_media_usage_reconciliations")
+				.select("collection_id")
+				.where("collection_id", "=", reconciliation.collectionId)
+				.executeTakeFirst(),
+		).toBeUndefined();
 	});
 
-	it("advances bounded collection deletion from the Node maintenance callback", async () => {
-		const scheduler = new CapturingScheduler();
+	it("does not create a no-progress continuation when initialization spent the query budget", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const fixture = await activateCollection(runtime, "spent_slice_posts");
+		await insertEntry(runtime, fixture.tableName, "entry-1");
+		const metrics = createRequestMetrics(performance.now());
+		metrics.dbCount =
+			MEDIA_USAGE_MAINTENANCE_LIMITS.eventQueryCeiling -
+			MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries +
+			1;
+
+		const continuation = await runWithContext({ editMode: false, metrics }, () =>
+			runtime!.runMediaUsageMaintenanceSlice(),
+		);
+
+		expect(continuation).toEqual({ kind: "none" });
+		expect(await countWork(runtime)).toBe(1);
+	});
+
+	it("does not start a unit after the Cloudflare slice deadline", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const fixture = await activateCollection(runtime, "timed_slice_posts");
+		await insertEntry(runtime, fixture.tableName, "entry-1");
+		const metrics = createRequestMetrics(
+			performance.now() - MEDIA_USAGE_MAINTENANCE_LIMITS.stepStartDeadlineMs,
+		);
+
+		const continuation = await runWithContext({ editMode: false, metrics }, () =>
+			runtime!.runMediaUsageMaintenanceSlice(),
+		);
+
+		expect(continuation).toEqual({ kind: "none" });
+		expect(await countWork(runtime)).toBe(1);
+	});
+
+	it("continues a metered Queue slice beyond the old twenty-second cutoff", async () => {
+		runtime = await EmDashRuntime.create(createDeps(null));
+		const fixture = await activateCollection(runtime, "long_io_slice_posts");
+		await insertEntry(runtime, fixture.tableName, "entry-1");
+		await insertEntry(runtime, fixture.tableName, "entry-2");
+		const metrics = createRequestMetrics(performance.now() - 20_001);
+
+		const continuation = await runWithContext({ editMode: false, metrics }, () =>
+			runtime!.runMediaUsageMaintenanceSlice(),
+		);
+
+		expect(continuation).toEqual({ kind: "none" });
+		expect(await countWork(runtime)).toBe(0);
+	});
+
+	it("starts reconciliation from an explicit Node wake", async () => {
+		const scheduler = new ContinuousCapturingScheduler();
+		const metrics = createRequestMetrics(performance.now());
+		runtime = await EmDashRuntime.create(createDeps(() => scheduler));
+		await runtime.schemaRegistry.createCollection({
+			slug: "node_reconciliation",
+			label: "Node reconciliation",
+		});
+		await runtime.schemaRegistry.createField("node_reconciliation", {
+			slug: "title",
+			label: "Title",
+			type: "string",
+		});
+		await sql`
+			INSERT INTO ${sql.ref("ec_node_reconciliation")} (id, slug, status, title)
+			VALUES ('existing-entry', 'existing-entry', 'published', 'Existing entry')
+		`.execute(runtime.db);
+		metrics.dbCount = MEDIA_USAGE_MAINTENANCE_LIMITS.eventQueryCeiling;
+
+		await expect(activateMediaUsageCapture(runtime.db, { writersDrained: true })).resolves.toEqual({
+			outcome: "active",
+			processedCollections: 1,
+		});
+		expect(
+			await runtime.db
+				.selectFrom("_emdash_media_usage_reconciliations")
+				.select("collection_id")
+				.executeTakeFirst(),
+		).toBeUndefined();
+
+		await runWithContext({ editMode: false, metrics }, async () => {
+			runtime!.wakeMediaUsageMaintenance();
+			await scheduler.runContinuation();
+			await scheduler.runContinuation();
+			await scheduler.runContinuation();
+		});
+
+		const reconciliation = await runtime.db
+			.selectFrom("_emdash_media_usage_reconciliations")
+			.select("collection_id")
+			.executeTakeFirst();
+		const coverage = await runtime.db
+			.selectFrom("_emdash_media_usage_index_status")
+			.select("status")
+			.where("scope_key", "=", "node_reconciliation")
+			.executeTakeFirstOrThrow();
+		expect(reconciliation !== undefined || coverage.status === "complete").toBe(true);
+	});
+
+	it("advances bounded collection deletion from an explicit Node wake", async () => {
+		const scheduler = new ContinuousCapturingScheduler();
 		runtime = await EmDashRuntime.create(createDeps(() => scheduler));
 		const fixture = await activateCollection(runtime, "node_delete");
 		await runtime.schemaRegistry.deleteCollection("node_delete", { force: true });
 
-		await scheduler.runMaintenance();
-		await scheduler.runMaintenance();
+		runtime.wakeMediaUsageMaintenance();
+		await scheduler.runContinuation();
+		await scheduler.runContinuation();
 
-		expect(await deletionPhase(runtime, fixture.collectionId)).toBe("sources");
+		expect(await deletionPhase(runtime, fixture.collectionId)).toBe("status");
 	});
 
 	it("processes a trigger-created job before returning from an authenticated write", async () => {
@@ -156,121 +536,105 @@ describe("media usage scheduled drivers", () => {
 		).not.toBeNull();
 	});
 
-	it("persists a fair entry, deletion, reconciliation turn sequence", async () => {
+	it("continues confirmed activation one bounded collection at a time", async () => {
 		runtime = await EmDashRuntime.create(createDeps(null));
-		const fixture = await activateCollection(runtime, "fair_posts");
-		await runtime.db
-			.updateTable("_emdash_media_usage_index_status")
-			.set({ status: "stale", reconciliation_required: 1 })
-			.where("collection_id", "=", fixture.collectionId)
-			.execute();
+		await runtime.schemaRegistry.createCollection({ slug: "activation_alpha", label: "Alpha" });
+		await runtime.schemaRegistry.createCollection({ slug: "activation_beta", label: "Beta" });
 
-		const classes = [];
-		for (let index = 0; index < 3; index++) {
-			const result = await runtime.runScheduledMediaUsageTasks();
-			classes.push(result.taskClass);
-		}
-		expect(classes).toEqual(["entry_work", "collection_deletion", "reconciliation"]);
-		expect(
-			await runtime.db
-				.selectFrom("_emdash_media_usage_reconciliations")
-				.select("collection_id")
-				.where("collection_id", "=", fixture.collectionId)
-				.executeTakeFirst(),
-		).toBeDefined();
-	});
+		await expect(activateMediaUsageCapture(runtime.db, { writersDrained: true })).resolves.toEqual({
+			outcome: "activating",
+			processedCollections: 1,
+			collectionCursor: "activation_alpha",
+		});
+		const confirmed = await activationState(runtime);
 
-	it("does not advance the turn or spend class queries before activation", async () => {
-		runtime = await EmDashRuntime.create(createDeps(null));
-		const before = await maintenanceTurn(runtime);
-		await expect(runtime.runScheduledMediaUsageTasks()).resolves.toEqual({
-			outcome: "inactive",
-			taskClass: null,
-			turn: null,
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toEqual({
+			state: "progress",
+			continuation: { kind: "immediate" },
 		});
-		expect(await maintenanceTurn(runtime)).toBe(before);
+		expect(await activationState(runtime)).toEqual(
+			expect.objectContaining({
+				state: "active",
+				drain_confirmed_at: confirmed.drain_confirmed_at,
+				attempt_count: confirmed.attempt_count + 1,
+				last_error_code: null,
+			}),
+		);
 	});
 
-	it("reserves ten queries of headroom before changing the persisted turn", async () => {
+	it("does not automatically retry a stored activation failure", async () => {
 		runtime = await EmDashRuntime.create(createDeps(null));
 		await runtime.db
 			.updateTable("_emdash_media_usage_activation")
-			.set({ state: "active" })
-			.where("task_key", "=", "incremental_capture")
+			.set({
+				state: "activating",
+				drain_confirmed_at: "2026-08-18T12:00:00.000Z",
+				last_error_code: "MEDIA_USAGE_ACTIVATION_FAILED",
+			})
 			.execute();
-		const before = await maintenanceTurn(runtime);
-		const metrics = createRequestMetrics(performance.now());
-		metrics.dbCount =
-			MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS.eventCeiling -
-			MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS.maxClassQueries;
+		const before = await activationState(runtime);
 
-		const result = await runWithContext({ editMode: false, metrics }, () =>
-			runtime!.runScheduledMediaUsageTasks(),
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toEqual({
+			state: "inactive",
+			continuation: { kind: "none" },
+		});
+		expect(await activationState(runtime)).toEqual(before);
+
+		await expect(activateMediaUsageCapture(runtime.db, { writersDrained: true })).resolves.toEqual({
+			outcome: "active",
+			processedCollections: 0,
+		});
+		expect(await activationState(runtime)).toEqual(
+			expect.objectContaining({
+				state: "active",
+				attempt_count: before.attempt_count + 1,
+				last_error_code: null,
+			}),
 		);
-		expect(result).toEqual({ outcome: "admission_closed", taskClass: null, turn: null });
-		expect(await maintenanceTurn(runtime)).toBe(before);
 	});
 
-	it("measures every mutation class within its exported event reservation", async () => {
+	it("rejects an incompatible active generation before advancing maintenance", async () => {
 		runtime = await EmDashRuntime.create(createDeps(null));
-		const work = await activateCollection(runtime, "measure_work");
-		await insertEntry(runtime, work.tableName, "entry-1");
-		await activateCollection(runtime, "measure_delete");
-		await runtime.schemaRegistry.deleteCollection("measure_delete", { force: true });
-		const reconciliation = await activateCollection(runtime, "measure_reconcile");
 		await runtime.db
-			.updateTable("_emdash_media_usage_index_status")
-			.set({ status: "stale", reconciliation_required: 1 })
-			.where("collection_id", "=", reconciliation.collectionId)
+			.updateTable("_emdash_media_usage_activation")
+			.set({ state: "active", runtime_generation: 2 })
 			.execute();
+		const before = await activationState(runtime);
 
-		const expected = [
-			["entry_work", MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS.entryWork],
-			["collection_deletion", MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS.collectionDeletion],
-			["reconciliation", MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS.reconciliation],
-		] as const;
-		for (const [taskClass, reservation] of expected) {
-			const metrics = createRequestMetrics(performance.now());
-			const result = await runWithContext({ editMode: false, metrics }, () =>
-				runtime!.runScheduledMediaUsageTasks(),
-			);
-			expect(result.taskClass).toBe(taskClass);
-			expect(metrics.dbCount).toBeLessThanOrEqual(1 + reservation);
-			expect(metrics.dbCount).toBeLessThanOrEqual(
-				MEDIA_USAGE_MAINTENANCE_QUERY_RESERVATIONS.eventCeiling,
-			);
-		}
+		await expect(runtime.runMediaUsageMaintenanceStep()).resolves.toEqual({
+			state: "inactive",
+			continuation: { kind: "none" },
+		});
+		expect(await activationState(runtime)).toEqual(before);
 	});
 });
 
-class CapturingScheduler implements CronScheduler {
-	private maintenance: SystemCleanupFn | null = null;
-	private mediaUsageMaintenance: SystemCleanupFn | null = null;
+class QueryCountingPlugin implements KyselyPlugin {
+	count = 0;
 
-	setSystemCleanup(fn: SystemCleanupFn): void {
-		this.maintenance = fn;
-	}
-	setMediaUsageMaintenance(fn: SystemCleanupFn): void {
-		this.mediaUsageMaintenance = fn;
+	transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+		this.count++;
+		return args.node;
 	}
 
-	start(): void {}
-	stop(): void {}
-	reschedule(): void {}
-
-	async runMaintenance(): Promise<void> {
-		if (!this.maintenance) throw new Error("Expected Node maintenance callback");
-		await this.maintenance();
-		if (!this.mediaUsageMaintenance) throw new Error("Expected Media Usage maintenance callback");
-		await this.mediaUsageMaintenance();
+	transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+		return Promise.resolve(args.result);
 	}
 }
 
-class LegacyCapturingScheduler implements CronScheduler {
-	private maintenance: SystemCleanupFn | null = null;
+class ContinuousCapturingScheduler implements CronScheduler {
+	private systemCleanup: SystemCleanupFn | null = null;
+	private mediaUsageMaintenance: MediaUsageContinuationFn | null = null;
+	wakeCount = 0;
 
 	setSystemCleanup(fn: SystemCleanupFn): void {
-		this.maintenance = fn;
+		this.systemCleanup = fn;
+	}
+	setContinuousMediaUsageMaintenance(fn: MediaUsageContinuationFn): void {
+		this.mediaUsageMaintenance = fn;
+	}
+	wakeMediaUsageMaintenance(): void {
+		this.wakeCount++;
 	}
 
 	start(): void {}
@@ -278,8 +642,15 @@ class LegacyCapturingScheduler implements CronScheduler {
 	reschedule(): void {}
 
 	async runMaintenance(): Promise<void> {
-		if (!this.maintenance) throw new Error("Expected Node maintenance callback");
-		await this.maintenance();
+		if (!this.systemCleanup) throw new Error("Expected Node maintenance callback");
+		await this.systemCleanup();
+	}
+
+	async runContinuation() {
+		if (!this.mediaUsageMaintenance) {
+			throw new Error("Expected continuous Media Usage maintenance callback");
+		}
+		return this.mediaUsageMaintenance();
 	}
 }
 
@@ -370,13 +741,12 @@ async function deletionPhase(runtime: EmDashRuntime, collectionId: string): Prom
 	return row?.phase ?? null;
 }
 
-async function maintenanceTurn(runtime: EmDashRuntime): Promise<number> {
-	const row = await runtime.db
+function activationState(runtime: EmDashRuntime) {
+	return runtime.db
 		.selectFrom("_emdash_media_usage_activation")
-		.select("media_usage_maintenance_turn")
+		.selectAll()
 		.where("task_key", "=", "incremental_capture")
 		.executeTakeFirstOrThrow();
-	return row.media_usage_maintenance_turn;
 }
 
 function canonicalSourceKey(collectionId: string, contentId: string): string {
diff --git a/packages/core/tests/unit/api/media-usage-activation-route.test.ts b/packages/core/tests/unit/api/media-usage-activation-route.test.ts
index 2b0bf03bd2..18f89dc255 100644
--- a/packages/core/tests/unit/api/media-usage-activation-route.test.ts
+++ b/packages/core/tests/unit/api/media-usage-activation-route.test.ts
@@ -1,6 +1,6 @@
 import { Role, type RoleLevel } from "@emdash-cms/auth";
 import { sql } from "kysely";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { injectCoreRoutes } from "../../../src/astro/integration/routes.js";
 import { GET, POST } from "../../../src/astro/routes/api/admin/media-usage/activation.js";
@@ -175,10 +175,14 @@ describe("admin media usage activation status route", () => {
 	});
 
 	it("advances exactly one collection per confirmed request and is idempotent when active", async () => {
+		const wake = vi.fn();
 		const first = await POST(
-			routeContext(activationPost({ writersDrained: true, maintenanceReady: true }), Role.ADMIN, [
-				"admin",
-			]),
+			routeContext(
+				activationPost({ writersDrained: true, maintenanceReady: true }),
+				Role.ADMIN,
+				["admin"],
+				wake,
+			),
 		);
 		expect(first.status).toBe(200);
 		expect(await first.json()).toEqual({
@@ -189,6 +193,7 @@ describe("admin media usage activation status route", () => {
 				activation: expect.objectContaining({ state: "activating" }),
 			},
 		});
+		expect(wake).toHaveBeenCalledOnce();
 
 		const second = await POST(
 			routeContext(activationPost({ writersDrained: true, maintenanceReady: true }), Role.ADMIN),
@@ -243,6 +248,26 @@ describe("admin media usage activation status route", () => {
 		expect(JSON.stringify(body)).not.toContain("private-owner-token");
 	});
 
+	it("keeps a committed response when the Node scheduler wake fails", async () => {
+		const error = vi.spyOn(console, "error").mockImplementation(() => {});
+		const response = await POST(
+			routeContext(
+				activationPost({ writersDrained: true, maintenanceReady: true }),
+				Role.ADMIN,
+				["admin"],
+				() => {
+					throw new Error("private scheduler detail");
+				},
+			),
+		);
+
+		expect(response.status).toBe(200);
+		expect(error).toHaveBeenCalledExactlyOnceWith(
+			"[media-usage:activation] Failed to wake background maintenance",
+		);
+		expect(JSON.stringify(error.mock.calls)).not.toContain("private scheduler detail");
+	});
+
 	it("maps ownership loss to a stable conflict", async () => {
 		await sql`
 			CREATE TRIGGER steal_activation_lease_from_route
@@ -302,11 +327,12 @@ describe("admin media usage activation status route", () => {
 		request: Request,
 		role: RoleLevel | null,
 		tokenScopes?: string[],
+		wakeMediaUsageMaintenance = vi.fn(),
 	): GetContext {
 		return {
 			request,
 			locals: {
-				emdash: { db: ctx!.db },
+				emdash: { db: ctx!.db, wakeMediaUsageMaintenance },
 				user: role == null ? null : { id: "user-1", role },
 				tokenScopes,
 			},
diff --git a/packages/core/tests/unit/api/media-usage-progress-route.test.ts b/packages/core/tests/unit/api/media-usage-progress-route.test.ts
new file mode 100644
index 0000000000..4df7c7314a
--- /dev/null
+++ b/packages/core/tests/unit/api/media-usage-progress-route.test.ts
@@ -0,0 +1,195 @@
+import { Role, type RoleLevel } from "@emdash-cms/auth";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { injectCoreRoutes } from "../../../src/astro/integration/routes.js";
+import { GET } from "../../../src/astro/routes/api/admin/media-usage/progress.js";
+import {
+	setupForDialectWithCollections,
+	teardownForDialect,
+	type DialectTestContext,
+} from "../../utils/test-db.js";
+
+type GetContext = Parameters<typeof GET>[0];
+
+describe("admin media usage progress route", () => {
+	let ctx: DialectTestContext | undefined;
+	let collectionId: string;
+
+	beforeEach(async () => {
+		ctx = await setupForDialectWithCollections("sqlite");
+		const collections = await ctx.db
+			.selectFrom("_emdash_collections")
+			.select(["id", "slug"])
+			.execute();
+		collectionId = collections.find(({ slug }) => slug === "post")!.id;
+		for (const collection of collections) {
+			await ctx.db
+				.updateTable("_emdash_media_usage_index_status")
+				.set({
+					collection_id: collection.id,
+					capture_state: "active",
+					status: "complete",
+					schema_version: 1,
+					reconciliation_required: 0,
+				})
+				.where("adapter_id", "=", "content-media")
+				.where("scope_type", "=", "collection")
+				.where("scope_key", "=", collection.slug)
+				.execute();
+		}
+		await ctx.db
+			.updateTable("_emdash_media_usage_activation")
+			.set({ state: "active" })
+			.where("task_key", "=", "incremental_capture")
+			.execute();
+	});
+
+	afterEach(async () => {
+		await teardownForDialect(ctx);
+		ctx = undefined;
+	});
+
+	it("registers the progress route", () => {
+		const routes: Array<{ pattern: string; entrypoint: string }> = [];
+		injectCoreRoutes((route) => routes.push(route));
+
+		expect(routes).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({
+					pattern: "/_emdash/api/admin/media-usage/progress",
+					entrypoint: expect.stringContaining("api/admin/media-usage/progress"),
+				}),
+			]),
+		);
+	});
+
+	it("requires authentication, schema permission, and admin token scope", async () => {
+		await expectError(await GET(routeContext(null)), 401, "UNAUTHORIZED");
+		await expectError(await GET(routeContext(Role.EDITOR)), 403, "FORBIDDEN");
+		await expectError(
+			await GET(routeContext(Role.ADMIN, ["content:read"])),
+			403,
+			"INSUFFICIENT_SCOPE",
+		);
+	});
+
+	it("returns aggregate readiness without exposing collection or work details", async () => {
+		const response = await GET(routeContext(Role.ADMIN, ["admin"]));
+
+		expect(response.status).toBe(200);
+		expect(response.headers.get("Cache-Control")).toBe("private, no-store");
+		const body = await response.json();
+		expect(body).toEqual({
+			success: true,
+			data: {
+				status: "ready",
+				readyCollections: 2,
+				totalCollections: 2,
+				indexingStarted: true,
+			},
+		});
+		expect(JSON.stringify(body)).not.toContain(collectionId);
+		expect(JSON.stringify(body)).not.toContain("post");
+	});
+
+	it("distinguishes indexing startup from a current reconciliation", async () => {
+		await ctx!.db
+			.updateTable("_emdash_media_usage_index_status")
+			.set({
+				status: "stale",
+				started_at: "2026-01-01T00:00:00.000Z",
+				schema_version: 0,
+				reconciliation_required: 1,
+			})
+			.execute();
+
+		const before = await GET(routeContext(Role.ADMIN, ["admin"]));
+		expect(await before.json()).toEqual({
+			success: true,
+			data: {
+				status: "indexing",
+				readyCollections: 0,
+				totalCollections: 2,
+				indexingStarted: false,
+			},
+		});
+
+		await ctx!.db
+			.insertInto("_emdash_media_usage_reconciliations")
+			.values({
+				collection_id: collectionId,
+				collection_slug: "post",
+				run_token: "current-run",
+				next_attempt_at: "2026-08-18T12:00:00.000Z",
+				updated_at: "2026-08-18T12:00:00.000Z",
+			})
+			.execute();
+
+		const after = await GET(routeContext(Role.ADMIN, ["admin"]));
+		expect(await after.json()).toEqual({
+			success: true,
+			data: {
+				status: "indexing",
+				readyCollections: 0,
+				totalCollections: 2,
+				indexingStarted: true,
+			},
+		});
+	});
+
+	it("rejects progress reads before activation is active", async () => {
+		await ctx!.db
+			.updateTable("_emdash_media_usage_activation")
+			.set({ state: "activating" })
+			.where("task_key", "=", "incremental_capture")
+			.execute();
+
+		await expectError(
+			await GET(routeContext(Role.ADMIN, ["admin"])),
+			409,
+			"MEDIA_USAGE_PROGRESS_NOT_ACTIVE",
+		);
+	});
+
+	it("rejects an incompatible activation runtime generation", async () => {
+		await ctx!.db
+			.updateTable("_emdash_media_usage_activation")
+			.set({ runtime_generation: 2 })
+			.where("task_key", "=", "incremental_capture")
+			.execute();
+
+		await expectError(
+			await GET(routeContext(Role.ADMIN, ["admin"])),
+			409,
+			"MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH",
+		);
+	});
+
+	it("returns a stable redacted read error", async () => {
+		await ctx!.db.schema.dropTable("_emdash_media_usage_index_status").execute();
+
+		const response = await GET(routeContext(Role.ADMIN, ["admin"]));
+		const body = await response.clone().json();
+
+		await expectError(response, 500, "MEDIA_USAGE_PROGRESS_READ_ERROR");
+		expect(JSON.stringify(body)).not.toContain("_emdash_media_usage_index_status");
+	});
+
+	function routeContext(role: RoleLevel | null, tokenScopes?: string[]): GetContext {
+		return {
+			request: new Request("http://localhost/_emdash/api/admin/media-usage/progress"),
+			locals: {
+				emdash: { db: ctx!.db },
+				user: role == null ? null : { id: "user-1", role },
+				tokenScopes,
+			},
+		} as GetContext;
+	}
+});
+
+async function expectError(response: Response, status: number, code: string): Promise<void> {
+	expect(response.status).toBe(status);
+	const body = (await response.json()) as { error: { code: string } };
+	expect(body.error.code).toBe(code);
+	expect(response.headers.get("Cache-Control")).toBe("private, no-store");
+}
diff --git a/packages/core/tests/unit/api/openapi.test.ts b/packages/core/tests/unit/api/openapi.test.ts
index 03db925cf9..e7ae865d61 100644
--- a/packages/core/tests/unit/api/openapi.test.ts
+++ b/packages/core/tests/unit/api/openapi.test.ts
@@ -159,6 +159,25 @@ describe("OpenAPI document generation", () => {
 		);
 	});
 
+	it("documents aggregate media usage indexing progress", () => {
+		const doc = generateOpenApiDocument();
+		const get = doc.paths?.["/_emdash/api/admin/media-usage/progress"]?.get as
+			| { operationId?: string; responses?: Record<string, unknown> }
+			| undefined;
+
+		expect(get?.operationId).toBe("getMediaUsageProgress");
+		expect(get?.responses).toEqual(
+			expect.objectContaining({
+				"200": expect.any(Object),
+				"401": expect.any(Object),
+				"403": expect.any(Object),
+				"409": expect.any(Object),
+				"500": expect.any(Object),
+			}),
+		);
+		expect(JSON.stringify(get?.responses?.["200"])).toContain("MediaUsageProgress");
+	});
+
 	it("includes schema paths", () => {
 		const doc = generateOpenApiDocument();
 		const paths = Object.keys(doc.paths ?? {});
diff --git a/packages/core/tests/unit/astro/middleware-prerender.test.ts b/packages/core/tests/unit/astro/middleware-prerender.test.ts
index 47808a9c59..f6711d36f5 100644
--- a/packages/core/tests/unit/astro/middleware-prerender.test.ts
+++ b/packages/core/tests/unit/astro/middleware-prerender.test.ts
@@ -25,6 +25,7 @@ const {
 	mockGetPluginRouteMeta,
 	mockHandlePluginApiRoute,
 	mockGetPublicUrl,
+	mockWakeMediaUsageMaintenance,
 } = vi.hoisted(() => {
 	const publicPluginResult = { success: true, data: { ok: true } };
 	const ok = async () => ({ success: true });
@@ -36,6 +37,7 @@ const {
 		return null;
 	});
 	const handlePluginApiRoute = vi.fn(async () => publicPluginResult);
+	const wakeMediaUsageMaintenance = vi.fn();
 
 	return {
 		MOCK_RUNTIME: {
@@ -90,11 +92,15 @@ const {
 			syncMarketplacePlugins: async () => undefined,
 			syncRegistryPlugins: async () => undefined,
 			setPluginStatus: async () => undefined,
+			wakeMediaUsageMaintenance() {
+				wakeMediaUsageMaintenance(this);
+			},
 		},
 		PUBLIC_PLUGIN_RESULT: publicPluginResult,
 		mockGetPluginRouteMeta: getPluginRouteMeta,
 		mockHandlePluginApiRoute: handlePluginApiRoute,
 		mockGetPublicUrl: getPublicUrl,
+		mockWakeMediaUsageMaintenance: wakeMediaUsageMaintenance,
 	};
 });
 
@@ -241,6 +247,7 @@ describe("astro middleware prerendered routes", () => {
 		mockGetPluginRouteMeta.mockClear();
 		mockHandlePluginApiRoute.mockClear();
 		mockGetPublicUrl.mockClear();
+		mockWakeMediaUsageMaintenance.mockClear();
 	});
 
 	it("does not access context.session on prerendered public runtime routes", async () => {
@@ -647,6 +654,24 @@ describe("astro middleware request-scoped db", () => {
 		expect(mockGetLastContentWriteAt).not.toHaveBeenCalled();
 	});
 
+	it("lets authenticated API routes wake Media Usage maintenance immediately", async () => {
+		const locals: Record<string, unknown> = {};
+		const { context } = createRequestContext({
+			url: "https://example.com/_emdash/api/admin/media-usage/activation",
+			method: "POST",
+			headers: { authorization: "Bearer ec_pat_example" },
+			locals,
+		});
+
+		await onRequest(context as Parameters<typeof onRequest>[0], async () => {
+			const emdash = locals.emdash as { wakeMediaUsageMaintenance: () => void };
+			emdash.wakeMediaUsageMaintenance();
+			return new Response("ok");
+		});
+
+		expect(mockWakeMediaUsageMaintenance).toHaveBeenCalledExactlyOnceWith(MOCK_RUNTIME);
+	});
+
 	it("forces isWrite true for POST requests on public pages", async () => {
 		const commit = vi.fn();
 		vi.mocked(createRequestScopedDb).mockReturnValue({
diff --git a/packages/core/tests/unit/client/client.test.ts b/packages/core/tests/unit/client/client.test.ts
index fc36e30bcf..55c1bbd6de 100644
--- a/packages/core/tests/unit/client/client.test.ts
+++ b/packages/core/tests/unit/client/client.test.ts
@@ -1021,6 +1021,30 @@ describe("EmDashClient", () => {
 	});
 
 	describe("media usage work operators", () => {
+		it("reads aggregate media usage indexing progress", async () => {
+			let capturedRequest: Request | undefined;
+			const progress = {
+				status: "indexing" as const,
+				readyCollections: 2,
+				totalCollections: 3,
+			};
+			const client = new EmDashClient({
+				baseUrl: "http://localhost:4321",
+				token: "test",
+				interceptors: [
+					async (request) => {
+						capturedRequest = request;
+						return jsonResponse(progress);
+					},
+				],
+			});
+			await expect(client.mediaGetUsageProgress()).resolves.toEqual(progress);
+			expect(capturedRequest?.method).toBe("GET");
+			expect(new URL(capturedRequest!.url).pathname).toBe(
+				"/_emdash/api/admin/media-usage/progress",
+			);
+		});
+
 		it("reads the redacted activation status", async () => {
 			let capturedRequest: Request | undefined;
 			const status = {
diff --git a/packages/core/tests/unit/plugins/node-cron-scheduler.test.ts b/packages/core/tests/unit/plugins/node-cron-scheduler.test.ts
new file mode 100644
index 0000000000..c88cf8fe73
--- /dev/null
+++ b/packages/core/tests/unit/plugins/node-cron-scheduler.test.ts
@@ -0,0 +1,217 @@
+import type { Kysely } from "kysely";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { Database } from "../../../src/database/types.js";
+import { CronExecutor } from "../../../src/plugins/cron.js";
+import { NodeCronScheduler } from "../../../src/plugins/scheduler/node.js";
+import { setupTestDatabase, teardownTestDatabase } from "../../utils/test-db.js";
+
+describe("NodeCronScheduler Media Usage continuation", () => {
+	let db: Kysely<Database>;
+	let executor: CronExecutor;
+	let scheduler: NodeCronScheduler;
+
+	beforeEach(async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-08-17T12:00:00.000Z"));
+		db = await setupTestDatabase();
+		executor = new CronExecutor(db, async () => {});
+		vi.spyOn(executor, "getNextDueTime").mockResolvedValue(null);
+		vi.spyOn(executor, "tick").mockResolvedValue(0);
+		vi.spyOn(executor, "recoverStaleLocks").mockResolvedValue(0);
+		scheduler = new NodeCronScheduler(executor);
+	});
+
+	afterEach(async () => {
+		scheduler.stop();
+		vi.useRealTimers();
+		await teardownTestDatabase(db);
+		vi.restoreAllMocks();
+	});
+
+	it("yields to a new timer turn between immediate units", async () => {
+		const maintenance = vi
+			.fn()
+			.mockResolvedValueOnce({ kind: "immediate" } as const)
+			.mockResolvedValueOnce({ kind: "none" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+		scheduler.wakeMediaUsageMaintenance();
+
+		await vi.advanceTimersByTimeAsync(0);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		await vi.advanceTimersToNextTimerAsync();
+		expect(maintenance).toHaveBeenCalledTimes(2);
+	});
+
+	it("starts Media Usage maintenance immediately when explicitly woken", async () => {
+		const maintenance = vi.fn().mockResolvedValue({ kind: "none" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+
+		scheduler.wakeMediaUsageMaintenance();
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(maintenance).toHaveBeenCalledOnce();
+	});
+
+	it("keeps the general heartbeat independent from Media Usage", async () => {
+		const maintenance = vi.fn().mockResolvedValue({ kind: "none" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+
+		await vi.advanceTimersToNextTimerAsync();
+
+		expect(executor.tick).toHaveBeenCalledOnce();
+		expect(maintenance).not.toHaveBeenCalled();
+	});
+
+	it("does not let heartbeats shorten a delayed continuation", async () => {
+		vi.mocked(executor.getNextDueTime).mockImplementation(async () =>
+			new Date(Date.now()).toISOString(),
+		);
+		const maintenance = vi
+			.fn()
+			.mockResolvedValueOnce({ kind: "delayed", delaySeconds: 30 } as const)
+			.mockResolvedValue({ kind: "none" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+		scheduler.wakeMediaUsageMaintenance();
+
+		await vi.advanceTimersByTimeAsync(0);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		await vi.advanceTimersByTimeAsync(29_000);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		await vi.advanceTimersByTimeAsync(1_000);
+		expect(maintenance).toHaveBeenCalledTimes(2);
+	});
+
+	it("lets an explicit wake replace a delayed continuation", async () => {
+		const maintenance = vi
+			.fn()
+			.mockResolvedValueOnce({ kind: "delayed", delaySeconds: 30 } as const)
+			.mockResolvedValue({ kind: "none" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+		scheduler.wakeMediaUsageMaintenance();
+
+		await vi.advanceTimersByTimeAsync(0);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		scheduler.wakeMediaUsageMaintenance();
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(maintenance).toHaveBeenCalledTimes(2);
+	});
+
+	it("keeps an explicit wake requested during a delayed in-flight unit", async () => {
+		let release!: () => void;
+		const held = new Promise<void>((resolve) => {
+			release = resolve;
+		});
+		const maintenance = vi
+			.fn()
+			.mockImplementationOnce(async () => {
+				await held;
+				return { kind: "delayed", delaySeconds: 30 } as const;
+			})
+			.mockResolvedValue({ kind: "none" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+		scheduler.wakeMediaUsageMaintenance();
+
+		await vi.advanceTimersByTimeAsync(0);
+		scheduler.wakeMediaUsageMaintenance();
+		release();
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(maintenance).toHaveBeenCalledTimes(2);
+	});
+
+	it("keeps general heartbeats independent from a held unit", async () => {
+		vi.mocked(executor.getNextDueTime).mockImplementation(async () =>
+			new Date(Date.now()).toISOString(),
+		);
+		let releaseFirst!: () => void;
+		const first = new Promise<void>((resolve) => {
+			releaseFirst = resolve;
+		});
+		let active = 0;
+		let maximumActive = 0;
+		const maintenance = vi.fn(async () => {
+			active++;
+			maximumActive = Math.max(maximumActive, active);
+			if (maintenance.mock.calls.length === 1) await first;
+			active--;
+			return { kind: "none" } as const;
+		});
+		const cleanup = vi.fn(async () => {});
+		scheduler.setSystemCleanup(cleanup);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+		scheduler.wakeMediaUsageMaintenance();
+
+		await vi.advanceTimersByTimeAsync(0);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		await vi.advanceTimersByTimeAsync(3_000);
+		expect(executor.tick).toHaveBeenCalledTimes(3);
+		expect(cleanup).toHaveBeenCalledTimes(3);
+		expect(maximumActive).toBe(1);
+
+		releaseFirst();
+		await vi.advanceTimersByTimeAsync(0);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		expect(maximumActive).toBe(1);
+	});
+
+	it("clears a pending continuation when stopped", async () => {
+		const maintenance = vi.fn().mockResolvedValue({ kind: "immediate" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+		scheduler.wakeMediaUsageMaintenance();
+
+		await vi.advanceTimersByTimeAsync(0);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		scheduler.stop();
+		await vi.runAllTimersAsync();
+		expect(maintenance).toHaveBeenCalledTimes(1);
+	});
+
+	it("unrefs Media Usage continuation timers", async () => {
+		const timeout = vi.spyOn(globalThis, "setTimeout");
+		const maintenance = vi.fn().mockResolvedValue({ kind: "none" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+		scheduler.wakeMediaUsageMaintenance();
+
+		await vi.advanceTimersByTimeAsync(0);
+		const mediaTimerIndex = timeout.mock.calls.findIndex((call) => call[1] === 0);
+		expect(mediaTimerIndex).toBeGreaterThanOrEqual(0);
+		expect(isUnreferencedTimer(timeout.mock.results[mediaTimerIndex]?.value)).toBe(true);
+	});
+
+	it("logs a failed unit once without heartbeat recovery", async () => {
+		const error = vi.spyOn(console, "error").mockImplementation(() => {});
+		const maintenance = vi
+			.fn()
+			.mockRejectedValueOnce(new Error("maintenance failed"))
+			.mockResolvedValue({ kind: "none" } as const);
+		scheduler.setContinuousMediaUsageMaintenance(maintenance);
+		scheduler.start();
+		scheduler.wakeMediaUsageMaintenance();
+
+		await vi.advanceTimersByTimeAsync(0);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		expect(error).toHaveBeenCalledTimes(1);
+		await vi.advanceTimersByTimeAsync(0);
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		await vi.advanceTimersToNextTimerAsync();
+		expect(maintenance).toHaveBeenCalledTimes(1);
+		expect(error).toHaveBeenCalledTimes(1);
+	});
+});
+
+function isUnreferencedTimer(value: unknown): boolean {
+	if (!value || typeof value !== "object" || !("hasRef" in value)) return false;
+	const hasRef = value.hasRef;
+	return typeof hasRef === "function" && hasRef.call(value) === false;
+}
diff --git a/packages/core/tests/workerd/media-usage-activation-d1.test.ts b/packages/core/tests/workerd/media-usage-activation-d1.test.ts
index 2fac11f356..0c00181091 100644
--- a/packages/core/tests/workerd/media-usage-activation-d1.test.ts
+++ b/packages/core/tests/workerd/media-usage-activation-d1.test.ts
@@ -5,6 +5,7 @@ import { afterAll, beforeAll, expect, it } from "vitest";
 
 import { EmDashD1Dialect, RawBindingD1Dialect } from "../../../cloudflare/src/db/d1-dialect.js";
 import { GET, POST } from "../../src/astro/routes/api/admin/media-usage/activation.js";
+import { GET as GET_PROGRESS } from "../../src/astro/routes/api/admin/media-usage/progress.js";
 import { runMigrations } from "../../src/database/migrations/runner.js";
 import type { Database } from "../../src/database/types.js";
 import { MEDIA_USAGE_ACTIVATION_RUNTIME_GENERATION } from "../../src/media/usage/activation.js";
@@ -58,6 +59,8 @@ it("keeps complete authenticated activation route costs within the D1 envelope",
 	await record("get-activating", "session", GET, activationGet(), 200, evidence);
 	await record("final-collection", "session", POST, activationPost(), 200, evidence);
 	await record("get-active", "raw", GET, activationGet(), 200, evidence);
+	await record("progress-indexing", "session", GET_PROGRESS, progressGet(), 200, evidence);
+	expect(evidence.at(-1)).toEqual(expect.objectContaining({ queries: 1, rowsWritten: 0 }));
 	await record("active-idempotent", "session", POST, activationPost(), 200, evidence);
 
 	await adminDb
@@ -143,6 +146,10 @@ function activationPost(): Request {
 	});
 }
 
+function progressGet(): Request {
+	return new Request("http://localhost/_emdash/api/admin/media-usage/progress");
+}
+
 async function resetActivation(state: "expanded" | "activating", cursor: string | null) {
 	await adminDb
 		.updateTable("_emdash_media_usage_activation")
diff --git a/packages/core/tests/workerd/media-usage-maintenance-engine-d1.test.ts b/packages/core/tests/workerd/media-usage-maintenance-engine-d1.test.ts
new file mode 100644
index 0000000000..dba98c415c
--- /dev/null
+++ b/packages/core/tests/workerd/media-usage-maintenance-engine-d1.test.ts
@@ -0,0 +1,337 @@
+import { env } from "cloudflare:test";
+import { Kysely, sql } from "kysely";
+import { afterAll, beforeAll, expect, it } from "vitest";
+
+import { RawBindingD1Dialect } from "../../../cloudflare/src/db/d1-dialect.js";
+import { createRequestScopedDb } from "../../../cloudflare/src/db/d1.js";
+import { kyselyLogOption } from "../../src/database/instrumentation.js";
+import { runMigrations } from "../../src/database/migrations/runner.js";
+import { MediaUsageRepository } from "../../src/database/repositories/media-usage.js";
+import type { Database } from "../../src/database/types.js";
+import {
+	MEDIA_USAGE_MAINTENANCE_LIMITS,
+	runMediaUsageMaintenanceSlice,
+	runMediaUsageMaintenanceStep,
+} from "../../src/media/usage/maintenance-engine.js";
+import { createRequestMetrics, runWithContext } from "../../src/request-context.js";
+import { SchemaRegistry } from "../../src/schema/registry.js";
+import {
+	createMediaUsageAdmissionFixture,
+	insertMediaUsageMeasurementEntry,
+	mediaUsageMeasurementData,
+} from "../utils/media-usage-admission-fixture.js";
+
+declare module "cloudflare:test" {
+	interface ProvidedEnv {
+		DB: D1Database;
+	}
+}
+
+interface D1Measurement {
+	queries: number;
+	rowsRead: number;
+	rowsWritten: number;
+	durationMs: number;
+	wallDurationMs: number;
+	maxBinds: number;
+	maxSqlBytes: number;
+}
+
+let adminDb: Kysely<Database>;
+
+beforeAll(async () => {
+	adminDb = new Kysely<Database>({
+		dialect: new RawBindingD1Dialect({ database: env.DB }),
+	});
+	await runMigrations(adminDb);
+});
+
+afterAll(async () => {
+	await adminDb.destroy();
+});
+
+it("keeps full-repair source lookups within D1 value limits", async () => {
+	const collectionId = "collection-" + "x".repeat(40);
+	const sourceKeys = Array.from(
+		{ length: 50_000 },
+		(_, index) => `content:${collectionId}:${String(index).padStart(8, "0")}:draft_overlay`,
+	);
+
+	await expect(new MediaUsageRepository(adminDb).findSources(sourceKeys)).resolves.toEqual(
+		new Map(),
+	);
+});
+
+it("keeps the largest entry step below the shared reservation", async () => {
+	const fixture = await createMediaUsageAdmissionFixture(adminDb, "d1_engine_boundary");
+	await adminDb
+		.updateTable("_emdash_media_usage_activation")
+		.set({ state: "active" })
+		.where("task_key", "=", "incremental_capture")
+		.execute();
+	await insertMediaUsageMeasurementEntry(
+		adminDb,
+		fixture,
+		"boundary-entry",
+		mediaUsageMeasurementData(500, "boundary-entry"),
+	);
+
+	const measurement = emptyMeasurement();
+	const db = new Kysely<Database>({
+		dialect: new RawBindingD1Dialect({ database: captureD1(env.DB, measurement) }),
+		log: kyselyLogOption(),
+	});
+	const startedAt = performance.now();
+	const result = await runMediaUsageMaintenanceStep(db);
+	measurement.wallDurationMs = Number((performance.now() - startedAt).toFixed(3));
+	await db.destroy();
+
+	expect(result).toEqual({
+		state: "progress",
+		continuation: { kind: "immediate" },
+	});
+	expect(measurement.queries).toBeLessThanOrEqual(MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries);
+	expect(measurement.maxBinds).toBeLessThanOrEqual(100);
+	expect(measurement.maxSqlBytes).toBeLessThan(100 * 1024);
+	expect(measurement.wallDurationMs).toBeLessThan(5_000);
+	console.info(`PR8_D1_MAINTENANCE_STEP=${JSON.stringify(measurement)}`);
+});
+
+it("drains several durable units without exceeding one D1 event", async () => {
+	const fixture = await createMediaUsageAdmissionFixture(adminDb, "d1_engine_slice");
+	await adminDb
+		.updateTable("_emdash_media_usage_activation")
+		.set({ state: "active" })
+		.where("task_key", "=", "incremental_capture")
+		.execute();
+	for (let index = 0; index < 5; index++) {
+		await insertMediaUsageMeasurementEntry(
+			adminDb,
+			fixture,
+			`slice-entry-${index}`,
+			mediaUsageMeasurementData(index, `slice-entry-${index}`),
+		);
+	}
+
+	const measurement = emptyMeasurement();
+	const db = new Kysely<Database>({
+		dialect: new RawBindingD1Dialect({ database: captureD1(env.DB, measurement) }),
+		log: kyselyLogOption(),
+	});
+	const metrics = createRequestMetrics(performance.now());
+	const startedAt = performance.now();
+	const continuation = await runWithContext({ editMode: false, metrics }, () =>
+		runMediaUsageMaintenanceSlice(db),
+	);
+	measurement.wallDurationMs = Number((performance.now() - startedAt).toFixed(3));
+	const sliceQueryCount = measurement.queries;
+	const remaining = await db
+		.selectFrom("_emdash_media_usage_work")
+		.select((eb) => eb.fn.countAll<number>().as("count"))
+		.where("collection_id", "=", fixture.collectionId)
+		.executeTakeFirstOrThrow();
+	await db.destroy();
+
+	expect(continuation).toEqual({ kind: "none" });
+	expect(Number(remaining.count)).toBe(0);
+	expect(metrics.dbCount).toBe(sliceQueryCount);
+	expect(sliceQueryCount).toBeLessThanOrEqual(MEDIA_USAGE_MAINTENANCE_LIMITS.eventQueryCeiling);
+	expect(measurement.maxBinds).toBeLessThanOrEqual(100);
+	expect(measurement.maxSqlBytes).toBeLessThan(100 * 1024);
+	expect(measurement.wallDurationMs).toBeLessThan(25_000);
+	console.info(`PR8_D1_MAINTENANCE_SLICE=${JSON.stringify(measurement)}`);
+});
+
+it("drains several durable units through the deployed D1 session path", async () => {
+	const fixture = await createMediaUsageAdmissionFixture(adminDb, "d1_session_engine_slice");
+	await adminDb
+		.updateTable("_emdash_media_usage_activation")
+		.set({ state: "active" })
+		.where("task_key", "=", "incremental_capture")
+		.execute();
+	for (let index = 0; index < 5; index++) {
+		await insertMediaUsageMeasurementEntry(
+			adminDb,
+			fixture,
+			`session-slice-entry-${index}`,
+			mediaUsageMeasurementData(index, `session-slice-entry-${index}`),
+		);
+	}
+
+	const scoped = createRequestScopedDb({
+		config: { binding: "DB", session: "auto" },
+		isAuthenticated: false,
+		isWrite: true,
+		cookies: { get: () => undefined, set: () => {} },
+		url: new URL("https://queue.emdash.internal/"),
+	});
+	if (!scoped) throw new Error("Expected a D1 session-scoped database");
+	const metrics = createRequestMetrics(performance.now());
+	const continuation = await runWithContext({ editMode: false, metrics }, () =>
+		runMediaUsageMaintenanceSlice(scoped.db),
+	);
+	const remaining = await adminDb
+		.selectFrom("_emdash_media_usage_work")
+		.select((eb) => eb.fn.countAll<number>().as("count"))
+		.where("collection_id", "=", fixture.collectionId)
+		.executeTakeFirstOrThrow();
+	scoped.commit();
+	await scoped.db.destroy();
+
+	expect(continuation).toEqual({ kind: "none" });
+	expect(metrics.dbCount).toBeGreaterThan(0);
+	expect(Number(remaining.count)).toBe(0);
+});
+
+it("runs one complete batch when a database does not report query metrics", async () => {
+	const fixture = await createMediaUsageAdmissionFixture(adminDb, "d1_engine_unmetered");
+	await adminDb
+		.updateTable("_emdash_media_usage_activation")
+		.set({ state: "active" })
+		.where("task_key", "=", "incremental_capture")
+		.execute();
+	for (let index = 0; index < 2; index++) {
+		await insertMediaUsageMeasurementEntry(
+			adminDb,
+			fixture,
+			`unmetered-entry-${index}`,
+			mediaUsageMeasurementData(0, `unmetered-entry-${index}`),
+		);
+	}
+
+	const db = new Kysely<Database>({
+		dialect: new RawBindingD1Dialect({ database: env.DB }),
+	});
+	const metrics = createRequestMetrics(performance.now());
+	const continuation = await runWithContext({ editMode: false, metrics }, () =>
+		runMediaUsageMaintenanceSlice(db),
+	);
+	const remaining = await db
+		.selectFrom("_emdash_media_usage_work")
+		.select((eb) => eb.fn.countAll<number>().as("count"))
+		.where("collection_id", "=", fixture.collectionId)
+		.executeTakeFirstOrThrow();
+	await db.destroy();
+
+	expect(continuation).toEqual({ kind: "immediate" });
+	expect(metrics.dbCount).toBe(0);
+	expect(Number(remaining.count)).toBe(0);
+});
+
+it("keeps the largest admitted activation trigger replacement inside one step", async () => {
+	await adminDb
+		.updateTable("_emdash_media_usage_activation")
+		.set({
+			state: "expanded",
+			collection_cursor: null,
+			drain_confirmed_at: null,
+			lease_token: null,
+			lease_expires_at: null,
+			last_error_code: null,
+		})
+		.where("task_key", "=", "incremental_capture")
+		.execute();
+	const collection = await new SchemaRegistry(adminDb).createCollection({
+		slug: "aaa_d1_activation_bound",
+		label: "Activation bound",
+	});
+	for (let index = 0; index < 100; index++) {
+		const triggerName = `emdash_mu_bound_${String(index).padStart(3, "0")}`;
+		await sql`
+			CREATE TRIGGER ${sql.ref(triggerName)}
+			AFTER INSERT ON ${sql.ref("ec_aaa_d1_activation_bound")}
+			BEGIN
+				SELECT 1;
+			END
+		`.execute(adminDb);
+	}
+	await adminDb
+		.updateTable("_emdash_media_usage_activation")
+		.set({
+			state: "activating",
+			drain_confirmed_at: "2026-08-18T12:00:00.000Z",
+		})
+		.where("task_key", "=", "incremental_capture")
+		.execute();
+
+	const measurement = emptyMeasurement();
+	const db = new Kysely<Database>({
+		dialect: new RawBindingD1Dialect({ database: captureD1(env.DB, measurement) }),
+		log: kyselyLogOption(),
+	});
+	const metrics = createRequestMetrics(performance.now());
+	const result = await runWithContext({ editMode: false, metrics }, () =>
+		runMediaUsageMaintenanceStep(db),
+	);
+	const status = await adminDb
+		.selectFrom("_emdash_media_usage_index_status")
+		.select("capture_state")
+		.where("collection_id", "=", collection.id)
+		.executeTakeFirstOrThrow();
+	await db.destroy();
+
+	expect(result).toEqual({
+		state: "progress",
+		continuation: { kind: "immediate" },
+	});
+	expect(status.capture_state).toBe("active");
+	expect(measurement.queries).toBeLessThanOrEqual(MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries);
+	expect(metrics.dbCount).toBe(measurement.queries);
+});
+
+function emptyMeasurement(): D1Measurement {
+	return {
+		queries: 0,
+		rowsRead: 0,
+		rowsWritten: 0,
+		durationMs: 0,
+		wallDurationMs: 0,
+		maxBinds: 0,
+		maxSqlBytes: 0,
+	};
+}
+
+function captureD1(database: D1Database, measurement: D1Measurement): D1Database {
+	return new Proxy(database, {
+		get(target, property) {
+			if (property === "prepare") {
+				return (query: string) => captureStatement(target.prepare(query), query, [], measurement);
+			}
+			const value: unknown = Reflect.get(target, property, target);
+			return typeof value === "function" ? value.bind(target) : value;
+		},
+	});
+}
+
+function captureStatement(
+	statement: D1PreparedStatement,
+	query: string,
+	binds: unknown[],
+	measurement: D1Measurement,
+): D1PreparedStatement {
+	return new Proxy(statement, {
+		get(target, property) {
+			if (property === "bind") {
+				return (...values: unknown[]) =>
+					captureStatement(target.bind(...values), query, values, measurement);
+			}
+			if (property === "all") {
+				return async <T>() => {
+					measurement.queries++;
+					measurement.maxBinds = Math.max(measurement.maxBinds, binds.length);
+					measurement.maxSqlBytes = Math.max(
+						measurement.maxSqlBytes,
+						new TextEncoder().encode(query).byteLength,
+					);
+					const result = await target.all<T>();
+					measurement.rowsRead += result.meta.rows_read;
+					measurement.rowsWritten += result.meta.rows_written;
+					measurement.durationMs += result.meta.duration;
+					return result;
+				};
+			}
+			const value: unknown = Reflect.get(target, property, target);
+			return typeof value === "function" ? value.bind(target) : value;
+		},
+	});
+}
diff --git a/packages/core/tests/workerd/media-usage-projection-admission-d1.test.ts b/packages/core/tests/workerd/media-usage-projection-admission-d1.test.ts
index 6997e707a9..bf618f38c0 100644
--- a/packages/core/tests/workerd/media-usage-projection-admission-d1.test.ts
+++ b/packages/core/tests/workerd/media-usage-projection-admission-d1.test.ts
@@ -60,14 +60,13 @@ it("reports real D1 metadata for the approved full runtime boundary", async () =
 
 	const measurement = await measure(() =>
 		runtime.handleContentUpdate(fixture.collectionSlug, created.data.item.id, {
-			data: mediaUsageMeasurementData(12, "boundary-d1-draft"),
+			data: mediaUsageMeasurementData(500, "boundary-d1-draft"),
 		}),
 	);
 	expect(measurement.value.success).toBe(true);
-	expect(measurement.d1Queries).toBeLessThanOrEqual(40);
-	// The collection/source cleanup cursors add one index write for this source
-	// and each of its 12 occurrences; keep the bound exact so further growth fails.
-	expect(measurement.rowsWritten).toBeLessThanOrEqual(135);
+	expect(measurement.d1Queries).toBeLessThanOrEqual(150);
+	expect(measurement.rowsWritten).toBeLessThanOrEqual(5_000);
+	expect(measurement.wallDurationMs).toBeLessThan(5_000);
 	expect(measurement.maxBinds).toBeLessThanOrEqual(100);
 	expect(measurement.maxSqlBytes).toBeLessThan(100 * 1024);
 	const { value: _value, ...evidence } = measurement;
diff --git a/templates/blog-cloudflare/src/worker.ts b/templates/blog-cloudflare/src/worker.ts
index 75fe3e2743..942774f85b 100644
--- a/templates/blog-cloudflare/src/worker.ts
+++ b/templates/blog-cloudflare/src/worker.ts
@@ -1,8 +1,18 @@
-import handler, { createScheduledHandler, PluginBridge } from "@emdash-cms/cloudflare/worker";
+import handler, {
+	createMediaUsageQueueHandler,
+	createMediaUsageFetchHandler,
+	createScheduledHandler,
+	type MediaUsageWakeMessage,
+	PluginBridge,
+} from "@emdash-cms/cloudflare/worker";
 
 export { PluginBridge };
 
+const resolveMediaUsageQueue = (env: Env) => env.MEDIA_USAGE_QUEUE;
+
 export default {
 	...handler,
+	fetch: createMediaUsageFetchHandler(handler, resolveMediaUsageQueue),
 	scheduled: createScheduledHandler(),
-};
+	queue: createMediaUsageQueueHandler(resolveMediaUsageQueue),
+} satisfies ExportedHandler<Env, MediaUsageWakeMessage>;
diff --git a/templates/blog-cloudflare/tsconfig.json b/templates/blog-cloudflare/tsconfig.json
index 0903753115..c2e1508a58 100644
--- a/templates/blog-cloudflare/tsconfig.json
+++ b/templates/blog-cloudflare/tsconfig.json
@@ -3,5 +3,5 @@
 	"compilerOptions": {
 		"types": ["node"]
 	},
-	"include": ["src", ".astro/types.d.ts", "emdash-env.d.ts"]
+	"include": ["src", ".astro/types.d.ts", "emdash-env.d.ts", "worker-configuration.d.ts"]
 }
diff --git a/templates/blog-cloudflare/worker-configuration.d.ts b/templates/blog-cloudflare/worker-configuration.d.ts
index 8d6646e145..0f021c3461 100644
--- a/templates/blog-cloudflare/worker-configuration.d.ts
+++ b/templates/blog-cloudflare/worker-configuration.d.ts
@@ -5,6 +5,7 @@ declare namespace Cloudflare {
 	interface Env {
 		MEDIA: R2Bucket;
 		DB: D1Database;
+		MEDIA_USAGE_QUEUE: Queue;
 	}
 }
 interface Env extends Cloudflare.Env {}
diff --git a/templates/blog-cloudflare/wrangler.jsonc b/templates/blog-cloudflare/wrangler.jsonc
index 23632b0e98..612917c615 100644
--- a/templates/blog-cloudflare/wrangler.jsonc
+++ b/templates/blog-cloudflare/wrangler.jsonc
@@ -22,8 +22,28 @@
 			"binding": "LOADER",
 		},
 	],
+	"queues": {
+		"producers": [
+			{
+				"binding": "MEDIA_USAGE_QUEUE",
+				"queue": "my-emdash-site-media-usage",
+			},
+		],
+		"consumers": [
+			{
+				"queue": "my-emdash-site-media-usage",
+				"max_batch_size": 1,
+				"max_batch_timeout": 0,
+				"max_retries": 3,
+				"max_concurrency": 1,
+			},
+		],
+	},
+	"limits": {
+		"cpu_ms": 300000,
+	},
 	// General maintenance plus the bounded Media Usage lane (see src/worker.ts)
 	"triggers": {
-		"crons": ["* * * * *", "*/2 * * * *"],
+		"crons": ["* * * * *"],
 	},
 }
diff --git a/templates/marketing-cloudflare/src/worker.ts b/templates/marketing-cloudflare/src/worker.ts
index 75fe3e2743..942774f85b 100644
--- a/templates/marketing-cloudflare/src/worker.ts
+++ b/templates/marketing-cloudflare/src/worker.ts
@@ -1,8 +1,18 @@
-import handler, { createScheduledHandler, PluginBridge } from "@emdash-cms/cloudflare/worker";
+import handler, {
+	createMediaUsageQueueHandler,
+	createMediaUsageFetchHandler,
+	createScheduledHandler,
+	type MediaUsageWakeMessage,
+	PluginBridge,
+} from "@emdash-cms/cloudflare/worker";
 
 export { PluginBridge };
 
+const resolveMediaUsageQueue = (env: Env) => env.MEDIA_USAGE_QUEUE;
+
 export default {
 	...handler,
+	fetch: createMediaUsageFetchHandler(handler, resolveMediaUsageQueue),
 	scheduled: createScheduledHandler(),
-};
+	queue: createMediaUsageQueueHandler(resolveMediaUsageQueue),
+} satisfies ExportedHandler<Env, MediaUsageWakeMessage>;
diff --git a/templates/marketing-cloudflare/worker-configuration.d.ts b/templates/marketing-cloudflare/worker-configuration.d.ts
index 8d6646e145..0f021c3461 100644
--- a/templates/marketing-cloudflare/worker-configuration.d.ts
+++ b/templates/marketing-cloudflare/worker-configuration.d.ts
@@ -5,6 +5,7 @@ declare namespace Cloudflare {
 	interface Env {
 		MEDIA: R2Bucket;
 		DB: D1Database;
+		MEDIA_USAGE_QUEUE: Queue;
 	}
 }
 interface Env extends Cloudflare.Env {}
diff --git a/templates/marketing-cloudflare/wrangler.jsonc b/templates/marketing-cloudflare/wrangler.jsonc
index e5e23e764d..7a23587099 100644
--- a/templates/marketing-cloudflare/wrangler.jsonc
+++ b/templates/marketing-cloudflare/wrangler.jsonc
@@ -22,8 +22,28 @@
 			"binding": "LOADER",
 		},
 	],
+	"queues": {
+		"producers": [
+			{
+				"binding": "MEDIA_USAGE_QUEUE",
+				"queue": "my-marketing-site-media-usage",
+			},
+		],
+		"consumers": [
+			{
+				"queue": "my-marketing-site-media-usage",
+				"max_batch_size": 1,
+				"max_batch_timeout": 0,
+				"max_retries": 3,
+				"max_concurrency": 1,
+			},
+		],
+	},
+	"limits": {
+		"cpu_ms": 300000,
+	},
 	// General maintenance plus the bounded Media Usage lane (see src/worker.ts)
 	"triggers": {
-		"crons": ["* * * * *", "*/2 * * * *"],
+		"crons": ["* * * * *"],
 	},
 }
diff --git a/templates/portfolio-cloudflare/src/worker.ts b/templates/portfolio-cloudflare/src/worker.ts
index 75fe3e2743..942774f85b 100644
--- a/templates/portfolio-cloudflare/src/worker.ts
+++ b/templates/portfolio-cloudflare/src/worker.ts
@@ -1,8 +1,18 @@
-import handler, { createScheduledHandler, PluginBridge } from "@emdash-cms/cloudflare/worker";
+import handler, {
+	createMediaUsageQueueHandler,
+	createMediaUsageFetchHandler,
+	createScheduledHandler,
+	type MediaUsageWakeMessage,
+	PluginBridge,
+} from "@emdash-cms/cloudflare/worker";
 
 export { PluginBridge };
 
+const resolveMediaUsageQueue = (env: Env) => env.MEDIA_USAGE_QUEUE;
+
 export default {
 	...handler,
+	fetch: createMediaUsageFetchHandler(handler, resolveMediaUsageQueue),
 	scheduled: createScheduledHandler(),
-};
+	queue: createMediaUsageQueueHandler(resolveMediaUsageQueue),
+} satisfies ExportedHandler<Env, MediaUsageWakeMessage>;
diff --git a/templates/portfolio-cloudflare/worker-configuration.d.ts b/templates/portfolio-cloudflare/worker-configuration.d.ts
index 8d6646e145..0f021c3461 100644
--- a/templates/portfolio-cloudflare/worker-configuration.d.ts
+++ b/templates/portfolio-cloudflare/worker-configuration.d.ts
@@ -5,6 +5,7 @@ declare namespace Cloudflare {
 	interface Env {
 		MEDIA: R2Bucket;
 		DB: D1Database;
+		MEDIA_USAGE_QUEUE: Queue;
 	}
 }
 interface Env extends Cloudflare.Env {}
diff --git a/templates/portfolio-cloudflare/wrangler.jsonc b/templates/portfolio-cloudflare/wrangler.jsonc
index 792c1fda4d..4f400bd911 100644
--- a/templates/portfolio-cloudflare/wrangler.jsonc
+++ b/templates/portfolio-cloudflare/wrangler.jsonc
@@ -22,8 +22,28 @@
 			"binding": "LOADER",
 		},
 	],
+	"queues": {
+		"producers": [
+			{
+				"binding": "MEDIA_USAGE_QUEUE",
+				"queue": "my-portfolio-site-media-usage",
+			},
+		],
+		"consumers": [
+			{
+				"queue": "my-portfolio-site-media-usage",
+				"max_batch_size": 1,
+				"max_batch_timeout": 0,
+				"max_retries": 3,
+				"max_concurrency": 1,
+			},
+		],
+	},
+	"limits": {
+		"cpu_ms": 300000,
+	},
 	// General maintenance plus the bounded Media Usage lane (see src/worker.ts)
 	"triggers": {
-		"crons": ["* * * * *", "*/2 * * * *"],
+		"crons": ["* * * * *"],
 	},
 }
diff --git a/templates/starter-cloudflare/src/worker.ts b/templates/starter-cloudflare/src/worker.ts
index 75fe3e2743..942774f85b 100644
--- a/templates/starter-cloudflare/src/worker.ts
+++ b/templates/starter-cloudflare/src/worker.ts
@@ -1,8 +1,18 @@
-import handler, { createScheduledHandler, PluginBridge } from "@emdash-cms/cloudflare/worker";
+import handler, {
+	createMediaUsageQueueHandler,
+	createMediaUsageFetchHandler,
+	createScheduledHandler,
+	type MediaUsageWakeMessage,
+	PluginBridge,
+} from "@emdash-cms/cloudflare/worker";
 
 export { PluginBridge };
 
+const resolveMediaUsageQueue = (env: Env) => env.MEDIA_USAGE_QUEUE;
+
 export default {
 	...handler,
+	fetch: createMediaUsageFetchHandler(handler, resolveMediaUsageQueue),
 	scheduled: createScheduledHandler(),
-};
+	queue: createMediaUsageQueueHandler(resolveMediaUsageQueue),
+} satisfies ExportedHandler<Env, MediaUsageWakeMessage>;
diff --git a/templates/starter-cloudflare/tsconfig.json b/templates/starter-cloudflare/tsconfig.json
index 0903753115..c2e1508a58 100644
--- a/templates/starter-cloudflare/tsconfig.json
+++ b/templates/starter-cloudflare/tsconfig.json
@@ -3,5 +3,5 @@
 	"compilerOptions": {
 		"types": ["node"]
 	},
-	"include": ["src", ".astro/types.d.ts", "emdash-env.d.ts"]
+	"include": ["src", ".astro/types.d.ts", "emdash-env.d.ts", "worker-configuration.d.ts"]
 }
diff --git a/templates/starter-cloudflare/worker-configuration.d.ts b/templates/starter-cloudflare/worker-configuration.d.ts
index 8d6646e145..0f021c3461 100644
--- a/templates/starter-cloudflare/worker-configuration.d.ts
+++ b/templates/starter-cloudflare/worker-configuration.d.ts
@@ -5,6 +5,7 @@ declare namespace Cloudflare {
 	interface Env {
 		MEDIA: R2Bucket;
 		DB: D1Database;
+		MEDIA_USAGE_QUEUE: Queue;
 	}
 }
 interface Env extends Cloudflare.Env {}
diff --git a/templates/starter-cloudflare/wrangler.jsonc b/templates/starter-cloudflare/wrangler.jsonc
index 23632b0e98..612917c615 100644
--- a/templates/starter-cloudflare/wrangler.jsonc
+++ b/templates/starter-cloudflare/wrangler.jsonc
@@ -22,8 +22,28 @@
 			"binding": "LOADER",
 		},
 	],
+	"queues": {
+		"producers": [
+			{
+				"binding": "MEDIA_USAGE_QUEUE",
+				"queue": "my-emdash-site-media-usage",
+			},
+		],
+		"consumers": [
+			{
+				"queue": "my-emdash-site-media-usage",
+				"max_batch_size": 1,
+				"max_batch_timeout": 0,
+				"max_retries": 3,
+				"max_concurrency": 1,
+			},
+		],
+	},
+	"limits": {
+		"cpu_ms": 300000,
+	},
 	// General maintenance plus the bounded Media Usage lane (see src/worker.ts)
 	"triggers": {
-		"crons": ["* * * * *", "*/2 * * * *"],
+		"crons": ["* * * * *"],
 	},
 }