teamspec 3.2.0 → 4.0.0

package/lib/linter.js

@@ -1,1184 +1,931 @@
 /**
  * TeamSpec Linter
- * Enforces TeamSpec Feature Canon operating model rules
  * 
- * Rule Categories:
- * - TS-PROJ: Project structure and registration
- * - TS-FEAT: Feature Canon integrity
- * - TS-STORY: Story format and delta compliance
- * - TS-ADR: Architecture decisions
- * - TS-DEVPLAN: Development planning
- * - TS-DOD: Definition of Done gates
- * - TS-NAMING: Naming conventions (from PROJECT_STRUCTURE.yml)
+ * Validates project artifacts against TeamSpec 4.0 rules.
+ * Rules are defined in spec/4.0/lint-rules.md and registry.yml
+ * 
+ * Version: 4.0
  */
 
 const fs = require('fs');
 const path = require('path');
+const { loadRegistry, loadFolderStructure, getArtifactPatterns, getArtifactNamingRegex } = require('./structure-loader');
 
 // =============================================================================
-// Severity Levels
+// SEVERITY LEVELS
 // =============================================================================
 
 const SEVERITY = {
-  ERROR: 'error',
-  BLOCKER: 'blocker',
-  WARNING: 'warning',
-  INFO: 'info',
+    BLOCKER: 'blocker',
+    ERROR: 'error',
+    WARNING: 'warning',
+    INFO: 'info'
 };
 
 // =============================================================================
-// Naming Patterns (from PROJECT_STRUCTURE.yml)
+// LINT RESULT
 // =============================================================================
 
-const NAMING_PATTERNS = {
-  feature: /^F-\d{3,}-[a-z][a-z0-9-]*\.md$/,
-  story: /^S-\d{3,}-[a-z][a-z0-9-]*\.md$/,
-  adr: /^ADR-\d{3,}-[a-z][a-z0-9-]*\.md$/,
-  decision: /^DECISION-\d{3,}-[a-z][a-z0-9-]*\.md$/,
-  epic: /^EPIC-\d{3,}-[a-z][a-z0-9-]*\.md$/,
-  devPlan: /^story-\d{3,}-tasks\.md$/,
-  sprint: /^sprint-\d+$/,
-};
+class LintResult {
+    constructor() {
+        this.errors = [];
+        this.warnings = [];
+        this.info = [];
+    }
+
+    add(rule, message, file, severity = SEVERITY.ERROR) {
+        const result = { rule, message, file, severity };
+
+        switch (severity) {
+            case SEVERITY.BLOCKER:
+            case SEVERITY.ERROR:
+                this.errors.push(result);
+                break;
+            case SEVERITY.WARNING:
+                this.warnings.push(result);
+                break;
+            case SEVERITY.INFO:
+                this.info.push(result);
+                break;
+        }
+    }
+
+    hasErrors() {
+        return this.errors.length > 0;
+    }
+
+    hasBlockers() {
+        return this.errors.some(e => e.severity === SEVERITY.BLOCKER);
+    }
+
+    getAll() {
+        return [...this.errors, ...this.warnings, ...this.info];
+    }
+
+    getSummary() {
+        return {
+            errors: this.errors.length,
+            warnings: this.warnings.length,
+            info: this.info.length,
+            total: this.getAll().length,
+            passed: !this.hasErrors()
+        };
+    }
+}
 
 // =============================================================================
-// Required Sections
+// YAML PARSER (Simple)
 // =============================================================================
 
