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

package/dist/mcp/handlers-consolidated.js

@@ -4,9 +4,9 @@
  * Each handler dispatches based on mode/flags following Unix CLI patterns.
  */
 // Import shared utilities from handlers module
-import { normalizeTriggerType, getTemplates, resolvePersona, } from "./handlers/index.js";
+import { resolvePersona, } from "./handlers/index.js";
 // Import extracted persona mode handlers
-import { hasExtractedHandler, getPersonaModeHandler, } from "./handlers/persona/index.js";
+import { hasExtractedHandler, getPersonaModeHandler, handleVersion, } from "./handlers/persona/index.js";
 // Import extracted handlers (Phase 1 modularization)
 import { handleEnv as handleEnvExtracted } from "./handlers/env/index.js";
 import { handleTemplate as handleTemplateExtracted } from "./handlers/template/index.js";
@@ -14,156 +14,38 @@ import { handleAction as handleActionExtracted } from "./handlers/action/index.j
 import { handleReference as handleReferenceExtracted } from "./handlers/reference/index.js";
 import { handleKnowledge as handleKnowledgeExtracted } from "./handlers/knowledge/index.js";
 import { handleSync as handleSyncExtracted } from "./handlers/sync/index.js";
-import { createVersionStorage } from "../sdk/version-storage.js";
-import { createVersionPolicyEngine } from "../sdk/version-policy.js";
-import { detectWorkflowIssues, validateWorkflowConnections, suggestWorkflowFixes, } from "../sdk/knowledge.js";
-import { compileWorkflow } from "../sdk/workflow-generator.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 { autoFixWorkflow } from "../sdk/workflow-fixer.js";
-import { SanitizationSession, detectWithPatterns, } from "../sdk/sanitizer.js";
+// Import extracted workflow handler (Phase 2 modularization)
+// Note: Imported as "Extracted" to avoid conflict with local definition during transition
+// The local handleWorkflow will be removed once all tests pass
+import { handleWorkflow as handleWorkflowExtracted } from "./handlers/workflow/index.js";
 // Args type imported from handlers/types.ts
 // ─────────────────────────────────────────────────────────────────────────────
-// Generation Templates for data(mode="generate")
+// Generation Templates - MOVED to handlers/data/templates.ts
+// Import via: import { GENERATION_TEMPLATES } from "./handlers/data/templates.js"
 // ─────────────────────────────────────────────────────────────────────────────
-/**
- * Built-in templates for document generation.
- * Used by data(mode="generate", from="...").
- */
-export const GENERATION_TEMPLATES = {
-    // Reference data
-    "countries": {
-        description: "ISO 3166-1 countries with code and name",
-        category: "reference",
-        prompt: "Generate a JSON array of {count} ISO 3166-1 countries with fields: code (2-letter), name. Format: {format}",
-    },
-    "industries": {
-        description: "NAICS industry classifications",
-        category: "reference",
-        prompt: "Generate a JSON array of {count} NAICS industry classifications with fields: code, name, description. Format: {format}",
-    },
-    "currencies": {
-        description: "ISO 4217 currencies",
-        category: "reference",
-        prompt: "Generate a JSON array of {count} ISO 4217 currencies with fields: code (3-letter), name, symbol. Format: {format}",
-    },
-    // Demo kits
-    "demo-sales-sdr": {
-        description: "Sales SDR demo kit with prospects, products, and Q&A",
-        category: "demo",
-        prompt: `Generate a comprehensive sales demo kit in {format} format containing:
-1. {count} realistic B2B prospect profiles (company name, contact, role, pain points, budget)
-2. 3-5 product entries with features and pricing
-3. 10 common sales objections with responses
-4. Sample discovery call script`,
-    },
-    "demo-support": {
-        description: "Customer support demo kit with customers, FAQs, and tickets",
-        category: "demo",
-        prompt: `Generate a customer support demo kit in {format} format containing:
-1. {count} customer profiles (name, company, subscription tier, history)
-2. 10 frequently asked questions with detailed answers
-3. 5 sample support tickets with resolutions
-4. Escalation guidelines`,
-    },
-    "demo-hr": {
-        description: "HR assistant demo kit with employees, policies, and benefits",
-        category: "demo",
-        prompt: `Generate an HR demo kit in {format} format containing:
-1. {count} employee profiles (name, department, role, start date)
-2. 5 company policies (PTO, remote work, expenses)
-3. 3 benefits descriptions (health, 401k, equity)
-4. Onboarding checklist`,
-    },
-    // Entity templates
-    "customer": {
-        description: "B2B customer profile",
-        category: "entity",
-        prompt: `Generate {count} realistic B2B customer profiles in {format} format with fields:
-- company_name, industry, size (employees), annual_revenue
-- primary_contact (name, title, email, phone)
-- pain_points (array of 2-3 business challenges)
-- current_solutions (what they use today)
-- budget_range, decision_timeline`,
-    },
-    "product": {
-        description: "Product catalog entry with pricing",
-        category: "entity",
-        prompt: `Generate {count} product catalog entries in {format} format with fields:
-- name, sku, category
-- description (2-3 sentences)
-- features (array of 3-5 key features)
-- pricing (base_price, currency, billing_period)
-- availability (in_stock, lead_time)`,
-    },
-    "faq": {
-        description: "FAQ entries",
-        category: "entity",
-        prompt: `Generate {count} FAQ entries in {format} format with fields:
-- question (clear, specific question)
-- answer (comprehensive answer, 2-4 sentences)
-- category (e.g., billing, technical, getting-started)
-- related_questions (array of 2-3 related question titles)`,
-    },
-    "employee": {
-        description: "Employee profile for HR systems",
-        category: "entity",
-        prompt: `Generate {count} employee profiles in {format} format with fields:
-- name, email, employee_id
-- department, title, manager
-- start_date, location (office or remote)
-- skills (array), certifications (array)`,
-    },
-};
 // ─────────────────────────────────────────────────────────────────────────────
 // Widget Validation Helpers
 // ─────────────────────────────────────────────────────────────────────────────
 // isValidWidget and sanitizeWidgets imported from ../sdk/proto-config.js
 // validateWidgetsForApi imported from handlers/utils.ts
-// ─────────────────────────────────────────────────────────────────────────────
-// Deprecation tracking - helps users migrate to new param names
-// ─────────────────────────────────────────────────────────────────────────────
-const DEPRECATED_PARAMS = {
-    identifier: { newName: "id", removeVersion: "2.0.0" },
-    clone_from: { newName: "from", removeVersion: "2.0.0" },
-    template_id: { newName: "from", removeVersion: "2.0.0" },
-    clone_data: { newName: "include_data", removeVersion: "2.0.0" },
-};
-/**
- * Check for deprecated params and collect warnings.
- * Returns array of warning messages for deprecated params that were used.
- */
-function checkDeprecatedParams(args) {
-    const warnings = [];
-    for (const [oldName, { newName, removeVersion }] of Object.entries(DEPRECATED_PARAMS)) {
-        if (args[oldName] !== undefined) {
-            warnings.push(`'${oldName}' is deprecated, use '${newName}' instead (will be removed in v${removeVersion})`);
-        }
-    }
-    return warnings;
-}
-/**
- * Add deprecation warnings to response if any deprecated params were used.
- */
-function addDeprecationWarnings(result, warnings) {
-    if (warnings.length > 0) {
-        return { ...result, _deprecation_warnings: warnings };
-    }
-    return result;
-}
+// Deprecation tracking - single source of truth
+import { checkDeprecatedParams, addDeprecationWarnings } from "./handlers/deprecation.js";
 // Template utilities imported from handlers/utils.ts:
 // - normalizeTriggerType
 // - getTemplates
 // - clearTemplateCache
 // - getPersonaTypeFromTemplate
 // ═══════════════════════════════════════════════════════════════════════════
-// ENV Handler
+// Extracted Handler Exports
 // ═══════════════════════════════════════════════════════════════════════════
-// Delegate to extracted handler
+// These handlers are fully extracted to handlers/*/ directories.
+// Re-exported here for backwards compatibility with server.ts imports.
 export const handleEnv = handleEnvExtracted;
+export const handleAction = handleActionExtracted;
+export const handleTemplate = handleTemplateExtracted;
+export const handleKnowledge = handleKnowledgeExtracted;
+export const handleReference = handleReferenceExtracted;
+export const handleSync = handleSyncExtracted;
 // ═══════════════════════════════════════════════════════════════════════════
 // PERSONA Handler
 // ═══════════════════════════════════════════════════════════════════════════
@@ -243,7 +125,9 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
             const fs = await import("fs/promises");
             return fs.readFile(path);
         };
-        return handleData(dataArgs, client, readFile);
+        // Use extracted handler
+        const { handleData: handleDataExtracted } = await import("./handlers/data/index.js");
+        return handleDataExtracted(dataArgs, client, readFile);
     }
     // ═══════════════════════════════════════════════════════════════════════════
     // ROUTING: Workflow modifications
@@ -253,11 +137,18 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
     const workflowSpec = args.workflow_spec;
     const input = args.input;
     // ───────────────────────────────────────────────────────────────────────────
-    // CRITICAL FIX: Natural language `input` goes to handleWorkflow
-    // handleWorkflow has the FULL node addition/modification/removal logic
-    // handleUpdate can only rewire/remove nodes, NOT add new ones
+    // LLM-DRIVEN ARCHITECTURE: Route workflow modifications to handleWorkflow
+    // 
+    // handleWorkflow accepts STRUCTURED OPERATIONS from the Agent.
+    // It does NOT parse natural language - that's the Agent's job.
+    //
+    // Route to handleWorkflow when:
+    // - mode === "modify" (explicit modify mode)
+    // - mode === "update" with `operations` (Agent built structured ops)
+    // - mode === "update" with `input` (legacy - returns context for Agent)
     // ───────────────────────────────────────────────────────────────────────────
-    if (mode === "update" && idOrName && input) {
+    const operations = args.operations;
+    if ((mode === "modify" || (mode === "update" && (input || operations))) && idOrName) {
         const workflowArgs = {
             ...args,
             persona_id: idOrName,
@@ -265,14 +156,13 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
         };
         delete workflowArgs.id;
         delete workflowArgs.identifier;
-        return handleWorkflow(workflowArgs, client, getTemplateId);
+        return handleWorkflowExtracted(workflowArgs, client, getTemplateId);
     }
-    // mode="update" without input → modular handleUpdate (config/workflow_spec changes only)
+    // mode="update" without input/operations → modular handleUpdate (config/workflow_spec changes only)
     if (mode === "update" && idOrName) {
         return getPersonaModeHandler("update")(args, client);
     }
-    // Workflow operations (optimize, etc.) → handleWorkflow (legacy)
-    // TODO: Deprecate handleWorkflow and move remaining logic to modular handlers
+    // Workflow operations (optimize, etc.) → handleWorkflowExtracted (extracted handler)
     if (optimize || (idOrName && workflowDef && mode !== "update")) {
         // Map persona args to workflow args
         const workflowArgs = {
@@ -281,7 +171,7 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
         };
         delete workflowArgs.id;
         delete workflowArgs.identifier;
-        return handleWorkflow(workflowArgs, client, getTemplateId);
+        return handleWorkflowExtracted(workflowArgs, client, getTemplateId);
     }
     // ═══════════════════════════════════════════════════════════════════════════
     // Standard persona operations (get, list, compare, version management)
@@ -310,8 +200,8 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
             return {
                 error: "Explicit method required",
                 message: "You provided a persona id/name. What operation would you like to perform?",
-                valid_methods: ["get", "update", "delete", "analyze", "sanitize", "snapshot", "history", "restore", "compare"],
-                hint: "Specify method='get' to fetch, method='update' to modify",
+                valid_methods: ["get", "update", "delete", "sanitize", "snapshot", "history", "restore"],
+                hint: "LLM does analysis/comparison. Use method='get' to fetch data, then reason about it.",
                 example: `persona(method="get", id="${idOrName}")`,
             };
         }
@@ -397,230 +287,35 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
                 return { error: `Failed to get schema: ${error instanceof Error ? error.message : String(error)}` };
             }
         }
