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

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

@@ -5,18 +5,20 @@
  * instead of a giant switch statement. Each mode is in its own file
  * for better testability and maintainability.
  *
- * All standard persona modes are now extracted:
- * - get: Fetch single persona
+ * Persona modes:
+ * - get: Fetch single persona (LLM then analyzes the data)
  * - list: List all personas
  * - templates: List available templates
- * - compare: Compare two personas
  * - sanitize: Sanitize persona data
  * - update: Update persona config
  * - delete: Delete persona (with confirmation)
  * - create/clone: Create new persona from template or clone existing
- * - analyze: Analyze persona for issues
  * - intent: Direct Intent Architect invocation for qualification
  *
+ * REMOVED (LLM does these):
+ * - analyze: LLM analyzes data from 'get'
+ * - compare: LLM compares data from two 'get' calls
+ *
  * Version management modes extracted to version.ts:
  * - snapshot/version_create, history/version_list, version_get
  * - version_compare, restore/version_restore, version_policy
@@ -25,29 +27,27 @@
 import { handleGet } from "./get.js";
 import { handleList } from "./list.js";
 import { handleTemplates } from "./templates.js";
-import { handleCompare } from "./compare.js";
 import { handleSanitize } from "./sanitize.js";
 import { handleUpdate } from "./update.js";
 import { handleDelete } from "./delete.js";
 import { handleCreate } from "./create.js";
-import { handleAnalyze } from "./analyze.js";
 import { handleIntent } from "./intent.js";
 /**
  * Dispatch table for persona modes
  *
  * Note: create/clone handlers require getTemplateId callback as extra param
+ *
+ * REMOVED analyze/compare - LLM does analysis/comparison
  */
 export const PERSONA_MODE_HANDLERS = {
     get: handleGet,
     list: handleList,
     templates: handleTemplates,
-    compare: handleCompare,
     sanitize: handleSanitize,
     update: handleUpdate,
     delete: handleDelete,
     create: handleCreate,
     clone: handleCreate, // Clone uses same handler as create
-    analyze: handleAnalyze,
     intent: handleIntent,
 };
 /**
@@ -66,12 +66,11 @@ export function getPersonaModeHandler(mode) {
 export { handleGet } from "./get.js";
 export { handleList } from "./list.js";
 export { handleTemplates } from "./templates.js";
-export { handleCompare } from "./compare.js";
 export { handleSanitize } from "./sanitize.js";
 export { handleUpdate } from "./update.js";
 export { handleDelete } from "./delete.js";
 export { handleCreate } from "./create.js";
-export { handleAnalyze } from "./analyze.js";
 export { handleIntent } from "./intent.js";
+// REMOVED: handleCompare, handleAnalyze - LLM does analysis/comparison
 // Version management
 export { handleVersion, isVersionMode } from "./version.js";

package/dist/mcp/handlers/persona/update.js

@@ -174,7 +174,8 @@ function applySpecToWorkflow(spec, existingWorkflow) {
  * Handle persona(mode="update") - update persona config or workflow
  *
  * @param args.id - Persona ID or name (required)
- * @param args.proto_config - Proto config changes (smart merged with widgets)
+ * @param args.config - Config changes with widgets (preferred, smart merged)
+ * @param args.proto_config - Alias for config (internal, for backwards compatibility)
  * @param args.workflow - Optional raw workflow_def to set
  * @param args.workflow_spec - Optional WorkflowSpec (agent-built) - will be compiled
  * @param args.preview - If true, return changes without deploying (default: false)
@@ -201,8 +202,9 @@ export async function handleUpdate(args, client) {
     const projectSettings = existingProtoConfig.projectSettings;
     const isVoice = projectSettings?.projectType === 5;
     // Build merged proto_config with smart widget-level merging
+    // Accept both 'config' (tool schema) and 'proto_config' (internal) for compatibility
     let mergedProtoConfig = { ...existingProtoConfig };
-    const newProtoConfig = args.proto_config;
+    const newProtoConfig = (args.config ?? args.proto_config);
     const updatedWidgets = [];
     if (newProtoConfig) {
         // If proto_config has widgets, do smart widget-level merge

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/sync/index.js

@@ -4,28 +4,13 @@
  * Handles cross-environment synchronization of personas.
  */
 import { resolvePersona } from "../utils.js";
