gopeak 2.0.1 → 2.2.0

package/build/index.js

@@ -8,21 +8,22 @@
  */
 import { fileURLToPath } from 'url';
 import { join, dirname, basename, normalize } from 'path';
-import { existsSync, readdirSync, mkdirSync } from 'fs';
+import { existsSync, readdirSync, mkdirSync, readFileSync, appendFileSync, writeFileSync } from 'fs';
 import { spawn } from 'child_process';
 import { promisify } from 'util';
 import { exec } from 'child_process';
-import { createServer } from 'http';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { setupResourceHandlers } from './resources.js';
 import { GodotLSPClient, createLSPTools, handleLSPTool } from './lsp_client.js';
 import { GodotDAPClient, createDAPTools, handleDAPTool } from './dap_client.js';
+import { mapProject } from './gdscript_parser.js';
+import { serveVisualization, setProjectPath } from './visualizer-server.js';
+import { getDefaultBridge } from './godot-bridge.js';
 // Check if debug mode is enabled
 const DEBUG_MODE = process.env.DEBUG === 'true';
 const GODOT_DEBUG_MODE = true; // Always use GODOT DEBUG MODE
-const HEALTH_PORT = parseInt(process.env.MCP_HEALTH_PORT || '8080', 10);
 const execAsync = promisify(exec);
 // Derive __filename and __dirname in ESM
 const __filename = fileURLToPath(import.meta.url);
