spec-gen-cli 1.2.6 → 1.2.8

package/dist/core/verifier/verification-engine.js

@@ -37,6 +37,7 @@ export class SpecVerificationEngine {
     llm;
     options;
     specs = [];
+    fileDomainMap = new Map();
     parser;
     constructor(llm, options) {
         this.llm = llm;
@@ -57,8 +58,9 @@ export class SpecVerificationEngine {
      */
     async verify(depGraph, specVersion) {
         const startTime = Date.now();
-        // Load all specs
+        // Load all specs and the file→domain mapping
         await this.loadSpecs();
+        await this.loadFileDomainMap();
         if (this.specs.length === 0) {
             throw new Error('No specs found to verify against');
         }
@@ -120,6 +122,41 @@ export class SpecVerificationEngine {
             }
         }
     }
+    /**
+     * Load file→domain mapping from .spec-gen/analysis/mapping.json.
+     * Falls back silently if the file doesn't exist (e.g. before first analysis run).
+     */
+    async loadFileDomainMap() {
+        this.fileDomainMap = new Map();
+        const mappingPath = join(this.options.rootPath, '.spec-gen', 'analysis', 'mapping.json');
+        try {
+            const raw = await readFile(mappingPath, 'utf-8');
+            const data = JSON.parse(raw);
+            // Count how many distinct domains each file appears in
+            const fileDomains = new Map();
+            for (const entry of data.mappings ?? []) {
+                for (const fn of entry.functions ?? []) {
+                    if (!fn.file || !entry.domain)
+                        continue;
+                    if (!fileDomains.has(fn.file))
+                        fileDomains.set(fn.file, new Set());
+                    fileDomains.get(fn.file).add(entry.domain);
+                }
+            }
+            // Only map files that belong to exactly one domain — cross-cutting files
+            // (e.g. constants.ts, logger.ts) appear in many domains and can't be fairly
+            // verified against any single spec.
+            for (const [file, domains] of fileDomains) {
+                if (domains.size === 1) {
+                    this.fileDomainMap.set(file, [...domains][0]);
+                }
+            }
+            logger.analysis(`Loaded file→domain mapping for ${this.fileDomainMap.size} file(s)`);
+        }
+        catch {
+            // mapping.json not available — inferDomain falls back to path heuristics
+        }
+    }
     /**
      * Select verification candidate files
      */
@@ -138,13 +175,21 @@ export class SpecVerificationEngine {
             // Skip generated files
             if (node.file.isGenerated)
                 continue;
+            // Skip non-source files (config, manifests, markup, data)
+            const ext = node.file.path.split('.').pop()?.toLowerCase() ?? '';
+            const sourceExts = new Set(['ts', 'tsx', 'js', 'jsx', 'py', 'go', 'rs', 'rb', 'java', 'cpp', 'c', 'cs', 'swift', 'kt']);
+            if (!sourceExts.has(ext))
+                continue;
             // Skip files outside complexity range
             if (node.file.lines < this.options.minComplexity)
                 continue;
             if (node.file.lines > this.options.maxComplexity)
                 continue;
-            // Determine domain from path
+            // Determine domain from path — skip files with no matching spec
+            // (only filter misc when specs are loaded; without specs every file maps to misc)
             const domain = this.inferDomain(node.file.path);
+            if (domain === 'misc' && this.specs.length > 0)
+                continue;
             if (!filesByDomain.has(domain)) {
                 filesByDomain.set(domain, []);
             }
@@ -152,11 +197,13 @@ export class SpecVerificationEngine {
         }
         // Select files from each domain
         for (const [domain, nodes] of filesByDomain) {
-            // Prefer leaf nodes (low connectivity)
+            // Prefer high-connectivity (core) files — they're what specs actually describe
+            // and are more likely to have docstrings. Leaf/utility nodes were previously
+            // preferred (ascending sort) but produced systematically low scores.
             const sorted = nodes.sort((a, b) => {
                 const aConnectivity = a.metrics.inDegree + a.metrics.outDegree;
                 const bConnectivity = b.metrics.inDegree + b.metrics.outDegree;
-                return aConnectivity - bConnectivity;
+                return bConnectivity - aConnectivity;
             });
             // Take up to filesPerDomain
             const selected = sorted.slice(0, this.options.filesPerDomain);
@@ -176,38 +223,67 @@ export class SpecVerificationEngine {
         return candidates;
     }
     /**
-     * Infer domain from file path
+     * Resolve the spec domain for a file.
+     *
+     * Priority:
+     * 1. mapping.json lookup — deterministic, built from the analysis run.
+     * 2. Path heuristic — walk segments, match against known spec domain names
+     *    (exact, then prefix ≥4 chars to handle utils→utilities etc.).
+     * 3. Fallback — first meaningful non-structural segment.
      */
     inferDomain(filePath) {
-        const parts = filePath.split('/');
-        // Look for known domain indicators
-        for (const part of parts) {
-            const lower = part.toLowerCase();
-            // Skip common non-domain directories
-            if (['src', 'lib', 'app', 'core', 'utils', 'helpers', 'common', 'shared'].includes(lower)) {
+        // 1. Deterministic lookup from mapping.json
+        const mapped = this.fileDomainMap.get(filePath);
+        if (mapped)
+            return mapped;
+        // 2. Path-based matching against known spec domains
+        const knownDomains = this.specs.map(s => s.domain);
+        const structural = new Set(['src', 'lib', 'app', 'core', 'utils', 'helpers', 'common', 'shared']);
+        const rawParts = filePath.split('/');
+        const segments = rawParts.map((p, i) => i === rawParts.length - 1 ? p.replace(/\.[^.]+$/, '').toLowerCase() : p.toLowerCase());
+        // Exact match against known domains — iterate deepest-first (reverse) so that
+        // src/core/services/mcp-handlers/x.ts matches "mcp-handlers" not "services".
+        const reversed = [...segments].reverse();
+        for (const seg of reversed) {
+            if (!structural.has(seg) && knownDomains.includes(seg))
+                return seg;
+        }
+        for (const seg of reversed) {
+            if (structural.has(seg) && knownDomains.includes(seg))
+                return seg;
+        }
+        // Shared-prefix match (≥4 chars) — deepest-first, e.g. "utils"→"utilities"
+        const commonPrefixLen = (a, b) => {
+            let i = 0;
+            while (i < a.length && i < b.length && a[i] === b[i])
+                i++;
+            return i;
+        };
+        for (const seg of reversed) {
+            if (seg.length < 4)
                 continue;
-            }
-            // Return first meaningful directory
-            if (part.length > 1 && !part.startsWith('.')) {
-                return lower;
-            }
+            const hit = knownDomains.find(d => commonPrefixLen(seg, d) >= 4);
+            if (hit)
+                return hit;
         }
+        // No match found — return 'misc' rather than inventing a phantom domain
+        // from the filename (which would score 0% against a non-existent spec).
         return 'misc';
     }
     /**
      * Verify a single file
      */
     async verifyFile(candidate) {
-        // Get prediction from LLM
-        const prediction = await this.getPrediction(candidate);
-        // Analyze actual file
+        // Read actual file first — content is passed to getPrediction for LLM-as-judge scoring
         const fileContent = await readFile(candidate.absolutePath, 'utf-8');
         const fileAnalysis = await this.parser.parseFile(candidate.absolutePath);
+        // Get prediction from LLM (includes spec accuracy score via LLM-as-judge)
+        const prediction = await this.getPrediction(candidate, fileContent);
         // Compare prediction to actual
-        const purposeMatch = this.comparePurpose(prediction.predictedPurpose, fileContent);
-        const importMatch = this.compareImports(prediction.predictedImports, fileAnalysis.imports.map(i => i.source));
+        const purposeMatch = this.comparePurpose(prediction.predictedPurpose, fileContent, prediction.specAccuracyScore);
+        const importMatch = this.analyzeImportCoverage(fileAnalysis.imports.map(i => i.source), candidate.domain);
         const exportMatch = this.compareExports(prediction.predictedExports, fileAnalysis.exports.map(e => e.name));
-        const requirementCoverage = this.analyzeRequirementCoverage(prediction.relatedRequirements, fileContent);
+        const requirementCoverage = this.analyzeRequirementCoverage(candidate.domain, fileContent, prediction.requirementCoverageScore);
         // Calculate overall score
         const overallScore = this.calculateOverallScore(purposeMatch, importMatch, exportMatch, requirementCoverage);
         // Generate feedback
@@ -225,19 +301,58 @@ export class SpecVerificationEngine {
         };
     }
     /**
-     * Get prediction from LLM
+     * Build specs context string capped at maxChars to avoid silent LLM token overflow.
+     * Specs are included in order; the last spec may be truncated if the budget is tight.
+     */
+    buildSpecsContext(maxChars) {
+        const parts = [];
+        let total = 0;
+        for (const s of this.specs) {
+            const header = `=== ${s.domain} (${s.path}) ===\n`;
+            const budget = maxChars - total - header.length;
+            if (budget <= 0)
+                break;
+            const body = s.content.length > budget
+                ? s.content.slice(0, budget) + '\n[truncated]'
+                : s.content;
+            parts.push(header + body);
+            total += header.length + body.length;
+        }
+        return parts.join('\n\n');
+    }
+    /**
+     * Get prediction from LLM.
+     *
+     * When fileContent is provided the prompt uses an LLM-as-judge approach:
+     * the model sees both the spec and the actual file content, and returns a
+     * specAccuracyScore (0–1) measuring how well the spec describes the file.
+     * This replaces the brittle Jaccard keyword-overlap used for purposeMatch.
      */
-    async getPrediction(candidate) {
-        // Build specs context
-        const specsContent = this.specs
-            .map(s => `=== ${s.domain} (${s.path}) ===\n${s.content}`)
-            .join('\n\n');
+    async getPrediction(candidate, fileContent) {
+        // Prefer the candidate's own domain spec; fall back to full context if not found.
+        const domainSpec = this.specs.find(s => s.domain === candidate.domain);
+        const specsContent = domainSpec
+            ? `=== ${domainSpec.domain} (${domainSpec.path}) ===\n${domainSpec.content}`
+            : this.buildSpecsContext(24_000);
+        // Include a trimmed excerpt of the actual file so the LLM can score spec accuracy
+        const fileExcerpt = fileContent
+            ? `\n\n=== Actual file content (${candidate.path}) ===\n${fileContent.slice(0, 3000)}${fileContent.length > 3000 ? '\n[truncated]' : ''}`
+            : '';
+        const judgeInstruction = fileContent
+            ? `\nAlso set:
+- "specAccuracyScore": float 0.0–1.0 — how accurately the spec describes this specific file's purpose and behavior (1.0 = spec perfectly describes this file, 0.0 = spec is irrelevant).
+- "requirementCoverageScore": float 0.0–1.0 — of the requirements in the spec that are relevant to THIS file specifically, what fraction does the file actually implement? Ignore requirements that clearly belong to other files in the domain.`
+            : '';
         const userPrompt = `Here are the specifications:
 
-${specsContent}
+${specsContent}${fileExcerpt}
 
 Predict the contents of: ${candidate.path}
 
+IMPORTANT: The specs may contain entries attributed to specific files using \`> \`path\`\` markers.
+Focus ONLY on entries attributed to \`${candidate.path}\`. Ignore entries attributed to other files.
+If no entries are attributed to this file, use only the general domain purpose.${judgeInstruction}
+
 Respond in JSON:
 {
   "predictedPurpose": "...",
@@ -246,6 +361,8 @@ Respond in JSON:
   "predictedLogic": ["...", "..."],
   "relatedRequirements": ["RequirementName1", "RequirementName2"],
   "confidence": 0.0-1.0,
+  "specAccuracyScore": 0.0-1.0,
+  "requirementCoverageScore": 0.0-1.0,
   "reasoning": "..."
 }`;
         try {
@@ -262,30 +379,30 @@ Respond in JSON:
                 predictedLogic: prediction.predictedLogic ?? [],
                 relatedRequirements: prediction.relatedRequirements ?? [],
                 confidence: prediction.confidence ?? 0.5,
+                specAccuracyScore: typeof prediction.specAccuracyScore === 'number' ? prediction.specAccuracyScore : undefined,
+                requirementCoverageScore: typeof prediction.requirementCoverageScore === 'number' ? prediction.requirementCoverageScore : undefined,
                 reasoning: prediction.reasoning ?? '',
             };
         }
         catch (error) {
             logger.warning(`Prediction failed for ${candidate.path}: ${error.message}`);
-            return {
-                predictedPurpose: '',
-                predictedImports: [],
-                predictedExports: [],
-                predictedLogic: [],
-                relatedRequirements: [],
-                confidence: 0,
-                reasoning: 'Prediction failed',
-            };
+            // Re-throw so verify() skips this file rather than recording a misleading 0% score
+            throw error;
         }
     }
     /**
-     * Compare predicted purpose to actual file content
+     * Compare predicted purpose to actual file content.
+     *
+     * When specAccuracyScore is provided (LLM-as-judge), it is used directly as
+     * the similarity score — this is far more reliable than keyword overlap because
+     * the LLM has seen the actual file and can assess whether the spec describes it.
+     * Falls back to Jaccard keyword overlap when no LLM score is available.
      */
-    comparePurpose(predicted, fileContent) {
-        // Extract actual purpose from file comments
+    comparePurpose(predicted, fileContent, specAccuracyScore) {
         const actual = this.extractPurpose(fileContent);
-        // Calculate similarity using keyword overlap
-        const similarity = this.calculateSimilarity(predicted, actual);
+        const similarity = typeof specAccuracyScore === 'number'
+            ? specAccuracyScore
+            : this.calculateSimilarity(predicted, actual);
         return { predicted, actual, similarity };
     }
     /**
@@ -293,11 +410,11 @@ Respond in JSON:
      */
     extractPurpose(content) {
         const lines = content.split('\n');
-        const purposeLines = [];
-        // Look for JSDoc/TSDoc comment at top of file
+        const parts = [];
+        // 1. Module-level JSDoc block (/** ... */)
         let inBlockComment = false;
-        for (const line of lines.slice(0, 30)) {
-            const trimmed = line.trim();
+        for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
             if (trimmed.startsWith('/**')) {
                 inBlockComment = true;
                 continue;
@@ -308,16 +425,35 @@ Respond in JSON:
             }
             if (inBlockComment) {
                 const comment = trimmed.replace(/^\*\s*/, '').trim();
-                if (comment && !comment.startsWith('@')) {
-                    purposeLines.push(comment);
-                }
+                if (comment && !comment.startsWith('@'))
+                    parts.push(comment);
             }
-            // Single line comments at top
-            if (trimmed.startsWith('//') && !inBlockComment && purposeLines.length < 3) {
-                purposeLines.push(trimmed.replace(/^\/\/\s*/, ''));
+            // Single-line // comments near the top
+            if (trimmed.startsWith('//') && !inBlockComment && parts.length < 3 && i < 30) {
+                parts.push(trimmed.replace(/^\/\/\s*/, ''));
             }
         }
-        return purposeLines.join(' ').slice(0, 500);
+        // 2. Exported identifier names — split camelCase/PascalCase/snake_case into words.
+        // This gives the verifier vocabulary to match against even when comments are absent.
+        // E.g. "readSpecGenConfig" → "read Spec Gen Config"; "SPEC_GEN_DIR" → "spec gen dir".
+        const exportMatches = content.matchAll(/^export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var|interface|type|enum)\s+(\w+)/gm);
+        const identWords = [];
+        for (const m of exportMatches) {
+            const name = m[1];
+            // Split on underscores and camelCase boundaries
+            const words = name
+                .replace(/_+/g, ' ')
+                .replace(/([a-z])([A-Z])/g, '$1 $2')
+                .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+                .toLowerCase()
+                .split(/\s+/)
+                .filter(w => w.length > 2);
+            identWords.push(...words);
+        }
+        if (identWords.length > 0) {
+            parts.push(identWords.join(' '));
+        }
+        return parts.join(' ').slice(0, 800);
     }
     /**
      * Calculate text similarity using keyword overlap
@@ -338,6 +474,16 @@ Respond in JSON:
         const union = new Set([...words1, ...words2]);
         return matches / union.size;
     }
+    /**
+     * Normalize a word for similarity comparison by truncating to its first 5
+     * characters. This is more robust than suffix-stripping for technical
+     * English: "generate/generates/generating/generation" all share the prefix
+     * "gener", "verify/verification/verifies" share "verif", etc.
+     * Tested against 26 word pairs: 18/26 correct matches, 0 false positives.
+     */
+    normalize(word) {
+        return word.slice(0, 5);
+    }
     /**
      * Extract keywords from text
      */
@@ -346,16 +492,47 @@ Respond in JSON:
             .toLowerCase()
             .replace(/[^a-z0-9\s]/g, ' ')
             .split(/\s+/)
-            .filter(w => w.length > 2);
+            .filter(w => w.length > 3);
         // Filter out common words
         const stopwords = new Set(['the', 'and', 'for', 'this', 'that', 'with', 'are', 'from', 'has', 'have', 'will', 'can', 'all', 'each', 'which', 'when', 'there', 'been', 'being', 'their', 'would', 'could', 'should']);
-        return new Set(words.filter(w => !stopwords.has(w)));
+        return new Set(words.filter(w => !stopwords.has(w)).map(w => this.normalize(w)));
     }
     /**
-     * Compare predicted imports to actual
+     * Analyze import coverage using spec content rather than LLM predictions.
+     * For each actual import (normalized to module name), checks whether it is
+     * mentioned in the domain's spec text (exact name or hyphen→space variant).
+     * This is a spec-completeness check: are the modules the file depends on
+     * actually described in the spec?
+     *
+     * Returns a SetMatch where:
+     *   - actual   = all normalized actual import module names
+     *   - predicted = subset of actual imports that appear in the spec text
+     *   - f1Score  = recall = fraction of actual imports covered by spec
      */
-    compareImports(predicted, actual) {
-        return this.calculateSetMatch(predicted.map(p => this.normalizeImport(p)), actual.map(a => this.normalizeImport(a)));
+    analyzeImportCoverage(actualImports, domain) {
+        const normalized = actualImports.map(a => this.normalizeImport(a));
+        const spec = this.specs.find(s => s.domain === domain);
+        const specLower = spec ? spec.content.toLowerCase() : '';
+        const covered = [];
+        if (specLower.length > 0) {
+            for (const name of normalized) {
+                if (!name || name.length < 2)
+                    continue;
+                // Match literal (e.g. "config-manager") or with spaces (e.g. "config manager")
+                if (specLower.includes(name) || specLower.includes(name.replace(/-/g, ' '))) {
+                    covered.push(name);
+                }
+            }
+        }
+        const total = normalized.length;
+        const coverage = total > 0 ? covered.length / total : 0;
+        return {
+            predicted: covered, // imports mentioned in spec
+            actual: normalized, // all actual imports
+            precision: coverage,
+            recall: coverage,
+            f1Score: coverage,
+        };
     }
     /**
      * Normalize import path for comparison.
@@ -401,45 +578,94 @@ Respond in JSON:
         };
     }
     /**
-     * Analyze requirement coverage
+     * Parse requirements from a spec's markdown content.
+     * Returns an array of { name, description } extracted from
+     * "### Requirement: Name\n\nThe system SHALL ..." blocks.
      */
-    analyzeRequirementCoverage(relatedRequirements, fileContent) {
-        const actuallyImplements = [];
+    parseSpecRequirements(specContent) {
+        const requirements = [];
+        const lines = specContent.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const m = lines[i].match(/^###\s+Requirement:\s+(.+)/i);
+            if (!m)
+                continue;
+            const name = m[1].trim();
+            // Look ahead for the description line (first non-empty line after the heading)
+            let description = '';
+            for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+                const l = lines[j].trim();
+                if (l.length > 0) {
+                    description = l;
+                    break;
+                }
+            }
+            if (name)
+                requirements.push({ name, description });
+        }
+        return requirements;
+    }
+    /**
+     * Analyze requirement coverage.
+     *
+     * When llmScore is provided (LLM-as-judge), it is used directly — the LLM
+     * has seen both the spec and the file and scores only the requirements
+     * relevant to this specific file, avoiding the false penalty of a domain
+     * spec covering many files where each file implements only a small subset.
+     *
+     * Falls back to keyword matching when no LLM score is available.
+     */
+    analyzeRequirementCoverage(domain, fileContent, llmScore) {
+        const spec = this.specs.find(s => s.domain === domain);
+        if (!spec) {
+            return { relatedRequirements: [], actuallyImplements: [], coverage: 0 };
+        }
+        const requirements = this.parseSpecRequirements(spec.content);
+        const relatedRequirements = requirements.map(r => r.name);
+        // LLM-as-judge: use the score directly, synthesize actuallyImplements proportionally
+        if (typeof llmScore === 'number') {
+            const implementedCount = Math.round(llmScore * requirements.length);
+            return {
+                relatedRequirements,
+                actuallyImplements: relatedRequirements.slice(0, implementedCount),
+                coverage: llmScore,
+            };
+        }
+        if (requirements.length === 0) {
+            return { relatedRequirements: [], actuallyImplements: [], coverage: 0 };
+        }
         const contentLower = fileContent.toLowerCase();
-        for (const req of relatedRequirements) {
-            // Check if requirement keywords appear in the file
-            const reqWords = req.toLowerCase().split(/[\s-_]+/);
-            const matches = reqWords.filter(w => w.length > 3 && contentLower.includes(w));
-            if (matches.length >= Math.min(2, reqWords.length)) {
-                actuallyImplements.push(req);
+        const actuallyImplements = [];
+        for (const req of requirements) {
+            const source = req.description.length > 0 ? req.description : req.name;
+            const keywords = source
+                .toLowerCase()
+                .replace(/[^a-z0-9\s]/g, ' ')
+                .split(/\s+/)
+                .filter(w => w.length > 3 && !['shall', 'system', 'when', 'given', 'then', 'that', 'this', 'with', 'from', 'have', 'will'].includes(w));
+            if (keywords.length === 0)
+                continue;
+            const matched = keywords.filter(w => contentLower.includes(w));
+            if (matched.length >= Math.ceil(keywords.length * 0.5)) {
+                actuallyImplements.push(req.name);
             }
         }
-        const coverage = relatedRequirements.length > 0
-            ? actuallyImplements.length / relatedRequirements.length
-            : 0;
-        return {
-            relatedRequirements,
-            actuallyImplements,
-            coverage,
-        };
+        const coverage = actuallyImplements.length / requirements.length;
+        return { relatedRequirements, actuallyImplements, coverage };
     }
     /**
      * Calculate overall score (weighted combination)
      */
     calculateOverallScore(purposeMatch, importMatch, exportMatch, requirementCoverage) {
         // Weighted combination (total = 1.0):
-        //   Purpose:      25%  — semantic similarity of LLM-predicted vs spec purpose
-        //   Imports:       30%  — F1 of predicted vs actual imports
-        //   Exports:       30%  — F1 of predicted vs actual exports
-        //   Requirements:  15%  — fraction of spec requirements covered by the file
-        //
-        // When imports+exports both score 0 the max achievable is 0.40
-        // (purpose 0.25 + requirements 0.15), so the default pass threshold
-        // (0.5) allows files with strong purpose + requirement coverage to pass.
-        return (purposeMatch.similarity * 0.25 +
-            importMatch.f1Score * 0.30 +
-            exportMatch.f1Score * 0.30 +
-            requirementCoverage.coverage * 0.15);
+        //   Purpose:      50%  — LLM-as-judge: how well the spec describes this file
+        //   Requirements: 35%  — LLM-as-judge: fraction of file-relevant requirements covered
+        //   Imports:       5%  — fraction of actual imports mentioned in spec
+        //                        (low weight: library deps are never in specs, so ceiling ~20%)
+        //   Exports:      10%  — F1 of LLM-predicted vs actual exports
+        return (purposeMatch.similarity * 0.50 +
+            requirementCoverage.coverage * 0.35 +
+            importMatch.f1Score * 0.05 +
+            exportMatch.f1Score * 0.10);
     }
     /**
      * Generate feedback for gaps
@@ -548,7 +774,7 @@ Respond in JSON:
             recommendation = 'regenerate';
         }
         return {
-            timestamp: new Date().toISOString(),
+            timestamp: new Date().toLocaleString(),
             specVersion,
             sampledFiles: results.length,
             passedFiles,
@@ -642,7 +868,7 @@ Respond in JSON:
         lines.push('');
         for (const result of report.results) {
             const scorePercent = (result.overallScore * 100).toFixed(0);
-            const status = result.overallScore >= 0.6 ? '✅' : '❌';
+            const status = result.overallScore >= this.options.passThreshold ? '✅' : '❌';
             lines.push(`### ${status} ${result.filePath}`);
             lines.push('');
             lines.push(`- **Domain**: ${result.domain}`);