@case-framework/survey-assistant 0.1.0

package/dist/tools-Hz2p7vyv.mjs

@@ -0,0 +1,1879 @@
+import { W as assistantItemTypeManifestSchema, gt as surveyOperationSchema, u as surveyChangeSetSchema } from "./protocol-DV0ka9WT.mjs";
+import { a as getDeterministicCreateItemTypes, o as inspectAssistantItem, s as resolveAssistantCapabilityReference } from "./capabilities-B6tvE7fK.mjs";
+import { A as getRawSurvey, B as resolveItemSummary, C as clampLimit, F as mapKeyIndexById, H as summarizeFocusItemNode, I as mapOutlineById, J as translationEntrySchema, K as summarizeOutlineNode, L as mapRawItemsById, M as itemConfigDetailsSchema, N as itemMatchesQuery, P as itemSummarySchema, R as normalizeText, U as summarizeItemById, V as sliceWithCursor, W as summarizeKeyIndexEntries, Y as unique, _ as buildConfigSearchText, a as SURVEY_CHANGE_CONTINUATION_MODES, b as buildItemTranslationEntries, d as normalizeSurveyChangeOperations, f as buildExpressionMutationPatches, i as SURVEY_CHANGE_CONTINUATION_DESCRIPTION, j as getRawSurveyItems, k as getKeyIndexEntries, l as createSurveyChangeSet, p as expressionMutationSchema, q as summarizeRawItem, t as auditSurvey, v as buildEmbeddedFormDetails, w as findDirectChildrenByFullKey, y as buildItemConfigDetails } from "./engine-sPvuixWg.mjs";
+import { r as requireSurveyAssistantTurnState } from "./request-context-jcmXT_Q2.mjs";
+import { n as surveyAuthoringReferences, t as surveyAuthoringReferenceTopics } from "./authoring-references-X6uRaWuf.mjs";
+import { z } from "zod";
+import { JsonPatchError, encodeJsonPointerSegment, getAssetUsagesFromContent, getValueAtJsonPointer } from "@case-framework/survey-core";
+import { randomUUID } from "node:crypto";
+import { createTool, isValidationError } from "@mastra/core/tools";
+//#region src/server/tools/tool-model-output.ts
+const FALLBACK_MODEL_TEXT = "The tool returned no model-readable output. Review the tool arguments and retry with valid values.";
+const unwrapToolOutput$1 = (value) => value && typeof value === "object" && "output" in value && value.output !== void 0 ? value.output : value;
+const createTextModelOutput = (text) => ({
+	type: "content",
+	value: [{
+		type: "text",
+		text: typeof text === "string" && text.trim().length > 0 ? text : FALLBACK_MODEL_TEXT
+	}]
+});
+const toTextModelOutput = (value, summarize) => {
+	const output = unwrapToolOutput$1(value);
+	if (isValidationError(output)) return createTextModelOutput(output.message);
+	try {
+		return createTextModelOutput(summarize(output));
+	} catch {
+		return createTextModelOutput(void 0);
+	}
+};
+//#endregion
+//#region src/server/tools/survey-authoring-reference-tool.ts
+const TOOL_ID$10 = "survey_authoring_reference";
+const topicSchema = z.string().min(1).max(120);
+const surveyAuthoringReferenceTool = createTool({
+	id: TOOL_ID$10,
+	description: "Load one narrow CASE survey authoring reference or an installed item capability's reference. For a capability-owned reference, provide both itemType and the reference topic advertised in the capability manifest.",
+	inputSchema: z.object({
+		topic: topicSchema.describe("The narrow authoring reference to load."),
+		itemType: z.string().min(1).max(120).optional().describe("Installed custom item type that owns this reference, when applicable."),
+		reason: z.string().max(500).optional().describe("Short reason this reference is needed.")
+	}),
+	outputSchema: z.object({
+		ok: z.boolean(),
+		topic: topicSchema,
+		itemType: z.string().optional(),
+		title: z.string(),
+		content: z.string()
+	}),
+	mcp: { annotations: {
+		title: "Read authoring reference",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const builtInEntry = surveyAuthoringReferenceTopics.includes(inputData.topic) ? surveyAuthoringReferences[inputData.topic] : void 0;
+		const engineContext = context?.requestContext?.get("engineContext");
+		const capability = inputData.itemType ? engineContext?.trustedCapabilities?.byItemType.get(inputData.itemType) : void 0;
+		const capabilityReference = inputData.itemType ? resolveAssistantCapabilityReference({
+			capabilities: engineContext?.trustedCapabilities,
+			itemType: inputData.itemType,
+			topic: inputData.topic
+		}) : void 0;
+		const entry = capabilityReference ? {
+			title: capabilityReference.title ?? `${capability?.manifest.displayName} authoring`,
+			content: capabilityReference.markdown
+		} : builtInEntry;
+		if (!entry) return {
+			ok: false,
+			topic: inputData.topic,
+			itemType: inputData.itemType,
+			title: "Reference unavailable",
+			content: inputData.itemType ? `No reference named "${inputData.topic}" is installed for item type "${inputData.itemType}".` : `No built-in reference named "${inputData.topic}" is available.`
+		};
+		return {
+			ok: true,
+			topic: inputData.topic,
+			itemType: inputData.itemType,
+			title: entry.title,
+			content: entry.content
+		};
+	},
+	toModelOutput: (value) => toTextModelOutput(value, (output) => `# ${output.title}\n\n${output.content}`)
+});
+//#endregion
+//#region src/server/tools/survey-change-tool.ts
+const TOOL_ID$9 = "survey_change";
+const inputSchema$9 = z.object({
+	intent: z.string().min(1).max(500).describe("The concrete survey change requested by the user."),
+	summary: z.string().min(1).max(500).describe("Short user-facing summary of the intended survey change."),
+	operations: z.array(z.unknown()).min(1).max(200).describe("Assistant operation objects to validate and package as one undoable change. Every operation uses the exact discriminator field \"kind\", never \"type\". Canonical create shape: { kind: \"create-item\", target: { parentItemId, index? }, item: { id, key, itemType, config }, translations?: [{ locale, contentKey, plainText } | { locale, contentKey, content }] }. Put parentItemId in target, respondent content in top-level translations, and item-type settings in item.config. When creating a new item that contains an imported or external image, put the complete richText content including its image block directly in create-item.translations[].content in the same call; never create a placeholder and then call update-placed-image because the new item is absent from the immutable snapshot. When deleting referenced images and their assets, include all reference-removal operations and remove-image-asset in this same operations array, with remove-image-asset last; do not split that dependency across survey_change and survey_asset. For a choice item, config.options entries use id and optional key/embeddedForm only; option labels are top-level translations at options.<optionId>.label. Canonical presentation shapes are { kind: \"update-item-label\", itemId, itemLabel } for the editor-only label and { kind: \"update-item-color\", itemId, color } for a supported editor swatch. Across editor views, unqualified labels for items/questions mean update-item-label; question titles and option/field labels are respondent-visible translations. Canonical item config shape: { kind: \"patch-item-config\", itemId, patches: [{ op, path, value? }] }, where paths are relative to that item config root. Inspect the item and load its capability reference first. Canonical add-choice-option shape: { kind: \"add-choice-option\", itemId, locale?, index?, option: { id?, key?, label: \"visible text\" } }; label is a plain string, and this operation creates its translation. Canonical text-update shape: { kind: \"update-item-translation\", itemId, locale, contentKey, plainText } for ordinary text; content is only a structured Content object for meaningful formatting. To edit one image already placed in rich text, use { kind: \"update-placed-image\", itemId, locale, contentKey, imageIndex, expectedAssetId?, changes } where imageIndex counts only image blocks from zero. changes can set a local asset source or an external URL and can update alt, caption, width, height, maxWidth, maxHeight, and alignment; null removes an optional property. This changes the rendered placement, while update-image-asset-metadata changes only global asset metadata. Canonical raw shape: { kind: \"survey-json-patch\", patches: [{ op, path, value? }] }; it must be the only operation and all related raw edits belong in its plural patches array, never patch. Patch paths are rooted at the survey, for example /surveyItems/<index>/config or /translations/<locale>. Keep proposals bounded; if validation says there are too many operations, split the same work into independent smaller change calls. Use compact typed operations for common edits, patch-item-config for item-local config, and one survey-json-patch operation for survey-wide raw edits."),
+	continuationMode: z.enum(SURVEY_CHANGE_CONTINUATION_MODES).nullish().transform((value) => value ?? void 0).describe(`${SURVEY_CHANGE_CONTINUATION_DESCRIPTION} Omit this field instead of sending null.`),
+	inspectedContext: z.array(z.string().max(240)).max(20).nullish().transform((value) => value ?? void 0).describe("Optional item ids, paths, or references inspected before proposing this change."),
+	notes: z.string().max(1e3).nullish().transform((value) => value ?? void 0).describe("Optional implementation notes for validation/debugging; not shown as persisted survey content.")
+});
+const rejectedOperationParseEvent = ({ issueText, summary, turnId }) => ({
+	protocolVersion: 1,
+	id: randomUUID(),
+	turnId,
+	status: "rejected",
+	summary,
+	operations: [],
+	validation: {
+		valid: false,
+		issues: [{
+			severity: "error",
+			code: "invalid-operation-shape",
+			message: issueText
+		}],
+		warnings: [],
+		normalizedOperations: []
+	},
+	createdAt: (/* @__PURE__ */ new Date()).toISOString()
+});
+const describeOperationTarget = (operation) => {
+	switch (operation.kind) {
+		case "update-item-translation": return `${operation.kind} ${operation.locale}:${operation.itemId}:${operation.contentKey}`;
+		case "update-placed-image": return `${operation.kind} ${operation.locale}:${operation.itemId}:${operation.contentKey}#${operation.imageIndex}`;
+		case "update-item-label":
+		case "update-item-color":
+		case "update-item-key":
+		case "patch-item-config":
+		case "remove-item":
+		case "move-item": return `${operation.kind} ${operation.itemId}`;
+		case "upsert-form-field-group": return `${operation.kind} ${operation.target.itemId}:${operation.group.id}`;
+		case "remove-form-field-group": return `${operation.kind} ${operation.target.itemId}:${operation.groupId}`;
+		case "reorder-form-field-groups": return `${operation.kind} ${operation.target.itemId}`;
+		case "upsert-form-field": return `${operation.kind} ${operation.target.itemId}:${operation.field.id}`;
+		case "remove-form-field":
+		case "move-form-field": return `${operation.kind} ${operation.target.itemId}:${operation.fieldId}`;
+		case "set-embedded-form":
+		case "remove-embedded-form": return `${operation.kind} ${operation.itemId}:${operation.optionId}`;
+		case "add-choice-option": return `${operation.kind} ${operation.itemId}:${operation.option.id ?? operation.option.key ?? operation.option.label}`;
+		case "update-choice-option-label":
+		case "remove-choice-option": return `${operation.kind} ${operation.itemId}:${operation.optionId}`;
+		case "reorder-choice-options": return `${operation.kind} ${operation.itemId}`;
+		case "reorder-items": return `${operation.kind} ${operation.parentItemId}`;
+		case "update-survey-metadata":
+		case "update-survey-pagination": return operation.kind;
+		case "update-survey-translation": return `${operation.kind} ${operation.locale}:${operation.surface}:${operation.contentKey}`;
+		case "remove-survey-locale": return `${operation.kind} ${operation.locale}`;
+		case "set-image-asset":
+		case "update-image-asset-metadata":
+		case "remove-image-asset": return `${operation.kind} ${operation.assetId}`;
+		case "create-item": return `${operation.kind} ${operation.item.id ?? operation.item.key ?? operation.item.itemType}`;
+		case "survey-json-patch": return `${operation.kind} ${operation.patches.map((patch) => patch.path).join(", ")}`;
+	}
+};
+const summarizeValidation = (event) => {
+	const lines = [`${event.status === "validated" ? "Validated" : "Rejected"} survey change: ${event.summary}`, `Change id: ${event.id}`];
+	if (event.operations.length > 0) lines.push(`Operations: ${event.operations.map((operation) => operation.kind).join(", ")}`);
+	if (event.status === "rejected") {
+		lines.push("Apply status: this turn is blocked and will authorize no survey changes unless a later complete proposal validates with continuationMode \"replace\".");
+		if (event.operations.length > 0) {
+			const checklist = event.operations.slice(0, 24).map(describeOperationTarget);
+			lines.push(`Unapplied target sample (${checklist.length} of ${event.operations.length}):\n${checklist.map((target) => `- ${target}`).join("\n")}`);
+			if (event.operations.length > checklist.length) lines.push(`The sample omits ${event.operations.length - checklist.length} additional operation target(s). The original tool input is authoritative; preserve its complete requested scope when retrying.`);
+		}
+	}
+	if (event.status === "validated") {
+		lines.push("Lifecycle: this candidate is registered, not live. Do not target its new ids again in this response; successful turn completion authorizes the collector's final candidate ids for browser apply.");
+		if (event.supersedesChangeIds?.length) lines.push(`Queue: replaces ${event.supersedesChangeIds.length} earlier survey_change proposal(s) from this response.`);
+	}
+	if (event.supersedesChangeIds?.length && event.status === "rejected") lines.push(`Queue: discarded ${event.supersedesChangeIds.length} earlier candidate proposal(s); their work is not retained or authorized. Include that discarded work in the complete replacement before claiming the request is complete.`);
+	if (event.validation.issues.length > 0) {
+		lines.push("Issues:");
+		for (const issue of event.validation.issues) lines.push(`- ${issue.code}: ${issue.message}`);
+		const issueCodes = new Set(event.validation.issues.map((issue) => issue.code));
+		if (issueCodes.has("missing-create-content") || issueCodes.has("missing-field-groups-wrapper") || issueCodes.has("missing-choice-options") || issueCodes.has("missing-choice-option-labels")) lines.push("Recovery hint: load the assistant-operations reference, then retry the complete create-item proposal with continuationMode \"replace\". Put visible text in top-level translations[] beside item, config inside item.config, choice options in item.config.options, and form fields inside item.config.fieldGroups[].fields. Every choice option id needs a matching top-level translation whose contentKey is options.<optionId>.label.");
+		if (issueCodes.has("too-many-operations")) lines.push("Recovery hint: keep the same inspected survey context and immediately split these edits into smaller survey_change calls. Use continuationMode \"replace\" on the first repaired chunk, then \"append\" on every later independent chunk. Do not claim that a new snapshot is needed unless a tool explicitly reported a missing snapshot.");
+		if (issueCodes.has("change-mode-required")) lines.push("Recovery hint: retry the complete intended proposal with continuationMode \"append\" for independent additional work or \"replace\" for a correction. Nothing from the ambiguous sequence is currently authorized.");
+		if (issueCodes.has("change-mode-repair-required")) lines.push("Recovery hint: the turn remains blocked. Retry the complete intended proposal with continuationMode \"replace\". Only a validated replacement clears the block; after that, use \"append\" for later independent chunks.");
+	}
+	if (event.validation.warnings.length > 0) {
+		lines.push("Warnings:");
+		for (const warning of event.validation.warnings) lines.push(`- ${warning.code}: ${warning.message}`);
+	}
+	return lines.join("\n");
+};
+const surveyChangeTool = createTool({
+	id: TOOL_ID$9,
+	description: "Validate and queue one final, bounded, undoable survey change. This is not a dry run and does not mutate the live snapshot during the response. Put related operations and newly created dependencies in one call, in dependency order; embed expressions on new dependent items. Omit continuationMode only on the first mutation call in a turn; every later mutation call must use \"append\" for independent additional work or \"replace\" for a correction. Every operation uses \"kind\". A create-item has top-level target, item, and translations.",
+	inputSchema: inputSchema$9,
+	outputSchema: surveyChangeSetSchema,
+	mcp: { annotations: {
+		title: "Prepare survey change",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: false,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const { changeCollector, turnId } = requireSurveyAssistantTurnState(context?.requestContext);
+		const snapshot = context?.requestContext?.get("engineContext");
+		const defaultLocale = snapshot?.ui.selectedLocale ?? snapshot?.inspection.locales[0] ?? "en";
+		const continuationMode = inputData.continuationMode ?? void 0;
+		const operationsParse = z.array(surveyOperationSchema).safeParse(normalizeSurveyChangeOperations(inputData.operations, defaultLocale));
+		if (!operationsParse.success) return changeCollector.register(rejectedOperationParseEvent({
+			summary: inputData.summary,
+			turnId,
+			issueText: operationsParse.error.issues.slice(0, 8).map((issue) => `${issue.path.join(".") || "operation"}: ${issue.message}`).join("; ")
+		}), { continuationMode });
+		const event = createSurveyChangeSet({
+			operations: operationsParse.data,
+			snapshot,
+			summary: inputData.summary,
+			turnId
+		});
+		return changeCollector.register(event, { continuationMode });
+	},
+	toModelOutput: (value) => toTextModelOutput(value, summarizeValidation)
+});
+//#endregion
+//#region src/server/tools/survey-expression-tool.ts
+const TOOL_ID$8 = "survey_expression";
+const contextActionSchema = z.object({
+	action: z.literal("context"),
+	reason: z.string().max(500).optional(),
+	itemIds: z.array(z.string().min(1).max(240)).max(12).optional(),
+	includeRawLocations: z.boolean().optional()
+});
+const continuationModeSchema = z.enum(SURVEY_CHANGE_CONTINUATION_MODES).optional().describe(SURVEY_CHANGE_CONTINUATION_DESCRIPTION);
+const prepareActionSchema = z.object({
+	action: z.literal("prepare"),
+	intent: z.string().min(1).max(500),
+	summary: z.string().min(1).max(500),
+	mutations: z.array(expressionMutationSchema).min(1).max(40),
+	continuationMode: continuationModeSchema,
+	inspectedContext: z.array(z.string().max(240)).max(20).optional()
+});
+const inputSchema$8 = z.object({
+	action: z.enum(["context", "prepare"]).describe("Use context to inspect expression refs; use prepare to create expression edits."),
+	reason: z.string().max(500).optional(),
+	itemIds: z.array(z.string().min(1).max(240)).max(12).optional().describe("For context: optional item ids/keys to focus existing expression locations."),
+	includeRawLocations: z.boolean().optional().describe("For context: include existing expression locations by raw item."),
+	intent: z.string().min(1).max(500).optional().describe("For prepare: requested expression edit."),
+	summary: z.string().min(1).max(500).optional().describe("For prepare: user-facing summary."),
+	mutations: z.array(z.record(z.string(), z.unknown())).min(1).max(40).optional().describe("For prepare: expression mutation objects using kebab-case kind names. Item visibility shape: { kind: \"set-item-display-condition\", itemId: \"<existing-item-id>\", expression: { type: \"function\", functionName: \"eq\", arguments: [...] } }. expression is always CASE expression JSON, never a string or expression-language snippet. Other supported kinds set/clear component display/disabled conditions, validation expressions, prefills, and template values."),
+	continuationMode: continuationModeSchema,
+	inspectedContext: z.array(z.string().max(240)).max(20).optional()
+}).superRefine((value, ctx) => {
+	if (value.action !== "prepare") return;
+	if (!value.intent) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["intent"],
+		message: "Required for prepare."
+	});
+	if (!value.summary) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["summary"],
+		message: "Required for prepare."
+	});
+	if (!value.mutations?.length) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["mutations"],
+		message: "At least one mutation is required for prepare."
+	});
+});
+const contextOutputSchema = z.object({
+	ok: z.boolean(),
+	action: z.literal("context"),
+	modelSummary: z.string(),
+	responseSlots: z.array(z.object({
+		ref: z.string(),
+		valueType: z.string().optional()
+	})),
+	expressionLocations: z.array(z.object({
+		itemId: z.string(),
+		key: z.string(),
+		itemType: z.string(),
+		rawIndex: z.number().int().nonnegative(),
+		locations: z.array(z.string())
+	})).optional()
+});
+const outputSchema$7 = z.union([contextOutputSchema, surveyChangeSetSchema]);
+const createIssue = ({ severity = "error", ...input }) => ({
+	severity,
+	...input
+});
+const buildResponseSlotTypes = (snapshot) => snapshot.responseSlotTypes;
+const rejectedEvent = ({ issues, summary, turnId, warnings = [] }) => ({
+	protocolVersion: 1,
+	id: randomUUID(),
+	turnId,
+	status: "rejected",
+	summary,
+	operations: [],
+	validation: {
+		valid: false,
+		issues,
+		warnings,
+		normalizedOperations: []
+	},
+	createdAt: (/* @__PURE__ */ new Date()).toISOString()
+});
+const summarizeDraftEvent = (event) => {
+	const lines = [`${event.status === "validated" ? "Validated" : "Rejected"} expression change: ${event.summary}`, `Change id: ${event.id}`];
+	if (event.operations.length > 0) lines.push(`Operations: ${event.operations.map((operation) => operation.kind).join(", ")}`);
+	if (event.status === "rejected") lines.push("Apply status: this turn is blocked and will authorize no survey changes unless a later complete proposal validates with continuationMode \"replace\".");
+	if (event.supersedesChangeIds?.length) lines.push(event.status === "validated" ? `Queue: replaces ${event.supersedesChangeIds.length} earlier candidate proposal(s) from this response.` : `Queue: discarded ${event.supersedesChangeIds.length} earlier candidate proposal(s); their work is not retained or authorized.`);
+	if (event.validation.issues.length > 0) {
+		lines.push("Issues:");
+		for (const issue of event.validation.issues) lines.push(`- ${issue.code}: ${issue.message}`);
+		const issueCodes = new Set(event.validation.issues.map((issue) => issue.code));
+		if (issueCodes.has("change-mode-required")) lines.push("Recovery hint: retry the complete intended proposal with continuationMode \"append\" for independent additional work or \"replace\" for a correction. Nothing from the ambiguous sequence is currently authorized.");
+		if (issueCodes.has("change-mode-repair-required")) lines.push("Recovery hint: the turn remains blocked. Retry the complete intended proposal with continuationMode \"replace\". Only a validated replacement clears the block; after that, use \"append\" for later independent chunks.");
+	}
+	if (event.validation.warnings.length > 0) {
+		lines.push("Warnings:");
+		for (const warning of event.validation.warnings) lines.push(`- ${warning.code}: ${warning.message}`);
+	}
+	return lines.join("\n");
+};
+const buildContextOutput = (snapshot, input) => {
+	const rawItems = getRawSurveyItems(snapshot);
+	const responseSlotTypes = buildResponseSlotTypes(snapshot);
+	const responseSlots = Object.entries(responseSlotTypes).map(([ref, valueType]) => ({
+		ref,
+		...valueType ? { valueType } : {}
+	}));
+	const itemFilter = input.action === "context" && input.itemIds?.length ? new Set(input.itemIds) : void 0;
+	const expressionLocations = input.action === "context" && input.includeRawLocations === true ? rawItems.map((item, rawIndex) => {
+		if (itemFilter && !itemFilter.has(item.id) && !itemFilter.has(item.key)) return;
+		const locations = [
+			item.displayConditions?.root ? "displayConditions.root" : void 0,
+			...Object.keys(item.displayConditions?.components ?? {}).map((componentId) => `displayConditions.components.${componentId}`),
+			...Object.keys(item.disabledConditions?.components ?? {}).map((componentId) => `disabledConditions.components.${componentId}`),
+			...Object.keys(item.validations ?? {}).map((validationKey) => `validations.${validationKey}`),
+			...(item.prefills ?? []).map((prefill) => `prefills.${prefill.id}`)
+		].filter((location) => Boolean(location));
+		return {
+			itemId: item.id,
+			key: item.key,
+			itemType: item.itemType,
+			rawIndex,
+			locations
+		};
+	}).filter((entry) => Boolean(entry)) : void 0;
+	return {
+		ok: true,
+		action: "context",
+		modelSummary: [
+			"Expression capability loaded.",
+			"Use prepare mutations for display conditions, disabled conditions, validations, prefills, and template values.",
+			"Display, disabled, validation, and prefill.when expressions must return boolean.",
+			"Use response refs exactly as listed and check their value types before choosing functions.",
+			"For choice options: use eq(response reference, reference const) when the slot type is reference; use list_contains(response reference[], reference const) only when the slot type is reference[].",
+			`Response slots (${responseSlots.length}): ${responseSlots.slice(0, 80).map((slot) => `${slot.ref}${slot.valueType ? `:${slot.valueType}` : ""}`).join(", ")}`,
+			responseSlots.length > 80 ? "Response slot list truncated in summary; inspect context result for more." : void 0,
+			"Functions: and, or, not, eq, gt, gte, lt, lte, in_range, list_contains, sum, min, max, str_eq, date_eq.",
+			expressionLocations ? `Existing expression locations: ${expressionLocations.filter((entry) => entry.locations.length > 0).map((entry) => `${entry.key}(${entry.itemId}) -> ${entry.locations.join("|")}`).join("; ") || "none"}` : void 0
+		].filter((line) => Boolean(line)).join("\n"),
+		responseSlots,
+		...expressionLocations ? { expressionLocations } : {}
+	};
+};
+const surveyExpressionTool = createTool({
+	id: TOOL_ID$8,
+	description: "Inspect response refs or queue expression edits for CASE survey items already present in the live snapshot. Covers display and disabled conditions, validations, prefills, and template values. Newly proposed items are not visible until the response ends; embed their expressions in the same survey_change call that creates them. For prepare, omit continuationMode only on the first mutation call in a turn; every later mutation call must use \"append\" or \"replace\".",
+	inputSchema: inputSchema$8,
+	outputSchema: outputSchema$7,
+	mcp: { annotations: {
+		title: "Work with expressions",
+		readOnlyHint: false,
+		destructiveHint: false,
+		idempotentHint: false,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const input = inputData;
+		const requestContext = context?.requestContext;
+		const snapshot = context?.requestContext?.get("engineContext");
+		if (!snapshot) {
+			if (input.action === "context") return {
+				ok: false,
+				action: "context",
+				modelSummary: "No live editor snapshot is available for expression work.",
+				responseSlots: []
+			};
+			const { changeCollector, turnId } = requireSurveyAssistantTurnState(requestContext);
+			return changeCollector.register(rejectedEvent({
+				summary: input.summary ?? "Expression change",
+				turnId,
+				issues: [createIssue({
+					code: "missing-snapshot",
+					message: "No live editor snapshot is available for expression work."
+				})]
+			}), { continuationMode: input.continuationMode });
+		}
+		if (input.action === "context") {
+			const contextParse = contextActionSchema.safeParse(inputData);
+			return buildContextOutput(snapshot, contextParse.success ? contextParse.data : input);
+		}
+		const { changeCollector, turnId } = requireSurveyAssistantTurnState(requestContext);
+		const register = (event) => changeCollector.register(event, { continuationMode: input.continuationMode });
+		const prepareParse = prepareActionSchema.safeParse(inputData);
+		if (!prepareParse.success) return register(rejectedEvent({
+			summary: input.summary ?? "Expression change",
+			turnId,
+			issues: [createIssue({
+				code: "invalid-expression-mutation-shape",
+				message: prepareParse.error.issues.slice(0, 8).map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; ")
+			})]
+		}));
+		const prepareInput = prepareParse.data;
+		const issues = [];
+		const patches = [];
+		const responseSlotTypes = buildResponseSlotTypes(snapshot);
+		prepareInput.mutations.forEach((mutation, operationIndex) => {
+			buildExpressionMutationPatches({
+				mutation,
+				operationIndex,
+				issues,
+				patches,
+				responseSlotTypes,
+				snapshot
+			});
+		});
+		const errors = issues.filter((issue) => issue.severity === "error");
+		const warnings = issues.filter((issue) => issue.severity === "warning");
+		if (errors.length > 0) return register(rejectedEvent({
+			summary: prepareInput.summary,
+			turnId,
+			issues: errors,
+			warnings
+		}));
+		if (patches.length === 0) return register(rejectedEvent({
+			summary: prepareInput.summary,
+			turnId,
+			issues: [createIssue({
+				code: "no-expression-patches",
+				message: "No expression patches were produced. Check whether the requested locations already match the target state."
+			})],
+			warnings
+		}));
+		const event = createSurveyChangeSet({
+			operations: [{
+				kind: "survey-json-patch",
+				patches
+			}],
+			snapshot,
+			summary: prepareInput.summary,
+			turnId
+		});
+		return register({
+			...event,
+			validation: {
+				...event.validation,
+				warnings: [...event.validation.warnings, ...warnings]
+			}
+		});
+	},
+	toModelOutput: (value) => toTextModelOutput(value, (output) => "action" in output && output.action === "context" ? output.modelSummary : summarizeDraftEvent(output))
+});
+//#endregion
+//#region src/server/tools/survey-get-current-context-tool.ts
+const TOOL_ID$7 = "survey_get_current_context";
+const contextScopeSchema = z.enum([
+	"summary",
+	"selected-item",
+	"outline",
+	"response-slots",
+	"ui-context",
+	"history"
+]);
+const outlineModeSchema$1 = z.enum([
+	"full",
+	"focused",
+	"children"
+]);
+const translationSnippetSchema = z.object({
+	locale: z.string(),
+	contentKey: z.string(),
+	text: z.string()
+});
+const inputSchema$7 = z.object({
+	scopes: z.array(contextScopeSchema).min(1).default(["summary"]).describe("Which current editor context sections to inspect."),
+	itemId: z.string().optional().describe("Optional item id to inspect. Defaults to the selected/focused item."),
+	query: z.string().max(160).optional().describe("Optional text used to find matching item ids, keys, labels, or response slots."),
+	cursor: z.string().optional().describe("Optional numeric cursor returned by a previous outline or response slot request."),
+	outlineMode: outlineModeSchema$1.default("full").optional().describe("For outline scope: \"full\" pages the complete survey key index, \"focused\" returns the selected/focused neighborhood, and \"children\" returns direct children of itemId."),
+	limit: z.number().int().min(1).max(50).default(12).describe("Maximum number of rows to return for list-like scopes.")
+});
+const outputSchema$6 = z.object({
+	ok: z.boolean(),
+	reason: z.string().optional(),
+	revision: z.number().int().nonnegative().optional(),
+	contentHash: z.string().optional(),
+	scopes: z.array(contextScopeSchema).optional(),
+	summary: z.object({
+		sessionId: z.string().nullable(),
+		view: z.string(),
+		selectedItemId: z.string().optional(),
+		focusItemId: z.string().optional(),
+		selectedLocale: z.string(),
+		recentItemIds: z.array(z.string()),
+		surveyKey: z.string().optional(),
+		locales: z.array(z.string()),
+		itemCount: z.number().int().nonnegative(),
+		historyIndex: z.number().int(),
+		outlineItemCount: z.number().int().nonnegative(),
+		responseSlotCount: z.number().int().nonnegative(),
+		rootItem: itemSummarySchema.optional(),
+		availableItemTypes: z.array(z.string()),
+		deterministicCreateItemTypes: z.array(z.string()),
+		itemTypeDetails: z.array(assistantItemTypeManifestSchema)
+	}).optional(),
+	selectedItem: z.object({
+		available: z.boolean(),
+		reason: z.string().optional(),
+		requestedItemId: z.string().optional(),
+		item: itemSummarySchema.optional(),
+		relationSource: z.string().optional(),
+		pathItems: z.array(itemSummarySchema).optional(),
+		siblingItems: z.array(itemSummarySchema).optional(),
+		childItems: z.array(itemSummarySchema).optional(),
+		translationSnippets: z.array(translationSnippetSchema).optional(),
+		descendantItems: z.array(itemSummarySchema).optional(),
+		descendantCount: z.number().int().nonnegative().optional(),
+		descendantsTruncated: z.boolean().optional()
+	}).optional(),
+	outline: z.object({
+		strategy: z.string(),
+		mode: outlineModeSchema$1.optional(),
+		query: z.string().optional(),
+		requestedItemId: z.string().optional(),
+		totalAvailable: z.number().int().nonnegative(),
+		returned: z.number().int().nonnegative(),
+		nextCursor: z.string().optional(),
+		truncated: z.boolean(),
+		items: z.array(itemSummarySchema),
+		note: z.string().optional()
+	}).optional(),
+	responseSlots: z.object({
+		available: z.boolean(),
+		query: z.string().optional(),
+		totalAvailable: z.number().int().nonnegative(),
+		returned: z.number().int().nonnegative(),
+		nextCursor: z.string().optional(),
+		truncated: z.boolean(),
+		slots: z.array(z.string()),
+		note: z.string().optional()
+	}).optional(),
+	uiContext: z.object({
+		activeSurface: z.string().optional(),
+		openPanels: z.array(z.string()),
+		highlights: z.array(z.object({
+			kind: z.string(),
+			itemId: z.string().optional(),
+			componentId: z.string().optional(),
+			label: z.string().optional(),
+			details: z.string().optional()
+		}))
+	}).optional(),
+	history: z.object({
+		currentIndex: z.number().int(),
+		totalEntries: z.number().int().nonnegative(),
+		canUndo: z.boolean(),
+		canRedo: z.boolean(),
+		recent: z.array(z.object({
+			index: z.number().int(),
+			kind: z.enum(["survey-snapshot", "asset-change"]),
+			label: z.string(),
+			source: z.enum([
+				"user",
+				"system",
+				"assistant"
+			]).optional(),
+			timestamp: z.number(),
+			isCurrent: z.boolean()
+		}))
+	}).optional()
+});
+const findFocusItemNode = (node, itemId) => {
+	if (!node) return;
+	if (node.itemId === itemId) return node;
+	for (const descendant of node.descendants) {
+		const match = findFocusItemNode(descendant, itemId);
+		if (match) return match;
+	}
+};
+const flattenFocusDescendants = (node) => {
+	const descendants = [];
+	const visit = (current) => {
+		for (const descendant of current.descendants) {
+			descendants.push(descendant);
+			visit(descendant);
+		}
+	};
+	visit(node);
+	return descendants;
+};
+const getCandidateItems = (snapshot) => {
+	const outlineById = mapOutlineById(snapshot);
+	return summarizeKeyIndexEntries(getKeyIndexEntries(snapshot), outlineById);
+};
+const buildSummary = (snapshot) => ({
+	rootItem: snapshot.inspection.outline.filter((item) => item.depth === 0).map(summarizeOutlineNode)[0],
+	sessionId: snapshot.version.sessionId,
+	view: snapshot.ui.view,
+	selectedItemId: snapshot.ui.selectedItemId,
+	focusItemId: snapshot.ui.focusItemId,
+	selectedLocale: snapshot.ui.selectedLocale,
+	recentItemIds: snapshot.ui.recentItemIds ?? [],
+	surveyKey: snapshot.inspection.surveyKey,
+	locales: snapshot.inspection.locales,
+	itemCount: snapshot.inspection.itemCount,
+	historyIndex: snapshot.version.historyIndex,
+	outlineItemCount: snapshot.inspection.keyIndex.length,
+	responseSlotCount: snapshot.inspection.responseSlots.length,
+	availableItemTypes: snapshot.capabilities.itemTypes.map((entry) => entry.itemType),
+	deterministicCreateItemTypes: getDeterministicCreateItemTypes(snapshot.capabilities),
+	itemTypeDetails: snapshot.capabilities.itemTypes
+});
+const buildSelectedItem = (snapshot, input) => {
+	const outlineById = mapOutlineById(snapshot);
+	const indexById = mapKeyIndexById(snapshot);
+	const resolvedInputItem = input.itemId ? resolveItemSummary(input.itemId, indexById, outlineById) : void 0;
+	const requestedItemId = resolvedInputItem?.itemId ?? input.itemId ?? snapshot.ui.selectedItemId ?? snapshot.ui.focusItemId;
+	if (!requestedItemId) return {
+		available: false,
+		reason: "No item is currently selected or focused in the editor."
+	};
+	const focusNode = findFocusItemNode(snapshot.inspection.focusItem, requestedItemId);
+	const item = focusNode ? summarizeFocusItemNode(focusNode, outlineById) : resolvedInputItem ?? summarizeItemById(requestedItemId, indexById, outlineById);
+	if (!item) return {
+		available: false,
+		requestedItemId,
+		reason: "The requested item is not present in the current context snapshot."
+	};
+	const limit = clampLimit(input.limit);
+	const descendants = focusNode ? flattenFocusDescendants(focusNode) : [];
+	return {
+		available: true,
+		requestedItemId,
+		item,
+		relationSource: snapshot.inspection.focus?.focusItemId === requestedItemId ? "selected-focus" : focusNode ? "focused-subtree" : "key-index",
+		pathItems: snapshot.inspection.focus?.pathItemIds?.map((itemId) => summarizeItemById(itemId, indexById, outlineById)).filter((entry) => Boolean(entry)),
+		siblingItems: snapshot.inspection.focus?.siblingItemIds?.map((itemId) => summarizeItemById(itemId, indexById, outlineById)).filter((entry) => Boolean(entry)),
+		childItems: snapshot.inspection.focus?.childItemIds?.map((itemId) => summarizeItemById(itemId, indexById, outlineById)).filter((entry) => Boolean(entry)),
+		translationSnippets: focusNode?.translations.slice(0, limit),
+		descendantItems: descendants.slice(0, limit).map((descendant) => summarizeFocusItemNode(descendant, outlineById)),
+		descendantCount: descendants.length,
+		descendantsTruncated: descendants.length > limit || snapshot.inspection.focusItemTreeTruncated
+	};
+};
+const buildOutline = (snapshot, input) => {
+	const query = normalizeText(input.query);
+	const outlineById = mapOutlineById(snapshot);
+	const indexById = mapKeyIndexById(snapshot);
+	const resolvedInputItem = input.itemId ? resolveItemSummary(input.itemId, indexById, outlineById) : void 0;
+	const requestedItemId = resolvedInputItem?.itemId ?? input.itemId ?? snapshot.ui.focusItemId ?? snapshot.ui.selectedItemId;
+	const outlineMode = input.outlineMode ?? "full";
+	let strategy = "focused-snapshot-outline";
+	let items;
+	let note;
+	if (query) {
+		strategy = "query-match";
+		items = getCandidateItems(snapshot).filter((item) => itemMatchesQuery(item, query));
+	} else if (outlineMode === "children" && requestedItemId) {
+		strategy = "direct-children";
+		const parent = resolvedInputItem ?? summarizeItemById(requestedItemId, indexById, outlineById);
+		items = parent ? findDirectChildrenByFullKey(getKeyIndexEntries(snapshot), outlineById, parent.fullKey) : [];
+		if (!parent) note = "The requested item could not be resolved by item id, key, or fullKey.";
+	} else if (outlineMode === "focused" && requestedItemId && snapshot.inspection.focus?.focusItemId === requestedItemId) {
+		const focus = snapshot.inspection.focus;
+		const descendantIds = snapshot.inspection.focusItem ? flattenFocusDescendants(snapshot.inspection.focusItem).map((item) => item.itemId) : [];
+		items = unique([
+			...focus.pathItemIds,
+			requestedItemId,
+			...focus.childItemIds,
+			...focus.siblingItemIds,
+			...descendantIds
+		]).map((itemId) => summarizeItemById(itemId, indexById, outlineById)).filter((entry) => Boolean(entry));
+	} else if (outlineMode === "focused" && requestedItemId) {
+		strategy = "item-match";
+		const item = resolvedInputItem ?? summarizeItemById(requestedItemId, indexById, outlineById);
+		items = item ? [item] : [];
+		note = "The requested item is outside the selected focus tree in this snapshot.";
+	} else {
+		strategy = "full-key-index";
+		items = getCandidateItems(snapshot);
+	}
+	const page = sliceWithCursor(items, input);
+	return {
+		strategy,
+		mode: outlineMode,
+		query: input.query,
+		requestedItemId,
+		totalAvailable: items.length,
+		returned: page.items.length,
+		nextCursor: page.nextCursor,
+		truncated: page.truncated,
+		items: page.items,
+		note
+	};
+};
+const buildResponseSlots = (snapshot, input) => {
+	const responseSlots = snapshot.inspection.responseSlots;
+	const query = normalizeText(input.query);
+	const filtered = query ? responseSlots.filter((slot) => slot.toLowerCase().includes(query)) : responseSlots;
+	const page = sliceWithCursor(filtered, input);
+	return {
+		available: true,
+		query: input.query,
+		totalAvailable: filtered.length,
+		returned: page.items.length,
+		nextCursor: page.nextCursor,
+		truncated: page.truncated,
+		slots: page.items
+	};
+};
+const summarizeForModel$3 = (output) => {
+	if (!output.ok) return output.reason ?? "Current editor context is unavailable.";
+	const lines = [`Snapshot revision ${output.revision}, content hash ${output.contentHash}.`];
+	if (output.summary) {
+		const selected = output.summary.selectedItemId ?? "none";
+		const surveyKey = output.summary.surveyKey ?? "not set";
+		lines.push(`Summary: view=${output.summary.view}; selectedItemId=${selected}; locale=${output.summary.selectedLocale}; surveyKey=${surveyKey}; itemCount=${output.summary.itemCount}.`);
+		if (output.summary.rootItem) lines.push(`Root group for top-level create-item target.parentItemId: ${output.summary.rootItem.fullKey} (id=${output.summary.rootItem.itemId}, key=${output.summary.rootItem.key}).`);
+		lines.push(`Outline access: ${output.summary.outlineItemCount} item(s) are pageable.`);
+		const creatableDetails = output.summary.itemTypeDetails.filter((entry) => entry.create === "deterministic").map((entry) => {
+			const primarySurface = entry.contentSurfaces.find((surface) => surface.role === "primary");
+			const fixedSurfaces = entry.contentSurfaces.filter((surface) => !surface.pattern).map((surface) => surface.key);
+			const patterns = entry.contentSurfaces.filter((surface) => surface.pattern).map((surface) => surface.key);
+			const contentKeys = [
+				primarySurface ? `primary=${primarySurface.key}` : void 0,
+				fixedSurfaces.length ? `visible=${fixedSurfaces.join("|")}` : void 0,
+				patterns.length ? `dynamic=${patterns.join("|")}` : void 0
+			].filter((value) => Boolean(value)).join("; ");
+			return contentKeys ? `${entry.itemType} (${contentKeys})` : entry.itemType;
+		});
+		if (creatableDetails.length > 0) lines.push(`Creatable item types: ${creatableDetails.join(", ")}.`);
+	}
+	if (output.selectedItem) if (output.selectedItem.available && output.selectedItem.item) {
+		lines.push(`Selected item: ${output.selectedItem.item.fullKey} (${output.selectedItem.item.itemType})${output.selectedItem.item.itemLabel ? ` - ${output.selectedItem.item.itemLabel}` : ""}.`);
+		if (output.selectedItem.translationSnippets?.length) lines.push(`Translation snippets: ${output.selectedItem.translationSnippets.map((entry) => `${entry.locale}.${entry.contentKey}: ${entry.text}`).join("; ")}`);
+	} else lines.push(`Selected item unavailable: ${output.selectedItem.reason ?? "unknown reason"}.`);
+	if (output.outline) {
+		lines.push(`Outline (${output.outline.strategy}${output.outline.mode ? `, mode=${output.outline.mode}` : ""}): ${output.outline.returned}/${output.outline.totalAvailable} rows returned.`);
+		for (const item of output.outline.items) lines.push(`- ${item.fullKey} (${item.itemType})${item.itemLabel ? ` - ${item.itemLabel}` : ""}`);
+		if (output.outline.nextCursor) lines.push(`More outline rows are available with cursor ${output.outline.nextCursor}.`);
+	}
+	if (output.responseSlots) lines.push(output.responseSlots.available ? `Response slots: ${output.responseSlots.slots.join(", ") || "none"}` : `Response slots unavailable: ${output.responseSlots.note ?? "not indexed"}.`);
+	if (output.uiContext) lines.push(`UI context: activeSurface=${output.uiContext.activeSurface ?? "not provided"}; openPanels=${output.uiContext.openPanels.join(", ") || "none"}; highlights=${output.uiContext.highlights.map((entry) => entry.label ?? entry.itemId ?? entry.componentId ?? entry.kind).join(", ") || "none"}.`);
+	if (output.history) lines.push(`Recent editor history (${output.history.currentIndex + 1}/${output.history.totalEntries}): ${output.history.recent.map((entry) => `${entry.index}:${entry.label}${entry.isCurrent ? " [current]" : ""}`).join("; ") || "none"}.`);
+	return lines.join("\n");
+};
+const surveyGetCurrentContextTool = createTool({
+	id: TOOL_ID$7,
+	description: "Read the current Survey Editor context from the latest request snapshot. Use for questions about this screen, selected item, survey outline, item keys, labels, locales, or response slots. The outline scope can page the complete survey key index, so use cursor/limit instead of guessing when a focused outline is truncated.",
+	inputSchema: inputSchema$7,
+	outputSchema: outputSchema$6,
+	mcp: { annotations: {
+		title: "Get current survey context",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const input = {
+			...inputData,
+			scopes: inputData.scopes ?? ["summary"],
+			limit: inputData.limit ?? 12,
+			outlineMode: inputData.outlineMode ?? "full"
+		};
+		const snapshot = context?.requestContext?.get("engineContext");
+		if (!snapshot) return {
+			ok: false,
+			reason: "No live editor snapshot was provided with this assistant turn.",
+			scopes: input.scopes
+		};
+		const scopes = unique(input.scopes);
+		const output = {
+			ok: true,
+			revision: snapshot.version.revision,
+			contentHash: snapshot.version.contentHash,
+			scopes
+		};
+		if (scopes.includes("summary")) output.summary = buildSummary(snapshot);
+		if (scopes.includes("selected-item")) output.selectedItem = buildSelectedItem(snapshot, input);
+		if (scopes.includes("outline")) output.outline = buildOutline(snapshot, input);
+		if (scopes.includes("response-slots")) output.responseSlots = buildResponseSlots(snapshot, input);
+		if (scopes.includes("ui-context")) output.uiContext = {
+			activeSurface: snapshot.ui.activeSurface,
+			openPanels: snapshot.ui.openPanels ?? [],
+			highlights: snapshot.ui.highlights ?? []
+		};
+		if (scopes.includes("history") && snapshot.ui.history) output.history = snapshot.ui.history;
+		return output;
+	},
+	toModelOutput: (value) => toTextModelOutput(value, summarizeForModel$3)
+});
+//#endregion
+//#region src/server/tools/survey-get-item-details-tool.ts
+const TOOL_ID$6 = "survey_get_item_details";
+const DEFAULT_TEXT_LIMIT$1 = 400;
+const MAX_TEXT_LIMIT = 2e3;
+const DEFAULT_CHILDREN_LIMIT = 20;
+const inputSchema$6 = z.object({
+	itemId: z.string().describe("Identifier of the item to inspect: its itemId, key (e.g. \"info_1\"), or fullKey (e.g. \"survey.info_1\"). Discover candidates first via survey_inspect search or current context."),
+	locales: z.array(z.string()).optional().describe("Optional locale codes to restrict returned translations to. Defaults to all locales."),
+	textLimit: z.number().int().min(20).max(MAX_TEXT_LIMIT).default(DEFAULT_TEXT_LIMIT$1).describe("Maximum characters returned per translation snippet."),
+	includeChildren: z.boolean().optional().describe("Deprecated alias for includeSurveyChildren. This means survey-tree children only, not choice options or form fields."),
+	includeSurveyChildren: z.boolean().default(false).describe("Whether to include a shallow list of this item's direct survey-tree children, such as group members."),
+	includeItemConfig: z.boolean().default(true).describe("Whether to include item-internal config details such as choice options and form field groups."),
+	childrenLimit: z.number().int().min(1).max(50).default(DEFAULT_CHILDREN_LIMIT).describe("Maximum number of direct survey-tree children to return.")
+});
+const outputSchema$5 = z.object({
+	ok: z.boolean(),
+	reason: z.string().optional(),
+	item: itemSummarySchema.optional(),
+	translations: z.array(translationEntrySchema).optional(),
+	surveyChildren: z.array(itemSummarySchema).optional(),
+	surveyChildrenTruncated: z.boolean().optional(),
+	configDetails: itemConfigDetailsSchema.optional(),
+	capabilityDetails: z.object({
+		summary: z.string(),
+		details: z.unknown().optional()
+	}).optional()
+});
+const summarizeConfigDetails = (configDetails) => {
+	const lines = [`Config details (${configDetails.kind}): ${configDetails.summary.join("; ")}`];
+	if (configDetails.mainResponseSlotId) lines.push(`Main response slot: ${configDetails.mainResponseSlotId}`);
+	for (const option of configDetails.choiceOptions ?? []) {
+		lines.push(`- option ${option.key ?? option.id} (id=${option.id}, labelContentKey=${option.labelContentKey})`);
+		if (option.embeddedFormItemId || option.embeddedFormFieldGroupCount) {
+			lines.push(`  embedded form: itemId=${option.embeddedFormItemId ?? "inline"}, fieldGroups=${option.embeddedFormFieldGroupCount ?? 0}`);
+			if (option.embeddedFormTranslationPrefix || option.embeddedFormResponseSlotPrefix) lines.push(`  embedded form keys: translationPrefix=${option.embeddedFormTranslationPrefix ?? "n/a"}, responseSlotPrefix=${option.embeddedFormResponseSlotPrefix ?? "n/a"}`);
+		}
+	}
+	for (const group of configDetails.formFieldGroups ?? []) {
+		lines.push(`- field group ${group.id}: ${group.fieldCount} field(s), titleContentKey=${group.titleContentKey}, layout=${group.layout.base}/${group.layout.xs}/${group.layout.sm}/${group.layout.md}/${group.layout.xl}`);
+		if (group.hasDisplayCondition !== void 0) lines.push(`  hasDisplayCondition=${group.hasDisplayCondition ? "true" : "false"}`);
+		for (const field of group.fields) {
+			lines.push(`  - field ${field.key} (${field.type}, id=${field.id}, responseSlot=${field.responseSlotId}, labelContentKey=${field.labelContentKey})`);
+			lines.push(`    extra content keys: description=${field.descriptionContentKey}, error=${field.errorContentKey}${field.placeholderContentKey ? `, placeholder=${field.placeholderContentKey}` : ""}${field.unitContentKey ? `, unit=${field.unitContentKey}` : ""}${field.checkedLabelContentKey ? `, checkedLabel=${field.checkedLabelContentKey}` : ""}${field.uncheckedLabelContentKey ? `, uncheckedLabel=${field.uncheckedLabelContentKey}` : ""}`);
+			if (field.validationTypes?.length) lines.push(`    validations: ${field.validationTypes.join(", ")}`);
+			if (field.validationMessageContentKeys?.length) lines.push(`    validation message keys: ${field.validationMessageContentKeys.join(", ")}`);
+			if (field.selectOptions?.length) lines.push(`    select options: ${field.selectOptions.map((option) => `${option.value ?? option.id} (${option.labelContentKey})`).join(", ")}`);
+		}
+	}
+	return lines;
+};
+const summarizeForModel$2 = (output) => {
+	if (!output.ok) return output.reason ?? "Item details are unavailable.";
+	const lines = [];
+	if (output.item) lines.push(`Item: ${output.item.fullKey} (${output.item.itemType})${output.item.itemLabel ? ` - ${output.item.itemLabel}` : ""}.`);
+	if (output.translations?.length) lines.push(`Translations: ${output.translations.map((entry) => `${entry.locale}.${entry.contentKey}: ${entry.text}`).join("; ")}`);
+	else lines.push("Translations: none found for this item.");
+	if (output.surveyChildren) {
+		lines.push(`Survey-tree children (${output.surveyChildren.length}):`);
+		for (const child of output.surveyChildren) lines.push(`- ${child.fullKey} (${child.itemType})${child.itemLabel ? ` - ${child.itemLabel}` : ""}`);
+		if (output.surveyChildrenTruncated) lines.push("More children exist than were returned; narrow down or raise childrenLimit.");
+	}
+	if (output.configDetails) lines.push(...summarizeConfigDetails(output.configDetails));
+	if (output.capabilityDetails) {
+		lines.push(`Item capability: ${output.capabilityDetails.summary}`);
+		if (output.capabilityDetails.details !== void 0) lines.push(`Capability details: ${JSON.stringify(output.capabilityDetails.details)}`);
+	}
+	return lines.join("\n");
+};
+const surveyGetItemDetailsTool = createTool({
+	id: TOOL_ID$6,
+	description: "Fetch full details for a SPECIFIC survey item, whether or not it is currently selected. Returns item translations plus item-internal config details such as choice options and form fields. Use survey_search_items first when you only know visible text.",
+	inputSchema: inputSchema$6,
+	outputSchema: outputSchema$5,
+	mcp: { annotations: {
+		title: "Get survey item details",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const input = {
+			...inputData,
+			textLimit: inputData.textLimit ?? DEFAULT_TEXT_LIMIT$1,
+			includeSurveyChildren: inputData.includeSurveyChildren ?? inputData.includeChildren ?? false,
+			includeItemConfig: inputData.includeItemConfig ?? true,
+			childrenLimit: inputData.childrenLimit ?? DEFAULT_CHILDREN_LIMIT
+		};
+		const snapshot = context?.requestContext?.get("engineContext");
+		if (!snapshot) return {
+			ok: false,
+			reason: "No live editor snapshot was provided with this assistant turn."
+		};
+		const outlineById = mapOutlineById(snapshot);
+		const indexById = mapKeyIndexById(snapshot);
+		const rawItemsById = mapRawItemsById(snapshot);
+		const item = resolveItemSummary(input.itemId, indexById, outlineById);
+		if (!item) return {
+			ok: false,
+			reason: `No item matching "${input.itemId}" (by itemId, key, or fullKey) was found in the current context snapshot.`
+		};
+		const output = {
+			ok: true,
+			item,
+			translations: buildItemTranslationEntries(snapshot, item.itemId, input)
+		};
+		if (input.includeSurveyChildren) {
+			const allChildren = findDirectChildrenByFullKey(getKeyIndexEntries(snapshot), outlineById, item.fullKey);
+			const limit = clampLimit(input.childrenLimit);
+			output.surveyChildren = allChildren.slice(0, limit);
+			output.surveyChildrenTruncated = allChildren.length > limit;
+		}
+		if (input.includeItemConfig) {
+			const rawItem = rawItemsById.get(item.itemId);
+			output.configDetails = rawItem ? buildItemConfigDetails(rawItem) : void 0;
+			output.capabilityDetails = rawItem ? inspectAssistantItem({
+				capabilities: snapshot.trustedCapabilities,
+				item: rawItem
+			}) : void 0;
+			if (rawItem?.itemType === "choiceItem" && output.configDetails?.choiceOptions) {
+				const rawConfig = rawItem.config && typeof rawItem.config === "object" && !Array.isArray(rawItem.config) ? rawItem.config : void 0;
+				const rawOptions = Array.isArray(rawConfig?.options) ? rawConfig.options : [];
+				for (const option of output.configDetails.choiceOptions) {
+					const rawOption = rawOptions.find((candidate) => candidate && typeof candidate === "object" && "id" in candidate && candidate.id === option.id);
+					const embeddedFormDetails = buildEmbeddedFormDetails(option, rawOption && typeof rawOption === "object" && "embeddedForm" in rawOption ? rawOption.embeddedForm : void 0);
+					if (embeddedFormDetails?.formFieldGroups?.length) output.configDetails.formFieldGroups = [...output.configDetails.formFieldGroups ?? [], ...embeddedFormDetails.formFieldGroups];
+				}
+			}
+		}
+		return output;
+	},
+	toModelOutput: (value) => toTextModelOutput(value, summarizeForModel$2)
+});
+//#endregion
+//#region src/server/tools/survey-get-raw-survey-tool.ts
+const TOOL_ID$5 = "survey_get_raw_survey";
+const DEFAULT_VALUE_CHARACTER_LIMIT = 12e3;
+const MAX_VALUE_CHARACTER_LIMIT = 6e4;
+const jsonPointerPathSchema = z.string().max(500).describe("JSON Pointer path into the survey document. Examples: \"/surveyItems/0/config/items\", \"/metadata\", \"/translations/en/itemTranslations/<itemId>/title\".");
+const inputSchema$5 = z.object({
+	paths: z.array(jsonPointerPathSchema).min(1).max(20).optional().describe("Optional exact JSON Pointer paths to inspect. Omit paths and itemIdentifiers for a top-level raw survey overview."),
+	itemIdentifiers: z.array(z.string().min(1).max(240)).min(1).max(20).optional().describe("Optional item ids, keys, or fullKeys to inspect. Returns exact /surveyItems/<index> paths plus item translation paths for each item."),
+	valueCharacterLimit: z.number().int().min(1e3).max(MAX_VALUE_CHARACTER_LIMIT).default(DEFAULT_VALUE_CHARACTER_LIMIT).describe("Maximum serialized characters returned per requested value.")
+});
+const rawSurveyItemPathSchema = z.object({
+	path: z.string(),
+	id: z.string(),
+	key: z.string(),
+	itemType: z.string(),
+	parentId: z.string().optional(),
+	childCount: z.number().int().nonnegative().optional()
+});
+const outputSchema$4 = z.object({
+	ok: z.boolean(),
+	reason: z.string().optional(),
+	revision: z.number().int().nonnegative().optional(),
+	contentHash: z.string().optional(),
+	overview: z.object({
+		topLevelKeys: z.array(z.string()),
+		surveyItemCount: z.number().int().nonnegative(),
+		locales: z.array(z.string()),
+		itemPaths: z.array(rawSurveyItemPathSchema),
+		note: z.string().optional()
+	}).optional(),
+	values: z.array(z.object({
+		path: z.string(),
+		found: z.boolean(),
+		value: z.unknown().optional(),
+		preview: z.string().optional(),
+		truncated: z.boolean().optional(),
+		error: z.string().optional()
+	})).optional(),
+	items: z.array(z.object({
+		identifier: z.string(),
+		found: z.boolean(),
+		itemId: z.string().optional(),
+		itemPath: z.string().optional(),
+		rawItem: z.unknown().optional(),
+		rawItemPreview: z.string().optional(),
+		rawItemTruncated: z.boolean().optional(),
+		translationPaths: z.array(z.string()).optional(),
+		translationsByLocale: z.record(z.string(), z.unknown()).optional(),
+		translationsPreview: z.string().optional(),
+		translationsTruncated: z.boolean().optional(),
+		error: z.string().optional()
+	})).optional()
+});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getGroupChildren = (item) => {
+	if (!isRecord(item) || !isRecord(item.config) || !Array.isArray(item.config.items)) return [];
+	return item.config.items.filter((entry) => typeof entry === "string");
+};
+const buildParentByChildId = (rawSurvey) => {
+	const parentByChildId = /* @__PURE__ */ new Map();
+	const rawItems = Array.isArray(rawSurvey.surveyItems) ? rawSurvey.surveyItems : [];
+	for (const item of rawItems) for (const childId of getGroupChildren(item)) parentByChildId.set(childId, item.id);
+	return parentByChildId;
+};
+const buildOverview = (snapshot) => {
+	const rawSurvey = getRawSurvey(snapshot);
+	const rawItems = getRawSurveyItems(snapshot);
+	const parentByChildId = buildParentByChildId(rawSurvey);
+	return {
+		topLevelKeys: Object.keys(rawSurvey).sort(),
+		surveyItemCount: rawItems.length,
+		locales: snapshot.inspection.locales,
+		itemPaths: rawItems.map((item, index) => ({
+			path: `/surveyItems/${index}`,
+			id: item.id,
+			key: item.key,
+			itemType: item.itemType,
+			parentId: parentByChildId.get(item.id),
+			childCount: getGroupChildren(item).length || void 0
+		})),
+		note: "Use paths with JSON Pointer syntax. Patch operations are applied relative to the survey document root, so do not prefix paths with \"/survey\"."
+	};
+};
+const toOutputValue = (value, characterLimit) => {
+	const serialized = JSON.stringify(value, null, 2) ?? "undefined";
+	if (serialized.length <= characterLimit) return {
+		value,
+		truncated: false
+	};
+	return {
+		preview: serialized.slice(0, characterLimit),
+		truncated: true
+	};
+};
+const buildValues = (snapshot, input) => {
+	const rawSurvey = getRawSurvey(snapshot);
+	return input.paths.map((path) => {
+		try {
+			return {
+				path,
+				found: true,
+				...toOutputValue(getValueAtJsonPointer(rawSurvey, path), input.valueCharacterLimit)
+			};
+		} catch (error) {
+			return {
+				path,
+				found: false,
+				error: (error instanceof JsonPatchError ? error : void 0)?.message ?? (error instanceof Error ? error.message : "The requested JSON Pointer path was not found.")
+			};
+		}
+	});
+};
+const findRawItemByIdentifier = (snapshot, identifier) => {
+	const rawItems = getRawSurveyItems(snapshot);
+	const directIndex = rawItems.findIndex((item) => item.id === identifier);
+	if (directIndex >= 0) return {
+		item: rawItems[directIndex],
+		index: directIndex
+	};
+	const resolved = resolveItemSummary(identifier, mapKeyIndexById(snapshot), mapOutlineById(snapshot));
+	if (!resolved) return;
+	const resolvedIndex = rawItems.findIndex((item) => item.id === resolved.itemId);
+	if (resolvedIndex < 0) return;
+	return {
+		item: rawItems[resolvedIndex],
+		index: resolvedIndex
+	};
+};
+const getTranslationsByLocaleForItem = (rawSurvey, itemId) => {
+	const entries = {};
+	for (const [locale, localeTranslations] of Object.entries(rawSurvey.translations ?? {})) {
+		const itemTranslations = localeTranslations?.itemTranslations?.[itemId];
+		if (itemTranslations) entries[locale] = itemTranslations;
+	}
+	return entries;
+};
+const buildItemValues = (snapshot, input) => {
+	const rawSurvey = getRawSurvey(snapshot);
+	return input.itemIdentifiers.map((identifier) => {
+		const resolved = findRawItemByIdentifier(snapshot, identifier);
+		if (!resolved) return {
+			identifier,
+			found: false,
+			error: `No item matching "${identifier}" was found by item id, key, or fullKey.`
+		};
+		const itemId = resolved.item.id;
+		const rawItemOutput = toOutputValue(resolved.item, input.valueCharacterLimit);
+		const translationsOutput = toOutputValue(getTranslationsByLocaleForItem(rawSurvey, itemId), input.valueCharacterLimit);
+		const translationsValue = "value" in translationsOutput && isRecord(translationsOutput.value) ? translationsOutput.value : void 0;
+		return {
+			identifier,
+			found: true,
+			itemId,
+			itemPath: `/surveyItems/${resolved.index}`,
+			rawItem: "value" in rawItemOutput ? rawItemOutput.value : void 0,
+			rawItemPreview: "preview" in rawItemOutput ? rawItemOutput.preview : void 0,
+			rawItemTruncated: rawItemOutput.truncated,
+			translationPaths: snapshot.inspection.locales.map((locale) => `/translations/${encodeJsonPointerSegment(locale)}/itemTranslations/${encodeJsonPointerSegment(itemId)}`),
+			translationsByLocale: translationsValue,
+			translationsPreview: "preview" in translationsOutput ? translationsOutput.preview : void 0,
+			translationsTruncated: translationsOutput.truncated
+		};
+	});
+};
+const summarizeForModel$1 = (output) => {
+	if (!output.ok) return output.reason ?? "Raw survey context is unavailable.";
+	const lines = [];
+	if (output.overview) {
+		lines.push(`Raw survey overview: ${output.overview.surveyItemCount} item(s), top-level keys ${output.overview.topLevelKeys.join(", ")}.`);
+		lines.push(`Locales: ${output.overview.locales.join(", ") || "none"}.`);
+		lines.push("Survey item JSON paths:");
+		for (const item of output.overview.itemPaths.slice(0, 50)) lines.push(`- ${item.path}: ${item.key} (${item.itemType}, id=${item.id})${item.parentId ? ` parent=${item.parentId}` : ""}`);
+		if (output.overview.itemPaths.length > 50) lines.push("More item paths exist; request a specific path for exact raw JSON.");
+	}
+	for (const item of output.items ?? []) {
+		if (!item.found) {
+			lines.push(`${item.identifier}: not found (${item.error ?? "unknown error"})`);
+			continue;
+		}
+		lines.push(`${item.identifier}: itemId=${item.itemId}; raw path ${item.itemPath}.`);
+		if (item.translationPaths?.length) lines.push(`Translation paths: ${item.translationPaths.join(", ")}.`);
+		if (item.rawItemTruncated) lines.push(`Raw item truncated preview:\n${item.rawItemPreview ?? ""}`);
+		else lines.push(`Raw item: ${JSON.stringify(item.rawItem)}`);
+		if (item.translationsTruncated) lines.push(`Translations truncated preview:\n${item.translationsPreview ?? ""}`);
+		else lines.push(`Translations by locale: ${JSON.stringify(item.translationsByLocale ?? {})}`);
+	}
+	for (const entry of output.values ?? []) {
+		if (!entry.found) {
+			lines.push(`${entry.path}: not found (${entry.error ?? "unknown error"})`);
+			continue;
+		}
+		if (entry.truncated) lines.push(`${entry.path}: truncated JSON preview:\n${entry.preview ?? ""}`);
+		else lines.push(`${entry.path}: ${JSON.stringify(entry.value)}`);
+	}
+	return lines.join("\n");
+};
+const surveyGetRawSurveyTool = createTool({
+	id: TOOL_ID$5,
+	description: "Inspect exact raw survey JSON by item id/key/fullKey or JSON Pointer path. Use this before survey-json-patch edits to inspect item config, survey-level metadata, maxItemsPerPage, templateValues, translations/locales, or group ordering arrays.",
+	inputSchema: inputSchema$5,
+	outputSchema: outputSchema$4,
+	mcp: { annotations: {
+		title: "Get raw survey JSON",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const input = {
+			...inputData,
+			valueCharacterLimit: inputData.valueCharacterLimit ?? DEFAULT_VALUE_CHARACTER_LIMIT
+		};
+		const snapshot = context?.requestContext?.get("engineContext");
+		if (!snapshot) return {
+			ok: false,
+			reason: "No live editor snapshot was provided with this assistant turn."
+		};
+		return {
+			ok: true,
+			revision: snapshot.version.revision,
+			contentHash: snapshot.version.contentHash,
+			overview: input.paths || input.itemIdentifiers ? void 0 : buildOverview(snapshot),
+			items: input.itemIdentifiers ? buildItemValues(snapshot, {
+				itemIdentifiers: input.itemIdentifiers,
+				valueCharacterLimit: input.valueCharacterLimit ?? DEFAULT_VALUE_CHARACTER_LIMIT
+			}) : void 0,
+			values: input.paths ? buildValues(snapshot, {
+				paths: input.paths,
+				valueCharacterLimit: input.valueCharacterLimit ?? DEFAULT_VALUE_CHARACTER_LIMIT
+			}) : void 0
+		};
+	},
+	toModelOutput: (value) => toTextModelOutput(value, summarizeForModel$1)
+});
+//#endregion
+//#region src/server/tools/survey-search-items-tool.ts
+const TOOL_ID$4 = "survey_search_items";
+const MAX_QUERY_LENGTH = 180;
+const MAX_MATCHES_PER_ITEM = 6;
+const DEFAULT_TEXT_LIMIT = 220;
+const searchMatchSchema = z.object({
+	source: z.enum([
+		"structure",
+		"translation",
+		"config"
+	]),
+	field: z.string().optional(),
+	locale: z.string().optional(),
+	contentKey: z.string().optional(),
+	text: z.string(),
+	score: z.number()
+});
+const searchResultSchema = z.object({
+	item: itemSummarySchema,
+	score: z.number(),
+	matches: z.array(searchMatchSchema)
+});
+const inputSchema$4 = z.object({
+	query: z.string().min(1).max(MAX_QUERY_LENGTH).describe("Text to search for across all survey items, including visible translated content such as titles, option labels, and form field labels. Examples: \"age\", \"consent\", \"blood pressure\"."),
+	itemTypes: z.array(z.string()).optional().describe("Optional item types to restrict results to, such as choiceItem or formItem."),
+	locales: z.array(z.string()).optional().describe("Optional locale codes to restrict translation-content matches to."),
+	cursor: z.string().optional().describe("Optional numeric cursor returned by a previous search."),
+	limit: z.number().int().min(1).max(50).default(12).describe("Maximum number of matching items to return.")
+});
+const outputSchema$3 = z.object({
+	ok: z.boolean(),
+	reason: z.string().optional(),
+	query: z.string().optional(),
+	totalAvailable: z.number().int().nonnegative().optional(),
+	returned: z.number().int().nonnegative().optional(),
+	nextCursor: z.string().optional(),
+	truncated: z.boolean().optional(),
+	results: z.array(searchResultSchema).optional()
+});
+const STOP_WORDS = new Set([
+	"a",
+	"about",
+	"an",
+	"and",
+	"called",
+	"choice",
+	"field",
+	"form",
+	"for",
+	"in",
+	"item",
+	"label",
+	"named",
+	"of",
+	"option",
+	"question",
+	"survey",
+	"the",
+	"this",
+	"title",
+	"titled",
+	"with"
+]);
+const normalizeSearchText = (value) => value.trim().toLowerCase().replace(/\s+/g, " ");
+const queryTerms = (query) => {
+	const terms = normalizeSearchText(query).split(/[\s.,;:!?()[\]{}"'`/\\]+/).map((term) => term.trim()).filter((term) => term.length > 1 && !STOP_WORDS.has(term));
+	if (terms.length > 0) return terms;
+	return normalizeSearchText(query).split(/[\s.,;:!?()[\]{}"'`/\\]+/).map((term) => term.trim()).filter((term) => term.length > 1);
+};
+const scoreText = (value, query, terms, baseScore) => {
+	const normalizedValue = normalizeSearchText(value);
+	const normalizedQuery = normalizeSearchText(query);
+	if (!normalizedValue || !normalizedQuery) return null;
+	if (normalizedValue === normalizedQuery) return baseScore + 80;
+	if (normalizedValue.includes(normalizedQuery)) return baseScore + 50;
+	const hitCount = terms.filter((term) => normalizedValue.includes(term)).length;
+	if (terms.length > 0 && hitCount === terms.length) return baseScore + hitCount * 12;
+	return null;
+};
+const addMatch = (matches, match) => {
+	const text = match.text?.trim();
+	if (!text) return;
+	if (!matches.some((existing) => existing.source === match.source && existing.field === match.field && existing.locale === match.locale && existing.contentKey === match.contentKey && existing.text === text)) matches.push({
+		...match,
+		text
+	});
+};
+const candidateItems = (snapshot) => {
+	const outlineById = mapOutlineById(snapshot);
+	const rawItemsById = mapRawItemsById(snapshot);
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	for (const entry of summarizeKeyIndexEntries(snapshot.inspection.keyIndex, outlineById)) {
+		seen.add(entry.itemId);
+		candidates.push({
+			item: entry,
+			rawItem: rawItemsById.get(entry.itemId)
+		});
+	}
+	for (const rawItem of rawItemsById.values()) {
+		if (seen.has(rawItem.id)) continue;
+		candidates.push({
+			item: summarizeRawItem(rawItem),
+			rawItem
+		});
+	}
+	return candidates;
+};
+const searchItems = (snapshot, input) => {
+	const terms = queryTerms(input.query);
+	const itemTypeFilter = input.itemTypes?.length ? new Set(input.itemTypes) : void 0;
+	return candidateItems(snapshot).filter(({ item }) => !itemTypeFilter || itemTypeFilter.has(item.itemType)).map(({ item, rawItem }) => {
+		const matches = [];
+		const structuralFields = [
+			["itemId", item.itemId],
+			["itemType", item.itemType],
+			["key", item.key],
+			["fullKey", item.fullKey],
+			["itemLabel", item.itemLabel],
+			["path", item.path?.join(" ")]
+		];
+		for (const [field, text] of structuralFields) {
+			if (!text) continue;
+			const score = scoreText(text, input.query, terms, 50);
+			if (score !== null) addMatch(matches, {
+				source: "structure",
+				field,
+				text,
+				score
+			});
+		}
+		for (const translation of buildItemTranslationEntries(snapshot, item.itemId, {
+			locales: input.locales,
+			textLimit: DEFAULT_TEXT_LIMIT
+		})) {
+			const score = scoreText(`${translation.contentKey} ${translation.text}`, input.query, terms, 100);
+			if (score !== null) addMatch(matches, {
+				source: "translation",
+				locale: translation.locale,
+				contentKey: translation.contentKey,
+				text: translation.text,
+				score
+			});
+		}
+		if (rawItem) for (const text of buildConfigSearchText(rawItem)) {
+			const score = scoreText(text, input.query, terms, 60);
+			if (score !== null) addMatch(matches, {
+				source: "config",
+				text,
+				score
+			});
+		}
+		if (matches.length === 0) return;
+		matches.sort((a, b) => b.score - a.score);
+		return {
+			item,
+			matches: matches.slice(0, MAX_MATCHES_PER_ITEM),
+			score: matches.reduce((sum, match) => sum + match.score, 0)
+		};
+	}).filter((result) => Boolean(result)).sort((a, b) => b.score - a.score || a.item.fullKey.localeCompare(b.item.fullKey));
+};
+const summarizeForModel = (output) => {
+	if (!output.ok) return output.reason ?? "Survey item search is unavailable.";
+	const lines = [`Search "${output.query ?? ""}": ${output.returned ?? 0}/${output.totalAvailable ?? 0} matching item(s) returned.`];
+	for (const result of output.results ?? []) {
+		lines.push(`- ${result.item.fullKey} (${result.item.itemType}, itemId=${result.item.itemId}, score=${result.score})`);
+		for (const match of result.matches) {
+			const source = match.source === "translation" ? `${match.locale}.${match.contentKey}` : match.field ?? match.source;
+			lines.push(`  match ${match.source}:${source}: ${match.text}`);
+		}
+	}
+	if (output.nextCursor) lines.push(`More search results are available with cursor ${output.nextCursor}.`);
+	lines.push("Use survey_inspect with action \"item-details\" and itemRef to inspect a result.");
+	return lines.join("\n");
+};
+const surveySearchItemsTool = createTool({
+	id: TOOL_ID$4,
+	description: "Search all survey items by visible translated text, item keys, labels, and config identifiers. Use this when the user refers to an unselected item by title, label, option text, field label, or another phrase rather than an item id.",
+	inputSchema: inputSchema$4,
+	outputSchema: outputSchema$3,
+	mcp: { annotations: {
+		title: "Search survey items",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const input = {
+			...inputData,
+			limit: inputData.limit ?? 12
+		};
+		const snapshot = context?.requestContext?.get("engineContext");
+		if (!snapshot) return {
+			ok: false,
+			reason: "No live editor snapshot was provided with this assistant turn.",
+			query: input.query
+		};
+		const results = searchItems(snapshot, input);
+		const page = sliceWithCursor(results, input);
+		return {
+			ok: true,
+			query: input.query,
+			totalAvailable: results.length,
+			returned: page.items.length,
+			nextCursor: page.nextCursor,
+			truncated: page.truncated,
+			results: page.items
+		};
+	},
+	toModelOutput: (value) => toTextModelOutput(value, summarizeForModel)
+});
+//#endregion
+//#region src/server/tools/survey-inspect-tool.ts
+const TOOL_ID$3 = "survey_inspect";
+const inspectActionSchema = z.enum([
+	"current-context",
+	"search-items",
+	"item-details",
+	"assets",
+	"raw-json"
+]);
+const outlineModeSchema = z.enum([
+	"full",
+	"focused",
+	"children"
+]);
+const optionalInput = (schema) => z.preprocess((value) => value === null ? void 0 : value, schema.optional());
+const optionalNonBlankString = (maxLength) => z.preprocess((value) => value === null || typeof value === "string" && value.trim().length === 0 ? void 0 : value, z.string().min(1).max(maxLength).optional());
+const inputSchema$3 = z.object({
+	action: inspectActionSchema.describe("The survey information to inspect."),
+	reason: optionalInput(z.string().max(500)).describe("Short reason this inspection is needed."),
+	scopes: optionalInput(z.array(z.enum([
+		"summary",
+		"selected-item",
+		"outline",
+		"response-slots",
+		"ui-context",
+		"history"
+	])).min(1).max(6)).describe("For current-context: context sections to inspect."),
+	query: optionalNonBlankString(180).describe("For search-items: text to search across survey content. For assets: optional asset id, filename, name, ALT text, or media type filter. For current-context outline: optional key/fullKey/label filter."),
+	itemRef: optionalNonBlankString(240).describe("For current-context outline, item-details, or raw-json: item id, key, fullKey, visible label, or \"selected\"."),
+	cursor: optionalNonBlankString(240).describe("For current-context/search-items pagination: numeric cursor from a previous result."),
+	outlineMode: optionalInput(outlineModeSchema).describe("For current-context outline: \"full\" pages all survey items, \"focused\" returns the selected/focused neighborhood, and \"children\" returns direct children of itemRef."),
+	paths: optionalInput(z.array(z.string().min(1).max(500)).min(1).max(20)).describe("For raw-json: exact JSON Pointer paths to inspect."),
+	includeChildren: optionalInput(z.boolean()).describe("For item-details: include direct survey-tree children."),
+	includeItemConfig: optionalInput(z.boolean()).describe("For item-details: include choice/form/internal item config details."),
+	limit: optionalInput(z.number().int().min(1).max(50)).describe("Maximum list rows to return.")
+});
+const outputSchema$2 = z.object({
+	ok: z.boolean(),
+	action: inspectActionSchema,
+	reason: z.string().optional(),
+	modelSummary: z.string(),
+	result: z.unknown().optional()
+});
+const runTool = async (tool, input, context) => {
+	const execute = tool.execute;
+	if (!execute) throw new Error("Survey inspection backend is not executable.");
+	return execute(input, context);
+};
+const unwrapToolOutput = (value) => {
+	if (value && typeof value === "object" && "output" in value && value.output !== void 0) return value.output;
+	return value;
+};
+const stringifyForModel = (value) => {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value, null, 2);
+};
+const resolveItemRef = (input, snapshot) => {
+	if (input.itemRef && input.itemRef !== "selected") return input.itemRef;
+	return snapshot?.ui.selectedItemId;
+};
+const listAssetUsageSummaries = (survey) => {
+	const usagesByAssetId = /* @__PURE__ */ new Map();
+	const addContent = (content, usage) => {
+		for (const assetUsage of getAssetUsagesFromContent(content)) {
+			const usages = usagesByAssetId.get(assetUsage.assetId) ?? [];
+			usages.push({
+				...usage,
+				blockIndex: assetUsage.blockIndex
+			});
+			usagesByAssetId.set(assetUsage.assetId, usages);
+		}
+	};
+	for (const [locale, localeTranslations] of Object.entries(survey.translations ?? {})) {
+		for (const scope of [
+			"surveyCardContent",
+			"navigationContent",
+			"validationMessages"
+		]) for (const [contentKey, content] of Object.entries(localeTranslations[scope] ?? {})) addContent(content, {
+			locale,
+			scope,
+			contentKey
+		});
+		for (const [itemId, itemTranslations] of Object.entries(localeTranslations.itemTranslations ?? {})) for (const [contentKey, content] of Object.entries(itemTranslations ?? {})) addContent(content, {
+			locale,
+			scope: "itemTranslation",
+			itemId,
+			contentKey
+		});
+	}
+	return usagesByAssetId;
+};
+const summarizeAssetSource = (asset) => ({
+	type: asset.source.type,
+	mediaType: asset.source.mediaType
+});
+const listAssets = (input, snapshot) => {
+	const survey = snapshot.survey;
+	const usagesByAssetId = listAssetUsageSummaries(survey);
+	const query = input.query?.trim().toLowerCase();
+	const allAssets = Object.entries(survey.assets ?? {}).map(([assetId, asset]) => {
+		const usages = usagesByAssetId.get(assetId) ?? [];
+		return {
+			assetId,
+			kind: asset.kind,
+			source: summarizeAssetSource(asset),
+			...asset.metadata ? { metadata: asset.metadata } : {},
+			usageCount: usages.length,
+			usages
+		};
+	}).filter((asset) => {
+		if (!query) return true;
+		return [
+			asset.assetId,
+			asset.source.mediaType,
+			asset.metadata?.name,
+			asset.metadata?.filename,
+			asset.metadata?.alt
+		].some((value) => value?.toLowerCase().includes(query));
+	}).sort((left, right) => left.assetId.localeCompare(right.assetId));
+	const parsedCursor = Number.parseInt(input.cursor ?? "0", 10);
+	const offset = Number.isFinite(parsedCursor) && parsedCursor >= 0 ? parsedCursor : 0;
+	const limit = input.limit ?? 20;
+	const assets = allAssets.slice(offset, offset + limit);
+	const nextOffset = offset + assets.length;
+	return {
+		totalAvailable: allAssets.length,
+		returned: assets.length,
+		...nextOffset < allAssets.length ? { nextCursor: String(nextOffset) } : {},
+		assets
+	};
+};
+const surveyInspectTool = createTool({
+	id: TOOL_ID$3,
+	description: "Inspect current survey state through one compact interface: current context, item search, item details, image assets with explicit asset IDs and usages, or focused raw JSON. Use this before making changes when the answer depends on the live editor state.",
+	inputSchema: inputSchema$3,
+	outputSchema: outputSchema$2,
+	mcp: { annotations: {
+		title: "Inspect survey",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const input = inputData;
+		const snapshot = context?.requestContext?.get("engineContext");
+		if (!snapshot) return {
+			ok: false,
+			action: input.action,
+			reason: "No live editor snapshot was provided with this assistant turn.",
+			modelSummary: "No live editor snapshot is available for this turn."
+		};
+		if (input.action === "current-context") {
+			const result = unwrapToolOutput(await runTool(surveyGetCurrentContextTool, {
+				scopes: input.scopes ?? ["summary", "selected-item"],
+				limit: input.limit,
+				cursor: input.cursor,
+				itemId: resolveItemRef(input, snapshot),
+				query: input.query,
+				outlineMode: input.outlineMode
+			}, context));
+			return {
+				ok: true,
+				action: input.action,
+				modelSummary: stringifyForModel(result),
+				result
+			};
+		}
+		if (input.action === "search-items") {
+			if (!input.query) return {
+				ok: false,
+				action: input.action,
+				reason: "Search requires a query.",
+				modelSummary: "Search requires a query."
+			};
+			const result = unwrapToolOutput(await runTool(surveySearchItemsTool, {
+				query: input.query,
+				limit: input.limit,
+				cursor: input.cursor
+			}, context));
+			return {
+				ok: true,
+				action: input.action,
+				modelSummary: stringifyForModel(result),
+				result
+			};
+		}
+		if (input.action === "item-details") {
+			const itemId = resolveItemRef(input, snapshot);
+			if (!itemId) return {
+				ok: false,
+				action: input.action,
+				reason: "No item reference was provided and no item is selected.",
+				modelSummary: "No item reference was provided and no item is selected."
+			};
+			const result = unwrapToolOutput(await runTool(surveyGetItemDetailsTool, {
+				itemId,
+				includeSurveyChildren: input.includeChildren ?? false,
+				includeItemConfig: input.includeItemConfig ?? true,
+				childrenLimit: input.limit
+			}, context));
+			return {
+				ok: true,
+				action: input.action,
+				modelSummary: stringifyForModel(result),
+				result
+			};
+		}
+		if (input.action === "assets") {
+			const result = listAssets(input, snapshot);
+			return {
+				ok: true,
+				action: input.action,
+				modelSummary: stringifyForModel(result),
+				result
+			};
+		}
+		const itemId = resolveItemRef(input, snapshot);
+		const itemIdentifiers = itemId ? [itemId] : void 0;
+		const result = unwrapToolOutput(await runTool(surveyGetRawSurveyTool, {
+			paths: input.paths,
+			itemIdentifiers
+		}, context));
+		return {
+			ok: true,
+			action: input.action,
+			modelSummary: stringifyForModel(result),
+			result
+		};
+	},
+	toModelOutput: (value) => toTextModelOutput(value, (output) => output.modelSummary)
+});
+//#endregion
+//#region src/server/tools/survey-attachment-tool.ts
+const TOOL_ID$2 = "survey_attachment";
+const surveyAttachmentTool = createTool({
+	id: TOOL_ID$2,
+	description: "Attach only the stored PDFs or images needed for the current task to the next native model request. After this succeeds, read the original files directly and continue the task.",
+	inputSchema: z.object({ documentIds: z.array(z.string().min(1)).min(1).max(4).describe("IDs of only the stored attachments needed for the current request.") }),
+	outputSchema: z.object({ loaded: z.array(z.object({
+		id: z.string(),
+		filename: z.string(),
+		mediaType: z.string()
+	})) }),
+	mcp: { annotations: {
+		title: "Load chat attachment",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	} },
+	execute: async (inputData, context) => {
+		const access = (context?.requestContext)?.get("attachmentAccess");
+		if (!access) return { loaded: [] };
+		const requestedIds = [...new Set(inputData.documentIds)];
+		const authorized = access.documents.filter((document) => requestedIds.includes(document.id));
+		const attachments = await access.load(authorized.map((document) => document.id));
+		access.selectedAttachments.splice(0, access.selectedAttachments.length, ...attachments);
+		return { loaded: authorized.map((document) => ({
+			id: document.id,
+			filename: document.name,
+			mediaType: document.mediaType
+		})) };
+	},
+	toModelOutput: (value) => toTextModelOutput(value, () => "The selected original attachments are included in this model input. Read them directly now and continue the user's task. Do not claim that their content is unavailable or ask the user to paste extracted text.")
+});
+//#endregion
+//#region src/server/tools/survey-audit-tool.ts
+const TOOL_ID$1 = "survey_audit";
+const surveyAuditTool = createTool({
+	id: TOOL_ID$1,
+	description: "Audit the current survey for deterministic structural, content, localization, response, and asset issues, and return a research-informed questionnaire-quality review rubric for qualitative critique. This is read-only and is not psychometric validation.",
+	inputSchema: z.object({
+		sourceLocale: z.string().min(1).optional().describe("Locale treated as the source when checking translation completeness."),
+		targetLocales: z.array(z.string().min(1)).max(20).optional(),
+		maxFindings: z.number().int().min(1).max(300).default(120).optional(),
+		reason: z.string().max(500).optional()
+	}),
+	outputSchema: z.object({
+		ok: z.boolean(),
+		reason: z.string().optional(),
+		report: z.unknown().optional()
+	}),
+	mcp: { annotations: {
+		title: "Audit survey",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
+	} },
+	execute: async (input, context) => {
+		const snapshot = context?.requestContext?.get("engineContext");
+		if (!snapshot) return {
+			ok: false,
+			reason: "No live editor snapshot is available for this turn."
+		};
+		return {
+			ok: true,
+			report: auditSurvey(snapshot, input)
+		};
+	},
+	toModelOutput: (value) => toTextModelOutput(value, (output) => JSON.stringify(output, null, 2))
+});
+//#endregion
+//#region src/server/tools/survey-asset-tool.ts
+const TOOL_ID = "survey_asset";
+const inputSchema = z.object({
+	action: z.enum([
+		"import-attachment",
+		"update-metadata",
+		"remove"
+	]),
+	documentId: z.string().min(1).optional().describe("Stored attachment id for import-attachment."),
+	assetId: z.string().min(1).max(240).optional(),
+	name: z.string().max(500).nullable().optional(),
+	filename: z.string().max(500).nullable().optional(),
+	alt: z.string().max(2e3).nullable().optional(),
+	continuationMode: z.enum(SURVEY_CHANGE_CONTINUATION_MODES).optional().describe("Required after any earlier mutation candidate in the turn. Use \"append\" to keep earlier candidates, including an imported asset; use \"replace\" only when resubmitting the complete intended proposal."),
+	summary: z.string().min(1).max(500)
+});
+const slug = (value) => value.toLowerCase().replace(/\.[^.]+$/, "").replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100) || "image";
+const OMITTED_EMBEDDED_IMAGE_DATA = "[embedded image data omitted from transcript]";
+const getAssetReferenceLabels = (snapshot, assetId) => {
+	const translations = (snapshot?.survey)?.translations;
+	if (!translations) return [];
+	const references = [];
+	const inspectContent = (content, label) => {
+		if (getAssetUsagesFromContent(content).some((usage) => usage.assetId === assetId)) references.push(label);
+	};
+	for (const [locale, localeTranslations] of Object.entries(translations)) {
+		for (const surface of [
+			"surveyCardContent",
+			"navigationContent",
+			"validationMessages"
+		]) for (const [contentKey, content] of Object.entries(localeTranslations[surface] ?? {})) inspectContent(content, `${locale}:${surface}:${contentKey}`);
+		for (const [itemId, itemTranslations] of Object.entries(localeTranslations.itemTranslations ?? {})) for (const [contentKey, content] of Object.entries(itemTranslations ?? {})) inspectContent(content, `${locale}:item:${itemId}:${contentKey}`);
+	}
+	return references;
+};
+const getToolOutput = (value) => value && typeof value === "object" && "output" in value && value.output !== void 0 ? value.output : value;
+const describeAssetOperation = (operation) => {
+	switch (operation.kind) {
+		case "set-image-asset":
+		case "update-image-asset-metadata":
+		case "remove-image-asset": return `${operation.kind} ${operation.assetId}`;
+		default: return operation.kind;
+	}
+};
+const summarizeAssetChange = (event) => {
+	const lines = [`${event.status === "validated" ? "Validated" : "Rejected"} survey asset change: ${event.summary}`, `Change id: ${event.id}`];
+	if (event.operations.length > 0) lines.push(`Operations: ${event.operations.map(describeAssetOperation).join(", ")}`);
+	if (event.status === "validated") {
+		lines.push("Lifecycle: this candidate is registered, not live. The embedded image bytes remain available to the application and were omitted from model context.");
+		const importedAssetIds = event.operations.filter((operation) => operation.kind === "set-image-asset").map((operation) => operation.assetId);
+		if (importedAssetIds.length > 0) {
+			lines.push(`Asset id to reference: ${importedAssetIds.join(", ")}`);
+			lines.push("Required continuation: pass continuationMode \"append\" on every following mutation that should keep this asset import. To use the image in a NEW item, create that item in one survey_change call and put the image block directly in create-item.translations[].content; do not create placeholder text and do not call update-placed-image for an item that is not in the immutable snapshot. For an existing rich-text image placement, use update-placed-image. If a later proposal is rejected, re-import the attachment with continuationMode \"replace\", then append one corrected dependent survey_change; never replace the turn with only the asset reference.");
+			lines.push(`New info-item image source: { "type": "asset", "assetId": "${importedAssetIds[0]}" }. Embed it in a richText image block inside the create-item translation content.`);
+			lines.push(`New info-item translation example: { "locale": "<selected-locale>", "contentKey": "content", "content": { "type": "richText", "version": 1, "doc": { "type": "doc", "blocks": [{ "type": "image", "source": { "type": "asset", "assetId": "${importedAssetIds[0]}" }, "alt": "<meaningful description>" }] } } }.`);
+		}
+	}
+	if (event.validation.issues.length > 0) lines.push(`Issues:\n${event.validation.issues.map((issue) => `- ${issue.code}: ${issue.message}`).join("\n")}`);
+	if (event.validation.warnings.length > 0) lines.push(`Warnings:\n${event.validation.warnings.map((warning) => `- ${warning.code}: ${warning.message}`).join("\n")}`);
+	return lines.join("\n");
+};
+const redactEmbeddedImageOperation = (operation) => operation.kind === "set-image-asset" ? {
+	...operation,
+	asset: {
+		...operation.asset,
+		source: {
+			...operation.asset.source,
+			data: OMITTED_EMBEDDED_IMAGE_DATA
+		}
+	}
+} : operation;
+const redactAssetChangeForTranscript = (event) => ({
+	...event,
+	operations: event.operations.map(redactEmbeddedImageOperation),
+	validation: {
+		...event.validation,
+		normalizedOperations: event.validation.normalizedOperations.map(redactEmbeddedImageOperation)
+	}
+});
+const surveyAssetTool = createTool({
+	id: TOOL_ID,
+	description: "Import an attached image into survey assets without asking the model to copy base64, or update/remove an existing image asset. The result is an undoable candidate change, not a live asset. After importing, pass continuationMode \"append\" to the dependent mutation so the import and references are authorized together. For a new item, embed the asset image block directly in create-item.translations[].content in that one dependent call; update-placed-image is only for an image placement that already exists in the immutable snapshot. This tool refuses to remove a currently referenced asset. To delete references and their asset together, use one survey_change candidate with reference-removal operations first and remove-image-asset last.",
+	inputSchema,
+	outputSchema: surveyChangeSetSchema,
+	mcp: { annotations: {
+		title: "Prepare survey asset change",
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: false,
+		openWorldHint: false
+	} },
+	execute: async (input, context) => {
+		const requestContext = context?.requestContext;
+		const { changeCollector, turnId } = requireSurveyAssistantTurnState(requestContext);
+		const snapshot = requestContext?.get("engineContext");
+		let operation;
+		if (input.action === "import-attachment") {
+			if (!input.documentId) throw new Error("import-attachment requires documentId.");
+			const access = requestContext?.get("attachmentAccess");
+			const manifest = access?.documents.find((entry) => entry.id === input.documentId);
+			if (!access || !manifest) throw new Error(`Attachment "${input.documentId}" is not available for this turn.`);
+			if (!manifest.mediaType.startsWith("image/")) throw new Error(`Attachment "${manifest.name}" is not an image.`);
+			const [loaded] = await access.load([input.documentId]);
+			if (!loaded) throw new Error(`Attachment "${manifest.name}" could not be loaded.`);
+			const base = input.assetId ?? slug(manifest.name);
+			let assetId = base;
+			let suffix = 2;
+			while (snapshot?.survey.assets?.[assetId]) assetId = `${base}-${suffix++}`;
+			operation = {
+				kind: "set-image-asset",
+				assetId,
+				asset: {
+					kind: "image",
+					source: {
+						type: "embedded",
+						mediaType: loaded.mediaType,
+						encoding: "base64",
+						data: loaded.data
+					},
+					metadata: {
+						filename: input.filename ?? loaded.filename,
+						name: input.name ?? void 0,
+						alt: input.alt ?? void 0
+					}
+				}
+			};
+		} else if (input.action === "update-metadata") {
+			if (!input.assetId) throw new Error("update-metadata requires assetId.");
+			operation = {
+				kind: "update-image-asset-metadata",
+				assetId: input.assetId,
+				metadata: {
+					name: input.name,
+					filename: input.filename,
+					alt: input.alt
+				}
+			};
+		} else {
+			if (!input.assetId) throw new Error("remove requires assetId.");
+			operation = {
+				kind: "remove-image-asset",
+				assetId: input.assetId
+			};
+		}
+		let event = createSurveyChangeSet({
+			operations: [operation],
+			snapshot,
+			summary: input.summary,
+			turnId
+		});
+		if (operation.kind === "remove-image-asset") {
+			const referenceLabels = getAssetReferenceLabels(snapshot, operation.assetId);
+			if (referenceLabels.length > 0) event = surveyChangeSetSchema.parse({
+				...event,
+				status: "rejected",
+				validation: {
+					...event.validation,
+					valid: false,
+					issues: [...event.validation.issues, {
+						severity: "error",
+						code: "image-asset-still-referenced",
+						message: `Image asset "${operation.assetId}" is still referenced by ${referenceLabels.slice(0, 3).join(", ")}. Prepare one survey_change candidate containing every reference-removal operation first and remove-image-asset last. If replacing earlier candidates in this turn, that combined candidate must use continuationMode "replace".`,
+						operationIndex: 0
+					}],
+					normalizedOperations: []
+				}
+			});
+		}
+		return changeCollector.register(event, { continuationMode: input.continuationMode });
+	},
+	transform: { transcript: { output: ({ output }) => output ? redactAssetChangeForTranscript(getToolOutput(output)) : output } },
+	toModelOutput: (value) => toTextModelOutput(value, summarizeAssetChange)
+});
+//#endregion
+//#region src/server/tools/index.ts
+const SURVEY_ASSISTANT_TOOL_IDS = [
+	TOOL_ID$3,
+	TOOL_ID$9,
+	TOOL_ID$8,
+	TOOL_ID$10,
+	TOOL_ID$2,
+	TOOL_ID$1,
+	TOOL_ID
+];
+const surveyAssistantTools = Object.freeze({
+	[TOOL_ID$3]: surveyInspectTool,
+	[TOOL_ID$9]: surveyChangeTool,
+	[TOOL_ID$10]: surveyAuthoringReferenceTool,
+	[TOOL_ID$8]: surveyExpressionTool,
+	[TOOL_ID$2]: surveyAttachmentTool,
+	[TOOL_ID$1]: surveyAuditTool,
+	[TOOL_ID]: surveyAssetTool
+});
+//#endregion
+export { surveyAuditTool as i, surveyAssistantTools as n, surveyAssetTool as r, SURVEY_ASSISTANT_TOOL_IDS as t };
+
+//# sourceMappingURL=tools-Hz2p7vyv.mjs.map