@@ -40,6 +41,37 @@ class GodotServer {
     lspClient = null;
     dapClient = null;
     lastProjectPath = null;
+    recordingMode = (process.env.LOG_MODE === 'full' ? 'full' : 'lite');
+    logQueue = [];
+    logFlushTimer = null;
+    logFlushIntervalMs = 1500;
+    godotBridge;
+    cachedToolDefinitions = [];
+    toolExposureProfile;
+    toolsListPageSize;
+    compactAliasToLegacy = {
+        'tool.catalog': 'tool_catalog',
+        'project.list': 'list_projects',
+        'project.info': 'get_project_info',
+        'project.search': 'search_project',
+        'editor.launch': 'launch_editor',
+        'editor.run': 'run_project',
+        'editor.stop': 'stop_project',
+        'editor.debug_output': 'get_debug_output',
+        'editor.status': 'get_editor_status',
+        'scene.create': 'create_scene',
+        'scene.node.add': 'add_node',
+        'scene.save': 'save_scene',
+        'script.create': 'create_script',
+        'script.modify': 'modify_script',
+        'script.info': 'get_script_info',
+        'class.query': 'query_classes',
+        'class.info': 'query_class_info',
+        'runtime.status': 'get_runtime_status',
+        'visualizer.map': 'map_project',
+        'lsp.diagnostics': 'lsp_get_diagnostics',
+        'dap.output': 'dap_get_output',
+    };
     /**
      * Parameter name mappings between snake_case and camelCase
      * This allows the server to accept both formats
@@ -87,6 +119,17 @@ class GodotServer {
      */
     reverseParameterMappings = {};
     constructor(config) {
+        const rawProfile = (process.env.GOPEAK_TOOL_PROFILE || process.env.MCP_TOOL_PROFILE || 'compact').toLowerCase();
+        if (rawProfile === 'full' || rawProfile === 'legacy' || rawProfile === 'compact') {
+            this.toolExposureProfile = rawProfile;
+        }
+        else {
+            this.toolExposureProfile = 'compact';
+        }
+        const rawToolsPageSize = parseInt(process.env.GOPEAK_TOOLS_PAGE_SIZE || '20', 10);
+        this.toolsListPageSize = Number.isFinite(rawToolsPageSize) && rawToolsPageSize > 0
+            ? rawToolsPageSize
+            : 20;
         // Initialize reverse parameter mappings
         for (const [snakeCase, camelCase] of Object.entries(this.parameterMappings)) {
             this.reverseParameterMappings[camelCase] = snakeCase;
@@ -118,6 +161,8 @@ class GodotServer {
         }
         // Set the path to the operations script
         this.operationsScriptPath = join(__dirname, 'scripts', 'godot_operations.gd');
+        // Initialize the Godot Editor Bridge (WebSocket server for editor plugin)
+        this.godotBridge = getDefaultBridge();
         if (debugMode)
             console.error(`[DEBUG] Operations script path: ${this.operationsScriptPath}`);
         // Initialize the MCP server
@@ -344,6 +389,11 @@ class GodotServer {
      */
     async cleanup() {
         this.logDebug('Cleaning up resources');
+        if (this.logFlushTimer) {
+            clearTimeout(this.logFlushTimer);
+            this.logFlushTimer = null;
+        }
+        this.flushLogQueue();
         if (this.activeProcess) {
             this.logDebug('Killing active Godot process');
             this.activeProcess.process.kill();
@@ -363,6 +413,12 @@ class GodotServer {
             catch { }
             this.dapClient = null;
         }
+        if (this.godotBridge) {
+            try {
+                await this.godotBridge.stop();
+            }
+            catch { }
+        }
         await this.server.close();
     }
     async handleRuntimeCommand(command, args) {
@@ -431,6 +487,86 @@ class GodotServer {
         }
         return handleDAPTool(this.dapClient, toolName, args);
     }
+    resolveToolAlias(requestedToolName) {
+        return this.compactAliasToLegacy[requestedToolName] || requestedToolName;
+    }
+    buildCompactTools(allTools) {
+        const compactTools = [];
+        for (const [compactName, legacyName] of Object.entries(this.compactAliasToLegacy)) {
+            const source = allTools.find((tool) => tool.name === legacyName);
+            if (!source) {
+                continue;
+            }
+            compactTools.push({
+                ...source,
+                name: compactName,
+                description: `[compact alias of ${legacyName}] ${source.description}`,
+            });
+        }
+        return compactTools;
+    }
+    getExposedTools(allTools) {
+        if (this.toolExposureProfile === 'full' || this.toolExposureProfile === 'legacy') {
+            return allTools;
+        }
+        return this.buildCompactTools(allTools);
+    }
+    parseToolsListCursor(cursor, total) {
+        if (typeof cursor !== 'string' || cursor.length === 0) {
+            return 0;
+        }
+        const offset = Number.parseInt(cursor, 10);
+        if (!Number.isInteger(offset) || offset < 0 || offset > total) {
+            throw new McpError(ErrorCode.InvalidParams, `Invalid tools/list cursor: ${cursor}`);
+        }
+        return offset;
+    }
+    paginateToolsForList(tools, cursor) {
+        const start = this.parseToolsListCursor(cursor, tools.length);
+        const end = Math.min(start + this.toolsListPageSize, tools.length);
+        const page = tools.slice(start, end);
+        if (end < tools.length) {
+            return {
+                tools: page,
+                nextCursor: String(end),
+            };
+        }
+        return { tools: page };
+    }
+    async handleToolCatalog(args) {
+        const normalizedArgs = this.normalizeParameters(args || {});
+        const query = typeof normalizedArgs.query === 'string' ? normalizedArgs.query.trim().toLowerCase() : '';
+        const rawLimit = typeof normalizedArgs.limit === 'number' ? normalizedArgs.limit : 30;
+        const limit = Math.max(1, Math.min(100, rawLimit));
+        const tools = this.cachedToolDefinitions;
+        const reverseAlias = new Map();
+        for (const [compactName, legacyName] of Object.entries(this.compactAliasToLegacy)) {
+            reverseAlias.set(legacyName, compactName);
+        }
+        const filtered = tools.filter((tool) => {
+            if (!query)
+                return true;
+            const haystack = `${tool.name} ${tool.description}`.toLowerCase();
+            return haystack.includes(query);
+        });
+        const items = filtered.slice(0, limit).map((tool) => ({
+            tool: tool.name,
+            compactAlias: reverseAlias.get(tool.name) || null,
+            description: tool.description,
+        }));
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        profile: this.toolExposureProfile,
+                        totalTools: tools.length,
+                        query: query || null,
+                        returned: items.length,
+                        tools: items,
+                    }, null, 2),
+                }],
+        };
+    }
     /**
      * Check if the Godot version is 4.4 or later
      * @param version The Godot version string
@@ -675,8 +811,8 @@ class GodotServer {
      */
     setupToolHandlers() {
         // Define available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: [
+        this.server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+            const allTools = [
                 {
                     name: 'launch_editor',
                     description: 'Opens the Godot editor GUI for a project. Use when visual inspection or manual editing of scenes/scripts is needed. Opens a new window on the host system. Requires: project directory with project.godot file.',
@@ -774,6 +910,210 @@ class GodotServer {
                         required: ['projectPath'],
                     },
                 },
+                {
+                    name: 'scaffold_gameplay_prototype',
+                    description: 'Creates a minimal playable prototype scaffold in one shot: main scene, player scene, basic nodes, common input actions, and optional starter player script.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: {
+                                type: 'string',
+                                description: 'Absolute path to project directory containing project.godot.',
+                            },
+                            scenePath: {
+                                type: 'string',
+                                description: 'Main scene path relative to project. Default: scenes/Main.tscn',
+                            },
+                            playerScenePath: {
+                                type: 'string',
+                                description: 'Player scene path relative to project. Default: scenes/Player.tscn',
+                            },
+                            includePlayerScript: {
+                                type: 'boolean',
+                                description: 'If true, creates scripts/player.gd starter script. Default: true',
+                            },
+                        },
+                        required: ['projectPath'],
+                    },
+                },
+                {
+                    name: 'validate_patch_with_lsp',
+                    description: 'Runs Godot LSP diagnostics for a script and returns whether it is safe to apply changes. Intended as a pre-apply quality gate.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: {
+                                type: 'string',
+                                description: 'Absolute path to project directory containing project.godot.',
+                            },
+                            scriptPath: {
+                                type: 'string',
+                                description: 'Script path relative to project (e.g., scripts/player.gd).',
+                            },
+                        },
+                        required: ['projectPath', 'scriptPath'],
+                    },
+                },
+                {
+                    name: 'enforce_version_gate',
+                    description: 'Checks Godot version and runtime addon protocol/capabilities against minimum requirements before risky operations.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: {
+                                type: 'string',
+                                description: 'Absolute path to project directory containing project.godot.',
+                            },
+                            minGodotVersion: {
+                                type: 'string',
+                                description: 'Minimum required Godot version (major.minor). Default: 4.2',
+                            },
+                            minProtocolVersion: {
+                                type: 'string',
+                                description: 'Minimum required runtime protocol version. Default: 1.0',
+                            },
+                        },
+                        required: ['projectPath'],
+                    },
+                },
+                {
+                    name: 'capture_intent_snapshot',
+                    description: 'Capture/update an intent snapshot for current work (goal, constraints, acceptance criteria) and persist it for handoff.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to project directory containing project.godot.' },
+                            goal: { type: 'string', description: 'Primary goal of the current work.' },
+                            why: { type: 'string', description: 'Why this work matters.' },
+                            constraints: { type: 'array', items: { type: 'string' }, description: 'Operational/technical constraints.' },
+                            acceptanceCriteria: { type: 'array', items: { type: 'string' }, description: 'Definition of done.' },
+                            nonGoals: { type: 'array', items: { type: 'string' }, description: 'Out of scope items.' },
+                            priority: { type: 'string', description: 'Priority label (e.g., P0, P1).' }
+                        },
+                        required: ['projectPath', 'goal'],
+                    },
+                },
+                {
+                    name: 'record_decision_log',
+                    description: 'Record a structured decision log entry with rationale and alternatives.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to project directory containing project.godot.' },
+                            intentId: { type: 'string', description: 'Related intent id. Optional if latest intent should be inferred.' },
+                            decision: { type: 'string', description: 'Decision statement.' },
+                            rationale: { type: 'string', description: 'Why this decision was made.' },
+                            alternativesRejected: { type: 'array', items: { type: 'string' }, description: 'Alternatives considered and rejected.' },
+                            evidenceRefs: { type: 'array', items: { type: 'string' }, description: 'References supporting the decision.' }
+                        },
+                        required: ['projectPath', 'decision'],
+                    },
+                },
+                {
+                    name: 'generate_handoff_brief',
+                    description: 'Generate a handoff brief from saved intents, decisions, and execution traces for the next AI/operator.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to project directory containing project.godot.' },
+                            maxItems: { type: 'number', description: 'Max items per section. Default: 5' }
+                        },
+                        required: ['projectPath'],
+                    },
+                },
+                {
+                    name: 'summarize_intent_context',
+                    description: 'Summarize current intent context (goal, open decisions, risks, next actions) in compact form.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to project directory containing project.godot.' }
+                        },
+                        required: ['projectPath'],
+                    },
+                },
+                {
+                    name: 'record_work_step',
+                    description: 'Unified operation: records execution trace and optionally refreshes handoff pack in one call.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to project directory containing project.godot.' },
+                            intentId: { type: 'string', description: 'Related intent id. Optional: auto-link active intent.' },
+                            action: { type: 'string', description: 'Executed action name.' },
+                            command: { type: 'string', description: 'Command or tool invocation.' },
+                            filesChanged: { type: 'array', items: { type: 'string' }, description: 'Changed file paths.' },
+                            result: { type: 'string', description: 'success|failed|partial' },
+                            artifact: { type: 'string', description: 'Artifact reference (branch, commit, build id).' },
+                            error: { type: 'string', description: 'Error details when failed.' },
+                            refreshHandoffPack: { type: 'boolean', description: 'If true, regenerates handoff pack after recording. Default: true' },
+                            maxItems: { type: 'number', description: 'Max items for refreshed handoff pack. Default: 10' }
+                        },
+                        required: ['projectPath', 'action', 'result'],
+                    },
+                },
+                {
+                    name: 'record_execution_trace',
+                    description: 'Record execution trace for a work step (command/tool, files changed, result, artifacts).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to project directory containing project.godot.' },
+                            intentId: { type: 'string', description: 'Related intent id. Optional: auto-link active intent.' },
+                            action: { type: 'string', description: 'Executed action name.' },
+                            command: { type: 'string', description: 'Command or tool invocation.' },
+                            filesChanged: { type: 'array', items: { type: 'string' }, description: 'Changed file paths.' },
+                            result: { type: 'string', description: 'success|failed|partial' },
+                            artifact: { type: 'string', description: 'Artifact reference (branch, commit, build id).' },
+                            error: { type: 'string', description: 'Error details when failed.' }
+                        },
+                        required: ['projectPath', 'action', 'result'],
+                    },
+                },
+                {
+                    name: 'export_handoff_pack',
+                    description: 'Export a machine-readable handoff pack combining intent, decisions, and execution traces.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to project directory containing project.godot.' },
+                            maxItems: { type: 'number', description: 'Maximum decisions/traces to include. Default: 10' }
+                        },
+                        required: ['projectPath'],
+                    },
+                },
+                {
+                    name: 'set_recording_mode',
+                    description: 'Set recording mode: lite (minimal overhead) or full (richer context).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            mode: { type: 'string', description: 'lite|full' }
+                        },
+                        required: ['mode'],
+                    },
+                },
+                {
+                    name: 'get_recording_mode',
+                    description: 'Get current recording mode and queue status.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        required: [],
+                    },
+                },
+                {
+                    name: 'tool_catalog',
+                    description: 'Discover available tools including hidden legacy tools. Use query to search by capability keywords (e.g., animation, import, tilemap, audio).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string', description: 'Optional keyword search over tool names and descriptions.' },
+                            limit: { type: 'number', description: 'Maximum results to return. Default: 30, max: 100.' },
+                        },
+                        required: [],
+                    },
+                },
                 {
                     name: 'create_scene',
                     description: 'Creates a new Godot scene file (.tscn) with a specified root node type. Use to start building new game levels, UI screens, or reusable components. The scene is saved automatically after creation.',
@@ -1789,6 +2129,10 @@ class GodotServer {
                                 type: 'string',
                                 description: 'Optional: template name - "singleton", "state_machine", "component", "resource"',
                             },
+                            reason: {
+                                type: 'string',
+                                description: 'Optional reason/context for this change. Displayed in visualizer audit timeline.',
+                            },
                         },
                         required: ['projectPath', 'scriptPath'],
                     },
