@hailer/mcp 1.2.1 → 1.3.10

package/dist/mcp/tools/workflow.js

@@ -6,9 +6,13 @@
  * These are PLAYGROUND tools requiring workspace administrator permissions.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.workflowTools = exports.autoSetKeysTool = exports.updateWorkflowPhaseTool = exports.coreInitTool = exports.countActivitiesTool = exports.listWorkflowsMinimalTool = exports.testFunctionFieldTool = exports.updateWorkflowFieldTool = exports.removeWorkflowTool = exports.installWorkflowTool = exports.listWorkflowsTool = exports.listWorkflowPhasesTool = exports.getWorkflowSchemaTool = void 0;
+exports.workflowTools = exports.autoSetKeysTool = exports.coreInitTool = exports.testFunctionFieldTool = exports.updateWorkflowStructureTool = exports.removeWorkflowTool = exports.installWorkflowTool = exports.describeWorkflowsTool = void 0;
+exports.renderWorkflowListMinimal = renderWorkflowListMinimal;
+exports.renderWorkflowListFull = renderWorkflowListFull;
+exports.renderPhasesSection = renderPhasesSection;
 const zod_1 = require("zod");
 const tool_registry_1 = require("../tool-registry");
+const UserContextCache_1 = require("../UserContextCache");
 const logger_1 = require("../../lib/logger");
 const request_logger_1 = require("../../lib/request-logger");
 const workspace_overview_1 = require("../../bot/workspace-overview");
