@growth-labs/cms 0.8.24 → 0.8.28

package/src/surveys/auto-label.ts

@@ -11,9 +11,15 @@
 // pre-filter plus <answer> delimiting so personal details never reach the
 // model and reader text is framed as data, not instructions (B2).
 
+import { z } from 'zod'
 import type { D1Database } from '../engine/d1.js'
-import type { LlmDispatch, LlmDispatchResult } from '../providers/types.js'
-import type { SurveyAnswerLabel } from './schema.js'
+import type { LlmDispatch, LlmDispatchResult, LlmDispatchSubmission } from '../providers/types.js'
+import {
+	BoundedRecordIdSchema,
+	type SurveyAnswerLabel,
+	SurveyIdSchema,
+	SurveyQuestionIdSchema,
+} from './schema.js'
 
 /** The masthead-ai-assist task for survey classification. Foundry does not
  *  validate `task` (articlechain/mastheadaiassist.go: "a sixth Masthead action
@@ -146,6 +152,9 @@ export interface SurveyAutoLabelAttemptRecord {
 	nextAt: number
 	/** Epoch ms until another request's dispatch claims this answer. */
 	inflightUntil: number
+	/** Opaque Go correlation, never reader text or identity. */
+	taskId?: string
+	reason?: 'callback_expired' | 'dispatch_failed' | 'llm_failed' | 'unparseable'
 }
 
 /** Narrow persistence the batch runner needs; the KV adapter below satisfies
@@ -154,6 +163,8 @@ export interface SurveyAutoLabelAttemptStore {
 	get(key: string): Promise<SurveyAutoLabelAttemptRecord | null>
 	put(key: string, record: SurveyAutoLabelAttemptRecord, ttlSeconds: number): Promise<void>
 	delete(key: string): Promise<void>
+	putTask?(taskId: string, record: SurveyAutoLabelTaskRecord): Promise<void>
+	getTask?(taskId: string): Promise<SurveyAutoLabelTaskRecord | null>
 }
 
 export function surveyAutoLabelAttemptKey(
@@ -175,31 +186,111 @@ interface KvLike {
 /** Attempt records in a Workers KV namespace (`survey-autolabel:` prefix).
  *  The same namespace the host's LlmDispatch result slots live in is fine:
  *  the key prefixes never collide (`masthead:llm:result:` vs ours). */
+const AttemptRecordSchema = z
+	.object({
+		attempts: z.number().int().nonnegative(),
+		nextAt: z.number().nonnegative(),
+		inflightUntil: z.number().nonnegative(),
+		taskId: z.string().min(1).max(256).optional(),
+		reason: z.enum(['callback_expired', 'dispatch_failed', 'llm_failed', 'unparseable']).optional(),
+	})
+	.strict()
+const TaskRecordSchema = z
+	.object({
+		surveyId: SurveyIdSchema,
+		responseId: BoundedRecordIdSchema,
+		questionId: SurveyQuestionIdSchema,
+		attempts: z.number().int().nonnegative(),
+	})
+	.strict()
+export type SurveyAutoLabelTaskRecord = z.infer<typeof TaskRecordSchema>
+export const SURVEY_AUTO_LABEL_TASK_PREFIX = 'survey-autolabel-task:'
+
 export function kvSurveyAutoLabelAttemptStore(kv: KvLike): SurveyAutoLabelAttemptStore {
 	return {
 		async get(key) {
 			const raw = await kv.get(key)
-			if (raw === null) return null
-			try {
-				const value = JSON.parse(raw) as Partial<SurveyAutoLabelAttemptRecord>
-				return {
-					attempts: typeof value.attempts === 'number' ? value.attempts : 0,
-					nextAt: typeof value.nextAt === 'number' ? value.nextAt : 0,
-					inflightUntil: typeof value.inflightUntil === 'number' ? value.inflightUntil : 0,
-				}
-			} catch {
-				return null
-			}
+			return raw === null ? null : AttemptRecordSchema.parse(JSON.parse(raw))
 		},
 		async put(key, record, ttlSeconds) {
-			await kv.put(key, JSON.stringify(record), { expirationTtl: ttlSeconds })
+			await kv.put(key, JSON.stringify(AttemptRecordSchema.parse(record)), {
+				expirationTtl: ttlSeconds,
+			})
 		},
 		async delete(key) {
 			await kv.delete(key)
 		},
+		async putTask(taskId, record) {
+			await kv.put(
+				`${SURVEY_AUTO_LABEL_TASK_PREFIX}${taskId}`,
+				JSON.stringify(TaskRecordSchema.parse(record)),
+				{ expirationTtl: SURVEY_AUTO_LABEL_ATTEMPT_TTL_SECONDS },
+			)
+		},
+		async getTask(taskId) {
+			const raw = await kv.get(`${SURVEY_AUTO_LABEL_TASK_PREFIX}${taskId}`)
+			return raw === null ? null : TaskRecordSchema.parse(JSON.parse(raw))
+		},
 	}
 }
 