@@ -1861,6 +2205,10 @@ class GodotServer {
                                     required: ['type', 'name'],
                                 },
                             },
+                            reason: {
+                                type: 'string',
+                                description: 'Optional reason/context for this change. Displayed in visualizer audit timeline.',
+                            },
                         },
                         required: ['projectPath', 'scriptPath', 'modifications'],
                     },
@@ -2684,12 +3032,38 @@ class GodotServer {
                         required: ['x', 'y'],
                     },
                 },
+                // Editor Plugin Bridge Status
+                {
+                    name: 'get_editor_status',
+                    description: 'Returns the connection status of the Godot Editor Plugin bridge. Use to check if the editor is connected before using scene/resource tools that require the editor plugin.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                // Project Visualizer Tool
+                {
+                    name: 'map_project',
+                    description: 'Crawl the entire Godot project and build an interactive visual map of all scripts showing their structure (variables, functions, signals), connections (extends, preloads, signal connections), and descriptions. Opens an interactive browser-based visualization at localhost:6505.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to the Godot project directory' },
+                            root: { type: 'string', description: 'Root path to start crawling from (default: res://)' },
+                            include_addons: { type: 'boolean', description: 'Whether to include scripts in addons/ folder (default: false)' },
+                        },
+                        required: ['projectPath'],
+                    },
+                },
                 // Godot LSP Tools (GDScript diagnostics via Godot editor LSP on port 6005)
                 ...createLSPTools(),
                 // Godot DAP Tools (Debug Adapter Protocol via Godot editor DAP on port 6006)
                 ...createDAPTools(),