-// Deprecated param mappings for backwards compatibility
-const DEPRECATED_PARAMS = {
-    identifier: { newName: "id", message: "'identifier' is deprecated, use 'id' instead (will be removed in v2.0.0)" },
-};
-function checkDeprecatedParams(args) {
-    const warnings = [];
-    for (const [oldName, info] of Object.entries(DEPRECATED_PARAMS)) {
-        if (args[oldName] !== undefined) {
-            warnings.push(info.message);
-        }
-    }
-    return warnings;
-}
+import { handleDeprecatedParams } from "../deprecation.js";
 /**
  * Handle sync tool requests - sync personas across environments
  */
 export async function handleSync(args, createClient, getSyncOptions) {
-    // Check for deprecated params and log warnings
-    const deprecationWarnings = checkDeprecatedParams(args);
-    for (const warning of deprecationWarnings) {
-        console.warn(`[sync] Deprecation: ${warning}`);
-    }
+    // Check for deprecated params
+    handleDeprecatedParams(args, "sync");
     const mode = args.mode || "run";
     const id = args.id;
     const identifier = args.identifier; // deprecated alias for 'id'

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,31 @@
  * Workflow Deploy Handler
  *
  * Deploys a workflow_def to an existing persona.
+ * Includes deprecation warnings (does not block, just warns).
+ *
+ * BLOCKING VALIDATION:
+ * - If workflow has knowledge search nodes, data sources MUST be attached and indexed.
  */
 import { sanitizeWorkflowForDeploy } from "./utils.js";
+import { DEPRECATED_ACTIONS_FALLBACK, checkWorkflowDeprecations } from "./index.js";
+/**
+ * Detect knowledge search nodes in a workflow.
+ * Returns true if workflow contains search/v2 or search_datastore nodes (NOT web_search).
+ */
+function hasKnowledgeSearchNodes(workflowDef) {
+    const actions = (workflowDef.actions ?? []);
+    return actions.some(a => {
+        const actionType = a.action || a.actionType || "";
+        const name = a.name || "";
+        // Match: search, search/v2, search_datastore
+        // Exclude: web_search, live_web_search
+        const isSearchNode = actionType.includes("search") ||
+            name.toLowerCase().includes("search");
+        const isWebSearch = actionType.includes("web_search") ||
+            name.toLowerCase().includes("web_search");
+        return isSearchNode && !isWebSearch;
+    });
+}
 /**
  * Handle workflow deploy mode
  */
@@ -21,8 +44,103 @@ export async function handleWorkflowDeploy(args, client) {
     if (!persona) {
         return { error: `Persona not found: ${personaId}` };
     }
+    // ── BLOCKING VALIDATION: Bidirectional search/data source validation ──
+    const hasSearchNodes = hasKnowledgeSearchNodes(workflowDef);
+    let dataSourceStats = null;
+    // Try to get data source stats (used for both validation directions)
+    try {
+        dataSourceStats = await client.getDataSourceAggregates(personaId);
+    }
+    catch (statsError) {
+        // If we can't check stats, log warning but don't block
+        console.error(`[deploy] Could not verify data sources: ${statsError}`);
+    }
+    // VALIDATION 1: If workflow has search nodes, data sources MUST exist and be indexed
+    if (hasSearchNodes && dataSourceStats) {
+        if (dataSourceStats.total === 0) {
+            return {
+                error: "DEPLOYMENT BLOCKED: Workflow contains knowledge search nodes but persona has no data sources attached.",
+                mode: "deploy",
+                persona_id: personaId,
+                persona_name: persona.name,
+                validation_failed: "search_nodes_require_data_sources",
+                current_state: {
+                    search_nodes_detected: true,
+                    data_sources_total: 0,
+                    data_sources_indexed: 0,
+                },
+                _fix: [
+                    "1. Upload documents: persona(id='...',data={method:'upload',path:'/path/to/doc.pdf'})",
+                    "2. Check status: persona(id='...',data={method:'stats'}) → wait for 'success' > 0",
+                    "3. Then retry: workflow(mode='deploy', persona_id='...', workflow_def={...})",
+                ],
+            };
+        }
+        if (dataSourceStats.success === 0) {
+            return {
+                error: "DEPLOYMENT BLOCKED: Workflow contains knowledge search nodes but no data sources have been successfully indexed.",
+                mode: "deploy",
+                persona_id: personaId,
+                persona_name: persona.name,
+                validation_failed: "search_nodes_require_indexed_data",
+                current_state: {
+                    search_nodes_detected: true,
+                    data_sources_total: dataSourceStats.total,
+                    data_sources_pending: dataSourceStats.pending,
+                    data_sources_success: dataSourceStats.success,
+                    data_sources_failed: dataSourceStats.failed,
+                },
+                _fix: dataSourceStats.pending > 0
+                    ? [
+                        "Data sources are still indexing. Wait for indexing to complete:",
+                        "1. Check status: persona(id='...',data={method:'stats'})",
+                        "2. Retry when 'success' > 0",
+                    ]
+                    : [
+                        "All data sources failed indexing. Check file formats and re-upload:",
+                        "1. List files: persona(id='...',data={method:'list'})",
+                        "2. Delete failed: persona(id='...',data={method:'delete',file_id:'...'})",
+                        "3. Re-upload: persona(id='...',data={method:'upload',path:'...'})",
+                    ],
+            };
+        }
+    }
+    // VALIDATION 2: If persona has indexed data sources but workflow has NO search nodes → BLOCK
+    // This catches the case where user uploads documents but deploys a workflow that won't use them
+    if (!hasSearchNodes && dataSourceStats && dataSourceStats.success > 0) {
+        return {
+            error: "DEPLOYMENT BLOCKED: Persona has indexed knowledge files but workflow has no search nodes. The uploaded documents will NEVER be used.",
+            mode: "deploy",
+            persona_id: personaId,
+            persona_name: persona.name,
+            validation_failed: "data_sources_require_search_nodes",
+            current_state: {
+                search_nodes_detected: false,
+                data_sources_total: dataSourceStats.total,
+                data_sources_indexed: dataSourceStats.success,
+            },
+            _fix: [
+                "Your workflow needs a search node to query the uploaded documents.",
+                "1. Get workflow schema: workflow(mode='get', persona_id='...')",
+                "2. Add search node: Update workflow_def to include a search/v2 node that queries the knowledge base",
+                "3. Wire it up: Connect chat_trigger → summarizer → search → respond_for_external_actions",
+                "Example pattern: trigger → conversation_summarizer → search/v2 → respond_for_external_actions → WORKFLOW_OUTPUT",
+            ],
+            _example_workflow_pattern: {
+                nodes: [
+                    "chat_trigger (trigger)",
+                    "conversation_summarizer (extract query from conversation)",
+                    "search/v2 (query knowledge base with datastore_configs)",
+                    "respond_for_external_actions (generate response with sources)",
+                ],
+                flow: "trigger → summarizer → search → respond → output",
+            },
+        };
+    }
     // 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 +149,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 +181,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";
@@ -142,30 +142,13 @@ async function deployToNewPersona(args, client, compiled, actionRegistry, getTem
         widgets: Array.from(widgetMap.values()),
     };
     // Step 4: Deploy workflow
-    const existingWorkflow = newPersona.workflow_def;
-    const existingWfName = existingWorkflow?.workflowName;
-    const workflowForDeploy = JSON.parse(JSON.stringify(compiled.workflow_def));
-    const wfName = workflowForDeploy.workflowName;
-    if (wfName?.name && existingWfName?.name) {
-        wfName.name.namespaces = existingWfName.name.namespaces;
-        wfName.name.name = existingWfName.name.name;
-    }
-    // Fix results format
-    const compiledResults = workflowForDeploy.results;
-    if (compiledResults) {
-        const newResults = {};
-        for (const [, value] of Object.entries(compiledResults)) {
-            if (value.actionName && value.outputName) {
-                const key = `${value.actionName}.${value.outputName}`;
-                newResults[key] = value;
-            }
-        }
-        workflowForDeploy.results = newResults;
-    }
+    // NOTE: The SDK's updateAiEmployee() handles workflowName namespace automatically.
+    // It will copy from existing workflow if present, or generate a valid namespace if not.
+    // It also fixes the results format. No need to manually manipulate these here.
     try {
         await client.updateAiEmployee({
             persona_id: newPersonaId,
-            workflow: workflowForDeploy,
+            workflow: compiled.workflow_def,
             proto_config: mergedProtoConfig,
         }, { verbose: true });
         return { success: true, personaId: newPersonaId, personaName };
@@ -182,7 +165,7 @@ async function deployToNewPersona(args, client, compiled, actionRegistry, getTem
             personaId: newPersonaId,
             personaName,
             workflowDeployError: errMsg,
-            workflowAttempted: workflowForDeploy,
+            workflowAttempted: compiled.workflow_def,
         };
     }
 }
@@ -288,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 = {
@@ -304,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);