+/** Finalize through the existing signed callback, independently of waitUntil.
+ * Missing correlation/persistence throws so Go retries rather than acknowledging lost work. */
+export async function finalizeSurveyAutoLabel(
+	db: D1Database,
+	store: SurveyAutoLabelAttemptStore,
+	taskId: string,
+	result: { terminalState: 'completed' | 'failed'; result?: string },
+	now = Date.now(),
+): Promise<void> {
+	const target = await store.getTask?.(taskId)
+	if (!target) throw new Error('survey correlation unavailable')
+	const key = surveyAutoLabelAttemptKey(target.surveyId, target.responseId, target.questionId)
+	const label =
+		result.terminalState === 'completed' ? parseSurveyLabelReply(result.result ?? '') : null
+	if (label) {
+		await db
+			.prepare(`INSERT INTO survey_answer_labels
+		 (survey_id, response_id, question_id, label, source, labeled_by, labeled_at)
+		 VALUES (?, ?, ?, ?, 'auto', NULL, ?)
+		 ON CONFLICT(survey_id, response_id, question_id) DO NOTHING`)
+			.bind(target.surveyId, target.responseId, target.questionId, label, now)
+			.run()
+		const current = await store.get(key)
+		if (current?.taskId === taskId) await store.delete(key)
+		return
+	}
+	const existing = await db
+		.prepare(
+			'SELECT label FROM survey_answer_labels WHERE survey_id = ? AND response_id = ? AND question_id = ? LIMIT 1',
+		)
+		.bind(target.surveyId, target.responseId, target.questionId)
+		.first()
+	if (existing) return
+	const current = await store.get(key)
+	if (!current) throw new Error('survey attempt unavailable')
+	if (
+		current.taskId === taskId &&
+		current.inflightUntil === 0 &&
+		current.attempts > target.attempts
+	)
+		return
+	// A delayed failed callback must not reset a newer retry or a completed label.
+	if (current?.taskId !== taskId) return
+	const attempts = target.attempts + 1
+	await store.put(
+		key,
+		{
+			attempts,
+			nextAt: now + SURVEY_AUTO_LABEL_BACKOFF_MS[Math.min(attempts, 3) - 1],
+			inflightUntil: 0,
+			taskId,
+			reason: result.terminalState === 'failed' ? 'llm_failed' : 'unparseable',
+		},
+		SURVEY_AUTO_LABEL_ATTEMPT_TTL_SECONDS,
+	)
+}
+
 /**
  * In-isolate in-flight gate. KV has no compare-and-swap, so a dedupe window
  * this small is enforced synchronously in module scope (all concurrent
@@ -256,18 +347,34 @@ async function runSurveyAutoLabelBatch(
 	batch: SurveyAutoLabelCandidate[],
 ): Promise<void> {
 	let cursor = 0
+	let admitted = 0
+	const reserveAdmission = () => {
+		if (admitted >= SURVEY_AUTO_LABEL_BATCH_LIMIT) return false
+		admitted += 1
+		return true
+	}
 	let stored = 0
+	let processed = 0
 	let deferred = 0
 	let halted: string | null = null
+	const admissionDeadline = (options.now ?? Date.now)() + 20_000
 	const skipReasons = new Set<string>()
 
 	const worker = async (): Promise<void> => {
 		for (;;) {
-			if (halted !== null) return
+			if (halted !== null || admitted >= SURVEY_AUTO_LABEL_BATCH_LIMIT) return
+			if ((options.now ?? Date.now)() >= admissionDeadline) {
+				halted = 'admission_window_ended'
+				return
+			}
 			const next = cursor
 			cursor += 1
 			if (next >= batch.length) return
-			const outcome = await classifyAndStore(options, batch[next])
+			const outcome = await classifyAndStore(options, batch[next], reserveAdmission).catch(() => ({
+				kind: 'unavailable' as const,
+				reason: 'attempt_write_failed',
+			}))
+			processed += 1
 			if (outcome.kind === 'stored') {
 				stored += 1
 				continue
@@ -292,7 +399,7 @@ async function runSurveyAutoLabelBatch(
 
 	// Failure-class skips only: a wholly deferred batch (all in flight or
 	// backing off) is the steady state of the dedupe, not a failure to report.
-	const skipped = batch.length - stored - deferred
+	const skipped = (halted === null ? processed : batch.length) - stored - deferred
 	if (skipped === 0) return
 	const reasons = new Set(skipReasons)
 	if (halted !== null) reasons.add(halted)
@@ -305,14 +412,19 @@ async function runSurveyAutoLabelBatch(
 
 type ClassifyOutcome =
 	| { kind: 'stored' }
-	| { kind: 'deferred'; reason: 'in_flight' | 'backoff' | 'gave_up' | 'pii' }
+	| {
+			kind: 'deferred'
+			reason: 'in_flight' | 'backoff' | 'gave_up' | 'pii' | 'empty' | 'batch_limit'
+	  }
 	| { kind: 'skipped'; reason: string }
 	| { kind: 'unavailable'; reason: string }
 
 async function classifyAndStore(
 	options: SurveyAutoLabelOptions,
 	candidate: SurveyAutoLabelCandidate,
+	reserveAdmission: () => boolean,
 ): Promise<ClassifyOutcome> {
+	if (candidate.answerText.trim().length === 0) return { kind: 'deferred', reason: 'empty' }
 	// B2 first, before any store or dispatch work: personal details never
 	// leave the Worker, and the skip consumes no attempt.
 	if (containsPersonalDetails(candidate.answerText)) return { kind: 'deferred', reason: 'pii' }
@@ -327,12 +439,25 @@ async function classifyAndStore(
 	try {
 		record = await options.attempts.get(key)
 	} catch {
-		// The attempt store is dedupe hygiene, not label correctness: an
-		// unreadable record proceeds as if absent (worst case: one duplicate
-		// dispatch, still bounded by the in-isolate gate).
+		return { kind: 'unavailable', reason: 'attempt_read_failed' }
 	}
 	if (record) {
 		if (record.inflightUntil > now) return { kind: 'deferred', reason: 'in_flight' }
+		if (record.inflightUntil > 0) {
+			const attempts = record.attempts + 1
+			await options.attempts.put(
+				key,
+				{
+					attempts,
+					nextAt: now + SURVEY_AUTO_LABEL_BACKOFF_MS[Math.min(attempts, 3) - 1],
+					inflightUntil: 0,
+					...(record.taskId ? { taskId: record.taskId } : {}),
+					reason: 'callback_expired',
+				},
+				SURVEY_AUTO_LABEL_ATTEMPT_TTL_SECONDS,
+			)
+			return { kind: 'deferred', reason: 'backoff' }
+		}
 		if (record.attempts >= SURVEY_AUTO_LABEL_MAX_ATTEMPTS) {
 			return { kind: 'deferred', reason: 'gave_up' }
 		}
@@ -340,6 +465,7 @@ async function classifyAndStore(
 	}
 	if (!reserveInFlight(key, now)) return { kind: 'deferred', reason: 'in_flight' }
 	try {
+		if (!reserveAdmission()) return { kind: 'deferred', reason: 'batch_limit' }
 		// Claimed. Record the failure (or the backoff it earns) at each exit;
 		// the KV marker goes out BEFORE the dispatch so a concurrent request
 		// in another isolate defers instead of duplicating the work.
@@ -352,23 +478,68 @@ async function classifyAndStore(
 			await options.attempts
 				.put(
 					key,
-					{ attempts, nextAt: now + backoff, inflightUntil: 0 },
+					{
+						attempts,
+						nextAt: now + backoff,
+						inflightUntil: 0,
+						reason: outcome.reason === 'unparseable' ? 'unparseable' : 'dispatch_failed',
+					},
 					SURVEY_AUTO_LABEL_ATTEMPT_TTL_SECONDS,
 				)
 				.catch(() => {})
 			return outcome
 		}
-		await options.attempts
-			.put(
-				key,
-				{
-					attempts: record?.attempts ?? 0,
-					nextAt: record?.nextAt ?? 0,
-					inflightUntil: now + SURVEY_AUTO_LABEL_INFLIGHT_MS,
-				},
-				SURVEY_AUTO_LABEL_ATTEMPT_TTL_SECONDS,
-			)
-			.catch(() => {})
+		if (!options.llm.submit)
+			await options.attempts
+				.put(
+					key,
+					{
+						attempts: record?.attempts ?? 0,
+						nextAt: record?.nextAt ?? 0,
+						inflightUntil: now + SURVEY_AUTO_LABEL_INFLIGHT_MS,
+					},
+					SURVEY_AUTO_LABEL_ATTEMPT_TTL_SECONDS,
+				)
+				.catch(() => {
+					throw new Error('attempt_write_failed')
+				})
+
+		if (options.llm.submit) {
+			if (!options.attempts.putTask)
+				return await failure({ kind: 'unavailable', reason: 'no_correlation_store' })
+			let admission: LlmDispatchSubmission
+			try {
+				admission = await options.llm.submit(
+					{
+						task: SURVEY_AUTO_LABEL_TASK,
+						prompt: buildSurveyLabelPrompt(candidate.questionPrompt, candidate.answerText),
+					},
+					async (taskId) => {
+						await options.attempts.putTask!(taskId, {
+							surveyId: options.surveyId,
+							responseId: candidate.responseId,
+							questionId: candidate.questionId,
+							attempts: record?.attempts ?? 0,
+						})
+						await options.attempts.put(
+							key,
+							{
+								attempts: record?.attempts ?? 0,
+								nextAt: 0,
+								inflightUntil: now + SURVEY_AUTO_LABEL_INFLIGHT_MS,
+								taskId,
+							},
+							SURVEY_AUTO_LABEL_ATTEMPT_TTL_SECONDS,
+						)
+					},
+				)
+			} catch {
+				return await failure({ kind: 'unavailable', reason: 'dispatch_threw' })
+			}
+			if (admission.status === 'unavailable')
+				return await failure({ kind: 'unavailable', reason: admission.reason })
+			return { kind: 'deferred', reason: 'in_flight' }
+		}
 
 		let result: LlmDispatchResult
 		try {

package/src/surveys/readout.ts

@@ -0,0 +1,243 @@
+import type { SurveyQuestion, SurveyResults } from './schema.js'
+
+// Pure readout math for the survey results screen. Every share here names its
+// denominator: a question's share is of the people who answered it, and a
+// group's share is of that group's members who answered it — never of a page.
+
+export type SurveyResponse = SurveyResults['responses'][number]
+type ScaleQuestion = Extract<SurveyQuestion, { kind: 'scale' }>
+type ChoiceQuestion = Extract<SurveyQuestion, { kind: 'single_choice' | 'multi_choice' }>
+
+export type Mood = 'unhappy' | 'neutral' | 'happy'
+
+export interface ScaleSummary {
+	min: number
+	max: number
+	answered: number
+	average: number | null
+	happy: number
+	neutral: number
+	unhappy: number
+	happyRange: string
+	unhappyRange: string
+	/** The midpoint value on an odd-length scale; null when the scale has no middle. */
+	neutralValue: number | null
+}
+
+export function scaleMood(value: number, min: number, max: number): Mood {
+	const midpoint = (min + max) / 2
+	if (value > midpoint) return 'happy'
+	if (value < midpoint) return 'unhappy'
+	return 'neutral'
+}
+
+export function summarizeScale(
+	options: { min: number; max: number },
+	distribution: Record<string, number>,
+): ScaleSummary {
+	const { min, max } = options
+	const midpoint = (min + max) / 2
+	let answered = 0
+	let sum = 0
+	const totals = { happy: 0, neutral: 0, unhappy: 0 }
+	for (let value = min; value <= max; value += 1) {
+		const count = distribution[String(value)] ?? 0
+		answered += count
+		sum += value * count
+		totals[scaleMood(value, min, max)] += count
+	}
+	return {
+		min,
+		max,
+		answered,
+		average: answered === 0 ? null : sum / answered,
+		...totals,
+		happyRange: valueRange(Math.floor(midpoint) + 1, max),
+		unhappyRange: valueRange(min, Math.ceil(midpoint) - 1),
+		neutralValue: Number.isInteger(midpoint) ? midpoint : null,
+	}
+}
+
+export function share(count: number, of: number): number {
+	return of === 0 ? 0 : count / of
+}
+
+export function percent(count: number, of: number): string {
+	return `${Math.round(share(count, of) * 100)}%`
+}
+
+export interface OptionShare {
+	option: string
+	count: number
+}
+
+// A multi-choice question is a ranking ("which two would you most want"), so it
+// reads best sorted; a single choice keeps its configured order, which is often
+// ordinal (daily → rarely) and must not be reshuffled.
+export function optionRows(question: ChoiceQuestion): OptionShare[] {
+	const rows = question.options.map((option) => ({ option, count: question.counts[option] ?? 0 }))
+	return question.kind === 'multi_choice' ? [...rows].sort((a, b) => b.count - a.count) : rows
+}
+
+export function questionTakeaway(question: SurveyQuestion, responseCount: number): string {
+	if (question.answerCount === 0) return 'Nobody has answered this yet.'
+	if (question.kind === 'scale') {
+		const summary = summarizeScale(question.options, question.distribution)
+		return `${percent(summary.happy, summary.answered)} rated it ${summary.happyRange} · average ${formatAverage(summary.average)} out of ${summary.max}`
+	}
+	if (question.kind === 'text') {
+		return `${question.answerCount} of ${responseCount} people wrote an answer (${percent(question.answerCount, responseCount)})`
+	}
+	const rows = [...optionRows(question)].sort((a, b) => b.count - a.count)
+	const [first, second] = rows
+	if (question.kind === 'multi_choice') {
+		return second && second.count > 0
+			? `Most picked: “${first.option}” (${percent(first.count, question.answerCount)}), then “${second.option}” (${percent(second.count, question.answerCount)})`
+			: `Most picked: “${first.option}” (${percent(first.count, question.answerCount)})`
+	}
+	return `${percent(first.count, question.answerCount)} chose “${first.option}”`
+}
+
+export function formatAverage(average: number | null): string {
+	return average === null ? '—' : average.toFixed(2)
+}
+
+/** The first scale question is the survey's headline number. */
+export function headlineScale(questions: SurveyQuestion[]): ScaleQuestion | null {
+	const scale = questions.find((question) => question.kind === 'scale')
+	return scale?.kind === 'scale' ? scale : null
+}
+
+export function answerValue(response: SurveyResponse, questionId: string): unknown {
+	return response.answers?.find((answer) => answer.questionId === questionId)?.value
+}
+
+// ── Comparing groups ────────────────────────────────────────────────────
+
+export const MEMBERSHIP_SPLIT = 'membership'
+
+export interface ResponseGroup {
+	key: string
+	label: string
+	responses: SurveyResponse[]
+	/** Set when the groups are moods: they then wear the mood colors, not group hues. */
+	mood?: Mood
+}
+
+/** Questions that can divide readers into groups: one answer per person. */
+export function splitQuestions(questions: SurveyQuestion[]): SurveyQuestion[] {
+	return questions.filter(
+		(question) => question.kind === 'single_choice' || question.kind === 'scale',
+	)
+}
+
+export function groupResponses(
+	responses: SurveyResponse[],
+	split: string,
+	questions: SurveyQuestion[],
+): ResponseGroup[] {
+	if (split === MEMBERSHIP_SPLIT) {
+		return nonEmpty([
+			group('member', 'Members', responses, (r) => r.respondentSegment === 'member'),
+			group('non_member', 'Non-members', responses, (r) => r.respondentSegment === 'non_member'),
+			group('unknown', 'Membership unknown', responses, (r) => r.respondentSegment === 'unknown'),
+		])
+	}
+	const question = questions.find((candidate) => candidate.id === split)
+	if (question?.kind === 'single_choice') {
+		return nonEmpty(
+			question.options.map((option) =>
+				group(option, option, responses, (r) => answerValue(r, question.id) === option),
+			),
+		)
+	}
+	if (question?.kind === 'scale') {
+		// Six separate satisfaction groups are too thin to read; editors ask
+		// "what do unhappy readers want", so a scale splits by mood.
+		const { min, max } = question.options
+		const summary = summarizeScale(question.options, {})
+		const moodOf = (r: SurveyResponse) => {
+			const value = answerValue(r, question.id)
+			return typeof value === 'number' ? scaleMood(value, min, max) : null
+		}
+		const labels: Record<Mood, string> = {
+			unhappy: `Unhappy (${summary.unhappyRange})`,
+			neutral: `In the middle (${summary.neutralValue ?? ''})`,
+			happy: `Happy (${summary.happyRange})`,
+		}
+		return nonEmpty(
+			(['unhappy', 'neutral', 'happy'] as const).map((mood) => ({
+				...group(mood, labels[mood], responses, (r) => moodOf(r) === mood),
+				mood,
+			})),
+		)
+	}
+	return []
+}
+
+export interface GroupCount {
+	count: number
+	answered: number
+}
+
+export type QuestionComparison =
+	| { kind: 'choice'; rows: Array<{ option: string; byGroup: GroupCount[] }> }
+	| { kind: 'scale'; byGroup: ScaleSummary[] }
+	| { kind: 'none' }
+
+export function compareQuestion(
+	question: SurveyQuestion,
+	groups: ResponseGroup[],
+): QuestionComparison {
+	if (question.kind === 'single_choice' || question.kind === 'multi_choice') {
+		const valuesByGroup = groups.map((g) =>
+			g.responses
+				.map((r) => answerValue(r, question.id))
+				.filter((value) => value !== undefined)
+				.map((value) => (Array.isArray(value) ? value : [value])),
+		)
+		return {
+			kind: 'choice',
+			rows: optionRows(question).map(({ option }) => ({
+				option,
+				byGroup: valuesByGroup.map((answers) => ({
+					count: answers.filter((picked) => picked.includes(option)).length,
+					answered: answers.length,
+				})),
+			})),
+		}
+	}
+	if (question.kind === 'scale') {
+		return {
+			kind: 'scale',
+			byGroup: groups.map((g) => {
+				const distribution: Record<string, number> = {}
+				for (const r of g.responses) {
+					const value = answerValue(r, question.id)
+					if (typeof value === 'number') {
+						distribution[String(value)] = (distribution[String(value)] ?? 0) + 1
+					}
+				}
+				return summarizeScale(question.options, distribution)
+			}),
+		}
+	}
+	return { kind: 'none' }
+}
+
+function group(
+	key: string,
+	label: string,
+	responses: SurveyResponse[],
+	matches: (response: SurveyResponse) => boolean,
+): ResponseGroup {
+	return { key, label, responses: responses.filter(matches) }
+}
+
+function nonEmpty(groups: ResponseGroup[]): ResponseGroup[] {
+	return groups.filter((g) => g.responses.length > 0)
+}
+
+function valueRange(from: number, to: number): string {
+	return from === to ? String(from) : `${from}–${to}`
+}

