@principal-ai/subsystems-core 0.29.0 → 0.31.0

package/src/workflow/__tests__/validator.test.ts

@@ -1,3225 +0,0 @@
-/**
- * Tests for workflow template validator
- */
-
-import { WorkflowValidator } from '../validator';
-import type { WorkflowTemplate, WorkflowValidationContext } from '../validator';
-import type { ExtendedCanvas } from '../../types/canvas';
-import type { ComponentLibrary } from '../../types/library';
-import { EventRegistry } from '../../registry/EventRegistry';
-import { NodeFileSystemAdapter } from '@principal-ai/repository-abstraction/node';
-import { mkdtempSync, writeFileSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('WorkflowValidator', () => {
-  let validator: WorkflowValidator;
-  let tempDir: string;
-
-  beforeEach(() => {
-    validator = new WorkflowValidator(new NodeFileSystemAdapter());
-    // Create a temporary directory for test files
-    tempDir = mkdtempSync(join(tmpdir(), 'workflow-validator-test-'));
-  });
-
-  afterEach(() => {
-    // Clean up temp directory
-    if (tempDir) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  // ============================================================================
-  // Helper Functions
-  // ============================================================================
-
-  function createValidWorkflow(): WorkflowTemplate {
-    return {
-      version: '1.0.0',
-      canvas: 'test.otel.canvas',
-      name: 'Test Workflow',
-      description: 'A test workflow template',
-      spanPattern: 'test.execution',
-      scenarioSelection: 'first-match',
-      scenarios: [
-        {
-          id: 'test-passed',
-          priority: 1,
-          description: 'Test passed successfully',
-          template: {
-            introduction: 'Test passed',
-            events: {
-              'test.started': 'Started test',
-              'test.complete': 'Test completed',
-            },
-            summary: 'Success',
-          },
-        },
-        {
-          id: 'test-failed',
-          priority: 2,
-          description: 'Test failed',
-          template: {
-            introduction: 'Test failed',
-            events: {
-              'test.started': 'Test started',
-              'test.failed': 'Test failed',
-            },
-          },
-        },
-      ],
-    };
-  }
-
-  function createValidCanvas(): ExtendedCanvas {
-    return {
-      nodes: [
-        {
-          id: 'test-started',
-          type: 'otel-event',
-          x: 0,
-          y: 0,
-          width: 200,
-          height: 100,
-          eventRef: 'test.started',
-        },
-        {
-          id: 'test-complete',
-          type: 'otel-event',
-          x: 250,
-          y: 0,
-          width: 200,
-          height: 100,
-          eventRef: 'test.complete',
-        },
-        {
-          id: 'test-error',
-          type: 'otel-event',
-          x: 500,
-          y: 0,
-          width: 200,
-          height: 100,
-          eventRef: 'test.error',
-        },
-      ],
-      edges: [
-        {
-          id: 'edge1',
-          fromNode: 'test-started',
-          toNode: 'test-complete',
-          fromSide: 'right',
-          toSide: 'left',
-        },
-        {
-          id: 'edge2',
-          fromNode: 'test-started',
-          toNode: 'test-error',
-          fromSide: 'right',
-          toSide: 'left',
-        },
-      ],
-      pv: {
-        version: '1.0.0',
-        name: 'Test Canvas',
-        markdown: 'test.md',
-      },
-    };
-  }
-
-  function createContext(
-    workflow: Partial<WorkflowTemplate>,
-    options: {
-      canvas?: ExtendedCanvas;
-      canvasPath?: string;
-    } = {}
-  ): WorkflowValidationContext {
-    const fullWorkflow = {
-      ...createValidWorkflow(),
-      ...workflow,
-    } as WorkflowTemplate;
-
-    return {
-      workflow: fullWorkflow,
-      workflowPath: 'test.workflow.json',
-      canvas: options.canvas,
-      canvasPath: options.canvasPath,
-      basePath: tempDir,
-    };
-  }
-
-  // ============================================================================
-  // Schema Validation Tests
-  // ============================================================================
-
-  describe('checkSchema', () => {
-    it('should pass for valid workflow template', async () => {
-      // Create canvas file so canvas-exists check passes
-      const canvasPath = join(tempDir, 'test.otel.canvas');
-      const markdownPath = join(tempDir, 'test.md');
-      writeFileSync(canvasPath, JSON.stringify(createValidCanvas()));
-      writeFileSync(markdownPath, '# Test Documentation');
-
-      const context = createContext({}, { canvasPath });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBe(0);
-      expect(result.warningCount).toBe(0);
-    });
-
-    it('should flag missing version', async () => {
-      const context = createContext({ version: undefined as unknown });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-schema-valid',
-          path: 'version',
-          message: expect.stringContaining('Missing required field "version"'),
-        })
-      );
-    });
-
-    it('should flag invalid semver version', async () => {
-      const context = createContext({ version: 'not-a-version' });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-schema-valid',
-          path: 'version',
-          message: expect.stringContaining('Invalid version format'),
-        })
-      );
-    });
-
-    it('should flag missing canvas reference', async () => {
-      const context = createContext({ canvas: undefined as unknown });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-schema-valid',
-          path: 'canvas',
-          message: expect.stringContaining('Missing required field "canvas"'),
-        })
-      );
-    });
-
-    it('should flag missing name', async () => {
-      const context = createContext({ name: undefined as unknown });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-schema-valid',
-          path: 'name',
-          message: expect.stringContaining('Missing required field "name"'),
-        })
-      );
-    });
-
-    it('should flag missing description', async () => {
-      const context = createContext({ description: undefined as unknown });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-schema-valid',
-          path: 'description',
-        })
-      );
-    });
-
-    it('should flag invalid scenarioSelection', async () => {
-      const context = createContext({ scenarioSelection: 'invalid' as unknown });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-schema-valid',
-          path: 'scenarioSelection',
-        })
-      );
-    });
-
-    it('should flag empty scenarios array', async () => {
-      const context = createContext({ scenarios: [] });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-schema-valid',
-          path: 'scenarios',
-          message: expect.stringContaining('empty'),
-        })
-      );
-    });
-  });
-
-  // ============================================================================
-  // Canvas Existence Tests
-  // ============================================================================
-
-  describe('checkCanvasExists', () => {
-    it('should pass when canvas file exists', async () => {
-      // Create a canvas file in temp directory
-      const canvasPath = join(tempDir, 'test.otel.canvas');
-      const markdownPath = join(tempDir, 'test.md');
-      writeFileSync(canvasPath, JSON.stringify(createValidCanvas()));
-      writeFileSync(markdownPath, '# Test Documentation');
-
-      const context = createContext(
-        { canvas: 'test.otel.canvas' },
-        { canvasPath }
-      );
-      const result = await validator.validate(context);
-
-      const canvasViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-canvas-exists'
-      );
-      expect(canvasViolations).toHaveLength(0);
-    });
-
-    it('should flag when canvas file does not exist', async () => {
-      const context = createContext(
-        { canvas: 'nonexistent.otel.canvas' },
-        { canvasPath: join(tempDir, 'nonexistent.otel.canvas') }
-      );
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-canvas-exists',
-          message: expect.stringContaining('does not exist'),
-        })
-      );
-    });
-  });
-
-  // ============================================================================
-  // Implementation Files Existence Tests (workflow-files-exist)
-  // ============================================================================
-
-  describe('workflow-files-exist', () => {
-    // Create the referenced canvas so unrelated canvas-exists violations stay silent.
-    function setupCanvas(): string {
-      const canvasPath = join(tempDir, 'test.otel.canvas');
-      writeFileSync(canvasPath, JSON.stringify(createValidCanvas()));
-      writeFileSync(join(tempDir, 'test.md'), '# Test');
-      return canvasPath;
-    }
-
-    it('should pass when status is implemented and all files exist', async () => {
-      const canvasPath = setupCanvas();
-      writeFileSync(join(tempDir, 'impl.ts'), '// impl');
-
-      const context = createContext(
-        { status: 'implemented', scope: 'test-scope', files: ['impl.ts'] },
-        { canvasPath }
-      );
-      const result = await validator.validate(context);
-
-      const fileViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-files-exist'
-      );
-      expect(fileViolations).toHaveLength(0);
-    });
-
-    it('should flag each missing file when status is implemented', async () => {
-      const canvasPath = setupCanvas();
-
-      const context = createContext(
-        {
-          status: 'implemented',
-          scope: 'test-scope',
-          files: ['missing-one.ts', 'missing-two.ts'],
-        },
-        { canvasPath }
-      );
-      const result = await validator.validate(context);
-
-      const fileViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-files-exist'
-      );
-      expect(fileViolations).toHaveLength(2);
-      expect(fileViolations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-files-exist',
-          severity: 'error',
-          path: 'files',
-          message: expect.stringContaining('missing-one.ts'),
-        })
-      );
-      expect(fileViolations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-files-exist',
-          message: expect.stringContaining('missing-two.ts'),
-        })
-      );
-    });
-
-    it('should flag only the missing files when some exist and some do not', async () => {
-      const canvasPath = setupCanvas();
-      writeFileSync(join(tempDir, 'present.ts'), '// present');
-
-      const context = createContext(
-        {
-          status: 'implemented',
-          scope: 'test-scope',
-          files: ['present.ts', 'absent.ts'],
-        },
-        { canvasPath }
-      );
-      const result = await validator.validate(context);
-
-      const fileViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-files-exist'
-      );
-      expect(fileViolations).toHaveLength(1);
-      expect(fileViolations[0].message).toContain('absent.ts');
-    });
-
-    it('should not check file existence when status is draft', async () => {
-      const canvasPath = setupCanvas();
-
-      const context = createContext(
-        { status: 'draft', files: ['does-not-exist.ts'] },
-        { canvasPath }
-      );
-      const result = await validator.validate(context);
-
-      const fileViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-files-exist'
-      );
-      expect(fileViolations).toHaveLength(0);
-    });
-
-    it('should not check file existence when status is approved', async () => {
-      const canvasPath = setupCanvas();
-
-      const context = createContext(
-        {
-          status: 'approved',
-          scope: 'test-scope',
-          files: ['does-not-exist.ts'],
-        },
-        { canvasPath }
-      );
-      const result = await validator.validate(context);
-
-      const fileViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-files-exist'
-      );
-      expect(fileViolations).toHaveLength(0);
-    });
-  });
-
-  // ============================================================================
-  // Scenario Validation Tests
-  // ============================================================================
-
-  describe('checkScenarios', () => {
-    it('should pass for valid scenarios', async () => {
-      const context = createContext({});
-      const result = await validator.validate(context);
-
-      const scenarioViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-scenario-valid'
-      );
-      expect(scenarioViolations).toHaveLength(0);
-    });
-
-    it('should flag missing scenario ID', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: undefined as unknown,
-            priority: 1,
-            description: 'Test',
-            template: { introduction: 'Test' },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-scenario-valid',
-          message: expect.stringContaining('missing required "id"'),
-        })
-      );
-    });
-
-    it('should flag duplicate scenario IDs', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'duplicate',
-            priority: 1,
-            description: 'First',
-            template: { introduction: 'First' },
-          },
-          {
-            id: 'duplicate',
-            priority: 2,
-            description: 'Second',
-            template: { introduction: 'Second' },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-scenario-valid',
-          message: expect.stringContaining('Duplicate scenario ID'),
-        })
-      );
-    });
-
-    it('should flag missing priority', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: undefined as unknown,
-            description: 'Test',
-            template: { introduction: 'Test' },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-scenario-valid',
-          message: expect.stringContaining('missing required "priority"'),
-        })
-      );
-    });
-
-    it('should flag negative priority', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: -1,
-            description: 'Test',
-            template: { introduction: 'Test' },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-scenario-valid',
-          message: expect.stringContaining('non-negative'),
-        })
-      );
-    });
-
-    it('should flag duplicate priorities', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'first',
-            priority: 1,
-            description: 'First',
-            template: { introduction: 'First' },
-          },
-          {
-            id: 'second',
-            priority: 1,
-            description: 'Second',
-            template: { introduction: 'Second' },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-scenario-valid',
-          message: expect.stringContaining('Duplicate priority'),
-        })
-      );
-    });
-
-    it('should flag missing description', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: undefined as unknown,
-            template: { introduction: 'Test' },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-scenario-valid',
-          message: expect.stringContaining('missing required "description"'),
-        })
-      );
-    });
-
-    it('should flag missing template', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: undefined as unknown,
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-scenario-valid',
-          message: expect.stringContaining('missing required "template"'),
-        })
-      );
-    });
-  });
-
-  // ============================================================================
-  // Template Syntax Tests
-  // ============================================================================
-
-  describe('checkTemplateSyntax', () => {
-    it('should pass for valid template strings', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: 'Started {test.name}',
-              events: {
-                'test.started': 'Test {test.id} started',
-                'test.complete': '{result.status === "passed" ? "✅ Passed" : "❌ Failed"}',
-              },
-              summary: 'Completed in {duration}ms',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      const syntaxViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-template-syntax'
-      );
-      expect(syntaxViolations).toHaveLength(0);
-    });
-
-    it('should flag unbalanced braces (missing closing)', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: 'Test {test.name',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-syntax',
-          message: expect.stringContaining('Unbalanced braces'),
-        })
-      );
-    });
-
-    it('should flag unbalanced braces (extra closing)', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: 'Test {test.name}}',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-syntax',
-          message: expect.stringContaining('Unbalanced braces'),
-        })
-      );
-    });
-
-    it('should flag incomplete conditional expression', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: '{result.passed ? "Success"}',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-syntax',
-          message: expect.stringContaining('Incomplete conditional'),
-        })
-      );
-    });
-
-    it('should handle quotes in template strings', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: '{test.status === "passed" ? "Success" : "Failed"}',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      const syntaxViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-template-syntax'
-      );
-      expect(syntaxViolations).toHaveLength(0);
-    });
-
-    it('should validate event templates', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              events: {
-                'test.started': 'Started {test.name',
-                'test.complete': 'Completed',
-              },
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-syntax',
-          path: expect.stringContaining('events.test.started'),
-        })
-      );
-    });
-
-    it('should flag Handlebars {{#if}} conditionals', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: '{{#if hasError}}Error occurred{{/if}}',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-conditional',
-          message: expect.stringContaining('Conditional syntax detected'),
-          suggestion: expect.stringContaining('Split into separate scenarios'),
-        })
-      );
-    });
-
-    it('should flag Handlebars {{#unless}} conditionals', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              summary: '{{#unless success}}Failed{{/unless}}',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-conditional',
-          message: expect.stringContaining('{{#unless'),
-        })
-      );
-    });
-
-    it('should flag Handlebars {{#each}} iteration', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: '{{#each items}}{{name}}{{/each}}',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-conditional',
-          message: expect.stringContaining('{{#each'),
-        })
-      );
-    });
-
-    it('should flag Handlebars {{else}} clause', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              events: {
-                'test.started': '{{#if fast}}Quick{{else}}Slow{{/if}}',
-              },
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-conditional',
-        })
-      );
-    });
-
-    it('should allow simple variable interpolation without conditionals', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: 'Test {{name}} completed in {{duration}}ms',
-              events: {
-                'test.started': 'Started {{testName}}',
-              },
-              summary: 'Result: {{status}}',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      const conditionalViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-template-conditional'
-      );
-      expect(conditionalViolations).toHaveLength(0);
-    });
-  });
-
-  // ============================================================================
-  // Emoji Validation Tests
-  // ============================================================================
-
-  describe('checkTemplateEmojis', () => {
-    it('should flag emojis in event templates', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              events: {
-                'test.started': '🚀 Starting test',
-              },
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-emoji',
-          message: expect.stringContaining('emoji'),
-          suggestion: expect.stringContaining('Remove emoji'),
-        })
-      );
-    });
-
-    it('should flag emojis in introduction', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: '✅ Test Started',
-              events: {
-                'test.started': 'Started',
-              },
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-emoji',
-        })
-      );
-    });
-
-    it('should flag emojis in summary', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              events: {
-                'test.started': 'Started',
-              },
-              summary: '❌ Failed',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-template-emoji',
-        })
-      );
-    });
-
-    it('should flag multiple different emojis', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: '🔄 Loading...',
-              events: {
-                'test.started': '▶️ Started',
-                'test.complete': '✅ Done',
-              },
-              summary: '🎉 Success!',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      const emojiViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-template-emoji'
-      );
-      expect(emojiViolations.length).toBeGreaterThan(0);
-    });
-
-    it('should allow templates without emojis', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: '[START] Test Beginning',
-              events: {
-                'test.started': 'Started: {{name}}',
-                'test.complete': 'Completed in {{duration}}ms',
-              },
-              summary: '[DONE] Test finished successfully',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      const emojiViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-template-emoji'
-      );
-      expect(emojiViolations).toHaveLength(0);
-    });
-
-    it('should allow special characters that are not emojis', async () => {
-      const context = createContext({
-        scenarios: [
-          {
-            id: 'test',
-            priority: 1,
-            description: 'Test',
-            template: {
-              introduction: '>>> Test Output <<<',
-              events: {
-                'test.started': '* Started @ {{timestamp}}',
-                'test.complete': '# Complete - Duration: {{duration}}ms',
-              },
-              summary: '=== Summary ===',
-            },
-          },
-        ],
-      });
-      const result = await validator.validate(context);
-
-      const emojiViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-template-emoji'
-      );
-      expect(emojiViolations).toHaveLength(0);
-    });
-  });
-
-  // ============================================================================
-  // Formatting Options Tests
-  // ============================================================================
-
-  describe('checkFormattingOptions', () => {
-    it('should pass for valid formatting options', async () => {
-      const context = createContext({
-        formatting: {
-          indentPerLevel: '  ',
-          timestampFormat: 'HH:mm:ss.SSS',
-          showTimestamps: true,
-          showDuration: true,
-          showSpanIds: false,
-          showAttributes: 'matched',
-        },
-      });
-      const result = await validator.validate(context);
-
-      const formattingViolations = result.violations.filter(
-        (v) => v.ruleId === 'workflow-formatting-options'
-      );
-      expect(formattingViolations).toHaveLength(0);
-    });
-
-    it('should flag invalid showAttributes value', async () => {
-      const context = createContext({
-        formatting: {
-          showAttributes: 'invalid' as unknown,
-        },
-      });
-      const result = await validator.validate(context);
-
-      expect(result.warningCount).toBeGreaterThan(0);
-      expect(result.violations).toContainEqual(
-        expect.objectContaining({
-          ruleId: 'workflow-formatting-options',
-          severity: 'warn',
-          message: expect.stringContaining('Invalid showAttributes'),
-        })
-      );
-    });
-
-    it('should accept valid showAttributes values', async () => {
-      const values = ['none', 'matched', 'all'];
-
-      for (const value of values) {
-        const context = createContext({
-          formatting: {
-            showAttributes: value as unknown,
-          },
-        });
-        const result = await validator.validate(context);
-
-        const formattingViolations = result.violations.filter(
-          (v) => v.ruleId === 'workflow-formatting-options' && v.path === 'formatting.showAttributes'
-        );
-        expect(formattingViolations).toHaveLength(0);
-      }
-    });
-  });
-
-  // ============================================================================
-  // Aggregate Results Tests
-  // ============================================================================
-
-  describe('aggregateResults', () => {
-    it('should correctly count errors and warnings', async () => {
-      const context = createContext({
-        version: undefined as unknown,
-        name: undefined as unknown,
-        formatting: {
-          showAttributes: 'invalid' as unknown,
-        },
-      });
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBeGreaterThan(0);
-      expect(result.warningCount).toBeGreaterThan(0);
-      expect(result.violations.length).toBe(result.errorCount + result.warningCount);
-    });
-
-    it('should count fixable violations', async () => {
-      // Currently no violations are fixable, but test the infrastructure
-      const context = createContext({});
-      const result = await validator.validate(context);
-
-      const fixable = result.violations.filter((v) => v.fixable);
-      expect(result.fixableCount).toBe(fixable.length);
-    });
-  });
-
-  // ============================================================================
-  // Integration Tests
-  // ============================================================================
-
-  describe('integration tests', () => {
-    it('should validate a complete valid workflow template', async () => {
-      const canvasPath = join(tempDir, 'test.otel.canvas');
-      const markdownPath = join(tempDir, 'test.md');
-      writeFileSync(canvasPath, JSON.stringify(createValidCanvas()));
-      writeFileSync(markdownPath, '# Test Documentation');
-
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        canvas: 'test.otel.canvas',
-        name: 'Complete Test Workflow',
-        description: 'A complete workflow template for testing',
-        spanPattern: 'test.integration',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'error',
-            priority: 1,
-            description: 'Error scenario',
-            template: {
-              introduction: '[ERROR] Error Occurred',
-              events: {
-                'test.started': 'Started: {test.name}',
-                'test.error': 'Error: {error.message}',
-              },
-              summary: '[FAILED]',
-            },
-          },
-          {
-            id: 'success',
-            priority: 2,
-            description: 'Success scenario',
-            template: {
-              introduction: '[SUCCESS] Test Passed',
-              events: {
-                'test.started': 'Started: {test.name}',
-                'test.complete': 'Completed in {duration}ms',
-              },
-              summary: '[SUCCESS]',
-            },
-          },
-        ],
-        formatting: {
-          indentPerLevel: '  ',
-          showTimestamps: false,
-          showDuration: true,
-          showAttributes: 'matched',
-        },
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas: createValidCanvas(),
-        canvasPath,
-        basePath: tempDir,
-      };
-
-      const result = await validator.validate(context);
-
-      expect(result.errorCount).toBe(0);
-      expect(result.warningCount).toBe(0);
-      expect(result.violations).toHaveLength(0);
-    });
-
-    it('should collect multiple violations from different rules', async () => {
-      const workflow = {
-        version: 'invalid-version',
-        canvas: 'nonexistent.canvas',
-        name: '',
-        scenarios: [
-          {
-            id: 'test',
-            priority: -1,
-            template: {
-              introduction: '{unclosed',
-            },
-          },
-        ],
-        formatting: {
-          showAttributes: 'invalid',
-        },
-      } as unknown as WorkflowTemplate;
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir,
-      };
-
-      const result = await validator.validate(context);
-
-      expect(result.violations.length).toBeGreaterThan(5);
-
-      const ruleIds = new Set(result.violations.map((v) => v.ruleId));
-      expect(ruleIds.size).toBeGreaterThan(3); // Multiple different rules triggered
-    });
-  });
-
-  // ============================================================================
-  // EventRegistry Enhanced Error Messages Tests
-  // ============================================================================
-
-  describe('checkEventReferences with EventRegistry', () => {
-    function createLibrary(eventSchemas: Record<string, { description: string; attributes: Record<string, unknown> }>): ComponentLibrary {
-      return {
-        version: '1.0.0',
-        name: 'Test Library',
-        nodeComponents: {},
-        edgeComponents: {},
-        eventSchemas,
-      };
-    }
-
-    function createCanvasWithEvents(events: string[]): ExtendedCanvas {
-      return {
-        nodes: events.map((eventName, i) => ({
-          id: `node-${i}`,
-          type: 'text' as const,
-          x: i * 100,
-          y: 0,
-          width: 100,
-          height: 50,
-          pv: {
-            eventRef: eventName,
-          },
-        })),
-        edges: [],
-        pv: {
-          version: '1.0.0',
-          name: 'Test Canvas',
-          markdown: 'test.md',
-        },
-      };
-    }
-
-    it('should show library suggestion when event exists in library but not canvas', async () => {
-      // Create library with the event
-      const library = createLibrary({
-        'cleanup.started': { description: 'Cleanup started', attributes: {} },
-      });
-
-      // Create a canvas WITHOUT the event
-      const canvas = createCanvasWithEvents(['other.event']);
-
-      // Create another canvas that HAS the event (for the registry)
-      const otherCanvas = createCanvasWithEvents(['cleanup.started']);
-
-      // Build registry with library
-      const canvases = new Map<string, ExtendedCanvas>();
-      canvases.set('other.otel.canvas', otherCanvas);
-      const eventRegistry = EventRegistry.build(library, canvases, 'library.yaml');
-
-      // Workflow references an event not in its canvas
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        canvas: 'test.otel.canvas',
-        name: 'Test Workflow',
-        description: 'Test',
-        mode: 'span-tree',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'default',
-            priority: 1,
-            description: 'Default',
-            template: {
-              events: {
-                'cleanup.started': 'Cleanup started', // Not in canvas
-              },
-            },
-          },
-        ],
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        canvasPath: join(tempDir, 'test.otel.canvas'),
-        basePath: tempDir,
-        eventRegistry,
-      };
-
-      const result = await validator.validate(context);
-
-      // Should have an error about the missing event
-      const eventViolation = result.violations.find(
-        v => v.ruleId === 'workflow-event-sync' && v.message.includes('cleanup.started')
-      );
-
-      expect(eventViolation).toBeDefined();
-      // Should suggest using eventRef since it's in the library
-      expect(eventViolation!.message).toContain('available in library');
-      expect(eventViolation!.suggestion).toContain('eventRef');
-    });
-
-    it('should show canvas location when event exists in another canvas but not library', async () => {
-      // No library events
-      const canvases = new Map<string, ExtendedCanvas>();
-
-      // Create another canvas that has the event we're looking for
-      const cleanupCanvas = createCanvasWithEvents(['cleanup.started']);
-      canvases.set('cleanup-operations.otel.canvas', cleanupCanvas);
-
-      // Build registry without library
-      const eventRegistry = EventRegistry.build(undefined, canvases);
-
-      // Create a canvas WITHOUT the event
-      const canvas = createCanvasWithEvents(['other.event']);
-
-      // Workflow references an event not in its canvas
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        canvas: 'test.otel.canvas',
-        name: 'Test Workflow',
-        description: 'Test',
-        mode: 'span-tree',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'default',
-            priority: 1,
-            description: 'Default',
-            template: {
-              events: {
-                'cleanup.started': 'Cleanup started', // Not in canvas but in another canvas
-              },
-            },
-          },
-        ],
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        canvasPath: join(tempDir, 'test.otel.canvas'),
-        basePath: tempDir,
-        eventRegistry,
-      };
-
-      const result = await validator.validate(context);
-
-      // Should have an error about the missing event
-      const eventViolation = result.violations.find(
-        v => v.ruleId === 'workflow-event-sync' && v.message.includes('cleanup.started')
-      );
-
-      expect(eventViolation).toBeDefined();
-      // Should mention where the event was found
-      expect(eventViolation!.message).toContain('cleanup-operations.otel.canvas');
-      // Should suggest adding to library
-      expect(eventViolation!.suggestion).toContain('library.yaml');
-    });
-
-    it('should show generic error when event not found anywhere', async () => {
-      // Empty registry
-      const eventRegistry = EventRegistry.build(undefined, new Map());
-
-      // Create a canvas without the event
-      const canvas = createCanvasWithEvents(['other.event']);
-
-      // Workflow references an event that doesn't exist anywhere
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        canvas: 'test.otel.canvas',
-        name: 'Test Workflow',
-        description: 'Test',
-        mode: 'span-tree',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'default',
-            priority: 1,
-            description: 'Default',
-            template: {
-              events: {
-                'nonexistent.event': 'Does not exist anywhere',
-              },
-            },
-          },
-        ],
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        canvasPath: join(tempDir, 'test.otel.canvas'),
-        basePath: tempDir,
-        eventRegistry,
-      };
-
-      const result = await validator.validate(context);
-
-      // Should have an error about the missing event
-      const eventViolation = result.violations.find(
-        v => v.ruleId === 'workflow-event-sync' && v.message.includes('nonexistent.event')
-      );
-
-      expect(eventViolation).toBeDefined();
-      // Should show the standard error message
-      expect(eventViolation!.message).toContain('not defined in canvas');
-    });
-
-    it('should work without eventRegistry (backward compatible)', async () => {
-      // Create a canvas without the event
-      const canvas = createCanvasWithEvents(['other.event']);
-
-      // Workflow references an event not in canvas
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        canvas: 'test.otel.canvas',
-        name: 'Test Workflow',
-        description: 'Test',
-        mode: 'span-tree',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'default',
-            priority: 1,
-            description: 'Default',
-            template: {
-              events: {
-                'missing.event': 'Not in canvas',
-              },
-            },
-          },
-        ],
-      };
-
-      // No eventRegistry provided
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        canvasPath: join(tempDir, 'test.otel.canvas'),
-        basePath: tempDir,
-        // eventRegistry: undefined
-      };
-
-      const result = await validator.validate(context);
-
-      // Should still report the error, just without enhanced suggestions
-      const eventViolation = result.violations.find(
-        v => v.ruleId === 'workflow-event-sync' && v.message.includes('missing.event')
-      );
-
-      expect(eventViolation).toBeDefined();
-      expect(eventViolation!.message).toContain('not defined in canvas');
-    });
-  });
-
-  // ============================================================================
-  // Event Connectivity Validation Tests
-  // ============================================================================
-
-  describe('checkEventConnectivity', () => {
-    it('should pass when all events are connected', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'event.started': 'Started',
-              'event.processing': 'Processing',
-              'event.complete': 'Complete'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          { id: 'n1', type: 'otel-event', x: 0, y: 0, width: 100, height: 50, event: { name: 'event.started', attributes: {} } },
-          { id: 'n2', type: 'otel-event', x: 150, y: 0, width: 100, height: 50, event: { name: 'event.processing', attributes: {} } },
-          { id: 'n3', type: 'otel-event', x: 300, y: 0, width: 100, height: 50, event: { name: 'event.complete', attributes: {} } }
-        ],
-        edges: [
-          { id: 'e1', fromNode: 'n1', toNode: 'n2' },
-          { id: 'e2', fromNode: 'n2', toNode: 'n3' }
-        ],
-        pv: {
-          version: '1.0.0',
-          name: 'Test Canvas',
-          markdown: 'test.md'
-        }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const connectivityViolations = result.violations.filter(v => v.ruleId === 'workflow-event-connectivity');
-      expect(connectivityViolations).toHaveLength(0);
-    });
-
-    it('should error when events are disconnected', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'event.started': 'Started',
-              'event.complete': 'Complete',
-              'event.error': 'Error' // Disconnected - no path from started/complete to error
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          { id: 'n1', type: 'otel-event', x: 0, y: 0, width: 100, height: 50, event: { name: 'event.started', attributes: {} } },
-          { id: 'n2', type: 'otel-event', x: 150, y: 0, width: 100, height: 50, event: { name: 'event.complete', attributes: {} } },
-          { id: 'n3', type: 'otel-event', x: 0, y: 100, width: 100, height: 50, event: { name: 'event.error', attributes: {} } }
-        ],
-        edges: [
-          { id: 'e1', fromNode: 'n1', toNode: 'n2' }
-          // n3 is isolated - no edges connecting it to n1 or n2
-        ],
-        pv: {
-          version: '1.0.0',
-          name: 'Test Canvas',
-          markdown: 'test.md'
-        }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const connectivityViolations = result.violations.filter(v => v.ruleId === 'workflow-event-connectivity');
-      expect(connectivityViolations).toHaveLength(1);
-      expect(connectivityViolations[0].severity).toBe('error');
-      expect(connectivityViolations[0].message).toContain('disconnected');
-    });
-
-    it('should error when canvas has no edges but workflow has multi-event scenarios', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'event.started': 'Started',
-              'event.complete': 'Complete'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          { id: 'n1', type: 'otel-event', x: 0, y: 0, width: 100, height: 50, event: { name: 'event.started', attributes: {} } },
-          { id: 'n2', type: 'otel-event', x: 150, y: 0, width: 100, height: 50, event: { name: 'event.complete', attributes: {} } }
-        ],
-        edges: [], // No edges defined
-        pv: {
-          version: '1.0.0',
-          name: 'Test Canvas',
-          markdown: 'test.md'
-        }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      // Should produce connectivity violation when canvas has no edges but scenario has multiple events
-      const connectivityViolations = result.violations.filter(v => v.ruleId === 'workflow-event-connectivity');
-      expect(connectivityViolations).toHaveLength(1);
-      expect(connectivityViolations[0].severity).toBe('error');
-      expect(connectivityViolations[0].message).toContain('has no edges');
-    });
-
-    it('should skip check when scenario has less than 2 events', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'event.started': 'Started'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          { id: 'n1', type: 'otel-event', x: 0, y: 0, width: 100, height: 50, event: { name: 'event.started', attributes: {} } }
-        ],
-        edges: [],
-        pv: {
-          version: '1.0.0',
-          name: 'Test Canvas',
-          markdown: 'test.md'
-        }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const connectivityViolations = result.violations.filter(v => v.ruleId === 'workflow-event-connectivity');
-      expect(connectivityViolations).toHaveLength(0);
-    });
-
-    it('should handle events connected through intermediate nodes', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'event.start': 'Start',
-              'event.end': 'End'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          { id: 'n1', type: 'otel-event', x: 0, y: 0, width: 100, height: 50, event: { name: 'event.start', attributes: {} } },
-          { id: 'n2', type: 'otel-event', x: 150, y: 0, width: 100, height: 50, event: { name: 'event.middle1', attributes: {} } },
-          { id: 'n3', type: 'otel-event', x: 300, y: 0, width: 100, height: 50, event: { name: 'event.middle2', attributes: {} } },
-          { id: 'n4', type: 'otel-event', x: 450, y: 0, width: 100, height: 50, event: { name: 'event.end', attributes: {} } }
-        ],
-        edges: [
-          { id: 'e1', fromNode: 'n1', toNode: 'n2' },
-          { id: 'e2', fromNode: 'n2', toNode: 'n3' },
-          { id: 'e3', fromNode: 'n3', toNode: 'n4' }
-        ],
-        pv: {
-          version: '1.0.0',
-          name: 'Test Canvas',
-          markdown: 'test.md'
-        }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const connectivityViolations = result.violations.filter(v => v.ruleId === 'workflow-event-connectivity');
-      // Should pass because events are connected through intermediate nodes
-      expect(connectivityViolations).toHaveLength(0);
-    });
-  });
-
-  // ============================================================================
-  // Subset Validation Tests
-  // ============================================================================
-
-  describe('checkScenarioSubsets', () => {
-    it('should pass when scenarios have mutually exclusive event sets', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'success',
-            priority: 1,
-            description: 'Success scenario',
-            template: {
-              events: {
-                'payment.authorized': 'Payment authorized',
-                'order.confirmed': 'Order confirmed'
-              }
-            }
-          },
-          {
-            id: 'failure',
-            priority: 2,
-            description: 'Failure scenario',
-            template: {
-              events: {
-                'payment.declined': 'Payment declined',
-                'error.logged': 'Error logged'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-      expect(subsetViolations).toHaveLength(0);
-    });
-
-    it('should pass when scenarios have overlapping but not subset event sets', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'google-oauth',
-            priority: 1,
-            description: 'Google OAuth',
-            template: {
-              events: {
-                'oauth.google': 'Google auth',
-                'oauth.complete': 'OAuth complete',
-                'user.created': 'User created'
-              }
-            }
-          },
-          {
-            id: 'email-password',
-            priority: 2,
-            description: 'Email/password signup',
-            template: {
-              events: {
-                'email.verified': 'Email verified',
-                'password.set': 'Password set',
-                'user.created': 'User created'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-      expect(subsetViolations).toHaveLength(0);
-    });
-
-    it('should error when one scenario is a strict subset of another', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'basic-checkout',
-            priority: 1,
-            description: 'Basic checkout',
-            template: {
-              events: {
-                'cart.viewed': 'Cart viewed',
-                'checkout.started': 'Checkout started'
-              }
-            }
-          },
-          {
-            id: 'complete-checkout',
-            priority: 2,
-            description: 'Complete checkout',
-            template: {
-              events: {
-                'cart.viewed': 'Cart viewed',
-                'checkout.started': 'Checkout started',
-                'payment.complete': 'Payment complete'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-
-      expect(subsetViolations).toHaveLength(1);
-      expect(subsetViolations[0].severity).toBe('error');
-      expect(subsetViolations[0].message).toContain('basic-checkout');
-      expect(subsetViolations[0].message).toContain('strict subset');
-      expect(subsetViolations[0].message).toContain('complete-checkout');
-      expect(subsetViolations[0].impact).toContain('ambiguous');
-      expect(subsetViolations[0].suggestion).toContain('Merge into one scenario');
-      expect(subsetViolations[0].suggestion).toContain('mutually exclusive');
-    });
-
-    it('should detect reverse subset relationship', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'complete-flow',
-            priority: 1,
-            description: 'Complete flow',
-            template: {
-              events: {
-                'step.one': 'Step 1',
-                'step.two': 'Step 2',
-                'step.three': 'Step 3'
-              }
-            }
-          },
-          {
-            id: 'partial-flow',
-            priority: 2,
-            description: 'Partial flow',
-            template: {
-              events: {
-                'step.one': 'Step 1',
-                'step.two': 'Step 2'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-
-      expect(subsetViolations).toHaveLength(1);
-      expect(subsetViolations[0].message).toContain('partial-flow');
-      expect(subsetViolations[0].message).toContain('strict subset');
-      expect(subsetViolations[0].message).toContain('complete-flow');
-    });
-
-    it('should pass when scenarios have same number of events but different events', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'scenario-a',
-            priority: 1,
-            description: 'Scenario A',
-            template: {
-              events: {
-                'event.a': 'Event A',
-                'event.b': 'Event B'
-              }
-            }
-          },
-          {
-            id: 'scenario-b',
-            priority: 2,
-            description: 'Scenario B',
-            template: {
-              events: {
-                'event.c': 'Event C',
-                'event.d': 'Event D'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-      expect(subsetViolations).toHaveLength(0);
-    });
-
-    it('should pass when workflow has only one scenario', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'only-scenario',
-            priority: 1,
-            description: 'Only scenario',
-            template: {
-              events: {
-                'event.one': 'Event 1'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-      expect(subsetViolations).toHaveLength(0);
-    });
-
-    it('should handle scenarios with empty event sets', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'empty-events',
-            priority: 1,
-            description: 'Empty events',
-            template: {
-              introduction: 'Test',
-              events: {}
-            }
-          },
-          {
-            id: 'with-events',
-            priority: 2,
-            description: 'With events',
-            template: {
-              events: {
-                'event.one': 'Event 1'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-
-      // Empty set is a strict subset of any non-empty set
-      expect(subsetViolations).toHaveLength(1);
-      expect(subsetViolations[0].message).toContain('empty-events');
-      expect(subsetViolations[0].message).toContain('strict subset');
-    });
-
-    it('should detect multiple subset violations in a workflow', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'minimal',
-            priority: 1,
-            description: 'Minimal',
-            template: {
-              events: {
-                'event.a': 'A'
-              }
-            }
-          },
-          {
-            id: 'medium',
-            priority: 2,
-            description: 'Medium',
-            template: {
-              events: {
-                'event.a': 'A',
-                'event.b': 'B'
-              }
-            }
-          },
-          {
-            id: 'complete',
-            priority: 3,
-            description: 'Complete',
-            template: {
-              events: {
-                'event.a': 'A',
-                'event.b': 'B',
-                'event.c': 'C'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-
-      // Should detect:
-      // 1. minimal ⊂ medium
-      // 2. minimal ⊂ complete
-      // 3. medium ⊂ complete
-      expect(subsetViolations.length).toBeGreaterThanOrEqual(3);
-    });
-
-    it('should provide helpful fix suggestions in error messages', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarioSelection: 'first-match',
-        scenarios: [
-          {
-            id: 'abandoned',
-            priority: 1,
-            description: 'Abandoned cart',
-            template: {
-              events: {
-                'cart.created': 'Cart created',
-                'items.added': 'Items added'
-              }
-            }
-          },
-          {
-            id: 'completed',
-            priority: 2,
-            description: 'Completed purchase',
-            template: {
-              events: {
-                'cart.created': 'Cart created',
-                'items.added': 'Items added',
-                'checkout.complete': 'Checkout complete'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-
-      expect(subsetViolations).toHaveLength(1);
-
-      const violation = subsetViolations[0];
-      expect(violation.suggestion).toContain('cart.created');
-      expect(violation.suggestion).toContain('items.added');
-      expect(violation.suggestion).toContain('checkout.complete');
-      expect(violation.suggestion).toContain('Merge into one scenario');
-      expect(violation.suggestion).toContain('template conditionals');
-      expect(violation.suggestion).toContain('mutually exclusive');
-      expect(violation.suggestion).toContain('distinguishing events');
-    });
-
-    it('should error when two scenarios have identical event sets', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        spanPattern: 'test.*',
-        scenarios: [
-          {
-            id: 'scenario-a',
-            priority: 1,
-            description: 'First scenario',
-            template: {
-              summary: 'Test A',
-              events: {
-                'event.start': 'Started',
-                'event.complete': 'Completed'
-              }
-            }
-          },
-          {
-            id: 'scenario-b',
-            priority: 2,
-            description: 'Second scenario with same events',
-            template: {
-              summary: 'Test B',
-              events: {
-                'event.start': 'Started',
-                'event.complete': 'Completed'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const identicalViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-identical');
-
-      expect(identicalViolations).toHaveLength(1);
-      expect(identicalViolations[0].severity).toBe('error');
-      expect(identicalViolations[0].message).toContain('scenario-a');
-      expect(identicalViolations[0].message).toContain('scenario-b');
-      expect(identicalViolations[0].message).toContain('identical event sets');
-      expect(identicalViolations[0].impact).toContain('arbitrary');
-      expect(identicalViolations[0].suggestion).toContain('Merge into a single scenario');
-    });
-
-    it('should pass when scenarios have same size but different events', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        spanPattern: 'test.*',
-        scenarios: [
-          {
-            id: 'oauth-flow',
-            priority: 1,
-            description: 'OAuth login',
-            template: {
-              summary: 'OAuth',
-              events: {
-                'oauth.start': 'Started',
-                'oauth.complete': 'Completed'
-              }
-            }
-          },
-          {
-            id: 'password-flow',
-            priority: 2,
-            description: 'Password login',
-            template: {
-              summary: 'Password',
-              events: {
-                'password.start': 'Started',
-                'password.complete': 'Completed'
-              }
-            }
-          }
-        ]
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const identicalViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-identical');
-      const subsetViolations = result.violations.filter(v => v.ruleId === 'workflow-scenario-subset');
-
-      expect(identicalViolations).toHaveLength(0);
-      expect(subsetViolations).toHaveLength(0);
-    });
-  });
-
-  // ============================================================================
-  // Span Pattern Validation Tests
-  // ============================================================================
-
-  describe('validateSpanPatterns (CLI-level validation)', () => {
-    it('should pass when all workflows have unique spanPatterns', () => {
-      const workflows = [
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Payment Workflow',
-            description: 'Payment processing',
-            spanPattern: 'payment.authorize',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'workflows/payment.workflow.json',
-        },
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Inventory Workflow',
-            description: 'Inventory management',
-            spanPattern: 'inventory.reserve',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'workflows/inventory.workflow.json',
-        },
-      ];
-
-      const violations = WorkflowValidator.validateSpanPatterns(workflows);
-      expect(violations).toHaveLength(0);
-    });
-
-    it('should error when workflows have duplicate spanPatterns', () => {
-      const workflows = [
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test1.otel.canvas',
-            name: 'Payment Workflow 1',
-            description: 'Payment processing',
-            spanPattern: 'payment.authorize',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'workflows/payment1.workflow.json',
-        },
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test2.otel.canvas',
-            name: 'Payment Workflow 2',
-            description: 'Payment processing alternative',
-            spanPattern: 'payment.authorize',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'workflows/payment2.workflow.json',
-        },
-      ];
-
-      const violations = WorkflowValidator.validateSpanPatterns(workflows);
-
-      expect(violations).toHaveLength(2); // One for each workflow
-      expect(violations[0].ruleId).toBe('workflow-span-pattern-duplicate');
-      expect(violations[0].severity).toBe('error');
-      expect(violations[0].message).toContain('payment.authorize');
-      expect(violations[0].message).toContain('Duplicate spanPattern');
-      expect(violations[0].suggestion).toContain('payment2.workflow.json');
-    });
-
-    it('should detect multiple duplicates across many workflows', () => {
-      const workflows = [
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Workflow A1',
-            description: 'Test',
-            spanPattern: 'span.a',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'a1.workflow.json',
-        },
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Workflow A2',
-            description: 'Test',
-            spanPattern: 'span.a',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'a2.workflow.json',
-        },
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Workflow B',
-            description: 'Test',
-            spanPattern: 'span.b',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'b.workflow.json',
-        },
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Workflow C1',
-            description: 'Test',
-            spanPattern: 'span.c',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'c1.workflow.json',
-        },
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Workflow C2',
-            description: 'Test',
-            spanPattern: 'span.c',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'c2.workflow.json',
-        },
-      ];
-
-      const violations = WorkflowValidator.validateSpanPatterns(workflows);
-
-      // Should have violations for: a1, a2, c1, c2 (4 workflows with duplicates)
-      expect(violations.length).toBe(4);
-
-      // Check that span.b has no violations
-      const spanBViolations = violations.filter(v => v.file === 'b.workflow.json');
-      expect(spanBViolations).toHaveLength(0);
-    });
-
-    it('should handle workflows without spanPattern gracefully', () => {
-      const workflows = [
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Valid Workflow',
-            description: 'Test',
-            spanPattern: 'payment.authorize',
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          },
-          workflowPath: 'valid.workflow.json',
-        },
-        {
-          workflow: {
-            version: '1.0.0',
-            canvas: 'test.otel.canvas',
-            name: 'Invalid Workflow',
-            description: 'Test',
-            // spanPattern missing - will be caught by individual validation
-            scenarioSelection: 'first-match' as const,
-            scenarios: [],
-          } as Partial<WorkflowTemplate> as WorkflowTemplate,
-          workflowPath: 'invalid.workflow.json',
-        },
-      ];
-
-      const violations = WorkflowValidator.validateSpanPatterns(workflows);
-
-      // Should not error - just skip the workflow without spanPattern
-      expect(violations).toHaveLength(0);
-    });
-  });
-
-  // ============================================================================
-  // Span Pattern Schema Validation Tests
-  // ============================================================================
-
-  describe('checkSchema - spanPattern', () => {
-    it('should error when spanPattern is missing', async () => {
-      const context = createContext({ spanPattern: undefined });
-      const result = await validator.validate(context);
-
-      const spanPatternViolations = result.violations.filter(
-        v => v.ruleId === 'workflow-schema-valid' && v.path === 'spanPattern'
-      );
-
-      expect(spanPatternViolations).toHaveLength(1);
-      expect(spanPatternViolations[0].message).toContain('Missing required field "spanPattern"');
-      expect(spanPatternViolations[0].suggestion).toContain('exact span name');
-    });
-
-    it('should error when spanPattern is empty string', async () => {
-      const context = createContext({ spanPattern: '' });
-      const result = await validator.validate(context);
-
-      const spanPatternViolations = result.violations.filter(
-        v => v.ruleId === 'workflow-schema-valid' && v.path === 'spanPattern'
-      );
-
-      expect(spanPatternViolations).toHaveLength(1);
-      expect(spanPatternViolations[0].message).toContain('Missing required field');
-    });
-
-    it('should pass when spanPattern is a valid string', async () => {
-      const canvasPath = join(tempDir, 'test.otel.canvas');
-      writeFileSync(canvasPath, JSON.stringify(createValidCanvas()));
-
-      const context = createContext({ spanPattern: 'payment.authorize' }, { canvasPath });
-      const result = await validator.validate(context);
-
-      const spanPatternViolations = result.violations.filter(
-        v => v.ruleId === 'workflow-schema-valid' && v.path === 'spanPattern'
-      );
-
-      expect(spanPatternViolations).toHaveLength(0);
-    });
-
-    it('should allow parentheses in spanPattern (Next.js style span names)', async () => {
-      const canvasPath = join(tempDir, 'test.otel.canvas');
-      writeFileSync(canvasPath, JSON.stringify(createValidCanvas()));
-
-      // Next.js creates span names like "executing api route (app) /api/auth/me/route"
-      const context = createContext({
-        spanPattern: 'executing api route (app) /api/auth/me/route'
-      }, { canvasPath });
-      const result = await validator.validate(context);
-
-      const spanPatternViolations = result.violations.filter(
-        v => v.ruleId === 'workflow-span-pattern-exact' && v.path === 'spanPattern'
-      );
-
-      expect(spanPatternViolations).toHaveLength(0);
-    });
-
-    it('should error when spanPattern contains wildcard *', async () => {
-      const context = createContext({ spanPattern: 'payment.*' });
-      const result = await validator.validate(context);
-
-      const spanPatternViolations = result.violations.filter(
-        v => v.ruleId === 'workflow-span-pattern-exact' && v.path === 'spanPattern'
-      );
-
-      expect(spanPatternViolations).toHaveLength(1);
-      expect(spanPatternViolations[0].message).toContain('wildcard');
-    });
-
-    it('should error when spanPattern contains regex special characters', async () => {
-      const regexPatterns = [
-        'payment[type]',      // square brackets
-        'payment{1,2}',       // curly braces (quantifier)
-        'payment^start',      // caret
-        'payment$end',        // dollar
-        'payment|refund',     // pipe (alternation)
-        'payment\\d+',        // backslash
-        'payment+',           // plus
-        'payment?',           // question mark
-      ];
-
-      for (const pattern of regexPatterns) {
-        const context = createContext({ spanPattern: pattern });
-        const result = await validator.validate(context);
-
-        const spanPatternViolations = result.violations.filter(
-          v => v.ruleId === 'workflow-span-pattern-exact' && v.path === 'spanPattern'
-        );
-
-        expect(spanPatternViolations).toHaveLength(1);
-        expect(spanPatternViolations[0].message).toContain('regex special characters');
-      }
-    });
-  });
-
-  // ============================================================================
-  // Event Attribute Requirements
-  // ============================================================================
-
-  describe('Event Attribute Requirements', () => {
-    it('should error when attribute is not used in any template', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'order.completed': 'Order {{orderId}} completed' // total is not used
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'order.completed',
-              description: 'Order completion event',
-              attributes: {
-                orderId: { type: 'string' },
-                total: { type: 'number' } // not used in template
-              }
-            }
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-attribute-unused');
-
-      expect(violations).toHaveLength(1);
-      expect(violations[0].message).toContain('order.completed');
-      expect(violations[0].message).toContain('total');
-      expect(violations[0].message).toContain('not used in any template');
-    });
-
-    it('should pass when all attributes are used', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'order.completed': 'Order {{orderId}} for {{total}}'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'order.completed',
-              description: 'Order completion event',
-              attributes: {
-                orderId: { type: 'string' },
-                total: { type: 'number' }
-              }
-            }
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-attribute-unused');
-
-      expect(violations).toHaveLength(0);
-    });
-
-    it('should consider nested property access as using the parent attribute', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'config.loaded': 'Loaded {{config.timeout}} ms timeout'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'config.loaded',
-              description: 'Configuration loaded',
-              attributes: {
-                config: { type: 'object' } // used via nested path {{config.timeout}}
-              }
-            }
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-attribute-unused');
-
-      expect(violations).toHaveLength(0);
-    });
-
-    it('should check library event schemas via eventRef', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'user.signup': 'User {{email}} signed up' // name is not used
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            eventRef: 'user.signup'
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const library: ComponentLibrary = {
-        version: '1.0.0',
-        eventSchemas: {
-          'user.signup': {
-            description: 'User signup event',
-            attributes: {
-              email: { type: 'string' },
-              name: { type: 'string' } // not used in template
-            }
-          }
-        }
-      };
-
-      const canvases = new Map<string, ExtendedCanvas>();
-      canvases.set('test.otel.canvas', canvas);
-      const eventRegistry = EventRegistry.build(library, canvases, 'library.yaml');
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir,
-        eventRegistry
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-attribute-unused');
-
-      expect(violations).toHaveLength(1);
-      expect(violations[0].message).toContain('user.signup');
-      expect(violations[0].message).toContain('name');
-    });
-
-    it('should not validate attributes for events not included in workflow (disconnected subgraph support)', async () => {
-      // This test verifies the fix for Issue 3: Conflicting Validation Rules for Shared Canvases with Disconnected Subgraphs
-      // A canvas may have multiple disconnected flows, and workflows may focus on only one flow.
-      // We should NOT report "attribute not used" errors for events that aren't even part of the workflow.
-
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Navigation Flow',
-        description: 'Workflow focusing only on navigation events (subgraph 1)',
-        mode: 'span-tree',
-        canvas: 'multi-flow.otel.canvas',
-        scenarios: [{
-          id: 'navigation',
-          priority: 1,
-          description: 'Navigation flow',
-          template: {
-            events: {
-              // Only uses events from the navigation subgraph
-              'panel.opened': 'Panel {{panelName}} opened',
-              'panel.closed': 'Panel {{panelName}} closed'
-            }
-          }
-        }]
-      };
-
-      // Canvas with TWO disconnected subgraphs:
-      // Subgraph 1 (navigation): panel.opened -> panel.closed
-      // Subgraph 2 (tool execution): tool.started -> tool.completed
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          // Subgraph 1: Navigation (included in workflow)
-          {
-            id: 'nav1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'panel.opened',
-              description: 'Panel opened event',
-              attributes: {
-                panelName: { type: 'string' }
-              }
-            }
-          },
-          {
-            id: 'nav2',
-            type: 'otel-event',
-            x: 200,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'panel.closed',
-              description: 'Panel closed event',
-              attributes: {
-                panelName: { type: 'string' }
-              }
-            }
-          },
-          // Subgraph 2: Tool execution (NOT included in workflow)
-          {
-            id: 'tool1',
-            type: 'otel-event',
-            x: 0,
-            y: 200,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'tool.started',
-              description: 'Tool started event',
-              attributes: {
-                toolName: { type: 'string' },
-                toolArgs: { type: 'string' } // These attributes are NOT used in the workflow
-              }
-            }
-          },
-          {
-            id: 'tool2',
-            type: 'otel-event',
-            x: 200,
-            y: 200,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'tool.completed',
-              description: 'Tool completed event',
-              attributes: {
-                toolName: { type: 'string' },
-                result: { type: 'string' } // These attributes are NOT used in the workflow
-              }
-            }
-          }
-        ],
-        edges: [
-          // Subgraph 1 edges
-          { id: 'e1', fromNode: 'nav1', fromSide: 'right', toNode: 'nav2', toSide: 'left' },
-          // Subgraph 2 edges (disconnected from subgraph 1)
-          { id: 'e2', fromNode: 'tool1', fromSide: 'right', toNode: 'tool2', toSide: 'left' }
-        ],
-        pv: { version: '1.0.0', name: 'Multi-Flow Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'navigation.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const attributeViolations = result.violations.filter(v => v.ruleId === 'workflow-attribute-unused');
-      const connectivityViolations = result.violations.filter(v => v.ruleId === 'workflow-event-connectivity');
-
-      // Should NOT have any "attribute not used" errors for tool.started or tool.completed
-      // because those events are not part of this workflow
-      expect(attributeViolations).toHaveLength(0);
-
-      // Should NOT have connectivity errors because the workflow only uses connected events
-      expect(connectivityViolations).toHaveLength(0);
-    });
-  });
-
-  describe('workflow-template-attribute-not-in-schema', () => {
-    it('should error when template references attribute not in event schema', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              // Template references context.projectRoot which is NOT in the schema
-              'task.delete.error': 'Task {{input.taskId}} not found in {{context.projectRoot}}'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'task.delete.error',
-              description: 'Task deletion error',
-              attributes: {
-                'error.type': { type: 'string' },
-                'error.message': { type: 'string' },
-                'input.taskId': { type: 'string' }
-                // Note: context.projectRoot is NOT defined here
-              }
-            }
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-template-attribute-not-in-schema');
-
-      expect(violations).toHaveLength(1);
-      expect(violations[0].message).toContain('context.projectRoot');
-      expect(violations[0].message).toContain('not defined in the event schema');
-      expect(violations[0].message).toContain('task.delete.error');
-    });
-
-    it('should pass when all template attributes are in event schema', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'task.create.complete': 'Created task {{output.taskId}} in {{duration.ms}}ms'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'task.create.complete',
-              description: 'Task creation complete',
-              attributes: {
-                'output.taskId': { type: 'string' },
-                'duration.ms': { type: 'number' }
-              }
-            }
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-template-attribute-not-in-schema');
-
-      expect(violations).toHaveLength(0);
-    });
-
-    it('should error for multiple undefined attributes', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              'task.delete.error': 'Task {{input.taskId}} not found in {{context.projectRoot}} ({{context.taskCount}} tasks)'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'task.delete.error',
-              description: 'Task deletion error',
-              attributes: {
-                'input.taskId': { type: 'string' }
-                // context.projectRoot and context.taskCount are NOT defined
-              }
-            }
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-template-attribute-not-in-schema');
-
-      expect(violations).toHaveLength(2);
-      expect(violations.some(v => v.message.includes('context.projectRoot'))).toBe(true);
-      expect(violations.some(v => v.message.includes('context.taskCount'))).toBe(true);
-    });
-
-    it('should handle nested attribute access when parent is defined', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              // Accessing nested path input.taskId when input.taskId is defined
-              'task.update.started': 'Updating task {{input.taskId}}'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'task.update.started',
-              description: 'Task update started',
-              attributes: {
-                'input.taskId': { type: 'string' },
-                'input.hasTitle': { type: 'boolean' }
-              }
-            }
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-template-attribute-not-in-schema');
-
-      expect(violations).toHaveLength(0);
-    });
-
-    it('should suggest similar attributes when typo detected', async () => {
-      const workflow: WorkflowTemplate = {
-        version: '1.0.0',
-        name: 'Test',
-        description: 'Test workflow',
-        mode: 'span-tree',
-        canvas: 'test.otel.canvas',
-        scenarios: [{
-          id: 'test',
-          priority: 1,
-          description: 'Test scenario',
-          template: {
-            events: {
-              // Typo: input.takId instead of input.taskId
-              'task.delete.started': 'Deleting task {{input.takId}}'
-            }
-          }
-        }]
-      };
-
-      const canvas: ExtendedCanvas = {
-        nodes: [
-          {
-            id: 'n1',
-            type: 'otel-event',
-            x: 0,
-            y: 0,
-            width: 100,
-            height: 50,
-            event: {
-              name: 'task.delete.started',
-              description: 'Task deletion started',
-              attributes: {
-                'input.taskId': { type: 'string' }
-              }
-            }
-          }
-        ],
-        edges: [],
-        pv: { version: '1.0.0', name: 'Test Canvas', markdown: 'test.md' }
-      };
-
-      const context: WorkflowValidationContext = {
-        workflow,
-        workflowPath: 'test.workflow.json',
-        canvas,
-        basePath: tempDir
-      };
-
-      const result = await validator.validate(context);
-      const violations = result.violations.filter(v => v.ruleId === 'workflow-template-attribute-not-in-schema');
-
-      expect(violations).toHaveLength(1);
-      expect(violations[0].message).toContain('input.takId');
-      // Should suggest the similar attribute
-      expect(violations[0].suggestion).toContain('input.taskId');
-    });
-  });
-});