@skillcap/gdh 3.2.3 → 4.1.0

package/node_modules/@gdh/mcp/dist/index.js

@@ -1,3 +1,5 @@
+import fs from "node:fs/promises";
+import path from "node:path";
 import { doctorAuthoringDiagnostics, getAuthoringDiagnosticsStatus, getCurrentAuthoringDiagnostics, readProjectConfig, readWorktreeState, refreshAuthoringDiagnostics, resolveAuthoringStatus, resolveEffectiveTargetPath, resolveTargetGodotDocsVersion, runAuthoringCheck, runTargetPrepare, warmupManagedLsp, } from "@gdh/authoring";
 import { definePackageBoundary, GDH_MCP_MANIFEST_VERSION, presentPublicRuntimeTerms, readGdhUpdateMetaOrNull, resolveGdhProductMetadata, } from "@gdh/core";
 import { fetchOfficialGodotDoc, searchOfficialGodotDocs } from "@gdh/docs";
@@ -185,84 +187,599 @@ const TOOL_MANIFEST = [
         outputContract: "GdhAuthoringLspWarmupResult",
     },
     {
-        name: "run-config.check",
-        summary: "Evaluate whether one run configuration is runnable, blocked, or misconfigured for the bound target.",
+        name: "editor.session.status",
+        summary: "Inspect whether GDH can run Godot-native editor operations for the exact bound target/worktree.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor Bridge session status request.", {
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled. Defaults to auto.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorSessionSummary",
+    },
+    {
+        name: "editor.state",
+        summary: "Read current Godot editor context for the exact target/worktree: project state plus current/open scene and selection when an adopted editor exposes them.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor state request.", {
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled. Use adopt_only when the user asks about the already-open editor.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.scene.tree",
+        summary: "Load one saved scene through Godot editor APIs and return a bounded node tree. Requires scenePath; use editor.state first when you need the active editor scene.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor scene tree request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            maxDepth: {
+                type: "number",
+                description: "Optional positive depth limit for returned children.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.node.inspect",
+        summary: "Inspect one node from a saved scene: node summary plus requested property values or a bounded inspector-style property list.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor node inspection request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            nodePath: {
+                type: "string",
+                description: "Optional node path relative to the scene root. Defaults to root.",
+            },
+            propertyNames: stringArraySchema("Optional exact property names to read from the node."),
+            includePropertyList: {
+                type: "boolean",
+                description: "When true, return bounded property metadata similar to inspector discovery.",
+            },
+            propertyQuery: {
+                type: "string",
+                description: "Optional substring filter for returned property metadata.",
+            },
+            propertyLimit: {
+                type: "number",
+                description: "Optional positive limit for returned property metadata.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.resource.read",
+        summary: "Read requested properties from one Godot resource via editor APIs. Nested arrays/dictionaries are encoded recursively with bounded resource handles.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor resource read request.", {
+            resourcePath: {
+                type: "string",
+                description: "Required res:// resource path, including ::subresource id when needed.",
+            },
+            propertyNames: stringArraySchema("Optional exact property names to read from the resource."),
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["resourcePath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.resource.properties",
+        summary: "Discover bounded property metadata for one Godot resource before choosing propertyNames for editor.resource.read.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor resource property discovery request.", {
+            resourcePath: {
+                type: "string",
+                description: "Required res:// resource path, including ::subresource id when needed.",
+            },
+            propertyQuery: {
+                type: "string",
+                description: "Optional substring filter for returned property metadata.",
+            },
+            propertyLimit: {
+                type: "number",
+                description: "Optional positive limit for returned property metadata.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["resourcePath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.class.search",
+        summary: "Search Godot ClassDB and registered script classes with bounded query controls.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Run-configuration check request.", {
-            runConfigurationId: {
+        inputSchema: defineObjectSchema("Editor class search request.", {
+            query: {
+                type: "string",
+                description: "Optional substring query for class names.",
+            },
+            baseClass: {
+                type: "string",
+                description: "Optional base class filter.",
+            },
+            instantiableOnly: {
+                type: "boolean",
+                description: "When false, include non-instantiable classes. Defaults to true.",
+            },
+            limit: {
+                type: "number",
+                description: "Optional positive result limit.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.class.info",
+        summary: "Return bounded property metadata for one Godot or registered script class.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor class info request.", {
+            className: {
+                type: "string",
+                description: "Required Godot or registered script class name.",
+            },
+            includeInherited: {
+                type: "boolean",
+                description: "When true, include inherited properties. Defaults to true.",
+            },
+            propertyQuery: {
+                type: "string",
+                description: "Optional substring filter for returned property metadata.",
+            },
+            propertyLimit: {
+                type: "number",
+                description: "Optional positive property metadata limit.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["className"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.player.inspect",
+        summary: "Inspect an AnimationPlayer or AnimationMixer node in a saved scene, including libraries, clips, autoplay, and blend metadata.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation player inspection request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.clip.read",
+        summary: "Read one AnimationPlayer clip through Godot APIs, including tracks and optionally bounded keyframe data.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation clip read request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            includeKeys: {
+                type: "boolean",
+                description: "When true, include bounded keyframe data for each returned track.",
+            },
+            keyLimit: {
+                type: "number",
+                description: "Optional positive keyframe limit across each track.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.clip.create",
+        summary: "Create or overwrite one AnimationPlayer clip in an AnimationLibrary through Godot editor APIs.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation clip create request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            length: {
+                type: "number",
+                description: "Optional animation length in seconds. Defaults to 1.0.",
+            },
+            step: {
+                type: "number",
+                description: "Optional animation step in seconds.",
+            },
+            loopMode: {
+                type: ["string", "number"],
+                description: "Optional loop mode: none, linear, pingpong, or a Godot numeric value.",
+            },
+            overwrite: {
+                type: "boolean",
+                description: "When true, replace an existing clip with the same name.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.clip.delete",
+        summary: "Delete one AnimationPlayer clip from an AnimationLibrary through Godot editor APIs.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation clip delete request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.track.add",
+        summary: "Add a typed Animation track to one clip, using Godot track types and a NodePath such as Sprite2D:modulate:a.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation track add request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            trackType: {
+                type: ["string", "number"],
+                description: "Optional Godot Animation track type. Use value, position_3d, rotation_3d, scale_3d, blend_shape, method, bezier, audio, or animation. Defaults to value.",
+            },
+            trackPath: {
+                type: "string",
+                description: "Required Animation track NodePath, relative to the AnimationPlayer root.",
+            },
+            atPosition: {
+                type: "number",
+                description: "Optional zero-based insertion position. Defaults to appending the track.",
+            },
+            interpolation: {
+                type: ["string", "number"],
+                description: "Optional interpolation: nearest, linear, cubic, linear_angle, cubic_angle, or a Godot numeric value.",
+            },
+            updateMode: {
+                type: ["string", "number"],
+                description: "Optional value-track update mode: continuous, discrete, capture, or a Godot numeric value.",
+            },
+            mode: {
+                type: "string",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackPath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        name: "editor.animation.track.remove",
+        summary: "Remove one track from an AnimationPlayer clip by zero-based track index.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Editor animation track remove request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
                 type: "string",
-                description: "Run configuration id to evaluate.",
+                description: "Required animation key inside the selected library.",
             },
-            provider: {
+            trackIndex: {
+                type: "number",
+                description: "Required zero-based track index.",
+            },
+            mode: {
                 type: "string",
-                description: "Optional provider id to force when a run configuration supports multiple providers.",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
             },
-            parameters: stringMapSchema("Optional parameter overrides keyed by parameter id."),
-            enabledFeatures: stringArraySchema("Feature flag ids to force on for this check."),
-            disabledFeatures: stringArraySchema("Feature flag ids to force off for this check."),
-            environment: stringMapSchema("Environment variable overrides keyed by variable name."),
-            liveWorkspace: {
-                type: "boolean",
-                description: "When true, evaluate the run configuration against the live workspace instead of an isolated copy.",
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
             },
-        }, ["runConfigurationId"]),
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackIndex"]),
         outputSchema: outputEnvelopeSchema,
-        outputContract: "GdhRuntimeRecipeCheckResult",
+        outputContract: "GdhEditorOperationResult",
     },
     {
-        name: "run-config.run",
-        summary: "Run one bound-target run configuration and return the structured run result.",
+        name: "editor.animation.keyframe.upsert",
+        summary: "Insert or replace one keyframe on an Animation track. Values use GDH's encoded Variant shape for vectors, colors, resources, and scalars.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Run-configuration execution request.", {
-            runConfigurationId: {
+        inputSchema: defineObjectSchema("Editor animation keyframe upsert request.", {
+            scenePath: {
                 type: "string",
-                description: "Run configuration id to execute.",
+                description: "Required res:// path for the saved scene to load.",
             },
-            provider: {
+            animationPlayerPath: {
                 type: "string",
-                description: "Optional provider id to force when a run configuration supports multiple providers.",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
             },
-            parameters: stringMapSchema("Optional parameter overrides keyed by parameter id."),
-            enabledFeatures: stringArraySchema("Feature flag ids to force on for this run."),
-            disabledFeatures: stringArraySchema("Feature flag ids to force off for this run."),
-            environment: stringMapSchema("Environment variable overrides keyed by variable name."),
-            liveWorkspace: {
-                type: "boolean",
-                description: "When true, execute against the live workspace instead of an isolated copy.",
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
             },
-            renderedScreenshot: {
-                type: "boolean",
-                description: "When true, request one rendered screenshot artifact for this run when the selected runtime path can capture it.",
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            trackIndex: {
+                type: "number",
+                description: "Required zero-based track index.",
+            },
+            time: {
+                type: "number",
+                description: "Required key time in seconds.",
+            },
+            value: {
+                type: ["string", "number", "boolean", "object", "array"],
+                description: "Required key value as a JSON-serializable Godot Variant encoding.",
+                additionalProperties: true,
+            },
+            transition: {
+                type: "number",
+                description: "Optional key transition value. Defaults to 1.0.",
             },
-        }, ["runConfigurationId"]),
-        outputSchema: outputEnvelopeSchema,
-        outputContract: "GdhRuntimeRecipeRunResult",
-    },
-    {
-        name: "editor.session.status",
-        summary: "Inspect whether GDH can run Godot-native editor operations for the exact bound target/worktree.",
-        targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor Bridge session status request.", {
             mode: {
                 type: "string",
-                description: "Optional session mode: auto, headless_only, adopt_only, or disabled. Defaults to auto.",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
             },
             godotEditorBin: {
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }),
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackIndex", "time", "value"]),
         outputSchema: outputEnvelopeSchema,
-        outputContract: "GdhEditorSessionSummary",
+        outputContract: "GdhEditorOperationResult",
     },
     {
-        name: "editor.state",
-        summary: "Read current Godot editor context for the exact target/worktree: project state plus current/open scene and selection when an adopted editor exposes them.",
+        name: "editor.animation.keyframe.delete",
+        summary: "Delete one keyframe from an Animation track by key index or key time.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor state request.", {
+        inputSchema: defineObjectSchema("Editor animation keyframe delete request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationPlayerPath: {
+                type: "string",
+                description: "Required node path to the AnimationPlayer or AnimationMixer.",
+            },
+            libraryName: {
+                type: "string",
+                description: "Optional AnimationLibrary name. Defaults to the global empty-name library.",
+            },
+            animationName: {
+                type: "string",
+                description: "Required animation key inside the selected library.",
+            },
+            trackIndex: {
+                type: "number",
+                description: "Required zero-based track index.",
+            },
+            keyIndex: {
+                type: "number",
+                description: "Optional zero-based key index. Provide keyIndex or time.",
+            },
+            time: {
+                type: "number",
+                description: "Optional key time in seconds. Provide keyIndex or time.",
+            },
             mode: {
                 type: "string",
-                description: "Optional session mode: auto, headless_only, adopt_only, or disabled. Use adopt_only when the user asks about the already-open editor.",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
             },
             timeoutMs: {
                 type: "number",
@@ -272,22 +789,31 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }),
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackIndex"]),
         outputSchema: outputEnvelopeSchema,
         outputContract: "GdhEditorOperationResult",
     },
     {
-        name: "editor.scene.tree",
-        summary: "Load one saved scene through Godot editor APIs and return a bounded node tree. Requires scenePath; use editor.state first when you need the active editor scene.",
+        name: "editor.animation.state_machine.create",
+        summary: "Create an AnimationNodeStateMachine tree_root on an AnimationTree node through Godot editor APIs.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor scene tree request.", {
+        inputSchema: defineObjectSchema("Editor animation state-machine create request.", {
             scenePath: {
                 type: "string",
                 description: "Required res:// path for the saved scene to load.",
             },
-            maxDepth: {
-                type: "number",
-                description: "Optional positive depth limit for returned children.",
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree.",
+            },
+            overwrite: {
+                type: "boolean",
+                description: "When true, replace an existing AnimationNodeStateMachine tree_root.",
+            },
+            properties: {
+                type: "object",
+                description: "Optional properties to set on the AnimationNodeStateMachine resource.",
+                additionalProperties: true,
             },
             mode: {
                 type: "string",
@@ -301,35 +827,22 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }, ["scenePath"]),
+        }, ["scenePath", "animationTreePath"]),
         outputSchema: outputEnvelopeSchema,
         outputContract: "GdhEditorOperationResult",
     },
     {
-        name: "editor.node.inspect",
-        summary: "Inspect one node from a saved scene: node summary plus requested property values or a bounded inspector-style property list.",
+        name: "editor.animation.state_machine.read",
+        summary: "Read an AnimationTree state-machine graph as compact nodes and transitions without automating the editor UI.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor node inspection request.", {
+        inputSchema: defineObjectSchema("Editor animation state-machine graph read request.", {
             scenePath: {
                 type: "string",
                 description: "Required res:// path for the saved scene to load.",
             },
-            nodePath: {
-                type: "string",
-                description: "Optional node path relative to the scene root. Defaults to root.",
-            },
-            propertyNames: stringArraySchema("Optional exact property names to read from the node."),
-            includePropertyList: {
-                type: "boolean",
-                description: "When true, return bounded property metadata similar to inspector discovery.",
-            },
-            propertyQuery: {
+            animationTreePath: {
                 type: "string",
-                description: "Optional substring filter for returned property metadata.",
-            },
-            propertyLimit: {
-                type: "number",
-                description: "Optional positive limit for returned property metadata.",
+                description: "Required node path to the AnimationTree with an AnimationNodeStateMachine tree_root.",
             },
             mode: {
                 type: "string",
@@ -343,20 +856,41 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }, ["scenePath"]),
+        }, ["scenePath", "animationTreePath"]),
         outputSchema: outputEnvelopeSchema,
         outputContract: "GdhEditorOperationResult",
     },
     {
-        name: "editor.resource.read",
-        summary: "Read requested properties from one Godot resource via editor APIs. Nested arrays/dictionaries are encoded recursively with bounded resource handles.",
+        name: "editor.animation.state_machine.node.upsert",
+        summary: "Create or update one node in an AnimationTree state-machine graph without automating the editor UI.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor resource read request.", {
-            resourcePath: {
+        inputSchema: defineObjectSchema("Editor animation state-machine node upsert request.", {
+            scenePath: {
                 type: "string",
-                description: "Required res:// resource path, including ::subresource id when needed.",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree.",
+            },
+            stateName: {
+                type: "string",
+                description: "Required state-machine node name.",
+            },
+            nodeType: {
+                type: "string",
+                description: "Optional AnimationNode type. Defaults to AnimationNodeAnimation.",
+            },
+            position: {
+                type: "object",
+                description: 'Optional graph position encoded as {"$vector2":{"x":0,"y":0}}.',
+                additionalProperties: true,
+            },
+            properties: {
+                type: "object",
+                description: 'Optional properties to set on the AnimationNode, for example {"animation":"idle"}.',
+                additionalProperties: true,
             },
-            propertyNames: stringArraySchema("Optional exact property names to read from the resource."),
             mode: {
                 type: "string",
                 description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
@@ -369,26 +903,26 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }, ["resourcePath"]),
+        }, ["scenePath", "animationTreePath", "stateName"]),
         outputSchema: outputEnvelopeSchema,
         outputContract: "GdhEditorOperationResult",
     },
     {
-        name: "editor.resource.properties",
-        summary: "Discover bounded property metadata for one Godot resource before choosing propertyNames for editor.resource.read.",
+        name: "editor.animation.state_machine.node.delete",
+        summary: "Delete one node from an AnimationTree state-machine graph.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor resource property discovery request.", {
-            resourcePath: {
+        inputSchema: defineObjectSchema("Editor animation state-machine node delete request.", {
+            scenePath: {
                 type: "string",
-                description: "Required res:// resource path, including ::subresource id when needed.",
+                description: "Required res:// path for the saved scene to load.",
             },
-            propertyQuery: {
+            animationTreePath: {
                 type: "string",
-                description: "Optional substring filter for returned property metadata.",
+                description: "Required node path to the AnimationTree.",
             },
-            propertyLimit: {
-                type: "number",
-                description: "Optional positive limit for returned property metadata.",
+            stateName: {
+                type: "string",
+                description: "Required state-machine node name.",
             },
             mode: {
                 type: "string",
@@ -402,30 +936,35 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }, ["resourcePath"]),
+        }, ["scenePath", "animationTreePath", "stateName"]),
         outputSchema: outputEnvelopeSchema,
         outputContract: "GdhEditorOperationResult",
     },
     {
-        name: "editor.class.search",
-        summary: "Search Godot ClassDB and registered script classes with bounded query controls.",
+        name: "editor.animation.state_machine.transition.upsert",
+        summary: "Create or replace one transition in an AnimationTree state-machine graph without automating the editor UI.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor class search request.", {
-            query: {
+        inputSchema: defineObjectSchema("Editor animation state-machine transition upsert request.", {
+            scenePath: {
                 type: "string",
-                description: "Optional substring query for class names.",
+                description: "Required res:// path for the saved scene to load.",
             },
-            baseClass: {
+            animationTreePath: {
                 type: "string",
-                description: "Optional base class filter.",
+                description: "Required node path to the AnimationTree.",
             },
-            instantiableOnly: {
-                type: "boolean",
-                description: "When false, include non-instantiable classes. Defaults to true.",
+            fromState: {
+                type: "string",
+                description: "Required source state name.",
             },
-            limit: {
-                type: "number",
-                description: "Optional positive result limit.",
+            toState: {
+                type: "string",
+                description: "Required target state name.",
+            },
+            properties: {
+                type: "object",
+                description: "Optional properties to set on the transition resource.",
+                additionalProperties: true,
             },
             mode: {
                 type: "string",
@@ -439,30 +978,30 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }),
+        }, ["scenePath", "animationTreePath", "fromState", "toState"]),
         outputSchema: outputEnvelopeSchema,
         outputContract: "GdhEditorOperationResult",
     },
     {
-        name: "editor.class.info",
-        summary: "Return bounded property metadata for one Godot or registered script class.",
+        name: "editor.animation.state_machine.transition.delete",
+        summary: "Delete one transition from an AnimationTree state-machine graph.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor class info request.", {
-            className: {
+        inputSchema: defineObjectSchema("Editor animation state-machine transition delete request.", {
+            scenePath: {
                 type: "string",
-                description: "Required Godot or registered script class name.",
+                description: "Required res:// path for the saved scene to load.",
             },
-            includeInherited: {
-                type: "boolean",
-                description: "When true, include inherited properties. Defaults to true.",
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree.",
             },
-            propertyQuery: {
+            fromState: {
                 type: "string",
-                description: "Optional substring filter for returned property metadata.",
+                description: "Required source state name.",
             },
-            propertyLimit: {
-                type: "number",
-                description: "Optional positive property metadata limit.",
+            toState: {
+                type: "string",
+                description: "Required target state name.",
             },
             mode: {
                 type: "string",
@@ -476,13 +1015,13 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }, ["className"]),
+        }, ["scenePath", "animationTreePath", "fromState", "toState"]),
         outputSchema: outputEnvelopeSchema,
         outputContract: "GdhEditorOperationResult",
     },
     {
         name: "editor.operation.run",
-        summary: "Advanced escape hatch for one targeted Godot-native editor operation. Prefer focused editor.* tools for normal reads. Payloads dispatch on operation.kind, not type.",
+        summary: "Advanced escape hatch for one targeted Godot-native editor operation. Prefer focused editor.* tools for normal reads and common writes. Payloads dispatch on operation.kind, not type.",
         targetPathPolicy: "optional",
         inputSchema: defineObjectSchema("Editor Bridge operation request.", {
             operation: {
@@ -516,69 +1055,15 @@ const TOOL_MANIFEST = [
         stringArraySchema,
         stringMapSchema,
     }),
-    {
-        name: "verify.run",
-        summary: "Execute one verification scenario over a run configuration and return the structured run record.",
-        targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Runtime verification execution request.", {
-            runConfigurationId: {
-                type: "string",
-                description: "Run configuration id to execute.",
-            },
-            verificationScenarioId: {
-                type: "string",
-                description: "Verification scenario id to run over the selected run configuration.",
-            },
-            provider: {
-                type: "string",
-                description: "Optional provider id to force when a run configuration supports multiple providers.",
-            },
-            parameters: stringMapSchema("Optional parameter overrides keyed by parameter id."),
-            enabledFeatures: stringArraySchema("Feature flag ids to force on for this verification run."),
-            disabledFeatures: stringArraySchema("Feature flag ids to force off for this verification run."),
-            environment: stringMapSchema("Environment variable overrides keyed by variable name."),
-            liveWorkspace: {
-                type: "boolean",
-                description: "When true, execute against the live workspace instead of an isolated copy.",
-            },
-            renderedScreenshot: {
-                type: "boolean",
-                description: "When true, request one rendered screenshot artifact for this verification run when the selected runtime path can capture it.",
-            },
-        }, ["runConfigurationId", "verificationScenarioId"]),
-        outputSchema: outputEnvelopeSchema,
-        outputContract: "GdhRuntimeRunBundle",
-    },
 ];
 const RESOURCE_MANIFEST = [
     {
-        name: "run-configurations",
-        summary: "Read the discovered run configurations for the bound target as structured JSON.",
-        mimeType: "application/json",
-        uri: "gdh://run-configurations",
-        uriTemplate: null,
-    },
-    {
-        name: "run-configuration",
-        summary: "Read one run configuration for the bound target by id as structured JSON.",
-        mimeType: "application/json",
-        uri: null,
-        uriTemplate: "gdh://run-configurations/{id}",
-    },
-    {
-        name: "verification-scenarios",
-        summary: "Read the discovered verification scenarios for the bound target as structured JSON.",
-        mimeType: "application/json",
-        uri: "gdh://verification-scenarios",
+        name: "run-game-knowledge",
+        summary: "Read project-owned guidance for how agents should run this Godot target.",
+        mimeType: "text/markdown",
+        uri: "gdh://runtime-knowledge/run-game",
         uriTemplate: null,
     },
-    {
-        name: "verification-scenario",
-        summary: "Read one verification scenario for the bound target by id as structured JSON.",
-        mimeType: "application/json",
-        uri: null,
-        uriTemplate: "gdh://verification-scenarios/{id}",
-    },
 ];
 export function listMcpTools() {
     return TOOL_MANIFEST;
@@ -757,10 +1242,6 @@ async function invokeMcpToolWithContext(request, context) {
                 return succeeded(request.toolName, targetPath, await invokeAuthoringDiagnosticsDoctorTool(targetPath));
             case "authoring.warmup":
                 return succeeded(request.toolName, targetPath, await invokeAuthoringWarmupTool(targetPath, request.input));
-            case "run-config.check":
-                return succeeded(request.toolName, targetPath, await invokeRunConfigCheckTool(targetPath, request.input));
-            case "run-config.run":
-                return succeeded(request.toolName, targetPath, await invokeRunConfigRunTool(targetPath, request.input));
             case "editor.session.status":
                 return succeeded(request.toolName, targetPath, await invokeEditorSessionStatusTool(targetPath, request.input));
             case "editor.state":
@@ -807,19 +1288,139 @@ async function invokeMcpToolWithContext(request, context) {
                     propertyQuery: readOptionalString(request.input["propertyQuery"], "propertyQuery"),
                     propertyLimit: readOptionalPositiveInteger(request.input["propertyLimit"], "propertyLimit"),
                 })));
+            case "editor.animation.player.inspect":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.player.inspect", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                })));
+            case "editor.animation.clip.read":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.clip.read", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    includeKeys: readOptionalBoolean(request.input["includeKeys"], "includeKeys"),
+                    keyLimit: readOptionalPositiveInteger(request.input["keyLimit"], "keyLimit"),
+                })));
+            case "editor.animation.clip.create":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.clip.create", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    length: readOptionalNumber(request.input["length"], "length"),
+                    step: readOptionalNumber(request.input["step"], "step"),
+                    loopMode: readOptionalStringOrNumber(request.input["loopMode"], "loopMode"),
+                    overwrite: readOptionalBoolean(request.input["overwrite"], "overwrite"),
+                })));
+            case "editor.animation.clip.delete":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.clip.delete", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                })));
+            case "editor.animation.track.add":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.track.add", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    trackType: readOptionalStringOrNumber(request.input["trackType"], "trackType") ?? "value",
+                    trackPath: requireString(request.input["trackPath"], "trackPath"),
+                    atPosition: readOptionalNumber(request.input["atPosition"], "atPosition"),
+                    interpolation: readOptionalStringOrNumber(request.input["interpolation"], "interpolation"),
+                    updateMode: readOptionalStringOrNumber(request.input["updateMode"], "updateMode"),
+                })));
+            case "editor.animation.track.remove":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.track.remove", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    trackIndex: requireNumber(request.input["trackIndex"], "trackIndex"),
+                })));
+            case "editor.animation.keyframe.upsert":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.keyframe.upsert", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    trackIndex: requireNumber(request.input["trackIndex"], "trackIndex"),
+                    time: requireNumber(request.input["time"], "time"),
+                    value: requireJsonValue(request.input["value"], "value"),
+                    transition: readOptionalNumber(request.input["transition"], "transition"),
+                })));
+            case "editor.animation.keyframe.delete":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.keyframe.delete", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationPlayerPath: requireString(request.input["animationPlayerPath"], "animationPlayerPath"),
+                    libraryName: readOptionalString(request.input["libraryName"], "libraryName"),
+                    animationName: requireString(request.input["animationName"], "animationName"),
+                    trackIndex: requireNumber(request.input["trackIndex"], "trackIndex"),
+                    keyIndex: readOptionalNumber(request.input["keyIndex"], "keyIndex"),
+                    time: readOptionalNumber(request.input["time"], "time"),
+                })));
+            case "editor.animation.state_machine.create":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.create", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    overwrite: readOptionalBoolean(request.input["overwrite"], "overwrite"),
+                    properties: request.input["properties"] === undefined
+                        ? undefined
+                        : requireObject(request.input["properties"], "properties"),
+                })));
+            case "editor.animation.state_machine.read":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.read", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                })));
+            case "editor.animation.state_machine.node.upsert":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.node.upsert", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    stateName: requireString(request.input["stateName"], "stateName"),
+                    nodeType: readOptionalString(request.input["nodeType"], "nodeType"),
+                    position: request.input["position"] === undefined
+                        ? undefined
+                        : requireJsonValue(request.input["position"], "position"),
+                    properties: request.input["properties"] === undefined
+                        ? undefined
+                        : requireObject(request.input["properties"], "properties"),
+                })));
+            case "editor.animation.state_machine.node.delete":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.node.delete", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    stateName: requireString(request.input["stateName"], "stateName"),
+                })));
+            case "editor.animation.state_machine.transition.upsert":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.transition.upsert", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    fromState: requireString(request.input["fromState"], "fromState"),
+                    toState: requireString(request.input["toState"], "toState"),
+                    properties: request.input["properties"] === undefined
+                        ? undefined
+                        : requireObject(request.input["properties"], "properties"),
+                })));
+            case "editor.animation.state_machine.transition.delete":
+                return succeeded(request.toolName, targetPath, await invokeFocusedEditorOperationTool(targetPath, request.input, createEditorOperation("animation.state_machine.transition.delete", {
+                    scenePath: requireString(request.input["scenePath"], "scenePath"),
+                    animationTreePath: requireString(request.input["animationTreePath"], "animationTreePath"),
+                    fromState: requireString(request.input["fromState"], "fromState"),
+                    toState: requireString(request.input["toState"], "toState"),
+                })));
             case "editor.operation.run":
                 return succeeded(request.toolName, targetPath, await invokeEditorOperationRunTool(targetPath, request.input));
