agent-enderun 1.1.8 → 1.1.10

package/framework-mcp/src/tools/control_plane/locking.ts

@@ -1,77 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ToolResult } from "../types.js";
-import { resolveFrameworkDir } from "../../utils/security.js";
-
-interface LockArgs {
-    resource: string;
-    agent: string;
-    ttl?: number;
-}
-
-/**
- * Handles acquiring a stateful lock on a resource.
- */
-export async function handleAcquireLock(projectRoot: string, args: LockArgs): Promise<ToolResult> {
-    const { resource, agent, ttl = 60 } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const lockDir = path.join(projectRoot, frameworkDir, "locks");
-    const lockPath = path.join(lockDir, `${resource}.lock`);
-
-    try {
-        if (!fs.existsSync(lockDir)) fs.mkdirSync(lockDir, { recursive: true });
-
-        if (fs.existsSync(lockPath)) {
-            const stat = fs.statSync(lockPath);
-            const now = new Date().getTime();
-            const age = (now - stat.mtimeMs) / 1000;
-
-            if (age < ttl) {
-                return {
-                    isError: true,
-                    content: [{ type: "text", text: `Resource '${resource}' is currently locked by another agent.` }]
-                };
-            }
-            // Lock expired, safe to override
-            fs.unlinkSync(lockPath);
-        }
-
-        fs.writeFileSync(lockPath, JSON.stringify({ agent, timestamp: new Date().toISOString() }));
-        return {
-            content: [{ type: "text", text: `✅ Lock acquired for resource '${resource}' by ${agent}.` }]
-        };
-    } catch (e) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Failed to acquire lock: ${String(e)}` }]
-        };
-    }
-}
-
-/**
- * Handles releasing a lock.
- */
-export async function handleReleaseLock(projectRoot: string, args: LockArgs): Promise<ToolResult> {
-    const { resource, agent } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const lockPath = path.join(projectRoot, frameworkDir, "locks", `${resource}.lock`);
-
-    try {
-        if (!fs.existsSync(lockPath)) {
-            return { content: [{ type: "text", text: `ℹ️ No lock found for resource '${resource}'.` }] };
-        }
-
-        const lockData = JSON.parse(fs.readFileSync(lockPath, "utf8"));
-        if (lockData.agent !== agent) {
-            return {
-                isError: true,
-                content: [{ type: "text", text: `❌ Denied: You do not own the lock for '${resource}'. Owned by ${lockData.agent}.` }]
-            };
-        }
-
-        fs.unlinkSync(lockPath);
-        return { content: [{ type: "text", text: `✅ Lock released for resource '${resource}' by ${agent}.` }] };
-    } catch (e) {
-        return { isError: true, content: [{ type: "text", text: `Failed to release lock: ${String(e)}` }] };
-    }
-}

package/framework-mcp/src/tools/control_plane/registry.ts

@@ -1,44 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ToolResult } from "../types.js";
-import { resolveFrameworkDir } from "../../utils/security.js";
-
-interface RegisterArgs {
-    agent: string;
-    role: string;
-    capability?: number;
-}
-
-/**
- * Handles agent registration with the Control Plane.
- * This can be used to validate permissions and active status.
- */
-export async function handleRegisterAgent(projectRoot: string, args: RegisterArgs): Promise<ToolResult> {
-    const { agent, role, capability = 5 } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const registryDir = path.join(projectRoot, frameworkDir, "registry");
-    const agentFile = path.join(registryDir, `${agent.replace("@", "")}_active.json`);
-
-    try {
-        if (!fs.existsSync(registryDir)) fs.mkdirSync(registryDir, { recursive: true });
-
-        const agentData = {
-            agent,
-            role,
-            capability,
-            last_seen: new Date().toISOString(),
-            status: "ACTIVE"
-        };
-
-        fs.writeFileSync(agentFile, JSON.stringify(agentData, null, 2));
-        
-        return {
-            content: [{ type: "text", text: `🎖️ Agent ${agent} (${role}) registered successfully in the Enderun Control Plane.` }]
-        };
-    } catch (e) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Failed to register agent: ${String(e)}` }]
-        };
-    }
-}

package/framework-mcp/src/tools/dashboard/start_dashboard.ts