@@ -34,7 +38,7 @@ function isSdkProject() {
 function sdkRedirect(tool, sdkCommand, sdkFile) {
     return {
         content: [{
-                type: "text",
+                type: 'text',
                 text: `⚠️ **SDK project detected — use the SDK instead of \`${tool}\`**\n\n` +
                     `This project has a \`workspace/\` directory, which means workflow configuration should be managed through SDK files.\n\n` +
                     `**Instead, do this:**\n` +
@@ -96,17 +100,20 @@ function generateKey(name, existingKeys) {
         .replace(/[^a-zA-Z0-9\s-_]/g, '')
         .split(/[\s\-_]+/)
         .filter(w => w.length > 0);
-    if (words.length === 0)
+    if (words.length === 0) {
         return 'unnamed';
+    }
     const base = words[0].toLowerCase() + words.slice(1).map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
     const key = base.slice(0, 64);
-    if (!existingKeys || !existingKeys.has(key))
+    if (!existingKeys || !existingKeys.has(key)) {
         return key;
+    }
     // Dedup: append incrementing suffix
     for (let i = 2; i <= 99; i++) {
         const candidate = `${key}${i}`.slice(0, 64);
-        if (!existingKeys.has(candidate))
+        if (!existingKeys.has(candidate)) {
             return candidate;
+        }
     }
     return `${key}${Date.now()}`.slice(0, 64);
 }
@@ -125,13 +132,15 @@ async function autoSetKeys(workflowId, context) {
     // Collect existing keys to avoid duplicates
     const existingPhaseKeys = new Set();
     for (const phase of Object.values(workflow.phases || {})) {
-        if (phase.key)
+        if (phase.key) {
             existingPhaseKeys.add(phase.key);
+        }
     }
     const existingFieldKeys = new Set();
     for (const field of Object.values(workflow.fields || {})) {
-        if (field.key)
+        if (field.key) {
             existingFieldKeys.add(field.key);
+        }
     }
     // Set workflow key (unique per workspace — no local dedup needed, API rejects duplicates)
     if (!workflow.key && workflow.name) {
@@ -174,338 +183,305 @@ async function autoSetKeys(workflowId, context) {
             }
         }
     }
+    // Invalidate the cached context: field-key validation in create/update_activity
+    // reads cached core.init (15-min TTL) and would reject the keys minted above.
+    UserContextCache_1.UserContextCache.clearContext(context.apiKey);
     return result;
 }
 // ============================================================================
-// READ TOOLS - Workflow Schema and Information
+// READ TOOLS - Workflow Discovery (describe_workflows)
 // ============================================================================
-const getWorkflowSchemaDescription = `Get workflow field structure - CALL THIS BEFORE create_activity or update_activity.
-
-**SDK project?** If workspace/ exists, read field definitions from workspace/<WorkflowName>_<id>/fields.ts instead of calling this tool.
-
-**Hailer Concept:** Shows all fields (columns) in a workflow with their IDs, types, and options. You MUST know field IDs to create or update activities.
-
-**Returns:** Field IDs, labels, types (text, numeric, date, dropdown, user, activitylink), required status, dropdown options.
-
-**Critical:** Never guess field IDs - always get them from this tool first.`;
-exports.getWorkflowSchemaTool = {
-    name: 'get_workflow_schema',
-    group: tool_registry_1.ToolGroup.READ,
-    description: getWorkflowSchemaDescription,
-    schema: zod_1.z.object({
-        workflowId: zod_1.z.string().describe("Workflow ID or key to get schema from"),
-        phaseId: zod_1.z.string().describe("Phase ID or key to get schema from (use list_workflow_phases to get available phases)"),
-        compact: zod_1.z.boolean().optional().describe("Return compact summary instead of full field details (default: false)"),
-        force: zod_1.z.boolean().optional().describe("Override SDK redirect — use API even when workspace/ exists"),
-    }),
-    async execute(args, context) {
-        if (isSdkProject() && !args.force) {
-            return sdkRedirect('get_workflow_schema', 'cat workspace/<WorkflowName>_<id>/fields.ts', 'workspace/<WorkflowName>_<id>/fields.ts');
-        }
-        try {
-            // Use cached workflow data from context.init (already fetched during initialization)
-            const workflow = resolveWorkflow(context.init.processes || [], args.workflowId);
-            if (!workflow) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `❌ Workflow "${args.workflowId}" not found`,
-                        }],
-                };
-            }
-            // Get schema for field validation/requirements (optional, mainly for name field info)
-            const schemaData = await context.hailer.getWorkflowSchema(args.workflowId, args.phaseId);
-            // Get complete field definitions from workflow (includes keys and all metadata)
-            const workflowFields = workflow.fields || {};
-            const fieldsOrder = workflow.fieldsOrder || Object.keys(workflowFields);
-            // Compact mode: brief summary for chat agents WITH field IDs (required for insights)
-            if (args.compact) {
-                const fieldLines = fieldsOrder.map((fieldId) => {
-                    const field = workflowFields[fieldId];
-                    if (!field)
-                        return null;
-                    return `- ${field.label || 'Unnamed'} (${field.type}): fieldId="${fieldId}"`;
-                }).filter(Boolean);
-                return {
-                    content: [{
-                            type: "text",
-                            text: `📋 **${workflow.name}** (workflowId: ${args.workflowId})\n\n**Fields:**\n${fieldLines.join('\n')}`,
-                        }],
-                };
-            }
-            let responseText = (isSdkProject() ? SDK_DISCOVERY_HINT : '') + `📋 **WORKFLOW SCHEMA** for "${workflow.name}":\n\n`;
-            if (schemaData.name) {
-                responseText += `**Name Field:**\n`;
-                responseText += `- Type: ${schemaData.name.type}\n`;
-                responseText += `- Required: ${schemaData.name.required || false}\n`;
-                if (schemaData.name.placeholder) {
-                    responseText += `- Placeholder: "${schemaData.name.placeholder}"\n`;
-                }
-                responseText += `\n`;
-            }
-            // Use fieldsOrder to display fields in correct order
-            if (fieldsOrder.length > 0) {
-                responseText += `**Available Fields (${fieldsOrder.length} total):**\n\n`;
-                fieldsOrder.forEach((fieldId, index) => {
-                    const field = workflowFields[fieldId];
-                    if (!field)
-                        return;
-                    responseText += `${index + 1}. **${field.label || 'Unnamed Field'}**\n`;
-                    responseText += `   - Field ID: \`${fieldId}\`\n`;
-                    if (field.key)
-                        responseText += `   - Key: \`${field.key}\`\n`;
-                    responseText += `   - Type: ${field.type}`;
-                    if (field.subtype)
-                        responseText += ` (${field.subtype})`;
-                    responseText += `\n`;
-                    if (field.required)
-                        responseText += `   - Required: Yes\n`;
-                    if (field.description)
-                        responseText += `   - Description: ${field.description}\n`;
-                    if (field.placeholder)
-                        responseText += `   - Placeholder: "${field.placeholder}"\n`;
-                    if (field.data && field.data.length > 0) {
-                        responseText += `   - Options: ${field.data.slice(0, 3).join(', ')}`;
-                        if (field.data.length > 3)
-                            responseText += ` (and ${field.data.length - 3} more)`;
-                        responseText += `\n`;
-                    }
-                    responseText += `\n`;
+/** Render the minimal workflow list — former list_workflows_minimal output. Exported for tests. */
+function renderWorkflowListMinimal(context) {
+    const workflows = context.init.processes || [];
+    let responseText = (isSdkProject() ? SDK_DISCOVERY_HINT : '') + `📋 **Workflows Found**\n\n`;
+    responseText += `Total: ${workflows.length}\n\n`;
+    workflows.forEach((wf) => {
+        const star = wf.isStarred ? '⭐ ' : '';
+        responseText += `${star}**${wf.name}**\n`;
+        responseText += `  ID: \`${wf._id}\`\n`;
+        responseText += `  Activities: ${wf.createdActivities || 0}\n\n`;
+    });
+    responseText += `\n💡 **Next Steps:**\n`;
+    responseText += `- Use \`describe_workflows\` with a workflowId and include: ['schema'] to see fields\n`;
+    responseText += `- Use \`describe_workflows\` with a workflowId and include: ['phases'] to see phases\n`;
+    return responseText;
+}
+/** Render the full workflow list with ActivityLink relationships — former list_workflows output. Exported for tests. */
+function renderWorkflowListFull(context) {
+    const workflows = context.init.processes || [];
+    const workflowSummary = workflows.map((workflow) => {
+        const activityLinkFields = Object.entries(workflow.fields ?? {})
+            .filter(([, field]) => field.type === 'activitylink');
+        const initialPhases = Object.values(workflow.phases || {})
+            .filter(phase => phase.isInitial)
+            .map(phase => ({
+            id: phase._id,
+            name: phase.name
+        }));
+        // Calculate linksTo from activitylink fields
+        const linksTo = activityLinkFields.flatMap(([, field]) => field.data || []);
+        return {
+            id: workflow._id,
+            name: workflow.name,
+            workspaceId: workflow.cid,
+            activityCount: workflow.createdActivities || 0,
+            isStarred: workflow.isStarred || false,
+            hasActivityLinks: activityLinkFields.length > 0,
+            linksTo,
+            linkedFrom: [], // Would need to scan all workflows - skip for now
+            initialPhases: initialPhases,
+        };
+    });
+    let responseText = `📋 **${workflows.length} Workflows Found**\n\n`;
+    responseText += JSON.stringify(workflowSummary, null, 2);
+    const relationships = [];
+    for (const workflow of workflows) {
+        const activityLinkFields = Object.entries(workflow.fields ?? {})
+            .filter(([, field]) => field.type === 'activitylink')
+            .map(([fieldId, field]) => ({
+            id: fieldId,
+            label: field.label,
+            key: field.key,
+            targetWorkflowIds: field.data || [],
+            required: field.required || false,
+        }));
+        for (const field of activityLinkFields) {
+            for (const targetWorkflowId of field.targetWorkflowIds) {
+                const targetWorkflow = workflows.find((wf) => wf._id === targetWorkflowId);
+                relationships.push({
+                    sourceWorkflowId: workflow._id,
+                    sourceWorkflowName: workflow.name,
+                    targetWorkflowId,
+                    targetWorkflowName: targetWorkflow?.name || 'Unknown',
+                    fieldLabel: field.label,
+                    fieldKey: field.key,
+                    required: field.required,
                 });
             }
-            responseText += `💡 **USAGE:**\n`;
-            responseText += `- Use field IDs (or keys if available) in the 'fields' parameter of list_activities\n`;
-            responseText += `- **Select ONLY 2-3 essential fields** to minimize token costs\n`;
-            const firstFieldId = fieldsOrder[0];
-            const secondFieldId = fieldsOrder[1];
-            const firstFieldKey = firstFieldId && workflowFields[firstFieldId]?.key;
-            const secondFieldKey = secondFieldId && workflowFields[secondFieldId]?.key;
-            if (firstFieldId && secondFieldId) {
-                responseText += `- Example with IDs: fields: ["${firstFieldId}", "${secondFieldId}"] (just 2 fields)\n`;
-                if (firstFieldKey && secondFieldKey) {
-                    responseText += `- Example with keys: fields: ["${firstFieldKey}", "${secondFieldKey}"] (more readable)\n`;
-                }
-            }
-            responseText += `- For listings: name + key metric (price/status) is usually sufficient\n`;
-            responseText += `- Only add description/detail fields when user explicitly needs them`;
-            return {
-                content: [{
-                        type: "text",
-                        text: responseText,
-                    }],
-            };
         }
-        catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Failed to get workflow schema", error);
-            return {
-                content: [{
-                        type: "text",
-                        text: `❌ Failed to get workflow schema: ${error instanceof Error ? error.message : String(error)}`,
-                    }],
-            };
+    }
+    if (relationships.length > 0) {
+        responseText += `\n\n🔗 **Workflow Relationships:**\n`;
+        relationships.forEach(rel => {
+            responseText += `• ${rel.sourceWorkflowName} → ${rel.targetWorkflowName} (${rel.fieldLabel})\n`;
+        });
+    }
+    responseText += `\n\n💡 Use describe_workflows with a specific workflowId for detailed information.`;
+    return responseText;
+}
+/** Render a single-workflow summary — describe_workflows with workflowId and no includes */
+function renderWorkflowSummary(workflow) {
+    const fieldCount = Object.keys(workflow.fields || {}).length;
+    const phaseCount = Object.keys(workflow.phases || {}).length;
+    let responseText = `📋 **${workflow.name}**\n\n`;
+    responseText += `- ID: \`${workflow._id}\`\n`;
+    if (workflow.key) {
+        responseText += `- Key: \`${workflow.key}\`\n`;
+    }
+    responseText += `- Workspace: \`${workflow.cid}\`\n`;
+    responseText += `- Activities: ${workflow.createdActivities || 0}\n`;
+    responseText += `- Fields: ${fieldCount}\n`;
+    responseText += `- Phases: ${phaseCount}\n`;
+    if (workflow.description) {
+        responseText += `- Description: ${workflow.description}\n`;
+    }
+    responseText += `\n💡 Add include: ['schema'] for field IDs, include: ['phases'] for phase IDs.`;
+    return responseText;
+}
+/** Render compact field list — former get_workflow_schema compact mode (default) */
+function renderSchemaCompact(workflow) {
+    const workflowFields = workflow.fields || {};
+    const fieldsOrder = workflow.fieldsOrder || Object.keys(workflowFields);
+    const fieldLines = fieldsOrder.map((fieldId) => {
+        const field = workflowFields[fieldId];
+        if (!field) {
+            return null;
         }
-    },
-};
-const listWorkflowPhasesDescription = `List phases (stages/statuses) in a workflow - REQUIRED to get phase IDs.
-
-**SDK project?** If workspace/ exists, read phases from workspace/<WorkflowName>_<id>/phases.ts instead of calling this tool.
-
-**Hailer Concept:** Phases are stages like "New" → "In Progress" → "Done". Activities move through phases as work progresses.
-
-**When to use:** Before list_activities (need phaseId), before create_activity (need initial phase), before update_activity (to move to new phase).
-
-**Returns:** Phase names, IDs, which phase is initial (for new items), which is endpoint (completed).`;
-exports.listWorkflowPhasesTool = {
-    name: 'list_workflow_phases',
-    group: tool_registry_1.ToolGroup.READ,
-    description: listWorkflowPhasesDescription,
-    schema: zod_1.z.object({
-        workflowId: zod_1.z.string().describe("Workflow ID or key to get phases from"),
-        force: zod_1.z.boolean().optional().describe("Override SDK redirect — use API even when workspace/ exists"),
-    }),
-    async execute(args, context) {
-        if (isSdkProject() && !args.force) {
-            return sdkRedirect('list_workflow_phases', 'cat workspace/<WorkflowName>_<id>/phases.ts', 'workspace/<WorkflowName>_<id>/phases.ts');
+        return `- ${field.label || 'Unnamed'} (${field.type}): fieldId="${fieldId}"`;
+    }).filter(Boolean);
+    return `📋 **${workflow.name}** (workflowId: ${workflow._id})\n\n**Fields:**\n${fieldLines.join('\n')}`;
+}
+/** Render full field details — former get_workflow_schema full mode (detail: 'full') */
+async function renderSchemaFull(workflow, context) {
+    // The per-phase schema endpoint supplies name-field metadata; default to the initial phase
+    const phaseList = Object.values(workflow.phases || {});
+    const schemaPhase = phaseList.find(ph => ph.isInitial) || phaseList[0];
+    const schemaData = schemaPhase ? await context.hailer.getWorkflowSchema(workflow._id, schemaPhase._id) : {};
+    // Get complete field definitions from workflow (includes keys and all metadata)
+    const workflowFields = workflow.fields || {};
+    const fieldsOrder = workflow.fieldsOrder || Object.keys(workflowFields);
+    let responseText = `📋 **WORKFLOW SCHEMA** for "${workflow.name}":\n\n`;
+    if (schemaData.name) {
+        responseText += `**Name Field:**\n`;
+        responseText += `- Type: ${schemaData.name.type}\n`;
+        responseText += `- Required: ${schemaData.name.required || false}\n`;
+        responseText += schemaData.name.placeholder ? `- Placeholder: "${schemaData.name.placeholder}"\n` : '';
+        responseText += `\n`;
+    }
+    // Use fieldsOrder to display fields in correct order
+    if (fieldsOrder.length > 0) {
+        responseText += `**Available Fields (${fieldsOrder.length} total):**\n\n`;
+    }
+    fieldsOrder.forEach((fieldId, index) => {
+        const field = workflowFields[fieldId];
+        if (!field) {
+            return;
         }
-        try {
-            // Use cached workflow data from context.init (already fetched during initialization)
-            const workflowData = resolveWorkflow(context.init.processes || [], args.workflowId);
-            if (!workflowData) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `❌ Workflow "${args.workflowId}" not found`,
-                        }],
-                };
-            }
-            const phases = workflowData.phases || {};
-            const phasesOrder = workflowData.phasesOrder || [];
-            let responseText = (isSdkProject() ? SDK_DISCOVERY_HINT : '') + `📊 **WORKFLOW PHASES** for "${workflowData.name}":\n\n`;
-            if (Object.keys(phases).length === 0) {
-                responseText += `❌ No phases found in workflow "${workflowData.name}".`;
-                return {
-                    content: [{ type: "text", text: responseText }],
-                };
-            }
-            responseText += `Found ${Object.keys(phases).length} phases:\n\n`;
-            const orderedPhaseIds = phasesOrder.length > 0 ? phasesOrder : Object.keys(phases);
-            orderedPhaseIds.forEach((phaseId, index) => {
-                const phase = phases[phaseId];
-                if (phase) {
-                    responseText += `${index + 1}. **${phase.name}**\n`;
-                    responseText += `   - Phase ID: \`${phase._id}\`\n`;
-                    if (phase.key) {
-                        responseText += `   - Key: \`${phase.key}\`\n`;
-                    }
-                    if (phase.description) {
-                        responseText += `   - Description: ${phase.description}\n`;
-                    }
-                    if (phase.color) {
-                        responseText += `   - Color: ${phase.color}\n`;
-                    }
-                    if (phase.isInitial) {
-                        responseText += `   - Initial Phase: Yes\n`;
-                    }
-                    if (phase.isEndpoint) {
-                        responseText += `   - Endpoint Phase: Yes\n`;
-                    }
-                    responseText += `\n`;
-                }
-            });
-            responseText += `💡 **USAGE:** Use any of these Phase IDs with the \`list_activities\` tool to get activities in that phase.\n\n`;
-            responseText += `🔍 **FOR COMPREHENSIVE WORKFLOW VIEW:**\n`;
-            responseText += `- To see ALL activities across the entire workflow, call \`list_activities\` for each phase ID above\n`;
-            responseText += `- Each phase contains different activities at different stages of the workflow\n`;
-            responseText += `- Combine results from all phases to get the complete picture of the workflow\n`;
-            responseText += `\n**Example workflow:**\n`;
-            responseText += `1. First call: \`list_activities\` with first phase ID to see new/pending activities\n`;
-            responseText += `2. Second call: \`list_activities\` with second phase ID to see completed activities\n`;
-            responseText += `3. Continue for all phases to see the full workflow status`;
-            return {
-                content: [{
-                        type: "text",
-                        text: responseText,
-                    }],
-            };
+        responseText += `${index + 1}. **${field.label || 'Unnamed Field'}**\n`;
+        responseText += `   - Field ID: \`${fieldId}\`\n`;
+        if (field.key) {
+            responseText += `   - Key: \`${field.key}\`\n`;
         }
-        catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Failed to list workflow phases", error);
-            return {
-                content: [{
-                        type: "text",
-                        text: `❌ Failed to list workflow phases: ${error instanceof Error ? error.message : String(error)}`,
-                    }],
-            };
+        responseText += `   - Type: ${field.type}`;
+        if (field.subtype) {
+            responseText += ` (${field.subtype})`;
         }
-    },
-};
-const listWorkflowsDescription = `List workflows (processes/pipelines) in the Hailer workspace.
-
-**Hailer Concept:** A Workflow is like a database table or Kanban board - it defines a process with fields (columns) and phases (stages). Examples: "Sales Pipeline", "Customer Database", "Project Tasks".
-
-**When to use:** To see all available workflows, find workflow IDs, or understand the workspace structure.
-
-**Returns:** Workflow names, IDs, activity counts, and relationships between workflows.
-
-**Next steps:** Use \`list_workflow_phases\` to see stages, then \`get_workflow_schema\` for field structure.`;
-exports.listWorkflowsTool = {
-    name: 'list_workflows',
+        responseText += `\n`;
+        if (field.required) {
+            responseText += `   - Required: Yes\n`;
+        }
+        if (field.description) {
+            responseText += `   - Description: ${field.description}\n`;
+        }
+        if (field.placeholder) {
+            responseText += `   - Placeholder: "${field.placeholder}"\n`;
+        }
+        if (field.data && field.data.length > 0) {
+            const extraOptions = field.data.length > 3 ? ` (and ${field.data.length - 3} more)` : '';
+            responseText += `   - Options: ${field.data.slice(0, 3).join(', ')}${extraOptions}\n`;
+        }
+        responseText += `\n`;
+    });
+    responseText += `💡 **USAGE:**\n`;
+    responseText += `- Use field IDs (or keys if available) in the 'fields' parameter of list_activities\n`;
+    responseText += `- **Select ONLY 2-3 essential fields** to minimize token costs\n`;
+    const firstFieldId = fieldsOrder[0];
+    const secondFieldId = fieldsOrder[1];
+    const firstFieldKey = firstFieldId && workflowFields[firstFieldId]?.key;
+    const secondFieldKey = secondFieldId && workflowFields[secondFieldId]?.key;
+    if (firstFieldId && secondFieldId) {
+        responseText += `- Example with IDs: fields: ["${firstFieldId}", "${secondFieldId}"] (just 2 fields)\n`;
+    }
+    if (firstFieldId && secondFieldId && firstFieldKey && secondFieldKey) {
+        responseText += `- Example with keys: fields: ["${firstFieldKey}", "${secondFieldKey}"] (more readable)\n`;
+    }
+    responseText += `- For listings: name + key metric (price/status) is usually sufficient\n`;
+    responseText += `- Only add description/detail fields when user explicitly needs them`;
+    return responseText;
+}
+/** Render the phase list — former list_workflow_phases output. Exported for tests. */
+function renderPhasesSection(workflow) {
+    const phases = workflow.phases || {};
+    const phasesOrder = workflow.phasesOrder || [];
+    let responseText = `📊 **WORKFLOW PHASES** for "${workflow.name}":\n\n`;
+    if (Object.keys(phases).length === 0) {
+        responseText += `❌ No phases found in workflow "${workflow.name}".`;
+        return responseText;
+    }
+    responseText += `Found ${Object.keys(phases).length} phases:\n\n`;
+    const orderedPhaseIds = phasesOrder.length > 0 ? phasesOrder : Object.keys(phases);
+    orderedPhaseIds.forEach((phaseId, index) => {
+        const phase = phases[phaseId];
+        if (!phase) {
+            return;
+        }
+        responseText += `${index + 1}. **${phase.name}**\n`;
+        responseText += `   - Phase ID: \`${phase._id}\`\n`;
+        if (phase.key) {
+            responseText += `   - Key: \`${phase.key}\`\n`;
+        }
+        if (phase.description) {
+            responseText += `   - Description: ${phase.description}\n`;
+        }
+        if (phase.color) {
+            responseText += `   - Color: ${phase.color}\n`;
+        }
+        if (phase.isInitial) {
+            responseText += `   - Initial Phase: Yes\n`;
+        }
+        if (phase.isEndpoint) {
+            responseText += `   - Endpoint Phase: Yes\n`;
+        }
+        responseText += `\n`;
+    });
+    responseText += `💡 **USAGE:** Use any of these Phase IDs with the \`list_activities\` tool to get activities in that phase.\n\n`;
+    responseText += `🔍 **FOR COMPREHENSIVE WORKFLOW VIEW:**\n`;
+    responseText += `- To see ALL activities across the entire workflow, call \`list_activities\` for each phase ID above\n`;
+    responseText += `- Each phase contains different activities at different stages of the workflow\n`;
+    responseText += `- Combine results from all phases to get the complete picture of the workflow`;
+    return responseText;
+}
+const describeWorkflowsDescription = `Discover workflows. Modes: (1) no args → list all workflows (IDs, names, activity counts); detail:'full' adds ActivityLink relationships. (2) workflowId → that workflow's summary. (3) workflowId + include:['schema','phases'] → field IDs/types/options and/or phase IDs/flags; detail:'full' expands schema to full field details. Never guess IDs — call this before create_activity, update_activity, or list_activities.`;
+const describeWorkflowsSchema = zod_1.z.object({
+    workflowId: zod_1.z.string().optional().describe('Workflow ID (24-char) or key. Omit to list all workflows'),
+    include: zod_1.z
+        .array(zod_1.z.enum(['schema', 'phases']))
+        .optional()
+        .describe("Sections to include when workflowId is given: 'schema' = fields, 'phases' = phases. Both can be combined"),
+    detail: zod_1.z
+        .enum(['minimal', 'full'])
+        .optional()
+        .default('minimal')
+        .describe("'full' adds relationships to the workflow list and complete field details to the schema (default: 'minimal')"),
+    force: zod_1.z.boolean().optional().describe('Override SDK redirect — use API even when workspace/ exists'),
+});
+exports.describeWorkflowsTool = {
+    name: 'describe_workflows',
     group: tool_registry_1.ToolGroup.READ,
-    description: listWorkflowsDescription,
-    schema: zod_1.z.object({
-        workspace: zod_1.z.string().optional().describe("Optional workspace ID or name"),
-        includeRelationships: zod_1.z.coerce.boolean().optional().default(true).describe("Show ActivityLink relationships between workflows"),
-    }),
+    description: describeWorkflowsDescription,
+    schema: describeWorkflowsSchema,
     async execute(args, context) {
-        logger.debug('Listing workflows', {
+        logger.debug('Describing workflows', {
+            workflowId: args.workflowId,
+            include: args.include,
+            detail: args.detail,
             apiKey: context.apiKey.substring(0, 8) + '...'
         });
         try {
-            // Use cached workflows from context.init (already fetched during initialization)
-            let workflows = context.init.processes || [];
-            if (args.workspace) {
-                // Filter by workspace ID or name
-                const workspaceFilter = args.workspace;
-                workflows = workflows.filter(w => w.cid === workspaceFilter ||
-                    w.cid === workspaceFilter // Could add name-based lookup here if needed
-                );
+            // Mode 1: no workflowId → list all workflows
+            if (!args.workflowId) {
+                const text = args.detail === 'full' ? renderWorkflowListFull(context) : renderWorkflowListMinimal(context);
+                return { content: [{ type: 'text', text }] };
             }
-            const workflowSummary = workflows.map((workflow) => {
-                const activityLinkFields = Object.entries(workflow.fields ?? {})
-                    .filter(([_, field]) => field.type === 'activitylink');
-                const initialPhases = Object.values(workflow.phases || {})
-                    .filter(phase => phase.isInitial)
-                    .map(phase => ({
-                    id: phase._id,
-                    name: phase.name
-                }));
-                // Calculate linksTo from activitylink fields
-                const linksTo = activityLinkFields.flatMap(([_, field]) => field.data || []);
+            const workflow = resolveWorkflow(context.init.processes || [], args.workflowId);
+            if (!workflow) {
                 return {
-                    id: workflow._id,
-                    name: workflow.name,
-                    workspaceId: workflow.cid,
-                    activityCount: workflow.createdActivities || 0,
-                    isStarred: workflow.isStarred || false,
-                    hasActivityLinks: activityLinkFields.length > 0,
-                    linksTo,
-                    linkedFrom: [], // Would need to scan all workflows - skip for now
-                    initialPhases: initialPhases,
+                    content: [{
+                            type: 'text',
+                            text: `❌ Workflow "${args.workflowId}" not found`,
+                        }],
                 };
-            });
-            let responseText = `📋 **${workflows.length} Workflows Found**\n\n`;
-            responseText += JSON.stringify(workflowSummary, null, 2);
-            if (args.includeRelationships) {
-                const relationships = [];
-                for (const workflow of workflows) {
-                    const activityLinkFields = Object.entries(workflow.fields ?? {})
-                        .filter(([_, field]) => field.type === 'activitylink')
-                        .map(([fieldId, field]) => ({
-                        id: fieldId,
-                        label: field.label,
-                        key: field.key,
-                        targetWorkflowIds: field.data || [],
-                        required: field.required || false,
-                    }));
-                    for (const field of activityLinkFields) {
-                        for (const targetWorkflowId of field.targetWorkflowIds) {
-                            const targetWorkflow = workflows.find(w => w._id === targetWorkflowId);
-                            relationships.push({
-                                sourceWorkflowId: workflow._id,
-                                sourceWorkflowName: workflow.name,
-                                targetWorkflowId,
-                                targetWorkflowName: targetWorkflow?.name || 'Unknown',
-                                fieldLabel: field.label,
-                                fieldKey: field.key,
-                                required: field.required,
-                            });
-                        }
-                    }
-                }
-                if (relationships.length > 0) {
-                    responseText += `\n\n🔗 **Workflow Relationships:**\n`;
-                    relationships.forEach(rel => {
-                        responseText += `• ${rel.sourceWorkflowName} → ${rel.targetWorkflowName} (${rel.fieldLabel})\n`;
-                    });
-                }
             }
-            responseText += `\n\n💡 Use get_workflow_info with specific workflow ID for detailed information.`;
-            return {
-                content: [{
-                        type: "text",
-                        text: responseText,
-                    }],
-            };
+            const include = args.include || [];
+            // Mode 2: workflowId without includes → summary
+            if (include.length === 0) {
+                const prefix = isSdkProject() ? SDK_DISCOVERY_HINT : '';
+                return { content: [{ type: 'text', text: prefix + renderWorkflowSummary(workflow) }] };
+            }
+            // Mode 3: workflowId + includes → schema and/or phases deep dive
+            if (isSdkProject() && !args.force) {
+                return sdkRedirect('describe_workflows', 'cat workspace/<WorkflowName>_<id>/fields.ts workspace/<WorkflowName>_<id>/phases.ts', 'workspace/<WorkflowName>_<id>/');
+            }
+            const sections = [];
+            if (include.includes('schema')) {
+                const schemaText = args.detail === 'full' ? await renderSchemaFull(workflow, context) : renderSchemaCompact(workflow);
+                sections.push(schemaText);
+            }
+            if (include.includes('phases')) {
+                sections.push(renderPhasesSection(workflow));
+            }
+            const prefix = isSdkProject() ? SDK_DISCOVERY_HINT : '';
+            return { content: [{ type: 'text', text: prefix + sections.join('\n\n') }] };
         }
         catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Error listing workflows", error);
+            if (!request_logger_1.RequestLogger.getCurrent()) {
+                logger.error('Failed to describe workflows', error);
+            }
             return {
                 content: [{
-                        type: "text",
-                        text: `❌ Error listing workflows: ${error instanceof Error ? error.message : String(error)}`,
+                        type: 'text',
+                        text: `❌ Failed to describe workflows: ${error instanceof Error ? error.message : String(error)}`,
                     }],
             };
         }
@@ -519,60 +495,67 @@ exports.listWorkflowsTool = {
 // ============================================================================
 const installWorkflowDescription = `Install workflow from template
 
-**Field types:** text, textarea, numeric, numericunit, date, datetime, textpredefinedoptions (for dropdowns - NOT 'select'!), activitylink, users, teams, country, subheader`;
+**Field types:** text, textarea, numeric, numericunit, date, datetime, textpredefinedoptions (for dropdowns - NOT 'select'!), activitylink, users, teams, country, subheader
+
+**Workflow vs dataset — pick the right shape:**
+- A WORKFLOW is for things with a lifecycle (sales pipeline, project tracker, support tickets) — model with multiple phases the activity moves through.
+- A DATASET is for reference data (customer list, product catalog, equipment register, vendor list) — items don't move through stages, they sit in categories. Model with a SINGLE phase (\`isInitial: true\`), or at most two (e.g. Active/Archived). Don't create rich multi-phase workflows for reference data — the user will end up with a kanban they never use.
+- When the user's request is ambiguous ('customer list', 'projects'), ask them once whether they want stages or just a list before committing.
+
+**IMPORTANT — do NOT include real Mongo ObjectId-shaped \`_id\` values anywhere in the template (workflow, fields, or phases).** The server assigns those itself. The only \`_id\` values allowed are template-local references like \`_0001\` (workflow), \`_1000\` (fields), \`_2000\` (phases). Including a 24-hex-char ObjectId can crash Hailer's bulk insert with a duplicate-key error; any such values are stripped before send as a safety net.`;
 const installWorkflowSchema = zod_1.z.object({
     workspaceId: zod_1.z
         .string()
         .optional()
-        .describe("Optional workspace ID or name - defaults to current workspace"),
+        .describe('Optional workspace ID or name - defaults to current workspace'),
     workflowTemplates: zod_1.z
         .array(zod_1.z.object({
         _id: zod_1.z
             .string()
-            .regex(/^_\d{4}$/, "Workflow _id must match pattern _0001, _0002, etc. (underscore + 4 digits)")
+            .regex(/^_\d{4}$/, 'Workflow _id must match pattern _0001, _0002, etc. (underscore + 4 digits)')
             .optional()
             .describe("Workflow _id for cross-references in activitylink fields (e.g., '_0001', '_0002')"),
-        name: zod_1.z.string().min(1).describe("Workflow name"),
-        description: zod_1.z.string().optional().describe("Workflow description"),
+        name: zod_1.z.string().min(1).describe('Workflow name'),
+        description: zod_1.z.string().optional().describe('Workflow description'),
         fields: zod_1.z
             .record(zod_1.z.object({
-            label: zod_1.z.string().describe("Field label shown in UI"),
+            label: zod_1.z.string().describe('Field label shown in UI'),
             type: zod_1.z.enum([
                 'activitylink', 'country', 'teams', 'text', 'textarea', 'textunit',
                 'textpredefinedoptions', 'users', 'numeric', 'numericunit', 'date',
                 'time', 'datetime', 'daterange', 'timerange', 'datetimerange', 'subheader'
-            ]).describe("Field type"),
-            key: zod_1.z.string().optional().describe("Readable field name (like SQL column name) - RECOMMENDED"),
-            required: zod_1.z.boolean().optional().describe("Whether field is required"),
+            ]).describe('Field type'),
+            key: zod_1.z.string().optional().describe('Readable field name (like SQL column name) - RECOMMENDED'),
+            required: zod_1.z.boolean().optional().describe('Whether field is required'),
             data: zod_1.z.array(zod_1.z.string()).optional().describe("For textpredefinedoptions: string array like [\"Low\", \"Medium\", \"High\"]. For activitylink: target workflow IDs. NOTE: 'options' also accepted, will be converted to 'data'"),
-            placeholder: zod_1.z.string().optional().describe("Placeholder text"),
-            unit: zod_1.z.string().optional().describe("Unit for numeric/textunit fields"),
-            description: zod_1.z.string().optional().describe("Field description"),
-            editable: zod_1.z.boolean().optional().describe("Whether field is editable"),
+            placeholder: zod_1.z.string().optional().describe('Placeholder text'),
+            unit: zod_1.z.string().optional().describe('Unit for numeric/textunit fields'),
+            description: zod_1.z.string().optional().describe('Field description'),
+            editable: zod_1.z.boolean().optional().describe('Whether field is editable'),
         }).passthrough())
             .optional()
-            .refine((fields) => !fields || Object.keys(fields).every(id => /^_\d{4}$/.test(id)), { message: "Field IDs must match pattern _1000, _1001, etc. (underscore + 4 digits)" })
-            .describe("Field definitions keyed by field ID (_1000, _1001, etc.)"),
+            .refine((fields) => !fields || Object.keys(fields).every(id => /^_\d{4}$/.test(id)), { message: 'Field IDs must match pattern _1000, _1001, etc. (underscore + 4 digits)' })
+            .describe('Field definitions keyed by field ID (_1000, _1001, etc.)'),
         phases: zod_1.z
             .record(zod_1.z.object({
-            name: zod_1.z.string().describe("Phase name"),
-            isInitial: zod_1.z.boolean().optional().describe("Whether activities can be created in this phase"),
-            fields: zod_1.z.array(zod_1.z.string()).optional().describe("Field IDs visible in this phase (defaults to all)"),
-            description: zod_1.z.string().optional().describe("Phase description"),
+            name: zod_1.z.string().describe('Phase name'),
+            isInitial: zod_1.z.boolean().optional().describe('Whether activities can be created in this phase'),
+            fields: zod_1.z.array(zod_1.z.string()).optional().describe('Field IDs visible in this phase (defaults to all)'),
+            description: zod_1.z.string().optional().describe('Phase description'),
         }).passthrough())
             .optional()
-            .refine((phases) => !phases || Object.keys(phases).every(id => /^_\d{4}$/.test(id)), { message: "Phase IDs must match pattern _2000, _2001, etc. (underscore + 4 digits)" })
-            .describe("Phase definitions keyed by phase ID (_2000, _2001, etc.)"),
-        fieldsOrder: zod_1.z.array(zod_1.z.string()).optional().describe("Order of field IDs (auto-generated if omitted)"),
-        phasesOrder: zod_1.z.array(zod_1.z.string()).optional().describe("Order of phase IDs (auto-generated if omitted)"),
-        enableMessenger: zod_1.z.boolean().optional().describe("Enable discussion features (defaults to true)"),
-        enableLinkedAnnouncements: zod_1.z.boolean().optional().describe("Enable announcements (defaults to true)"),
-        defaultView: zod_1.z.enum(['timeline', 'table', 'kanban', 'calendar', 'map']).optional().describe("Default view type"),
+            .refine((phases) => !phases || Object.keys(phases).every(id => /^_\d{4}$/.test(id)), { message: 'Phase IDs must match pattern _2000, _2001, etc. (underscore + 4 digits)' })
+            .describe('Phase definitions keyed by phase ID (_2000, _2001, etc.)'),
+        fieldsOrder: zod_1.z.array(zod_1.z.string()).optional().describe('Order of field IDs (auto-generated if omitted)'),
+        phasesOrder: zod_1.z.array(zod_1.z.string()).optional().describe('Order of phase IDs (auto-generated if omitted)'),
+        enableMessenger: zod_1.z.boolean().optional().describe('Enable discussion features (defaults to true)'),
+        enableLinkedAnnouncements: zod_1.z.boolean().optional().describe('Enable announcements (defaults to true)'),
+        defaultView: zod_1.z.enum(['timeline', 'table', 'kanban', 'calendar', 'map']).optional().describe('Default view type'),
     }).passthrough())
-        .min(1, "At least one workflow template is required")
-        .max(100, "Maximum 100 workflow templates per installation")
-        .describe("Array of workflow template objects to install"),
-    force: zod_1.z.boolean().optional().describe("Override SDK redirect — use API directly even when workspace/ exists"),
+        .min(1, 'At least one workflow template is required')
+        .max(100, 'Maximum 100 workflow templates per installation')
+        .describe('Array of workflow template objects to install'),
+    force: zod_1.z.boolean().optional().describe('Override SDK redirect — use API directly even when workspace/ exists'),
 });
 exports.installWorkflowTool = {
     name: 'install_workflow',
@@ -597,14 +580,70 @@ exports.installWorkflowTool = {
             if (!workspaceId) {
                 return {
                     content: [{
-                            type: "text",
+                            type: 'text',
                             text: `❌ Could not resolve workspace`,
                         }],
                 };
             }
+            // LLMs occasionally invent 24-hex-char ObjectIds that look real
+            // and stuff them into `_id` slots. Hailer's server-side install
+            // path inserts these verbatim via bulkWrite, and a colliding
+            // value crashes the API with `MongoBulkWriteError: E11000
+            // duplicate key error`. Strip any `_id` that isn't a
+            // template-local reference (`_NNNN`) here as a safety net.
+            const TEMPLATE_LOCAL_ID_RE = /^_\d{4}$/;
+            const stripBadId = (obj, kind) => {
+                if (obj && typeof obj === 'object' && '_id' in obj) {
+                    const id = obj._id;
+                    if (typeof id !== 'string' || !TEMPLATE_LOCAL_ID_RE.test(id)) {
+                        logger.warn(`install_workflow: stripped non-template ${kind} _id from payload`, { strippedId: id });
+                        delete obj._id;
+                    }
+                }
+            };
+            // Track template-local workflow `_id`s used in this call so we can
+            // hand out a unique one to every workflow that doesn't already have
+            // a usable id. Why this exists:
+            //
+            // hailer-api's `WorkflowV3.prepareProcessTemplate` hardcodes any
+            // missing workflow `_id` to the sentinel `'_9999'`, then
+            // `Company.instanceFromTemplate` rewrites `_NNNN` value-strings to
+            // freshly-generated ObjectIds via an `idsMap` that's SHARED across
+            // all processes in one call. Two workflows without an `_id` both
+            // get `'_9999'`, both map to the same ObjectId, and the bulk
+            // insert crashes with `E11000 duplicate key error` on process._id.
+            //
+            // Assigning a unique `_0NNN` template-local here side-steps the
+            // upstream collision entirely — each workflow ends up with a
+            // distinct ObjectId. The result map still returns `_0NNN → real id`
+            // so the caller (and the workflow-id extraction below) keep working.
+            const usedWorkflowIds = new Set();
+            let workflowIdCounter = 0;
+            const nextWorkflowId = () => {
+                let id;
+                do {
+                    id = '_' + String(workflowIdCounter++).padStart(4, '0');
+                } while (usedWorkflowIds.has(id));
+                usedWorkflowIds.add(id);
+                return id;
+            };
             // Transform templates: fix common LLM mistakes
             const transformedTemplates = args.workflowTemplates.map((template) => {
-                let result = { ...template };
+                const result = { ...template };
+                stripBadId(result, 'workflow');
+                // Ensure each workflow has a unique template-local `_id` in
+                // this call. See block comment above for the hailer-api bug
+                // this works around.
+                const existingId = result._id;
+                if (typeof existingId === 'string' && TEMPLATE_LOCAL_ID_RE.test(existingId) && !usedWorkflowIds.has(existingId)) {
+                    usedWorkflowIds.add(existingId);
+                }
+                else {
+                    if (existingId !== undefined) {
+                        logger.warn('install_workflow: duplicate or invalid workflow template _id — reassigning', { existingId });
+                    }
+                    result._id = nextWorkflowId();
+                }
                 // Transform fields
                 if (template.fields) {
                     const transformedFields = {};
@@ -632,6 +671,7 @@ exports.installWorkflowTool = {
                         delete f.name; // Only 'label' is allowed
                         delete f.sequence; // Not supported
                         delete f.order; // Not supported
+                        stripBadId(f, 'field');
                         transformedFields[fieldId] = f;
                     }
                     result.fields = transformedFields;
@@ -643,6 +683,7 @@ exports.installWorkflowTool = {
                         const p = { ...phase };
                         delete p.sequence;
                         delete p.order;
+                        stripBadId(p, 'phase');
                         transformedPhases[phaseId] = p;
                     }
                     result.phases = transformedPhases;
@@ -682,8 +723,9 @@ exports.installWorkflowTool = {
             // Fallback: if no _0xxx pattern, take all values that look like workflow IDs
             if (newWorkflowIds.length === 0) {
                 for (const [, id] of Object.entries(result)) {
-                    if (id.length === 24)
+                    if (id.length === 24) {
                         newWorkflowIds.push(id);
+                    }
                     break; // Just take the first one
                 }
             }
@@ -724,7 +766,7 @@ exports.installWorkflowTool = {
             let responseText = `✅ **Workflow "${templates[0]?.name || 'Unknown'}" Created**\n\n`;
             // MOST IMPORTANT - Workflow ID for create_activity
             responseText += `**🎯 WORKFLOW ID (use this for create_activity):**\n`;
-            responseText += `\`${workflowIds[0] || 'check list_workflows'}\`\n\n`;
+            responseText += `\`${workflowIds[0] || 'check describe_workflows'}\`\n\n`;
             // Field IDs
             if (Object.keys(fieldIds).length > 0) {
                 responseText += `**📋 Field IDs:**\n`;
@@ -749,12 +791,15 @@ exports.installWorkflowTool = {
             if (keyResults.length > 0) {
                 const kr = keyResults[0].keys;
                 responseText += `**🔑 Auto-generated keys:**\n`;
-                if (kr.workflow)
+                if (kr.workflow) {
                     responseText += `- Workflow: \`${kr.workflow}\`\n`;
-                for (const [, key] of Object.entries(kr.phases))
+                }
+                for (const [, key] of Object.entries(kr.phases)) {
                     responseText += `- Phase: \`${key}\`\n`;
-                for (const [, key] of Object.entries(kr.fields))
+                }
+                for (const [, key] of Object.entries(kr.fields)) {
                     responseText += `- Field: \`${key}\`\n`;
+                }
                 if (kr.errors.length > 0) {
                     responseText += `- ⚠️ ${kr.errors.length} key(s) failed\n`;
                 }
@@ -770,35 +815,38 @@ exports.installWorkflowTool = {
             responseText += `{\n`;
             responseText += `  "workflowId": "${exampleWorkflow}",\n`;
             responseText += `  "name": "New Activity",\n`;
-            if (examplePhase)
+            if (examplePhase) {
                 responseText += `  "phaseId": "${examplePhase}",\n`;
-            if (exampleField)
+            }
+            if (exampleField) {
                 responseText += `  "fields": { "${exampleField}": "value" }\n`;
+            }
             responseText += `}\n`;
             responseText += `\`\`\``;
             return {
                 content: [{
-                        type: "text",
+                        type: 'text',
                         text: responseText,
                     }],
             };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Error installing workflow", new Error(errorMessage));
+            if (!request_logger_1.RequestLogger.getCurrent()) {
+                logger.error('Error installing workflow', new Error(errorMessage));
+            }
             // Handle permission errors
             if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied')) {
                 return {
                     content: [{
-                            type: "text",
+                            type: 'text',
                             text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to install workflows.\n\n**Error:** ${errorMessage}`,
                         }],
                 };
             }
             return {
                 content: [{
-                        type: "text",
+                        type: 'text',
                         text: `❌ **Error installing workflow**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Templates must have valid structure (name, fields, phases)\n- Field/Phase IDs must match pattern _0001, _1000, _2000 (underscore + 4 digits)\n- Workspace ID must be valid`,
                     }],
             };
@@ -812,20 +860,20 @@ const removeWorkflowDescription = `Delete workflow permanently`;
 const removeWorkflowSchema = zod_1.z.object({
     workflowId: zod_1.z
         .string()
-        .min(1, "Workflow ID is required")
-        .describe("The workflow ID or key to remove (get from list_workflows)"),
+        .min(1, 'Workflow ID is required')
+        .describe('The workflow ID or key to remove (get from describe_workflows)'),
     workspaceId: zod_1.z
         .string()
         .optional()
-        .describe("Optional workspace ID or name - defaults to current workspace"),
+        .describe('Optional workspace ID or name - defaults to current workspace'),
     confirmed: zod_1.z
         .boolean()
         .optional()
-        .describe("First confirmation - must be true to proceed"),
+        .describe('First confirmation - must be true to proceed'),
     secondConfirmed: zod_1.z
         .boolean()
         .optional()
-        .describe("Second confirmation - must be true to proceed (required for double-check safety)"),
+        .describe('Second confirmation - must be true to proceed (required for double-check safety)'),
 });
 exports.removeWorkflowTool = {
     name: 'remove_workflow',
@@ -845,7 +893,7 @@ exports.removeWorkflowTool = {
             if (!workflow) {
                 return {
                     content: [{
-                            type: "text",
+                            type: 'text',
                             text: `❌ Workflow "${args.workflowId}" not found`,
                         }],
                 };
@@ -879,11 +927,11 @@ exports.removeWorkflowTool = {
                 warningText += `💡 **Before proceeding:**\n`;
                 warningText += `- Load \`remove-workflow-skill\` to review safety checklist\n`;
                 warningText += `- Export data if needed (\`list_activities\`)\n`;
-                warningText += `- Check for dependencies (\`list_workflows\`)\n`;
+                warningText += `- Check for dependencies (\`describe_workflows\` detail:'full')\n`;
                 warningText += `- Verify with user that this is intentional`;
                 return {
                     content: [{
-                            type: "text",
+                            type: 'text',
                             text: warningText,
                         }],
                 };
@@ -902,29 +950,33 @@ exports.removeWorkflowTool = {
                 workspaceId,
                 workspaceName
             });
+            // Invalidate the cached context so the removed workflow disappears
+            // from listings and validation immediately (cached core.init, 15-min TTL).
+            UserContextCache_1.UserContextCache.clearContext(context.apiKey);
             // Build success response
             let responseText = `✅ **Workflow Removed Successfully**\n\n`;
             responseText += `**Workflow:** ${workflowName}\n`;
             responseText += `**Workflow ID:** \`${args.workflowId}\`\n`;
             responseText += `**Workspace:** ${workspaceName} (\`${workspaceId}\`)\n\n`;
             responseText += `⚠️ **All activities and discussions in this workflow have been permanently deleted.**\n\n`;
-            responseText += `💡 Use \`list_workflows\` to see remaining workflows in the workspace.`;
+            responseText += `💡 Use \`describe_workflows\` to see remaining workflows in the workspace.`;
             return {
                 content: [{
-                        type: "text",
+                        type: 'text',
                         text: responseText,
                     }],
             };
         }
         catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Error removing workflow", error);
+            if (!request_logger_1.RequestLogger.getCurrent()) {
+                logger.error('Error removing workflow', error);
+            }
             const errorMessage = error instanceof Error ? error.message : String(error);
             // Handle permission errors
             if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied') || errorMessage.includes('permission')) {
                 return {
                     content: [{
-                            type: "text",
+                            type: 'text',
                             text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to remove workflows.\n\n**Error:** ${errorMessage}`,
                         }],
                 };
@@ -933,14 +985,14 @@ exports.removeWorkflowTool = {
             if (errorMessage.includes('not found') || errorMessage.includes('NotFound')) {
                 return {
                     content: [{
-                            type: "text",
-                            text: `❌ **Workflow Not Found**\n\nThe specified workflow does not exist or you don't have access to it.\n\n**Workflow ID:** \`${args.workflowId}\`\n\n**Error:** ${errorMessage}\n\n💡 Use \`list_workflows\` to see available workflows.`,
+                            type: 'text',
+                            text: `❌ **Workflow Not Found**\n\nThe specified workflow does not exist or you don't have access to it.\n\n**Workflow ID:** \`${args.workflowId}\`\n\n**Error:** ${errorMessage}\n\n💡 Use \`describe_workflows\` to see available workflows.`,
                         }],
                 };
             }
             return {
                 content: [{
-                        type: "text",
+                        type: 'text',
                         text: `❌ **Error removing workflow**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Workflow ID must be valid and exist in the workspace\n- Workflow must not be referenced by other workflows (check ActivityLinks)`,
                     }],
             };
@@ -948,142 +1000,415 @@ exports.removeWorkflowTool = {
     }
 };
 // ============================================================================
-// TOOL 3: UPDATE WORKFLOW FIELD
+// TOOL 3: UPDATE WORKFLOW STRUCTURE (create/update fields and phases)
 // ============================================================================
-const updateWorkflowFieldDescription = `Update workflow field properties. Field type cannot be changed after creation. Load \`sdk-ws-config-skill\` for field type reference and updatable properties.`;
-const updateWorkflowFieldSchema = zod_1.z.object({
+const updateWorkflowStructureDescription = `Modify workflow structure. Actions: create_field (field.label + field.type required; type is permanent), update_field (fieldId + field required), create_phase (adds a phase named "New Phase" — rename it via update_phase), update_phase (phaseId + phase required; name/description/color). update_field auto-generates a camelCase key from field.label when no key is given — set autoGenerateKey:false when changing only the label. Field types: text, textarea, numeric, numericunit, date, datetime, textpredefinedoptions (dropdown), activitylink, users, teams.`;
+const updateWorkflowStructureSchema = zod_1.z.object({
     workflowId: zod_1.z
         .string()
-        .min(1, "Workflow ID is required")
-        .describe("The workflow ID or key containing the field (get from list_workflows)"),
-    fieldId: zod_1.z
-        .string()
-        .min(1, "Field ID is required")
-        .describe("The field ID to update (get from workflow schema)"),
-    fieldData: zod_1.z
-        .record(zod_1.z.unknown())
-        .describe("Field properties to update (label, key, type, data, required, etc.)"),
-    workspaceId: zod_1.z
-        .string()
-        .optional()
-        .describe("Optional workspace ID or name - defaults to current workspace"),
-    language: zod_1.z
-        .string()
-        .default("en")
-        .optional()
-        .describe("Language code for the update (default: 'en')"),
+        .min(1, 'Workflow ID is required')
+        .describe('The workflow ID (24-char) or key to modify'),
+    action: zod_1.z
+        .enum(['create_field', 'update_field', 'create_phase', 'update_phase'])
+        .describe('Structure operation to perform'),
+    fieldId: zod_1.z.string().optional().describe('Field ID to update (required for update_field)'),
+    phaseId: zod_1.z.string().optional().describe('Phase ID or key to update (required for update_phase)'),
+    field: zod_1.z.object({
+        label: zod_1.z.string().optional().describe('Field display label (required for create_field)'),
+        type: zod_1.z.enum([
+            'text', 'textarea', 'numeric', 'numericunit',
+            'date', 'datetime', 'daterange', 'datetimerange', 'time', 'timerange',
+            'textpredefinedoptions', 'activitylink', 'users', 'teams',
+            'country', 'linkedfrom', 'subheader'
+        ]).optional().describe('Field type (required for create_field; cannot be changed after creation)'),
+        key: zod_1.z.string().optional().describe('Unique field key (for programmatic access)'),
+        unit: zod_1.z.string().optional().describe("Unit for numericunit fields (e.g. '€', 'kg')"),
+        data: zod_1.z.array(zod_1.z.string()).optional().describe('For textpredefinedoptions: option values. For activitylink: target workflow IDs'),
+        required: zod_1.z.boolean().optional().describe('Whether field is required'),
+        description: zod_1.z.string().optional().describe('Field description/help text'),
+        placeholder: zod_1.z.string().optional().describe('Placeholder text'),
+        defaultTo: zod_1.z.boolean().optional().describe('Enable default value'),
+        defaultValue: zod_1.z.string().optional().describe('Default value if defaultTo is enabled'),
+    }).passthrough().optional().describe('Field definition (create_field) or properties to change (update_field)'),
+    phase: zod_1.z.object({
+        name: zod_1.z.string().optional().describe('New phase name'),
+        description: zod_1.z.string().optional().describe('New phase description'),
+        color: zod_1.z.string().optional().describe('Phase color code'),
+    }).passthrough().optional().describe('Phase properties to update (update_phase)'),
     autoGenerateKey: zod_1.z
         .boolean()
-        .default(true)
         .optional()
-        .describe("Auto-generate camelCase key from label if key not provided (default: true). IMPORTANT: Set to false when updating ONLY the label to prevent key regeneration errors."),
-    force: zod_1.z.boolean().optional().describe("Override SDK redirect — use API directly even when workspace/ exists"),
+        .default(true)
+        .describe('update_field only: auto-generate camelCase key from field.label if key not provided (default: true). Set to false when updating ONLY the label to prevent key regeneration errors.'),
+    force: zod_1.z.boolean().optional().describe('Override SDK redirect — use API directly even when workspace/ exists'),
 });
-exports.updateWorkflowFieldTool = {
-    name: 'update_workflow_field',
-    group: tool_registry_1.ToolGroup.PLAYGROUND,
-    description: updateWorkflowFieldDescription,
-    schema: updateWorkflowFieldSchema,
-    async execute(args, context) {
-        if (isSdkProject() && !args.force) {
-            return sdkRedirect('update_workflow_field', 'npm run fields-push:force', 'workspace/<WorkflowName>_<id>/fields.ts');
+/** Build a validation error response for update_workflow_structure */
+function structureValidationError(message) {
+    return {
+        content: [{
+                type: 'text',
+                text: `❌ **Invalid update_workflow_structure call**\n\n${message}`,
+            }],
+    };
+}
+/** create_field action — former create_workflow_field body */
+async function executeCreateField(workflowId, field, context) {
+    logger.debug('Creating workflow field', {
+        workflowId,
+        fieldLabel: field.label,
+        fieldType: field.type,
+    });
+    try {
+        if (workflowId.length !== 24) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Invalid workflowId "${workflowId}" - must be a 24-character ID.\n\n**How to get valid workflow IDs:**\n\`\`\`\ndescribe_workflows()\n\`\`\``,
+                    }],
+            };
         }
-        logger.debug('Updating workflow field', {
-            workflowId: args.workflowId,
-            fieldId: args.fieldId,
-            apiKey: context.apiKey.substring(0, 8) + '...'
+        // Call RPC endpoint process.create_field
+        const newField = await context.hailer.request('process.create_field', [
+            workflowId,
+            field
+        ]);
+        logger.debug('Workflow field created', {
+            workflowId,
+            fieldId: newField?._id,
+            fieldLabel: newField?.label,
         });
-        try {
-            // Get current workspace from cached init data
-            let workspaceId = args.workspaceId;
-            if (!workspaceId) {
-                workspaceId = context.init.network?._id;
-            }
-            // Process field data - auto-generate key from label if requested
-            const fieldData = { ...args.fieldData };
-            const autoGenerateKey = args.autoGenerateKey !== false; // Default to true
-            if (autoGenerateKey && fieldData.label && !fieldData.key) {
-                const generatedKey = labelToCamelCase(fieldData.label);
-                fieldData.key = generatedKey;
-                logger.debug('Auto-generated key from label', {
-                    label: fieldData.label,
-                    key: generatedKey
-                });
-            }
-            const language = args.language || 'en';
-            logger.debug('Calling process.update_field', {
-                workflowId: args.workflowId,
-                fieldId: args.fieldId,
-                language,
-                fieldData
-            });
-            // Call process.update_field endpoint
-            await context.hailer.request('process.update_field', [
-                args.workflowId,
-                args.fieldId,
-                fieldData,
-                language
-            ]);
-            logger.debug('Workflow field update successful', {
-                workflowId: args.workflowId,
-                fieldId: args.fieldId
-            });
-            // Build success response
-            let responseText = `✅ **Workflow Field Updated Successfully**\n\n`;
-            responseText += `**Workflow ID:** \`${args.workflowId}\`\n`;
-            responseText += `**Field ID:** \`${args.fieldId}\`\n`;
-            responseText += `**Workspace:** ${workspaceId}\n\n`;
-            responseText += `**Updated Properties:**\n`;
-            Object.entries(fieldData).forEach(([key, value]) => {
-                const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);
-                responseText += `- ${key}: \`${valueStr}\`\n`;
+        // Invalidate the cached context: field-key validation in create/update_activity
+        // reads cached core.init (15-min TTL) and would reject this fresh field ID
+        // for up to 15 minutes — exactly the flow the Next Steps below recommend.
+        UserContextCache_1.UserContextCache.clearContext(context.apiKey);
+        let responseText = `✅ **Field Created Successfully**\n\n`;
+        responseText += `**Workflow ID:** \`${workflowId}\`\n`;
+        responseText += `**Field ID:** \`${newField._id}\`\n`;
+        responseText += `**Label:** ${newField.label}\n`;
+        responseText += `**Type:** ${newField.type}\n`;
+        if (newField.key) {
+            responseText += `**Key:** ${newField.key}\n`;
+        }
+        if (newField.unit) {
+            responseText += `**Unit:** ${newField.unit}\n`;
+        }
+        if (newField.data?.length) {
+            responseText += `**Options/Links:** ${newField.data.join(', ')}\n`;
+        }
+        responseText += `\n💡 **Next Steps:**\n`;
+        responseText += `- Use this field ID in \`create_activity\` or \`update_activity\` to set values\n`;
+        responseText += `- Use \`describe_workflows\` with include: ['schema'] to verify the field was added\n`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: responseText,
+                }],
+        };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error creating workflow field', error);
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes('Permission') || errorMessage.includes('permission')) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ **Permission Denied**\n\nYou must be a workflow administrator to create fields.\n\n**Error:** ${errorMessage}`,
+                    }],
+            };
+        }
+        if (errorMessage.includes('key')) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ **Duplicate Key**\n\n${errorMessage}\n\nUse a different \`key\` value or omit it to auto-generate.`,
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ **Error creating field**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workflow administrator\n- Workflow ID must be valid (24 characters)\n- Field type must be valid\n- Field key must be unique within workflow`,
+                }],
+        };
+    }
+}
+/** update_field action — former update_workflow_field body */
+async function executeUpdateField(workflowId, fieldId, field, autoGenerateKey, context) {
+    logger.debug('Updating workflow field', {
+        workflowId,
+        fieldId,
+        apiKey: context.apiKey.substring(0, 8) + '...'
+    });
+    try {
+        const workspaceId = context.init.network?._id;
+        // Process field data - auto-generate key from label if requested
+        const fieldData = { ...field };
+        if (autoGenerateKey && fieldData.label && !fieldData.key) {
+            const generatedKey = labelToCamelCase(fieldData.label);
+            fieldData.key = generatedKey;
+            logger.debug('Auto-generated key from label', {
+                label: fieldData.label,
+                key: generatedKey
             });
-            responseText += `\n💡 **Next Steps:**\n`;
-            responseText += `- Use \`get_workflow_schema\` to verify the field changes\n`;
-            responseText += `- Use \`list_activities\` with \`returnFlat: true\` to see the key in action\n`;
-            if (fieldData.key) {
-                responseText += `\n**Using the new key:**\n`;
-                responseText += `When creating/updating activities with \`returnFlat: true\`, use:\n`;
-                responseText += `\`\`\`javascript\n`;
-                responseText += `fields: { "${fieldData.key}": "value" }\n`;
-                responseText += `\`\`\``;
-            }
+        }
+        const language = 'en';
+        logger.debug('Calling process.update_field', {
+            workflowId,
+            fieldId,
+            language,
+            fieldData
+        });
+        // Call process.update_field endpoint
+        await context.hailer.request('process.update_field', [
+            workflowId,
+            fieldId,
+            fieldData,
+            language
+        ]);
+        logger.debug('Workflow field update successful', {
+            workflowId,
+            fieldId
+        });
+        // Invalidate the cached context so key/label changes are visible to
+        // field-key validation immediately (cached core.init, 15-min TTL).
+        UserContextCache_1.UserContextCache.clearContext(context.apiKey);
+        // Build success response
+        let responseText = `✅ **Workflow Field Updated Successfully**\n\n`;
+        responseText += `**Workflow ID:** \`${workflowId}\`\n`;
+        responseText += `**Field ID:** \`${fieldId}\`\n`;
+        responseText += `**Workspace:** ${workspaceId}\n\n`;
+        responseText += `**Updated Properties:**\n`;
+        Object.entries(fieldData).forEach(([key, value]) => {
+            const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);
+            responseText += `- ${key}: \`${valueStr}\`\n`;
+        });
+        responseText += `\n💡 **Next Steps:**\n`;
+        responseText += `- Use \`describe_workflows\` with include: ['schema'] to verify the field changes\n`;
+        responseText += `- Use \`list_activities\` with \`returnFlat: true\` to see the key in action\n`;
+        if (fieldData.key) {
+            responseText += `\n**Using the new key:**\n`;
+            responseText += `When creating/updating activities with \`returnFlat: true\`, use:\n`;
+            responseText += `\`\`\`javascript\n`;
+            responseText += `fields: { "${fieldData.key}": "value" }\n`;
+            responseText += `\`\`\``;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: responseText,
+                }],
+        };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error updating workflow field', error);
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Handle permission errors
+        if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied') || errorMessage.includes('permission')) {
             return {
                 content: [{
-                        type: "text",
-                        text: responseText,
+                        type: 'text',
+                        text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to update workflow fields.\n\n**Error:** ${errorMessage}`,
                     }],
             };
         }
-        catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Error updating workflow field", error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Handle permission errors
-            if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied') || errorMessage.includes('permission')) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to update workflow fields.\n\n**Error:** ${errorMessage}`,
-                        }],
-                };
-            }
-            // Handle not found errors
-            if (errorMessage.includes('not found') || errorMessage.includes('NotFound')) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `❌ **Workflow or Field Not Found**\n\nThe specified workflow or field does not exist.\n\n**Workflow ID:** \`${args.workflowId}\`\n**Field ID:** \`${args.fieldId}\`\n\n**Error:** ${errorMessage}\n\n💡 Use \`list_workflows\` and \`get_workflow_schema\` to see available workflows and fields.`,
-                        }],
-                };
-            }
+        // Handle not found errors
+        if (errorMessage.includes('not found') || errorMessage.includes('NotFound')) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ **Workflow or Field Not Found**\n\nThe specified workflow or field does not exist.\n\n**Workflow ID:** \`${workflowId}\`\n**Field ID:** \`${fieldId}\`\n\n**Error:** ${errorMessage}\n\n💡 Use \`describe_workflows\` to see available workflows and fields.`,
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ **Error updating workflow field**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Workflow ID and Field ID must be valid\n- Field data must match field type requirements\n- Some field types may have restrictions on updates`,
+                }],
+        };
+    }
+}
+/** create_phase action — former create_workflow_phase body */
+async function executeCreatePhase(workflowId, context) {
+    logger.debug('Creating workflow phase', {
+        workflowId,
+        apiKey: context.apiKey.substring(0, 8) + '...'
+    });
+    try {
+        // Validate workflowId format
+        if (workflowId.length !== 24) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Invalid workflowId "${workflowId}" - must be a 24-character ID.\n\n**How to get valid workflow IDs:**\n\`\`\`\ndescribe_workflows()\n\`\`\``,
+                    }],
+            };
+        }
+        // Call RPC endpoint phase.create
+        const newPhase = await context.hailer.request('phase.create', [workflowId]);
+        logger.debug('Workflow phase created', {
+            workflowId,
+            phaseId: newPhase?._id
+        });
+        // Invalidate the cached context: phase transitions match on exact phase
+        // names from cached core.init (15-min TTL) — a stale cache can't see this
+        // phase until it expires.
+        UserContextCache_1.UserContextCache.clearContext(context.apiKey);
+        let responseText = `✅ **Phase Created Successfully**\n\n`;
+        responseText += `**Workflow ID:** \`${workflowId}\`\n`;
+        responseText += `**New Phase ID:** \`${newPhase._id}\`\n`;
+        responseText += `**Name:** ${newPhase.name}\n\n`;
+        responseText += `💡 **Next Steps:**\n`;
+        responseText += `- Rename: \`update_workflow_structure({ workflowId: "${workflowId}", action: "update_phase", ` +
+            `phaseId: "${newPhase._id}", phase: { name: "Your Phase Name" } })\`\n`;
+        responseText += `- Verify: \`describe_workflows({ workflowId: "${workflowId}", include: ["phases"] })\`\n`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: responseText,
+                }],
+        };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error creating workflow phase', error);
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes('Permission') || errorMessage.includes('permission')) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ **Permission Denied**\n\nYou must be a workflow administrator to create phases.\n\n**Error:** ${errorMessage}`,
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ **Error creating phase**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workflow administrator\n- Workflow ID must be valid (24 characters)\n- Use \`describe_workflows\` to find workflow IDs`,
+                }],
+        };
+    }
+}
+/** update_phase action — former update_workflow_phase body */
+async function executeUpdatePhase(workflowId, phaseId, phase, context) {
+    logger.debug('Updating workflow phase', {
+        workflowId,
+        phaseId,
+        apiKey: context.apiKey.substring(0, 8) + '...'
+    });
+    try {
+        const workspaceId = context.init.network?._id;
+        const phaseData = phase;
+        const language = 'en'; // Default language
+        logger.debug('Calling RPC phase.update', {
+            workflowId,
+            phaseId,
+            phaseData
+        });
+        // Call RPC endpoint phase.update
+        // Args: [processId, phaseId, phaseSettings, language]
+        await context.hailer.request('phase.update', [
+            workflowId,
+            phaseId,
+            phaseData,
+            language
+        ]);
+        logger.debug('Workflow phase update successful', {
+            workflowId,
+            phaseId
+        });
+        // Invalidate the cached context: phase transitions match on exact phase
+        // names from cached core.init (15-min TTL) — a renamed phase would be
+        // invisible to them until the cache expires.
+        UserContextCache_1.UserContextCache.clearContext(context.apiKey);
+        // Build success response
+        let responseText = `✅ **Workflow Phase Updated Successfully**\n\n`;
+        responseText += `**Workflow ID:** \`${workflowId}\`\n`;
+        responseText += `**Phase ID:** \`${phaseId}\`\n`;
+        responseText += `**Workspace:** ${workspaceId}\n\n`;
+        responseText += `**Updated Properties:**\n`;
+        Object.entries(phaseData).forEach(([key, value]) => {
+            const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);
+            responseText += `- ${key}: \`${valueStr}\`\n`;
+        });
+        responseText += `\n💡 **Next Steps:**\n`;
+        responseText += `- Use \`describe_workflows\` with include: ['phases'] to verify the phase changes\n`;
+        responseText += `- Phase changes will be immediately visible in the workflow\n`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: responseText,
+                }],
+        };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error updating workflow phase', error);
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Handle permission errors
+        if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied') || errorMessage.includes('permission')) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to update workflow phases.\n\n**Error:** ${errorMessage}`,
+                    }],
+            };
+        }
+        // Handle method not found errors
+        if (errorMessage.includes('Method not found')) {
             return {
                 content: [{
-                        type: "text",
-                        text: `❌ **Error updating workflow field**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Workflow ID and Field ID must be valid\n- Field data must match field type requirements\n- Some field types may have restrictions on updates`,
+                        type: 'text',
+                        text: `❌ **API Method Not Available**\n\nThe \`process.update_phase\` API method may not be available in this Hailer version.\n\n**Alternative:** Use the Hailer web interface to update phase names manually.\n\n**Error:** ${errorMessage}`,
                     }],
             };
         }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ **Error updating workflow phase**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Workflow ID must be valid (24 characters)\n- Phase ID must exist in the workflow\n- Use \`describe_workflows\` with include: ['phases'] to find phase IDs`,
