@ema.co/mcp-toolkit 1.5.1 → 1.6.0

package/dist/sdk/workflow-optimizer.js

@@ -0,0 +1,665 @@
+/**
+ * Workflow Optimizer - Proactive Intelligence Engine
+ *
+ * Goes beyond issue detection to find optimization opportunities,
+ * suggest improvements, and calculate workflow health scores.
+ * This is the "brains" that makes workflows better.
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Main Entry Point
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Analyze workflow for optimization opportunities
+ */
+export function analyzeOptimizations(workflow) {
+    const actions = workflow.actions || [];
+    const graph = buildDependencyGraph(actions);
+    const metrics = calculateMetrics(actions, graph);
+    const optimizations = [];
+    // 1. Find consolidation opportunities (duplicate/redundant nodes)
+    optimizations.push(...findConsolidationOpportunities(actions, graph));
+    // 2. Find parallelization opportunities
+    optimizations.push(...findParallelizationOpportunities(actions, graph));
+    // 3. Find passthrough nodes to eliminate
+    optimizations.push(...findPassthroughNodes(actions, graph));
+    // 4. Find error handling gaps
+    optimizations.push(...findErrorHandlingGaps(actions, graph));
+    // 5. Find LLM call optimizations
+    optimizations.push(...findLlmOptimizations(actions, graph));
+    // 6. Find search optimizations
+    optimizations.push(...findSearchOptimizations(actions, graph));
+    // 7. Find naming improvements
+    optimizations.push(...findNamingImprovements(actions));
+    // 8. Find safety improvements (HITL for side effects)
+    optimizations.push(...findSafetyImprovements(actions, graph));
+    // Calculate health score
+    const healthScore = calculateWorkflowHealth(actions, metrics, optimizations);
+    // Categorize optimizations
+    const quickWins = optimizations.filter(o => o.auto_applicable && o.risk === "none" && o.severity !== "suggestion");
+    const strategic = optimizations.filter(o => !o.auto_applicable || o.risk !== "none");
+    // Generate recommendations
+    const recommendations = generateRecommendations(optimizations, metrics, healthScore);
+    return {
+        workflow_health_score: healthScore,
+        grade: healthScoreToGrade(healthScore),
+        optimizations,
+        quick_wins: quickWins,
+        strategic,
+        metrics,
+        recommendations,
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Graph Building
+// ─────────────────────────────────────────────────────────────────────────────
+function buildDependencyGraph(actions) {
+    const nodes = new Map();
+    const edges = new Map();
+    const reverseEdges = new Map();
+    // Initialize nodes
+    for (const action of actions) {
+        const actionType = action.action?.name?.name || "unknown";
+        nodes.set(action.name, {
+            id: action.name,
+            type: actionType,
+            depth: 0,
+            inputs: [],
+            outputs: [],
+        });
+        edges.set(action.name, new Set());
+        reverseEdges.set(action.name, new Set());
+    }
+    // Build edges from input bindings
+    for (const action of actions) {
+        const node = nodes.get(action.name);
+        if (action.inputs) {
+            for (const [inputName, binding] of Object.entries(action.inputs)) {
+                const bindingObj = binding;
+                const actionOutput = bindingObj?.actionOutput;
+                if (actionOutput?.actionName) {
+                    const sourceNode = String(actionOutput.actionName);
+                    node.inputs.push(sourceNode);
+                    // Source → Target edge
+                    edges.get(sourceNode)?.add(action.name);
+                    reverseEdges.get(action.name)?.add(sourceNode);
+                    // Update source node outputs
+                    const sourceGraphNode = nodes.get(sourceNode);
+                    if (sourceGraphNode) {
+                        sourceGraphNode.outputs.push(action.name);
+                    }
+                }
+            }
+        }
+    }
+    // Calculate depths (BFS from trigger)
+    const trigger = actions.find(a => a.action?.name?.name?.includes("trigger"));
+    if (trigger) {
+        const visited = new Set();
+        const queue = [{ node: trigger.name, depth: 0 }];
+        while (queue.length > 0) {
+            const { node, depth } = queue.shift();
+            if (visited.has(node))
+                continue;
+            visited.add(node);
+            const graphNode = nodes.get(node);
+            if (graphNode) {
+                graphNode.depth = depth;
+            }
+            for (const child of edges.get(node) || []) {
+                if (!visited.has(child)) {
+                    queue.push({ node: child, depth: depth + 1 });
+                }
+            }
+        }
+    }
+    return { nodes, edges, reverseEdges };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Metrics Calculation
+// ─────────────────────────────────────────────────────────────────────────────
+function calculateMetrics(actions, graph) {
+    // Count node types
+    const nodeTypes = {};
+    for (const action of actions) {
+        const type = action.action?.name?.name || "unknown";
+        nodeTypes[type] = (nodeTypes[type] || 0) + 1;
+    }
+    // Calculate max depth
+    const maxDepth = Math.max(...Array.from(graph.nodes.values()).map(n => n.depth), 0);
+    // Count branches (nodes with multiple outputs)
+    const branchCount = Array.from(graph.nodes.values()).filter(n => n.outputs.length > 1).length;
+    // Count parallel opportunities (nodes at same depth that could run together)
+    const nodesByDepth = new Map();
+    for (const [id, node] of graph.nodes) {
+        const nodes = nodesByDepth.get(node.depth) || [];
+        nodes.push(id);
+        nodesByDepth.set(node.depth, nodes);
+    }
+    const parallelOpportunities = Array.from(nodesByDepth.values())
+        .filter(nodes => nodes.length > 1).length;
+    // Calculate redundancy score
+    const redundancyScore = calculateRedundancyScore(actions, graph);
+    // Calculate complexity score
+    const complexityScore = calculateComplexityScore(actions, graph, maxDepth, branchCount);
+    // Count sequential latency factors (LLM + search calls on critical path)
+    const latencyFactors = countLatencyFactors(actions, graph);
+    return {
+        total_nodes: actions.length,
+        node_types: nodeTypes,
+        max_depth: maxDepth,
+        branch_count: branchCount,
+        parallel_opportunities: parallelOpportunities,
+        redundancy_score: redundancyScore,
+        complexity_score: complexityScore,
+        estimated_latency_factors: latencyFactors,
+    };
+}
+function calculateRedundancyScore(actions, graph) {
+    let redundancy = 0;
+    // Check for duplicate node types with same inputs
+    const nodeSignatures = new Map();
+    for (const action of actions) {
+        const type = action.action?.name?.name || "unknown";
+        const node = graph.nodes.get(action.name);
+        const signature = `${type}:${node?.inputs.sort().join(",")}`;
+        const existing = nodeSignatures.get(signature) || [];
+        existing.push(action.name);
+        nodeSignatures.set(signature, existing);
+    }
+    // Each duplicate adds to redundancy
+    for (const [_, nodes] of nodeSignatures) {
+        if (nodes.length > 1) {
+            redundancy += (nodes.length - 1) * 10;
+        }
+    }
+    return Math.min(redundancy, 100);
+}
+function calculateComplexityScore(actions, graph, maxDepth, branchCount) {
+    // Base complexity from node count
+    let complexity = Math.min(actions.length * 5, 30);
+    // Add complexity for depth
+    complexity += Math.min(maxDepth * 5, 20);
+    // Add complexity for branching
+    complexity += Math.min(branchCount * 10, 30);
+    // Add complexity for conditional logic
+    const conditionalNodes = actions.filter(a => a.runIf).length;
+    complexity += Math.min(conditionalNodes * 5, 20);
+    return Math.min(complexity, 100);
+}
+function countLatencyFactors(actions, graph) {
+    // Count LLM and search nodes on the longest path
+    const latencyNodes = actions.filter(a => {
+        const type = a.action?.name?.name || "";
+        return type.includes("llm") ||
+            type.includes("respond") ||
+            type.includes("search") ||
+            type.includes("categorizer");
+    });
+    // Find the longest sequential chain of latency nodes
+    let maxSequential = 0;
+    for (const node of latencyNodes) {
+        let count = 1;
+        let current = node.name;
+        // Follow the dependency chain
+        while (true) {
+            const graphNode = graph.nodes.get(current);
+            if (!graphNode || graphNode.outputs.length === 0)
+                break;
+            // Find a latency node in outputs
+            const nextLatency = graphNode.outputs.find(out => latencyNodes.some(ln => ln.name === out));
+            if (!nextLatency)
+                break;
+            count++;
+            current = nextLatency;
+        }
+        maxSequential = Math.max(maxSequential, count);
+    }
+    return maxSequential;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Optimization Finders
+// ─────────────────────────────────────────────────────────────────────────────
+function findConsolidationOpportunities(actions, graph) {
+    const opportunities = [];
+    // Find duplicate search nodes with same query source
+    const searchNodes = actions.filter(a => a.action?.name?.name?.includes("search") &&
+        !a.action?.name?.name?.includes("combine"));
+    const searchByQuery = new Map();
+    for (const search of searchNodes) {
+        const querySource = getQuerySource(search);
+        const existing = searchByQuery.get(querySource) || [];
+        existing.push(search);
+        searchByQuery.set(querySource, existing);
+    }
+    for (const [query, duplicates] of searchByQuery) {
+        if (duplicates.length > 1) {
+            opportunities.push({
+                id: `consolidate-search-${hashString(query)}`,
+                type: "consolidate_nodes",
+                severity: "recommended",
+                title: "Consolidate Redundant Searches",
+                current_state: `${duplicates.length} search nodes using same query source: "${query}"`,
+                proposed_change: "Consolidate into single search node, share results via named_inputs",
+                benefit: `Reduce API calls by ${duplicates.length - 1}x, faster execution, consistent results`,
+                risk: "low",
+                auto_applicable: false, // Requires careful rewiring
+                affected_nodes: duplicates.map(d => d.name),
+                implementation_hint: "Keep one search, remove others, use named_inputs to pass results to all consumers",
+            });
+        }
+    }
+    // Find duplicate LLM calls with similar prompts
+    const llmNodes = actions.filter(a => a.action?.name?.name?.includes("llm") ||
+        a.action?.name?.name?.includes("respond"));
+    if (llmNodes.length > 2) {
+        // Check for sequential LLM calls
+        for (const node of llmNodes) {
+            const graphNode = graph.nodes.get(node.name);
+            if (graphNode) {
+                const llmChildren = graphNode.outputs.filter(out => llmNodes.some(ln => ln.name === out));
+                if (llmChildren.length > 0) {
+                    opportunities.push({
+                        id: `merge-llm-${node.name}`,
+                        type: "merge_llm_calls",
+                        severity: "suggestion",
+                        title: "Consider Merging Sequential LLM Calls",
+                        current_state: `${node.name} feeds into LLM node(s): ${llmChildren.join(", ")}`,
+                        proposed_change: "Merge into single comprehensive LLM call with structured prompt",
+                        benefit: "Reduce latency, potentially lower cost, more coherent output",
+                        risk: "medium",
+                        auto_applicable: false,
+                        affected_nodes: [node.name, ...llmChildren],
+                        implementation_hint: "Combine prompts, use structured output format, single call_llm with all context",
+                    });
+                }
+            }
+        }
+    }
+    return opportunities;
+}
+function findParallelizationOpportunities(actions, graph) {
+    const opportunities = [];
+    // Find nodes at same depth that share a parent but are sequential
+    const nodesByParent = new Map();
+    for (const [nodeId, graphNode] of graph.nodes) {
+        for (const input of graphNode.inputs) {
+            const siblings = nodesByParent.get(input) || [];
+            siblings.push(nodeId);
+            nodesByParent.set(input, siblings);
+        }
+    }
+    // Check for sequential siblings that could be parallel
+    for (const [parent, children] of nodesByParent) {
+        if (children.length > 1) {
+            // Check if they're actually sequential (one depends on another)
+            const sequential = children.filter(child => {
+                const node = graph.nodes.get(child);
+                return node && children.some(other => other !== child && node.inputs.includes(other));
+            });
+            if (sequential.length > 0 && sequential.length < children.length) {
+                opportunities.push({
+                    id: `parallelize-${parent}`,
+                    type: "parallelize_paths",
+                    severity: "suggestion",
+                    title: "Parallelization Opportunity",
+                    current_state: `Children of ${parent} could potentially run in parallel`,
+                    proposed_change: "Restructure so independent operations branch from same source",
+                    benefit: "Reduced latency through parallel execution",
+                    risk: "low",
+                    auto_applicable: false,
+                    affected_nodes: [parent, ...children],
+                });
+            }
+        }
+    }
+    return opportunities;
+}
+function findPassthroughNodes(actions, graph) {
+    const opportunities = [];
+    // Find nodes that just pass data through without transformation
+    for (const action of actions) {
+        const graphNode = graph.nodes.get(action.name);
+        if (!graphNode)
+            continue;
+        // Skip trigger and output nodes
+        const type = action.action?.name?.name || "";
+        if (type.includes("trigger") || graphNode.outputs.length === 0)
+            continue;
+        // Check if this node has single input and single output with no transformation
+        if (graphNode.inputs.length === 1 && graphNode.outputs.length === 1) {
+            // Check if it's a simple passthrough (no significant configuration)
+            const inputCount = Object.keys(action.inputs || {}).length;
+            const hasTransformation = type.includes("llm") ||
+                type.includes("search") ||
+                type.includes("categorizer") ||
+                type.includes("extract");
+            if (!hasTransformation && inputCount <= 2) {
+                opportunities.push({
+                    id: `eliminate-passthrough-${action.name}`,
+                    type: "eliminate_passthrough",
+                    severity: "suggestion",
+                    title: "Potential Passthrough Node",
+                    current_state: `${action.name} appears to pass data without significant transformation`,
+                    proposed_change: "Consider removing and connecting predecessor directly to successor",
+                    benefit: "Simpler workflow, reduced complexity",
+                    risk: "low",
+                    auto_applicable: false,
+                    affected_nodes: [action.name],
+                });
+            }
+        }
+    }
+    return opportunities;
+}
+function findErrorHandlingGaps(actions, graph) {
+    const opportunities = [];
+    // Check for external action callers without error handling
+    const externalCallers = actions.filter(a => a.action?.name?.name?.includes("external") ||
+        a.action?.name?.name?.includes("email") ||
+        a.action?.name?.name?.includes("tool"));
+    for (const caller of externalCallers) {
+        // Check if there's error handling downstream
+        const graphNode = graph.nodes.get(caller.name);
+        const hasErrorPath = graphNode?.outputs.some(out => {
+            const action = actions.find(a => a.name === out);
+            return action?.runIf && JSON.stringify(action.runIf).includes("error");
+        });
+        if (!hasErrorPath) {
+            opportunities.push({
+                id: `add-error-handling-${caller.name}`,
+                type: "add_error_handling",
+                severity: "recommended",
+                title: "Add Error Handling",
+                current_state: `External action ${caller.name} has no error handling path`,
+                proposed_change: "Add conditional path for handling failures gracefully",
+                benefit: "Better user experience when external services fail",
+                risk: "none",
+                auto_applicable: false,
+                affected_nodes: [caller.name],
+                implementation_hint: "Add runIf condition checking for error status, route to fallback response",
+            });
+        }
+    }
+    return opportunities;
+}
+function findLlmOptimizations(actions, graph) {
+    const opportunities = [];
+    const llmNodes = actions.filter(a => a.action?.name?.name?.includes("llm") ||
+        a.action?.name?.name?.includes("respond"));
+    // Check for call_llm being used instead of respond_with_sources for search results
+    for (const node of llmNodes) {
+        const type = node.action?.name?.name || "";
+        const graphNode = graph.nodes.get(node.name);
+        if (type === "call_llm" && graphNode) {
+            // Check if input comes from search
+            const hasSearchInput = graphNode.inputs.some(input => {
+                const inputAction = actions.find(a => a.name === input);
+                return inputAction?.action?.name?.name?.includes("search");
+            });
+            if (hasSearchInput) {
+                opportunities.push({
+                    id: `use-respond-with-sources-${node.name}`,
+                    type: "improve_response_quality",
+                    severity: "recommended",
+                    title: "Use Purpose-Built Response Node",
+                    current_state: `${node.name} uses call_llm for search-based responses`,
+                    proposed_change: "Replace with respond_with_sources for better citation handling",
+                    benefit: "Better citations, grounded responses, less configuration needed",
+                    risk: "low",
+                    auto_applicable: false,
+                    affected_nodes: [node.name],
+                });
+            }
+        }
+    }
+    return opportunities;
+}
+function findSearchOptimizations(actions, graph) {
+    const opportunities = [];
+    // Check for web search without KB search
+    const hasKbSearch = actions.some(a => a.action?.name?.name === "search" ||
+        a.action?.name?.name?.includes("file_search"));
+    const hasWebSearch = actions.some(a => a.action?.name?.name?.includes("web_search") ||
+        a.action?.name?.name?.includes("live_web"));
+    if (hasWebSearch && !hasKbSearch) {
+        opportunities.push({
+            id: "add-kb-search",
+            type: "optimize_search",
+            severity: "recommended",
+            title: "Add Knowledge Base Search",
+            current_state: "Workflow uses web search but no internal KB search",
+            proposed_change: "Add KB search as primary source, use web search as supplement",
+            benefit: "Faster responses, more controlled content, reduced external dependencies",
+            risk: "none",
+            auto_applicable: false,
+            affected_nodes: actions.filter(a => a.action?.name?.name?.includes("web")).map(a => a.name),
+        });
+    }
+    return opportunities;
+}
+function findNamingImprovements(actions) {
+    const opportunities = [];
+    // Check for generic names
+    const genericPatterns = [
+        /^node_\d+$/i,
+        /^action_\d+$/i,
+        /^step_\d+$/i,
+        /^untitled/i,
+        /^new_/i,
+    ];
+    const poorlyNamed = actions.filter(a => genericPatterns.some(p => p.test(a.name)) ||
+        genericPatterns.some(p => p.test(a.actionDisplayName || "")));
+    if (poorlyNamed.length > 0) {
+        opportunities.push({
+            id: "improve-naming",
+            type: "improve_naming",
+            severity: "suggestion",
+            title: "Improve Node Naming",
+            current_state: `${poorlyNamed.length} nodes have generic names: ${poorlyNamed.map(n => n.name).join(", ")}`,
+            proposed_change: "Use descriptive names that indicate purpose (e.g., 'search_customer_faq', 'respond_billing_inquiry')",
+            benefit: "Better maintainability, easier debugging, clearer workflow understanding",
+            risk: "none",
+            auto_applicable: false,
+            affected_nodes: poorlyNamed.map(n => n.name),
+        });
+    }
+    return opportunities;
+}
+function findSafetyImprovements(actions, graph) {
+    const opportunities = [];
+    // Check for external actions without HITL
+    const sideEffectNodes = actions.filter(a => {
+        const type = a.action?.name?.name || "";
+        return type.includes("email") ||
+            type.includes("external") ||
+            type.includes("create_") ||
+            type.includes("update_") ||
+            type.includes("delete_");
+    });
+    const hitlNodes = actions.filter(a => a.action?.name?.name?.includes("hitl"));
+    for (const sideEffect of sideEffectNodes) {
+        const graphNode = graph.nodes.get(sideEffect.name);
+        if (!graphNode)
+            continue;
+        // Check if there's a HITL node upstream
+        const hasUpstreamHitl = graphNode.inputs.some(input => hitlNodes.some(h => h.name === input));
+        if (!hasUpstreamHitl) {
+            opportunities.push({
+                id: `add-hitl-${sideEffect.name}`,
+                type: "add_hitl_for_safety",
+                severity: "important",
+                title: "Add Human Approval Before Side Effect",
+                current_state: `${sideEffect.name} can execute without human confirmation`,
+                proposed_change: "Add HITL node before this action to confirm before execution",
+                benefit: "Prevent unintended external actions, maintain human oversight",
+                risk: "none",
+                auto_applicable: false,
+                affected_nodes: [sideEffect.name],
+                implementation_hint: "Insert general_hitl between the previous node and this action, add both success and failure paths",
+            });
+        }
+    }
+    return opportunities;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Health Score Calculation
+// ─────────────────────────────────────────────────────────────────────────────
+function calculateWorkflowHealth(actions, metrics, optimizations) {
+    let score = 100;
+    // Deduct for optimizations based on severity
+    for (const opt of optimizations) {
+        switch (opt.severity) {
+            case "important":
+                score -= 15;
+                break;
+            case "recommended":
+                score -= 8;
+                break;
+            case "suggestion":
+                score -= 3;
+                break;
+        }
+    }
+    // Deduct for high complexity
+    if (metrics.complexity_score > 70) {
+        score -= 10;
+    }
+    else if (metrics.complexity_score > 50) {
+        score -= 5;
+    }
+    // Deduct for high redundancy
+    if (metrics.redundancy_score > 30) {
+        score -= 10;
+    }
+    else if (metrics.redundancy_score > 10) {
+        score -= 5;
+    }
+    // Deduct for many sequential latency factors
+    if (metrics.estimated_latency_factors > 5) {
+        score -= 10;
+    }
+    else if (metrics.estimated_latency_factors > 3) {
+        score -= 5;
+    }
+    // Bonus for good practices
+    const hasTrigger = actions.some(a => a.action?.name?.name?.includes("trigger"));
+    const hasResponse = actions.some(a => a.action?.name?.name?.includes("respond") ||
+        a.action?.name?.name?.includes("llm"));
+    if (hasTrigger && hasResponse) {
+        score = Math.min(score + 5, 100);
+    }
+    return Math.max(score, 0);
+}
+function healthScoreToGrade(score) {
+    if (score >= 90)
+        return "A";
+    if (score >= 80)
+        return "B";
+    if (score >= 70)
+        return "C";
+    if (score >= 60)
+        return "D";
+    return "F";
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Recommendations Generator
+// ─────────────────────────────────────────────────────────────────────────────
+function generateRecommendations(optimizations, metrics, healthScore) {
+    const recommendations = [];
+    // Top priority optimizations
+    const important = optimizations.filter(o => o.severity === "important");
+    if (important.length > 0) {
+        recommendations.push(`🔴 Address ${important.length} important issue(s): ${important.map(o => o.title).join(", ")}`);
+    }
+    // Quick wins
+    const quickWins = optimizations.filter(o => o.auto_applicable && o.risk === "none");
+    if (quickWins.length > 0) {
+        recommendations.push(`✅ ${quickWins.length} quick win(s) available for immediate improvement`);
+    }
+    // Complexity warning
+    if (metrics.complexity_score > 60) {
+        recommendations.push(`⚠️ High complexity (${metrics.complexity_score}/100). Consider simplifying or breaking into sub-workflows.`);
+    }
+    // Latency warning
+    if (metrics.estimated_latency_factors > 4) {
+        recommendations.push(`⏱️ High latency risk: ${metrics.estimated_latency_factors} sequential LLM/search calls. Consider parallelization.`);
+    }
+    // Redundancy warning
+    if (metrics.redundancy_score > 20) {
+        recommendations.push(`🔄 Redundancy detected (${metrics.redundancy_score}/100). Consider consolidating duplicate operations.`);
+    }
+    // Overall assessment
+    if (healthScore >= 90) {
+        recommendations.push("🌟 Excellent workflow health! Minor optimizations optional.");
+    }
+    else if (healthScore >= 70) {
+        recommendations.push("👍 Good workflow health. Apply recommended optimizations for best results.");
+    }
+    else if (healthScore >= 50) {
+        recommendations.push("⚠️ Workflow needs attention. Apply important fixes first.");
+    }
+    else {
+        recommendations.push("🚨 Workflow needs significant improvements. Review all recommendations.");
+    }
+    return recommendations;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Utilities
+// ─────────────────────────────────────────────────────────────────────────────
+function getQuerySource(action) {
+    const queryInput = action.inputs?.query;
+    const actionOutput = queryInput?.actionOutput;
+    if (actionOutput) {
+        return `${actionOutput.actionName}.${actionOutput.output}`;
+    }
+    return "unknown";
+}
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36).substring(0, 8);
+}
+/**
+ * Get a human-readable summary of the optimization report
+ */
+export function summarizeOptimizationReport(report) {
+    const lines = [];
+    lines.push(`## Workflow Health Report`);
+    lines.push("");
+    lines.push(`**Health Score**: ${report.workflow_health_score}/100 (Grade: ${report.grade})`);
+    lines.push("");
+    lines.push("### Metrics");
+    lines.push(`- Nodes: ${report.metrics.total_nodes}`);
+    lines.push(`- Max Depth: ${report.metrics.max_depth}`);
+    lines.push(`- Branches: ${report.metrics.branch_count}`);
+    lines.push(`- Complexity: ${report.metrics.complexity_score}/100`);
+    lines.push(`- Redundancy: ${report.metrics.redundancy_score}/100`);
+    lines.push(`- Latency Factors: ${report.metrics.estimated_latency_factors}`);
+    lines.push("");
+    if (report.quick_wins.length > 0) {
+        lines.push("### Quick Wins");
+        for (const opt of report.quick_wins) {
+            lines.push(`- **${opt.title}**: ${opt.proposed_change}`);
+        }
+        lines.push("");
+    }
+    if (report.strategic.length > 0) {
+        lines.push("### Strategic Improvements");
+        for (const opt of report.strategic) {
+            const severity = opt.severity === "important" ? "🔴" :
+                opt.severity === "recommended" ? "🟡" : "🟢";
+            lines.push(`${severity} **${opt.title}**: ${opt.current_state}`);
+            lines.push(`   → ${opt.proposed_change}`);
+        }
+        lines.push("");
+    }
+    lines.push("### Recommendations");
+    for (const rec of report.recommendations) {
+        lines.push(`- ${rec}`);
+    }
+    return lines.join("\n");
+}