-        // Compare, clone, create, analyze - all handled by extracted handlers
-        case "compare":
+        // Clone and create - handled by extracted handlers
         case "clone":
-        case "create":
-        case "analyze": {
+        case "create": {
             // These modes have been extracted to handlers/persona/*.ts
             // - create.ts: handleCreate (~410 lines)
-            // - analyze.ts: handleAnalyze (~195 lines)
             return { error: `Mode "${effectiveMode}" should be handled by extracted handler` };
         }
-        // ─────────────── Version Management Modes ───────────────
-        // Schema exposes: snapshot, history, restore
-        // Handlers use: version_create, version_list, version_restore
-        case "snapshot": // Alias for version_create
-        case "version_create": {
-            if (!idOrName) {
-                return { error: "id required for version_create mode" };
-            }
-            if (!versionContext) {
-                return { error: "Version tracking not configured. Provide workspaceRoot in context." };
-            }
-            const persona = await resolvePersona(client, idOrName);
-            if (!persona) {
-                return { error: `Persona not found: ${idOrName}` };
-            }
-            // Fetch full persona with workflow
-            const fullPersona = await client.getPersonaById(persona.id);
-            if (!fullPersona) {
-                return { error: `Could not fetch full persona: ${persona.id}` };
-            }
-            const storage = createVersionStorage(versionContext.workspaceRoot);
-            const engine = createVersionPolicyEngine(storage);
-            const result = engine.forceCreateVersion(fullPersona, {
-                environment: versionContext.environment,
-                tenant_id: versionContext.tenant_id,
-                message: args.message,
-                created_by: "mcp-toolkit",
-            });
-            if (!result.created || !result.version) {
-                return { error: result.reason };
-            }
-            return {
-                success: true,
-                version: {
-                    id: result.version.id,
-                    version_number: result.version.version_number,
-                    version_name: result.version.version_name,
-                    content_hash: result.version.content_hash,
-                    created_at: result.version.created_at,
-                    message: result.version.message,
-                },
-                changes_from_parent: result.changes_from_parent,
-                versions_pruned: result.versions_pruned,
-            };
-        }
-        case "history": // Alias for version_list
-        case "version_list": {
-            if (!idOrName) {
-                return { error: "id required for history mode" };
-            }
-            if (!versionContext) {
-                return { error: "Version tracking not configured. Provide workspaceRoot in context." };
-            }
-            const persona = await resolvePersona(client, idOrName);
-            if (!persona) {
-                return { error: `Persona not found: ${idOrName}` };
-            }
-            const storage = createVersionStorage(versionContext.workspaceRoot);
-            const engine = createVersionPolicyEngine(storage);
-            const versions = engine.listVersions(persona.id, {
-                limit: args.limit,
-            });
-            return {
-                persona_id: persona.id,
-                persona_name: persona.name,
-                versions,
-                count: versions.length,
-            };
-        }
-        case "version_get": {
-            if (!idOrName) {
-                return { error: "id required for version_get mode" };
-            }
-            if (!versionContext) {
-                return { error: "Version tracking not configured. Provide workspaceRoot in context." };
-            }
-            const persona = await resolvePersona(client, idOrName);
-            if (!persona) {
-                return { error: `Persona not found: ${idOrName}` };
-            }
-            const versionId = args.version ?? "latest";
-            const storage = createVersionStorage(versionContext.workspaceRoot);
-            const engine = createVersionPolicyEngine(storage);
-            const version = engine.getVersion(persona.id, versionId);
-            if (!version) {
-                return { error: `Version not found: ${versionId}` };
-            }
-            return {
-                persona_id: persona.id,
-                persona_name: persona.name,
-                version: {
-                    id: version.id,
-                    version_number: version.version_number,
-                    version_name: version.version_name,
-                    content_hash: version.content_hash,
-                    created_at: version.created_at,
-                    created_by: version.created_by,
-                    trigger: version.trigger,
-                    message: version.message,
-                    changes_summary: version.changes_summary,
-                },
-                snapshot: {
-                    display_name: version.snapshot.display_name,
-                    description: version.snapshot.description,
-                    workflow_id: version.snapshot.workflow_id,
-                    trigger_type: version.snapshot.trigger_type,
-                    embedding_enabled: version.snapshot.embedding_enabled,
-                    has_workflow: !!version.snapshot.workflow_definition,
-                    has_proto_config: !!version.snapshot.proto_config,
-                },
-            };
-        }
-        case "version_compare": {
-            if (!idOrName) {
-                return { error: "id required for version_compare mode" };
-            }
-            if (!versionContext) {
-                return { error: "Version tracking not configured. Provide workspaceRoot in context." };
-            }
-            const v1 = args.v1;
-            const v2 = args.v2;
-            if (!v1 || !v2) {
-                return { error: "v1 and v2 required for version_compare mode" };
-            }
-            const persona = await resolvePersona(client, idOrName);
-            if (!persona) {
-                return { error: `Persona not found: ${idOrName}` };
-            }
-            const storage = createVersionStorage(versionContext.workspaceRoot);
-            const engine = createVersionPolicyEngine(storage);
-            const result = engine.compareVersions(persona.id, v1, v2);
-            if (!result.success) {
-                return { error: result.error };
-            }
-            return {
-                persona_id: persona.id,
-                persona_name: persona.name,
-                comparison: {
-                    v1: result.diff?.v1,
-                    v2: result.diff?.v2,
-                    identical: result.diff?.identical,
-                    changed_fields: result.diff?.changed_fields,
-                    workflow_diff: result.diff?.workflow_diff,
-                },
-                summary: result.summary,
-            };
-        }
-        case "restore": // Alias for version_restore
-        case "version_restore": {
-            if (!idOrName) {
-                return { error: "id required for restore mode" };
-            }
-            if (!versionContext) {
-                return { error: "Version tracking not configured. Provide workspaceRoot in context." };
-            }
-            const versionId = args.version;
-            if (!versionId) {
-                return { error: "version required for version_restore mode" };
-            }
-            const persona = await resolvePersona(client, idOrName);
-            if (!persona) {
-                return { error: `Persona not found: ${idOrName}` };
-            }
-            const storage = createVersionStorage(versionContext.workspaceRoot);
-            const engine = createVersionPolicyEngine(storage);
-            const restoreData = engine.getRestoreData(persona.id, versionId);
-            if (!restoreData.success || !restoreData.restore_payload) {
-                return { error: restoreData.error ?? "Failed to get restore data" };
-            }
-            // Create a version snapshot before restoring (audit trail)
-            const fullPersona = await client.getPersonaById(persona.id);
-            if (fullPersona) {
-                engine.forceCreateVersion(fullPersona, {
-                    environment: versionContext.environment,
-                    tenant_id: versionContext.tenant_id,
-                    message: `Before restore to ${restoreData.version?.version_name}`,
-                    created_by: "mcp-toolkit",
-                });
-            }
-            // Apply the restore
-            const payload = restoreData.restore_payload;
-            await client.updateAiEmployee({
-                persona_id: payload.persona_id,
-                name: payload.name,
-                description: payload.description,
-                proto_config: payload.proto_config,
-                workflow: payload.workflow ?? undefined,
-                welcome_messages: payload.welcome_messages ?? undefined,
-                embedding_enabled: payload.embedding_enabled ?? undefined,
-            });
-            // Create post-restore version
-            const restoredPersona = await client.getPersonaById(persona.id);
-            if (restoredPersona) {
-                engine.forceCreateVersion(restoredPersona, {
-                    environment: versionContext.environment,
-                    tenant_id: versionContext.tenant_id,
-                    message: `Restored to ${restoreData.version?.version_name}`,
-                    created_by: "mcp-toolkit",
-                });
-            }
+        // Analyze and compare - LLM does this, not MCP
+        case "analyze":
+        case "compare": {
             return {
-                success: true,
-                persona_id: persona.id,
-                restored_to: {
-                    version_id: restoreData.version?.id,
-                    version_name: restoreData.version?.version_name,
-                    version_number: restoreData.version?.version_number,
-                },
-                message: `Persona restored to ${restoreData.version?.version_name}`,
+                error: `Method "${effectiveMode}" removed - LLM does analysis/comparison`,
+                hint: "Use method='get' to fetch persona data, then do your own analysis/comparison.",
+                example: `persona(method="get", id="...", include_workflow=true)`,
             };
         }
+        // ─────────────── Version Management Modes ───────────────
+        // Extracted to handlers/persona/version.ts
+        case "snapshot":
+        case "history":
+        case "restore":
+        case "version_create":
+        case "version_list":
+        case "version_get":
+        case "version_compare":
+        case "version_restore":
         case "version_policy": {
             if (!idOrName) {
-                return { error: "id required for version_policy mode" };
+                return { error: `id required for ${effectiveMode} mode` };
             }
             if (!versionContext) {
                 return { error: "Version tracking not configured. Provide workspaceRoot in context." };
@@ -629,2345 +324,27 @@ export async function handlePersona(args, client, getTemplateId, createClientFor
             if (!persona) {
                 return { error: `Persona not found: ${idOrName}` };
             }
-            const storage = createVersionStorage(versionContext.workspaceRoot);
-            const engine = createVersionPolicyEngine(storage);
-            // Check if we're updating or just getting
-            const hasUpdates = args.auto_on_deploy !== undefined ||
-                args.auto_on_sync !== undefined ||
-                args.max_versions !== undefined;
-            if (hasUpdates) {
-                const updated = engine.updatePolicy(persona.id, {
-                    auto_version_on_deploy: args.auto_on_deploy,
-                    auto_version_on_sync: args.auto_on_sync,
-                    max_versions: args.max_versions,
-                });
-                return {
-                    success: true,
-                    persona_id: persona.id,
-                    persona_name: persona.name,
-                    policy: updated,
-                    message: "Policy updated",
-                };
-            }
-            // Just get current policy
-            const policy = engine.getPolicy(persona.id);
-            return {
-                persona_id: persona.id,
-                persona_name: persona.name,
-                policy,
-            };
-        }
-        default:
-            return { error: `Unknown mode: ${effectiveMode}` };
-    }
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// WORKFLOW Handler - Unified greenfield/brownfield operations
-// ═══════════════════════════════════════════════════════════════════════════
-export async function handleWorkflow(args, client, getTemplateId) {
-    const personaId = args.persona_id;
-    const workflowDef = args.workflow_def;
-    const input = args.input;
-    const optimize = args.optimize;
-    const compareTo = args.compare_to;
-    // Default to preview=true for safety (no accidental deploys)
-    const preview = args.preview !== false;
-    // Smart mode detection - user doesn't need to specify
-    // Priority: extraction_schema > compare > optimize > brownfield > greenfield > analyze
-    let effectiveMode;
-    if (args.mode === "compile") {
-        // Explicit compile mode (for advanced users)
-        effectiveMode = "compile";
-    }
-    else if (compareTo) {
-        // Compare two workflows
-        effectiveMode = "compare";
-    }
-    else if (optimize && personaId) {
-        // Auto-fix issues
-        effectiveMode = "optimize";
-    }
-    else if (personaId && workflowDef) {
-        // DEPLOY: Persona exists + workflow_def provided → deploy directly (no input needed)
-        effectiveMode = "deploy";
-    }
-    else if (personaId && input) {
-        // MODIFY: Persona exists + input provided → generate new workflow from input
-        effectiveMode = "modify"; // New unified mode for all brownfield changes
-    }
-    else if (input && !personaId) {
-        // GREENFIELD: Create new workflow
-        effectiveMode = "generate";
-    }
-    else if (personaId || workflowDef || args.include) {
-        // Just analyzing
-        effectiveMode = "analyze";
-    }
-    else {
-        effectiveMode = "analyze";
-    }
-    // Legacy mode support (backwards compatibility)
-    const legacyMode = args.mode;
-    if (legacyMode === "extend")
-        effectiveMode = "modify";
-    if (legacyMode === "deploy") {
-        // If explicit deploy mode, use it (works with or without input)
-        effectiveMode = "deploy";
-    }
-    switch (effectiveMode) {
-        case "generate": {
-            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 {
-                    status: "incomplete",
-                    input_type: parseResult.input_type,
-                    missing: parseResult.validation.missing,
-                    questions: parseResult.validation.questions,
-                };
-            }
-            // 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;
-            }
-            // ═══════════════════════════════════════════════════════════════════════════
-            // PERSONA WIDGET CONTEXT: If persona_id provided, fetch available widgets
-            // Workflows reference widgets by name - agent needs to know what's available
-            // ═══════════════════════════════════════════════════════════════════════════
-            let personaWidgets = [];
-            if (personaId) {
-                try {
-                    const persona = await client.getPersonaById(personaId);
-                    const protoConfig = persona?.proto_config;
-                    if (protoConfig?.widgets) {
-                        personaWidgets = protoConfig.widgets
-                            .filter(w => typeof w.name === "string" && w.name.trim().length > 0)
-                            .map(w => ({
-                            name: w.name,
-                            type: String(w.type ?? "unknown"),
-                            title: w.title,
-                        }));
-                    }
-                }
-                catch {
-                    // Persona not found or no widgets - continue without context
-                }
-            }
-            // ═══════════════════════════════════════════════════════════════════════════
-            // 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 and widget context
-                let enhancedPrompt = architectResult.prompt_package;
-                if (enhancedPrompt) {
-                    let systemAdditions = "";
-                    // Add action catalog if available
-                    if (schemaRegistry) {
-                        const actionCatalog = generateActionCatalogForLLM(schemaRegistry);
-                        systemAdditions += "\n\n## Available Actions\n" + actionCatalog;
-                        availableActions = schemaRegistry.getAllActions().map(a => a.name);
-                        availableTemplates = schemaRegistry.getAllTemplates().map(t => ({ id: t.id, name: t.name, type: t.type }));
-                    }
-                    // Add persona widget context if available
-                    if (personaWidgets.length > 0) {
-                        systemAdditions += "\n\n## Available Persona Widgets\n";
-                        systemAdditions += "Use these exact widget names in workflow bindings (widgetName field):\n";
-                        for (const w of personaWidgets) {
-                            systemAdditions += `- \`${w.name}\` (${w.type})${w.title ? ` - "${w.title}"` : ""}\n`;
-                        }
-                    }
-                    if (systemAdditions) {
-                        enhancedPrompt = {
-                            system: enhancedPrompt.system + systemAdditions,
-                            user: enhancedPrompt.user,
-                        };
-                    }
-                }
-                return {
-                    status: "needs_intent_architect",
-                    // Persona widget context (for workflow bindings)
-                    available_widgets: personaWidgets.length > 0 ? personaWidgets : undefined,
-                    // 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 (enhancedPrompt) {
-                    let systemAdditions = "";
-                    if (schemaRegistry) {
-                        const actionCatalog = generateActionCatalogForLLM(schemaRegistry);
-                        systemAdditions += "\n\n" + actionCatalog;
-                        availableActions = schemaRegistry.getAllActions().map(a => a.name);
-                        availableTemplates = schemaRegistry.getAllTemplates().map(t => ({ id: t.id, name: t.name, type: t.type }));
-                    }
-                    // Add persona widget context if available
-                    if (personaWidgets.length > 0) {
-                        systemAdditions += "\n\n## Available Persona Widgets\n";
-                        systemAdditions += "Use these exact widget names in workflow bindings (widgetName field):\n";
-                        for (const w of personaWidgets) {
-                            systemAdditions += `- \`${w.name}\` (${w.type})${w.title ? ` - "${w.title}"` : ""}\n`;
-                        }
-                    }
-                    if (systemAdditions) {
-                        enhancedPrompt = {
-                            system: enhancedPrompt.system + systemAdditions,
-                            user: enhancedPrompt.user,
-                        };
-                    }
-                }
-                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,
-                    // Persona widget context (for workflow bindings)
-                    available_widgets: personaWidgets.length > 0 ? personaWidgets : undefined,
-                };
-            }
-            // 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",
-                status: preview ? "preview" : "deployed",
-                workflow_def: compiled.workflow_def,
-                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;
-            }
-            // If preview=false and persona_id provided, deploy
-            if (!preview && personaId) {
-                const persona = await client.getPersonaById(personaId);
-                if (!persona) {
-                    return { error: `Persona not found: ${personaId}` };
-                }
-                await client.updateAiEmployee({
-                    persona_id: personaId,
-                    workflow: compiled.workflow_def,
-                    proto_config: args.proto_config || compiled.proto_config || persona.proto_config,
-                });
-                result.deployed_to = { persona_id: personaId, persona_name: persona.name };
-            }
-            else if (!preview && !personaId) {
-                // GREENFIELD: Create new persona from template, then deploy workflow + proto_config
-                const personaName = args.name;
-                if (personaName) {
-                    const personaType = args.type || "chat";
-                    // Dynamic template lookup - templates are tenant-specific
-                    // Match by normalized trigger_type label
-                    const templates = await getTemplates(client);
-                    const matchingTemplate = templates.find(t => normalizeTriggerType(t.trigger_type) === personaType.toLowerCase());
-                    // Try getTemplateId callback, then registry, then dynamic lookup
-                    const templateFromRegistry = actionRegistry.getTemplateForType(personaType);
-                    const templateId = getTemplateId?.(personaType) || templateFromRegistry?.id || matchingTemplate?.id;
-                    if (!templateId) {
-                        const availableTypes = [...new Set(templates.map(t => normalizeTriggerType(t.trigger_type)).filter(Boolean))];
-                        return {
-                            error: `No template found for type "${personaType}".`,
-                            available_types: availableTypes,
-                            hint: "Provide template_id directly or use one of the available types.",
-                        };
-                    }
-                    // Step 1: Create the persona from template
-                    const createResult = await client.createAiEmployee({
-                        name: personaName,
-                        description: args.description,
-                        template_id: templateId,
-                    });
-                    const newPersonaId = createResult.persona_id ?? createResult.id;
-                    if (!newPersonaId) {
-                        return { error: "Failed to create persona: no ID returned" };
-                    }
-                    // Step 2: Fetch the newly created persona to get template's valid structure
-                    const newPersona = await client.getPersonaById(newPersonaId);
-                    if (!newPersona) {
-                        return { error: `Failed to fetch newly created persona: ${newPersonaId}` };
-                    }
-                    // Step 3: Merge proto_config - keep template structure, update widget values
-                    const existingProtoConfig = (newPersona.proto_config ?? {});
-                    const generatedProtoConfig = args.proto_config || compiled.proto_config || {};
-                    // Merge widgets by name - template widgets provide structure, generated values override
-                    const existingWidgets = (existingProtoConfig.widgets ?? []);
-                    const generatedWidgets = (generatedProtoConfig.widgets ?? []);
-                    const widgetMap = new Map();
-                    // Start with template widgets (valid structure)
-                    for (const w of existingWidgets) {
-                        if (typeof w.name === "string" && w.name.trim().length > 0) {
-                            widgetMap.set(w.name, w);
-                        }
-                    }
-                    // Merge generated widget VALUES into template structure
-                    for (const genWidget of generatedWidgets) {
-                        const widgetName = genWidget.name;
-                        if (typeof widgetName === "string" && widgetName.trim().length > 0) {
-                            const existing = widgetMap.get(widgetName);
-                            if (existing) {
-                                // Merge: keep template structure, update config values
-                                const merged = { ...existing };
-                                // The widget config is stored under the widget name (e.g., conversationSettings)
-                                if (genWidget[widgetName]) {
-                                    merged[widgetName] = { ...(existing[widgetName] || {}), ...genWidget[widgetName] };
-                                }
-                                widgetMap.set(widgetName, merged);
-                            }
-                            else {
-                                // New widget not in template - add as-is
-                                widgetMap.set(widgetName, genWidget);
-                            }
-                        }
-                    }
-                    const mergedProtoConfig = {
-                        ...existingProtoConfig,
-                        widgets: Array.from(widgetMap.values()),
-                    };
-                    // 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,
-                        created: true
-                    };
-                    result.status = "deployed";
-                    result.next_steps = [
-                        `Persona "${personaName}" created with template workflow.`,
-                        `To customize the workflow, use: workflow(persona_id="${newPersonaId}", input="add search node", preview=false)`,
-                    ];
-                }
-                else {
-                    result.hint = "Provide name to create new persona, or persona_id to deploy to existing persona";
-                }
-            }
-            if (preview) {
-                result.next_steps = [
-                    "Review the generated workflow_def",
-                    personaId
-                        ? `Deploy with: workflow(mode="generate", input=..., persona_id="${personaId}", preview=false)`
-                        : "Create persona first: persona(mode='create', name='...', type='...')",
-                ];
-            }
-            return result;
-        }
-        case "modify":
-        case "extend": {
-            // BROWNFIELD: Intelligently modify existing workflow
-            // Handles: add, remove, replace, consolidate, rewire - all in one
-            if (!personaId) {
-                return { error: "persona_id required for workflow modifications" };
-            }
-            if (!input) {
-                return { error: "input required. Describe what you want to change." };
-            }
-            const persona = await client.getPersonaById(personaId);
-            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 {
-                    error: `Persona "${persona.name}" has no workflow to modify`,
-                    hint: "Provide just input= to create a new workflow (greenfield)",
-                };
-            }
-            // Intelligently analyze what the user wants to do
-            const changeAnalysis = analyzeModificationRequest(input, existingWorkflow);
-            // Apply the changes to the workflow
-            const modifyResult = applyWorkflowModifications(existingWorkflow, changeAnalysis);
-            // Validate the result
-            const issues = detectWorkflowIssues(modifyResult.workflow);
-            const fixes = issues.length > 0 ? suggestWorkflowFixes(issues) : [];
-            const result = {
-                mode: "modify",
-                status: preview ? "preview" : "deploying",
-                persona_id: personaId,
-                persona_name: persona.name,
-                // What we understood from the request
-                analysis: {
-                    understood_intent: changeAnalysis.intent,
-                    operations: changeAnalysis.operations.map(op => ({
-                        type: op.type,
-                        description: op.description,
-                    })),
-                },
-                // What we did
-                changes_applied: modifyResult.changesApplied,
-                nodes_added: modifyResult.nodesAdded,
-                nodes_removed: modifyResult.nodesRemoved,
-                nodes_modified: modifyResult.nodesModified,
-                connections_changed: modifyResult.connectionsChanged,
-                // The result
-                modified_workflow: modifyResult.workflow,
-            };
-            // Add contextual tip when no changes were made (likely a content change request)
-            if (changeAnalysis.operations.length === 0 || modifyResult.changesApplied.length === 0) {
-                result._tip = "No structural changes detected. If you're trying to change DATA inside nodes " +
-                    "(fixed_response content, call_llm prompts), use this approach instead: " +
-                    "1) persona(id='...', include_workflow=true) to get workflow_def, " +
-                    "2) Edit the node's inputs.data.stringValue in the JSON, " +
-                    "3) workflow(mode='deploy', persona_id='...', workflow_def={edited})";
-                result._content_change_hint = {
-                    step1: `persona(id="${personaId}", include_workflow=true)`,
-                    step2: "Edit workflow_def.actions[N].inputs.data.stringValue",
-                    step3: `workflow(mode="deploy", persona_id="${personaId}", workflow_def={...})`,
-                };
-            }
-            if (issues.length > 0) {
-                result.remaining_issues = issues.length;
-                result.issues = issues.slice(0, 5); // Show first 5
-                result.suggested_fixes = fixes.slice(0, 5);
-            }
-            // Deploy if preview=false
-            if (!preview) {
-                const sanitizedWorkflow = sanitizeWorkflowForDeploy(modifyResult.workflow);
-                try {
-                    await client.updateAiEmployee({
-                        persona_id: personaId,
-                        workflow: sanitizedWorkflow,
-                        proto_config: args.proto_config || persona.proto_config,
-                    });
-                    result.status = "deployed";
-                    result.deployed = true;
-                    result.modified_workflow = sanitizedWorkflow;
-                }
-                catch (err) {
-                    const errorMessage = err instanceof Error ? err.message : String(err);
-                    result.deployed = false;
-                    result.deploy_error = errorMessage;
-                    result.status = "preview_only";
-                    result.hint = `Deployment failed: ${errorMessage}. The modified_workflow is ready - you may need to deploy via UI for complex structural changes.`;
-                }
-            }
-            else {
-                result.next_steps = [
-                    "Review the changes_applied and modified_workflow",
-                    issues.length > 0 ? `Address ${issues.length} remaining issues` : null,
-                    `Deploy with: workflow(persona_id="${personaId}", input="...", preview=false)`,
-                ].filter(Boolean);
-            }
-            return result;
-        }
-        case "analyze": {
-            let workflow = workflowDef;
-            let persona = null;
-            if (personaId && !workflow) {
-                persona = await client.getPersonaById(personaId);
-                if (!persona) {
-                    return { error: `Persona not found: ${personaId}` };
-                }
-                workflow = persona.workflow_def;
-            }
-            if (!workflow) {
-                return { error: "No workflow to analyze. Provide workflow_def or persona_id." };
-            }
-            // Determine what to include (now supports execution_flow!)
-            const include = args.include || ["issues", "connections", "fixes", "metrics"];
-            const result = {
-                mode: "analyze",
-                persona_id: personaId,
-                persona_name: persona?.name,
-                environment: "demo",
-            };
-            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;
-            }
-            if (include.includes("connections")) {
-                result.connections = validateWorkflowConnections(workflow);
-            }
-            if (include.includes("metrics")) {
-                result.metrics = calculateMetrics(workflow);
-            }
-            // NEW: Execution flow analysis - detects loops, multiple responders, redundant classifiers
-            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 };
-            }
-            // Always provide 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;
-            }
-            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;
-        }
-        case "deploy": {
-            // DEPLOY: Direct workflow deployment to existing persona (no input required)
-            if (!personaId) {
-                return { error: "persona_id required for deploy mode" };
-            }
-            if (!workflowDef) {
-                return { error: "workflow_def required for deploy mode" };
-            }
-            const persona = await client.getPersonaById(personaId);
-            if (!persona) {
-                return { error: `Persona not found: ${personaId}` };
-            }
-            // Sanitize workflow before deployment
-            const sanitizedWorkflow = sanitizeWorkflowForDeploy(workflowDef);
-            // Determine proto_config to use: provided > existing
-            const existingProtoConfig = persona.proto_config;
-            const providedProtoConfig = args.proto_config;
-            const protoConfigToUse = providedProtoConfig || existingProtoConfig || {};
-            // Check if this is a voice persona and warn if critical settings are missing
-            const projectSettings = protoConfigToUse.projectSettings;
-            const isVoice = projectSettings?.projectType === 5;
-            const warnings = [];
-            if (isVoice && !providedProtoConfig) {
-                // Check if existing proto_config has conversationSettings populated
-                const widgets = (protoConfigToUse.widgets ?? []);
-                const convSettings = widgets.find(w => w.name === "conversationSettings");
-                const convConfig = convSettings?.conversationSettings;
-                if (!convConfig?.welcomeMessage || !convConfig?.identityAndPurpose) {
-                    warnings.push("Voice persona detected but proto_config not provided. Voice settings (welcomeMessage, identityAndPurpose, etc.) may be empty or generic. " +
-                        "If you generated the workflow with workflow(input=...), pass the generated proto_config along with workflow_def to preserve voice settings.");
-                }
-            }
-            // Deploy workflow (always deploy, preview is not applicable for explicit deploy mode)
-            try {
-                await client.updateAiEmployee({
-                    persona_id: personaId,
-                    workflow: sanitizedWorkflow,
-                    proto_config: protoConfigToUse,
-                });
-                const result = {
-                    mode: "deploy",
-                    status: "deployed",
-                    persona_id: personaId,
-                    persona_name: persona.name,
-                    workflow_deployed: true,
-                };
-                if (warnings.length > 0) {
-                    result.warnings = warnings;
-                }
-                return result;
-            }
-            catch (err) {
-                const errorMessage = err instanceof Error ? err.message : String(err);
-                return {
-                    mode: "deploy",
-                    status: "failed",
-                    persona_id: personaId,
-                    persona_name: persona.name,
-                    error: errorMessage,
-                };
-            }
-        }
-        case "compare": {
-            if (!personaId || !args.compare_to) {
-                return { error: "persona_id and compare_to required for compare mode" };
-            }
-            const persona1 = await client.getPersonaById(personaId);
-            const persona2 = await client.getPersonaById(args.compare_to);
-            if (!persona1 || !persona2) {
-                return { error: "One or both personas not found" };
-            }
-            const workflow1 = persona1.workflow_def;
-            const workflow2 = persona2.workflow_def;
-            return {
-                persona_1: { id: persona1.id, name: persona1.name },
-                persona_2: { id: persona2.id, name: persona2.name },
-                differences: compareWorkflows(workflow1, workflow2),
-            };
-        }
-        case "compile": {
-            const nodes = args.nodes;
-            const resultMappings = args.result_mappings;
-            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",
-                persona_type: args.type || "chat",
-                nodes: nodes,
-                result_mappings: resultMappings || [],
-            };
-            const compiled = compileWorkflow(spec, { registry: compileRegistry });
-            return {
-                workflow_def: compiled.workflow_def,
-                proto_config: compiled.proto_config,
-                registry_loaded: compileRegistry.isLoaded(),
-            };
-        }
-        case "optimize": {
-            // FIX issues in existing workflow (not extend - that's mode="extend")
-            if (!personaId) {
-                return { error: "persona_id required for optimize mode" };
-            }
-            const persona = await client.getPersonaById(personaId);
-            if (!persona) {
-                return { error: `Persona not found: ${personaId}` };
-            }
-            const existingWorkflow = persona.workflow_def;
-            if (!existingWorkflow) {
-                return {
-                    error: `Persona "${persona.name}" has no workflow to optimize`,
-                    hint: "Use mode='generate' to create a workflow first",
-                };
-            }
-            // Analyze and detect issues
-            const issues = detectWorkflowIssues(existingWorkflow);
-            const fixes = suggestWorkflowFixes(issues);
-            if (issues.length === 0) {
-                return {
-                    mode: "optimize",
-                    status: "✅ No issues found",
-                    persona_id: personaId,
-                    persona_name: persona.name,
-                    workflow_healthy: true,
-                };
-            }
-            // Apply fixes
-            const fixedWorkflow = applySimpleFixes(existingWorkflow, issues);
-            const result = {
-                mode: "optimize",
-                status: preview ? "preview" : "deployed",
-                persona_id: personaId,
-                persona_name: persona.name,
-                issues_found: issues.length,
-                issues: issues.map(i => ({
-                    type: i.type,
-                    severity: i.severity,
-                    reason: i.reason,
-                })),
-                suggested_fixes: fixes,
-                fixed_workflow: fixedWorkflow,
-            };
-            // If preview=false, deploy the fixed workflow
-            if (!preview) {
-                await client.updateAiEmployee({
-                    persona_id: personaId,
-                    workflow: fixedWorkflow,
-                    proto_config: args.proto_config || persona.proto_config,
-                });
-                result.deployed = true;
-            }
-            else {
-                result.next_steps = [
-                    "Review the suggested fixes and fixed_workflow",
-                    `Deploy with: workflow(mode="optimize", persona_id="${personaId}", preview=false)`,
-                ];
-            }
-            return result;
+            return handleVersion(effectiveMode, args, client, persona, versionContext);
         }
         default:
             return { error: `Unknown mode: ${effectiveMode}` };
     }
 }
 // ═══════════════════════════════════════════════════════════════════════════
