atabey-mcp 0.0.7 → 0.0.8

package/{src/constants.ts → dist/constants.js}

@@ -1,12 +1,9 @@
 import path from "path";
-
 /**
  * Agent Atabey — Single Source of Truth for framework constants.
  * Import from here instead of hardcoding paths, phases, or directory names.
  */
-
 // ─── Framework identity ───────────────────────────────────────────────────
-
 export const FRAMEWORK = {
     NAME: "Agent Atabey",
     CORE_DIR: ".atabey",
@@ -17,7 +14,6 @@ export const FRAMEWORK = {
     // This is where all skills are stored
     SKILLS_DIR: "skills",
 };
-
 export const FRAMEWORK_SUBDIRS = {
     AGENTS: "agents",
     SKILLS: "skills",
@@ -28,26 +24,22 @@ export const FRAMEWORK_SUBDIRS = {
     LOGS: "logs",
     CONFIG: "config",
 };
-
 export const ROOT_CONFIG_FILES = {
     MCP: "mcp.json",
     NATIVE_MODULES: "native-modules.json",
     TSCONFIG: "tsconfig.json",
     ESLINT: "eslint.config.js",
 };
-
 export const MCP = {
     // Environment variable used by MCP to identify project root
     PROJECT_ROOT_ENV: "ATABEY_PROJECT_ROOT",
     // Environment variable for test mode
     TEST_DIR_ENV: "ATABEY_TEST_DIR",
 };
-
 export const MEMORY_FILES = {
     STATE: "state.json",
     SHARED_FACTS: "shared_facts.json",
 };
-
 export const NATIVE_AGENT_PATHS = {
     gemini: ".gemini/agents",
     claude: ".claude/agents",
@@ -56,23 +48,17 @@ export const NATIVE_AGENT_PATHS = {
     grok: ".grok",
     "antigravity-cli": ".agents/agents",
 };
-
 // ─── Backward-compatible aliases ──────────────────────────────────────────
-
 export const CORE_FRAMEWORK_DIR = FRAMEWORK.CORE_DIR;
 export const UNIFIED_HUB_DIR = FRAMEWORK.UNIFIED_HUB_DIR;
 export const SKILLS_HUB_PATH = pathJoin(UNIFIED_HUB_DIR, FRAMEWORK_SUBDIRS.SKILLS);
-
 // ─── Path Helpers ─────────────────────────────────────────────────────────
-
-function pathJoin(...args: string[]): string {
+function pathJoin(...args) {
     return path.join(...args);
 }
-
-function corePath(subdir: string, filename: string): string {
+function corePath(subdir, filename) {
     return pathJoin(FRAMEWORK.CORE_DIR, subdir, filename);
 }
-
-export function knowledgePath(filename: string): string {
+export function knowledgePath(filename) {
     return corePath(FRAMEWORK_SUBDIRS.KNOWLEDGE, filename);
 }

package/{src/index.ts → dist/index.js}

@@ -4,55 +4,39 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-    CallToolRequestSchema,
-    ListToolsRequestSchema,
-    ListResourcesRequestSchema,
-    ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { TOOLS, toolHandlers } from "./tools/index.js";
 import { RESOURCES, handleReadResource } from "./resources/index.js";
-
-
 // ─── Server Setup ─────────────────────────────────────────────────
-
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 // Robustly find package.json by walking up from __dirname
-function findPackageJson(startDir: string): string {
+function findPackageJson(startDir) {
     let currentDir = startDir;
     while (currentDir !== path.parse(currentDir).root) {
         const pkgPath = path.join(currentDir, "package.json");
-        if (fs.existsSync(pkgPath)) return pkgPath;
+        if (fs.existsSync(pkgPath))
+            return pkgPath;
         currentDir = path.dirname(currentDir);
     }
     throw new Error("Could not find package.json for atabey-mcp");
 }
-
 const pkgPath = findPackageJson(__dirname);
 const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
 const serverVersion = pkg.version;
-
-const server = new Server(
-    {
-        name: "atabey-mcp",
-        version: serverVersion,
+const server = new Server({
+    name: "atabey-mcp",
+    version: serverVersion,
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
     },
-    {
-        capabilities: {
-            tools: {},
-            resources: {},
-        },
-    }
-);
-
+});
 // Basic Schema Validator for Required Fields
-function validateArgs(toolName: string, args: Record<string, unknown>): string | null {
+function validateArgs(toolName, args) {
     const definition = TOOLS.find(t => t.name === toolName);
-    if (!definition) return `Unknown tool: ${toolName}`;
-    
+    if (!definition)
+        return `Unknown tool: ${toolName}`;
     const required = definition.inputSchema.required || [];
     for (const field of required) {
         if (args[field] === undefined || args[field] === null || args[field] === "") {
@@ -61,22 +45,19 @@ function validateArgs(toolName: string, args: Record<string, unknown>): string |
     }
     return null;
 }
-
 server.setRequestHandler(ListToolsRequestSchema, async (request) => {
     // 2026 Stateless Spec: Log client info from metadata if available
-    const meta = (request as { _meta?: { client?: { name?: string; version?: string } } })._meta;
+    const meta = request._meta;
     if (meta) {
         process.stderr.write(`[MCP] Stateless ListTools from ${meta.client?.name || "unknown"} v${meta.client?.version || "?.?"}\n`);
     }
     return { tools: TOOLS };
 });
-
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
     return { resources: RESOURCES };
 });
-
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const uri = (request as { params: { uri: string } }).params.uri;
+    const uri = request.params.uri;
     try {
         const content = await handleReadResource(uri);
         return {
@@ -88,84 +69,75 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
                 },
             ],
         };
-    } catch (error: unknown) {
+    }
+    catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to read resource: ${message}`, { cause: error });
     }
 });
-
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const req = request as { params: { name: string, arguments?: Record<string, unknown> } };
+    const req = request;
     const { name, arguments: args } = req.params;
-    const meta = (request as { _meta?: { client?: { name?: string; version?: string } } })._meta;
-    
+    const meta = request._meta;
     // 2026 Stateless Spec: Prioritize metadata-driven context
     if (meta) {
         process.stderr.write(`[MCP] Stateless CallTool: ${name} (Client: ${meta.client?.name || "unknown"})\n`);
     }
-
     const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
-
     try {
         const handler = toolHandlers[name];
         if (!handler) {
             return {
                 isError: true,
-                content: [{ type: "text" as const, text: `[ERROR] Unknown tool: ${name}` }],
+                content: [{ type: "text", text: `[ERROR] Unknown tool: ${name}` }],
             };
         }
-
         // [SECURITY] Runtime Validation
         const validationError = validateArgs(name, args || {});
         if (validationError) {
             return {
                 isError: true,
-                content: [{ type: "text" as const, text: `[ERROR] Validation Error: ${validationError}` }],
+                content: [{ type: "text", text: `[ERROR] Validation Error: ${validationError}` }],
             };
         }
-        
         return await handler(projectRoot, args || {});
-    } catch (error: unknown) {
+    }
+    catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error occurred";
         return {
             isError: true,
-            content: [{ type: "text" as const, text: `[ERROR] Execution failed: ${message}` }],
+            content: [{ type: "text", text: `[ERROR] Execution failed: ${message}` }],
         };
     }
 });
-
 // ─── Graceful Startup & Shutdown ──────────────────────────────────
-
 async function run() {
     const transport = new StdioServerTransport();
-
     // Prevent unhandled errors from crashing the MCP stream
-    process.on("uncaughtException", (error: Error) => {
+    process.on("uncaughtException", (error) => {
         process.stderr.write(`[atabey-mcp] Uncaught exception: ${error.message}
 `);
     });
-    process.on("unhandledRejection", (reason: unknown) => {
+    process.on("unhandledRejection", (reason) => {
         const message = reason instanceof Error ? reason.message : String(reason);
         process.stderr.write(`[atabey-mcp] Unhandled rejection: ${message}
 `);
     });
-
     // Graceful shutdown on SIGINT/SIGTERM
     const shutdown = async () => {
         try {
             await server.close();
-        } catch {
+        }
+        catch {
             // Already closed or failed — safe to ignore
         }
         process.exit(0);
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-
     await server.connect(transport);
 }
-
-run().catch((error: Error) => {
+run().catch((error) => {
     process.stderr.write(`[atabey-mcp] Fatal startup error: ${error.message}
 `);
     process.exit(1);

package/{src/resources/index.ts → dist/resources/index.js}

@@ -1,5 +1,4 @@
-import { Storage, AgentRow, TaskRow } from "../../../src/shared/storage.js";
-
+import { Storage } from "../../../src/shared/storage.js";
 /**
  * [DATA] MCP Resource Definitions
  */
@@ -23,43 +22,37 @@ export const RESOURCES = [
         mimeType: "text/markdown"
     }
 ];
-
-export async function handleReadResource(uri: string): Promise<string> {
+export async function handleReadResource(uri) {
     if (uri === "atabey://army/status") {
         const agents = Storage.getAllAgents();
         let md = "# [AI] Agent Army Status\n\n| Agent | State | Active Task | Last Updated |\n| :--- | :--- | :--- | :--- |\n";
-        agents.forEach((a: AgentRow) => {
+        agents.forEach((a) => {
             md += `| @${a.name} | ${a.state} | ${a.task} | ${a.last_updated} |\n`;
         });
         return md;
     }
-
     if (uri === "atabey://plan/active") {
         const tasks = Storage.getTasks();
         let md = "# 📋 Active Execution Plan\n\n| ID | Task | Agent | Status | Dependencies |\n| :--- | :--- | :--- | :--- | :--- |\n";
-        tasks.forEach((t: TaskRow) => {
+        tasks.forEach((t) => {
             const deps = t.dependencies.join(", ") || "-";
             md += `| ${t.id} | ${t.description} | ${t.agent} | ${t.status} | ${deps} |\n`;
         });
         return md;
     }
-
     if (uri === "atabey://memory/project") {
         const fs = await import("fs");
         const path = await import("path");
         const { getFrameworkDir } = await import("../../../src/cli/utils/memory.js");
-        
         const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
         const fwDir = getFrameworkDir();
         const p = path.isAbsolute(fwDir)
             ? path.join(fwDir, "memory", "PROJECT_MEMORY.md")
             : path.join(projectRoot, fwDir, "memory", "PROJECT_MEMORY.md");
-        
         if (fs.existsSync(p)) {
             return fs.readFileSync(p, "utf8");
         }
         return "Project memory not found. Run 'atabey init' first.";
     }
-
     throw new Error(`Unknown resource URI: ${uri}`);
 }

package/dist/src/cli/adapters/core.js

@@ -2,6 +2,7 @@ import fs from "fs";
 import path from "path";
 import { writeJsonFile } from "../utils/fs.js";
 import { getPackageRoot } from "../utils/pkg.js";
+import { MCP } from "../../shared/constants.js";
 import { ADAPTER_CONFIGS, POST_INIT_HANDLERS } from "../../modules/adapters/definitions.js";
 export const ADAPTERS = ADAPTER_CONFIGS;
 export const SHIM_FILES = Object.keys(ADAPTERS).map((id) => ADAPTERS[id].shimFile);
@@ -25,7 +26,7 @@ export function buildMcpServerEntry(projectRoot) {
     let relativePath;
     if (isLocalFrameworkDev) {
         // In local framework dev, always use the build path directly relative to project root
-        let mcpServerPath = path.join(packageRoot, "framework-mcp/dist/index.js");
+        let mcpServerPath = path.join(packageRoot, MCP.SERVER_DIST_PATH);
         if (!fs.existsSync(mcpServerPath)) {
             mcpServerPath = path.join(packageRoot, "../atabey-mcp/dist/index.js");
         }
@@ -39,39 +40,31 @@ export function buildMcpServerEntry(projectRoot) {
     }
     else {
         // If we are initializing in a user's project:
-        // We want to target the local node_modules of the user's project.
-        // Even if node_modules is not populated yet (e.g. running via npx before npm install),
-        // we should write the local node_modules path so that it will work once installed.
-        const localAtabeyPath = path.join(projectRoot, "node_modules/atabey/framework-mcp/dist/index.js");
-        const localScopedPath = path.join(projectRoot, "node_modules/atabey-mcp/dist/index.js");
-        if (fs.existsSync(localScopedPath)) {
-            relativePath = path.relative(projectRoot, localScopedPath);
-        }
-        else if (fs.existsSync(localAtabeyPath)) {
-            relativePath = path.relative(projectRoot, localAtabeyPath);
-        }
-        else {
-            // Default to the standard relative local path in node_modules/atabey
-            // This is clean and portable across machines/developers.
-            relativePath = "node_modules/atabey/framework-mcp/dist/index.js";
+        // We target the atabey-mcp package which is a dependency of atabey.
+        // This ensures a stable path across different npm/pnpm/yarn setups.
+        relativePath = "node_modules/atabey-mcp/dist/index.js";
+        // Fallback check if it actually exists in a different location during init
+        const localAtabeyPath = path.join(projectRoot, "node_modules/atabey", MCP.SERVER_DIST_PATH);
+        if (!fs.existsSync(path.join(projectRoot, relativePath)) && fs.existsSync(localAtabeyPath)) {
+            relativePath = path.join("node_modules/atabey", MCP.SERVER_DIST_PATH);
         }
     }
     return {
         command: "node",
         args: [relativePath],
         env: {
-            ATABEY_PROJECT_ROOT: projectRoot,
+            [MCP.PROJECT_ROOT_ENV]: projectRoot,
         },
     };
 }
 export function runAdapterPostInit(adapter, projectRoot) {
     const mcpEntry = buildMcpServerEntry(projectRoot);
-    const mcpBlock = { mcpServers: { "atabey": mcpEntry } };
+    const mcpBlock = { mcpServers: { [MCP.SERVER_NAME]: mcpEntry } };
     const postInitFn = POST_INIT_HANDLERS[adapter.id];
     if (postInitFn) {
         postInitFn(projectRoot, mcpBlock);
     }
-    const rootMcpPath = path.join(projectRoot, "mcp.json");
+    const rootMcpPath = path.join(projectRoot, MCP.ROOT_CONFIG_FILE);
     if (!fs.existsSync(rootMcpPath)) {
         writeJsonFile(rootMcpPath, mcpBlock);
     }

package/dist/src/shared/constants.js

@@ -143,6 +143,7 @@ export const MCP = {
     ROOT_CONFIG_FILE: "mcp.json",
     PROJECT_ROOT_ENV: "ATABEY_PROJECT_ROOT",
     TEST_DIR_ENV: "ATABEY_TEST_DIR",
+    SERVER_DIST_PATH: "framework-mcp/dist/index.js",
 };
 export const ROOT_CONFIG_FILES = {
     MCP: MCP.ROOT_CONFIG_FILE,

package/{src/tools/control_plane/locking.ts → dist/tools/control_plane/locking.js}

@@ -1,26 +1,22 @@
 import fs from "fs";
 import path from "path";
-import { ToolResult, AcquireLockArgs, ReleaseLockArgs } from "../types.js";
 import { resolveFrameworkDir } from "../../utils/security.js";
-
 /**
  * Handles acquiring a stateful lock on a resource.
  */
-export async function handleAcquireLock(projectRoot: string, args: AcquireLockArgs): Promise<ToolResult> {
+export async function handleAcquireLock(projectRoot, args) {
     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(lockDir))
+            fs.mkdirSync(lockDir, { recursive: true });
         // Check for stale lock first
         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,
@@ -32,21 +28,21 @@ export async function handleAcquireLock(projectRoot: string, args: AcquireLockAr
             try {
                 fs.renameSync(lockPath, tempLockPath);
                 fs.unlinkSync(tempLockPath);
-            } catch {
+            }
+            catch {
                 // If rename failed, it means another agent already evicting/deleting it.
                 // Do not delete anything else; proceed and let writeFileSync (wx flag) fail if a new lock exists.
             }
         }
-
         // Use 'wx' flag for atomic file creation
         const lockData = JSON.stringify({ agent, timestamp: new Date().toISOString() });
         fs.writeFileSync(lockPath, lockData, { flag: "wx" });
-        
         return {
             content: [{ type: "text", text: `[OK] Lock acquired for resource '${resource}' by ${agent}.` }]
         };
-    } catch (e) {
-        const error = e as { code?: string };
+    }
+    catch (e) {
+        const error = e;
         if (error.code === "EEXIST") {
             return {
                 isError: true,
@@ -59,20 +55,17 @@ export async function handleAcquireLock(projectRoot: string, args: AcquireLockAr
         };
     }
 }
-
 /**
  * Handles releasing a lock.
  */
-export async function handleReleaseLock(projectRoot: string, args: ReleaseLockArgs): Promise<ToolResult> {
+export async function handleReleaseLock(projectRoot, args) {
     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 {
@@ -80,10 +73,10 @@ export async function handleReleaseLock(projectRoot: string, args: ReleaseLockAr
                 content: [{ type: "text", text: `[ERROR] Denied: You do not own the lock for '${resource}'. Owned by ${lockData.agent}.` }]
             };
         }
-
         fs.unlinkSync(lockPath);
         return { content: [{ type: "text", text: `[OK] Lock released for resource '${resource}' by ${agent}.` }] };
-    } catch (e) {
+    }
+    catch (e) {
         return { isError: true, content: [{ type: "text", text: `Failed to release lock: ${String(e)}` }] };
     }
 }

package/{src/tools/control_plane/registry.ts → dist/tools/control_plane/registry.js}

@@ -1,21 +1,18 @@
 import fs from "fs";
 import path from "path";
-import { ToolResult, RegisterAgentArgs } from "../types.js";
 import { resolveFrameworkDir } from "../../utils/security.js";
-
 /**
  * Handles agent registration with the Control Plane.
  * This can be used to validate permissions and active status.
  */
-export async function handleRegisterAgent(projectRoot: string, args: RegisterAgentArgs): Promise<ToolResult> {
+export async function handleRegisterAgent(projectRoot, args) {
     const { agent, role, capability = 5, specialties } = 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 });
-
+        if (!fs.existsSync(registryDir))
+            fs.mkdirSync(registryDir, { recursive: true });
         const agentData = {
             agent,
             role,
@@ -24,13 +21,12 @@ export async function handleRegisterAgent(projectRoot: string, args: RegisterAge
             last_seen: new Date().toISOString(),
             status: "ACTIVE"
         };
-
         fs.writeFileSync(agentFile, JSON.stringify(agentData, null, 2));
-        
         return {
             content: [{ type: "text", text: `[ATABEY] Agent ${agent} (${role}) registered successfully in the Atabey Control Plane.` }]
         };
-    } catch (e) {
+    }
+    catch (e) {
         return {
             isError: true,
             content: [{ type: "text", text: `Failed to register agent: ${String(e)}` }]

package/{src/tools/definitions.ts → dist/tools/definitions.js}

@@ -1,6 +1,4 @@
-import { ToolDefinition } from "../tools/types.js";
-
-export const TOOLS: ToolDefinition[] = [
+export const TOOLS = [
     {
         name: "read_file",
         description: "Read the content of a file within the project. Supports optional line range reading to prevent stream overload.",
@@ -321,4 +319,4 @@ export const TOOLS: ToolDefinition[] = [
             required: ["path"],
         },
     }
-];
+];

package/{src/tools/file_system/batch_surgical_edit.ts → dist/tools/file_system/batch_surgical_edit.js}

@@ -1,53 +1,37 @@
 import fs from "fs";
 import { safePath } from "../../utils/security.js";
 import { writeTextFileAtomic } from "../../utils/fs.js";
-import { BatchSurgicalEditArgs, ToolResult } from "../types.js";
 import { Metrics } from "../../utils/metrics.js";
 import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
 import { verifyWritePermission } from "../../utils/permissions.js";
-
-interface SurgicalEdit {
-    path: string;
-    oldText: string;
-    newText: string;
-    allowMultiple?: boolean;
-}
-
 /**
  * Performs multiple surgical text replacements across multiple files in a single batch.
  */
-export async function handleBatchSurgicalEdit(projectRoot: string, args: BatchSurgicalEditArgs): Promise<ToolResult> {
-    const edits = args.edits as SurgicalEdit[];
+export async function handleBatchSurgicalEdit(projectRoot, args) {
+    const edits = args.edits;
     if (!Array.isArray(edits) || edits.length === 0) {
         const err = "No edits provided in the batch request.";
         Metrics.logError(projectRoot, "@mcp", "batch_surgical_edit", err);
         throw new Error(err);
     }
-
-    const results: string[] = [];
+    const results = [];
     let totalTokens = 0;
-
     for (const edit of edits) {
         const filePath = safePath(projectRoot, edit.path);
-        
         // ENFORCE PERMISSION MATRIX
         verifyWritePermission(projectRoot, edit.path);
-        
         if (!fs.existsSync(filePath)) {
             const err = `File not found: ${edit.path}`;
             Metrics.logError(projectRoot, "@mcp", `batch_surgical_edit:${edit.path}`, err);
             throw new Error(err);
         }
-
         const content = fs.readFileSync(filePath, "utf8");
         const { oldText, newText, allowMultiple = false } = edit;
-
         if (!content.includes(oldText)) {
             const err = `Text not found in file ${edit.path}`;
             Metrics.logError(projectRoot, "@mcp", `batch_surgical_edit:${edit.path}`, err);
             throw new Error(err);
         }
-
         // Surgical precision guard
         if (!allowMultiple) {
             const firstIndex = content.indexOf(oldText);
@@ -58,30 +42,23 @@ export async function handleBatchSurgicalEdit(projectRoot: string, args: BatchSu
                 throw new Error(err);
             }
         }
-
-        const newContent = allowMultiple 
+        const newContent = allowMultiple
             ? content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newText)
             : content.replace(oldText, newText);
-
         // ENFORCE CORPORATE COMPLIANCE
         verifyCorporateCompliance(newContent, edit.path);
-
         // ENFORCE RISK & HUMAN APPROVAL GATEWAY
         await verifyRiskAndAwaitApproval(projectRoot, newContent, edit.path);
-
         writeTextFileAtomic(filePath, newContent);
-        
         const tokens = Metrics.estimateTokens(newText);
         totalTokens += tokens;
         results.push(`[OK] 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")}` 
-        }] 
+    return {
+        content: [{
+                type: "text",
+                text: `Successfully performed ${edits.length} edits:\n${results.join("\n")}`
+            }]
     };
 }