agentic-qe 3.7.15 → 3.7.17

package/dist/mcp/handlers/handler-factory.js

@@ -15,7 +15,7 @@ import { getFleetState, isFleetInitialized } from './core-handlers';
 import { createTaskExecutor } from '../../coordination/task-executor';
 import { getTaskRouter } from '../services/task-router';
 import { toErrorMessage } from '../../shared/error-utils.js';
-import { createInitializedFeedbackLoop } from '../../feedback/feedback-loop.js';
+import { createInitializedFeedbackLoop, getQualityFeedbackLoop } from '../../feedback/feedback-loop.js';
 // ============================================================================
 // Shared Utilities (exported for response mappers)
 // ============================================================================
@@ -131,6 +131,81 @@ function toolNameToDomain(toolName) {
 async function getLearningEngineForCapture() {
     return getLearningEngine();
 }
+/**
+ * Record domain-specific feedback for test_outcomes / coverage_sessions.
+ * ADR-023: Wires domain execution results into the quality feedback loop.
+ */
+async function recordDomainFeedback(domain, data, durationMs, params) {
+    // Wait for the feedback loop that was initialized during getTaskExecutor()
+    let loop = getQualityFeedbackLoop();
+    if (!loop && _feedbackLoopPromise) {
+        loop = await _feedbackLoopPromise;
+    }
+    if (!loop)
+        return;
+    if (domain === 'test-generation' && data) {
+        // Extract test results from generation output and record as outcomes
+        const tests = (data.tests || data.generatedTests || []);
+        for (const test of tests.slice(0, 20)) { // Cap at 20 per invocation
+            const outcome = {
+                id: String(test.id || randomUUID()),
+                testId: String(test.id || test.name || randomUUID()),
+                testName: String(test.name || test.testName || 'generated-test'),
+                generatedBy: 'qe-test-generation',
+                patternId: test.patternId,
+                framework: (test.framework || params.framework || 'vitest'),
+                language: (test.language || params.language || 'typescript'),
+                domain: 'test-generation',
+                passed: test.passed !== false, // Default to true for generated (not yet executed)
+                coverage: {
+                    lines: Number(test.coverageLines || 0),
+                    branches: Number(test.coverageBranches || 0),
+                    functions: Number(test.coverageFunctions || 0),
+                },
+                executionTimeMs: Number(test.executionTimeMs || durationMs / Math.max(tests.length, 1)),
+                flaky: Boolean(test.flaky),
+                maintainabilityScore: Number(test.qualityScore || test.maintainability || 0.7),
+                timestamp: new Date(),
+            };
+            await loop.recordTestOutcome(outcome);
+        }
+    }
+    if (domain === 'coverage-analysis' && data) {
+        // Extract coverage session data and record for learning
+        const session = {
+            id: randomUUID(),
+            targetPath: String(params.target || params.targetPath || 'src/'),
+            agentId: 'qe-coverage-analysis',
+            technique: (params.technique || 'gap-analysis'),
+            beforeCoverage: {
+                lines: Number(data.beforeCoverage?.lines || 0),
+                branches: Number(data.beforeCoverage?.branches || 0),
+                functions: Number(data.beforeCoverage?.functions || 0),
+            },
+            afterCoverage: {
+                lines: Number(data.lineCoverage || data.lines || 0),
+                branches: Number(data.branchCoverage || data.branches || 0),
+                functions: Number(data.functionCoverage || data.functions || 0),
+            },
+            testsGenerated: Number(data.testsGenerated || 0),
+            testsPassed: Number(data.testsPassed || 0),
+            gapsTargeted: (data.gaps || []).map((g, i) => ({
+                id: String(g.id || `gap-${randomUUID().slice(0, 8)}-${i}`),
+                type: (['uncovered-line', 'uncovered-branch', 'uncovered-function', 'partial-branch'].includes(String(g.type))
+                    ? String(g.type) : 'uncovered-line'),
+                filePath: String(g.file || g.filePath || ''),
+                startLine: Number(g.line || g.startLine || 0),
+                endLine: g.endLine ? Number(g.endLine) : undefined,
+                riskScore: Number(g.riskScore || 0.5),
+                addressed: Boolean(g.addressed),
+            })),
+            durationMs,
+            startedAt: new Date(Date.now() - durationMs),
+            completedAt: new Date(),
+        };
+        await loop.recordCoverageSession(session);
+    }
+}
 /**
  * Analyze code complexity
  */
@@ -257,6 +332,8 @@ export function detectAntiPatterns(sourceCode, language) {
 // ============================================================================
 // Cached task executor
 let taskExecutor = null;
+// Cached feedback loop promise (resolves once feedback loop is ready)
+let _feedbackLoopPromise = null;
 // Cached learning engine for pattern search (declared here for use in resetTaskExecutor)
 let cachedLearningEngine = null;
 /**
@@ -271,16 +348,13 @@ export function getTaskExecutor() {
         taskExecutor = createTaskExecutor(kernel);
         // Wire QualityFeedbackLoop for routing outcome persistence
         const executor = taskExecutor;
-        try {
-            createInitializedFeedbackLoop().then(loop => {
-                executor.setQualityFeedbackLoop(loop);
-            }).catch(e => {
-                console.warn('[HandlerFactory] Failed to initialize QualityFeedbackLoop:', e);
-            });
-        }
-        catch (e) {
-            console.warn('[HandlerFactory] Sync error in feedback loop setup:', e);
-        }
+        _feedbackLoopPromise = createInitializedFeedbackLoop().then(loop => {
+            executor.setQualityFeedbackLoop(loop);
+            return loop;
+        }).catch(e => {
+            console.warn('[HandlerFactory] Failed to initialize QualityFeedbackLoop:', e);
+            return null;
+        });
     }
     return taskExecutor;
 }
@@ -526,6 +600,13 @@ export function createDomainHandler(config) {
             recordPatternUsageAsync(routingResult?.patternHints, true, domain, result.duration);
             // Step 5c: Capture real execution learning (fire-and-forget)
             captureExecutionLearning(`qe-${domain}`, taskType, params, data, result.duration).catch(() => { }); // Swallow errors — learning is non-critical
+            // Step 5d: Record feedback for test_outcomes / coverage_sessions
+            try {
+                await recordDomainFeedback(domain, data, result.duration, params);
+            }
+            catch {
+                // Non-critical — don't fail handler if feedback recording fails
+            }
             return {
                 success: true,
                 data: mappedResult,

package/dist/mcp/services/task-router.d.ts

@@ -51,6 +51,16 @@ export interface TaskRoutingResult {
     readonly patternHints?: readonly PatternHint[];
     /** Pattern context formatted for agent prompts (Phase 5.2) */
     readonly patternContext?: string;
+    /** Overlay config overrides for the routed agent (BMAD-002) */
+    readonly overlayConfig?: {
+        minimumFindings?: number;
+        maxParallelAgents?: number;
+        preferredFrameworks?: string[];
+        severityThresholds?: Record<string, number>;
+        needsContext?: boolean;
+    };
+    /** Compiled context from ContextCompiler (BMAD-005) */
+    compiledContext?: string;
 }
 /**
  * Routing log entry for metrics and debugging
@@ -113,6 +123,7 @@ export declare class TaskRouterService {
     private readonly modelRouter;
     private readonly minCutRouter;
     private readonly routingLog;
+    private readonly contextCompiler;
     private disposed;
     private constructor();
     /**

package/dist/mcp/services/task-router.js

@@ -9,6 +9,8 @@
  */
 import { createModelRouter, createModelRouterWithAgentBooster, TIER_METADATA, } from '../../integrations/agentic-flow';
 import { createMinCutRoutingService, } from './mincut-routing-service.js';
+import { getAgentOverlayConfig } from '../../routing/qe-agent-registry.js';
+import { ContextCompiler, formatContextForPrompt } from '../../context/compiler.js';
 /**
  * Default Task Router configuration
  */
@@ -47,10 +49,12 @@ export class TaskRouterService {
     modelRouter;
     minCutRouter;
     routingLog = [];
+    contextCompiler;
     disposed = false;
     constructor(config, modelRouter) {
         this.config = config;
         this.modelRouter = modelRouter;
+        this.contextCompiler = new ContextCompiler();
         this.minCutRouter = createMinCutRoutingService({
             enableLogging: config.enableLogging,
         });
@@ -188,6 +192,26 @@ export class TaskRouterService {
         const patternContext = patternHints && patternHints.length > 0
             ? this.formatPatternContext(patternHints)
             : undefined;
+        // Check for overlay config overrides for the routed agent
+        const agentType = input.agentType;
+        const overlayConfig = agentType
+            ? (getAgentOverlayConfig(agentType) || getAgentOverlayConfig(agentType.replace('v3-qe-', 'qe-')))
+            : undefined;
+        // Compile context if file paths are provided (BMAD-005)
+        let compiledContext;
+        if (input.filePaths && input.filePaths.length > 0) {
+            try {
+                const compiled = await this.contextCompiler.compile({
+                    targetFiles: input.filePaths,
+                    agentType: input.agentType || 'unknown',
+                    taskDescription: input.task,
+                });
+                compiledContext = formatContextForPrompt(compiled);
+            }
+            catch {
+                // Non-blocking — context compilation failure should not affect routing
+            }
+        }
         return {
             decision: effectiveDecision,
             executionStrategy,
@@ -202,6 +226,8 @@ export class TaskRouterService {
             logEntry,
             patternHints,
             patternContext,
+            overlayConfig,
+            compiledContext,
         };
     }
     /**

package/dist/routing/qe-agent-registry.d.ts

@@ -23,6 +23,7 @@
  */
 import type { QEAgentProfile, AgentCapability, ProgrammingLanguage, TestFramework, ComplexityLevel } from './types.js';
 import type { QEDomain } from '../learning/qe-patterns.js';
+import type { AgentOverlay } from '../agents/overlay-schema.js';
 /**
  * All QE agents in the registry
  */
@@ -91,4 +92,14 @@ export declare function getAgentsByPerformance(domain?: QEDomain): QEAgentProfil
  * Reset all agent performance metrics (for testing)
  */
 export declare function resetAgentPerformanceMetrics(): void;
+/**
+ * Initialize overlay configurations from project root.
+ * Loads all .claude/agent-overrides/*.yaml files and caches their config sections.
+ */
+export declare function initializeOverlays(projectRoot: string): void;
+/**
+ * Get overlay configuration for a specific agent.
+ * Returns undefined if no overlay exists for the agent.
+ */
+export declare function getAgentOverlayConfig(agentId: string): AgentOverlay['config'] | undefined;
 //# sourceMappingURL=qe-agent-registry.d.ts.map

package/dist/routing/qe-agent-registry.js

@@ -21,6 +21,7 @@
  * - V3 Specialized: {name} (cross-cutting, no v3-qe prefix, e.g., memory-specialist)
  * - Legacy/V2 Compatibility: qe-* (deprecated, use v3-qe-* instead)
  */
+import { loadOverlays } from '../agents/overlay-loader.js';
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -1174,4 +1175,37 @@ export function resetAgentPerformanceMetrics() {
     }
     console.error('[AgentRegistry] Reset all agent performance metrics');
 }
+// ============================================================================
+// Agent Customization Overlays (BMAD-002)
+// ============================================================================
+/** Module-level cache of overlay configs keyed by agent ID */
+let overlayConfigs = new Map();
+/**
+ * Initialize overlay configurations from project root.
+ * Loads all .claude/agent-overrides/*.yaml files and caches their config sections.
+ */
+export function initializeOverlays(projectRoot) {
+    overlayConfigs = new Map();
+    const result = loadOverlays(projectRoot);
+    for (const overlay of result.overlays) {
+        if (overlay.config) {
+            overlayConfigs.set(overlay.agent, overlay.config);
+        }
+    }
+    if (overlayConfigs.size > 0) {
+        console.error(`[AgentRegistry] Loaded overlay configs for ${overlayConfigs.size} agent(s): ${[...overlayConfigs.keys()].join(', ')}`);
+    }
+    if (result.warnings.length > 0) {
+        for (const warning of result.warnings) {
+            console.error(`[AgentRegistry] Overlay warning: ${warning}`);
+        }
+    }
+}
+/**
+ * Get overlay configuration for a specific agent.
+ * Returns undefined if no overlay exists for the agent.
+ */
+export function getAgentOverlayConfig(agentId) {
+    return overlayConfigs.get(agentId);
+}
 //# sourceMappingURL=qe-agent-registry.js.map

package/dist/routing/qe-task-router.d.ts

@@ -17,6 +17,7 @@ export declare class QETaskRouter {
     private agentEmbeddings;
     private initialized;
     private embeddingCache;
+    private contextCompiler;
     /** Optional witness chain for audit trail of routing decisions (ADR-070) */
     private _witnessChain;
     set witnessChain(wc: WitnessChain | null);

package/dist/routing/qe-task-router.js

@@ -9,8 +9,9 @@
  */
 import { performance } from 'perf_hooks';
 import { DEFAULT_ROUTER_CONFIG } from './types.js';
-import { QE_AGENT_REGISTRY, getAgentById } from './qe-agent-registry.js';
+import { QE_AGENT_REGISTRY, getAgentById, getAgentOverlayConfig, initializeOverlays } from './qe-agent-registry.js';
 import { computeRealEmbedding, cosineSimilarity, } from '../learning/real-embeddings.js';
+import { ContextCompiler, formatContextForPrompt } from '../context/compiler.js';
 // ============================================================================
 // Task Keyword Detection
 // ============================================================================
@@ -130,6 +131,7 @@ export class QETaskRouter {
     agentEmbeddings = new Map();
     initialized = false;
     embeddingCache = new Map();
+    contextCompiler = null;
     /** Optional witness chain for audit trail of routing decisions (ADR-070) */
     _witnessChain = null;
     set witnessChain(wc) { this._witnessChain = wc; }
@@ -142,12 +144,15 @@ export class QETaskRouter {
     async initialize() {
         if (this.initialized)
             return;
+        // Load overlay configs so routing can apply user customizations
+        initializeOverlays(process.cwd());
         // Compute embedding for each agent based on their description and capabilities
         for (const agent of QE_AGENT_REGISTRY) {
             const text = this.buildAgentEmbeddingText(agent);
             const embedding = await computeRealEmbedding(text);
             this.agentEmbeddings.set(agent.id, embedding);
         }
+        this.contextCompiler = new ContextCompiler();
         this.initialized = true;
     }
     /**
@@ -209,7 +214,23 @@ export class QETaskRouter {
             }, 'qe-task-router');
         }
         catch { /* best-effort witness */ }
-        return {
+        // Compile context for the recommended agent (if files provided)
+        let compiledContext;
+        const filePaths = task.context?.files;
+        if (filePaths && filePaths.length > 0 && this.contextCompiler) {
+            try {
+                const context = await this.contextCompiler.compile({
+                    targetFiles: filePaths,
+                    agentType: topScore.agent,
+                    taskDescription: task.description,
+                });
+                compiledContext = formatContextForPrompt(context);
+            }
+            catch {
+                // Context compilation failure is non-blocking
+            }
+        }
+        const decision = {
             recommended: topScore.agent,
             confidence: topScore.combinedScore,
             alternatives,
@@ -223,6 +244,10 @@ export class QETaskRouter {
             latencyMs,
             timestamp: new Date(),
         };
+        if (compiledContext) {
+            decision.compiledContext = compiledContext;
+        }
+        return decision;
     }
     /**
      * Detect QE domain from task description
@@ -372,6 +397,13 @@ export class QETaskRouter {
         if (task.context?.previousAgent === agent.id) {
             bonus += 0.05;
         }
+        // Bonus from overlay config (user customizations)
+        const overlayConfig = getAgentOverlayConfig(agent.id) || getAgentOverlayConfig(agent.id.replace('v3-qe-', 'qe-'));
+        if (overlayConfig?.preferredFrameworks && task.framework) {
+            if (overlayConfig.preferredFrameworks.includes(task.framework)) {
+                bonus += 0.1;
+            }
+        }
         // 5. Combined weighted score
         const { weights } = this.config;
         const combinedScore = Math.min(1.0, (weights.similarity * similarityScore) +

package/dist/routing/routing-feedback.d.ts

@@ -36,6 +36,11 @@ export declare class RoutingFeedbackCollector {
      * Persist a single outcome to the database
      */
     private persistOutcome;
+    /**
+     * Infer model tier from agent name for analytics.
+     * Maps known agent patterns to ADR-026 tiers.
+     */
+    private inferTier;
     /**
      * Delete oldest rows beyond retention limit
      */

package/dist/routing/routing-feedback.js

@@ -135,13 +135,22 @@ export class RoutingFeedbackCollector {
             return;
         try {
             const database = this.db.getDatabase();
+            // Ensure model_tier column exists (for databases created before this schema addition)
+            try {
+                database.prepare(`ALTER TABLE routing_outcomes ADD COLUMN model_tier TEXT`).run();
+            }
+            catch {
+                // Column already exists — expected
+            }
+            // Extract tier from usedAgent name (e.g. "tier-0" → "booster", "qe-test-architect" → "sonnet")
+            const modelTier = this.inferTier(outcome.usedAgent);
             database.prepare(`
         INSERT OR REPLACE INTO routing_outcomes (
           id, task_json, decision_json, used_agent,
           followed_recommendation, success, quality_score,
-          duration_ms, error
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(outcome.id, JSON.stringify(outcome.task), JSON.stringify(outcome.decision), outcome.usedAgent, outcome.followedRecommendation ? 1 : 0, outcome.outcome.success ? 1 : 0, outcome.outcome.qualityScore, outcome.outcome.durationMs, outcome.outcome.error || null);
+          duration_ms, error, model_tier
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(outcome.id, JSON.stringify(outcome.task), JSON.stringify(outcome.decision), outcome.usedAgent, outcome.followedRecommendation ? 1 : 0, outcome.outcome.success ? 1 : 0, outcome.outcome.qualityScore, outcome.outcome.durationMs, outcome.outcome.error || null, modelTier);
             this.persistCount++;
             if (this.persistCount % RoutingFeedbackCollector.RETENTION_CLEANUP_INTERVAL === 0) {
                 this.enforceRetention(database);
@@ -151,6 +160,23 @@ export class RoutingFeedbackCollector {
             console.warn('[RoutingFeedbackCollector] Failed to persist outcome:', toErrorMessage(error));
         }
     }
+    /**
+     * Infer model tier from agent name for analytics.
+     * Maps known agent patterns to ADR-026 tiers.
+     */
+    inferTier(agentName) {
+        const lower = agentName.toLowerCase();
+        if (lower.includes('booster') || lower === 'tier-0')
+            return 'booster';
+        if (lower === 'tier-1' || lower.includes('haiku'))
+            return 'haiku';
+        if (lower === 'tier-2' || lower.includes('sonnet'))
+            return 'sonnet';
+        if (lower.includes('opus'))
+            return 'opus';
+        // Default: most qe-* agents run at sonnet tier
+        return 'sonnet';
+    }
     /**
      * Delete oldest rows beyond retention limit
      */

package/dist/routing/types.d.ts

@@ -112,6 +112,8 @@ export interface QERoutingDecision {
     readonly latencyMs: number;
     /** Timestamp */
     readonly timestamp: Date;
+    /** Compiled context for the recommended agent (if files provided) */
+    compiledContext?: string;
 }
 /**
  * Routing weights for combining scores

package/dist/sync/pull-agent.js

@@ -20,6 +20,7 @@ import { createConnectionManager } from './cloud/tunnel-manager.js';
 import { createPostgresWriter } from './cloud/postgres-writer.js';
 import { createPostgresReader } from './cloud/postgres-reader.js';
 import { createSQLiteWriter } from './writers/sqlite-writer.js';
+import { findProjectRoot } from '../kernel/unified-memory.js';
 import { toErrorMessage, toError } from '../shared/error-utils.js';
 import { LoggerFactory } from '../logging/index.js';
 const logger = LoggerFactory.create('pull-agent');
@@ -259,7 +260,7 @@ export class PullSyncAgent {
         if (this.config.targetDb) {
             return path.resolve(this.config.targetDb);
         }
-        return path.resolve(process.cwd(), '.agentic-qe/memory.db');
+        return path.resolve(findProjectRoot(), '.agentic-qe/memory.db');
     }
     backupLocalDb() {
         if (this.config.dryRun)

package/dist/test-scheduling/pipeline.d.ts

@@ -69,6 +69,13 @@ export interface PipelineResult {
     ciEnvironment: CIEnvironment;
     /** Total duration in milliseconds */
     totalDurationMs: number;
+    /** Per-step latencies in milliseconds (for Tier 3 instrumentation) */
+    stepLatencies?: {
+        selectionMs: number;
+        executionMs: number;
+        analysisMs: number;
+        reportingMs: number;
+    };
 }
 export declare class TestSchedulingPipeline {
     private readonly config;

package/dist/test-scheduling/pipeline.js

@@ -105,6 +105,7 @@ export class TestSchedulingPipeline {
         let selectedTests = [];
         let ranAllTests = this.config.runAllTests ?? false;
         // Step 1: Select affected tests (unless running all)
+        const selectionStart = performance.now();
         if (!ranAllTests) {
             const selectionResult = await this.selector.selectAffectedTests();
             if (selectionResult.runAllTests) {
@@ -121,7 +122,9 @@ export class TestSchedulingPipeline {
                 console.log(`[TestSchedulingPipeline] Selected ${selectedTests.length} affected tests`);
             }
         }
+        const selectionMs = performance.now() - selectionStart;
         // Step 2: Execute tests
+        const executionStart = performance.now();
         let phaseResults;
         if (ranAllTests) {
             // Run all phases with all tests
@@ -131,16 +134,21 @@ export class TestSchedulingPipeline {
             // Run with selected test files
             phaseResults = await this.runWithSelectedTests(selectedTests);
         }
+        const executionMs = performance.now() - executionStart;
         // Step 3: Get flaky analysis (tracker already updated by executor)
+        const analysisStart = performance.now();
         const flakyAnalysis = this.flakyTracker.analyze();
         // Step 4: Save flaky history
         if (this.config.flakyHistoryPath) {
             await saveFlakyTracker(this.flakyTracker, this.config.flakyHistoryPath);
         }
+        const analysisMs = performance.now() - analysisStart;
         // Step 5: Report to CI/CD
+        const reportingStart = performance.now();
         if (this.ciEnvironment.isCI) {
             await this.reporter.writeOutput(phaseResults);
         }
+        const reportingMs = performance.now() - reportingStart;
         const totalDurationMs = Date.now() - startTime;
         return {
             phaseResults,
@@ -149,6 +157,7 @@ export class TestSchedulingPipeline {
             flakyAnalysis,
             ciEnvironment: this.ciEnvironment,
             totalDurationMs,
+            stepLatencies: { selectionMs, executionMs, analysisMs, reportingMs },
         };
     }
     /**

package/dist/validation/index.d.ts

@@ -20,4 +20,7 @@ export { TriggerOptimizer, createTriggerOptimizer, parseSkillFrontmatter, } from
 export type { SkillMetadata, TriggerAnalysisConfig, TriggerAnalysisResult, TriggerSuggestion, TriggerOptimizationReport, } from './trigger-optimizer.js';
 export { VersionComparator, createVersionComparator, } from './version-comparator.js';
 export type { VersionComparisonConfig, SkillVersion, VersionComparisonResult, VersionResult, ComparisonStats, TestCaseComparison, } from './version-comparator.js';
+export { runPipeline, formatPipelineReport, } from './pipeline.js';
+export type { StepCategory, StepSeverity, StepStatus, Finding, ValidationContext, ValidationStep, StepResult, PipelineConfig, PipelineResult, } from './pipeline.js';
+export { REQUIREMENTS_VALIDATION_STEPS, createRequirementsPipeline, formatCheckStep, completenessCheckStep, investCriteriaStep, smartAcceptanceStep, testabilityScoreStep, vagueTermStep, informationDensityStep, traceabilityCheckStep, implementationLeakageStep, domainComplianceStep, dependencyAnalysisStep, bddScenarioStep, holisticQualityStep, } from './steps/requirements.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/validation/index.js

@@ -36,4 +36,14 @@ export { TriggerOptimizer, createTriggerOptimizer, parseSkillFrontmatter, } from
 // Version Comparator (ADR-056: A/B testing between skill versions)
 // ============================================================================
 export { VersionComparator, createVersionComparator, } from './version-comparator.js';
+// ============================================================================
+// Structured Validation Pipeline (BMAD-003)
+// ============================================================================
+export { runPipeline, formatPipelineReport, } from './pipeline.js';
+// ============================================================================
+// Requirements Validation Steps (BMAD-003)
+// ============================================================================
+export { REQUIREMENTS_VALIDATION_STEPS, createRequirementsPipeline, 
+// Individual steps
+formatCheckStep, completenessCheckStep, investCriteriaStep, smartAcceptanceStep, testabilityScoreStep, vagueTermStep, informationDensityStep, traceabilityCheckStep, implementationLeakageStep, domainComplianceStep, dependencyAnalysisStep, bddScenarioStep, holisticQualityStep, } from './steps/requirements.js';
 //# sourceMappingURL=index.js.map

package/dist/validation/pipeline.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Structured Validation Pipeline Framework (BMAD-003)
+ *
+ * Generic pipeline runner that executes validation steps sequentially,
+ * enforcing gates and producing structured reports.
+ */
+export type StepCategory = 'format' | 'content' | 'quality' | 'traceability' | 'compliance';
+export type StepSeverity = 'blocking' | 'warning' | 'info';
+export type StepStatus = 'pass' | 'fail' | 'warn' | 'skip';
+export interface Finding {
+    id: string;
+    stepId: string;
+    severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    title: string;
+    description: string;
+    location?: string;
+    suggestion?: string;
+}
+export interface ValidationContext {
+    /** The content being validated (requirements doc, code, etc.) */
+    content: string;
+    /** File path if applicable */
+    filePath?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Results from previous steps (accumulated) */
+    previousResults: StepResult[];
+}
+export interface ValidationStep {
+    id: string;
+    name: string;
+    category: StepCategory;
+    severity: StepSeverity;
+    description?: string;
+    execute(context: ValidationContext): Promise<StepResult>;
+}
+export interface StepResult {
+    stepId: string;
+    stepName: string;
+    status: StepStatus;
+    score: number;
+    findings: Finding[];
+    evidence: string[];
+    duration: number;
+}
+export interface PipelineConfig {
+    /** Pipeline identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Steps to execute */
+    steps: ValidationStep[];
+    /** Continue past blocking failures */
+    continueOnFailure?: boolean;
+    /** Only run specific steps (by id) */
+    stepFilter?: string[];
+    /** Weights for score calculation (step category -> weight) */
+    categoryWeights?: Record<StepCategory, number>;
+}
+export interface PipelineResult {
+    pipelineId: string;
+    pipelineName: string;
+    overall: 'pass' | 'fail' | 'warn';
+    score: number;
+    steps: StepResult[];
+    blockers: Finding[];
+    halted: boolean;
+    haltedAt?: string;
+    totalDuration: number;
+    timestamp: string;
+}
+/**
+ * Execute a validation pipeline.
+ */
+export declare function runPipeline(config: PipelineConfig, content: string, filePath?: string, metadata?: Record<string, unknown>): Promise<PipelineResult>;
+/**
+ * Format pipeline result as markdown report.
+ */
+export declare function formatPipelineReport(result: PipelineResult): string;
+//# sourceMappingURL=pipeline.d.ts.map