@uemcp/server 0.1.0 → 0.4.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 #!/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 { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
@@ -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 = () => {
@@ -1954,6 +2429,13 @@ var RegistryWriteQueue = class {
 function createHttpApi(options) {
 	const app = Fastify({ logger: false });
 	const registryWriteQueue = options.registryWriteQueue ?? new RegistryWriteQueue();
+	const notifyRegistryChanged = () => {
+		try {
+			options.onRegistryChanged?.();
+		} catch (error) {
+			options.logger.warn({ error }, "Failed to notify listeners that the registry changed");
+		}
+	};
 	app.setErrorHandler((error, _request, reply) => {
 		if (error instanceof HttpError) {
 			reply.code(error.statusCode).send({
@@ -2038,6 +2520,7 @@ function createHttpApi(options) {
 			projectName: entry.projectName,
 			projectPath: entry.projectPath
 		}, "Upserted Unreal Editor project registration");
+		notifyRegistryChanged();
 		return {
 			projectId: entry.projectId,
 			stored: true
@@ -2068,6 +2551,7 @@ function createHttpApi(options) {
 			existed,
 			projectId
 		}, "Removed Unreal Editor project registration");
+		if (existed) notifyRegistryChanged();
 		return {
 			projectId,
 			removed: true
@@ -2497,73 +2981,6 @@ function isLogLevel(value) {
 	return value === "fatal" || value === "error" || value === "warn" || value === "info" || value === "debug" || value === "trace" || value === "silent";
 }
 //#endregion
-//#region src/buildDiagnostics.ts
-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;
-function diagnosticKey(diagnostic) {
-	return `${diagnostic.file ?? ""}|${diagnostic.line ?? ""}|${diagnostic.message}`;
-}
-function parseBuildDiagnostics(output) {
-	const errors = [];
-	const warnings = [];
-	const seenErrors = /* @__PURE__ */ new Set();
-	const seenWarnings = /* @__PURE__ */ new Set();
-	for (const rawLine of output.split(/\r?\n/u)) {
-		const line = rawLine.trim();
-		if (line.length === 0) continue;
-		const match = CLANG_DIAGNOSTIC_PATTERN.exec(line) ?? MSVC_DIAGNOSTIC_PATTERN.exec(line);
-		if (!match?.groups) continue;
-		const groups = match.groups;
-		const { file, line: lineText, message, severity } = groups;
-		if (file === void 0 || lineText === void 0 || message === void 0 || severity === void 0) continue;
-		const code = typeof groups.code === "string" ? `${groups.code}: ` : "";
-		const diagnostic = {
-			file,
-			line: Number.parseInt(lineText, 10),
-			message: `${code}${message}`.trim()
-		};
-		const isError = severity === "error" || severity === "fatal error";
-		const target = isError ? errors : warnings;
-		const seen = isError ? seenErrors : seenWarnings;
-		const key = diagnosticKey(diagnostic);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		target.push(diagnostic);
-	}
-	return {
-		errorCount: errors.length,
-		errors,
-		warningCount: warnings.length,
-		warnings
-	};
-}
-function parseClangTidyFindings(output) {
-	const findings = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const rawLine of output.split(/\r?\n/u)) {
-		const match = CLANG_TIDY_PATTERN.exec(rawLine.trim());
-		if (!match?.groups) continue;
-		const groups = match.groups;
-		const { file, line, message } = groups;
-		if (file === void 0 || line === void 0 || message === void 0) continue;
-		const severity = groups.severity === "error" ? "error" : "warning";
-		const finding = {
-			check: groups.check ?? "unknown",
-			file,
-			line: Number.parseInt(line, 10),
-			message: message.trim(),
-			severity
-		};
-		if (typeof groups.column === "string") finding.column = Number.parseInt(groups.column, 10);
-		const key = `${finding.file}|${finding.line}|${finding.column ?? ""}|${finding.check}|${finding.message}`;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		findings.push(finding);
-	}
-	return findings;
-}
-//#endregion
 //#region src/engineToolchain.ts
 const UNREAL_BUILD_CONFIGURATIONS = [
 	"Debug",
@@ -2577,8 +2994,24 @@ 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;
+const ENGINE_INSTALL_DIRECTORY_PATTERN = /^UE_(\d+(?:\.\d+)*)$/u;
 async function defaultFileExists(filePath) {
 	try {
 		await access(filePath);
@@ -2593,6 +3026,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 +3086,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 +3100,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 +3123,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 +3147,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,20 +3213,67 @@ 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) {
-	if (context.platform === "win32") {
-		const ubtExe = path.join(engineRoot, "Engine", "Binaries", "DotNET", "UnrealBuildTool", "UnrealBuildTool.exe");
-		if (!await context.fileExists(ubtExe)) throw new EngineToolchainError(`UnrealBuildTool.exe not found at ${ubtExe}`);
+async function listEngineInstalls(context) {
+	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).");
+	let entries;
+	try {
+		entries = await context.listDirectory(ueInstallsDir);
+	} catch (error) {
+		throw new EngineToolchainError(`Failed to read UE_INSTALLS_DIR ${ueInstallsDir}: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : void 0 });
+	}
+	const installs = [];
+	for (const entry of entries) {
+		const engineVersion = ENGINE_INSTALL_DIRECTORY_PATTERN.exec(entry)?.[1];
+		if (engineVersion === void 0) continue;
+		const engineRoot = path.join(ueInstallsDir, entry);
+		installs.push({
+			engineRoot,
+			engineVersion,
+			unrealBuildToolResolved: await isUnrealBuildToolResolvable(engineRoot, context)
+		});
+	}
+	return installs.sort((left, right) => compareEngineVersions(left.engineVersion, right.engineVersion));
+}
+async function isUnrealBuildToolResolvable(engineRoot, context) {
+	try {
+		await resolveUnrealBuildTool(engineRoot, context);
+		return true;
+	} catch (error) {
+		if (error instanceof EngineToolchainError) return false;
+		throw error;
+	}
+}
+function compareEngineVersions(left, right) {
+	const leftSegments = left.split(".");
+	const rightSegments = right.split(".");
+	const segmentCount = Math.max(leftSegments.length, rightSegments.length);
+	for (let index = 0; index < segmentCount; index += 1) {
+		const difference = Number(leftSegments[index] ?? 0) - Number(rightSegments[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+async function resolveUnrealBuildTool(engineRoot, context) {
+	if (context.platform === "win32") {
+		const ubtExe = path.join(engineRoot, "Engine", "Binaries", "DotNET", "UnrealBuildTool", "UnrealBuildTool.exe");
+		if (!await context.fileExists(ubtExe)) throw new EngineToolchainError(`UnrealBuildTool.exe not found at ${ubtExe}`);
 		return {
 			args: [],
 			command: ubtExe
@@ -2771,8 +3287,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 +3368,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;
 	}
 }
@@ -2799,6 +3380,425 @@ function buildUnrealBuildToolInvocation(engine, extraArgs) {
 		command: engine.unrealBuildTool.command
 	};
 }
+const RESOURCE_MIME_TYPE = "application/json";
+const REGISTRY_RESOURCE_URI = "uemcp://registry";
+const REGISTRY_PROJECT_RESOURCE_URI_TEMPLATE = "uemcp://registry/{projectId}";
+const ENGINES_RESOURCE_URI = "uemcp://engines";
+const WORKSPACE_PROJECT_RESOURCE_URI = "uemcp://workspace/project";
+function readRegistryResource(dependencies) {
+	const entries = dependencies.registry.snapshot();
+	return clampResourceList(entries, (visibleEntries, truncated) => ({
+		entries: visibleEntries,
+		totalCount: entries.length,
+		truncated
+	}));
+}
+function readRegistryProjectResource(projectId, dependencies) {
+	const parsedProjectId = projectIdSchema.safeParse(projectId);
+	if (!parsedProjectId.success) return {
+		entry: null,
+		found: false,
+		projectId,
+		reason: "The requested projectId is not a canonical 32-character Unreal ProjectID.",
+		truncated: false
+	};
+	const entry = dependencies.registry.getProject(parsedProjectId.data);
+	if (!entry) return {
+		entry: null,
+		found: false,
+		projectId: parsedProjectId.data,
+		reason: "No Unreal Editor is registered with this server for that projectId.",
+		truncated: false
+	};
+	return clampResourcePayload({
+		entry,
+		found: true,
+		projectId: entry.projectId,
+		truncated: false
+	}, () => ({
+		entry: null,
+		found: true,
+		projectId: parsedProjectId.data,
+		reason: "The registry entry exceeded the resource payload budget.",
+		truncated: true
+	}));
+}
+async function readEnginesResource(dependencies) {
+	const context = dependencies.engineToolchainContext ?? createEngineToolchainContext();
+	const installsDirectory = context.env.UE_INSTALLS_DIR?.trim() ?? null;
+	let engineInstalls;
+	try {
+		engineInstalls = await listEngineInstalls(context);
+	} catch (error) {
+		if (!(error instanceof EngineToolchainError)) throw error;
+		dependencies.logger.warn({ error }, "Failed to enumerate installed Unreal engines for the engines resource");
+		return {
+			engineInstalls: [],
+			installsDirectory: installsDirectory && installsDirectory.length > 0 ? installsDirectory : null,
+			reason: error.message,
+			totalCount: 0,
+			truncated: false
+		};
+	}
+	return clampResourceList(engineInstalls, (visibleInstalls, truncated) => ({
+		engineInstalls: visibleInstalls,
+		installsDirectory: installsDirectory && installsDirectory.length > 0 ? installsDirectory : null,
+		totalCount: engineInstalls.length,
+		truncated
+	}));
+}
+async function readWorkspaceProjectResource(dependencies) {
+	const workingDirectory = dependencies.workingDirectory ?? process.cwd();
+	try {
+		const resolved = await dependencies.projectIdResolver.resolveProjectIdFromProjectPath(workingDirectory);
+		return clampResourcePayload({
+			configPath: resolved.configPath,
+			projectId: resolved.projectId,
+			projectPath: resolved.projectPath,
+			resolved: true,
+			truncated: false,
+			workingDirectory
+		}, () => ({
+			reason: "The resolved workspace project exceeded the resource payload budget.",
+			resolved: false,
+			truncated: true,
+			workingDirectory
+		}));
+	} catch (error) {
+		if (!(error instanceof ProjectIdResolutionError)) throw error;
+		return {
+			configPath: error.filePath,
+			reason: error.reason,
+			resolved: false,
+			truncated: false,
+			workingDirectory
+		};
+	}
+}
+function registerMcpResources(server, dependencies) {
+	server.registerResource("registry", REGISTRY_RESOURCE_URI, {
+		description: "Every Unreal Editor currently registered with this server, straight from the in-memory registry. Attach this instead of calling list_registered_projects when you only need to know which editors are live and which projectId to pass to the tools. Reads no files and never contacts an editor.",
+		mimeType: RESOURCE_MIME_TYPE,
+		title: "Registered Unreal Editors"
+	}, (uri) => buildResourceContents(uri, readRegistryResource(dependencies)));
+	server.registerResource("registry-project", new ResourceTemplate(REGISTRY_PROJECT_RESOURCE_URI_TEMPLATE, {
+		complete: { projectId: (value) => completeRegisteredProjectId(value, dependencies) },
+		list: () => listRegistryProjectResources(dependencies)
+	}), {
+		description: "The registration for a single Unreal Editor, addressed by canonical 32-character ProjectID. Reports found: false with a reason rather than failing when the projectId is unknown or malformed.",
+		mimeType: RESOURCE_MIME_TYPE,
+		title: "Registered Unreal Editor"
+	}, (uri, variables) => buildResourceContents(uri, readRegistryProjectResource(readTemplateVariable(variables.projectId), dependencies)));
+	server.registerResource("engines", ENGINES_RESOURCE_URI, {
+		description: "Unreal Engine installs discovered under UE_INSTALLS_DIR, each with its version, engine root, and whether UnrealBuildTool resolved inside it. Source builds and GUID engine associations are excluded because the build tools cannot resolve them either.",
+		mimeType: RESOURCE_MIME_TYPE,
+		title: "Installed Unreal Engines"
+	}, async (uri) => buildResourceContents(uri, await readEnginesResource(dependencies)));
+	server.registerResource("workspace-project", WORKSPACE_PROJECT_RESOURCE_URI, {
+		description: "The Unreal project identity of the server's working directory, resolved from Config/DefaultGame.ini. Reports resolved: false with a reason when the working directory is not an Unreal project.",
+		mimeType: RESOURCE_MIME_TYPE,
+		title: "Workspace Unreal Project"
+	}, async (uri) => buildResourceContents(uri, await readWorkspaceProjectResource(dependencies)));
+}
+function listRegistryProjectResources(dependencies) {
+	return { resources: dependencies.registry.snapshot().map((entry) => ({
+		description: `Registration for ${entry.projectName} at ${entry.projectPath}`,
+		mimeType: RESOURCE_MIME_TYPE,
+		name: entry.projectId,
+		title: entry.projectName,
+		uri: buildRegistryProjectUri(entry.projectId)
+	})) };
+}
+function completeRegisteredProjectId(value, dependencies) {
+	const prefix = value.trim().toLowerCase();
+	return dependencies.registry.snapshot().map((entry) => entry.projectId).filter((projectId) => projectId.startsWith(prefix));
+}
+function buildRegistryProjectUri(projectId) {
+	return `${REGISTRY_RESOURCE_URI}/${projectId}`;
+}
+function buildResourceContents(uri, payload) {
+	return { contents: [{
+		mimeType: RESOURCE_MIME_TYPE,
+		text: serializeResourcePayload(payload),
+		uri: uri.href
+	}] };
+}
+function readTemplateVariable(value) {
+	if (Array.isArray(value)) return value[0] ?? "";
+	return value ?? "";
+}
+function clampResourceList(items, build) {
+	const fullPayload = build(items, false);
+	if (measureResourcePayloadBytes(fullPayload) <= 65536) return fullPayload;
+	let smallestRejected = items.length;
+	let largestAccepted = 0;
+	while (largestAccepted + 1 < smallestRejected) {
+		const candidateCount = Math.floor((largestAccepted + smallestRejected) / 2);
+		if (measureResourcePayloadBytes(build(items.slice(0, candidateCount), true)) <= 65536) {
+			largestAccepted = candidateCount;
+			continue;
+		}
+		smallestRejected = candidateCount;
+	}
+	return build(items.slice(0, largestAccepted), true);
+}
+function clampResourcePayload(payload, buildMinimal) {
+	if (measureResourcePayloadBytes(payload) <= 65536) return payload;
+	return buildMinimal();
+}
+function measureResourcePayloadBytes(payload) {
+	return Buffer$1.byteLength(serializeResourcePayload(payload), "utf8");
+}
+function serializeResourcePayload(payload) {
+	return JSON.stringify(payload, null, 2);
+}
+//#endregion
+//#region src/mcpPrompts.ts
+const projectIdPromptArgument = projectIdSchema.describe("Canonical 32-character Unreal ProjectID of the target editor. Read uemcp://registry to find one.");
+const diagnoseCrashPromptArgs = { projectId: projectIdPromptArgument };
+const diagnoseBridgeDisconnectPromptArgs = { projectPath: z.string().trim().min(1).optional().describe("Filesystem path of the Unreal project directory or .uproject, when it is known.") };
+const smokeTestBridgePromptArgs = { projectId: projectIdPromptArgument };
+const addGameplayFeaturePromptArgs = {
+	className: bridgeCreateCppClassRequestSchema.shape.className.describe("Name of the C++ class to create, without the type prefix (for example PatrolComponent)."),
+	moduleName: bridgeCreateCppClassRequestSchema.shape.moduleName.describe("Target module for the new class. Omitted means the project’s primary game module."),
+	parentClass: bridgeCreateCppClassRequestSchema.shape.parentClass.describe("Parent class to derive from (for example Actor, ActorComponent, or a project class)."),
+	projectId: projectIdPromptArgument
+};
+function buildDiagnoseCrashPrompt(args) {
+	return buildPromptResult("Investigate the most recent Unreal Editor crash for a registered project.", [
+		`Investigate the most recent crash for Unreal project ${args.projectId}.`,
+		"",
+		"Work in this order and stop as soon as the cause is established:",
+		`1. Read ${buildRegistryProjectUri(args.projectId)}, then call ping_project. A registration that is present but unreachable is the signature of a crash: deregistration only runs on a clean shutdown, so a killed process leaves its entry behind. An absent entry proves nothing on its own — the editor may never have registered, or a prior health check may already have evicted it.`,
+		"2. Call get_crash_callstack for the project. Read the newest record first. Note the crash type, the assert or exception text, and the topmost project frames — engine frames below them are usually the victim, not the cause.",
+		"3. Call get_editor_state to see what the editor was doing (PIE state, loaded level, current selection). A crash during PIE and a crash while idle have different suspects.",
+		"4. Call stream_output_log with maxEvents around 50 and minVerbosity of warning. The first call establishes the subscription and returns no events; call it again with the returned cursor to drain. Look for the warnings immediately preceding the crash.",
+		"5. If the callstack names a Blueprint, call get_blueprint_compile_errors for it; if it names a C++ symbol, call get_compile_status to check whether the running binary matches the current source.",
+		"",
+		"Report the crash type, the failing frame, the evidence that supports it, and the smallest change that would address it. Say so plainly if the callstack is inconclusive rather than guessing."
+	].join("\n"));
+}
+function buildDiagnoseBridgeDisconnectPrompt(args) {
+	const projectPathStep = args.projectPath ? `2. Call get_project_id with projectPath ${args.projectPath} to get the canonical ProjectID, then compare it to the registry entries from step 1. A mismatch means the editor and this server are reading different Config/DefaultGame.ini files.` : "2. Ask for the project path if you need one, then call get_project_id with it and compare the result to the registry entries from step 1. A mismatch means the editor and this server are reading different Config/DefaultGame.ini files.";
+	return buildPromptResult("Diagnose why this server cannot reach a running Unreal Editor over the MCPBridge.", [
+		"The MCP server cannot reach a running Unreal Editor. Find which leg of the connection is broken before changing anything.",
+		"",
+		"The two processes meet in two places: the editor registers itself over this server’s HTTP API, and this server opens a TCP bridge socket to the port the editor recorded in that registration.",
+		"",
+		`1. Read ${REGISTRY_RESOURCE_URI}. No entry at all means registration never landed or was evicted. An entry with a stale lastSeenAt means registration landed but health checks are failing.`,
+		projectPathStep,
+		"3. Call ping_project with the registered projectId. reachable: false with registrationRemoved: true means the editor’s TCP listener is gone — the editor died, or the plugin lost its port. Note that this call evicts a stale registration, so read the registry resource before calling it, not after.",
+		"4. If the registration looks healthy but one specific tool fails, call stream_output_log and drain with the returned cursor. Plugin-side faults are logged under the LogMCPBridgeRuntime category: failures resolving the ProjectID, failures binding the bridge socket, and rejected registrations all name themselves there.",
+		"",
+		"Common causes, in rough order of likelihood: the editor was closed or crashed and the registration is stale; the editor is open on a different project than the one being asked about; the project directory was copied, so two directories share one ProjectID and fight over one registration; the plugin is pointed at a different server address.",
+		"",
+		"Report which leg is broken and the single smallest action that fixes it. Do not propose code changes until the diagnosis is complete — this failure is usually configuration, not a bug."
+	].join("\n"));
+}
+function buildSmokeTestBridgePrompt(args) {
+	return buildPromptResult("Prove the MCPBridge works end to end for a registered project.", [
+		`Verify the MCPBridge is healthy for Unreal project ${args.projectId}. This is green-path verification, not fault diagnosis.`,
+		"",
+		`1. Read ${buildRegistryProjectUri(args.projectId)}. Expect a registration whose lastSeenAt is recent and whose port is in the 7000-7100 range.`,
+		"2. Call ping_project. Expect reachable: true, registrationRemoved: false, and attemptsUsed: 1.",
+		"3. Call get_editor_state. Expect the loaded level and PIE state of the editor actually open in front of the user.",
+		"4. Exercise log streaming, which is the one path that covers subscribe, emit, drain, and unsubscribe together:",
+		"   a. Call stream_output_log with categoryAllow of [\"LogTemp\"], textContains of \"smoke-bridge-output\", and maxEvents of 10. The first call returns an empty events array and a cursor. That is correct — the subscription has nothing buffered yet.",
+		"   b. Call exec_console_command with the command: log LogTemp Warning smoke-bridge-output ping",
+		"   c. Call stream_output_log again with the same arguments plus the cursor from step 4a. Expect at least one event whose message contains smoke-bridge-output, and a nextCursor that has advanced.",
+		"",
+		"Report each step as pass or fail with the value that proves it. If any step fails, stop and say which one — the diagnose_bridge_disconnect prompt takes it from there. Treat an empty first drain as expected, never as a failure."
+	].join("\n"));
+}
+function buildAddGameplayFeaturePrompt(args) {
+	const moduleClause = args.moduleName ? ` in module ${args.moduleName}` : "";
+	return buildPromptResult("Add a C++ gameplay class to a live Unreal project and take it through compile and test.", [
+		`Add a C++ class ${args.className} deriving from ${args.parentClass}${moduleClause} to Unreal project ${args.projectId}, then get it compiling and tested.`,
+		"",
+		"Every step here is asynchronous. Each start returns a job id; do not assume success from the start call alone.",
+		"",
+		`1. Call create_cpp_class with className ${args.className}, parentClass ${args.parentClass}${args.moduleName ? `, moduleName ${args.moduleName}` : ""}. It returns a createClassJobId immediately.`,
+		"2. Wait for it with wait_for_job using kind create_class, or poll get_create_class_status. Do not edit the generated files until it reports completion — the editor is still writing them.",
+		"3. Read the generated header and source, then write the actual implementation. A generated class compiles but does nothing.",
+		"4. Call trigger_live_compile, then wait_for_job with kind compile. On failure, read the diagnostics from get_compile_status, fix the source, and compile again. Do not proceed past a failing compile.",
+		"5. Call list_automation_tests to find the tests covering this area, then run_automation_tests, then wait_for_job with kind test_run. Report which tests ran and which failed.",
+		"6. Call save_dirty_packages once the work is done so nothing is left unsaved in the editor.",
+		"",
+		"If the project has no automation tests covering the new class, say so rather than reporting the step as passed."
+	].join("\n"));
+}
+function registerMcpPrompts(server) {
+	server.registerPrompt("diagnose_crash", {
+		argsSchema: diagnoseCrashPromptArgs,
+		description: "Walk the most recent Unreal Editor crash for a project back to its cause using the crash callstack, editor state, and output log.",
+		title: "Diagnose Unreal Crash"
+	}, (args) => buildDiagnoseCrashPrompt(args));
+	server.registerPrompt("diagnose_bridge_disconnect", {
+		argsSchema: diagnoseBridgeDisconnectPromptArgs,
+		description: "Find which leg of the MCPBridge is broken when this server cannot reach a running Unreal Editor — missing registration, ProjectID mismatch, dead listener, or a plugin-side failure.",
+		title: "Diagnose Bridge Disconnect"
+	}, (args) => buildDiagnoseBridgeDisconnectPrompt(args));
+	server.registerPrompt("smoke_test_bridge", {
+		argsSchema: smokeTestBridgePromptArgs,
+		description: "Prove the MCPBridge round-trips end to end for a project: registration, ping, editor state, and a full log subscribe-emit-drain cycle.",
+		title: "Smoke-Test the Bridge"
+	}, (args) => buildSmokeTestBridgePrompt(args));
+	server.registerPrompt("add_gameplay_feature", {
+		argsSchema: addGameplayFeaturePromptArgs,
+		description: "Add a C++ gameplay class to a live Unreal project and drive it through class creation, implementation, live compile, and automation tests.",
+		title: "Add Gameplay Feature"
+	}, (args) => buildAddGameplayFeaturePrompt(args));
+}
+function buildPromptResult(description, text) {
+	return {
+		description,
+		messages: [{
+			content: {
+				text,
+				type: "text"
+			},
+			role: "user"
+		}]
+	};
+}
+//#endregion
+//#region src/buildDiagnostics.ts
+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 = [];
+	const seenErrors = /* @__PURE__ */ new Set();
+	const seenWarnings = /* @__PURE__ */ new Set();
+	for (const rawLine of output.split(/\r?\n/u)) {
+		const line = rawLine.trim();
+		if (line.length === 0) continue;
+		const match = CLANG_DIAGNOSTIC_PATTERN.exec(line) ?? MSVC_DIAGNOSTIC_PATTERN.exec(line);
+		if (!match?.groups) continue;
+		const groups = match.groups;
+		const { file, line: lineText, message, severity } = groups;
+		if (file === void 0 || lineText === void 0 || message === void 0 || severity === void 0) continue;
+		const code = typeof groups.code === "string" ? `${groups.code}: ` : "";
+		const diagnostic = {
+			file,
+			line: Number.parseInt(lineText, 10),
+			message: `${code}${message}`.trim()
+		};
+		const isError = severity === "error" || severity === "fatal error";
+		const target = isError ? errors : warnings;
+		const seen = isError ? seenErrors : seenWarnings;
+		const key = diagnosticKey(diagnostic);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		target.push(diagnostic);
+	}
+	return {
+		errorCount: errors.length,
+		errors,
+		warningCount: warnings.length,
+		warnings
+	};
+}
+function parseClangTidyFindings(output) {
+	const findings = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const rawLine of output.split(/\r?\n/u)) {
+		const match = CLANG_TIDY_PATTERN.exec(rawLine.trim());
+		if (!match?.groups) continue;
+		const groups = match.groups;
+		const { file, line, message } = groups;
+		if (file === void 0 || line === void 0 || message === void 0) continue;
+		const severity = groups.severity === "error" ? "error" : "warning";
+		const finding = {
+			check: groups.check ?? "unknown",
+			file,
+			line: Number.parseInt(line, 10),
+			message: message.trim(),
+			severity
+		};
+		if (typeof groups.column === "string") finding.column = Number.parseInt(groups.column, 10);
+		const key = `${finding.file}|${finding.line}|${finding.column ?? ""}|${finding.check}|${finding.message}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		findings.push(finding);
+	}
+	return findings;
+}
 //#endregion
 //#region src/moduleScaffold.ts
 const MODULE_DESCRIPTOR_TYPES = [
@@ -3013,11 +4013,393 @@ function isPlainObject(value) {
 function getErrorCode(error) {
 	if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
 }
+const PACKAGE_JOB_MAX_OUTPUT_BYTES = 2097152;
+var PackageJobCapacityError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PackageJobCapacityError";
+	}
+};
+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);
+		}
+	}
+};
+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'."),
@@ -3106,6 +4488,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 +4535,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 +4646,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 +5154,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 +5211,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 +5274,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 +5340,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 +5562,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 +5601,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 +5756,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 +5905,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 +6329,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 +6672,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 +6875,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 +7214,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.4.0";
 const logger = createModuleLogger("bootstrap");
 const enginePingLogger = createModuleLogger("engine-ping");
 const httpApiLogger = createModuleLogger("http-api");
@@ -4895,8 +7233,12 @@ async function startServer(options) {
 		readTimeoutMs: options.config.startupPingTimeoutMs
 	});
 	await pruneRegistryEntries(registry, store, options.config);
+	let notifyRegistryChanged = () => {};
 	const httpApi = createHttpApi({
 		logger: httpApiLogger,
+		onRegistryChanged: () => {
+			notifyRegistryChanged();
+		},
 		projectIdResolver,
 		registry,
 		registryWriteQueue,
@@ -4909,7 +7251,7 @@ async function startServer(options) {
 	const listeningHttpPort = getListeningHttpPort(httpApi, options.config.httpPort);
 	let mcpServer;
 	try {
-		mcpServer = createMcpServer({
+		const createdMcpServer = createMcpServer({
 			logger: mcpToolLogger,
 			logSessionManager,
 			pingTimeoutMs: options.config.startupPingTimeoutMs,
@@ -4918,6 +7260,10 @@ async function startServer(options) {
 			registryWriteQueue,
 			store
 		});
+		mcpServer = createdMcpServer;
+		notifyRegistryChanged = () => {
+			createdMcpServer.sendResourceListChanged();
+		};
 		if (options.connectMcpTransport !== false) await mcpServer.connect(new StdioServerTransport());
 	} catch (error) {
 		try {
@@ -4971,8 +7317,14 @@ function createMcpServer(dependencies) {
 	const server = new McpServer({
 		name: SERVER_NAME,
 		version: SERVER_VERSION
-	}, { capabilities: { tools: {} } });
+	}, { capabilities: {
+		prompts: {},
+		resources: {},
+		tools: {}
+	} });
 	registerMcpTools(server, dependencies);
+	registerMcpResources(server, dependencies);
+	registerMcpPrompts(server);
 	return server;
 }
 async function pruneRegistryEntries(registry, store, config) {