@growth-labs/cms 0.8.1 → 0.8.3

package/src/engine/fronts-publish.ts

@@ -24,7 +24,14 @@
 // additive and gated by FRONTS_PUBLISH_ENABLED (default ON — a rollback lever,
 // not a dark-staging gate).
 
+import type { LlmDispatch } from '../providers/types.js'
 import type { ContentType, FrontsPublishStatus } from '../schema/types.js'
+import {
+	applyGeneratedContentDek,
+	generateContentDekSuggestion,
+	loadDekGenerationContextFromSnapshot,
+} from './ai-dek.js'
+import { parseLockedFields } from './ai-writeback.js'
 import type { D1Database } from './d1.js'
 import { FrontsScheduleOverflowError } from './fronts-publish-intent.js'
 import { podcastPublishBlocker } from './podcast-source.js'
@@ -35,6 +42,7 @@ import {
 	snapshotRecord,
 } from './publication-current-guard.js'
 import { getContentSnapshot } from './publisher.js'
+import { getRevision } from './revisions.js'
 
 /** The five lifecycle states foundryd reports for a Fronts publish intent. */
 export const FRONTS_PUBLISH_STATUSES: readonly FrontsPublishStatus[] = [
@@ -161,6 +169,8 @@ export interface FrontsPublishCallbackInput {
 	now?: number
 	/** Optional occurrence evidence carried by current publish workers. */
 	publishAt?: number | null
+	/** Optional existing CMS LLM hook for best-effort missing-dek generation. */
+	llm?: LlmDispatch
 	/** The route supplies the same host hook used by the editorial publish action. */
 	checkReadiness?: (item: {
 		id: string
@@ -183,6 +193,10 @@ export interface FrontsPublishCallbackResult {
 	ledgerError: string | null
 	/** A retryable hold or stale/cancelled snapshot; never consumes event_id. */
 	rejection?: { code: string; status: 404 | 409 | 503; blockers?: string[]; message: string }
+	/** Safe post-commit reason for a missing-dek editor notification. */
+	dekFailureReason?: 'ai_generation_unavailable' | 'ai_generation_timeout' | null
+	/** Existing lifecycle payload fields, present only for this call's committed publication. */
+	publishedItem?: { id: string; type: ContentType; title: string } | null
 }
 
 function hasReceipt(receipt: FrontsPublishReceipt | null | undefined): boolean {
@@ -210,6 +224,8 @@ function resolveOccurredAtSeconds(
 	return Math.min(seconds, now)
 }
 
+class DekGenerationTimeoutError extends Error {}
+
 /**
  * Apply one foundryd publish-callback. Idempotent by `event_id`: a repeat
  * delivery returns the stored outcome without re-applying. See the module
@@ -250,6 +266,8 @@ export async function applyFrontsPublishCallback(
 	let published = item.status === 'published'
 	let attemptId: string | null = null
 	let ledgerError: string | null = null
+	let committedDekFailureReason: FrontsPublishCallbackResult['dekFailureReason'] = null
+	let committedPublishedItem: FrontsPublishCallbackResult['publishedItem'] = null
 	const shouldPublish = input.status === 'live' && hasReceipt(input.receipt)
 	if (shouldPublish && item.status === 'published') {
 		const current = await getContentSnapshot(db, input.contentId)
@@ -326,9 +344,88 @@ export async function applyFrontsPublishCallback(
 				['publish_not_due'],
 			)
 		}
+		let dekFailureReason: FrontsPublishCallbackResult['dekFailureReason'] = null
+		const initialExcerpt =
+			typeof expectedItem.excerpt === 'string' ? expectedItem.excerpt.trim() : ''
+		const initialLocks = parseLockedFields(
+			typeof expectedItem.ai_locked_fields === 'string' ? expectedItem.ai_locked_fields : null,
+		)
+		if (!initialExcerpt && !initialLocks.includes('excerpt')) {
+			if (!input.llm) {
+				dekFailureReason = 'ai_generation_unavailable'
+			} else {
+				const deadlineAt = performance.now() + 8_000
+				let timeout: ReturnType<typeof setTimeout> | undefined
+				try {
+					const generated = await Promise.race([
+						(async () => {
+							const context = await loadDekGenerationContextFromSnapshot(db, expectedSnapshot)
+							if (!context) {
+								return {
+									context: null,
+									suggestion: {
+										status: 'unavailable' as const,
+										dek: null,
+										reason: 'unavailable',
+									},
+								}
+							}
+							return {
+								context,
+								suggestion: await generateContentDekSuggestion({
+									context,
+									llm: input.llm!,
+								}),
+							}
+						})(),
+						new Promise<never>((_resolve, rejectTimeout) => {
+							timeout = setTimeout(() => rejectTimeout(new DekGenerationTimeoutError()), 8_000)
+						}),
+					])
+					if (generated.suggestion.status !== 'generated') {
+						dekFailureReason = 'ai_generation_unavailable'
+					} else if (!generated.context || performance.now() >= deadlineAt) {
+						dekFailureReason = 'ai_generation_timeout'
+					} else {
+						const applied = await applyGeneratedContentDek({
+							db,
+							contentId: input.contentId,
+							dek: generated.suggestion.dek,
+							context: generated.context,
+							expectedPublicationSnapshot: expectedSnapshot,
+						})
+						if (applied.status === 'unavailable') dekFailureReason = 'ai_generation_unavailable'
+					}
+				} catch (error) {
+					dekFailureReason =
+						error instanceof DekGenerationTimeoutError
+							? 'ai_generation_timeout'
+							: 'ai_generation_unavailable'
+				} finally {
+					if (timeout !== undefined) clearTimeout(timeout)
+				}
+			}
+		}
+
+		const currentSnapshot = await getContentSnapshot(db, input.contentId)
+		try {
+			assertCurrentPublicationSnapshot(currentSnapshot ?? {}, expectedSnapshot)
+		} catch {
+			return reject(
+				'publish_snapshot_changed',
+				409,
+				'Scheduled content or media changed before publication.',
+			)
+		}
+		const currentItem = snapshotRecord(currentSnapshot?.item)
+		const currentExcerpt = typeof currentItem.excerpt === 'string' ? currentItem.excerpt.trim() : ''
+		const currentLocks = parseLockedFields(
+			typeof currentItem.ai_locked_fields === 'string' ? currentItem.ai_locked_fields : null,
+		)
+		if (currentExcerpt || currentLocks.includes('excerpt')) dekFailureReason = null
 		const blocker =
-			expectedItem.type === 'podcast'
-				? podcastPublishBlocker(snapshotRecord(expectedSnapshot.content))
+			currentItem.type === 'podcast'
+				? podcastPublishBlocker(snapshotRecord(currentSnapshot?.content))
 				: null
 		if (blocker) return reject('publish_not_ready', 503, blocker.message, [blocker.code])
 		if (input.checkReadiness) {
@@ -337,7 +434,7 @@ export async function applyFrontsPublishCallback(
 				const readiness = await Promise.race([
 					input.checkReadiness({
 						id: input.contentId,
-						type: expectedItem.type as ContentType,
+						type: currentItem.type as ContentType,
 						status: 'scheduled',
 					}),
 					new Promise<never>((_resolve, rejectTimeout) => {
@@ -378,11 +475,29 @@ export async function applyFrontsPublishCallback(
 				...(publishedAt !== null ? { publishedAt } : {}),
 				createdBy: 'foundry.fronts-publish',
 				surfaces: [surface],
-				expectedCurrentSnapshot: expectedSnapshot,
+				expectedCurrentSnapshot: currentSnapshot!,
 				expectedReceiptIdentity: receiptIdentity,
 			})
 			attemptId = receipt.attemptId
 			published = true
+			const committedRevision = await getRevision(db, input.contentId, receipt.revisionId)
+			if (attemptId && committedRevision) {
+				const committedItem = snapshotRecord(committedRevision.payload.item)
+				const committedExcerpt =
+					typeof committedItem.excerpt === 'string' ? committedItem.excerpt.trim() : ''
+				const committedLocks = parseLockedFields(
+					typeof committedItem.ai_locked_fields === 'string'
+						? committedItem.ai_locked_fields
+						: null,
+				)
+				committedDekFailureReason =
+					committedExcerpt || committedLocks.includes('excerpt') ? null : dekFailureReason
+				committedPublishedItem = {
+					id: String(committedItem.id ?? input.contentId),
+					type: committedItem.type as ContentType,
+					title: String(committedItem.title ?? ''),
+				}
+			}
 		} catch (error) {
 			// A concurrently published row may belong to a newer editor/source
 			// revision. Only a matching committed snapshot and full receipt prove
@@ -496,6 +611,8 @@ export async function applyFrontsPublishCallback(
 		attemptId,
 		contentFound: true,
 		ledgerError,
+		dekFailureReason: committedDekFailureReason,
+		publishedItem: committedPublishedItem,
 	}
 }
 

package/src/engine/index.ts

@@ -78,6 +78,7 @@ export type { D1Database, D1DatabaseSession, D1PreparedStatement, D1Result } fro
 export {
 	applyFoundryCallback,
 	type CallbackInput,
+	createFoundrySourceCaptureToken,
 	type DispatchResult,
 	dispatchToFoundry,
 	type ProcessingState,

package/src/engine/podcast-source.ts

@@ -9,19 +9,21 @@ export interface FrontsPodcastSourceSnapshot {
 }
 
 /**
- * Stable over polling, machine media callbacks and rescheduling. Canonical
- * editor/source changes invalidate the old production. Neither the raw source
+ * V1 captures keep their canonical-version binding. New v2 captures remain
+ * stable over editorial metadata edits, polling, callbacks and rescheduling;
+ * source/slug/token changes invalidate production. Neither the raw source
  * token nor URL needs to appear in callback/notification identities.
  */
 export async function frontsPodcastSourceGeneration(
 	input: FrontsPodcastSourceSnapshot,
 ): Promise<string> {
+	const version = input.processing_trigger_token?.startsWith('fronts-source-v2:') ? 2 : 1
 	const bytes = new TextEncoder().encode(
 		JSON.stringify([
-			'fronts-podcast-source.v1',
+			`fronts-podcast-source.v${version}`,
 			input.content_id,
 			input.slug,
-			input.canonical_version,
+			...(version === 1 ? [input.canonical_version] : []),
 			input.processing_source_url,
 			input.processing_source_kind,
 			input.processing_trigger_token,

package/src/engine/publisher.ts

@@ -793,7 +793,10 @@ export async function updateContentItem(
 	// Resolve all media identity/duration invariants before the base content row,
 	// tags, or relations can be mutated. D1 does not provide a transaction on the
 	// structural surface used here, so validation must be a strict preflight.
-	if (input.content && existing.type === 'video') {
+	if (
+		(input.content || input.slug !== undefined || input.visibility !== undefined) &&
+		existing.type === 'video'
+	) {
 		const current = await db
 			.prepare(
 				`SELECT script, video_id, duration_seconds, thumbnail_image_id,
@@ -813,7 +816,7 @@ export async function updateContentItem(
 			}>()
 
 		if (current) {
-			const videoContent = input.content as Partial<VideoInput['content']>
+			const videoContent = (input.content ?? {}) as Partial<VideoInput['content']>
 			const sourceUrl = hasOwn(videoContent, 'processingSourceUrl')
 				? (videoContent.processingSourceUrl ?? null)
 				: current.processing_source_url
@@ -851,14 +854,19 @@ export async function updateContentItem(
 					: current.thumbnail_image_id,
 				sourceUrl,
 				sourceKind,
-				sourceChanged,
+				sourceChanged:
+					sourceChanged ||
+					resolvedDuration !== current.duration_seconds ||
+					(input.slug !== undefined && input.slug !== existing.slug) ||
+					(input.visibility !== undefined && input.visibility !== existing.visibility) ||
+					(hasOwn(videoContent, 'videoId') && videoContent.videoId !== current.video_id),
 			}
 		} else {
 			videoUpdatePlan = null
 		}
 	}
 
-	if (input.content && existing.type === 'podcast') {
+	if ((input.content || input.slug !== undefined) && existing.type === 'podcast') {
 		const current = await db
 			.prepare(
 				`SELECT transcript, audio_r2_key, duration_seconds, processing_trigger_token,
@@ -878,7 +886,7 @@ export async function updateContentItem(
 			}>()
 
 		if (current) {
-			const podcastContent = input.content as Partial<PodcastInput['content']>
+			const podcastContent = (input.content ?? {}) as Partial<PodcastInput['content']>
 			const audioR2Key = hasOwn(podcastContent, 'audioR2Key')
 				? (podcastContent.audioR2Key ?? current.audio_r2_key)
 				: current.audio_r2_key
@@ -910,9 +918,13 @@ export async function updateContentItem(
 					)
 			const replacementTranscriptProvided =
 				hasOwn(podcastContent, 'transcript') && typeof podcastContent.transcript === 'string'
+			const preparationChanged =
+				sourceChanged ||
+				resolvedDuration !== current.duration_seconds ||
+				(input.slug !== undefined && input.slug !== existing.slug)
 
 			podcastUpdatePlan = {
-				transcript: sourceChanged
+				transcript: preparationChanged
 					? replacementTranscriptProvided
 						? (podcastContent.transcript as string)
 						: ''
@@ -924,7 +936,7 @@ export async function updateContentItem(
 					durationProvided || sourceChanged
 						? resolvedDuration
 						: (resolvedDuration ?? current.duration_seconds),
-				processingTriggerToken: sourceChanged ? null : current.processing_trigger_token,
+				processingTriggerToken: preparationChanged ? null : current.processing_trigger_token,
 				sourceUrl,
 				sourceKind,
 			}
@@ -1196,7 +1208,7 @@ export async function updateContentItem(
 	}
 	if (!options.expectedMediaSource) await updateBaseContent()
 
-	if (input.content) {
+	if (input.content || videoUpdatePlan || podcastUpdatePlan) {
 		if (isBodyBackedContentType(existing.type)) {
 			const current = await db
 				.prepare(

package/src/engine/soft-delete.ts

@@ -1,4 +1,21 @@
-import type { D1Database } from './d1.js'
+import type { D1Database, D1PreparedStatement } from './d1.js'
+
+/** V2 metadata-stable captures must not survive an invalidating lifecycle transition. */
+export function invalidateMediaCaptureStatements(
+	db: D1Database,
+	id: string,
+): D1PreparedStatement[] {
+	return [
+		db
+			.prepare(`UPDATE video_content SET processing_trigger_token = NULL, processing_correlation_id = NULL
+			WHERE content_id = ? AND processing_trigger_token LIKE 'fronts-source-v2:%'`)
+			.bind(id),
+		db
+			.prepare(`UPDATE podcast_content SET processing_trigger_token = NULL
+			WHERE content_id = ? AND processing_trigger_token LIKE 'fronts-source-v2:%'`)
+			.bind(id),
+	]
+}
 
 export async function softDeleteContent(
 	db: D1Database,
@@ -6,13 +23,16 @@ export async function softDeleteContent(
 	now?: number,
 ): Promise<boolean> {
 	const ts = now ?? Math.floor(Date.now() / 1000)
-	const res = await db
-		.prepare(
-			'UPDATE content_items SET deleted_at = ?, updated_at = unixepoch(), canonical_version = canonical_version + 1 WHERE id = ? AND deleted_at IS NULL',
-		)
-		.bind(ts, id)
-		.run()
-	return Boolean(res.meta && (res.meta as { changes?: number }).changes)
+	const results = await db.batch([
+		...invalidateMediaCaptureStatements(db, id),
+		db
+			.prepare(
+				'UPDATE content_items SET deleted_at = ?, updated_at = unixepoch(), canonical_version = canonical_version + 1 WHERE id = ? AND deleted_at IS NULL',
+			)
+			.bind(ts, id),
+	])
+	const res = results[2]
+	return Boolean(res?.meta && (res.meta as { changes?: number }).changes)
 }
 
 export async function restoreContent(db: D1Database, id: string): Promise<boolean> {

package/src/engine/video-source.ts

@@ -9,8 +9,10 @@ export interface FrontsVideoSourceSnapshot {
 }
 
 /**
- * Stable over polling, machine media callbacks and rescheduling; canonical
- * editor/source changes invalidate the old production. The raw trigger token
+ * V1 captures retain their original canonical-version binding. New v2 capture
+ * tokens separate media identity from editorial revisions: a title/body edit
+ * or reschedule cannot cancel useful media work. Slug/source/token changes
+ * still change the generation. The raw trigger token
  * and URL never need to appear in callback or notification identities. The
  * Go consumer's contract is `fronts-video-source.v1` (foundry
  * `publishplane/masthead/videosource.schema.json`, exported by
@@ -19,12 +21,13 @@ export interface FrontsVideoSourceSnapshot {
 export async function frontsVideoSourceGeneration(
 	input: FrontsVideoSourceSnapshot,
 ): Promise<string> {
+	const version = input.processing_trigger_token?.startsWith('fronts-source-v2:') ? 2 : 1
 	const bytes = new TextEncoder().encode(
 		JSON.stringify([
-			'fronts-video-source.v1',
+			`fronts-video-source.v${version}`,
 			input.content_id,
 			input.slug,
-			input.canonical_version,
+			...(version === 1 ? [input.canonical_version] : []),
 			input.processing_source_url,
 			input.processing_source_kind,
 			input.processing_trigger_token,

package/src/integration/index.ts

@@ -111,6 +111,13 @@ export default function growthLabsCms(userOptions: CmsIntegrationOptions): Astro
 					pattern: `${base}/api/content/insights-ingest`,
 					entrypoint: resolveEntrypoint('../ui/api/content/insights-ingest'),
 				})
+				// Author denylist + existing-content coverage index for foundryd's
+				// weekly content-insights funnel (W1-07 PR 6) — M2M poll, HMAC-guarded
+				// same as fronts/schedule below, sibling of insights-ingest.
+				injectRoute({
+					pattern: `${base}/api/content/insights-inputs`,
+					entrypoint: resolveEntrypoint('../ui/api/content/insights-inputs'),
+				})
 				// Fronts publish path (additive, flag-gated) — M2M siblings of the
 				// foundry-callback / insights-ingest routes. HMAC-guarded.
 				injectRoute({

package/src/routes/content-insights.ts

@@ -13,6 +13,10 @@ import { InsightDismissalReasonCodeSchema } from '../schema/types.js'
 import type { CmsRouteConfig } from './config.js'
 import { resolveConfig } from './config.js'
 import { json, type RouteContext } from './context.js'
+import {
+	resolveFoundryHmacSecret as resolveFoundryHmacSecretForInputs,
+	verifyFoundrySignedRequest,
+} from './fronts-publish.js'
 
 const DismissSchema = z
 	.object({
@@ -72,8 +76,32 @@ export interface ContentInsightsRouteHandlers {
 	undismiss(ctx: RouteContext): Promise<Response>
 	/** POST /content/insights-ingest — HMAC machine ingest (replay-safe replace). */
 	ingest(ctx: RouteContext): Promise<Response>
+	/**
+	 * GET /content/insights-inputs?site=<id> — the funnel's author denylist +
+	 * existing-content coverage index for this site, read by foundryd's
+	 * sitebrain.insights.run schedule (W1-07 PR 6). Same M2M signing family as
+	 * fronts/schedule (X-Foundry-Timestamp + X-Foundry-Signature over the raw
+	 * query string, verified against FOUNDRY_HMAC_SECRET) -- a sibling poll,
+	 * not a new auth scheme.
+	 */
+	insightsInputs(ctx: RouteContext): Promise<Response>
 }
 
+/** authors row shape this route returns: just enough for the author denylist,
+ * never email/bio/social -- the funnel matches on name/slug only. */
+const AUTHORS_QUERY = 'SELECT name, slug FROM authors ORDER BY name LIMIT 1000'
+
+/**
+ * Existing-content index for lexical coverage: every content item an editor
+ * could currently be working on or has already shipped, so the funnel can
+ * skip a candidate that duplicates it. status/deleted_at match the-foundry's
+ * own SiteContentItemSchema (content-insights/ledger.ts, read-only) exactly,
+ * so this row shape ports verbatim.
+ */
+const EXISTING_CONTENT_QUERY = `SELECT title, slug FROM content_items
+	WHERE status IN ('published', 'draft', 'scheduled', 'review') AND deleted_at IS NULL
+	LIMIT 5000`
+
 export function createContentInsightsRoutes(
 	config: ContentInsightsRouteConfig,
 ): ContentInsightsRouteHandlers {
@@ -181,5 +209,38 @@ export function createContentInsightsRoutes(
 				throw error
 			}
 		},
+
+		// HMAC-guarded machine poll -- NOT behind requirePublisher, same M2M
+		// family as fronts/schedule (timestamp-bound signature over the query
+		// string; a GET has no body to bind freshness to instead).
+		async insightsInputs(ctx) {
+			const hmacSecret = await resolveFoundryHmacSecretForInputs(ctx.env)
+			if (!hmacSecret) return json({ error: 'FOUNDRY_HMAC_SECRET is not configured' }, 500)
+
+			const url = new URL(ctx.request.url)
+			const denied = await verifyFoundrySignedRequest(
+				ctx.request,
+				hmacSecret,
+				url.search,
+				'content/insights-inputs',
+			)
+			if (denied) return denied
+
+			const requestedSite = url.searchParams.get('site')
+			const authorsResult = await ctx.db.prepare(AUTHORS_QUERY).all<{
+				name: string
+				slug: string
+			}>()
+			const existingResult = await ctx.db.prepare(EXISTING_CONTENT_QUERY).all<{
+				title: string
+				slug: string
+			}>()
+			return json({
+				ok: true,
+				site: requestedSite ?? siteId,
+				authors: authorsResult.results ?? [],
+				existing: existingResult.results ?? [],
+			})
+		},
 	}
 }

package/src/routes/content.ts

@@ -33,6 +33,10 @@ import {
 	type ProcessingState,
 	verifyHmac,
 } from '../engine/foundry-dispatch.js'
+import {
+	parseFrontsDefaultChannelTargets,
+	setFrontsChannelTargets,
+} from '../engine/fronts-publish-intent.js'
 import { evaluateArticleBody } from '../engine/publish-guard.js'
 import {
 	createContent,
@@ -55,7 +59,7 @@ import {
 	restoreRevision,
 } from '../engine/revisions.js'
 import { applySlugRenameRedirects } from '../engine/slug-redirects.js'
-import { softDeleteContent } from '../engine/soft-delete.js'
+import { invalidateMediaCaptureStatements, softDeleteContent } from '../engine/soft-delete.js'
 import { normalizeSourceSections } from '../engine/source-sections.js'
 import { TagInputError } from '../engine/taxonomy.js'
 import type { ValidationError } from '../engine/validator/index.js'
@@ -190,7 +194,23 @@ export type PublishReadinessHook = (input: {
 	status: string
 }) => Promise<PublishReadinessOutcome>
 
+export type FrontsScheduleMaintenanceOperation =
+	| 'recover-video-sources'
+	| 'reconcile-article-enrichment'
+
+/** Host-owned bounded recovery/repair work invoked by the signed Fronts schedule route. */
+export type FrontsScheduleMaintenanceHook = (input: {
+	ctx: RouteContext
+	operation: FrontsScheduleMaintenanceOperation
+	limit: 3 | 5
+	signal: AbortSignal
+}) => Promise<{ contentIds: string[] }>
+
 export interface ContentRouteConfig extends CmsRouteConfig {
+	/** Host-configured publish destinations; only absent stored targets are armed. No global default. */
+	frontsDefaultChannelTargets?: readonly string[]
+	/** Optional host-owned bounded recovery/repair hook for the signed schedule POST. */
+	frontsScheduleMaintenance?: FrontsScheduleMaintenanceHook
 	/** Optional Foundry takeaways dispatcher (bead 08). Omit to disable. */
 	dispatchTakeaways?: DispatchTakeawaysHook
 	/** Optional FAQ enrichment dispatcher (P4 Task 7). Omit to disable. */
@@ -836,6 +856,17 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 	const dispatchWebhook = config.dispatchWebhook
 	const publishReadiness = config.publishReadiness
 	const activeWorkspaceId = config.activeWorkspaceId ?? 'default'
+	const targetDefaults =
+		config.frontsDefaultChannelTargets === undefined
+			? null
+			: parseFrontsDefaultChannelTargets(config.frontsDefaultChannelTargets)
+	const defaultTargetsError = () =>
+		targetDefaults && 'error' in targetDefaults ? json({ error: targetDefaults.error }, 500) : null
+	async function armDefaultTargets(ctx: RouteContext, contentId: string): Promise<void> {
+		if (targetDefaults && 'targets' in targetDefaults) {
+			await setFrontsChannelTargets(ctx.db, contentId, targetDefaults.targets, { onlyIfNull: true })
+		}
+	}
 
 	async function loadStoredMediaSource(
 		db: D1Database,
@@ -1305,6 +1336,8 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			}
 
 			if (op === 'schedule') {
+				const configError = defaultTargetsError()
+				if (configError) return configError
 				const { publishAt } = parsed.data
 				const publishAtMs = Date.parse(publishAt)
 				if (!Number.isFinite(publishAtMs)) {
@@ -1313,6 +1346,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				const publishAtSeconds = Math.floor(publishAtMs / 1000)
 				for (const id of ids) {
 					await scheduleContent(ctx.db, id, publishAtSeconds)
+					await armDefaultTargets(ctx, id)
 				}
 				return json({ scheduled: ids })
 			}
@@ -1329,6 +1363,8 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			const ownAuthor = actor?.subject ?? ctx.userId ?? null
 			const denied = await requireContentAction(ctx, 'write', ownAuthor)
 			if (denied) return denied
+			const configError = defaultTargetsError()
+			if (configError) return configError
 
 			const parsed = CreateSchema.safeParse(await readJson(ctx))
 			if (!parsed.success) {
@@ -1360,6 +1396,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				if (conflict) return conflict
 				throw error
 			}
+			await armDefaultTargets(ctx, created.id)
 			const podcastAttempt: PodcastFoundryAttempt =
 				parsed.data.type === 'podcast'
 					? await dispatchPodcastAfterSave(ctx, created.id)
@@ -1484,6 +1521,8 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			if (config.updateStatusConstraint && existing.status !== config.updateStatusConstraint) {
 				return json({ error: 'update_status_conflict', state: existing.status }, 409)
 			}
+			const configError = defaultTargetsError()
+			if (configError) return configError
 
 			const parsed = UpdateSchema.safeParse(await readJson(ctx))
 			if (!parsed.success) {
@@ -1607,6 +1646,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			if (updated.mediaSourceConflict) {
 				return json({ error: 'media_source_conflict' }, 409)
 			}
+			await armDefaultTargets(ctx, id)
 			const podcastAttempt: PodcastFoundryAttempt =
 				existing.type === 'podcast'
 					? await dispatchPodcastAfterSave(ctx, id)
@@ -1649,6 +1689,8 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			if (denied) return denied
 
 			if (action === 'schedule') {
+				const configError = defaultTargetsError()
+				if (configError) return configError
 				const parsed = ScheduleSchema.safeParse(await readJson(ctx))
 				if (!parsed.success) {
 					return json({ error: 'Invalid request', details: parsed.error.flatten() }, 400)
@@ -1680,6 +1722,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				}
 
 				await scheduleContent(ctx.db, id, publishAtSeconds as number, publishTimeZone)
+				await armDefaultTargets(ctx, id)
 
 				// Fire content.scheduled webhook.
 				await fireWebhook(ctx, 'content.scheduled', {
@@ -1895,12 +1938,14 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			}
 
 			if (action === 'archive') {
-				await ctx.db
-					.prepare(
-						"UPDATE content_items SET status = 'archived', updated_at = unixepoch(), canonical_version = canonical_version + 1 WHERE id = ? AND status <> 'archived'",
-					)
-					.bind(id)
-					.run()
+				await ctx.db.batch([
+					...invalidateMediaCaptureStatements(ctx.db, id),
+					ctx.db
+						.prepare(
+							"UPDATE content_items SET status = 'archived', updated_at = unixepoch(), canonical_version = canonical_version + 1 WHERE id = ? AND status <> 'archived'",
+						)
+						.bind(id),
+				])
 
 				// Fire content.deleted (archive = soft delete lifecycle) webhook.
 				await fireWebhook(ctx, 'content.deleted', {
@@ -2005,36 +2050,16 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 				if (!resolved.hooks.foundryVideo) {
 					return json({ error: 'Foundry video dispatch is not configured' }, 501)
 				}
-				if (existing.type === 'podcast') {
-					const row = await ctx.db
-						.prepare(
-							`SELECT processing_trigger_token
-							FROM podcast_content
-							WHERE content_id = ?
-							LIMIT 1`,
-						)
-						.bind(id)
-						.first<{ processing_trigger_token: string | null }>()
-					const existingToken = row?.processing_trigger_token?.trim() ?? ''
-					if (existingToken) {
-						return json(
-							{
-								status: 'queued',
-								correlationId: null,
-								triggerToken: existingToken,
-								skipped: true,
-							},
-							202,
-						)
-					}
-				}
 				try {
-					const result = await dispatchToFoundry(ctx.db, id, resolved.hooks.foundryVideo)
+					const result = await dispatchToFoundry(ctx.db, id, resolved.hooks.foundryVideo, {
+						ifUncaptured: url.searchParams.get('capture') === '1',
+					})
 					return json(
 						{
 							status: 'queued',
 							correlationId: result.correlationId,
 							triggerToken: result.triggerToken,
+							...(result.skipped ? { skipped: true } : {}),
 						},
 						202,
 					)