package/src/surveys/schema.ts

@@ -5,7 +5,7 @@ const MAX_TITLE_LENGTH = 300
 const MAX_PROMPT_LENGTH = 1_000
 const MAX_QUESTIONS = 100
 const MAX_RESPONSES = 500
-const MAX_FREE_TEXT_ENTRIES = 500
+export const MAX_FREE_TEXT_ENTRIES = 500
 const MAX_FREE_TEXT_LENGTH = 20_000
 const MAX_CHOICE_OPTIONS = 100
 const MAX_OPTION_LENGTH = 256
@@ -196,6 +196,38 @@ export const SurveyQuestionSchema = z
 		}
 	})
 
+/** Reviewed delivery notes supplied by a site, never generated from private answers. */
+export const SurveyFeedbackThemeSchema = z
+	.object({
+		id: SurveyIdSchema,
+		title: z.string().trim().min(1).max(160),
+		state: z.enum(['open', 'partly_shipped', 'shipped', 'unknown']),
+		summary: z.string().trim().min(1).max(1_000),
+		reviewedAt: IsoTimestampSchema,
+		evidence: z
+			.array(
+				z
+					.object({
+						label: z.string().trim().min(1).max(160),
+						href: z
+							.string()
+							.url()
+							.max(2_000)
+							.refine((value) => value.startsWith('https://')),
+					})
+					.strict(),
+			)
+			.max(6),
+	})
+	.strict()
+export const SurveyFeedbackThemesSchema = z
+	.array(SurveyFeedbackThemeSchema)
+	.max(25)
+	.refine((themes) => new Set(themes.map(({ id }) => id)).size === themes.length, {
+		message: 'Feedback theme IDs must be unique',
+	})
+export type SurveyFeedbackTheme = z.infer<typeof SurveyFeedbackThemeSchema>
+
 export const SurveyResultsSchema = z
 	.object({
 		survey: z
@@ -244,6 +276,28 @@ export const SurveyResultsSchema = z
 									.object({
 										questionId: SurveyQuestionIdSchema,
 										value: AnswerValueSchema,
+										writtenValue: z
+											.string()
+											.max(
+												Math.max(
+													MAX_FREE_TEXT_LENGTH,
+													MAX_CHOICE_OPTIONS * (MAX_OPTION_LENGTH + 1),
+												),
+											)
+											.optional(),
+										label: z.enum(['technical', 'general']).optional(),
+										labelSource: z.enum(['owner', 'auto', 'import']).optional(),
+										classificationStatus: z
+											.enum([
+												'pending',
+												'retry',
+												'expired',
+												'manual_review',
+												'unavailable',
+												'queued',
+											])
+											.optional(),
+										nextAttemptAt: z.number().nonnegative().optional(),
 									})
 									.strict(),
 							)
@@ -269,6 +323,10 @@ export const SurveyResultsSchema = z
 						// Owner payloads carry it; non-owner entries pass through
 						// undecorated, exactly as they do for `label`.
 						labelSource: z.enum(['owner', 'auto', 'import']).optional(),
+						classificationStatus: z
+							.enum(['pending', 'retry', 'expired', 'manual_review', 'unavailable', 'queued'])
+							.optional(),
+						nextAttemptAt: z.number().nonnegative().optional(),
 					})
 					.strict(),
 			)