+                }],
+        };
+    }
+}
+exports.updateWorkflowStructureTool = {
+    name: 'update_workflow_structure',
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: updateWorkflowStructureDescription,
+    schema: updateWorkflowStructureSchema,
+    async execute(args, context) {
+        // SDK redirect applies to update actions only (create actions never redirected)
+        if (args.action === 'update_field' && isSdkProject() && !args.force) {
+            return sdkRedirect('update_workflow_structure', 'npm run fields-push:force', 'workspace/<WorkflowName>_<id>/fields.ts');
+        }
+        if (args.action === 'update_phase' && isSdkProject() && !args.force) {
+            return sdkRedirect('update_workflow_structure', 'npm run phases-push:force', 'workspace/<WorkflowName>_<id>/phases.ts');
+        }
+        if (args.action === 'create_field' && (!args.field?.label || !args.field?.type)) {
+            return structureValidationError("action 'create_field' requires a `field` object with at least `label` and `type`.");
+        }
+        if (args.action === 'create_field') {
+            return executeCreateField(args.workflowId, args.field, context);
+        }
+        if (args.action === 'update_field' && (!args.fieldId || !args.field)) {
+            return structureValidationError("action 'update_field' requires `fieldId` and a `field` object with the properties to change.");
+        }
+        if (args.action === 'update_field') {
+            return executeUpdateField(args.workflowId, args.fieldId, args.field, args.autoGenerateKey ?? true, context);
+        }
+        if (args.action === 'create_phase') {
+            return executeCreatePhase(args.workflowId, context);
+        }
+        if (!args.phaseId || !args.phase) {
+            return structureValidationError("action 'update_phase' requires `phaseId` and a `phase` object (name/description/color).");
+        }
+        return executeUpdatePhase(args.workflowId, args.phaseId, args.phase, context);
     }
 };
 // ============================================================================
