@fses/workbench-app 0.2.0 → 0.2.2

package/node_modules/@byteluck/agentic-protocol/dist/index.mjs

@@ -0,0 +1,3380 @@
+//#region src/thread-item-notification-contract.ts
+const FDE_TYPED_TURN_V2_PROTOCOL_VERSION = "fde_typed_turn_v2";
+const FDE_TURN_STATUSES = [
+	"inProgress",
+	"completed",
+	"failed",
+	"interrupted"
+];
+const FDE_TURN_ITEMS_VIEWS = [
+	"notLoaded",
+	"summary",
+	"full"
+];
+const FDE_PUBLIC_ITEM_LIFECYCLES = [
+	"started",
+	"updated",
+	"completed"
+];
+const FDE_AGENT_MESSAGE_PHASES = ["final_answer", "commentary"];
+const FDE_EXECUTION_STATUSES = [
+	"pending",
+	"running",
+	"succeeded",
+	"failed",
+	"declined"
+];
+const FDE_EVENT_APPENDED_NOTIFICATION_METHODS = [
+	"item/started",
+	"item/updated",
+	"item/completed",
+	"serverRequest/resolved",
+	"fde-core/event.watermark",
+	"fde-core/turn.started",
+	"fde-core/turn.completed",
+	"fde-core/turn.failed",
+	"fde-core/turn.cancelled",
+	"fde/archiveResource/saved"
+];
+const FDE_DELTA_NOTIFICATION_METHODS = [
+	"item/commandExecution/outputDelta",
+	"item/fileChange/patchUpdated",
+	"item/agentMessage/delta",
+	"item/plan/delta",
+	"item/reasoning/summaryTextDelta",
+	"item/mcpToolCall/progress"
+];
+const FDE_PROJECTION_BACKED_LIVE_NOTIFICATION_METHODS = ["runtime.state.updated"];
+const FDE_ADAPTER_LIVE_NOTIFICATION_METHODS = [
+	"fde-core/turn.started",
+	"fde-core/turn.completed",
+	"fde-core/turn.failed",
+	"fde-core/turn.cancelled",
+	"fde/archiveResource/saved"
+];
+const FDE_SUBSCRIPTION_NOTIFICATION_METHODS = [
+	...FDE_EVENT_APPENDED_NOTIFICATION_METHODS,
+	...FDE_DELTA_NOTIFICATION_METHODS,
+	...FDE_PROJECTION_BACKED_LIVE_NOTIFICATION_METHODS
+];
+//#endregion
+//#region src/fde-core/identity.ts
+function fdeCoreServerRequestIdentityKey(identity) {
+	const normalized = normalizeFdeCoreServerRequestIdentity(identity);
+	return JSON.stringify([
+		normalized.threadId,
+		normalized.turnId,
+		normalized.requestId,
+		normalized.requestRevision,
+		normalized.stateRevision
+	]);
+}
+function normalizeFdeCoreServerRequestIdentity(value) {
+	const identity = asRecord$2(value, "serverRequestIdentity");
+	return {
+		requestId: requiredString$2(identity.requestId, "requestId"),
+		requestRevision: requiredNumber$2(identity.requestRevision, "requestRevision"),
+		stateRevision: requiredNumber$2(identity.stateRevision, "stateRevision"),
+		threadId: requiredString$2(identity.threadId, "threadId"),
+		turnId: requiredString$2(identity.turnId, "turnId")
+	};
+}
+function isFdeCoreServerRequestIdentityWire(value) {
+	try {
+		normalizeFdeCoreServerRequestIdentity(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function normalizeFdeCoreResponseToRequestWire(value, fieldName = "responseToRequest") {
+	if (value === void 0) return void 0;
+	const record = asRecord$2(value, fieldName);
+	return {
+		ownerTurnId: requiredString$2(record.ownerTurnId, `${fieldName}.ownerTurnId`),
+		requestId: requiredString$2(record.requestId, `${fieldName}.requestId`),
+		requestRevision: requiredPositiveSafeInteger$1(record.requestRevision, `${fieldName}.requestRevision`),
+		requestStateRevision: requiredPositiveSafeInteger$1(record.requestStateRevision, `${fieldName}.requestStateRevision`)
+	};
+}
+function normalizeFdeCoreResponseToRequestWireFromRecord(value, fieldName = "turn") {
+	const record = asRecord$2(value, fieldName);
+	if (Object.prototype.hasOwnProperty.call(record, "response_to_request")) throw new Error(`${fieldName}.response_to_request is not a protocol field; map it in fde-agent before normalization.`);
+	if (!Object.prototype.hasOwnProperty.call(record, "responseToRequest")) return;
+	return normalizeFdeCoreResponseToRequestWire(record.responseToRequest, `${fieldName}.responseToRequest`);
+}
+function fdeCoreServerRequestIdentityFromResponseToRequest(input) {
+	const responseToRequest = normalizeFdeCoreResponseToRequestWire(input.responseToRequest);
+	if (!responseToRequest) throw new Error("responseToRequest is required.");
+	return {
+		requestId: responseToRequest.requestId,
+		requestRevision: responseToRequest.requestRevision,
+		stateRevision: responseToRequest.requestStateRevision,
+		threadId: requiredString$2(input.threadId, "threadId"),
+		turnId: responseToRequest.ownerTurnId
+	};
+}
+function asRecord$2(value, field) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${field} must be an object.`);
+	return value;
+}
+function requiredString$2(value, field) {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${field} is required.`);
+	return value.trim();
+}
+function requiredNumber$2(value, field) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${field} is required.`);
+	return value;
+}
+function requiredPositiveSafeInteger$1(value, field) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new Error(`${field} must be a positive safe integer.`);
+	return value;
+}
+//#endregion
+//#region src/fde-core/index.ts
+/**
+* app/UI wire 常量：用于让 fde-agent adapter 和前端识别“formal save approval”
+* 这个 approval surface。它不是 core runtime 的能力声明，也不表示协议包知道
+* formal-save materialization 的目标、private context、provider receipt 或
+* 平台 side-effect scope。新增 formal-save 细节时应留在 app adapter 的私有
+* payload/执行层，protocol 只承载可公开展示和可提交的 decision。
+*/
+const SYSTEM_ANALYSIS_FORMAL_SAVE_APPROVE_REQUEST_TYPE = "system_analysis.formal_save.approve";
+const BUILD_FORMAL_SAVE_APPROVE_REQUEST_TYPE = "build.formal_save.approve";
+const BUILD_RETIRED_SAVE_APPROVAL_REQUEST_TYPES = [
+	"build.overwrite.approve",
+	"build.platform_sync.approve",
+	"build.publish.approve"
+];
+const BUILD_RETIRED_NON_SAVE_REQUEST_TYPES = [
+	"build.clarification",
+	"build.semantic_target.clarification",
+	"build.module.select",
+	"build.requirement.clarification",
+	"build.requirement.clarify",
+	"build.structured_model_edit.clarification",
+	"build.target.resolve",
+	"build.model_blueprint.confirm",
+	"build.model_blueprint.clarify",
+	"build.model_blueprint.generation_failed",
+	"build.model_edit_safety.resolve",
+	"build.review.decide",
+	"build.dependency_request",
+	"build.source_dependency.select",
+	"build_source_dependency_required",
+	"build_module_required"
+];
+const BUILD_RETIRED_NON_SAVE_PUBLIC_PAYLOAD_TYPES = [
+	"build_model_blueprint_confirmation",
+	"build_goal_plan_required",
+	"build_output_target_required",
+	"build_skill_dependency_required",
+	"build_source_dependency_required",
+	"build_module_required",
+	"build.semantic_clarification"
+];
+const BUILD_RETIRED_NON_SAVE_SURFACE_KINDS = [
+	"build_source_dependency",
+	"build_module_selection",
+	"model_blueprint_confirmation"
+];
+const BUILD_RETIRED_NON_SAVE_SURFACE_KIND_TO_PUBLIC_PAYLOAD_TYPE = {
+	build_module_selection: "build_module_required",
+	build_source_dependency: "build_source_dependency_required",
+	model_blueprint_confirmation: "build_model_blueprint_confirmation"
+};
+const FDE_PROTOCOL_BUILD = {
+	contractRevision: "fde-core-surface-v2-formal-save-required-operation",
+	packageName: "@byteluck/agentic-protocol",
+	schemaHash: "fde-core-surface-v2-formal-save-required-operation",
+	version: "1.0.5"
+};
+const clientMethods = new Set([
+	"thread/read",
+	"thread/resume",
+	"thread/start",
+	"thread/turns/list",
+	"turn/continue",
+	"turn/interrupt",
+	"turn/read",
+	"turn/start",
+	"turn/steer"
+]);
+function normalizeFdeCoreClientRequest(value) {
+	const request = asRecord$1(value, "request");
+	const id = requiredString$1(request.id, "id");
+	const method = requiredClientMethod(request.method);
+	const params = asRecord$1(request.params, "params");
+	switch (method) {
+		case "thread/read": return {
+			id,
+			method,
+			params: {
+				includeTurns: optionalBoolean(params.includeTurns, "includeTurns"),
+				threadId: requiredString$1(params.threadId, "threadId")
+			}
+		};
+		case "thread/resume":
+			if ("connectionId" in params) throw new Error("connectionId is not supported for thread/resume. Use afterOffset.");
+			return {
+				id,
+				method,
+				params: {
+					afterOffset: optionalNumber$1(params.afterOffset, "afterOffset"),
+					includeRecentTurns: optionalNumber$1(params.includeRecentTurns, "includeRecentTurns"),
+					threadId: requiredString$1(params.threadId, "threadId")
+				}
+			};
+		case "thread/start": return {
+			id,
+			method,
+			params: {
+				appId: requiredString$1(params.appId, "appId"),
+				clientRequestId: requiredString$1(params.clientRequestId, "clientRequestId"),
+				initialTitle: optionalString$1(params.initialTitle, "initialTitle")
+			}
+		};
+		case "thread/turns/list": return {
+			id,
+			method,
+			params: {
+				cursor: optionalString$1(params.cursor, "cursor"),
+				limit: optionalNumber$1(params.limit, "limit"),
+				threadId: requiredString$1(params.threadId, "threadId")
+			}
+		};
+		case "turn/continue": {
+			const clientUserMessageId = optionalNonEmptyString(params.clientUserMessageId, "clientUserMessageId");
+			return {
+				id,
+				method,
+				params: {
+					baseTurnId: requiredString$1(params.baseTurnId, "baseTurnId"),
+					clientRequestId: requiredString$1(params.clientRequestId, "clientRequestId"),
+					...clientUserMessageId === void 0 ? {} : { clientUserMessageId },
+					expectedTaskSessionRevision: requiredNonNegativeSafeInteger(params.expectedTaskSessionRevision, "expectedTaskSessionRevision"),
+					input: requiredInputArray(params.input, "input"),
+					taskSessionId: requiredString$1(params.taskSessionId, "taskSessionId"),
+					threadId: requiredString$1(params.threadId, "threadId")
+				}
+			};
+		}
+		case "turn/interrupt": return {
+			id,
+			method,
+			params: {
+				clientRequestId: requiredString$1(params.clientRequestId, "clientRequestId"),
+				reason: optionalString$1(params.reason, "reason"),
+				threadId: requiredString$1(params.threadId, "threadId"),
+				turnId: requiredString$1(params.turnId, "turnId")
+			}
+		};
+		case "turn/read": return {
+			id,
+			method,
+			params: {
+				threadId: requiredString$1(params.threadId, "threadId"),
+				turnId: requiredString$1(params.turnId, "turnId")
+			}
+		};
+		case "turn/start": {
+			const clientUserMessageId = optionalNonEmptyString(params.clientUserMessageId, "clientUserMessageId");
+			if ("skillId" in params) throw new Error("skillId is not supported for turn/start. Use capabilityId.");
+			return {
+				id,
+				method,
+				params: {
+					capabilityId: optionalNonEmptyString(params.capabilityId, "capabilityId"),
+					threadId: requiredString$1(params.threadId, "threadId"),
+					input: requiredInputArray(params.input, "input"),
+					clientRequestId: requiredString$1(params.clientRequestId, "clientRequestId"),
+					...clientUserMessageId === void 0 ? {} : { clientUserMessageId }
+				}
+			};
+		}
+		case "turn/steer": {
+			const clientUserMessageId = optionalNonEmptyString(params.clientUserMessageId, "clientUserMessageId");
+			if ("turnId" in params) throw new Error("turnId is not supported for turn/steer. Use expectedTurnId.");
+			return {
+				id,
+				method,
+				params: {
+					threadId: requiredString$1(params.threadId, "threadId"),
+					expectedTurnId: requiredString$1(params.expectedTurnId, "expectedTurnId"),
+					input: requiredInputArray(params.input, "input"),
+					clientRequestId: requiredString$1(params.clientRequestId, "clientRequestId"),
+					...clientUserMessageId === void 0 ? {} : { clientUserMessageId }
+				}
+			};
+		}
+	}
+}
+function toFdeCoreSuccessResponse(id, result) {
+	return {
+		id,
+		result
+	};
+}
+function normalizeFdeCoreThreadResumeResult(value) {
+	const result = asRecord$1(value, "thread/resume.result");
+	if ("projection" in result) throw new Error("thread/resume.result.projection is not supported. Use bootstrapFrames.");
+	if ("thread" in result) throw new Error("thread/resume.result.thread is not supported. Use bootstrapFrames.");
+	if ("initialReplayFrames" in result) throw new Error("thread/resume.result.initialReplayFrames is not supported. Use bootstrapFrames.");
+	const threadId = requiredString$1(result.threadId, "thread/resume.result.threadId");
+	const latestOffset = requiredNonNegativeSafeInteger(result.latestOffset, "thread/resume.result.latestOffset");
+	const bootstrapFrames = requiredArray(result.bootstrapFrames, "thread/resume.result.bootstrapFrames").map((frame, index) => {
+		const normalized = normalizeFdeCoreSubscriptionFrame(frame);
+		if (normalized.kind !== "event_appended" && normalized.kind !== "projection_snapshot") throw new Error(`thread/resume.result.bootstrapFrames[${index}] must be event_appended or projection_snapshot.`);
+		if (normalized.threadId !== threadId) throw new Error(`thread/resume.result.bootstrapFrames[${index}].threadId must match result.threadId.`);
+		return normalized;
+	});
+	if (bootstrapFrames.filter((frame) => frame.kind === "projection_snapshot").length !== 1) throw new Error("thread/resume.result.bootstrapFrames must contain exactly one projection_snapshot.");
+	const finalFrame = bootstrapFrames[bootstrapFrames.length - 1];
+	if (!finalFrame || finalFrame.kind !== "projection_snapshot") throw new Error("thread/resume.result.bootstrapFrames must end with projection_snapshot.");
+	if (finalFrame.offset !== latestOffset) throw new Error("thread/resume.result.latestOffset must equal final projection_snapshot.offset.");
+	if (finalFrame.projection.metadata.lastEventCursor !== latestOffset) throw new Error("thread/resume final projection metadata cursor must equal latestOffset.");
+	return {
+		bootstrapFrames,
+		latestOffset,
+		threadId
+	};
+}
+function toFdeCoreThreadResumeSuccessResponse(id, result) {
+	return toFdeCoreSuccessResponse(id, normalizeFdeCoreThreadResumeResult(result));
+}
+function toFdeCoreErrorResponse(id, code, message, data) {
+	return {
+		id,
+		error: {
+			code,
+			...data === void 0 ? {} : { data },
+			message
+		}
+	};
+}
+function createFdeCoreUserInputServerRequest(input) {
+	const fields = normalizeRequestFields(input.fields, "fields");
+	assertUserInputRequestSurface(input.kind, fields);
+	const publicPayload = sanitizePublicPayload(input.publicPayload);
+	const surface = normalizeRequiredActionSurfaceWire(input.surface, "surface");
+	const itemBoundIdentity = normalizeItemBoundIdentity(input);
+	return {
+		id: fdeCoreServerRequestIdentityKey(input),
+		method: "fde/serverRequest/userInput",
+		params: {
+			actionId: input.actionId,
+			...input.domain === void 0 ? {} : { domain: input.domain },
+			...fields === void 0 ? {} : { fields },
+			...itemBoundIdentity,
+			itemId: input.itemId,
+			kind: input.kind,
+			prompt: input.prompt,
+			...publicPayload === void 0 ? {} : { publicPayload },
+			requestId: input.requestId,
+			requestRevision: input.requestRevision,
+			...input.requestType === void 0 ? {} : { requestType: input.requestType },
+			stateRevision: input.stateRevision,
+			...surface === void 0 ? {} : { surface },
+			threadId: input.threadId,
+			turnId: input.turnId
+		}
+	};
+}
+function createFdeCoreApprovalServerRequest(input) {
+	const publicPayload = sanitizePublicPayload(input.publicPayload);
+	const surface = normalizeRequiredActionSurfaceWire(input.surface, "surface");
+	const itemBoundIdentity = normalizeItemBoundIdentity(input);
+	return {
+		id: fdeCoreServerRequestIdentityKey(input),
+		method: "fde/serverRequest/approval",
+		params: {
+			actionId: input.actionId,
+			decisions: normalizeApprovalDecisionOptions(input.decisions, "decisions"),
+			...input.domain === void 0 ? {} : { domain: input.domain },
+			...itemBoundIdentity,
+			itemId: input.itemId,
+			kind: "approval",
+			prompt: input.prompt,
+			...publicPayload === void 0 ? {} : { publicPayload },
+			requestId: input.requestId,
+			requestRevision: input.requestRevision,
+			...input.requestType === void 0 ? {} : { requestType: input.requestType },
+			stateRevision: input.stateRevision,
+			...surface === void 0 ? {} : { surface },
+			threadId: input.threadId,
+			turnId: input.turnId
+		}
+	};
+}
+function normalizeFdeCoreServerRequest(value) {
+	const request = asRecord$1(value, "serverRequest");
+	const method = requiredServerRequestMethod(request.method);
+	const params = asRecord$1(request.params, "params");
+	if (method === "fde/serverRequest/userInput") {
+		if ("options" in params) throw new TypeError("params.options is not supported for FDE Core user-input requests.");
+		const requestId = requiredString$1(params.requestId, "requestId");
+		const envelope = createFdeCoreUserInputServerRequest({
+			actionId: requiredString$1(params.actionId, "actionId"),
+			domain: optionalString$1(params.domain, "domain"),
+			fields: normalizeRequestFields(params.fields, "params.fields"),
+			...normalizeItemBoundIdentity(params),
+			itemId: requiredString$1(params.itemId, "itemId"),
+			kind: requiredUserInputKind(params.kind),
+			prompt: requiredString$1(params.prompt, "prompt"),
+			publicPayload: optionalPublicPayload(params),
+			requestId,
+			requestRevision: requiredNumber$1(params.requestRevision, "requestRevision"),
+			requestType: optionalString$1(params.requestType, "requestType"),
+			stateRevision: requiredNumber$1(params.stateRevision, "stateRevision"),
+			surface: normalizeRequiredActionSurfaceWire(params.surface, "params.surface"),
+			threadId: requiredString$1(params.threadId, "threadId"),
+			turnId: requiredString$1(params.turnId, "turnId")
+		});
+		ensureMatchingId(request.id, fdeCoreServerRequestIdentityKey(envelope.params));
+		return envelope;
+	}
+	const requestId = requiredString$1(params.requestId, "requestId");
+	const envelope = createFdeCoreApprovalServerRequest({
+		actionId: requiredString$1(params.actionId, "actionId"),
+		decisions: normalizeApprovalDecisionOptions(params.decisions, "params.decisions"),
+		domain: optionalString$1(params.domain, "domain"),
+		...normalizeItemBoundIdentity(params),
+		itemId: requiredString$1(params.itemId, "itemId"),
+		prompt: requiredString$1(params.prompt, "prompt"),
+		publicPayload: optionalPublicPayload(params),
+		requestId,
+		requestRevision: requiredNumber$1(params.requestRevision, "requestRevision"),
+		requestType: optionalString$1(params.requestType, "requestType"),
+		stateRevision: requiredNumber$1(params.stateRevision, "stateRevision"),
+		surface: normalizeRequiredActionSurfaceWire(params.surface, "params.surface"),
+		threadId: requiredString$1(params.threadId, "threadId"),
+		turnId: requiredString$1(params.turnId, "turnId")
+	});
+	ensureMatchingId(request.id, fdeCoreServerRequestIdentityKey(envelope.params));
+	if (params.kind !== "approval") throw new TypeError("params.kind must be approval for FDE Core approval requests.");
+	return envelope;
+}
+function normalizeFdeCoreServerResponse(value) {
+	const response = asRecord$1(value, "serverResponse");
+	const id = requiredString$1(response.id, "id");
+	const method = requiredServerRequestMethod(response.method);
+	const params = asRecord$1(response.params, "params");
+	const requestId = requiredString$1(params.requestId, "requestId");
+	const identity = {
+		requestId,
+		requestRevision: requiredNumber$1(params.expectedRequestRevision, "expectedRequestRevision"),
+		stateRevision: requiredNumber$1(params.expectedStateRevision, "expectedStateRevision"),
+		threadId: requiredString$1(params.threadId, "threadId"),
+		turnId: requiredString$1(params.turnId, "turnId")
+	};
+	ensureMatchingId(id, fdeCoreServerRequestIdentityKey(identity));
+	const baseParams = {
+		expectedRequestRevision: identity.requestRevision,
+		expectedStateRevision: identity.stateRevision,
+		requestId,
+		threadId: identity.threadId,
+		turnId: identity.turnId
+	};
+	const responseBody = asRecord$1(response.response, "response");
+	if (method === "fde/serverRequest/userInput") {
+		const decision = responseBody.decision;
+		if (decision !== "answer" && decision !== "cancel") throw new Error("decision must be answer or cancel.");
+		return {
+			id,
+			method,
+			params: baseParams,
+			response: {
+				answers: normalizeUserInputAnswers(responseBody.answers),
+				decision
+			}
+		};
+	}
+	const decision = responseBody.decision;
+	if (decision !== "approve" && decision !== "reject" && decision !== "cancel") throw new Error("decision must be approve, reject or cancel.");
+	return {
+		id,
+		method,
+		params: baseParams,
+		response: {
+			decision,
+			reason: optionalString$1(responseBody.reason, "reason")
+		}
+	};
+}
+function getFdeCoreRequestSerialization(request) {
+	switch (request.method) {
+		case "thread/read":
+		case "thread/resume":
+		case "turn/continue":
+		case "turn/interrupt":
+		case "turn/read":
+		case "turn/start":
+		case "turn/steer": return {
+			mode: "thread",
+			key: readThreadId(request.params)
+		};
+		case "thread/start":
+		case "thread/turns/list": return { mode: "none" };
+	}
+}
+function createFdeCoreLiveNotification(method, params) {
+	if (method === "serverRequest/resolved") throw new Error("Use createFdeCoreServerRequestResolvedNotification for serverRequest/resolved");
+	const sanitizedParams = params === void 0 ? void 0 : sanitizePublicPayload(params);
+	return sanitizedParams === void 0 ? { method } : {
+		method,
+		params: sanitizedParams
+	};
+}
+function createFdeCoreServerRequestResolvedNotification(identity) {
+	return {
+		method: "serverRequest/resolved",
+		params: normalizeFdeCoreServerRequestIdentity(identity)
+	};
+}
+function isFdeCoreServerRequestResolvedNotification(notification) {
+	return notification.method === "serverRequest/resolved" && isFdeCoreServerRequestIdentityWire(notification.params);
+}
+function normalizeFdeCoreLiveNotification(value) {
+	const notification = asRecord$1(value, "notification");
+	const method = requiredString$1(notification.method, "method");
+	if (method === "serverRequest/resolved") return createFdeCoreServerRequestResolvedNotification(normalizeFdeCoreServerRequestIdentity(notification.params));
+	if (method === "fde-core/turn.started") return normalizeFdeCoreTurnStartedNotification(notification);
+	if (method === "fde-core/turn.completed" || method === "fde-core/turn.failed" || method === "fde-core/turn.cancelled") return normalizeFdeCoreTurnTerminalNotification(notification, method);
+	if (isFdeEventAppendedNotificationMethod(method)) return normalizeFdeEventAppendedNotification(notification);
+	return createFdeCoreLiveNotification(method, notification.params === void 0 ? void 0 : asRecord$1(notification.params, "notification.params"));
+}
+function normalizeFdeCoreLiveDeltaNotification(value) {
+	const notification = asRecord$1(value, "notification");
+	const method = requiredString$1(notification.method, "method");
+	if (!isFdeDeltaNotificationMethod(method)) throw new Error(`live_notification method is not delta: ${method}`);
+	return normalizeFdeDeltaNotification(notification);
+}
+function normalizeFdeLiveNotification(value) {
+	const notification = asRecord$1(value, "notification");
+	const method = requiredString$1(notification.method, "method");
+	if (isFdeDeltaNotificationMethod(method)) return normalizeFdeDeltaNotification(notification);
+	if (isFdeProjectionBackedLiveNotificationMethod(method)) return normalizeFdeProjectionBackedLiveNotification(notification, method);
+	throw new Error(`Unsupported FDE live_notification method: ${method}`);
+}
+function normalizeFdeCoreSubscriptionFrame(value) {
+	const frame = asRecord$1(value, "frame");
+	const kind = requiredString$1(frame.kind, "kind");
+	if (kind === "projection_snapshot") {
+		if ("notifications" in frame) throw new Error("projection_snapshot.notifications is not supported.");
+		if ("serverRequests" in frame) throw new Error("projection_snapshot.serverRequests is not supported.");
+		if ("runtime_state" in frame) throw new Error("projection_snapshot.runtime_state is not supported.");
+		if ("runtimeState" in frame) throw new Error("projection_snapshot.runtimeState is not supported.");
+		return {
+			kind,
+			offset: requiredNumber$1(frame.offset, "offset"),
+			projection: normalizeFdeCoreProjection(frame.projection),
+			resumeHighWater: optionalNumber$1(frame.resumeHighWater, "resumeHighWater"),
+			threadId: requiredString$1(frame.threadId, "threadId")
+		};
+	}
+	if (kind === "event_appended") {
+		if ("event" in frame) throw new Error("event_appended.event is not supported.");
+		return {
+			kind,
+			notifications: requiredArray(frame.notifications, "notifications").map((notification) => normalizeFdeEventAppendedNotification(notification)),
+			offset: requiredNumber$1(frame.offset, "offset"),
+			serverRequests: requiredArray(frame.serverRequests, "serverRequests").map((request) => normalizeFdeCoreServerRequest(request)),
+			threadId: requiredString$1(frame.threadId, "threadId")
+		};
+	}
+	if (kind === "stream_ready") {
+		rejectFrameFields(frame, kind, [
+			"offset",
+			"notifications",
+			"serverRequests",
+			"projection",
+			"liveSeq",
+			"error"
+		]);
+		return {
+			connectionId: requiredString$1(frame.connectionId, "connectionId"),
+			kind,
+			threadId: requiredString$1(frame.threadId, "threadId")
+		};
+	}
+	if (kind === "stream_error") {
+		rejectFrameFields(frame, kind, [
+			"offset",
+			"notifications",
+			"serverRequests",
+			"projection",
+			"liveSeq"
+		]);
+		const error = asRecord$1(frame.error, "stream_error.error");
+		return {
+			connectionId: requiredString$1(frame.connectionId, "connectionId"),
+			error: withoutUndefinedFields$1({
+				code: optionalString$1(error.code, "stream_error.error.code"),
+				detail: optionalString$1(error.detail, "stream_error.error.detail"),
+				message: requiredString$1(error.message, "stream_error.error.message")
+			}),
+			kind,
+			threadId: requiredString$1(frame.threadId, "threadId")
+		};
+	}
+	if (kind === "live_notification") {
+		rejectFrameFields(frame, kind, [
+			"offset",
+			"serverRequests",
+			"projection",
+			"connectionId",
+			"error"
+		]);
+		return {
+			kind,
+			liveSeq: optionalNumber$1(frame.liveSeq, "liveSeq"),
+			notifications: requiredArray(frame.notifications, "notifications").map((notification) => normalizeFdeLiveNotification(notification)),
+			threadId: requiredString$1(frame.threadId, "threadId")
+		};
+	}
+	throw new Error(`Unsupported FDE Core subscription frame kind: ${kind}`);
+}
+function requiredClientMethod(value) {
+	if (typeof value !== "string" || !clientMethods.has(value)) throw new Error("method is invalid.");
+	return value;
+}
+function normalizeFdeCoreProjection(value) {
+	const projection = asRecord$1(value, "projection");
+	const metadata = asRecord$1(projection.metadata, "projection.metadata");
+	const artifactPanel = asRecord$1(projection.artifactPanel, "projection.artifactPanel");
+	return withoutUndefinedFields$1({
+		activeRequiredAction: projection.activeRequiredAction === void 0 ? void 0 : normalizeRequiredAction(projection.activeRequiredAction),
+		activeTurnControl: projection.activeTurnControl === void 0 ? void 0 : normalizeActiveTurnControl(projection.activeTurnControl),
+		artifactPanel: { items: requiredArray(artifactPanel.items, "projection.artifactPanel.items").map((item, index) => normalizeArtifactPanelItemWire(item, `projection.artifactPanel.items[${index}]`)) },
+		continuableTaskSession: projection.continuableTaskSession === void 0 ? void 0 : normalizeContinuableTaskSession(projection.continuableTaskSession),
+		metadata: { lastEventCursor: requiredNumber$1(metadata.lastEventCursor, "projection.metadata.lastEventCursor") },
+		runtimeState: projection.runtimeState === void 0 ? void 0 : normalizeFdeRuntimeStateSnapshotWire(projection.runtimeState, "projection.runtimeState"),
+		threadId: requiredString$1(projection.threadId, "projection.threadId"),
+		turns: requiredArray(projection.turns, "projection.turns").map((turn, index) => normalizeTurnWire(turn, `projection.turns[${index}]`))
+	});
+}
+function normalizeTurnWire(value, fieldName) {
+	const turn = asRecord$1(value, fieldName);
+	const metadata = asRecord$1(turn.metadata, `${fieldName}.metadata`);
+	rejectFrameFields(turn, fieldName, [
+		`assistantMessage`,
+		`finalAnswer`,
+		"notifications",
+		`requiredAction`,
+		`transcriptItems`,
+		`userMessage`
+	]);
+	const itemsView = requiredTypedTurnItemsView(turn.itemsView, `${fieldName}.itemsView`);
+	const rawItems = requiredArray(turn.items, `${fieldName}.items`);
+	const base = withoutUndefinedFields$1({
+		artifacts: requiredArray(turn.artifacts, `${fieldName}.artifacts`).map((item, index) => normalizeArtifactRefWire(item, `${fieldName}.artifacts[${index}]`)),
+		baseTurnId: optionalString$1(turn.baseTurnId, `${fieldName}.baseTurnId`),
+		capability: turn.capability === void 0 ? void 0 : normalizeCapabilitySummaryWire(turn.capability, `${fieldName}.capability`),
+		clientRequestId: optionalString$1(turn.clientRequestId, `${fieldName}.clientRequestId`),
+		durationMs: optionalNumber$1(turn.durationMs, `${fieldName}.durationMs`),
+		endedAt: optionalString$1(turn.endedAt, `${fieldName}.endedAt`),
+		error: turn.error === void 0 ? void 0 : normalizePublicErrorWire(turn.error, `${fieldName}.error`),
+		diff: turn.diff === void 0 ? void 0 : normalizeTurnDiffSnapshot(turn.diff, `${fieldName}.diff`),
+		facts: requiredArray(turn.facts, `${fieldName}.facts`).map((item, index) => asRecord$1(item, `${fieldName}.facts[${index}]`)),
+		memoryContext: turn.memoryContext === void 0 ? void 0 : normalizeMemoryContextProjection(turn.memoryContext, `${fieldName}.memoryContext`),
+		metadata: { lastEventCursor: requiredNumber$1(metadata.lastEventCursor, `${fieldName}.metadata.lastEventCursor`) },
+		plan: turn.plan === void 0 ? void 0 : normalizeTurnPlanSnapshot(turn.plan, `${fieldName}.plan`),
+		responseToRequest: normalizeFdeCoreResponseToRequestWireFromRecord(turn, fieldName),
+		runtimeStates: turn.runtimeStates === void 0 ? void 0 : requiredArray(turn.runtimeStates, `${fieldName}.runtimeStates`).map((item, index) => normalizeFdeRuntimeStateSnapshotWire(item, `${fieldName}.runtimeStates[${index}]`)),
+		saveCompletions: turn.saveCompletions === void 0 ? void 0 : requiredArray(turn.saveCompletions, `${fieldName}.saveCompletions`).map((item, index) => normalizeSaveCompletionWire(item, `${fieldName}.saveCompletions[${index}]`)),
+		startedAt: optionalString$1(turn.startedAt, `${fieldName}.startedAt`),
+		status: requiredTurnStatus(turn.status, `${fieldName}.status`),
+		threadId: requiredString$1(turn.threadId, `${fieldName}.threadId`),
+		turnId: requiredString$1(turn.turnId, `${fieldName}.turnId`)
+	});
+	if (itemsView === "notLoaded") {
+		if (rawItems.length !== 0) throw new Error(`${fieldName}.items must be empty when itemsView is notLoaded.`);
+		return {
+			...base,
+			items: [],
+			itemsView
+		};
+	}
+	if (itemsView === "summary") return withoutUndefinedFields$1({
+		...base,
+		items: rawItems.map((item, index) => normalizeFdeThreadItemPreview(item, `${fieldName}.items[${index}]`)),
+		itemsView,
+		previewHighWater: optionalPositiveSafeInteger(turn.previewHighWater, `${fieldName}.previewHighWater`)
+	});
+	return {
+		...base,
+		items: rawItems.map((item, index) => normalizeFdeFullThreadItem(item, `${fieldName}.items[${index}]`)),
+		itemsView,
+		projectionHighWater: requiredPositiveSafeInteger(turn.projectionHighWater, `${fieldName}.projectionHighWater`)
+	};
+}
+function normalizeFdeDeltaNotification(value) {
+	const notification = asRecord$1(value, "notification");
+	const method = requiredString$1(notification.method, "method");
+	const params = asRecord$1(notification.params, "notification.params");
+	switch (method) {
+		case "item/agentMessage/delta":
+			assertExactKeys(params, "notification.params", [
+				"delta",
+				"itemId",
+				"threadId",
+				"turnId"
+			]);
+			return {
+				method,
+				params: {
+					delta: requiredString$1(params.delta, "notification.params.delta"),
+					itemId: requiredString$1(params.itemId, "notification.params.itemId"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId")
+				}
+			};
+		case "item/commandExecution/outputDelta":
+			assertExactKeys(params, "notification.params", [
+				"delta",
+				"itemId",
+				"threadId",
+				"turnId"
+			]);
+			return {
+				method,
+				params: {
+					delta: requiredPlainString(params.delta, "notification.params.delta"),
+					itemId: requiredString$1(params.itemId, "notification.params.itemId"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId")
+				}
+			};
+		case "item/fileChange/patchUpdated":
+			assertExactKeys(params, "notification.params", [
+				"changes",
+				"itemId",
+				"threadId",
+				"turnId"
+			]);
+			return {
+				method,
+				params: {
+					changes: normalizeFileChangeEntries(params.changes, "notification.params.changes"),
+					itemId: requiredString$1(params.itemId, "notification.params.itemId"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId")
+				}
+			};
+		case "item/plan/delta":
+			assertExactKeys(params, "notification.params", [
+				"delta",
+				"itemId",
+				"threadId",
+				"turnId"
+			]);
+			return {
+				method,
+				params: {
+					delta: requiredString$1(params.delta, "notification.params.delta"),
+					itemId: requiredString$1(params.itemId, "notification.params.itemId"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId")
+				}
+			};
+		case "item/reasoning/summaryTextDelta":
+			assertExactKeys(params, "notification.params", [
+				"delta",
+				"itemId",
+				"summaryIndex",
+				"threadId",
+				"turnId"
+			]);
+			return {
+				method,
+				params: {
+					delta: requiredString$1(params.delta, "notification.params.delta"),
+					itemId: requiredString$1(params.itemId, "notification.params.itemId"),
+					summaryIndex: requiredNumber$1(params.summaryIndex, "notification.params.summaryIndex"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId")
+				}
+			};
+		case "item/mcpToolCall/progress":
+			assertExactKeys(params, "notification.params", [
+				"itemId",
+				"message",
+				"threadId",
+				"turnId"
+			]);
+			return {
+				method,
+				params: {
+					itemId: requiredString$1(params.itemId, "notification.params.itemId"),
+					message: requiredPlainString(params.message, "notification.params.message"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId")
+				}
+			};
+		default: throw new Error(`Unsupported FDE delta notification method: ${method}`);
+	}
+}
+function normalizeFdeProjectionBackedLiveNotification(notification, method) {
+	switch (method) {
+		case "runtime.state.updated": return {
+			method,
+			params: normalizeFdeRuntimeStateSnapshotWire(notification.params, "runtime_state")
+		};
+	}
+}
+function normalizeFdeRuntimeStateSnapshotWire(value, fieldName) {
+	const state = asRecord$1(value, fieldName);
+	rejectFrameFields(state, fieldName, [
+		"current_phase",
+		"last_agent",
+		"mode",
+		"pending_action",
+		"pending_fields",
+		"target_artifact",
+		"updated_at"
+	]);
+	assertAllowedKeys(state, fieldName, [
+		"activities",
+		"clock",
+		"content_policy",
+		"gates",
+		"outputs",
+		"right_panel",
+		"run",
+		"sources",
+		"summary",
+		"version"
+	]);
+	if (requiredNumber$1(state.version, `${fieldName}.version`) !== 1) throw new Error(`${fieldName}.version is unsupported.`);
+	const run = asRecord$1(state.run, `${fieldName}.run`);
+	rejectFrameFields(run, `${fieldName}.run`, [
+		"assistant_message_id",
+		"conversation_id",
+		"conversationId",
+		"user_message_id"
+	]);
+	assertAllowedKeys(run, `${fieldName}.run`, [
+		"elapsed_ms",
+		"ended_at",
+		"message_id",
+		"phase",
+		"run_id",
+		"started_at",
+		"status",
+		"thread_id",
+		"turn_id",
+		"updated_at"
+	]);
+	const clock = asRecord$1(state.clock, `${fieldName}.clock`);
+	assertAllowedKeys(clock, `${fieldName}.clock`, [
+		"revision",
+		"source_offset",
+		"updated_at"
+	]);
+	const summary = asRecord$1(state.summary, `${fieldName}.summary`);
+	assertAllowedKeys(summary, `${fieldName}.summary`, [
+		"current",
+		"done",
+		"next",
+		"outputs"
+	]);
+	const contentPolicy = asRecord$1(state.content_policy, `${fieldName}.content_policy`);
+	assertAllowedKeys(contentPolicy, `${fieldName}.content_policy`, [
+		"contains_internal_reasoning",
+		"contains_raw_tool_payload",
+		"visible_reply_contract"
+	]);
+	const containsInternalReasoning = requiredBoolean(contentPolicy.contains_internal_reasoning, `${fieldName}.content_policy.contains_internal_reasoning`);
+	const containsRawToolPayload = requiredBoolean(contentPolicy.contains_raw_tool_payload, `${fieldName}.content_policy.contains_raw_tool_payload`);
+	if (containsInternalReasoning || containsRawToolPayload) throw new Error(`${fieldName}.content_policy contains private content.`);
+	const visibleReplyContract = optionalString$1(contentPolicy.visible_reply_contract, `${fieldName}.content_policy.visible_reply_contract`);
+	if (visibleReplyContract !== void 0 && visibleReplyContract !== "terminal_summary") throw new Error(`${fieldName}.content_policy.visible_reply_contract is invalid.`);
+	return withoutUndefinedFields$1({
+		activities: requiredArray(state.activities, `${fieldName}.activities`).map((item, index) => normalizeFdeRuntimeActivityWire(item, `${fieldName}.activities[${index}]`)),
+		clock: withoutUndefinedFields$1({
+			revision: requiredNonNegativeSafeInteger(clock.revision, `${fieldName}.clock.revision`),
+			source_offset: optionalNonNegativeSafeInteger(clock.source_offset, `${fieldName}.clock.source_offset`),
+			updated_at: requiredString$1(clock.updated_at, `${fieldName}.clock.updated_at`)
+		}),
+		content_policy: withoutUndefinedFields$1({
+			contains_internal_reasoning: containsInternalReasoning,
+			contains_raw_tool_payload: containsRawToolPayload,
+			visible_reply_contract: visibleReplyContract
+		}),
+		gates: requiredArray(state.gates, `${fieldName}.gates`).map((item, index) => normalizeFdeRuntimeGateWire(item, `${fieldName}.gates[${index}]`)),
+		outputs: requiredArray(state.outputs, `${fieldName}.outputs`).map((item, index) => normalizeFdeRuntimeOutputRefWire(item, `${fieldName}.outputs[${index}]`)),
+		right_panel: state.right_panel === void 0 ? void 0 : normalizeFdeRuntimeRightPanelWire(state.right_panel, `${fieldName}.right_panel`),
+		run: withoutUndefinedFields$1({
+			elapsed_ms: optionalNumber$1(run.elapsed_ms, `${fieldName}.run.elapsed_ms`),
+			ended_at: optionalString$1(run.ended_at, `${fieldName}.run.ended_at`),
+			message_id: optionalString$1(run.message_id, `${fieldName}.run.message_id`),
+			phase: requiredRuntimeRunPhase(run.phase, `${fieldName}.run.phase`),
+			run_id: requiredString$1(run.run_id, `${fieldName}.run.run_id`),
+			started_at: optionalString$1(run.started_at, `${fieldName}.run.started_at`),
+			status: requiredRuntimeRunStatus(run.status, `${fieldName}.run.status`),
+			thread_id: requiredString$1(run.thread_id, `${fieldName}.run.thread_id`),
+			turn_id: requiredString$1(run.turn_id, `${fieldName}.run.turn_id`),
+			updated_at: requiredString$1(run.updated_at, `${fieldName}.run.updated_at`)
+		}),
+		sources: requiredArray(state.sources, `${fieldName}.sources`).map((item, index) => normalizeFdeRuntimeSourceRefWire(item, `${fieldName}.sources[${index}]`)),
+		summary: withoutUndefinedFields$1({
+			current: optionalString$1(summary.current, `${fieldName}.summary.current`),
+			done: requiredStringArray$1(summary.done, `${fieldName}.summary.done`),
+			next: requiredStringArray$1(summary.next, `${fieldName}.summary.next`),
+			outputs: requiredArray(summary.outputs, `${fieldName}.summary.outputs`).map((item, index) => normalizeFdeRuntimeOutputRefWire(item, `${fieldName}.summary.outputs[${index}]`))
+		}),
+		version: 1
+	});
+}
+function normalizeFdeRuntimeActivityWire(value, fieldName) {
+	const activity = asRecord$1(value, fieldName);
+	assertAllowedKeys(activity, fieldName, [
+		"detail",
+		"ended_at",
+		"id",
+		"label",
+		"started_at",
+		"status",
+		"updated_at"
+	]);
+	return withoutUndefinedFields$1({
+		detail: optionalString$1(activity.detail, `${fieldName}.detail`),
+		ended_at: optionalString$1(activity.ended_at, `${fieldName}.ended_at`),
+		id: requiredString$1(activity.id, `${fieldName}.id`),
+		label: requiredString$1(activity.label, `${fieldName}.label`),
+		started_at: optionalString$1(activity.started_at, `${fieldName}.started_at`),
+		status: requiredRuntimeActivityStatus(activity.status, `${fieldName}.status`),
+		updated_at: optionalString$1(activity.updated_at, `${fieldName}.updated_at`)
+	});
+}
+function normalizeFdeRuntimeGateWire(value, fieldName) {
+	const gate = asRecord$1(value, fieldName);
+	assertAllowedKeys(gate, fieldName, [
+		"id",
+		"kind",
+		"message",
+		"request_id",
+		"request_revision",
+		"request_state_revision",
+		"required_action_id",
+		"status",
+		"title",
+		"turn_id"
+	]);
+	return withoutUndefinedFields$1({
+		id: requiredString$1(gate.id, `${fieldName}.id`),
+		kind: requiredRuntimeGateKind(gate.kind, `${fieldName}.kind`),
+		message: optionalString$1(gate.message, `${fieldName}.message`),
+		request_id: optionalString$1(gate.request_id, `${fieldName}.request_id`),
+		request_revision: optionalNonNegativeSafeInteger(gate.request_revision, `${fieldName}.request_revision`),
+		request_state_revision: optionalNonNegativeSafeInteger(gate.request_state_revision, `${fieldName}.request_state_revision`),
+		required_action_id: optionalString$1(gate.required_action_id, `${fieldName}.required_action_id`),
+		status: requiredRuntimeGateStatus(gate.status, `${fieldName}.status`),
+		title: requiredString$1(gate.title, `${fieldName}.title`),
+		turn_id: optionalString$1(gate.turn_id, `${fieldName}.turn_id`)
+	});
+}
+function normalizeFdeRuntimeOutputRefWire(value, fieldName) {
+	const output = asRecord$1(value, fieldName);
+	assertAllowedKeys(output, fieldName, [
+		"document_uid",
+		"id",
+		"kind",
+		"mime_type",
+		"rel_path",
+		"title",
+		"uri"
+	]);
+	return withoutUndefinedFields$1({
+		document_uid: optionalString$1(output.document_uid, `${fieldName}.document_uid`),
+		id: requiredString$1(output.id, `${fieldName}.id`),
+		kind: requiredRuntimeOutputKind(output.kind, `${fieldName}.kind`),
+		mime_type: optionalString$1(output.mime_type, `${fieldName}.mime_type`),
+		rel_path: optionalString$1(output.rel_path, `${fieldName}.rel_path`),
+		title: requiredString$1(output.title, `${fieldName}.title`),
+		uri: optionalRuntimeUri(output.uri, `${fieldName}.uri`)
+	});
+}
+function normalizeFdeRuntimeSourceRefWire(value, fieldName) {
+	const source = asRecord$1(value, fieldName);
+	assertAllowedKeys(source, fieldName, [
+		"document_uid",
+		"id",
+		"kind",
+		"rel_path",
+		"title",
+		"uri"
+	]);
+	return withoutUndefinedFields$1({
+		document_uid: optionalString$1(source.document_uid, `${fieldName}.document_uid`),
+		id: requiredString$1(source.id, `${fieldName}.id`),
+		kind: requiredRuntimeSourceKind(source.kind, `${fieldName}.kind`),
+		rel_path: optionalString$1(source.rel_path, `${fieldName}.rel_path`),
+		title: requiredString$1(source.title, `${fieldName}.title`),
+		uri: optionalRuntimeUri(source.uri, `${fieldName}.uri`)
+	});
+}
+function normalizeFdeRuntimeRightPanelWire(value, fieldName) {
+	const panel = asRecord$1(value, fieldName);
+	assertAllowedKeys(panel, fieldName, [
+		"document_uid",
+		"kind",
+		"ref_id",
+		"title"
+	]);
+	return withoutUndefinedFields$1({
+		document_uid: optionalString$1(panel.document_uid, `${fieldName}.document_uid`),
+		kind: requiredRuntimeRightPanelKind(panel.kind, `${fieldName}.kind`),
+		ref_id: optionalString$1(panel.ref_id, `${fieldName}.ref_id`),
+		title: requiredString$1(panel.title, `${fieldName}.title`)
+	});
+}
+function normalizeFdeEventAppendedNotification(value) {
+	const notification = asRecord$1(value, "notification");
+	const method = requiredString$1(notification.method, "method");
+	const params = asRecord$1(notification.params, "notification.params");
+	switch (method) {
+		case "item/started":
+			assertExactKeys(params, "notification.params", [
+				"item",
+				"startedAtMs",
+				"threadId",
+				"turnId"
+			]);
+			return {
+				method,
+				params: {
+					item: normalizeFdeFullThreadItem(params.item, "notification.params.item"),
+					startedAtMs: requiredNumber$1(params.startedAtMs, "notification.params.startedAtMs"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId")
+				}
+			};
+		case "item/updated":
+			assertExactKeys(params, "notification.params", [
+				"item",
+				"threadId",
+				"turnId",
+				"updatedAtMs"
+			]);
+			return {
+				method,
+				params: {
+					item: normalizeFdeFullThreadItem(params.item, "notification.params.item"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId"),
+					updatedAtMs: requiredNumber$1(params.updatedAtMs, "notification.params.updatedAtMs")
+				}
+			};
+		case "item/completed":
+			assertExactKeys(params, "notification.params", [
+				"completedAtMs",
+				"item",
+				"threadId",
+				"turnId"
+			]);
+			return {
+				method,
+				params: {
+					completedAtMs: requiredNumber$1(params.completedAtMs, "notification.params.completedAtMs"),
+					item: normalizeFdeFullThreadItem(params.item, "notification.params.item"),
+					threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+					turnId: requiredString$1(params.turnId, "notification.params.turnId")
+				}
+			};
+		case "serverRequest/resolved": return createFdeCoreServerRequestResolvedNotification(normalizeFdeCoreServerRequestIdentity(params));
+		case "fde-core/turn.started": return normalizeFdeCoreTurnStartedNotification(notification);
+		case "fde-core/turn.completed":
+		case "fde-core/turn.failed":
+		case "fde-core/turn.cancelled": return normalizeFdeCoreTurnTerminalNotification(notification, method);
+		case "fde-core/event.watermark":
+		case "fde/archiveResource/saved": {
+			const sanitizedParams = sanitizePublicPayload(params);
+			return sanitizedParams === void 0 ? { method } : {
+				method,
+				params: sanitizedParams
+			};
+		}
+		default: throw new Error(`Unsupported FDE event_appended notification method: ${method}`);
+	}
+}
+function normalizeFdeFullThreadItem(value, fieldName) {
+	const item = asRecord$1(value, fieldName);
+	const type = requiredString$1(item.type, `${fieldName}.type`);
+	const base = withoutUndefinedFields$1({
+		createdAtMs: optionalNumber$1(item.createdAtMs, `${fieldName}.createdAtMs`),
+		id: requiredString$1(item.id, `${fieldName}.id`),
+		sourceSeq: requiredPositiveSafeInteger(item.sourceSeq, `${fieldName}.sourceSeq`),
+		type,
+		updatedAtMs: optionalNumber$1(item.updatedAtMs, `${fieldName}.updatedAtMs`)
+	});
+	switch (type) {
+		case "userMessage": return withoutUndefinedFields$1({
+			...base,
+			clientId: optionalString$1(item.clientId, `${fieldName}.clientId`),
+			clientRequestId: optionalString$1(item.clientRequestId, `${fieldName}.clientRequestId`),
+			content: requiredInputArray(item.content, `${fieldName}.content`),
+			text: optionalString$1(item.text, `${fieldName}.text`),
+			type
+		});
+		case "agentMessage": return {
+			...base,
+			phase: requiredAgentMessagePhase(item.phase, `${fieldName}.phase`),
+			text: requiredPlainString(item.text, `${fieldName}.text`),
+			type
+		};
+		case "artifact": return {
+			...base,
+			artifactRefs: requiredArray(item.artifactRefs, `${fieldName}.artifactRefs`).map((ref, index) => normalizeFdeArtifactRef(ref, `${fieldName}.artifactRefs[${index}]`)),
+			title: requiredString$1(item.title, `${fieldName}.title`),
+			type
+		};
+		case "clarification":
+		case "confirmation": return withoutUndefinedFields$1({
+			...base,
+			displaySnapshot: normalizeRequestDisplaySnapshot(item.displaySnapshot, `${fieldName}.displaySnapshot`),
+			requestIdentity: normalizeRequestDisplayIdentity(item.requestIdentity, `${fieldName}.requestIdentity`),
+			requestType: optionalString$1(item.requestType, `${fieldName}.requestType`),
+			response: item.response === void 0 ? void 0 : sanitizePublicPayload(asRecord$1(item.response, `${fieldName}.response`)),
+			state: requiredRequestDisplayState(item.state, `${fieldName}.state`),
+			type
+		});
+		case "collabAgentToolCall": return withoutUndefinedFields$1({
+			...base,
+			prompt: optionalString$1(item.prompt, `${fieldName}.prompt`),
+			receiverThreadIds: requiredStringArray$1(item.receiverThreadIds, `${fieldName}.receiverThreadIds`),
+			status: requiredExecutionStatus(item.status, `${fieldName}.status`),
+			tool: requiredString$1(item.tool, `${fieldName}.tool`),
+			toolKind: optionalToolKind(item.toolKind, `${fieldName}.toolKind`),
+			type
+		});
+		case "commandExecution": return withoutUndefinedFields$1({
+			...base,
+			aggregatedOutput: optionalString$1(item.aggregatedOutput, `${fieldName}.aggregatedOutput`),
+			approvalRequestId: optionalString$1(item.approvalRequestId, `${fieldName}.approvalRequestId`),
+			command: requiredString$1(item.command, `${fieldName}.command`),
+			cwd: optionalString$1(item.cwd, `${fieldName}.cwd`),
+			durationMs: optionalNullableNumber(item.durationMs, `${fieldName}.durationMs`),
+			exitCode: optionalNullableNumber(item.exitCode, `${fieldName}.exitCode`),
+			status: requiredExecutionStatus(item.status, `${fieldName}.status`),
+			type
+		});
+		case "diagnostic": return withoutUndefinedFields$1({
+			...base,
+			debugId: optionalString$1(item.debugId, `${fieldName}.debugId`),
+			detail: optionalString$1(item.detail, `${fieldName}.detail`),
+			publicPayload: item.publicPayload === void 0 ? void 0 : sanitizePublicPayload(asRecord$1(item.publicPayload, `${fieldName}.publicPayload`)),
+			severity: optionalDiagnosticSeverity(item.severity, `${fieldName}.severity`),
+			title: requiredString$1(item.title, `${fieldName}.title`),
+			type
+		});
+		case "dynamicToolCall":
+		case "mcpToolCall": return withoutUndefinedFields$1({
+			...base,
+			durationMs: optionalNullableNumber(item.durationMs, `${fieldName}.durationMs`),
+			error: item.error === void 0 || item.error === null ? item.error : normalizeFdeTurnError(item.error, `${fieldName}.error`),
+			namespace: type === "dynamicToolCall" ? optionalString$1(item.namespace, `${fieldName}.namespace`) : void 0,
+			server: type === "mcpToolCall" ? optionalString$1(item.server, `${fieldName}.server`) : void 0,
+			status: requiredExecutionStatus(item.status, `${fieldName}.status`),
+			tool: requiredString$1(item.tool, `${fieldName}.tool`),
+			toolKind: optionalToolKind(item.toolKind, `${fieldName}.toolKind`),
+			type,
+			...item.arguments === void 0 ? {} : { arguments: sanitizePublicPayloadValue(item.arguments) },
+			...item.result === void 0 ? {} : { result: sanitizePublicPayloadValue(item.result) }
+		});
+		case "error": return withoutUndefinedFields$1({
+			...base,
+			code: optionalString$1(item.code, `${fieldName}.code`),
+			detail: optionalString$1(item.detail, `${fieldName}.detail`),
+			message: requiredString$1(item.message, `${fieldName}.message`),
+			type
+		});
+		case "fileChange": return withoutUndefinedFields$1({
+			...base,
+			approvalRequestId: optionalString$1(item.approvalRequestId, `${fieldName}.approvalRequestId`),
+			artifactRefs: item.artifactRefs === void 0 ? void 0 : requiredArray(item.artifactRefs, `${fieldName}.artifactRefs`).map((ref, index) => normalizeFdeArtifactRef(ref, `${fieldName}.artifactRefs[${index}]`)),
+			changes: item.changes === void 0 ? [] : normalizeFileChangeEntries(item.changes, `${fieldName}.changes`),
+			diff: optionalString$1(item.diff, `${fieldName}.diff`),
+			path: optionalString$1(item.path, `${fieldName}.path`),
+			status: requiredExecutionStatus(item.status, `${fieldName}.status`),
+			type
+		});
+		case "imageGeneration": return withoutUndefinedFields$1({
+			...base,
+			artifactRefs: item.artifactRefs === void 0 ? void 0 : requiredArray(item.artifactRefs, `${fieldName}.artifactRefs`).map((ref, index) => normalizeFdeArtifactRef(ref, `${fieldName}.artifactRefs[${index}]`)),
+			prompt: requiredString$1(item.prompt, `${fieldName}.prompt`),
+			status: item.status === void 0 ? void 0 : requiredExecutionStatus(item.status, `${fieldName}.status`),
+			type
+		});
+		case "webSearch": return withoutUndefinedFields$1({
+			...base,
+			query: requiredString$1(item.query, `${fieldName}.query`),
+			results: item.results === void 0 ? void 0 : requiredArray(item.results, `${fieldName}.results`),
+			status: item.status === void 0 ? void 0 : requiredExecutionStatus(item.status, `${fieldName}.status`),
+			type
+		});
+		case "plan":
+			if ("steps" in item) throw new Error(`${fieldName}.steps is not supported.`);
+			if ("explanation" in item) throw new Error(`${fieldName}.explanation is not supported.`);
+			return {
+				...base,
+				text: requiredString$1(item.text, `${fieldName}.text`),
+				type
+			};
+		case "reasoning": return {
+			...base,
+			summary: requiredStringArray$1(item.summary, `${fieldName}.summary`),
+			type
+		};
+		case "skillCall": return withoutUndefinedFields$1({
+			...base,
+			artifactRefs: item.artifactRefs === void 0 ? void 0 : requiredArray(item.artifactRefs, `${fieldName}.artifactRefs`).map((ref, index) => normalizeFdeArtifactRef(ref, `${fieldName}.artifactRefs[${index}]`)),
+			result: item.result === void 0 ? void 0 : sanitizePublicPayloadValue(item.result),
+			skillId: optionalString$1(item.skillId, `${fieldName}.skillId`),
+			status: requiredExecutionStatus(item.status, `${fieldName}.status`),
+			title: optionalString$1(item.title, `${fieldName}.title`) ?? optionalString$1(item.toolName, `${fieldName}.toolName`) ?? optionalString$1(item.skillId, `${fieldName}.skillId`) ?? requiredString$1(item.title, `${fieldName}.title`),
+			toolKind: optionalToolKind(item.toolKind, `${fieldName}.toolKind`),
+			toolCallId: optionalString$1(item.toolCallId, `${fieldName}.toolCallId`),
+			toolName: optionalString$1(item.toolName, `${fieldName}.toolName`),
+			type
+		});
+		default: throw new Error(`${fieldName}.type is invalid.`);
+	}
+}
+function normalizeFdeThreadItemPreview(value, fieldName) {
+	const item = asRecord$1(value, fieldName);
+	if ("sourceSeq" in item) throw new Error(`${fieldName}.sourceSeq is not supported for previews.`);
+	const type = requiredString$1(item.type, `${fieldName}.type`);
+	const base = withoutUndefinedFields$1({
+		createdAtMs: optionalNumber$1(item.createdAtMs, `${fieldName}.createdAtMs`),
+		id: requiredString$1(item.id, `${fieldName}.id`),
+		type,
+		updatedAtMs: optionalNumber$1(item.updatedAtMs, `${fieldName}.updatedAtMs`)
+	});
+	switch (type) {
+		case "agentMessage":
+		case "plan":
+		case "userMessage": return withoutUndefinedFields$1({
+			...base,
+			text: optionalString$1(item.text, `${fieldName}.text`),
+			type
+		});
+		case "clarification":
+		case "confirmation": return withoutUndefinedFields$1({
+			...base,
+			state: optionalRequestDisplayState(item.state, `${fieldName}.state`),
+			title: optionalString$1(item.title, `${fieldName}.title`),
+			type
+		});
+		case "diagnostic":
+		case "error": return withoutUndefinedFields$1({
+			...base,
+			message: optionalString$1(item.message, `${fieldName}.message`),
+			title: optionalString$1(item.title, `${fieldName}.title`),
+			type
+		});
+		case "artifact":
+		case "collabAgentToolCall":
+		case "commandExecution":
+		case "dynamicToolCall":
+		case "fileChange":
+		case "imageGeneration":
+		case "mcpToolCall":
+		case "skillCall":
+		case "webSearch": return withoutUndefinedFields$1({
+			...base,
+			title: optionalString$1(item.title, `${fieldName}.title`),
+			type
+		});
+		default: throw new Error(`${fieldName}.type is invalid.`);
+	}
+}
+function normalizeFdeArtifactRef(value, fieldName) {
+	const item = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		artifactId: optionalString$1(item.artifactId, `${fieldName}.artifactId`),
+		fileKey: optionalString$1(item.fileKey, `${fieldName}.fileKey`),
+		id: optionalString$1(item.id, `${fieldName}.id`),
+		logicalPath: optionalString$1(item.logicalPath, `${fieldName}.logicalPath`),
+		path: optionalString$1(item.path, `${fieldName}.path`),
+		resourceId: optionalString$1(item.resourceId, `${fieldName}.resourceId`),
+		sourceCollection: requiredString$1(item.sourceCollection, `${fieldName}.sourceCollection`),
+		title: optionalString$1(item.title, `${fieldName}.title`)
+	});
+}
+function normalizeRequestDisplayIdentity(value, fieldName) {
+	const identity = asRecord$1(value, fieldName);
+	return {
+		ownerTurnId: requiredString$1(identity.ownerTurnId, `${fieldName}.ownerTurnId`),
+		requestId: requiredString$1(identity.requestId, `${fieldName}.requestId`),
+		requestRevision: requiredNumber$1(identity.requestRevision, `${fieldName}.requestRevision`),
+		stateRevision: requiredNumber$1(identity.stateRevision, `${fieldName}.stateRevision`),
+		threadId: requiredString$1(identity.threadId, `${fieldName}.threadId`)
+	};
+}
+function normalizeRequestDisplaySnapshot(value, fieldName) {
+	const snapshot = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		prompt: requiredString$1(snapshot.prompt, `${fieldName}.prompt`),
+		publicPayload: snapshot.publicPayload === void 0 ? void 0 : sanitizePublicPayload(asRecord$1(snapshot.publicPayload, `${fieldName}.publicPayload`)),
+		title: optionalString$1(snapshot.title, `${fieldName}.title`)
+	});
+}
+function normalizeFileChangeEntries(value, fieldName) {
+	return requiredArray(value, fieldName).map((entry, index) => normalizeFileChangeEntry(entry, `${fieldName}[${index}]`));
+}
+function normalizeFileChangeEntry(value, fieldName) {
+	const entry = asRecord$1(value, fieldName);
+	assertExactKeys(entry, fieldName, [
+		"diff",
+		"kind",
+		"path"
+	]);
+	return {
+		diff: requiredPlainString(entry.diff, `${fieldName}.diff`),
+		kind: normalizePatchChangeKind(entry.kind, `${fieldName}.kind`),
+		path: requiredString$1(entry.path, `${fieldName}.path`)
+	};
+}
+function normalizePatchChangeKind(value, fieldName) {
+	const kind = asRecord$1(value, fieldName);
+	const type = requiredString$1(kind.type, `${fieldName}.type`);
+	if (type === "add" || type === "delete") {
+		assertExactKeys(kind, fieldName, ["type"]);
+		return { type };
+	}
+	if (type === "update") {
+		assertExactKeys(kind, fieldName, ["movePath", "type"]);
+		return withoutUndefinedFields$1({
+			movePath: optionalString$1(kind.movePath, `${fieldName}.movePath`),
+			type
+		});
+	}
+	throw new Error(`${fieldName}.type is invalid.`);
+}
+function normalizeTurnDiffSnapshot(value, fieldName) {
+	const diff = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		fileCount: requiredNumber$1(diff.fileCount, `${fieldName}.fileCount`),
+		sourceSeq: optionalNumber$1(diff.sourceSeq, `${fieldName}.sourceSeq`),
+		unifiedDiff: requiredPlainString(diff.unifiedDiff, `${fieldName}.unifiedDiff`),
+		updatedAt: optionalString$1(diff.updatedAt, `${fieldName}.updatedAt`)
+	});
+}
+function normalizeTurnPlanSnapshot(value, fieldName) {
+	const plan = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		explanation: optionalString$1(plan.explanation, `${fieldName}.explanation`),
+		itemId: optionalString$1(plan.itemId, `${fieldName}.itemId`),
+		sourceSeq: optionalNumber$1(plan.sourceSeq, `${fieldName}.sourceSeq`),
+		steps: requiredArray(plan.steps, `${fieldName}.steps`).map((step, index) => normalizePlanStep(step, `${fieldName}.steps[${index}]`)),
+		text: optionalString$1(plan.text, `${fieldName}.text`),
+		updatedAt: optionalString$1(plan.updatedAt, `${fieldName}.updatedAt`)
+	});
+}
+function normalizePlanStep(value, fieldName) {
+	const step = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		id: optionalString$1(step.id, `${fieldName}.id`),
+		status: requiredPlanStepStatus(step.status, `${fieldName}.status`),
+		step: requiredString$1(step.step, `${fieldName}.step`)
+	});
+}
+function normalizeFdeTurnError(value, fieldName) {
+	const error = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		code: optionalString$1(error.code, `${fieldName}.code`),
+		detail: optionalString$1(error.detail, `${fieldName}.detail`),
+		message: requiredString$1(error.message, `${fieldName}.message`)
+	});
+}
+function normalizeCapabilitySummaryWire(value, fieldName) {
+	const capability = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		capabilityId: requiredString$1(capability.capabilityId, `${fieldName}.capabilityId`),
+		displayName: optionalString$1(capability.displayName, `${fieldName}.displayName`),
+		mode: requiredString$1(capability.mode, `${fieldName}.mode`),
+		reasonCode: optionalString$1(capability.reasonCode, `${fieldName}.reasonCode`)
+	});
+}
+function normalizePublicErrorWire(value, fieldName) {
+	const error = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		code: optionalString$1(error.code, `${fieldName}.code`),
+		detail: optionalString$1(error.detail, `${fieldName}.detail`),
+		message: requiredString$1(error.message, `${fieldName}.message`),
+		nextAction: optionalString$1(error.nextAction, `${fieldName}.nextAction`),
+		targetPath: optionalString$1(error.targetPath, `${fieldName}.targetPath`),
+		title: optionalString$1(error.title, `${fieldName}.title`)
+	});
+}
+function normalizeSaveCompletionWire(value, fieldName) {
+	const completion = asRecord$1(value, fieldName);
+	return {
+		completionId: requiredString$1(completion.completionId, `${fieldName}.completionId`),
+		operation: requiredSaveCompletionOperation(completion.operation, `${fieldName}.operation`),
+		requestId: requiredString$1(completion.requestId, `${fieldName}.requestId`),
+		requestRevision: requiredNonNegativeSafeInteger(completion.requestRevision, `${fieldName}.requestRevision`),
+		requestStateRevision: requiredNonNegativeSafeInteger(completion.requestStateRevision, `${fieldName}.requestStateRevision`),
+		status: requiredSaveCompletionStatus(completion.status, `${fieldName}.status`),
+		summary: requiredString$1(completion.summary, `${fieldName}.summary`),
+		targetPaths: requiredArray(completion.targetPaths, `${fieldName}.targetPaths`).map((path, index) => requiredString$1(path, `${fieldName}.targetPaths[${index}]`))
+	};
+}
+function normalizeArtifactRefWire(value, fieldName) {
+	const item = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		artifactId: requiredString$1(item.artifactId, `${fieldName}.artifactId`),
+		artifact_kind: optionalString$1(item.artifact_kind, `${fieldName}.artifact_kind`),
+		locator: item.locator === void 0 ? void 0 : asRecord$1(item.locator, `${fieldName}.locator`),
+		operationSource: requiredOptionalOperationSource(item.operationSource, `${fieldName}.operationSource`),
+		path: requiredString$1(item.path, `${fieldName}.path`),
+		platformSyncStatus: requiredOptionalPlatformSyncStatus(item.platformSyncStatus, `${fieldName}.platformSyncStatus`),
+		resourceOperation: requiredOptionalResourceOperation(item.resourceOperation, `${fieldName}.resourceOperation`),
+		title: optionalString$1(item.title, `${fieldName}.title`)
+	});
+}
+function normalizeArtifactPanelItemWire(value, fieldName) {
+	const record = asRecord$1(value, fieldName);
+	return {
+		...normalizeArtifactRefWire(value, fieldName),
+		turnId: requiredString$1(record.turnId, `${fieldName}.turnId`)
+	};
+}
+function normalizeRequiredAction(value) {
+	const action = asRecord$1(value, "activeRequiredAction");
+	const kind = requiredString$1(action.kind, "activeRequiredAction.kind");
+	if (kind === "status") {
+		if ("surface" in action) throw new TypeError("activeRequiredAction.surface is not supported for status required actions.");
+		return {
+			actionId: requiredString$1(action.actionId, "activeRequiredAction.actionId"),
+			kind,
+			prompt: requiredString$1(action.prompt, "activeRequiredAction.prompt"),
+			stateRevision: requiredNumber$1(action.stateRevision, "activeRequiredAction.stateRevision"),
+			turnId: requiredString$1(action.turnId, "activeRequiredAction.turnId")
+		};
+	}
+	if (kind !== "text" && kind !== "choice" && kind !== "form" && kind !== "approval") throw new Error("activeRequiredAction.kind is invalid.");
+	const identity = normalizeFdeCoreServerRequestIdentity(action);
+	const submitKind = kind;
+	return withoutUndefinedFields$1({
+		...identity,
+		actionId: requiredString$1(action.actionId, "activeRequiredAction.actionId"),
+		decisions: optionalArray(action.decisions),
+		domain: optionalString$1(action.domain, "activeRequiredAction.domain"),
+		fields: optionalArray(action.fields),
+		kind: submitKind,
+		prompt: requiredString$1(action.prompt, "activeRequiredAction.prompt"),
+		publicPayload: optionalPublicPayload(action),
+		requestType: optionalString$1(action.requestType, "activeRequiredAction.requestType"),
+		surface: normalizeRequiredActionSurfaceWire(action.surface, "activeRequiredAction.surface")
+	});
+}
+function normalizeRequiredActionSurfaceWire(value, fieldName) {
+	if (value === void 0) return void 0;
+	const surface = asRecord$1(value, fieldName);
+	const kind = requiredString$1(surface.kind, `${fieldName}.kind`);
+	const version = requiredNumber$1(surface.version, `${fieldName}.version`);
+	if (version !== 1) throw new TypeError(`${fieldName}.version is unsupported.`);
+	switch (kind) {
+		case "build_module_selection": return {
+			diagnostics: normalizePublicDiagnostics(surface.diagnostics, `${fieldName}.diagnostics`),
+			goalId: optionalString$1(surface.goalId, `${fieldName}.goalId`),
+			kind,
+			modules: requiredArray(surface.modules, `${fieldName}.modules`).map((module, index) => normalizeBuildModuleSelectionSurfaceModule(module, `${fieldName}.modules[${index}]`)),
+			version
+		};
+		case "build_source_dependency": return {
+			dependencies: requiredArray(surface.dependencies, `${fieldName}.dependencies`).map((dependency, index) => normalizeBuildSourceDependencySurfaceDependency(dependency, `${fieldName}.dependencies[${index}]`)),
+			diagnostics: normalizePublicDiagnostics(surface.diagnostics, `${fieldName}.diagnostics`),
+			goalId: optionalString$1(surface.goalId, `${fieldName}.goalId`),
+			kind,
+			mode: requiredBuildSourceDependencyMode(surface.mode, `${fieldName}.mode`),
+			version
+		};
+		case "formal_save_approval": return {
+			diagnostics: normalizePublicDiagnostics(surface.diagnostics, `${fieldName}.diagnostics`),
+			kind,
+			targetSummary: requiredArray(surface.targetSummary, `${fieldName}.targetSummary`).map((target, index) => normalizeFormalSaveApprovalSurfaceTarget(target, `${fieldName}.targetSummary[${index}]`)),
+			title: requiredString$1(surface.title, `${fieldName}.title`),
+			version
+		};
+		case "model_blueprint_confirmation": return {
+			blueprint: normalizeModelBlueprintSummaryWire(surface.blueprint, `${fieldName}.blueprint`),
+			decisionMode: requiredDecisionMode(surface.decisionMode, `${fieldName}.decisionMode`),
+			diagnostics: normalizePublicDiagnostics(surface.diagnostics, `${fieldName}.diagnostics`),
+			goalId: requiredString$1(surface.goalId, `${fieldName}.goalId`),
+			kind,
+			missingSlots: requiredArray(surface.missingSlots, `${fieldName}.missingSlots`).map((slot, index) => normalizeModelBlueprintMissingSlotWire(slot, `${fieldName}.missingSlots[${index}]`)),
+			nextAction: requiredModelBlueprintNextAction(surface.nextAction, `${fieldName}.nextAction`),
+			version
+		};
+		default: throw new TypeError(`${fieldName}.kind is unsupported.`);
+	}
+}
+function normalizePublicDiagnostics(value, fieldName) {
+	return requiredArray(value ?? [], fieldName).map((item, index) => {
+		const diagnostic = asRecord$1(item, `${fieldName}[${index}]`);
+		return withoutUndefinedFields$1({
+			code: requiredString$1(diagnostic.code, `${fieldName}[${index}].code`),
+			message: requiredString$1(diagnostic.message, `${fieldName}[${index}].message`),
+			severity: requiredPublicDiagnosticSeverity(diagnostic.severity, `${fieldName}[${index}].severity`),
+			targetPath: optionalString$1(diagnostic.targetPath, `${fieldName}[${index}].targetPath`)
+		});
+	});
+}
+function normalizeModelBlueprintSummaryWire(value, fieldName) {
+	const blueprint = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		blueprintId: requiredString$1(blueprint.blueprintId, `${fieldName}.blueprintId`),
+		confidence: optionalNumber$1(blueprint.confidence, `${fieldName}.confidence`),
+		dictionaries: requiredArray(blueprint.dictionaries, `${fieldName}.dictionaries`).map((dictionary, index) => normalizeModelBlueprintDictionaryWire(dictionary, `${fieldName}.dictionaries[${index}]`)),
+		entities: requiredArray(blueprint.entities, `${fieldName}.entities`).map((entity, index) => normalizeModelBlueprintEntityWire(entity, `${fieldName}.entities[${index}]`))
+	});
+}
+function normalizeModelBlueprintEntityWire(value, fieldName) {
+	const entity = asRecord$1(value, fieldName);
+	return {
+		code: requiredString$1(entity.code, `${fieldName}.code`),
+		fieldCount: requiredNumber$1(entity.fieldCount, `${fieldName}.fieldCount`),
+		fields: requiredArray(entity.fields, `${fieldName}.fields`).map((field, index) => normalizeModelBlueprintFieldWire(field, `${fieldName}.fields[${index}]`)),
+		title: requiredString$1(entity.title, `${fieldName}.title`)
+	};
+}
+function normalizeModelBlueprintFieldWire(value, fieldName) {
+	const field = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		code: requiredString$1(field.code, `${fieldName}.code`),
+		dictionaryCode: optionalString$1(field.dictionaryCode, `${fieldName}.dictionaryCode`),
+		name: requiredString$1(field.name, `${fieldName}.name`),
+		relationHint: optionalString$1(field.relationHint, `${fieldName}.relationHint`),
+		relationTargetCode: optionalString$1(field.relationTargetCode, `${fieldName}.relationTargetCode`),
+		required: optionalBoolean(field.required, `${fieldName}.required`),
+		typeHint: optionalString$1(field.typeHint, `${fieldName}.typeHint`),
+		valueSource: optionalString$1(field.valueSource, `${fieldName}.valueSource`)
+	});
+}
+function normalizeModelBlueprintDictionaryWire(value, fieldName) {
+	const dictionary = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		code: requiredString$1(dictionary.code, `${fieldName}.code`),
+		title: requiredString$1(dictionary.title, `${fieldName}.title`),
+		valueCount: optionalNumber$1(dictionary.valueCount, `${fieldName}.valueCount`),
+		valuesPreview: requiredArray(dictionary.valuesPreview, `${fieldName}.valuesPreview`).map((item, index) => {
+			const valueRecord = asRecord$1(item, `${fieldName}.valuesPreview[${index}]`);
+			return {
+				label: requiredString$1(valueRecord.label, `${fieldName}.valuesPreview[${index}].label`),
+				value: requiredString$1(valueRecord.value, `${fieldName}.valuesPreview[${index}].value`)
+			};
+		})
+	});
+}
+function normalizeModelBlueprintMissingSlotWire(value, fieldName) {
+	const slot = asRecord$1(value, fieldName);
+	return {
+		blocking: requiredBoolean(slot.blocking, `${fieldName}.blocking`),
+		candidates: requiredArray(slot.candidates, `${fieldName}.candidates`).map((candidate, index) => {
+			const record = asRecord$1(candidate, `${fieldName}.candidates[${index}]`);
+			return withoutUndefinedFields$1({
+				description: optionalString$1(record.description, `${fieldName}.candidates[${index}].description`),
+				id: requiredString$1(record.id, `${fieldName}.candidates[${index}].id`),
+				label: requiredString$1(record.label, `${fieldName}.candidates[${index}].label`)
+			});
+		}),
+		field: requiredString$1(slot.field, `${fieldName}.field`),
+		owner: requiredString$1(slot.owner, `${fieldName}.owner`),
+		ownerId: requiredString$1(slot.ownerId, `${fieldName}.ownerId`),
+		reason: requiredString$1(slot.reason, `${fieldName}.reason`),
+		slotId: requiredString$1(slot.slotId, `${fieldName}.slotId`)
+	};
+}
+function normalizeBuildSourceDependencySurfaceDependency(value, fieldName) {
+	const dependency = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		blocking: requiredBoolean(dependency.blocking, `${fieldName}.blocking`),
+		candidates: requiredArray(dependency.candidates, `${fieldName}.candidates`).map((candidate, index) => {
+			const record = asRecord$1(candidate, `${fieldName}.candidates[${index}]`);
+			return withoutUndefinedFields$1({
+				description: optionalString$1(record.description, `${fieldName}.candidates[${index}].description`),
+				id: requiredString$1(record.id, `${fieldName}.candidates[${index}].id`),
+				label: requiredString$1(record.label, `${fieldName}.candidates[${index}].label`),
+				resourceType: optionalString$1(record.resourceType, `${fieldName}.candidates[${index}].resourceType`)
+			});
+		}),
+		dependencyId: requiredString$1(dependency.dependencyId, `${fieldName}.dependencyId`),
+		reason: requiredBuildSourceDependencyReason(dependency.reason, `${fieldName}.reason`),
+		resourceName: optionalString$1(dependency.resourceName, `${fieldName}.resourceName`),
+		resourceType: requiredBuildResourceType(dependency.resourceType, `${fieldName}.resourceType`)
+	});
+}
+function normalizeBuildModuleSelectionSurfaceModule(value, fieldName) {
+	const module = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		description: optionalString$1(module.description, `${fieldName}.description`),
+		id: requiredString$1(module.id, `${fieldName}.id`),
+		label: requiredString$1(module.label, `${fieldName}.label`),
+		selected: optionalBoolean(module.selected, `${fieldName}.selected`)
+	});
+}
+function normalizeFormalSaveApprovalSurfaceTarget(value, fieldName) {
+	const target = asRecord$1(value, fieldName);
+	return withoutUndefinedFields$1({
+		changeType: requiredOptionalChangeType(target.changeType, `${fieldName}.changeType`),
+		id: requiredString$1(target.id, `${fieldName}.id`),
+		label: requiredString$1(target.label, `${fieldName}.label`),
+		operationSource: requiredOperationSource(target.operationSource, `${fieldName}.operationSource`),
+		platformSyncStatus: requiredPlatformSyncStatus(target.platformSyncStatus, `${fieldName}.platformSyncStatus`),
+		resourceOperation: requiredResourceOperation(target.resourceOperation, `${fieldName}.resourceOperation`),
+		resourceType: optionalString$1(target.resourceType, `${fieldName}.resourceType`)
+	});
+}
+function normalizeActiveTurnControl(value) {
+	const active = asRecord$1(value, "activeTurnControl");
+	const status = optionalString$1(active.status, "activeTurnControl.status");
+	if (status !== void 0 && status !== "running" && status !== "interrupting") throw new Error("activeTurnControl.status is invalid.");
+	return {
+		clientRequestId: optionalString$1(active.clientRequestId, "activeTurnControl.clientRequestId"),
+		stateRevision: requiredNumber$1(active.stateRevision, "activeTurnControl.stateRevision"),
+		status,
+		turnId: requiredString$1(active.turnId, "activeTurnControl.turnId")
+	};
+}
+function normalizeContinuableTaskSession(value) {
+	const session = asRecord$1(value, "continuableTaskSession");
+	const status = requiredString$1(session.status, "continuableTaskSession.status");
+	if (status !== "continuable") throw new Error("continuableTaskSession.status is invalid.");
+	const continuableStatus = status;
+	return withoutUndefinedFields$1({
+		baseTurnId: requiredString$1(session.baseTurnId, "continuableTaskSession.baseTurnId"),
+		status: continuableStatus,
+		taskSessionId: requiredString$1(session.taskSessionId, "continuableTaskSession.taskSessionId"),
+		taskSessionRevision: requiredNonNegativeSafeInteger(session.taskSessionRevision, "continuableTaskSession.taskSessionRevision")
+	});
+}
+function normalizeMemoryContextProjection(value, fieldName) {
+	const context = asRecord$1(value, fieldName);
+	rejectFrameFields(context, fieldName, [
+		"tenant_id",
+		"conversation_id",
+		"turn_id",
+		"created_at",
+		"source_status",
+		"suppressed_refs",
+		"budget_breakdown"
+	]);
+	const budget = asRecord$1(context.budget, `${fieldName}.budget`);
+	return {
+		snapshot_id: requiredString$1(context.snapshot_id, `${fieldName}.snapshot_id`),
+		selected_count: requiredNumber$1(context.selected_count, `${fieldName}.selected_count`),
+		suppressed_count: requiredNumber$1(context.suppressed_count, `${fieldName}.suppressed_count`),
+		suppressed_reason_counts: normalizeSuppressedReasonCounts(context.suppressed_reason_counts, `${fieldName}.suppressed_reason_counts`),
+		budget: {
+			max_tokens: requiredNumber$1(budget.max_tokens, `${fieldName}.budget.max_tokens`),
+			estimated_tokens: requiredNumber$1(budget.estimated_tokens, `${fieldName}.budget.estimated_tokens`)
+		},
+		summary_available: requiredBoolean(context.summary_available, `${fieldName}.summary_available`),
+		snapshot_detail_status: requiredMemorySnapshotDetailStatus(context.snapshot_detail_status, `${fieldName}.snapshot_detail_status`),
+		fallback_level: requiredMemoryFallbackLevel(context.fallback_level, `${fieldName}.fallback_level`),
+		selected_refs: requiredArray(context.selected_refs, `${fieldName}.selected_refs`).map((ref, index) => normalizePublicMemoryContextRef(ref, `${fieldName}.selected_refs[${index}]`))
+	};
+}
+function normalizeSuppressedReasonCounts(value, fieldName) {
+	const record = asRecord$1(value, fieldName);
+	const out = {};
+	for (const [key, count] of Object.entries(record)) out[key] = requiredNumber$1(count, `${fieldName}.${key}`);
+	return out;
+}
+function normalizePublicMemoryContextRef(value, fieldName) {
+	const ref = asRecord$1(value, fieldName);
+	const type = requiredString$1(ref.type, `${fieldName}.type`);
+	if (type === "memory_record") return withoutUndefinedFields$1({
+		type,
+		memory_id: requiredString$1(ref.memory_id, `${fieldName}.memory_id`),
+		scope: requiredMemoryScope(ref.scope, `${fieldName}.scope`),
+		category: ref.category === void 0 ? void 0 : requiredMemoryRecordCategory(ref.category, `${fieldName}.category`),
+		trust_level: ref.trust_level === void 0 ? void 0 : requiredMemoryTrustLevel(ref.trust_level, `${fieldName}.trust_level`),
+		title: optionalString$1(ref.title, `${fieldName}.title`),
+		summary: requiredString$1(ref.summary, `${fieldName}.summary`),
+		reason: requiredMemoryRecordContextReason(ref.reason, `${fieldName}.reason`),
+		rank: requiredNumber$1(ref.rank, `${fieldName}.rank`),
+		token_estimate: requiredNumber$1(ref.token_estimate, `${fieldName}.token_estimate`)
+	});
+	if (type === "conversation_summary") return {
+		type,
+		summary_id: requiredString$1(ref.summary_id, `${fieldName}.summary_id`),
+		conversation_id: requiredString$1(ref.conversation_id, `${fieldName}.conversation_id`),
+		summary: requiredString$1(ref.summary, `${fieldName}.summary`),
+		reason: requiredConversationSummaryContextReason(ref.reason, `${fieldName}.reason`),
+		rank: requiredNumber$1(ref.rank, `${fieldName}.rank`),
+		token_estimate: requiredNumber$1(ref.token_estimate, `${fieldName}.token_estimate`)
+	};
+	if (type === "recent_message_range") return withoutUndefinedFields$1({
+		type,
+		conversation_id: requiredString$1(ref.conversation_id, `${fieldName}.conversation_id`),
+		from_message_seq: optionalNumber$1(ref.from_message_seq, `${fieldName}.from_message_seq`),
+		to_message_seq: optionalNumber$1(ref.to_message_seq, `${fieldName}.to_message_seq`),
+		reason: requiredRecentMessageContextReason(ref.reason, `${fieldName}.reason`),
+		rank: requiredNumber$1(ref.rank, `${fieldName}.rank`),
+		token_estimate: requiredNumber$1(ref.token_estimate, `${fieldName}.token_estimate`)
+	});
+	throw new Error(`${fieldName}.type is invalid.`);
+}
+function requiredServerRequestMethod(value) {
+	if (value === "fde/serverRequest/userInput" || value === "fde/serverRequest/approval") return value;
+	throw new Error("method is invalid.");
+}
+function requiredTurnStatus(value, fieldName) {
+	if (value === "running" || value === "awaiting_input" || value === "completed" || value === "failed" || value === "cancelled") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRuntimeRunStatus(value, fieldName) {
+	if (value === "running" || value === "waiting_user" || value === "completed" || value === "failed" || value === "cancelled") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRuntimeRunPhase(value, fieldName) {
+	if (value === "prework" || value === "planning" || value === "executing" || value === "answering" || value === "saving" || value === "done") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRuntimeActivityStatus(value, fieldName) {
+	if (value === "pending" || value === "running" || value === "completed" || value === "failed" || value === "skipped") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRuntimeGateKind(value, fieldName) {
+	if (value === "user_input" || value === "approval" || value === "server_request") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRuntimeGateStatus(value, fieldName) {
+	if (value === "pending" || value === "resolved" || value === "cancelled") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRuntimeOutputKind(value, fieldName) {
+	if (value === "artifact" || value === "file" || value === "message" || value === "panel") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRuntimeSourceKind(value, fieldName) {
+	if (value === "file" || value === "artifact" || value === "tool" || value === "knowledge") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRuntimeRightPanelKind(value, fieldName) {
+	if (value === "produce" || value === "artifact" || value === "diff" || value === "approval") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredMemoryScope(value, fieldName) {
+	if (value === "platform" || value === "tenant" || value === "app" || value === "resource" || value === "user" || value === "conversation") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredMemoryRecordCategory(value, fieldName) {
+	if (value === "profile" || value === "preference" || value === "business_term" || value === "design_decision" || value === "constraint" || value === "open_question" || value === "workflow_pattern") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredMemoryTrustLevel(value, fieldName) {
+	if (value === "admin_confirmed" || value === "owner_confirmed" || value === "user_confirmed" || value === "imported") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredMemorySnapshotDetailStatus(value, fieldName) {
+	if (value === "available" || value === "pending" || value === "unavailable") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredMemoryFallbackLevel(value, fieldName) {
+	if (value === "memory_summary_recent" || value === "summary_recent" || value === "recent_only") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredMemoryRecordContextReason(value, fieldName) {
+	if (value === "retrieved" || value === "recent_write" || value === "pinned") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredConversationSummaryContextReason(value, fieldName) {
+	if (value === "recent_summary") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredRecentMessageContextReason(value, fieldName) {
+	if (value === "recent_messages") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredDecisionMode(value, fieldName) {
+	if (value === "clarify" || value === "confirm") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredModelBlueprintNextAction(value, fieldName) {
+	if (value === "clarify_model_blueprint" || value === "confirm_model_blueprint") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredPublicDiagnosticSeverity(value, fieldName) {
+	if (value === "blocking" || value === "info" || value === "warning") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredBuildSourceDependencyMode(value, fieldName) {
+	if (value === "ambiguous" || value === "missing") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredBuildSourceDependencyReason(value, fieldName) {
+	if (value === "ambiguous" || value === "missing" || value === "not_found") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredBuildResourceType(value, fieldName) {
+	if (value === "document" || value === "form_page" || value === "list_page" || value === "model" || value === "script" || value === "workflow") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredOptionalChangeType(value, fieldName) {
+	if (value === void 0) return void 0;
+	if (value === "create" || value === "delete" || value === "edit") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredOptionalResourceOperation(value, fieldName) {
+	if (value === void 0) return void 0;
+	if (value === "create" || value === "edit") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredResourceOperation(value, fieldName) {
+	const result = requiredOptionalResourceOperation(value, fieldName);
+	if (result === void 0) throw new Error(`${fieldName} is required.`);
+	return result;
+}
+function requiredOptionalOperationSource(value, fieldName) {
+	if (value === void 0) return void 0;
+	if (value === "semantic_planner" || value === "typed_user_decision" || value === "runtime_resolution") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredOperationSource(value, fieldName) {
+	const result = requiredOptionalOperationSource(value, fieldName);
+	if (result === void 0) throw new Error(`${fieldName} is required.`);
+	return result;
+}
+function requiredSaveCompletionOperation(value, fieldName) {
+	if (value === "formal_save" || value === "platform_sync") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredSaveCompletionStatus(value, fieldName) {
+	if (value === "succeeded") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredOptionalPlatformSyncStatus(value, fieldName) {
+	if (value === void 0) return void 0;
+	if (value === "not_required" || value === "pending_user_confirm" || value === "succeeded" || value === "failed" || value === "failed_retryable" || value === "failed_terminal" || value === "partial_write" || value === "waived") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function requiredPlatformSyncStatus(value, fieldName) {
+	const result = requiredOptionalPlatformSyncStatus(value, fieldName);
+	if (result === void 0) throw new Error(`${fieldName} is required.`);
+	return result;
+}
+function ensureMatchingId(id, requestId) {
+	if (id !== requestId) throw new Error(`stale_or_invalid server response id mismatch for requestId ${requestId}.`);
+}
+function requiredArray(value, fieldName) {
+	if (!Array.isArray(value)) throw new TypeError(`${fieldName} must be an array.`);
+	return value;
+}
+function optionalArray(value) {
+	return value === void 0 ? void 0 : requiredArray(value, "array");
+}
+function optionalPublicPayload(record) {
+	if ("public_payload" in record) throw new TypeError("public_payload is not supported for app/UI server request wire.");
+	const value = record.publicPayload;
+	if (value === void 0) return void 0;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("publicPayload must be an object.");
+	return sanitizePublicPayload(value);
+}
+function optionalBoundItemType(value, fieldName) {
+	if (value === void 0) return void 0;
+	if (value === "commandExecution" || value === "fileChange") return value;
+	throw new TypeError(`${fieldName} is invalid.`);
+}
+function normalizeItemBoundIdentity(params) {
+	const approvalRequestId = optionalNonEmptyString(params.approvalRequestId, "approvalRequestId");
+	const boundItemId = optionalNonEmptyString(params.boundItemId, "boundItemId");
+	const boundItemType = optionalBoundItemType(params.boundItemType, "boundItemType");
+	if (boundItemId && !boundItemType || !boundItemId && boundItemType) throw new TypeError("boundItemId and boundItemType must be provided together.");
+	return withoutUndefinedFields$1({
+		approvalRequestId,
+		boundItemId,
+		boundItemType
+	});
+}
+const FDE_PUBLIC_PAYLOAD_MAX_DEPTH = 8;
+const FDE_PUBLIC_PAYLOAD_MAX_OBJECT_KEYS = 64;
+const FDE_PUBLIC_PAYLOAD_MAX_ARRAY_ITEMS = 100;
+const FDE_PUBLIC_PAYLOAD_MAX_STRING_LENGTH = 2e4;
+const PRIVATE_PUBLIC_PAYLOAD_KEYS = new Set([
+	["projection", "Requirements"].join(""),
+	["projection", "requirements"].join("_"),
+	"attachment_id",
+	"attachmentId",
+	"base64",
+	"binary",
+	"candidate_catalog_hash",
+	"candidate_set_hash",
+	"candidateCatalogHash",
+	"candidateSetHash",
+	"canonical_path",
+	"canonical_turn_id",
+	"canonicalPath",
+	"canonicalTurnId",
+	"commit_idempotency_key",
+	"commitIdempotencyKey",
+	"content_hash",
+	"contentHash",
+	"conversation_id",
+	"conversationId",
+	"document_uid",
+	"documentUid",
+	"draft_id",
+	"draftId",
+	"edit_intents",
+	"editIntents",
+	"field_list",
+	"fieldList",
+	"debug_log",
+	"debug_logs",
+	"debugLog",
+	"debugLogs",
+	"file_key",
+	"fileKey",
+	"formal_abs_path",
+	"formal_save",
+	"formalAbsPath",
+	"formalSave",
+	"full_path",
+	"fullPath",
+	"idempotency_key",
+	"idempotencyKey",
+	"internalReasoning",
+	"internal_trace",
+	"internalTrace",
+	"lock_fencing_token",
+	"lock_id",
+	"lockFencingToken",
+	"lockId",
+	"migration_policies",
+	"migrationPolicies",
+	"model_edit_intent_bundle",
+	"modelEditIntentBundle",
+	"logical_path",
+	"logicalPath",
+	"materialization_idempotency_key",
+	"materializationIdempotencyKey",
+	"message_id",
+	"messageId",
+	"operation_id",
+	"operationId",
+	"package",
+	"package_contract",
+	"package_draft_id",
+	"package_formal_evidence_hash",
+	"package_formal_evidence_id",
+	"package_hash",
+	"package_path",
+	"package_required",
+	"package_review",
+	"package_sha256",
+	"packageContract",
+	"packageDraftId",
+	"packageFormalEvidenceHash",
+	"packageFormalEvidenceId",
+	"packageHash",
+	"packagePath",
+	"packageRequired",
+	"packageReview",
+	"packageSha256",
+	"owner_session_id",
+	"ownerSessionId",
+	"platform_document_message_id",
+	"platform_message_id",
+	"platform_resource_identity",
+	"platform_side_effect_scope",
+	"platform_sync",
+	"snapshot_path",
+	"snapshotPath",
+	"platform_version",
+	"platformDocumentMessageId",
+	"platformMessageId",
+	"platformResourceIdentity",
+	"platformSideEffectScope",
+	"platformSync",
+	"platformVersion",
+	"policy_invocation_idempotency_key",
+	"policyInvocationIdempotencyKey",
+	"private_ref",
+	"private_refs",
+	"private_result",
+	"private_state",
+	"private_state_hash",
+	"privateRef",
+	"privateRefs",
+	"privateResult",
+	"privateState",
+	"privateStateHash",
+	"promote",
+	"pull_policy",
+	"pulled_at",
+	"pulled_turn_id",
+	"pullPolicy",
+	"pulledAt",
+	"pulledTurnId",
+	"raw_input",
+	"raw_json",
+	"raw_model_output",
+	"raw_output",
+	"raw_plan",
+	"raw_reasoning",
+	"raw_result",
+	"raw_skill_input",
+	"raw_skill_output",
+	"raw_tool_result",
+	"rawInput",
+	"rawJson",
+	"rawModelOutput",
+	"rawOutput",
+	"rawPlan",
+	"rawReasoning",
+	"rawResult",
+	"rawSkillInput",
+	"rawSkillOutput",
+	"rawToolResult",
+	"receipt_identity",
+	"receiptIdentity",
+	"request_id",
+	"request_identity",
+	"request_identity_hash",
+	"review_task_id",
+	"requestId",
+	"requestIdentity",
+	"requestIdentityHash",
+	"reviewTaskId",
+	"resolved_ref",
+	"resolvedRef",
+	"resource_key",
+	"resource_ref",
+	"resource_refs",
+	"resourceKey",
+	"resourceRef",
+	"resourceRefs",
+	"rp_id",
+	"rpId",
+	"runtime_identity",
+	"runtimeIdentity",
+	"save_to_platform",
+	"saveToPlatform",
+	"server_response_id",
+	"serverResponseId",
+	"side_effect_scope",
+	"sideEffectScope",
+	"skillOutput",
+	"source_dependency_fingerprint",
+	"source_hash",
+	"sourceDependencyFingerprint",
+	"sourceHash",
+	"stack",
+	"stderr",
+	"stdout",
+	"store_key",
+	"storeKey",
+	"sync_to_platform",
+	"syncToPlatform",
+	"target_id",
+	"target_plan_id",
+	"task_id",
+	"targetId",
+	"targetPlanId",
+	"taskId",
+	"validation_main",
+	"validationMain",
+	"validator_main",
+	"validator_main_doc",
+	"validatorMain",
+	"validatorMainDoc",
+	"tool_args",
+	"toolArgs",
+	"update_time",
+	"updateTime",
+	"user_id",
+	"userId",
+	"userid",
+	"workflow_run_id",
+	"workflowRunId",
+	"workspace_abs_path",
+	"workspace_path",
+	"workspace_resolution",
+	"workspaceAbsPath",
+	"workspacePath",
+	"workspaceResolution"
+]);
+function normalizePublicPayloadKey(key) {
+	return key.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+}
+function isPrivatePublicPayloadKey(key, denylist) {
+	if (denylist.has(key)) return true;
+	const normalized = normalizePublicPayloadKey(key);
+	for (const denied of denylist) if (normalizePublicPayloadKey(denied) === normalized) return true;
+	return false;
+}
+function sanitizePublicPayload(value) {
+	if (!value) return void 0;
+	const sanitized = isBuildPublicPayload(value) ? sanitizeBuildPublicPayload(value) : isSkillRuntimePublicPayload(value) ? sanitizeSkillRuntimePublicPayload(value) : sanitizePublicPayloadRecord(value, 0);
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+const BUILD_PUBLIC_PAYLOAD_TYPES = new Set([
+	"build_model_blueprint_confirmation",
+	"build_module_required",
+	"build_output_target_required",
+	"build_source_dependency_required"
+]);
+const BUILD_PUBLIC_PAYLOAD_KEYS = new Set([
+	"allow_create",
+	"blueprint_summary",
+	"candidate_modules",
+	"candidate_summary",
+	"decision_mode",
+	"diagnostics",
+	"display_mode",
+	"expected_patch_slots",
+	"goal_id",
+	"missing_slots",
+	"next_action",
+	"proposed_module_name",
+	"reason",
+	"type"
+]);
+const SKILL_PUBLIC_PAYLOAD_TYPES = new Set(["skill_dependency_required"]);
+function isBuildPublicPayload(value) {
+	return typeof value.type === "string" && BUILD_PUBLIC_PAYLOAD_TYPES.has(value.type);
+}
+function sanitizeBuildPublicPayload(record) {
+	const out = {};
+	for (const [key, value] of Object.entries(record)) {
+		if (!BUILD_PUBLIC_PAYLOAD_KEYS.has(key)) continue;
+		const sanitized = key === "candidate_summary" ? sanitizeBuildCandidateSummary(value) : sanitizePublicPayloadValue(value, 0);
+		if (sanitized !== void 0) out[key] = sanitized;
+	}
+	return out;
+}
+function sanitizeBuildCandidateSummary(value) {
+	if (!Array.isArray(value)) return sanitizePublicPayloadValue(value, 0);
+	const sanitized = value.map((item) => sanitizeBuildSourceDependencyCandidateSummary(item)).filter((item) => item !== void 0);
+	return sanitized.length === 0 ? void 0 : sanitized;
+}
+function sanitizeBuildSourceDependencyCandidateSummary(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const record = value;
+	if (typeof record.resource_type !== "string" || record.resource_type.trim() === "") return void 0;
+	const sanitized = sanitizePublicPayloadRecord({
+		dependency_id: record.dependency_id,
+		description: record.description,
+		label: record.label,
+		match_evidence: sanitizeBuildMatchEvidenceDisplay(record.match_evidence),
+		option_id: record.option_id,
+		resource_identity: sanitizeBuildResourceIdentityDisplay(record.resource_identity),
+		resource_type: record.resource_type,
+		status: record.status
+	}, 0);
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+function sanitizeBuildResourceIdentityDisplay(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const record = value;
+	const sanitized = stringRecordWithoutUndefinedFields({
+		code: stringFromUnknown(record.code),
+		form_key: stringFromUnknown(record.form_key) ?? stringFromUnknown(record.formKey),
+		list_key: stringFromUnknown(record.list_key) ?? stringFromUnknown(record.listKey),
+		node_key: stringFromUnknown(record.node_key) ?? stringFromUnknown(record.nodeKey),
+		resource_key: stringFromUnknown(record.resource_key) ?? stringFromUnknown(record.resourceKey),
+		rp_id: stringFromUnknown(record.rp_id) ?? stringFromUnknown(record.rpId)
+	});
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+function sanitizeBuildMatchEvidenceDisplay(value) {
+	const sanitized = arrayFromUnknown(value).map((item) => {
+		const record = recordFromUnknown(item);
+		if (!record) return void 0;
+		const evidence = stringRecordWithoutUndefinedFields({
+			field: stringFromUnknown(record.field),
+			reason: stringFromUnknown(record.reason),
+			score: stringFromUnknown(record.score),
+			source: stringFromUnknown(record.source),
+			value: stringFromUnknown(record.value)
+		});
+		return Object.keys(evidence).length === 0 ? void 0 : evidence;
+	}).filter((item) => item !== void 0);
+	return sanitized.length === 0 ? void 0 : sanitized;
+}
+function sanitizePublicPayloadRecord(record, depth) {
+	if (depth > 8) return {};
+	const out = {};
+	for (const [key, value] of Object.entries(record).slice(0, 64)) {
+		if (isPrivatePublicPayloadKey(key, PRIVATE_PUBLIC_PAYLOAD_KEYS)) continue;
+		const sanitized = key === "skill_runtime" || key === "skillRuntime" ? sanitizeSkillRuntimePublicPayloadOrUndefined(value) : sanitizePublicPayloadValue(value, depth + 1);
+		if (sanitized !== void 0) out[key] = sanitized;
+	}
+	return out;
+}
+function sanitizePublicPayloadValue(value, depth = 0) {
+	if (value === void 0) return void 0;
+	if (depth > 8) return void 0;
+	if (typeof value === "string") return value.length > 2e4 ? `${value.slice(0, FDE_PUBLIC_PAYLOAD_MAX_STRING_LENGTH)}...[truncated]` : value;
+	if (Array.isArray(value)) return value.slice(0, 100).map((item) => sanitizePublicPayloadValue(item, depth + 1)).filter((item) => item !== void 0);
+	if (value && typeof value === "object") {
+		const record = value;
+		const sanitized = isSkillRuntimePublicPayload(record) ? sanitizeSkillRuntimePublicPayload(record) : sanitizePublicPayloadRecord(record, depth + 1);
+		return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+	}
+	return value;
+}
+function isSkillRuntimePublicPayload(value) {
+	return isSkillDependencyPublicPayload(value) || isSkillPublicSummaryPayload(value);
+}
+function isSkillDependencyPublicPayload(value) {
+	return typeof value.type === "string" && SKILL_PUBLIC_PAYLOAD_TYPES.has(value.type);
+}
+function isSkillPublicSummaryPayload(value) {
+	if (stringFromUnknown(value.skill_id ?? value.skillId) === void 0) return false;
+	return stringFromUnknown(value.runtime_kind ?? value.runtimeKind) !== void 0 || stringFromUnknown(value.result_kind ?? value.resultKind) !== void 0 || value.artifact_count !== void 0 || value.artifactCount !== void 0 || value.artifact_refs !== void 0 || value.artifactRefs !== void 0 || value.diagnostic_count !== void 0 || value.diagnosticCount !== void 0 || value.fact_count !== void 0 || value.factCount !== void 0 || value.fact_refs !== void 0 || value.factRefs !== void 0 || value.missing_dependencies !== void 0 || value.missingDependencies !== void 0;
+}
+function sanitizeSkillRuntimePublicPayload(record) {
+	return withoutUndefinedFields$1({
+		artifact_count: numberFromUnknown(record.artifact_count),
+		artifact_refs: sanitizeSkillArtifactRefs(record.artifact_refs),
+		artifactCount: numberFromUnknown(record.artifactCount),
+		artifactRefs: sanitizeSkillArtifactRefs(record.artifactRefs),
+		candidate_count: numberFromUnknown(record.candidate_count),
+		candidateCount: numberFromUnknown(record.candidateCount),
+		candidates: sanitizeSkillDependencyCandidates(record.candidates),
+		diagnostic_count: numberFromUnknown(record.diagnostic_count),
+		diagnosticCount: numberFromUnknown(record.diagnosticCount),
+		fact_count: numberFromUnknown(record.fact_count),
+		fact_refs: sanitizeSkillFactRefs(record.fact_refs),
+		factCount: numberFromUnknown(record.factCount),
+		factRefs: sanitizeSkillFactRefs(record.factRefs),
+		kind: stringFromUnknown(record.kind),
+		message: stringFromUnknown(record.message),
+		missing_dependencies: sanitizeSkillMissingDependencies(record.missing_dependencies),
+		missingDependencies: sanitizeSkillMissingDependencies(record.missingDependencies),
+		public_ref: stringFromUnknown(record.public_ref),
+		publicRef: stringFromUnknown(record.publicRef),
+		required: booleanFromUnknown(record.required),
+		result_kind: stringFromUnknown(record.result_kind),
+		resultKind: stringFromUnknown(record.resultKind),
+		runtime_kind: stringFromUnknown(record.runtime_kind),
+		runtimeKind: stringFromUnknown(record.runtimeKind),
+		skill_id: stringFromUnknown(record.skill_id),
+		skill_runtime: sanitizeSkillRuntimePublicPayloadOrUndefined(record.skill_runtime),
+		skillId: stringFromUnknown(record.skillId),
+		skillRuntime: sanitizeSkillRuntimePublicPayloadOrUndefined(record.skillRuntime),
+		slot: stringFromUnknown(record.slot),
+		status: stringFromUnknown(record.status),
+		summary: stringFromUnknown(record.summary),
+		type: stringFromUnknown(record.type)
+	});
+}
+function sanitizeSkillRuntimePublicPayloadOrUndefined(value) {
+	const record = recordFromUnknown(value);
+	if (!record) return void 0;
+	const sanitized = sanitizeSkillRuntimePublicPayload(record);
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+function sanitizeSkillArtifactRefs(value) {
+	const sanitized = arrayFromUnknown(value).map((item) => sanitizeSkillArtifactRef(recordFromUnknown(item))).filter((item) => Boolean(item));
+	return sanitized.length === 0 ? void 0 : sanitized;
+}
+function sanitizeSkillArtifactRef(record) {
+	if (!record) return void 0;
+	const sanitized = withoutUndefinedFields$1({
+		artifact_kind: stringFromUnknown(record.artifact_kind),
+		artifactKind: stringFromUnknown(record.artifactKind),
+		logical_key: stringFromUnknown(record.logical_key),
+		logicalKey: stringFromUnknown(record.logicalKey),
+		title: stringFromUnknown(record.title)
+	});
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+function sanitizeSkillFactRefs(value) {
+	const sanitized = arrayFromUnknown(value).map((item) => sanitizeSkillFactRef(recordFromUnknown(item))).filter((item) => Boolean(item));
+	return sanitized.length === 0 ? void 0 : sanitized;
+}
+function sanitizeSkillFactRef(record) {
+	if (!record) return void 0;
+	const sanitized = withoutUndefinedFields$1({
+		fact_id: stringFromUnknown(record.fact_id),
+		factId: stringFromUnknown(record.factId),
+		title: stringFromUnknown(record.title)
+	});
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+function sanitizeSkillMissingDependencies(value) {
+	const sanitized = arrayFromUnknown(value).map((item) => sanitizeSkillMissingDependency(recordFromUnknown(item))).filter((item) => Boolean(item));
+	return sanitized.length === 0 ? void 0 : sanitized;
+}
+function sanitizeSkillMissingDependency(record) {
+	if (!record) return void 0;
+	const sanitized = withoutUndefinedFields$1({
+		candidate_count: numberFromUnknown(record.candidate_count),
+		candidateCount: numberFromUnknown(record.candidateCount),
+		kind: stringFromUnknown(record.kind),
+		required: booleanFromUnknown(record.required),
+		slot: stringFromUnknown(record.slot)
+	});
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+function sanitizeSkillDependencyCandidates(value) {
+	const sanitized = arrayFromUnknown(value).map((item) => sanitizeSkillDependencyCandidate(recordFromUnknown(item))).filter((item) => Boolean(item));
+	return sanitized.length === 0 ? void 0 : sanitized;
+}
+function sanitizeSkillDependencyCandidate(record) {
+	if (!record) return void 0;
+	const sanitized = withoutUndefinedFields$1({
+		description: stringFromUnknown(record.description),
+		label: stringFromUnknown(record.label),
+		option_id: stringFromUnknown(record.option_id),
+		optionId: stringFromUnknown(record.optionId),
+		public_ref: stringFromUnknown(record.public_ref),
+		publicRef: stringFromUnknown(record.publicRef)
+	});
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+function recordFromUnknown(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function arrayFromUnknown(value) {
+	return Array.isArray(value) ? value : [];
+}
+function stringFromUnknown(value) {
+	if (typeof value === "string") return value.trim() || void 0;
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+}
+function numberFromUnknown(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function booleanFromUnknown(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function requiredUserInputKind(value) {
+	if (value === "choice" || value === "form" || value === "text") return value;
+	throw new Error("kind is invalid.");
+}
+function requiredApprovalDecision(value, fieldName) {
+	if (value === "approve" || value === "reject" || value === "cancel") return value;
+	throw new Error(`${fieldName} is invalid.`);
+}
+function normalizeApprovalDecisionOptions(value, fieldName) {
+	if (!Array.isArray(value) || value.length === 0) throw new TypeError(`${fieldName} must be a non-empty array.`);
+	const seen = /* @__PURE__ */ new Set();
+	return value.map((item, index) => {
+		const option = asRecord$1(item, `${fieldName}[${index}]`);
+		const decision = requiredApprovalDecision(option.decision, `${fieldName}[${index}].decision`);
+		if (seen.has(decision)) throw new TypeError(`duplicate approval decision: ${decision}.`);
+		seen.add(decision);
+		const style = option.style;
+		if (style !== void 0 && style !== "primary" && style !== "secondary" && style !== "danger") throw new TypeError(`${fieldName}[${index}].style is invalid.`);
+		return {
+			decision,
+			label: requiredString$1(option.label, `${fieldName}[${index}].label`),
+			...style === void 0 ? {} : { style }
+		};
+	});
+}
+function normalizeRequestFields(value, fieldName) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new TypeError(`${fieldName} must be an array.`);
+	return value.map((field, index) => normalizeRequestField(field, `${fieldName}[${index}]`));
+}
+function normalizeUserInputAnswers(value) {
+	if (value === void 0) return void 0;
+	const answers = asRecord$1(value, "answers");
+	const normalized = {};
+	for (const [fieldId, answerValue] of Object.entries(answers)) {
+		if (!fieldId) throw new TypeError("answer field id must be a non-empty string.");
+		if (!answerValue || typeof answerValue !== "object" || Array.isArray(answerValue)) throw new TypeError("answer value must be an object.");
+		const answer = asRecord$1(answerValue, `answers.${fieldId}`);
+		const type = answer.type;
+		if (type !== "attachment_ids" && type !== "option_ids" && type !== "text") throw new TypeError("answer type must be attachment_ids, option_ids or text.");
+		if (!Array.isArray(answer.answers)) throw new TypeError("answers must be an array.");
+		normalized[fieldId] = {
+			answers: answer.answers.map((item, index) => requiredString$1(item, `answers.${fieldId}.answers[${index}]`)),
+			type
+		};
+	}
+	return normalized;
+}
+function normalizeRequestField(value, fieldName) {
+	const field = asRecord$1(value, fieldName);
+	const type = requiredString$1(field.type, `${fieldName}.type`);
+	const base = {
+		id: requiredString$1(field.id, `${fieldName}.id`),
+		label: requiredString$1(field.label, `${fieldName}.label`),
+		required: optionalBoolean(field.required, `${fieldName}.required`)
+	};
+	if (type === "text" || type === "textarea") return {
+		...base,
+		type
+	};
+	if (type === "single_select" || type === "multi_select") return {
+		...base,
+		options: requiredRequestOptions(field.options, `${fieldName}.options`),
+		type
+	};
+	throw new Error(`${fieldName}.type is invalid.`);
+}
+function requiredRequestOptions(value, fieldName) {
+	if (!Array.isArray(value) || value.length === 0) throw new TypeError(`${fieldName} must be a non-empty array.`);
+	return value.map((option, index) => normalizeRequestOption(option, `${fieldName}[${index}]`));
+}
+function normalizeRequestOption(value, fieldName) {
+	const option = asRecord$1(value, fieldName);
+	return {
+		description: optionalString$1(option.description, `${fieldName}.description`),
+		id: requiredString$1(option.id, `${fieldName}.id`),
+		label: requiredString$1(option.label, `${fieldName}.label`)
+	};
+}
+function assertUserInputRequestSurface(kind, fields) {
+	assertUniqueFieldIds(fields);
+	assertUniqueSelectableOptionIds(fields);
+	if (kind === "choice") {
+		if (!fields || fields.length !== 1 || fields[0]?.type !== "single_select") throw new TypeError("choice requests must contain exactly one single_select field.");
+		return;
+	}
+	if (kind === "form") {
+		if (!fields || fields.length === 0) throw new TypeError("form requests must contain at least one field.");
+		return;
+	}
+	if (fields && fields.length > 1) throw new TypeError("text requests may contain at most one text field.");
+	const [field] = fields ?? [];
+	if (field && field.type !== "text" && field.type !== "textarea") throw new TypeError("text requests may not contain select fields.");
+}
+function assertUniqueFieldIds(fields) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const field of fields ?? []) {
+		if (seen.has(field.id)) throw new TypeError(`duplicate request field id: ${field.id}.`);
+		seen.add(field.id);
+	}
+}
+function assertUniqueSelectableOptionIds(fields) {
+	for (const field of fields ?? []) {
+		if (field.type !== "single_select" && field.type !== "multi_select") continue;
+		const seen = /* @__PURE__ */ new Set();
+		for (const option of field.options) {
+			if (seen.has(option.id)) throw new TypeError(`duplicate request option id for field ${field.id}: ${option.id}.`);
+			seen.add(option.id);
+		}
+	}
+}
+function asRecord$1(value, field) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${field} must be an object.`);
+	return value;
+}
+function rejectFrameFields(frame, kind, fields) {
+	for (const field of fields) if (field in frame) throw new Error(`${kind}.${field} is not supported.`);
+}
+function assertExactKeys(record, fieldName, allowedKeys) {
+	const allowed = new Set(allowedKeys);
+	for (const key of Object.keys(record)) if (!allowed.has(key)) throw new Error(`${fieldName}.${key} is not supported.`);
+	for (const key of allowedKeys) {
+		if (key === "explanation" || key === "movePath") continue;
+		if (!(key in record)) throw new Error(`${fieldName}.${key} is required.`);
+	}
+}
+function assertAllowedKeys(record, fieldName, allowedKeys) {
+	const allowed = new Set(allowedKeys);
+	for (const key of Object.keys(record)) if (!allowed.has(key)) throw new Error(`${fieldName}.${key} is not supported.`);
+}
+function isFdeEventAppendedNotificationMethod(method) {
+	return FDE_EVENT_APPENDED_NOTIFICATION_METHODS.includes(method);
+}
+function isFdeDeltaNotificationMethod(method) {
+	return FDE_DELTA_NOTIFICATION_METHODS.includes(method);
+}
+function isFdeProjectionBackedLiveNotificationMethod(method) {
+	return FDE_PROJECTION_BACKED_LIVE_NOTIFICATION_METHODS.includes(method);
+}
+function normalizeFdeCoreTurnStartedNotification(notification) {
+	const params = asRecord$1(notification.params, "notification.params");
+	return {
+		method: "fde-core/turn.started",
+		params: withoutUndefinedFields$1({
+			...sanitizePublicPayload(omitKeys(params, [
+				"baseTurnId",
+				"offset",
+				"responseToRequest",
+				"startedAt",
+				"startedAtMs",
+				"threadId",
+				"turnId"
+			])) ?? {},
+			baseTurnId: optionalString$1(params.baseTurnId, "notification.params.baseTurnId"),
+			offset: optionalNumber$1(params.offset, "notification.params.offset"),
+			responseToRequest: normalizeFdeCoreResponseToRequestWireFromRecord(params, "notification.params"),
+			startedAt: optionalString$1(params.startedAt, "notification.params.startedAt"),
+			startedAtMs: optionalNumber$1(params.startedAtMs, "notification.params.startedAtMs"),
+			threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+			turnId: requiredString$1(params.turnId, "notification.params.turnId")
+		})
+	};
+}
+function normalizeFdeCoreTurnTerminalNotification(notification, method) {
+	const params = asRecord$1(notification.params, "notification.params");
+	return {
+		method,
+		params: withoutUndefinedFields$1({
+			...sanitizePublicPayload(omitKeys(params, [
+				"clientRequestId",
+				"completedAt",
+				"completedAtMs",
+				"offset",
+				"responseToRequest",
+				"threadId",
+				"turnId"
+			])) ?? {},
+			clientRequestId: optionalString$1(params.clientRequestId, "notification.params.clientRequestId"),
+			completedAt: optionalString$1(params.completedAt, "notification.params.completedAt"),
+			completedAtMs: optionalNumber$1(params.completedAtMs, "notification.params.completedAtMs"),
+			offset: optionalNumber$1(params.offset, "notification.params.offset"),
+			responseToRequest: normalizeFdeCoreResponseToRequestWireFromRecord(params, "notification.params"),
+			threadId: requiredString$1(params.threadId, "notification.params.threadId"),
+			turnId: requiredString$1(params.turnId, "notification.params.turnId")
+		})
+	};
+}
+function withoutUndefinedFields$1(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, fieldValue]) => fieldValue !== void 0));
+}
+function stringRecordWithoutUndefinedFields(value) {
+	return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== void 0));
+}
+function omitKeys(value, keys) {
+	const omitted = new Set(keys);
+	return Object.fromEntries(Object.entries(value).filter(([key]) => !omitted.has(key)));
+}
+function requiredString$1(value, field) {
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${field} must be a non-empty string.`);
+	return value;
+}
+function requiredPlainString(value, field) {
+	if (typeof value !== "string") throw new TypeError(`${field} must be a string.`);
+	return value;
+}
+function optionalString$1(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new TypeError(`${field} must be a string.`);
+	return value;
+}
+function optionalNonEmptyString(value, field) {
+	const result = optionalString$1(value, field);
+	if (result !== void 0 && result.trim().length === 0) throw new Error(`${field} must be a non-empty string.`);
+	return result;
+}
+function optionalNumber$1(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${field} must be a finite number.`);
+	return value;
+}
+function optionalNonNegativeSafeInteger(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new TypeError(`${field} must be a non-negative safe integer.`);
+	return value;
+}
+function optionalPositiveSafeInteger(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${field} must be a positive safe integer.`);
+	return value;
+}
+function requiredPositiveSafeInteger(value, field) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${field} must be a positive safe integer.`);
+	return value;
+}
+function requiredNonNegativeSafeInteger(value, field) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new TypeError(`${field} must be a non-negative safe integer.`);
+	return value;
+}
+function optionalNullableNumber(value, field) {
+	if (value === void 0) return void 0;
+	if (value === null) return null;
+	return requiredNumber$1(value, field);
+}
+function optionalBoolean(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "boolean") throw new TypeError(`${field} must be a boolean.`);
+	return value;
+}
+function requiredBoolean(value, field) {
+	if (typeof value !== "boolean") throw new TypeError(`${field} must be a boolean.`);
+	return value;
+}
+function requiredNumber$1(value, field) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${field} must be a finite number.`);
+	return value;
+}
+function requiredStringArray$1(value, field) {
+	if (!Array.isArray(value)) throw new TypeError(`${field} must be an array.`);
+	return value.map((item, index) => requiredString$1(item, `${field}[${index}]`));
+}
+function optionalRuntimeUri(value, field) {
+	const uri = optionalString$1(value, field);
+	if (uri === void 0) return void 0;
+	if (uri.startsWith("/") || uri.startsWith("file://") || uri.startsWith("http://") || uri.startsWith("https://")) throw new Error(`${field} must be a public protocol uri.`);
+	return uri;
+}
+function requiredAgentMessagePhase(value, field) {
+	if (typeof value === "string" && FDE_AGENT_MESSAGE_PHASES.includes(value)) return value;
+	throw new Error(`${field} is invalid.`);
+}
+function requiredExecutionStatus(value, field) {
+	if (typeof value === "string" && FDE_EXECUTION_STATUSES.includes(value)) return value;
+	throw new Error(`${field} is invalid.`);
+}
+function optionalToolKind(value, field) {
+	if (value === void 0) return void 0;
+	if (value === "mcp" || value === "dynamic" || value === "skill" || value === "unknown") return value;
+	throw new Error(`${field} is invalid.`);
+}
+function requiredRequestDisplayState(value, field) {
+	if (value === "pending" || value === "answered" || value === "cancelled") return value;
+	throw new Error(`${field} is invalid.`);
+}
+function optionalRequestDisplayState(value, field) {
+	if (value === void 0) return void 0;
+	return requiredRequestDisplayState(value, field);
+}
+function optionalDiagnosticSeverity(value, field) {
+	if (value === void 0) return void 0;
+	if (value === "debug" || value === "error" || value === "info" || value === "warning") return value;
+	throw new Error(`${field} is invalid.`);
+}
+function requiredPlanStepStatus(value, field) {
+	if (value === "pending" || value === "inProgress" || value === "completed") return value;
+	throw new Error(`${field} is invalid.`);
+}
+function requiredTypedTurnItemsView(value, field) {
+	if (typeof value === "string" && FDE_TURN_ITEMS_VIEWS.includes(value)) return value;
+	throw new Error(`${field} is invalid.`);
+}
+function requiredInputArray(value, field) {
+	if (!Array.isArray(value)) throw new TypeError(`${field} must be an array.`);
+	return value.map((item, index) => normalizeWireUserInput(item, `${field}[${index}]`));
+}
+function normalizeWireUserInput(value, field) {
+	const item = asRecord$1(value, field);
+	const type = requiredString$1(item.type, `${field}.type`);
+	switch (type) {
+		case "text": return {
+			text: requiredString$1(item.text, `${field}.text`),
+			type
+		};
+		case "attachment":
+		case "screenshot": return withoutUndefinedFields$1({
+			attachment_id: requiredString$1(item.attachment_id, `${field}.attachment_id`),
+			mime_type: optionalString$1(item.mime_type, `${field}.mime_type`),
+			name: optionalString$1(item.name, `${field}.name`),
+			parse_status: optionalAttachmentParseStatus(item.parse_status, `${field}.parse_status`),
+			parsed_content_item_id: optionalString$1(item.parsed_content_item_id, `${field}.parsed_content_item_id`),
+			parsed_text_ref: optionalString$1(item.parsed_text_ref, `${field}.parsed_text_ref`),
+			size_bytes: requiredNumber$1(item.size_bytes, `${field}.size_bytes`),
+			type
+		});
+		case "resource_ref": return withoutUndefinedFields$1({
+			data: optionalResourceRefData(item.data, `${field}.data`),
+			resource_id: requiredString$1(item.resource_id, `${field}.resource_id`),
+			resource_type: optionalString$1(item.resource_type, `${field}.resource_type`),
+			title: optionalString$1(item.title, `${field}.title`),
+			type
+		});
+		default: throw new Error(`${field}.type is invalid.`);
+	}
+}
+function optionalAttachmentParseStatus(value, field) {
+	if (value === void 0) return void 0;
+	if (value === "failed" || value === "not_parsed" || value === "parsed") return value;
+	throw new Error(`${field} is invalid.`);
+}
+function optionalResourceRefData(value, field) {
+	if (value === void 0) return void 0;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${field} must be an object.`);
+	return sanitizePublicPayload(value);
+}
+function readThreadId(params) {
+	if (!params || typeof params !== "object" || typeof params.threadId !== "string") throw new Error("threadId is required for serialized fde-core requests.");
+	return params.threadId;
+}
+//#endregion
+//#region src/memory/wire.ts
+const FDE_MEMORY_ADMIN_RECORD_CATEGORIES = [
+	"business_term",
+	"design_decision",
+	"constraint",
+	"open_question",
+	"workflow_pattern"
+];
+const MEMORY_SCOPES = new Set([
+	"platform",
+	"tenant",
+	"app",
+	"resource",
+	"user",
+	"conversation"
+]);
+const MEMORY_CATEGORIES = new Set([
+	"profile",
+	"preference",
+	"business_term",
+	"design_decision",
+	"constraint",
+	"open_question",
+	"workflow_pattern"
+]);
+const MEMORY_SENSITIVITIES = new Set([
+	"public",
+	"internal",
+	"sensitive"
+]);
+const MEMORY_TRUST_LEVELS = new Set([
+	"admin_confirmed",
+	"owner_confirmed",
+	"user_confirmed",
+	"imported"
+]);
+const RECORD_STATUSES = new Set([
+	"active",
+	"archived",
+	"deleted"
+]);
+const RECORD_VISIBILITIES = new Set([
+	"model_readable",
+	"ui_only",
+	"disabled"
+]);
+const CANDIDATE_STATUSES = new Set([
+	"pending_review",
+	"accepted",
+	"edited_accepted",
+	"ignored",
+	"rejected_scope",
+	"expired"
+]);
+const REVIEW_POLICIES = new Set([
+	"auto_low_risk",
+	"manual_user",
+	"manual_owner",
+	"manual_admin",
+	"scope_denied"
+]);
+const RISK_LEVELS = new Set([
+	"low",
+	"medium",
+	"high"
+]);
+const ADMIN_RECORD_CATEGORIES = new Set(FDE_MEMORY_ADMIN_RECORD_CATEGORIES);
+const LEGACY_SCOPE_FIELD = ["scope", "key"].join("_");
+const LEGACY_PROPOSED_SCOPE_FIELD = [
+	"proposed",
+	"scope",
+	"key"
+].join("_");
+const CLIENT_TRUSTED_SAVE_INTENT_FIELDS = [
+	"actor_user_id",
+	"tenant_id",
+	LEGACY_PROPOSED_SCOPE_FIELD,
+	"capture_trigger",
+	"capture_reason",
+	"source_ref",
+	"idempotency_key"
+];
+const CLIENT_TRUSTED_ADMIN_CREATE_FIELDS = [
+	"scope",
+	"scope_ref",
+	"scope_context",
+	LEGACY_SCOPE_FIELD,
+	"tenant_id",
+	"actor_user_id",
+	"trust_level",
+	"origin",
+	"activation",
+	"capture_trigger",
+	"source_ref",
+	"conflict_key",
+	"memory_id",
+	"record_id",
+	"status",
+	"visibility",
+	"confidence",
+	"usage_count",
+	"version",
+	"created_at",
+	"updated_at",
+	"last_used_at"
+];
+function normalizeFdeMemorySaveIntentRequest(input) {
+	const value = asRecord(input, "save_intent");
+	rejectFields(value, "save_intent", CLIENT_TRUSTED_SAVE_INTENT_FIELDS);
+	rejectUnknownFields(value, "save_intent", [
+		"proposed_scope",
+		"scope_ref",
+		"scope_context",
+		"category",
+		"title",
+		"summary",
+		"tags",
+		"sensitivity",
+		"client_source"
+	]);
+	return withoutUndefinedFields({
+		proposed_scope: requiredEnum(value.proposed_scope, "proposed_scope", MEMORY_SCOPES),
+		scope_ref: normalizeScopeRef(value.scope_ref, "scope_ref"),
+		scope_context: normalizeScopeContext(value.scope_context, "scope_context"),
+		category: requiredEnum(value.category, "category", MEMORY_CATEGORIES),
+		title: requiredString(value.title, "title"),
+		summary: requiredString(value.summary, "summary"),
+		tags: value.tags === void 0 ? void 0 : requiredStringArray(value.tags, "tags"),
+		sensitivity: value.sensitivity === void 0 ? void 0 : requiredEnum(value.sensitivity, "sensitivity", MEMORY_SENSITIVITIES),
+		client_source: value.client_source === void 0 ? void 0 : normalizeClientSource(value.client_source)
+	});
+}
+function normalizeFdeMemoryCandidateDecisionRequest(input) {
+	const value = asRecord(input, "decision");
+	const action = requiredString(value.action, "action");
+	const base = {
+		expected_status: requiredEnum(value.expected_status, "expected_status", CANDIDATE_STATUSES),
+		expected_updated_at: requiredString(value.expected_updated_at, "expected_updated_at"),
+		reason: optionalString(value.reason, "reason")
+	};
+	if (action === "accept") {
+		assertStatus(base.expected_status, ["pending_review"], "expected_status");
+		return withoutUndefinedFields({
+			action,
+			...base
+		});
+	}
+	if (action === "edit_and_accept") {
+		assertStatus(base.expected_status, ["pending_review"], "expected_status");
+		return withoutUndefinedFields({
+			action,
+			...base,
+			patch: normalizeDecisionPatch(value.patch)
+		});
+	}
+	if (action === "ignore") {
+		assertStatus(base.expected_status, ["pending_review", "rejected_scope"], "expected_status");
+		return withoutUndefinedFields({
+			action,
+			...base
+		});
+	}
+	if (action === "change_scope") {
+		assertStatus(base.expected_status, ["pending_review", "rejected_scope"], "expected_status");
+		return withoutUndefinedFields({
+			action,
+			...base,
+			target_scope: requiredEnum(value.target_scope, "target_scope", MEMORY_SCOPES),
+			target_scope_ref: normalizeScopeRef(value.target_scope_ref, "target_scope_ref"),
+			target_scope_context: normalizeScopeContext(value.target_scope_context, "target_scope_context")
+		});
+	}
+	if (action === "select_fallback_scope") {
+		assertStatus(base.expected_status, ["rejected_scope"], "expected_status");
+		return withoutUndefinedFields({
+			action,
+			...base,
+			fallback_scope: requiredEnum(value.fallback_scope, "fallback_scope", MEMORY_SCOPES),
+			fallback_scope_ref: normalizeScopeRef(value.fallback_scope_ref, "fallback_scope_ref"),
+			fallback_scope_context: normalizeScopeContext(value.fallback_scope_context, "fallback_scope_context")
+		});
+	}
+	throw new Error("action is invalid.");
+}
+function normalizeFdeMemoryRecordPatchRequest(input) {
+	const value = asRecord(input, "record_patch");
+	rejectFields(value, "record_patch", [
+		"scope",
+		LEGACY_SCOPE_FIELD,
+		"proposed_scope",
+		LEGACY_PROPOSED_SCOPE_FIELD,
+		"status",
+		"visibility"
+	]);
+	rejectUnknownFields(value, "record_patch", [
+		"expected_version",
+		"title",
+		"summary",
+		"tags",
+		"sensitivity",
+		"valid_from",
+		"valid_until",
+		"conflict_key",
+		"reason"
+	]);
+	return withoutUndefinedFields({
+		expected_version: requiredNumber(value.expected_version, "expected_version"),
+		title: optionalString(value.title, "title"),
+		summary: optionalString(value.summary, "summary"),
+		tags: value.tags === void 0 ? void 0 : requiredStringArray(value.tags, "tags"),
+		sensitivity: value.sensitivity === void 0 ? void 0 : requiredEnum(value.sensitivity, "sensitivity", MEMORY_SENSITIVITIES),
+		valid_from: optionalString(value.valid_from, "valid_from"),
+		valid_until: optionalString(value.valid_until, "valid_until"),
+		conflict_key: optionalString(value.conflict_key, "conflict_key"),
+		reason: optionalString(value.reason, "reason")
+	});
+}
+function normalizeFdeMemoryRecordLifecycleRequest(input) {
+	const value = asRecord(input, "record_lifecycle");
+	rejectUnknownFields(value, "record_lifecycle", ["expected_version", "reason"]);
+	return withoutUndefinedFields({
+		expected_version: requiredNumber(value.expected_version, "expected_version"),
+		reason: optionalString(value.reason, "reason")
+	});
+}
+function normalizeFdeMemoryAdminRecordListQuery(input) {
+	const value = asRecord(input, "admin_record_query");
+	rejectUnknownFields(value, "admin_record_query", [
+		"category",
+		"status",
+		"visibility",
+		"q",
+		"cursor",
+		"limit"
+	]);
+	return withoutUndefinedFields({
+		category: optionalEnum(value.category, "category", ADMIN_RECORD_CATEGORIES),
+		status: optionalEnum(value.status, "status", RECORD_STATUSES),
+		visibility: optionalEnum(value.visibility, "visibility", RECORD_VISIBILITIES),
+		q: optionalString(value.q, "q"),
+		cursor: optionalString(value.cursor, "cursor"),
+		limit: optionalBoundedLimit(value.limit, "limit", 1, 100)
+	});
+}
+function normalizeFdeMemoryAdminCreateRecordRequest(input) {
+	const value = asRecord(input, "admin_create_record");
+	rejectFields(value, "admin_create_record", CLIENT_TRUSTED_ADMIN_CREATE_FIELDS);
+	rejectUnknownFields(value, "admin_create_record", [
+		"category",
+		"title",
+		"summary",
+		"tags",
+		"sensitivity",
+		"valid_from",
+		"valid_until",
+		"reason",
+		"client_request_id"
+	]);
+	return withoutUndefinedFields({
+		category: requiredEnum(value.category, "category", ADMIN_RECORD_CATEGORIES),
+		title: requiredString(value.title, "title"),
+		summary: requiredString(value.summary, "summary"),
+		tags: value.tags === void 0 ? void 0 : requiredStringArray(value.tags, "tags"),
+		sensitivity: value.sensitivity === void 0 ? void 0 : requiredEnum(value.sensitivity, "sensitivity", MEMORY_SENSITIVITIES),
+		valid_from: optionalString(value.valid_from, "valid_from"),
+		valid_until: optionalString(value.valid_until, "valid_until"),
+		reason: optionalString(value.reason, "reason"),
+		client_request_id: optionalString(value.client_request_id, "client_request_id")
+	});
+}
+function normalizeFdeMemoryAdminRecordLifecycleRequest(input) {
+	return normalizeFdeMemoryRecordLifecycleRequest(input);
+}
+function normalizeFdeMemoryRecordListQuery(input) {
+	const value = asRecord(input, "record_query");
+	rejectUnknownFields(value, "record_query", [
+		"scope",
+		"category",
+		"trust_level",
+		"status",
+		"visibility",
+		"source_conversation_id",
+		"q",
+		"cursor",
+		"limit"
+	]);
+	return withoutUndefinedFields({
+		scope: optionalEnum(value.scope, "scope", MEMORY_SCOPES),
+		category: optionalEnum(value.category, "category", MEMORY_CATEGORIES),
+		trust_level: optionalEnum(value.trust_level, "trust_level", MEMORY_TRUST_LEVELS),
+		status: optionalEnum(value.status, "status", RECORD_STATUSES),
+		visibility: optionalEnum(value.visibility, "visibility", RECORD_VISIBILITIES),
+		source_conversation_id: optionalString(value.source_conversation_id, "source_conversation_id"),
+		q: optionalString(value.q, "q"),
+		cursor: optionalString(value.cursor, "cursor"),
+		limit: optionalNumber(value.limit, "limit")
+	});
+}
+function normalizeFdeMemoryCandidateListQuery(input) {
+	const value = asRecord(input, "candidate_query");
+	rejectUnknownFields(value, "candidate_query", [
+		"scope",
+		"category",
+		"status",
+		"review_policy",
+		"risk_level",
+		"source_conversation_id",
+		"q",
+		"cursor",
+		"limit"
+	]);
+	return withoutUndefinedFields({
+		scope: optionalEnum(value.scope, "scope", MEMORY_SCOPES),
+		category: optionalEnum(value.category, "category", MEMORY_CATEGORIES),
+		status: optionalEnum(value.status, "status", CANDIDATE_STATUSES),
+		review_policy: optionalEnum(value.review_policy, "review_policy", REVIEW_POLICIES),
+		risk_level: optionalEnum(value.risk_level, "risk_level", RISK_LEVELS),
+		source_conversation_id: optionalString(value.source_conversation_id, "source_conversation_id"),
+		q: optionalString(value.q, "q"),
+		cursor: optionalString(value.cursor, "cursor"),
+		limit: optionalNumber(value.limit, "limit")
+	});
+}
+function normalizeFdeMemoryScopesQuery(input) {
+	const value = asRecord(input, "scopes_query");
+	rejectUnknownFields(value, "scopes_query", [
+		"app_id",
+		"conversation_id",
+		"resource_type",
+		"resource_id"
+	]);
+	return normalizeScopeContext(value, "scopes_query");
+}
+function normalizeScopeRef(value, fieldName) {
+	const ref = asRecord(value, fieldName);
+	const token = requiredString(ref.ref, `${fieldName}.ref`);
+	if (/^(platform|tenant|app|resource|user|conversation):/.test(token)) throw new Error(`${fieldName}.ref must be an opaque signed token.`);
+	const refType = requiredString(ref.ref_type, `${fieldName}.ref_type`);
+	if (refType !== "signed_scope_token") throw new Error(`${fieldName}.ref_type is invalid.`);
+	return {
+		scope: requiredEnum(ref.scope, `${fieldName}.scope`, MEMORY_SCOPES),
+		ref_type: refType,
+		ref: token
+	};
+}
+function normalizeScopeContext(value, fieldName) {
+	const context = asRecord(value, fieldName);
+	rejectUnknownFields(context, fieldName, [
+		"app_id",
+		"conversation_id",
+		"resource_type",
+		"resource_id"
+	]);
+	return withoutUndefinedFields({
+		app_id: optionalString(context.app_id, `${fieldName}.app_id`),
+		conversation_id: optionalString(context.conversation_id, `${fieldName}.conversation_id`),
+		resource_type: optionalString(context.resource_type, `${fieldName}.resource_type`),
+		resource_id: optionalString(context.resource_id, `${fieldName}.resource_id`)
+	});
+}
+function normalizeClientSource(value) {
+	const source = asRecord(value, "client_source");
+	rejectUnknownFields(source, "client_source", [
+		"conversation_id",
+		"turn_id",
+		"message_ids",
+		"artifact_id",
+		"fact_id",
+		"selected_text_hash"
+	]);
+	return withoutUndefinedFields({
+		conversation_id: optionalString(source.conversation_id, "client_source.conversation_id"),
+		turn_id: optionalString(source.turn_id, "client_source.turn_id"),
+		message_ids: source.message_ids === void 0 ? void 0 : requiredStringArray(source.message_ids, "client_source.message_ids"),
+		artifact_id: optionalString(source.artifact_id, "client_source.artifact_id"),
+		fact_id: optionalString(source.fact_id, "client_source.fact_id"),
+		selected_text_hash: optionalString(source.selected_text_hash, "client_source.selected_text_hash")
+	});
+}
+function normalizeDecisionPatch(value) {
+	const patch = asRecord(value, "patch");
+	rejectUnknownFields(patch, "patch", [
+		"title",
+		"summary",
+		"tags",
+		"category",
+		"conflict_key"
+	]);
+	return withoutUndefinedFields({
+		title: optionalString(patch.title, "patch.title"),
+		summary: optionalString(patch.summary, "patch.summary"),
+		tags: patch.tags === void 0 ? void 0 : requiredStringArray(patch.tags, "patch.tags"),
+		category: patch.category === void 0 ? void 0 : requiredEnum(patch.category, "patch.category", MEMORY_CATEGORIES),
+		conflict_key: optionalString(patch.conflict_key, "patch.conflict_key")
+	});
+}
+function asRecord(value, fieldName) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${fieldName} must be an object.`);
+	return value;
+}
+function requiredString(value, fieldName) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${fieldName} must be a non-empty string.`);
+	return value;
+}
+function optionalString(value, fieldName) {
+	if (value === void 0) return void 0;
+	return requiredString(value, fieldName);
+}
+function requiredNumber(value, fieldName) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${fieldName} must be a finite number.`);
+	return value;
+}
+function optionalNumber(value, fieldName) {
+	if (value === void 0) return void 0;
+	return requiredNumber(value, fieldName);
+}
+function optionalBoundedLimit(value, fieldName, min, max) {
+	const numberValue = optionalNumber(value, fieldName);
+	if (numberValue === void 0) return void 0;
+	return Math.max(min, Math.min(max, Math.trunc(numberValue)));
+}
+function requiredStringArray(value, fieldName) {
+	if (!Array.isArray(value)) throw new TypeError(`${fieldName} must be an array.`);
+	return value.map((item, index) => requiredString(item, `${fieldName}[${index}]`));
+}
+function requiredEnum(value, fieldName, allowed) {
+	if (typeof value !== "string" || value.includes(",") || !allowed.has(value)) throw new Error(`${fieldName} is invalid.`);
+	return value;
+}
+function optionalEnum(value, fieldName, allowed) {
+	if (value === void 0) return void 0;
+	return requiredEnum(value, fieldName, allowed);
+}
+function assertStatus(value, allowed, fieldName) {
+	if (!allowed.includes(value)) throw new Error(`${fieldName} is invalid for action.`);
+}
+function rejectFields(record, fieldName, fields) {
+	for (const field of fields) if (field in record) throw new Error(`${fieldName}.${field} is not supported.`);
+}
+function rejectUnknownFields(record, fieldName, allowed) {
+	const allowedSet = new Set(allowed);
+	for (const key of Object.keys(record)) if (!allowedSet.has(key)) throw new Error(`${fieldName}.${key} is not supported.`);
+}
+function withoutUndefinedFields(value) {
+	for (const key of Object.keys(value)) if (value[key] === void 0) delete value[key];
+	return value;
+}
+//#endregion
+//#region src/memory/index.ts
+const FDE_MEMORY_RECORD_CATEGORIES = [
+	"profile",
+	"preference",
+	"business_term",
+	"design_decision",
+	"constraint",
+	"open_question",
+	"workflow_pattern"
+];
+const FDE_MEMORY_SCOPES = [
+	"platform",
+	"tenant",
+	"app",
+	"resource",
+	"user",
+	"conversation"
+];
+const FDE_MEMORY_TRUST_LEVELS = [
+	"admin_confirmed",
+	"owner_confirmed",
+	"user_confirmed",
+	"imported"
+];
+//#endregion
+//#region src/canonical-fixtures.ts
+const threadId = "thread-canonical-1";
+const turnId = "turn-canonical-1";
+const requestId = "request-canonical-1";
+const requestRevision = 2;
+const stateRevision = 7;
+const eventOffset = 11;
+const now = "2026-06-21T00:00:00.000Z";
+const turnStartRequest = normalizeFdeCoreClientRequest({
+	id: "rpc-canonical-turn-start-1",
+	method: "turn/start",
+	params: {
+		capabilityId: "system_analysis",
+		clientRequestId: "client-request-canonical-1",
+		clientUserMessageId: "user-message-canonical-1",
+		input: [{
+			text: "请梳理订单履约流程，并标记需要确认的业务术语。",
+			type: "text"
+		}],
+		threadId
+	}
+});
+const serverRequest = createFdeCoreUserInputServerRequest({
+	actionId: "required-action-canonical-1",
+	domain: "system_analysis",
+	fields: [{
+		id: "term_scope",
+		label: "术语作用域",
+		options: [{
+			id: "tenant",
+			label: "租户级"
+		}, {
+			id: "app",
+			label: "应用级"
+		}],
+		required: true,
+		type: "single_select"
+	}, {
+		id: "term_note",
+		label: "补充说明",
+		required: false,
+		type: "textarea"
+	}],
+	itemId: "item-confirmation-canonical-1",
+	kind: "form",
+	prompt: "请选择“履约状态”的业务术语作用域。",
+	publicPayload: {
+		candidate_term: "履约状态",
+		source: "canonical_fixture"
+	},
+	requestId,
+	requestRevision,
+	requestType: "system_analysis.term_scope.confirm",
+	stateRevision,
+	threadId,
+	turnId
+});
+const serverResponse = normalizeFdeCoreServerResponse({
+	id: fdeCoreServerRequestIdentityKey(serverRequest.params),
+	method: "fde/serverRequest/userInput",
+	params: {
+		expectedRequestRevision: requestRevision,
+		expectedStateRevision: stateRevision,
+		requestId,
+		threadId,
+		turnId
+	},
+	response: {
+		answers: {
+			term_note: {
+				answers: ["履约状态只在当前应用内生效。"],
+				type: "text"
+			},
+			term_scope: {
+				answers: ["app"],
+				type: "option_ids"
+			}
+		},
+		decision: "answer"
+	}
+});
+const eventAppendedFrame = normalizeFdeCoreSubscriptionFrame({
+	kind: "event_appended",
+	notifications: [{
+		method: "item/started",
+		params: {
+			item: {
+				content: turnStartRequest.params.input,
+				createdAtMs: 1782e9,
+				id: "item-user-canonical-1",
+				sourceSeq: 1,
+				text: "请梳理订单履约流程，并标记需要确认的业务术语。",
+				type: "userMessage"
+			},
+			startedAtMs: 1782e9,
+			threadId,
+			turnId
+		}
+	}],
+	offset: eventOffset,
+	serverRequests: [serverRequest],
+	threadId
+});
+const projectionSnapshotFrame = normalizeFdeCoreSubscriptionFrame({
+	kind: "projection_snapshot",
+	offset: eventOffset,
+	projection: {
+		activeRequiredAction: { ...serverRequest.params },
+		artifactPanel: { items: [] },
+		metadata: { lastEventCursor: eventOffset },
+		threadId,
+		turns: [{
+			artifacts: [],
+			clientRequestId: turnStartRequest.params.clientRequestId,
+			facts: [],
+			items: [{
+				content: turnStartRequest.params.input,
+				createdAtMs: 1782e9,
+				id: "item-user-canonical-1",
+				sourceSeq: 1,
+				text: "请梳理订单履约流程，并标记需要确认的业务术语。",
+				type: "userMessage"
+			}, {
+				displaySnapshot: {
+					prompt: serverRequest.params.prompt,
+					publicPayload: serverRequest.params.publicPayload,
+					title: "业务术语确认"
+				},
+				id: "item-confirmation-canonical-1",
+				requestIdentity: {
+					ownerTurnId: turnId,
+					requestId,
+					requestRevision,
+					stateRevision,
+					threadId
+				},
+				requestType: serverRequest.params.requestType,
+				sourceSeq: 2,
+				state: "pending",
+				type: "clarification"
+			}],
+			itemsView: "full",
+			memoryContext: {
+				budget: {
+					estimated_tokens: 32,
+					max_tokens: 512
+				},
+				fallback_level: "memory_summary_recent",
+				selected_count: 1,
+				selected_refs: [{
+					category: "business_term",
+					memory_id: "memory-canonical-1",
+					rank: 1,
+					reason: "retrieved",
+					scope: "app",
+					summary: "履约状态用于表达订单从待发货到已完成的业务阶段。",
+					title: "履约状态术语",
+					token_estimate: 32,
+					trust_level: "owner_confirmed",
+					type: "memory_record"
+				}],
+				snapshot_detail_status: "available",
+				snapshot_id: "memory-snapshot-canonical-1",
+				summary_available: true,
+				suppressed_count: 0,
+				suppressed_reason_counts: {}
+			},
+			metadata: { lastEventCursor: eventOffset },
+			projectionHighWater: eventOffset,
+			startedAt: now,
+			status: "awaiting_input",
+			threadId,
+			turnId
+		}]
+	},
+	resumeHighWater: eventOffset,
+	threadId
+});
+const memorySaveIntent = normalizeFdeMemorySaveIntentRequest({
+	category: "business_term",
+	client_source: {
+		conversation_id: threadId,
+		turn_id: turnId
+	},
+	proposed_scope: "app",
+	scope_context: {
+		app_id: "app-canonical-1",
+		conversation_id: threadId,
+		resource_id: "order",
+		resource_type: "domain_model"
+	},
+	scope_ref: {
+		ref: "signed-scope-token-canonical-1",
+		ref_type: "signed_scope_token",
+		scope: "app"
+	},
+	sensitivity: "internal",
+	summary: "履约状态用于表达订单从待发货到已完成的业务阶段。",
+	tags: ["order", "fulfillment"],
+	title: "履约状态术语"
+});
+const AGENTIC_CANONICAL_PROTOCOL_FIXTURES = Object.freeze({
+	eventAppendedFrame,
+	memorySaveIntent,
+	projectionSnapshotFrame,
+	serverRequest,
+	serverResponse,
+	turnStartRequest
+});
+//#endregion
+export { AGENTIC_CANONICAL_PROTOCOL_FIXTURES, BUILD_FORMAL_SAVE_APPROVE_REQUEST_TYPE, BUILD_RETIRED_NON_SAVE_PUBLIC_PAYLOAD_TYPES, BUILD_RETIRED_NON_SAVE_REQUEST_TYPES, BUILD_RETIRED_NON_SAVE_SURFACE_KINDS, BUILD_RETIRED_NON_SAVE_SURFACE_KIND_TO_PUBLIC_PAYLOAD_TYPE, BUILD_RETIRED_SAVE_APPROVAL_REQUEST_TYPES, FDE_ADAPTER_LIVE_NOTIFICATION_METHODS, FDE_AGENT_MESSAGE_PHASES, FDE_DELTA_NOTIFICATION_METHODS, FDE_EVENT_APPENDED_NOTIFICATION_METHODS, FDE_EXECUTION_STATUSES, FDE_MEMORY_ADMIN_RECORD_CATEGORIES, FDE_MEMORY_RECORD_CATEGORIES, FDE_MEMORY_SCOPES, FDE_MEMORY_TRUST_LEVELS, FDE_PROJECTION_BACKED_LIVE_NOTIFICATION_METHODS, FDE_PROTOCOL_BUILD, FDE_PUBLIC_ITEM_LIFECYCLES, FDE_PUBLIC_PAYLOAD_MAX_ARRAY_ITEMS, FDE_PUBLIC_PAYLOAD_MAX_DEPTH, FDE_PUBLIC_PAYLOAD_MAX_OBJECT_KEYS, FDE_PUBLIC_PAYLOAD_MAX_STRING_LENGTH, FDE_SUBSCRIPTION_NOTIFICATION_METHODS, FDE_TURN_ITEMS_VIEWS, FDE_TURN_STATUSES, FDE_TYPED_TURN_V2_PROTOCOL_VERSION, SYSTEM_ANALYSIS_FORMAL_SAVE_APPROVE_REQUEST_TYPE, createFdeCoreApprovalServerRequest, createFdeCoreLiveNotification, createFdeCoreServerRequestResolvedNotification, createFdeCoreUserInputServerRequest, fdeCoreServerRequestIdentityFromResponseToRequest, fdeCoreServerRequestIdentityKey, getFdeCoreRequestSerialization, isFdeCoreServerRequestIdentityWire, isFdeCoreServerRequestResolvedNotification, normalizeFdeCoreClientRequest, normalizeFdeCoreLiveDeltaNotification, normalizeFdeCoreLiveNotification, normalizeFdeCoreResponseToRequestWire, normalizeFdeCoreResponseToRequestWireFromRecord, normalizeFdeCoreServerRequest, normalizeFdeCoreServerRequestIdentity, normalizeFdeCoreServerResponse, normalizeFdeCoreSubscriptionFrame, normalizeFdeCoreThreadResumeResult, normalizeFdeLiveNotification, normalizeFdeMemoryAdminCreateRecordRequest, normalizeFdeMemoryAdminRecordLifecycleRequest, normalizeFdeMemoryAdminRecordListQuery, normalizeFdeMemoryCandidateDecisionRequest, normalizeFdeMemoryCandidateListQuery, normalizeFdeMemoryRecordLifecycleRequest, normalizeFdeMemoryRecordListQuery, normalizeFdeMemoryRecordPatchRequest, normalizeFdeMemorySaveIntentRequest, normalizeFdeMemoryScopesQuery, toFdeCoreErrorResponse, toFdeCoreSuccessResponse, toFdeCoreThreadResumeSuccessResponse };