@growth-labs/cms 0.8.2 → 0.8.3

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/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,
 					)

package/src/routes/context.ts

@@ -119,6 +119,12 @@ export interface Authz {
 export interface RouteContext {
 	/** The inbound request (standard Fetch `Request`). */
 	request: Request
+	/**
+	 * Host-supplied execution-lifetime bridge. Maintenance-capable adapters
+	 * provide this so abort cleanup can settle after the HTTP response; adapters
+	 * must bind methods that depend on their original receiver.
+	 */
+	waitUntil?: (promise: Promise<unknown>) => void
 	/** Route params (e.g. `{ id }` for `/content/[id]`). */
 	params: Record<string, string | undefined>
 	/** The site's D1 binding. */

package/src/routes/fronts-publish.ts

@@ -2,6 +2,7 @@
 // the out-of-process Fronts publish worker (foundryd) drives:
 //
 //   GET  /admin/api/fronts/schedule?window=<from>..<to>  — the poll surface.
+//   POST /admin/api/fronts/schedule                    — bounded schedule maintenance.
 //   POST /admin/api/fronts/publish-callback              — the callback receiver.
 //
 // AUTH reuses the existing M2M primitive (`verifyHmac` + `X-Foundry-Signature`
@@ -18,11 +19,12 @@
 // CONSTANT — so one captured URL+header pair would be a permanent bearer
 // credential for the pre-publication embargo schedule.
 //
-// Both endpoints ship ENABLED behind FRONTS_PUBLISH_ENABLED (a rollback lever,
+// The endpoints ship ENABLED behind FRONTS_PUBLISH_ENABLED (a rollback lever,
 // default ON). Failures are loud: bad/stale HMAC → 401 + warn log; a `live`
 // callback that cannot commit through the ledger → 500 + error log; disabled → 503.
 
 import { z } from 'zod'
+import { createDekFailureNotifications } from '../engine/ai-dek-notifications.js'
 import { verifyHmac } from '../engine/foundry-dispatch.js'
 import {
 	applyFrontsPublishCallback,
@@ -30,12 +32,19 @@ import {
 	listFrontsPublishSchedule,
 } from '../engine/fronts-publish.js'
 import {
+	backfillFrontsChannelTargets,
 	FrontsScheduleOverflowError,
+	hydrateFrontsMediaPreparations,
 	hydrateFrontsPublishIntents,
+	parseFrontsDefaultChannelTargets,
 } from '../engine/fronts-publish-intent.js'
 import { publicUrlFor } from '../ui/screens/public-url.js'
 import { resolveConfig } from './config.js'
-import type { ContentRouteConfig } from './content.js'
+import type {
+	ContentRouteConfig,
+	FrontsScheduleMaintenanceHook,
+	FrontsScheduleMaintenanceOperation,
+} from './content.js'
 import { json, type RouteContext } from './context.js'
 
 /**
@@ -130,9 +139,92 @@ const CallbackSchema = z
 	})
 	.strip()
 
+const ArmChannelTargetsSchema = z
+	.object({
+		operation: z.literal('arm-channel-targets'),
+		limit: z.number().int().min(1).max(50).default(50),
+	})
+	.strict()
+
+const FrontsScheduleMaintenanceSchema = z.union([
+	z
+		.object({
+			operation: z.literal('recover-video-sources'),
+			limit: z.literal(3).default(3),
+		})
+		.strict(),
+	z
+		.object({
+			operation: z.literal('reconcile-article-enrichment'),
+			limit: z.literal(5).default(5),
+		})
+		.strict(),
+])
+
+const FRONTS_SCHEDULE_MAINTENANCE_TIMEOUT_MS = 25_000
+
+class FrontsScheduleMaintenanceTimeoutError extends Error {}
+
+function isMaintenanceOperation(value: unknown): value is FrontsScheduleMaintenanceOperation {
+	return value === 'recover-video-sources' || value === 'reconcile-article-enrichment'
+}
+
+function validateMaintenanceResult(result: unknown, limit: 3 | 5): { contentIds: string[] } | null {
+	const parsed = z
+		.object({
+			contentIds: z.array(z.string().refine((id) => id.trim().length > 0)).max(limit),
+		})
+		.strict()
+		.safeParse(result)
+	if (!parsed.success || new Set(parsed.data.contentIds).size !== parsed.data.contentIds.length)
+		return null
+	return parsed.data
+}
+
+async function runScheduleMaintenance(
+	ctx: RouteContext,
+	hook: FrontsScheduleMaintenanceHook,
+	operation: FrontsScheduleMaintenanceOperation,
+	limit: 3 | 5,
+): Promise<{ contentIds: string[] }> {
+	const controller = new AbortController()
+	let rejectDeadline: (error: FrontsScheduleMaintenanceTimeoutError) => void = () => undefined
+	let deadlineReached = false
+	const deadline = new Promise<never>((_resolve, reject) => {
+		rejectDeadline = reject
+	})
+	const abort = () => {
+		if (deadlineReached) return
+		deadlineReached = true
+		rejectDeadline(new FrontsScheduleMaintenanceTimeoutError())
+		controller.abort()
+	}
+	if (ctx.request.signal.aborted) abort()
+	else ctx.request.signal.addEventListener('abort', abort, { once: true })
+	const timer = setTimeout(abort, FRONTS_SCHEDULE_MAINTENANCE_TIMEOUT_MS)
+	const work = Promise.resolve().then(() =>
+		hook({ ctx, operation, limit, signal: controller.signal }),
+	)
+	// Keep the already-running hook alive through abort cleanup while observing
+	// either settlement so a late private rejection cannot escape the runtime.
+	const observedWork = work.then(
+		() => undefined,
+		() => undefined,
+	)
+	ctx.waitUntil?.(observedWork)
+	try {
+		return await Promise.race([work, deadline])
+	} finally {
+		clearTimeout(timer)
+		ctx.request.signal.removeEventListener('abort', abort)
+	}
+}
+
 export interface FrontsPublishRouteHandlers {
 	/** GET /fronts/schedule?window=<from>..<to> — items due for foundryd to publish. */
 	schedule(ctx: RouteContext): Promise<Response>
+	/** POST /fronts/schedule — bounded target arming or host-owned maintenance. */
+	maintainSchedule(ctx: RouteContext): Promise<Response>
 	/** POST /fronts/publish-callback — foundryd's outbound lifecycle callback. */
 	publishCallback(ctx: RouteContext): Promise<Response>
 }
@@ -164,6 +256,90 @@ function parseWindow(
 export function createFrontsPublishRoutes(config: ContentRouteConfig): FrontsPublishRouteHandlers {
 	const resolved = resolveConfig(config)
 	return {
+		async maintainSchedule(ctx) {
+			let responseOperation: 'arm-channel-targets' | FrontsScheduleMaintenanceOperation =
+				'arm-channel-targets'
+			const respond = (body: Record<string, unknown>, status = 200) =>
+				json({ version: 1, operation: responseOperation, ...body }, status)
+			const hmacSecret = await resolveFoundryHmacSecret(ctx.env)
+			if (!hmacSecret)
+				return respond({ ok: false, error: 'foundry_hmac_secret_not_configured' }, 500)
+			let rawBody: string
+			try {
+				rawBody = await ctx.request.text()
+			} catch {
+				return respond({ ok: false, error: 'invalid_channel_targets_request' }, 400)
+			}
+			const denied = await verifyFoundrySignedRequest(
+				ctx.request,
+				hmacSecret,
+				rawBody,
+				'fronts/schedule.arm-channel-targets',
+			)
+			if (denied) return respond({ ok: false, error: 'invalid_foundry_signature' }, denied.status)
+			if (!isFrontsPublishEnabled(ctx.env))
+				return respond({ ok: false, error: 'fronts_publish_disabled' }, 503)
+			let raw: unknown
+			try {
+				raw = JSON.parse(rawBody)
+			} catch {
+				return respond({ ok: false, error: 'invalid_channel_targets_request' }, 400)
+			}
+			const rawOperation =
+				typeof raw === 'object' && raw !== null && 'operation' in raw
+					? (raw as { operation?: unknown }).operation
+					: undefined
+			if (isMaintenanceOperation(rawOperation)) {
+				responseOperation = rawOperation
+				const parsed = FrontsScheduleMaintenanceSchema.safeParse(raw)
+				if (!parsed.success)
+					return respond({ ok: false, error: 'invalid_fronts_schedule_maintenance_request' }, 400)
+				if (!config.frontsScheduleMaintenance)
+					return respond({ ok: false, error: 'fronts_schedule_maintenance_unconfigured' }, 503)
+				try {
+					const rawResult = await runScheduleMaintenance(
+						ctx,
+						config.frontsScheduleMaintenance,
+						parsed.data.operation,
+						parsed.data.limit,
+					)
+					const result = validateMaintenanceResult(rawResult, parsed.data.limit)
+					if (!result)
+						return respond({ ok: false, error: 'fronts_schedule_maintenance_invalid_result' }, 500)
+					return respond({
+						ok: true,
+						limit: parsed.data.limit,
+						completed: result.contentIds.length,
+						contentIds: result.contentIds,
+					})
+				} catch (error) {
+					if (error instanceof FrontsScheduleMaintenanceTimeoutError)
+						return respond({ ok: false, error: 'fronts_schedule_maintenance_timeout' }, 503)
+					console.error('[cms] fronts/schedule host maintenance failed')
+					return respond({ ok: false, error: 'fronts_schedule_maintenance_failed' }, 500)
+				}
+			}
+			const parsed = ArmChannelTargetsSchema.safeParse(raw)
+			if (!parsed.success)
+				return respond({ ok: false, error: 'invalid_channel_targets_request' }, 400)
+			const defaults = parseFrontsDefaultChannelTargets(config.frontsDefaultChannelTargets)
+			if ('error' in defaults)
+				return respond(
+					{ ok: false, error: defaults.error },
+					defaults.error === 'missing_fronts_default_channel_targets' ? 503 : 500,
+				)
+			try {
+				const result = await backfillFrontsChannelTargets(
+					ctx.db,
+					defaults.targets,
+					parsed.data.limit,
+				)
+				return respond({ ok: true, limit: parsed.data.limit, ...result })
+			} catch (error) {
+				console.error('[cms] fronts/schedule target arming failed', error)
+				return respond({ ok: false, error: 'fronts_channel_targets_backfill_failed' }, 500)
+			}
+		},
 		async schedule(ctx) {
 			const hmacSecret = await resolveFoundryHmacSecret(ctx.env)
 			if (!hmacSecret) return json({ error: 'FOUNDRY_HMAC_SECRET is not configured' }, 500)
@@ -210,6 +386,10 @@ export function createFrontsPublishRoutes(config: ContentRouteConfig): FrontsPub
 					// origin is deliberately deferred (packages-docs/cms.md).
 					resolveContentUrl: (row) => publicUrlFor(row),
 				})
+				const preparations = await hydrateFrontsMediaPreparations(ctx.db, {
+					podcastSourceProductionEnabled: config.podcastSourceProductionEnabled,
+					videoSourceProductionEnabled: config.videoSourceProductionEnabled,
+				})
 				return json({
 					ok: true,
 					now,
@@ -218,6 +398,7 @@ export function createFrontsPublishRoutes(config: ContentRouteConfig): FrontsPub
 					items,
 					intents: hydrated.intents,
 					incomplete: hydrated.incomplete,
+					preparations,
 				})
 			} catch (error) {
 				if (error instanceof FrontsScheduleOverflowError) {
@@ -279,6 +460,7 @@ export function createFrontsPublishRoutes(config: ContentRouteConfig): FrontsPub
 				occurredAt: parsed.data.occurred_at ?? null,
 				receipt: parsed.data.receipt ?? null,
 				error: parsed.data.error ?? null,
+				llm: resolved.hooks.llm,
 				checkReadiness: config.publishReadiness
 					? (item) =>
 							config.publishReadiness!({
@@ -323,6 +505,35 @@ export function createFrontsPublishRoutes(config: ContentRouteConfig): FrontsPub
 					500,
 				)
 			}
+			const newlyPublished =
+				result.ok && result.published && !result.deduped && result.attemptId !== null
+			if (newlyPublished && result.publishedItem) {
+				if (result.dekFailureReason) {
+					try {
+						await createDekFailureNotifications({
+							db: ctx.db,
+							workspaceId: config.activeWorkspaceId ?? 'default',
+							contentId: result.publishedItem.id,
+							title: result.publishedItem.title,
+							reason: result.dekFailureReason,
+							occurrenceId: `${eventId}:${result.attemptId}`,
+						})
+					} catch {
+						console.error('[cms] failed to create post-publication dek notification')
+					}
+				}
+				if (config.dispatchWebhook) {
+					try {
+						await config.dispatchWebhook(ctx, {
+							eventType: 'content.published',
+							workspaceId: config.activeWorkspaceId ?? 'default',
+							data: result.publishedItem,
+						})
+					} catch {
+						console.error('[cms] content.published webhook dispatch failed')
+					}
+				}
+			}
 
 			return json({
 				ok: true,