@@ -1093,23 +1418,23 @@ const testFunctionFieldDescription = `Test function field code against an activi
 const testFunctionFieldSchema = zod_1.z.object({
     activityId: zod_1.z
         .string()
-        .min(1, "Activity ID is required")
-        .describe("Activity ID to test the function against (must have dependency field values)"),
+        .min(1, 'Activity ID is required')
+        .describe('Activity ID to test the function against (must have dependency field values)'),
     fieldId: zod_1.z
         .string()
-        .min(1, "Field ID is required")
-        .describe("Field ID for context and to get field configuration (label, type, etc.)"),
+        .min(1, 'Field ID is required')
+        .describe('Field ID for context and to get field configuration (label, type, etc.)'),
     function: zod_1.z
         .string()
-        .min(1, "Function code is required")
-        .describe("JavaScript function code to test - access dependencies via dep.variableName"),
+        .min(1, 'Function code is required')
+        .describe('JavaScript function code to test - access dependencies via dep.variableName'),
     functionVariables: zod_1.z
         .record(zod_1.z.object({
         type: zod_1.z.string().describe("Dependency type - use '=' for same-activity field"),
-        data: zod_1.z.array(zod_1.z.string()).describe("Array with field ID to depend on")
+        data: zod_1.z.array(zod_1.z.string()).describe('Array with field ID to depend on')
     }))
         .optional()
-        .describe("Optional function dependencies - if not provided, reads from field definition"),
+        .describe('Optional function dependencies - if not provided, reads from field definition'),
 });
 exports.testFunctionFieldTool = {
     name: 'test_function_field',
@@ -1127,7 +1452,7 @@ exports.testFunctionFieldTool = {
             if (!activity?.process) {
                 return {
                     content: [{
-                            type: "text",
+                            type: 'text',
                             text: `❌ Could not find activity or workflow for activity ID: ${args.activityId}`
                         }],
                 };
@@ -1143,7 +1468,7 @@ exports.testFunctionFieldTool = {
                     : `Field "${field.label || args.fieldId}" has no function dependencies configured.`;
                 return {
                     content: [{
-                            type: "text",
+                            type: 'text',
                             text: `❌ No function dependencies available.
 
 ${reason}
