emdash 0.35.0 → 0.37.0

package/src/media/usage/extractor.ts

@@ -37,13 +37,7 @@ export function extractMediaUsageOccurrences({
 		const value = data[field.slug];
 
 		if (field.type === "image") {
-			addOccurrence(occurrences, seen, {
-				fieldSlug: field.slug,
-				fieldPath: field.slug,
-				referenceType: "image_field",
-				value,
-				fallbackKind: "image",
-			});
+			addImageOccurrences(occurrences, seen, field.slug, field.slug, value);
 			continue;
 		}
 
@@ -86,17 +80,42 @@ function extractRepeaterOccurrences(
 		for (const subField of subFields) {
 			if (subField.type !== "image") continue;
 
-			addOccurrence(occurrences, seen, {
+			addImageOccurrences(
+				occurrences,
+				seen,
 				fieldSlug,
-				fieldPath: `${fieldSlug}[${itemIndex}].${subField.slug}`,
-				referenceType: "image_field",
-				value: item[subField.slug],
-				fallbackKind: "image",
-			});
+				`${fieldSlug}[${itemIndex}].${subField.slug}`,
+				item[subField.slug],
+			);
 		}
 	}
 }
 
+function addImageOccurrences(
+	occurrences: ExtractedMediaUsageOccurrence[],
+	seen: Set<string>,
+	fieldSlug: string,
+	fieldPath: string,
+	value: unknown,
+): void {
+	addOccurrence(occurrences, seen, {
+		fieldSlug,
+		fieldPath,
+		referenceType: "image_field",
+		value,
+		fallbackKind: "image",
+	});
+	if (isRecord(value) && value.darkVariant != null) {
+		addOccurrence(occurrences, seen, {
+			fieldSlug,
+			fieldPath: `${fieldPath}.darkVariant`,
+			referenceType: "image_field",
+			value: value.darkVariant,
+			fallbackKind: "image",
+		});
+	}
+}
+
 function extractPortableTextOccurrences(
 	occurrences: ExtractedMediaUsageOccurrence[],
 	seen: Set<string>,

package/src/media/usage/maintenance-engine.ts

@@ -0,0 +1,166 @@
+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,
+});
+
+const TASK_CLASSES: readonly MediaUsageMaintenanceTaskClass[] = [
+	"collection_deletion",
+	"entry_work",
+	"reconciliation",
+];
+
+export async function runMediaUsageMaintenanceStep(
+	db: Kysely<Database>,
+): Promise<MediaUsageMaintenanceStepResult> {
+	const activation = 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);
+	}
+	let blocked = false;
+	let blockedReconciliation = false;
+	let madeProgress = false;
+
+	for (const taskClass of TASK_CLASSES) {
+		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);
+		if (outcome === "inactive") return inactiveResult();
+		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;
+	}
+}
+
+async function runTaskClass(
+	db: Kysely<Database>,
+	taskClass: MediaUsageMaintenanceTaskClass,
+): Promise<"inactive" | "idle" | "blocked" | "progress"> {
+	if (taskClass === "entry_work") {
+		const result = await processDueMediaUsageWork(db, {
+			activationKnownActive: 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: { dbCount: number }): boolean {
+	return (
+		metrics.dbCount + MEDIA_USAGE_MAINTENANCE_LIMITS.maxStepQueries <=
+		MEDIA_USAGE_MAINTENANCE_LIMITS.eventQueryCeiling
+	);
+}

package/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);

package/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));
@@ -482,6 +487,12 @@ export class MediaUsageReconciliationRepository {
 			.where("status.collection_id", "=", collectionId)
 			.where("status.status", "=", "running")
 			.where("status.cursor", "=", runToken)
+			.where(sql<boolean>`status.change_epoch = (
+				SELECT reconciliation.target_epoch
+				FROM _emdash_media_usage_reconciliations AS reconciliation
+				WHERE reconciliation.collection_id = ${collectionId}
+					AND reconciliation.run_token = ${runToken}
+			)`)
 			.where((eb) =>
 				eb.exists(
 					eb
@@ -751,6 +762,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
@@ -1005,7 +1080,15 @@ export class MediaUsageReconciliationRepository {
 						.where("status.scope_type", "=", COLLECTION_SCOPE)
 						.where("status.capture_state", "=", "active")
 						.where("status.reconciliation_required", "=", 1)
-						.where("status.cursor", "is", null)
+						.where((status) =>
+							status.or([
+								status("status.cursor", "is", null),
+								status.and([
+									status("status.status", "=", "running"),
+									status("status.cursor", "=", runToken),
+								]),
+							]),
+						)
 						.where("status.change_epoch", ">", targetEpoch),
 				),
 			)