@ema.co/mcp-toolkit 1.5.2 → 1.6.0

package/dist/mcp/handlers-consolidated.js

@@ -8,7 +8,9 @@ import { createVersionStorage } from "../sdk/version-storage.js";
 import { createVersionPolicyEngine } from "../sdk/version-policy.js";
 import { AGENT_CATALOG, WORKFLOW_PATTERNS, QUALIFYING_QUESTIONS, PLATFORM_CONCEPTS, WORKFLOW_EXECUTION_MODEL, COMMON_MISTAKES, DEBUG_CHECKLIST, GUIDANCE_TOPICS, VOICE_PERSONA_TEMPLATE, getAgentByName, getWidgetsForPersonaType, checkTypeCompatibility, getQualifyingQuestionsByCategory, getRequiredQualifyingQuestions, getConceptByTerm, suggestAgentsForUseCase, validateWorkflowPrompt, detectWorkflowIssues, validateWorkflowConnections, suggestWorkflowFixes, } from "../sdk/knowledge.js";
 import { compileWorkflow } from "../sdk/workflow-generator.js";
-import { parseInput, intentToSpec } from "../sdk/workflow-intent.js";
+import { ensureActionRegistry } from "../sdk/action-registry.js";
+import { parseInput, intentToSpec, generateWorkflow } from "../sdk/workflow-intent.js";
+import { ensureSchemaRegistry, validateWorkflowSpec, generateActionCatalogForLLM } from "../sdk/workflow-validator.js";
 import { analyzeExecutionFlow, generateASCIIFlow } from "../sdk/workflow-execution-analyzer.js";
 // ─────────────────────────────────────────────────────────────────────────────
 // Widget Validation Helpers
@@ -61,6 +63,29 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
     const identifier = args.identifier; // deprecated alias
     const idOrName = id ?? identifier;
     const mode = args.mode;
