@agile-vibe-coding/avc 0.1.1 → 0.3.1

package/cli/epic-story-validator.js

@@ -0,0 +1,659 @@
+import { ValidationRouter } from './validation-router.js';
+import { LLMProvider } from './llm-provider.js';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { loadAgent } from './agent-loader.js';
+import { validateWithMicroChecks } from './micro-check-validator.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Multi-Agent Epic and Story Validator
+ *
+ * Orchestrates validation via micro-checks: 370 small YES/NO LLM calls across
+ * 15 domain perspectives, deterministic scoring, and atomic per-check fixes.
+ */
+class EpicStoryValidator {
+  constructor(llmProvider, verificationTracker, stagesConfig = null, useSmartSelection = false, progressCallback = null, projectContext = null) {
+    this.llmProvider = llmProvider;
+    this.verificationTracker = verificationTracker;
+    this.projectContext = projectContext;
+
+    // Create router with smart selection support and project context
+    this.router = new ValidationRouter(llmProvider, useSmartSelection, projectContext);
+
+    this.agentsPath = path.join(__dirname, 'agents');
+    this.validationFeedback = new Map();
+
+    // Store validation stage configuration (solver stage removed — micro-checks handle fixes).
+    this.validationStageConfig = stagesConfig?.validation || null;
+
+    // Cache for validator-specific providers
+    this._validatorProviders = {};
+
+    // Smart selection flag
+    this.useSmartSelection = useSmartSelection;
+
+    // Progress callback for UI detail emissions
+    this.progressCallback = progressCallback;
+
+    // Per-call token callback (propagated to all created providers)
+    this._tokenCallback = null;
+
+    // Root project context.md string — prepended to all validation prompts when set
+    this.rootContextMd = null;
+
+  }
+
+  /**
+   * Register a callback to be fired after every LLM API call made by this validator.
+   * Propagates to all provider instances created by this validator.
+   * @param {Function} fn - Receives { input, output, provider, model }
+   */
+  setTokenCallback(fn) {
+    this._tokenCallback = fn;
+  }
+
+  /**
+   * Attach a PromptLogger so all providers created by this validator write payloads.
+   * @param {import('./prompt-logger.js').PromptLogger} logger
+   */
+  setPromptLogger(logger) {
+    this._promptLogger = logger;
+  }
+
+  /**
+   * Set the root project context.md string — prepended to all validation prompts.
+   * @param {string} md - Canonical root context markdown
+   */
+  setRootContextMd(md) {
+    this.rootContextMd = md;
+  }
+
+  /**
+   * Set callback invoked when a validator call fails with a quota/rate-limit error.
+   * Signature: async ({ validatorName, errMsg, provider, model }) => { newProvider?, newModel? }
+   * Returning { newProvider, newModel } switches the validation+solver stage config.
+   * Returning null/undefined retries with the same model.
+   */
+  setQuotaExceededCallback(fn) {
+    this._quotaExceededCallback = fn;
+  }
+
+  /**
+   * Update validation stage config to a new provider/model and clear provider cache.
+   * Called after user selects "Switch Provider" in the quota-limit dialog.
+   */
+  _updateValidationStageConfig(newProvider, newModel) {
+    const oldProvider = this.validationStageConfig?.provider;
+    const oldModel = this.validationStageConfig?.model;
+    if (!this.validationStageConfig) this.validationStageConfig = {};
+    this.validationStageConfig.provider = newProvider;
+    this.validationStageConfig.model = newModel;
+    // Surgical cache invalidation: only clear entries matching the old provider/model
+    // so providers that were already on the new target are preserved
+    if (oldProvider || oldModel) {
+      for (const [key, prov] of Object.entries(this._validatorProviders)) {
+        if (prov?._providerName === oldProvider || prov?._modelName === oldModel) {
+          delete this._validatorProviders[key];
+        }
+      }
+    } else {
+      // No previous config — clear everything
+      this._validatorProviders = {};
+    }
+  }
+
+  /**
+   * Returns true if the error message indicates a quota or persistent rate-limit failure.
+   */
+  _isQuotaOrRateLimit(errMsg) {
+    const m = (errMsg || '').toLowerCase();
+    return m.includes('429') || m.includes('quota') || m.includes('rate limit') ||
+      m.includes('resource exhausted') || m.includes('resource_exhausted') ||
+      m.includes('too many requests') ||
+      // Anthropic credit-balance exhausted (400 invalid_request_error)
+      m.includes('credit balance is too low') || m.includes('credit balance') ||
+      m.includes('billing') || m.includes('insufficient_quota');
+  }
+
+  /**
+   * Generate canonical context.md string for an epic from its JSON fields.
+   * This is the bounded, structured format passed to validators and solvers.
+   * @param {Object} epic
+   * @returns {string}
+   */
+  generateEpicContextMd(epic) {
+    const features = (epic.features || []).map(f => `- ${f}`).join('\n') || '- (none)';
+    const deps = epic.dependencies || [];
+    const optional = deps.filter(d => /optional/i.test(d));
+    const required = deps.filter(d => !/optional/i.test(d));
+    const reqLines = required.length ? required.map(d => `- ${d}`).join('\n') : '- (none)';
+    const storyCount = (epic.stories || []).length;
+    const lines = [
+      `# Epic: ${epic.name}`,
+      ``,
+      `## Identity`,
+      `- id: ${epic.id || '(pending)'}`,
+      `- domain: ${epic.domain}`,
+      `- stories: ${storyCount}`,
+      ``,
+      `## Summary`,
+      epic.description || '(no description)',
+      ``,
+      `## Features`,
+      features,
+      ``,
+      `## Dependencies`,
+      ``,
+      `### Required`,
+      reqLines,
+    ];
+    if (optional.length) {
+      lines.push('', '### Optional');
+      optional.forEach(d => lines.push(`- ${d}`));
+    }
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate canonical context.md string for a story from its JSON fields.
+   * @param {Object} story
+   * @param {Object} epic - Parent epic for identity context
+   * @returns {string}
+   */
+  generateStoryContextMd(story, epic) {
+    const ac = (story.acceptance || []).map((a, i) => `${i + 1}. ${a}`).join('\n') || '1. (none)';
+    const deps = (story.dependencies || []).map(d => `- ${d}`).join('\n') || '- (none)';
+    return [
+      `# Story: ${story.name}`,
+      ``,
+      `## Identity`,
+      `- id: ${story.id || '(pending)'}`,
+      `- epic: ${epic.id || '(pending)'} (${epic.name})`,
+      `- userType: ${story.userType || 'team member'}`,
+      ``,
+      `## Summary`,
+      story.description || '(no description)',
+      ``,
+      `## Acceptance Criteria`,
+      ac,
+      ``,
+      `## Dependencies`,
+      deps,
+    ].join('\n');
+  }
+
+  /** Emit a Level-3 detail line to the UI (fire-and-forget safe) */
+  async _detail(msg) {
+    await this.progressCallback?.(null, null, { detail: msg });
+  }
+
+  /**
+   * Wrap an async LLM call with a periodic elapsed-time heartbeat.
+   * Emits a detail message every `intervalMs` ms while the call runs,
+   * so the UI always shows activity during long LLM operations.
+   */
+  _withHeartbeat(fn, getMsg, intervalMs = 5000) {
+    const startTime = Date.now();
+    let lastMsg = null;
+    const timer = setInterval(() => {
+      const elapsed = Math.round((Date.now() - startTime) / 1000);
+      const msg = getMsg(elapsed);
+      if (msg != null && msg !== lastMsg) {
+        lastMsg = msg;
+        this._detail(msg).catch(() => {});
+        // Also log to debug output so stuck calls are visible in log files
+        console.log(`[HEARTBEAT] ${msg} (${elapsed}s elapsed)`);
+      }
+    }, intervalMs);
+    return fn().finally(() => clearInterval(timer));
+  }
+
+  /**
+   * Determine validation type from validator name
+   * Returns: 'universal', 'domain', or 'feature'
+   */
+  getValidationType(validatorName) {
+    const role = validatorName.replace(/^validator-(epic|story)-/, '');
+
+    // Universal validators (always applied)
+    const epicUniversal = ['solution-architect', 'developer', 'security'];
+    const storyUniversal = ['developer', 'qa', 'test-architect'];
+
+    if (epicUniversal.includes(role) || storyUniversal.includes(role)) {
+      return 'universal';
+    }
+
+    // Domain validators
+    const domainValidators = ['devops', 'cloud', 'backend', 'database', 'api',
+                              'frontend', 'ui', 'ux', 'mobile', 'data'];
+
+    if (domainValidators.includes(role)) {
+      return 'domain';
+    }
+
+    // Everything else is feature-based
+    return 'feature';
+  }
+
+  /**
+   * Get provider for a specific validator based on validation type
+   * @param {string} validatorName - Validator name (e.g., 'validator-epic-security')
+   * @returns {Promise<LLMProvider>} LLM provider instance
+   */
+  async getProviderForValidator(validatorName) {
+    const validationType = this.getValidationType(validatorName);
+
+    // Check validation-type specific configuration
+    const validationTypeConfig = this.validationStageConfig?.validationTypes?.[validationType];
+
+    let provider, model;
+
+    if (validationTypeConfig?.provider) {
+      // Use validation-type-specific config
+      provider = validationTypeConfig.provider;
+      model = validationTypeConfig.model;
+    } else if (this.validationStageConfig?.provider) {
+      // Fallback to validation stage default
+      provider = this.validationStageConfig.provider;
+      model = this.validationStageConfig.model;
+    } else {
+      // Fallback to global default (use default llmProvider)
+      return this.llmProvider;
+    }
+
+    // Check cache
+    const cacheKey = `${validatorName}:${provider}:${model}`;
+    if (this._validatorProviders[cacheKey]) {
+      return this._validatorProviders[cacheKey];
+    }
+
+    // Create new provider
+    const role = this.extractDomain(validatorName);
+    const providerInstance = await LLMProvider.create(provider, model);
+    if (this._tokenCallback) providerInstance.onCall((delta) => this._tokenCallback(delta, 'validation'));
+    if (this._promptLogger) providerInstance.setPromptLogger(this._promptLogger, `validation-${role}`);
+    this._validatorProviders[cacheKey] = providerInstance;
+
+    return providerInstance;
+  }
+
+  /**
+   * Get provider for contextual agent selection (agent-selector LLM call).
+   * Uses validation stage config; falls back to this.llmProvider.
+   * @returns {Promise<LLMProvider>}
+   */
+  async getProviderForSelection() {
+    if (this.validationStageConfig?.provider && this.validationStageConfig?.model) {
+      const cacheKey = `selection:${this.validationStageConfig.provider}:${this.validationStageConfig.model}`;
+      if (this._validatorProviders[cacheKey]) return this._validatorProviders[cacheKey];
+      const instance = await LLMProvider.create(this.validationStageConfig.provider, this.validationStageConfig.model);
+      if (this._tokenCallback) instance.onCall((delta) => this._tokenCallback(delta, 'validation'));
+      if (this._promptLogger) instance.setPromptLogger(this._promptLogger, 'selection');
+      this._validatorProviders[cacheKey] = instance;
+      return instance;
+    }
+    return this.llmProvider;
+  }
+
+  /**
+   * Validate an Epic via micro-checks: parallel YES/NO domain checks,
+   * cross-reference consistency checks, deterministic scoring, and atomic fixes.
+   * @param {Object} epic - Epic work.json object
+   * @param {string} epicContext - Epic context.md content
+   * @returns {Object} Aggregated validation result
+   */
+  async validateEpic(epic, epicContext) {
+    console.log(`\n🔍 Validating Epic (micro-checks): ${epic.name}`);
+    // Determine perspectives from router
+    let perspectives;
+    if (epic.metadata?.selectedValidators) {
+      perspectives = epic.metadata.selectedValidators.map(v => this.extractDomain(v));
+    } else {
+      const validators = this.router.getValidatorsForEpic(epic);
+      if (!epic.metadata) epic.metadata = {};
+      epic.metadata.selectedValidators = validators;
+      perspectives = validators.map(v => this.extractDomain(v));
+    }
+    const workItemText = epicContext || this.generateEpicContextMd(epic);
+    const mcResult = await validateWithMicroChecks(
+      epic, workItemText, 'epic', perspectives, this.llmProvider,
+      {
+        concurrency: this.validationStageConfig?.concurrency ?? 5,
+        batchSize: this.validationStageConfig?.batchSize ?? 8,
+        maxFixAttempts: this.validationStageConfig?.maxFixAttempts ?? 3,
+        generateContextFn: (wi) => this.generateEpicContextMd(wi),
+        progressCallback: this.progressCallback,
+        projectRoot: this.projectContext?.projectRoot,
+      }
+    );
+    epic.metadata = epic.metadata || {};
+    epic.metadata.validationResult = {
+      averageScore: mcResult.averageScore,
+      overallStatus: mcResult.overallStatus,
+      readyToPublish: mcResult.readyToPublish,
+      criticalIssues: mcResult.criticalIssues,
+      majorIssues: mcResult.majorIssues,
+      minorIssues: mcResult.minorIssues,
+      validatorResults: mcResult.validatorResults,
+      validatedAt: mcResult.validatedAt,
+    };
+    this.storeValidationFeedback(epic.id, mcResult);
+    return mcResult;
+  }
+
+  /**
+   * Validate a Story via micro-checks: parallel YES/NO domain checks,
+   * cross-reference consistency checks, deterministic scoring, and atomic fixes.
+   * @param {Object} story - Story work.json object
+   * @param {string} storyContext - Story context.md content
+   * @param {Object} epic - Parent epic for routing
+   * @returns {Object} Aggregated validation result
+   */
+  async validateStory(story, storyContext, epic) {
+    console.log(`\n🔍 Validating Story (micro-checks): ${story.name}`);
+    let perspectives;
+    if (story.metadata?.selectedValidators) {
+      perspectives = story.metadata.selectedValidators.map(v => this.extractDomain(v));
+    } else {
+      const validators = this.router.getValidatorsForStory(story, epic);
+      if (!story.metadata) story.metadata = {};
+      story.metadata.selectedValidators = validators;
+      perspectives = validators.map(v => this.extractDomain(v));
+    }
+    const workItemText = storyContext || this.generateStoryContextMd(story, epic);
+    const mcResult = await validateWithMicroChecks(
+      story, workItemText, 'story', perspectives, this.llmProvider,
+      {
+        concurrency: this.validationStageConfig?.concurrency ?? 5,
+        batchSize: this.validationStageConfig?.batchSize ?? 8,
+        maxFixAttempts: this.validationStageConfig?.maxFixAttempts ?? 3,
+        generateContextFn: (wi) => this.generateStoryContextMd(wi, epic),
+        progressCallback: this.progressCallback,
+        projectRoot: this.projectContext?.projectRoot,
+      }
+    );
+    story.metadata = story.metadata || {};
+    story.metadata.validationResult = {
+      averageScore: mcResult.averageScore,
+      overallStatus: mcResult.overallStatus,
+      readyToPublish: mcResult.readyToPublish,
+      criticalIssues: mcResult.criticalIssues,
+      majorIssues: mcResult.majorIssues,
+      minorIssues: mcResult.minorIssues,
+      validatorResults: mcResult.validatorResults,
+      validatedAt: mcResult.validatedAt,
+    };
+    this.storeValidationFeedback(story.id, mcResult);
+    return mcResult;
+  }
+
+  /**
+   * Build the prompt for the story-splitter agent.
+   * @param {Object} story - The oversized story to split
+   * @param {Object} epic - Parent epic for context
+   * @param {Array} allIssues - MAJOR+CRITICAL issues from all validators
+   * @returns {string}
+   * @private
+   */
+  _buildStorySplitterPrompt(story, epic, allIssues) {
+    const fullEpicContext = this.generateEpicContextMd(epic);
+    const epicContextMd = fullEpicContext.length > 3000
+      ? fullEpicContext.substring(0, 3000) + '\n… (truncated)'
+      : fullEpicContext;
+    const storyContext = this.generateStoryContextMd(story, epic);
+    const critMajor = allIssues.filter(i => i.severity === 'critical' || i.severity === 'major');
+    const issueText = critMajor.map((issue, i) => {
+      const cat = issue.category ? `[${issue.category}] ` : '';
+      const sug = issue.suggestion ? `\n   Required fix: ${issue.suggestion}` : '';
+      return `${i + 1}. [${(issue.severity || 'major').toUpperCase()}] ${cat}${issue.description || ''}${sug}`;
+    }).join('\n');
+
+    return `# Story to Split
+
+## Parent Epic (canonical)
+
+${epicContextMd}
+
+## Original Story (too large — ${(story.acceptance || []).length} acceptance criteria)
+
+${storyContext}
+
+## Validator Issues That Triggered This Split
+
+${issueText || 'Story exceeded the acceptance criteria size limit after multiple validation passes.'}
+
+Split this story into 2-3 smaller independently deliverable stories.
+Return a JSON array of story objects as specified in your instructions.
+`;
+  }
+
+  /**
+   * Call the story-splitter agent to decompose an oversized story into 2-3 smaller stories.
+   * Returns an array of 2-3 new story objects, or null if the split failed/produced invalid output.
+   * @param {Object} workingStory - The fully-validated but too-large story
+   * @param {Object} epic - Parent epic for context
+   * @param {Array} allIssues - MAJOR+CRITICAL issues from all validators
+   * @returns {Promise<Array<Object>|null>}
+   */
+  async _splitStory(workingStory, epic, allIssues) {
+    const agentInstructions = this.loadAgentInstructions('story-splitter.md');
+    const prompt = this._buildStorySplitterPrompt(workingStory, epic, allIssues);
+    const provider = await this.getProviderForValidator('story-splitter');
+
+    const _usageBefore = provider.getTokenUsage();
+    const _t0 = Date.now();
+    console.log(`[API-START] story-splitter (story="${workingStory.name}", ACs=${(workingStory.acceptance || []).length})`);
+
+    let result;
+    try {
+      result = await this._withHeartbeat(
+        () => provider.generateJSON(prompt, agentInstructions),
+        (elapsed) => {
+          if (elapsed < 20) return `   ✂ splitting story — analyzing scope boundaries…`;
+          if (elapsed < 40) return `   ✂ splitting story — assigning acceptance criteria…`;
+          return `   ✂ splitting story — still running…`;
+        },
+        10000
+      );
+    } catch (err) {
+      console.warn(`   ⚠ story-splitter failed: ${err.message.split('\n')[0]}`);
+      return null;
+    }
+
+    const _elapsed = Date.now() - _t0;
+    const _usageAfter = provider.getTokenUsage();
+    const _deltaIn = _usageAfter.inputTokens - _usageBefore.inputTokens;
+    const _deltaOut = _usageAfter.outputTokens - _usageBefore.outputTokens;
+    console.log(`[API-DONE] story-splitter — ${_elapsed}ms | in=${_deltaIn} out=${_deltaOut} tokens`);
+
+    // Validate: result must be an array of 2-3 stories
+    if (!Array.isArray(result) || result.length < 2 || result.length > 3) {
+      console.warn(`   ⚠ story-splitter returned unexpected shape (expected array of 2-3, got ${Array.isArray(result) ? result.length : typeof result}) — skipping split`);
+      return null;
+    }
+
+    // Validate each split story has required fields; cap ACs to 8
+    for (const s of result) {
+      if (!s.id || !s.name || !Array.isArray(s.acceptance)) {
+        console.warn(`   ⚠ story-splitter returned malformed story (missing id/name/acceptance) — skipping split`);
+        return null;
+      }
+      if (s.acceptance.length > 8) {
+        s.acceptance = s.acceptance.slice(0, 8);
+      }
+    }
+
+    if (this.verificationTracker) {
+      this.verificationTracker.recordCheck('story-splitter', 'story-splitting', true);
+    }
+
+    return result;
+  }
+
+  /**
+   * Aggregate multiple validation results into a single report
+   * @private
+   */
+  aggregateValidationResults(results, type) {
+    const aggregated = {
+      type: type, // 'epic' or 'story'
+      validatorCount: results.length,
+      validators: results.map(r => r._validatorName),
+      // Exclude errored validators (API failures) from the average — a 0 from a
+      // network failure is not a real score and would corrupt the aggregate.
+      averageScore: (() => {
+        const scorable = results.filter(r => !r._validatorError);
+        if (scorable.length === 0) return 0;
+        return Math.round(scorable.reduce((sum, r) => sum + (r.overallScore || 0), 0) / scorable.length);
+      })(),
+
+      // Aggregate issues by severity
+      criticalIssues: [],
+      majorIssues: [],
+      minorIssues: [],
+
+      // Aggregate strengths (deduplicated)
+      strengths: [],
+
+      // Aggregate improvement priorities (ranked by frequency)
+      improvementPriorities: [],
+
+      // Per-validator results summary
+      validatorResults: results.map(r => ({
+        validator: r._validatorName,
+        status: r.validationStatus,
+        score: r.overallScore || 0,
+        issueCount: (r.issues || []).length
+      }))
+    };
+
+    // Collect and categorize issues
+    results.forEach(result => {
+      (result.issues || []).forEach(issue => {
+        const enhancedIssue = {
+          ...issue,
+          validator: result._validatorName,
+          domain: this.extractDomain(result._validatorName)
+        };
+
+        if (issue.severity === 'critical') {
+          aggregated.criticalIssues.push(enhancedIssue);
+        } else if (issue.severity === 'major') {
+          aggregated.majorIssues.push(enhancedIssue);
+        } else {
+          aggregated.minorIssues.push(enhancedIssue);
+        }
+      });
+
+      // Collect strengths (deduplicate similar ones)
+      (result.strengths || []).forEach(strength => {
+        if (!aggregated.strengths.some(s => this.isSimilar(s, strength))) {
+          aggregated.strengths.push(strength);
+        }
+      });
+    });
+
+    // Rank improvement priorities by frequency across validators
+    const priorityMap = new Map();
+    results.forEach(result => {
+      (result.improvementPriorities || []).forEach(priority => {
+        priorityMap.set(priority, (priorityMap.get(priority) || 0) + 1);
+      });
+    });
+
+    aggregated.improvementPriorities = Array.from(priorityMap.entries())
+      .sort((a, b) => b[1] - a[1]) // Sort by frequency
+      .slice(0, 5) // Top 5
+      .map(([priority, count]) => ({ priority, mentionedBy: count }));
+
+    return aggregated;
+  }
+
+  /**
+   * Determine overall status from multiple validators
+   * Uses "highest severity wins" approach
+   * @private
+   */
+  determineOverallStatus(results) {
+    const statuses = results.map(r => r.validationStatus);
+
+    // If any validator errored (API failure), mark as needs-improvement so
+    // readyToPublish stays false — validation is incomplete, not "acceptable"
+    if (statuses.includes('error')) {
+      return 'needs-improvement';
+    }
+
+    // If any validator says "needs-improvement", overall is "needs-improvement"
+    if (statuses.includes('needs-improvement')) {
+      return 'needs-improvement';
+    }
+
+    // If all are "excellent", overall is "excellent"
+    if (statuses.every(s => s === 'excellent')) {
+      return 'excellent';
+    }
+
+    // Otherwise "acceptable"
+    return 'acceptable';
+  }
+
+  /**
+   * Load agent instructions from .md file
+   * @private
+   */
+  loadAgentInstructions(filename) {
+    try {
+      return loadAgent(filename);
+    } catch (err) {
+      throw new Error(`Agent file not found: ${filename}`);
+    }
+  }
+
+
+  /**
+   * Extract domain name from validator or solver name
+   * @private
+   */
+  extractDomain(validatorName) {
+    // Extract domain from validator/solver name
+    // e.g., "validator-epic-security" → "security"
+    // e.g., "solver-epic-security" → "security"
+    if (!validatorName) return 'unknown';
+    const match = validatorName.match(/(?:validator|solver)-(?:epic|story)-(.+)/);
+    return match ? match[1] : 'unknown';
+  }
+
+  /**
+   * Check if two strings are similar (for deduplication)
+   * @private
+   */
+  isSimilar(str1, str2) {
+    // Simple similarity check (can be enhanced with fuzzy matching)
+    const s1 = str1.toLowerCase();
+    const s2 = str2.toLowerCase();
+    return s1.includes(s2) || s2.includes(s1);
+  }
+
+  /**
+   * Store validation feedback for learning/feedback loops
+   * @private
+   */
+  storeValidationFeedback(workItemId, aggregatedResult) {
+    this.validationFeedback.set(workItemId, aggregatedResult);
+  }
+
+  /**
+   * Get validation feedback for a work item
+   * @param {string} workItemId - Work item ID
+   * @returns {Object|null} Aggregated validation result or null
+   */
+  getValidationFeedback(workItemId) {
+    return this.validationFeedback.get(workItemId) || null;
+  }
+}
+
+export { EpicStoryValidator };