@ema.co/mcp-toolkit 2026.1.26-4 → 2026.1.27

package/dist/mcp/handlers/action/index.js

@@ -14,10 +14,20 @@ export async function handleAction(args, client) {
     const id = args.id;
     const identifier = args.identifier; // deprecated alias for 'id'
     const idOrName = id ?? identifier;
-    // Categories list
+    // Categories list - API-first with catalog fallback
     if (args.categories) {
+        try {
+            const actions = await client.listActions();
+            const apiCategories = [...new Set(actions.map(a => a.category).filter(Boolean))];
+            if (apiCategories.length > 0) {
+                return { categories: apiCategories, count: apiCategories.length, source: "api" };
+            }
+        }
+        catch {
+            // Fallback to catalog
+        }
         const categories = [...new Set(Object.values(AGENT_CATALOG).map(a => a.category))];
-        return { categories, count: categories.length };
+        return { categories, count: categories.length, source: "catalog" };
     }
     // Suggest for use case
     if (args.suggest) {
@@ -97,6 +107,7 @@ export async function handleAction(args, client) {
                     ...a,
                     documentation: a.name ? getAgentByName(a.name) : undefined,
                 })),
+                source: "api",
             };
         }
         return {
@@ -107,6 +118,7 @@ export async function handleAction(args, client) {
                 category: a.category,
                 enabled: a.enabled,
             })),