@@ -1171,7 +1496,7 @@ functionVariables: {
                 const cleanMessage = errorMessage.replace(/^(SyntaxError|ReferenceError|TypeError):\s*/, '');
                 return {
                     content: [{
-                            type: "text",
+                            type: 'text',
                             text: `❌ **Function Field Test Failed**
 
 **Error Type:** ${errorType}
@@ -1185,7 +1510,7 @@ functionVariables: {
 **Next Steps:**
 1. Fix the function code syntax/logic
 2. Test again with \`test_function_field\`
-3. When test passes, save with \`update_workflow_field\``,
+3. When test passes, save with \`update_workflow_structure\` (action: update_field)`,
                         }],
                 };
             }
@@ -1216,30 +1541,33 @@ functionVariables: {
             const iterations = stats['Iterations Used'];
             if (executionTime !== undefined || iterations !== undefined) {
                 text += '\n**⏱️  Execution Statistics:**\n';
-                if (executionTime !== undefined)
+                if (executionTime !== undefined) {
                     text += `- Execution Time: ${executionTime}ms\n`;
-                if (iterations !== undefined)
+                }
+                if (iterations !== undefined) {
                     text += `- Iterations: ${iterations}\n`;
+                }
             }
             text += `
 **✅ Next Steps:**
 - Test with other activities to verify edge cases
 - Check activities where dependencies might be null/undefined
-- If you need to modify the function, use \`update_workflow_field\` to save changes
+- If you need to modify the function, use \`update_workflow_structure\` (action: update_field) to save changes
 - Function is working correctly and ready for production use!`;
             return {
-                content: [{ type: "text", text }],
+                content: [{ type: 'text', text }],
             };
         }
         catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Error testing function field", error);
