@yasserkhanorg/e2e-agents 1.5.0 → 1.6.0

package/dist/esm/training/scanner.js

@@ -15,6 +15,50 @@ const SKIP_DIRS = new Set([
 ]);
 const TEST_EXTENSIONS = ['.spec.ts', '.test.ts', '.spec.js', '.test.js', '.spec.tsx', '.test.tsx'];
 const GO_TEST_SUFFIX = '_test.go';
+/**
+ * Test category directories that organize tests but aren't feature families.
+ * Test-only families matching these names are excluded.
+ */
+const TEST_CATEGORY_DIRS = new Set([
+    'specs', 'spec', 'accessibility', 'visual', 'smoke', 'regression',
+    'integration', 'functional', 'unit', 'e2e', 'performance', 'load',
+]);
+/**
+ * Structural directories that are code-organization concerns, not feature families.
+ * Discovered source dirs matching these names are excluded from family creation.
+ */
+const STRUCTURAL_DIRS = new Set([
+    'actions', 'client', 'components', 'hooks', 'i18n', 'packages',
+    'reducers', 'selectors', 'store', 'stores', 'tests', 'types',
+    'utils', 'helpers', 'lib', 'common', 'shared', 'constants',
+    'config', 'styles', 'sass', 'css', 'assets', 'images', 'fonts',
+    'middleware', 'contexts', 'providers', 'layouts', 'templates',
+]);
+/**
+ * Server Go files that are infrastructure / cross-cutting concerns,
+ * not feature-specific domains.  Matched after stripping _local/_store suffixes.
+ */
+const SERVER_INFRA_FILES = new Set([
+    'api', 'apitestlib', 'context', 'helpers', 'params', 'swagger',
+    'app', 'server', 'enterprise', 'product_service', 'security_update_check',
+    'store', 'adapters', 'errors', 'integrity', 'migrate', 'doc',
+    'main', 'init', 'cluster_discovery', 'web_conn', 'web_broadcast_hooks',
+    'manualtesting', 'testlib', 'router', 'handler', 'opentracing',
+    'platform', 'focalboard', 'playbooks', 'client4', 'model',
+    'manifest', 'permission', 'log', 'utils',
+]);
+/**
+ * Server tier directories to scan for Go domain files.
+ * Each tier represents a layer of the backend architecture.
+ */
+const SERVER_TIERS = [
+    'channels/api4',
+    'channels/app',
+    'channels/store/sqlstore',
+    'channels/web',
+    'channels/wsapi',
+    'public/model',
+];
 /** Type-safe includes check for readonly arrays */
 const includes = (arr, v) => arr.includes(v);
 function isSkipped(name) {
@@ -314,10 +358,273 @@ function detectFeatures(familyId, group, projectRoot) {
     }
     return features;
 }