-            ],
-        }));
+            ];
+            this.cachedToolDefinitions = allTools;
+            const exposedTools = this.getExposedTools(allTools);
+            return this.paginateToolsForList(exposedTools, request.params?.cursor);
+        });
         // Handle tool calls
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             this.logDebug(`Handling tool request: ${request.params.name}`);
@@ -2697,7 +3071,8 @@ class GodotServer {
             if (rawArgs?.projectPath && typeof rawArgs.projectPath === 'string') {
                 this.lastProjectPath = rawArgs.projectPath;
             }
-            switch (request.params.name) {
+            const resolvedToolName = this.resolveToolAlias(request.params.name);
+            switch (resolvedToolName) {
                 case 'launch_editor':
                     return await this.handleLaunchEditor(request.params.arguments);
                 case 'run_project':
@@ -2712,31 +3087,57 @@ class GodotServer {
                     return await this.handleListProjects(request.params.arguments);
                 case 'get_project_info':
                     return await this.handleGetProjectInfo(request.params.arguments);
+                case 'scaffold_gameplay_prototype':
+                    return await this.handleScaffoldGameplayPrototype(request.params.arguments);
+                case 'validate_patch_with_lsp':
+                    return await this.handleValidatePatchWithLsp(request.params.arguments);
+                case 'enforce_version_gate':
+                    return await this.handleEnforceVersionGate(request.params.arguments);
+                case 'capture_intent_snapshot':
+                    return await this.handleCaptureIntentSnapshot(request.params.arguments);
+                case 'record_decision_log':
+                    return await this.handleRecordDecisionLog(request.params.arguments);
+                case 'generate_handoff_brief':
+                    return await this.handleGenerateHandoffBrief(request.params.arguments);
+                case 'summarize_intent_context':
+                    return await this.handleSummarizeIntentContext(request.params.arguments);
+                case 'record_work_step':
+                    return await this.handleRecordWorkStep(request.params.arguments);
+                case 'record_execution_trace':
+                    return await this.handleRecordExecutionTrace(request.params.arguments);
+                case 'export_handoff_pack':
+                    return await this.handleExportHandoffPack(request.params.arguments);
+                case 'set_recording_mode':
+                    return await this.handleSetRecordingMode(request.params.arguments);
+                case 'get_recording_mode':
+                    return await this.handleGetRecordingMode();
+                case 'tool_catalog':
+                    return await this.handleToolCatalog(request.params.arguments);
                 case 'create_scene':
-                    return await this.handleCreateScene(request.params.arguments);
+                    return await this.handleViaBridge('create_scene', request.params.arguments);
                 case 'add_node':
-                    return await this.handleAddNode(request.params.arguments);
+                    return await this.handleViaBridge('add_node', request.params.arguments);
                 case 'load_sprite':
-                    return await this.handleLoadSprite(request.params.arguments);
+                    return await this.handleViaBridge('load_sprite', request.params.arguments);
                 case 'save_scene':
-                    return await this.handleSaveScene(request.params.arguments);
+                    return await this.handleViaBridge('save_scene', request.params.arguments);
                 case 'get_uid':
                     return await this.handleGetUid(request.params.arguments);
                 case 'update_project_uids':
                     return await this.handleUpdateProjectUids(request.params.arguments);
                 // Phase 1: Scene Operations handlers
                 case 'list_scene_nodes':
-                    return await this.handleListSceneNodes(request.params.arguments);
+                    return await this.handleViaBridge('list_scene_nodes', request.params.arguments);
                 case 'get_node_properties':
-                    return await this.handleGetNodeProperties(request.params.arguments);
+                    return await this.handleViaBridge('get_node_properties', request.params.arguments);
                 case 'set_node_properties':
-                    return await this.handleSetNodeProperties(request.params.arguments);
+                    return await this.handleViaBridge('set_node_properties', request.params.arguments);
                 case 'delete_node':
-                    return await this.handleDeleteNode(request.params.arguments);
+                    return await this.handleViaBridge('delete_node', request.params.arguments);
                 case 'duplicate_node':
-                    return await this.handleDuplicateNode(request.params.arguments);
+                    return await this.handleViaBridge('duplicate_node', request.params.arguments);
                 case 'reparent_node':
-                    return await this.handleReparentNode(request.params.arguments);
+                    return await this.handleViaBridge('reparent_node', request.params.arguments);
                 // Phase 2: Import/Export Pipeline handlers
                 case 'get_import_status':
                     return await this.handleGetImportStatus(request.params.arguments);
@@ -2776,11 +3177,11 @@ class GodotServer {
                     return await this.handleSetMainScene(request.params.arguments);
                 // Signal Management handlers
                 case 'connect_signal':
-                    return await this.handleConnectSignal(request.params.arguments);
+                    return await this.handleViaBridge('connect_signal', request.params.arguments);
                 case 'disconnect_signal':
-                    return await this.handleDisconnectSignal(request.params.arguments);
+                    return await this.handleViaBridge('disconnect_signal', request.params.arguments);
                 case 'list_connections':
-                    return await this.handleListConnections(request.params.arguments);
+                    return await this.handleViaBridge('list_connections', request.params.arguments);
                 // Phase 4: Runtime Tools handlers
                 case 'get_runtime_status':
                     return await this.handleGetRuntimeStatus(request.params.arguments);
@@ -2794,11 +3195,11 @@ class GodotServer {
                     return await this.handleGetRuntimeMetrics(request.params.arguments);
                 // Resource Creation Tools handlers
                 case 'create_resource':
-                    return await this.handleCreateResource(request.params.arguments);
+                    return await this.handleViaBridge('create_resource', request.params.arguments);
                 case 'create_material':
-                    return await this.handleCreateMaterial(request.params.arguments);
+                    return await this.handleViaBridge('create_material', request.params.arguments);
                 case 'create_shader':
-                    return await this.handleCreateShader(request.params.arguments);
+                    return await this.handleViaBridge('create_shader', request.params.arguments);
                 // GDScript File Operations handlers
                 case 'create_script':
                     return await this.handleCreateScript(request.params.arguments);
@@ -2808,9 +3209,9 @@ class GodotServer {
                     return await this.handleGetScriptInfo(request.params.arguments);
                 // Animation Tools handlers
                 case 'create_animation':
-                    return await this.handleCreateAnimation(request.params.arguments);
+                    return await this.handleViaBridge('create_animation', request.params.arguments);
                 case 'add_animation_track':
-                    return await this.handleAddAnimationTrack(request.params.arguments);
+                    return await this.handleViaBridge('add_animation_track', request.params.arguments);
                 // Plugin Management handlers
                 case 'list_plugins':
                     return await this.handleListPlugins(request.params.arguments);
@@ -2826,9 +3227,9 @@ class GodotServer {
                     return await this.handleSearchProject(request.params.arguments);
                 // 2D Tile Tools handlers
                 case 'create_tileset':
-                    return await this.handleCreateTileset(request.params.arguments);
+                    return await this.handleViaBridge('create_tileset', request.params.arguments);
                 case 'set_tilemap_cells':
-                    return await this.handleSetTilemapCells(request.params.arguments);
+                    return await this.handleViaBridge('set_tilemap_cells', request.params.arguments);
                 // Audio System Tools handlers
                 case 'create_audio_bus':
                     return await this.handleCreateAudioBus(request.params.arguments);
@@ -2842,24 +3243,24 @@ class GodotServer {
                 // Physics Tools handlers
                 // Navigation Tools handlers
                 case 'create_navigation_region':
-                    return await this.handleCreateNavigationRegion(request.params.arguments);
+                    return await this.handleViaBridge('create_navigation_region', request.params.arguments);
                 case 'create_navigation_agent':
-                    return await this.handleCreateNavigationAgent(request.params.arguments);
+                    return await this.handleViaBridge('create_navigation_agent', request.params.arguments);
                 // Rendering Tools handlers
                 // Animation Tree Tools handlers
                 case 'create_animation_tree':
-                    return await this.handleCreateAnimationTree(request.params.arguments);
+                    return await this.handleViaBridge('create_animation_tree', request.params.arguments);
                 case 'add_animation_state':
-                    return await this.handleAddAnimationState(request.params.arguments);
+                    return await this.handleViaBridge('add_animation_state', request.params.arguments);
                 case 'connect_animation_states':
-                    return await this.handleConnectAnimationStates(request.params.arguments);
+                    return await this.handleViaBridge('connect_animation_states', request.params.arguments);
                 // UI/Theme Tools handlers
                 case 'set_theme_color':
-                    return await this.handleSetThemeColor(request.params.arguments);
+                    return await this.handleViaBridge('set_theme_color', request.params.arguments);
                 case 'set_theme_font_size':
-                    return await this.handleSetThemeFontSize(request.params.arguments);
+                    return await this.handleViaBridge('set_theme_font_size', request.params.arguments);
                 case 'apply_theme_shader':
-                    return await this.handleApplyThemeShader(request.params.arguments);
+                    return await this.handleViaBridge('apply_theme_shader', request.params.arguments);
                 case 'search_assets':
                     return await this.handleSearchAssets(request.params.arguments);
                 case 'fetch_asset':
@@ -2875,7 +3276,13 @@ class GodotServer {
                     return await this.handleInspectInheritance(request.params.arguments);
                 // Resource Modification Tool
                 case 'modify_resource':
-                    return await this.handleModifyResource(request.params.arguments);
+                    return await this.handleViaBridge('modify_resource', request.params.arguments);
+                // Editor Plugin Bridge Status
+                case 'get_editor_status':
+                    return { content: [{ type: 'text', text: JSON.stringify(this.godotBridge.getStatus(), null, 2) }] };
+                // Project Visualizer Tool
+                case 'map_project':
+                    return await this.handleMapProject(request.params.arguments);
                 case 'capture_screenshot':
                     return await this.handleRuntimeCommand('capture_screenshot', request.params.arguments);
                 case 'capture_viewport':
@@ -2892,7 +3299,7 @@ class GodotServer {
                 case 'lsp_get_completions':
                 case 'lsp_get_hover':
                 case 'lsp_get_symbols':
-                    return await this.handleLSP(request.params.name, request.params.arguments);
+                    return await this.handleLSP(resolvedToolName, request.params.arguments);
                 case 'dap_get_output':
                 case 'dap_set_breakpoint':
                 case 'dap_remove_breakpoint':
@@ -2900,7 +3307,7 @@ class GodotServer {
                 case 'dap_pause':
                 case 'dap_step_over':
                 case 'dap_get_stack_trace':
-                    return await this.handleDAP(request.params.name, request.params.arguments);
+                    return await this.handleDAP(resolvedToolName, request.params.arguments);
                 default:
                     throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
             }
@@ -3046,6 +3453,33 @@ class GodotServer {
             ]);
         }
     }
+    /**
+     * Route a tool call through the Godot Editor Plugin bridge (WebSocket).
+     * Returns an error response if the editor is not connected.
+     */
+    async handleViaBridge(toolName, args) {
+        if (!this.godotBridge.isConnected()) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: 'Godot Editor not connected. Launch Godot Editor and enable the "Godot MCP Editor" plugin to use this tool.',
+                            suggestion: 'Use the launch_editor tool to open the Godot Editor, then enable the plugin in Project > Project Settings > Plugins.',
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        try {
+            const result = await this.godotBridge.invokeTool(toolName, args);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+    }
     /**
      * Handle the get_debug_output tool
      */
@@ -3299,6 +3733,699 @@ class GodotServer {
             ]);
         }
     }
+    compareMajorMinorVersions(actual, minimum) {
+        const parse = (value) => {
+            const m = value.match(/(\d+)\.(\d+)/);
+            if (!m)
+                return [0, 0];
+            return [parseInt(m[1], 10), parseInt(m[2], 10)];
+        };
+        const [aMaj, aMin] = parse(actual);
+        const [mMaj, mMin] = parse(minimum);
+        if (aMaj > mMaj)
+            return true;
+        if (aMaj < mMaj)
+            return false;
+        return aMin >= mMin;
+    }
+    /**
+     * One-shot gameplay prototype scaffold
+     */
+    async handleScaffoldGameplayPrototype(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath) {
+            return this.createErrorResponse('Project path is required', ['Provide projectPath']);
+        }
+        const projectFile = join(args.projectPath, 'project.godot');
+        if (!existsSync(projectFile)) {
+            return this.createErrorResponse(`Not a valid Godot project: ${args.projectPath}`, [
+                'Ensure project.godot exists in the provided path',
+            ]);
+        }
+        const scenePath = args.scenePath || 'scenes/Main.tscn';
+        const playerScenePath = args.playerScenePath || 'scenes/Player.tscn';
+        const includePlayerScript = args.includePlayerScript !== false;
+        const steps = [];
+        const runOperation = async (operation, params) => {
+            const { stdout, stderr } = await this.executeOperation(operation, params, args.projectPath);
+            const ok = !(stderr && stderr.includes('ERROR'));
+            return { ok, stdout: stdout?.trim() || '', stderr: stderr?.trim() || '' };
+        };
+        try {
+            // 1) Create main scene
+            const createMain = await runOperation('create_scene', {
+                scenePath,
+                rootNodeType: 'Node2D',
+            });
+            steps.push({ step: 'create_main_scene', ok: createMain.ok, detail: createMain.stderr || createMain.stdout });
+            if (!createMain.ok) {
+                return this.createErrorResponse('Failed to scaffold: could not create main scene', [createMain.stderr || 'Unknown error']);
+            }
+            // 2) Create player scene
+            const createPlayerScene = await runOperation('create_scene', {
+                scenePath: playerScenePath,
+                rootNodeType: 'CharacterBody2D',
+            });
+            steps.push({ step: 'create_player_scene', ok: createPlayerScene.ok, detail: createPlayerScene.stderr || createPlayerScene.stdout });
+            if (!createPlayerScene.ok) {
+                return this.createErrorResponse('Failed to scaffold: could not create player scene', [createPlayerScene.stderr || 'Unknown error']);
+            }
+            // 3) Add common player child nodes
+            const playerNodeAdds = [
+                { nodeType: 'Sprite2D', nodeName: 'Sprite2D' },
+                { nodeType: 'CollisionShape2D', nodeName: 'CollisionShape2D' },
+                { nodeType: 'Camera2D', nodeName: 'Camera2D', properties: { enabled: true } },
+            ];
+            for (const node of playerNodeAdds) {
+                const add = await runOperation('add_node', {
+                    scenePath: playerScenePath,
+                    nodeType: node.nodeType,
+                    nodeName: node.nodeName,
+                    properties: node.properties,
+                });
+                steps.push({ step: `add_node_${node.nodeName}`, ok: add.ok, detail: add.stderr || add.stdout });
+            }
+            // 4) Add Player instance placeholder to main scene (as Node2D) and attach player scene path as meta hint
+            const addPlayerRoot = await runOperation('add_node', {
+                scenePath,
+                nodeType: 'Node2D',
+                nodeName: 'Player',
+            });
+            steps.push({ step: 'add_player_root_to_main', ok: addPlayerRoot.ok, detail: addPlayerRoot.stderr || addPlayerRoot.stdout });
+            // 5) Input actions
+            const inputActions = [
+                {
+                    actionName: 'move_left',
+                    events: [{ type: 'key', keycode: 'A' }, { type: 'key', keycode: 'Left' }],
+                },
+                {
+                    actionName: 'move_right',
+                    events: [{ type: 'key', keycode: 'D' }, { type: 'key', keycode: 'Right' }],
+                },
+                {
+                    actionName: 'jump',
+                    events: [{ type: 'key', keycode: 'Space' }],
+                },
+            ];
+            for (const action of inputActions) {
+                const inputResult = await runOperation('add_input_action', action);
+                steps.push({ step: `add_input_${action.actionName}`, ok: inputResult.ok, detail: inputResult.stderr || inputResult.stdout });
+            }
+            // 6) Optional starter player script
+            if (includePlayerScript) {
+                const scriptResult = await runOperation('create_script', {
+                    script_path: 'scripts/player.gd',
+                    class_name: 'PlayerController',
+                    extends_class: 'CharacterBody2D',
+                    content: "@export var speed: float = 220.0\n@export var jump_velocity: float = -420.0\n@export var gravity: float = 980.0\n\nfunc _physics_process(delta: float) -> void:\n\tvar dir := Input.get_axis(\"move_left\", \"move_right\")\n\tvelocity.x = dir * speed\n\tif not is_on_floor():\n\t\tvelocity.y += gravity * delta\n\tif is_on_floor() and Input.is_action_just_pressed(\"jump\"):\n\t\tvelocity.y = jump_velocity\n\tmove_and_slide()\n",
+                });
+                steps.push({ step: 'create_player_script', ok: scriptResult.ok, detail: scriptResult.stderr || scriptResult.stdout });
+                // Attach script to player root
+                const attachScript = await runOperation('set_node_properties', {
+                    scenePath: playerScenePath,
+                    nodePath: '.',
+                    properties: { script: 'res://scripts/player.gd' },
+                });
+                steps.push({ step: 'attach_player_script', ok: attachScript.ok, detail: attachScript.stderr || attachScript.stdout });
+            }
+            // 7) Set main scene
+            const setMain = await runOperation('set_main_scene', { scenePath });
+            steps.push({ step: 'set_main_scene', ok: setMain.ok, detail: setMain.stderr || setMain.stdout });
+            const allOk = steps.every((s) => s.ok);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: allOk,
+                            summary: allOk
+                                ? 'Gameplay prototype scaffold completed.'
+                                : 'Scaffold completed with some failed steps. Check steps[] details.',
+                            outputs: {
+                                mainScene: scenePath,
+                                playerScene: playerScenePath,
+                                playerScript: includePlayerScript ? 'scripts/player.gd' : null,
+                            },
+                            steps,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse(`Failed to scaffold gameplay prototype: ${error?.message || 'Unknown error'}`, [
+                'Ensure Godot is installed and accessible',
+                'Check project path and write permissions',
+            ]);
+        }
+    }
+    /**
+     * Pre-apply LSP validation gate
+     */
+    async handleValidatePatchWithLsp(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath || !args.scriptPath) {
+            return this.createErrorResponse('Missing required parameters', ['Provide projectPath and scriptPath']);
+        }
+        try {
+            const lspResult = await this.handleLSP('lsp_get_diagnostics', {
+                projectPath: args.projectPath,
+                scriptPath: args.scriptPath,
+            });
+            const textPayload = lspResult?.content?.[0]?.text || '{}';
+            let diagnostics = [];
+            try {
+                const parsed = JSON.parse(textPayload);
+                diagnostics = Array.isArray(parsed?.diagnostics) ? parsed.diagnostics : [];
+            }
+            catch {
+                diagnostics = [];
+            }
+            const hasBlocking = diagnostics.some((d) => {
+                const severity = d?.severity;
+                return severity === 1 || severity === 'error' || severity === 'ERROR';
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            scriptPath: args.scriptPath,
+                            diagnosticsCount: diagnostics.length,
+                            blockOnError: hasBlocking,
+                            canApply: !hasBlocking,
+                            diagnostics,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse(`Failed LSP validation: ${error?.message || 'Unknown error'}`, [
+                'Ensure Godot editor is running with LSP enabled (port 6005)',
+            ]);
+        }
+    }
+    /**
+     * Version and protocol gate
+     */
+    async handleEnforceVersionGate(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath) {
+            return this.createErrorResponse('Project path is required', ['Provide projectPath']);
+        }
+        const minGodotVersion = args.minGodotVersion || '4.2';
+        const minProtocolVersion = args.minProtocolVersion || '1.0';
+        try {
+            const versionResult = await this.handleGetGodotVersion();
+            const godotVersion = (versionResult?.content?.[0]?.text || '').trim();
+            const godotOk = this.compareMajorMinorVersions(godotVersion, minGodotVersion);
+            let runtimeProtocol = 'unknown';
+            let runtimeConnected = false;
+            let protocolOk = false;
+            let capabilityInfo = {};
+            const runtime = await this.handleRuntimeCommand('ping', {});
+            const runtimeText = runtime?.content?.[0]?.text || '{}';
+            try {
+                const parsed = JSON.parse(runtimeText);
+                runtimeConnected = !parsed?.error;
+                runtimeProtocol = parsed?.protocol_version || parsed?.protocolVersion || '1.0';
+                capabilityInfo = {
+                    hasRuntime: runtimeConnected,
+                    responseType: parsed?.type || null,
+                };
+            }
+            catch {
+                runtimeConnected = false;
+            }
+            protocolOk = this.compareMajorMinorVersions(runtimeProtocol, minProtocolVersion);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: godotOk && (runtimeConnected ? protocolOk : true),
+                            requirements: {
+                                minGodotVersion,
+                                minProtocolVersion,
+                            },
+                            actual: {
+                                godotVersion,
+                                runtimeConnected,
+                                runtimeProtocol,
+                            },
+                            checks: {
+                                godotOk,
+                                protocolOk: runtimeConnected ? protocolOk : null,
+                            },
+                            capabilityInfo,
+                            recommendation: godotOk
+                                ? runtimeConnected
+                                    ? protocolOk
+                                        ? 'Version gate passed.'
+                                        : 'Runtime protocol is below minimum. Update runtime addon.'
+                                    : 'Godot version is compatible. Runtime addon not connected; run project/addon for full protocol check.'
+                                : 'Godot version below minimum requirement. Upgrade Godot.',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse(`Failed to enforce version gate: ${error?.message || 'Unknown error'}`, [
+                'Ensure Godot is installed and runtime addon is available',
+            ]);
+        }
+    }
+    getIntentMemoryDir(projectPath) {
+        const dir = join(projectPath, '.godot-mcp-memory');
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+    }
+    scheduleLogFlush() {
+        if (this.logFlushTimer)
+            return;
+        this.logFlushTimer = setTimeout(() => {
+            this.flushLogQueue();
+        }, this.logFlushIntervalMs);
+    }
+    flushLogQueue() {
+        const batch = this.logQueue.splice(0, this.logQueue.length);
+        this.logFlushTimer = null;
+        if (batch.length === 0)
+            return;
+        const grouped = new Map();
+        for (const item of batch) {
+            const line = JSON.stringify(item.payload) + '\n';
+            const existing = grouped.get(item.filePath) || [];
+            existing.push(line);
+            grouped.set(item.filePath, existing);
+        }
+        for (const [filePath, lines] of grouped.entries()) {
+            appendFileSync(filePath, lines.join(''), 'utf8');
+        }
+    }
+    appendJsonl(filePath, payload) {
+        // Lite mode: asynchronous queued write to reduce user-facing latency
+        // Full mode: still queued/batched to avoid frequent fs sync stalls
+        this.logQueue.push({ filePath, payload });
+        // Backpressure guard: if queue grows too large, flush immediately
+        if (this.logQueue.length >= 50) {
+            this.flushLogQueue();
+            return;
+        }
+        this.scheduleLogFlush();
+    }
+    readJsonArray(filePath) {
+        if (!existsSync(filePath))
+            return [];
+        try {
+            const raw = readFileSync(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    writeJsonArray(filePath, value) {
+        writeFileSync(filePath, JSON.stringify(value, null, 2), 'utf8');
+    }
+    readJsonl(filePath) {
+        if (!existsSync(filePath))
+            return [];
+        const raw = readFileSync(filePath, 'utf8');
+        return raw
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((v) => v !== null);
+    }
+    /**
+     * Capture/update current intent snapshot
+     */
+    async handleCaptureIntentSnapshot(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath || !args.goal) {
+            return this.createErrorResponse('Missing required parameters', ['Provide projectPath and goal']);
+        }
+        const projectFile = join(args.projectPath, 'project.godot');
+        if (!existsSync(projectFile)) {
+            return this.createErrorResponse(`Not a valid Godot project: ${args.projectPath}`, ['Ensure project.godot exists']);
+        }
+        const memoryDir = this.getIntentMemoryDir(args.projectPath);
+        const indexPath = join(memoryDir, 'intent-index.json');
+        const existing = this.readJsonArray(indexPath);
+        const intentId = `intent_${Date.now()}`;
+        const snapshot = {
+            intent_id: intentId,
+            ts: new Date().toISOString(),
+            goal: args.goal,
+            why: args.why || '',
+            constraints: Array.isArray(args.constraints) ? args.constraints : [],
+            acceptance_criteria: Array.isArray(args.acceptanceCriteria) ? args.acceptanceCriteria : [],
+            non_goals: Array.isArray(args.nonGoals) ? args.nonGoals : [],
+            priority: args.priority || 'P1',
+            status: 'active',
+        };
+        for (const item of existing) {
+            if (item && item.status === 'active') {
+                item.status = 'archived';
+            }
+        }
+        existing.push(snapshot);
+        this.writeJsonArray(indexPath, existing);
+        const eventsPath = join(memoryDir, 'dev-activity.jsonl');
+        this.appendJsonl(eventsPath, {
+            ts: new Date().toISOString(),
+            actor: 'mcp-server',
+            action: 'capture_intent_snapshot',
+            intent_id: intentId,
+            result: 'success',
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, intent: snapshot, files: { indexPath, eventsPath } }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Record decision log entry
+     */
+    async handleRecordDecisionLog(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath || !args.decision) {
+            return this.createErrorResponse('Missing required parameters', ['Provide projectPath and decision']);
+        }
+        const projectFile = join(args.projectPath, 'project.godot');
+        if (!existsSync(projectFile)) {
+            return this.createErrorResponse(`Not a valid Godot project: ${args.projectPath}`, ['Ensure project.godot exists']);
+        }
+        const memoryDir = this.getIntentMemoryDir(args.projectPath);
+        const indexPath = join(memoryDir, 'intent-index.json');
+        const decisionsPath = join(memoryDir, 'decision-log.jsonl');
+        const intents = this.readJsonArray(indexPath);
+        const activeIntent = intents.find((i) => i && i.status === 'active');
+        const intentId = args.intentId || activeIntent?.intent_id || null;
+        const decisionRecord = {
+            decision_id: `dec_${Date.now()}`,
+            ts: new Date().toISOString(),
+            intent_id: intentId,
+            decision: args.decision,
+            rationale: args.rationale || '',
+            alternatives_rejected: Array.isArray(args.alternativesRejected) ? args.alternativesRejected : [],
+            evidence_refs: Array.isArray(args.evidenceRefs) ? args.evidenceRefs : [],
+        };
+        this.appendJsonl(decisionsPath, decisionRecord);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, decision: decisionRecord, file: decisionsPath }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Generate handoff brief
+     */
+    async handleGenerateHandoffBrief(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath) {
+            return this.createErrorResponse('Project path is required', ['Provide projectPath']);
+        }
+        const projectFile = join(args.projectPath, 'project.godot');
+        if (!existsSync(projectFile)) {
+            return this.createErrorResponse(`Not a valid Godot project: ${args.projectPath}`, ['Ensure project.godot exists']);
+        }
+        const maxItems = Number.isFinite(Number(args.maxItems)) ? Number(args.maxItems) : 5;
+        const memoryDir = this.getIntentMemoryDir(args.projectPath);
+        const indexPath = join(memoryDir, 'intent-index.json');
+        const decisionsPath = join(memoryDir, 'decision-log.jsonl');
+        const eventsPath = join(memoryDir, 'dev-activity.jsonl');
+        const intents = this.readJsonArray(indexPath);
+        const decisions = this.readJsonl(decisionsPath);
+        const events = this.readJsonl(eventsPath);
+        const activeIntent = intents.find((i) => i && i.status === 'active');
+        const relatedDecisions = decisions.filter((d) => d?.intent_id && activeIntent?.intent_id && d.intent_id === activeIntent.intent_id).slice(-maxItems);
+        const recentEvents = events.slice(-maxItems);
+        const brief = {
+            handoff_id: `handoff_${Date.now()}`,
+            ts: new Date().toISOString(),
+            current_goal: activeIntent?.goal || null,
+            constraints: activeIntent?.constraints || [],
+            acceptance_criteria: activeIntent?.acceptance_criteria || [],
+            open_decisions: relatedDecisions.map((d) => d.decision),
+            recent_actions: recentEvents.map((e) => `${e.ts} ${e.action}`),
+            next_actions: [
+                'Validate active intent against latest user message',
+                'Resolve top open decision and record rationale',
+                'Execute next implementation step and append execution trace',
+            ],
+        };
+        const handoffPath = join(memoryDir, 'handoff-latest.json');
+        writeFileSync(handoffPath, JSON.stringify(brief, null, 2), 'utf8');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, handoff: brief, file: handoffPath }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Summarize current intent context
+     */
+    async handleSummarizeIntentContext(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath) {
+            return this.createErrorResponse('Project path is required', ['Provide projectPath']);
+        }
+        const projectFile = join(args.projectPath, 'project.godot');
+        if (!existsSync(projectFile)) {
+            return this.createErrorResponse(`Not a valid Godot project: ${args.projectPath}`, ['Ensure project.godot exists']);
+        }
+        const memoryDir = this.getIntentMemoryDir(args.projectPath);
+        const indexPath = join(memoryDir, 'intent-index.json');
+        const decisionsPath = join(memoryDir, 'decision-log.jsonl');
+        const intents = this.readJsonArray(indexPath);
+        const decisions = this.readJsonl(decisionsPath);
+        const activeIntent = intents.find((i) => i && i.status === 'active');
+        const relatedDecisions = decisions.filter((d) => d?.intent_id && activeIntent?.intent_id && d.intent_id === activeIntent.intent_id).slice(-3);
+        const summary = {
+            goal: activeIntent?.goal || null,
+            why: activeIntent?.why || null,
+            constraints: activeIntent?.constraints || [],
+            acceptance_criteria: activeIntent?.acceptance_criteria || [],
+            recent_decisions: relatedDecisions.map((d) => ({
+                decision: d.decision,
+                rationale: d.rationale,
+            })),
+            risk: relatedDecisions.length === 0 ? 'No decisions logged yet; context may be weak.' : null,
+            next_action: 'Call generate_handoff_brief after next major change.',
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(summary, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Unified work-step recorder (trace + optional handoff pack refresh)
+     */
+    async handleRecordWorkStep(args) {
+        args = this.normalizeParameters(args);
+        const traceResponse = await this.handleRecordExecutionTrace(args);
+        const refreshHandoffPack = args.refreshHandoffPack !== false;
+        if (!refreshHandoffPack) {
+            return traceResponse;
+        }
+        const handoffResponse = await this.handleExportHandoffPack({
+            projectPath: args.projectPath,
+            maxItems: args.maxItems,
+        });
+        const traceText = traceResponse?.content?.[0]?.text;
+        const handoffText = handoffResponse?.content?.[0]?.text;
+        let tracePayload = null;
+        let handoffPayload = null;
+        try {
+            tracePayload = traceText ? JSON.parse(traceText) : null;
+        }
+        catch { }
+        try {
+            handoffPayload = handoffText ? JSON.parse(handoffText) : null;
+        }
+        catch { }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: !!(tracePayload?.success && handoffPayload?.success),
+                        mode: 'record_work_step',
+                        trace: tracePayload,
+                        handoffPack: handoffPayload,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Record execution trace
+     */
+    async handleRecordExecutionTrace(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath || !args.action || !args.result) {
+            return this.createErrorResponse('Missing required parameters', ['Provide projectPath, action, result']);
+        }
+        const projectFile = join(args.projectPath, 'project.godot');
+        if (!existsSync(projectFile)) {
+            return this.createErrorResponse(`Not a valid Godot project: ${args.projectPath}`, ['Ensure project.godot exists']);
+        }
+        const memoryDir = this.getIntentMemoryDir(args.projectPath);
+        const indexPath = join(memoryDir, 'intent-index.json');
+        const eventsPath = join(memoryDir, 'dev-activity.jsonl');
+        const tracesPath = join(memoryDir, 'execution-trace.jsonl');
+        const intents = this.readJsonArray(indexPath);
+        const activeIntent = intents.find((i) => i && i.status === 'active');
+        const intentId = args.intentId || activeIntent?.intent_id || null;
+        const liteMode = this.recordingMode === 'lite';
+        const trace = {
+            trace_id: `trace_${Date.now()}`,
+            ts: new Date().toISOString(),
+            intent_id: intentId,
+            action: args.action,
+            command: args.command || null,
+            files_changed: Array.isArray(args.filesChanged) ? args.filesChanged : [],
+            result: args.result,
+            artifact: args.artifact || null,
+            error: args.error || null,
+            mode: this.recordingMode,
+        };
+        this.appendJsonl(tracesPath, trace);
+        this.appendJsonl(eventsPath, {
+            ts: new Date().toISOString(),
+            actor: 'mcp-server',
+            action: 'record_execution_trace',
+            intent_id: intentId,
+            result: args.result,
+            summary: liteMode ? `${args.action}:${args.result}` : `${args.action}:${args.result} files=${trace.files_changed.length}`,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, trace, file: tracesPath }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Export handoff pack for team-mode relay
+     */
+    async handleExportHandoffPack(args) {
+        args = this.normalizeParameters(args);
+        if (!args.projectPath) {
+            return this.createErrorResponse('Project path is required', ['Provide projectPath']);
+        }
+        const projectFile = join(args.projectPath, 'project.godot');
+        if (!existsSync(projectFile)) {
+            return this.createErrorResponse(`Not a valid Godot project: ${args.projectPath}`, ['Ensure project.godot exists']);
+        }
+        const maxItems = Number.isFinite(Number(args.maxItems)) ? Number(args.maxItems) : 10;
+        const memoryDir = this.getIntentMemoryDir(args.projectPath);
+        const indexPath = join(memoryDir, 'intent-index.json');
+        const decisionsPath = join(memoryDir, 'decision-log.jsonl');
+        const tracesPath = join(memoryDir, 'execution-trace.jsonl');
+        const intents = this.readJsonArray(indexPath);
+        const decisions = this.readJsonl(decisionsPath);
+        const traces = this.readJsonl(tracesPath);
+        const activeIntent = intents.find((i) => i && i.status === 'active');
+        const intentId = activeIntent?.intent_id || null;
+        const relatedDecisions = decisions.filter((d) => d?.intent_id && intentId && d.intent_id === intentId).slice(-maxItems);
+        const relatedTraces = traces.filter((t) => t?.intent_id && intentId && t.intent_id === intentId).slice(-maxItems);
+        const handoffPack = {
+            pack_id: `pack_${Date.now()}`,
+            ts: new Date().toISOString(),
+            mode: this.recordingMode,
+            intent: activeIntent || null,
+            decisions: relatedDecisions,
+            execution_traces: relatedTraces,
+            summary: {
+                decisions_count: relatedDecisions.length,
+                traces_count: relatedTraces.length,
+                latest_result: relatedTraces.length > 0 ? relatedTraces[relatedTraces.length - 1].result : null,
+            },
+            next_actions: [
+                'Check intent acceptance criteria against latest changes',
+                'Resolve remaining open decisions',
+                'Execute next highest-priority trace and record result',
+            ],
+        };
+        const packPath = join(memoryDir, 'handoff_pack.json');
+        writeFileSync(packPath, JSON.stringify(handoffPack, null, 2), 'utf8');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, file: packPath, handoffPack }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Set recording mode
+     */
+    async handleSetRecordingMode(args) {
+        args = this.normalizeParameters(args);
+        const mode = `${args.mode || ''}`.toLowerCase();
+        if (mode !== 'lite' && mode !== 'full') {
+            return this.createErrorResponse('Invalid mode', ['Use mode="lite" or mode="full"']);
+        }
+        this.recordingMode = mode;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, recordingMode: this.recordingMode }, null, 2),
+                },
+            ],
+        };
+    }
+    /**
+     * Get recording mode
+     */
+    async handleGetRecordingMode() {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        recordingMode: this.recordingMode,
+                        queueSize: this.logQueue.length,
+                        flushIntervalMs: this.logFlushIntervalMs,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
     /**
      * Handle the create_scene tool
      */
@@ -5397,7 +6524,9 @@ class GodotServer {
             const transport = new StdioServerTransport();
             await this.server.connect(transport);
             console.error('Godot MCP server running on stdio');
-            this.startHealthServer();
+            // Start the Godot Editor Bridge (WebSocket server for editor plugin)
+            await this.godotBridge.start();
+            console.error('[SERVER] Godot Editor Bridge started on port 6505');
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
@@ -5405,78 +6534,6 @@ class GodotServer {
             process.exit(1);
         }
     }
-    /**
-     * Start a lightweight HTTP server for health checks from Godot editor plugin.
-     * Supports GET /health and POST / (MCP initialize handshake).
-     */
-    startHealthServer() {
-        const httpServer = createServer((req, res) => {
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept');
-            if (req.method === 'OPTIONS') {
-                res.writeHead(204);
-                res.end();
-                return;
-            }
-            if (req.method === 'GET' && (req.url === '/health' || req.url === '/')) {
-                const payload = {
-                    status: 'ok',
-                    serverName: 'godot-mcp',
-                    version: '1.1.0',
-                    godotPath: this.godotPath,
-                    uptime: process.uptime(),
-                    timestamp: new Date().toISOString(),
-                };
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(payload));
-                return;
-            }
-            if (req.method === 'POST' && (req.url === '/' || req.url === '/mcp')) {
-                let body = '';
-                req.on('data', (chunk) => { body += chunk.toString(); });
-                req.on('end', () => {
-                    try {
-                        const parsed = JSON.parse(body);
-                        if (parsed.method === 'initialize') {
-                            const response = {
-                                jsonrpc: '2.0',
-                                id: parsed.id ?? 1,
-                                result: {
-                                    protocolVersion: parsed.params?.protocolVersion || '2025-06-18',
-                                    capabilities: {},
-                                    serverInfo: { name: 'godot-mcp', version: '1.1.0' },
-                                },
-                            };
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify(response));
-                            return;
-                        }
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Unsupported method' }));
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON' }));
-                    }
-                });
-                return;
-            }
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Not found' }));
-        });
-        httpServer.listen(HEALTH_PORT, () => {
-            console.error(`[SERVER] Health endpoint: http://localhost:${HEALTH_PORT}/health`);
-        });
-        httpServer.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                console.error(`[SERVER] Port ${HEALTH_PORT} in use — health endpoint disabled`);
-            }
-            else {
-                console.error(`[SERVER] Health endpoint error: ${err.message}`);
-            }
-        });
-    }
     // ============================================
     // 2D Tile Tools Handlers
     // ============================================
@@ -6265,6 +7322,40 @@ uniform float dissolve_amount : hint_range(0.0, 1.0) = 0.0;
         }
         return await this.executeOperation('modify_resource', params, projectPath);
     }
+    async handleMapProject(args) {
+        const projectPath = args?.projectPath || args?.project_path;
+        if (!projectPath) {
+            throw new McpError(ErrorCode.InvalidParams, 'projectPath is required');
+        }
+        const root = args?.root || 'res://';
+        const includeAddons = args?.include_addons || false;
+        const result = mapProject(projectPath, root, includeAddons);
+        if (!result.ok || !result.project_map) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ ok: false, error: result.error || 'Failed to map project' }) }],
+                isError: true,
+            };
+        }
+        setProjectPath(projectPath);
+        try {
+            const url = await serveVisualization(result.project_map, this.godotBridge);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            ok: true,
+                            url,
+                            total_scripts: result.project_map.total_scripts,
+                            total_connections: result.project_map.total_connections,
+                            message: `Interactive project map opened at ${url} — ${result.project_map.total_scripts} scripts, ${result.project_map.total_connections} connections`,
+                        }, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ ok: false, error: `Failed to start visualizer: ${errMsg}`, project_map: result.project_map }) }],
+            };
+        }
+    }
 }
 // Create and run the server
 const server = new GodotServer();