-// ACTION Handler
-// ═══════════════════════════════════════════════════════════════════════════
-// Delegate to extracted handler
-export const handleAction = handleActionExtracted;
-// ═══════════════════════════════════════════════════════════════════════════
-// TEMPLATE Handler
-// ═══════════════════════════════════════════════════════════════════════════
-// Delegate to extracted handler
-export const handleTemplate = handleTemplateExtracted;
-// ═══════════════════════════════════════════════════════════════════════════
-// KNOWLEDGE Handler
-// ═══════════════════════════════════════════════════════════════════════════
-// Delegate to extracted handler
-export const handleKnowledge = handleKnowledgeExtracted;
-// ═══════════════════════════════════════════════════════════════════════════
-// REFERENCE Handler (v2 unified: envs, actions, templates, patterns, concepts, guidance)
-// ═══════════════════════════════════════════════════════════════════════════
-// Delegate to extracted handler
-export const handleReference = handleReferenceExtracted;
+// WORKFLOW Handler - REMOVED
 // ═══════════════════════════════════════════════════════════════════════════
-// DATA Handler (v2 alias for knowledge)
+// The handleWorkflow function has been fully extracted to handlers/workflow/
+// Import via: import { handleWorkflow } from "./handlers/workflow/index.js"
+//
+// Modular structure:
+// - handlers/workflow/analyze.ts
+// - handlers/workflow/compare.ts
+// - handlers/workflow/compile.ts
+// - handlers/workflow/deploy.ts
+// - handlers/workflow/generate.ts
+// - handlers/workflow/modify.ts
+// - handlers/workflow/optimize.ts
+// - handlers/workflow/index.ts (router)
 // ═══════════════════════════════════════════════════════════════════════════
