@yasserkhanorg/e2e-agents 1.9.5 → 1.10.0

package/dist/esm/knowledge/api_surface.js

@@ -2,39 +2,233 @@
 // See LICENSE.txt for license information.
 import { existsSync, readFileSync, readdirSync, writeFileSync } from 'fs';
 import { join, extname } from 'path';
+import ts from 'typescript';
+// ── TypeScript AST-based extraction ────────────────────────
+function extractMethodsFromAST(sourceFile, checker) {
+    const surfaces = [];
+    ts.forEachChild(sourceFile, (node) => {
+        if (!ts.isClassDeclaration(node) || !node.name) {
+            return;
+        }
+        const className = node.name.text;
+        const methods = [];
+        const seen = new Set();
+        // Get base class name if extends
+        let extendsName;
+        if (node.heritageClauses) {
+            for (const clause of node.heritageClauses) {
+                if (clause.token === ts.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+                    const expr = clause.types[0].expression;
+                    if (ts.isIdentifier(expr)) {
+                        extendsName = expr.text;
+                    }
+                }
+            }
+        }
+        for (const member of node.members) {
+            // Skip constructor
+            if (ts.isConstructorDeclaration(member)) {
+                continue;
+            }
+            // Skip private/protected members
+            const modifiers = ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined;
+            if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword)) {
+                continue;
+            }
+            const name = member.name && ts.isIdentifier(member.name) ? member.name.text : null;
+            if (!name || name.startsWith('_') || seen.has(name)) {
+                continue;
+            }
+            seen.add(name);
+            if (ts.isMethodDeclaration(member)) {
+                const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+                const params = extractParams(member.parameters, checker);
+                const returnType = extractReturnType(member, checker);
+                methods.push({
+                    name,
+                    kind: 'method',
+                    async: isAsync ? true : undefined,
+                    params: params.length > 0 ? params : undefined,
+                    returnType: returnType || undefined,
+                });
+            }
+            else if (ts.isGetAccessorDeclaration(member)) {
+                methods.push({ name, kind: 'getter' });
+            }
+            else if (ts.isPropertyDeclaration(member)) {
+                // Check if it's an arrow function property (e.g., name = async () => {})
+                if (member.initializer && (ts.isArrowFunction(member.initializer) || ts.isFunctionExpression(member.initializer))) {
+                    const fn = member.initializer;
+                    const fnModifiers = ts.canHaveModifiers(fn) ? ts.getModifiers(fn) : undefined;
+                    const isAsync = fnModifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+                    const params = extractParams(fn.parameters, checker);
+                    methods.push({
+                        name,
+                        kind: 'method',
+                        async: isAsync ? true : undefined,
+                        params: params.length > 0 ? params : undefined,
+                    });
+                }
+                else {
+                    methods.push({ name, kind: 'property' });
+                }
+            }
+        }
+        if (methods.length > 0) {
+            surfaces.push({
+                className,
+                file: sourceFile.fileName,
+                methods,
+                extends: extendsName,
+            });
+        }
+    });
+    return surfaces;
+}
+function extractParams(params, checker) {
+    return params.map((p) => {
+        const name = ts.isIdentifier(p.name) ? p.name.text : p.name.getText();
+        const optional = p.questionToken !== undefined || p.initializer !== undefined;
+        let type;
+        if (p.type) {
+            type = p.type.getText();
+        }
+        else if (checker) {
+            try {
+                const symbol = checker.getSymbolAtLocation(p.name);
+                if (symbol) {
+                    const t = checker.getTypeOfSymbolAtLocation(symbol, p);
+                    type = checker.typeToString(t);
+                }
+            }
+            catch {
+                // Type inference failure is non-fatal
+            }
+        }
+        return { name, type, optional: optional || undefined };
+    });
+}
+function extractReturnType(method, checker) {
+    if (method.type) {
+        return method.type.getText();
+    }
+    if (checker) {
+        try {
+            const signature = checker.getSignatureFromDeclaration(method);
+            if (signature) {
+                const returnType = checker.getReturnTypeOfSignature(signature);
+                const typeStr = checker.typeToString(returnType);
+                // Skip overly verbose inferred types
+                if (typeStr.length < 100) {
+                    return typeStr;
+                }
+            }
+        }
+        catch {
+            // Type inference failure is non-fatal
+        }
+    }
+    return null;
+}
+/**
+ * Extract page objects using the TypeScript Compiler API.
+ * Falls back to regex if compilation fails.
+ */
+function extractWithAST(files) {
+    if (files.length === 0) {
+        return [];
+    }
+    // Find the nearest tsconfig.json
+    const firstDir = join(files[0], '..');
+    const tsconfigPath = ts.findConfigFile(firstDir, ts.sys.fileExists, 'tsconfig.json');
+    let program;
+    if (tsconfigPath) {
+        const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+        const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, join(tsconfigPath, '..'));
+        // Only compile the files we care about, using the config's compiler options
+        program = ts.createProgram(files, parsedConfig.options);
+    }
+    else {
+        program = ts.createProgram(files, {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            strict: true,
+            allowJs: false,
+            noEmit: true,
+        });
+    }
+    const checker = program.getTypeChecker();
+    const surfaces = [];
+    for (const filePath of files) {
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile) {
+            continue;
+        }
+        surfaces.push(...extractMethodsFromAST(sourceFile, checker));
+    }
+    // Resolve inherited methods: if class extends another class in the catalog,
+    // merge parent methods that the child doesn't override
+    resolveInheritance(surfaces);
+    return surfaces;
+}
+/**
+ * Merge parent class methods into child classes that extend them.
+ */
+function resolveInheritance(surfaces) {
+    const byName = new Map(surfaces.map((s) => [s.className, s]));
+    for (const surface of surfaces) {
+        if (!surface.extends) {
+            continue;
+        }
+        const parent = byName.get(surface.extends);
+        if (!parent) {
+            continue;
+        }
+        const childMethodNames = new Set(surface.methods.map((m) => m.name));
+        for (const parentMethod of parent.methods) {
+            if (!childMethodNames.has(parentMethod.name)) {
+                surface.methods.push({ ...parentMethod });
+            }
+        }
+    }
+}
+// ── Regex-based extraction (fallback) ──────────────────────
 const RESERVED_WORDS = new Set([
     'private', 'protected', 'static', 'abstract', 'override',
     'if', 'for', 'while', 'switch', 'return',
     'const', 'let', 'var', 'import', 'export',
     'class', 'type', 'interface', 'constructor',
 ]);