@@ -1,33 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { exec } from "child_process";
-import { ToolArgs, ToolResult } from "../types.js";
-
-/**
- * Starts the Enderun Web Dashboard server.
- */
-export function handleStartDashboard(projectRoot: string, args: ToolArgs): ToolResult {
-    const port = args.port || 5858;
-    const dashboardScript = path.join(projectRoot, "bin/enderun-dashboard.js");
-
-    if (!fs.existsSync(dashboardScript)) {
-        throw new Error("Dashboard server script not found in bin/enderun-dashboard.js");
-    }
-
-    try {
-        // Start the dashboard as a background process
-        exec(`node "${dashboardScript}"`, {
-            cwd: projectRoot,
-            env: { ...process.env, PORT: String(port) }
-        });
-
-        return {
-            content: [{
-                type: "text",
-                text: `🖥️ **Enderun Web Dashboard started!**\n\nAccess it at: http://localhost:${port}\n\nThis interface will show real-time agent status, system health, and orchestration logs.`
-            }]
-        };
-    } catch (e) {
-        return { isError: true, content: [{ type: "text", text: `Failed to start dashboard: ${String(e)}` }] };
-    }
-}

package/framework-mcp/src/tools/definitions.ts

@@ -1,272 +0,0 @@
-import { ToolDefinition } from "../tools/types.js";
-
-export const TOOLS: ToolDefinition[] = [
-    {
-        name: "read_file",
-        description: "Read the content of a file within the project. Supports optional line range reading to prevent stream overload.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the file relative to project root" },
-                startLine: { type: "number", description: "Optional starting line number (1-indexed)" },
-                endLine: { type: "number", description: "Optional ending line number (inclusive)" },
-            },
-            required: ["path"],
-        },
-    },
-    {
-        name: "list_dir",
-        description: "List the contents of a directory. Essential for codebase exploration.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the directory relative to project root (default: '.')" },
-            },
-        },
-    },
-    {
-        name: "grep_search",
-        description: "Perform a recursive regex search across the codebase to find functions, variables, or patterns.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                pattern: { type: "string", description: "The regex pattern to search for" },
-                includePattern: { type: "string", description: "Optional: Filter files by extension (e.g., '.ts')" },
-                excludePattern: { type: "string", description: "Optional: Directory pattern to exclude (default: 'node_modules')" },
-            },
-            required: ["pattern"],
-        },
-    },
-    {
-        name: "write_file",
-        description: "Write content to a file. Creates directories if missing.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the file relative to project root" },
-                content: { type: "string", description: "Complete content of the file" },
-            },
-            required: ["path", "content"],
-        },
-    },
-    {
-        name: "replace_text",
-        description: "Surgically replace a string in a file with another string.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the file" },
-                oldText: { type: "string", description: "The exact text to find" },
-                newText: { type: "string", description: "The text to replace it with" },
-                allowMultiple: { type: "boolean", description: "Allow multiple replacements if oldText is not unique." }
-            },
-            required: ["path", "oldText", "newText"],
-        },
-    },
-    {
-        name: "batch_surgical_edit",
-        description: "Perform multiple surgical text replacements across multiple files in a single batch request. More efficient for cross-cutting changes.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                edits: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            path: { type: "string", description: "Path to the file" },
-                            oldText: { type: "string", description: "The exact text to find" },
-                            newText: { type: "string", description: "The text to replace it with" },
-                            allowMultiple: { type: "boolean", description: "Allow multiple replacements in this file." }
-                        },
-                        required: ["path", "oldText", "newText"]
-                    }
-                }
-            },
-            required: ["edits"],
-        },
-    },
-    {
-        name: "patch_file",
-        description: "Safely update a file by replacing a specific line range with new content.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the file" },
-                startLine: { type: "number", description: "Starting line number (1-indexed)" },
-                endLine: { type: "number", description: "Ending line number (inclusive)" },
-                newContent: { type: "string", description: "The new lines to insert" },
-            },
-            required: ["path", "startLine", "endLine", "newContent"],
-        },
-    },
-    {
-        name: "get_project_map",
-        description: "Generate a tree-view map of the project structure to visualize the layout. Useful for onboarding and architectural analysis.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                maxDepth: { type: "number", description: "Maximum directory depth to scan (default: 3)" },
-                includeFiles: { type: "boolean", description: "Whether to include files in the map (default: true)" }
-            }
-        }
-    },
-    {
-        name: "get_project_gaps",
-        description: "Scans the codebase for TODOs, FIXMEs, and empty function bodies. Helps identify what is left and where the agent might have skipped logic.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Path to the source directory (default: 'src')" },
-            },
-        },
-    },
-    {
-        name: "audit_dependencies",
-        description: "Audits package.json for unused, redundant, or duplicate-like packages to ensure a clean dependency tree.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "run_tests",
-        description: "Execute project test suites (Vitest, Playwright, etc.) and capture detailed pass/fail reports for analysis.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                command: { type: "string", description: "The test command to run (default: 'npm test')" }
-            }
-        }
-    },
-    {
-        name: "get_system_health",
-        description: "Retrieve real-time system metrics like CPU load, RAM usage, and uptime.",
-        inputSchema: { type: "object", properties: {} }
-    },
-    {
-        name: "check_active_ports",
-        description: "Identify which network ports are currently active and listening. Helps verify if the dev server or API is running.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                filter: { type: "string", description: "Optional: Filter results by port number or service name (e.g., ':3000')" }
-            }
-        }
-    },
-    {
-        name: "start_dashboard",
-        description: "Start the Enderun Web Dashboard (Command Center) to visualize real-time agent status, logs, and system metrics in the browser.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                port: { type: "number", description: "Optional: Port to run the dashboard on (default: 5858)" }
-            }
-        }
-    },
-    {
-        name: "get_framework_status",
-        description: "Get the current project phase, active traces, and agent states.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "read_project_memory",
-        description: "Read the full project central memory (PROJECT_MEMORY.md). Use this at the start of a session to gain context.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "get_memory_insights",
-        description: "Retrieve a summarized version of the project memory (active phase, trace, and last 5 actions) to save tokens.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "update_project_memory",
-        description: "Update a specific section in PROJECT_MEMORY.md.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                section: { type: "string", description: "Section name (e.g., HISTORY, ACTIVE TASKS)" },
-                content: { type: "string", description: "Markdown content to append or set" },
-            },
-            required: ["section", "content"],
-        },
-    },
-    {
-        name: "orchestrate_loop",
-        description: "Process the pending Hermes messages and trigger dynamic state transitions.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "send_agent_message",
-        description: "Send a Hermes protocol message to another agent for collaboration or sub-tasking.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                from: { type: "string", description: "Sender agent (e.g., @manager, @backend)." },
-                to: { type: "string", description: "Target agent (e.g., @backend, @quality)." },
-                category: { type: "string", enum: ["ACTION", "DELEGATION", "SUBTASK", "REPLY", "ALERT"], description: "Message type." },
-                content: { type: "string", description: "Task description or message content." },
-                traceId: { type: "string", description: "Active Trace ID." },
-                parentId: { type: "string", description: "Optional parent task trace ID for hierarchical tracking." },
-                priority: { type: "string", enum: ["HIGH", "NORMAL", "LOW"], description: "Optional priority level (HIGH, NORMAL, LOW). Defaults to HIGH for ALERT/ACTION." },
-            },
-            required: ["from", "to", "category", "content", "traceId"],
-        },
-    },
-    {
-        name: "acquire_lock",
-        description: "Acquire a stateful lock on a shared resource (like PROJECT_MEMORY.md) to prevent concurrent write conflicts.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                resource: { type: "string", description: "The resource name or path to lock (e.g., 'memory')." },
-                agent: { type: "string", description: "The agent requesting the lock (e.g., '@backend')." },
-                ttl: { type: "number", description: "Time-to-live in seconds before the lock auto-expires (default: 60)." }
-            },
-            required: ["resource", "agent"]
-        }
-    },
-    {
-        name: "release_lock",
-        description: "Release a previously acquired lock on a resource.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                resource: { type: "string", description: "The resource name or path." },
-                agent: { type: "string", description: "The agent releasing the lock." }
-            },
-            required: ["resource", "agent"]
-        }
-    },
-    {
-        name: "register_agent",
-        description: "Register an agent instance with the Control Plane and validate its permissions.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agent: { type: "string", description: "The agent name (e.g., '@backend')." },
-                role: { type: "string", description: "The role of the agent." },
-                capability: { type: "number", description: "The capability score (1-10)." }
-            },
-            required: ["agent", "role"]
-        }
-    },
-    {
-        name: "log_agent_action",
-        description: "Log an agent action to the framework logs.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agent: { type: "string", description: "The agent name (e.g., @manager, @backend)" },
-                action: { type: "string", description: "Action type or name" },
-                traceId: { type: "string", description: "The active Trace ID" },
-                status: { type: "string", enum: ["SUCCESS", "FAILURE"], description: "The status of the action" },
-                summary: { type: "string", description: "Brief description of the action taken" },
-                findings: { type: "string", description: "Optional comma-separated findings or details" }
-            },
-            required: ["agent", "action", "traceId", "status", "summary"]
-        }
-    },
-    {
-        name: "update_contract_hash",
-        description: "Re-generate and synchronize the backend contract SHA-256 hash.",
-        inputSchema: { type: "object", properties: {} }
-    }
-];

