@uemcp/server 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import os from "node:os";
+import os, { tmpdir } from "node:os";
 import path from "node:path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -10,7 +10,9 @@ import Fastify from "fastify";
 import { Buffer as Buffer$1 } from "node:buffer";
 import pino from "pino";
 import { spawn } from "node:child_process";
-import { access, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { access, mkdir, mkdtemp, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { createInterface } from "node:readline";
 //#region src/errors.ts
 var McpServerError = class extends Error {
 	constructor(message, options) {
@@ -228,6 +230,75 @@ const BRIDGE_GET_CREATE_CLASS_STATUS_REQUEST_TYPE = "get_create_class_status";
 const BRIDGE_FIND_ASSETS_REQUEST_TYPE = "find_assets";
 const BRIDGE_GET_ASSET_DEPENDENCIES_REQUEST_TYPE = "get_asset_dependencies";
 const BRIDGE_FIND_BLUEPRINT_REFERENCES_REQUEST_TYPE = "find_blueprint_references";
+const BRIDGE_GET_BLUEPRINT_SUMMARY_REQUEST_TYPE = "get_blueprint_summary";
+const BRIDGE_GET_BLUEPRINT_GRAPH_REQUEST_TYPE = "get_blueprint_graph";
+const BRIDGE_GET_BLUEPRINT_COMPILE_ERRORS_REQUEST_TYPE = "get_blueprint_compile_errors";
+const BRIDGE_COMPILE_BLUEPRINT_REQUEST_TYPE = "compile_blueprint";
+const BRIDGE_GET_BLUEPRINT_COMPILE_STATUS_REQUEST_TYPE = "get_blueprint_compile_status";
+const BRIDGE_GET_CONFIG_VALUE_REQUEST_TYPE = "get_config_value";
+const BRIDGE_SET_CONFIG_VALUE_REQUEST_TYPE = "set_config_value";
+const BRIDGE_LIST_CONFIG_SECTION_REQUEST_TYPE = "list_config_section";
+const BRIDGE_CONFIG_FILES = [
+	"Engine",
+	"Game",
+	"Input",
+	"Editor",
+	"EditorPerProjectUserSettings"
+];
+const BRIDGE_CONFIG_WRITE_SCOPES = ["project_default", "saved_user"];
+const BRIDGE_CONFIG_RESOLVED_SCOPES = [
+	"engine_base",
+	"project_default",
+	"saved_user",
+	"unknown"
+];
+const BRIDGE_CONFIG_MAX_VALUE_CHARS = 4096;
+const BRIDGE_BLUEPRINT_KINDS = [
+	"normal",
+	"const",
+	"macro_library",
+	"interface",
+	"level_script",
+	"function_library",
+	"unknown"
+];
+const BRIDGE_BLUEPRINT_GRAPH_KINDS = [
+	"event",
+	"function",
+	"macro",
+	"interface",
+	"construction_script",
+	"delegate",
+	"unknown"
+];
+const BRIDGE_BLUEPRINT_MEMBER_KINDS = [
+	"function",
+	"event",
+	"macro",
+	"interface"
+];
+const BRIDGE_BLUEPRINT_PIN_DIRECTIONS = ["input", "output"];
+const BRIDGE_BLUEPRINT_REPLICATION_MODES = [
+	"none",
+	"replicated",
+	"rep_notify"
+];
+const BRIDGE_BLUEPRINT_STATUSES = [
+	"up_to_date",
+	"warnings",
+	"error",
+	"dirty",
+	"unknown",
+	"not_loaded",
+	"not_found"
+];
+const BRIDGE_COMPILE_BLUEPRINT_STATES = ["compiling", "unsupported"];
+const BRIDGE_BLUEPRINT_COMPILE_STATUS_STATES = [
+	"compiling",
+	"succeeded",
+	"failed",
+	"unknown_job"
+];
 const BRIDGE_CREATE_CLASS_STATES = ["creating", "unsupported"];
 const BRIDGE_CREATE_CLASS_STATUS_STATES = [
 	"creating",
@@ -391,6 +462,26 @@ const assetPathArraySchema = z.array(assetPathSchema).max(32);
 const assetDependencyCategorySchema = z.enum(BRIDGE_ASSET_DEPENDENCY_CATEGORIES);
 const assetDependencyLinkageSchema = z.enum(BRIDGE_ASSET_DEPENDENCY_LINKAGES);
 const blueprintReferenceKindSchema = z.enum(BRIDGE_BLUEPRINT_REFERENCE_KINDS);
+const blueprintKindSchema = z.enum(BRIDGE_BLUEPRINT_KINDS);
+const blueprintGraphKindSchema = z.enum(BRIDGE_BLUEPRINT_GRAPH_KINDS);
+const blueprintMemberKindSchema = z.enum(BRIDGE_BLUEPRINT_MEMBER_KINDS);
+const blueprintPinDirectionSchema = z.enum(BRIDGE_BLUEPRINT_PIN_DIRECTIONS);
+const blueprintReplicationSchema = z.enum(BRIDGE_BLUEPRINT_REPLICATION_MODES);
+const blueprintStatusSchema = z.enum(BRIDGE_BLUEPRINT_STATUSES);
+const compileBlueprintStateSchema = z.enum(BRIDGE_COMPILE_BLUEPRINT_STATES);
+const blueprintCompileStatusStateSchema = z.enum(BRIDGE_BLUEPRINT_COMPILE_STATUS_STATES);
+const blueprintCompileJobIdSchema = z.string().trim().min(1);
+const blueprintGraphNameSchema = z.string().trim().min(1).max(256);
+const blueprintMemberLimitSchema = z.number().int().min(1).max(200);
+const blueprintNodeLimitSchema = z.number().int().min(1).max(200);
+const blueprintPathArraySchema = z.array(assetPathSchema).min(1).max(32);
+const configFileSchema = z.enum(BRIDGE_CONFIG_FILES);
+const configWriteScopeSchema = z.enum(BRIDGE_CONFIG_WRITE_SCOPES);
+const configResolvedScopeSchema = z.enum(BRIDGE_CONFIG_RESOLVED_SCOPES);
+const configSectionSchema = z.string().trim().min(1).max(256);
+const configKeySchema = z.string().trim().min(1).max(256);
+const configValueSchema = z.string().max(BRIDGE_CONFIG_MAX_VALUE_CHARS);
+const configSectionMaxResultsSchema = z.number().int().min(1).max(200);
 const createClassStateSchema = z.enum(BRIDGE_CREATE_CLASS_STATES);
 const createClassStatusStateSchema = z.enum(BRIDGE_CREATE_CLASS_STATUS_STATES);
 const createClassJobIdSchema = z.string().trim().min(1);
@@ -694,6 +785,77 @@ const bridgeFindBlueprintReferencesRequestSchema = z.object({
 	type: z.literal(BRIDGE_FIND_BLUEPRINT_REFERENCES_REQUEST_TYPE),
 	version: z.literal(1)
 });
+const bridgeGetBlueprintSummaryRequestSchema = z.object({
+	blueprintPath: assetPathSchema,
+	componentCursor: assetCursorSchema.default(0),
+	functionCursor: assetCursorSchema.default(0),
+	graphCursor: assetCursorSchema.default(0),
+	loadIfNeeded: z.boolean().default(false),
+	maxResults: blueprintMemberLimitSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BLUEPRINT_SUMMARY_REQUEST_TYPE),
+	variableCursor: assetCursorSchema.default(0),
+	version: z.literal(1)
+});
+const bridgeGetBlueprintGraphRequestSchema = z.object({
+	blueprintPath: assetPathSchema,
+	graphName: blueprintGraphNameSchema,
+	loadIfNeeded: z.boolean().default(false),
+	maxNodes: blueprintNodeLimitSchema,
+	nodeCursor: assetCursorSchema.default(0),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BLUEPRINT_GRAPH_REQUEST_TYPE),
+	version: z.literal(1)
+});
+const bridgeGetBlueprintCompileErrorsRequestSchema = z.object({
+	blueprintPaths: blueprintPathArraySchema,
+	cursor: assetCursorSchema.default(0),
+	maxResults: assetMaxResultsSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BLUEPRINT_COMPILE_ERRORS_REQUEST_TYPE),
+	version: z.literal(1)
+});
+const bridgeCompileBlueprintRequestSchema = z.object({
+	blueprintPaths: blueprintPathArraySchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_COMPILE_BLUEPRINT_REQUEST_TYPE),
+	version: z.literal(1)
+});
+const bridgeGetBlueprintCompileStatusRequestSchema = z.object({
+	compileJobId: blueprintCompileJobIdSchema,
+	cursor: assetCursorSchema.default(0),
+	maxResults: assetMaxResultsSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BLUEPRINT_COMPILE_STATUS_REQUEST_TYPE),
+	version: z.literal(1)
+});
+const bridgeGetConfigValueRequestSchema = z.object({
+	file: configFileSchema,
+	key: configKeySchema,
+	requestId: requestIdSchema,
+	section: configSectionSchema,
+	type: z.literal(BRIDGE_GET_CONFIG_VALUE_REQUEST_TYPE),
+	version: z.literal(1)
+});
+const bridgeSetConfigValueRequestSchema = z.object({
+	file: configFileSchema,
+	key: configKeySchema,
+	requestId: requestIdSchema,
+	scope: configWriteScopeSchema.default("project_default"),
+	section: configSectionSchema,
+	type: z.literal(BRIDGE_SET_CONFIG_VALUE_REQUEST_TYPE),
+	value: configValueSchema,
+	version: z.literal(1)
+});
+const bridgeListConfigSectionRequestSchema = z.object({
+	cursor: assetCursorSchema.default(0),
+	file: configFileSchema,
+	maxResults: configSectionMaxResultsSchema.default(100),
+	requestId: requestIdSchema,
+	section: configSectionSchema,
+	type: z.literal(BRIDGE_LIST_CONFIG_SECTION_REQUEST_TYPE),
+	version: z.literal(1)
+});
 const bridgePingSuccessResponseSchema = z.object({
 	ok: z.literal(true),
 	port: z.number().int().min(1).max(65535),
@@ -1198,6 +1360,197 @@ const bridgeFindBlueprintReferencesSuccessResponseSchema = z.object({
 	type: z.literal(BRIDGE_FIND_BLUEPRINT_REFERENCES_REQUEST_TYPE),
 	version: z.literal(1)
 });
+const bridgeBlueprintComponentSchema = z.object({
+	className: z.string(),
+	isInherited: z.boolean(),
+	isRoot: z.boolean(),
+	name: z.string(),
+	parentName: z.string().optional()
+});
+const bridgeBlueprintVariableSchema = z.object({
+	category: z.string().optional(),
+	defaultValue: z.string().optional(),
+	name: z.string(),
+	replication: blueprintReplicationSchema,
+	type: z.string()
+});
+const bridgeBlueprintMemberSchema = z.object({
+	graphName: z.string().optional(),
+	kind: blueprintMemberKindSchema,
+	name: z.string(),
+	parameters: z.array(bridgeReflectionParameterSchema)
+});
+const bridgeBlueprintGraphSummarySchema = z.object({
+	kind: blueprintGraphKindSchema,
+	name: z.string(),
+	nodeCount: z.number().int().min(0)
+});
+const bridgeGetBlueprintSummarySuccessResponseSchema = z.object({
+	blueprintName: z.string(),
+	blueprintPath: z.string(),
+	componentCount: z.number().int().min(0),
+	components: z.array(bridgeBlueprintComponentSchema),
+	functionCount: z.number().int().min(0),
+	functions: z.array(bridgeBlueprintMemberSchema),
+	generatedClassPath: z.string().optional(),
+	graphCount: z.number().int().min(0),
+	graphs: z.array(bridgeBlueprintGraphSummarySchema),
+	interfaces: z.array(z.string()),
+	kind: blueprintKindSchema,
+	loaded: z.boolean(),
+	nextComponentCursor: assetCursorSchema.optional(),
+	nextFunctionCursor: assetCursorSchema.optional(),
+	nextGraphCursor: assetCursorSchema.optional(),
+	nextVariableCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	parentClass: z.string().optional(),
+	parentClassPath: z.string().optional(),
+	requestId: requestIdSchema,
+	scanning: z.boolean(),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_BLUEPRINT_SUMMARY_REQUEST_TYPE),
+	variableCount: z.number().int().min(0),
+	variables: z.array(bridgeBlueprintVariableSchema),
+	version: z.literal(1)
+});
+const bridgeBlueprintPinLinkSchema = z.object({
+	nodeId: z.string(),
+	pinId: z.string()
+});
+const bridgeBlueprintPinSchema = z.object({
+	defaultValue: z.string().optional(),
+	direction: blueprintPinDirectionSchema,
+	linkedTo: z.array(bridgeBlueprintPinLinkSchema),
+	linkedToCount: z.number().int().min(0),
+	name: z.string(),
+	pinId: z.string(),
+	type: z.string()
+});
+const bridgeBlueprintNodeSchema = z.object({
+	comment: z.string().optional(),
+	nodeClass: z.string(),
+	nodeId: z.string(),
+	pinCount: z.number().int().min(0),
+	pins: z.array(bridgeBlueprintPinSchema),
+	title: z.string()
+});
+const bridgeGetBlueprintGraphSuccessResponseSchema = z.object({
+	blueprintPath: z.string(),
+	graphKind: blueprintGraphKindSchema,
+	graphName: z.string(),
+	nodeCount: z.number().int().min(0),
+	nodes: z.array(bridgeBlueprintNodeSchema),
+	nextNodeCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_BLUEPRINT_GRAPH_REQUEST_TYPE),
+	version: z.literal(1)
+});
+const bridgeBlueprintCompileDiagnosticSchema = bridgeCompileDiagnosticSchema.extend({
+	graphName: z.string().optional(),
+	nodeGuid: z.string().optional(),
+	nodeName: z.string().optional()
+});
+const bridgeBlueprintCompileResultSchema = z.object({
+	blueprintPath: z.string(),
+	compiledAt: nonEmptyStringSchema.optional(),
+	errorCount: z.number().int().min(0),
+	errors: z.array(bridgeBlueprintCompileDiagnosticSchema),
+	hasDiagnostics: z.boolean(),
+	status: blueprintStatusSchema,
+	warningCount: z.number().int().min(0),
+	warnings: z.array(bridgeBlueprintCompileDiagnosticSchema)
+});
+const bridgeGetBlueprintCompileErrorsSuccessResponseSchema = z.object({
+	nextCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	results: z.array(bridgeBlueprintCompileResultSchema),
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_BLUEPRINT_COMPILE_ERRORS_REQUEST_TYPE),
+	version: z.literal(1)
+});
+const bridgeCompileBlueprintSuccessResponseSchema = z.object({
+	compileJobId: blueprintCompileJobIdSchema.optional(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: compileBlueprintStateSchema,
+	type: z.literal(BRIDGE_COMPILE_BLUEPRINT_REQUEST_TYPE),
+	version: z.literal(1)
+}).refine((value) => value.state === "compiling" === (value.compileJobId !== void 0), {
+	message: "A compile_blueprint response must carry compileJobId exactly when state is 'compiling'.",
+	path: ["compileJobId"]
+});
+const bridgeGetBlueprintCompileStatusSuccessResponseSchema = z.object({
+	compileJobId: blueprintCompileJobIdSchema,
+	durationMs: z.number().int().min(0).optional(),
+	finishedAt: nonEmptyStringSchema.optional(),
+	nextCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	results: z.array(bridgeBlueprintCompileResultSchema),
+	state: blueprintCompileStatusStateSchema,
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_BLUEPRINT_COMPILE_STATUS_REQUEST_TYPE),
+	version: z.literal(1)
+}).superRefine((value, ctx) => {
+	if (value.state === "succeeded" || value.state === "failed") return;
+	for (const field of ["durationMs", "finishedAt"]) if (value[field] !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `${field} must be absent unless state is succeeded or failed`,
+		path: [field]
+	});
+});
+const bridgeConfigEntrySchema = z.object({
+	key: configKeySchema,
+	value: configValueSchema,
+	valueTruncated: z.boolean().optional()
+});
+const bridgeGetConfigValueSuccessResponseSchema = z.object({
+	file: configFileSchema,
+	filePath: z.string().trim().min(1).optional(),
+	key: configKeySchema,
+	ok: z.literal(true),
+	present: z.boolean(),
+	requestId: requestIdSchema,
+	resolvedFrom: configResolvedScopeSchema,
+	section: configSectionSchema,
+	type: z.literal(BRIDGE_GET_CONFIG_VALUE_REQUEST_TYPE),
+	value: configValueSchema.optional(),
+	valueTruncated: z.boolean().optional(),
+	version: z.literal(1)
+});
+const bridgeSetConfigValueSuccessResponseSchema = z.object({
+	file: configFileSchema,
+	filePath: z.string().trim().min(1),
+	key: configKeySchema,
+	ok: z.literal(true),
+	previousPresent: z.boolean(),
+	previousValue: configValueSchema.optional(),
+	previousValueTruncated: z.boolean().optional(),
+	requestId: requestIdSchema,
+	scope: configWriteScopeSchema,
+	section: configSectionSchema,
+	type: z.literal(BRIDGE_SET_CONFIG_VALUE_REQUEST_TYPE),
+	value: configValueSchema,
+	version: z.literal(1)
+});
+const bridgeListConfigSectionSuccessResponseSchema = z.object({
+	entries: z.array(bridgeConfigEntrySchema).max(200),
+	file: configFileSchema,
+	nextCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	section: configSectionSchema,
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_LIST_CONFIG_SECTION_REQUEST_TYPE),
+	version: z.literal(1)
+});
 const bridgeErrorResponseSchema = z.object({
 	error: bridgeErrorSchema,
 	ok: z.literal(false),
@@ -1235,6 +1588,14 @@ const bridgeGetCreateClassStatusResponseSchema = z.union([bridgeGetCreateClassSt
 const bridgeFindAssetsResponseSchema = z.union([bridgeFindAssetsSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeGetAssetDependenciesResponseSchema = z.union([bridgeGetAssetDependenciesSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeFindBlueprintReferencesResponseSchema = z.union([bridgeFindBlueprintReferencesSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetBlueprintSummaryResponseSchema = z.union([bridgeGetBlueprintSummarySuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetBlueprintGraphResponseSchema = z.union([bridgeGetBlueprintGraphSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetBlueprintCompileErrorsResponseSchema = z.union([bridgeGetBlueprintCompileErrorsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCompileBlueprintResponseSchema = z.union([bridgeCompileBlueprintSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetBlueprintCompileStatusResponseSchema = z.union([bridgeGetBlueprintCompileStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetConfigValueResponseSchema = z.union([bridgeGetConfigValueSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetConfigValueResponseSchema = z.union([bridgeSetConfigValueSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeListConfigSectionResponseSchema = z.union([bridgeListConfigSectionSuccessResponseSchema, bridgeErrorResponseSchema]);
 function createBridgeFindAssetsRequest(options = {}, requestId = randomUUID()) {
 	return bridgeFindAssetsRequestSchema.parse({
 		classNames: options.classNames,
@@ -1273,6 +1634,93 @@ function createBridgeFindBlueprintReferencesRequest(className, options = {}, req
 		version: 1
 	});
 }
+function createBridgeGetBlueprintSummaryRequest(blueprintPath, options = {}, requestId = randomUUID()) {
+	return bridgeGetBlueprintSummaryRequestSchema.parse({
+		blueprintPath,
+		componentCursor: options.componentCursor,
+		functionCursor: options.functionCursor,
+		graphCursor: options.graphCursor,
+		loadIfNeeded: options.loadIfNeeded,
+		maxResults: options.maxResults ?? 25,
+		requestId,
+		type: BRIDGE_GET_BLUEPRINT_SUMMARY_REQUEST_TYPE,
+		variableCursor: options.variableCursor,
+		version: 1
+	});
+}
+function createBridgeGetBlueprintGraphRequest(blueprintPath, graphName, options = {}, requestId = randomUUID()) {
+	return bridgeGetBlueprintGraphRequestSchema.parse({
+		blueprintPath,
+		graphName,
+		loadIfNeeded: options.loadIfNeeded,
+		maxNodes: options.maxNodes ?? 25,
+		nodeCursor: options.nodeCursor,
+		requestId,
+		type: BRIDGE_GET_BLUEPRINT_GRAPH_REQUEST_TYPE,
+		version: 1
+	});
+}
+function createBridgeGetBlueprintCompileErrorsRequest(blueprintPaths, options = {}, requestId = randomUUID()) {
+	return bridgeGetBlueprintCompileErrorsRequestSchema.parse({
+		blueprintPaths,
+		cursor: options.cursor,
+		maxResults: options.maxResults ?? 50,
+		requestId,
+		type: BRIDGE_GET_BLUEPRINT_COMPILE_ERRORS_REQUEST_TYPE,
+		version: 1
+	});
+}
+function createBridgeCompileBlueprintRequest(blueprintPaths, requestId = randomUUID()) {
+	return bridgeCompileBlueprintRequestSchema.parse({
+		blueprintPaths,
+		requestId,
+		type: BRIDGE_COMPILE_BLUEPRINT_REQUEST_TYPE,
+		version: 1
+	});
+}
+function createBridgeGetBlueprintCompileStatusRequest(compileJobId, options = {}, requestId = randomUUID()) {
+	return bridgeGetBlueprintCompileStatusRequestSchema.parse({
+		compileJobId,
+		cursor: options.cursor,
+		maxResults: options.maxResults ?? 50,
+		requestId,
+		type: BRIDGE_GET_BLUEPRINT_COMPILE_STATUS_REQUEST_TYPE,
+		version: 1
+	});
+}
+function createBridgeGetConfigValueRequest(input, requestId = randomUUID()) {
+	return bridgeGetConfigValueRequestSchema.parse({
+		file: input.file,
+		key: input.key,
+		requestId,
+		section: input.section,
+		type: BRIDGE_GET_CONFIG_VALUE_REQUEST_TYPE,
+		version: 1
+	});
+}
+function createBridgeSetConfigValueRequest(input, requestId = randomUUID()) {
+	return bridgeSetConfigValueRequestSchema.parse({
+		file: input.file,
+		key: input.key,
+		requestId,
+		scope: input.scope,
+		section: input.section,
+		type: BRIDGE_SET_CONFIG_VALUE_REQUEST_TYPE,
+		value: input.value,
+		version: 1
+	});
+}
+function createBridgeListConfigSectionRequest(input, requestId = randomUUID()) {
+	return bridgeListConfigSectionRequestSchema.parse({
+		cursor: input.cursor,
+		file: input.file,
+		maxResults: input.maxResults,
+		requestId,
+		section: input.section,
+		type: BRIDGE_LIST_CONFIG_SECTION_REQUEST_TYPE,
+		version: 1
+	});
+}
 function createBridgePingRequest(requestId = randomUUID()) {
 	return {
 		requestId,
@@ -1587,6 +2035,15 @@ async function sendBridgeGetCdoDefaultsRequest(request, options) {
 async function sendBridgeExecConsoleCommandRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeExecConsoleCommandResponseSchema, request.requestId);
 }
+async function sendBridgeGetConfigValueRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetConfigValueResponseSchema, request.requestId);
+}
+async function sendBridgeSetConfigValueRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetConfigValueResponseSchema, request.requestId);
+}
+async function sendBridgeListConfigSectionRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListConfigSectionResponseSchema, request.requestId);
+}
 async function sendBridgeStatSnapshotRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeStatSnapshotResponseSchema, request.requestId);
 }
@@ -1605,6 +2062,21 @@ async function sendBridgeGetAssetDependenciesRequest(request, options) {
 async function sendBridgeFindBlueprintReferencesRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeFindBlueprintReferencesResponseSchema, request.requestId);
 }
+async function sendBridgeGetBlueprintSummaryRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetBlueprintSummaryResponseSchema, request.requestId);
+}
+async function sendBridgeGetBlueprintGraphRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetBlueprintGraphResponseSchema, request.requestId);
+}
+async function sendBridgeGetBlueprintCompileErrorsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetBlueprintCompileErrorsResponseSchema, request.requestId);
+}
+async function sendBridgeCompileBlueprintRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCompileBlueprintResponseSchema, request.requestId);
+}
+async function sendBridgeGetBlueprintCompileStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetBlueprintCompileStatusResponseSchema, request.requestId);
+}
 function encodeBridgeFrame(payload) {
 	const payloadBuffer = Buffer.from(JSON.stringify(payload), "utf8");
 	if (payloadBuffer.length === 0 || payloadBuffer.length > 65536) throw new BridgeSocketError("invalid_frame", `Bridge payload size ${String(payloadBuffer.length)} is outside the allowed range.`);
@@ -1684,6 +2156,7 @@ var BridgeSessionClient = class {
 				port: this.options.port
 			});
 			this.connectingSocket = socket;
+			socket.on("error", ignoreSocketError);
 			let settled = false;
 			const connectTimeout = setTimeout(() => {
 				socket.destroy(new BridgeSocketError("connect_timeout", `Timed out connecting to localhost bridge on port ${String(this.options.port)}.`));
@@ -1817,6 +2290,7 @@ function parseBridgePayload(responsePayload) {
 		throw new BridgeSocketError("invalid_frame", `Bridge response contained invalid JSON: ${error.message}. Payload bytes: ${String(Buffer.byteLength(responsePayload, "utf8"))}.`, { cause: error });
 	}
 }
+function ignoreSocketError() {}
 function exchangeBridgeMessage(frame, options) {
 	return new Promise((resolve, reject) => {
 		const socket = net.createConnection({
@@ -1846,6 +2320,7 @@ function exchangeBridgeMessage(frame, options) {
 			settled = true;
 			clearTimers();
 			socket.removeAllListeners();
+			socket.on("error", ignoreSocketError);
 			handler();
 		};
 		const refreshReadTimeout = () => {
@@ -2501,9 +2976,80 @@ function isLogLevel(value) {
 const CLANG_DIAGNOSTIC_PATTERN = /^(?<file>.+?):(?<line>\d+):(?:(?<column>\d+):)?\s+(?<severity>fatal error|error|warning):\s+(?<message>.*)$/u;
 const MSVC_DIAGNOSTIC_PATTERN = /^(?<file>.+?)\((?<line>\d+)(?:,\d+)?\):\s+(?<severity>fatal error|error|warning)\s+(?<code>[A-Z]+\d+):\s+(?<message>.*)$/u;
 const CLANG_TIDY_PATTERN = /^(?<file>.+?):(?<line>\d+):(?<column>\d+):\s+(?<severity>error|warning):\s+(?<message>.*?)(?:\s+\[(?<check>[^\]]+)\])?$/u;
+const COOK_LINE_PREFIX_PATTERN = /^(?:\[[^\]]*\]\s*)*(?:[A-Za-z]+Helper:\s*[^:]*:\s*)?/u;
+const COOK_DIAGNOSTIC_PATTERN = /^(?<category>[A-Za-z_][A-Za-z0-9_]*):\s+(?<severity>Error|Warning)(?::)?\s+(?<message>.+)$/u;
+const UAT_DIAGNOSTIC_PATTERN = /^(?<severity>ERROR|WARNING):\s+(?<message>.+)$/u;
 function diagnosticKey(diagnostic) {
 	return `${diagnostic.file ?? ""}|${diagnostic.line ?? ""}|${diagnostic.message}`;
 }
+function matchCookDiagnostic(rawLine) {
+	const line = rawLine.trim().replace(COOK_LINE_PREFIX_PATTERN, "").trim();
+	if (line.length === 0) return null;
+	const categoryMatch = COOK_DIAGNOSTIC_PATTERN.exec(line);
+	if (categoryMatch?.groups) {
+		const { category, message, severity } = categoryMatch.groups;
+		if (category === void 0 || message === void 0 || severity === void 0) return null;
+		return {
+			isError: severity === "Error",
+			message: `${category}: ${message.trim()}`
+		};
+	}
+	const uatMatch = UAT_DIAGNOSTIC_PATTERN.exec(line);
+	if (!uatMatch?.groups) return null;
+	const { message, severity } = uatMatch.groups;
+	if (message === void 0 || severity === void 0) return null;
+	return {
+		isError: severity === "ERROR",
+		message: message.trim()
+	};
+}
+var CookDiagnosticCollector = class {
+	maxEntriesPerSeverity;
+	errors = [];
+	warnings = [];
+	seenErrors = /* @__PURE__ */ new Set();
+	seenWarnings = /* @__PURE__ */ new Set();
+	pending = "";
+	truncatedFlag = false;
+	constructor(maxEntriesPerSeverity) {
+		this.maxEntriesPerSeverity = maxEntriesPerSeverity;
+	}
+	push(chunk) {
+		const lines = (this.pending + chunk).split(/\r?\n/u);
+		this.pending = lines.pop() ?? "";
+		for (const line of lines) this.pushLine(line);
+	}
+	flush() {
+		if (this.pending.length === 0) return;
+		const remaining = this.pending;
+		this.pending = "";
+		this.pushLine(remaining);
+	}
+	snapshot() {
+		return {
+			errorCount: this.errors.length,
+			errors: [...this.errors],
+			truncated: this.truncatedFlag,
+			warningCount: this.warnings.length,
+			warnings: [...this.warnings]
+		};
+	}
+	pushLine(rawLine) {
+		const matched = matchCookDiagnostic(rawLine);
+		if (!matched) return;
+		const diagnostic = { message: matched.message };
+		const target = matched.isError ? this.errors : this.warnings;
+		const seen = matched.isError ? this.seenErrors : this.seenWarnings;
+		const key = diagnosticKey(diagnostic);
+		if (seen.has(key)) return;
+		seen.add(key);
+		if (target.length >= this.maxEntriesPerSeverity) {
+			this.truncatedFlag = true;
+			return;
+		}
+		target.push(diagnostic);
+	}
+};
 function parseBuildDiagnostics(output) {
 	const errors = [];
 	const warnings = [];
@@ -2577,8 +3123,23 @@ const UNREAL_TARGET_PLATFORMS = [
 	"Mac",
 	"Linux"
 ];
+const UNREAL_COOK_TARGET_PLATFORMS = [
+	"Win64",
+	"Mac",
+	"Linux",
+	"LinuxArm64",
+	"Android",
+	"IOS",
+	"TVOS",
+	"VisionOS"
+];
+const COOK_COMMANDLET_PLATFORM_NAMES = { Win64: "Windows" };
+function cookCommandletTargetPlatform(platform) {
+	return COOK_COMMANDLET_PLATFORM_NAMES[platform] ?? platform;
+}
 const DEFAULT_PROCESS_TIMEOUT_MS = 18e5;
 const MAX_PROCESS_TIMEOUT_MS = 72e5;
+const DEFAULT_PACKAGE_TIMEOUT_MS = 54e5;
 async function defaultFileExists(filePath) {
 	try {
 		await access(filePath);
@@ -2593,6 +3154,26 @@ async function defaultListDirectory(dirPath) {
 async function defaultReadFile(filePath) {
 	return await readFile(filePath, "utf8");
 }
+async function defaultWriteFile(filePath, contents) {
+	await writeFile(filePath, contents, "utf8");
+}
+function defaultReadTextLines(filePath) {
+	return createInterface({
+		crlfDelay: Number.POSITIVE_INFINITY,
+		input: createReadStream(filePath, "utf8")
+	});
+}
+async function defaultCreateTempDirectory(prefix) {
+	return await mkdtemp(path.join(tmpdir(), prefix));
+}
+async function defaultRemoveDirectory(dirPath) {
+	await rm(dirPath, {
+		force: true,
+		maxRetries: 3,
+		recursive: true,
+		retryDelay: 50
+	});
+}
 var RollingTextBuffer = class {
 	maxBytes;
 	chunks = [];
@@ -2633,7 +3214,11 @@ const runProcess = (options) => {
 	return new Promise((resolve, reject) => {
 		const child = spawn(options.command, options.args, {
 			cwd: options.cwd,
-			env: options.env
+			env: options.env,
+			...options.windowsVerbatimArguments === true && process.platform === "win32" ? {
+				argv0: `"${options.command}"`,
+				windowsVerbatimArguments: true
+			} : {}
 		});
 		const stdoutBuffer = new RollingTextBuffer(maxOutputBytes);
 		const stderrBuffer = new RollingTextBuffer(maxOutputBytes);
@@ -2643,7 +3228,13 @@ const runProcess = (options) => {
 		const append = (buffer, text) => {
 			buffer.push(text);
 			combinedBuffer.push(text);
+			options.onOutput?.(text);
+		};
+		const abortListener = () => {
+			child.kill("SIGKILL");
 		};
+		if (options.signal?.aborted === true) child.kill("SIGKILL");
+		else options.signal?.addEventListener("abort", abortListener, { once: true });
 		child.stdout.setEncoding("utf8");
 		child.stderr.setEncoding("utf8");
 		child.stdout.on("data", (chunk) => {
@@ -2660,12 +3251,14 @@ const runProcess = (options) => {
 			if (settled) return;
 			settled = true;
 			clearTimeout(timeoutHandle);
+			options.signal?.removeEventListener("abort", abortListener);
 			reject(new ProcessExecutionError(options.command, error.message, { cause: error }));
 		});
 		child.on("close", (code, signal) => {
 			if (settled) return;
 			settled = true;
 			clearTimeout(timeoutHandle);
+			options.signal?.removeEventListener("abort", abortListener);
 			resolve({
 				combinedOutput: combinedBuffer.toString(),
 				durationMs: Date.now() - startedAt,
@@ -2682,12 +3275,16 @@ const runProcess = (options) => {
 function createEngineToolchainContext(overrides = {}) {
 	return {
 		arch: overrides.arch ?? process.arch,
+		createTempDirectory: overrides.createTempDirectory ?? defaultCreateTempDirectory,
 		env: overrides.env ?? process.env,
 		fileExists: overrides.fileExists ?? defaultFileExists,
 		listDirectory: overrides.listDirectory ?? defaultListDirectory,
 		platform: overrides.platform ?? process.platform,
 		readFile: overrides.readFile ?? defaultReadFile,
-		runProcess: overrides.runProcess ?? runProcess
+		readTextLines: overrides.readTextLines ?? defaultReadTextLines,
+		removeDirectory: overrides.removeDirectory ?? defaultRemoveDirectory,
+		runProcess: overrides.runProcess ?? runProcess,
+		writeFile: overrides.writeFile ?? defaultWriteFile
 	};
 }
 function defaultTargetPlatform(platform) {
@@ -2744,14 +3341,20 @@ async function resolveEngine(options) {
 	const { context } = options;
 	const ueInstallsDir = context.env.UE_INSTALLS_DIR?.trim();
 	if (!ueInstallsDir) throw new EngineToolchainError("UE_INSTALLS_DIR is not set; define it in .env (see .env.example).");
-	const engineVersion = options.engineVersion?.trim() || await readEngineAssociation(options.uprojectPath, context);
+	const explicitEngineVersion = options.engineVersion?.trim();
+	const { uprojectPath } = options;
+	let engineVersion;
+	if (explicitEngineVersion) engineVersion = explicitEngineVersion;
+	else if (uprojectPath === void 0) throw new EngineToolchainError("Engine resolution needs either an engineVersion or a project path.");
+	else engineVersion = await readEngineAssociation(uprojectPath, context);
 	if (!/^\d+(?:\.\d+)*$/u.test(engineVersion)) throw new EngineToolchainError(`EngineAssociation "${engineVersion}" is not a numeric version; pass engineVersion explicitly (e.g. "5.7").`);
 	const engineRoot = path.join(ueInstallsDir, `UE_${engineVersion}`);
 	if (!await context.fileExists(engineRoot)) throw new EngineToolchainError(`Engine directory not found for UE version ${engineVersion}: ${engineRoot}`);
+	const unrealBuildTool = await resolveUnrealBuildTool(engineRoot, context);
 	return {
 		engineRoot,
 		engineVersion,
-		unrealBuildTool: await resolveUnrealBuildTool(engineRoot, context)
+		unrealBuildTool
 	};
 }
 async function resolveUnrealBuildTool(engineRoot, context) {
@@ -2771,8 +3374,72 @@ async function resolveUnrealBuildTool(engineRoot, context) {
 		command: bundledDotnet ?? "dotnet"
 	};
 }
+async function resolveAutomationTool(engineRoot, context) {
+	if (context.platform !== "win32") {
+		const scriptPath = path.join(engineRoot, "Engine", "Build", "BatchFiles", "RunUAT.sh");
+		if (!await context.fileExists(scriptPath)) throw new EngineToolchainError(`RunUAT.sh not found at ${scriptPath}`);
+		return {
+			args: [],
+			command: scriptPath
+		};
+	}
+	const automationToolDirectory = path.join(engineRoot, "Engine", "Binaries", "DotNET", "AutomationTool");
+	const automationToolDll = path.join(automationToolDirectory, "AutomationTool.dll");
+	if (!await context.fileExists(automationToolDll)) throw new EngineToolchainError(`AutomationTool.dll not found at ${automationToolDll}`);
+	const bundledDotnet = await resolveBundledDotnet(engineRoot, context);
+	if (bundledDotnet === void 0) return {
+		args: [automationToolDll],
+		command: "dotnet",
+		cwd: automationToolDirectory,
+		env: buildAutomationToolEnvironment(context.env)
+	};
+	return {
+		args: [automationToolDll],
+		command: bundledDotnet,
+		cwd: automationToolDirectory,
+		env: buildAutomationToolEnvironment(context.env, path.dirname(bundledDotnet))
+	};
+}
+const VISUAL_STUDIO_ENVIRONMENT_KEYS = [
+	"PkgDefApplicationConfigFile",
+	"VSAPPIDDIR",
+	"VSSKUEDITION",
+	"VisualStudioDir",
+	"VisualStudioEdition",
+	"VisualStudioVersion"
+];
+function buildAutomationToolEnvironment(parentEnvironment, dotnetDirectory) {
+	const environment = { ...parentEnvironment };
+	const clearedKeys = new Set(VISUAL_STUDIO_ENVIRONMENT_KEYS.map((key) => key.toUpperCase()));
+	for (const key of Object.keys(environment)) if (clearedKeys.has(key.toUpperCase())) delete environment[key];
+	if (dotnetDirectory === void 0) return environment;
+	const pathKey = Object.keys(environment).find((key) => key.toUpperCase() === "PATH") ?? "PATH";
+	const inheritedPath = environment[pathKey];
+	environment[pathKey] = inheritedPath === void 0 || inheritedPath.length === 0 ? dotnetDirectory : `${dotnetDirectory}${path.delimiter}${inheritedPath}`;
+	environment.DOTNET_MULTILEVEL_LOOKUP = "0";
+	environment.DOTNET_ROLL_FORWARD = "LatestMajor";
+	environment.DOTNET_ROOT = dotnetDirectory;
+	return environment;
+}
+function editorBinariesDirs(platform, arch) {
+	if (platform === "win32") return ["Win64"];
+	if (platform === "darwin") return ["Mac"];
+	return arch === "arm64" ? ["LinuxArm64", "Linux"] : ["Linux"];
+}
+async function resolveUnrealEditorCmd(engineRoot, context) {
+	const binaryName = context.platform === "win32" ? "UnrealEditor-Cmd.exe" : "UnrealEditor-Cmd";
+	const candidates = editorBinariesDirs(context.platform, context.arch).map((binariesDir) => path.join(engineRoot, "Engine", "Binaries", binariesDir, binaryName));
+	for (const candidate of candidates) if (await context.fileExists(candidate)) return candidate;
+	throw new EngineToolchainError(`${binaryName} not found under ${path.join(engineRoot, "Engine", "Binaries")}`);
+}
+async function resolveUnrealInsights(engineRoot, context) {
+	const binariesRoot = path.join(engineRoot, "Engine", "Binaries");
+	const candidates = context.platform === "win32" ? [path.join(binariesRoot, "Win64", "UnrealInsights.exe")] : context.platform === "darwin" ? [path.join(binariesRoot, "Mac", "UnrealInsights.app", "Contents", "MacOS", "UnrealInsights"), path.join(binariesRoot, "Mac", "UnrealInsights")] : editorBinariesDirs(context.platform, context.arch).map((binariesDir) => path.join(binariesRoot, binariesDir, "UnrealInsights"));
+	for (const candidate of candidates) if (await context.fileExists(candidate)) return candidate;
+	return null;
+}
 function dotnetHostPlatformDirs(platform, arch) {
-	const osPrefix = platform === "darwin" ? "mac" : platform === "linux" ? "linux" : void 0;
+	const osPrefix = platform === "darwin" ? "mac" : platform === "linux" ? "linux" : platform === "win32" ? "win" : void 0;
 	if (!osPrefix) return [];
 	const archDir = arch === "arm64" ? "arm64" : "x64";
 	const otherArchDir = archDir === "arm64" ? "x64" : "arm64";
@@ -2788,8 +3455,9 @@ async function resolveBundledDotnet(engineRoot, context) {
 	} catch {
 		return;
 	}
+	const executableName = context.platform === "win32" ? "dotnet.exe" : "dotnet";
 	for (const versionDir of versionDirs) for (const platformDir of platformDirs) {
-		const candidate = path.join(dotnetRoot, versionDir, platformDir, "dotnet");
+		const candidate = path.join(dotnetRoot, versionDir, platformDir, executableName);
 		if (await context.fileExists(candidate)) return candidate;
 	}
 }
@@ -3013,30 +3681,412 @@ function isPlainObject(value) {
 function getErrorCode(error) {
 	if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
 }
-//#endregion
-//#region src/mcpTools.ts
-const EDITOR_WORK_TIMEOUT_MS = 1e4;
-const getProjectIdInputSchema = { projectPath: z.string().trim().min(1) };
-const pingProjectInputSchema = { projectId: projectIdSchema };
-const startPieInputSchema = {
-	map: z.string().trim().min(1).max(512).optional().describe("Optional level/map path to load before play (e.g. /Game/Maps/MyLevel)."),
-	mode: z.enum(BRIDGE_PIE_MODES).optional().describe("Play-in-Editor mode: 'selected_viewport', 'new_window' (default), or 'standalone'."),
-	netMode: z.enum(BRIDGE_PIE_NET_MODES).optional().describe("Multiplayer net mode: 'standalone', 'listen_server', 'client', or 'dedicated_server'. Omit for single-player editor defaults."),
-	numClients: z.number().int().min(1).max(16).optional().describe(`Number of client windows to launch (1-${String(16)}). With a server net mode, launches 1 server + N-1 clients.`),
-	projectId: projectIdSchema,
-	runUnderOneProcess: z.boolean().optional().describe("Run all multiplayer instances under a single process instead of separate processes.")
-};
-const getPieStatusInputSchema = {
-	pieSessionId: z.string().trim().min(1).max(512).optional().describe("Optional pieSessionId returned by start_pie; omit to query the editor current PIE session."),
-	projectId: projectIdSchema
+const PACKAGE_JOB_MAX_OUTPUT_BYTES = 2097152;
+var PackageJobCapacityError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PackageJobCapacityError";
+	}
 };
-const stopPieInputSchema = {
-	pieSessionId: z.string().trim().min(1).max(512).optional().describe("Optional pieSessionId returned by start_pie; omit to stop the editor current PIE session."),
-	projectId: projectIdSchema
+var PackageJobRegistry = class {
+	jobs = /* @__PURE__ */ new Map();
+	start(options) {
+		this.evictFinishedJobs();
+		const projectKey = projectComparisonKey(options.projectPath);
+		this.assertCapacity(projectKey, options.projectPath);
+		const record = {
+			abortController: new AbortController(),
+			args: [...options.args],
+			cancelled: false,
+			collector: new CookDiagnosticCollector(200),
+			command: options.command,
+			kind: options.kind,
+			outputTail: "",
+			outputTruncated: false,
+			packageJobId: randomUUID().replaceAll("-", ""),
+			projectKey,
+			projectPath: options.projectPath,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			state: "running",
+			timedOut: false
+		};
+		if (options.platform !== void 0) record.platform = options.platform;
+		this.jobs.set(record.packageJobId, record);
+		this.run(record, options);
+		return toPackageJobStatus(record);
+	}
+	get(packageJobId) {
+		const record = this.jobs.get(packageJobId);
+		return record ? toPackageJobStatus(record) : null;
+	}
+	cancel(packageJobId) {
+		const record = this.jobs.get(packageJobId);
+		if (!record) return {
+			cancelled: false,
+			state: "unknown_job"
+		};
+		if (record.state !== "running") return {
+			cancelled: false,
+			state: record.state
+		};
+		record.cancelled = true;
+		record.abortController.abort();
+		return {
+			cancelled: true,
+			state: record.state
+		};
+	}
+	async run(record, options) {
+		try {
+			const result = await options.runProcess({
+				args: options.args,
+				command: options.command,
+				cwd: options.cwd,
+				...options.env ? { env: options.env } : {},
+				maxOutputBytes: PACKAGE_JOB_MAX_OUTPUT_BYTES,
+				onOutput: (chunk) => {
+					record.collector.push(chunk);
+					appendOutputTail(record, chunk);
+				},
+				signal: record.abortController.signal,
+				timeoutMs: options.timeoutMs
+			});
+			record.collector.flush();
+			record.durationMs = result.durationMs;
+			record.exitCode = result.exitCode;
+			record.outputTail = result.combinedOutput.slice(-8e3);
+			record.outputTruncated = record.outputTruncated || result.truncated || result.combinedOutput.length > 8e3;
+			record.timedOut = result.timedOut;
+			record.state = resolveTerminalState(record, result.exitCode, result.timedOut);
+		} catch (error) {
+			record.collector.flush();
+			record.failureReason = error instanceof Error ? error.message : String(error);
+			record.state = record.cancelled ? "cancelled" : "failed";
+			options.logger.error({
+				error,
+				kind: record.kind,
+				packageJobId: record.packageJobId,
+				projectPath: record.projectPath
+			}, "Package job process failed to run");
+		} finally {
+			record.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+		}
+	}
+	assertCapacity(projectKey, projectPath) {
+		let activeCount = 0;
+		let activeForProject = 0;
+		for (const record of this.jobs.values()) {
+			if (record.state !== "running") continue;
+			activeCount += 1;
+			if (record.projectKey === projectKey) activeForProject += 1;
+		}
+		if (activeForProject >= 1) throw new PackageJobCapacityError(`A cook, package or commandlet job is already running for '${projectPath}'. Wait for it, or cancel it with cancel_package_job.`);
+		if (activeCount >= 4) throw new PackageJobCapacityError(`${String(4)} cook, package or commandlet jobs are already running. Wait for one to finish, or cancel one with cancel_package_job.`);
+	}
+	evictFinishedJobs() {
+		if (this.jobs.size < 20) return;
+		for (const [packageJobId, record] of this.jobs) {
+			if (this.jobs.size < 20) return;
+			if (record.state !== "running") this.jobs.delete(packageJobId);
+		}
+	}
 };
-const listLaunchDevicesInputSchema = { projectId: projectIdSchema };
-const launchOnDeviceInputSchema = {
-	deviceId: z.string().trim().min(1).max(512).describe("Target device id from list_launch_devices (e.g. IOS@MyiPhone, Android@serial)."),
+function projectComparisonKey(projectPath) {
+	const resolved = path.resolve(projectPath.trim());
+	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function appendOutputTail(record, chunk) {
+	const outputTail = record.outputTail + chunk;
+	if (outputTail.length > 8e3) record.outputTruncated = true;
+	record.outputTail = outputTail.slice(-8e3);
+}
+function resolveTerminalState(record, exitCode, timedOut) {
+	if (record.cancelled) return "cancelled";
+	return exitCode === 0 && !timedOut ? "succeeded" : "failed";
+}
+function toPackageJobStatus(record) {
+	const diagnostics = record.collector.snapshot();
+	const status = {
+		args: [...record.args],
+		command: record.command,
+		diagnosticsTruncated: diagnostics.truncated,
+		errorCount: diagnostics.errorCount,
+		errors: diagnostics.errors,
+		kind: record.kind,
+		outputTail: record.outputTail,
+		outputTruncated: record.outputTruncated,
+		packageJobId: record.packageJobId,
+		projectPath: record.projectPath,
+		startedAt: record.startedAt,
+		state: record.state,
+		timedOut: record.timedOut,
+		warningCount: diagnostics.warningCount,
+		warnings: diagnostics.warnings
+	};
+	if (record.durationMs !== void 0) status.durationMs = record.durationMs;
+	if (record.exitCode !== void 0) status.exitCode = record.exitCode;
+	if (record.failureReason !== void 0) status.failureReason = record.failureReason;
+	if (record.finishedAt !== void 0) status.finishedAt = record.finishedAt;
+	if (record.platform !== void 0) status.platform = record.platform;
+	return status;
+}
+//#endregion
+//#region src/traceAnalysis.ts
+const SECONDS_TO_MS = 1e3;
+const FRAME_ROOT_TIMER_NAMES = /* @__PURE__ */ new Set(["FEngineLoop::Tick"]);
+function parseCsvRows(text) {
+	const [headerLine, ...dataLines] = splitCsvLines(text);
+	if (headerLine === void 0) return [];
+	const headers = parseCsvLine(headerLine);
+	return dataLines.map((line) => {
+		const values = parseCsvLine(line);
+		const row = {};
+		headers.forEach((header, index) => {
+			row[header] = values[index] ?? "";
+		});
+		return row;
+	});
+}
+function splitCsvLines(text) {
+	return text.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function parseCsvLine(line) {
+	const values = [];
+	let current = "";
+	let inQuotes = false;
+	for (let index = 0; index < line.length; index += 1) {
+		const character = line[index];
+		if (character === "\"") {
+			if (inQuotes && line[index + 1] === "\"") {
+				current += "\"";
+				index += 1;
+				continue;
+			}
+			inQuotes = !inQuotes;
+			continue;
+		}
+		if (character === "," && !inQuotes) {
+			values.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += character ?? "";
+	}
+	values.push(current.trim());
+	return values;
+}
+function findColumn(row, ...candidates) {
+	const headers = Object.keys(row);
+	for (const candidate of candidates) {
+		const match = headers.find((header) => header.toLowerCase() === candidate.toLowerCase());
+		if (match !== void 0) return match;
+	}
+	for (const candidate of candidates) {
+		const match = headers.find((header) => header.toLowerCase().includes(candidate.toLowerCase()));
+		if (match !== void 0) return match;
+	}
+}
+function readNumber(value) {
+	if (value === void 0 || value.length === 0) return;
+	const parsed = Number.parseFloat(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function summarizeTimerStatistics(rows, maxScopes) {
+	const [firstRow] = rows;
+	if (firstRow === void 0) return {
+		byExclusiveTime: [],
+		byInclusiveTime: [],
+		totalScopeCount: 0,
+		truncated: false
+	};
+	const nameColumn = findColumn(firstRow, "Name", "TimerName");
+	const inclusiveColumn = findColumn(firstRow, "Incl", "TotalInclusiveTime", "InclusiveTime");
+	const exclusiveColumn = findColumn(firstRow, "Excl", "TotalExclusiveTime", "ExclusiveTime");
+	const countColumn = findColumn(firstRow, "Count", "InstanceCount");
+	if (nameColumn === void 0 || inclusiveColumn === void 0 || exclusiveColumn === void 0) return {
+		byExclusiveTime: [],
+		byInclusiveTime: [],
+		totalScopeCount: 0,
+		truncated: false
+	};
+	const scopes = [];
+	for (const row of rows) {
+		const name = row[nameColumn];
+		const inclusive = readNumber(row[inclusiveColumn]);
+		const exclusive = readNumber(row[exclusiveColumn]);
+		if (name === void 0 || name.length === 0 || inclusive === void 0 || exclusive === void 0) continue;
+		const scope = {
+			exclusiveTimeMs: exclusive * SECONDS_TO_MS,
+			inclusiveTimeMs: inclusive * SECONDS_TO_MS,
+			name
+		};
+		const count = countColumn === void 0 ? void 0 : readNumber(row[countColumn]);
+		if (count !== void 0) scope.count = count;
+		scopes.push(scope);
+	}
+	const byInclusiveTime = [...scopes].sort((left, right) => right.inclusiveTimeMs - left.inclusiveTimeMs);
+	return {
+		byExclusiveTime: [...scopes].sort((left, right) => right.exclusiveTimeMs - left.exclusiveTimeMs).slice(0, maxScopes),
+		byInclusiveTime: byInclusiveTime.slice(0, maxScopes),
+		totalScopeCount: scopes.length,
+		truncated: scopes.length > maxScopes
+	};
+}
+function isGpuThread(threadName) {
+	return threadName.toUpperCase().includes("GPU");
+}
+async function summarizeTimingEventStream(lines, options) {
+	let headers;
+	let threadIndex = -1;
+	let timerIndex = -1;
+	let durationIndex = -1;
+	let startIndex = -1;
+	let depthIndex = -1;
+	let cpuTimeMs = 0;
+	let gpuTimeMs = 0;
+	const frameDurationsMs = [];
+	const worstHitches = [];
+	let hitchCount = 0;
+	for await (const rawLine of lines) {
+		const line = rawLine.trim();
+		if (line.length === 0) continue;
+		const values = parseCsvLine(line);
+		if (headers === void 0) {
+			headers = values;
+			const headerRow = Object.fromEntries(headers.map((header) => [header, ""]));
+			threadIndex = columnIndex(headers, findColumn(headerRow, "ThreadName", "Thread", "TrackName"));
+			timerIndex = columnIndex(headers, findColumn(headerRow, "TimerName"));
+			durationIndex = columnIndex(headers, findColumn(headerRow, "Duration", "InclusiveTime"));
+			startIndex = columnIndex(headers, findColumn(headerRow, "StartTime", "Start"));
+			depthIndex = columnIndex(headers, findColumn(headerRow, "Depth"));
+			if (threadIndex < 0 || durationIndex < 0) break;
+			continue;
+		}
+		const duration = readNumber(values[durationIndex]);
+		const threadName = values[threadIndex];
+		if (duration === void 0 || threadName === void 0) continue;
+		if ((depthIndex < 0 ? 0 : readNumber(values[depthIndex]) ?? 0) !== 0) continue;
+		const durationMs = duration * SECONDS_TO_MS;
+		if (isGpuThread(threadName)) {
+			gpuTimeMs += durationMs;
+			continue;
+		}
+		cpuTimeMs += durationMs;
+		if (timerIndex < 0 || !FRAME_ROOT_TIMER_NAMES.has(values[timerIndex] ?? "")) continue;
+		frameDurationsMs.push(durationMs);
+		if (durationMs < options.hitchThresholdMs) continue;
+		hitchCount += 1;
+		retainWorstHitch(worstHitches, options.maxHitches, {
+			durationMs,
+			startTimeMs: (startIndex < 0 ? 0 : readNumber(values[startIndex]) ?? 0) * SECONDS_TO_MS
+		});
+	}
+	return {
+		frames: summarizeFrameDurations(frameDurationsMs, worstHitches, hitchCount, options),
+		threads: {
+			cpuTimeMs,
+			gpuTimeMs
+		}
+	};
+}
+function retainWorstHitch(worstHitches, maxHitches, hitch) {
+	if (worstHitches.length >= maxHitches) {
+		const weakest = worstHitches[worstHitches.length - 1];
+		if (weakest === void 0 || hitch.durationMs <= weakest.durationMs) return;
+		worstHitches.pop();
+	}
+	const insertAt = worstHitches.findIndex((candidate) => hitch.durationMs > candidate.durationMs);
+	worstHitches.splice(insertAt < 0 ? worstHitches.length : insertAt, 0, hitch);
+}
+function columnIndex(headers, header) {
+	return header === void 0 ? -1 : headers.indexOf(header);
+}
+function summarizeFrameDurations(frameDurationsMs, worstHitches, hitchCount, options) {
+	if (frameDurationsMs.length === 0) return {
+		frameCount: 0,
+		hitches: [],
+		hitchesTruncated: false
+	};
+	const sortedDurations = [...frameDurationsMs].sort((left, right) => left - right);
+	return {
+		frameCount: frameDurationsMs.length,
+		hitches: worstHitches,
+		hitchesTruncated: hitchCount > options.maxHitches,
+		percentilesMs: {
+			p50: percentile(sortedDurations, .5),
+			p90: percentile(sortedDurations, .9),
+			p99: percentile(sortedDurations, .99)
+		},
+		worstFrameMs: sortedDurations[sortedDurations.length - 1]
+	};
+}
+function percentile(sortedValues, fraction) {
+	if (sortedValues.length === 0) return 0;
+	return sortedValues[Math.min(sortedValues.length - 1, Math.max(0, Math.ceil(fraction * sortedValues.length) - 1))] ?? 0;
+}
+//#endregion
+//#region src/mcpTools.ts
+const EDITOR_WORK_TIMEOUT_MS = 1e4;
+const WAIT_FOR_JOB_KINDS = [
+	"compile",
+	"create_class",
+	"pie",
+	"test_run"
+];
+const WAIT_FOR_JOB_MAX_TIMEOUT_MS = 6e5;
+const WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS = {
+	compile: 12e4,
+	create_class: 6e4,
+	pie: 3e4,
+	test_run: 3e5
+};
+const WAIT_FOR_JOB_POLL_CADENCE_MS = {
+	compile: {
+		capMs: 2e3,
+		initialMs: 250
+	},
+	create_class: {
+		capMs: 2e3,
+		initialMs: 250
+	},
+	pie: {
+		capMs: 2e3,
+		initialMs: 250
+	},
+	test_run: {
+		capMs: 5e3,
+		initialMs: 1e3
+	}
+};
+const ANALYZE_TRACE_DEFAULT_TIMEOUT_MS = 6e5;
+const ANALYZE_TRACE_DEFAULT_HITCH_THRESHOLD_MS = 33.4;
+const ANALYZE_TRACE_MAX_RESPONSE_BYTES = 32768;
+const BRIDGE_LOOPBACK_HOST = "127.0.0.1";
+const getProjectIdInputSchema = { projectPath: z.string().trim().min(1) };
+const pingProjectInputSchema = { projectId: projectIdSchema };
+const listRegisteredProjectsInputSchema = {
+	maxResults: z.number().int().min(1).max(200).optional().describe(`Maximum registrations to return (1-${String(200)}, default ${String(50)}). Sets truncated when more exist.`),
+	verify: z.boolean().optional().describe("Ping every returned registration once, concurrently, and annotate it with reachable/reason. Costs a bridge round trip per entry; omit for the cheap registry-only listing.")
+};
+const startPieInputSchema = {
+	map: z.string().trim().min(1).max(512).optional().describe("Optional level/map path to load before play (e.g. /Game/Maps/MyLevel)."),
+	mode: z.enum(BRIDGE_PIE_MODES).optional().describe("Play-in-Editor mode: 'selected_viewport', 'new_window' (default), or 'standalone'."),
+	netMode: z.enum(BRIDGE_PIE_NET_MODES).optional().describe("Multiplayer net mode: 'standalone', 'listen_server', 'client', or 'dedicated_server'. Omit for single-player editor defaults."),
+	numClients: z.number().int().min(1).max(16).optional().describe(`Number of client windows to launch (1-${String(16)}). With a server net mode, launches 1 server + N-1 clients.`),
+	projectId: projectIdSchema,
+	runUnderOneProcess: z.boolean().optional().describe("Run all multiplayer instances under a single process instead of separate processes.")
+};
+const getPieStatusInputSchema = {
+	pieSessionId: z.string().trim().min(1).max(512).optional().describe("Optional pieSessionId returned by start_pie; omit to query the editor current PIE session."),
+	projectId: projectIdSchema
+};
+const stopPieInputSchema = {
+	pieSessionId: z.string().trim().min(1).max(512).optional().describe("Optional pieSessionId returned by start_pie; omit to stop the editor current PIE session."),
+	projectId: projectIdSchema
+};
+const listLaunchDevicesInputSchema = { projectId: projectIdSchema };
+const launchOnDeviceInputSchema = {
+	deviceId: z.string().trim().min(1).max(512).describe("Target device id from list_launch_devices (e.g. IOS@MyiPhone, Android@serial)."),
 	map: z.string().trim().min(1).max(512).optional().describe("Optional level/map path to load on the device before play (e.g. /Game/Maps/MyLevel)."),
 	projectId: projectIdSchema
 };
@@ -3106,6 +4156,12 @@ const getTestRunStatusInputSchema = {
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the automation run to poll."),
 	testRunId: z.string().trim().min(1).describe("The testRunId returned by run_automation_tests for the run to poll.")
 };
+const waitForJobInputSchema = {
+	jobId: z.string().trim().min(1).max(512).describe("Job identifier to wait on: compileJobId (compile), createClassJobId (create_class), testRunId (test_run), or pieSessionId (pie)."),
+	kind: z.enum(WAIT_FOR_JOB_KINDS).describe("Which async job the id belongs to. Required — job ids are bare GUIDs and carry no type tag, so the kind cannot be inferred."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the job."),
+	timeoutMs: z.number().int().min(1).optional().describe(`Wall-clock budget for the wait, clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms. Defaults per kind: compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms.`)
+};
 const getEditorStateInputSchema = { projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report its state.") };
 const saveDirtyPackagesInputSchema = {
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should save its changes."),
@@ -3147,6 +4203,45 @@ const cleanBuildInputSchema = {
 	target: targetSchema,
 	timeoutMs: buildTimeoutSchema
 };
+const packageTimeoutSchema = z.number().int().min(1e3).max(MAX_PROCESS_TIMEOUT_MS).optional().describe(`Hard timeout in milliseconds before the cook/package process is killed (default ${String(DEFAULT_PACKAGE_TIMEOUT_MS)}, max ${String(MAX_PROCESS_TIMEOUT_MS)}).`);
+const cookPlatformSchema = z.enum(UNREAL_COOK_TARGET_PLATFORMS).describe("Cook/package target platform (Win64, Mac, Linux, LinuxArm64, Android, IOS, TVOS, VisionOS).");
+const packageForceSchema = z.boolean().default(false).describe("Run even if this project's UnrealEditor is registered and running. Default false refuses, because a second editor process contends for the same Saved/, Intermediate/ and DDC paths.");
+const cookContentInputSchema = {
+	engineVersion: engineVersionSchema,
+	force: packageForceSchema,
+	maps: z.array(z.string().trim().min(1).max(512)).max(64).optional().describe("Explicit maps to cook (e.g. /Game/Maps/MyLevel). Omit to cook everything (-CookAll)."),
+	platform: cookPlatformSchema,
+	projectPath: projectPathSchema,
+	timeoutMs: packageTimeoutSchema
+};
+const packageProjectInputSchema = {
+	archiveDirectory: z.string().trim().min(1).describe("Directory the staged build is archived into (-archivedirectory)."),
+	configuration: configurationSchema,
+	engineVersion: engineVersionSchema,
+	force: packageForceSchema,
+	platform: cookPlatformSchema,
+	projectPath: projectPathSchema,
+	timeoutMs: packageTimeoutSchema
+};
+const runEditorCommandletInputSchema = {
+	args: z.array(z.string().trim().min(1).max(512)).max(64).optional().describe("Commandlet arguments as separate argv entries (never one string to be split). -run= and -Project= are set by the tool and are rejected here."),
+	commandletName: z.string().trim().min(1).max(128).describe("Commandlet class name, identifier characters only (e.g. ResavePackages, FixupRedirects, DataValidation)."),
+	engineVersion: engineVersionSchema,
+	force: packageForceSchema,
+	projectPath: projectPathSchema,
+	timeoutMs: packageTimeoutSchema
+};
+const analyzeTraceInputSchema = {
+	engineVersion: engineVersionSchema,
+	hitchThresholdMs: z.number().min(1).max(1e4).optional().describe(`Frame duration at or above which a frame counts as a hitch (default ${String(ANALYZE_TRACE_DEFAULT_HITCH_THRESHOLD_MS)}ms, about two frames at 60Hz).`),
+	maxHitches: z.number().int().min(1).max(50).optional().describe(`Maximum worst-hitch entries to return (default ${String(10)}, max ${String(50)}).`),
+	maxScopes: z.number().int().min(1).max(100).optional().describe(`Maximum timing scopes to return per ranking (default ${String(20)}, max ${String(100)}).`),
+	projectPath: z.string().trim().min(1).optional().describe("Project whose EngineAssociation selects the analyzer engine. Omit when engineVersion is given."),
+	timeoutMs: z.number().int().min(1e3).max(MAX_PROCESS_TIMEOUT_MS).optional().describe(`Hard timeout in milliseconds for the analyzer run (default ${String(ANALYZE_TRACE_DEFAULT_TIMEOUT_MS)}).`),
+	tracePath: z.string().trim().min(1).describe("Path to the .utrace file produced by stop_insights_trace.")
+};
+const getPackageStatusInputSchema = { packageJobId: z.string().trim().min(1).max(512).describe("packageJobId returned by cook_content, package_project, or run_editor_commandlet.") };
+const cancelPackageJobInputSchema = { packageJobId: z.string().trim().min(1).max(512).describe("packageJobId of the in-flight job to abort.") };
 const runClangTidyInputSchema = {
 	checks: z.string().trim().min(1).optional().describe("clang-tidy --checks expression (e.g. \"-*,bugprone-*\"); omit to use the .clang-tidy config."),
 	compileCommandsDir: z.string().trim().min(1).describe("Directory containing the compile_commands.json produced by the compile-commands sync."),
@@ -3219,6 +4314,313 @@ async function buildTarget(input, dependencies, context = createEngineToolchainC
 		warnings: diagnostics.warnings
 	};
 }
+async function analyzeTrace(input, dependencies, context = createEngineToolchainContext()) {
+	const tracePath = path.resolve(input.tracePath);
+	if (!await context.fileExists(tracePath)) throw new EngineToolchainError(`Trace file not found or unreadable: ${tracePath}`);
+	const engine = await resolveEngineForTrace(input, context);
+	const analyzerPath = await resolveUnrealInsights(engine.engineRoot, context);
+	const hitchThresholdMs = input.hitchThresholdMs ?? 33.4;
+	if (!analyzerPath) return {
+		durationMs: 0,
+		engineVersion: engine.engineVersion,
+		hitchThresholdMs,
+		hitches: [],
+		reason: `UnrealInsights was not found under ${path.join(engine.engineRoot, "Engine", "Binaries")}; the installed UE ${engine.engineVersion} does not ship the trace analyzer for this host.`,
+		state: "unsupported",
+		topScopesByExclusiveTime: [],
+		topScopesByInclusiveTime: [],
+		tracePath,
+		truncated: []
+	};
+	const timeoutMs = input.timeoutMs ?? 6e5;
+	const exportDirectory = await context.createTempDirectory("uemcp-trace-");
+	const timerStatisticsPath = path.join(exportDirectory, "timer-statistics.csv");
+	const timingEventsPath = path.join(exportDirectory, "timing-events.csv");
+	const commandFilePath = path.join(exportDirectory, "export.rsp");
+	try {
+		await context.writeFile(commandFilePath, [`TimingInsights.ExportTimerStatistics ${quoteConsoleArgument(timerStatisticsPath)}`, `TimingInsights.ExportTimingEvents ${quoteConsoleArgument(timingEventsPath)} -columns=ThreadName,TimerName,StartTime,Duration,Depth`].join("\n"));
+		dependencies.logger.info({
+			engineVersion: engine.engineVersion,
+			tracePath
+		}, "Running Unreal Insights trace analysis");
+		const isWindowsHost = context.platform === "win32";
+		const quoteValue = (value) => isWindowsHost ? `"${value}"` : value;
+		const run = await context.runProcess({
+			args: [
+				`-OpenTraceFile=${quoteValue(tracePath)}`,
+				`-ExecOnAnalysisCompleteCmd=${quoteValue(`@=${commandFilePath}`)}`,
+				"-AutoQuit",
+				"-NoUI"
+			],
+			command: analyzerPath,
+			timeoutMs,
+			windowsVerbatimArguments: isWindowsHost
+		});
+		if (run.timedOut) throw new EngineToolchainError(`Unreal Insights did not finish analyzing ${tracePath} within ${String(timeoutMs)}ms; raise timeoutMs or trim the trace.`);
+		if (run.exitCode !== 0) throw new EngineToolchainError(`Unreal Insights exited with code ${String(run.exitCode)} while analyzing ${tracePath}: ${run.combinedOutput.slice(-1e3).trim()}`);
+		const scopeSummaries = summarizeTimerStatistics(await readCsvRows(timerStatisticsPath, context), input.maxScopes ?? 20);
+		const timingEvents = await summarizeTimingEventStream(await context.fileExists(timingEventsPath) ? context.readTextLines(timingEventsPath) : emptyTextLines(), {
+			hitchThresholdMs,
+			maxHitches: input.maxHitches ?? 10
+		});
+		const frames = timingEvents.frames;
+		const threadTimes = timingEvents.threads;
+		const truncated = [];
+		if (scopeSummaries.truncated) truncated.push("topScopes");
+		if (frames.hitchesTruncated) truncated.push("hitches");
+		const result = {
+			analyzerPath,
+			cpuTimeMs: threadTimes.cpuTimeMs,
+			durationMs: run.durationMs,
+			engineVersion: engine.engineVersion,
+			exitCode: run.exitCode,
+			frameCount: frames.frameCount,
+			gpuTimeMs: threadTimes.gpuTimeMs,
+			hitchThresholdMs,
+			hitches: frames.hitches,
+			state: "analyzed",
+			topScopesByExclusiveTime: scopeSummaries.byExclusiveTime,
+			topScopesByInclusiveTime: scopeSummaries.byInclusiveTime,
+			totalScopeCount: scopeSummaries.totalScopeCount,
+			tracePath,
+			truncated
+		};
+		if (frames.percentilesMs) result.framePercentilesMs = frames.percentilesMs;
+		if (frames.worstFrameMs !== void 0) result.worstFrameMs = frames.worstFrameMs;
+		if (frames.frameCount === 0) result.reason = "The trace contains no FEngineLoop::Tick scopes, so frame percentiles and hitches are unavailable; capture with the cpu channel while the engine is ticking.";
+		return boundAnalyzeTraceResult(result);
+	} finally {
+		try {
+			await context.removeDirectory(exportDirectory);
+		} catch (error) {
+			dependencies.logger.warn({
+				error,
+				exportDirectory
+			}, "Failed to remove the Unreal Insights export directory");
+		}
+	}
+}
+async function resolveEngineForTrace(input, context) {
+	if (input.projectPath === void 0) return await resolveEngine({
+		context,
+		engineVersion: input.engineVersion
+	});
+	const { uprojectPath } = await resolveProjectPaths(input.projectPath, context);
+	return await resolveEngine({
+		context,
+		engineVersion: input.engineVersion,
+		uprojectPath
+	});
+}
+function quoteConsoleArgument(value) {
+	return `"${value.replace(/\\/gu, "\\\\")}"`;
+}
+async function* emptyTextLines() {}
+async function readCsvRows(filePath, context) {
+	if (!await context.fileExists(filePath)) return [];
+	return parseCsvRows(await context.readFile(filePath));
+}
+function boundAnalyzeTraceResult(result) {
+	const bounded = {
+		...result,
+		truncated: [...result.truncated]
+	};
+	while (JSON.stringify(bounded).length > ANALYZE_TRACE_MAX_RESPONSE_BYTES) {
+		const longestListLength = Math.max(bounded.topScopesByInclusiveTime.length, bounded.topScopesByExclusiveTime.length, bounded.hitches.length);
+		if (longestListLength <= 1) {
+			addTruncationReason(bounded, "responseBytesExceeded");
+			return bounded;
+		}
+		if (bounded.topScopesByInclusiveTime.length === longestListLength) {
+			bounded.topScopesByInclusiveTime = bounded.topScopesByInclusiveTime.slice(0, longestListLength - 1);
+			bounded.topScopesByExclusiveTime = bounded.topScopesByExclusiveTime.slice(0, longestListLength - 1);
+			addTruncationReason(bounded, "topScopes");
+			continue;
+		}
+		bounded.hitches = bounded.hitches.slice(0, bounded.hitches.length - 1);
+		addTruncationReason(bounded, "hitches");
+	}
+	return bounded;
+}
+function addTruncationReason(result, reason) {
+	if (!result.truncated.includes(reason)) result.truncated.push(reason);
+}
+const COMMANDLET_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
+const ENGINE_CONTROLLED_COMMANDLET_SWITCHES = ["-run=", "-project="];
+const defaultPackageJobRegistry = new PackageJobRegistry();
+function resolvePackageJobRegistry(dependencies) {
+	return dependencies.packageJobRegistry ?? defaultPackageJobRegistry;
+}
+async function cookContent(input, dependencies, context = createEngineToolchainContext()) {
+	if (!input.force) await assertEditorNotRunning(input.projectPath, dependencies);
+	const { uprojectPath } = await resolveProjectPaths(input.projectPath, context);
+	const engine = await resolveEngine({
+		context,
+		engineVersion: input.engineVersion,
+		uprojectPath
+	});
+	const editorCmd = await resolveUnrealEditorCmd(engine.engineRoot, context);
+	const mapArgs = input.maps && input.maps.length > 0 ? [`-Map=${input.maps.join("+")}`] : ["-CookAll"];
+	const args = [
+		uprojectPath,
+		"-run=Cook",
+		`-TargetPlatform=${cookCommandletTargetPlatform(input.platform)}`,
+		...mapArgs,
+		"-Unversioned",
+		"-unattended",
+		"-nopause",
+		"-nosplash",
+		"-stdout"
+	];
+	dependencies.logger.info({
+		engineVersion: engine.engineVersion,
+		platform: input.platform,
+		projectPath: uprojectPath
+	}, "Starting Unreal cook");
+	return toStartPackageJobResult(resolvePackageJobRegistry(dependencies).start({
+		args,
+		command: editorCmd,
+		cwd: engine.engineRoot,
+		kind: "cook",
+		logger: dependencies.logger,
+		platform: input.platform,
+		projectPath: uprojectPath,
+		runProcess: context.runProcess,
+		timeoutMs: input.timeoutMs ?? 54e5
+	}), engine.engineVersion);
+}
+async function packageProject(input, dependencies, context = createEngineToolchainContext()) {
+	if (!input.force) await assertEditorNotRunning(input.projectPath, dependencies);
+	const { uprojectPath } = await resolveProjectPaths(input.projectPath, context);
+	const engine = await resolveEngine({
+		context,
+		engineVersion: input.engineVersion,
+		uprojectPath
+	});
+	const automationTool = await resolveAutomationTool(engine.engineRoot, context);
+	const args = [
+		...automationTool.args,
+		"BuildCookRun",
+		`-project=${uprojectPath}`,
+		"-noP4",
+		"-utf8output",
+		"-nocompileeditor",
+		"-unattended",
+		`-platform=${input.platform}`,
+		`-clientconfig=${input.configuration}`,
+		"-build",
+		"-cook",
+		"-stage",
+		"-pak",
+		"-archive",
+		`-archivedirectory=${path.resolve(input.archiveDirectory)}`
+	];
+	dependencies.logger.info({
+		configuration: input.configuration,
+		engineVersion: engine.engineVersion,
+		platform: input.platform,
+		projectPath: uprojectPath
+	}, "Starting AutomationTool BuildCookRun");
+	return toStartPackageJobResult(resolvePackageJobRegistry(dependencies).start({
+		args,
+		command: automationTool.command,
+		cwd: automationTool.cwd ?? engine.engineRoot,
+		...automationTool.env ? { env: automationTool.env } : {},
+		kind: "package",
+		logger: dependencies.logger,
+		platform: input.platform,
+		projectPath: uprojectPath,
+		runProcess: context.runProcess,
+		timeoutMs: input.timeoutMs ?? 54e5
+	}), engine.engineVersion);
+}
+async function runEditorCommandlet(input, dependencies, context = createEngineToolchainContext()) {
+	assertValidCommandletName(input.commandletName);
+	const commandletArgs = input.args ?? [];
+	for (const argument of commandletArgs) assertCommandletArgumentAllowed(argument);
+	if (!input.force) await assertEditorNotRunning(input.projectPath, dependencies);
+	const { uprojectPath } = await resolveProjectPaths(input.projectPath, context);
+	const engine = await resolveEngine({
+		context,
+		engineVersion: input.engineVersion,
+		uprojectPath
+	});
+	const editorCmd = await resolveUnrealEditorCmd(engine.engineRoot, context);
+	const args = [
+		uprojectPath,
+		`-run=${input.commandletName}`,
+		...commandletArgs,
+		"-unattended",
+		"-nopause",
+		"-nosplash",
+		"-stdout"
+	];
+	dependencies.logger.info({
+		commandletName: input.commandletName,
+		engineVersion: engine.engineVersion,
+		projectPath: uprojectPath
+	}, "Starting Unreal editor commandlet");
+	return toStartPackageJobResult(resolvePackageJobRegistry(dependencies).start({
+		args,
+		command: editorCmd,
+		cwd: engine.engineRoot,
+		kind: "commandlet",
+		logger: dependencies.logger,
+		projectPath: uprojectPath,
+		runProcess: context.runProcess,
+		timeoutMs: input.timeoutMs ?? 54e5
+	}), engine.engineVersion);
+}
+function getPackageStatus(input, dependencies) {
+	const status = resolvePackageJobRegistry(dependencies).get(input.packageJobId);
+	if (status) return status;
+	return {
+		args: [],
+		command: "",
+		diagnosticsTruncated: false,
+		errorCount: 0,
+		errors: [],
+		outputTail: "",
+		outputTruncated: false,
+		packageJobId: input.packageJobId,
+		projectPath: "",
+		startedAt: "",
+		state: "unknown_job",
+		timedOut: false,
+		warningCount: 0,
+		warnings: []
+	};
+}
+function cancelPackageJob(input, dependencies) {
+	const outcome = resolvePackageJobRegistry(dependencies).cancel(input.packageJobId);
+	return {
+		cancelled: outcome.cancelled,
+		packageJobId: input.packageJobId,
+		state: outcome.state
+	};
+}
+function assertValidCommandletName(commandletName) {
+	if (!COMMANDLET_NAME_PATTERN.test(commandletName)) throw new EngineToolchainError(`Commandlet name '${commandletName}' is invalid; use identifier characters only (e.g. ResavePackages).`);
+}
+function assertCommandletArgumentAllowed(argument) {
+	const normalized = argument.toLowerCase();
+	for (const reserved of ENGINE_CONTROLLED_COMMANDLET_SWITCHES) if (normalized.startsWith(reserved)) throw new EngineToolchainError(`Commandlet argument '${argument}' overrides the engine switch ${reserved} that run_editor_commandlet sets itself.`);
+	if (/[\0\r\n]/u.test(argument)) throw new EngineToolchainError("Commandlet arguments cannot contain control characters.");
+}
+function toStartPackageJobResult(status, engineVersion) {
+	const result = {
+		args: status.args,
+		command: status.command,
+		engineVersion,
+		kind: status.kind,
+		packageJobId: status.packageJobId,
+		projectPath: status.projectPath,
+		startedAt: status.startedAt,
+		state: status.state
+	};
+	if (status.platform !== void 0) result.platform = status.platform;
+	return result;
+}
 async function generateProjectFiles(input, dependencies, context = createEngineToolchainContext()) {
 	const { uprojectPath } = await resolveProjectPaths(input.projectPath, context);
 	const engine = await resolveEngine({
@@ -3420,6 +4822,30 @@ const execConsoleCommandInputSchema = {
 	command: z.string().trim().min(1).max(BRIDGE_EXEC_CONSOLE_MAX_COMMAND_CHARS).describe("Console command line to execute, exactly as it would be typed into the editor console (e.g. stat fps)."),
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should execute the console command.")
 };
+const configFileInputSchema = z.enum(BRIDGE_CONFIG_FILES).describe("Which engine ini to read or write: Engine (DefaultEngine.ini), Game, Input, Editor, or EditorPerProjectUserSettings.");
+const configSectionInputSchema = bridgeGetConfigValueRequestSchema.shape.section.describe("Ini section without brackets, e.g. /Script/Engine.RendererSettings or SystemSettings.");
+const configKeyInputSchema = bridgeGetConfigValueRequestSchema.shape.key.describe("Key inside the section.");
+const getConfigValueInputSchema = {
+	file: configFileInputSchema,
+	key: configKeyInputSchema,
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the config."),
+	section: configSectionInputSchema
+};
+const setConfigValueInputSchema = {
+	file: configFileInputSchema,
+	key: configKeyInputSchema,
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should write the config."),
+	scope: z.enum(BRIDGE_CONFIG_WRITE_SCOPES).optional().describe("Where to write: 'project_default' (Config/Default<File>.ini, the default and the checked-in setting) or 'saved_user' (Saved/Config user override)."),
+	section: configSectionInputSchema,
+	value: bridgeSetConfigValueRequestSchema.shape.value.describe("Value to write verbatim. An empty string writes a present-but-empty value, which is distinct from removing the key.")
+};
+const listConfigSectionInputSchema = {
+	cursor: bridgeListConfigSectionRequestSchema.shape.cursor.describe("Offset into the stable-ordered key list (default 0). Pass the previous response nextCursor for the next page."),
+	file: configFileInputSchema,
+	maxResults: bridgeListConfigSectionRequestSchema.shape.maxResults.describe(`Maximum key/value pairs per page (1-${String(200)}, default ${String(100)}).`),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the config."),
+	section: configSectionInputSchema
+};
 const getStatSnapshotInputSchema = { projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should sample its performance counters.") };
 const startInsightsTraceInputSchema = {
 	channels: z.array(z.string().trim().min(1).max(64)).max(32).optional().describe("Unreal Insights channels to record (e.g. cpu, gpu, frame, loadtime). Omit to record the engine's default channel set."),
@@ -3453,6 +4879,40 @@ const findBlueprintReferencesInputSchema = {
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should query its Asset Registry."),
 	referenceKinds: bridgeFindBlueprintReferencesRequestSchema.shape.referenceKinds.describe("Restrict results to 'subclass' and/or 'module_dependency'; omit to return both.")
 };
+const getBlueprintSummaryInputSchema = {
+	blueprintPath: bridgeGetBlueprintSummaryRequestSchema.shape.blueprintPath.describe("Package name or object path of the Blueprint (e.g. /Game/BP/BP_Player or /Game/BP/BP_Player.BP_Player)."),
+	componentCursor: bridgeGetBlueprintSummaryRequestSchema.shape.componentCursor.describe("Offset into the component list (default 0). Pass the previous response nextComponentCursor to fetch the next page."),
+	functionCursor: bridgeGetBlueprintSummaryRequestSchema.shape.functionCursor.describe("Offset into the function/event/macro list (default 0). Pass the previous response nextFunctionCursor to fetch the next page."),
+	graphCursor: bridgeGetBlueprintSummaryRequestSchema.shape.graphCursor.describe("Offset into the graph inventory (default 0). Pass the previous response nextGraphCursor to fetch the next page."),
+	loadIfNeeded: bridgeGetBlueprintSummaryRequestSchema.shape.loadIfNeeded.describe("Load the Blueprint if it is not already in memory (default false). With false, an unloaded asset answers from Asset Registry metadata only — parent class and generated class, with loaded=false and empty member lists."),
+	maxResults: bridgeGetBlueprintSummaryRequestSchema.shape.maxResults.default(25).describe("Maximum entries per list per page (1-200, default 25). The *Count fields stay authoritative."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should read the Blueprint."),
+	variableCursor: bridgeGetBlueprintSummaryRequestSchema.shape.variableCursor.describe("Offset into the variable list (default 0). Pass the previous response nextVariableCursor to fetch the next page.")
+};
+const getBlueprintGraphInputSchema = {
+	blueprintPath: bridgeGetBlueprintGraphRequestSchema.shape.blueprintPath.describe("Package name or object path of the Blueprint that owns the graph."),
+	graphName: bridgeGetBlueprintGraphRequestSchema.shape.graphName.describe("Name of the graph to dump, as reported by get_blueprint_summary (e.g. 'EventGraph', 'UserConstructionScript', a function name)."),
+	loadIfNeeded: bridgeGetBlueprintGraphRequestSchema.shape.loadIfNeeded.describe("Load the Blueprint if it is not already in memory (default false). Graph contents require the asset in memory, so an unloaded Blueprint fails with blueprint_not_loaded unless this is true."),
+	maxNodes: bridgeGetBlueprintGraphRequestSchema.shape.maxNodes.default(25).describe("Maximum nodes to return per page (1-200, default 25). nodeCount still reports the whole graph."),
+	nodeCursor: bridgeGetBlueprintGraphRequestSchema.shape.nodeCursor.describe("Offset into the GUID-ordered node list (default 0). Pass the previous response nextNodeCursor to fetch the next page."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should read the Blueprint.")
+};
+const getBlueprintCompileErrorsInputSchema = {
+	blueprintPaths: bridgeGetBlueprintCompileErrorsRequestSchema.shape.blueprintPaths.describe("Blueprints to report on, as package names or object paths (1-32 entries)."),
+	cursor: bridgeGetBlueprintCompileErrorsRequestSchema.shape.cursor.describe("Offset into the path-ordered result list (default 0). Pass the previous response nextCursor to fetch the next page."),
+	maxResults: bridgeGetBlueprintCompileErrorsRequestSchema.shape.maxResults.default(50).describe("Maximum results to return per page (1-100, default 50)."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report Blueprint status.")
+};
+const compileBlueprintInputSchema = {
+	blueprintPaths: bridgeCompileBlueprintRequestSchema.shape.blueprintPaths.describe("Blueprints to compile, as package names or object paths (1-32 entries). Each is loaded if needed."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should compile the Blueprints.")
+};
+const getBlueprintCompileStatusInputSchema = {
+	compileJobId: bridgeGetBlueprintCompileStatusRequestSchema.shape.compileJobId.describe("Job id returned by compile_blueprint."),
+	cursor: bridgeGetBlueprintCompileStatusRequestSchema.shape.cursor.describe("Offset into the result list (default 0). Pass the previous response nextCursor to fetch the next page."),
+	maxResults: bridgeGetBlueprintCompileStatusRequestSchema.shape.maxResults.default(50).describe("Maximum results to return per page (1-100, default 50)."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the compile job.")
+};
 function registerMcpTools(server, dependencies) {
 	server.registerTool("get_project_id", {
 		description: "Resolve the canonical Unreal ProjectID from a project path by reading Config/DefaultGame.ini.",
@@ -3482,6 +4942,16 @@ function registerMcpTools(server, dependencies) {
 	}, async ({ projectId }) => {
 		return toToolSuccess(await pingProject(projectId, dependencies));
 	});
+	server.registerTool("list_registered_projects", {
+		description: "List every Unreal Editor currently registered with this server (projectId, projectName, projectPath, host, port, pid, registeredAt, lastSeenAt). Call this first to discover which editors are running and which projectId to pass to the other tools. Reads the registry only and performs no network I/O unless verify is true, which pings each entry once and adds reachable/reason. Never evicts a registration — use ping_project for that.",
+		inputSchema: listRegisteredProjectsInputSchema,
+		title: "List Registered Projects"
+	}, async ({ maxResults, verify }) => {
+		return toToolSuccess(await listRegisteredProjects({
+			maxResults,
+			verify
+		}, dependencies));
+	});
 	server.registerTool("trigger_live_compile", {
 		description: "Trigger an Unreal Live Coding recompile of patched modules for a projectId; tail stream_output_log (LogLiveCoding) for build output.",
 		inputSchema: triggerLiveCompileInputSchema,
@@ -3538,6 +5008,48 @@ function registerMcpTools(server, dependencies) {
 	}, async (input) => {
 		return toToolSuccess(await cleanBuild(input, dependencies));
 	});
+	server.registerTool("cook_content", {
+		description: "Start a full offline cook (UnrealEditor-Cmd -run=Cook) for a target platform and return a packageJobId immediately; poll it with get_package_status. Unlike launch_on_device (cook-on-the-fly) this proves the content actually cooks, surfacing missing references, unfixed redirectors and platform shader failures. Runs for minutes to tens of minutes. Refuses while the project editor is running unless force is true. Server-side; no running editor required.",
+		inputSchema: cookContentInputSchema,
+		title: "Cook Content"
+	}, async (input) => {
+		return toToolSuccess(await cookContent(input, dependencies));
+	});
+	server.registerTool("package_project", {
+		description: "Start a full package via RunUAT BuildCookRun (build + cook + stage + pak + archive) for a platform, configuration and archive directory, returning a packageJobId immediately; poll it with get_package_status. Runs for minutes to tens of minutes. Refuses while the project editor is running unless force is true. Server-side; no running editor required.",
+		inputSchema: packageProjectInputSchema,
+		title: "Package Project"
+	}, async (input) => {
+		return toToolSuccess(await packageProject(input, dependencies));
+	});
+	server.registerTool("run_editor_commandlet", {
+		description: "Start an editor commandlet (UnrealEditor-Cmd -run=<name>) with an argv array and return a packageJobId; poll it with get_package_status. Unlocks the maintenance commandlets you reach for after a failed cook — ResavePackages, FixupRedirects, DataValidation. The commandlet name must be identifier characters only and arguments are passed as separate argv entries without a shell; -run= and -Project= are set by the tool and rejected as arguments. A commandlet can modify or delete project assets, so it refuses to run while the project editor is running unless force is true.",
+		inputSchema: runEditorCommandletInputSchema,
+		title: "Run Editor Commandlet"
+	}, async (input) => {
+		return toToolSuccess(await runEditorCommandlet(input, dependencies));
+	});
+	server.registerTool("analyze_trace", {
+		description: "Analyze a completed .utrace (the path stop_insights_trace returns) headlessly with the engine's Unreal Insights analyzer and return a bounded, readable summary: frame-time p50/p90/p99, the worst N hitches with timestamps, a CPU vs GPU time split, and top-N timing scopes by inclusive and exclusive time. Memory and LLM-tag totals are deliberately not reported — they need a separate analysis pass. Resolve the engine with engineVersion or projectPath. Every list is top-N and the response is byte-capped, with truncated naming what was shortened. Returns state 'unsupported' when the installed engine ships no Insights analyzer for this host.",
+		inputSchema: analyzeTraceInputSchema,
+		title: "Analyze Trace"
+	}, async (input) => {
+		return toToolSuccess(await analyzeTrace(input, dependencies));
+	});
+	server.registerTool("get_package_status", {
+		description: "Poll a job started by cook_content, package_project, or run_editor_commandlet. Returns state ('running', 'succeeded', 'failed', 'cancelled', or 'unknown_job' for an unknown/evicted id), structured cook/UAT error and warning diagnostics, truncation flags, exit code, and timing once finished.",
+		inputSchema: getPackageStatusInputSchema,
+		title: "Get Package Status"
+	}, async ({ packageJobId }) => {
+		return toToolSuccess(getPackageStatus({ packageJobId }, dependencies));
+	});
+	server.registerTool("cancel_package_job", {
+		description: "Abort an in-flight cook, package, or commandlet job by its packageJobId. Returns cancelled=true (state cancelled) when a live job was killed, or cancelled=false with the job current state (or unknown_job) otherwise.",
+		inputSchema: cancelPackageJobInputSchema,
+		title: "Cancel Package Job"
+	}, async ({ packageJobId }) => {
+		return toToolSuccess(cancelPackageJob({ packageJobId }, dependencies));
+	});
 	server.registerTool("run_clang_tidy", {
 		description: "Run clang-tidy over a project's synced compile_commands.json and return structured findings (file, line, column, check, severity, message), catching issues before a compile. Report only; does not apply fixes. Server-side; does not require a running editor.",
 		inputSchema: runClangTidyInputSchema,
@@ -3718,6 +5230,18 @@ function registerMcpTools(server, dependencies) {
 			testRunId
 		}, dependencies));
 	});
+	server.registerTool("wait_for_job", {
+		description: `Block server-side until an async job reaches a terminal state, then return the payload its get_*_status tool would have returned under 'status'. Use instead of a poll loop after trigger_live_compile, trigger_hot_reload (kind 'compile'), create_cpp_class ('create_class'), run_automation_tests ('test_run'), or start_pie ('pie'). kind is required — job ids carry no type tag. outcome is 'completed', 'timed_out' (the last observed status is still returned; call again or poll), or 'unknown_job' (unknown/expired/cancelled id, returned immediately). timeoutMs defaults per kind (compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms) and is clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms, so a long automation run may need more than one call. For kind 'test_run' the returned status.results is the first page only — page the rest with get_test_run_status and nextCursor. For kind 'pie' only 'starting' keeps waiting; 'running', 'stopped' and 'none' are all terminal.`,
+		inputSchema: waitForJobInputSchema,
+		title: "Wait For Job"
+	}, async ({ jobId, kind, projectId, timeoutMs }) => {
+		return toToolSuccess(await waitForJob({
+			jobId,
+			kind,
+			projectId,
+			timeoutMs
+		}, dependencies));
+	});
 	server.registerTool("cancel_test_run", {
 		description: "Abort an in-progress Unreal automation run for a project by its testRunId. Returns cancelled=true (state cancelled) when a live run was aborted, or cancelled=false (state not_found) when the run is unknown or already finished.",
 		inputSchema: cancelTestRunInputSchema,
@@ -3745,6 +5269,45 @@ function registerMcpTools(server, dependencies) {
 			projectId
 		}, dependencies));
 	});
+	server.registerTool("get_config_value", {
+		description: "Read one project config value through the running editor's config system, which resolves the full Base*/Default*/Saved hierarchy. Returns the resolved value, the ini it came from, and resolvedFrom ('engine_base', 'project_default', 'saved_user'), and reports present=false for an unset key so an absent value is distinguishable from a present-but-empty one. file is a closed set of known ini names, not a path.",
+		inputSchema: getConfigValueInputSchema,
+		title: "Get Config Value"
+	}, async ({ file, key, projectId, section }) => {
+		return toToolSuccess(await getConfigValue({
+			file,
+			key,
+			projectId,
+			section
+		}, dependencies));
+	});
+	server.registerTool("set_config_value", {
+		description: "Write one project config value through the running editor's config system and flush it to disk, so the ini is normalised the way the engine expects and the live editor picks the change up without a restart. Writes Config/Default<File>.ini by default, or the Saved/Config user override with scope 'saved_user'. Returns the previous value as the editor resolved it across the whole hierarchy, which is not necessarily what the target layer held: if it came from an engine or default layer, writing it back leaves the key materialised in the layer this tool wrote. Requires a registered editor: a raw file write behind a running editor is clobbered when the editor saves its own config.",
+		inputSchema: setConfigValueInputSchema,
+		title: "Set Config Value"
+	}, async ({ file, key, projectId, scope, section, value }) => {
+		return toToolSuccess(await setConfigValue({
+			file,
+			key,
+			projectId,
+			scope,
+			section,
+			value
+		}, dependencies));
+	});
+	server.registerTool("list_config_section", {
+		description: "Dump one config section as key/value pairs as the running editor resolves it. Paged: pass the previous response nextCursor for the next page; totalCount reports the full key count.",
+		inputSchema: listConfigSectionInputSchema,
+		title: "List Config Section"
+	}, async ({ cursor, file, maxResults, projectId, section }) => {
+		return toToolSuccess(await listConfigSection({
+			cursor,
+			file,
+			maxResults,
+			projectId,
+			section
+		}, dependencies));
+	});
 	server.registerTool("get_class_reflection", {
 		description: "Reflect a UCLASS or USTRUCT in a project's running Unreal Editor: parent type, implemented interfaces, class flags, and the declared properties (name, C++ type, UPROPERTY specifiers, metadata) and functions (UFUNCTION specifiers, parameters, metadata). Use it to learn a type's API without reading headers. Properties and functions page independently — pass the previous response nextPropertyCursor/nextFunctionCursor to continue.",
 		inputSchema: getClassReflectionInputSchema,
@@ -3861,6 +5424,70 @@ function registerMcpTools(server, dependencies) {
 			referenceKinds
 		}, dependencies));
 	});
+	server.registerTool("get_blueprint_summary", {
+		description: "Describe what is inside a Blueprint asset: parent class, implemented interfaces, its component hierarchy from the Simple Construction Script, its variables (type, default, category, replication), its functions/events/macros with signatures, and an inventory of its graphs. Use the returned graph names with get_blueprint_graph. By default nothing is loaded — an unloaded Blueprint answers from Asset Registry metadata (parent and generated class only) and reports loaded=false; pass loadIfNeeded to read the full contents. Each list pages independently.",
+		inputSchema: getBlueprintSummaryInputSchema,
+		title: "Get Blueprint Summary"
+	}, async ({ blueprintPath, componentCursor, functionCursor, graphCursor, loadIfNeeded, maxResults, projectId, variableCursor }) => {
+		return toToolSuccess(await getBlueprintSummary({
+			blueprintPath,
+			componentCursor,
+			functionCursor,
+			graphCursor,
+			loadIfNeeded,
+			maxResults,
+			projectId,
+			variableCursor
+		}, dependencies));
+	});
+	server.registerTool("get_blueprint_graph", {
+		description: "Dump one Blueprint graph as nodes and connections: each node reports its title, node class and pins, and each pin reports its name, direction, type, default value and the node/pin ids it links to. Get valid graph names from get_blueprint_summary first. Reading a graph requires the Blueprint in memory, so pass loadIfNeeded for an unloaded asset. Nodes are ordered by their stable GUID and paged via nextNodeCursor.",
+		inputSchema: getBlueprintGraphInputSchema,
+		title: "Get Blueprint Graph"
+	}, async ({ blueprintPath, graphName, loadIfNeeded, maxNodes, nodeCursor, projectId }) => {
+		return toToolSuccess(await getBlueprintGraph({
+			blueprintPath,
+			graphName,
+			loadIfNeeded,
+			maxNodes,
+			nodeCursor,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_blueprint_compile_errors", {
+		description: "Report each Blueprint's compile status (up_to_date, warnings, error, dirty, unknown, not_loaded, not_found) plus the errors and warnings from the last compile this bridge ran, including the node each message was attached to. hasDiagnostics=false means this bridge has not compiled that Blueprint in this editor session, so empty lists do not mean it is clean — run compile_blueprint first to get diagnostics.",
+		inputSchema: getBlueprintCompileErrorsInputSchema,
+		title: "Get Blueprint Compile Errors"
+	}, async ({ blueprintPaths, cursor, maxResults, projectId }) => {
+		return toToolSuccess(await getBlueprintCompileErrors({
+			blueprintPaths,
+			cursor,
+			maxResults,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("compile_blueprint", {
+		description: "Compile one or more Blueprints in the running editor so content breakage is caught after a C++ change that altered a base class or a UFUNCTION signature. Compiling is asynchronous: this returns a compileJobId to poll with get_blueprint_compile_status, which reports the per-Blueprint diagnostics. Blueprints are loaded as needed and their assets are modified in memory — save them with save_dirty_packages if you want the result on disk.",
+		inputSchema: compileBlueprintInputSchema,
+		title: "Compile Blueprint"
+	}, async ({ blueprintPaths, projectId }) => {
+		return toToolSuccess(await compileBlueprint({
+			blueprintPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_blueprint_compile_status", {
+		description: "Poll a compile_blueprint job. Reports 'compiling' while it runs, then 'succeeded' or 'failed' with per-Blueprint errors and warnings (each carrying the node the compiler blamed); 'unknown_job' means the id was never issued or has been evicted.",
+		inputSchema: getBlueprintCompileStatusInputSchema,
+		title: "Get Blueprint Compile Status"
+	}, async ({ compileJobId, cursor, maxResults, projectId }) => {
+		return toToolSuccess(await getBlueprintCompileStatus({
+			compileJobId,
+			cursor,
+			maxResults,
+			projectId
+		}, dependencies));
+	});
 }
 async function findAssets(input, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(input.projectId);
@@ -3946,6 +5573,142 @@ async function findBlueprintReferences(input, dependencies) {
 		truncated: response.truncated
 	};
 }
+async function getBlueprintSummary(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeGetBlueprintSummaryRequest(createBridgeGetBlueprintSummaryRequest(input.blueprintPath, {
+		componentCursor: input.componentCursor,
+		functionCursor: input.functionCursor,
+		graphCursor: input.graphCursor,
+		loadIfNeeded: input.loadIfNeeded,
+		maxResults: input.maxResults,
+		variableCursor: input.variableCursor
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_blueprint_summary failed (${response.error.code}): ${response.error.message}`);
+	return {
+		blueprintName: response.blueprintName,
+		blueprintPath: response.blueprintPath,
+		componentCount: response.componentCount,
+		components: response.components,
+		functionCount: response.functionCount,
+		functions: response.functions,
+		generatedClassPath: response.generatedClassPath,
+		graphCount: response.graphCount,
+		graphs: response.graphs,
+		interfaces: response.interfaces,
+		kind: response.kind,
+		loaded: response.loaded,
+		nextComponentCursor: response.nextComponentCursor,
+		nextFunctionCursor: response.nextFunctionCursor,
+		nextGraphCursor: response.nextGraphCursor,
+		nextVariableCursor: response.nextVariableCursor,
+		parentClass: response.parentClass,
+		parentClassPath: response.parentClassPath,
+		projectId: entry.projectId,
+		scanning: response.scanning,
+		truncated: response.truncated,
+		variableCount: response.variableCount,
+		variables: response.variables
+	};
+}
+async function getBlueprintGraph(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeGetBlueprintGraphRequest(createBridgeGetBlueprintGraphRequest(input.blueprintPath, input.graphName, {
+		loadIfNeeded: input.loadIfNeeded,
+		maxNodes: input.maxNodes,
+		nodeCursor: input.nodeCursor
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_blueprint_graph failed (${response.error.code}): ${response.error.message}`);
+	return {
+		blueprintPath: response.blueprintPath,
+		graphKind: response.graphKind,
+		graphName: response.graphName,
+		nextNodeCursor: response.nextNodeCursor,
+		nodeCount: response.nodeCount,
+		nodes: response.nodes,
+		projectId: entry.projectId,
+		truncated: response.truncated
+	};
+}
+async function getBlueprintCompileErrors(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeGetBlueprintCompileErrorsRequest(createBridgeGetBlueprintCompileErrorsRequest(input.blueprintPaths, {
+		cursor: input.cursor,
+		maxResults: input.maxResults
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_blueprint_compile_errors failed (${response.error.code}): ${response.error.message}`);
+	return {
+		nextCursor: response.nextCursor,
+		projectId: entry.projectId,
+		results: response.results,
+		totalCount: response.totalCount,
+		truncated: response.truncated
+	};
+}
+async function compileBlueprint(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeCompileBlueprintRequest(createBridgeCompileBlueprintRequest(input.blueprintPaths), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge compile_blueprint failed (${response.error.code}): ${response.error.message}`);
+	return {
+		compileJobId: response.compileJobId,
+		message: response.message,
+		projectId: entry.projectId,
+		state: response.state
+	};
+}
+async function getBlueprintCompileStatus(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeGetBlueprintCompileStatusRequest(createBridgeGetBlueprintCompileStatusRequest(input.compileJobId, {
+		cursor: input.cursor,
+		maxResults: input.maxResults
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_blueprint_compile_status failed (${response.error.code}): ${response.error.message}`);
+	return {
+		compileJobId: response.compileJobId,
+		durationMs: response.durationMs,
+		finishedAt: response.finishedAt,
+		nextCursor: response.nextCursor,
+		projectId: entry.projectId,
+		results: response.results,
+		state: response.state,
+		totalCount: response.totalCount,
+		truncated: response.truncated
+	};
+}
 async function getClassReflection(input, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(input.projectId);
 	const entry = dependencies.registry.getProject(normalizedProjectId);
@@ -4234,6 +5997,71 @@ async function pingProject(projectId, dependencies) {
 		registrationRemoved: true
 	};
 }
+async function listRegisteredProjects(input, dependencies) {
+	const maxResults = input.maxResults ?? 50;
+	const entries = dependencies.registry.snapshot().sort(compareRegistryEntries);
+	const page = entries.slice(0, maxResults);
+	const verified = input.verify === true;
+	return {
+		projects: verified ? await verifyRegisteredProjects(page, dependencies) : page.map(toRegisteredProjectSummary),
+		totalCount: entries.length,
+		truncated: entries.length > page.length,
+		verified
+	};
+}
+async function verifyRegisteredProjects(entries, dependencies) {
+	const budgetMs = deriveVerifySweepBudgetMs(dependencies.pingTimeoutMs);
+	let budgetTimer;
+	const budgetExpiry = new Promise((resolve) => {
+		budgetTimer = setTimeout(() => {
+			resolve({
+				alive: false,
+				reason: `Verification budget of ${String(budgetMs)}ms expired before the editor answered.`
+			});
+		}, budgetMs);
+	});
+	try {
+		return await Promise.all(entries.map(async (entry) => {
+			const pingResult = await Promise.race([pingRegistryEntry$1(entry, {
+				logger: dependencies.logger,
+				timeoutMs: dependencies.pingTimeoutMs
+			}), budgetExpiry]);
+			const summary = toRegisteredProjectSummary(entry);
+			if (pingResult.alive) return {
+				...summary,
+				reachable: true
+			};
+			return {
+				...summary,
+				reachable: false,
+				reason: pingResult.reason ?? "Unknown ping failure."
+			};
+		}));
+	} finally {
+		clearTimeout(budgetTimer);
+	}
+}
+function toRegisteredProjectSummary(entry) {
+	return {
+		host: BRIDGE_LOOPBACK_HOST,
+		lastSeenAt: entry.lastSeenAt,
+		pid: entry.pid,
+		port: entry.port,
+		projectId: entry.projectId,
+		projectName: entry.projectName,
+		projectPath: entry.projectPath,
+		registeredAt: entry.registeredAt
+	};
+}
+function compareRegistryEntries(left, right) {
+	if (left.projectName !== right.projectName) return left.projectName < right.projectName ? -1 : 1;
+	if (left.projectPath !== right.projectPath) return left.projectPath < right.projectPath ? -1 : 1;
+	if (left.projectId === right.projectId) return 0;
+	return left.projectId < right.projectId ? -1 : 1;
+}
+function deriveVerifySweepBudgetMs(pingTimeoutMs) {
+	return Math.max(1, Math.round(pingTimeoutMs * 2));
+}
 async function startPie(input, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(input.projectId);
 	const entry = dependencies.registry.getProject(normalizedProjectId);
@@ -4512,6 +6340,92 @@ async function execConsoleCommand(input, dependencies) {
 		truncated: response.truncated
 	};
 }
+async function getConfigValue(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeGetConfigValueRequest(createBridgeGetConfigValueRequest({
+		file: input.file,
+		key: input.key,
+		section: input.section
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_config_value failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		file: response.file,
+		key: response.key,
+		present: response.present,
+		projectId: entry.projectId,
+		resolvedFrom: response.resolvedFrom,
+		section: response.section
+	};
+	if (response.filePath !== void 0) result.filePath = response.filePath;
+	if (response.value !== void 0) result.value = response.value;
+	if (response.valueTruncated === true) result.valueTruncated = true;
+	return result;
+}
+async function setConfigValue(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'. Config writes go through the running editor so the engine normalises the ini and the live editor observes the change; start the editor, or edit the ini by hand.`);
+	const response = await sendBridgeSetConfigValueRequest(createBridgeSetConfigValueRequest({
+		file: input.file,
+		key: input.key,
+		scope: input.scope,
+		section: input.section,
+		value: input.value
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge set_config_value failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		file: response.file,
+		filePath: response.filePath,
+		key: response.key,
+		previousPresent: response.previousPresent,
+		projectId: entry.projectId,
+		scope: response.scope,
+		section: response.section,
+		value: response.value
+	};
+	if (response.previousValue !== void 0) result.previousValue = response.previousValue;
+	if (response.previousValueTruncated === true) result.previousValueTruncated = true;
+	return result;
+}
+async function listConfigSection(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeListConfigSectionRequest(createBridgeListConfigSectionRequest({
+		cursor: input.cursor,
+		file: input.file,
+		maxResults: input.maxResults,
+		section: input.section
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge list_config_section failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		entries: response.entries,
+		file: response.file,
+		projectId: entry.projectId,
+		section: response.section,
+		totalCount: response.totalCount,
+		truncated: response.truncated
+	};
+	if (response.nextCursor !== void 0) result.nextCursor = response.nextCursor;
+	return result;
+}
 async function getStatSnapshot(projectId, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(projectId);
 	const entry = dependencies.registry.getProject(normalizedProjectId);
@@ -4629,6 +6543,98 @@ function buildGetCreateClassStatusResult(response, projectId) {
 	if (response.sourcePath !== void 0) result.sourcePath = response.sourcePath;
 	return result;
 }
+async function waitForJob(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	if (!dependencies.registry.getProject(normalizedProjectId)) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const timeoutMs = clampWaitForJobTimeoutMs(input.kind, input.timeoutMs);
+	const cadence = WAIT_FOR_JOB_POLL_CADENCE_MS[input.kind];
+	const startedAtMs = Date.now();
+	const deadlineMs = startedAtMs + timeoutMs;
+	let delayMs = cadence.initialMs;
+	let pollCount = 0;
+	let lastStatus;
+	let lastTransientError;
+	for (;;) {
+		pollCount += 1;
+		try {
+			const status = await pollJobStatus(input.kind, input.jobId, normalizedProjectId, dependencies);
+			lastStatus = status;
+			lastTransientError = void 0;
+			const progress = classifyJobStatus(input.kind, status);
+			if (progress !== "pending") return {
+				jobId: input.jobId,
+				kind: input.kind,
+				outcome: progress,
+				pollCount,
+				projectId: normalizedProjectId,
+				status,
+				timeoutMs,
+				waitedMs: Date.now() - startedAtMs
+			};
+		} catch (error) {
+			if (!isTransientBridgeError(error)) throw error;
+			lastTransientError = error;
+			dependencies.logger.warn({
+				error,
+				jobId: input.jobId,
+				kind: input.kind,
+				projectId: normalizedProjectId
+			}, "Retrying wait_for_job poll after a transient bridge failure");
+		}
+		const remainingMs = deadlineMs - Date.now();
+		if (remainingMs <= 0) break;
+		await sleep(Math.min(delayMs, remainingMs));
+		delayMs = Math.min(cadence.capMs, delayMs * 2);
+	}
+	if (!lastStatus) throw lastTransientError ?? /* @__PURE__ */ new Error(`wait_for_job could not read the ${input.kind} status of job '${input.jobId}' for projectId '${normalizedProjectId}' before the ${String(timeoutMs)}ms budget expired.`);
+	return {
+		jobId: input.jobId,
+		kind: input.kind,
+		outcome: "timed_out",
+		pollCount,
+		projectId: normalizedProjectId,
+		status: lastStatus,
+		timeoutMs,
+		waitedMs: Date.now() - startedAtMs
+	};
+}
+function clampWaitForJobTimeoutMs(kind, timeoutMs) {
+	return Math.min(timeoutMs ?? WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS[kind], WAIT_FOR_JOB_MAX_TIMEOUT_MS);
+}
+async function pollJobStatus(kind, jobId, projectId, dependencies) {
+	switch (kind) {
+		case "compile": return await getCompileStatus({
+			compileJobId: jobId,
+			projectId
+		}, dependencies);
+		case "create_class": return await getCreateClassStatus({
+			createClassJobId: jobId,
+			projectId
+		}, dependencies);
+		case "pie": return await getPieStatus({
+			pieSessionId: jobId,
+			projectId
+		}, dependencies);
+		case "test_run": return await getTestRunStatus({
+			projectId,
+			testRunId: jobId
+		}, dependencies);
+	}
+}
+function classifyJobStatus(kind, status) {
+	switch (kind) {
+		case "compile": return status.state === "compiling" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
+		case "create_class": return status.state === "creating" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
+		case "pie": return status.state === "starting" ? "pending" : "completed";
+		case "test_run": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_run");
+	}
+}
+function toTerminalOutcome(isUnknownJob) {
+	return isUnknownJob ? "unknown_job" : "completed";
+}
+function isTransientBridgeError(error) {
+	return error instanceof BridgeSocketError && (error.code === "read_timeout" || error.code === "connection_closed");
+}
 async function runQueuedRegistryWrite(dependencies, operation) {
 	return await (dependencies.registryWriteQueue ?? new RegistryWriteQueue()).run(operation);
 }
@@ -4876,7 +6882,7 @@ function isMissingFileError(error) {
 //#endregion
 //#region src/server.ts
 const SERVER_NAME = "ue-mcp-server";
-const SERVER_VERSION = "0.1.0";
+const SERVER_VERSION = "0.3.0";
 const logger = createModuleLogger("bootstrap");
 const enginePingLogger = createModuleLogger("engine-ping");
 const httpApiLogger = createModuleLogger("http-api");