+            source: "api",
         };
     }
     catch (e) {

package/dist/mcp/handlers/data/index.js

@@ -138,6 +138,8 @@ export async function handleData(args, client, readFile) {
             // Upload file or LLM-generated content (dashboard rows)
             const filePath = (dataArgs?.path ?? dataArgs?.file ?? args.file);
             const items = dataArgs?.items;
+            // Widget name for targeting specific upload widgets (especially for Document Generation personas)
+            const widgetName = (dataArgs?.widget_name ?? args.widget_name);
             if (filePath) {
                 // File upload - use provided readFile or fall back to fs
                 try {
@@ -151,11 +153,14 @@ export async function handleData(args, client, readFile) {
                     }
                     const path = await import("path");
                     const filename = path.basename(filePath);
-                    const result = await client.uploadDataSource(personaId, fileContent, filename);
+                    const result = await client.uploadDataSource(personaId, fileContent, filename, {
+                        widgetName: widgetName, // Pass through widget_name for doc gen personas
+                    });
                     return {
                         method: "upload",
                         persona_id: personaId,
                         path: filePath,
+                        widget_name: widgetName ?? "fileUpload",
                         ...result,
                     };
                 }
@@ -164,14 +169,74 @@ export async function handleData(args, client, readFile) {
                 }
             }
             else if (items && items.length > 0) {
-                // Dashboard row upload (LLM-generated content)
+                // Dashboard row upload (LLM-generated content or file attachments)
                 try {
                     const results = [];
+                    const path = await import("path");
+                    const fs = await import("fs/promises");
                     for (const item of items) {
-                        // Convert item to DashboardInput format (name + string_value)
-                        const inputs = Object.entries(item).map(([key, value]) => ({
-                            name: key,
-                            string_value: typeof value === "string" ? value : JSON.stringify(value),
+                        // Convert item to DashboardInput format
+                        // Supports: string_value, number_value, boolean_value, document_value
+                        const inputs = await Promise.all(Object.entries(item).map(async ([key, value]) => {
+                            // File attachment: { file: "/path/to/file.pdf" } or { file_path: "..." }
+                            if (typeof value === "object" && value !== null && ("file" in value || "file_path" in value)) {
+                                const filePath = value.file ?? value.file_path;
+                                if (typeof filePath === "string") {
+                                    let fileContent;
+                                    if (readFile) {
+                                        fileContent = await readFile(filePath);
+                                    }
+                                    else {
+                                        fileContent = await fs.readFile(filePath);
+                                    }
+                                    const filename = path.basename(filePath);
+                                    const ext = path.extname(filePath).toLowerCase();
+                                    const mimeTypes = {
+                                        ".pdf": "application/pdf",
+                                        ".json": "application/json",
+                                        ".txt": "text/plain",
+                                        ".csv": "text/csv",
+                                        ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                                        ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                                    };
+                                    return {
+                                        name: key,
+                                        document_value: [{
+                                                name: filename,
+                                                contents: fileContent.toString("base64"),
+                                                is_base64_encoded: true,
+                                                mime_type: mimeTypes[ext] ?? "application/octet-stream",
+                                            }],
+                                    };
+                                }
+                            }
+                            // Inline document: { contents: "...", mime_type: "..." }
+                            if (typeof value === "object" && value !== null && "contents" in value) {
+                                const doc = value;
+                                return {
+                                    name: key,
+                                    document_value: [{
+                                            name: doc.name ?? `${key}.txt`,
+                                            contents: typeof doc.contents === "string" && doc.is_base64_encoded
+                                                ? doc.contents
+                                                : Buffer.from(String(doc.contents)).toString("base64"),
+                                            is_base64_encoded: true,
+                                            mime_type: doc.mime_type ?? "text/plain",
+                                        }],
+                                };
+                            }
+                            // Primitive values
+                            if (typeof value === "number") {
+                                return { name: key, number_value: value };
+                            }
+                            if (typeof value === "boolean") {
+                                return { name: key, boolean_value: value };
+                            }
+                            // Default: string value
+                            return {
+                                name: key,
+                                string_value: typeof value === "string" ? value : JSON.stringify(value),
+                            };
                         }));
                         const result = await client.uploadAndRunDashboardRow(personaId, inputs);
                         results.push(result);
@@ -181,6 +246,7 @@ export async function handleData(args, client, readFile) {
                         persona_id: personaId,
                         uploaded_rows: results.length,
                         row_ids: results.map(r => r.row_id),
+                        _tip: "Dashboard rows created with file attachments trigger workflow execution automatically",
                     };
                 }
                 catch (error) {

package/dist/mcp/handlers/env/index.js

@@ -25,9 +25,9 @@ export async function handleEnv(_args, getEnvironments, toolkit) {
         getting_started: {
             workflow: [
                 "1. List personas: persona(method=\"list\")",
-                "2. Get details: persona(method=\"get\", id=\"...\")",
-                "3. Analyze before modifying: persona(method=\"get\", id=\"...\", analyze=true)",
-                "4. Preview before deploying: persona(method=\"update\", id=\"...\", preview=true, ...)",
+                "2. Get workflow data: workflow(mode=\"get\", persona_id=\"...\")",
+                "3. Analyze workflow: Fetch ema://rules/anti-patterns and check workflow_def against rules",
+                "4. Preview before deploying: workflow(mode=\"deploy\", persona_id=\"...\", workflow_def={...}, preview=true)",
             ],
             critical_rules: criticalRules,
             resources: [

package/dist/mcp/handlers/reference/index.js

@@ -34,10 +34,22 @@ export async function handleReference(args, context) {
     if (type === "actions") {
         const client = context?.client;
         const id = args.id;
-        // Categories list
+        // Categories list - API-first with catalog fallback
         if (args.categories) {
+            if (client) {
+                try {
+                    const actions = await client.listActions();
+                    const apiCategories = [...new Set(actions.map(a => a.category).filter(Boolean))];
+                    if (apiCategories.length > 0) {
+                        return { categories: apiCategories, count: apiCategories.length, source: "api" };
+                    }
+                }
+                catch {
+                    // Fallback to catalog
+                }
+            }
             const categories = [...new Set(Object.values(AGENT_CATALOG).map(a => a.category))];
-            return { categories, count: categories.length };
+            return { categories, count: categories.length, source: "catalog" };
         }
         // Suggest for use case
         if (args.suggest) {
@@ -114,6 +126,7 @@ export async function handleReference(args, context) {
                         category: a.category,
                         enabled: a.enabled,
                     })),
+                    source: "api",
                 };
             }
             catch {

package/dist/mcp/handlers/workflow/analyze.js

@@ -1,20 +1,21 @@
 /**
  * Workflow Analyze Handler
  *
- * Analyzes workflow structure, detects issues, and provides metrics.
+ * Returns workflow DATA for LLM to analyze using rules from ema://rules/*.
  *
- * Features:
- * - Issue detection (critical, warning, info)
- * - Connection validation
- * - Metrics calculation
- * - Execution flow analysis (loops, dead code, multiple responders)
- * - Auto-fix support
+ * IMPORTANT: This handler does NOT pre-compute issues or fixes.
+ * The LLM applies ANTI_PATTERNS, INPUT_SOURCE_RULES, and OPTIMIZATION_RULES
+ * to reason about the workflow.
+ *
+ * Returns:
+ * - workflow_def: The raw workflow structure
+ * - connections: Type information for each edge
+ * - metrics: Basic counts (nodes, edges, etc.)
+ * - rules_hint: Pointer to ema://rules/* for analysis guidance
  */
-import { detectWorkflowIssues, suggestWorkflowFixes, validateWorkflowConnections } from "../../../sdk/knowledge.js";
-import { autoFixWorkflow } from "../../../sdk/workflow-fixer.js";
-import { analyzeExecutionFlow, generateASCIIFlow } from "../../../sdk/workflow-execution-analyzer.js";
+import { validateWorkflowConnections, parseWorkflowDef } from "../../../sdk/knowledge.js";
 /**
- * Calculate workflow metrics
+ * Calculate workflow metrics (pure data, no analysis)
  */
 function calculateMetrics(workflow) {
     const actions = workflow.actions;
@@ -36,15 +37,24 @@ function calculateMetrics(workflow) {
     // Get trigger type
     const trigger = workflow.trigger;
     const triggerType = trigger?.trigger_type;
+    // Check for categorizer
+    const hasCategorizer = actions.some(a => {
+        const name = a.name?.toLowerCase() ?? "";
+        const action = a.action?.name?.name;
+        return name.includes("categorizer") || action?.includes("categorizer");
+    });
     return {
         node_count: actions.length,
         connection_count: connectionCount,
         has_hitl: hasHitl,
+        has_categorizer: hasCategorizer,
         trigger_type: triggerType,
     };
 }
 /**
  * Handle workflow analyze mode
+ *
+ * Returns DATA for LLM to analyze - does NOT pre-compute issues.
  */
 export async function handleWorkflowAnalyze(args, client) {
     const personaId = args.persona_id;
@@ -62,110 +72,48 @@ export async function handleWorkflowAnalyze(args, client) {
     if (!workflow) {
         return { error: "No workflow to analyze. Provide workflow_def or persona_id." };
     }
-    // Determine what to include
-    const include = args.include || ["issues", "connections", "fixes", "metrics"];
+    // Parse workflow to simpler structure
+    const nodes = parseWorkflowDef(workflow);
+    // Get connection type information
+    const connections = validateWorkflowConnections(workflow);
+    // Calculate metrics
+    const metrics = calculateMetrics(workflow);
     const result = {
         mode: "analyze",
         persona_id: personaId,
         persona_name: persona?.name,
-        environment: "demo",
+        // RAW DATA for LLM to analyze
+        workflow_def: workflow,
+        node_count: nodes.length,
+        nodes: nodes.map(n => ({
+            id: n.id,
+            action: n.action_name,
+            display_name: n.display_name,
+            inputs: n.incoming_edges?.map(e => `${e.source_node_id}.${e.source_output}`),
+        })),
+        // Type information for connections
+        connections: connections.map(c => ({
+            edge: c.edge_id,
+            source_type: c.source_type,
+            target_type: c.target_type,
+            compatible: c.compatible,
+            note: c.note,
+        })),
+        // Basic metrics
+        metrics,
+        // Tell LLM where to find analysis rules
+        _next_steps: [
+            "1. Fetch ema://rules/anti-patterns",
+            "2. Fetch ema://rules/structural-invariants",
+            "3. Check each node against the rules",
+            "4. Report issues YOU find (MCP does not pre-compute)",
+        ],
     };
-    // Issues and fixes
-    if (include.includes("issues") || include.includes("fixes")) {
-        const issues = detectWorkflowIssues(workflow);
-        if (include.includes("issues")) {
-            result.issues = issues;
-        }
-        if (include.includes("fixes")) {
-            result.fixes = suggestWorkflowFixes(issues);
-        }
-        result.issue_summary = {
-            total: issues.length,
-            critical: issues.filter((i) => i.severity === "critical").length,
-            warning: issues.filter((i) => i.severity === "warning").length,
-            info: issues.filter((i) => i.severity === "info").length,
-        };
-        result.validation_passed = issues.filter((i) => i.severity === "critical").length === 0;
-    }
-    // Connection validation
-    if (include.includes("connections")) {
-        result.connections = validateWorkflowConnections(workflow);
-    }
-    // Metrics
-    if (include.includes("metrics")) {
-        result.metrics = calculateMetrics(workflow);
-    }
-    // Execution flow analysis
-    if (include.includes("execution_flow")) {
-        const execAnalysis = analyzeExecutionFlow(workflow);
-        result.execution_flow = {
-            summary: execAnalysis.summary,
-            loops: execAnalysis.loops,
-            multiple_responder_issues: execAnalysis.multipleResponderIssues,
-            redundant_classifiers: execAnalysis.redundantClassifiers,
-            data_flow_issues: execAnalysis.dataFlowIssues,
-            dead_code_paths: execAnalysis.deadCodePaths,
-        };
-        // Include ASCII visualization if requested
-        if (args.visualize) {
-            result.execution_flow_ascii = generateASCIIFlow(execAnalysis);
-        }
-        // Add specific warnings for triple response risk
-        if (execAnalysis.summary.mayRepeatResponses) {
-            result.triple_response_warning = "⚠️ This workflow may cause duplicate/triple responses due to ungated parallel responders";
-        }
-    }
     if (persona) {
         result.persona = {
             id: persona.id,
             name: persona.name
         };
     }
-    // Calculate optimization guidance
-    const issues = result.issues;
-    const criticalCount = issues?.filter(i => i.severity === "critical").length ?? 0;
-    const warningCount = issues?.filter(i => i.severity === "warning").length ?? 0;
-    // AUTO-FIX: If fix=true, apply fixes and deploy
-    if (args.fix && personaId && persona && workflow) {
-        const fixResult = autoFixWorkflow(workflow);
-        result.fixes_applied = fixResult.fixesApplied;
-        result.fixes_warnings = fixResult.warnings;
-        if (fixResult.fixesApplied.length > 0 && fixResult.success) {
-            // Deploy the fixed workflow
-            try {
-                const fixedWorkflow = fixResult.workflowDef;
-                await client.updateAiEmployee({
-                    persona_id: personaId,
-                    workflow: fixedWorkflow,
-                    proto_config: persona.proto_config,
-                });
-                result.fix_status = "deployed";
-                result.fixes_deployed = fixResult.fixesApplied.length;
-                result.status = `✅ Applied ${fixResult.fixesApplied.length} fixes and deployed`;
-            }
-            catch (deployErr) {
-                result.fix_status = "failed";
-                result.fix_error = deployErr instanceof Error ? deployErr.message : String(deployErr);
-                result.status = `⚠️ Fixes applied but deploy failed: ${result.fix_error}`;
-            }
-        }
-        else if (fixResult.fixesApplied.length === 0) {
-            result.fix_status = "no_fixes_needed";
-            result.status = "✅ No auto-fixable issues found";
-        }
-        else {
-            result.fix_status = "failed";
-            result.status = "⚠️ Fix generation failed";
-        }
-        return result;
-    }
-    // Provide optimization suggestion
-    if (criticalCount > 0 || warningCount > 0) {
-        result.optimization_suggestion = `This workflow has ${criticalCount} critical and ${warningCount} warning issues. ` +
-            `Use workflow(persona_id="${personaId ?? 'ID'}", optimize=true) to auto-fix.`;
-    }
-    else {
-        result.status = "✅ Workflow is healthy - no issues detected";
-    }
     return result;
 }

package/dist/mcp/handlers/workflow/deploy.js

@@ -2,8 +2,10 @@
  * Workflow Deploy Handler
  *
  * Deploys a workflow_def to an existing persona.
+ * Includes deprecation warnings (does not block, just warns).
  */
 import { sanitizeWorkflowForDeploy } from "./utils.js";
+import { DEPRECATED_ACTIONS_FALLBACK, checkWorkflowDeprecations } from "./index.js";
 /**
  * Handle workflow deploy mode
  */
@@ -23,6 +25,8 @@ export async function handleWorkflowDeploy(args, client) {
     }
     // Sanitize workflow before deployment
     const sanitizedWorkflow = sanitizeWorkflowForDeploy(workflowDef);
+    // Check for deprecated actions (warn, don't block)
+    const deprecationWarnings = checkWorkflowDeprecations(workflowDef, DEPRECATED_ACTIONS_FALLBACK);
     // Determine proto_config to use: provided > existing
     const existingProtoConfig = persona.proto_config;
     const providedProtoConfig = args.proto_config;
@@ -31,6 +35,11 @@ export async function handleWorkflowDeploy(args, client) {
     const projectSettings = protoConfigToUse.projectSettings;
     const isVoice = projectSettings?.projectType === 5;
     const warnings = [];
+    // Add deprecation warning message if deprecated actions found
+    if (deprecationWarnings.length > 0) {
+        warnings.push(`Workflow uses ${deprecationWarnings.length} deprecated action(s). ` +
+            "Consider updating to prevent future breakage when deprecated actions are removed.");
+    }
     if (isVoice && !providedProtoConfig) {
         // Check if existing proto_config has conversationSettings populated
         const widgets = (protoConfigToUse.widgets ?? []);
@@ -58,6 +67,12 @@ export async function handleWorkflowDeploy(args, client) {
         if (warnings.length > 0) {
             result.warnings = warnings;
         }
+        // Include detailed deprecation info if any deprecated actions found
+        if (deprecationWarnings.length > 0) {
+            result.deprecation_warnings = deprecationWarnings;
+            result._warning = "Workflow deployed but contains deprecated actions. Update before platform removes them.";
+            result._next_step = "Use workflow(mode='get') to see current schema, then deploy updated workflow_def with non-deprecated actions.";
+        }
         return result;
     }
     catch (err) {

package/dist/mcp/handlers/workflow/generate.js

@@ -10,7 +10,7 @@
  */
 import { parseInput, intentToSpec, generateWorkflow } from "../../../sdk/workflow-intent.js";
 import { compileWorkflow } from "../../../sdk/workflow-generator.js";
-import { detectWorkflowIssues } from "../../../sdk/knowledge.js";
+// Detection removed - LLM analyzes with rules from ema://rules/*
 import { runIntentArchitect } from "../../../sdk/intent-architect.js";
 import { ensureActionRegistry } from "../../../sdk/action-registry.js";
 import { ensureSchemaRegistry, validateWorkflowSpec, generateActionCatalogForLLM } from "../../../sdk/workflow-validator.js";
@@ -271,14 +271,14 @@ export async function handleWorkflowGenerate(args, client, getTemplateId) {
         }
     }
     const compiled = compileWorkflow(spec, { registry: actionRegistry });
-    // Validate generated workflow
-    const issues = detectWorkflowIssues(compiled.workflow_def);
     const result = {
         mode: "generate",
         status: preview ? "preview" : "deployed",
         workflow_def: compiled.workflow_def,
         proto_config: compiled.proto_config,
         validation: parseResult.validation,
+        // LLM should analyze with ema://rules/anti-patterns
+        _analysis_hint: "Use ema://rules/anti-patterns to check for issues",
     };
     if (specValidation) {
         result.api_validation = {
@@ -287,9 +287,6 @@ export async function handleWorkflowGenerate(args, client, getTemplateId) {
             action_coverage: specValidation.action_coverage,
         };
     }
-    if (issues.length > 0) {
-        result.issues = issues;
-    }
     // Deploy if not preview
     if (!preview && personaId) {
         const persona = await client.getPersonaById(personaId);

package/dist/mcp/handlers/workflow/index.js

@@ -36,7 +36,8 @@ export { handleWorkflowModify } from "./modify.js";
 export { applyWorkflowModifications, buildWorkflowAction, buildInputBinding, } from "./modify.js";
 // Fallback deprecated actions - ONLY used when API unavailable
 // Source: ema/ema_backend/grpc/workflow_actions/registered_actions.py (synced 2026-01-26)
-const DEPRECATED_ACTIONS_FALLBACK = {
+// Exported for use by deploy handler
+export const DEPRECATED_ACTIONS_FALLBACK = {
     "search/v0": { replacement: "search/v2", notes: "v2 requires datastore_configs input" },
     "web_search/v0": { replacement: "live_web_search or ai_web_search", notes: "Split into two specialized actions" },
     "call_llm/v0": { replacement: "call_llm/v2" },
@@ -79,8 +80,9 @@ async function getDeprecatedActions(client) {
 }
 /**
  * Check if workflow uses deprecated actions
+ * Exported for use by deploy handler
  */
-function checkWorkflowDeprecations(workflowDef, deprecatedActions) {
+export function checkWorkflowDeprecations(workflowDef, deprecatedActions) {
     if (!workflowDef)
         return [];
     const warnings = [];
@@ -185,14 +187,27 @@ async function handleWorkflowGet(args, client) {
             hitl: "For actions with side effects (email, external calls), consider general_hitl for approval",
             search: "Use search/v2 with datastore_configs. Wire query from trigger output.",
         },
-        // Tell LLM to check for deprecated actions if any exist
+        // LLM-driven analysis pattern: MCP provides data, LLM does the thinking
         _next_steps: deprecationWarnings.length > 0
             ? [
                 "WARNING: Workflow uses deprecated actions. Update them first:",
                 ...deprecationWarnings.map(w => `  - ${w.action}: ${w.replacement || "check catalog for replacement"}`),
+                "",
+                "To analyze workflow health:",
+                "1. Fetch ema://rules/anti-patterns",
+                "2. Fetch ema://rules/structural-invariants",
+                "3. Check workflow_def nodes against the rules",
+                "4. Report issues YOU find (MCP does not pre-compute)",
+                "",
                 "Then deploy with: workflow(mode='deploy', persona_id='...', workflow_def={...})",
             ]
             : [
+                "To analyze workflow health:",
+                "1. Fetch ema://rules/anti-patterns",
+                "2. Fetch ema://rules/structural-invariants",
+                "3. Check workflow_def nodes against the rules",
+                "4. Report issues YOU find (MCP does not pre-compute)",
+                "",
                 "Generate or modify workflow_def based on requirements above",
                 "Deploy with: workflow(mode='deploy', persona_id='...', workflow_def={...})",
             ],

package/dist/mcp/handlers/workflow/modify.js

@@ -8,7 +8,6 @@
  *
  * See: src/mcp/AGENTS.md for anti-patterns to avoid.
  */
-import { detectWorkflowIssues, suggestWorkflowFixes } from "../../../sdk/knowledge.js";
 import { sanitizeWorkflowForDeploy } from "./utils.js";
 import { ensureSchemaRegistry } from "../../../sdk/workflow-validator.js";
 // ─────────────────────────────────────────────────────────────────────────
@@ -323,9 +322,6 @@ export async function handleWorkflowModify(args, client) {
             return { error: "Persona has no workflow_def" };
         }
         const actions = (workflow.actions || []);
-        // Run analysis to give Agent context
-        const issues = detectWorkflowIssues(workflow);
-        const suggestions = suggestWorkflowFixes(issues);
         // Load schema registry for action catalog
         const schemaRegistry = await ensureSchemaRegistry(client);
         const availableActions = schemaRegistry.isLoaded()
@@ -335,20 +331,21 @@ export async function handleWorkflowModify(args, client) {
             message: "No operations provided. Returning workflow context for Agent to build operations.",
             persona_id: personaId,
             persona_name: persona.name,
-            // Current workflow state
+            // Current workflow state (DATA for Agent)
             current_nodes: actions.map(a => ({
                 name: a.name,
                 display_name: a.displaySettings?.displayName,
                 action_type: a.action?.name?.name,
             })),
-            // Analysis
-            issues: issues.map(i => ({ severity: i.severity, type: i.type, node: i.node, reason: i.reason })),
-            suggestions,
             // Available actions from registry
             available_actions: availableActions.slice(0, 20), // Top 20 for context
             // Guidance for Agent
-            _tip: "Build ModificationOperation[] and pass as 'operations' parameter",
-            _next_step: "Use the current_nodes and available_actions to build structured operations",
+            _next_steps: [
+                "1. Review current_nodes and available_actions above",
+                "2. Fetch ema://rules/anti-patterns to check for issues",
+                "3. Build ModificationOperation[] based on your analysis",
+                "4. Pass operations as 'operations' parameter",
+            ],
             // Example operation structures
             example_operations: {
                 insert_hitl: {
@@ -392,9 +389,6 @@ export async function handleWorkflowModify(args, client) {
     const result = applyWorkflowModifications(workflow, operations, schemaRegistry);
     // Sanitize before deploy
     const sanitized = sanitizeWorkflowForDeploy(result.workflow);
-    // Run validation
-    const postIssues = detectWorkflowIssues(sanitized);
-    const errors = postIssues.filter(i => i.severity === "critical");
     if (preview) {
         return {
             preview: true,
@@ -406,23 +400,9 @@ export async function handleWorkflowModify(args, client) {
             nodes_removed: result.nodesRemoved,
             nodes_modified: result.nodesModified,
             connections_changed: result.connectionsChanged,
-            // Validation
-            validation_errors: errors.map(e => e.reason || e.type),
-            validation_warnings: postIssues.filter(i => i.severity === "warning").map(w => w.reason || w.type),
-            // The modified workflow
+            // The modified workflow (LLM should analyze with ema://rules/*)
             modified_workflow: sanitized,
-            _tip: errors.length > 0
-                ? "Fix validation errors before deploying"
-                : "Preview looks good. Call without preview=true to deploy",
-        };
-    }
-    // Deploy if validation passes
-    if (errors.length > 0) {
-        return {
-            error: "Validation failed - cannot deploy",
-            validation_errors: errors.map(e => e.reason || e.type),
-            changes_attempted: result.changesApplied,
-            _tip: "Fix validation errors and try again",
+            _tip: "Preview complete. Use ema://rules/anti-patterns to check for issues. Call without preview=true to deploy.",
         };
     }
     // Deploy the workflow