package/framework-mcp/src/tools/file_system/batch_surgical_edit.ts

@@ -1,70 +0,0 @@
-import fs from "fs";
-import { safePath } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-import { Metrics } from "../../utils/metrics.js";
-import { verifyCorporateCompliance } from "../../utils/compliance.js";
-
-interface SurgicalEdit {
-    path: string;
-    oldText: string;
-    newText: string;
-    allowMultiple?: boolean;
-}
-
-/**
- * Performs multiple surgical text replacements across multiple files in a single batch.
- */
-export function handleBatchSurgicalEdit(projectRoot: string, args: ToolArgs): ToolResult {
-    const edits = args.edits as SurgicalEdit[];
-    if (!Array.isArray(edits) || edits.length === 0) {
-        throw new Error("No edits provided in the batch request.");
-    }
-
-    const results: string[] = [];
-    let totalTokens = 0;
-
-    for (const edit of edits) {
-        const filePath = safePath(projectRoot, edit.path);
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found: ${edit.path}`);
-        }
-
-        const content = fs.readFileSync(filePath, "utf8");
-        const { oldText, newText, allowMultiple = false } = edit;
-
-        if (!content.includes(oldText)) {
-            throw new Error(`Text not found in file ${edit.path}: "${oldText.slice(0, 50)}..."`);
-        }
-
-        // Surgical precision guard
-        if (!allowMultiple) {
-            const firstIndex = content.indexOf(oldText);
-            const lastIndex = content.lastIndexOf(oldText);
-            if (firstIndex !== lastIndex) {
-                throw new Error(`Ambiguous replacement in ${edit.path}: "${oldText.slice(0, 50)}..." found multiple times.`);
-            }
-        }
-
-        const newContent = allowMultiple 
-            ? content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newText)
-            : content.replace(oldText, newText);
-
-        // ENFORCE CORPORATE COMPLIANCE
-        verifyCorporateCompliance(newContent, edit.path);
-
-        fs.writeFileSync(filePath, newContent);
-        
-        const tokens = Metrics.estimateTokens(newText);
-        totalTokens += tokens;
-        results.push(`✅ Edited ${edit.path}`);
-    }
-
-    Metrics.logUsage(projectRoot, "@mcp", `batch_surgical_edit: ${edits.length} files`, totalTokens);
-
-    return { 
-        content: [{ 
-            type: "text", 
-            text: `Successfully performed ${edits.length} edits:\n${results.join("\n")}` 
-        }] 
-    };
-}

package/framework-mcp/src/tools/file_system/patch_file.ts

@@ -1,29 +0,0 @@
-import fs from "fs";
-import { safePath } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-import { Metrics } from "../../utils/metrics.js";
-
-export function handlePatchFile(projectRoot: string, args: ToolArgs): ToolResult {
-    const filePath = safePath(projectRoot, args.path as string);
-    const lines = fs.readFileSync(filePath, "utf8").split("\n");
-    const start = (args.startLine as number) - 1;
-    const end = args.endLine as number;
-    const newContent = (args.newContent as string).split("\n");
-
-    if (start < 0 || start > lines.length) {
-        throw new Error(`Invalid start line: ${start + 1}. File has ${lines.length} lines.`);
-    }
-    if (end < start + 1 || end > lines.length) {
-        throw new Error(`Invalid end line: ${end}. Must be between ${start + 1} and ${lines.length}.`);
-    }
-
-    lines.splice(start, end - start, ...newContent);
-    fs.writeFileSync(filePath, lines.join("\n"));
-
-    const tokens = Metrics.estimateTokens(args.newContent as string);
-    Metrics.logUsage(projectRoot, "@mcp", `patch_file: ${args.path}`, tokens);
-
-    return { content: [{ type: "text", text: `✅ File patched successfully: ${args.path}` }] };
-}
-
-

package/framework-mcp/src/tools/file_system/read_file.ts

@@ -1,39 +0,0 @@
-import fs from "fs";
-import { safePath } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-import { Metrics } from "../../utils/metrics.js";
-
-export function handleReadFile(projectRoot: string, args: ToolArgs): ToolResult {
-    const filePath = safePath(projectRoot, args.path as string);
-    const startLine = args.startLine !== undefined ? Number(args.startLine) : undefined;
-    const endLine = args.endLine !== undefined ? Number(args.endLine) : undefined;
-
-    const content = fs.readFileSync(filePath, "utf8");
-    const lines = content.split(/\r?\n/);
-    if (startLine !== undefined || endLine !== undefined) {
-        const start = startLine !== undefined ? Math.max(1, startLine) - 1 : 0;
-        const end = endLine !== undefined ? Math.min(lines.length, endLine) : lines.length;
-        const sliced = lines.slice(start, end).join("\n");
-        const tokens = Metrics.estimateTokens(sliced);
-        Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path}`, tokens);
-        return { content: [{ type: "text", text: sliced }] };
-    }
-
-    // Default protection limit: 1000 lines
-    const DEFAULT_MAX_LINES = 1000;
-    if (lines.length > DEFAULT_MAX_LINES) {
-        const sliced = lines.slice(0, DEFAULT_MAX_LINES).join("\n");
-        const tokens = Metrics.estimateTokens(sliced);
-        Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path} (truncated)`, tokens);
-        return {
-            content: [{
-                type: "text",
-                text: `${sliced}\n\n... [TRUNCATED - File is too long (${lines.length} lines). Only the first ${DEFAULT_MAX_LINES} lines are shown. Use startLine and endLine parameters to read other parts of the file.]`
-            }]
-        };
-    }
-
-    const tokens = Metrics.estimateTokens(content);
-    Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path}`, tokens);
-    return { content: [{ type: "text", text: content }] };
-}

