@principal-ai/subsystems-core 0.29.0

package/dist/workflow/validator.js

@@ -0,0 +1,2283 @@
+"use strict";
+/**
+ * Workflow Template Validator
+ * Validates .workflow.json files against their corresponding .otel.canvas files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflowValidator = exports.WorkflowValidator = void 0;
+const types_1 = require("./types");
+const canvas_1 = require("../types/canvas");
+const path_1 = require("path");
+// ============================================================================
+// Validator Implementation
+// ============================================================================
+class WorkflowValidator {
+    constructor(fsAdapter) {
+        this.fsAdapter = fsAdapter;
+    }
+    /**
+     * Validate a workflow template
+     */
+    async validate(context) {
+        const violations = [];
+        // Run all validation rules
+        violations.push(...(await this.checkSchema(context)));
+        violations.push(...(await this.checkCanvasExists(context)));
+        violations.push(...this.checkCanvasNodeLabels(context));
+        violations.push(...this.checkCanvasCrossReference(context));
+        violations.push(...this.checkDeprecatedFields(context));
+        violations.push(...this.checkScenarios(context));
+        violations.push(...this.checkScenarioSubsets(context));
+        // Check event name syntax BEFORE checking event references
+        // This ensures we catch unsupported syntax before trying to match events
+        violations.push(...this.checkEventNameSyntax(context));
+        // Only run canvas-dependent checks if canvas was loaded
+        if (context.canvas) {
+            violations.push(...this.checkEventReferences(context));
+            violations.push(...this.checkAttributeReferences(context));
+            violations.push(...this.checkEventConnectivity(context));
+            violations.push(...this.checkEventAttributeRequirements(context));
+            violations.push(...this.checkTemplateAttributesDefinedInSchema(context));
+            violations.push(...this.checkScenarioScopeConsistency(context));
+        }
+        violations.push(...this.checkTemplateSyntax(context));
+        violations.push(...this.checkConflictingAttributePaths(context));
+        violations.push(...this.checkFormattingOptions(context));
+        // Check execution data completeness if execution files are provided
+        if (context.executionFiles && context.executionFiles.length > 0) {
+            violations.push(...(await this.checkExecutionDataCompleteness(context)));
+        }
+        return this.aggregateResults(violations);
+    }
+    /**
+     * Validate multiple workflows for duplicate spanPatterns
+     *
+     * This is a CLI-level validation that checks for conflicts across workflows.
+     * Call this method after validating individual workflows.
+     *
+     * @param workflows Array of workflow templates with their file paths
+     * @returns Array of violations for duplicate spanPatterns
+     */
+    static validateSpanPatterns(workflows) {
+        const violations = [];
+        const spanPatternMap = new Map(); // spanPattern -> workflow paths
+        // Collect all spanPatterns
+        for (const { workflow, workflowPath } of workflows) {
+            if (!workflow.spanPattern) {
+                continue; // Will be caught by individual validation
+            }
+            if (!spanPatternMap.has(workflow.spanPattern)) {
+                spanPatternMap.set(workflow.spanPattern, []);
+            }
+            spanPatternMap.get(workflow.spanPattern).push(workflowPath);
+        }
+        // Check for duplicates
+        for (const [spanPattern, paths] of spanPatternMap.entries()) {
+            if (paths.length > 1) {
+                // Duplicate spanPattern found
+                for (const path of paths) {
+                    const otherPaths = paths.filter(p => p !== path);
+                    violations.push({
+                        ruleId: 'workflow-span-pattern-duplicate',
+                        severity: 'error',
+                        file: path,
+                        path: 'spanPattern',
+                        message: `Duplicate spanPattern "${spanPattern}" found in multiple workflows`,
+                        impact: 'Multiple workflows cannot match the same span - this creates ambiguous workflow selection',
+                        suggestion: `This spanPattern is also used in:\n${otherPaths.map(p => `  - ${p}`).join('\n')}\n\nEach workflow must have a unique spanPattern. Consider:\n  - Using different span names (e.g., "payment.authorize" vs "payment.refund")\n  - Merging these workflows into one with multiple scenarios`,
+                        fixable: false,
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check schema validity (required fields, valid values)
+     */
+    async checkSchema(context) {
+        const violations = [];
+        const { workflow, workflowPath } = context;
+        // Valid fields at the workflow root level
+        const validWorkflowFields = [
+            'version',
+            'canvas',
+            'name',
+            'description',
+            'spanPattern',
+            'scope',
+            'files',
+            'status',
+            'scenarioSelection',
+            'showLogsPerSpan',
+            'scenarios',
+            'formatting',
+        ];
+        // Check for unknown fields at workflow level
+        const workflowRecord = workflow;
+        const workflowKeys = Object.keys(workflowRecord);
+        for (const key of workflowKeys) {
+            if (!validWorkflowFields.includes(key)) {
+                violations.push({
+                    ruleId: 'workflow-unknown-field',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: key,
+                    message: `Unknown workflow field "${key}"`,
+                    impact: 'This field will be ignored and may indicate a misunderstanding of the schema',
+                    suggestion: `Valid workflow fields are: ${validWorkflowFields.join(', ')}. Remove the "${key}" field or check for typos.`,
+                    fixable: false,
+                });
+            }
+        }
+        // Check version
+        if (!workflow.version) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'version',
+                message: 'Missing required field "version"',
+                impact: 'Cannot determine template version for compatibility',
+                suggestion: 'Add a version field (e.g., "1.0.0")',
+                fixable: false,
+            });
+        }
+        else if (!this.isValidSemver(workflow.version)) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'version',
+                message: `Invalid version format: "${workflow.version}"`,
+                impact: 'Version must follow semver format',
+                suggestion: 'Use semver format like "1.0.0"',
+                fixable: false,
+            });
+        }
+        // Check canvas reference
+        if (!workflow.canvas) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'canvas',
+                message: 'Missing required field "canvas"',
+                impact: 'Cannot determine which canvas this workflow belongs to',
+                suggestion: 'Add a canvas field pointing to an .otel.canvas file',
+                fixable: false,
+            });
+        }
+        // Check name
+        if (!workflow.name) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'name',
+                message: 'Missing required field "name"',
+                impact: 'Cannot identify this workflow template',
+                suggestion: 'Add a human-readable name',
+                fixable: false,
+            });
+        }
+        // Check description
+        if (!workflow.description) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'description',
+                message: 'Missing required field "description"',
+                impact: 'Cannot understand the purpose of this workflow',
+                suggestion: 'Add a description explaining what this workflow shows',
+                fixable: false,
+            });
+        }
+        // Check spanPattern
+        if (!workflow.spanPattern) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'spanPattern',
+                message: 'Missing required field "spanPattern"',
+                impact: 'Cannot determine which spans this workflow applies to',
+                suggestion: 'Add a spanPattern field specifying the exact span name (e.g., "payment.authorize")',
+                fixable: false,
+            });
+        }
+        else if (typeof workflow.spanPattern !== 'string' || workflow.spanPattern.trim() === '') {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'spanPattern',
+                message: 'spanPattern must be a non-empty string',
+                impact: 'Cannot match spans with invalid pattern',
+                suggestion: 'Provide a valid span name (e.g., "payment.authorize", "checkout.process")',
+                fixable: false,
+            });
+        }
+        else if (workflow.spanPattern.includes('*')) {
+            // Reject glob/wildcard patterns - only exact match is supported
+            violations.push({
+                ruleId: 'workflow-span-pattern-exact',
+                severity: 'error',
+                file: workflowPath,
+                path: 'spanPattern',
+                message: `spanPattern contains wildcard "*" which is not supported: "${workflow.spanPattern}"`,
+                impact: 'Glob patterns create ambiguity when multiple workflows could match the same span',
+                suggestion: 'Use an exact span name instead (e.g., "payment.authorize" not "payment.*")',
+                fixable: false,
+            });
+        }
+        else if (/[[\]{}^$|\\+?]/.test(workflow.spanPattern)) {
+            // Reject regex special characters (except . which is common in span names, and () which appear in framework span names like Next.js)
+            violations.push({
+                ruleId: 'workflow-span-pattern-exact',
+                severity: 'error',
+                file: workflowPath,
+                path: 'spanPattern',
+                message: `spanPattern contains regex special characters which are not supported: "${workflow.spanPattern}"`,
+                impact: 'Regex patterns are not supported - only exact span name matching is used',
+                suggestion: 'Use an exact span name that matches your instrumented span (e.g., "GET /api/auth/me/route")',
+                fixable: false,
+            });
+        }
+        // Check scope against owned-scopes
+        if (workflow.scope && context.ownedScopes && context.ownedScopes.length > 0) {
+            if (!context.ownedScopes.includes(workflow.scope)) {
+                violations.push({
+                    ruleId: 'workflow-scope-owned',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: 'scope',
+                    message: `Scope "${workflow.scope}" is not in owned-scopes list`,
+                    impact: 'Spans from this scope will not be matched - the scope must be declared in library.yaml owned-scopes',
+                    suggestion: `Either:\n  - Add "${workflow.scope}" to owned-scopes in library.yaml\n  - Change scope to one of: ${context.ownedScopes.join(', ')}\n  - Remove scope if using a different tracer`,
+                    fixable: false,
+                });
+            }
+        }
+        // Check status value
+        const validStatuses = ['draft', 'approved', 'implemented'];
+        if (workflow.status && !validStatuses.includes(workflow.status)) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'status',
+                message: `Invalid status: "${workflow.status}"`,
+                impact: 'Status must be a valid lifecycle value',
+                suggestion: `Use one of: ${validStatuses.join(', ')}`,
+                fixable: false,
+            });
+        }
+        // Check files requirement based on status
+        const status = workflow.status || 'draft';
+        if ((status === 'approved' || status === 'implemented') && (!workflow.files || workflow.files.length === 0)) {
+            violations.push({
+                ruleId: 'workflow-files-required',
+                severity: 'error',
+                file: workflowPath,
+                path: 'files',
+                message: `Status "${status}" requires files to be specified`,
+                impact: 'Cannot validate implementation without knowing which files contain the span instrumentation',
+                suggestion: 'Add a "files" array with the paths where this span is created (e.g., ["src/app/api/auth/me/route.ts"])',
+                fixable: false,
+            });
+        }
+        // Check files exist when status is implemented
+        if (status === 'implemented' && workflow.files && workflow.files.length > 0) {
+            for (const file of workflow.files) {
+                const filePath = (0, path_1.resolve)(context.basePath, file);
+                if (!(await this.fsAdapter.exists(filePath))) {
+                    violations.push({
+                        ruleId: 'workflow-files-exist',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: 'files',
+                        message: `Implementation file not found: ${file}`,
+                        impact: 'Workflow is marked as implemented but the source file does not exist',
+                        suggestion: `Either:\n  - Create the file at ${file}\n  - Update the files array with the correct path\n  - Change status to "approved" or "draft"`,
+                        fixable: false,
+                    });
+                }
+            }
+        }
+        // Check scope requirement based on status
+        if ((status === 'approved' || status === 'implemented') && !workflow.scope) {
+            violations.push({
+                ruleId: 'workflow-scope-required',
+                severity: 'error',
+                file: workflowPath,
+                path: 'scope',
+                message: `Status "${status}" requires scope to be specified`,
+                impact: 'Cannot validate instrumentation scope without knowing which tracer emits this span',
+                suggestion: 'Add a "scope" field with the instrumentation scope name (e.g., "terminal-activity", "auth")',
+                fixable: false,
+            });
+        }
+        // Check scenarioSelection
+        const validSelections = ['first-match', 'manual'];
+        if (workflow.scenarioSelection && !validSelections.includes(workflow.scenarioSelection)) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'scenarioSelection',
+                message: `Invalid scenarioSelection: "${workflow.scenarioSelection}"`,
+                impact: 'Scenario selection must be a valid type',
+                suggestion: `Use one of: ${validSelections.join(', ')}`,
+                fixable: false,
+            });
+        }
+        // Check scenarios array
+        if (!workflow.scenarios || !Array.isArray(workflow.scenarios)) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'scenarios',
+                message: 'Missing or invalid "scenarios" field',
+                impact: 'Cannot generate workflows without scenarios',
+                suggestion: 'Add a scenarios array with at least one scenario',
+                fixable: false,
+            });
+        }
+        else if (workflow.scenarios.length === 0) {
+            violations.push({
+                ruleId: 'workflow-schema-valid',
+                severity: 'error',
+                file: workflowPath,
+                path: 'scenarios',
+                message: 'Scenarios array is empty',
+                impact: 'Cannot generate workflows without scenarios',
+                suggestion: 'Add at least one scenario definition',
+                fixable: false,
+            });
+        }
+        return violations;
+    }
+    /**
+     * Check that the referenced canvas file exists
+     */
+    async checkCanvasExists(context) {
+        const violations = [];
+        const { workflow, workflowPath, basePath, canvasPath } = context;
+        if (!workflow.canvas) {
+            // Already flagged by checkSchema
+            return violations;
+        }
+        // Resolve canvas path
+        const resolvedPath = canvasPath || (0, path_1.resolve)(basePath, workflow.canvas);
+        if (!(await this.fsAdapter.exists(resolvedPath))) {
+            violations.push({
+                ruleId: 'workflow-canvas-exists',
+                severity: 'error',
+                file: workflowPath,
+                path: 'canvas',
+                message: `Referenced canvas file does not exist: ${workflow.canvas}`,
+                impact: 'Cannot validate event references without the canvas',
+                suggestion: `Canvas paths must be relative to the repository root, not the workflow file. Use a path like ".principal-views/your-storyboard/canvas.otel.canvas" instead of relative paths like "../canvas.otel.canvas"`,
+                fixable: false,
+            });
+        }
+        return violations;
+    }
+    /**
+     * Check OTEL node labels are meaningful (not equal to their IDs).
+     * Labels should be human-readable display names, not technical identifiers.
+     */
+    checkCanvasNodeLabels(context) {
+        const violations = [];
+        const { canvas, canvasPath } = context;
+        if (!canvas?.nodes || !canvasPath) {
+            return violations;
+        }
+        // OTEL node types that require meaningful labels
+        const otelNodeTypes = ['otel-event', 'otel-span-convention', 'otel-scope', 'otel-resource', 'otel-boundary'];
+        for (const node of canvas.nodes) {
+            // Check if it's an OTEL node type
+            if (!otelNodeTypes.includes(node.type)) {
+                continue;
+            }
+            // Get label from OTEL node (top-level field)
+            const label = 'label' in node ? node.label : undefined;
+            // Skip if no label defined
+            if (!label) {
+                continue;
+            }
+            // Check if label equals ID
+            if (label === node.id) {
+                violations.push({
+                    ruleId: 'canvas-node-label-meaningful',
+                    severity: 'warn',
+                    file: canvasPath,
+                    path: `nodes[${node.id}].label`,
+                    message: `Node "${node.id}" has label identical to its ID`,
+                    impact: 'Labels should be human-readable display names, not technical identifiers',
+                    suggestion: `Change the label to a human-readable name like "${this.idToHumanReadable(node.id)}"`,
+                    fixable: true,
+                });
+            }
+        }
+        return violations;
+    }
+    /**
+     * Convert a dot-separated ID to a human-readable label.
+     * E.g., "multi-canvas-panel.render" → "Multi Canvas Panel Render"
+     */
+    idToHumanReadable(id) {
+        return id
+            .split(/[-.]/)
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
+    /**
+     * Check if workflow references a canvas from a different storyboard folder.
+     * Workflows should be co-located with their canvas in the same storyboard.
+     */
+    checkCanvasCrossReference(context) {
+        const violations = [];
+        const { workflow, workflowPath } = context;
+        if (!workflow.canvas) {
+            return violations;
+        }
+        // Extract storyboard folder from workflow path
+        // e.g., ".principal-views/task-management/task-workflow/task-complete.workflow.json"
+        // -> storyboard is "task-management"
+        const workflowStoryboard = this.extractStoryboardName(workflowPath);
+        // Extract storyboard folder from canvas path
+        // e.g., ".principal-views/cleanup-operations/cleanup-operations.otel.canvas"
+        // -> storyboard is "cleanup-operations"
+        const canvasStoryboard = this.extractStoryboardName(workflow.canvas);
+        if (workflowStoryboard && canvasStoryboard && workflowStoryboard !== canvasStoryboard) {
+            violations.push({
+                ruleId: 'workflow-canvas-cross-reference',
+                severity: 'error',
+                file: workflowPath,
+                path: 'canvas',
+                message: `Workflow in "${workflowStoryboard}" references canvas from different storyboard "${canvasStoryboard}"`,
+                impact: 'Cross-referencing canvases across storyboards makes it difficult to understand which workflows cover a canvas and fragments the storyboard organization',
+                suggestion: `Create a canvas in the "${workflowStoryboard}" storyboard with the events this workflow needs. ` +
+                    `Duplicating events across canvases is acceptable - each storyboard should be self-contained. ` +
+                    `Move or copy the relevant event nodes to ".principal-views/${workflowStoryboard}/${workflowStoryboard}.otel.canvas"`,
+                fixable: false,
+            });
+        }
+        return violations;
+    }
+    /**
+     * Extract storyboard name from a path within .principal-views
+     * e.g., ".principal-views/task-management/task-workflow/file.json" -> "task-management"
+     * e.g., ".principal-views/cleanup-operations/cleanup-operations.otel.canvas" -> "cleanup-operations"
+     */
+    extractStoryboardName(filePath) {
+        const parts = filePath.split('/');
+        const pvIndex = parts.indexOf('.principal-views');
+        if (pvIndex === -1 || parts.length < pvIndex + 2) {
+            return null;
+        }
+        // The storyboard name is the folder immediately after .principal-views
+        return parts[pvIndex + 1];
+    }
+    /**
+     * Check for deprecated fields (condition, condition.requires, etc.)
+     */
+    checkDeprecatedFields(context) {
+        const violations = [];
+        const { workflow, workflowPath } = context;
+        if (!workflow.scenarios || workflow.scenarios.length === 0) {
+            return violations;
+        }
+        workflow.scenarios.forEach((scenario, idx) => {
+            // Check if scenario has a 'condition' field
+            const deprecatedScenario = scenario;
+            if (deprecatedScenario.condition) {
+                const condition = deprecatedScenario.condition;
+                // Build list of what was in condition
+                const conditionFields = [];
+                if (condition.requires)
+                    conditionFields.push('requires');
+                if (condition.excludes)
+                    conditionFields.push('excludes');
+                if (condition.assertions)
+                    conditionFields.push('assertions');
+                if (condition.default)
+                    conditionFields.push('default');
+                if (condition.any)
+                    conditionFields.push('any');
+                const fieldsDescription = conditionFields.length > 0
+                    ? ` (${conditionFields.join(', ')})`
+                    : '';
+                violations.push({
+                    ruleId: 'workflow-deprecated-condition',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: `scenarios[${idx}].condition`,
+                    message: `The "condition" field is no longer supported${fieldsDescription}`,
+                    impact: 'Required events are now automatically derived from template.events keys',
+                    suggestion: `Remove the "condition" field. Required events are inferred from template.events.\n\n` +
+                        `Migration:\n` +
+                        `  Before:\n` +
+                        `    {\n` +
+                        `      "condition": { "requires": ["event.a", "event.b"] },\n` +
+                        `      "template": { "events": { "event.a": "...", "event.b": "..." }}\n` +
+                        `    }\n\n` +
+                        `  After:\n` +
+                        `    {\n` +
+                        `      "template": { "events": { "event.a": "...", "event.b": "..." }}\n` +
+                        `    }\n\n` +
+                        `Simply remove the "condition" field - the same events should already be defined in "template.events".`,
+                    fixable: true,
+                });
+            }
+        });
+        return violations;
+    }
+    /**
+     * Check that events referenced in templates exist in the canvas
+     *
+     * Note: This is currently a placeholder as canvas files don't yet define event schemas.
+     * In the future, when canvas files include OTEL event schema definitions,
+     * this will validate event references.
+     */
+    checkEventReferences(context) {
+        const violations = [];
+        const { workflow, workflowPath, canvas } = context;
+        if (!canvas || !canvas.nodes) {
+            return violations;
+        }
+        // Extract all event names from canvas nodes (otel-event nodes only)
+        const canvasEvents = new Set();
+        for (const node of canvas.nodes) {
+            // Only process otel-event nodes
+            if ((0, canvas_1.isOtelEventNode)(node)) {
+                const otelEventNode = node;
+                if (otelEventNode.event?.name) {
+                    canvasEvents.add(otelEventNode.event.name);
+                }
+                else if (otelEventNode.eventRef) {
+                    canvasEvents.add(otelEventNode.eventRef);
+                }
+            }
+            // Legacy pv.event/pv.eventRef format is no longer supported - use otel-event nodes
+        }
+        // Extract all event names from workflow scenarios (from template.events)
+        const workflowEvents = new Set();
+        for (const scenario of workflow.scenarios) {
+            // From template.events
+            if (scenario.template?.events) {
+                for (const eventName of Object.keys(scenario.template.events)) {
+                    // Skip wildcard patterns
+                    if (!eventName.includes('*')) {
+                        workflowEvents.add(eventName);
+                    }
+                }
+            }
+        }
+        // Check for workflow events not in canvas
+        for (const eventName of Array.from(workflowEvents)) {
+            if (!canvasEvents.has(eventName)) {
+                // Try to find this event elsewhere using the registry
+                const eventSources = context.eventRegistry?.findEvent(eventName) ?? [];
+                let message = `Workflow references event "${eventName}" which is not defined in canvas`;
+                let suggestion = `Add event "${eventName}" to a node in ${workflow.canvas} or remove it from the workflow`;
+                if (eventSources.length > 0) {
+                    // Event found elsewhere - provide helpful guidance
+                    const librarySources = eventSources.filter(s => s.type === 'library');
+                    const canvasSources = eventSources.filter(s => s.type === 'canvas');
+                    if (librarySources.length > 0) {
+                        // Event is in library - suggest using eventRef
+                        message = `Event "${eventName}" not found in canvas but is available in library`;
+                        suggestion = `Add a node with eventRef: "${eventName}" to ${workflow.canvas}`;
+                    }
+                    else if (canvasSources.length > 0) {
+                        // Event is in another canvas - suggest adding to library
+                        const canvasNames = canvasSources.map(s => (0, path_1.basename)(s.path)).join(', ');
+                        message = `Event "${eventName}" not found in canvas. Found in: ${canvasNames}`;
+                        suggestion = `Add "${eventName}" to library.yaml eventSchemas and use eventRef in ${workflow.canvas}`;
+                    }
+                }
+                violations.push({
+                    ruleId: 'workflow-event-sync',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: 'events',
+                    message,
+                    impact: 'This event will never highlight a canvas node and may never match',
+                    suggestion,
+                    fixable: false,
+                });
+            }
+        }
+        // Check for canvas events not in workflow (warning only)
+        // If allWorkflowEvents is provided, check against the combined set of all workflows
+        // for this canvas. Otherwise, check against just this workflow's events.
+        const eventsToCheckAgainst = context.allWorkflowEvents ?? workflowEvents;
+        for (const eventName of Array.from(canvasEvents)) {
+            if (!eventsToCheckAgainst.has(eventName)) {
+                violations.push({
+                    ruleId: 'workflow-event-coverage',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: 'events',
+                    message: context.allWorkflowEvents
+                        ? `Canvas defines event "${eventName}" which is not used in any workflow for this canvas`
+                        : `Canvas defines event "${eventName}" which is not used in this workflow scenario`,
+                    impact: 'This canvas node may never be highlighted during workflow playback',
+                    suggestion: `Add event "${eventName}" to a scenario's template.events`,
+                    fixable: false,
+                });
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check that scenarios are well-formed
+     */
+    checkScenarios(context) {
+        const violations = [];
+        const { workflow, workflowPath } = context;
+        if (!workflow.scenarios || workflow.scenarios.length === 0) {
+            return violations; // Already flagged by checkSchema
+        }
+        const scenarioIds = new Set();
+        const priorities = new Set();
+        // Valid fields for scenario objects
+        const validScenarioFields = ['id', 'priority', 'description', 'template', 'outcomeType', 'filterDefault'];
+        const validOutcomeTypes = ['expected', 'expected-issue', 'unknown-issue'];
+        workflow.scenarios.forEach((scenario, idx) => {
+            // Check for unknown fields at scenario level
+            const scenarioRecord = scenario;
+            const scenarioKeys = Object.keys(scenarioRecord);
+            for (const key of scenarioKeys) {
+                if (!validScenarioFields.includes(key)) {
+                    violations.push({
+                        ruleId: 'workflow-scenario-unknown-field',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: `scenarios[${idx}].${key}`,
+                        message: `Unknown scenario field "${key}"`,
+                        impact: 'This field will be ignored and may indicate a misunderstanding of the schema',
+                        suggestion: `Valid scenario fields are: ${validScenarioFields.join(', ')}. ` +
+                            (key === 'match' || key === 'excludeEvents'
+                                ? 'Scenario matching is based solely on template.events keys - there is no separate match configuration.'
+                                : key === 'condition' || key === 'requires'
+                                    ? 'Required events are automatically derived from template.events keys.'
+                                    : `Remove the "${key}" field or check for typos.`),
+                        fixable: false,
+                    });
+                }
+            }
+            // Check for required fields
+            if (!scenario.id) {
+                violations.push({
+                    ruleId: 'workflow-scenario-valid',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: `scenarios[${idx}].id`,
+                    message: 'Scenario is missing required "id" field',
+                    impact: 'Cannot identify this scenario',
+                    suggestion: 'Add a unique ID for this scenario',
+                    fixable: false,
+                });
+            }
+            else {
+                // Check for duplicate IDs
+                if (scenarioIds.has(scenario.id)) {
+                    violations.push({
+                        ruleId: 'workflow-scenario-valid',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: `scenarios[${idx}].id`,
+                        message: `Duplicate scenario ID: "${scenario.id}"`,
+                        impact: 'Scenario IDs must be unique',
+                        suggestion: 'Use a unique identifier for each scenario',
+                        fixable: false,
+                    });
+                }
+                scenarioIds.add(scenario.id);
+            }
+            // Check priority
+            if (scenario.priority === undefined || scenario.priority === null) {
+                violations.push({
+                    ruleId: 'workflow-scenario-valid',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: `scenarios[${idx}].priority`,
+                    message: 'Scenario is missing required "priority" field',
+                    impact: 'Cannot determine scenario selection order',
+                    suggestion: 'Add a priority (lower number = higher priority)',
+                    fixable: false,
+                });
+            }
+            else {
+                if (scenario.priority < 0) {
+                    violations.push({
+                        ruleId: 'workflow-scenario-valid',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: `scenarios[${idx}].priority`,
+                        message: 'Priority must be a non-negative number',
+                        impact: 'Invalid priority value',
+                        suggestion: 'Use a positive integer (1 = highest priority)',
+                        fixable: false,
+                    });
+                }
+                // Check for duplicate priorities
+                if (priorities.has(scenario.priority)) {
+                    violations.push({
+                        ruleId: 'workflow-scenario-valid',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: `scenarios[${idx}].priority`,
+                        message: `Duplicate priority: ${scenario.priority}`,
+                        impact: 'Priorities must be unique to determine selection order',
+                        suggestion: 'Assign unique priority values to each scenario',
+                        fixable: false,
+                    });
+                }
+                priorities.add(scenario.priority);
+            }
+            // Check description
+            if (!scenario.description) {
+                violations.push({
+                    ruleId: 'workflow-scenario-valid',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: `scenarios[${idx}].description`,
+                    message: 'Scenario is missing required "description" field',
+                    impact: 'Cannot understand what this scenario represents',
+                    suggestion: 'Add a description explaining what this scenario represents',
+                    fixable: false,
+                });
+            }
+            // Check outcomeType if present
+            if (scenario.outcomeType !== undefined && !validOutcomeTypes.includes(scenario.outcomeType)) {
+                violations.push({
+                    ruleId: 'workflow-scenario-valid',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: `scenarios[${idx}].outcomeType`,
+                    message: `Invalid outcomeType: "${scenario.outcomeType}"`,
+                    impact: 'The scenario outcome type will not be recognized',
+                    suggestion: `Valid outcomeType values are: ${validOutcomeTypes.join(', ')}`,
+                    fixable: false,
+                });
+            }
+            // Check filterDefault if present (should be boolean)
+            if (scenario.filterDefault !== undefined && typeof scenario.filterDefault !== 'boolean') {
+                violations.push({
+                    ruleId: 'workflow-scenario-valid',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: `scenarios[${idx}].filterDefault`,
+                    message: `filterDefault must be a boolean, got: ${typeof scenario.filterDefault}`,
+                    impact: 'The filter default state will not be applied correctly',
+                    suggestion: 'Set filterDefault to true or false',
+                    fixable: false,
+                });
+            }
+            // Check template
+            if (!scenario.template) {
+                violations.push({
+                    ruleId: 'workflow-scenario-valid',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: `scenarios[${idx}].template`,
+                    message: 'Scenario is missing required "template" field',
+                    impact: 'Cannot render workflow without a template',
+                    suggestion: 'Add a template with introduction, events, or flow',
+                    fixable: false,
+                });
+            }
+            else {
+                // Validate template structure
+                violations.push(...this.checkTemplateStructure(scenario.template, workflowPath, idx));
+            }
+        });
+        return violations;
+    }
+    /**
+     * Check for subset relationships between scenarios
+     *
+     * Ensures no scenario's event set is a strict subset of another scenario's event set.
+     * This prevents ambiguous matching where a trace could match multiple scenarios.
+     */
+    checkScenarioSubsets(context) {
+        const violations = [];
+        const { workflow, workflowPath } = context;
+        if (!workflow.scenarios || workflow.scenarios.length < 2) {
+            return violations; // Need at least 2 scenarios to check subsets
+        }
+        const scenarios = workflow.scenarios;
+        for (let i = 0; i < scenarios.length; i++) {
+            for (let j = i + 1; j < scenarios.length; j++) {
+                const eventsA = new Set(Object.keys(scenarios[i].template?.events || {}));
+                const eventsB = new Set(Object.keys(scenarios[j].template?.events || {}));
+                // Check if A is a strict subset of B
+                if (this.isStrictSubset(eventsA, eventsB)) {
+                    violations.push({
+                        ruleId: 'workflow-scenario-subset',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: `scenarios[${i}]`,
+                        message: `Scenario "${scenarios[i].id}" is a strict subset of "${scenarios[j].id}"`,
+                        impact: 'A trace with all events from both scenarios will match both, causing ambiguous scenario selection',
+                        suggestion: this.generateSubsetFixSuggestion(scenarios[i], scenarios[j]),
+                        fixable: false,
+                    });
+                }
+                // Check if B is a strict subset of A
+                if (this.isStrictSubset(eventsB, eventsA)) {
+                    violations.push({
+                        ruleId: 'workflow-scenario-subset',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: `scenarios[${j}]`,
+                        message: `Scenario "${scenarios[j].id}" is a strict subset of "${scenarios[i].id}"`,
+                        impact: 'A trace with all events from both scenarios will match both, causing ambiguous scenario selection',
+                        suggestion: this.generateSubsetFixSuggestion(scenarios[j], scenarios[i]),
+                        fixable: false,
+                    });
+                }
+                // Check if A and B have identical event sets
+                if (this.areIdenticalSets(eventsA, eventsB)) {
+                    violations.push({
+                        ruleId: 'workflow-scenario-identical',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: `scenarios[${i}], scenarios[${j}]`,
+                        message: `Scenarios "${scenarios[i].id}" and "${scenarios[j].id}" have identical event sets`,
+                        impact: 'Both scenarios will match the same traces, making scenario selection arbitrary based on priority alone',
+                        suggestion: this.generateIdenticalFixSuggestion(scenarios[i], scenarios[j]),
+                        fixable: false,
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check if set A is a strict subset of set B
+     *
+     * A is a strict subset of B if:
+     * 1. All elements of A are in B
+     * 2. A has fewer elements than B
+     */
+    isStrictSubset(A, B) {
+        // A must have fewer elements than B
+        if (A.size >= B.size) {
+            return false;
+        }
+        // All elements of A must be in B
+        for (const item of A) {
+            if (!B.has(item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if two sets have identical elements
+     *
+     * Two sets are identical if they have the same size and all elements match.
+     */
+    areIdenticalSets(A, B) {
+        if (A.size !== B.size) {
+            return false;
+        }
+        for (const item of A) {
+            if (!B.has(item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Generate helpful suggestion for fixing identical event sets
+     */
+    generateIdenticalFixSuggestion(scenarioA, scenarioB) {
+        const events = Object.keys(scenarioA.template?.events || {});
+        return (`Both scenarios have events: [${events.join(', ')}]\n\n` +
+            `Recommended fixes:\n\n` +
+            `1. Merge into a single scenario with template conditionals for any differences:\n` +
+            `   Scenarios with identical events represent the same execution path.\n` +
+            `   Use template conditionals or attribute-based logic to handle variations.\n\n` +
+            `2. If they represent genuinely different paths, add distinguishing events:\n` +
+            `   - Add an event unique to "${scenarioA.id}" (e.g., "${scenarioA.id}.marker")\n` +
+            `   - Add an event unique to "${scenarioB.id}" (e.g., "${scenarioB.id}.marker")\n\n` +
+            `3. If the difference is attribute-based, use template variables:\n` +
+            `   Instead of separate scenarios, use {{attribute}} in templates to show variations.`);
+    }
+    /**
+     * Generate helpful suggestion for fixing subset relationship
+     */
+    generateSubsetFixSuggestion(subsetScenario, supersetScenario) {
+        const subsetEvents = Object.keys(subsetScenario.template?.events || {});
+        const supersetEvents = Object.keys(supersetScenario.template?.events || {});
+        const extraEvents = supersetEvents.filter(e => !subsetEvents.includes(e));
+        return (`Scenario "${subsetScenario.id}" events: [${subsetEvents.join(', ')}]\n` +
+            `Scenario "${supersetScenario.id}" events: [${supersetEvents.join(', ')}]\n\n` +
+            `Recommended fixes:\n\n` +
+            `1. Merge into one scenario with template conditionals:\n` +
+            `   {\n` +
+            `     "id": "${subsetScenario.id}",\n` +
+            `     "template": {\n` +
+            `       "events": { ${subsetEvents.map(e => `"${e}": "..."`).join(', ')} },\n` +
+            `       "flow": [\n` +
+            `         "Base flow steps...",\n` +
+            `         {{#if ${extraEvents[0]}}}Additional step...{{/if}}\n` +
+            `       ]\n` +
+            `     }\n` +
+            `   }\n\n` +
+            `2. Make them mutually exclusive by adding distinguishing events:\n` +
+            `   - Add an event to "${subsetScenario.id}" that distinguishes it (e.g., "conversion.timeout", "conversion.abandoned")\n` +
+            `   - Or ensure "${supersetScenario.id}" has events that never co-occur with "${subsetScenario.id}"`);
+    }
+    /**
+     * Check that all events in a scenario come from nodes with the same scope
+     *
+     * This ensures scenarios don't accidentally span multiple instrumentation boundaries.
+     * Cross-scope workflows should be explicitly designed and documented.
+     */
+    checkScenarioScopeConsistency(context) {
+        const violations = [];
+        const { workflow, workflowPath, canvas } = context;
+        if (!canvas || !workflow.scenarios) {
+            return violations;
+        }
+        // Build a map of event name -> scope from canvas nodes (otel-event nodes only)
+        const eventToScope = new Map();
+        const eventToNodeId = new Map();
+        for (const node of canvas.nodes || []) {
+            // Only process otel-event nodes
+            if ((0, canvas_1.isOtelEventNode)(node)) {
+                const otelEventNode = node;
+                const eventName = otelEventNode.event?.name || otelEventNode.eventRef;
+                const scope = otelEventNode.otel?.scope;
+                if (eventName) {
+                    eventToScope.set(eventName, scope);
+                    eventToNodeId.set(eventName, node.id);
+                }
+            }
+            // Legacy pv.event/pv.eventRef format is no longer supported
+        }
+        // Check each scenario for scope consistency
+        for (let idx = 0; idx < workflow.scenarios.length; idx++) {
+            const scenario = workflow.scenarios[idx];
+            const templateEvents = Object.keys(scenario.template?.events || {});
+            if (templateEvents.length === 0) {
+                continue;
+            }
+            // Collect scopes for all events in this scenario
+            const scopesInScenario = new Map(); // scope -> event names
+            for (const eventName of templateEvents) {
+                // Skip wildcard events
+                if (eventName === '*')
+                    continue;
+                const scope = eventToScope.get(eventName);
+                const scopeKey = scope || '__undefined__';
+                if (!scopesInScenario.has(scopeKey)) {
+                    scopesInScenario.set(scopeKey, []);
+                }
+                scopesInScenario.get(scopeKey).push(eventName);
+            }
+            // Check if there are multiple scopes
+            const definedScopes = Array.from(scopesInScenario.keys()).filter(s => s !== '__undefined__');
+            const undefinedEvents = scopesInScenario.get('__undefined__') || [];
+            if (definedScopes.length > 1) {
+                // Multiple scopes detected - this is a cross-scope scenario
+                const scopeBreakdown = definedScopes
+                    .map(scope => `  - ${scope}: ${scopesInScenario.get(scope).join(', ')}`)
+                    .join('\n');
+                violations.push({
+                    ruleId: 'workflow-scenario-cross-scope',
+                    severity: 'warn',
+                    file: workflowPath,
+                    path: `scenarios[${idx}]`,
+                    message: `Scenario "${scenario.id}" spans multiple instrumentation scopes`,
+                    impact: 'This scenario crosses instrumentation boundaries, which may indicate:\n' +
+                        '  - A workflow that should be split into separate scope-specific workflows\n' +
+                        '  - A legitimate cross-scope operation that needs documentation',
+                    suggestion: `Scopes detected:\n${scopeBreakdown}\n\n` +
+                        'Consider:\n' +
+                        '  1. Split into separate workflows per scope\n' +
+                        '  2. If intentional, document the cross-scope nature in the workflow description\n' +
+                        '  3. Ensure all nodes have pv.otel.scope defined for accurate tracking',
+                    fixable: false,
+                });
+            }
+            // Warn about events with undefined scopes (only if some events have scopes)
+            if (undefinedEvents.length > 0 && definedScopes.length > 0) {
+                violations.push({
+                    ruleId: 'workflow-scenario-scope-missing',
+                    severity: 'warn',
+                    file: workflowPath,
+                    path: `scenarios[${idx}]`,
+                    message: `Scenario "${scenario.id}" has events without scope defined`,
+                    impact: 'Cannot determine if these events belong to the same instrumentation boundary',
+                    suggestion: `Events missing scope: ${undefinedEvents.join(', ')}\n` +
+                        `Add pv.otel.scope to these nodes in the canvas to enable scope consistency checking`,
+                    fixable: false,
+                });
+            }
+            // Check if node scopes are in owned-scopes list
+            if (context.ownedScopes && context.ownedScopes.length > 0) {
+                const unknownScopes = definedScopes.filter(scope => !context.ownedScopes.includes(scope));
+                if (unknownScopes.length > 0) {
+                    const eventsPerScope = unknownScopes
+                        .map(scope => `  - ${scope}: ${scopesInScenario.get(scope).join(', ')}`)
+                        .join('\n');
+                    violations.push({
+                        ruleId: 'workflow-node-scope-not-owned',
+                        severity: 'error',
+                        file: workflowPath,
+                        path: `scenarios[${idx}]`,
+                        message: `Scenario "${scenario.id}" uses scopes not declared in library.yaml owned-scopes`,
+                        impact: 'Spans from these scopes will not be matched - scopes must be declared in library.yaml',
+                        suggestion: `Unknown scopes:\n${eventsPerScope}\n\n` +
+                            `Either:\n` +
+                            `  - Add these scopes to owned-scopes in library.yaml\n` +
+                            `  - Update the nodes to use a declared scope: ${context.ownedScopes.join(', ')}`,
+                        fixable: false,
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check that template uses valid fields (not legacy format)
+     */
+    checkTemplateStructure(template, file, scenarioIdx) {
+        const violations = [];
+        const validFields = ['introduction', 'events', 'logs', 'summary', 'span', 'children'];
+        // Type guard: ensure template is an object
+        if (typeof template !== 'object' || template === null) {
+            return violations;
+        }
+        const templateRecord = template;
+        const templateKeys = Object.keys(templateRecord);
+        // Check that events field is present and is an object
+        if (!templateRecord.events) {
+            violations.push({
+                ruleId: 'workflow-template-structure',
+                severity: 'error',
+                file,
+                path: `scenarios[${scenarioIdx}].template`,
+                message: 'Template is missing required "events" field',
+                impact: 'Template must specify how to render each event type',
+                suggestion: 'Add "events: { eventName: template }" to map event names to templates',
+                fixable: false,
+            });
+        }
+        else if (typeof templateRecord.events !== 'object' || Array.isArray(templateRecord.events)) {
+            violations.push({
+                ruleId: 'workflow-template-structure',
+                severity: 'error',
+                file,
+                path: `scenarios[${scenarioIdx}].template.events`,
+                message: 'Template "events" field must be an object',
+                impact: 'Events will not render correctly',
+                suggestion: 'Use object format: { "event.name": "template string" }',
+                fixable: false,
+            });
+        }
+        else if (typeof templateRecord.events === 'object' && templateRecord.events !== null && Object.keys(templateRecord.events).length === 0) {
+            violations.push({
+                ruleId: 'workflow-template-structure',
+                severity: 'error',
+                file,
+                path: `scenarios[${scenarioIdx}].template.events`,
+                message: 'Template "events" field must not be empty',
+                impact: 'No events will be rendered in this scenario',
+                suggestion: 'Add at least one event template: { "event.name": "template string" }',
+                fixable: false,
+            });
+        }
+        // Check for invalid/legacy fields
+        for (const key of templateKeys) {
+            if (!validFields.includes(key)) {
+                // Check for common legacy format fields
+                if (key === 'steps') {
+                    violations.push({
+                        ruleId: 'workflow-template-structure',
+                        severity: 'error',
+                        file,
+                        path: `scenarios[${scenarioIdx}].template.${key}`,
+                        message: `Invalid template field "${key}" (legacy format detected)`,
+                        impact: 'Template will not render - "steps" field is not supported',
+                        suggestion: 'Use "events: { eventName: template }" to map event names to templates',
+                        fixable: false,
+                    });
+                }
+                else if (key === 'details') {
+                    violations.push({
+                        ruleId: 'workflow-template-structure',
+                        severity: 'error',
+                        file,
+                        path: `scenarios[${scenarioIdx}].template.${key}`,
+                        message: `Invalid template field "${key}" (legacy format detected)`,
+                        impact: 'Template will not render - "details" field is not supported',
+                        suggestion: 'Remove "details" field - use template variables in "events" or "summary" instead',
+                        fixable: false,
+                    });
+                }
+                else {
+                    violations.push({
+                        ruleId: 'workflow-template-structure',
+                        severity: 'error',
+                        file,
+                        path: `scenarios[${scenarioIdx}].template.${key}`,
+                        message: `Unknown template field "${key}"`,
+                        impact: 'This field will be ignored and may cause unexpected behavior',
+                        suggestion: `Valid fields are: ${validFields.join(', ')}`,
+                        fixable: false,
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check that event names don't use attribute filter syntax
+     */
+    checkEventNameSyntax(context) {
+        const violations = [];
+        const { workflow, workflowPath } = context;
+        workflow.scenarios.forEach((scenario, scenarioIdx) => {
+            // Check template.events
+            if (scenario.template?.events) {
+                Object.keys(scenario.template.events).forEach((eventName) => {
+                    if (eventName.includes('[') && eventName.includes(']')) {
+                        violations.push({
+                            ruleId: 'workflow-event-name-syntax',
+                            severity: 'error',
+                            file: workflowPath,
+                            path: `scenarios[${scenarioIdx}].template.events["${eventName}"]`,
+                            message: `Event name uses unsupported [attribute=value] syntax: "${eventName}"`,
+                            impact: 'Attribute filter syntax is not supported - template will never render',
+                            suggestion: `Use a distinct event name instead (e.g., "${this.extractBaseEventName(eventName)}.${this.extractAttributeValue(eventName)}")`,
+                            fixable: false,
+                        });
+                    }
+                });
+            }
+        });
+        return violations;
+    }
+    /**
+     * Check template syntax (balanced braces, valid expressions)
+     */
+    checkTemplateSyntax(context) {
+        const violations = [];
+        const { workflow, workflowPath } = context;
+        workflow.scenarios.forEach((scenario, scenarioIdx) => {
+            if (!scenario.template) {
+                return;
+            }
+            const template = scenario.template;
+            // Check introduction
+            if (template.introduction) {
+                violations.push(...this.validateTemplateString(template.introduction, workflowPath, `scenarios[${scenarioIdx}].template.introduction`));
+            }
+            // Check summary
+            if (template.summary) {
+                violations.push(...this.validateTemplateString(template.summary, workflowPath, `scenarios[${scenarioIdx}].template.summary`));
+            }
+            // Check event templates
+            if (template.events) {
+                Object.entries(template.events).forEach(([eventName, templateEntry]) => {
+                    const templateStr = (0, types_1.getEventTemplateString)(templateEntry);
+                    violations.push(...this.validateTemplateString(templateStr, workflowPath, `scenarios[${scenarioIdx}].template.events.${eventName}`));
+                });
+            }
+            // Check log templates
+            if (template.logs) {
+                Object.entries(template.logs).forEach(([severity, templateStr]) => {
+                    if (typeof templateStr === 'string') {
+                        violations.push(...this.validateTemplateString(templateStr, workflowPath, `scenarios[${scenarioIdx}].template.logs.${severity}`));
+                    }
+                });
+            }
+        });
+        return violations;
+    }
+    /**
+     * Validate a single template string
+     */
+    validateTemplateString(templateStr, file, path) {
+        const violations = [];
+        // Check for balanced braces
+        let braceDepth = 0;
+        let inQuote = false;
+        let quoteChar = '';
+        for (let i = 0; i < templateStr.length; i++) {
+            const char = templateStr[i];
+            const prevChar = i > 0 ? templateStr[i - 1] : '';
+            // Track quotes
+            if ((char === "'" || char === '"') && prevChar !== '\\') {
+                if (!inQuote) {
+                    inQuote = true;
+                    quoteChar = char;
+                }
+                else if (char === quoteChar) {
+                    inQuote = false;
+                    quoteChar = '';
+                }
+            }
+            // Track braces (only outside of quotes)
+            if (!inQuote) {
+                if (char === '{') {
+                    braceDepth++;
+                }
+                else if (char === '}') {
+                    braceDepth--;
+                    if (braceDepth < 0) {
+                        violations.push({
+                            ruleId: 'workflow-template-syntax',
+                            severity: 'error',
+                            file,
+                            path,
+                            message: 'Unbalanced braces: closing } without opening {',
+                            impact: 'Template will fail to render',
+                            suggestion: 'Ensure all {{variables}} and {expressions} have matching braces',
+                            fixable: false,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        if (braceDepth > 0) {
+            violations.push({
+                ruleId: 'workflow-template-syntax',
+                severity: 'error',
+                file,
+                path,
+                message: 'Unbalanced braces: missing closing }',
+                impact: 'Template will fail to render',
+                suggestion: 'Ensure all {{variables}} and {expressions} have matching braces',
+                fixable: false,
+            });
+        }
+        // Check for incomplete conditional expressions (? without :)
+        const conditionalPattern = /\{[^}]*\?[^}]*\}/g;
+        const conditionals = templateStr.match(conditionalPattern) || [];
+        conditionals.forEach((expr) => {
+            // Simple check: if has ? but no :, it's incomplete
+            const questionCount = (expr.match(/\?/g) || []).length;
+            const colonCount = (expr.match(/:/g) || []).length;
+            if (questionCount > colonCount) {
+                violations.push({
+                    ruleId: 'workflow-template-syntax',
+                    severity: 'error',
+                    file,
+                    path,
+                    message: `Incomplete conditional expression: ${expr}`,
+                    impact: 'Template will fail to render',
+                    suggestion: 'Use Handlebars syntax: {{#if condition}}true{{else}}false{{/if}}',
+                    fixable: false,
+                });
+            }
+        });
+        // Check for Handlebars conditionals - these are not allowed in scenarios
+        // A scenario must represent a single deterministic trace, not multiple conditional paths
+        const handlebarsConditionalPattern = /\{\{#(if|unless|each)\b[^}]*\}\}|\{\{else\}\}/g;
+        const handlebarsConditionals = templateStr.match(handlebarsConditionalPattern) || [];
+        if (handlebarsConditionals.length > 0) {
+            const firstMatch = handlebarsConditionals[0];
+            violations.push({
+                ruleId: 'workflow-template-conditional',
+                severity: 'error',
+                file,
+                path,
+                message: `Conditional syntax detected: ${firstMatch}`,
+                impact: 'Scenarios must represent a single deterministic trace. Conditionals introduce ambiguity about which events should be present.',
+                suggestion: 'Split into separate scenarios for each conditional path. Each scenario should represent one specific trace shape.',
+                fixable: false,
+            });
+        }
+        // Check for emojis - templates should be plain text without emoji characters
+        const emojiPattern = /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{1F600}-\u{1F64F}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2300}-\u{23FF}]|[\u{2B50}-\u{2B55}]|[\u{200D}]|[\u{FE0F}]/gu;
+        const emojiMatches = templateStr.match(emojiPattern);
+        if (emojiMatches && emojiMatches.length > 0) {
+            const uniqueEmojis = [...new Set(emojiMatches)].slice(0, 5);
+            violations.push({
+                ruleId: 'workflow-template-emoji',
+                severity: 'error',
+                file,
+                path,
+                message: `Template contains emoji characters: ${uniqueEmojis.join(' ')}`,
+                impact: 'Emojis in templates can cause rendering issues and inconsistent display across platforms',
+                suggestion: 'Remove emoji characters and use plain text descriptions instead',
+                fixable: true,
+            });
+        }
+        return violations;
+    }
+    /**
+     * Check for conflicting attribute paths in templates
+     *
+     * Detects when one attribute path is a prefix of another, which causes
+     * rendering issues. For example:
+     * - `git.branch` (expects string value)
+     * - `git.branch.source` (expects git.branch to be an object)
+     *
+     * When both are used, the nested object conversion will clobber the string
+     * value, resulting in `[object Object]` being rendered.
+     */
+    checkConflictingAttributePaths(context) {
+        const violations = [];
+        const { workflow, workflowPath, canvas, canvasPath } = context;
+        // Helper function to find conflicts in a set of paths
+        const findConflicts = (paths) => {
+            const pathArray = Array.from(paths);
+            const conflicts = new Map();
+            for (let i = 0; i < pathArray.length; i++) {
+                for (let j = 0; j < pathArray.length; j++) {
+                    if (i === j)
+                        continue;
+                    const pathA = pathArray[i];
+                    const pathB = pathArray[j];
+                    // Check if pathA is a prefix of pathB (pathA.something)
+                    if (pathB.startsWith(pathA + '.')) {
+                        if (!conflicts.has(pathA)) {
+                            conflicts.set(pathA, []);
+                        }
+                        if (!conflicts.get(pathA).includes(pathB)) {
+                            conflicts.get(pathA).push(pathB);
+                        }
+                    }
+                }
+            }
+            return conflicts;
+        };
+        // 1. Check canvas event schema attributes for conflicts
+        if (canvas?.nodes) {
+            for (const node of canvas.nodes) {
+                // Only check nodes that have event schemas (not text nodes)
+                if (!('event' in node) || !node.event)
+                    continue;
+                const eventSchema = node.event;
+                if (eventSchema.attributes && typeof eventSchema.attributes === 'object') {
+                    const attributeNames = new Set(Object.keys(eventSchema.attributes));
+                    const conflicts = findConflicts(attributeNames);
+                    for (const [parent, children] of conflicts.entries()) {
+                        violations.push({
+                            ruleId: 'canvas-event-attribute-conflict',
+                            severity: 'error',
+                            file: canvasPath || workflowPath,
+                            path: `nodes[${node.id}].event.attributes`,
+                            message: `Conflicting attribute paths in event "${eventSchema.name || 'unknown'}": "${parent}" conflicts with ${children.map(c => `"${c}"`).join(', ')}`,
+                            impact: `When rendered in workflow templates, "${parent}" will become "[object Object]" because nested paths require it to be an object`,
+                            suggestion: `Rename attributes to avoid conflicts:\n` +
+                                `  - "${parent}" → "${parent}Value" or "${parent.replace(/\./g, '_')}"\n` +
+                                `  - Or use a different naming scheme that doesn't nest (e.g., "${parent.split('.').slice(0, -1).join('.')}_${parent.split('.').pop()}")`,
+                            fixable: false,
+                        });
+                    }
+                }
+            }
+        }
+        // 2. Check each scenario's template variables for conflicts
+        workflow.scenarios.forEach((scenario, scenarioIdx) => {
+            if (!scenario.template)
+                return;
+            // Collect all attribute paths from this scenario's templates
+            const allPaths = new Set();
+            // From introduction
+            if (scenario.template.introduction) {
+                this.extractAttributeReferences(scenario.template.introduction).forEach(p => allPaths.add(p));
+            }
+            // From summary
+            if (scenario.template.summary) {
+                this.extractAttributeReferences(scenario.template.summary).forEach(p => allPaths.add(p));
+            }
+            // From event templates
+            if (scenario.template.events) {
+                Object.values(scenario.template.events).forEach(templateEntry => {
+                    const templateStr = (0, types_1.getEventTemplateString)(templateEntry);
+                    this.extractAttributeReferences(templateStr).forEach(p => allPaths.add(p));
+                });
+            }
+            // Check for conflicts
+            const conflicts = findConflicts(allPaths);
+            // Report violations
+            for (const [parent, children] of conflicts.entries()) {
+                violations.push({
+                    ruleId: 'workflow-attribute-path-conflict',
+                    severity: 'error',
+                    file: workflowPath,
+                    path: `scenarios[${scenarioIdx}].template`,
+                    message: `Conflicting attribute paths: "{{${parent}}}" conflicts with ${children.map(c => `"{{${c}}}"`).join(', ')}`,
+                    impact: `"{{${parent}}}" will render as "[object Object]" because nested paths require it to be an object, not a primitive value`,
+                    suggestion: `Options:\n` +
+                        `  1. Remove "{{${parent}}}" and only use the nested paths\n` +
+                        `  2. Rename attributes to avoid conflicts (e.g., "${parent}" → "${parent}_value" or "${parent}.value")\n` +
+                        `  3. Use different attribute names that don't share a common prefix`,
+                    fixable: false,
+                });
+            }
+        });
+        return violations;
+    }
+    /**
+     * Check attribute references against execution data
+     *
+     * Validates that:
+     * - Attributes referenced in templates exist in execution data
+     * - Object attributes are accessed via properties (not used directly)
+     * - Attribute names are correct (catches typos)
+     */
+    checkAttributeReferences(context) {
+        const violations = [];
+        const { workflow, workflowPath, executionData } = context;
+        // Skip if no execution data provided
+        if (!executionData) {
+            return violations;
+        }
+        const { aggregates, eventAttributes } = executionData;
+        // Check each scenario's template
+        for (const scenario of workflow.scenarios) {
+            const scenarioPath = `scenarios[${scenario.id}]`;
+            // Check introduction template
+            if (scenario.template.introduction) {
+                const attrs = this.extractAttributeReferences(scenario.template.introduction);
+                violations.push(...this.validateAttributes(attrs, aggregates, null, // introduction doesn't have specific event context
+                workflowPath, `${scenarioPath}.template.introduction`));
+            }
+            // Check event templates
+            if (scenario.template.events) {
+                for (const [eventName, eventTemplateEntry] of Object.entries(scenario.template.events)) {
+                    const eventTemplate = (0, types_1.getEventTemplateString)(eventTemplateEntry);
+                    const attrs = this.extractAttributeReferences(eventTemplate);
+                    const eventAttrs = eventAttributes.get(eventName);
+                    violations.push(...this.validateAttributes(attrs, aggregates, eventAttrs || null, workflowPath, `${scenarioPath}.template.events.${eventName}`, eventName));
+                }
+            }
+            // Check summary template
+            if (scenario.template.summary) {
+                const attrs = this.extractAttributeReferences(scenario.template.summary);
+                violations.push(...this.validateAttributes(attrs, aggregates, null, // summary uses global aggregates
+                workflowPath, `${scenarioPath}.template.summary`));
+            }
+        }
+        return violations;
+    }
+    /**
+     * Validate a list of attribute references against available data
+     *
+     * @param attributes - Attribute paths to validate
+     * @param aggregates - Global aggregate attributes
+     * @param eventAttributes - Event-specific attributes (if validating event template)
+     * @param file - File path for violation reporting
+     * @param path - JSON path for violation reporting
+     * @param eventName - Event name (if validating event template)
+     * @returns Array of violations found
+     */
+    validateAttributes(attributes, aggregates, eventAttributes, file, path, eventName) {
+        const violations = [];
+        for (const attr of attributes) {
+            // Check if attribute exists in global aggregates
+            const globalValue = aggregates[attr];
+            const eventValue = eventAttributes?.[attr];
+            // Attribute doesn't exist anywhere
+            if (globalValue === undefined && eventValue === undefined) {
+                // Try to find similar attributes for helpful suggestions
+                const allKeys = [
+                    ...Object.keys(aggregates),
+                    ...(eventAttributes ? Object.keys(eventAttributes) : []),
+                ];
+                const similar = this.findSimilarAttributes(attr, allKeys);
+                violations.push({
+                    ruleId: 'workflow-attribute-undefined',
+                    severity: 'warn',
+                    file,
+                    path,
+                    message: eventName
+                        ? `Attribute "{{${attr}}}" not found in event "${eventName}" or global aggregates`
+                        : `Attribute "{{${attr}}}" not found in execution data`,
+                    impact: 'Template will render as empty or "undefined"',
+                    suggestion: similar.length > 0 ? `Did you mean: ${similar.join(', ')}?` : undefined,
+                    fixable: false,
+                });
+                continue;
+            }
+            // Check if object is used directly (should use property access)
+            const value = eventValue !== undefined ? eventValue : globalValue;
+            if (this.isObjectType(value)) {
+                const objectKeys = Object.keys(value);
+                const suggestions = objectKeys.slice(0, 3).map((k) => `{{${attr}.${k}}}`);
+                violations.push({
+                    ruleId: 'workflow-attribute-object',
+                    severity: 'warn',
+                    file,
+                    path,
+                    message: `Attribute "{{${attr}}}" is an object and will render as "[object Object]"`,
+                    impact: 'Template will show "[object Object]" instead of useful data',
+                    suggestion: `Access a property instead: ${suggestions.join(', ')}`,
+                    fixable: false,
+                });
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check event attribute requirements:
+     * All attributes defined in event schemas must be used in at least one template.
+     *
+     * This ensures all defined attributes have a purpose and are displayed to users.
+     */
+    checkEventAttributeRequirements(context) {
+        const violations = [];
+        const { workflow, workflowPath, canvas, canvasPath } = context;
+        if (!canvas?.nodes) {
+            return violations;
+        }
+        // Collect all event names referenced in workflow scenarios
+        // Only validate attributes for events that are INCLUDED in the workflow
+        const workflowEventNames = new Set();
+        for (const scenario of workflow.scenarios) {
+            if (!scenario.template?.events)
+                continue;
+            for (const eventName of Object.keys(scenario.template.events)) {
+                workflowEventNames.add(eventName);
+            }
+        }
+        // Collect all attribute references from workflow templates by event name
+        const templateAttributesByEvent = new Map();
+        for (const scenario of workflow.scenarios) {
+            if (!scenario.template?.events)
+                continue;
+            for (const [eventName, eventTemplateEntry] of Object.entries(scenario.template.events)) {
+                const eventTemplate = (0, types_1.getEventTemplateString)(eventTemplateEntry);
+                const attrs = this.extractAttributeReferences(eventTemplate);
+                if (!templateAttributesByEvent.has(eventName)) {
+                    templateAttributesByEvent.set(eventName, new Set());
+                }
+                const eventAttrs = templateAttributesByEvent.get(eventName);
+                attrs.forEach((attr) => eventAttrs.add(attr));
+            }
+        }
+        // Check each canvas node's event schema (only for events included in the workflow)
+        // Only otel-event nodes are supported
+        for (const node of canvas.nodes) {
+            let eventName;
+            let eventSchema;
+            let schemaSource = 'inline';
+            // Only process otel-event nodes
+            if ((0, canvas_1.isOtelEventNode)(node)) {
+                const otelEventNode = node;
+                if (otelEventNode.event?.name) {
+                    eventName = otelEventNode.event.name;
+                    eventSchema = otelEventNode.event;
+                }
+                else if (otelEventNode.eventRef) {
+                    eventName = otelEventNode.eventRef;
+                    schemaSource = 'library';
+                    const sources = context.eventRegistry?.findEvent(eventName) ?? [];
+                    const librarySource = sources.find((s) => s.type === 'library' && s.eventSchema);
+                    if (librarySource?.eventSchema) {
+                        eventSchema = librarySource.eventSchema;
+                    }
+                }
+            }
+            // Legacy pv.event/pv.eventRef format is no longer supported
+            if (!eventName || !eventSchema?.attributes) {
+                continue; // No schema to validate
+            }
+            // Skip events not included in this workflow
+            // This allows canvases with disconnected subgraphs where different workflows focus on different flows
+            if (!workflowEventNames.has(eventName)) {
+                continue;
+            }
+            // Get all defined attributes
+            const definedAttrs = Object.keys(eventSchema.attributes);
+            // All attributes must be used in templates
+            const usedAttrs = templateAttributesByEvent.get(eventName) ?? new Set();
+            for (const attr of definedAttrs) {
+                // Check if attribute is used (direct match or as prefix of a nested path)
+                const isUsed = Array.from(usedAttrs).some((usedAttr) => usedAttr === attr || usedAttr.startsWith(attr + '.'));
+                if (!isUsed) {
+                    violations.push({
+                        ruleId: 'workflow-attribute-unused',
+                        severity: 'error',
+                        file: canvasPath || workflowPath,
+                        path: schemaSource === 'inline' ? `nodes[${node.id}].event.attributes.${attr}` : `library.eventSchemas.${eventName}.attributes.${attr}`,
+                        message: `Event "${eventName}" defines attribute "${attr}" that is not used in any template`,
+                        impact: 'This attribute is defined but never used in any template',
+                        suggestion: `Use {{${attr}}} in a template for event "${eventName}", or remove the attribute if it's not needed`,
+                        fixable: false,
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check that template attributes are defined in the canvas event schema.
+     *
+     * This validates the reverse of checkEventAttributeRequirements:
+     * - checkEventAttributeRequirements: schema defines attr not used in template → error
+     * - checkTemplateAttributesDefinedInSchema: template uses attr not in schema → error
+     *
+     * This catches cases where:
+     * - Template references {{context.projectRoot}} but schema doesn't define it
+     * - Typos in attribute names (e.g., {{contex.projectRoot}})
+     * - Attributes emitted by instrumentation but not documented in schema
+     */
+    checkTemplateAttributesDefinedInSchema(context) {
+        const violations = [];
+        const { workflow, workflowPath, canvas, canvasPath } = context;
+        if (!canvas?.nodes) {
+            return violations;
+        }
+        // Build a map of event name -> schema attributes (including nested paths)
+        // Only otel-event nodes are supported
+        const eventSchemaAttributes = new Map();
+        for (const node of canvas.nodes) {
+            let eventName;
+            let eventSchema;
+            // Only process otel-event nodes
+            if ((0, canvas_1.isOtelEventNode)(node)) {
+                const otelEventNode = node;
+                if (otelEventNode.event?.name) {
+                    eventName = otelEventNode.event.name;
+                    eventSchema = otelEventNode.event;
+                }
+                else if (otelEventNode.eventRef) {
+                    eventName = otelEventNode.eventRef;
+                    const sources = context.eventRegistry?.findEvent(eventName) ?? [];
+                    const librarySource = sources.find((s) => s.type === 'library' && s.eventSchema);
+                    if (librarySource?.eventSchema) {
+                        eventSchema = librarySource.eventSchema;
+                    }
+                }
+            }
+            // Legacy pv.event/pv.eventRef format is no longer supported
+            if (!eventName)
+                continue;
+            // Collect all attribute paths from schema (exact paths only, not parents)
+            const schemaAttrs = new Set();
+            if (eventSchema?.attributes) {
+                for (const attrName of Object.keys(eventSchema.attributes)) {
+                    schemaAttrs.add(attrName);
+                }
+            }
+            eventSchemaAttributes.set(eventName, schemaAttrs);
+        }
+        // Check each scenario's event templates
+        for (let scenarioIdx = 0; scenarioIdx < workflow.scenarios.length; scenarioIdx++) {
+            const scenario = workflow.scenarios[scenarioIdx];
+            if (!scenario.template?.events)
+                continue;
+            for (const [eventName, eventTemplateEntry] of Object.entries(scenario.template.events)) {
+                // Skip wildcard patterns
+                if (eventName.includes('*'))
+                    continue;
+                const schemaAttrs = eventSchemaAttributes.get(eventName);
+                // If event has no schema, we can't validate (already flagged by checkEventReferences)
+                if (!schemaAttrs)
+                    continue;
+                // Extract attribute references from this template
+                const eventTemplate = (0, types_1.getEventTemplateString)(eventTemplateEntry);
+                const templateAttrs = this.extractAttributeReferences(eventTemplate);
+                for (const attr of templateAttrs) {
+                    // Check if attribute is defined in schema:
+                    // 1. Exact match: {{input.taskId}} with schema "input.taskId"
+                    // 2. Parent access: {{input}} with schema "input.taskId" (accessing parent object)
+                    // 3. NOT: {{input.takId}} with schema "input.taskId" (typo - different leaf)
+                    const isDefinedInSchema = schemaAttrs.has(attr) || // Exact match
+                        Array.from(schemaAttrs).some(schemaAttr => schemaAttr.startsWith(attr + '.')); // attr is parent of schema attr
+                    if (!isDefinedInSchema) {
+                        // Find similar attributes for suggestions
+                        const similar = this.findSimilarAttributes(attr, Array.from(schemaAttrs));
+                        violations.push({
+                            ruleId: 'workflow-template-attribute-not-in-schema',
+                            severity: 'error',
+                            file: workflowPath,
+                            path: `scenarios[${scenarioIdx}].template.events["${eventName}"]`,
+                            message: `Template references "{{${attr}}}" but it is not defined in the event schema for "${eventName}"`,
+                            impact: 'This attribute may render as empty or cause unexpected behavior. The schema should document all attributes used in templates.',
+                            suggestion: similar.length > 0
+                                ? `Did you mean: ${similar.map(s => `{{${s}}}`).join(', ')}? Or add "${attr}" to the event schema in ${canvasPath || 'the canvas file'}.`
+                                : `Add "${attr}" to the event schema for "${eventName}" in ${canvasPath || 'the canvas file'}, or remove it from the template if not needed.`,
+                            fixable: false,
+                        });
+                    }
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check if all events in scenario templates are connected through canvas edges
+     */
+    checkEventConnectivity(context) {
+        const violations = [];
+        if (!context.canvas) {
+            return violations; // Can't validate without canvas
+        }
+        // Check if canvas has edges - if not, error for workflows with multi-event scenarios
+        if (!context.canvas.edges || context.canvas.edges.length === 0) {
+            const { workflow } = context;
+            for (let i = 0; i < workflow.scenarios.length; i++) {
+                const scenario = workflow.scenarios[i];
+                if (!scenario.template?.events) {
+                    continue;
+                }
+                const eventNames = Object.keys(scenario.template.events);
+                if (eventNames.length >= 2) {
+                    violations.push({
+                        ruleId: 'workflow-event-connectivity',
+                        severity: 'error',
+                        file: context.workflowPath,
+                        path: `scenarios[${i}]`,
+                        message: `Scenario "${scenario.id}" has ${eventNames.length} events but the canvas has no edges`,
+                        impact: 'Events will appear as isolated nodes in workflow visualizations, making it unclear how execution flows between them',
+                        suggestion: 'Add edges to the canvas to connect the events in this scenario',
+                        fixable: false,
+                    });
+                }
+            }
+            return violations;
+        }
+        const { workflow, canvas } = context;
+        // Build event name → node ID mapping (otel-event nodes only)
+        const eventToNodeId = new Map();
+        for (const node of canvas.nodes || []) {
+            if ((0, canvas_1.isOtelEventNode)(node)) {
+                const otelEventNode = node;
+                const eventName = otelEventNode.event?.name || otelEventNode.eventRef;
+                if (eventName) {
+                    eventToNodeId.set(eventName, node.id);
+                }
+            }
+            // Legacy pv.event/pv.eventRef format is no longer supported
+        }
+        // Build adjacency graph from edges
+        const adjacency = new Map();
+        for (const edge of canvas.edges) {
+            if (!adjacency.has(edge.fromNode)) {
+                adjacency.set(edge.fromNode, new Set());
+            }
+            if (!adjacency.has(edge.toNode)) {
+                adjacency.set(edge.toNode, new Set());
+            }
+            adjacency.get(edge.fromNode).add(edge.toNode);
+            adjacency.get(edge.toNode).add(edge.fromNode); // Treat as undirected for connectivity
+        }
+        // Check each scenario
+        for (let i = 0; i < workflow.scenarios.length; i++) {
+            const scenario = workflow.scenarios[i];
+            if (!scenario.template?.events) {
+                continue;
+            }
+            const eventNames = Object.keys(scenario.template.events);
+            const nodeIds = eventNames
+                .map(name => eventToNodeId.get(name))
+                .filter((id) => id !== undefined);
+            if (nodeIds.length < 2) {
+                continue; // Need at least 2 nodes to check connectivity
+            }
+            // Check if all nodes are in the same connected component
+            const disconnected = this.findDisconnectedNodes(nodeIds, adjacency);
+            if (disconnected.length > 0) {
+                violations.push({
+                    ruleId: 'workflow-event-connectivity',
+                    severity: 'error',
+                    file: context.workflowPath,
+                    path: `scenarios[${i}].template.events`,
+                    message: `Scenario "${scenario.id}" has ${disconnected.length} disconnected event(s)`,
+                    impact: 'Events will appear as isolated nodes in workflow visualizations, making it unclear how execution flows between them',
+                    suggestion: `Add intermediate events to connect the flow. Disconnected events: ${disconnected.map(id => {
+                        const node = canvas.nodes?.find(n => n.id === id);
+                        if (!node)
+                            return id;
+                        if ((0, canvas_1.isOtelEventNode)(node)) {
+                            const otelEventNode = node;
+                            return otelEventNode.event?.name || otelEventNode.eventRef || id;
+                        }
+                        return id;
+                    }).join(', ')}`,
+                    fixable: false,
+                });
+            }
+        }
+        return violations;
+    }
+    /**
+     * Find nodes that are not connected to the main component
+     */
+    findDisconnectedNodes(nodeIds, adjacency) {
+        if (nodeIds.length === 0)
+            return [];
+        // BFS from first node - traverse ALL nodes to find connectivity
+        const visited = new Set();
+        const queue = [nodeIds[0]];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            const neighbors = adjacency.get(current) || new Set();
+            for (const neighbor of neighbors) {
+                if (!visited.has(neighbor)) {
+                    queue.push(neighbor);
+                }
+            }
+        }
+        // Return nodes from nodeIds that were not visited (disconnected)
+        return nodeIds.filter(id => !visited.has(id));
+    }
+    /**
+     * Find similar attribute names for helpful suggestions
+     *
+     * Uses simple string similarity (Levenshtein-like) to find typos
+     *
+     * @param target - The attribute being searched for
+     * @param available - Available attribute names
+     * @returns Array of similar attribute names (max 3)
+     */
+    findSimilarAttributes(target, available) {
+        const similar = [];
+        for (const attr of available) {
+            // Check for prefix match
+            if (attr.startsWith(target) || target.startsWith(attr)) {
+                similar.push({ attr, score: 10 });
+                continue;
+            }
+            // Check for substring match
+            if (attr.includes(target) || target.includes(attr)) {
+                similar.push({ attr, score: 5 });
+                continue;
+            }
+            // Check for similar structure (same number of dots)
+            const targetParts = target.split('.');
+            const attrParts = attr.split('.');
+            if (targetParts.length === attrParts.length) {
+                // Check if any parts match
+                const matchingParts = targetParts.filter((p, i) => p === attrParts[i]).length;
+                if (matchingParts > 0) {
+                    similar.push({ attr, score: matchingParts });
+                }
+            }
+        }
+        // Sort by score and return top 3
+        return similar
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 3)
+            .map((s) => s.attr);
+    }
+    /**
+     * Check formatting options
+     */
+    checkFormattingOptions(context) {
+        const violations = [];
+        const { workflow, workflowPath } = context;
+        if (!workflow.formatting) {
+            return violations;
+        }
+        // Check showAttributes
+        if (workflow.formatting.showAttributes) {
+            const validValues = ['none', 'matched', 'all'];
+            if (!validValues.includes(workflow.formatting.showAttributes)) {
+                violations.push({
+                    ruleId: 'workflow-formatting-options',
+                    severity: 'warn',
+                    file: workflowPath,
+                    path: 'formatting.showAttributes',
+                    message: `Invalid showAttributes value: "${workflow.formatting.showAttributes}"`,
+                    impact: 'May not display attributes correctly',
+                    suggestion: `Use one of: ${validValues.join(', ')}`,
+                    fixable: false,
+                });
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check execution data completeness
+     *
+     * Validates that co-located execution files contain the events and attributes
+     * that workflow templates reference.
+     */
+    async checkExecutionDataCompleteness(context) {
+        const violations = [];
+        const { workflow, workflowPath, executionFiles } = context;
+        if (!executionFiles || executionFiles.length === 0) {
+            return violations;
+        }
+        // Load and parse all execution files
+        const executions = [];
+        for (const execPath of executionFiles) {
+            try {
+                const content = await this.fsAdapter.readFile(execPath);
+                const data = JSON.parse(content);
+                executions.push({ path: execPath, data });
+            }
+            catch (error) {
+                // Skip files that can't be loaded/parsed
+                continue;
+            }
+        }
+        if (executions.length === 0) {
+            return violations;
+        }
+        // Check for multiple traces in single files (anti-pattern)
+        for (const { path, data } of executions) {
+            const traceIds = new Set();
+            data.resourceSpans?.forEach((rs) => {
+                rs.scopeSpans?.forEach((ss) => {
+                    ss.spans?.forEach((span) => {
+                        if (span.traceId) {
+                            traceIds.add(typeof span.traceId === 'string' ? span.traceId : Buffer.from(span.traceId).toString('hex'));
+                        }
+                    });
+                });
+            });
+            if (traceIds.size > 1) {
+                const fileName = path.split('/').pop() || path;
+                violations.push({
+                    ruleId: 'workflow-execution-multiple-traces',
+                    severity: 'warn',
+                    file: path,
+                    message: `Execution file contains ${traceIds.size} traces - should contain only one trace per file`,
+                    impact: 'Cannot establish clear trace-to-scenario association, makes debugging harder',
+                    suggestion: `Split ${fileName} into ${traceIds.size} separate files, one per test case (e.g., success.otel.json, error.otel.json)`,
+                    fixable: false,
+                });
+            }
+        }
+        // For each scenario, check if execution data can satisfy the template
+        workflow.scenarios.forEach((scenario, scenarioIdx) => {
+            if (!scenario.template)
+                return;
+            // Extract all template variables from this scenario
+            const templateVars = new Set();
+            const eventTemplates = new Map();
+            // Extract variables from summary
+            if (scenario.template.summary) {
+                this.extractTemplateVariables(scenario.template.summary).forEach(v => templateVars.add(v));
+            }
+            // Extract variables from introduction
+            if (scenario.template.introduction) {
+                this.extractTemplateVariables(scenario.template.introduction).forEach(v => templateVars.add(v));
+            }
+            // Extract variables from event templates
+            if (scenario.template.events) {
+                Object.entries(scenario.template.events).forEach(([eventName, templateEntry]) => {
+                    const template = (0, types_1.getEventTemplateString)(templateEntry);
+                    const vars = this.extractTemplateVariables(template);
+                    if (!eventTemplates.has(eventName)) {
+                        eventTemplates.set(eventName, new Set());
+                    }
+                    vars.forEach(v => {
+                        templateVars.add(v);
+                        eventTemplates.get(eventName).add(v);
+                    });
+                });
+            }
+            // Check if ANY execution file has the data needed
+            const hasCompleteData = executions.some(({ data }) => {
+                return this.executionHasTemplateData(data, scenario.template, templateVars, eventTemplates);
+            });
+            if (!hasCompleteData && templateVars.size > 0) {
+                const missingInfo = this.findMissingTemplateData(executions, scenario.template, eventTemplates);
+                violations.push({
+                    ruleId: 'workflow-execution-data-incomplete',
+                    severity: 'warn',
+                    file: workflowPath,
+                    path: `scenarios[${scenarioIdx}].template`,
+                    message: `Template references data not found in co-located execution files`,
+                    impact: 'Template variables will not resolve when viewing executions',
+                    suggestion: missingInfo.length > 0
+                        ? `Missing: ${missingInfo.slice(0, 3).join(', ')}${missingInfo.length > 3 ? ` and ${missingInfo.length - 3} more` : ''}`
+                        : 'Ensure execution files contain the events and attributes referenced in templates',
+                    fixable: false,
+                });
+            }
+        });
+        return violations;
+    }
+    /**
+     * Extract template variable references from a template string
+     * Matches {{variableName}} and {{@span.attributeName}} patterns
+     */
+    extractTemplateVariables(template) {
+        const vars = [];
+        // Match {{variableName}}, {{object.property}}, or {{@span.attributeName}}
+        // but not {{#if}} {{/if}} {{else}}
+        const pattern = /\{\{(?!\s*[#/])\s*(@?[a-zA-Z_][a-zA-Z0-9._]*)\s*\}\}/g;
+        let match;
+        while ((match = pattern.exec(template)) !== null) {
+            const varName = match[1];
+            // Skip Handlebars helpers and keywords
+            if (!['this', 'else', 'each', 'if', 'unless', 'with'].includes(varName)) {
+                // Skip @span.* variables - they reference span attributes which are
+                // validated separately and don't need to be in event attributes
+                if (!varName.startsWith('@span.')) {
+                    vars.push(varName);
+                }
+            }
+        }
+        return vars;
+    }
+    /**
+     * Check if execution data contains the template data needed
+     */
+    executionHasTemplateData(execution, template, templateVars, eventTemplates) {
+        // Collect all events and their attributes from the execution
+        const executionEvents = new Map();
+        execution.resourceSpans?.forEach((rs) => {
+            rs.scopeSpans?.forEach((ss) => {
+                ss.spans?.forEach((span) => {
+                    // Add span events
+                    span.events?.forEach((event) => {
+                        const eventName = event.name;
+                        if (!executionEvents.has(eventName)) {
+                            executionEvents.set(eventName, new Set());
+                        }
+                        // Add event attributes
+                        event.attributes?.forEach((attr) => {
+                            executionEvents.get(eventName).add(attr.key);
+                        });
+                    });
+                    // Also check span-level attributes (available as aggregates)
+                    if (span.name) {
+                        if (!executionEvents.has(span.name)) {
+                            executionEvents.set(span.name, new Set());
+                        }
+                        span.attributes?.forEach((attr) => {
+                            executionEvents.get(span.name).add(attr.key);
+                        });
+                    }
+                });
+            });
+        });
+        // Check if the execution has the events referenced in templates
+        let hasAllData = true;
+        for (const [eventName, requiredVars] of eventTemplates.entries()) {
+            // Check if this event exists in execution
+            const eventData = executionEvents.get(eventName);
+            if (!eventData) {
+                // Event doesn't exist - this is incomplete
+                hasAllData = false;
+                break;
+            }
+            // Check if event has all required attributes
+            for (const varName of requiredVars) {
+                const baseVar = varName.split('.')[0]; // Handle nested properties
+                if (!eventData.has(baseVar)) {
+                    hasAllData = false;
+                    break;
+                }
+            }
+            if (!hasAllData)
+                break;
+        }
+        return hasAllData;
+    }
+    /**
+     * Find what specific data is missing from executions
+     */
+    findMissingTemplateData(executions, template, eventTemplates) {
+        const missing = [];
+        const allEvents = new Set();
+        // Collect all events from all executions
+        executions.forEach(({ data }) => {
+            data.resourceSpans?.forEach((rs) => {
+                rs.scopeSpans?.forEach((ss) => {
+                    ss.spans?.forEach((span) => {
+                        span.events?.forEach((event) => {
+                            allEvents.add(event.name);
+                        });
+                        if (span.name) {
+                            allEvents.add(span.name);
+                        }
+                    });
+                });
+            });
+        });
+        // Check what's missing
+        for (const [eventName, requiredVars] of eventTemplates.entries()) {
+            if (!allEvents.has(eventName)) {
+                missing.push(`event "${eventName}"`);
+            }
+            else {
+                // Event exists, check attributes
+                requiredVars.forEach(varName => {
+                    missing.push(`attribute "${varName}" in event "${eventName}"`);
+                });
+            }
+        }
+        return missing;
+    }
+    /**
+     * Aggregate violations into result
+     */
+    aggregateResults(violations) {
+        let errorCount = 0;
+        let warningCount = 0;
+        let fixableCount = 0;
+        violations.forEach((v) => {
+            if (v.severity === 'error') {
+                errorCount++;
+            }
+            else {
+                warningCount++;
+            }
+            if (v.fixable) {
+                fixableCount++;
+            }
+        });
+        return {
+            violations,
+            errorCount,
+            warningCount,
+            fixableCount,
+        };
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    /**
+     * Check if a version string is valid semver
+     */
+    isValidSemver(version) {
+        const semverPattern = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+        return semverPattern.test(version);
+    }
+    /**
+     * Check if an event name matches any available event (supports globs)
+     */
+    matchesEventPattern(eventName, availableEvents) {
+        // Exact match only
+        return availableEvents.includes(eventName);
+    }
+    /**
+     * Extract base event name from event pattern
+     *
+     * Examples:
+     * - "installation.started" -> "installation.started"
+     * - "installation.progress[stage=skills_discovered]" -> "installation.progress"
+     * - "error.*[severity=high]" -> "error.*"
+     */
+    extractBaseEventName(eventPattern) {
+        const bracketIndex = eventPattern.indexOf('[');
+        if (bracketIndex === -1) {
+            return eventPattern;
+        }
+        return eventPattern.substring(0, bracketIndex);
+    }
+    /**
+     * Extract attribute value from event pattern for suggestion
+     *
+     * Examples:
+     * - "installation.progress[stage=skills_discovered]" -> "skills_discovered"
+     * - "error.*[severity=high]" -> "high"
+     * - "installation.started" -> ""
+     */
+    extractAttributeValue(eventPattern) {
+        const match = eventPattern.match(/\[.*?=(.*?)\]/);
+        if (!match) {
+            return '';
+        }
+        return match[1];
+    }
+    /**
+     * Extract attribute references from Handlebars template
+     *
+     * Parses template strings like:
+     * - "{{source}}" -> ["source"]
+     * - "{{source.url}}" -> ["source.url"]
+     * - "{{#if options.global}}" -> ["options.global"]
+     * - "{{#if (eq install.mode 'symlink')}}" -> ["install.mode"]
+     *
+     * @param template - Handlebars template string
+     * @returns Array of attribute paths referenced in the template
+     */
+    extractAttributeReferences(template) {
+        const attributes = new Set();
+        // Match all Handlebars expressions: {{...}}
+        const expressionPattern = /\{\{([^}]+)\}\}/g;
+        let match;
+        while ((match = expressionPattern.exec(template)) !== null) {
+            const expression = match[1].trim();
+            // Skip block helpers closing tags
+            if (expression.startsWith('/')) {
+                continue;
+            }
+            // Handle block helpers: #if, #each, #unless, etc.
+            if (expression.startsWith('#')) {
+                // Extract the condition/expression after the helper
+                const helperMatch = expression.match(/^#\w+\s+(.+)$/);
+                if (helperMatch) {
+                    this.extractAttributesFromExpression(helperMatch[1], attributes);
+                }
+                continue;
+            }
+            // Handle regular expressions
+            this.extractAttributesFromExpression(expression, attributes);
+        }
+        return Array.from(attributes);
+    }
+    /**
+     * Extract attribute references from a single Handlebars expression
+     *
+     * Handles:
+     * - Simple references: source.url
+     * - Helper calls: (eq install.mode 'symlink')
+     * - Nested expressions
+     *
+     * @param expression - The expression to parse
+     * @param attributes - Set to add found attributes to
+     */
+    extractAttributesFromExpression(expression, attributes) {
+        // Remove helper parentheses: (eq install.mode 'symlink') -> eq install.mode 'symlink'
+        const cleaned = expression.replace(/^\(|\)$/g, '').trim();
+        // Split on spaces to handle helper arguments
+        const parts = cleaned.split(/\s+/);
+        for (const part of parts) {
+            // Skip helper names, string literals, numbers, and boolean literals
+            if (part.match(/^(if|unless|each|with|eq|ne|lt|gt|lte|gte|and|or|not)$/) ||
+                part.match(/^['"].*['"]$/) ||
+                part.match(/^\d+$/) ||
+                part.match(/^(true|false|null|undefined)$/)) {
+                continue;
+            }
+            // Remove any remaining quotes or parentheses
+            const cleanPart = part.replace(/['"()]/g, '');
+            // If it looks like an attribute path (contains letters/dots/underscores)
+            if (cleanPart && cleanPart.match(/^[a-zA-Z_][a-zA-Z0-9_.]*$/)) {
+                attributes.add(cleanPart);
+            }
+        }
+    }
+    /**
+     * Check if an attribute is an object type
+     *
+     * @param value - The attribute value to check
+     * @returns true if value is a plain object (not array, not null)
+     */
+    isObjectType(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !(value instanceof Date));
+    }
+}
+exports.WorkflowValidator = WorkflowValidator;
+/**
+ * Create a validator instance
+ */
+function createWorkflowValidator(fsAdapter) {
+    return new WorkflowValidator(fsAdapter);
+}
+exports.createWorkflowValidator = createWorkflowValidator;
+//# sourceMappingURL=validator.js.map