-            case "bridge.session.start":
-                return succeeded(request.toolName, targetPath, await invokeBridgeTool(request.toolName, targetPath, request.input, context));
             case "bridge.entry.list":
                 return succeeded(request.toolName, targetPath, await invokeBridgeTool(request.toolName, targetPath, request.input, context));
             case "bridge.entry.invoke":
                 return succeeded(request.toolName, targetPath, await invokeBridgeTool(request.toolName, targetPath, request.input, context));
             case "bridge.session.stop":
                 return succeeded(request.toolName, targetPath, await invokeBridgeTool(request.toolName, targetPath, request.input, context));
-            case "verify.run":
-                return succeeded(request.toolName, targetPath, await invokeVerifyRunTool(targetPath, request.input));
         }
+        return failed(request.toolName, targetPath, `Unknown GDH MCP tool: ${request.toolName}`);
     }
     catch (error) {
         return failed(request.toolName, targetPath, formatMcpError(error));
@@ -833,75 +1434,26 @@ async function resolveMcpTargetPath(targetPath) {
 }
 async function listMcpResources(targetPath) {
     const effectiveTargetPath = await resolveMcpTargetPath(targetPath);
-    const projectConfig = await readProjectConfig(effectiveTargetPath);
-    const [runConfigurations, verificationScenarios] = await Promise.all([
-        listRuntimeRecipes({ targetPath: effectiveTargetPath, projectConfig }),
-        listRuntimeScenarios({ targetPath: effectiveTargetPath }),
-    ]);
-    const resources = [
-        {
-            uri: "gdh://run-configurations",
-            name: "run-configurations",
-            description: "Discovered run configurations for the bound target.",
-            mimeType: "application/json",
-        },
+    void effectiveTargetPath;
+    return [
         {
-            uri: "gdh://verification-scenarios",
-            name: "verification-scenarios",
-            description: "Discovered verification scenarios for the bound target.",
-            mimeType: "application/json",
+            uri: "gdh://runtime-knowledge/run-game",
+            name: "run-game-knowledge",
+            description: "Project-owned guidance for how agents should run this Godot target.",
+            mimeType: "text/markdown",
         },
     ];
-    for (const runConfiguration of runConfigurations.recipes) {
-        resources.push({
-            uri: buildRunConfigurationUri(runConfiguration.id),
-            name: `run-configuration:${runConfiguration.id}`,
-            description: `Run configuration "${runConfiguration.id}" for the bound target.`,
-            mimeType: "application/json",
-        });
-    }
-    for (const verificationScenario of verificationScenarios.scenarios) {
-        resources.push({
-            uri: buildVerificationScenarioUri(verificationScenario.id),
-            name: `verification-scenario:${verificationScenario.id}`,
-            description: `Verification scenario "${verificationScenario.id}" for the bound target.`,
-            mimeType: "application/json",
-        });
-    }
-    return resources;
 }
 async function readMcpResource(targetPath, uri) {
     const effectiveTargetPath = await resolveMcpTargetPath(targetPath);
-    const projectConfig = await readProjectConfig(effectiveTargetPath);
-    if (uri === "gdh://run-configurations") {
-        return presentPublicRuntimeTerms(await listRuntimeRecipes({ targetPath: effectiveTargetPath, projectConfig }));
-    }
-    if (uri === "gdh://verification-scenarios") {
-        return presentPublicRuntimeTerms(await listRuntimeScenarios({ targetPath: effectiveTargetPath }));
-    }
-    const runConfigurationId = parseResourceId(uri, "gdh://run-configurations/");
-    if (runConfigurationId !== null) {
-        return presentPublicRuntimeTerms(await showRuntimeRecipe({
-            targetPath: effectiveTargetPath,
-            projectConfig,
-            recipeId: runConfigurationId,
-        }));
-    }
-    const verificationScenarioId = parseResourceId(uri, "gdh://verification-scenarios/");
-    if (verificationScenarioId !== null) {
-        return presentPublicRuntimeTerms(await showRuntimeScenario({
-            targetPath: effectiveTargetPath,
-            scenarioId: verificationScenarioId,
-        }));
+    if (uri === "gdh://runtime-knowledge/run-game") {
+        const projectConfig = await readProjectConfig(effectiveTargetPath);
+        const knowledgePath = projectConfig?.runtimeKnowledge.path ?? ".gdh/runtime-knowledge";
+        const runGamePath = path.join(effectiveTargetPath, knowledgePath, "run-game.md");
+        return await fs.readFile(runGamePath, "utf8");
     }
     throw new Error(`Unknown GDH MCP resource: ${uri}`);
 }
-function buildRunConfigurationUri(runConfigurationId) {
-    return `gdh://run-configurations/${encodeURIComponent(runConfigurationId)}`;
-}
-function buildVerificationScenarioUri(verificationScenarioId) {
-    return `gdh://verification-scenarios/${encodeURIComponent(verificationScenarioId)}`;
-}
 function parseResourceId(uri, prefix) {
     if (!uri.startsWith(prefix)) {
         return null;
@@ -1245,6 +1797,15 @@ function readOptionalString(value, fieldName) {
     }
     return value;
 }
+function readOptionalStringOrNumber(value, fieldName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(`MCP input field "${fieldName}" must be a string or number.`);
+    }
+    return value;
+}
 function readOptionalEditorSessionMode(value, fieldName) {
     const mode = readOptionalString(value, fieldName);
     if (mode === null || mode === "auto")
@@ -1264,6 +1825,28 @@ function requireString(value, fieldName) {
     }
     return stringValue;
 }
+function readOptionalNumber(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number") {
+        throw new Error(`MCP input field "${fieldName}" must be a number.`);
+    }
+    return value;
+}
+function requireNumber(value, fieldName) {
+    const numberValue = readOptionalNumber(value, fieldName);
+    if (numberValue === undefined) {
+        throw new Error(`MCP input field "${fieldName}" is required.`);
+    }
+    return numberValue;
+}
+function requireJsonValue(value, fieldName) {
+    if (value === undefined) {
+        throw new Error(`MCP input field "${fieldName}" is required.`);
+    }
+    return value;
+}
 function requireObject(value, fieldName) {
     if (value === undefined) {
         throw new Error(`MCP input field "${fieldName}" is required.`);