@path58/n8n-mcp 0.1.0

package/dist/autofix/suggestion-fixers/l6-pattern-fixer.js

@@ -0,0 +1,1475 @@
+/**
+ * L6 Pattern Fixers
+ *
+ * RAG-2.2.93.9: L6 Pattern Fixers
+ * Fixes L6 pattern validation problems from validation_problems:
+ * - L6_NO_RETRY_ON_HTTP: Adds retry configuration to HTTP nodes
+ * - L6_DEAD_END_NODE: Connects dead ends to output or error handler
+ * - L6_ERROR_OUTPUT_UNCONNECTED: Connects error outputs or enables continueOnFail
+ * - L6_INVALID_EXPRESSION_SYNTAX: Fixes unbalanced braces
+ * - L6_UNBALANCED_BRACES: Balances {{ }} braces in expressions
+ * - L6_NO_TRIGGER: Adds manual trigger when missing
+ * - L6_HARDCODED_URL: Records as gap (not auto-fixable)
+ *
+ * @module suggestion-fixers/l6-pattern-fixer
+ * @created 2026-01-23
+ */
+import { cloneWorkflow } from './types.js';
+import { logger } from '@tsvika58/shared-utilities/logging';
+/**
+ * Create a failure result with consistent format.
+ */
+function createFailureResult(fixerName, problemCode, reason) {
+    return {
+        success: false,
+        changes: [],
+        reason,
+        confidence: 0,
+        fixer_name: fixerName,
+        problem_code: problemCode,
+    };
+}
+/**
+ * Create a success result with consistent format.
+ */
+function createSuccessResult(fixerName, problemCode, workflow, changes, confidence) {
+    return {
+        success: true,
+        fixedWorkflow: workflow,
+        changes,
+        confidence,
+        fixer_name: fixerName,
+        problem_code: problemCode,
+    };
+}
+/**
+ * Find a node by ID or name in the workflow.
+ */
+function findNode(workflow, nodeId, nodeName) {
+    if (nodeId) {
+        const nodeById = workflow.nodes.find((n) => n.id === nodeId);
+        if (nodeById)
+            return nodeById;
+    }
+    if (nodeName) {
+        return workflow.nodes.find((n) => n.name === nodeName);
+    }
+    return undefined;
+}
+/**
+ * Extract node name from problem description.
+ * Handles patterns like:
+ * - HTTP node "Download Audio" has no retry configuration
+ * - Node "Some Name" is a dead end
+ */
+function extractNodeNameFromDescription(description) {
+    if (!description)
+        return undefined;
+    // Match quoted node name: "NodeName"
+    const quotedMatch = description.match(/(?:node|Node)\s+"([^"]+)"/);
+    if (quotedMatch) {
+        return quotedMatch[1];
+    }
+    // Match single-quoted node name: 'NodeName'
+    const singleQuotedMatch = description.match(/(?:node|Node)\s+'([^']+)'/);
+    if (singleQuotedMatch) {
+        return singleQuotedMatch[1];
+    }
+    return undefined;
+}
+/**
+ * Generate a unique node ID.
+ */
+function generateNodeId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+// ============================================================
+// L6 RETRY FIXER
+// ============================================================
+/**
+ * L6RetryFixer - Adds retry configuration to HTTP nodes
+ *
+ * Handles L6_NO_RETRY_ON_HTTP problems by:
+ * 1. Finding the HTTP node
+ * 2. Adding standard retry configuration
+ *
+ * Confidence: 0.90 (HIGH - standard retry config is safe)
+ * Auto-applicable: Yes - adding retry doesn't change workflow semantics
+ */
+export class L6RetryFixer {
+    name = 'L6RetryFixer';
+    description = 'Adds retry configuration to HTTP nodes';
+    supportedCodes = ['L6_NO_RETRY_ON_HTTP'];
+    minConfidence = 0.90;
+    canFix(problem) {
+        return problem.level === 'L6' && problem.code === 'L6_NO_RETRY_ON_HTTP';
+    }
+    fix(workflow, problem) {
+        if (!this.canFix(problem)) {
+            return createFailureResult(this.name, problem.code, 'Problem does not meet requirements for L6RetryFixer');
+        }
+        // Try to find node by id/name, or fallback to extracting from description
+        const nodeNameFromDesc = extractNodeNameFromDescription(problem.description);
+        const node = findNode(workflow, problem.node_id, problem.node_name) ||
+            (nodeNameFromDesc ? findNode(workflow, undefined, nodeNameFromDesc) : undefined);
+        if (!node) {
+            return createFailureResult(this.name, problem.code, `Node not found: ${problem.node_id || problem.node_name || nodeNameFromDesc || 'unknown'}`);
+        }
+        const fixedWorkflow = cloneWorkflow(workflow);
+        const targetNode = findNode(fixedWorkflow, node.id, node.name);
+        // Store old values for change tracking
+        const oldRetryOnFail = targetNode.retryOnFail;
+        const oldMaxTries = targetNode.maxTries;
+        const oldWaitBetweenTries = targetNode.waitBetweenTries;
+        const oldOnError = targetNode.onError;
+        // Add retry configuration
+        targetNode.retryOnFail = true;
+        targetNode.maxTries = 3;
+        targetNode.waitBetweenTries = 1000;
+        targetNode.onError = 'continueErrorOutput';
+        const change = {
+            change_type: 'parameter_update',
+            node_id: targetNode.id,
+            node_name: targetNode.name,
+            field: 'retryConfig',
+            old_value: {
+                retryOnFail: oldRetryOnFail,
+                maxTries: oldMaxTries,
+                waitBetweenTries: oldWaitBetweenTries,
+                onError: oldOnError,
+            },
+            new_value: {
+                retryOnFail: true,
+                maxTries: 3,
+                waitBetweenTries: 1000,
+                onError: 'continueErrorOutput',
+            },
+            confidence: 0.90,
+            description: `Added retry configuration to HTTP node "${targetNode.name}" (3 retries, 1000ms delay)`,
+        };
+        logger.info('L6RetryFixer applied fix', {
+            node_name: targetNode.name,
+            problem_code: problem.code,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], 0.90);
+    }
+}
+// ============================================================
+// L6 ERROR OUTPUT FIXER
+// ============================================================
+/**
+ * L6ErrorOutputFixer - Enables continueOnFail for nodes with unconnected error outputs
+ *
+ * Handles L6_ERROR_OUTPUT_UNCONNECTED problems by:
+ * 1. Finding the node
+ * 2. Enabling continueOnFail to handle errors gracefully
+ *
+ * Confidence: 0.80 (HIGH - enabling error handling is safe)
+ * Auto-applicable: Yes - doesn't change workflow semantics significantly
+ */
+export class L6ErrorOutputFixer {
+    name = 'L6ErrorOutputFixer';
+    description = 'Enables continueOnFail for nodes with unconnected error outputs';
+    supportedCodes = ['L6_ERROR_OUTPUT_UNCONNECTED'];
+    minConfidence = 0.80;
+    canFix(problem) {
+        return problem.level === 'L6' && problem.code === 'L6_ERROR_OUTPUT_UNCONNECTED';
+    }
+    fix(workflow, problem) {
+        if (!this.canFix(problem)) {
+            return createFailureResult(this.name, problem.code, 'Problem does not meet requirements for L6ErrorOutputFixer');
+        }
+        // Try to find node by id/name, or fallback to extracting from description
+        const nodeNameFromDesc = extractNodeNameFromDescription(problem.description);
+        const node = findNode(workflow, problem.node_id, problem.node_name) ||
+            (nodeNameFromDesc ? findNode(workflow, undefined, nodeNameFromDesc) : undefined);
+        if (!node) {
+            return createFailureResult(this.name, problem.code, `Node not found: ${problem.node_id || problem.node_name || nodeNameFromDesc || 'unknown'}`);
+        }
+        const fixedWorkflow = cloneWorkflow(workflow);
+        const targetNode = findNode(fixedWorkflow, node.id, node.name);
+        // Store old values
+        const oldContinueOnFail = targetNode.continueOnFail;
+        const oldOnError = targetNode.onError;
+        // Enable error handling
+        targetNode.continueOnFail = true;
+        targetNode.onError = 'continueRegularOutput';
+        const change = {
+            change_type: 'parameter_update',
+            node_id: targetNode.id,
+            node_name: targetNode.name,
+            field: 'errorHandling',
+            old_value: {
+                continueOnFail: oldContinueOnFail,
+                onError: oldOnError,
+            },
+            new_value: {
+                continueOnFail: true,
+                onError: 'continueRegularOutput',
+            },
+            confidence: 0.80,
+            description: `Enabled continueOnFail for node "${targetNode.name}" to handle errors gracefully`,
+        };
+        logger.info('L6ErrorOutputFixer applied fix', {
+            node_name: targetNode.name,
+            problem_code: problem.code,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], 0.80);
+    }
+}
+// ============================================================
+// L6 DEAD END FIXER
+// ============================================================
+/**
+ * L6DeadEndFixer - Handles dead end nodes
+ *
+ * Handles L6_DEAD_END_NODE problems by:
+ * 1. Finding the dead end node
+ * 2. Attempting to connect to an existing terminal node or set node
+ * 3. If no suitable target, marks node with noOp flag
+ *
+ * Confidence: 0.60 (MEDIUM - requires context to determine correct action)
+ * Auto-applicable: No - connection decisions require human judgment
+ */
+export class L6DeadEndFixer {
+    name = 'L6DeadEndFixer';
+    description = 'Handles dead end nodes by connecting or marking as intentional';
+    supportedCodes = ['L6_DEAD_END_NODE'];
+    minConfidence = 0.60;
+    canFix(problem) {
+        return problem.level === 'L6' && problem.code === 'L6_DEAD_END_NODE';
+    }
+    fix(workflow, problem) {
+        if (!this.canFix(problem)) {
+            return createFailureResult(this.name, problem.code, 'Problem does not meet requirements for L6DeadEndFixer');
+        }
+        // Try to find node by id/name, or fallback to extracting from description
+        const nodeNameFromDesc = extractNodeNameFromDescription(problem.description);
+        const node = findNode(workflow, problem.node_id, problem.node_name) ||
+            (nodeNameFromDesc ? findNode(workflow, undefined, nodeNameFromDesc) : undefined);
+        if (!node) {
+            return createFailureResult(this.name, problem.code, `Node not found: ${problem.node_id || problem.node_name || nodeNameFromDesc || 'unknown'}`);
+        }
+        const fixedWorkflow = cloneWorkflow(workflow);
+        // Strategy: Find the closest downstream node based on position
+        // and connect to it, or add a NoOp node
+        const targetNode = this.findBestTargetNode(workflow, node);
+        if (targetNode) {
+            // Connect to the found target
+            return this.connectToTarget(fixedWorkflow, node, targetNode, problem);
+        }
+        // No suitable target found - add noOp node as endpoint
+        return this.addNoOpEndpoint(fixedWorkflow, node, problem);
+    }
+    /**
+     * Find the best target node to connect to.
+     * Looks for Set, NoOp, or response nodes downstream.
+     */
+    findBestTargetNode(workflow, sourceNode) {
+        const terminalTypes = [
+            'n8n-nodes-base.respondToWebhook',
+            'n8n-nodes-base.stopAndError',
+            'n8n-nodes-base.noOp',
+            'n8n-nodes-base.set',
+        ];
+        // Find terminal nodes to the right of the source
+        const candidates = workflow.nodes.filter((n) => {
+            if (n.name === sourceNode.name)
+                return false;
+            if (n.position[0] <= sourceNode.position[0])
+                return false;
+            return terminalTypes.some((t) => n.type.toLowerCase().includes(t.toLowerCase().split('.')[1]));
+        });
+        if (candidates.length === 0)
+            return null;
+        // Return the closest one
+        return candidates.sort((a, b) => {
+            const distA = Math.abs(a.position[0] - sourceNode.position[0]) +
+                Math.abs(a.position[1] - sourceNode.position[1]);
+            const distB = Math.abs(b.position[0] - sourceNode.position[0]) +
+                Math.abs(b.position[1] - sourceNode.position[1]);
+            return distA - distB;
+        })[0];
+    }
+    /**
+     * Connect source node to target node.
+     */
+    connectToTarget(workflow, sourceNode, targetNode, problem) {
+        const fixedWorkflow = cloneWorkflow(workflow);
+        const sourceNodeName = sourceNode.name;
+        // Ensure connections object exists
+        if (!fixedWorkflow.connections[sourceNodeName]) {
+            fixedWorkflow.connections[sourceNodeName] = { main: [] };
+        }
+        if (!fixedWorkflow.connections[sourceNodeName].main) {
+            fixedWorkflow.connections[sourceNodeName].main = [];
+        }
+        // Add connection to first output
+        const outputs = fixedWorkflow.connections[sourceNodeName].main;
+        if (outputs.length === 0) {
+            outputs.push([]);
+        }
+        outputs[0].push({
+            node: targetNode.name,
+            type: 'main',
+            index: 0,
+        });
+        const change = {
+            change_type: 'parameter_update',
+            node_id: sourceNode.id,
+            node_name: sourceNode.name,
+            field: 'connections',
+            old_value: null,
+            new_value: { target: targetNode.name, type: 'main', index: 0 },
+            confidence: 0.60,
+            description: `Connected dead end "${sourceNode.name}" to existing node "${targetNode.name}"`,
+        };
+        logger.info('L6DeadEndFixer connected to existing node', {
+            source: sourceNode.name,
+            target: targetNode.name,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], 0.60);
+    }
+    /**
+     * Add a NoOp node as endpoint and connect to it.
+     */
+    addNoOpEndpoint(workflow, sourceNode, problem) {
+        const fixedWorkflow = cloneWorkflow(workflow);
+        // Create NoOp node
+        const noOpNode = {
+            id: generateNodeId(),
+            type: 'n8n-nodes-base.noOp',
+            name: `${sourceNode.name} End`,
+            position: [sourceNode.position[0] + 200, sourceNode.position[1]],
+            parameters: {},
+            typeVersion: 1,
+        };
+        // Add node to workflow
+        fixedWorkflow.nodes.push(noOpNode);
+        // Connect source to NoOp
+        if (!fixedWorkflow.connections[sourceNode.name]) {
+            fixedWorkflow.connections[sourceNode.name] = { main: [] };
+        }
+        if (!fixedWorkflow.connections[sourceNode.name].main) {
+            fixedWorkflow.connections[sourceNode.name].main = [];
+        }
+        const outputs = fixedWorkflow.connections[sourceNode.name].main;
+        if (outputs.length === 0) {
+            outputs.push([]);
+        }
+        outputs[0].push({
+            node: noOpNode.name,
+            type: 'main',
+            index: 0,
+        });
+        const change = {
+            change_type: 'parameter_update',
+            node_id: sourceNode.id,
+            node_name: sourceNode.name,
+            field: 'connections',
+            old_value: null,
+            new_value: { addedNode: noOpNode.name, type: 'noOp' },
+            confidence: 0.50,
+            description: `Added NoOp endpoint and connected dead end "${sourceNode.name}" to it`,
+        };
+        logger.info('L6DeadEndFixer added NoOp endpoint', {
+            source: sourceNode.name,
+            noOpNode: noOpNode.name,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], 0.50);
+    }
+}
+// ============================================================
+// L6 EXPRESSION FIXER
+// ============================================================
+/**
+ * L6ExpressionFixer - Fixes unbalanced braces in expressions
+ *
+ * Handles L6_UNBALANCED_BRACES and L6_INVALID_EXPRESSION_SYNTAX by:
+ * 1. Finding unbalanced {{ }} braces
+ * 2. Adding missing closing or opening braces
+ *
+ * Confidence: 0.85 (HIGH for simple brace balancing)
+ * Auto-applicable: Yes for simple cases
+ */
+export class L6ExpressionFixer {
+    name = 'L6ExpressionFixer';
+    description = 'Fixes unbalanced braces in expressions';
+    supportedCodes = ['L6_UNBALANCED_BRACES', 'L6_INVALID_EXPRESSION_SYNTAX'];
+    minConfidence = 0.85;
+    canFix(problem) {
+        if (problem.level !== 'L6')
+            return false;
+        return (problem.code === 'L6_UNBALANCED_BRACES' ||
+            problem.code === 'L6_INVALID_EXPRESSION_SYNTAX');
+    }
+    fix(workflow, problem) {
+        if (!this.canFix(problem)) {
+            return createFailureResult(this.name, problem.code, 'Problem does not meet requirements for L6ExpressionFixer');
+        }
+        // Try to find node by id/name, or fallback to extracting from description
+        const nodeNameFromDesc = extractNodeNameFromDescription(problem.description);
+        const node = findNode(workflow, problem.node_id, problem.node_name) ||
+            (nodeNameFromDesc ? findNode(workflow, undefined, nodeNameFromDesc) : undefined);
+        if (!node) {
+            return createFailureResult(this.name, problem.code, `Node not found: ${problem.node_id || problem.node_name || nodeNameFromDesc || 'unknown'}`);
+        }
+        // RAG-2.2.93.14: Get expression from raw_error (validation_problems table structure)
+        // Try multiple sources: raw_error.suggested_fix, raw_error.context, details, or description
+        const expressionFix = problem.raw_error?.suggested_fix?.patch?.expression_fix;
+        const expression = expressionFix?.old_value ||
+            problem.raw_error?.suggested_fix?.context?.expression_preview ||
+            problem.details?.expression ||
+            problem.details?.expression_preview;
+        if (!expression) {
+            // Log for debugging but flag for review instead of failing silently
+            logger.info('L6ExpressionFixer: No expression found, flagging for manual review', {
+                node_name: problem.node_name,
+                problem_code: problem.code,
+                has_raw_error: !!problem.raw_error,
+                has_suggested_fix: !!problem.raw_error?.suggested_fix,
+            });
+            return createFailureResult(this.name, problem.code, 'No expression found in raw_error or details - requires manual review');
+        }
+        // Get field path from raw_error if available
+        const fieldPath = expressionFix?.field_path ||
+            problem.path?.replace(/^nodes\.[^.]+\./, '') ||
+            '';
+        // Fix the expression
+        const fixedExpression = this.balanceBraces(expression);
+        if (fixedExpression === expression) {
+            // If we can't fix via brace balancing, check if raw_error has a suggested new_value
+            const suggestedFix = expressionFix?.new_value;
+            if (suggestedFix && suggestedFix !== expression) {
+                // Use the validator's suggested fix
+                return this.applyExpressionFix(workflow, node, expression, suggestedFix, fieldPath, problem);
+            }
+            logger.info('L6ExpressionFixer: Expression could not be auto-fixed', {
+                node_name: problem.node_name,
+                expression_preview: expression.substring(0, 50),
+                syntax_error: problem.raw_error?.suggested_fix?.context?.syntax_error,
+            });
+            return createFailureResult(this.name, problem.code, `Expression syntax error cannot be auto-fixed: ${problem.raw_error?.suggested_fix?.context?.syntax_error || 'unknown'}`);
+        }
+        return this.applyExpressionFix(workflow, node, expression, fixedExpression, fieldPath, problem);
+    }
+    /**
+     * Apply an expression fix to the workflow
+     */
+    applyExpressionFix(workflow, node, oldExpression, newExpression, fieldPath, problem) {
+        const fixedWorkflow = cloneWorkflow(workflow);
+        const targetNode = findNode(fixedWorkflow, node.id, node.name);
+        // Apply fix to node parameters
+        if (fieldPath && targetNode.parameters) {
+            // Extract just the parameter path (remove 'nodes.NodeName.' prefix if present)
+            const paramPath = fieldPath
+                .replace(/^nodes\.[^.]+\./, '')
+                .replace(/^parameters\./, '');
+            this.setNestedValue(targetNode.parameters, paramPath, newExpression);
+        }
+        const change = {
+            change_type: 'parameter_update',
+            node_id: targetNode.id,
+            node_name: targetNode.name,
+            field: fieldPath || 'expression',
+            old_value: oldExpression,
+            new_value: newExpression,
+            confidence: 0.85,
+            description: `Fixed expression syntax: "${oldExpression.substring(0, 30)}..." → "${newExpression.substring(0, 30)}..."`,
+        };
+        logger.info('L6ExpressionFixer applied fix', {
+            node_name: targetNode.name,
+            original: oldExpression.substring(0, 50),
+            fixed: newExpression.substring(0, 50),
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], 0.85);
+    }
+    /**
+     * Balance {{ }} braces in an expression.
+     */
+    balanceBraces(expr) {
+        let opens = 0;
+        let closes = 0;
+        let i = 0;
+        // Count {{ and }} pairs
+        while (i < expr.length - 1) {
+            if (expr[i] === '{' && expr[i + 1] === '{') {
+                opens++;
+                i += 2;
+            }
+            else if (expr[i] === '}' && expr[i + 1] === '}') {
+                closes++;
+                i += 2;
+            }
+            else {
+                i++;
+            }
+        }
+        // Balance the braces
+        if (opens > closes) {
+            return expr + '}}'.repeat(opens - closes);
+        }
+        else if (closes > opens) {
+            return '{{'.repeat(closes - opens) + expr;
+        }
+        return expr;
+    }
+    /**
+     * Set a nested value in an object using dot notation path.
+     */
+    setNestedValue(obj, path, value) {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            // Handle array indexing like [0]
+            const arrayMatch = part.match(/^(.+)\[(\d+)\]$/);
+            if (arrayMatch) {
+                const [, key, index] = arrayMatch;
+                if (!current[key])
+                    current[key] = [];
+                if (!current[key][parseInt(index)])
+                    current[key][parseInt(index)] = {};
+                current = current[key][parseInt(index)];
+            }
+            else {
+                if (!current[part])
+                    current[part] = {};
+                current = current[part];
+            }
+        }
+        const lastPart = parts[parts.length - 1];
+        const lastArrayMatch = lastPart.match(/^(.+)\[(\d+)\]$/);
+        if (lastArrayMatch) {
+            const [, key, index] = lastArrayMatch;
+            if (!current[key])
+                current[key] = [];
+            current[key][parseInt(index)] = value;
+        }
+        else {
+            current[lastPart] = value;
+        }
+    }
+}
+// ============================================================
+// L6 TRIGGER FIXER
+// ============================================================
+/**
+ * L6TriggerFixer - Adds manual trigger when missing
+ *
+ * Handles L6_NO_TRIGGER problems by:
+ * 1. Adding a Manual Trigger node
+ * 2. Connecting it to the first non-trigger node
+ *
+ * Confidence: 0.90 (HIGH - manual trigger is safe default)
+ * Auto-applicable: Yes - adding trigger allows workflow execution
+ */
+export class L6TriggerFixer {
+    name = 'L6TriggerFixer';
+    description = 'Adds manual trigger when workflow has no trigger';
+    supportedCodes = ['L6_NO_TRIGGER'];
+    minConfidence = 0.90;
+    canFix(problem) {
+        return problem.level === 'L6' && problem.code === 'L6_NO_TRIGGER';
+    }
+    fix(workflow, problem) {
+        if (!this.canFix(problem)) {
+            return createFailureResult(this.name, problem.code, 'Problem does not meet requirements for L6TriggerFixer');
+        }
+        const fixedWorkflow = cloneWorkflow(workflow);
+        // Create Manual Trigger node
+        const triggerNode = {
+            id: generateNodeId(),
+            type: 'n8n-nodes-base.manualTrigger',
+            name: 'Manual Trigger',
+            position: this.calculateTriggerPosition(workflow),
+            parameters: {},
+            typeVersion: 1,
+        };
+        // Add trigger to workflow
+        fixedWorkflow.nodes.push(triggerNode);
+        // Find the first node to connect to (leftmost non-trigger)
+        const firstNode = this.findFirstNode(workflow);
+        if (firstNode) {
+            // Connect trigger to first node
+            fixedWorkflow.connections[triggerNode.name] = {
+                main: [[{ node: firstNode.name, type: 'main', index: 0 }]],
+            };
+        }
+        const change = {
+            change_type: 'parameter_update',
+            node_id: triggerNode.id,
+            node_name: triggerNode.name,
+            field: 'nodes',
+            old_value: null,
+            new_value: {
+                addedTrigger: triggerNode.name,
+                connectedTo: firstNode?.name || null,
+            },
+            confidence: 0.90,
+            description: `Added Manual Trigger and connected to "${firstNode?.name || 'workflow'}"`,
+        };
+        logger.info('L6TriggerFixer applied fix', {
+            trigger: triggerNode.name,
+            connectedTo: firstNode?.name,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], 0.90);
+    }
+    /**
+     * Calculate position for new trigger node (left of all existing nodes).
+     */
+    calculateTriggerPosition(workflow) {
+        if (workflow.nodes.length === 0) {
+            return [250, 300];
+        }
+        const minX = Math.min(...workflow.nodes.map((n) => n.position[0]));
+        const avgY = workflow.nodes.reduce((sum, n) => sum + n.position[1], 0) / workflow.nodes.length;
+        return [minX - 250, avgY];
+    }
+    /**
+     * Find the first node in the workflow (leftmost).
+     */
+    findFirstNode(workflow) {
+        if (workflow.nodes.length === 0)
+            return null;
+        return workflow.nodes.reduce((leftmost, node) => {
+            if (node.position[0] < leftmost.position[0]) {
+                return node;
+            }
+            return leftmost;
+        });
+    }
+}
+// ============================================================
+// L6 HARDCODED URL GAP RECORDER
+// ============================================================
+/**
+ * L6HardcodedUrlHandler - Records hardcoded URLs as gaps (not auto-fixable)
+ *
+ * Handles L6_HARDCODED_URL by recording to factory.gaps table.
+ * These are NOT auto-fixable because:
+ * 1. URLs may be intentionally hardcoded for specific environments
+ * 2. Replacing requires knowledge of target environment
+ * 3. Security decision requires human review
+ *
+ * This "fixer" returns success: false but records the gap.
+ */
+export class L6HardcodedUrlHandler {
+    name = 'L6HardcodedUrlHandler';
+    description = 'Records hardcoded URLs as gaps (not auto-fixable)';
+    supportedCodes = ['L6_HARDCODED_URL'];
+    minConfidence = 0.0; // Not auto-applicable
+    canFix(problem) {
+        return problem.level === 'L6' && problem.code === 'L6_HARDCODED_URL';
+    }
+    fix(workflow, problem) {
+        // This handler records the gap but doesn't actually fix anything
+        // The gap recording happens in the pipeline, not here
+        logger.info('L6HardcodedUrlHandler: Gap recorded (not auto-fixable)', {
+            workflow_id: workflow.id,
+            node_name: problem.node_name,
+            code: problem.code,
+        });
+        return {
+            success: false,
+            changes: [],
+            reason: 'HARDCODED_URL is not auto-fixable - recorded as gap for manual review',
+            confidence: 0,
+            fixer_name: this.name,
+            problem_code: problem.code,
+        };
+    }
+}
+// ============================================================
+// L6 UNREACHABLE NODE FIXER v2 (RAG-2.2.108.1)
+// ============================================================
+/**
+ * Confidence thresholds for position-based connection algorithm
+ * RAG-2.2.108.1: Named constants for position-based confidence tiers
+ */
+const UNREACHABLE_FIXER_CONFIG = {
+    /** Y-distance threshold for same-row nodes (pixels) */
+    SAME_ROW_THRESHOLD: 50,
+    /** Y-distance threshold for close-row nodes (pixels) */
+    CLOSE_ROW_THRESHOLD: 150,
+    /** Confidence for same-row connections */
+    SAME_ROW_CONFIDENCE: 0.90,
+    /** Confidence for close-row connections */
+    CLOSE_ROW_CONFIDENCE: 0.75,
+    /** Confidence for distant nodes (manual review) */
+    DISTANT_CONFIDENCE: 0.40,
+    /** Confidence for disabled node skip */
+    DISABLED_NODE_CONFIDENCE: 1.0,
+    /** Confidence for duplicate trigger detection */
+    DUPLICATE_TRIGGER_CONFIDENCE: 0.90,
+};
+/**
+ * Known trigger node types for duplicate trigger detection
+ * RAG-2.2.108.1: List of node types that act as workflow entry points
+ */
+const TRIGGER_NODE_TYPES = new Set([
+    'n8n-nodes-base.webhook',
+    'n8n-nodes-base.manualTrigger',
+    'n8n-nodes-base.scheduleTrigger',
+    'n8n-nodes-base.cron',
+    'n8n-nodes-base.emailReadImap',
+    'n8n-nodes-base.emailTrigger',
+    'n8n-nodes-base.telegramTrigger',
+    'n8n-nodes-base.slackTrigger',
+    'n8n-nodes-base.githubTrigger',
+    'n8n-nodes-base.gitlabTrigger',
+    'n8n-nodes-base.stripeTrigger',
+    'n8n-nodes-base.shopifyTrigger',
+    'n8n-nodes-base.airtableTrigger',
+    'n8n-nodes-base.googleSheetsTrigger',
+    'n8n-nodes-base.formTrigger',
+    'n8n-nodes-base.executeWorkflowTrigger',
+]);
+/**
+ * Check if a node type is a trigger type
+ */
+function isTriggerType(nodeType) {
+    const lowerType = nodeType.toLowerCase();
+    // Check exact match
+    if (TRIGGER_NODE_TYPES.has(lowerType))
+        return true;
+    // Check if ends with 'trigger' (catches custom/community triggers)
+    return lowerType.endsWith('trigger');
+}
+/**
+ * Calculate the Y-distance between two nodes
+ */
+function calculateYDistance(node1, node2) {
+    return Math.abs(node1.position[1] - node2.position[1]);
+}
+/**
+ * Find all upstream nodes (nodes to the left that could potentially connect)
+ */
+function findUpstreamNodes(workflow, targetNode) {
+    return workflow.nodes.filter((node) => {
+        // Must be to the left of target
+        if (node.position[0] >= targetNode.position[0])
+            return false;
+        // Must not be the same node
+        if (node.id === targetNode.id || node.name === targetNode.name)
+            return false;
+        // Exclude sticky notes and other non-flow nodes
+        const lowerType = node.type.toLowerCase();
+        if (lowerType.includes('stickynote') || lowerType.includes('noop'))
+            return false;
+        return true;
+    });
+}
+/**
+ * Find the closest upstream node by Y-distance
+ */
+function findClosestUpstreamByY(upstreamNodes, targetNode) {
+    if (upstreamNodes.length === 0)
+        return null;
+    let closest = upstreamNodes[0];
+    let minYDistance = calculateYDistance(closest, targetNode);
+    for (const node of upstreamNodes) {
+        const yDistance = calculateYDistance(node, targetNode);
+        if (yDistance < minYDistance) {
+            minYDistance = yDistance;
+            closest = node;
+        }
+    }
+    return { node: closest, yDistance: minYDistance };
+}
+/**
+ * Determine confidence tier based on Y-distance
+ */
+function getConfidenceTier(yDistance) {
+    if (yDistance < UNREACHABLE_FIXER_CONFIG.SAME_ROW_THRESHOLD) {
+        return { confidence: UNREACHABLE_FIXER_CONFIG.SAME_ROW_CONFIDENCE, tier: 'same-row' };
+    }
+    if (yDistance < UNREACHABLE_FIXER_CONFIG.CLOSE_ROW_THRESHOLD) {
+        return { confidence: UNREACHABLE_FIXER_CONFIG.CLOSE_ROW_CONFIDENCE, tier: 'close-row' };
+    }
+    return { confidence: UNREACHABLE_FIXER_CONFIG.DISTANT_CONFIDENCE, tier: 'distant' };
+}
+/**
+ * L6UnreachableNodeFixerV2 - Position-based unreachable node fixer
+ *
+ * RAG-2.2.108.1: Replaces the always-fail handler with intelligent fixes:
+ * 1. Skip disabled nodes (confidence 1.0, not an error)
+ * 2. Flag duplicate triggers (confidence 0.90)
+ * 3. Same-row connection (Y-distance <50px → confidence 0.90)
+ * 4. Close-row connection (Y-distance <150px → confidence 0.75)
+ * 5. Distant nodes flag for manual review (confidence 0.40)
+ *
+ * Expected Impact: ~77% of unreachable nodes auto-fixed (same-row instances)
+ */
+export class L6UnreachableNodeFixerV2 {
+    name = 'L6UnreachableNodeFixerV2';
+    description = 'Position-based unreachable node fixer with confidence tiers';
+    supportedCodes = ['L6_UNREACHABLE_NODE'];
+    minConfidence = 0.40;
+    canFix(problem) {
+        return problem.level === 'L6' && problem.code === 'L6_UNREACHABLE_NODE';
+    }
+    fix(workflow, problem) {
+        if (!this.canFix(problem)) {
+            return createFailureResult(this.name, problem.code, 'Problem does not meet requirements for L6UnreachableNodeFixerV2');
+        }
+        // Find the unreachable node
+        const nodeNameFromDesc = extractNodeNameFromDescription(problem.description);
+        const node = findNode(workflow, problem.node_id, problem.node_name) ||
+            (nodeNameFromDesc ? findNode(workflow, undefined, nodeNameFromDesc) : undefined);
+        if (!node) {
+            return createFailureResult(this.name, problem.code, `Node not found: ${problem.node_id || problem.node_name || nodeNameFromDesc || 'unknown'}`);
+        }
+        // Step 1: Check if node is disabled → SKIP (confidence 1.0, not an error)
+        if (this.isNodeDisabled(node)) {
+            return this.createSkipDisabledResult(node, problem);
+        }
+        // Step 2: Check if node is a trigger type
+        if (isTriggerType(node.type)) {
+            return this.handleTriggerNode(workflow, node, problem);
+        }
+        // Step 3-7: Position-based connection algorithm
+        return this.applyPositionBasedFix(workflow, node, problem);
+    }
+    /**
+     * Check if a node is disabled
+     */
+    isNodeDisabled(node) {
+        return node.disabled === true;
+    }
+    /**
+     * Create result for disabled node skip
+     */
+    createSkipDisabledResult(node, problem) {
+        logger.info('L6UnreachableNodeFixerV2: Skipping disabled node', {
+            node_name: node.name,
+            node_type: node.type,
+        });
+        // Disabled nodes should be skipped entirely - not an error
+        // Return success with confidence 1.0 and no changes needed
+        return {
+            success: true,
+            fixedWorkflow: undefined, // No workflow changes needed
+            changes: [{
+                    change_type: 'parameter_update',
+                    node_id: node.id,
+                    node_name: node.name,
+                    field: 'status',
+                    old_value: 'unreachable',
+                    new_value: 'disabled_skip',
+                    confidence: UNREACHABLE_FIXER_CONFIG.DISABLED_NODE_CONFIDENCE,
+                    description: `Skipped disabled node "${node.name}" - not an error`,
+                }],
+            confidence: UNREACHABLE_FIXER_CONFIG.DISABLED_NODE_CONFIDENCE,
+            fixer_name: this.name,
+            problem_code: problem.code,
+        };
+    }
+    /**
+     * Handle trigger-type nodes
+     */
+    handleTriggerNode(workflow, node, problem) {
+        // Count existing triggers in the workflow
+        const triggers = workflow.nodes.filter((n) => isTriggerType(n.type));
+        const otherTriggers = triggers.filter((t) => t.id !== node.id && t.name !== node.name);
+        if (otherTriggers.length > 0) {
+            // Another trigger exists → flag as duplicate trigger for removal
+            logger.info('L6UnreachableNodeFixerV2: Detected duplicate trigger', {
+                node_name: node.name,
+                node_type: node.type,
+                other_triggers: otherTriggers.map((t) => t.name),
+            });
+            return {
+                success: true,
+                fixedWorkflow: undefined, // No auto-removal, just flagged
+                changes: [{
+                        change_type: 'parameter_update',
+                        node_id: node.id,
+                        node_name: node.name,
+                        field: 'status',
+                        old_value: 'unreachable',
+                        new_value: 'duplicate_trigger',
+                        confidence: UNREACHABLE_FIXER_CONFIG.DUPLICATE_TRIGGER_CONFIDENCE,
+                        description: `Duplicate trigger "${node.name}" - consider removal (primary: ${otherTriggers[0].name})`,
+                    }],
+                confidence: UNREACHABLE_FIXER_CONFIG.DUPLICATE_TRIGGER_CONFIDENCE,
+                fixer_name: this.name,
+                problem_code: problem.code,
+            };
+        }
+        // Only trigger in workflow but unreachable - workflow has no entry point
+        logger.info('L6UnreachableNodeFixerV2: Orphan trigger (no entry point)', {
+            node_name: node.name,
+        });
+        return createFailureResult(this.name, problem.code, `Trigger "${node.name}" is unreachable and is the only trigger - workflow may have structural issues`);
+    }
+    /**
+     * Apply position-based fix algorithm
+     */
+    applyPositionBasedFix(workflow, node, problem) {
+        // Find all upstream nodes (to the left)
+        const upstreamNodes = findUpstreamNodes(workflow, node);
+        if (upstreamNodes.length === 0) {
+            // No upstream nodes available
+            logger.info('L6UnreachableNodeFixerV2: No upstream nodes found', {
+                node_name: node.name,
+            });
+            return createFailureResult(this.name, problem.code, `No upstream nodes found for "${node.name}" - may be orphaned or misplaced`);
+        }
+        // Find closest upstream by Y-distance
+        const closest = findClosestUpstreamByY(upstreamNodes, node);
+        if (!closest) {
+            return createFailureResult(this.name, problem.code, `Could not determine closest upstream for "${node.name}"`);
+        }
+        // Determine confidence tier
+        const { confidence, tier } = getConfidenceTier(closest.yDistance);
+        // If distant, flag for manual review
+        if (tier === 'distant') {
+            logger.info('L6UnreachableNodeFixerV2: Distant node flagged for review', {
+                node_name: node.name,
+                closest_upstream: closest.node.name,
+                y_distance: closest.yDistance,
+                confidence,
+            });
+            return {
+                success: false,
+                changes: [],
+                reason: `Unreachable node "${node.name}" is distant from closest upstream "${closest.node.name}" (Y-distance: ${closest.yDistance}px) - requires manual review`,
+                confidence,
+                fixer_name: this.name,
+                problem_code: problem.code,
+            };
+        }
+        // Same-row or close-row: apply connection fix
+        return this.createConnectionFix(workflow, node, closest.node, confidence, tier, problem);
+    }
+    /**
+     * Create connection fix between upstream and target node
+     */
+    createConnectionFix(workflow, targetNode, upstreamNode, confidence, tier, problem) {
+        const fixedWorkflow = cloneWorkflow(workflow);
+        // Ensure connections object exists for upstream node
+        if (!fixedWorkflow.connections[upstreamNode.name]) {
+            fixedWorkflow.connections[upstreamNode.name] = { main: [] };
+        }
+        if (!fixedWorkflow.connections[upstreamNode.name].main) {
+            fixedWorkflow.connections[upstreamNode.name].main = [];
+        }
+        // Add connection from upstream to target
+        const outputs = fixedWorkflow.connections[upstreamNode.name].main;
+        if (outputs.length === 0) {
+            outputs.push([]);
+        }
+        // Add to first available output
+        outputs[0].push({
+            node: targetNode.name,
+            type: 'main',
+            index: 0,
+        });
+        const yDistance = calculateYDistance(upstreamNode, targetNode);
+        const change = {
+            change_type: 'parameter_update',
+            node_id: targetNode.id,
+            node_name: targetNode.name,
+            field: 'connections',
+            old_value: null,
+            new_value: {
+                source: upstreamNode.name,
+                target: targetNode.name,
+                type: 'main',
+                index: 0,
+            },
+            confidence,
+            description: `Connected ${tier} node "${targetNode.name}" to upstream "${upstreamNode.name}" (Y-distance: ${yDistance}px)`,
+        };
+        logger.info('L6UnreachableNodeFixerV2: Applied connection fix', {
+            target: targetNode.name,
+            upstream: upstreamNode.name,
+            tier,
+            y_distance: yDistance,
+            confidence,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], confidence);
+    }
+}
+// Keep legacy handler for backward compatibility (deprecated)
+/**
+ * @deprecated Use L6UnreachableNodeFixerV2 instead
+ * L6UnreachableNodeHandler - Legacy handler that flags for manual review
+ */
+export class L6UnreachableNodeHandler {
+    name = 'L6UnreachableNodeHandler';
+    description = '[DEPRECATED] Use L6UnreachableNodeFixerV2 - Flags unreachable nodes for manual review';
+    supportedCodes = ['L6_UNREACHABLE_NODE'];
+    minConfidence = 0.40;
+    canFix(problem) {
+        return problem.level === 'L6' && problem.code === 'L6_UNREACHABLE_NODE';
+    }
+    fix(workflow, problem) {
+        // Delegate to V2 fixer
+        const v2Fixer = new L6UnreachableNodeFixerV2();
+        return v2Fixer.fix(workflow, problem);
+    }
+}
+// ============================================================
+// L6 DEAD END FIXER V2 (RAG-2.2.108.2)
+// ============================================================
+/**
+ * Configuration for dead-end fixer v2
+ * RAG-2.2.108.2: Named constants for terminal detection and confidence tiers
+ */
+const DEAD_END_FIXER_CONFIG = {
+    /** Confidence for valid terminal node skip */
+    VALID_TERMINAL_CONFIDENCE: 1.0,
+    /** Confidence for single downstream auto-connection */
+    SINGLE_DOWNSTREAM_CONFIDENCE: 0.90,
+    /** Confidence for closest-Y downstream with multiple targets */
+    MULTIPLE_DOWNSTREAM_CONFIDENCE: 0.75,
+    /** Confidence for NoOp addition on data transform dead-ends */
+    DATA_TRANSFORM_NOOP_CONFIDENCE: 0.85,
+    /** Confidence for flow control missing branch flag */
+    FLOW_CONTROL_FLAG_CONFIDENCE: 0.50,
+    /** Confidence for manual review flag */
+    MANUAL_REVIEW_CONFIDENCE: 0.50,
+};
+/**
+ * Valid terminal node types that should NOT be flagged as dead-ends
+ * RAG-2.2.108.2: These nodes are intentional endpoints
+ */
+const VALID_TERMINAL_TYPES = new Set([
+    // Always terminal - explicit workflow endpoints
+    'n8n-nodes-base.respondToWebhook',
+    'n8n-nodes-base.stopAndError',
+    'n8n-nodes-base.noOp',
+    // Messaging - final action nodes (send and done)
+    'n8n-nodes-base.slack',
+    'n8n-nodes-base.telegram',
+    'n8n-nodes-base.whatsApp',
+    'n8n-nodes-base.discord',
+    'n8n-nodes-base.microsoftTeams',
+    // AI response nodes
+    '@n8n/n8n-nodes-langchain.openAi',
+    '@n8n/n8n-nodes-langchain.chat',
+    '@n8n/n8n-nodes-langchain.agent',
+    '@n8n/n8n-nodes-langchain.chainLlm',
+    // Issue tracking / notification - final action nodes
+    'n8n-nodes-base.linear',
+    'n8n-nodes-base.zendesk',
+    'n8n-nodes-base.jira',
+    'n8n-nodes-base.emailSend',
+    'n8n-nodes-base.gmail',
+    // Database write operations (commonly terminal)
+    'n8n-nodes-base.postgres',
+    'n8n-nodes-base.mysql',
+    'n8n-nodes-base.mongoDb',
+    'n8n-nodes-base.redis',
+    // Webhook response
+    'n8n-nodes-base.respondToWebhook',
+]);
+/**
+ * Data transform node types that should get NoOp appended
+ * RAG-2.2.108.2: These nodes need a downstream to not lose data
+ */
+const DATA_TRANSFORM_TYPES = new Set([
+    'n8n-nodes-base.set',
+    'n8n-nodes-base.code',
+    'n8n-nodes-base.functionItem',
+    'n8n-nodes-base.function',
+    'n8n-nodes-base.itemLists',
+]);
+/**
+ * Flow control node types that may have missing branches
+ * RAG-2.2.108.2: These nodes need all branches connected
+ */
+const FLOW_CONTROL_TYPES = new Set([
+    'n8n-nodes-base.if',
+    'n8n-nodes-base.switch',
+    'n8n-nodes-base.filter',
+]);
+/**
+ * Check if a node type is a valid terminal type
+ */
+function isValidTerminalType(nodeType) {
+    const lowerType = nodeType.toLowerCase();
+    // Check exact match
+    if (VALID_TERMINAL_TYPES.has(nodeType))
+        return true;
+    // Check lowercase match
+    for (const terminalType of VALID_TERMINAL_TYPES) {
+        if (lowerType === terminalType.toLowerCase())
+            return true;
+        // Check partial match for base type (e.g., 'slack' in 'n8n-nodes-base.slack')
+        const baseName = terminalType.split('.').pop()?.toLowerCase();
+        if (baseName && lowerType.includes(baseName))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if a node type is a data transform type
+ */
+function isDataTransformType(nodeType) {
+    const lowerType = nodeType.toLowerCase();
+    for (const transformType of DATA_TRANSFORM_TYPES) {
+        if (lowerType === transformType.toLowerCase())
+            return true;
+        const baseName = transformType.split('.').pop()?.toLowerCase();
+        if (baseName && lowerType.includes(baseName))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if a node type is a flow control type
+ */
+function isFlowControlType(nodeType) {
+    const lowerType = nodeType.toLowerCase();
+    for (const controlType of FLOW_CONTROL_TYPES) {
+        if (lowerType === controlType.toLowerCase())
+            return true;
+        const baseName = controlType.split('.').pop()?.toLowerCase();
+        if (baseName && lowerType.includes(baseName))
+            return true;
+    }
+    return false;
+}
+/**
+ * Find all downstream nodes (nodes to the right of the dead-end)
+ */
+function findDownstreamNodes(workflow, sourceNode) {
+    return workflow.nodes.filter((node) => {
+        // Must be to the right of source
+        if (node.position[0] <= sourceNode.position[0])
+            return false;
+        // Must not be the same node
+        if (node.id === sourceNode.id || node.name === sourceNode.name)
+            return false;
+        // Exclude sticky notes
+        const lowerType = node.type.toLowerCase();
+        if (lowerType.includes('stickynote'))
+            return false;
+        return true;
+    });
+}
+/**
+ * Find the closest downstream node by Y-distance
+ */
+function findClosestDownstreamByY(downstreamNodes, sourceNode) {
+    if (downstreamNodes.length === 0)
+        return null;
+    let closest = downstreamNodes[0];
+    let minYDistance = calculateYDistance(closest, sourceNode);
+    for (const node of downstreamNodes) {
+        const yDistance = calculateYDistance(node, sourceNode);
+        if (yDistance < minYDistance) {
+            minYDistance = yDistance;
+            closest = node;
+        }
+    }
+    return { node: closest, yDistance: minYDistance };
+}
+/**
+ * L6DeadEndFixerV2 - Position-based dead-end fixer with terminal detection
+ *
+ * RAG-2.2.108.2: Replaces the low-confidence handler with intelligent fixes:
+ * 1. Skip valid terminal types (confidence 1.0, not an error)
+ * 2. Single downstream → auto-connect (confidence 0.90)
+ * 3. Multiple downstream → connect to closest-Y (confidence 0.75)
+ * 4. Data transform dead-end → add NoOp (confidence 0.85)
+ * 5. Flow control missing branch → flag (confidence 0.50)
+ * 6. No downstream → flag for manual review (confidence 0.50)
+ *
+ * Expected Impact: ~40% of dead-end nodes auto-fixed
+ */
+export class L6DeadEndFixerV2 {
+    name = 'L6DeadEndFixerV2';
+    description = 'Position-based dead-end fixer with terminal detection';
+    supportedCodes = ['L6_DEAD_END_NODE'];
+    minConfidence = 0.50;
+    canFix(problem) {
+        return problem.level === 'L6' && problem.code === 'L6_DEAD_END_NODE';
+    }
+    fix(workflow, problem) {
+        if (!this.canFix(problem)) {
+            return createFailureResult(this.name, problem.code, 'Problem does not meet requirements for L6DeadEndFixerV2');
+        }
+        // Find the dead-end node
+        const nodeNameFromDesc = extractNodeNameFromDescription(problem.description);
+        const node = findNode(workflow, problem.node_id, problem.node_name) ||
+            (nodeNameFromDesc ? findNode(workflow, undefined, nodeNameFromDesc) : undefined);
+        if (!node) {
+            return createFailureResult(this.name, problem.code, `Node not found: ${problem.node_id || problem.node_name || nodeNameFromDesc || 'unknown'}`);
+        }
+        // Step 1: Check if node type is valid terminal → SKIP (not an error)
+        if (isValidTerminalType(node.type)) {
+            return this.createValidTerminalResult(node, problem);
+        }
+        // Step 2-6: Find downstream nodes and apply appropriate fix
+        const downstreamNodes = findDownstreamNodes(workflow, node);
+        // No downstream nodes
+        if (downstreamNodes.length === 0) {
+            return this.handleNoDownstream(workflow, node, problem);
+        }
+        // Single downstream → auto-connect (confidence 0.90)
+        if (downstreamNodes.length === 1) {
+            return this.createSingleDownstreamConnection(workflow, node, downstreamNodes[0], problem);
+        }
+        // Multiple downstream → connect to closest-Y (confidence 0.75)
+        return this.createClosestDownstreamConnection(workflow, node, downstreamNodes, problem);
+    }
+    /**
+     * Create result for valid terminal node skip
+     */
+    createValidTerminalResult(node, problem) {
+        logger.info('L6DeadEndFixerV2: Skipping valid terminal node', {
+            node_name: node.name,
+            node_type: node.type,
+        });
+        return {
+            success: true,
+            fixedWorkflow: undefined, // No workflow changes needed
+            changes: [{
+                    change_type: 'parameter_update',
+                    node_id: node.id,
+                    node_name: node.name,
+                    field: 'status',
+                    old_value: 'dead_end',
+                    new_value: 'valid_terminal',
+                    confidence: DEAD_END_FIXER_CONFIG.VALID_TERMINAL_CONFIDENCE,
+                    description: `Skipped valid terminal node "${node.name}" (${node.type}) - not an error`,
+                }],
+            confidence: DEAD_END_FIXER_CONFIG.VALID_TERMINAL_CONFIDENCE,
+            fixer_name: this.name,
+            problem_code: problem.code,
+        };
+    }
+    /**
+     * Handle dead-end with no downstream nodes
+     */
+    handleNoDownstream(workflow, node, problem) {
+        // Data transform → add NoOp (confidence 0.85)
+        if (isDataTransformType(node.type)) {
+            return this.addNoOpEndpoint(workflow, node, problem);
+        }
+        // Flow control → flag missing branch (confidence 0.50)
+        if (isFlowControlType(node.type)) {
+            return this.createFlowControlFlag(node, problem);
+        }
+        // Otherwise → flag for manual review (confidence 0.50)
+        logger.info('L6DeadEndFixerV2: Flagging dead-end for manual review', {
+            node_name: node.name,
+            node_type: node.type,
+        });
+        return {
+            success: false,
+            changes: [],
+            reason: `Dead-end node "${node.name}" (${node.type}) has no downstream nodes - requires manual review`,
+            confidence: DEAD_END_FIXER_CONFIG.MANUAL_REVIEW_CONFIDENCE,
+            fixer_name: this.name,
+            problem_code: problem.code,
+        };
+    }
+    /**
+     * Add NoOp endpoint for data transform dead-ends
+     */
+    addNoOpEndpoint(workflow, sourceNode, problem) {
+        const fixedWorkflow = cloneWorkflow(workflow);
+        // Create NoOp node
+        const noOpNode = {
+            id: generateNodeId(),
+            type: 'n8n-nodes-base.noOp',
+            name: `${sourceNode.name} End`,
+            position: [sourceNode.position[0] + 200, sourceNode.position[1]],
+            parameters: {},
+            typeVersion: 1,
+        };
+        // Add node to workflow
+        fixedWorkflow.nodes.push(noOpNode);
+        // Connect source to NoOp
+        if (!fixedWorkflow.connections[sourceNode.name]) {
+            fixedWorkflow.connections[sourceNode.name] = { main: [] };
+        }
+        if (!fixedWorkflow.connections[sourceNode.name].main) {
+            fixedWorkflow.connections[sourceNode.name].main = [];
+        }
+        const outputs = fixedWorkflow.connections[sourceNode.name].main;
+        if (outputs.length === 0) {
+            outputs.push([]);
+        }
+        outputs[0].push({
+            node: noOpNode.name,
+            type: 'main',
+            index: 0,
+        });
+        const change = {
+            change_type: 'parameter_update',
+            node_id: sourceNode.id,
+            node_name: sourceNode.name,
+            field: 'connections',
+            old_value: null,
+            new_value: { addedNode: noOpNode.name, type: 'noOp' },
+            confidence: DEAD_END_FIXER_CONFIG.DATA_TRANSFORM_NOOP_CONFIDENCE,
+            description: `Added NoOp endpoint for data transform dead-end "${sourceNode.name}"`,
+        };
+        logger.info('L6DeadEndFixerV2: Added NoOp endpoint for data transform', {
+            source: sourceNode.name,
+            noOpNode: noOpNode.name,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], DEAD_END_FIXER_CONFIG.DATA_TRANSFORM_NOOP_CONFIDENCE);
+    }
+    /**
+     * Create flow control missing branch flag
+     */
+    createFlowControlFlag(node, problem) {
+        logger.info('L6DeadEndFixerV2: Flagging flow control missing branch', {
+            node_name: node.name,
+            node_type: node.type,
+        });
+        return {
+            success: true,
+            fixedWorkflow: undefined, // No auto-fix, just flagged
+            changes: [{
+                    change_type: 'parameter_update',
+                    node_id: node.id,
+                    node_name: node.name,
+                    field: 'status',
+                    old_value: 'dead_end',
+                    new_value: 'missing_branch',
+                    confidence: DEAD_END_FIXER_CONFIG.FLOW_CONTROL_FLAG_CONFIDENCE,
+                    description: `Flow control node "${node.name}" has missing output branch - review required`,
+                }],
+            confidence: DEAD_END_FIXER_CONFIG.FLOW_CONTROL_FLAG_CONFIDENCE,
+            fixer_name: this.name,
+            problem_code: problem.code,
+        };
+    }
+    /**
+     * Create single downstream connection (confidence 0.90)
+     */
+    createSingleDownstreamConnection(workflow, sourceNode, targetNode, problem) {
+        const fixedWorkflow = cloneWorkflow(workflow);
+        // Ensure connections object exists
+        if (!fixedWorkflow.connections[sourceNode.name]) {
+            fixedWorkflow.connections[sourceNode.name] = { main: [] };
+        }
+        if (!fixedWorkflow.connections[sourceNode.name].main) {
+            fixedWorkflow.connections[sourceNode.name].main = [];
+        }
+        // Add connection to first output
+        const outputs = fixedWorkflow.connections[sourceNode.name].main;
+        if (outputs.length === 0) {
+            outputs.push([]);
+        }
+        outputs[0].push({
+            node: targetNode.name,
+            type: 'main',
+            index: 0,
+        });
+        const yDistance = calculateYDistance(sourceNode, targetNode);
+        const change = {
+            change_type: 'parameter_update',
+            node_id: sourceNode.id,
+            node_name: sourceNode.name,
+            field: 'connections',
+            old_value: null,
+            new_value: {
+                source: sourceNode.name,
+                target: targetNode.name,
+                type: 'main',
+                index: 0,
+            },
+            confidence: DEAD_END_FIXER_CONFIG.SINGLE_DOWNSTREAM_CONFIDENCE,
+            description: `Connected dead-end "${sourceNode.name}" to single downstream "${targetNode.name}" (Y-distance: ${yDistance}px)`,
+        };
+        logger.info('L6DeadEndFixerV2: Applied single downstream connection', {
+            source: sourceNode.name,
+            target: targetNode.name,
+            y_distance: yDistance,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], DEAD_END_FIXER_CONFIG.SINGLE_DOWNSTREAM_CONFIDENCE);
+    }
+    /**
+     * Create closest-Y downstream connection (confidence 0.75)
+     */
+    createClosestDownstreamConnection(workflow, sourceNode, downstreamNodes, problem) {
+        const closest = findClosestDownstreamByY(downstreamNodes, sourceNode);
+        if (!closest) {
+            return createFailureResult(this.name, problem.code, `Could not determine closest downstream for "${sourceNode.name}"`);
+        }
+        const fixedWorkflow = cloneWorkflow(workflow);
+        // Ensure connections object exists
+        if (!fixedWorkflow.connections[sourceNode.name]) {
+            fixedWorkflow.connections[sourceNode.name] = { main: [] };
+        }
+        if (!fixedWorkflow.connections[sourceNode.name].main) {
+            fixedWorkflow.connections[sourceNode.name].main = [];
+        }
+        // Add connection to first output
+        const outputs = fixedWorkflow.connections[sourceNode.name].main;
+        if (outputs.length === 0) {
+            outputs.push([]);
+        }
+        outputs[0].push({
+            node: closest.node.name,
+            type: 'main',
+            index: 0,
+        });
+        const change = {
+            change_type: 'parameter_update',
+            node_id: sourceNode.id,
+            node_name: sourceNode.name,
+            field: 'connections',
+            old_value: null,
+            new_value: {
+                source: sourceNode.name,
+                target: closest.node.name,
+                type: 'main',
+                index: 0,
+            },
+            confidence: DEAD_END_FIXER_CONFIG.MULTIPLE_DOWNSTREAM_CONFIDENCE,
+            description: `Connected dead-end "${sourceNode.name}" to closest downstream "${closest.node.name}" (Y-distance: ${closest.yDistance}px, ${downstreamNodes.length} candidates)`,
+        };
+        logger.info('L6DeadEndFixerV2: Applied closest-Y downstream connection', {
+            source: sourceNode.name,
+            target: closest.node.name,
+            y_distance: closest.yDistance,
+            candidates: downstreamNodes.length,
+        });
+        return createSuccessResult(this.name, problem.code, fixedWorkflow, [change], DEAD_END_FIXER_CONFIG.MULTIPLE_DOWNSTREAM_CONFIDENCE);
+    }
+}
+// Export V2 instance
+export const l6DeadEndFixerV2 = new L6DeadEndFixerV2();
+// Export configuration for external use
+export { DEAD_END_FIXER_CONFIG, VALID_TERMINAL_TYPES, DATA_TRANSFORM_TYPES, FLOW_CONTROL_TYPES };
+// ============================================================
+// EXPORTS
+// ============================================================
+// Export singleton instances
+export const l6RetryFixer = new L6RetryFixer();
+export const l6ErrorOutputFixer = new L6ErrorOutputFixer();
+/** @deprecated Use l6DeadEndFixerV2 instead - legacy fixer with lower confidence */
+export const l6DeadEndFixer = new L6DeadEndFixer();
+export const l6ExpressionFixer = new L6ExpressionFixer();
+export const l6TriggerFixer = new L6TriggerFixer();
+export const l6HardcodedUrlHandler = new L6HardcodedUrlHandler();
+export const l6UnreachableNodeFixerV2 = new L6UnreachableNodeFixerV2();
+/** @deprecated Use l6UnreachableNodeFixerV2 instead */
+export const l6UnreachableNodeHandler = new L6UnreachableNodeHandler();
+// Export configuration for external use
+export { UNREACHABLE_FIXER_CONFIG };
+/**
+ * All L6 pattern fixers for convenient import
+ * RAG-2.2.108.1: Updated to use V2 unreachable node fixer
+ * RAG-2.2.108.2: Updated to use V2 dead-end fixer with terminal detection
+ */
+export const l6PatternFixers = [
+    l6RetryFixer,
+    l6ErrorOutputFixer,
+    l6DeadEndFixerV2, // V2 replaces legacy fixer
+    l6ExpressionFixer,
+    l6TriggerFixer,
+    l6HardcodedUrlHandler,
+    l6UnreachableNodeFixerV2, // V2 replaces legacy handler
+];
+//# sourceMappingURL=l6-pattern-fixer.js.map