+            if (!request_logger_1.RequestLogger.getCurrent()) {
+                logger.error('Error testing function field', error);
+            }
             const errorMessage = error instanceof Error
                 ? error.message
                 : JSON.stringify(error, null, 2);
             return {
                 content: [{
-                        type: "text",
+                        type: 'text',
                         text: `❌ **Error Testing Function Field**
 
 ${errorMessage}
@@ -1254,243 +1582,6 @@ ${errorMessage}
     }
 };
 // ============================================================================
-// TOOL 5: LIST WORKFLOWS MINIMAL
-// ============================================================================
-const listWorkflowsMinimalDescription = `Quick list of all workflows - START HERE to find workflow IDs.
-
-**Hailer Concept:** Returns all workflows (processes/boards) with their IDs and names. This is usually your FIRST CALL to discover what's available.
-
-**When to use:** User asks "show my tasks", "what workflows do I have", "find customers" - use this to locate the right workflow ID.
-
-**Returns:** Workflow name, ID, activity count. Use the ID in subsequent calls.
-
-**Typical flow:** list_workflows_minimal → list_workflow_phases → get_workflow_schema → list_activities`;
-const listWorkflowsMinimalSchema = zod_1.z.object({
-    workspace: zod_1.z.string().optional().describe("Optional workspace ID or name"),
-    limit: zod_1.z.coerce.number().optional().describe("Maximum number of workflows to return"),
-    offset: zod_1.z.coerce.number().optional().default(0).describe("Number of workflows to skip (for pagination)"),
-    search: zod_1.z.string().optional().describe("Filter workflows by name (case-insensitive partial match)"),
-    starredOnly: zod_1.z.coerce.boolean().optional().default(false).describe("Only return starred workflows"),
-});
-exports.listWorkflowsMinimalTool = {
-    name: 'list_workflows_minimal',
-    group: tool_registry_1.ToolGroup.READ,
-    description: listWorkflowsMinimalDescription,
-    schema: listWorkflowsMinimalSchema,
-    async execute(args, context) {
-        logger.debug('Listing workflows (minimal)', {
-            apiKey: context.apiKey.substring(0, 8) + '...'
-        });
-        try {
-            // Use cached workflows from context.init (already fetched during initialization)
-            let workflows = context.init.processes || [];
-            // Filter by workspace if specified
-            if (args.workspace) {
-                workflows = workflows.filter(w => w.cid === args.workspace);
-            }
-            // Filter by starred if requested
-            if (args.starredOnly) {
-                workflows = workflows.filter(w => w.isStarred);
-            }
-            // Search by name if provided
-            if (args.search) {
-                const searchLower = args.search.toLowerCase();
-                workflows = workflows.filter(w => w.name.toLowerCase().includes(searchLower));
-            }
-            // Apply pagination
-            const offset = args.offset || 0;
-            const limit = args.limit;
-            const totalCount = workflows.length;
-            if (limit) {
-                workflows = workflows.slice(offset, offset + limit);
-            }
-            else if (offset > 0) {
-                workflows = workflows.slice(offset);
-            }
-            // Build minimal response - only id and name
-            const minimalWorkflows = workflows.map(w => ({
-                id: w._id,
-                name: w.name,
-                workspaceId: w.cid,
-                activityCount: w.createdActivities || 0,
-                isStarred: w.isStarred || false
-            }));
-            let responseText = (isSdkProject() ? SDK_DISCOVERY_HINT : '') + `📋 **Workflows Found**\n\n`;
-            responseText += `Total: ${totalCount}\n`;
-            responseText += `Showing: ${workflows.length}\n`;
-            if (offset > 0)
-                responseText += `Offset: ${offset}\n`;
-            responseText += `\n`;
-            minimalWorkflows.forEach(w => {
-                const star = w.isStarred ? '⭐ ' : '';
-                responseText += `${star}**${w.name}**\n`;
-                responseText += `  ID: \`${w.id}\`\n`;
-                responseText += `  Activities: ${w.activityCount}\n\n`;
-            });
-            responseText += `\n💡 **Next Steps:**\n`;
-            responseText += `- Use \`get_workflow_schema\` with workflow ID to see fields\n`;
-            responseText += `- Use \`list_workflow_phases\` to see available phases\n`;
-            if (limit && (offset + limit) < totalCount) {
-                responseText += `- Use \`offset: ${offset + limit}\` to see next page\n`;
-            }
-            return {
-                content: [{
-                        type: "text",
-                        text: responseText,
-                    }],
-            };
-        }
-        catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Error listing workflows (minimal)", error);
-            return {
-                content: [{
-                        type: "text",
-                        text: `❌ Error listing workflows: ${error instanceof Error ? error.message : String(error)}`,
-                    }],
-            };
-        }
-    }
-};
-// ============================================================================
-// COUNT ACTIVITIES TOOL
-// ============================================================================
-const countActivitiesDescription = `🔢 Count Activities - Get total count of activities in a workflow
-
-**Purpose**: Returns the total number of activities in a specific workflow. Useful for analytics, reporting, and understanding workflow size.
-
-**⚠️ PERFORMANCE NOTICE:**
-- This makes a separate API call per workflow (v3.activity.count)
-- Use \`list_workflows_minimal\` instead for bulk workflow counts (uses cached data from init, zero extra API calls)
-- Only use \`count_activities\` when you need phase-level breakdown or real-time count
-
-**Example**:
-\`\`\`javascript
-count_activities({
-  workflowId: "691b136906e6923eac972902"
-})
-\`\`\`
-
-**Response**: Returns count in details object
-
-**Use Cases**:
-- Single workflow activity count
-- Phase-by-phase breakdown (returned data shows counts per phase)
-- Real-time activity count (bypasses cache)
-
-**Tips**:
-- For bulk counts of ALL workflows, use \`list_workflows_minimal\` (free, no API calls)
-- This tool makes 1 API call per workflow
-- Use list_workflows to get workflow IDs`;
-const countActivitiesSchema = zod_1.z.object({
-    workflowId: zod_1.z.string().describe("Workflow ID or key"),
-});
-exports.countActivitiesTool = {
-    name: 'count_activities',
-    group: tool_registry_1.ToolGroup.READ,
-    description: countActivitiesDescription,
-    schema: countActivitiesSchema,
-    async execute(args, context) {
-        logger.debug('Counting activities', {
-            workflowId: args.workflowId,
-            apiKey: context.apiKey.substring(0, 8) + '...'
-        });
-        try {
-            // Get workflow name from cached data
-            const workflow = resolveWorkflow(context.init.processes || [], args.workflowId);
-            if (!workflow) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `❌ Workflow "${args.workflowId}" not found`,
-                        }],
-                };
-            }
-            logger.debug('Calling v3.activity.count', {
-                workflowId: args.workflowId,
-                workflowName: workflow.name
-            });
-            // Call v3.activity.count endpoint
-            // Returns object with phase IDs as keys and counts as values
-            const result = await context.hailer.request('v3.activity.count', [args.workflowId]);
-            logger.debug('Activity count retrieved', {
-                result: JSON.stringify(result)
-            });
-            // Sum all counts across phases
-            const count = Object.values(result).reduce((sum, phaseCount) => sum + phaseCount, 0);
-            // Build success response
-            let responseText = `🔢 **Activity Count for "${workflow.name}"**\n\n`;
-            responseText += `**Workflow ID:** \`${args.workflowId}\`\n`;
-            responseText += `**Total Activities:** ${count}\n\n`;
-            if (count === 0) {
-                responseText += `💡 This workflow has no activities yet. Use \`create_activity\` to add one.\n`;
-            }
-            else {
-                responseText += `💡 **Next Steps:**\n`;
-                responseText += `- Use \`list_activities\` to see the activities\n`;
-                responseText += `- Use \`get_workflow_schema\` to see workflow structure\n`;
-            }
-            return {
-                content: [{
-                        type: "text",
-                        text: responseText,
-                    }],
-            };
-        }
-        catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Error counting activities", error);
-            return {
-                content: [{
-                        type: "text",
-                        text: `❌ Error counting activities: ${error instanceof Error ? error.message : String(error)}\n\n**Tips:**\n- Check that workflow ID is valid (24 characters)\n- Use \`list_workflows\` to find workflow IDs`,
-                    }],
-            };
-        }
-    }
-};
-// ============================================================================
-// UPDATE WORKFLOW PHASE
-// ============================================================================
-const updateWorkflowPhaseDescription = `🏷️ Update Workflow Phase - Modify phase name and properties
-
-**What does this do?**
-Updates an existing workflow phase's properties like name, description, and settings.
-
-**Required Parameters**:
-- workflowId: Workflow ID containing the phase
-- phaseId: Phase ID to update
-- phaseData: Properties to update (name, description, etc.)
-
-**Example - Rename phase**:
-\`\`\`javascript
-update_workflow_phase({
-  workflowId: "68446dc05b30685f67c6fcd4",
-  phaseId: "181",
-  phaseData: { name: "Injured" }
-})
-\`\`\`
-
-**Updatable Properties**:
-- name - Phase display name
-- description - Phase description
-- color - Phase color code
-
-**Requirements**:
-- User must be workspace administrator
-`;
-const updateWorkflowPhaseSchema = zod_1.z.object({
-    workflowId: zod_1.z.string().describe("The workflow ID or key containing the phase"),
-    phaseId: zod_1.z.string().describe("The phase ID or key to update"),
-    phaseData: zod_1.z.object({
-        name: zod_1.z.string().optional().describe("New phase name"),
-        description: zod_1.z.string().optional().describe("New phase description"),
-        color: zod_1.z.string().optional().describe("Phase color code"),
-    }).passthrough().describe("Phase properties to update"),
-    workspaceId: zod_1.z.string().optional().describe("Optional workspace ID - defaults to current workspace"),
-    force: zod_1.z.boolean().optional().describe("Override SDK redirect — use API directly even when workspace/ exists"),
-});
-// ============================================================================
 // CORE INIT TOOL - Workspace overview for terminal Claude Code sessions
 // ============================================================================
 const coreInitDescription = `🚀 START HERE - Load workspace context and learn how to use Hailer tools.
@@ -1504,9 +1595,9 @@ Hailer is a workspace platform. Key concepts:
 
 ## How to use these tools:
 
-**Step 1 - Find workflow:** \`list_workflows_minimal\` → get workflow ID
-**Step 2 - Get phases:** \`list_workflow_phases(workflowId)\` → get phase IDs
-**Step 3 - Get fields:** \`get_workflow_schema(workflowId, phaseId)\` → get field IDs
+**Step 1 - Find workflow:** \`describe_workflows\` → get workflow ID
+**Step 2 - Get phases:** \`describe_workflows(workflowId, include: ['phases'])\` → get phase IDs
+**Step 3 - Get fields:** \`describe_workflows(workflowId, include: ['schema'])\` → get field IDs
 **Step 4 - Read/Write:**
 - \`list_activities\` - see items (requires workflowId, phaseId, fields[])
 - \`create_activity\` - create item (requires workflowId, use field IDs from schema)
@@ -1538,122 +1629,28 @@ exports.coreInitTool = {
                     `- Field types, labels, options → read \`workspace/<WorkflowName>_<id>/fields.ts\`\n` +
                     `- Phase names and order → read \`workspace/<WorkflowName>_<id>/phases.ts\`\n` +
                     `- Workflow config changes → edit workspace/ files + \`npm run push:force\`\n\n` +