-export function scanProject(projectRoot) {
+/**
+ * Discover families by walking the test directory tree at depth ≥ 2.
+ *
+ * This is the primary family discovery mechanism for projects where source
+ * code is organized by code type (components/, actions/) but tests are
+ * organized by feature (channels/drafts/, channels/search/).
+ *
+ * Each leaf test directory (containing spec files) at meaningful depth ≥ 2
+ * becomes a candidate family.  Top-level feature dirs (depth 1) are already
+ * discovered by the standard `discoverTestDirs` + `groupByFamily` pipeline.
+ */
+/**
+ * Normalize a Go filename into a family domain identifier.
+ * Strips _local, _store, trailing 's' (plurals), and normalizes casing.
+ */
+function normalizeServerDomain(baseName) {
+    let name = baseName;
+    // Strip common suffixes
+    name = name.replace(/_local$/, '');
+    name = name.replace(/_store$/, '');
+    // Skip very short names (e.g., single-letter files)
+    if (name.length < 3)
+        return null;
+    return normalizeId(name);
+}
+/**
+ * Given a domain name like "channel_bookmark", find its parent domain
+ * if a shorter prefix exists in the set (e.g., "channel").
+ * This groups related server files under a single family.
+ */
+function findParentDomain(name, allDomains) {
+    const parts = name.split('_');
+    // Try progressively shorter prefixes
+    for (let i = parts.length - 1; i >= 1; i--) {
+        const candidate = parts.slice(0, i).join('_');
+        if (allDomains.has(candidate) && candidate !== name) {
+            return candidate;
+        }
+    }
+    return name;
+}
+/**
+ * Discover families by scanning server Go source files.
+ *
+ * The backend follows a three-tier pattern:
+ *   api4/draft.go + app/draft.go + store/sqlstore/draft_store.go
+ *
+ * Related files are grouped under parent domains:
+ *   channel.go, channel_bookmark.go, channel_category.go → "channel" family
+ *
+ * Each domain becomes a candidate family with precise serverPaths.
+ */
+export function discoverServerDerivedFamilies(serverRoot) {
+    const resolved = resolve(serverRoot);
+    // First pass: collect all raw domain names across tiers
+    const allRawDomains = new Set();
+    // domain → tier → Set<file basenames>
+    const domainTierFiles = new Map();
+    function collectGoFile(entry, tierRelPath) {
+        if (!entry.endsWith('.go') || entry.endsWith('_test.go') || entry.startsWith('.'))
+            return;
+        const baseName = entry.replace('.go', '');
+        const domain = normalizeServerDomain(baseName);
+        if (!domain || SERVER_INFRA_FILES.has(domain))
+            return;
+        allRawDomains.add(domain);
+        if (!domainTierFiles.has(domain))
+            domainTierFiles.set(domain, new Map());
+        const tierMap = domainTierFiles.get(domain);
+        if (!tierMap.has(tierRelPath))
+            tierMap.set(tierRelPath, new Set());
+        tierMap.get(tierRelPath).add(baseName);
+    }
+    for (const tier of SERVER_TIERS) {
+        const tierPath = join(resolved, tier);
+        if (!existsSync(tierPath))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(tierPath);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            collectGoFile(entry, tier);
+            // Also check subdirectories (e.g., app/slashcommands/, app/users/)
+            const subPath = join(tierPath, entry);
+            try {
+                const stat = lstatSync(subPath);
+                if (stat.isDirectory() && !isSkipped(entry)) {
+                    const subEntries = readdirSync(subPath);
+                    for (const subEntry of subEntries) {
+                        collectGoFile(subEntry, `${tier}/${entry}`);
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    // Scan job directories — each subdirectory is a job type
+    const jobsPath = join(resolved, 'channels/jobs');
+    if (existsSync(jobsPath)) {
+        try {
+            for (const entry of readdirSync(jobsPath)) {
+                const jobPath = join(jobsPath, entry);
+                try {
+                    if (!lstatSync(jobPath).isDirectory() || isSkipped(entry))
+                        continue;
+                    const domain = normalizeId(entry);
+                    if (SERVER_INFRA_FILES.has(domain))
+                        continue;
+                    allRawDomains.add(domain);
+                    const jobFiles = readdirSync(jobPath);
+                    for (const jf of jobFiles) {
+                        if (jf.endsWith('.go') && !jf.endsWith('_test.go')) {
+                            if (!domainTierFiles.has(domain))
+                                domainTierFiles.set(domain, new Map());
+                            const tierMap = domainTierFiles.get(domain);
+                            const tierKey = `channels/jobs/${entry}`;
+                            if (!tierMap.has(tierKey))
+                                tierMap.set(tierKey, new Set());
+                            tierMap.get(tierKey).add(jf.replace('.go', ''));
+                        }
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Second pass: group child domains under parents
+    // e.g., channel_bookmark → channel, post_priority → post
+    // Track which top-level tiers each family touches for significance filtering.
+    const familyPaths = new Map();
+    const familyTiers = new Map();
+    for (const [domain, tierMap] of domainTierFiles) {
+        const parentDomain = findParentDomain(domain, allRawDomains);
+        if (!familyPaths.has(parentDomain))
+            familyPaths.set(parentDomain, new Set());
+        if (!familyTiers.has(parentDomain))
+            familyTiers.set(parentDomain, new Set());
+        const paths = familyPaths.get(parentDomain);
+        const tiers = familyTiers.get(parentDomain);
+        for (const [tierRelPath, fileNames] of tierMap) {
+            // Track the top-level tier (e.g., "channels/api4" from "channels/api4/slashcommands")
+            const topTier = tierRelPath.split('/').slice(0, 2).join('/');
+            tiers.add(topTier);
+            for (const baseName of fileNames) {
+                // Use directory-level glob to capture the file and related variants
+                paths.add(`server/${tierRelPath}/${baseName}*.go`);
+            }
+        }
+    }
+    // Build families from grouped domains.
+    // Only include server-only families that span ≥ 2 tiers (architecturally significant).
+    const families = [];
+    for (const [domain, paths] of familyPaths) {
+        if (paths.size === 0)
+            continue;
+        const tierCount = familyTiers.get(domain)?.size ?? 0;
+        if (tierCount < 2)
+            continue; // Skip single-tier domains (likely infrastructure)
+        families.push({
+            id: domain,
+            routes: [`/${domain.replace(/_/g, '-')}`],
+            webappPaths: [],
+            serverPaths: Array.from(paths),
+            specDirs: [],
+            cypressSpecDirs: [],
+            tags: [],
+            features: [],
+            routesGuessed: true,
+        });
+    }
+    return families;
+}
+export function discoverTestDerivedFamilies(testsRoot) {
+    const resolved = resolve(testsRoot);
+    const candidates = [];
+    function walk(dir, depth) {
+        if (depth > 8)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        const hasSpecs = entries.some((e) => TEST_EXTENSIONS.some((ext) => e.endsWith(ext)) || e.endsWith(GO_TEST_SUFFIX));
+        const subdirs = entries.filter((e) => {
+            if (isSkipped(e))
+                return false;
+            try {
+                const stat = lstatSync(join(dir, e));
+                return !stat.isSymbolicLink() && stat.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        const relPath = relative(resolved, dir).replace(/\\/g, '/');
+        const parts = relPath.split('/').filter(Boolean);
+        const meaningful = parts.filter((p) => !TEST_CATEGORY_DIRS.has(normalizeId(p)) && !isSkipped(p));
+        // Depth-2+ meaningful dirs with spec files → candidate families
+        if (meaningful.length >= 2 && hasSpecs) {
+            const leafId = normalizeId(meaningful[meaningful.length - 1]);
+            const parentId = normalizeId(meaningful[meaningful.length - 2]);
+            if (!STRUCTURAL_DIRS.has(leafId) && !TEST_CATEGORY_DIRS.has(leafId)) {
+                candidates.push({ dir, relPath, leafId, parentId });
+            }
+        }
+        for (const sub of subdirs) {
+            walk(join(dir, sub), depth + 1);
+        }
+    }
+    // Walk from standard test roots
+    const testRoots = ['tests', 'test', 'e2e-tests', 'e2e', 'specs', 'spec'];
+    for (const root of testRoots) {
+        const rootPath = join(resolved, root);
+        if (existsSync(rootPath)) {
+            walk(rootPath, 0);
+        }
+    }
+    // Detect leaf-name collisions across parents
+    const idCount = new Map();
+    for (const c of candidates) {
+        idCount.set(c.leafId, (idCount.get(c.leafId) || 0) + 1);
+    }
+    // Build families — prefix with parent when names collide
+    const familyMap = new Map();
+    for (const c of candidates) {
+        let familyId = c.leafId;
+        if ((idCount.get(c.leafId) || 0) > 1 && c.parentId) {
+            familyId = `${c.parentId}_${c.leafId}`;
+        }
+        if (!familyMap.has(familyId)) {
+            const specFiles = getSpecFiles(c.dir);
+            familyMap.set(familyId, {
+                id: familyId,
+                routes: [`/${familyId.replace(/_/g, '-')}`],
+                webappPaths: [],
+                serverPaths: [],
+                specDirs: [c.relPath + '/'],
+                cypressSpecDirs: [],
+                tags: extractTags(specFiles),
+                features: [],
+                routesGuessed: true,
+            });
+        }
+        else {
+            const existing = familyMap.get(familyId);
+            const specDir = c.relPath + '/';
+            if (!existing.specDirs.includes(specDir)) {
+                existing.specDirs.push(specDir);
+                existing.tags = [...new Set([...existing.tags, ...extractTags(getSpecFiles(c.dir))])];
+            }
+        }
+    }
+    return Array.from(familyMap.values());
+}
+export function scanProject(projectRoot, testsRoot, serverRoot) {
     const resolved = resolve(projectRoot);
+    const resolvedTestsRoot = testsRoot ? resolve(testsRoot) : resolved;
     const sourceDirs = discoverSourceDirs(resolved);
-    const testDirs = discoverTestDirs(resolved);
+    const testDirs = discoverTestDirs(resolvedTestsRoot);
     const allDirs = [...sourceDirs, ...testDirs];
     const groups = groupByFamily(allDirs);
     const families = [];
@@ -326,6 +633,13 @@ export function scanProject(projectRoot) {
         const hasTests = group.test.length > 0 || group.cypress.length > 0;
         if (!hasSrc && !hasTests)
             continue;
+        // Skip structural directories that are code-organization, not features.
+        // Only skip if they have source dirs but no corresponding test dirs.
+        if (STRUCTURAL_DIRS.has(familyId) && !hasTests)
+            continue;
+        // Skip test-only families that match broad test categories (not feature families).
+        if (!hasSrc && hasTests && TEST_CATEGORY_DIRS.has(familyId))
+            continue;
         const allSpecFiles = [];
         for (const td of [...group.test, ...group.cypress]) {
             allSpecFiles.push(...getSpecFiles(td.path));
@@ -343,6 +657,58 @@ export function scanProject(projectRoot) {
             routesGuessed: true,
         });
     }
+    // When a separate testsRoot is provided, discover families from test
+    // directory structure.  Projects with feature-organized tests but
+    // code-type-organized source benefit from this.
+    if (testsRoot) {
+        const testFamilies = discoverTestDerivedFamilies(resolvedTestsRoot);
+        const existingIds = new Set(families.map((f) => f.id));
+        for (const tf of testFamilies) {
+            if (existingIds.has(tf.id)) {
+                // Merge specDirs into existing family
+                const existing = families.find((f) => f.id === tf.id);
+                for (const sd of tf.specDirs) {
+                    if (!existing.specDirs.includes(sd)) {
+                        existing.specDirs.push(sd);
+                    }
+                }
+                existing.tags = [...new Set([...existing.tags, ...tf.tags])];
+            }
+            else {
+                families.push(tf);
+                existingIds.add(tf.id);
+            }
+        }
+    }
+    // When a separate serverRoot is provided, discover families from Go source
+    // filenames across the three-tier backend (api4, app, store).
+    if (serverRoot) {
+        const serverFamilies = discoverServerDerivedFamilies(resolve(serverRoot));
+        const existingIds = new Set(families.map((f) => f.id));
+        for (const sf of serverFamilies) {
+            // Try exact match, then singular/plural variants
+            let target = families.find((f) => f.id === sf.id);
+            if (!target && !sf.id.endsWith('s')) {
+                target = families.find((f) => f.id === sf.id + 's');
+            }
+            if (!target && sf.id.endsWith('s')) {
+                target = families.find((f) => f.id === sf.id.slice(0, -1));
+            }
+            if (target) {
+                // Merge serverPaths into existing family
+                for (const sp of sf.serverPaths) {
+                    if (!target.serverPaths.includes(sp)) {
+                        target.serverPaths.push(sp);
+                    }
+                }
+            }
+            else {
+                // New server-only family
+                families.push(sf);
+                existingIds.add(sf.id);
+            }
+        }
+    }
     const familyIds = new Set(families.map((f) => f.id));
     const unmatchedSourceDirs = sourceDirs.filter((d) => !familyIds.has(normalizeId(d.familyHint)));
     const unmatchedTestDirs = testDirs.filter((d) => !familyIds.has(normalizeId(d.familyHint)));

package/dist/training/enricher.d.ts

@@ -8,8 +8,10 @@ export interface EnrichedEntry {
     routes?: string[];
     pageObjects?: string[];
     components?: string[];
+    webappPaths?: string[];
+    serverPaths?: string[];
 }
 export declare function validateEntries(parsed: unknown[]): EnrichedEntry[];
 export declare function parseEnrichResponse(response: string): EnrichedEntry[];
-export declare function enrichFamilies(families: RouteFamily[], scanned: ScannedFamily[], projectRoot: string, provider: LLMProvider, budgetUSD: number): Promise<EnrichmentResult>;
+export declare function enrichFamilies(families: RouteFamily[], scanned: ScannedFamily[], projectRoot: string, provider: LLMProvider, budgetUSD: number, testsRoot?: string): Promise<EnrichmentResult>;
 //# sourceMappingURL=enricher.d.ts.map

package/dist/training/enricher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enricher.d.ts","sourceRoot":"","sources":["../../src/training/enricher.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gCAAgC,CAAC;AAGhE,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAmIhE,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,aAAa,EAAE,CAiBlE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,EAAE,CAwBrE;AA2BD,wBAAsB,cAAc,CAChC,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,aAAa,EAAE,EACxB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAgF3B"}
+{"version":3,"file":"enricher.d.ts","sourceRoot":"","sources":["../../src/training/enricher.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gCAAgC,CAAC;AAGhE,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAkLhE,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,aAAa,EAAE,CAmBlE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,EAAE,CAwBrE;AAkCD,wBAAsB,cAAc,CAChC,QAAQ,EAAE,WAAW,EAAE,EACvB,OAAO,EAAE,aAAa,EAAE,EACxB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAgF3B"}

package/dist/training/enricher.js

@@ -64,9 +64,47 @@ function sampleFiles(dir, maxFiles) {
     walk(dir);
     return files;
 }
-function buildEnrichPrompt(families, projectRoot) {
+/**
+ * Build a shallow directory listing of the source tree (depth 2-3) so the LLM
+ * can suggest accurate webappPaths / serverPaths for test-derived families.
+ */
+function getSourceTreeListing(projectRoot, maxDepth = 3) {
+    const lines = [];
+    function walk(dir, depth, prefix) {
+        if (depth > maxDepth || lines.length > 200)
+            return;
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(dir).sort();
+        }
+        catch {
+            return;
+        }
+        const dirs = entries.filter((e) => {
+            if (e.startsWith('.') || SKIP_DIRS.has(e))
+                return false;
+            try {
+                const stat = (0, fs_1.lstatSync)((0, path_1.join)(dir, e));
+                return !stat.isSymbolicLink() && stat.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        for (const d of dirs) {
+            lines.push(`${prefix}${d}/`);
+            walk((0, path_1.join)(dir, d), depth + 1, prefix + '  ');
+        }
+    }
+    walk((0, path_1.resolve)(projectRoot), 0, '');
+    return lines.join('\n');
+}
+function buildEnrichPrompt(families, projectRoot, testsRoot) {
     const sections = [];
+    const hasTestOnlyFamilies = families.some((f) => f.webappPaths.length === 0 && f.serverPaths.length === 0);
+    const resolvedTestsRoot = testsRoot ? (0, path_1.resolve)(testsRoot) : (0, path_1.resolve)(projectRoot);
     for (const family of families) {
+        const isTestOnly = family.webappPaths.length === 0 && family.serverPaths.length === 0;
         const allDirs = [
             ...family.webappPaths.map((p) => p.replace(/\/?\*.*$/, '')),
             ...family.serverPaths.map((p) => p.replace(/\/?\*.*$/, '')),
@@ -80,10 +118,19 @@ function buildEnrichPrompt(families, projectRoot) {
             if (samples.length >= MAX_FILES_PER_FAMILY)
                 break;
         }
+        // For test-only families, sample the test files themselves for richer context
+        if (isTestOnly) {
+            for (const specDir of family.specDirs) {
+                if (samples.length >= MAX_FILES_PER_FAMILY)
+                    break;
+                const fullDir = (0, path_1.join)(resolvedTestsRoot, specDir);
+                samples.push(...sampleFiles(fullDir, MAX_FILES_PER_FAMILY - samples.length));
+            }
+        }
         // Sample spec descriptions
         const specSamples = [];
         for (const specDir of family.specDirs) {
-            const fullDir = (0, path_1.join)((0, path_1.resolve)(projectRoot), specDir);
+            const fullDir = (0, path_1.join)(resolvedTestsRoot, specDir);
             const specFiles = sampleFiles(fullDir, 5);
             for (const sf of specFiles) {
                 const matches = sf.content.match(/(?:test|it|describe)\s*\(\s*['"`]([^'"`]+)/g);
@@ -92,7 +139,7 @@ function buildEnrichPrompt(families, projectRoot) {
                 }
             }
         }
-        sections.push(`## Family: ${family.id}
+        sections.push(`## Family: ${family.id}${isTestOnly ? ' [TEST-ONLY — needs webappPaths/serverPaths]' : ''}
 Routes (guessed): ${JSON.stringify(family.routes)}
 Webapp paths: ${JSON.stringify(family.webappPaths)}
 Server paths: ${JSON.stringify(family.serverPaths)}
@@ -107,6 +154,10 @@ Test descriptions:
 ${specSamples.length > 0 ? specSamples.map((d) => `- ${d}`).join('\n') : '(none found)'}
 `);
     }
+    // Include source tree listing when we have test-only families
+    const sourceTreeSection = hasTestOnlyFamilies
+        ? `\n## Source Directory Structure\nUse this to suggest accurate webappPaths and serverPaths for test-only families:\n\`\`\`\n${getSourceTreeListing(projectRoot)}\n\`\`\`\n`
+        : '';
     return `You are analyzing a codebase to enrich route-family definitions for an E2E test impact analysis tool.
 
 For each family below, provide:
@@ -115,6 +166,8 @@ For each family below, provide:
 3. **routes**: Improved URL patterns (e.g., "/{team}/channels/{channel}" instead of "/channels")
 4. **pageObjects**: Array of page object class names found in the code
 5. **components**: Array of UI component names relevant to this family
+6. **webappPaths**: Array of glob patterns for frontend source directories (e.g., "src/components/drafts/**"). REQUIRED for families marked [TEST-ONLY].
+7. **serverPaths**: Array of glob patterns for backend source directories. REQUIRED for families marked [TEST-ONLY].
 
 Respond in JSON format:
 \`\`\`json
@@ -125,11 +178,13 @@ Respond in JSON format:
     "userFlows": ["Flow name 1", "Flow name 2"],
     "routes": ["/improved/route/{param}"],
     "pageObjects": ["PageName"],
-    "components": ["ComponentName"]
+    "components": ["ComponentName"],
+    "webappPaths": ["src/components/feature_name/**"],
+    "serverPaths": ["server/channels/api4/feature.go"]
   }
 ]
 \`\`\`
-
+${sourceTreeSection}
 ${sections.join('\n---\n')}`;
 }
 function validateEntries(parsed) {
@@ -148,6 +203,8 @@ function validateEntries(parsed) {
         userFlows: filterStrings(entry.userFlows, 500),
         pageObjects: filterStrings(entry.pageObjects, 200),
         components: filterStrings(entry.components, 200),
+        webappPaths: filterStrings(entry.webappPaths, 300),
+        serverPaths: filterStrings(entry.serverPaths, 300),
     }));
 }
 function parseEnrichResponse(response) {
@@ -197,9 +254,16 @@ function applyEnrichment(family, enriched) {
     if (enriched.components && (!family.components || family.components.length === 0)) {
         result.components = enriched.components;
     }
+    // Only fill source paths when the family has none (test-derived families)
+    if (enriched.webappPaths && (!family.webappPaths || family.webappPaths.length === 0)) {
+        result.webappPaths = enriched.webappPaths;
+    }
+    if (enriched.serverPaths && (!family.serverPaths || family.serverPaths.length === 0)) {
+        result.serverPaths = enriched.serverPaths;
+    }
     return result;
 }
-async function enrichFamilies(families, scanned, projectRoot, provider, budgetUSD) {
+async function enrichFamilies(families, scanned, projectRoot, provider, budgetUSD, testsRoot) {
     const scannedMap = new Map(scanned.map((s) => [s.id, s]));
     const enriched = [];
     let totalTokens = 0;
@@ -223,7 +287,7 @@ async function enrichFamilies(families, scanned, projectRoot, provider, budgetUS
             enriched.push(...chunk);
             continue;
         }
-        let prompt = buildEnrichPrompt(scannedChunk, projectRoot);
+        let prompt = buildEnrichPrompt(scannedChunk, projectRoot, testsRoot);
         if (prompt.length > MAX_PROMPT_CHARS) {
             // Truncate at the last complete section boundary to avoid malformed input
             const lastSectionEnd = prompt.lastIndexOf('\n---\n', MAX_PROMPT_CHARS);

package/dist/training/merger.d.ts

@@ -1,5 +1,15 @@
 import type { RouteFamilyManifest } from '../knowledge/route_families.js';
 import type { MergeResult, ScannedFamily } from './types.js';
 export declare function mergeFamilies(existing: RouteFamilyManifest | null, scanned: ScannedFamily[]): MergeResult;
-export declare function detectStaleFamilies(manifest: RouteFamilyManifest, projectRoot: string): string[];
+/**
+ * Detect families whose paths no longer exist on disk.
+ *
+ * Paths in the manifest may be relative to different roots:
+ * - webappPaths / serverPaths are typically relative to the repo root
+ * - specDirs may be relative to the tests root
+ *
+ * We try each pattern against all provided roots (and the git repo root
+ * if discoverable) to avoid false positives from path-prefix mismatches.
+ */
+export declare function detectStaleFamilies(manifest: RouteFamilyManifest, projectRoot: string, testsRoot?: string): string[];
 //# sourceMappingURL=merger.d.ts.map

package/dist/training/merger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merger.d.ts","sourceRoot":"","sources":["../../src/training/merger.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAc,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAGrF,OAAO,KAAK,EAAC,WAAW,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAqE3D,wBAAgB,aAAa,CACzB,QAAQ,EAAE,mBAAmB,GAAG,IAAI,EACpC,OAAO,EAAE,aAAa,EAAE,GACzB,WAAW,CAyCb;AAED,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,mBAAmB,EAC7B,WAAW,EAAE,MAAM,GACpB,MAAM,EAAE,CA8BV"}
+{"version":3,"file":"merger.d.ts","sourceRoot":"","sources":["../../src/training/merger.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAc,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAGrF,OAAO,KAAK,EAAC,WAAW,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAkF3D,wBAAgB,aAAa,CACzB,QAAQ,EAAE,mBAAmB,GAAG,IAAI,EACpC,OAAO,EAAE,aAAa,EAAE,GACzB,WAAW,CA+Cb;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,mBAAmB,EAC7B,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACnB,MAAM,EAAE,CA6DV"}