-export async function handleData(args, client, readFile) {
-    const mode = args.mode;
-    const personaId = args.persona_id;
-    // ─────────────────────────────────────────────────────────────────────────
-    // Clarification when mode is omitted
-    // ─────────────────────────────────────────────────────────────────────────
-    if (!mode) {
-        // Try to infer from params if unambiguous
-        if (args.file && !args.file_id) {
-            // Has file path but no file_id → likely wants upload
-            return {
-                status: "clarification_needed",
-                message: "What operation would you like to perform?",
-                inferred: "upload",
-                hint: "You provided a file path. Did you mean mode='upload'?",
-                options: ["upload", "list", "generate", "embedding"],
-            };
-        }
-        if (args.file_id && args.input) {
-            // Has file_id and input → likely wants modify
-            return {
-                status: "clarification_needed",
-                message: "What operation would you like to perform?",
-                inferred: "modify",
-                hint: "You provided file_id and input. Did you mean mode='modify'?",
-                options: ["modify", "delete", "get"],
-            };
-        }
-        if (args.input || args.from) {
-            // Has input or from → likely wants generate
-            return {
-                status: "clarification_needed",
-                message: "What operation would you like to perform?",
-                inferred: "generate",
-                hint: "You provided input/from. Did you mean mode='generate'?",
-                options: ["generate", "list"],
-            };
-        }
-        if (args.template) {
-            // Wants a specific template
-            return {
-                status: "clarification_needed",
-                message: "What operation would you like to perform?",
-                inferred: "templates",
-                hint: "You provided template name. Did you mean mode='templates'?",
-                options: ["templates"],
-            };
-        }
-        // Default clarification
-        return {
-            status: "clarification_needed",
-            message: "What operation would you like to perform?",
-            options: ["list", "upload", "generate", "modify", "sanitize", "delete", "embedding", "templates"],
-            hint: "Specify mode='...' for direct execution. Example: data(persona_id='abc', mode='list')",
-        };
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Templates mode - list or get generation templates
-    // ─────────────────────────────────────────────────────────────────────────
-    if (mode === "templates") {
-        const templateName = args.template;
-        if (templateName) {
-            const template = GENERATION_TEMPLATES[templateName];
-            if (!template) {
-                return {
-                    error: `Template not found: ${templateName}`,
-                    available: Object.keys(GENERATION_TEMPLATES),
-                };
-            }
-            return {
-                name: templateName,
-                ...template,
-            };
-        }
-        // List all templates
-        return {
-            templates: Object.entries(GENERATION_TEMPLATES).map(([name, t]) => ({
-                name,
-                description: t.description,
-                category: t.category,
-            })),
-        };
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Generate mode - create new content via Document Generation API
-    // ─────────────────────────────────────────────────────────────────────────
-    if (mode === "generate") {
-        if (!personaId) {
-            return { error: "persona_id is required for generate mode" };
-        }
-        const from = args.from;
-        const input = args.input;
-        const count = args.count ?? 1;
-        const format = args.format ?? "markdown";
-        const data = args.data;
-        if (!from && !input) {
-            return {
-                error: "Either 'from' (template name) or 'input' (natural language) is required for generate mode",
-                available_templates: Object.keys(GENERATION_TEMPLATES),
-            };
-        }
-        // Build instructions from template or input
-        let instructions;
-        if (from) {
-            const template = GENERATION_TEMPLATES[from];
-            if (!template) {
-                return {
-                    error: `Template not found: ${from}`,
-                    available: Object.keys(GENERATION_TEMPLATES),
-                };
-            }
-            // Build instructions from template
-            instructions = template.prompt
-                .replace("{count}", String(count))
-                .replace("{format}", format);
-            if (data) {
-                // Inject additional context
-                instructions += `\n\nAdditional context: ${JSON.stringify(data)}`;
-            }
-        }
-        else {
-            instructions = input;
-            if (count > 1) {
-                instructions = `Generate ${count} items: ${instructions}`;
-            }
-            instructions += `\n\nOutput format: ${format}`;
-        }
-        // Call Document Generation API
-        try {
-            const result = await client.generateDocument(personaId, instructions, {
-                timeoutMs: 120_000,
-                pollIntervalMs: 2_000,
-            });
-            return {
-                success: true,
-                document_id: result.document_id,
-                project_id: result.project_id,
-                status: result.status,
-                content: result.content,
-                format,
-                template: from,
-            };
-        }
-        catch (err) {
-            const error = err;
-            return {
-                error: `Document generation failed: ${error.message}`,
-                template: from,
-                instructions_length: instructions.length,
-            };
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Modify mode - modify existing document
-    // ─────────────────────────────────────────────────────────────────────────
-    if (mode === "modify") {
-        if (!personaId) {
-            return { error: "persona_id is required for modify mode" };
-        }
-        const fileId = args.file_id;
-        const input = args.input;
-        if (!fileId) {
-            return { error: "file_id is required for modify mode" };
-        }
-        if (!input) {
-            return { error: "input (modification instructions) is required for modify mode" };
-        }
-        // For now, regenerate uses the Document Generation API's regenerate endpoint
-        // This requires document_id and project_id - we'd need to track these
-        // For MVP, return guidance
-        return {
-            status: "not_yet_implemented",
-            message: "Document modification via regenerate API requires document_id and project_id from the original generation.",
-            hint: "Use mode='generate' to create new content, or manually edit the file.",
-            file_id: fileId,
-            instructions: input,
-        };
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Get mode - get specific file details
-    // ─────────────────────────────────────────────────────────────────────────
-    if (mode === "get") {
-        if (!personaId) {
-            return { error: "persona_id is required for get mode" };
-        }
-        const fileId = args.file_id;
-        if (!fileId) {
-            return { error: "file_id is required for get mode" };
-        }
-        // List files and filter to the specific one
-        const files = await client.listDataSourceFiles(personaId, { limit: 1000 });
-        const file = files.files.find(f => f.id === fileId);
-        if (!file) {
-            return { error: `File not found: ${fileId}` };
-        }
-        return {
-            file,
-            persona_id: personaId,
-        };
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Sanitize mode - existing implementation
-    // ─────────────────────────────────────────────────────────────────────────
-    if (mode === "sanitize") {
-        // Data sanitization - needs special handling
-        const personaId = args.persona_id;
-        const includeWorkflow = args.include_workflow;
-        const sanitizeExamples = args.sanitize_examples;
-        const persona = await client.getPersonaById(personaId);
-        if (!persona) {
-            return { error: `Persona not found: ${personaId}` };
-        }
-        // Create sanitization session
-        const session = new SanitizationSession();
-        // Detect and sanitize in proto_config
-        const protoConfig = persona.proto_config;
-        let sanitizedConfig = protoConfig;
-        if (protoConfig) {
-            // Apply pattern-based detection and sanitization
-            const clonedConfig = JSON.parse(JSON.stringify(protoConfig)); // Deep clone
-            // Recursively find and sanitize string values
-            const sanitizeObject = (obj) => {
-                for (const key of Object.keys(obj)) {
-                    const val = obj[key];
-                    if (typeof val === "string" && val.length > 0) {
-                        const detected = detectWithPatterns(val);
-                        for (const entity of detected) {
-                            const replacement = session.getOrCreateReplacement(entity.value, entity.type);
-                            obj[key] = obj[key].split(entity.value).join(replacement);
-                        }
-                        // Also apply user examples
-                        if (sanitizeExamples) {
-                            for (const example of sanitizeExamples) {
-                                if (obj[key].includes(example)) {
-                                    const replacement = session.getOrCreateReplacement(example, "unknown");
-                                    obj[key] = obj[key].split(example).join(replacement);
-                                }
-                            }
-                        }
-                    }
-                    else if (typeof val === "object" && val !== null) {
-                        sanitizeObject(val);
-                    }
-                }
-            };
-            sanitizeObject(clonedConfig);
-            sanitizedConfig = clonedConfig;
-        }
-        // Optionally sanitize workflow
-        let sanitizedWorkflow = persona.workflow_def;
-        if (includeWorkflow && sanitizedWorkflow) {
-            const clonedWorkflow = JSON.parse(JSON.stringify(sanitizedWorkflow));
-            const sanitizeWfObj = (obj) => {
-                for (const key of Object.keys(obj)) {
-                    const val = obj[key];
-                    if (typeof val === "string" && val.length > 0) {
-                        const detected = detectWithPatterns(val);
-                        for (const entity of detected) {
-                            const replacement = session.getOrCreateReplacement(entity.value, entity.type);
-                            obj[key] = obj[key].split(entity.value).join(replacement);
-                        }
-                    }
-                    else if (typeof val === "object" && val !== null) {
-                        sanitizeWfObj(val);
-                    }
-                }
-            };
-            sanitizeWfObj(clonedWorkflow);
-            sanitizedWorkflow = clonedWorkflow;
-        }
-        // Apply updates
-        await client.updateAiEmployee({
-            persona_id: personaId,
-            proto_config: sanitizedConfig ?? {},
-            workflow: includeWorkflow ? sanitizedWorkflow : undefined,
-        });
-        // Convert Map to array for JSON response
-        const mappingsMap = session.getMappings();
-        const mappingsArray = Array.from(mappingsMap.entries()).map(([original, replacement]) => ({
-            original,
-            replacement,
-        }));
-        return {
-            success: true,
-            persona_id: personaId,
-            entities_sanitized: mappingsMap.size,
-            mappings: mappingsArray,
-            workflow_sanitized: !!includeWorkflow,
-        };
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Embedding mode - status or toggle
-    // ─────────────────────────────────────────────────────────────────────────
-    if (mode === "embedding") {
-        if (!personaId) {
-            return { error: "persona_id is required for embedding mode" };
-        }
-        const knowledgeArgs = { ...args };
-        if (args.enabled !== undefined) {
-            knowledgeArgs.mode = "toggle";
-        }
-        else {
-            knowledgeArgs.mode = "status";
-        }
-        // Call handleKnowledge without deprecation warning (data is the new interface)
-        return handleKnowledge(knowledgeArgs, client, readFile, { includeDeprecationWarning: false });
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Replicate mode - copy data by reference (fast, no re-upload)
-    // ─────────────────────────────────────────────────────────────────────────
-    if (mode === "replicate") {
-        if (!personaId) {
-            return { error: "persona_id is required for replicate mode (this is the TARGET persona)" };
-        }
-        const sourcePersonaId = args.from;
-        if (!sourcePersonaId) {
-            return {
-                error: "from is required for replicate mode (source persona ID)",
-                hint: "Use data(method='replicate', from='source-persona-id') to copy data by reference",
-            };
-        }
-        // Parse and validate widget mappings if provided
-        const widgetMappingsRaw = args.widget_mappings;
-        let widgetMappings;
-        if (widgetMappingsRaw !== undefined) {
-            // Validate that widget_mappings is an array
-            if (!Array.isArray(widgetMappingsRaw)) {
-                return {
-                    error: "widget_mappings must be an array",
-                    hint: "Use widget_mappings=[{source_widget: 'kb', target_widget: 'kb'}]",
-                };
-            }
-            // Validate each mapping has at least source_widget
-            try {
-                widgetMappings = widgetMappingsRaw.map((m, i) => {
-                    if (typeof m !== "object" || m === null) {
-                        throw new Error(`widget_mappings[${i}] must be an object`);
-                    }
-                    const mapping = m;
-                    const sourceWidget = mapping.source_widget ?? mapping.sourceWidget;
-                    if (!sourceWidget || typeof sourceWidget !== "string") {
-                        throw new Error(`widget_mappings[${i}].source_widget is required`);
-                    }
-                    return {
-                        sourceWidget,
-                        targetWidget: mapping.target_widget ?? mapping.targetWidget,
-                    };
-                });
-            }
-            catch (validationErr) {
-                return {
-                    error: `Invalid widget_mappings: ${validationErr.message}`,
-                    hint: "Each mapping must have source_widget (string). target_widget is optional.",
-                };
-            }
-        }
-        else {
-            // Default: replicate knowledge_base
-            widgetMappings = [{ sourceWidget: "knowledge_base" }];
-        }
-        const shouldWait = args.wait !== false; // Default to true
-        try {
-            // Call replicateData - copies S3 references, not actual files
-            const result = await client.replicateData({ type: "persona", id: sourcePersonaId }, { type: "persona", id: personaId }, widgetMappings);
-            // If wait=true (default), poll for completion
-            if (shouldWait && result.results.length > 0) {
-                const requestIds = result.results.map(r => r.requestId).filter(Boolean);
-                const statuses = [];
-                for (const requestId of requestIds) {
-                    try {
-                        const status = await client.waitForReplication(requestId, personaId, {
-                            timeoutMs: 60_000,
-                            pollIntervalMs: 1_000,
-                        });
-                        statuses.push({ requestId, status: status.status, failedReason: status.failedReason });
-                    }
-                    catch (pollErr) {
-                        statuses.push({ requestId, status: "timeout", failedReason: String(pollErr) });
-                    }
-                }
-                const allCompleted = statuses.every(s => s.status === "completed");
-                const anyFailed = statuses.some(s => s.status === "failed");
-                return {
-                    success: allCompleted,
-                    source_persona_id: sourcePersonaId,
-                    target_persona_id: personaId,
-                    replication_results: result.results,
-                    final_statuses: statuses,
-                    message: allCompleted
-                        ? "Data replicated successfully (by reference, no files copied)"
-                        : anyFailed
-                            ? "Some replications failed"
-                            : "Replication completed with warnings",
-                    _tip: "Replication copies S3 references - much faster than downloading and re-uploading files",
-                };
-            }
-            // If wait=false, return immediately with request IDs
-            return {
-                success: true,
-                source_persona_id: sourcePersonaId,
-                target_persona_id: personaId,
-                replication_results: result.results,
-                message: "Replication initiated (async)",
-                _tip: "Use getReplicationStatus with request IDs to check progress",
-            };
-        }
-        catch (err) {
-            const error = err;
-            return {
-                error: `Replication failed: ${error.message}`,
-                source_persona_id: sourcePersonaId,
-                target_persona_id: personaId,
-                hint: "Ensure both personas exist and have compatible data structures",
-            };
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Stats mode - get file counts by status
-    // ─────────────────────────────────────────────────────────────────────────
-    if (mode === "stats") {
-        if (!personaId) {
-            return { error: "persona_id is required for stats mode" };
-        }
-        const widgetName = args.widget_name;
-        try {
-            const aggregates = await client.getDataSourceAggregates(personaId, widgetName);
-            return {
-                persona_id: personaId,
-                widget_name: aggregates.widgetName ?? widgetName ?? "all",
-                total: aggregates.total,
-                pending: aggregates.pending,
-                success: aggregates.success,
-                failed: aggregates.failed,
-                _tip: "Use data(method='list') to see individual files",
-            };
-        }
-        catch (err) {
-            const error = err;
-            return {
-                error: `Failed to get data stats: ${error.message}`,
-                persona_id: personaId,
-            };
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // Remaining modes (list, upload, delete) - delegate to knowledge handler
-    // ─────────────────────────────────────────────────────────────────────────
-    if (!personaId && mode !== "templates") {
-        return { error: "persona_id is required for this operation" };
-    }
-    // Call handleKnowledge without deprecation warning (data is the new interface)
-    return handleKnowledge(args, client, readFile, { includeDeprecationWarning: false });
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// SYNC Handler
-// ═══════════════════════════════════════════════════════════════════════════
-// Delegate to extracted handler
-export const handleSync = handleSyncExtracted;
-/**
- * Analyze a natural language modification request and determine what operations are needed.
- * This is the "smart" part - understanding user intent.
- */
-function analyzeModificationRequest(input, existingWorkflow) {
-    const lowerInput = input.toLowerCase();
-    const operations = [];
-    let intent = "modify workflow";
-    const actions = (existingWorkflow.actions || []);
-    // ─────────────────────────────────────────────────────────────────────────
-    // CONSOLIDATION: "consolidate X agents into one", "merge", "combine"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("consolidat") || lowerInput.includes("merge") ||
-        lowerInput.includes("combine") || lowerInput.includes("into one") ||
-        lowerInput.includes("single agent") || lowerInput.includes("unified")) {
-        intent = "consolidate multiple nodes into one";
-        // Find nodes to consolidate - look for patterns like "8 custom agents", "the agents"
-        const customAgents = actions.filter(a => {
-            const actionType = getActionType(a);
-            return actionType === "custom_agent" || actionType.includes("custom");
-        });
-        if (customAgents.length > 1) {
-            operations.push({
-                type: "consolidate",
-                description: `Consolidate ${customAgents.length} custom_agent nodes into a single unified agent`,
-                target_nodes: customAgents.map(a => String(a.name || "")),
-            });
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // REMOVAL: "remove", "delete", "clean up orphan"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("remove") || lowerInput.includes("delete") ||
-        lowerInput.includes("clean up") || lowerInput.includes("orphan")) {
-        intent = "remove nodes";
-        // Check if removing orphans specifically
-        if (lowerInput.includes("orphan")) {
-            // Find orphan nodes by checking reachability
-            const orphanNodes = findOrphanNodes(existingWorkflow);
-            if (orphanNodes.length > 0) {
-                operations.push({
-                    type: "remove",
-                    description: `Remove ${orphanNodes.length} orphan nodes`,
-                    target_nodes: orphanNodes,
-                });
-            }
-        }
-        // Check for specific node names mentioned
-        // Strategy 1: Look for "remove the node NODENAME" pattern
-        const explicitNodeMatch = input.match(/remove\s+(?:the\s+)?node\s+["']?([a-zA-Z0-9_]+)["']?/i);
-        if (explicitNodeMatch) {
-            const nodeName = explicitNodeMatch[1];
-            const matchingNodes = actions.filter(a => String(a.name || "").toLowerCase() === nodeName.toLowerCase() ||
-                String(a.name || "").toLowerCase().includes(nodeName.toLowerCase()));
-            if (matchingNodes.length > 0) {
-                operations.push({
-                    type: "remove",
-                    description: `Remove node(s) matching "${nodeName}"`,
-                    target_nodes: matchingNodes.map(a => String(a.name || "")),
-                });
-            }
-        }
-        // Strategy 2: Check if any actual node ID appears in the input text
-        if (operations.length === 0) {
-            const nodeNames = actions.map(a => String(a.name || "")).filter(n => n.length > 0);
-            const foundNodes = nodeNames.filter(nodeName => input.toLowerCase().includes(nodeName.toLowerCase()));
-            if (foundNodes.length > 0) {
-                operations.push({
-                    type: "remove",
-                    description: `Remove node(s): ${foundNodes.join(", ")}`,
-                    target_nodes: foundNodes,
-                });
-            }
-        }
-        // Strategy 3: Fallback - simple "remove X" pattern (for short names)
-        if (operations.length === 0) {
-            const simpleMatch = input.match(/remove\s+(?:the\s+)?(\w+)/i);
-            if (simpleMatch && simpleMatch[1].toLowerCase() !== "node") {
-                const nodeName = simpleMatch[1];
-                const matchingNodes = actions.filter(a => String(a.name || "").toLowerCase().includes(nodeName.toLowerCase()));
-                if (matchingNodes.length > 0) {
-                    operations.push({
-                        type: "remove",
-                        description: `Remove node(s) matching "${nodeName}"`,
-                        target_nodes: matchingNodes.map(a => String(a.name || "")),
-                    });
-                }
-            }
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // REPLACEMENT: "replace X with Y", "swap", "use X instead of Y"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("replace") || lowerInput.includes("swap") ||
-        lowerInput.includes("instead of") || lowerInput.includes("use entity_extraction")) {
-        intent = "replace nodes";
-        // Parse "replace X with Y" pattern
-        const replaceMatch = input.match(/replace\s+(?:the\s+)?(.+?)\s+with\s+(.+)/i);
-        if (replaceMatch) {
-            operations.push({
-                type: "replace",
-                description: `Replace ${replaceMatch[1]} with ${replaceMatch[2]}`,
-                source: replaceMatch[1],
-                target: replaceMatch[2],
-            });
-        }
-        // Special case: "use entity_extraction" suggests replacing LLM-based extraction
-        if (lowerInput.includes("entity_extraction")) {
-            const llmNodes = actions.filter(a => {
-                const actionType = getActionType(a);
-                const displayName = a.displaySettings?.displayName || "";
-                return (actionType === "call_llm" &&
-                    (displayName.toLowerCase().includes("email") ||
-                        displayName.toLowerCase().includes("extract")));
-            });
-            if (llmNodes.length > 0) {
-                operations.push({
-                    type: "replace",
-                    description: `Replace ${llmNodes.length} LLM extraction nodes with entity_extraction`,
-                    target_nodes: llmNodes.map(a => String(a.name || "")),
-                });
-            }
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // HITL: "add hitl", "add approval", "confirm before"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("hitl") || lowerInput.includes("approval") ||
-        lowerInput.includes("confirm") || lowerInput.includes("human")) {
-        intent = "add human-in-the-loop";
-        // Find the action to add HITL before
-        const beforeMatch = input.match(/before\s+(\w+)/i);
-        const targetAction = beforeMatch ? beforeMatch[1] : "email";
-        // Find email/send nodes
-        const emailNodes = actions.filter(a => {
-            const actionType = getActionType(a);
-            const nodeName = String(a.name || "").toLowerCase();
-            return actionType.includes("email") || nodeName.includes("email") ||
-                nodeName.includes("send") || nodeName.includes(targetAction.toLowerCase());
-        });
-        operations.push({
-            type: "add",
-            description: `Add HITL approval before ${emailNodes.length > 0 ? emailNodes[0].name : targetAction}`,
-            new_node: {
-                type: "general_hitl",
-                name: `hitl_approval_${Date.now()}`,
-                before: emailNodes.length > 0 ? String(emailNodes[0].name) : targetAction,
-            },
-        });
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // WIRING: "connect", "wire", "link X to Y"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("connect") || lowerInput.includes("wire") ||
-        lowerInput.includes("link")) {
-        intent = "rewire connections";
-        // Parse "connect X to Y" pattern
-        const connectMatch = input.match(/(?:connect|wire|link)\s+(\w+)\s+to\s+(\w+)/i);
-        if (connectMatch) {
-            operations.push({
-                type: "rewire",
-                description: `Connect ${connectMatch[1]} to ${connectMatch[2]}`,
-                source: connectMatch[1],
-                target: connectMatch[2],
-            });
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // ADD: "add", "include", "new"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (operations.length === 0 && (lowerInput.includes("add") || lowerInput.includes("new") || lowerInput.includes("include"))) {
-        intent = "add new capabilities";
-        // Use existing parseExtensionInput for additive changes
-        const addChanges = parseExtensionInput(input);
-        for (const change of addChanges) {
-            operations.push({
-                type: "add",
-                description: change.description,
-                config: change.details,
-            });
-        }
-    }
-    // Determine confidence based on how specific the operations are
-    const confidence = operations.length > 0 && operations.every(op => op.target_nodes?.length || op.new_node) ? "high" :
-        operations.length > 0 ? "medium" : "low";
-    return { intent, operations, confidence };
-}
-/**
- * Find orphan nodes (not reachable from trigger).
- */
-function findOrphanNodes(workflow) {
-    const actions = (workflow.actions || []);
-    const orphans = [];
-    // Build a set of all referenced nodes (nodes that receive input from other nodes)
-    const referencedNodes = new Set();
-    referencedNodes.add("trigger"); // Trigger is always reachable
-    // Find all nodes that are referenced in actionOutput bindings
-    for (const action of actions) {
-        const inputs = (action.inputs || {});
-        for (const inputValue of Object.values(inputs)) {
-            const binding = inputValue;
-            if (binding?.actionOutput) {
-                const actionOutput = binding.actionOutput;
-                referencedNodes.add(String(actionOutput.actionName || ""));
-            }
-            // Check multiBinding
-            if (binding?.multiBinding) {
-                const multi = binding.multiBinding;
-                const elements = (multi.elements || []);
-                for (const elem of elements) {
-                    if (elem.namedBinding) {
-                        const named = elem.namedBinding;
-                        const value = named.value;
-                        if (value?.actionOutput) {
-                            const ao = value.actionOutput;
-                            referencedNodes.add(String(ao.actionName || ""));
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Find nodes that don't receive input from trigger chain
-    // This is a simplified check - proper reachability would need graph traversal
-    for (const action of actions) {
-        const nodeName = String(action.name || "");
-        const hasInputFromTrigger = checkNodeHasPath(nodeName, actions, "trigger", new Set());
-        if (!hasInputFromTrigger && nodeName !== "trigger") {
-            orphans.push(nodeName);
-        }
-    }
-    return orphans;
-}
-/**
- * Check if a node has a path from source (simple BFS).
- */
-function checkNodeHasPath(nodeName, actions, source, visited) {
-    if (visited.has(nodeName))
-        return false;
-    visited.add(nodeName);
-    const node = actions.find(a => a.name === nodeName);
-    if (!node)
-        return false;
-    const inputs = (node.inputs || {});
-    for (const inputValue of Object.values(inputs)) {
-        const binding = inputValue;
-        if (binding?.actionOutput) {
-            const actionOutput = binding.actionOutput;
-            const sourceNode = String(actionOutput.actionName || "");
-            if (sourceNode === source)
-                return true;
-            if (checkNodeHasPath(sourceNode, actions, source, visited))
-                return true;
-        }
-    }
-    return false;
-}
-/**
- * Apply modifications to the workflow based on analyzed operations.
- */
-function applyWorkflowModifications(existingWorkflow, analysis) {
-    const workflow = JSON.parse(JSON.stringify(existingWorkflow));
-    const actions = (workflow.actions || []);
-    const enumTypes = (workflow.enumTypes || []);
-    const results = (workflow.results || {});
-    const changesApplied = [];
-    const nodesAdded = [];
-    const nodesRemoved = [];
-    const nodesModified = [];
-    const connectionsChanged = [];
-    for (const op of analysis.operations) {
-        switch (op.type) {
-            case "consolidate": {
-                // Consolidate multiple nodes into one unified agent
-                const targetNodes = op.target_nodes || [];
-                if (targetNodes.length < 2) {
-                    changesApplied.push("Consolidation skipped: need 2+ nodes to consolidate");
-                    break;
-                }
-                // Get the first node as template
-                const templateIdx = actions.findIndex(a => a.name === targetNodes[0]);
-                if (templateIdx < 0)
-                    break;
-                const template = actions[templateIdx];
-                // Create unified agent node
-                const unifiedNode = {
-                    name: "unified_analysis_agent",
-                    action: template.action,
-                    inputs: {
-                        ...template.inputs,
-                        // Update instructions to be dynamic
-                        role_instructions: {
-                            inline: {
-                                wellKnown: {
-                                    stringValue: "You are a versatile analysis agent. Read your agent definition from the knowledge base based on the current intent type and adopt that role.",
-                                },
-                            },
-                            autoDetectedBinding: false,
-                        },
-                        task_instructions: {
-                            inline: {
-                                wellKnown: {
-                                    stringValue: "Execute the task based on the intent type. The knowledge base contains definitions for each intent with INPUT DATA, ANALYSIS FRAMEWORK, and OUTPUT SCHEMA. Follow those precisely.",
-                                },
-                            },
-                            autoDetectedBinding: false,
-                        },
-                    },
-                    displaySettings: {
-                        displayName: "Unified Analysis Agent",
-                        description: `Consolidated from ${targetNodes.length} separate agents`,
-                        coordinates: template.displaySettings?.coordinates || { x: 2000, y: 1500 },
-                    },
-                    typeArguments: template.typeArguments || {},
-                    tools: template.tools || [],
-                    disableHumanInteraction: false,
-                    // No runIf - runs for all intents, uses internal routing
-                };
-                // Remove all target nodes
-                for (const nodeName of targetNodes) {
-                    const idx = actions.findIndex(a => a.name === nodeName);
-                    if (idx >= 0) {
-                        actions.splice(idx, 1);
-                        nodesRemoved.push(nodeName);
-                        // Also remove from results mapping
-                        const resultKey = Object.keys(results).find(k => k.startsWith(nodeName + "."));
-                        if (resultKey) {
-                            delete results[resultKey];
-                        }
-                    }
-                }
-                // Add unified node
-                actions.push(unifiedNode);
-                nodesAdded.push("unified_analysis_agent");
-                // Add to results mapping
-                results["unified_analysis_agent.response_with_sources"] = {
-                    actionName: "unified_analysis_agent",
-                    outputName: "response_with_sources",
-                };
-                changesApplied.push(`Consolidated ${targetNodes.length} nodes into unified_analysis_agent`);
-                break;
-            }
-            case "remove": {
-                const targetNodes = op.target_nodes || [];
-                for (const nodeName of targetNodes) {
-                    const idx = actions.findIndex(a => a.name === nodeName);
-                    if (idx >= 0) {
-                        actions.splice(idx, 1);
-                        nodesRemoved.push(nodeName);
-                        // Also remove from results
-                        const resultKey = Object.keys(results).find(k => k.startsWith(nodeName + "."));
-                        if (resultKey) {
-                            delete results[resultKey];
-                        }
-                        changesApplied.push(`Removed node: ${nodeName}`);
-                    }
-                }
-                break;
-            }
-            case "replace": {
-                // For now, just note it - full replacement is complex
-                changesApplied.push(`Replace operation noted: ${op.description}. Manual verification needed.`);
-                break;
-            }
-            case "rewire": {
-                const source = op.source;
-                const target = op.target;
-                if (source && target) {
-                    // Find target node and update its inputs
-                    const targetNode = actions.find(a => String(a.name || "").toLowerCase().includes(target.toLowerCase()));
-                    if (targetNode) {
-                        nodesModified.push(String(targetNode.name));
-                        connectionsChanged.push(`${source} → ${targetNode.name}`);
-                        changesApplied.push(`Rewiring: ${source} → ${targetNode.name}`);
-                    }
-                }
-                break;
-            }
-            case "add": {
-                if (op.new_node) {
-                    const newNode = op.new_node;
-                    const nodeName = String(newNode.name || `new_node_${Date.now()}`);
-                    nodesAdded.push(nodeName);
-                    changesApplied.push(`Added node: ${nodeName}`);
-                }
-                else if (op.config) {
-                    // Use legacy merge for additive changes
-                    const legacyChanges = parseExtensionInput(op.description);
-                    const legacyResult = mergeWorkflowChanges(workflow, legacyChanges);
-                    changesApplied.push(...legacyResult.changesApplied);
-                }
-                break;
-            }
-            case "modify_config": {
-                changesApplied.push(`Config modification noted: ${op.description}`);
-                break;
-            }
-        }
-    }
-    workflow.actions = actions;
-    workflow.enumTypes = enumTypes;
-    workflow.results = results;
-    return {
-        workflow,
-        changesApplied,
-        nodesAdded,
-        nodesRemoved,
-        nodesModified,
-        connectionsChanged,
-    };
-}
-/**
- * Parse natural language input to detect what changes are being requested.
- * Handles multiple changes in one input (e.g., "add X, add Y, add Z").
- *
- * IMPORTANT: We need to be smart about splitting - don't split enum options!
- * "add caller_type enum options Advisor and Client" should keep "Advisor and Client" together
- */
-function parseExtensionInput(input) {
-    const changes = [];
-    // First, identify major change boundaries (comma-separated distinct changes)
-    // But be careful not to split within an enum options list
-    const segments = splitIntoChanges(input);
-    for (const segment of segments) {
-        const lowerSegment = segment.toLowerCase();
-        // Detect categorizer/enum changes - parse options carefully
-        if (lowerSegment.includes("categorizer") || lowerSegment.includes("enum") ||
-            lowerSegment.includes("caller_type") || lowerSegment.includes("actor")) {
-            // Extract options: "with Advisor and Client" or "options Advisor/Client" or "Advisor, Client"
-            const optionsMatch = segment.match(/(?:options?|with)\s+(.+?)(?:,\s*add|$)/i);
-            let options = [];
-            if (optionsMatch) {
-                // Split on "and", "/", or "," but preserve the values
-                options = optionsMatch[1]
-                    .split(/\s+and\s+|[,/]/i)
-                    .map(s => s.trim())
-                    .filter(s => s.length > 0 && !s.toLowerCase().includes('add'));
-            }
-            // Also look for target categorizer name
-            const categorizerMatch = segment.match(/(?:to\s+)?(\w+_categorizer|\w+categorizer)/i);
-            const targetCategorizer = categorizerMatch ? categorizerMatch[1] : undefined;
-            changes.push({
-                type: "categorizer",
-                description: `Add enum options: ${options.join(', ')}`,
-                details: {
-                    raw: segment,
-                    options,
-                    target_categorizer: targetCategorizer,
-                },
-            });
-        }
-        // Detect HITL/approval changes
-        else if (lowerSegment.includes("hitl") || lowerSegment.includes("approval") ||
-            lowerSegment.includes("confirm") || lowerSegment.includes("human")) {
-            // Parse "before email" or "before send_email" or "before send"
-            const beforeMatch = segment.match(/before\s+(\w+(?:_\w+)?)/i);
-            const targetAction = beforeMatch ? beforeMatch[1] : "unspecified";
-            changes.push({
-                type: "hitl",
-                description: `Add human-in-the-loop approval before ${targetAction}`,
-                details: { raw: segment, before_action: targetAction },
-            });
-        }
-        // Detect wiring/connection changes - parse source → target(s)
-        else if (lowerSegment.includes("connect") || lowerSegment.includes("wire") ||
-            lowerSegment.includes("link") || lowerSegment.match(/\w+\s+to\s+\w+\.\w+/)) {
-            // Parse: "connect entity_extraction_1 to send_communications_handler to_email and subject"
-            // Supports multiple target inputs separated by "and"
-            const wiringMatch = segment.match(/(?:connect\s+)?(\w+)(?:\.(\w+))?\s+(?:to|→|->)\s+(\w+)(?:\.|\s+)(.+)/i);
-            if (wiringMatch) {
-                const sourceNode = wiringMatch[1];
-                const sourceOutput = wiringMatch[2] || "extracted_entities";
-                const targetNode = wiringMatch[3];
-                // Parse multiple target inputs: "to_email and subject" or "to_email, subject"
-                const targetInputsRaw = wiringMatch[4];
-                const targetInputs = targetInputsRaw
-                    .split(/\s+and\s+|[,]/i)
-                    .map(s => s.trim())
-                    .filter(s => s.length > 0 && /^\w+$/.test(s));
-                // Create a wiring change for each target input
-                for (const targetInput of targetInputs) {
-                    changes.push({
-                        type: "wiring",
-                        description: `Connect ${sourceNode} to ${targetNode}.${targetInput}`,
-                        details: {
-                            raw: segment,
-                            source_node: sourceNode,
-                            source_output: sourceOutput,
-                            target_node: targetNode,
-                            target_input: targetInput,
-                        },
-                    });
-                }
-                if (targetInputs.length === 0) {
-                    changes.push({
-                        type: "wiring",
-                        description: `Modify connections: ${segment}`,
-                        details: { raw: segment },
-                    });
-                }
-            }
-            else {
-                changes.push({
-                    type: "wiring",
-                    description: `Modify connections: ${segment}`,
-                    details: { raw: segment },
-                });
-            }
-        }
-        // Detect intent changes
-        else if (lowerSegment.includes("intent")) {
-            const intentMatch = segment.match(/(?:add|new)\s+(?:intent:?\s*)?(\w+)/i);
-            const intentName = intentMatch ? intentMatch[1] : "new_intent";
-            changes.push({
-                type: "intent",
-                description: `Add new intent: ${intentName}`,
-                details: { raw: segment, intent_name: intentName },
-            });
-        }
-        // Detect new node/capability additions
-        else if (lowerSegment.includes("add") || lowerSegment.includes("new") || lowerSegment.includes("include")) {
-            changes.push({
-                type: "add_node",
-                description: `Add new capability: ${segment}`,
-                details: { raw: segment },
-            });
-        }
-    }
-    return changes;
-}
-/**
- * Split input into distinct change requests, being careful not to split
- * within enum option lists.
- */
-function splitIntoChanges(input) {
-    const changes = [];
-    // Split on ", add", ", connect", ", wire" patterns - these start new change requests
-    // Use a regex that keeps the keyword with the following text
-    const parts = input.split(/,\s*(?=add\s|connect\s|wire\s|link\s)/i);
-    for (const part of parts) {
-        const trimmed = part.trim();
-        // Skip very short fragments that are just keywords
-        if (trimmed.length > 5) {
-            changes.push(trimmed);
-        }
-    }
-    // If no splits found, return the whole input
-    if (changes.length === 0 && input.trim().length > 0) {
-        changes.push(input.trim());
-    }
-    return changes;
-}
-/**
- * Extract the action type from a workflow action node.
- * Handles nested structure: action.action.name.name or action.action.name
- */
-function getActionType(action) {
-    const actionObj = action.action;
-    if (!actionObj)
-        return "";
-    const nameObj = actionObj.name;
-    if (!nameObj)
-        return "";
-    // Nested structure: action.name.name
-    if (typeof nameObj === "object" && "name" in nameObj) {
-        return String(nameObj.name || "");
-    }
-    // Direct string
-    if (typeof nameObj === "string")
-        return nameObj;
-    return "";
-}
-/**
- * Merge detected changes into an existing workflow.
- * Returns the modified workflow and list of new nodes that need configuration.
- */
-function mergeWorkflowChanges(existingWorkflow, changes) {
-    const workflow = JSON.parse(JSON.stringify(existingWorkflow));
-    const actions = (workflow.actions || []);
-    const enumTypes = (workflow.enumTypes || []);
-    const newNodes = [];
-    const changesApplied = [];
-    for (const change of changes) {
-        switch (change.type) {
-            case "categorizer":
-            case "enum_option": {
-                const options = change.details.options || [];
-                const targetCategorizerName = change.details.target_categorizer;
-                if (options.length === 0) {
-                    changesApplied.push("No enum options specified");
-                    break;
-                }
-                // Find the target categorizer action
-                const categorizer = actions.find(a => {
-                    const nodeName = String(a.name || "");
-                    const actionType = getActionType(a);
-                    // Match by specific name or by type
-                    if (targetCategorizerName) {
-                        return nodeName.toLowerCase().includes(targetCategorizerName.toLowerCase());
-                    }
-                    return actionType.includes("categorizer");
-                });
-                if (!categorizer) {
-                    changesApplied.push(`No categorizer found to add options: ${options.join(', ')}`);
-                    break;
-                }
-                const categorizerName = String(categorizer.name || "");
-                // Find the corresponding enumType for this categorizer
-                // EnumType structure: { name: { name: { name: "EnumName", namespaces: [] } }, options: [...] }
-                let targetEnum = enumTypes.find(e => {
-                    const enumName = extractEnumTypeName(e);
-                    // Match by categorizer name or by checking typeArguments reference
-                    return enumName && (enumName.toLowerCase().includes(categorizerName.toLowerCase()) ||
-                        categorizerName.toLowerCase().includes(enumName.toLowerCase().replace(/_categories$/i, '')));
-                });
-                // If no matching enum found, try to find any enum (for simple workflows)
-                if (!targetEnum && enumTypes.length === 1) {
-                    targetEnum = enumTypes[0];
-                }
-                if (targetEnum) {
-                    // Add options to enumTypes[].options[]
-                    const enumOptions = (targetEnum.options || []);
-                    for (const opt of options) {
-                        const optLower = opt.toLowerCase();
-                        const exists = enumOptions.some(o => (o.name || "").toLowerCase() === optLower);
-                        if (!exists) {
-                            enumOptions.push({
-                                name: opt,
-                                description: `Added via MCP extend`
-                            });
-                            changesApplied.push(`Added "${opt}" to enumType.options`);
-                        }
-                    }
-                    targetEnum.options = enumOptions;
-                }
-                else {
-                    // No enumType found - note it for manual action
-                    changesApplied.push(`Enum options noted but no enumType found for ${categorizerName}: ${options.join(', ')}. Create enumType manually.`);
-                }
-                break;
-            }
-            case "hitl": {
-                const targetAction = change.details.before_action;
-                const hitlNodeName = `hitl_${targetAction || "approval"}_${Date.now()}`;
-                // Find the target action to insert HITL before
-                const targetNode = actions.find(a => {
-                    const nodeName = String(a.name || "").toLowerCase();
-                    return nodeName.includes(targetAction.toLowerCase());
-                });
-                newNodes.push({
-                    name: hitlNodeName,
-                    type: "human_in_the_loop",
-                    recommended_agent: "general_hitl",
-                });
-                if (targetNode) {
-                    changesApplied.push(`HITL node "${hitlNodeName}" to be inserted before "${targetNode.name}"`);
-                }
-                else {
-                    changesApplied.push(`HITL node "${hitlNodeName}" identified (target "${targetAction}" not found - wire manually)`);
-                }
-                break;
-            }
-            case "wiring": {
-                const sourceNode = change.details.source_node;
-                const sourceOutput = change.details.source_output;
-                const targetNode = change.details.target_node;
-                const targetInput = change.details.target_input;
-                if (sourceNode && targetNode && targetInput) {
-                    // Find the target action and update its input
-                    const target = actions.find(a => {
-                        const nodeName = String(a.name || "").toLowerCase();
-                        return nodeName.includes(targetNode.toLowerCase());
-                    });
-                    if (target && target.inputs) {
-                        const inputs = target.inputs;
-                        // Find the input field to update (may be nested as to_email, email_to, subject, etc.)
-                        const inputKey = Object.keys(inputs).find(k => k.toLowerCase().includes(targetInput.toLowerCase()) ||
-                            targetInput.toLowerCase().includes(k.toLowerCase()));
-                        if (inputKey) {
-                            // Update the actionOutput reference
-                            inputs[inputKey] = {
-                                actionOutput: {
-                                    actionName: sourceNode,
-                                    output: sourceOutput || "extracted_entities",
-                                },
-                                autoDetectedBinding: false,
-                            };
-                            changesApplied.push(`Wired ${sourceNode}.${sourceOutput || "output"} → ${target.name}.${inputKey}`);
-                        }
-                        else {
-                            changesApplied.push(`Input "${targetInput}" not found on "${target.name}" - wire manually`);
-                        }
-                    }
-                    else {
-                        changesApplied.push(`Target node "${targetNode}" not found - wire manually`);
-                    }
-                }
-                else {
-                    changesApplied.push(`Wiring change noted: ${change.description} (incomplete - specify source and target)`);
-                }
-                break;
-            }
-            case "intent": {
-                const intentName = change.details.intent_name;
-                // Add to enumType options (same as categorizer case)
-                const categorizer = actions.find(a => getActionType(a).includes("categorizer"));
-                if (categorizer && enumTypes.length > 0) {
-                    const targetEnum = enumTypes[0]; // Use first enum for intents
-                    const enumOptions = (targetEnum.options || []);
-                    const exists = enumOptions.some(o => (o.name || "").toLowerCase() === intentName.toLowerCase());
-                    if (!exists) {
-                        enumOptions.push({ name: intentName });
-                        targetEnum.options = enumOptions;
-                        changesApplied.push(`Added intent "${intentName}" to enumType.options`);
-                    }
-                }
-                else {
-                    changesApplied.push(`Intent "${intentName}" noted - add categorizer with enumType first`);
-                }
-                break;
-            }
-            case "add_node": {
-                const raw = change.details.raw.toLowerCase();
-                let nodeType = "unknown";
-                let recommended = "call_llm";
-                if (raw.includes("search") || raw.includes("kb") || raw.includes("knowledge")) {
-                    nodeType = "search";
-                    recommended = "search";
-                }
-                else if (raw.includes("email")) {
-                    nodeType = "send_email";
-                    recommended = "send_email_agent";
-                }
-                else if (raw.includes("ticket")) {
-                    nodeType = "external_action";
-                    recommended = "external_action_caller";
-                }
-                else if (raw.includes("extract")) {
-                    nodeType = "entity_extraction";
-                    recommended = "entity_extraction_with_documents";
-                }
-                newNodes.push({
-                    name: `${nodeType}_${Date.now()}`,
-                    type: nodeType,
-                    recommended_agent: recommended,
-                });
-                changesApplied.push(`New node identified: ${nodeType}`);
-                break;
-            }
-        }
-    }
-    workflow.actions = actions;
-    workflow.enumTypes = enumTypes;
-    return { workflow, newNodes, changesApplied };
-}
-/**
- * Extract the name from an enumType's nested name structure.
- * Structure: { name: { name: { name: "ActualName", namespaces: [] } } }
- */
-function extractEnumTypeName(enumType) {
-    try {
-        const outerName = enumType.name;
-        if (!outerName)
-            return null;
-        const innerName = outerName.name;
-        if (typeof innerName === "string")
-            return innerName;
-        if (!innerName)
-            return null;
-        const actualName = innerName.name;
-        if (typeof actualName === "string")
-            return actualName;
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Sanitize workflow before deployment to prevent API errors.
- * Same logic as deploy_workflow uses.
- */
-function sanitizeWorkflowForDeploy(workflow) {
-    const sanitized = JSON.parse(JSON.stringify(workflow));
-    // Fix enumTypes - remove entries with empty/missing names (causes server panic)
-    // EnumType structure: { name: { name: { name: "string", namespaces: [] } }, options: [...] }
-    const enumTypes = sanitized.enumTypes;
-    if (Array.isArray(enumTypes)) {
-        const validEnumTypes = enumTypes.filter(e => {
-            const outerName = e.name;
-            const innerName = outerName?.name;
-            const actualName = innerName?.name;
-            return typeof actualName === "string" && actualName.trim().length > 0;
-        });
-        if (validEnumTypes.length > 0) {
-            sanitized.enumTypes = validEnumTypes;
-        }
-        else {
-            delete sanitized.enumTypes;
-        }
-    }
-    // Ensure all actions have a 'name' field (node identifier)
-    const actions = sanitized.actions;
-    if (Array.isArray(actions)) {
-        for (const action of actions) {
-            // If action has 'actionName' but not 'name', fix it
-            if (!action.name && action.actionName) {
-                action.name = action.actionName;
-            }
-            // Ensure name is a non-empty string
-            if (typeof action.name !== "string" || !action.name.trim()) {
-                // Generate a name from action type if possible
-                const actionType = getActionType(action);
-                if (actionType) {
-                    action.name = `${actionType}_${Date.now()}`;
-                }
-            }
-        }
-    }
-    return sanitized;
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// Helper Functions
-// ═══════════════════════════════════════════════════════════════════════════
-// resolvePersona imported from handlers/utils.ts
-function comparePersonas(p1, p2) {
-    const diffs = {};
-    if (p1.name !== p2.name)
-        diffs.name = { from: p1.name, to: p2.name };
-    if (p1.description !== p2.description)
-        diffs.description = "different";
-    if (p1.status !== p2.status)
-        diffs.status = { from: p1.status, to: p2.status };
-    if (p1.template_id !== p2.template_id)
-        diffs.template_id = { from: p1.template_id, to: p2.template_id };
-    // Compare workflows
-    const w1 = p1.workflow_def;
-    const w2 = p2.workflow_def;
-    if (JSON.stringify(w1) !== JSON.stringify(w2)) {
-        diffs.workflow = "different";
-    }
-    return diffs;
-}
-function compareWorkflows(w1, w2) {
-    if (!w1 && !w2)
-        return { equal: true };
-    if (!w1 || !w2)
-        return { equal: false, reason: "one workflow missing" };
-    const actions1 = w1.actions || [];
-    const actions2 = w2.actions || [];
-    return {
-        equal: JSON.stringify(w1) === JSON.stringify(w2),
-        node_count: { before: actions1.length, after: actions2.length },
-    };
-}
-function calculateMetrics(workflow) {
-    const actions = workflow.actions || [];
-    // Helper to get action type from nested structure
-    const getType = (a) => {
-        const action = a.action;
-        if (!action?.name)
-            return "";
-        const nameObj = action.name;
-        if (typeof nameObj === "string")
-            return nameObj;
-        if (typeof nameObj === "object" && "name" in nameObj)
-            return String(nameObj.name || "");
-        return "";
-    };
-    return {
-        node_count: actions.length,
-        has_categorizer: actions.some(a => getType(a).includes("categorizer")),
-        has_hitl: actions.some(a => getType(a) === "general_hitl"),
-        has_external: actions.some(a => getType(a) === "external_action_caller"),
-    };
-}
-/**
- * Apply simple workflow fixes for auto_fixable issues
- * Handles orphan removal with cascading dependency cleanup
- */
-function applySimpleFixes(workflow, issues) {
-    // Deep clone to avoid mutating original
-    const fixed = JSON.parse(JSON.stringify(workflow));
-    // Get nodes array from workflow (handle different structures)
-    const getNodes = (w) => {
-        if (Array.isArray(w.nodes))
-            return w.nodes;
-        const wd = w.workflow_def;
-        if (wd && Array.isArray(wd.nodes))
-            return wd.nodes;
-        return undefined;
-    };
-    const nodes = getNodes(fixed);
-    if (!nodes)
-        return fixed;
-    // Collect all orphan node IDs to remove
-    const nodesToRemove = new Set();
-    for (const issue of issues) {
-        if (issue.type === "orphan" && issue.auto_fixable && issue.node) {
-            nodesToRemove.add(issue.node);
-        }
-    }
-    if (nodesToRemove.size === 0)
-        return fixed;
-    // Step 1: Remove orphan nodes
-    const filteredNodes = nodes.filter(n => {
-        const nodeId = n.id;
-        return nodeId && !nodesToRemove.has(nodeId);
-    });
-    // Step 2: Clean up dangling references in remaining nodes
-    for (const node of filteredNodes) {
-        const incomingEdges = node.incoming_edges;
-        if (incomingEdges && Array.isArray(incomingEdges)) {
-            // Filter out edges that reference removed nodes
-            node.incoming_edges = incomingEdges.filter(edge => {
-                const sourceNodeId = edge.source_node_id;
-                return sourceNodeId && !nodesToRemove.has(sourceNodeId);
-            });
-        }
-        // Also clean up inputBindings if they exist (different workflow format)
-        const inputBindings = node.inputBindings;
-        if (inputBindings && Array.isArray(inputBindings)) {
-            node.inputBindings = inputBindings.filter(binding => {
-                const actionOutput = binding.actionOutput;
-                const actionName = actionOutput?.actionName;
-                return !actionName || !nodesToRemove.has(actionName);
-            });
-        }
-    }
-    // Update nodes in the workflow
-    if (Array.isArray(fixed.nodes)) {
-        fixed.nodes = filteredNodes;
-    }
-    else {
-        const wd = fixed.workflow_def;
-        if (wd) {
-            wd.nodes = filteredNodes;
-        }
-    }
-    return fixed;
-}
+// Re-export the extracted handler for backwards compatibility
+export { handleWorkflow } from "./handlers/workflow/index.js";