@skillcap/gdh 4.0.0 → 4.2.0

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

@@ -1,6 +1,6 @@
 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 { doctorAuthoringDiagnostics, getAuthoringDiagnosticsStatus, getCurrentAuthoringDiagnostics, getAuthoringDocumentSymbols, getAuthoringSymbolDeclaration, getAuthoringSymbolDefinition, getAuthoringSymbolHover, getAuthoringSymbolReferences, getAuthoringSymbolStatus, 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";
 import { inspectEditorBridgeSession, runEditorOperation, } from "@gdh/editor";
@@ -66,6 +66,25 @@ const outputEnvelopeSchema = defineObjectSchema("Common MCP invocation envelope
         description: "Failure message when the invocation state is failed, or an empty string otherwise.",
     },
 }, ["manifestVersion", "toolName", "targetPath", "state", "error"]);
+function positionSymbolProperties() {
+    return {
+        filePath: {
+            type: "string",
+            description: "Target-relative, project-relative, or absolute .gd file path.",
+        },
+        line: {
+            type: "number",
+            description: "1-based source line.",
+        },
+        column: {
+            type: "number",
+            description: "1-based source column.",
+        },
+    };
+}
+function definePositionSymbolSchema(description) {
+    return defineObjectSchema(description, positionSymbolProperties(), ["filePath", "line", "column"]);
+}
 const TOOL_MANIFEST = [
     {
         name: "docs.search",
@@ -112,7 +131,7 @@ const TOOL_MANIFEST = [
         inputSchema: defineObjectSchema("Target-preparation request.", {
             sourceTargetPath: {
                 type: "string",
-                description: "Optional source target path to use when hydrating reusable .godot generated state.",
+                description: "Optional source target path to use when hydrating reusable .godot generated state; secondary git worktree checkouts infer the main checkout automatically when available.",
             },
             refreshImports: {
                 type: "boolean",
@@ -184,33 +203,612 @@ const TOOL_MANIFEST = [
         targetPathPolicy: "optional",
         inputSchema: emptyObjectSchema,
         outputSchema: outputEnvelopeSchema,
-        outputContract: "GdhAuthoringLspWarmupResult",
+        outputContract: "GdhAuthoringLspWarmupResult",
+    },
+    {
+        name: "authoring.symbols.status",
+        summary: "Report managed Godot LSP symbol-navigation health and advertised capabilities. Workspace-wide symbols are reported explicitly as unsupported when Godot does not advertise workspaceSymbolProvider.",
+        targetPathPolicy: "optional",
+        inputSchema: emptyObjectSchema,
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhAuthoringSymbolStatusResult",
+    },
+    {
+        name: "authoring.symbols.document",
+        summary: "Open the current .gd file text through the managed Godot LSP and return normalized document symbols. Results are on-demand and not persisted.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("Document-symbol request.", {
+            filePath: {
+                type: "string",
+                description: "Target-relative, project-relative, or absolute .gd file path.",
+            },
+        }, ["filePath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhAuthoringDocumentSymbolsResult",
+    },
+    {
+        name: "authoring.symbols.definition",
+        summary: "Open the current .gd file text through the managed Godot LSP and return normalized go-to-definition locations for a 1-based position.",
+        targetPathPolicy: "optional",
+        inputSchema: definePositionSymbolSchema("Definition request."),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhAuthoringSymbolLocationsResult",
+    },
+    {
+        name: "authoring.symbols.declaration",
+        summary: "Open the current .gd file text through the managed Godot LSP and return normalized go-to-declaration locations for a 1-based position.",
+        targetPathPolicy: "optional",
+        inputSchema: definePositionSymbolSchema("Declaration request."),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhAuthoringSymbolLocationsResult",
+    },
+    {
+        name: "authoring.symbols.references",
+        summary: "Open the current .gd file text through the managed Godot LSP and return normalized references for a 1-based position. Other-file results are Godot workspace/cache-derived.",
+        targetPathPolicy: "optional",
+        inputSchema: defineObjectSchema("References request.", {
+            ...positionSymbolProperties(),
+            includeDeclaration: {
+                type: "boolean",
+                description: "Whether to include the symbol declaration in references. Defaults to true.",
+            },
+        }, ["filePath", "line", "column"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhAuthoringSymbolLocationsResult",
+    },
+    {
+        name: "authoring.symbols.hover",
+        summary: "Open the current .gd file text through the managed Godot LSP and return hover information for a 1-based position.",
+        targetPathPolicy: "optional",
+        inputSchema: definePositionSymbolSchema("Hover request."),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhAuthoringSymbolHoverResult",
+    },
+    {
+        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("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.session.status",
-        summary: "Inspect whether GDH can run Godot-native editor operations for the exact bound target/worktree.",
+        name: "editor.animation.track.remove",
+        summary: "Remove one track from an AnimationPlayer clip by zero-based track index.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor Bridge session status request.", {
+        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: "Required animation key inside the selected library.",
+            },
+            trackIndex: {
+                type: "number",
+                description: "Required zero-based track index.",
+            },
             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"]),
         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.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("Editor state request.", {
+        inputSchema: defineObjectSchema("Editor animation keyframe upsert 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.",
+            },
+            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.",
+            },
             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",
@@ -220,22 +818,42 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }),
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackIndex", "time", "value"]),
         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.keyframe.delete",
+        summary: "Delete one keyframe from an Animation track by key index or key time.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor scene tree request.", {
+        inputSchema: defineObjectSchema("Editor animation keyframe delete request.", {
             scenePath: {
                 type: "string",
                 description: "Required res:// path for the saved scene to load.",
             },
-            maxDepth: {
+            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: "Optional positive depth limit for returned children.",
+                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",
@@ -249,35 +867,60 @@ const TOOL_MANIFEST = [
                 type: "string",
                 description: "Optional Godot editor executable override for this invocation.",
             },
-        }, ["scenePath"]),
+        }, ["scenePath", "animationPlayerPath", "animationName", "trackIndex"]),
         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.create",
+        summary: "Create an AnimationNodeStateMachine tree_root on an AnimationTree node through Godot editor APIs.",
         targetPathPolicy: "optional",
-        inputSchema: defineObjectSchema("Editor node inspection request.", {
+        inputSchema: defineObjectSchema("Editor animation state-machine create request.", {
             scenePath: {
                 type: "string",
                 description: "Required res:// path for the saved scene to load.",
             },
-            nodePath: {
+            animationTreePath: {
                 type: "string",
-                description: "Optional node path relative to the scene root. Defaults to root.",
+                description: "Required node path to the AnimationTree.",
             },
-            propertyNames: stringArraySchema("Optional exact property names to read from the node."),
-            includePropertyList: {
+            overwrite: {
                 type: "boolean",
-                description: "When true, return bounded property metadata similar to inspector discovery.",
+                description: "When true, replace an existing AnimationNodeStateMachine tree_root.",
             },
-            propertyQuery: {
+            properties: {
+                type: "object",
+                description: "Optional properties to set on the AnimationNodeStateMachine resource.",
+                additionalProperties: true,
+            },
+            mode: {
                 type: "string",
-                description: "Optional substring filter for returned property metadata.",
+                description: "Optional session mode: auto, headless_only, adopt_only, or disabled.",
             },
-            propertyLimit: {
+            timeoutMs: {
                 type: "number",
-                description: "Optional positive limit for returned property metadata.",
+                description: "Optional positive timeout in milliseconds for the editor operation.",
+            },
+            godotEditorBin: {
+                type: "string",
+                description: "Optional Godot editor executable override for this invocation.",
+            },
+        }, ["scenePath", "animationTreePath"]),
+        outputSchema: outputEnvelopeSchema,
+        outputContract: "GdhEditorOperationResult",
+    },
+    {
+        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 animation state-machine graph read request.", {
+            scenePath: {
+                type: "string",
+                description: "Required res:// path for the saved scene to load.",
+            },
+            animationTreePath: {
+                type: "string",
+                description: "Required node path to the AnimationTree with an AnimationNodeStateMachine tree_root.",
             },
             mode: {
                 type: "string",
@@ -291,20 +934,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.",
@@ -317,26 +981,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",
@@ -350,30 +1014,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",
@@ -387,30 +1056,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",
@@ -424,13 +1093,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: {
@@ -651,6 +1320,18 @@ 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 "authoring.symbols.status":
+                return succeeded(request.toolName, targetPath, await invokeAuthoringSymbolStatusTool(targetPath));
+            case "authoring.symbols.document":
+                return succeeded(request.toolName, targetPath, await invokeAuthoringDocumentSymbolsTool(targetPath, request.input));
+            case "authoring.symbols.definition":
+                return succeeded(request.toolName, targetPath, await invokeAuthoringPositionSymbolTool("definition", targetPath, request.input));
+            case "authoring.symbols.declaration":
+                return succeeded(request.toolName, targetPath, await invokeAuthoringPositionSymbolTool("declaration", targetPath, request.input));
+            case "authoring.symbols.references":
+                return succeeded(request.toolName, targetPath, await invokeAuthoringReferencesTool(targetPath, request.input));
+            case "authoring.symbols.hover":
+                return succeeded(request.toolName, targetPath, await invokeAuthoringPositionSymbolTool("hover", targetPath, request.input));
             case "editor.session.status":
                 return succeeded(request.toolName, targetPath, await invokeEditorSessionStatusTool(targetPath, request.input));
             case "editor.state":
@@ -697,6 +1378,129 @@ 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.entry.list":
@@ -920,6 +1724,53 @@ async function invokeAuthoringWarmupTool(targetPath, _input) {
     });
     return result;
 }
+async function invokeAuthoringSymbolStatusTool(targetPath) {
+    const context = await buildAuthoringContext(targetPath);
+    return getAuthoringSymbolStatus({
+        targetPath: context.targetPath,
+        status: context.status,
+        projectConfig: context.projectConfig,
+    });
+}
+async function invokeAuthoringDocumentSymbolsTool(targetPath, input) {
+    const context = await buildAuthoringContext(targetPath);
+    return getAuthoringDocumentSymbols({
+        targetPath: context.targetPath,
+        status: context.status,
+        projectConfig: context.projectConfig,
+        filePath: requireString(input["filePath"], "filePath"),
+    });
+}
+async function invokeAuthoringPositionSymbolTool(operation, targetPath, input) {
+    const context = await buildAuthoringContext(targetPath);
+    const symbolInput = {
+        targetPath: context.targetPath,
+        status: context.status,
+        projectConfig: context.projectConfig,
+        filePath: requireString(input["filePath"], "filePath"),
+        line: requirePositiveInteger(input["line"], "line"),
+        column: requirePositiveInteger(input["column"], "column"),
+    };
+    if (operation === "definition") {
+        return getAuthoringSymbolDefinition(symbolInput);
+    }
+    if (operation === "declaration") {
+        return getAuthoringSymbolDeclaration(symbolInput);
+    }
+    return getAuthoringSymbolHover(symbolInput);
+}
+async function invokeAuthoringReferencesTool(targetPath, input) {
+    const context = await buildAuthoringContext(targetPath);
+    return getAuthoringSymbolReferences({
+        targetPath: context.targetPath,
+        status: context.status,
+        projectConfig: context.projectConfig,
+        filePath: requireString(input["filePath"], "filePath"),
+        line: requirePositiveInteger(input["line"], "line"),
+        column: requirePositiveInteger(input["column"], "column"),
+        includeDeclaration: readOptionalBoolean(input["includeDeclaration"], "includeDeclaration") ?? true,
+    });
+}
 async function invokeRunConfigCheckTool(targetPath, input) {
     const projectConfig = await readProjectConfig(targetPath);
     const runtimeInput = normalizeRuntimeActionInput(input, {
@@ -1083,6 +1934,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")
@@ -1102,6 +1962,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.`);
@@ -1120,6 +2002,13 @@ function readOptionalPositiveInteger(value, fieldName) {
     }
     return value;
 }
+function requirePositiveInteger(value, fieldName) {
+    const numberValue = readOptionalPositiveInteger(value, fieldName);
+    if (numberValue === undefined) {
+        throw new Error(`MCP input field "${fieldName}" is required.`);
+    }
+    return numberValue;
+}
 function readOptionalStringArray(value, fieldName) {
     if (value === undefined) {
         return [];