@praneeth_54/agentdoctor 2.0.0 → 2.0.1

package/dist/platform/firewall/evaluate.js

@@ -2,12 +2,22 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { platformDir, writeJsonArtifact } from "../store.js";
 import { resolveRepoRoot } from "../../utils/path.js";
+import { composePolicy } from "../../policy/compose.js";
 const EVALUATE_ONLY = "Evaluate-only: no commands are executed and no agents are intercepted.";
 const DEFAULT_POLICY = {
     version: "2.0",
     defaultDecision: "require-approval",
     failClosed: false,
-    shellAllowlist: ["npm test", "npm run test", "vitest", "eslint", "tsc", "prettier"],
+    shellAllowlist: [
+        "npm test",
+        "npm run test",
+        "npm --version",
+        "npm -v",
+        "vitest",
+        "eslint",
+        "tsc",
+        "prettier",
+    ],
     rules: [
         {
             id: "block-secret-paths",
@@ -162,11 +172,22 @@ function denyAllPolicy(reason) {
 }
 /**
  * Load local action-policy document.
- * Invalid file + failClosed (file flag or option) → deny-all.
- * Invalid file + default → documented fallback DEFAULT_POLICY.
+ * Layers: composed builtin pack + `.agentdoctor/policy.json` (fail-closed on malformed repo policy),
+ * then optional platform `firewall-policy.json` overlay (highest precedence when valid).
+ * Invalid platform file + failClosed → deny-all.
+ * Invalid platform file + default → composed policy (or DEFAULT_POLICY when compose unavailable).
  */
 export async function loadFirewallPolicy(root, options) {
     const resolved = resolveRepoRoot(root);
+    const composed = await composePolicy({ root: resolved });
+    if (composed.validationError && composed.failClosed) {
+        return {
+            policy: composed.policy,
+            source: "fail-closed-deny",
+            validationError: composed.validationError,
+            composeSources: composed.sources,
+        };
+    }
     const file = path.join(platformDir(resolved), "firewall-policy.json");
     try {
         const raw = await fs.readFile(file, "utf8");
@@ -175,19 +196,20 @@ export async function loadFirewallPolicy(root, options) {
             parsed = JSON.parse(raw);
         }
         catch {
-            const failClosed = options?.failClosed === true;
+            const failClosed = options?.failClosed === true || composed.failClosed;
             if (failClosed) {
                 return {
                     policy: denyAllPolicy("Malformed policy JSON; fail-closed deny"),
                     source: "fail-closed-deny",
                     validationError: "Malformed JSON",
+                    composeSources: composed.sources,
                 };
             }
-            await writeJsonArtifact(resolved, "firewall-policy.json", DEFAULT_POLICY);
             return {
-                policy: DEFAULT_POLICY,
-                source: "default",
-                validationError: "Malformed JSON; wrote default policy",
+                policy: composed.policy,
+                source: "composed",
+                validationError: "Malformed platform firewall-policy.json; using composed policy",
+                composeSources: composed.sources,
             };
         }
         const validated = validateFirewallPolicy(parsed);
@@ -195,26 +217,55 @@ export async function loadFirewallPolicy(root, options) {
             const fileWantsFailClosed = parsed &&
                 typeof parsed === "object" &&
                 parsed.failClosed === true;
-            const failClosed = options?.failClosed === true || fileWantsFailClosed;
+            const failClosed = options?.failClosed === true || fileWantsFailClosed || composed.failClosed;
             if (failClosed) {
                 return {
                     policy: denyAllPolicy(`Invalid policy: ${validated.error}`),
                     source: "fail-closed-deny",
                     ...(validated.error ? { validationError: validated.error } : {}),
+                    composeSources: composed.sources,
                 };
             }
-            await writeJsonArtifact(resolved, "firewall-policy.json", DEFAULT_POLICY);
             return {
-                policy: DEFAULT_POLICY,
-                source: "default",
-                ...(validated.error ? { validationError: validated.error } : {}),
+                policy: composed.policy,
+                source: "composed",
+                ...(validated.error
+                    ? { validationError: `Invalid platform policy; using composed (${validated.error})` }
+                    : {}),
+                composeSources: composed.sources,
             };
         }
-        return { policy: validated.policy, source: "file" };
+        // Platform file rules first (highest precedence), then composed builtin+repo rules.
+        const merged = {
+            version: "2.0",
+            defaultDecision: validated.policy.defaultDecision,
+            failClosed: validated.policy.failClosed === true || composed.policy.failClosed === true,
+            ...(validated.policy.shellAllowlist
+                ? { shellAllowlist: validated.policy.shellAllowlist }
+                : composed.policy.shellAllowlist
+                    ? { shellAllowlist: composed.policy.shellAllowlist }
+                    : {}),
+            rules: [...validated.policy.rules, ...composed.policy.rules],
+        };
+        return {
+            policy: merged,
+            source: "file",
+            composeSources: composed.sources,
+        };
     }
     catch {
+        // No platform file: prefer repo-composed policy when `.agentdoctor/policy.json` exists.
+        // Otherwise seed DEFAULT_POLICY (includes allow-safe-dev-paths). Do not treat packName
+        // alone as a reason to skip DEFAULT_POLICY — compose always names a builtin pack.
+        if (composed.sources.includes("repo")) {
+            return {
+                policy: composed.policy,
+                source: "composed",
+                composeSources: composed.sources,
+            };
+        }
         await writeJsonArtifact(resolved, "firewall-policy.json", DEFAULT_POLICY);
-        return { policy: DEFAULT_POLICY, source: "default" };
+        return { policy: DEFAULT_POLICY, source: "default", composeSources: composed.sources };
     }
 }
 function ruleMatches(rule, action) {

package/dist/platform/graph/build.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { readTextFile } from "../../utils/fs.js";
 import { resolveRepoRoot, toPosixRelative } from "../../utils/path.js";
 const SKIP = new Set([
     "node_modules",
@@ -154,30 +155,25 @@ export async function buildRepositoryGraph(rootInput) {
         const fileId = nodeId("file", rel);
         nodes.push({ id: fileId, kind, label: path.basename(rel), path: rel });
         if (CODE_EXT.has(ext)) {
-            try {
-                const st = await fs.stat(absolute);
-                if (st.size > 256 * 1024)
-                    continue;
-                const content = await fs.readFile(absolute, "utf8");
-                nodes.push(...extractSymbols(content, rel));
-                const { edges: importEdges, dependencyNodes } = extractImports(content, rel);
-                edges.push(...importEdges);
-                for (const dep of dependencyNodes) {
-                    if (!nodes.some((n) => n.id === dep.id))
-                        nodes.push(dep);
-                }
-                if (/router\.|app\.(get|post|put|delete)|@app\.(get|post)/i.test(content)) {
-                    nodes.push({
-                        id: nodeId("api", rel),
-                        kind: "api",
-                        label: `api:${path.basename(rel)}`,
-                        path: rel,
-                        meta: { evidence: "inferred" },
-                    });
-                }
+            // open+fstat+read via readTextFile — avoids exists/stat→read TOCTOU
+            const content = await readTextFile(absolute, 256 * 1024);
+            if (content === null)
+                continue;
+            nodes.push(...extractSymbols(content, rel));
+            const { edges: importEdges, dependencyNodes } = extractImports(content, rel);
+            edges.push(...importEdges);
+            for (const dep of dependencyNodes) {
+                if (!nodes.some((n) => n.id === dep.id))
+                    nodes.push(dep);
             }
-            catch {
-                // skip unreadable
+            if (/router\.|app\.(get|post|put|delete)|@app\.(get|post)/i.test(content)) {
+                nodes.push({
+                    id: nodeId("api", rel),
+                    kind: "api",
+                    label: `api:${path.basename(rel)}`,
+                    path: rel,
+                    meta: { evidence: "inferred" },
+                });
             }
         }
     }

package/dist/platform/health/analyze.js

@@ -19,24 +19,30 @@ export async function analyzeCodeHealth(rootInput, graph) {
         let content;
         let size;
         try {
-            const st = await fs.stat(absolute);
-            size = st.size;
-            if (size > 512 * 1024) {
-                findings.push({
-                    id: fid("filesize", node.path),
-                    module: "code-health",
-                    severity: "medium",
-                    title: "Large source file",
-                    message: `${node.path} is ${size} bytes`,
-                    recommendation: "Split into smaller modules to reduce change risk",
-                    confidence: 0.9,
-                    evidence: [{ kind: "verified", path: node.path, detail: `sizeBytes=${size}` }],
-                });
-                continue;
+            const handle = await fs.open(absolute, "r");
+            try {
+                const st = await handle.stat();
+                size = st.size;
+                if (size > 512 * 1024) {
+                    findings.push({
+                        id: fid("filesize", node.path),
+                        module: "code-health",
+                        severity: "medium",
+                        title: "Large source file",
+                        message: `${node.path} is ${size} bytes`,
+                        recommendation: "Split into smaller modules to reduce change risk",
+                        confidence: 0.9,
+                        evidence: [{ kind: "verified", path: node.path, detail: `sizeBytes=${size}` }],
+                    });
+                    continue;
+                }
+                if (!/\.(ts|tsx|js|jsx|py|go)$/i.test(node.path))
+                    continue;
+                content = await handle.readFile("utf8");
+            }
+            finally {
+                await handle.close();
             }
-            if (!/\.(ts|tsx|js|jsx|py|go)$/i.test(node.path))
-                continue;
-            content = await fs.readFile(absolute, "utf8");
         }
         catch {
             continue;

package/dist/platform/index.js

@@ -15,12 +15,14 @@ import { resolveRepoRoot } from "../utils/path.js";
 function toTestImpactSnapshot(report) {
     return {
         gitAvailable: report.gitAvailable,
+        mode: report.mode,
         changedFiles: report.changedFiles,
         recommendedTests: report.recommendedTests,
         relatedModules: report.relatedModules,
         missingTestWarnings: report.missingTestWarnings,
         uncoveredAreas: report.uncoveredAreas,
         skipRisk: report.skipRisk,
+        coverage: report.coverage,
         limitations: report.limitations,
     };
 }

package/dist/platform/test-impact/analyze.d.ts

@@ -1,3 +1,4 @@
+import type { CoverageFormat } from "../../coverage/types.js";
 import type { EvidenceKind } from "../types.js";
 export interface TestImpactItem {
     testPath: string;
@@ -12,21 +13,38 @@ export interface MissingTestWarning {
     message: string;
     relatedModules: string[];
 }
+export interface CoverageImpactSummary {
+    format: CoverageFormat;
+    filesWithHits: number;
+    changedCoveredLines: number;
+    changedUncoveredLines: number;
+    coverageHits: number;
+    /** How recommended tests were attributed. */
+    testAttribution: "coverage-map" | "hybrid-heuristic" | "none";
+}
 export interface TestImpactReport {
     root: string;
     gitAvailable: boolean;
+    mode: "coverage-backed" | "heuristic";
     changedFiles: string[];
     recommendedTests: TestImpactItem[];
     relatedModules: string[];
     uncoveredAreas: string[];
     missingTestWarnings: MissingTestWarning[];
     skipRisk: string;
+    coverage: CoverageImpactSummary | null;
     limitations: string[];
 }
+export interface AnalyzeTestImpactOptions {
+    root?: string;
+    coveragePath?: string;
+    since?: string;
+}
 /**
- * Module H — Test impact analysis (naming + path heuristics).
- * Never claims tests passed unless actually executed elsewhere.
+ * Module H — Test impact analysis.
+ * Heuristic by default; coverage-backed when a coverage file is loaded and used
+ * for changed-line evidence. Never claims tests passed.
  */
-export declare function analyzeTestImpact(rootInput: string): Promise<TestImpactReport>;
+export declare function analyzeTestImpact(rootInput: string | AnalyzeTestImpactOptions, maybeOptions?: AnalyzeTestImpactOptions): Promise<TestImpactReport>;
 export declare function persistTestImpactReport(root: string, report: TestImpactReport): Promise<string>;
 export declare function formatTestImpactHuman(report: TestImpactReport): string;

package/dist/platform/test-impact/analyze.js

@@ -1,6 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { analyzeChanges } from "../../core/changes/analyze.js";
+import { loadCoverage } from "../../coverage/load.js";
+import { normalizeCoveragePath } from "../../coverage/types.js";
 import { resolveRepoRoot } from "../../utils/path.js";
 import { writeJsonArtifact } from "../store.js";
 function modulesForPath(file, attributed) {
@@ -24,41 +26,130 @@ async function fileExists(root, rel) {
         return false;
     }
 }
+function isTestPath(file) {
+    return /\.(test|spec)\./i.test(file) || file.includes("__tests__");
+}
+function heuristicCandidates(file) {
+    const ext = path.extname(file);
+    const base = ext ? file.slice(0, -ext.length) : file;
+    return [
+        `${base}.test${ext || ".ts"}`,
+        `${base}.spec${ext || ".ts"}`,
+        file.replace(/\/src\//, "/tests/"),
+        file.replace(/^src\//, "tests/"),
+    ].filter((c, i, arr) => c !== file && arr.indexOf(c) === i);
+}
+function coverageFileFor(changed, coverage) {
+    const norm = normalizeCoveragePath(changed);
+    if (coverage.files[norm])
+        return norm;
+    // Match by suffix (absolute paths in LCOV vs repo-relative changed paths)
+    const keys = Object.keys(coverage.files);
+    const suffixHit = keys.find((k) => k === norm || k.endsWith(`/${norm}`) || norm.endsWith(`/${k}`));
+    return suffixHit ?? null;
+}
+function countLineHits(fileCov) {
+    if (!fileCov)
+        return { covered: 0, uncovered: 0, hits: 0 };
+    let covered = 0;
+    let uncovered = 0;
+    let hits = 0;
+    for (const h of Object.values(fileCov.lines)) {
+        if (h > 0) {
+            covered += 1;
+            hits += h;
+        }
+        else {
+            uncovered += 1;
+        }
+    }
+    return { covered, uncovered, hits };
+}
+function testsFromCoverageMap(coverage, sourceKey) {
+    const fileCov = coverage.files[sourceKey];
+    const fromFile = fileCov?.coveredByTests ?? [];
+    const fromMap = [];
+    if (coverage.testToFiles) {
+        for (const [test, sources] of Object.entries(coverage.testToFiles)) {
+            if (sources.some((s) => s === sourceKey || s.endsWith(`/${sourceKey}`) || sourceKey.endsWith(`/${s}`))) {
+                fromMap.push(test);
+            }
+        }
+    }
+    return [...new Set([...fromFile, ...fromMap].map(normalizeCoveragePath))].sort();
+}
 /**
- * Module H — Test impact analysis (naming + path heuristics).
- * Never claims tests passed unless actually executed elsewhere.
+ * Module H — Test impact analysis.
+ * Heuristic by default; coverage-backed when a coverage file is loaded and used
+ * for changed-line evidence. Never claims tests passed.
  */
-export async function analyzeTestImpact(rootInput) {
-    const root = resolveRepoRoot(rootInput);
-    const changes = await analyzeChanges({ root, impact: true });
+export async function analyzeTestImpact(rootInput, maybeOptions) {
+    // Support both analyzeTestImpact(root) and analyzeTestImpact({ root, ... })
+    const options = typeof rootInput === "string" ? { ...(maybeOptions ?? {}), root: rootInput } : rootInput;
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const changes = await analyzeChanges({
+        root,
+        impact: true,
+        ...(options.since ? { since: options.since } : {}),
+    });
     const changed = changes.files.map((f) => f.path);
     const recommended = [];
     const uncovered = [];
     const missingTestWarnings = [];
     const allModules = new Set();
+    const limitations = [
+        "Does not execute tests; never claims pass/fail",
+        ...changes.limitations,
+    ];
+    let coverage = null;
+    let coverageSummary = null;
+    let mode = "heuristic";
+    let testAttribution = "none";
+    if (options.coveragePath) {
+        try {
+            coverage = await loadCoverage(options.coveragePath);
+            if (Object.keys(coverage.files).length === 0) {
+                limitations.push(`Coverage path provided but no file hits loaded (${coverage.format}): ${options.coveragePath}`);
+                limitations.push(...coverage.limitations);
+                coverage = null;
+            }
+            else {
+                limitations.push(...coverage.limitations);
+            }
+        }
+        catch (error) {
+            limitations.push(`Failed to load coverage from ${options.coveragePath}: ${error instanceof Error ? error.message : String(error)}`);
+            coverage = null;
+        }
+    }
     if (!changes.gitAvailable) {
         return {
             root,
             gitAvailable: false,
+            mode: "heuristic",
             changedFiles: [],
             recommendedTests: [],
             relatedModules: [],
             uncoveredAreas: [],
             missingTestWarnings: [],
             skipRisk: "Git not available — cannot infer changed files",
-            limitations: [
-                "Requires a git working tree to detect changes",
-                "Does not execute tests; never claims pass/fail",
-                ...changes.limitations,
-            ],
+            coverage: null,
+            limitations: ["Requires a git working tree to detect changes", ...limitations],
         };
     }
+    let changedCoveredLines = 0;
+    let changedUncoveredLines = 0;
+    let coverageHits = 0;
+    let filesWithHits = 0;
+    let usedCoverageForChangedLines = false;
+    let usedCoverageTestMap = false;
+    let usedHeuristicForTests = false;
     for (const fileEntry of changes.files) {
         const file = fileEntry.path;
         const relatedModules = modulesForPath(file, fileEntry.modules);
         for (const m of relatedModules)
             allModules.add(m);
-        if (/\.(test|spec)\./i.test(file) || file.includes("__tests__")) {
+        if (isTestPath(file)) {
             recommended.push({
                 testPath: file,
                 reason: "Changed file is itself a test",
@@ -69,14 +160,69 @@ export async function analyzeTestImpact(rootInput) {
             });
             continue;
         }
-        const ext = path.extname(file);
-        const base = ext ? file.slice(0, -ext.length) : file;
-        const candidates = [
-            `${base}.test${ext || ".ts"}`,
-            `${base}.spec${ext || ".ts"}`,
-            file.replace(/\/src\//, "/tests/"),
-            file.replace(/^src\//, "tests/"),
-        ].filter((c, i, arr) => c !== file && arr.indexOf(c) === i);
+        // Coverage-backed changed-line evidence
+        if (coverage) {
+            const covKey = coverageFileFor(file, coverage);
+            if (covKey) {
+                const counts = countLineHits(coverage.files[covKey]);
+                changedCoveredLines += counts.covered;
+                changedUncoveredLines += counts.uncovered;
+                coverageHits += counts.hits;
+                if (counts.covered + counts.uncovered > 0) {
+                    usedCoverageForChangedLines = true;
+                    filesWithHits += 1;
+                }
+                const mappedTests = testsFromCoverageMap(coverage, covKey);
+                if (mappedTests.length > 0) {
+                    usedCoverageTestMap = true;
+                    for (const testPath of mappedTests) {
+                        const exists = await fileExists(root, testPath);
+                        recommended.push({
+                            testPath,
+                            reason: `Coverage map links test to changed source ${file}`,
+                            confidence: exists ? 0.9 : 0.75,
+                            evidence: "verified",
+                            exists,
+                            relatedModules,
+                        });
+                    }
+                }
+                else {
+                    // Hybrid: coverage proves line hits; tests from naming heuristic
+                    usedHeuristicForTests = true;
+                    const candidates = heuristicCandidates(file);
+                    let anyExists = false;
+                    for (const c of candidates) {
+                        const exists = await fileExists(root, c);
+                        if (exists)
+                            anyExists = true;
+                        recommended.push({
+                            testPath: c,
+                            reason: exists
+                                ? `Heuristic test candidate for coverage-touched file ${file} (no test→source map)`
+                                : `Suggested test path for coverage-touched file ${file} (not found; no test→source map)`,
+                            confidence: exists ? 0.65 : 0.35,
+                            evidence: "inferred",
+                            exists,
+                            relatedModules,
+                        });
+                    }
+                    if (candidates.length === 0) {
+                        uncovered.push(file);
+                    }
+                    else if (!anyExists) {
+                        missingTestWarnings.push({
+                            sourceFile: file,
+                            message: `No co-located or tests/ counterpart found for ${file}`,
+                            relatedModules,
+                        });
+                    }
+                }
+                continue;
+            }
+        }
+        // Pure heuristic path (no coverage for this file, or no coverage loaded)
+        const candidates = heuristicCandidates(file);
         let anyExists = false;
         for (const c of candidates) {
             const exists = await fileExists(root, c);
@@ -85,10 +231,10 @@ export async function analyzeTestImpact(rootInput) {
             recommended.push({
                 testPath: c,
                 reason: exists
-                    ? `Existing test candidate for changed file ${file}`
-                    : `Suggested test path for changed file ${file} (file not found)`,
+                    ? `Existing test candidate for changed file ${file} (naming heuristic)`
+                    : `Suggested test path for changed file ${file} (file not found; naming heuristic)`,
                 confidence: exists ? 0.7 : 0.4,
-                evidence: exists ? "verified" : "inferred",
+                evidence: "inferred",
                 exists,
                 relatedModules,
             });
@@ -108,6 +254,44 @@ export async function analyzeTestImpact(rootInput) {
         for (const m of modulesForPath(rel))
             allModules.add(m);
     }
+    if (usedCoverageForChangedLines) {
+        mode = "coverage-backed";
+        if (usedCoverageTestMap && usedHeuristicForTests) {
+            testAttribution = "hybrid-heuristic";
+            limitations.push("mode=coverage-backed: changed-line evidence from coverage; some tests attributed via naming heuristic (hybrid)");
+        }
+        else if (usedCoverageTestMap) {
+            testAttribution = "coverage-map";
+            limitations.push("mode=coverage-backed: test attribution from coverage test→source map");
+        }
+        else {
+            testAttribution = "hybrid-heuristic";
+            limitations.push("mode=coverage-backed: coverage used for changed-line hits; test list uses naming heuristics because coverage lacks test→source map");
+        }
+        coverageSummary = {
+            format: coverage.format,
+            filesWithHits,
+            changedCoveredLines,
+            changedUncoveredLines,
+            coverageHits,
+            testAttribution,
+        };
+    }
+    else {
+        mode = "heuristic";
+        limitations.push("Impact mapping is path/naming heuristic — not coverage-backed (no usable coverage intersection with changed files)");
+        if (coverage) {
+            limitations.push("Coverage file was loaded but did not intersect changed source paths for line evidence");
+            coverageSummary = {
+                format: coverage.format,
+                filesWithHits: Object.keys(coverage.files).length,
+                changedCoveredLines: 0,
+                changedUncoveredLines: 0,
+                coverageHits: 0,
+                testAttribution: "none",
+            };
+        }
+    }
     const seen = new Set();
     const deduped = recommended.filter((r) => {
         if (seen.has(r.testPath))
@@ -118,6 +302,7 @@ export async function analyzeTestImpact(rootInput) {
     return {
         root,
         gitAvailable: true,
+        mode,
         changedFiles: changed,
         recommendedTests: deduped,
         relatedModules: [...allModules].sort(),
@@ -128,11 +313,8 @@ export async function analyzeTestImpact(rootInput) {
             : missingTestWarnings.length > 0
                 ? "Changed source files lack matching tests — skipping tests risks regressions"
                 : "Skipping recommended tests may miss regressions in changed modules",
-        limitations: [
-            "Impact mapping is path/naming heuristic — not a full coverage DB",
-            "Does not execute tests; never claims pass/fail",
-            ...changes.limitations,
-        ],
+        coverage: coverageSummary,
+        limitations,
     };
 }
 export async function persistTestImpactReport(root, report) {
@@ -141,6 +323,7 @@ export async function persistTestImpactReport(root, report) {
 export function formatTestImpactHuman(report) {
     const lines = [
         "AgentDoctor 2.0 test-impact",
+        `  mode: ${report.mode}`,
         `  git: ${report.gitAvailable ? "available" : "unavailable"}`,
         `  changed files: ${report.changedFiles.length}`,
         `  recommended tests: ${report.recommendedTests.length}`,
@@ -148,10 +331,13 @@ export function formatTestImpactHuman(report) {
         `  related modules: ${report.relatedModules.slice(0, 12).join(", ") || "(none)"}`,
         `  skip risk: ${report.skipRisk}`,
     ];
+    if (report.coverage) {
+        lines.push(`  coverage: format=${report.coverage.format} filesWithHits=${report.coverage.filesWithHits} coveredLines=${report.coverage.changedCoveredLines} uncoveredLines=${report.coverage.changedUncoveredLines} hits=${report.coverage.coverageHits} testAttribution=${report.coverage.testAttribution}`);
+    }
     if (report.recommendedTests.length) {
         lines.push("  affected tests:");
         for (const t of report.recommendedTests.slice(0, 20)) {
-            lines.push(`    - ${t.testPath} (exists=${t.exists}, confidence=${t.confidence}, ${t.reason})`);
+            lines.push(`    - ${t.testPath} (exists=${t.exists}, confidence=${t.confidence}, evidence=${t.evidence}, ${t.reason})`);
         }
     }
     if (report.missingTestWarnings.length) {