+    // ═══════════════════════════════════════════════════════════════════════════
+    // UNIFIED HANDLING: Route workflow operations to handleWorkflow
+    // ═══════════════════════════════════════════════════════════════════════════
+    const input = args.input;
+    const optimize = args.optimize;
+    const workflowDef = args.workflow_def ?? args.workflow;
+    // If input is provided → this is a create/modify workflow operation
+    // If optimize is provided → this is an optimize operation
+    // If id + workflowDef provided → this is a deploy operation
+    // Route these to handleWorkflow
+    if (input || optimize || (idOrName && workflowDef)) {
+        // Map persona args to workflow args
+        const workflowArgs = {
+            ...args,
+            persona_id: idOrName, // workflow uses persona_id not id
+        };
+        delete workflowArgs.id;
+        delete workflowArgs.identifier;
+        return handleWorkflow(workflowArgs, client, getTemplateId);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Standard persona operations (get, list, compare, version management)
+    // ═══════════════════════════════════════════════════════════════════════════
     // Determine effective mode
     let effectiveMode = mode;
     if (!effectiveMode) {
@@ -752,6 +777,8 @@ export async function handleWorkflow(args, client, getTemplateId) {
             if (!input) {
                 return { error: "input required for generate mode" };
             }
+            // Load action registry for API-driven action versions/namespaces
+            const actionRegistry = await ensureActionRegistry(client);
             const parseResult = parseInput(input);
             if (!parseResult.validation.complete) {
                 return {
@@ -761,10 +788,75 @@ export async function handleWorkflow(args, client, getTemplateId) {
                     questions: parseResult.validation.questions,
                 };
             }
-            // Convert to spec and compile
-            const spec = intentToSpec(parseResult.intent);
-            const compiled = compileWorkflow(spec);
-            // Validate the generated workflow
+            // Override persona_type from args.type if provided (args.type takes precedence)
+            if (args.type) {
+                parseResult.intent.persona_type = args.type;
+            }
+            // Check if intent requires LLM-driven generation
+            const genResult = generateWorkflow(parseResult.intent);
+            // Load schema registry for API-driven validation (graceful degradation if unavailable)
+            let schemaRegistry;
+            try {
+                schemaRegistry = await ensureSchemaRegistry(client);
+            }
+            catch {
+                // Schema registry unavailable - skip API validation
+                schemaRegistry = null;
+            }
+            if (genResult.needs_llm) {
+                // Complex workflow - return prompt for LLM to generate
+                // Enhanced with API-driven action catalog if available
+                let enhancedPrompt = genResult.llm_prompt;
+                let availableActions = [];
+                let availableTemplates = [];
+                if (schemaRegistry) {
+                    const actionCatalog = generateActionCatalogForLLM(schemaRegistry);
+                    enhancedPrompt = genResult.llm_prompt ? {
+                        system: genResult.llm_prompt.system + "\n\n" + actionCatalog,
+                        user: genResult.llm_prompt.user,
+                    } : undefined;
+                    availableActions = schemaRegistry.getAllActions().map(a => a.name);
+                    availableTemplates = schemaRegistry.getAllTemplates().map(t => ({ id: t.id, name: t.name, type: t.type }));
+                }
+                return {
+                    status: "needs_llm_generation",
+                    reason: genResult.reason,
+                    complexity: genResult.complexity,
+                    llm_prompt: enhancedPrompt,
+                    hint: "Send llm_prompt to an LLM, then call persona(workflow_def=<parsed_response>) to deploy.",
+                    // Also provide basic spec as fallback (without complex chains)
+                    fallback_spec: intentToSpec(parseResult.intent),
+                    // Include catalogs for reference (if available)
+                    available_actions: availableActions,
+                    available_templates: availableTemplates,
+                };
+            }
+            // Simple workflow - use generated spec directly
+            const spec = genResult.spec;
+            // Override spec name with provided name if given (args.name takes precedence over parsed name)
+            if (args.name) {
+                spec.name = args.name;
+            }
+            if (args.description) {
+                spec.description = args.description;
+            }
+            // Validate spec against API schemas BEFORE compiling (if schema registry available)
+            let specValidation = null;
+            if (schemaRegistry) {
+                specValidation = validateWorkflowSpec(spec, schemaRegistry);
+                if (!specValidation.valid) {
+                    return {
+                        status: "validation_failed",
+                        errors: specValidation.errors,
+                        warnings: specValidation.warnings,
+                        action_coverage: specValidation.action_coverage,
+                        hint: "Fix the validation errors and try again. Unknown actions may need to be checked against ListActions.",
+                        spec_attempted: spec,
+                    };
+                }
+            }
+            const compiled = compileWorkflow(spec, { registry: actionRegistry });
+            // Validate the generated workflow (structural checks)
             const issues = detectWorkflowIssues(compiled.workflow_def);
             const result = {
                 mode: "generate",
@@ -773,6 +865,14 @@ export async function handleWorkflow(args, client, getTemplateId) {
                 proto_config: compiled.proto_config,
                 validation: parseResult.validation,
             };
+            // Include API validation results if available
+            if (specValidation) {
+                result.api_validation = {
+                    valid: specValidation.valid,
+                    warnings: specValidation.warnings,
+                    action_coverage: specValidation.action_coverage,
+                };
+            }
             if (issues.length > 0) {
                 result.issues = issues;
             }
@@ -790,18 +890,19 @@ export async function handleWorkflow(args, client, getTemplateId) {
                 result.deployed_to = { persona_id: personaId, persona_name: persona.name };
             }
             else if (!preview && !personaId) {
-                // GREENFIELD: Create new persona from template, then update proto_config only
-                // The template provides a valid workflow structure - we don't replace it,
-                // we just configure the persona settings (voice config, welcome message, etc.)
+                // GREENFIELD: Create new persona from template, then deploy workflow + proto_config
                 const personaName = args.name;
                 if (personaName) {
                     const personaType = args.type || "chat";
-                    const DEFAULT_TEMPLATES = {
-                        voice: "00000000-0000-0000-0000-00000000001e", // Voice AI template
-                        chat: "00000000-0000-0000-0000-000000000004", // Chat AI template
-                        dashboard: "00000000-0000-0000-0000-000000000002", // Dashboard AI template
+                    // Try API-driven template lookup first, fallback to hardcoded IDs
+                    const FALLBACK_TEMPLATES = {
+                        voice: "00000000-0000-0000-0000-00000000001e", // Voice AI template (fallback)
+                        chat: "00000000-0000-0000-0000-000000000004", // Chat AI template (fallback)
+                        dashboard: "00000000-0000-0000-0000-000000000002", // Dashboard AI template (fallback)
                     };
-                    const templateId = getTemplateId?.(personaType) || DEFAULT_TEMPLATES[personaType];
+                    // Use registry to find template by type
+                    const templateFromRegistry = actionRegistry.getTemplateForType(personaType);
+                    const templateId = getTemplateId?.(personaType) || templateFromRegistry?.id || FALLBACK_TEMPLATES[personaType];
                     if (!templateId) {
                         return {
                             error: `No template found for type "${personaType}". Provide template_id or use type: voice, chat, or dashboard.`
@@ -859,12 +960,57 @@ export async function handleWorkflow(args, client, getTemplateId) {
                         ...existingProtoConfig,
                         widgets: Array.from(widgetMap.values()),
                     };
-                    // Step 4: Update persona with merged proto_config only
-                    // DO NOT send workflow - keep the template's valid workflow structure
-                    await client.updateAiEmployee({
-                        persona_id: newPersonaId,
-                        proto_config: mergedProtoConfig,
-                    });
+                    // Step 4: Deploy BOTH workflow AND proto_config for ALL persona types
+                    // Voice AI IS driven by workflow (not just identityAndPurpose)
+                    const existingWorkflow = newPersona.workflow_def;
+                    const existingWfName = existingWorkflow?.workflowName;
+                    // Clone our compiled workflow and set the namespace from the existing workflow
+                    const workflowForDeploy = JSON.parse(JSON.stringify(compiled.workflow_def));
+                    const wfName = workflowForDeploy.workflowName;
+                    if (wfName?.name && existingWfName?.name) {
+                        // Copy the exact namespace from the template workflow
+                        wfName.name.namespaces = existingWfName.name.namespaces;
+                        wfName.name.name = existingWfName.name.name; // template_id
+                    }
+                    // Fix results format - use "<actionName>.<outputName>" keys
+                    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;
+                    }
+                    try {
+                        await client.updateAiEmployee({
+                            persona_id: newPersonaId,
+                            workflow: workflowForDeploy,
+                            proto_config: mergedProtoConfig,
+                        }, { verbose: true });
+                    }
+                    catch (deployError) {
+                        // Workflow deploy failed - still set proto_config
+                        const errMsg = deployError instanceof Error ? deployError.message : String(deployError);
+                        await client.updateAiEmployee({
+                            persona_id: newPersonaId,
+                            proto_config: mergedProtoConfig,
+                        });
+                        result.workflow_deploy_error = errMsg;
+                        result.workflow_attempted = workflowForDeploy;
+                        result.status = "partial";
+                        result.hint = "Persona created, config set, but workflow deploy failed. Check workflow_attempted for details.";
+                        result.deployed_to = {
+                            persona_id: newPersonaId,
+                            persona_name: personaName,
+                            created: true,
+                            workflow_deployed: false,
+                        };
+                        return result;
+                    }
+                    // Success - workflow deployed for all persona types
                     result.deployed_to = {
                         persona_id: newPersonaId,
                         persona_name: personaName,
@@ -904,6 +1050,88 @@ export async function handleWorkflow(args, client, getTemplateId) {
             if (!persona) {
                 return { error: `Persona not found: ${personaId}` };
             }
+            // ─────────────────────────────────────────────────────────────────────────
+            // CONFIG-ONLY DETECTION: Route to proto_config update instead of workflow
+            // ─────────────────────────────────────────────────────────────────────────
+            const lowerInput = input.toLowerCase();
+            const isConfigOnlyUpdate = ((lowerInput.includes("voice settings") || lowerInput.includes("voice config")) ||
+                (lowerInput.includes("welcome message") && !lowerInput.includes("add") && !lowerInput.includes("node")) ||
+                (lowerInput.includes("identity") && lowerInput.includes("purpose")) ||
+                (lowerInput.includes("speech characteristics")) ||
+                (lowerInput.includes("hangup instructions") || lowerInput.includes("hangup")) ||
+                (lowerInput.includes("update") && (lowerInput.includes("persona settings") ||
+                    lowerInput.includes("conversation settings") ||
+                    lowerInput.includes("proto_config") ||
+                    lowerInput.includes("chat settings"))));
+            if (isConfigOnlyUpdate) {
+                // This is a config update, not a workflow modification
+                // Parse the config values from the input and update proto_config only
+                const existingProtoConfig = (persona.proto_config ?? {});
+                const existingWidgets = (existingProtoConfig.widgets ?? []);
+                // Find and update the conversationSettings widget
+                const widgetMap = new Map();
+                for (const w of existingWidgets) {
+                    if (typeof w.name === "string" && w.name.trim().length > 0) {
+                        widgetMap.set(w.name, { ...w });
+                    }
+                }
+                // Parse voice config updates from input
+                const configUpdates = {};
+                // Extract welcome message
+                const welcomeMatch = input.match(/welcome\s*message[:\s]*["']?([^"'\n]+(?:\n(?![0-9]+\.).*)*?)(?:["']|(?=\n\n|\n[0-9]+\.))/i);
+                if (welcomeMatch) {
+                    configUpdates.welcomeMessage = welcomeMatch[1].trim().replace(/^["']|["']$/g, '');
+                }
+                // Extract identity and purpose
+                const identityMatch = input.match(/identity\s*(?:and\s*)?purpose[:\s]*["']?(.+?)(?:["']|(?=\n\n[0-9]+\.|$))/is);
+                if (identityMatch) {
+                    configUpdates.identityAndPurpose = identityMatch[1].trim().replace(/^["']|["']$/g, '');
+                }
+                // Extract speech characteristics
+                const speechMatch = input.match(/speech\s*characteristics?[:\s]*["']?([^"'\n]+)["']?/i);
+                if (speechMatch) {
+                    configUpdates.speechCharacteristics = speechMatch[1].trim().replace(/^["']|["']$/g, '');
+                }
+                // Extract hangup instructions
+                const hangupMatch = input.match(/hangup\s*instructions?[:\s]*["']?(.+?)(?:["']|$)/is);
+                if (hangupMatch) {
+                    configUpdates.hangupInstructions = hangupMatch[1].trim().replace(/^["']|["']$/g, '');
+                }
+                // Update conversationSettings widget
+                const convWidget = widgetMap.get("conversationSettings") || {
+                    name: "conversationSettings",
+                    type: 39,
+                    conversationSettings: {},
+                };
+                const convSettings = (convWidget.conversationSettings ?? {});
+                // Merge config updates
+                for (const [key, value] of Object.entries(configUpdates)) {
+                    convSettings[key] = value;
+                }
+                convWidget.conversationSettings = convSettings;
+                widgetMap.set("conversationSettings", convWidget);
+                const mergedProtoConfig = {
+                    ...existingProtoConfig,
+                    widgets: Array.from(widgetMap.values()),
+                };
+                if (!preview) {
+                    // Deploy config update only - preserve existing workflow
+                    await client.updateAiEmployee({
+                        persona_id: personaId,
+                        proto_config: mergedProtoConfig,
+                        workflow: persona.workflow_def,
+                    });
+                }
+                return {
+                    mode: "config_update",
+                    status: preview ? "preview" : "deployed",
+                    persona_id: personaId,
+                    persona_name: persona.name,
+                    config_updates: configUpdates,
+                    note: "Updated persona configuration only. Workflow unchanged.",
+                    hint: "To modify the workflow itself, describe workflow changes like 'add search node' or 'add HITL before email'.",
+                };
+            }
             const existingWorkflow = persona.workflow_def;
             if (!existingWorkflow) {
                 return {
@@ -1139,6 +1367,8 @@ export async function handleWorkflow(args, client, getTemplateId) {
             if (!nodes) {
                 return { error: "nodes required for compile mode" };
             }
+            // Load action registry for API-driven action versions/namespaces
+            const compileRegistry = await ensureActionRegistry(client);
             const spec = {
                 name: args.name || "Compiled Workflow",
                 description: args.description || "Generated workflow",
@@ -1146,10 +1376,11 @@ export async function handleWorkflow(args, client, getTemplateId) {
                 nodes: nodes,
                 result_mappings: resultMappings || [],
             };
-            const compiled = compileWorkflow(spec);
+            const compiled = compileWorkflow(spec, { registry: compileRegistry });
             return {
                 workflow_def: compiled.workflow_def,
                 proto_config: compiled.proto_config,
+                registry_loaded: compileRegistry.isLoaded(),
             };
         }
         case "optimize": {

package/dist/mcp/server.js

@@ -2613,13 +2613,6 @@ const toolHandlers = {
                 preserveExistingNodes: false, // Replace with incoming structure
                 forceReplace: false, // Don't force if there are conflicts
             });
-            // #region agent log
-            // Log brownfield merge result
-            try {
-                fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:brownfieldMerge', message: 'Brownfield merge result', data: { success: mergeResult.success, description: mergeResult.description, diff: { nodesAdded: mergeResult.diff.nodesAdded, nodesRemoved: mergeResult.diff.nodesRemoved, nodesModified: mergeResult.diff.nodesModified, enumsAdded: mergeResult.diff.enumsAdded, enumsModified: mergeResult.diff.enumsModified, hasHitlNodes: mergeResult.diff.hasHitlNodes, conflictCount: mergeResult.diff.conflicts.length }, warnings: mergeResult.warnings, errors: mergeResult.errors, requiresAutobuilder: mergeResult.requiresAutobuilder }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'brownfield-merge', hypothesisId: 'H12' }) }).catch(() => { });
-            }
-            catch { }
-            // #endregion agent log
             if (!mergeResult.success) {
                 // Merge failed due to conflicts - return the errors
                 return {
@@ -2639,12 +2632,6 @@ const toolHandlers = {
             // Validate the merged workflow structure
             const mergeValidation = validateMergedWorkflow(workflowDef);
             if (!mergeValidation.valid) {
-                // #region agent log
-                try {
-                    fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:mergeValidationFailed', message: 'Merged workflow validation failed', data: { issues: mergeValidation.issues }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'brownfield-merge', hypothesisId: 'H12' }) }).catch(() => { });
-                }
-                catch { }
-                // #endregion agent log
                 return {
                     environment: client["env"].name,
                     success: false,
@@ -2660,12 +2647,6 @@ const toolHandlers = {
             // If HITL nodes are involved, force Autobuilder deployment
             // (Direct API doesn't support HITL workflow changes)
             if (mergeResult.requiresAutobuilder) {
-                // #region agent log
-                try {
-                    fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:hitlRequiresAutobuilder', message: 'HITL workflow requires Autobuilder', data: { hasHitlNodes: mergeResult.diff.hasHitlNodes, nodesAdded: mergeResult.diff.nodesAdded }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'brownfield-merge', hypothesisId: 'H11' }) }).catch(() => { });
-                }
-                catch { }
-                // #endregion agent log
                 deploymentMethod = "autobuilder";
             }
         }
@@ -2824,14 +2805,6 @@ const toolHandlers = {
                         actionOutputField.output = "hitl_status";
                         inlineRhsField.enumValue = correctedEnumVal;
                         hitlFixCount++;
-                        // #region agent log
-                        try {
-                            if (process.env.EMA_MCP_DEBUG_LOGS === "1") {
-                                fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:hitlAutoFix', message: 'Auto-fixed malformed HITL runIf', data: { nodeName: String(action.name), originalOutput: outputStr, correctedOutput: 'hitl_status', correctedEnumValue: correctedEnumVal }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'hitl-fix', hypothesisId: 'H1' }) }).catch(() => { });
-                            }
-                        }
-                        catch { }
-                        // #endregion agent log
                     }
                 }
             }
@@ -2842,57 +2815,6 @@ const toolHandlers = {
             proto_config: mergedProtoConfig,
             workflow: workflowDef,
         };
-        // #region agent log
-        // H1/H2: confirm what we're attempting to deploy (structure only).
-        try {
-            if (process.env.EMA_MCP_DEBUG_LOGS !== "1") {
-                // disabled
-            }
-            else {
-                const wf = workflowDef ?? {};
-                const actions = wf.actions ?? [];
-                const actionNames = actions.map((a) => String(a.name ?? "")).filter(Boolean);
-                const actionTypeNames = actions
-                    .map((a) => {
-                    const an = a.action;
-                    return String(an?.name?.name ?? "");
-                })
-                    .filter(Boolean);
-                const hasHitl = actionTypeNames.some((t) => t.toLowerCase().includes("hitl")) || actionNames.some((n) => n.toLowerCase().includes("hitl"));
-                const hasTriggerWhen = actions.some((a) => {
-                    const inputs = a.inputs;
-                    return !!inputs && Object.prototype.hasOwnProperty.call(inputs, "trigger_when");
-                });
-                const runIfCount = actions.reduce((acc, a) => acc + (a.runIf ? 1 : 0), 0);
-                const wfName = wf.workflowName ?? {};
-                fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:preDeploy', message: 'Deploy workflow request summary', data: { env: client["env"].name, personaId, validateFirst, autoFix, actionCount: actions.length, runIfCount, hasHitl, hasTriggerWhen, workflowName: wfName }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'pre-fix', hypothesisId: 'H1' }) }).catch(() => { });
-                // H1: Detect malformed HITL runIf patterns
-                const malformedHitlPatterns = [];
-                for (const action of actions) {
-                    const runIf = action.runIf;
-                    if (!runIf)
-                        continue;
-                    const lhs = runIf.lhs;
-                    if (!lhs?.actionOutput)
-                        continue;
-                    const actionOutput = lhs.actionOutput;
-                    const output = String(actionOutput.output ?? "");
-                    // Malformed pattern: output contains both field name AND enum value like "hitl_status_HITL Success"
-                    if (output.includes("hitl_status_HITL") || output.includes("hitl_status HITL")) {
-                        malformedHitlPatterns.push({
-                            nodeName: String(action.name),
-                            output,
-                            issue: `Should be output="hitl_status" with enumValue="${output.replace(/hitl_status[_\s]?/i, "")}"`
-                        });
-                    }
-                }
-                if (malformedHitlPatterns.length > 0) {
-                    fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:malformedHitl', message: 'DETECTED malformed HITL runIf patterns', data: { env: client["env"].name, personaId, malformedCount: malformedHitlPatterns.length, patterns: malformedHitlPatterns }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'debug-hitl', hypothesisId: 'H1' }) }).catch(() => { });
-                }
-            }
-        }
-        catch { }
-        // #endregion agent log
         // Deployment attempt with automatic fallback
         let deployedVia = "direct_api";
         let autobuilderResult;
@@ -2902,50 +2824,6 @@ const toolHandlers = {
             }
             catch (err) {
                 const errorMessage = err instanceof Error ? err.message : String(err);
-                // #region agent log
-                // H1/H2: capture top-level failure classification (do not log secrets).
-                try {
-                    if (process.env.EMA_MCP_DEBUG_LOGS !== "1") {
-                        // disabled
-                    }
-                    else {
-                        fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:directApiError', message: 'Direct deploy failed', data: { env: client["env"].name, personaId, errorMessage }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'pre-fix', hypothesisId: 'H2' }) }).catch(() => { });
-                    }
-                }
-                catch { }
-                // #endregion agent log
-                // H5: When update_persona returns a generic 500, attempt CheckWorkflow to extract structured validation errors.
-                // This is best-effort and only runs when debug logs are enabled to minimize extra traffic.
-                try {
-                    if (process.env.EMA_MCP_DEBUG_LOGS === "1" && workflowDef && errorMessage.toLowerCase().includes("internal server error")) {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const check = await client.checkWorkflow(workflowDef);
-                        const checkJson = JSON.stringify(check);
-                        const snippet = checkJson.length > 3000 ? `${checkJson.slice(0, 3000)}…(truncated)` : checkJson;
-                        fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:checkWorkflow', message: 'CheckWorkflow output (post-500)', data: { env: client["env"].name, personaId, checkSnippet: snippet }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'pre-fix', hypothesisId: 'H5' }) }).catch(() => { });
-                    }
-                }
-                catch (checkErr) {
-                    try {
-                        if (process.env.EMA_MCP_DEBUG_LOGS === "1") {
-                            const m = checkErr instanceof Error ? checkErr.message : String(checkErr);
-                            fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:checkWorkflowError', message: 'CheckWorkflow failed (post-500)', data: { env: client["env"].name, personaId, error: m }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'pre-fix', hypothesisId: 'H5' }) }).catch(() => { });
-                        }
-                    }
-                    catch { }
-                }
-                // #region agent log
-                // H2: Log fallback decision path for 500 errors
-                try {
-                    if (process.env.EMA_MCP_DEBUG_LOGS === "1") {
-                        const isNoExistingWorkflow = errorMessage.includes("Cannot set persona workflow without existing workflow");
-                        const isNameMismatch = errorMessage.includes("Workflow name does not match");
-                        const is500Error = errorMessage.toLowerCase().includes("internal server error") || errorMessage.includes("500");
-                        fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:fallbackDecision', message: 'Evaluating fallback path', data: { env: client["env"].name, personaId, errorMessage, isNoExistingWorkflow, isNameMismatch, is500Error, hasWorkflowDef: !!workflowDef, willFallbackToAutobuilder: isNoExistingWorkflow || is500Error }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'debug-fallback', hypothesisId: 'H2' }) }).catch(() => { });
-                    }
-                }
-                catch { }
-                // #endregion agent log
                 // If direct API fails due to "no existing workflow", try Auto Builder
                 if (errorMessage.includes("Cannot set persona workflow without existing workflow") && workflowDef) {
                     deploymentMethod = "autobuilder";
@@ -2957,15 +2835,7 @@ const toolHandlers = {
                         `(Technical: ${errorMessage})`);
                 }
                 else if ((errorMessage.toLowerCase().includes("internal server error") || errorMessage.includes("500")) && workflowDef) {
-                    // #region agent log
-                    // H2: 500 error - attempt Autobuilder fallback instead of throwing
-                    try {
-                        if (process.env.EMA_MCP_DEBUG_LOGS === "1") {
-                            fetch('http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'src/mcp/server.ts:deploy_workflow:500Fallback', message: '500 error - attempting Autobuilder fallback', data: { env: client["env"].name, personaId, errorMessage }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'debug-fallback', hypothesisId: 'H2' }) }).catch(() => { });
-                        }
-                    }
-                    catch { }
-                    // #endregion agent log
+                    // 500 error - attempt Autobuilder fallback
                     deploymentMethod = "autobuilder";
                 }
                 else {
@@ -5408,34 +5278,6 @@ function generateEntityDocument(entityType, entity, related, tags) {
 const promptRegistry = new PromptRegistry();
 const resourceRegistry = new ResourceRegistry();
 export async function startMcpServer() {
-    // #region agent log
-    // H6: confirm which server instance is running (cwd/version/env).
-    try {
-        if (process.env.EMA_MCP_DEBUG_LOGS === "1") {
-            fetch("http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    location: "src/mcp/server.ts:startMcpServer:startup",
-                    message: "MCP server starting",
-                    data: {
-                        cwd: process.cwd(),
-                        argv0to5: process.argv.slice(0, 6),
-                        nodeEnv: process.env.NODE_ENV ?? null,
-                        emaEnvName: process.env.EMA_ENV_NAME ?? null,
-                        codeDir: process.env.EMA_MCP_CODE_DIR ?? null,
-                        debugLogs: process.env.EMA_MCP_DEBUG_LOGS ?? null,
-                    },
-                    timestamp: Date.now(),
-                    sessionId: "debug-session",
-                    runId: "pre-fix",
-                    hypothesisId: "H6",
-                }),
-            }).catch(() => { });
-        }
-    }
-    catch { }
-    // #endregion agent log
     const server = new Server({ name: "ema", version: "1.0.0" }, {
         capabilities: {
             tools: {},
@@ -5450,28 +5292,6 @@ export async function startMcpServer() {
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         const handler = toolHandlers[name];
-        // #region agent log
-        // H6: prove which tool is invoked and with which top-level keys (no secrets).
-        try {
-            if (process.env.EMA_MCP_DEBUG_LOGS === "1") {
-                const argKeys = args && typeof args === "object" ? Object.keys(args) : [];
-                fetch("http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22", {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({
-                        location: "src/mcp/server.ts:CallToolRequestSchema:entry",
-                        message: "MCP tool invoked",
-                        data: { toolName: name, argKeys },
-                        timestamp: Date.now(),
-                        sessionId: "debug-session",
-                        runId: "pre-fix",
-                        hypothesisId: "H6",
-                    }),
-                }).catch(() => { });
-            }
-        }
-        catch { }
-        // #endregion agent log
         if (!handler) {
             return {
                 content: [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}` }) }],
@@ -5485,28 +5305,6 @@ export async function startMcpServer() {
             };
         }
         catch (error) {
-            // #region agent log
-            // H6: capture top-level handler exception message.
-            try {
-                if (process.env.EMA_MCP_DEBUG_LOGS === "1") {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    fetch("http://127.0.0.1:7245/ingest/c9b6768a-494d-4365-bd46-bf6c43dc1e22", {
-                        method: "POST",
-                        headers: { "Content-Type": "application/json" },
-                        body: JSON.stringify({
-                            location: "src/mcp/server.ts:CallToolRequestSchema:error",
-                            message: "Tool handler threw",
-                            data: { toolName: name, errorMessage: msg },
-                            timestamp: Date.now(),
-                            sessionId: "debug-session",
-                            runId: "pre-fix",
-                            hypothesisId: "H6",
-                        }),
-                    }).catch(() => { });
-                }
-            }
-            catch { }
-            // #endregion agent log
             return {
                 content: [{ type: "text", text: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }) }],
                 isError: true,