agentic-qe 3.7.18 → 3.7.20

package/assets/skills/validation-pipeline/schemas/output.json

@@ -0,0 +1,193 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://agentic-qe.dev/schemas/validation-pipeline-output.json",
+  "title": "AQE Validation Pipeline Skill Output Schema",
+  "description": "Schema for validation pipeline skill output. Includes step results, scores, findings, and blockers.",
+  "type": "object",
+  "required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
+  "properties": {
+    "skillName": {
+      "type": "string",
+      "const": "validation-pipeline",
+      "description": "Must be 'validation-pipeline'"
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$"
+    },
+    "timestamp": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["success", "partial", "failed", "skipped"]
+    },
+    "trustTier": {
+      "type": "integer",
+      "const": 3,
+      "description": "Trust tier 3 indicates full validation with eval suite"
+    },
+    "output": {
+      "type": "object",
+      "required": ["pipelineId", "pipelineName", "overall", "score", "steps"],
+      "properties": {
+        "pipelineId": {
+          "type": "string",
+          "description": "Pipeline identifier"
+        },
+        "pipelineName": {
+          "type": "string",
+          "description": "Human-readable pipeline name"
+        },
+        "overall": {
+          "type": "string",
+          "enum": ["pass", "fail", "warn"],
+          "description": "Overall pipeline verdict"
+        },
+        "score": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100,
+          "description": "Weighted average score across all steps"
+        },
+        "steps": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/stepResult" },
+          "minItems": 1,
+          "description": "Per-step results"
+        },
+        "blockers": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/finding" },
+          "description": "Findings from blocking steps that failed"
+        },
+        "halted": {
+          "type": "boolean",
+          "description": "Whether pipeline halted early"
+        },
+        "haltedAt": {
+          "type": "string",
+          "description": "Step ID where pipeline halted"
+        },
+        "totalDuration": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Total execution time in ms"
+        },
+        "summary": {
+          "type": "string",
+          "minLength": 20,
+          "maxLength": 2000,
+          "description": "Human-readable summary"
+        }
+      }
+    },
+    "metadata": { "$ref": "#/$defs/metadata" },
+    "validation": { "$ref": "#/$defs/validationResult" },
+    "learning": { "$ref": "#/$defs/learningData" }
+  },
+  "$defs": {
+    "stepResult": {
+      "type": "object",
+      "required": ["stepId", "stepName", "status", "score", "findings", "evidence", "duration"],
+      "properties": {
+        "stepId": {
+          "type": "string",
+          "description": "Step identifier"
+        },
+        "stepName": {
+          "type": "string",
+          "description": "Human-readable step name"
+        },
+        "status": {
+          "type": "string",
+          "enum": ["pass", "fail", "warn", "skip"],
+          "description": "Step verdict"
+        },
+        "score": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100,
+          "description": "Step score"
+        },
+        "findings": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/finding" }
+        },
+        "evidence": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "What was checked"
+        },
+        "duration": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Step duration in ms"
+        }
+      }
+    },
+    "finding": {
+      "type": "object",
+      "required": ["id", "stepId", "severity", "title", "description"],
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "stepId": {
+          "type": "string"
+        },
+        "severity": {
+          "type": "string",
+          "enum": ["critical", "high", "medium", "low", "info"]
+        },
+        "title": {
+          "type": "string",
+          "minLength": 5,
+          "maxLength": 200
+        },
+        "description": {
+          "type": "string",
+          "maxLength": 2000
+        },
+        "location": {
+          "type": "string",
+          "description": "File path or document section"
+        },
+        "suggestion": {
+          "type": "string",
+          "description": "Suggested fix"
+        }
+      }
+    },
+    "metadata": {
+      "type": "object",
+      "properties": {
+        "executionTimeMs": { "type": "integer", "minimum": 0 },
+        "toolsUsed": { "type": "array", "items": { "type": "string" } },
+        "agentId": { "type": "string" },
+        "pipelineType": { "type": "string" },
+        "targetFile": { "type": "string" },
+        "stepsExecuted": { "type": "integer", "minimum": 0 },
+        "stepsSkipped": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "validationResult": {
+      "type": "object",
+      "properties": {
+        "schemaValid": { "type": "boolean" },
+        "contentValid": { "type": "boolean" },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+        "warnings": { "type": "array", "items": { "type": "string" }, "maxItems": 20 },
+        "errors": { "type": "array", "items": { "type": "string" }, "maxItems": 20 }
+      }
+    },
+    "learningData": {
+      "type": "object",
+      "properties": {
+        "patternsDetected": { "type": "array", "items": { "type": "string" }, "maxItems": 20 },
+        "reward": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    }
+  }
+}

package/assets/skills/validation-pipeline/scripts/validate-config.json

@@ -0,0 +1,34 @@
+{
+  "skillName": "validation-pipeline",
+  "skillVersion": "1.0.0",
+  "requiredTools": [],
+  "optionalTools": ["jq"],
+  "schemaPath": "schemas/output.json",
+  "requiredFields": [
+    "skillName",
+    "status",
+    "output",
+    "output.pipelineId",
+    "output.pipelineName",
+    "output.overall",
+    "output.score",
+    "output.steps"
+  ],
+  "requiredNonEmptyFields": [
+    "output.pipelineName",
+    "output.steps"
+  ],
+  "mustContainTerms": [
+    "pipeline",
+    "validation"
+  ],
+  "mustNotContainTerms": [
+    "TODO",
+    "placeholder",
+    "FIXME"
+  ],
+  "enumValidations": {
+    ".status": ["success", "partial", "failed", "skipped"],
+    ".output.overall": ["pass", "fail", "warn"]
+  }
+}

package/dist/cli/bundle.js

@@ -49930,8 +49930,8 @@ var DEFAULT_GOVERNANCE_FLAGS = {
     enabled: true,
     maxConsecutiveRetries: 3,
     reworkRatioThreshold: 0.5,
-    idleTimeoutMs: 5 * 60 * 1e3,
-    // 5 minutes
+    idleTimeoutMs: 15 * 60 * 1e3,
+    // 15 minutes
     throttleOnExceed: true
   },
   memoryWriteGate: {
@@ -50066,7 +50066,7 @@ function loadFlagsFromEnv() {
       enabled: env.GOVERNANCE_CONTINUE_GATE !== "false",
       maxConsecutiveRetries: parseInt(env.GOVERNANCE_MAX_RETRIES || "3", 10),
       reworkRatioThreshold: parseFloat(env.GOVERNANCE_REWORK_THRESHOLD || "0.5"),
-      idleTimeoutMs: parseInt(env.GOVERNANCE_IDLE_TIMEOUT || "300000", 10),
+      idleTimeoutMs: parseInt(env.GOVERNANCE_IDLE_TIMEOUT || "900000", 10),
       throttleOnExceed: env.GOVERNANCE_THROTTLE !== "false"
     },
     memoryWriteGate: {
@@ -50390,7 +50390,7 @@ var ContinueGateIntegration = class _ContinueGateIntegration {
           budgetRemaining: {
             tokens: Math.max(0, flags.maxConsecutiveRetries * 10 * 500 - history.length * 500),
             toolCalls: Math.max(0, flags.maxConsecutiveRetries * 10 - history.length),
-            timeMs: Math.max(0, flags.idleTimeoutMs - (history.length > 0 ? Date.now() - history[0].timestamp : 0))
+            timeMs: Math.max(0, flags.idleTimeoutMs - (history.length > 0 ? Date.now() - history[history.length - 1].timestamp : 0))
           },
           recentDecisions: []
         };
@@ -135299,7 +135299,7 @@ var ALL_DOMAINS2 = [
   "enterprise-integration"
 ];
 function getAQEVersion() {
-  return true ? "3.7.18" : "3.0.0";
+  return true ? "3.7.20" : "3.0.0";
 }
 function createDefaultConfig(projectName, projectRoot) {
   return {
@@ -136509,7 +136509,9 @@ var AQE_COMMAND_PATTERNS = [
   /\baqe\b/i,
   /\bagentic-qe\b/i,
   /\bnpx\s+agentic-qe\b/i,
-  /\bnpx\s+@anthropics\/agentic-qe\b/i
+  /\bnpx\s+@anthropics\/agentic-qe\b/i,
+  /brain-checkpoint\.cjs/i,
+  /\.claude\/helpers\//i
 ];
 function isAqeHookEntry(entry) {
   const hookEntry = entry;
@@ -166104,7 +166106,7 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command21();
-var VERSION = true ? "3.7.18" : "0.0.0-dev";
+var VERSION = true ? "3.7.20" : "0.0.0-dev";
 program.name("aqe").description("Agentic QE - Domain-Driven Quality Engineering").version(VERSION);
 var registry2 = createCommandRegistry(context, cleanupAndExit, ensureInitialized, ensureInitializedStrict);
 registry2.registerAll(program);

package/dist/context/compiler.js

@@ -8,6 +8,8 @@ import { MemoryContextSource } from './sources/memory-source.js';
 import { GitContextSource } from './sources/git-source.js';
 import { TestContextSource } from './sources/test-source.js';
 import { CoverageContextSource } from './sources/coverage-source.js';
+import { RequirementsContextSource } from './sources/requirements-source.js';
+import { DefectContextSource } from './sources/defect-source.js';
 const DEFAULT_TOKEN_BUDGET = 8000;
 const DEFAULT_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 /**
@@ -16,7 +18,9 @@ const DEFAULT_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 export function createDefaultSources() {
     return [
         new MemoryContextSource(),
+        new RequirementsContextSource(),
         new TestContextSource(),
+        new DefectContextSource(),
         new GitContextSource(),
         new CoverageContextSource(),
     ];

package/dist/context/index.d.ts

@@ -5,4 +5,6 @@ export { MemoryContextSource } from './sources/memory-source.js';
 export { GitContextSource } from './sources/git-source.js';
 export { TestContextSource } from './sources/test-source.js';
 export { CoverageContextSource } from './sources/coverage-source.js';
+export { RequirementsContextSource } from './sources/requirements-source.js';
+export { DefectContextSource } from './sources/defect-source.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/context/index.js

@@ -3,4 +3,6 @@ export { MemoryContextSource } from './sources/memory-source.js';
 export { GitContextSource } from './sources/git-source.js';
 export { TestContextSource } from './sources/test-source.js';
 export { CoverageContextSource } from './sources/coverage-source.js';
+export { RequirementsContextSource } from './sources/requirements-source.js';
+export { DefectContextSource } from './sources/defect-source.js';
 //# sourceMappingURL=index.js.map

package/dist/context/sources/defect-source.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Defect Source - Historical defect patterns for target files
+ *
+ * Queries the learning database for defect intelligence data,
+ * providing historical bug patterns and regression hotspots
+ * relevant to the files under analysis.
+ */
+import type { ContextSource, ContextRequest, ContextFragment } from './types.js';
+export declare class DefectContextSource implements ContextSource {
+    id: string;
+    name: string;
+    priority: number;
+    maxTokens: number;
+    gather(request: ContextRequest): Promise<ContextFragment[]>;
+    private extractDefectKeywords;
+}
+//# sourceMappingURL=defect-source.d.ts.map

package/dist/context/sources/defect-source.js

@@ -0,0 +1,102 @@
+/**
+ * Defect Source - Historical defect patterns for target files
+ *
+ * Queries the learning database for defect intelligence data,
+ * providing historical bug patterns and regression hotspots
+ * relevant to the files under analysis.
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+export class DefectContextSource {
+    id = 'defects';
+    name = 'Defect Intelligence';
+    priority = 65;
+    maxTokens = 1500;
+    async gather(request) {
+        const fragments = [];
+        try {
+            const dbPath = join(process.cwd(), '.agentic-qe', 'memory.db');
+            if (!existsSync(dbPath)) {
+                return [];
+            }
+            const Database = (await import('better-sqlite3')).default;
+            const db = new Database(dbPath, { readonly: true });
+            try {
+                // Check if patterns table exists
+                const tableCheck = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='qe_patterns'").get();
+                if (!tableCheck) {
+                    return [];
+                }
+                // Query defect patterns related to target files
+                const filePatterns = request.targetFiles.map(f => `%${f.split('/').pop()}%`);
+                if (filePatterns.length > 0) {
+                    const placeholders = filePatterns.map(() => 'description LIKE ?').join(' OR ');
+                    const stmt = db.prepare(`SELECT name, domain, description, confidence
+             FROM qe_patterns
+             WHERE domain LIKE '%defect%'
+               AND (${placeholders})
+             ORDER BY confidence DESC
+             LIMIT 8`);
+                    const defects = stmt.all(...filePatterns);
+                    if (defects.length > 0) {
+                        const content = defects.map(d => `- **${d.name}** (confidence: ${(d.confidence * 100).toFixed(0)}%): ${d.description || 'No description'}`).join('\n');
+                        fragments.push({
+                            sourceId: this.id,
+                            title: 'Historical Defect Patterns',
+                            content: `Found ${defects.length} defect patterns for target files:\n\n${content}`,
+                            estimatedTokens: Math.ceil(content.length / 3.5),
+                            relevance: 0.7,
+                        });
+                    }
+                }
+                // Query regression hotspots based on task description
+                const regressionKeywords = this.extractDefectKeywords(request.taskDescription);
+                if (regressionKeywords.length > 0) {
+                    const kwPlaceholders = regressionKeywords.map(() => 'description LIKE ?').join(' OR ');
+                    const kwPatterns = regressionKeywords.map(k => `%${k}%`);
+                    const stmt = db.prepare(`SELECT name, domain, description, confidence
+             FROM qe_patterns
+             WHERE (domain LIKE '%defect%' OR domain LIKE '%regression%')
+               AND (${kwPlaceholders})
+             ORDER BY confidence DESC
+             LIMIT 5`);
+                    const regressions = stmt.all(...kwPatterns);
+                    if (regressions.length > 0) {
+                        const content = regressions.map(r => `- **${r.name}**: ${r.description || 'No description'}`).join('\n');
+                        fragments.push({
+                            sourceId: this.id,
+                            title: 'Regression Hotspots',
+                            content: `Known regression patterns:\n\n${content}`,
+                            estimatedTokens: Math.ceil(content.length / 3.5),
+                            relevance: 0.6,
+                        });
+                    }
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            // Database access failed — return empty (defect context is optional)
+            return [];
+        }
+        return fragments;
+    }
+    extractDefectKeywords(description) {
+        const keywords = [];
+        const desc = description.toLowerCase();
+        const defectTerms = [
+            'bug', 'defect', 'regression', 'fix', 'crash', 'error',
+            'null', 'undefined', 'timeout', 'race condition', 'deadlock',
+            'memory leak', 'overflow', 'injection', 'broken',
+        ];
+        for (const term of defectTerms) {
+            if (desc.includes(term)) {
+                keywords.push(term);
+            }
+        }
+        return keywords.slice(0, 5);
+    }
+}
+//# sourceMappingURL=defect-source.js.map

package/dist/context/sources/index.d.ts

@@ -3,4 +3,6 @@ export { MemoryContextSource } from './memory-source.js';
 export { GitContextSource } from './git-source.js';
 export { TestContextSource } from './test-source.js';
 export { CoverageContextSource } from './coverage-source.js';
+export { RequirementsContextSource } from './requirements-source.js';
+export { DefectContextSource } from './defect-source.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/context/sources/index.js

@@ -2,4 +2,6 @@ export { MemoryContextSource } from './memory-source.js';
 export { GitContextSource } from './git-source.js';
 export { TestContextSource } from './test-source.js';
 export { CoverageContextSource } from './coverage-source.js';
+export { RequirementsContextSource } from './requirements-source.js';
+export { DefectContextSource } from './defect-source.js';
 //# sourceMappingURL=index.js.map

package/dist/context/sources/requirements-source.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Requirements Source - Linked requirements for target files
+ *
+ * Queries the learning database for requirements traceability data,
+ * mapping target files to their associated requirements and acceptance criteria.
+ */
+import type { ContextSource, ContextRequest, ContextFragment } from './types.js';
+export declare class RequirementsContextSource implements ContextSource {
+    id: string;
+    name: string;
+    priority: number;
+    maxTokens: number;
+    gather(request: ContextRequest): Promise<ContextFragment[]>;
+    private fallbackGather;
+    private extractRequirementKeywords;
+}
+//# sourceMappingURL=requirements-source.d.ts.map

package/dist/context/sources/requirements-source.js

@@ -0,0 +1,119 @@
+/**
+ * Requirements Source - Linked requirements for target files
+ *
+ * Queries the learning database for requirements traceability data,
+ * mapping target files to their associated requirements and acceptance criteria.
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+export class RequirementsContextSource {
+    id = 'requirements';
+    name = 'Requirements Traceability';
+    priority = 75;
+    maxTokens = 2000;
+    async gather(request) {
+        const fragments = [];
+        try {
+            const dbPath = join(process.cwd(), '.agentic-qe', 'memory.db');
+            if (!existsSync(dbPath)) {
+                return this.fallbackGather(request);
+            }
+            const Database = (await import('better-sqlite3')).default;
+            const db = new Database(dbPath, { readonly: true });
+            try {
+                // Check if requirements table exists
+                const tableCheck = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='qe_patterns'").get();
+                if (!tableCheck) {
+                    return this.fallbackGather(request);
+                }
+                // Query patterns in the requirements domain linked to target files
+                const filePatterns = request.targetFiles.map(f => `%${f.split('/').pop()}%`);
+                if (filePatterns.length > 0) {
+                    const placeholders = filePatterns.map(() => 'description LIKE ?').join(' OR ');
+                    const stmt = db.prepare(`SELECT name, domain, description, confidence
+             FROM qe_patterns
+             WHERE domain LIKE '%requirement%'
+               AND (${placeholders})
+             ORDER BY confidence DESC
+             LIMIT 10`);
+                    const requirements = stmt.all(...filePatterns);
+                    if (requirements.length > 0) {
+                        const content = requirements.map(r => `- **${r.name}** (confidence: ${(r.confidence * 100).toFixed(0)}%): ${r.description || 'No description'}`).join('\n');
+                        fragments.push({
+                            sourceId: this.id,
+                            title: 'Linked Requirements',
+                            content: `Found ${requirements.length} requirements linked to target files:\n\n${content}`,
+                            estimatedTokens: Math.ceil(content.length / 3.5),
+                            relevance: 0.75,
+                        });
+                    }
+                }
+                // Also search by task description keywords for broader requirement context
+                const keywords = this.extractRequirementKeywords(request.taskDescription);
+                if (keywords.length > 0) {
+                    const kwPlaceholders = keywords.map(() => 'name LIKE ? OR description LIKE ?').join(' OR ');
+                    const kwPatterns = keywords.flatMap(k => [`%${k}%`, `%${k}%`]);
+                    const stmt = db.prepare(`SELECT DISTINCT name, domain, description, confidence
+             FROM qe_patterns
+             WHERE domain LIKE '%requirement%'
+               AND (${kwPlaceholders})
+             ORDER BY confidence DESC
+             LIMIT 5`);
+                    const related = stmt.all(...kwPatterns);
+                    if (related.length > 0) {
+                        const content = related.map(r => `- **${r.name}**: ${r.description || 'No description'}`).join('\n');
+                        fragments.push({
+                            sourceId: this.id,
+                            title: 'Related Requirements',
+                            content: `Requirements related to task:\n\n${content}`,
+                            estimatedTokens: Math.ceil(content.length / 3.5),
+                            relevance: 0.6,
+                        });
+                    }
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            return this.fallbackGather(request);
+        }
+        if (fragments.length === 0) {
+            return this.fallbackGather(request);
+        }
+        return fragments;
+    }
+    fallbackGather(request) {
+        // Provide basic file-to-requirement mapping hint
+        const fileList = request.targetFiles.join(', ');
+        const content = `No requirements traceability data found for: ${fileList}. Consider running requirements validation to establish traceability.`;
+        return [{
+                sourceId: this.id,
+                title: 'Requirements Context',
+                content,
+                estimatedTokens: Math.ceil(content.length / 3.5),
+                relevance: 0.3,
+            }];
+    }
+    extractRequirementKeywords(description) {
+        const keywords = [];
+        const desc = description.toLowerCase();
+        // Extract requirement-like identifiers (REQ-001, US-123, etc.)
+        const reqIds = desc.match(/(?:req|us|story|epic|feat)-?\d+/gi) || [];
+        keywords.push(...reqIds);
+        // Extract domain terms relevant to requirements
+        const domainTerms = [
+            'authentication', 'authorization', 'payment', 'registration',
+            'notification', 'search', 'api', 'login', 'user', 'admin',
+            'report', 'dashboard', 'import', 'export', 'integration',
+        ];
+        for (const term of domainTerms) {
+            if (desc.includes(term)) {
+                keywords.push(term);
+            }
+        }
+        return keywords.slice(0, 5); // Cap at 5 keywords
+    }
+}
+//# sourceMappingURL=requirements-source.js.map

package/dist/coordination/task-executor.js

@@ -324,9 +324,15 @@ export class DomainTaskExecutor {
         const payload = task.payload;
         const routingTier = payload?.routingTier ?? 2;
         const useAgentBooster = payload?.useAgentBooster ?? false;
+        const compiledContext = payload?.compiledContext ?? undefined;
         const modelId = getModelForTier(routingTier);
+        // BMAD-005: Attach compiled context to task metadata for domain handlers
+        if (compiledContext && task.payload) {
+            task.payload.__compiledContext = compiledContext;
+        }
         console.debug(`[TaskExecutor] Executing task ${task.id}: type=${task.type}, ` +
-            `tier=${routingTier}, model=${modelId}, useAgentBooster=${useAgentBooster}`);
+            `tier=${routingTier}, model=${modelId}, useAgentBooster=${useAgentBooster}` +
+            `${compiledContext ? ', hasContext=true' : ''}`);
         try {
             // ADR-051: Tier 0 - Try Agent Booster for mechanical transforms
             if (routingTier === 0 || useAgentBooster) {

package/dist/coordination/yaml-pipeline-loader.d.ts

@@ -0,0 +1,32 @@
+/**
+ * YAML Pipeline Loader (Imp-9)
+ *
+ * Converts declarative YAML files into WorkflowDefinition objects for
+ * deterministic, token-free execution through the WorkflowOrchestrator.
+ * Supports ${VAR} variable interpolation and schema validation.
+ */
+import { Result } from '../shared/types/index.js';
+import type { WorkflowDefinition } from './workflow-types.js';
+export declare class YamlPipelineLoader {
+    /** Parse a YAML string into a WorkflowDefinition with optional variable interpolation. */
+    parse(yaml: string, vars?: Record<string, unknown>): Result<WorkflowDefinition, Error>;
+    /** Load a WorkflowDefinition from a YAML file on disk. */
+    loadFromFile(filePath: string, vars?: Record<string, unknown>): Promise<Result<WorkflowDefinition, Error>>;
+    /** Interpolate ${VAR} placeholders. Supports flat and dot-path keys. */
+    interpolateVariables(yaml: string, vars: Record<string, unknown>): string;
+    /** Validate a raw parsed object against the WorkflowDefinition schema. */
+    validateSchema(parsed: unknown): Result<WorkflowDefinition, Error>;
+    private validateAndConvert;
+    private validateSteps;
+    private validateCondition;
+    private validateTriggers;
+    private validateRetry;
+    private validateRollback;
+    /** Validate that a value is Record<string, string>, undefined, or return an Error. */
+    private validateStringRecord;
+    /** Resolve a dot-path variable (e.g. "foo.bar") from a variables map. */
+    private resolveVarPath;
+    /** Detect circular dependencies. Returns a cycle description or null. */
+    private detectCircularDependencies;
+}
+//# sourceMappingURL=yaml-pipeline-loader.d.ts.map