-const FEATURE_REQUIRED_SECTIONS = [
-  'Purpose',
-  'Scope|In Scope',
-  'Actors|Personas|Users',
-  'Main Flow|Current Behavior|Behavior',
-  'Business Rules|Rules',
-  'Edge Cases|Exceptions|Error Handling',
-  'Non-Goals|Out of Scope',
-  'Change Log|Story Ledger|Changelog',
-];
-
-const STORY_FORBIDDEN_HEADINGS = [
-  'Full Specification',
-  'Complete Requirements',
-  'End-to-End Behavior',
-  'Full Flow',
-];
-
-const PLACEHOLDER_PATTERNS = [
-  /\{TBD\}/i,
-  /\bTBD\b/,
-  /\?\?\?/,
-  /lorem ipsum/i,
-  /to be defined/i,
-  /\bplaceholder\b/i,
-];
+function parseYamlSimple(content) {
+    const result = {};
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+        if (!line.trim() || line.trim().startsWith('#')) continue;
+
+        const match = line.match(/^\s*(\w+[\w.-]*):\s*(.*)$/);
+        if (match) {
+            let [, key, value] = match;
+            value = value.trim().replace(/^["']|["']$/g, '');
+
+            // Handle nested keys
+            if (key.includes('.')) {
+                const parts = key.split('.');
+                let obj = result;
+                for (let i = 0; i < parts.length - 1; i++) {
+                    if (!obj[parts[i]]) obj[parts[i]] = {};
+                    obj = obj[parts[i]];
+                }
+                obj[parts[parts.length - 1]] = value;
+            } else {
+                result[key] = value;
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Parse YAML frontmatter from markdown files
+ */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return {};
+    return parseYamlSimple(match[1]);
+}
+
+/**
+ * Parse product.yml or project.yml
+ */
+function parseConfigYaml(filePath) {
+    if (!fs.existsSync(filePath)) return null;
+
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const result = {};
+        const lines = content.split('\n');
+        let currentSection = null;
+        let inArray = false;
+        let arrayKey = null;
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) continue;
+
+            // Handle array items
+            if (trimmed.startsWith('- ')) {
+                if (arrayKey && result[arrayKey]) {
+                    result[arrayKey].push(trimmed.slice(2).trim());
+                }
+                continue;
+            }
+
+            const colonIdx = trimmed.indexOf(':');
+            if (colonIdx === -1) continue;
+
+            const key = trimmed.slice(0, colonIdx).trim();
+            let value = trimmed.slice(colonIdx + 1).trim();
+
+            // Handle section headers (product:, project:)
+            if (value === '' || value === '|') {
+                currentSection = key;
+                continue;
+            }
+
+            // Handle arrays
+            if (value === '[]') {
+                result[key] = [];
+                arrayKey = key;
+                continue;
+            }
+
+            // Clean quoted values
+            value = value.replace(/^["']|["']$/g, '');
+
+            result[key] = value;
+        }
+
+        return result;
+    } catch (err) {
+        return null;
+    }
+}
+
+// =============================================================================
+// NAMING PATTERN VALIDATION
+// =============================================================================
+
+// Cache for naming patterns loaded from registry
+let _namingPatterns = null;
+let _registry = null;
+
+// Fallback hardcoded patterns (used when registry unavailable)
+const FALLBACK_PATTERNS = {
+    'feature': /^f-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'business-analysis': /^ba-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'solution-design': /^sd-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'technical-architecture': /^ta-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'product-decision': /^dec-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'product-regression-test': /^rt-f-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'feature-increment': /^fi-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'epic': /^epic-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'story': /^s-e\d{3}-\d{3}-[\w-]+\.md$/,
+    'dev-plan': /^dp-e\d{3}-s\d{3}-[\w-]+\.md$/,
+    'project-test-case': /^tc-fi-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'ba-increment': /^bai-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'sd-increment': /^sdi-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'ta-increment': /^tai-[A-Z]{3,4}-\d{3}-[\w-]+\.md$/,
+    'bug-report': /^bug-[\w-]+-\d{3}-[\w-]+\.md$/,
+    'regression-impact': /^ri-fi-[A-Z]{3,4}-\d{3}\.md$/
+};
+
+/**
+ * Get naming patterns from registry (cached)
+ * Falls back to hardcoded patterns if registry unavailable
+ */
+function getNamingPatterns(workspaceDir) {
+    // Return fallback patterns if no workspace
+    if (!workspaceDir) {
+        return FALLBACK_PATTERNS;
+    }
+
+    if (_namingPatterns && _registry) {
+        return _namingPatterns;
+    }
+
+    // Try to load from registry
+    try {
+        const registry = loadRegistry(workspaceDir);
+        if (registry?.artifacts) {
+            _registry = registry;
+            _namingPatterns = getArtifactNamingRegex(registry);
+
+            // Fill in any missing patterns from fallback
+            for (const key of Object.keys(FALLBACK_PATTERNS)) {
+                if (!_namingPatterns[key]) {
+                    _namingPatterns[key] = FALLBACK_PATTERNS[key];
+                }
+            }
+            return _namingPatterns;
+        }
+    } catch (err) {
+        // Fall through to fallback
+    }
+
+    // Fallback to hardcoded patterns if registry not available
+    return FALLBACK_PATTERNS;
+}
+
+/**
+ * Reset cached patterns (for testing)
+ */
+function resetNamingPatterns() {
+    _namingPatterns = null;
+    _registry = null;
+}
 
 // =============================================================================
-// Helper Functions
+// RULE IMPLEMENTATIONS
 // =============================================================================
 
 /**
- * Parse YAML-like frontmatter from markdown
+ * TS-PROD-001: Product folder must be registered
  */
-function parseYamlFrontmatter(content) {
-  const yamlMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!yamlMatch) return {};
-  
-  const yaml = {};
-  const lines = yamlMatch[1].split('\n');
-  for (const line of lines) {
-    const match = line.match(/^([^:]+):\s*(.*)$/);
-    if (match) {
-      yaml[match[1].trim()] = match[2].trim();
+function checkProductRegistered(workspaceDir, productId, result) {
+    const indexPath = path.join(workspaceDir, 'products', 'products-index.md');
+
+    if (!fs.existsSync(indexPath)) {
+        result.add('TS-PROD-001', `products-index.md does not exist`, indexPath, SEVERITY.WARNING);
+        return;
+    }
+
+    const indexContent = fs.readFileSync(indexPath, 'utf-8');
+    if (!indexContent.includes(productId)) {
+        result.add('TS-PROD-001', `Product '${productId}' is not registered in products-index.md`, indexPath, SEVERITY.ERROR);
     }
-  }
-  return yaml;
 }
 
 /**
- * Parse simple YAML file
+ * TS-PROD-002: product.yml required with PRX
  */
-function parseSimpleYaml(content) {
-  const result = {};
-  const lines = content.split('\n');
-  let currentKey = null;
-  let currentArray = null;
-  
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    
-    // Array item
-    if (trimmed.startsWith('- ')) {
-      if (currentArray) {
-        currentArray.push(trimmed.slice(2).trim());
-      }
-      continue;
+function checkProductYml(productDir, productId, result) {
+    const ymlPath = path.join(productDir, 'product.yml');
+
+    if (!fs.existsSync(ymlPath)) {
+        result.add('TS-PROD-002', `product.yml is missing for product '${productId}'`, ymlPath, SEVERITY.ERROR);
+        return null;
     }
-    
-    // Key-value pair
-    const match = trimmed.match(/^([^:]+):\s*(.*)$/);
-    if (match) {
-      const key = match[1].trim();
-      const value = match[2].trim();
-      
-      if (value === '' || value === '[]') {
-        result[key] = [];
-        currentArray = result[key];
-        currentKey = key;
-      } else {
-        result[key] = value;
-        currentArray = null;
-        currentKey = key;
-      }
+
+    const config = parseConfigYaml(ymlPath);
+    if (!config) {
+        result.add('TS-PROD-002', `product.yml could not be parsed for product '${productId}'`, ymlPath, SEVERITY.ERROR);
+        return null;
+    }
+
+    // Check required fields
+    const requiredFields = ['id', 'name', 'prefix'];
+    for (const field of requiredFields) {
+        if (!config[field]) {
+            result.add('TS-PROD-002', `product.yml is missing required field: '${field}'`, ymlPath, SEVERITY.ERROR);
+        }
     }
-  }
-  
-  return result;
+
+    // Check PRX format
+    if (config.prefix && !/^[A-Z]{3,4}$/.test(config.prefix)) {
+        result.add('TS-PROD-002', `PRX '${config.prefix}' does not match pattern [A-Z]{3,4}`, ymlPath, SEVERITY.ERROR);
+    }
+
+    return config;
 }
 
 /**
- * Extract headings from markdown
+ * TS-PROJ-001: Project folder must be registered
  */
-function extractHeadings(content) {
-  const headings = [];
-  const lines = content.split(/\r?\n/);
-  for (const line of lines) {
-    const match = line.match(/^(#{1,6})\s+(.+?)[\r\s]*$/);
-    if (match) {
-      headings.push({
-        level: match[1].length,
-        text: match[2].trim(),
-      });
+function checkProjectRegistered(workspaceDir, projectId, result) {
+    const indexPath = path.join(workspaceDir, 'projects', 'projects-index.md');
+
+    if (!fs.existsSync(indexPath)) {
+        // projects-index.md is optional
+        return;
+    }
+
+    const indexContent = fs.readFileSync(indexPath, 'utf-8');
+    if (!indexContent.includes(projectId)) {
+        result.add('TS-PROJ-001', `Project '${projectId}' is not registered in projects-index.md`, indexPath, SEVERITY.WARNING);
     }
-  }
-  return headings;
 }
 
 /**
- * Check if content contains a pattern
+ * TS-PROJ-002: project.yml required with minimum metadata
  */
-function containsPattern(content, pattern) {
-  if (typeof pattern === 'string') {
-    return content.includes(pattern);
-  }
-  return pattern.test(content);
+function checkProjectYml(projectDir, projectId, result) {
+    const ymlPath = path.join(projectDir, 'project.yml');
+
+    if (!fs.existsSync(ymlPath)) {
+        result.add('TS-PROJ-002', `project.yml is missing for project '${projectId}'`, ymlPath, SEVERITY.ERROR);
+        return null;
+    }
+
+    const config = parseConfigYaml(ymlPath);
+    if (!config) {
+        result.add('TS-PROJ-002', `project.yml could not be parsed for project '${projectId}'`, ymlPath, SEVERITY.ERROR);
+        return null;
+    }
+
+    // Check required fields
+    const requiredFields = ['id', 'name', 'status'];
+    for (const field of requiredFields) {
+        if (!config[field]) {
+            result.add('TS-PROJ-002', `project.yml is missing required field: '${field}'`, ymlPath, SEVERITY.ERROR);
+        }
+    }
+
+    return config;
 }
 
 /**
- * Extract checkboxes from markdown
+ * TS-FI-001: Feature-Increment must have AS-IS and TO-BE sections
  */
-function extractCheckboxes(content, sectionHeading = null) {
-  let searchContent = content;
-  
-  if (sectionHeading) {
-    const sectionPattern = new RegExp(`##\\s+(${sectionHeading})\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`, 'i');
-    const match = content.match(sectionPattern);
-    if (match) {
-      searchContent = match[2];
-    } else {
-      return [];
+function checkFIContent(filePath, result) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const filename = path.basename(filePath);
+
+    // Check for AS-IS section
+    if (!content.includes('## AS-IS') && !content.includes('## 2. AS-IS') && !content.includes('## Current State')) {
+        result.add('TS-FI-001', `Feature-Increment '${filename}' is missing AS-IS section`, filePath, SEVERITY.ERROR);
+    }
+
+    // Check for TO-BE section
+    if (!content.includes('## TO-BE') && !content.includes('## 3. TO-BE') && !content.includes('## Proposed State')) {
+        result.add('TS-FI-001', `Feature-Increment '${filename}' is missing TO-BE section`, filePath, SEVERITY.ERROR);
+    }
+}
+
+/**
+ * TS-FI-002: Feature-Increment must link to target Feature
+ */
+function checkFIFeatureLink(filePath, workspaceDir, result) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const filename = path.basename(filePath);
+
+    // Look for feature reference (f-PRX-NNN pattern)
+    const featureRef = content.match(/f-[A-Z]{3,4}-\d{3}/);
+
+    if (!featureRef) {
+        result.add('TS-FI-002', `Feature-Increment '${filename.replace('.md', '')}' does not reference a target feature`, filePath, SEVERITY.ERROR);
+        return;
+    }
+
+    // Verify the referenced feature exists
+    const featurePattern = new RegExp(`${featureRef[0]}[\\w-]*\\.md`);
+    const productsDir = path.join(workspaceDir, 'products');
+
+    if (fs.existsSync(productsDir)) {
+        let featureFound = false;
+        const products = fs.readdirSync(productsDir, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+
+        for (const prod of products) {
+            const featuresDir = path.join(productsDir, prod, 'features');
+            if (fs.existsSync(featuresDir)) {
+                const features = fs.readdirSync(featuresDir);
+                if (features.some(f => featurePattern.test(f))) {
+                    featureFound = true;
+                    break;
+                }
+            }
+        }
+
+        if (!featureFound) {
+            result.add('TS-FI-002', `Feature '${featureRef[0]}' referenced by FI does not exist`, filePath, SEVERITY.WARNING);
+        }
+    }
+}
+
+/**
+ * TS-EPIC-001: Epic file naming convention
+ */
+function checkEpicNaming(filePath, result, workspaceDir = null) {
+    const filename = path.basename(filePath);
+    const patterns = getNamingPatterns(workspaceDir);
+    const pattern = patterns.epic || patterns['epic'];
+
+    if (pattern && !pattern.test(filename)) {
+        result.add('TS-EPIC-001', `Epic file '${filename}' does not match naming convention: epic-PRX-XXX-description.md`, filePath, SEVERITY.ERROR);
+    }
+}
+
+/**
+ * TS-STORY-001: Story must link to Epic via filename
+ */
+function checkStoryEpicLink(filePath, projectDir, result, workspaceDir = null) {
+    const filename = path.basename(filePath);
+    const patterns = getNamingPatterns(workspaceDir);
+    const pattern = patterns.story || patterns['story'];
+
+    // Check naming pattern
+    if (pattern && !pattern.test(filename)) {
+        result.add('TS-STORY-001', `Story '${filename}' does not match naming convention: s-eXXX-YYY-description.md`, filePath, SEVERITY.ERROR);
+        return;
+    }
+
+    // Extract epic number
+    const epicMatch = filename.match(/s-e(\d{3})-/);
+    if (epicMatch) {
+        const epicNum = epicMatch[1];
+        const epicsDir = path.join(projectDir, 'epics');
+
+        if (fs.existsSync(epicsDir)) {
+            const epics = fs.readdirSync(epicsDir);
+            const epicExists = epics.some(e => e.includes(`-${epicNum}-`) || e.includes(`-${parseInt(epicNum)}-`));
+
+            if (!epicExists) {
+                result.add('TS-STORY-001', `Story '${filename}' references non-existent epic ${epicNum}`, filePath, SEVERITY.ERROR);
+            }
+        }
+    }
+}
+
+/**
+ * TS-STORY-002: Story describes delta, not full behavior
+ */
+function checkStoryDelta(filePath, result) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const filename = path.basename(filePath);
+
+    // Look for delta language
+    const deltaTerms = ['adds', 'changes', 'removes', 'modifies', 'updates', 'introduces', 'replaces'];
+    const hasDeltaLanguage = deltaTerms.some(term =>
+        content.toLowerCase().includes(term)
+    );
+
+    // Look for Feature-Increment reference
+    const hasFIRef = /fi-[A-Z]{3,4}-\d{3}/.test(content);
+
+    if (!hasDeltaLanguage && !hasFIRef) {
+        result.add('TS-STORY-002', `Story '${filename.replace('.md', '')}' appears to describe full behavior instead of delta`, filePath, SEVERITY.WARNING);
     }
-  }
-  
-  const checkboxes = [];
-  const regex = /- \[([ xX])\]\s*(.+)/g;
-  let match;
-  
-  while ((match = regex.exec(searchContent)) !== null) {
-    checkboxes.push({
-      checked: match[1].toLowerCase() === 'x',
-      text: match[2].trim(),
-    });
-  }
-  
-  return checkboxes;
 }
 
 /**
- * Extract feature ID from story content
+ * TS-NAMING-*: Artifact naming conventions
  */
-function extractFeatureLinks(content) {
-  const links = [];
-  const patterns = [
-    /\[F-(\d{3,})/g,
-    /F-(\d{3,})/g,
-  ];
-  
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      links.push(`F-${match[1]}`);
+function checkArtifactNaming(filePath, artifactType, result, workspaceDir = null) {
+    const filename = path.basename(filePath);
+    const patterns = getNamingPatterns(workspaceDir);
+    const pattern = patterns[artifactType];
+
+    if (pattern && !pattern.test(filename)) {
+        const ruleId = `TS-NAMING-${artifactType.toUpperCase().replace(/-/g, '')}`;
+        result.add(ruleId, `File '${filename}' does not match naming convention for ${artifactType}`, filePath, SEVERITY.ERROR);
     }
-  }
-  
-  return [...new Set(links)];
 }
 
 /**
- * Extract story ID from filename or content
+ * TS-DOD-001: Story must have all AC verified
  */
-function extractStoryId(filename, content) {
-  // Try filename first
-  const filenameMatch = filename.match(/S-(\d{3,})/);
-  if (filenameMatch) return filenameMatch[1];
-  
-  // Try content
-  const contentMatch = content.match(/# Story: S-(\d{3,})/);
-  if (contentMatch) return contentMatch[1];
-  
-  return null;
+function checkDoneStoryAC(filePath, result) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const filename = path.basename(filePath);
+
+    // Check for unverified AC (unchecked checkboxes)
+    const hasUnverifiedAC = /- \[ \]/.test(content);
+
+    if (hasUnverifiedAC) {
+        result.add('TS-DOD-001', `Story '${filename.replace('.md', '')}' has unverified acceptance criteria`, filePath, SEVERITY.ERROR);
+    }
 }
 
 /**
- * Get metadata from markdown (bold fields like **Status:** value)
+ * TS-DOD-003: Product sync after deployment
  */
-function extractMetadata(content) {
-  const metadata = {};
-  const patterns = [
-    // Pattern: **Key:** Value (colon inside bold)
-    /\*\*([^*:]+):\*\*\s*(.+)/g,
-    // Pattern: **Key**: Value (colon outside bold)
-    /\*\*([^*]+)\*\*:\s*(.+)/g,
-    // Pattern: Key: Value at line start
-    /^([A-Za-z ]+):\s*(.+)/gm,
-  ];
-  
-  for (const pattern of patterns) {
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      const key = match[1].trim().replace(/:$/, '');  // Remove trailing colon if any
-      const value = match[2].trim();
-      if (!metadata[key]) {  // Don't overwrite existing keys
-        metadata[key] = value;
-      }
+function checkCanonSync(projectConfig, projectDir, result) {
+    if (projectConfig.deployed_date && !projectConfig.canon_synced) {
+        result.add('TS-DOD-003', `Project deployed but Product Canon not synced. Run ts:po sync`, path.join(projectDir, 'project.yml'), SEVERITY.BLOCKER);
     }
-  }
-  
-  return metadata;
 }
 
 /**
- * Recursively find files matching a pattern
+ * TS-QA-001: Deployed Feature-Increment must have test coverage
  */
-function findFiles(dir, pattern, results = []) {
-  if (!fs.existsSync(dir)) return results;
-  
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    
-    if (entry.isDirectory()) {
-      findFiles(fullPath, pattern, results);
-    } else if (pattern.test(entry.name)) {
-      results.push(fullPath);
+function checkFITestCoverage(fiFile, projectDir, result) {
+    const fiName = path.basename(fiFile, '.md');
+    const fiMatch = fiName.match(/^fi-([A-Z]{3,4}-\d{3})/);
+
+    if (!fiMatch) return;
+
+    const tcDir = path.join(projectDir, 'qa', 'test-cases');
+    if (!fs.existsSync(tcDir)) {
+        result.add('TS-QA-001', `No test-cases directory for FI test coverage validation`, tcDir, SEVERITY.WARNING);
+        return;
+    }
+
+    const tcFiles = fs.readdirSync(tcDir);
+    const hasTestCase = tcFiles.some(tc => tc.includes(fiMatch[1]));
+
+    if (!hasTestCase) {
+        result.add('TS-QA-001', `Deployed FI '${fiName}' has no test coverage. Expected: tc-fi-${fiMatch[1]}-*.md`, fiFile, SEVERITY.WARNING);
     }
-  }
-  
-  return results;
 }
 
 /**
- * Find all projects in workspace
+ * TS-QA-003: Regression impact must be recorded for each FI
  */
-function findProjects(workspaceDir) {
-  const projectsDir = path.join(workspaceDir, 'projects');
-  if (!fs.existsSync(projectsDir)) return [];
-  
-  const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
-  return entries
-    .filter(e => e.isDirectory() && e.name !== '.git')
-    .map(e => e.name);
+function checkRegressionImpact(fiFile, projectDir, workspaceDir, result) {
+    const fiName = path.basename(fiFile, '.md');
+    const fiMatch = fiName.match(/^fi-([A-Z]{3,4})-(\d{3})/);
+
+    if (!fiMatch) return;
+
+    const prx = fiMatch[1];
+    const num = fiMatch[2];
+    const riDir = path.join(projectDir, 'qa', 'regression-impact');
+    const riFile = path.join(riDir, `ri-fi-${prx}-${num}.md`);
+
+    if (!fs.existsSync(riFile)) {
+        result.add('TS-QA-003', `FI '${fiName}' has no regression impact record. Create ri-fi-${prx}-${num}.md`, fiFile, SEVERITY.ERROR);
+        return;
+    }
+
+    // Check ri file content
+    const riContent = fs.readFileSync(riFile, 'utf-8');
+
+    // Check for assessment field
+    const assessmentMatch = riContent.match(/assessment:\s*([\w-]+)/);
+    if (!assessmentMatch) {
+        result.add('TS-QA-003', `ri-fi-${prx}-${num}.md is missing 'assessment' field`, riFile, SEVERITY.ERROR);
+        return;
+    }
+
+    const assessment = assessmentMatch[1];
+
+    if (assessment === 'update-required') {
+        // Check for regression_tests field
+        if (!riContent.includes('regression_tests:')) {
+            result.add('TS-QA-003', `ri-fi-${prx}-${num}.md has assessment: update-required but no regression_tests listed`, riFile, SEVERITY.ERROR);
+        } else {
+            // Check that listed rt files exist
+            const rtMatches = riContent.match(/rt-f-[A-Z]{3,4}-\d{3}[\w-]*\.md/g) || [];
+            for (const rtFile of rtMatches) {
+                const rtFound = findRegressionTest(workspaceDir, prx, rtFile);
+                if (!rtFound) {
+                    result.add('TS-QA-003', `ri-fi-${prx}-${num}.md lists ${rtFile} but file does not exist`, riFile, SEVERITY.ERROR);
+                }
+            }
+        }
+    } else if (assessment === 'no-impact') {
+        // Check for rationale
+        if (!riContent.includes('rationale:') || !/rationale:\s*\S/.test(riContent)) {
+            result.add('TS-QA-003', `ri-fi-${prx}-${num}.md has assessment: no-impact but no rationale provided`, riFile, SEVERITY.ERROR);
+        }
+    }
+}
+
+/**
+ * Find a regression test file in products
+ */
+function findRegressionTest(workspaceDir, prx, rtFilename) {
+    const productsDir = path.join(workspaceDir, 'products');
+    if (!fs.existsSync(productsDir)) return false;
+
+    const products = fs.readdirSync(productsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+
+    for (const prod of products) {
+        const rtDir = path.join(productsDir, prod, 'qa', 'regression-tests');
+        if (fs.existsSync(rtDir)) {
+            const rtPath = path.join(rtDir, rtFilename);
+            if (fs.existsSync(rtPath)) return true;
+        }
+    }
+
+    return false;
 }
 
 // =============================================================================
-// Rule Definitions
+// MAIN LINTER
 // =============================================================================
 
-const rules = {
-  // -------------------------------------------------------------------------
-  // Project Rules (TS-PROJ)
-  // -------------------------------------------------------------------------
-  
-  'TS-PROJ-001': {
-    id: 'TS-PROJ-001',
-    name: 'Project folder must be registered',
-    severity: SEVERITY.ERROR,
-    owner: 'BA',
-    async check(ctx) {
-      const results = [];
-      const indexPath = path.join(ctx.workspaceDir, 'projects', 'projects-index.md');
-      
-      if (!fs.existsSync(indexPath)) {
-        // If no index exists, skip (will be caught by other rules)
-        return results;
-      }
-      
-      const indexContent = fs.readFileSync(indexPath, 'utf-8');
-      
-      for (const projectId of ctx.projects) {
-        if (!indexContent.includes(projectId)) {
-          results.push({
-            ruleId: 'TS-PROJ-001',
-            severity: SEVERITY.ERROR,
-            file: path.join(ctx.workspaceDir, 'projects', projectId),
-            message: `Project '${projectId}' is not registered in projects-index.md`,
-            owner: 'BA',
-          });
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-PROJ-002': {
-    id: 'TS-PROJ-002',
-    name: 'project.yml required with minimum metadata',
-    severity: SEVERITY.ERROR,
-    owner: 'BA',
-    requiredFields: ['project_id', 'name', 'status', 'stakeholders', 'roles'],
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const ymlPath = path.join(ctx.workspaceDir, 'projects', projectId, 'project.yml');
-        
-        if (!fs.existsSync(ymlPath)) {
-          results.push({
-            ruleId: 'TS-PROJ-002',
-            severity: SEVERITY.ERROR,
-            file: ymlPath,
-            message: `project.yml is missing for project '${projectId}'`,
-            owner: 'BA',
-          });
-          continue;
+/**
+ * Lint a TeamSpec workspace
+ * @param {string} workspaceDir - Path to workspace root
+ * @param {Object} options - Linting options
+ * @param {string} options.project - Specific project to lint
+ * @param {string} options.rule - Specific rule to check
+ * @returns {LintResult}
+ */
+function lint(workspaceDir, options = {}) {
+    const result = new LintResult();
+
+    // Load registry for patterns (if available)
+    const registry = loadRegistry(workspaceDir);
+
+    // Lint products
+    const productsDir = path.join(workspaceDir, 'products');
+    if (fs.existsSync(productsDir)) {
+        const products = fs.readdirSync(productsDir, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+
+        for (const productId of products) {
+            lintProduct(workspaceDir, productId, result, options);
         }
-        
-        const content = fs.readFileSync(ymlPath, 'utf-8');
-        const yaml = parseSimpleYaml(content);
-        
-        for (const field of this.requiredFields) {
-          if (!(field in yaml)) {
-            results.push({
-              ruleId: 'TS-PROJ-002',
-              severity: SEVERITY.ERROR,
-              file: ymlPath,
-              message: `project.yml is missing required field: '${field}'`,
-              owner: 'BA',
-            });
-          }
+    }
+
+    // Lint projects
+    const projectsDir = path.join(workspaceDir, 'projects');
+    if (fs.existsSync(projectsDir)) {
+        const projects = fs.readdirSync(projectsDir, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+
+        for (const projectId of projects) {
+            if (options.project && options.project !== projectId) continue;
+            lintProject(workspaceDir, projectId, result, options);
         }
-      }
-      
-      return results;
-    },
-  },
-  
-  // -------------------------------------------------------------------------
-  // Feature Rules (TS-FEAT)
-  // -------------------------------------------------------------------------
-  
-  'TS-FEAT-001': {
-    id: 'TS-FEAT-001',
-    name: 'Feature file required for any story link',
-    severity: SEVERITY.ERROR,
-    owner: 'BA/FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        const featuresDir = path.join(ctx.workspaceDir, 'projects', projectId, 'features');
-        const storyFiles = findFiles(storiesDir, /\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          if (path.basename(storyFile) === 'README.md') continue;
-          
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          const featureLinks = extractFeatureLinks(content);
-          
-          for (const featureId of featureLinks) {
-            const featurePattern = new RegExp(`^${featureId}-.*\\.md$`);
-            const featureFiles = fs.existsSync(featuresDir) 
-              ? fs.readdirSync(featuresDir).filter(f => featurePattern.test(f))
-              : [];
-            
-            if (featureFiles.length === 0) {
-              results.push({
-                ruleId: 'TS-FEAT-001',
-                severity: SEVERITY.ERROR,
-                file: storyFile,
-                message: `Referenced feature '${featureId}' not found in features/`,
-                owner: 'BA/FA',
-              });
+    }
+
+    return result;
+}
+
+/**
+ * Lint a product folder
+ */
+function lintProduct(workspaceDir, productId, result, options) {
+    const productDir = path.join(workspaceDir, 'products', productId);
+
+    // TS-PROD-001: Product registered
+    if (!options.rule || options.rule === 'TS-PROD-001') {
+        checkProductRegistered(workspaceDir, productId, result);
+    }
+
+    // TS-PROD-002: product.yml validation
+    if (!options.rule || options.rule === 'TS-PROD-002') {
+        const productConfig = checkProductYml(productDir, productId, result);
+
+        if (productConfig) {
+            // Lint features naming
+            const featuresDir = path.join(productDir, 'features');
+            if (fs.existsSync(featuresDir)) {
+                const features = fs.readdirSync(featuresDir)
+                    .filter(f => f.endsWith('.md') && f !== 'features-index.md' && f !== 'story-ledger.md');
+
+                for (const feature of features) {
+                    checkArtifactNaming(path.join(featuresDir, feature), 'feature', result, workspaceDir);
+                }
             }
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-FEAT-002': {
-    id: 'TS-FEAT-002',
-    name: 'Feature must include canon sections',
-    severity: SEVERITY.ERROR,
-    owner: 'BA/FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const featuresDir = path.join(ctx.workspaceDir, 'projects', projectId, 'features');
-        if (!fs.existsSync(featuresDir)) continue;
-        
-        const featureFiles = findFiles(featuresDir, /^F-\d{3,}-.*\.md$/);
-        
-        for (const featureFile of featureFiles) {
-          const content = fs.readFileSync(featureFile, 'utf-8');
-          const headings = extractHeadings(content);
-          const headingTexts = headings.map(h => h.text);
-          
-          for (const required of FEATURE_REQUIRED_SECTIONS) {
-            const patterns = required.split('|');
-            const found = patterns.some(p => 
-              headingTexts.some(h => h.toLowerCase().includes(p.toLowerCase()))
-            );
-            
-            if (!found) {
-              results.push({
-                ruleId: 'TS-FEAT-002',
-                severity: SEVERITY.ERROR,
-                file: featureFile,
-                message: `Feature is missing required section: '${required}'`,
-                owner: 'BA/FA',
-              });
+
+            // Lint regression tests naming
+            const rtDir = path.join(productDir, 'qa', 'regression-tests');
+            if (fs.existsSync(rtDir)) {
+                const rtFiles = fs.readdirSync(rtDir).filter(f => f.endsWith('.md'));
+                for (const rt of rtFiles) {
+                    checkArtifactNaming(path.join(rtDir, rt), 'product-regression-test', result, workspaceDir);
+                }
             }
-          }
         }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-FEAT-003': {
-    id: 'TS-FEAT-003',
-    name: 'Feature IDs must be unique within project',
-    severity: SEVERITY.ERROR,
-    owner: 'BA/FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const featuresDir = path.join(ctx.workspaceDir, 'projects', projectId, 'features');
-        if (!fs.existsSync(featuresDir)) continue;
-        
-        const featureFiles = findFiles(featuresDir, /^F-\d{3,}-.*\.md$/);
-        const idToFiles = new Map();
-        
-        for (const featureFile of featureFiles) {
-          const match = path.basename(featureFile).match(/^(F-\d{3,})/);
-          if (match) {
-            const id = match[1];
-            if (!idToFiles.has(id)) {
-              idToFiles.set(id, []);
+    }
+}
+
+/**
+ * Lint a project folder
+ */
+function lintProject(workspaceDir, projectId, result, options) {
+    const projectDir = path.join(workspaceDir, 'projects', projectId);
+
+    // TS-PROJ-001: Project registered
+    if (!options.rule || options.rule === 'TS-PROJ-001') {
+        checkProjectRegistered(workspaceDir, projectId, result);
+    }
+
+    // TS-PROJ-002: project.yml validation
+    let projectConfig = null;
+    if (!options.rule || options.rule === 'TS-PROJ-002') {
+        projectConfig = checkProjectYml(projectDir, projectId, result);
+    } else {
+        projectConfig = parseConfigYaml(path.join(projectDir, 'project.yml'));
+    }
+
+    // TS-DOD-003: Canon sync check
+    if (projectConfig && (!options.rule || options.rule === 'TS-DOD-003')) {
+        checkCanonSync(projectConfig, projectDir, result);
+    }
+
+    // Lint Feature-Increments
+    const fiDir = path.join(projectDir, 'feature-increments');
+    if (fs.existsSync(fiDir)) {
+        const fiFiles = fs.readdirSync(fiDir).filter(f => f.endsWith('.md') && f !== 'increments-index.md');
+
+        for (const fi of fiFiles) {
+            const fiPath = path.join(fiDir, fi);
+
+            // TS-FI-001: AS-IS/TO-BE sections
+            if (!options.rule || options.rule === 'TS-FI-001') {
+                checkFIContent(fiPath, result);
             }
-            idToFiles.get(id).push(featureFile);
-          }
-        }
-        
-        for (const [id, files] of idToFiles) {
-          if (files.length > 1) {
-            results.push({
-              ruleId: 'TS-FEAT-003',
-              severity: SEVERITY.ERROR,
-              file: files[1],
-              message: `Duplicate feature ID '${id}' found in: ${files.map(f => path.basename(f)).join(', ')}`,
-              owner: 'BA/FA',
-            });
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  // -------------------------------------------------------------------------
-  // Story Rules (TS-STORY)
-  // -------------------------------------------------------------------------
-  
-  'TS-STORY-001': {
-    id: 'TS-STORY-001',
-    name: 'Story must link to feature',
-    severity: SEVERITY.ERROR,
-    owner: 'FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        const storyFiles = findFiles(storiesDir, /^S-\d{3,}-.*\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          const featureLinks = extractFeatureLinks(content);
-          
-          // Check for Linked Features section
-          const hasLinkedSection = /##\s*(Linked Features?|Features?)/i.test(content);
-          
-          if (featureLinks.length === 0 && !hasLinkedSection) {
-            results.push({
-              ruleId: 'TS-STORY-001',
-              severity: SEVERITY.ERROR,
-              file: storyFile,
-              message: 'Story has no feature link. Stories must link to at least one feature.',
-              owner: 'FA',
-            });
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-STORY-002': {
-    id: 'TS-STORY-002',
-    name: 'Story must describe delta-only behavior',
-    severity: SEVERITY.ERROR,
-    owner: 'FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        const storyFiles = findFiles(storiesDir, /^S-\d{3,}-.*\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          
-          // Check for Before/After pattern
-          const hasBefore = /\b(Before|Current behavior).*:/i.test(content);
-          const hasAfter = /\b(After|New behavior).*:/i.test(content);
-          
-          if (!hasBefore || !hasAfter) {
-            results.push({
-              ruleId: 'TS-STORY-002',
-              severity: SEVERITY.ERROR,
-              file: storyFile,
-              message: 'Story must have Before/After sections describing delta behavior.',
-              owner: 'FA',
-            });
-          }
-          
-          // Check for forbidden full-spec headings
-          const headings = extractHeadings(content);
-          for (const heading of headings) {
-            for (const forbidden of STORY_FORBIDDEN_HEADINGS) {
-              if (heading.text.toLowerCase().includes(forbidden.toLowerCase())) {
-                results.push({
-                  ruleId: 'TS-STORY-002',
-                  severity: SEVERITY.ERROR,
-                  file: storyFile,
-                  message: `Story contains forbidden heading '${heading.text}'. Stories describe deltas, not full specifications.`,
-                  owner: 'FA',
-                });
-              }
+
+            // TS-FI-002: Feature link
+            if (!options.rule || options.rule === 'TS-FI-002') {
+                checkFIFeatureLink(fiPath, workspaceDir, result);
             }
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-STORY-003': {
-    id: 'TS-STORY-003',
-    name: 'Acceptance Criteria must be present and testable',
-    severity: SEVERITY.ERROR,
-    owner: 'FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        const storyFiles = findFiles(storiesDir, /^S-\d{3,}-.*\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          
-          // Check for AC section
-          const hasAC = /##\s*Acceptance Criteria/i.test(content);
-          
-          if (!hasAC) {
-            results.push({
-              ruleId: 'TS-STORY-003',
-              severity: SEVERITY.ERROR,
-              file: storyFile,
-              message: 'Acceptance Criteria section is missing.',
-              owner: 'FA',
-            });
-            continue;
-          }
-          
-          // Check for placeholders
-          for (const pattern of PLACEHOLDER_PATTERNS) {
-            if (pattern.test(content)) {
-              results.push({
-                ruleId: 'TS-STORY-003',
-                severity: SEVERITY.ERROR,
-                file: storyFile,
-                message: `Story contains placeholder text (${pattern.source}). All content must be complete.`,
-                owner: 'FA',
-              });
-              break;
+
+            // TS-NAMING-FI
+            if (!options.rule || options.rule === 'TS-NAMING-FI') {
+                checkArtifactNaming(fiPath, 'feature-increment', result, workspaceDir);
             }
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-STORY-004': {
-    id: 'TS-STORY-004',
-    name: 'Only SM can assign sprint',
-    severity: SEVERITY.ERROR,
-    owner: 'SM',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        const storyFiles = findFiles(storiesDir, /\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          if (path.basename(storyFile) === 'README.md') continue;
-          
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          const metadata = extractMetadata(content);
-          
-          // Check if sprint is assigned
-          if (metadata.Sprint && metadata.Sprint !== '-' && metadata.Sprint !== 'None') {
-            // Check for SM role in assignment - various patterns
-            const hasSMAssignment = /Assigned By:.*Role:\s*SM/i.test(content) ||
-                                    /Role:\s*SM.*Assigned/i.test(content) ||
-                                    /\*\*Assigned By:\*\*.*SM/i.test(content) ||
-                                    /Assigned By:.*SM\s*$/im.test(content);
-            
-            // Also fail if explicitly NOT SM
-            const hasNonSMAssignment = /\*\*Assigned By:\*\*\s*(DEV|BA|FA|ARCH|QA)\s*(\(|$)/i.test(content);
-            
-            if (!hasSMAssignment || hasNonSMAssignment) {
-              results.push({
-                ruleId: 'TS-STORY-004',
-                severity: SEVERITY.ERROR,
-                file: storyFile,
-                message: 'Sprint assignment must be done by SM role. Add "Assigned By: Role: SM".',
-                owner: 'SM',
-              });
+
+            // TS-QA-001: Test coverage (for deployed projects)
+            if (projectConfig?.status === 'deployed' || projectConfig?.deployed_date) {
+                if (!options.rule || options.rule === 'TS-QA-001') {
+                    checkFITestCoverage(fiPath, projectDir, result);
+                }
             }
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-STORY-005': {
-    id: 'TS-STORY-005',
-    name: 'Ready for Development requires DoR checklist complete',
-    severity: SEVERITY.ERROR,
-    owner: 'FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const readyDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories', 'ready-for-development');
-        if (!fs.existsSync(readyDir)) continue;
-        
-        const storyFiles = findFiles(readyDir, /\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          if (path.basename(storyFile) === 'README.md') continue;
-          
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          
-          // Stories in ready-for-development folder must have complete DoR
-          // Check for DoR section
-          const dorCheckboxes = extractCheckboxes(content, 'DoR Checklist|Definition of Ready');
-          
-          if (dorCheckboxes.length > 0) {
-            const unchecked = dorCheckboxes.filter(c => !c.checked);
-            if (unchecked.length > 0) {
-              results.push({
-                ruleId: 'TS-STORY-005',
-                severity: SEVERITY.ERROR,
-                file: storyFile,
-                message: `DoR Checklist incomplete. Unchecked items: ${unchecked.map(c => c.text).join(', ')}`,
-                owner: 'FA',
-              });
+
+            // TS-QA-003: Regression impact
+            if (projectConfig?.status === 'deployed' || projectConfig?.deployed_date) {
+                if (!options.rule || options.rule === 'TS-QA-003') {
+                    checkRegressionImpact(fiPath, projectDir, workspaceDir, result);
+                }
             }
-          }
         }
-      }
-      
-      return results;
-    },
-  },
-  
-  // -------------------------------------------------------------------------
-  // ADR Rules (TS-ADR)
-  // -------------------------------------------------------------------------
-  
-  'TS-ADR-001': {
-    id: 'TS-ADR-001',
-    name: 'Feature marked "Architecture Required" must have ADR',
-    severity: SEVERITY.ERROR,
-    owner: 'SA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        const storyFiles = findFiles(storiesDir, /\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          if (path.basename(storyFile) === 'README.md') continue;
-          
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          
-          // Check if ADR Required is checked
-          const checkboxes = extractCheckboxes(content);
-          const adrRequired = checkboxes.some(c => c.checked && /ADR Required/i.test(c.text));
-          
-          if (adrRequired) {
-            // Check for ADR reference
-            const hasAdrRef = /ADR-\d{3,}/i.test(content);
-            
-            if (!hasAdrRef) {
-              results.push({
-                ruleId: 'TS-ADR-001',
-                severity: SEVERITY.ERROR,
-                file: storyFile,
-                message: 'Story has "ADR Required" checked but no ADR reference found.',
-                owner: 'SA',
-              });
+    }
+
+    // Lint Epics
+    const epicsDir = path.join(projectDir, 'epics');
+    if (fs.existsSync(epicsDir)) {
+        const epics = fs.readdirSync(epicsDir)
+            .filter(f => f.endsWith('.md') && f !== 'epics-index.md');
+
+        for (const epic of epics) {
+            const epicPath = path.join(epicsDir, epic);
+
+            // TS-EPIC-001: Naming
+            if (!options.rule || options.rule === 'TS-EPIC-001') {
+                checkEpicNaming(epicPath, result, workspaceDir);
             }
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-ADR-002': {
-    id: 'TS-ADR-002',
-    name: 'ADR must link to feature(s)',
-    severity: SEVERITY.ERROR,
-    owner: 'SA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const adrDir = path.join(ctx.workspaceDir, 'projects', projectId, 'adr');
-        if (!fs.existsSync(adrDir)) continue;
-        
-        const adrFiles = findFiles(adrDir, /^ADR-\d{3,}-.*\.md$/);
-        
-        for (const adrFile of adrFiles) {
-          const content = fs.readFileSync(adrFile, 'utf-8');
-          
-          // Check for feature reference
-          const hasFeatureRef = /F-\d{3,}|Linked Feature|Related Feature/i.test(content);
-          
-          if (!hasFeatureRef) {
-            results.push({
-              ruleId: 'TS-ADR-002',
-              severity: SEVERITY.ERROR,
-              file: adrFile,
-              message: 'ADR must link to at least one feature.',
-              owner: 'SA',
-            });
-          }
         }
-      }
-      
-      return results;
-    },
-  },
-  
-  // -------------------------------------------------------------------------
-  // Dev Plan Rules (TS-DEVPLAN)
-  // -------------------------------------------------------------------------
-  
-  'TS-DEVPLAN-001': {
-    id: 'TS-DEVPLAN-001',
-    name: 'Story in sprint must have dev plan',
-    severity: SEVERITY.ERROR,
-    owner: 'DEV',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        const devPlansDir = path.join(ctx.workspaceDir, 'projects', projectId, 'dev-plans');
-        const storyFiles = findFiles(storiesDir, /^S-\d{3,}-.*\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          const metadata = extractMetadata(content);
-          
-          // Check if story is in sprint
-          const isInSprint = metadata.Status && /in sprint|in progress|ready for testing/i.test(metadata.Status);
-          
-          if (isInSprint) {
-            const storyId = extractStoryId(path.basename(storyFile), content);
-            
-            if (storyId) {
-              const devPlanPath = path.join(devPlansDir, `story-${storyId}-tasks.md`);
-              
-              if (!fs.existsSync(devPlanPath)) {
-                results.push({
-                  ruleId: 'TS-DEVPLAN-001',
-                  severity: SEVERITY.ERROR,
-                  file: storyFile,
-                  message: `Story is in sprint but dev plan is missing. Expected: dev-plans/story-${storyId}-tasks.md`,
-                  owner: 'DEV',
-                });
-              }
+    }
+
+    // Lint Stories
+    const storiesDir = path.join(projectDir, 'stories');
+    if (fs.existsSync(storiesDir)) {
+        const storyFolders = ['backlog', 'ready-to-refine', 'ready-to-develop', 'deferred', 'out-of-scope'];
+
+        for (const folder of storyFolders) {
+            const folderPath = path.join(storiesDir, folder);
+            if (!fs.existsSync(folderPath)) continue;
+
+            const stories = fs.readdirSync(folderPath).filter(f => f.endsWith('.md') && f !== 'README.md');
+
+            for (const story of stories) {
+                const storyPath = path.join(folderPath, story);
+
+                // TS-STORY-001: Epic link
+                if (!options.rule || options.rule === 'TS-STORY-001') {
+                    checkStoryEpicLink(storyPath, projectDir, result, workspaceDir);
+                }
+
+                // TS-STORY-002: Delta language
+                if (!options.rule || options.rule === 'TS-STORY-002') {
+                    checkStoryDelta(storyPath, result);
+                }
             }
-          }
         }
-      }
-      
-      return results;
-    },
-  },
-  
-  // -------------------------------------------------------------------------
-  // DoD Rules (TS-DOD)
-  // -------------------------------------------------------------------------
-  
-  'TS-DOD-001': {
-    id: 'TS-DOD-001',
-    name: 'Story cannot be Done if behavior changed and Canon not updated',
-    severity: SEVERITY.BLOCKER,
-    owner: 'FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        const storyFiles = findFiles(storiesDir, /\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          if (path.basename(storyFile) === 'README.md') continue;
-          
-          const content = fs.readFileSync(storyFile, 'utf-8');
-          const metadata = extractMetadata(content);
-          
-          // Check if status is Done
-          const isDone = metadata.Status && /done/i.test(metadata.Status);
-          
-          if (isDone) {
-            // Check if behavior is being added/changed (anywhere in file)
-            const allCheckboxes = extractCheckboxes(content);
-            const addsBehavior = allCheckboxes.some(c => c.checked && /adds behavior/i.test(c.text));
-            const changesBehavior = allCheckboxes.some(c => c.checked && /changes behavior/i.test(c.text));
-            
-            if (addsBehavior || changesBehavior) {
-              // Check DoD for Canon update - look for unchecked "Feature Canon updated" item
-              const dodCheckboxes = extractCheckboxes(content, 'DoD Checklist|Definition of Done');
-              const canonChecked = dodCheckboxes.some(c => c.checked && /feature canon updated|canon updated/i.test(c.text));
-              const canonUnchecked = dodCheckboxes.some(c => !c.checked && /feature canon updated|canon updated/i.test(c.text));
-              
-              if (canonUnchecked || (!canonChecked && dodCheckboxes.length > 0)) {
-                results.push({
-                  ruleId: 'TS-DOD-001',
-                  severity: SEVERITY.BLOCKER,
-                  file: storyFile,
-                  message: 'Story is marked Done with behavior changes but Feature Canon not updated. This blocks release.',
-                  owner: 'FA',
-                });
-              }
+    }
+
+    // Lint stories in sprint folders
+    const sprintsDir = path.join(projectDir, 'sprints');
+    if (fs.existsSync(sprintsDir)) {
+        const sprints = fs.readdirSync(sprintsDir, { withFileTypes: true })
+            .filter(d => d.isDirectory() && d.name.startsWith('sprint-'))
+            .map(d => d.name);
+
+        for (const sprint of sprints) {
+            const sprintDir = path.join(sprintsDir, sprint);
+            const stories = fs.readdirSync(sprintDir)
+                .filter(f => f.startsWith('s-') && f.endsWith('.md'));
+
+            for (const story of stories) {
+                const storyPath = path.join(sprintDir, story);
+
+                // TS-STORY-001
+                if (!options.rule || options.rule === 'TS-STORY-001') {
+                    checkStoryEpicLink(storyPath, projectDir, result, workspaceDir);
+                }
+
+                // TS-DOD-001: Done stories need verified AC
+                if (!options.rule || options.rule === 'TS-DOD-001') {
+                    checkDoneStoryAC(storyPath, result);
+                }
             }
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  // -------------------------------------------------------------------------
-  // Naming Convention Rules (TS-NAMING)
-  // -------------------------------------------------------------------------
-  
-  'TS-NAMING-FEATURE': {
-    id: 'TS-NAMING-FEATURE',
-    name: 'Feature file naming convention',
-    severity: SEVERITY.WARNING,
-    owner: 'FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const featuresDir = path.join(ctx.workspaceDir, 'projects', projectId, 'features');
-        if (!fs.existsSync(featuresDir)) continue;
-        
-        const files = fs.readdirSync(featuresDir).filter(f => f.endsWith('.md'));
-        
-        for (const file of files) {
-          if (['features-index.md', 'story-ledger.md', 'README.md'].includes(file)) continue;
-          
-          if (!NAMING_PATTERNS.feature.test(file)) {
-            results.push({
-              ruleId: 'TS-NAMING-FEATURE',
-              severity: SEVERITY.WARNING,
-              file: path.join(featuresDir, file),
-              message: `Feature file '${file}' does not match naming convention: F-NNN-description.md`,
-              owner: 'FA',
-            });
-          }
         }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-NAMING-STORY': {
-    id: 'TS-NAMING-STORY',
-    name: 'Story file naming convention',
-    severity: SEVERITY.WARNING,
-    owner: 'FA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const storiesDir = path.join(ctx.workspaceDir, 'projects', projectId, 'stories');
-        if (!fs.existsSync(storiesDir)) continue;
-        
-        const storyFiles = findFiles(storiesDir, /\.md$/);
-        
-        for (const storyFile of storyFiles) {
-          const filename = path.basename(storyFile);
-          if (filename === 'README.md') continue;
-          
-          if (!NAMING_PATTERNS.story.test(filename)) {
-            results.push({
-              ruleId: 'TS-NAMING-STORY',
-              severity: SEVERITY.WARNING,
-              file: storyFile,
-              message: `Story file '${filename}' does not match naming convention: S-NNN-description.md`,
-              owner: 'FA',
-            });
-          }
-        }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-NAMING-DEVPLAN': {
-    id: 'TS-NAMING-DEVPLAN',
-    name: 'Dev plan file naming convention',
-    severity: SEVERITY.WARNING,
-    owner: 'DEV',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const devPlansDir = path.join(ctx.workspaceDir, 'projects', projectId, 'dev-plans');
-        if (!fs.existsSync(devPlansDir)) continue;
-        
-        const files = fs.readdirSync(devPlansDir).filter(f => f.endsWith('.md'));
-        
-        for (const file of files) {
-          if (file === 'README.md') continue;
-          
-          if (!NAMING_PATTERNS.devPlan.test(file)) {
-            results.push({
-              ruleId: 'TS-NAMING-DEVPLAN',
-              severity: SEVERITY.WARNING,
-              file: path.join(devPlansDir, file),
-              message: `Dev plan file '${file}' does not match naming convention: story-NNN-tasks.md`,
-              owner: 'DEV',
-            });
-          }
+    }
+
+    // Lint test cases naming
+    const tcDir = path.join(projectDir, 'qa', 'test-cases');
+    if (fs.existsSync(tcDir)) {
+        const tcFiles = fs.readdirSync(tcDir).filter(f => f.endsWith('.md'));
+        for (const tc of tcFiles) {
+            checkArtifactNaming(path.join(tcDir, tc), 'project-test-case', result, workspaceDir);
         }
-      }
-      
-      return results;
-    },
-  },
-  
-  'TS-NAMING-ADR': {
-    id: 'TS-NAMING-ADR',
-    name: 'ADR file naming convention',
-    severity: SEVERITY.WARNING,
-    owner: 'SA',
-    async check(ctx) {
-      const results = [];
-      
-      for (const projectId of ctx.projects) {
-        const adrDir = path.join(ctx.workspaceDir, 'projects', projectId, 'adr');
-        if (!fs.existsSync(adrDir)) continue;
-        
-        const files = fs.readdirSync(adrDir).filter(f => f.endsWith('.md'));
-        
-        for (const file of files) {
-          if (file === 'README.md') continue;
-          
-          if (!NAMING_PATTERNS.adr.test(file)) {
-            results.push({
-              ruleId: 'TS-NAMING-ADR',
-              severity: SEVERITY.WARNING,
-              file: path.join(adrDir, file),
-              message: `ADR file '${file}' does not match naming convention: ADR-NNN-description.md`,
-              owner: 'SA',
-            });
-          }
+    }
+
+    // Lint bug reports naming
+    const bugDir = path.join(projectDir, 'qa', 'bug-reports');
+    if (fs.existsSync(bugDir)) {
+        const bugFiles = fs.readdirSync(bugDir).filter(f => f.endsWith('.md'));
+        for (const bug of bugFiles) {
+            checkArtifactNaming(path.join(bugDir, bug), 'bug-report', result, workspaceDir);
         }
-      }
-      
-      return results;
-    },
-  },
-};
+    }
+}
 
-// =============================================================================
-// Linter Class
-// =============================================================================
+/**
+ * Format lint results for console output
+ */
+function formatResults(result, verbose = false) {
+    const output = [];
+    const summary = result.getSummary();
 
-class Linter {
-  constructor(workspaceDir) {
-    this.workspaceDir = workspaceDir;
-  }
-  
-  /**
-   * Run all linter rules
-   */
-  async run(options = {}) {
-    const projects = options.project 
-      ? [options.project]
-      : findProjects(this.workspaceDir);
-    
-    const ctx = {
-      workspaceDir: this.workspaceDir,
-      projects,
-    };
-    
-    const results = [];
-    
-    for (const rule of Object.values(rules)) {
-      try {
-        const ruleResults = await rule.check(ctx);
-        results.push(...ruleResults);
-      } catch (err) {
-        results.push({
-          ruleId: rule.id,
-          severity: SEVERITY.ERROR,
-          file: this.workspaceDir,
-          message: `Rule execution failed: ${err.message}`,
-          owner: 'System',
-        });
-      }
+    if (summary.total === 0) {
+        output.push('✅ No lint errors found');
+        return output.join('\n');
     }
-    
-    return results;
-  }
-  
-  /**
-   * Run a specific rule
-   */
-  async runRule(ruleId, options = {}) {
-    const rule = rules[ruleId];
-    if (!rule) {
-      throw new Error(`Unknown rule: ${ruleId}`);
-    }
-    
-    const projects = options.project 
-      ? [options.project]
-      : findProjects(this.workspaceDir);
-    
-    const ctx = {
-      workspaceDir: this.workspaceDir,
-      projects,
-    };
-    
-    return rule.check(ctx);
-  }
-  
-  /**
-   * Group results by file
-   */
-  groupByFile(results) {
-    const grouped = {};
-    
-    for (const result of results) {
-      if (!grouped[result.file]) {
-        grouped[result.file] = [];
-      }
-      grouped[result.file].push(result);
+
+    // Group by file
+    const byFile = {};
+    for (const item of result.getAll()) {
+        if (!byFile[item.file]) byFile[item.file] = [];
+        byFile[item.file].push(item);
     }
-    
-    return grouped;
-  }
-  
-  /**
-   * Format results for console output
-   */
-  formatResults(results) {
-    if (results.length === 0) {
-      return '✅ No issues found.';
+
+    for (const [file, items] of Object.entries(byFile)) {
+        output.push(`\n📄 ${file}`);
+        for (const item of items) {
+            const icon = item.severity === SEVERITY.ERROR || item.severity === SEVERITY.BLOCKER
+                ? '❌'
+                : item.severity === SEVERITY.WARNING
+                    ? '⚠️'
+                    : 'ℹ️';
+            output.push(`  ${icon} [${item.rule}] ${item.message}`);
+        }
     }
-    
-    const lines = [];
-    const grouped = this.groupByFile(results);
-    
-    for (const [file, fileResults] of Object.entries(grouped)) {
-      lines.push(`\n📄 ${path.relative(this.workspaceDir, file)}`);
-      
-      for (const result of fileResults) {
-        const icon = result.severity === SEVERITY.ERROR || result.severity === SEVERITY.BLOCKER
-          ? '❌'
-          : result.severity === SEVERITY.WARNING
-          ? '⚠️'
-          : 'ℹ️';
-        
-        lines.push(`   ${icon} [${result.ruleId}] ${result.message}`);
-        lines.push(`      Owner: ${result.owner}`);
-      }
+
+    output.push('\n---');
+    output.push(`Summary: ${summary.errors} errors, ${summary.warnings} warnings, ${summary.info} info`);
+
+    if (result.hasBlockers()) {
+        output.push('🚫 BLOCKERS found - cannot proceed');
+    } else if (result.hasErrors()) {
+        output.push('❌ Lint check FAILED');
+    } else {
+        output.push('✅ Lint check passed (warnings only)');
     }
-    
-    // Summary
-    const errors = results.filter(r => r.severity === SEVERITY.ERROR || r.severity === SEVERITY.BLOCKER).length;
-    const warnings = results.filter(r => r.severity === SEVERITY.WARNING).length;
-    const info = results.filter(r => r.severity === SEVERITY.INFO).length;
-    
-    lines.push('\n' + '─'.repeat(60));
-    lines.push(`Summary: ${errors} errors, ${warnings} warnings, ${info} info`);
-    
-    return lines.join('\n');
-  }
+
+    return output.join('\n');
 }
 
 // =============================================================================
-// Exports
+// CLI INTEGRATION
 // =============================================================================
 
+/**
+ * Run linter from CLI
+ */
+function runLint(targetDir, options = {}) {
+    console.log(`\n🔍 Linting TeamSpec workspace: ${targetDir}\n`);
+
+    const result = lint(targetDir, options);
+    console.log(formatResults(result, options.verbose));
+
+    return result.hasErrors() ? 1 : 0;
+}
+
 module.exports = {
-  Linter,
-  rules,
-  SEVERITY,
-  NAMING_PATTERNS,
+    lint,
+    runLint,
+    formatResults,
+    LintResult,
+    SEVERITY,
+    getNamingPatterns,
+    resetNamingPatterns,
+    // Export individual checks for testing
+    checkProductRegistered,
+    checkProductYml,
+    checkProjectRegistered,
+    checkProjectYml,
+    checkFIContent,
+    checkFIFeatureLink,
+    checkEpicNaming,
+    checkStoryEpicLink,
+    checkStoryDelta,
+    checkDoneStoryAC,
+    checkCanonSync,
+    checkFITestCoverage,
+    checkRegressionImpact,
+    checkArtifactNaming
 };