package/framework-mcp/src/tools/file_system/replace_text.ts

@@ -1,50 +0,0 @@
-import fs from "fs";
-import { safePath } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-import { Metrics } from "../../utils/metrics.js";
-
-import { verifyCorporateCompliance } from "../../utils/compliance.js";
-
-export function handleReplaceText(projectRoot: string, args: ToolArgs): ToolResult {
-    const filePath = safePath(projectRoot, args.path as string);
-    const content = fs.readFileSync(filePath, "utf8");
-    const oldText = args.oldText as string;
-    const newText = args.newText as string;
-    const allowMultiple = args.allowMultiple || false; // Default to false
-
-    if (!content.includes(oldText)) {
-        throw new Error(`Text not found in file: ${oldText.slice(0, 100)}...`);
-    }
-
-    // Surgical precision guard: reject ambiguous replacements unless allowMultiple is true.
-    if (!allowMultiple) {
-        const firstIndex = content.indexOf(oldText);
-        const lastIndex = content.lastIndexOf(oldText);
-        if (firstIndex !== lastIndex) {
-            const count = (content.match(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) || []).length;
-            throw new Error(
-                `Ambiguous replacement: "${oldText.slice(0, 80)}..." found ${count} times in ${args.path}. ` +
-                "Provide a longer, unique context string or set 'allow_multiple' to true."
-            );
-        }
-    }
-
-    // Perform replacement(s)
-    let newContent: string;
-    if (allowMultiple) {
-        newContent = content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newText);
-    } else {
-        newContent = content.replace(oldText, newText);
-    }
-
-    // ENFORCE CORPORATE COMPLIANCE
-    verifyCorporateCompliance(newContent, args.path as string);
-    
-    fs.writeFileSync(filePath, newContent);
-
-    const tokens = Metrics.estimateTokens(newText);
-    Metrics.logUsage(projectRoot, "@mcp", `replace_text: ${args.path}`, tokens);
-
-    return { content: [{ type: "text", text: `✅ Surgical edit successful in ${args.path}` }] };
-}
-