-                    `**Use MCP tools ONLY for runtime data:** create_activity, update_activity, list_activities, preview_insight, discussions.\n\n`;
+                    `**Use MCP tools ONLY for runtime data:** create_activity, update_activity, list_activities, run_insight, discussions.\n\n`;
             }
             return {
                 content: [{
-                        type: "text",
+                        type: 'text',
                         text: prefix + overview,
                     }],
             };
         }
         catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Failed to generate workspace overview", error);
+            if (!request_logger_1.RequestLogger.getCurrent()) {
+                logger.error('Failed to generate workspace overview', error);
+            }
             return {
                 content: [{
-                        type: "text",
+                        type: 'text',
                         text: `❌ Failed to load workspace context: ${error instanceof Error ? error.message : String(error)}`,
                     }],
             };
         }
     },
 };
-exports.updateWorkflowPhaseTool = {
-    name: 'update_workflow_phase',
-    group: tool_registry_1.ToolGroup.PLAYGROUND,
-    description: updateWorkflowPhaseDescription,
-    schema: updateWorkflowPhaseSchema,
-    async execute(args, context) {
-        if (isSdkProject() && !args.force) {
-            return sdkRedirect('update_workflow_phase', 'npm run phases-push:force', 'workspace/<WorkflowName>_<id>/phases.ts');
-        }
-        logger.debug('Updating workflow phase', {
-            workflowId: args.workflowId,
-            phaseId: args.phaseId,
-            apiKey: context.apiKey.substring(0, 8) + '...'
-        });
-        try {
-            // Get current workspace from cached init data
-            let workspaceId = args.workspaceId;
-            if (!workspaceId) {
-                workspaceId = context.init.network?._id;
-            }
-            const phaseData = args.phaseData;
-            const language = 'en'; // Default language
-            logger.debug('Calling REST /phase/update', {
-                workflowId: args.workflowId,
-                phaseId: args.phaseId,
-                phaseData
-            });
-            // Call REST endpoint /api/phase/update
-            // API format: {"0": workflowId, "1": phaseId, "2": phaseSettings, "3": language}
-            await context.hailer.callRest({
-                operation: 'update_workflow_phase',
-                endpoint: '/api/phase/update',
-                method: 'POST',
-                body: {
-                    "0": args.workflowId,
-                    "1": args.phaseId,
-                    "2": phaseData,
-                    "3": language
-                }
-            });
-            logger.debug('Workflow phase update successful', {
-                workflowId: args.workflowId,
-                phaseId: args.phaseId
-            });
-            // Build success response
-            let responseText = `✅ **Workflow Phase Updated Successfully**\n\n`;
-            responseText += `**Workflow ID:** \`${args.workflowId}\`\n`;
-            responseText += `**Phase ID:** \`${args.phaseId}\`\n`;
-            responseText += `**Workspace:** ${workspaceId}\n\n`;
-            responseText += `**Updated Properties:**\n`;
-            Object.entries(phaseData).forEach(([key, value]) => {
-                const valueStr = typeof value === 'object' ? JSON.stringify(value) : String(value);
-                responseText += `- ${key}: \`${valueStr}\`\n`;
-            });
-            responseText += `\n💡 **Next Steps:**\n`;
-            responseText += `- Use \`list_workflow_phases\` to verify the phase changes\n`;
-            responseText += `- Phase changes will be immediately visible in the workflow\n`;
-            return {
-                content: [{
-                        type: "text",
-                        text: responseText,
-                    }],
-            };
-        }
-        catch (error) {
-            if (!request_logger_1.RequestLogger.getCurrent())
-                logger.error("Error updating workflow phase", error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Handle permission errors
-            if (errorMessage.includes('network admin') || errorMessage.includes('PermissionDenied') || errorMessage.includes('permission')) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `❌ **Permission Denied**\n\nYou must be a workspace administrator to update workflow phases.\n\n**Error:** ${errorMessage}`,
-                        }],
-                };
-            }
-            // Handle method not found errors
-            if (errorMessage.includes('Method not found')) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `❌ **API Method Not Available**\n\nThe \`process.update_phase\` API method may not be available in this Hailer version.\n\n**Alternative:** Use the Hailer web interface to update phase names manually.\n\n**Error:** ${errorMessage}`,
-                        }],
-                };
-            }
-            return {
-                content: [{
-                        type: "text",
-                        text: `❌ **Error updating workflow phase**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- User must be workspace administrator\n- Workflow ID must be valid (24 characters)\n- Phase ID must exist in the workflow\n- Use \`list_workflow_phases\` to find phase IDs`,
-                    }],
-            };
-        }
-    }
-};
 // ============================================================================
 // AUTO SET KEYS TOOL
 // ============================================================================
