@mandujs/mcp 0.37.0 → 0.37.2

package/README.md

@@ -136,10 +136,9 @@ bunx @mandujs/mcp --root /path/to/project
 
 ### Semantic Slots (RFC-001) 🆕
 
-| Tool | Description |
-|------|-------------|
-| `mandu_validate_slot` | Validate slot against constraints |
-| `mandu_validate_slots` | Batch validate multiple slots |
+| Tool | Description |
+|------|-------------|
+| `mandu_get_slot_constraints` | Get recommended slot constraint presets |
 
 ### Architecture Negotiation (RFC-001) 🆕
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/mcp",
-  "version": "0.37.0",
+  "version": "0.37.2",
   "description": "Mandu MCP Server - Agent-native interface for Mandu framework operations",
   "type": "module",
   "main": "./src/index.ts",
@@ -34,9 +34,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@mandujs/core": "^0.54.0",
-    "@mandujs/ate": "^1.0.0",
-    "@mandujs/skills": "^0.20.0",
+    "@mandujs/core": "^0.54.2",
+    "@mandujs/ate": "^0.26.1",
+    "@mandujs/skills": "^0.20.1",
     "@modelcontextprotocol/sdk": "^1.25.3"
   },
   "engines": {

package/src/prompts.ts

@@ -48,10 +48,10 @@ Follow these steps using Mandu MCP tools:
 1. Read current route manifest: Resource mandu://routes
 2. Read project config: Resource mandu://config
 3. Negotiate the feature spec: Tool mandu.negotiate
-4. Generate scaffold: Tool mandu.negotiate.scaffold
-5. If client interactivity needed, create island: Tool mandu_create_island
-   Use the declarative pattern: island('visible', Component)
-6. If data requirements exist, create slot: Tool mandu_create_slot
+4. Generate scaffold: Tool mandu.negotiate.scaffold
+5. If client interactivity needed, create island: Tool mandu_create_island
+   Use @mandujs/core/client with wrapComponent(Component) or island({ setup, render })
+6. If data requirements exist, create slot: Tool mandu_create_slot
    Slots are server-side data loaders that run before render
 7. If API is exposed, define contract: Tool mandu_create_contract
    Contracts are Zod schemas for validation and OpenAPI generation

package/src/resources/skills/mandu-deployment/rules/db-provider-supabase.md

@@ -138,8 +138,8 @@ export function createServerSupabase() {
 Mandu 의 client island 에서 Realtime 구독:
 
 ```tsx
-// app/messages/MessagesIsland.client.tsx
-import { island } from "@mandujs/core/client";
+// app/messages/MessagesIsland.client.tsx
+import { wrapComponent } from "@mandujs/core/client";
 import { useEffect, useState } from "react";
 import { supabase } from "@/lib/supabase";
 
@@ -174,7 +174,7 @@ function Messages() {
   );
 }
 
-export default island("visible", <Messages />);
+export default wrapComponent(Messages);
 ```
 
 ### 3.3 Storage

package/src/tools/ate.ts

@@ -105,7 +105,11 @@ export const ateToolDefinitions: Tool[] = [
           type: "string",
           description: "Dev server URL (default: http://localhost:3333). Must match the running mandu dev server.",
         },
-        ci: { type: "boolean", description: "CI mode: stricter timeouts, no interactive prompts" },
+        ci: { type: "boolean", description: "CI mode: stricter timeouts, no interactive prompts" },
+        timeoutMs: {
+          type: "number",
+          description: "Hard timeout for the whole Playwright process in milliseconds (default: 600000).",
+        },
         headless: { type: "boolean", description: "Run browsers headlessly (default: true)" },
         browsers: {
           type: "array",
@@ -260,7 +264,11 @@ export const ateToolDefinitions: Tool[] = [
           enum: ["L0", "L1", "L2", "L3"],
           description: "Assertion depth: L0=smoke, L1=HTTP status, L2=contract schema, L3=full behavioral",
         },
-        ci: { type: "boolean", description: "CI mode: stricter timeouts" },
+        ci: { type: "boolean", description: "CI mode: stricter timeouts" },
+        timeoutMs: {
+          type: "number",
+          description: "Hard timeout for the whole Playwright process in milliseconds (default: 600000).",
+        },
         useImpactAnalysis: {
           type: "boolean",
           description: "Run impact analysis first and only test changed routes (faster in CI)",
@@ -378,7 +386,7 @@ export function ateTools(projectRoot: string, server?: Server) {
       return await ateRun(input);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const isTimeout = /timed out/i.test(message);
+      const isTimeout = /timeout|timed out|타임아웃/i.test(message);
       const snap = tracker.snapshot();
       const partial: PartialRunResults = {
         runId: snap.runId ?? `unknown-${Date.now()}`,
@@ -439,19 +447,21 @@ export function ateTools(projectRoot: string, server?: Server) {
         browsers,
         onlyFiles,
         onlyRoutes,
-        grep,
-        progressToken,
-      } = args as {
+        grep,
+        timeoutMs,
+        progressToken,
+      } = args as {
         repoRoot: string;
         baseURL?: string;
         ci?: boolean;
         headless?: boolean;
         browsers?: ("chromium" | "firefox" | "webkit")[];
         onlyFiles?: string[];
-        onlyRoutes?: string[];
-        grep?: string;
-        progressToken?: string | number;
-      };
+        onlyRoutes?: string[];
+        grep?: string;
+        timeoutMs?: number;
+        progressToken?: string | number;
+      };
       return await runWithObservability(
         {
           repoRoot,
@@ -459,10 +469,11 @@ export function ateTools(projectRoot: string, server?: Server) {
           ci,
           headless,
           browsers,
-          onlyFiles,
-          onlyRoutes,
-          grep,
-        },
+          onlyFiles,
+          onlyRoutes,
+          grep,
+          timeoutMs,
+        },
         { progressToken },
       );
     },
@@ -518,9 +529,10 @@ export function ateTools(projectRoot: string, server?: Server) {
     },
     "mandu.ate.auto_pipeline": async (args: Record<string, unknown>) => {
       const {
-        repoRoot, baseURL, oracleLevel, ci, useImpactAnalysis,
-        base, head, autoHeal, tsconfigPath, routeGlobs, buildSalt,
-      } = args as {
+        repoRoot, baseURL, oracleLevel, ci, useImpactAnalysis,
+        base, head, autoHeal, tsconfigPath, routeGlobs, buildSalt,
+        timeoutMs,
+      } = args as {
         repoRoot: string;
         baseURL?: string;
         oracleLevel?: OracleLevel;
@@ -530,13 +542,14 @@ export function ateTools(projectRoot: string, server?: Server) {
         head?: string;
         autoHeal?: boolean;
         tsconfigPath?: string;
-        routeGlobs?: string[];
-        buildSalt?: string;
-      };
-      return await runFullPipeline({
-        repoRoot, baseURL, oracleLevel, ci, useImpactAnalysis,
-        base, head, autoHeal, tsconfigPath, routeGlobs, buildSalt,
-      });
+        routeGlobs?: string[];
+        buildSalt?: string;
+        timeoutMs?: number;
+      };
+      return await runFullPipeline({
+        repoRoot, baseURL, oracleLevel, ci, useImpactAnalysis,
+        base, head, autoHeal, tsconfigPath, routeGlobs, buildSalt, timeoutMs,
+      });
     },
     "mandu.ate.feedback": async (args: Record<string, unknown>) => {
       const { repoRoot, runId, autoApply } = args as {

package/src/tools/composite.ts

@@ -60,10 +60,10 @@ export const compositeToolDefinitions: Tool[] = [
     },
   },
   {
-    name: "mandu.island.add",
-    description:
-      "Create an island component with correct @mandujs/core/client imports and hydration strategy. " +
-      "Generates a .island.tsx file in app/{route}/ with the island() wrapper.",
+    name: "mandu.island.add",
+    description:
+      "Create an island component with correct @mandujs/core/client imports and hydration strategy. " +
+      "Generates a .island.tsx file in app/{route}/ with the wrapComponent() island definition.",
     annotations: {
       destructiveHint: true,
       readOnlyHint: false,
@@ -474,10 +474,10 @@ function generateMiddlewareSource(preset: string, options: Record<string, string
   return templates[preset] ?? templates.default;
 }
 
-function generateIslandSource(name: string, strategy: string): string {
-  return `"use client";
-import { island } from "@mandujs/core/client";
-import { useState } from "react";
+function generateIslandSource(name: string, strategy: string): string {
+  return `"use client";
+import { wrapComponent } from "@mandujs/core/client";
+import { useState } from "react";
 
 interface ${name}Props {
   [key: string]: unknown;
@@ -493,6 +493,8 @@ function ${name}Inner(props: ${name}Props) {
   );
 }
 
-export default island("${strategy}", ${name}Inner);
-`;
-}
+// Route hydration priority should be set on the page/manifest route.
+// Suggested priority for this island: "${strategy}".
+export default wrapComponent(${name}Inner);
+`;
+}

package/src/tools/index.ts

@@ -162,10 +162,10 @@ import {
 /**
  * 도구 모듈 정보
  */
-interface ToolModule {
-  category: string;
-  definitions: Tool[];
-  handlers: (
+export interface ToolModule {
+  category: string;
+  definitions: Tool[];
+  handlers: (
     projectRoot: string,
     server?: Server,
     monitor?: ActivityMonitor
@@ -188,7 +188,7 @@ interface ToolModule {
 /**
  * 빌트인 도구 모듈 목록
  */
-const TOOL_MODULES: ToolModule[] = [
+export const TOOL_MODULES: ToolModule[] = [
   { category: "spec", definitions: specToolDefinitions, handlers: specTools },
   { category: "generate", definitions: generateToolDefinitions, handlers: generateTools },
   { category: "transaction", definitions: transactionToolDefinitions, handlers: transactionTools },
@@ -200,18 +200,18 @@ const TOOL_MODULES: ToolModule[] = [
   { category: "slot", definitions: slotToolDefinitions, handlers: slotTools },
   { category: "hydration", definitions: hydrationToolDefinitions, handlers: hydrationTools },
   { category: "contract", definitions: contractToolDefinitions, handlers: contractTools },
-  { category: "brain", definitions: brainToolDefinitions, handlers: brainTools as ToolModule["handlers"], requiresServer: true },
+  { category: "brain", definitions: brainToolDefinitions, handlers: brainTools, requiresServer: true },
   { category: "runtime", definitions: runtimeToolDefinitions, handlers: runtimeTools },
   { category: "seo", definitions: seoToolDefinitions, handlers: seoTools },
-  { category: "project", definitions: projectToolDefinitions, handlers: projectTools as ToolModule["handlers"], requiresServer: true },
+  { category: "project", definitions: projectToolDefinitions, handlers: projectTools, requiresServer: true },
   // ate + ate-run accept an optional Server so notifications/progress
   // can flow (issue #238). `acceptsServer: true` forwards the server
   // when available but still registers when it isn't — callers that
   // boot without an MCP transport get progress no-oped silently.
-  { category: "ate", definitions: ateToolDefinitions, handlers: ateTools as ToolModule["handlers"], acceptsServer: true },
-  { category: "ate-phase5", definitions: atePhase5ToolDefinitions, handlers: createAtePhase5Handlers as unknown as ToolModule["handlers"] },
+  { category: "ate", definitions: ateToolDefinitions, handlers: ateTools, acceptsServer: true },
+  { category: "ate-phase5", definitions: atePhase5ToolDefinitions, handlers: createAtePhase5Handlers },
   { category: "ate-context", definitions: ateContextToolDefinitions, handlers: ateContextTools },
-  { category: "ate-run", definitions: ateRunToolDefinitions, handlers: ateRunTools as ToolModule["handlers"], acceptsServer: true },
+  { category: "ate-run", definitions: ateRunToolDefinitions, handlers: ateRunTools, acceptsServer: true },
   { category: "ate-flakes", definitions: ateFlakesToolDefinitions, handlers: ateFlakesTools },
   { category: "ate-prompt", definitions: atePromptToolDefinitions, handlers: atePromptTools },
   { category: "ate-exemplar", definitions: ateExemplarToolDefinitions, handlers: ateExemplarTools },
@@ -282,10 +282,41 @@ const TOOL_MODULES: ToolModule[] = [
     definitions: extractContractToolDefinitions,
     handlers: extractContractTools,
   },
-];
-
-/**
- * 빌트인 도구들을 레지스트리에 등록
+];
+
+export function validateBuiltinToolModules(
+  modules: readonly ToolModule[] = TOOL_MODULES
+): string[] {
+  const issues: string[] = [];
+  const categories = new Set<string>();
+  const toolNames = new Map<string, string>();
+
+  for (const module of modules) {
+    if (categories.has(module.category)) {
+      issues.push(`duplicate tool category: ${module.category}`);
+    }
+    categories.add(module.category);
+
+    if (module.definitions.length === 0) {
+      issues.push(`tool category has no definitions: ${module.category}`);
+    }
+
+    for (const definition of module.definitions) {
+      const previousCategory = toolNames.get(definition.name);
+      if (previousCategory) {
+        issues.push(
+          `duplicate tool definition: ${definition.name} in ${previousCategory} and ${module.category}`
+        );
+      }
+      toolNames.set(definition.name, module.category);
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * 빌트인 도구들을 레지스트리에 등록
  *
  * @param projectRoot - 프로젝트 루트 경로
  * @param server - MCP Server 인스턴스 (선택, brain/project 도구에 필요)
@@ -306,11 +337,15 @@ export function registerBuiltinTools(
   monitor?: ActivityMonitor,
   options?: { profile?: McpProfile }
 ): void {
-  const allowedCategories = options?.profile
-    ? getProfileCategories(options.profile)
-    : null;
-
-  for (const module of TOOL_MODULES) {
+  const allowedCategories = options?.profile
+    ? getProfileCategories(options.profile)
+    : null;
+  const definitionIssues = validateBuiltinToolModules();
+  if (definitionIssues.length > 0) {
+    throw new Error(`Invalid MCP tool module registry:\n${definitionIssues.join("\n")}`);
+  }
+
+  for (const module of TOOL_MODULES) {
     // Profile filtering: skip categories not in the allowed list
     if (allowedCategories && !allowedCategories.includes(module.category)) {
       continue;
@@ -321,17 +356,13 @@ export function registerBuiltinTools(
       continue;
     }
 
-    try {
-      let handlers: Record<string, (args: Record<string, unknown>) => Promise<unknown>>;
-      if (module.requiresServer) {
-        handlers = (module.handlers as (root: string, srv: Server, mon: ActivityMonitor) => Record<string, (args: Record<string, unknown>) => Promise<unknown>>)(
-          projectRoot,
-          server!,
-          monitor!,
-        );
-      } else if (module.acceptsServer) {
-        // Forward the Server when available; fall back to just projectRoot.
-        handlers = server
+    try {
+      let handlers: Record<string, (args: Record<string, unknown>) => Promise<unknown>>;
+      if (module.requiresServer) {
+        handlers = module.handlers(projectRoot, server, monitor);
+      } else if (module.acceptsServer) {
+        // Forward the Server when available; fall back to just projectRoot.
+        handlers = server
           ? module.handlers(projectRoot, server)
           : module.handlers(projectRoot);
       } else {

package/src/tools/kitchen.ts

@@ -4,9 +4,10 @@
  * Enables any MCP-compatible agent to read client-side errors in real-time.
  */
 
-import type { Tool } from "@modelcontextprotocol/sdk/types.js";
-import { loadManduConfig } from "@mandujs/core";
-import { getDevServerState } from "./project.js";
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { loadManduConfig } from "@mandujs/core";
+import { getDevServerState } from "./project.js";
+import { readRuntimeControl } from "../utils/runtime-control.js";
 
 export const kitchenToolDefinitions: Tool[] = [
   {
@@ -19,10 +20,18 @@ export const kitchenToolDefinitions: Tool[] = [
     inputSchema: {
       type: "object",
       properties: {
-        clear: {
-          type: "boolean",
-          description: "Clear errors after reading (default: false)",
-        },
+        clear: {
+          type: "boolean",
+          description: "Clear errors after reading (default: false)",
+        },
+        baseURL: {
+          type: "string",
+          description: "Explicit dev server URL. Overrides runtime-control/config discovery.",
+        },
+        port: {
+          type: "number",
+          description: "Explicit dev server port. Overrides runtime-control/config discovery.",
+        },
       },
       required: [],
     },
@@ -47,11 +56,19 @@ export const kitchenToolDefinitions: Tool[] = [
           description:
             "Include the extended diagnose report. Default true. Set false to lower latency when a11y_hints / package_export_gaps are noisy.",
         },
-        includeDiff: {
-          type: "boolean",
-          description:
-            "Include git diff against MANDU_DIFF_BASE (default HEAD). Default true. Set false to skip when git is unavailable.",
-        },
+        includeDiff: {
+          type: "boolean",
+          description:
+            "Include git diff against MANDU_DIFF_BASE (default HEAD). Default true. Set false to skip when git is unavailable.",
+        },
+        baseURL: {
+          type: "string",
+          description: "Explicit dev server URL. Overrides runtime-control/config discovery.",
+        },
+        port: {
+          type: "number",
+          description: "Explicit dev server port. Overrides runtime-control/config discovery.",
+        },
       },
       required: [],
     },
@@ -59,15 +76,32 @@ export const kitchenToolDefinitions: Tool[] = [
 ];
 
 /**
- * Resolve the dev server base URL. Prefers the port parsed from the
- * currently running `mandu dev` stdout; falls back to mandu config; final
- * default is 3333. Shared by every Kitchen-backed MCP tool so they all
- * agree on where to fetch from.
+ * Resolve the dev server base URL. Prefers explicit args, then
+ * `.mandu/runtime-control.json` from the running dev/start process, then
+ * captured stdout, then config/default 3333. Shared by every Kitchen-backed
+ * MCP tool so they all agree on where to fetch from.
  */
-async function resolveDevServerBaseUrl(projectRoot: string): Promise<string> {
-  let port: number | undefined;
-
-  const serverState = getDevServerState();
+async function resolveDevServerBaseUrl(
+  projectRoot: string,
+  args: { baseURL?: unknown; port?: unknown } = {},
+): Promise<string> {
+  if (typeof args.baseURL === "string" && args.baseURL.trim()) {
+    return args.baseURL.trim().replace(/\/+$/, "");
+  }
+
+  const explicitPort = normalizePort(args.port);
+  if (explicitPort) {
+    return `http://localhost:${explicitPort}`;
+  }
+
+  const control = await readRuntimeControl(projectRoot);
+  if (control?.baseUrl) {
+    return control.baseUrl.replace(/\/+$/, "");
+  }
+
+  let port: number | undefined;
+
+  const serverState = getDevServerState();
   if (serverState) {
     for (const line of serverState.output) {
       const portMatch = line.match(/https?:\/\/localhost:(\d+)/);
@@ -81,15 +115,21 @@ async function resolveDevServerBaseUrl(projectRoot: string): Promise<string> {
     const config = await loadManduConfig(projectRoot);
     port = config.server?.port ?? 3333;
   }
-
-  return `http://localhost:${port}`;
-}
+
+  return `http://localhost:${port}`;
+}
+
+function normalizePort(value: unknown): number | undefined {
+  const raw = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : NaN;
+  if (!Number.isInteger(raw) || raw < 1 || raw > 65535) return undefined;
+  return raw;
+}
 
 export function kitchenTools(projectRoot: string) {
   const handlers: Record<string, (args: Record<string, unknown>) => Promise<unknown>> = {
-    "mandu.kitchen.errors": async (args: Record<string, unknown>) => {
-      const { clear = false } = args as { clear?: boolean };
-      const baseUrl = await resolveDevServerBaseUrl(projectRoot);
+    "mandu.kitchen.errors": async (args: Record<string, unknown>) => {
+      const { clear = false } = args as { clear?: boolean };
+      const baseUrl = await resolveDevServerBaseUrl(projectRoot, args);
 
       try {
         // Fetch errors from Kitchen API
@@ -145,12 +185,12 @@ export function kitchenTools(projectRoot: string) {
      */
     "mandu.devtools.context": async (args: Record<string, unknown>) => {
       const {
-        includeBundle = true,
-        includeDiagnose = true,
-        includeDiff = true,
-      } = args as { includeBundle?: boolean; includeDiagnose?: boolean; includeDiff?: boolean };
-
-      const baseUrl = await resolveDevServerBaseUrl(projectRoot);
+        includeBundle = true,
+        includeDiagnose = true,
+        includeDiff = true,
+      } = args as { includeBundle?: boolean; includeDiagnose?: boolean; includeDiff?: boolean };
+
+      const baseUrl = await resolveDevServerBaseUrl(projectRoot, args);
       const params = new URLSearchParams();
       if (!includeBundle) params.set("bundle", "0");
       if (!includeDiagnose) params.set("diagnose", "0");

package/src/tools/slot-validation.ts

@@ -1,49 +1,13 @@
-import type { Tool } from "@modelcontextprotocol/sdk/types.js";
-import {
-  validateSlotConstraints,
-  DEFAULT_SLOT_CONSTRAINTS,
-  API_SLOT_CONSTRAINTS,
-  READONLY_SLOT_CONSTRAINTS,
-  type SlotConstraints,
-} from "@mandujs/core";
-
-export const slotValidationToolDefinitions: Tool[] = [
-  {
-    name: "mandu.slot.validate",
-    description:
-      "Validate a slot file against semantic constraints (lines, complexity, patterns, imports).",
-    annotations: {
-      readOnlyHint: true,
-    },
-    inputSchema: {
-      type: "object",
-      properties: {
-        file: {
-          type: "string",
-          description: "Path to the slot file to validate",
-        },
-        preset: {
-          type: "string",
-          enum: ["default", "api", "readonly"],
-          description: "Constraint preset to use (default: 'default')",
-        },
-        constraints: {
-          type: "object",
-          description: "Custom constraints (overrides preset)",
-          properties: {
-            maxLines: { type: "number" },
-            maxCyclomaticComplexity: { type: "number" },
-            requiredPatterns: { type: "array", items: { type: "string" } },
-            forbiddenPatterns: { type: "array", items: { type: "string" } },
-            allowedImports: { type: "array", items: { type: "string" } },
-          },
-        },
-      },
-      required: ["file"],
-    },
-  },
-  {
-    name: "mandu.slot.constraints",
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import {
+  DEFAULT_SLOT_CONSTRAINTS,
+  API_SLOT_CONSTRAINTS,
+  READONLY_SLOT_CONSTRAINTS,
+} from "@mandujs/core";
+
+export const slotValidationToolDefinitions: Tool[] = [
+  {
+    name: "mandu.slot.constraints",
     description:
       "Get recommended slot constraint presets (default, api, readonly).",
     annotations: {
@@ -63,79 +27,10 @@ export const slotValidationToolDefinitions: Tool[] = [
   },
 ];
 
-export function slotValidationTools(projectRoot: string) {
-  const handlers: Record<string, (args: Record<string, unknown>) => Promise<unknown>> = {
-    "mandu.slot.validate": async (args: Record<string, unknown>) => {
-      const { file, preset, constraints: customConstraints } = args as {
-        file: string;
-        preset?: "default" | "api" | "readonly";
-        constraints?: SlotConstraints;
-      };
-
-      if (!file) {
-        return {
-          error: "File path is required",
-          tip: "Provide the path to the slot file to validate",
-        };
-      }
-
-      // 프리셋 선택
-      let constraints: SlotConstraints;
-      if (customConstraints) {
-        constraints = customConstraints;
-      } else {
-        switch (preset) {
-          case "api":
-            constraints = API_SLOT_CONSTRAINTS;
-            break;
-          case "readonly":
-            constraints = READONLY_SLOT_CONSTRAINTS;
-            break;
-          default:
-            constraints = DEFAULT_SLOT_CONSTRAINTS;
-        }
-      }
-
-      // 파일 경로 정규화 및 보안 검증 (LFI 방지)
-      const path = await import("path");
-      const rawPath = file.startsWith("/") || file.includes(":")
-        ? file
-        : path.join(projectRoot, file);
-      const filePath = path.normalize(path.resolve(rawPath));
-      const normalizedRoot = path.normalize(path.resolve(projectRoot));
-
-      // 경로가 프로젝트 루트 내에 있는지 검증
-      if (!filePath.startsWith(normalizedRoot)) {
-        return {
-          error: "Access denied: File path is outside project root",
-          tip: "Only files within the project directory can be validated",
-          requestedPath: file,
-          projectRoot: projectRoot,
-        };
-      }
-
-      const result = await validateSlotConstraints(filePath, constraints);
-
-      return {
-        valid: result.valid,
-        file: result.filePath,
-        stats: result.stats,
-        violations: result.violations.map((v) => ({
-          type: v.type,
-          severity: v.severity,
-          message: v.message,
-          suggestion: v.suggestion,
-          line: v.line,
-        })),
-        suggestions: result.suggestions,
-        constraintsUsed: constraints,
-        tip: result.valid
-          ? "✅ Slot passes all constraints"
-          : "Fix violations before deployment. Use mandu.slot.constraints for guidance.",
-      };
-    },
-
-    "mandu.slot.constraints": async (args: Record<string, unknown>) => {
+export function slotValidationTools(projectRoot: string) {
+  void projectRoot;
+  const handlers: Record<string, (args: Record<string, unknown>) => Promise<unknown>> = {
+    "mandu.slot.constraints": async (args: Record<string, unknown>) => {
       const { preset } = args as { preset?: "default" | "api" | "readonly" };
 
       const presets = {
@@ -189,11 +84,10 @@ Mandu.filling()
         `.trim(),
       };
     },
-  };
-
-  // Backward-compatible aliases
-  handlers["mandu_validate_slot"] = handlers["mandu.slot.validate"];
-  handlers["mandu_get_slot_constraints"] = handlers["mandu.slot.constraints"];
-
+  };
+
+  // Backward-compatible aliases
+  handlers["mandu_get_slot_constraints"] = handlers["mandu.slot.constraints"];
+
   return handlers;
 }