package/framework-mcp/src/tools/file_system/write_file.ts

@@ -1,33 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { safePath, resolveFrameworkDir } from "../../utils/security.js";
-import { Metrics } from "../../utils/metrics.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-import { verifyCorporateCompliance } from "../../utils/compliance.js";
-
-export function handleWriteFile(projectRoot: string, args: ToolArgs): ToolResult {
-    const filePath = safePath(projectRoot, args.path as string);
-    const content = args.content as string;
-    
-    // ENFORCE CORPORATE COMPLIANCE
-    verifyCorporateCompliance(content, args.path as string);
-
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-    
-    // AUTO-LOGGING & METRICS
-    const tokens = Metrics.estimateTokens(content);
-    Metrics.logUsage(projectRoot, "@mcp", `write_file: ${args.path}`, tokens);
-
-    try {
-        const frameworkDir = resolveFrameworkDir(projectRoot);
-        const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
-        if (fs.existsSync(memoryPath)) {
-            const entry = `\n### ${new Date().toISOString().split("T")[0]} — Auto-Update\n- **Action:** wrote file \`${args.path}\` (${tokens} tokens estimated).\n`;
-            fs.appendFileSync(memoryPath, entry);
-        }
-    } catch { /* ignore memory logging errors */ }
-
-    return { content: [{ type: "text", text: `✅ File written: ${args.path}` }] };
-}