package/src/ui/api/content/insights-inputs.ts

@@ -4,10 +4,13 @@
 // X-Foundry-Timestamp + X-Foundry-Signature family as fronts/schedule) for
 // foundryd's sitebrain.insights.run schedule (W1-07 PR 6). NOT behind
 // requirePublisher. Sibling of insights-ingest under /content/.
+
+import { config } from 'virtual:growth-labs/cms/config'
 import type { APIContext } from 'astro'
 import { createContentInsightsRoutes } from '../../../routes/content-insights.js'
 import type { RouteContext } from '../../../routes/context.js'
 import { buildSiteAuthz } from '../_authz.js'
+import { toContentConfig } from '../_content-config.js'
 
 function toCtx(c: APIContext): RouteContext {
 	const env = (c.locals as { cmsEnv?: Record<string, unknown> }).cmsEnv ?? {}
@@ -16,7 +19,11 @@ function toCtx(c: APIContext): RouteContext {
 
 function siteId(c: APIContext): string {
 	const env = (c.locals as { cmsEnv?: Record<string, unknown> }).cmsEnv ?? {}
-	return (env.ACTIVE_WORKSPACE_ID as string | undefined) ?? 'default'
+	return (
+		toContentConfig(c).activeWorkspaceId ??
+		(env.ACTIVE_WORKSPACE_ID as string | undefined) ??
+		(config.workspaces?.length === 1 ? config.workspaces[0]!.id : 'default')
+	)
 }
 
 export const GET = (c: APIContext) =>