-function extractMethodsFromSource(content) {
+function extractMethodsFromRegex(content) {
     const methods = [];
     const seen = new Set();
-    // Match async method declarations: async methodName(
     const asyncMethodRe = /(?:async\s+)([a-zA-Z_]\w*)\s*\(/g;
     let match;
     while ((match = asyncMethodRe.exec(content)) !== null) {
         const name = match[1];
-        if (RESERVED_WORDS.has(name)) {
-            continue;
-        }
-        if (!seen.has(name)) {
+        if (!RESERVED_WORDS.has(name) && !seen.has(name)) {
             seen.add(name);
-            methods.push({ name, kind: 'method' });
+            methods.push({ name, kind: 'method', async: true });
         }
     }
-    // Match non-async public method patterns
     const methodRe = /^\s+(?:readonly\s+)?([a-zA-Z_]\w*)\s*(?:\(|=\s*(?:async\s*)?\()/gm;
     while ((match = methodRe.exec(content)) !== null) {
         const name = match[1];
-        if (RESERVED_WORDS.has(name) || seen.has(name)) {
-            continue;
+        if (!RESERVED_WORDS.has(name) && !seen.has(name)) {
+            seen.add(name);
+            const isAsync = match[0].includes('async');
+            methods.push({ name, kind: 'method', async: isAsync ? true : undefined });
+        }
+    }
+    const arrowRe = /^\s+([a-zA-Z_]\w*)\s*=\s*(async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>/gm;
+    while ((match = arrowRe.exec(content)) !== null) {
+        const name = match[1];
+        if (!RESERVED_WORDS.has(name) && !seen.has(name)) {
+            seen.add(name);
+            methods.push({ name, kind: 'method', async: match[2] ? true : undefined });
         }
-        seen.add(name);
-        methods.push({ name, kind: 'method' });
     }
-    // Match getter patterns: get propertyName()
     const getterRe = /\bget\s+([a-zA-Z_]\w*)\s*\(\)/g;
     while ((match = getterRe.exec(content)) !== null) {
         const name = match[1];
@@ -43,15 +237,13 @@ function extractMethodsFromSource(content) {
             methods.push({ name, kind: 'getter' });
         }
     }
-    // Match readonly property declarations
     const propRe = /^\s+(?:readonly\s+)?([a-zA-Z_]\w*)\s*[:=]/gm;
     while ((match = propRe.exec(content)) !== null) {
         const name = match[1];
-        if (RESERVED_WORDS.has(name) || seen.has(name)) {
-            continue;
+        if (!RESERVED_WORDS.has(name) && !seen.has(name)) {
+            seen.add(name);
+            methods.push({ name, kind: 'property' });
         }
-        seen.add(name);
-        methods.push({ name, kind: 'property' });
     }
     return methods;
 }
@@ -59,7 +251,27 @@ function extractClassName(content) {
     const match = content.match(/(?:export\s+)?class\s+(\w+)/);
     return match ? match[1] : null;
 }
-function scanDirectory(dir) {
+// ── Directory scanning ─────────────────────────────────────
+function collectTypeScriptFiles(dir) {
+    const files = [];
+    if (!existsSync(dir)) {
+        return files;
+    }
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectTypeScriptFiles(fullPath));
+            continue;
+        }
+        const ext = extname(entry.name);
+        if (ext === '.ts' || ext === '.tsx') {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function scanDirectoryWithRegex(dir) {
     const surfaces = [];
     if (!existsSync(dir)) {
         return surfaces;
@@ -68,29 +280,22 @@ function scanDirectory(dir) {
     for (const entry of entries) {
         const fullPath = join(dir, entry.name);
         if (entry.isDirectory()) {
-            surfaces.push(...scanDirectory(fullPath));
+            surfaces.push(...scanDirectoryWithRegex(fullPath));
             continue;
         }
         const ext = extname(entry.name);
         if (ext !== '.ts' && ext !== '.tsx') {
             continue;
         }
-        if (entry.name === 'index.ts' || entry.name === 'index.tsx') {
-            continue;
-        }
         try {
             const content = readFileSync(fullPath, 'utf-8');
             const className = extractClassName(content);
             if (!className) {
                 continue;
             }
-            const extractedMethods = extractMethodsFromSource(content);
+            const extractedMethods = extractMethodsFromRegex(content);
             if (extractedMethods.length > 0) {
-                surfaces.push({
-                    className,
-                    file: fullPath,
-                    methods: extractedMethods,
-                });
+                surfaces.push({ className, file: fullPath, methods: extractedMethods });
             }
         }
         catch {
@@ -99,6 +304,7 @@ function scanDirectory(dir) {
     }
     return surfaces;
 }
+// ── Public API ──────────────────────────────────────────────
 export function buildApiSurface(testsRoot, config) {
     const pageObjectsDir = config?.pageObjectsDir
         ? join(testsRoot, config.pageObjectsDir)
@@ -106,10 +312,30 @@ export function buildApiSurface(testsRoot, config) {
     const componentsDir = config?.componentsDir
         ? join(testsRoot, config.componentsDir)
         : join(testsRoot, 'lib', 'src', 'ui', 'components');
-    const pageObjects = [
-        ...scanDirectory(pageObjectsDir),
-        ...scanDirectory(componentsDir),
-    ];
+    let pageObjects;
+    if (config?.useRegexFallback) {
+        pageObjects = [
+            ...scanDirectoryWithRegex(pageObjectsDir),
+            ...scanDirectoryWithRegex(componentsDir),
+        ];
+    }
+    else {
+        // Use TypeScript AST — full type info, inheritance, params
+        const allFiles = [
+            ...collectTypeScriptFiles(pageObjectsDir),
+            ...collectTypeScriptFiles(componentsDir),
+        ];
+        try {
+            pageObjects = extractWithAST(allFiles);
+        }
+        catch {
+            // Fall back to regex if AST extraction fails
+            pageObjects = [
+                ...scanDirectoryWithRegex(pageObjectsDir),
+                ...scanDirectoryWithRegex(componentsDir),
+            ];
+        }
+    }
     return {
         pageObjects,
         generatedAt: new Date().toISOString(),
@@ -168,7 +394,12 @@ export function formatApiSurfaceForPrompt(catalog, classNames) {
             if (m.kind === 'getter') {
                 return `  get ${m.name}()`;
             }
-            return `  ${m.name}()`;
+            const prefix = m.async ? 'async ' : '';
+            const paramStr = m.params
+                ? m.params.map((p) => `${p.name}${p.optional ? '?' : ''}${p.type ? `: ${p.type}` : ''}`).join(', ')
+                : '';
+            const retStr = m.returnType ? `: ${m.returnType}` : '';
+            return `  ${prefix}${m.name}(${paramStr})${retStr}`;
         })
             .join('\n');
         sections.push(`${name}:\n${methodList}`);

package/dist/esm/knowledge/failure_history.js

@@ -0,0 +1,121 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Tracks historical test failure correlations: which tests fail when certain files change.
+ * Used to boost confidence in impact analysis — if a file change historically breaks a test,
+ * future changes to that file should prioritize that test.
+ *
+ * Data is stored as a JSON file at .e2e-ai-agents/failure-history.json.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+const DEFAULT_HISTORY = {
+    correlations: [],
+    totalRuns: 0,
+    updatedAt: new Date().toISOString(),
+};
+export function loadFailureHistory(testsRoot) {
+    const historyPath = join(testsRoot, '.e2e-ai-agents', 'failure-history.json');
+    if (!existsSync(historyPath)) {
+        return { ...DEFAULT_HISTORY };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(historyPath, 'utf-8'));
+        if (!Array.isArray(raw.correlations)) {
+            return { ...DEFAULT_HISTORY };
+        }
+        return raw;
+    }
+    catch {
+        return { ...DEFAULT_HISTORY };
+    }
+}
+export function saveFailureHistory(testsRoot, history) {
+    const historyPath = join(testsRoot, '.e2e-ai-agents', 'failure-history.json');
+    try {
+        const dir = dirname(historyPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        history.updatedAt = new Date().toISOString();
+        writeFileSync(historyPath, JSON.stringify(history, null, 2), 'utf-8');
+    }
+    catch {
+        // Non-fatal — history is advisory, not required
+    }
+}
+/**
+ * Record that a set of changed files caused a set of spec failures.
+ * Call this after a test run where failures were observed.
+ */
+export function recordFailures(history, changedFiles, failedSpecs) {
+    const now = new Date().toISOString();
+    const updated = { ...history, totalRuns: history.totalRuns + 1, correlations: [...history.correlations] };
+    for (const changedFile of changedFiles) {
+        for (const specFile of failedSpecs) {
+            const existing = updated.correlations.find((c) => c.changedFile === changedFile && c.specFile === specFile);
+            if (existing) {
+                existing.count++;
+                existing.lastSeen = now;
+            }
+            else {
+                updated.correlations.push({
+                    changedFile,
+                    specFile,
+                    count: 1,
+                    lastSeen: now,
+                });
+            }
+        }
+    }
+    // Prune stale correlations (not seen in 90 days)
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - 90);
+    const cutoffStr = cutoff.toISOString();
+    updated.correlations = updated.correlations.filter((c) => c.lastSeen >= cutoffStr);
+    return updated;
+}
+/**
+ * Get a confidence boost (0-20) for a file based on historical failure patterns.
+ * A file that historically causes test failures gets a higher confidence boost
+ * when detected as impacted, meaning the system is more confident it needs testing.
+ */
+export function getConfidenceBoost(history, changedFile) {
+    const correlations = history.correlations.filter((c) => c.changedFile === changedFile);
+    if (correlations.length === 0) {
+        return 0;
+    }
+    // More correlations and higher counts = more confidence
+    const totalCount = correlations.reduce((sum, c) => sum + c.count, 0);
+    const uniqueSpecs = correlations.length;
+    // Scale: 1 correlation = +5, 3+ = +10, 5+ with high counts = +15, max +20
+    if (totalCount >= 10 && uniqueSpecs >= 5)
+        return 20;
+    if (totalCount >= 5 && uniqueSpecs >= 3)
+        return 15;
+    if (totalCount >= 3)
+        return 10;
+    return 5;
+}
+/**
+ * Get the most likely failing specs for a set of changed files, based on history.
+ * Returns specs sorted by correlation strength (count * recency).
+ */
+export function getPredictedFailures(history, changedFiles, limit = 10) {
+    const specScores = new Map();
+    for (const changedFile of changedFiles) {
+        for (const c of history.correlations) {
+            if (c.changedFile !== changedFile)
+                continue;
+            // Score: count weighted by recency (days since last seen)
+            const daysSince = (Date.now() - new Date(c.lastSeen).getTime()) / (1000 * 60 * 60 * 24);
+            const recencyWeight = Math.max(0.1, 1 - daysSince / 90);
+            const score = c.count * recencyWeight;
+            specScores.set(c.specFile, (specScores.get(c.specFile) || 0) + score);
+        }
+    }
+    return Array.from(specScores.entries())
+        .map(([specFile, score]) => ({ specFile, score }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+}

package/dist/esm/knowledge/route_families.js

@@ -106,8 +106,22 @@ function validateFamily(family) {
     if (testType) {
         result.testType = testType;
     }
+    if (Array.isArray(obj.assertionPatterns)) {
+        result.assertionPatterns = validateAssertionPatterns(obj.assertionPatterns);
+    }
     return result;
 }
+const VALID_ASSERTION_TYPES = [
+    'state-change', 'cross-user', 'persistence', 'negative',
+    'permission', 'data-integrity', 'error-handling',
+];
+function validateAssertionPatterns(patterns) {
+    return patterns
+        .filter((p) => p != null && typeof p === 'object')
+        .filter((p) => typeof p.type === 'string' && typeof p.pattern === 'string')
+        .filter((p) => VALID_ASSERTION_TYPES.includes(p.type))
+        .map((p) => ({ type: p.type, pattern: p.pattern }));
+}
 function validateFeature(feature) {
     if (!feature || typeof feature !== 'object') {
         return null;
@@ -141,6 +155,9 @@ function validateFeature(feature) {
     if (Array.isArray(obj.userFlows)) {
         result.userFlows = obj.userFlows.filter((v) => typeof v === 'string');
     }
+    if (Array.isArray(obj.assertionPatterns)) {
+        result.assertionPatterns = validateAssertionPatterns(obj.assertionPatterns);
+    }
     return result;
 }
 export function loadRouteFamilyManifest(testsRoot, config) {
@@ -294,6 +311,19 @@ export function getRoutesForBinding(manifest, binding) {
     }
     return family.routes;
 }
+export function getAssertionPatternsForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        if (feature?.assertionPatterns && feature.assertionPatterns.length > 0) {
+            return feature.assertionPatterns;
+        }
+    }
+    return family.assertionPatterns || [];
+}
 export function clearManifestCache() {
     manifestCache.clear();
 }
@@ -345,7 +375,7 @@ export function serializeManifest(manifest) {
             const cleaned = { ...f };
             const optionalArrays = [
                 'pageObjects', 'components', 'webappPaths', 'serverPaths',
-                'specDirs', 'cypressSpecDirs', 'tags', 'userFlows', 'features', 'apiEndpoints',
+                'specDirs', 'cypressSpecDirs', 'tags', 'userFlows', 'features', 'apiEndpoints', 'assertionPatterns',
             ];
             for (const key of optionalArrays) {
                 if (!cleaned[key] || (Array.isArray(cleaned[key]) && cleaned[key].length === 0)) {

package/dist/esm/pipeline/stage1_impact.js

@@ -3,7 +3,8 @@
 import { LLMProviderFactory } from '../provider_factory.js';
 import { buildImpactPrompt, parseImpactResponse } from '../prompts/impact.js';
 import { formatContextForPrompt } from '../knowledge/context_loader.js';
-import { getFamilyById } from '../knowledge/route_families.js';
+import { getFamilyById, getAssertionPatternsForBinding } from '../knowledge/route_families.js';
+import { loadFailureHistory, getConfidenceBoost } from '../knowledge/failure_history.js';
 import { getSpecsForFamily } from '../knowledge/spec_index.js';
 import { computeConfidence, shouldForceCannotDetermine } from '../validation/guardrails.js';
 function normalizePriority(value) {
@@ -18,7 +19,7 @@ async function getProvider(config) {
     }
     return LLMProviderFactory.createFromEnv();
 }
-export async function runImpactStage(familyGroups, manifest, specIndex, apiSurface, context, config) {
+export async function runImpactStage(familyGroups, manifest, specIndex, apiSurface, context, config, testsRoot) {
     const warnings = [];
     const allDecisions = [];
     if (familyGroups.length === 0) {
@@ -35,6 +36,8 @@ export async function runImpactStage(familyGroups, manifest, specIndex, apiSurfa
         return { decisions: [], warnings, providerName: 'none' };
     }
     const contextBlock = formatContextForPrompt(context);
+    // Load historical failure correlations for confidence boosting
+    const failureHistory = testsRoot ? loadFailureHistory(testsRoot) : null;
     for (const group of familyGroups) {
         const family = manifest ? getFamilyById(manifest, group.familyId) : null;
         if (!family) {
@@ -83,15 +86,27 @@ export async function runImpactStage(familyGroups, manifest, specIndex, apiSurfa
                 if (!flow.id || !flow.changedFiles || !Array.isArray(flow.changedFiles)) {
                     continue;
                 }
+                // Compute confidence with optional historical failure boost
+                const changedFilesList = Array.isArray(flow.changedFiles)
+                    ? flow.changedFiles.filter((f) => typeof f === 'string')
+                    : [];
+                const historyBoost = failureHistory
+                    ? Math.max(...changedFilesList.map((f) => getConfidenceBoost(failureHistory, f)), 0)
+                    : 0;
                 const confidence = typeof flow.confidence === 'number'
-                    ? Math.max(0, Math.min(100, flow.confidence))
+                    ? Math.min(100, Math.max(0, flow.confidence) + historyBoost)
                     : computeConfidence({
                         hasRouteFamily: true,
                         hasSpecificRoute: Boolean(flow.route),
                         hasPageObject: Boolean(flow.pageObjects && flow.pageObjects.length > 0),
                         hasUserAction: Boolean(flow.userActions && flow.userActions.length > 0),
                         hasExistingSpecCited: false,
+                        historyBoost,
                     });
+                // Resolve assertion patterns from manifest for this flow's family/feature
+                const assertionPatterns = manifest
+                    ? getAssertionPatternsForBinding(manifest, { family: group.familyId, feature: group.featureId })
+                    : [];
                 const decision = {
                     flowId: flow.id,
                     flowName: flow.name || flow.id,
@@ -107,6 +122,7 @@ export async function runImpactStage(familyGroups, manifest, specIndex, apiSurfa
                     blockingReason: shouldForceCannotDetermine(confidence) ? 'Confidence too low to determine action.' : undefined,
                     priority: normalizePriority(flow.priority),
                     userActions: Array.isArray(flow.userActions) ? flow.userActions.filter((a) => typeof a === 'string') : [],
+                    assertionPatterns: assertionPatterns.length > 0 ? assertionPatterns : undefined,
                 };
                 allDecisions.push(decision);
             }

package/dist/esm/pipeline/stage2_coverage.js

@@ -43,13 +43,26 @@ export async function runCoverageStage(decisions, specIndex, context, testsRoot,
     for (const [familyId, familyDecisions] of byFamily) {
         // Gather relevant specs
         const specs = getSpecsForFamily(specIndex, familyId);
-        const specsWithContent = specs
-            .map((s) => {
+        // Two-tier approach: send all spec titles (compact), full content for top matches only
+        const allSpecSummaries = specs.map((s) => ({
+            relativePath: s.relativePath,
+            testTitles: s.testTitles,
+        }));
+        // Load full content with a total budget of 200K chars (~50K tokens) to avoid blowing context windows
+        const MAX_TOTAL_SPEC_CHARS = 200000;
+        let totalSpecChars = 0;
+        const specsWithContent = [];
+        for (const s of specs) {
+            if (specsWithContent.length >= 30)
+                break;
             const content = loadSpecFileContent(testsRoot, s.relativePath, maxSpecChars);
-            return content ? { relativePath: s.relativePath, content, testTitles: s.testTitles } : null;
-        })
-            .filter((s) => s !== null)
-            .slice(0, 15); // Limit to 15 specs per family to stay within token budget
+            if (!content)
+                continue;
+            if (totalSpecChars + content.length > MAX_TOTAL_SPEC_CHARS)
+                break;
+            totalSpecChars += content.length;
+            specsWithContent.push({ relativePath: s.relativePath, content, testTitles: s.testTitles });
+        }
         if (specsWithContent.length === 0) {
             // No specs to evaluate — mark all as create_spec
             for (const d of familyDecisions) {
@@ -70,10 +83,18 @@ export async function runCoverageStage(decisions, specIndex, context, testsRoot,
             evidence: d.evidence,
             priority: d.priority,
         }));
+        // Include titles-only summaries for specs beyond the content limit
+        const extraSummaries = allSpecSummaries
+            .slice(specsWithContent.length)
+            .map((s) => `  - ${s.relativePath}: ${s.testTitles.join(', ')}`)
+            .join('\n');
+        const extraContext = extraSummaries
+            ? `\nADDITIONAL SPECS (titles only, no content loaded):\n${extraSummaries}\n`
+            : '';
         const prompt = buildCoveragePrompt({
             flows,
             specs: specsWithContent,
-            contextBlock,
+            contextBlock: contextBlock + extraContext,
             profile: config.profile,
         });
         try {