@@ -1663,7 +1660,7 @@ exports.autoSetKeysTool = {
     group: tool_registry_1.ToolGroup.PLAYGROUND,
     description: autoSetKeysDescription,
     schema: zod_1.z.object({
-        workflowId: zod_1.z.string().describe("Workflow ID or key to set keys on"),
+        workflowId: zod_1.z.string().describe('Workflow ID or key to set keys on'),
     }),
     async execute(args, context) {
         try {
@@ -1704,28 +1701,23 @@ exports.autoSetKeysTool = {
                 }
             }
             responseText += `\n💡 You can now use these keys instead of hex IDs in all tools.`;
-            return { content: [{ type: "text", text: responseText }] };
+            return { content: [{ type: 'text', text: responseText }] };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             return {
-                content: [{ type: "text", text: `❌ **Error setting keys:** ${errorMessage}` }],
+                content: [{ type: 'text', text: `❌ **Error setting keys:** ${errorMessage}` }],
             };
         }
     }
 };
 /** All workflow tools */
 exports.workflowTools = [
-    exports.getWorkflowSchemaTool,
-    exports.listWorkflowPhasesTool,
-    exports.listWorkflowsTool,
+    exports.describeWorkflowsTool,
     exports.installWorkflowTool,
     exports.removeWorkflowTool,
-    exports.updateWorkflowFieldTool,
-    exports.updateWorkflowPhaseTool,
+    exports.updateWorkflowStructureTool,
     exports.testFunctionFieldTool,
-    exports.listWorkflowsMinimalTool,
-    exports.countActivitiesTool,
     exports.coreInitTool,
     exports.autoSetKeysTool,
 ];