@ema.co/mcp-toolkit 1.5.2 → 1.7.0

package/dist/mcp/handlers-consolidated.js

@@ -8,8 +8,12 @@ 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 { runIntentArchitect } from "../sdk/intent-architect.js";
 import { analyzeExecutionFlow, generateASCIIFlow } from "../sdk/workflow-execution-analyzer.js";
+import { SanitizationSession, sanitizePersona, buildConfirmationPrompt, detectWithPatterns, } from "../sdk/sanitizer.js";
 // ─────────────────────────────────────────────────────────────────────────────
 // Widget Validation Helpers
 // ─────────────────────────────────────────────────────────────────────────────
@@ -43,7 +47,7 @@ function validateWidgetsForApi(widgets) {
 // ═══════════════════════════════════════════════════════════════════════════
 // ENV Handler
 // ═══════════════════════════════════════════════════════════════════════════
-export async function handleEnv(_args, getEnvironments) {
+export async function handleEnv(_args, getEnvironments, toolkit) {
     const envs = getEnvironments();
     return {
         environments: envs.map(e => ({
@@ -51,6 +55,7 @@ export async function handleEnv(_args, getEnvironments) {
             default: e.isDefault,
         })),
         count: envs.length,
+        toolkit: toolkit ?? { name: "unknown", version: "unknown" },
     };
 }
 // ═══════════════════════════════════════════════════════════════════════════
@@ -61,13 +66,41 @@ 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
+    // BUG FIX: clone_from and name+type now properly route to "create" mode
     let effectiveMode = mode;
     if (!effectiveMode) {
         if (args.templates)
             effectiveMode = "templates";
         else if (args.all || args.query || args.status || args.trigger_type)
             effectiveMode = "list";
+        else if (args.sanitize && idOrName)
+            effectiveMode = "sanitize"; // Standalone sanitize mode
+        else if (args.clone_from || (args.name && (args.type || args.template_id)))
+            effectiveMode = "create";
         else if (idOrName)
             effectiveMode = "get";
         else
@@ -151,18 +184,185 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
             if (!templateId && args.type) {
                 templateId = getTemplateId(args.type);
             }
+            // Check if cloning from dashboard persona
+            const cloneFrom = args.clone_from;
+            const cloneData = args.clone_data;
+            let sourcePersona = null;
+            let sourcePersonaType;
+            let sourceDashboardId;
+            if (cloneFrom && cloneData) {
+                try {
+                    sourcePersona = await resolvePersona(client, cloneFrom);
+                    if (sourcePersona) {
+                        const protoConfig = sourcePersona.proto_config;
+                        const projectSettings = protoConfig?.projectSettings;
+                        const projectType = projectSettings?.projectType;
+                        sourcePersonaType = projectType === 5 ? "voice" : projectType === 4 ? "chat" : projectType === 2 ? "dashboard" : undefined;
+                        sourceDashboardId = sourcePersona.workflow_dashboard_id;
+                    }
+                }
+                catch {
+                    // Ignore errors in source persona detection
+                }
+            }
             const result = await client.createAiEmployee({
                 name,
                 description: args.description,
                 template_id: templateId,
-                source_persona_id: args.clone_from,
-                clone_data: args.clone_data,
+                source_persona_id: cloneFrom,
+                clone_data: cloneData,
             });
-            return {
+            const newPersonaId = result.persona_id ?? result.id;
+            // Automatically clone dashboard rows if source is a dashboard persona
+            let dashboardCloneResult;
+            if (sourcePersonaType === "dashboard" && sourceDashboardId && newPersonaId && cloneData) {
+                try {
+                    // Dashboard operations require the persona to be enabled
+                    // Auto-enable the persona temporarily for cloning
+                    const newPersona = await client.getPersonaById(newPersonaId);
+                    const newPersonaProtoConfig = newPersona?.proto_config;
+                    // Enable the persona so we can add dashboard rows
+                    await client.updateAiEmployee({
+                        persona_id: newPersonaId,
+                        proto_config: newPersonaProtoConfig ?? {},
+                        enabled_by_user: true,
+                    });
+                    // Get source dashboard rows
+                    const sourceRows = await client.getDashboardRows(sourceDashboardId, sourcePersona.id);
+                    if (sourceRows.rows.length > 0) {
+                        // Identify input columns
+                        const inputColumns = sourceRows.schema.columns.filter(c => c.isInput);
+                        // Clone each row
+                        const results = [];
+                        const shouldSanitize = args.sanitize;
+                        const sanitizeExamples = args.sanitize_examples;
+                        // Create sanitization session if needed
+                        let sanitizationSession;
+                        if (shouldSanitize) {
+                            sanitizationSession = new SanitizationSession();
+                        }
+                        for (const row of sourceRows.rows) {
+                            try {
+                                // Build inputs from row's input column values
+                                const inputs = [];
+                                for (const inputCol of inputColumns) {
+                                    const colValue = row.columnValues.find(cv => cv.columnId === inputCol.columnId);
+                                    if (!colValue)
+                                        continue;
+                                    // Handle different column types
+                                    if (inputCol.columnType === "COLUMN_TYPE_DOCUMENT") {
+                                        // Skip document columns for now
+                                        continue;
+                                    }
+                                    else if (inputCol.columnType === "COLUMN_TYPE_STRING") {
+                                        let value = colValue.value.stringValue ?? "";
+                                        // Sanitize if enabled
+                                        if (sanitizationSession && value) {
+                                            const detected = detectWithPatterns(value);
+                                            for (const entity of detected) {
+                                                const replacement = sanitizationSession.getOrCreateReplacement(entity.value, entity.type);
+                                                value = value.split(entity.value).join(replacement);
+                                            }
+                                            if (sanitizeExamples) {
+                                                for (const example of sanitizeExamples) {
+                                                    if (value.includes(example)) {
+                                                        const replacement = sanitizationSession.getOrCreateReplacement(example, "unknown");
+                                                        value = value.split(example).join(replacement);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        inputs.push({ name: inputCol.name, string_value: value });
+                                    }
+                                    else if (inputCol.columnType === "COLUMN_TYPE_ARRAY") {
+                                        const arrayVals = colValue.value.arrayValue?.arrayValues ?? [];
+                                        if (arrayVals.length > 0) {
+                                            let value = arrayVals[0].stringValue ?? "";
+                                            if (sanitizationSession && value) {
+                                                const detected = detectWithPatterns(value);
+                                                for (const entity of detected) {
+                                                    const replacement = sanitizationSession.getOrCreateReplacement(entity.value, entity.type);
+                                                    value = value.split(entity.value).join(replacement);
+                                                }
+                                            }
+                                            inputs.push({ name: inputCol.name, string_value: value });
+                                        }
+                                    }
+                                }
+                                if (inputs.length === 0) {
+                                    results.push({ source_row_id: row.id, status: "skipped", error: "No clonable input values" });
+                                    continue;
+                                }
+                                // Upload the row to target dashboard
+                                const uploadResult = await client.uploadAndRunDashboardRow(newPersonaId, inputs);
+                                results.push({ source_row_id: row.id, target_row_id: uploadResult.row_id, status: "cloned" });
+                            }
+                            catch (err) {
+                                results.push({ source_row_id: row.id, status: "error", error: err instanceof Error ? err.message : String(err) });
+                            }
+                        }
+                        const clonedCount = results.filter(r => r.status === "cloned").length;
+                        dashboardCloneResult = {
+                            source_rows: sourceRows.rows.length,
+                            cloned_rows: clonedCount,
+                            skipped_rows: results.filter(r => r.status === "skipped").length,
+                            error_rows: results.filter(r => r.status === "error").length,
+                            sanitization_applied: !!shouldSanitize,
+                        };
+                    }
+                    else {
+                        dashboardCloneResult = { source_rows: 0, cloned_rows: 0, message: "Source dashboard was empty" };
+                    }
+                }
+                catch (err) {
+                    dashboardCloneResult = { error: `Dashboard clone failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            }
+            // Handle sanitization for non-dashboard personas
+            const shouldSanitize = args.sanitize;
+            if (shouldSanitize && newPersonaId && sourcePersonaType !== "dashboard") {
+                const sanitizeResult = await sanitizePersonaById(client, newPersonaId, {
+                    examples: args.sanitize_examples,
+                });
+                return {
+                    success: true,
+                    persona_id: newPersonaId,
+                    name,
+                    sanitization: sanitizeResult,
+                };
+            }
+            const createResult = {
                 success: true,
-                persona_id: result.persona_id,
+                persona_id: newPersonaId,
                 name,
             };
+            if (sourcePersonaType) {
+                createResult.source_persona_type = sourcePersonaType;
+            }
+            if (dashboardCloneResult) {
+                createResult.dashboard_data_clone = dashboardCloneResult;
+            }
+            return createResult;
+        }
+        case "sanitize": {
+            // Standalone sanitize mode: sanitize an existing persona
+            if (!idOrName) {
+                return { error: "id required for sanitize mode" };
+            }
+            const persona = await resolvePersona(client, idOrName);
+            if (!persona) {
+                return { error: `Persona not found: ${idOrName}` };
+            }
+            const sanitizeResult = await sanitizePersonaById(client, persona.id, {
+                examples: args.sanitize_examples,
+                preview: args.preview,
+            });
+            return {
+                mode: "sanitize",
+                persona_id: persona.id,
+                persona_name: persona.name,
+                ...sanitizeResult,
+            };
         }
         case "update": {
             if (!idOrName) {
@@ -752,6 +952,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 +963,130 @@ 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;
+            }
+            // 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;
+            }
+            // ═══════════════════════════════════════════════════════════════════════════
+            // PROGRESSIVE ENHANCEMENT: Use Intent Architect for moderate/complex requests
+            // ═══════════════════════════════════════════════════════════════════════════
+            // 
+            // Uses the canonical runIntentArchitect() entrypoint which:
+            // - Detects complexity with typed scores (not enums)
+            // - Returns qualification questions or LLM prompt
+            // - Supports iterative refinement with previous_answers
+            //
+            // Configure rollout via max_complexity option (default: allow all levels)
+            const maxComplexity = args.max_complexity || undefined;
+            const inputStr = input; // Already validated above
+            const architectResult = runIntentArchitect(inputStr, {
+                persona_type: parseResult.intent.persona_type,
+                available_integrations: schemaRegistry?.getAllActions().slice(0, 20).map(a => a.displayName || a.name),
+            }, { max_complexity: maxComplexity });
+            // For moderate/complex: return Intent Architect result with questions or prompt
+            if (!architectResult.strategy.can_proceed) {
+                let availableActions = [];
+                let availableTemplates = [];
+                // Enhance prompt with action catalog if available
+                let enhancedPrompt = architectResult.prompt_package;
+                if (schemaRegistry && enhancedPrompt) {
+                    const actionCatalog = generateActionCatalogForLLM(schemaRegistry);
+                    enhancedPrompt = {
+                        system: enhancedPrompt.system + "\n\n## Available Actions\n" + actionCatalog,
+                        user: enhancedPrompt.user,
+                    };
+                    availableActions = schemaRegistry.getAllActions().map(a => a.name);
+                    availableTemplates = schemaRegistry.getAllTemplates().map(t => ({ id: t.id, name: t.name, type: t.type }));
+                }
+                return {
+                    status: "needs_intent_architect",
+                    // Typed assessment (new)
+                    assessment: architectResult.assessment,
+                    // Strategy decision (new)
+                    strategy: architectResult.strategy,
+                    // Qualification questions (new)
+                    questions: architectResult.questions,
+                    // LLM prompt (if full architect)
+                    llm_prompt: enhancedPrompt,
+                    // Hint for what to do next
+                    hint: architectResult.strategy.next_step,
+                    // Legacy fields for backward compatibility
+                    reason: architectResult.legacy?.signals.reason,
+                    complexity: architectResult.legacy?.complexity,
+                    approach: architectResult.strategy.approach,
+                    gates_to_ask: architectResult.strategy.gates_to_ask,
+                    // Also provide basic spec as fallback
+                    fallback_spec: intentToSpec(parseResult.intent),
+                    // Include catalogs for reference (if available)
+                    available_actions: availableActions,
+                    available_templates: availableTemplates,
+                };
+            }
+            // SIMPLE complexity: Check if intent requires LLM-driven generation (legacy path)
+            const genResult = generateWorkflow(parseResult.intent);
+            if (genResult.needs_llm) {
+                // Complex workflow detected by legacy system - return prompt for LLM to generate
+                // This is a fallback for cases the new complexity analyzer might miss
+                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 +1095,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 +1120,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 +1190,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 +1280,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 +1597,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 +1606,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": {
@@ -1541,6 +2002,205 @@ export async function handleKnowledge(args, client, readFile) {
                 message: `Data source '${widgetName}' attached to node '${nodeName}'`,
             };
         }
+        case "dashboard_rows": {
+            // Get rows from a dashboard persona
+            const persona = await client.getPersonaById(personaId);
+            if (!persona) {
+                return { error: `Persona not found: ${personaId}` };
+            }
+            const dashboardId = persona.workflow_dashboard_id;
+            if (!dashboardId) {
+                return {
+                    error: "This persona has no dashboard. Use dashboard_rows only for Dashboard-type AI Employees.",
+                    hint: "Check that the persona has trigger_type=DASHBOARD",
+                };
+            }
+            const limit = args.limit ?? 100;
+            const result = await client.getDashboardRows(dashboardId, personaId, { limit });
+            // Return schema and rows in a structured format
+            return {
+                persona_id: personaId,
+                dashboard_id: dashboardId,
+                dashboard_name: result.dashboardName,
+                total_rows: result.totalCount,
+                schema: {
+                    input_columns: result.schema.columns.filter(c => c.isInput),
+                    output_columns: result.schema.columns.filter(c => !c.isInput),
+                },
+                rows: result.rows.map(row => ({
+                    id: row.id,
+                    state: row.state,
+                    created_at: row.dashboardRowMetadata.createdAt,
+                    input_values: row.columnValues
+                        .filter(cv => result.schema.columns.find(c => c.columnId === cv.columnId)?.isInput)
+                        .map(cv => ({
+                        column: result.schema.columns.find(c => c.columnId === cv.columnId)?.name ?? cv.columnId,
+                        value: cv.value.stringValue ?? cv.value.documentCellValue?.documentValues?.[0]?.name ?? cv.value.arrayValue?.arrayValues?.[0]?.stringValue ?? "(complex)",
+                    })),
+                })),
+            };
+        }
+        case "dashboard_clone": {
+            const sourcePersonaId = args.source_persona_id;
+            if (!sourcePersonaId) {
+                return { error: "source_persona_id required for dashboard_clone" };
+            }
+            // Get source and target personas
+            const [sourcePersona, targetPersona] = await Promise.all([
+                client.getPersonaById(sourcePersonaId),
+                client.getPersonaById(personaId),
+            ]);
+            if (!sourcePersona) {
+                return { error: `Source persona not found: ${sourcePersonaId}` };
+            }
+            if (!targetPersona) {
+                return { error: `Target persona not found: ${personaId}` };
+            }
+            const sourceDashboardId = sourcePersona.workflow_dashboard_id;
+            if (!sourceDashboardId) {
+                return { error: "Source persona has no dashboard" };
+            }
+            // Dashboard operations require the persona to be enabled
+            // Auto-enable the target persona for cloning
+            const targetProtoConfig = targetPersona.proto_config;
+            await client.updateAiEmployee({
+                persona_id: personaId,
+                proto_config: targetProtoConfig ?? {},
+                enabled_by_user: true,
+            });
+            // Get source dashboard data
+            const sourceRows = await client.getDashboardRows(sourceDashboardId, sourcePersonaId);
+            if (sourceRows.rows.length === 0) {
+                return {
+                    success: true,
+                    message: "No rows to clone - source dashboard is empty",
+                    source_rows: 0,
+                    cloned_rows: 0,
+                };
+            }
+            // Identify input columns
+            const inputColumns = sourceRows.schema.columns.filter(c => c.isInput);
+            // Clone each row
+            const results = [];
+            const sanitize = args.sanitize;
+            const sanitizeExamples = args.sanitize_examples;
+            // Create sanitization session if needed
+            let sanitizationSession;
+            if (sanitize) {
+                sanitizationSession = new SanitizationSession();
+            }
+            for (const row of sourceRows.rows) {
+                try {
+                    // Build inputs from row's input column values
+                    const inputs = [];
+                    for (const inputCol of inputColumns) {
+                        const colValue = row.columnValues.find(cv => cv.columnId === inputCol.columnId);
+                        if (!colValue)
+                            continue;
+                        // Handle different column types
+                        if (inputCol.columnType === "COLUMN_TYPE_DOCUMENT") {
+                            // Document columns - we need to fetch the actual file content
+                            const docs = colValue.value.documentCellValue?.documentValues ?? [];
+                            if (docs.length > 0) {
+                                // For documents, we'd need to download from source and re-upload
+                                // For now, add as placeholder - requires file content fetching
+                                results.push({
+                                    source_row_id: row.id,
+                                    status: "skipped",
+                                    error: "Document cloning requires file content transfer (not yet implemented)",
+                                });
+                                continue;
+                            }
+                        }
+                        else if (inputCol.columnType === "COLUMN_TYPE_STRING") {
+                            let value = colValue.value.stringValue ?? "";
+                            // Sanitize if enabled
+                            if (sanitizationSession && value) {
+                                // Simple pattern-based sanitization for known types
+                                const detected = detectWithPatterns(value);
+                                for (const entity of detected) {
+                                    const replacement = sanitizationSession.getOrCreateReplacement(entity.value, entity.type);
+                                    value = value.split(entity.value).join(replacement);
+                                }
+                                // Also apply any user-provided examples
+                                if (sanitizeExamples) {
+                                    for (const example of sanitizeExamples) {
+                                        if (value.includes(example)) {
+                                            const replacement = sanitizationSession.getOrCreateReplacement(example, "unknown");
+                                            value = value.split(example).join(replacement);
+                                        }
+                                    }
+                                }
+                            }
+                            inputs.push({
+                                name: inputCol.name,
+                                string_value: value,
+                            });
+                        }
+                        else if (inputCol.columnType === "COLUMN_TYPE_ARRAY") {
+                            // Array values - take first value as string for simplicity
+                            const arrayVals = colValue.value.arrayValue?.arrayValues ?? [];
+                            if (arrayVals.length > 0) {
+                                let value = arrayVals[0].stringValue ?? "";
+                                if (sanitizationSession && value) {
+                                    const detected = detectWithPatterns(value);
+                                    for (const entity of detected) {
+                                        const replacement = sanitizationSession.getOrCreateReplacement(entity.value, entity.type);
+                                        value = value.split(entity.value).join(replacement);
+                                    }
+                                }
+                                inputs.push({
+                                    name: inputCol.name,
+                                    string_value: value,
+                                });
+                            }
+                        }
+                    }
+                    if (inputs.length === 0) {
+                        results.push({
+                            source_row_id: row.id,
+                            status: "skipped",
+                            error: "No clonable input values found",
+                        });
+                        continue;
+                    }
+                    // Upload the row to target dashboard
+                    const uploadResult = await client.uploadAndRunDashboardRow(personaId, inputs);
+                    results.push({
+                        source_row_id: row.id,
+                        target_row_id: uploadResult.row_id,
+                        status: "cloned",
+                    });
+                }
+                catch (err) {
+                    results.push({
+                        source_row_id: row.id,
+                        status: "error",
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            const clonedCount = results.filter(r => r.status === "cloned").length;
+            const skippedCount = results.filter(r => r.status === "skipped").length;
+            const errorCount = results.filter(r => r.status === "error").length;
+            return {
+                success: true,
+                source_persona_id: sourcePersonaId,
+                target_persona_id: personaId,
+                source_rows: sourceRows.rows.length,
+                cloned_rows: clonedCount,
+                skipped_rows: skippedCount,
+                error_rows: errorCount,
+                sanitization_applied: !!sanitize,
+                details: results,
+                notes: [
+                    "Dashboard clone creates NEW rows in the target dashboard",
+                    "Workflows will re-run on the new rows to generate output columns",
+                    "Document columns require manual re-upload (file content transfer not implemented)",
+                    sanitize ? "Sanitization applied to string/array values" : null,
+                ].filter(Boolean),
+            };
+        }
         default:
             return { error: `Unknown mode: ${mode}` };
     }
@@ -2502,6 +3162,94 @@ function sanitizeWorkflowForDeploy(workflow) {
 // ═══════════════════════════════════════════════════════════════════════════
 // Helper Functions
 // ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Sanitize a persona's content (PII, company names, etc.)
+ *
+ * Uses two-pass approach:
+ * 1. Detection pass: Find sensitive entities in all text fields
+ * 2. Alignment pass: Apply ALL mappings for cross-field consistency
+ *
+ * Supports typed examples: strings (type inferred) or objects with explicit type.
+ */
+async function sanitizePersonaById(client, personaId, options = {}) {
+    try {
+        // Fetch full persona
+        const persona = await client.getPersonaById(personaId);
+        if (!persona) {
+            return { success: false, preview: true, replacements_applied: 0, items_needing_review: 0, error: "Persona not found" };
+        }
+        // Build persona object for sanitization - include ALL text-containing fields
+        const personaData = {
+            name: persona.name,
+            description: persona.description,
+            proto_config: persona.proto_config,
+            workflow_def: persona.workflow_def,
+        };
+        // Create sanitization session with default policy
+        const session = new SanitizationSession();
+        // Normalize examples to TypedExample format
+        const typedExamples = options.examples?.map(ex => {
+            if (typeof ex === "string")
+                return ex;
+            return {
+                value: ex.value,
+                type: ex.type,
+                replacement: ex.replacement,
+            };
+        });
+        // Run sanitization with two-pass approach
+        const sanitizationOptions = {
+            examples: typedExamples,
+            auto_replace_threshold: "high", // Only auto-replace high confidence
+        };
+        const result = sanitizePersona(personaData, session, sanitizationOptions);
+        // If preview mode or there are items needing review, return preview
+        const isPreview = options.preview !== false;
+        if (isPreview || result.summary.items_needing_review > 0) {
+            // Build confirmation prompt with all replacements and items needing review
+            const allReplacements = result.results.flatMap(r => r.result.replacements);
+            const allNeedsReview = result.results.flatMap(r => r.result.needs_review);
+            const confirmation = buildConfirmationPrompt(allReplacements, allNeedsReview);
+            return {
+                success: true,
+                preview: true,
+                replacements_applied: 0,
+                items_needing_review: allNeedsReview.length,
+                by_class: result.summary.by_class,
+                by_type: result.summary.by_type,
+                confirmation,
+            };
+        }
+        // Apply sanitization by updating the persona
+        const sanitizedProtoConfig = result.sanitized.proto_config;
+        const sanitizedWorkflow = result.sanitized.workflow_def;
+        const sanitizedDescription = result.sanitized.description;
+        // Update the persona with sanitized data
+        await client.updateAiEmployee({
+            persona_id: personaId,
+            description: sanitizedDescription ?? persona.description,
+            proto_config: (sanitizedProtoConfig ?? persona.proto_config ?? {}),
+            workflow: sanitizedWorkflow ?? persona.workflow_def,
+        });
+        return {
+            success: true,
+            preview: false,
+            by_class: result.summary.by_class,
+            by_type: result.summary.by_type,
+            replacements_applied: result.summary.total_replacements,
+            items_needing_review: result.summary.items_needing_review,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            preview: true,
+            replacements_applied: 0,
+            items_needing_review: 0,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 async function resolvePersona(client, identifier) {
     // Try as UUID first
     const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;