agentic-qe 3.15.4 → 3.15.6

package/dist/coordination/handlers/coverage-target.js

@@ -0,0 +1,314 @@
+/**
+ * Coverage target resolution (issue #995).
+ *
+ * A coverage target can be the project root, a subfolder of it, a single source
+ * file, or an existing coverage report. Before #995 every target was treated as
+ * if it were the project root: `target: "src/"` ran vitest FROM `src/` (which
+ * found no tests, reported 0%, and wrote `src/coverage/` into the source tree),
+ * and `target: "coverage/lcov.info"` was searched for a `coverage/` folder
+ * inside a file and came back empty.
+ *
+ * This module answers the three questions every collector needs first:
+ *   1. Which project does the target belong to?  (`findCoverageProjectRoot`)
+ *   2. Is the target itself a coverage report?   (`isCoverageReportFile` /
+ *      `loadCoverageReportFile`)
+ *   3. Which entries of a project-wide report belong to the target?
+ *      (`scopeCoverageToTarget`)
+ *
+ * Kept free of task-executor and child-process imports so both the MCP handler
+ * and the CLI `coverage` command can share it.
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { loadCoverageData, parseCoberturaXml, parseCoverageJson, parseCoverageSummaryJson, parseLcovInfo, } from './handler-utils.js';
+import { isTestPath } from './coverage-collection.js';
+// ============================================================================
+// Project root
+// ============================================================================
+/**
+ * Files whose presence marks a directory as a project root, i.e. the directory
+ * a test/coverage tool must be run from. `.git` bounds the walk for projects
+ * without a manifest.
+ */
+const PROJECT_ROOT_MARKERS = [
+    'package.json',
+    'pyproject.toml', 'setup.py', 'setup.cfg',
+    'go.mod', 'Cargo.toml',
+    'pom.xml', 'build.gradle', 'build.gradle.kts',
+    '.git',
+];
+/**
+ * Walk up from a target to the nearest directory that holds a project marker.
+ *
+ * NEAREST rather than topmost: in a monorepo, `packages/core/src` belongs to
+ * `packages/core` (its own package.json and test config), not the workspace
+ * root. This intentionally differs from `kernel/findProjectRoot`, which locates
+ * the AQE data root (honouring AQE_PROJECT_ROOT and `.agentic-qe`).
+ *
+ * Returns `null` when the target does not exist (a typo must not silently
+ * resolve to — and run tests for — an ancestor project) or when no marker is
+ * found below the home directory / filesystem root within `maxDepth` levels.
+ */
+export function findCoverageProjectRoot(target, maxDepth = 12) {
+    let dir;
+    try {
+        const resolved = path.resolve(target);
+        if (!fs.existsSync(resolved))
+            return null;
+        const real = fs.realpathSync(resolved);
+        dir = fs.statSync(real).isDirectory() ? real : path.dirname(real);
+    }
+    catch {
+        return null;
+    }
+    let home = null;
+    try {
+        home = fs.realpathSync(os.homedir());
+    }
+    catch {
+        home = null;
+    }
+    const start = dir;
+    for (let depth = 0; depth <= maxDepth; depth++) {
+        // A stray manifest in $HOME must not claim every directory beneath it.
+        // $HOME is still a valid root when it is the target itself.
+        if (home !== null && dir === home && dir !== start)
+            return null;
+        if (PROJECT_ROOT_MARKERS.some(m => fs.existsSync(path.join(dir, m))))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+// ============================================================================
+// Coverage report files as targets
+// ============================================================================
+const REPORT_BASENAMES = new Set([
+    'lcov.info',
+    'coverage-final.json',
+    'coverage-summary.json',
+    'coverage.xml',
+    'cobertura-coverage.xml',
+    'cobertura.xml',
+]);
+/** Is this path (by name) a coverage report rather than source code? */
+export function isCoverageReportFile(filePath) {
+    const base = path.basename(filePath).toLowerCase();
+    return REPORT_BASENAMES.has(base) || base.endsWith('.lcov') || base.endsWith('.lcov.info');
+}
+/**
+ * Parse a coverage report file of any supported format.
+ *
+ * Returns `null` — never an empty "0%" report — when the file can't be read,
+ * can't be parsed, or lists no files.
+ */
+export async function loadCoverageReportFile(filePath) {
+    let content;
+    try {
+        content = await fs.promises.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    if (content.trim().length === 0)
+        return null;
+    try {
+        const base = path.basename(filePath).toLowerCase();
+        let data;
+        if (base.endsWith('.json')) {
+            const parsed = JSON.parse(content);
+            // coverage-summary.json carries a `total` entry with per-metric totals.
+            if (isSummaryShape(parsed))
+                data = parseCoverageSummaryJson(content);
+            // Anything else must be istanbul's per-file map. Raw V8 output
+            // (`{ result: [...] }`) and arbitrary JSON are rejected, not parsed into
+            // a phantom file called "result" with 0/0 coverage.
+            else if (isIstanbulShape(parsed))
+                data = parseCoverageJson(content);
+            else
+                return null;
+        }
+        else if (base.endsWith('.xml')) {
+            data = parseCoberturaXml(content);
+        }
+        else {
+            data = parseLcovInfo(content);
+        }
+        return data.files.length > 0 ? data : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isIstanbulShape(parsed) {
+    const entries = Object.values(parsed);
+    return entries.length > 0 && entries.every(e => typeof e === 'object' && e !== null && !Array.isArray(e) &&
+        typeof e.s === 'object' &&
+        typeof e.statementMap === 'object');
+}
+function isSummaryShape(parsed) {
+    const total = parsed.total;
+    return typeof total === 'object' && total !== null && typeof total.lines === 'object';
+}
+// ============================================================================
+// Scoping
+// ============================================================================
+/** True when `child` is `parent` or inside it (path-segment aware). */
+function isWithin(child, parent) {
+    const rel = path.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+/** Canonicalise a path without requiring it to exist (macOS /tmp → /private/tmp). */
+function canonical(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+/**
+ * Keep only the report entries that lie under `target`.
+ *
+ * Report paths come in two shapes: absolute (istanbul `coverage-final.json`)
+ * and project-root-relative (vitest/jest `lcov.info` writes `SF:src/math.ts`).
+ * Relative entries are resolved against `root` before comparing. Entry paths are
+ * returned unchanged.
+ */
+export function scopeCoverageToTarget(data, root, target) {
+    const rootAbs = canonical(root);
+    const targetAbs = canonical(target);
+    if (targetAbs === rootAbs)
+        return [...data.files];
+    return data.files.filter(f => {
+        const abs = path.isAbsolute(f.path) ? canonical(f.path) : path.resolve(rootAbs, f.path);
+        return isWithin(abs, targetAbs);
+    });
+}
+/**
+ * Decide what a report says about `target`. Shared by the MCP handler and the
+ * CLI so the two cannot disagree (#995 review B2).
+ *
+ * "Unmeasured" is decided ONLY from evidence that nothing was measured:
+ *   - the runner's own result says it ran 0 tests (`numTotalTests === 0`), or
+ *   - the report has no entry under the target.
+ * Hit counts are never used: a file listed with 0 hits is a measured 0%,
+ * whether the report came from our run or from the user (#995 review B3).
+ */
+export function evaluateCoverageForTarget(report, projectRoot, target, options = {}) {
+    if (options.numTotalTests === 0)
+        return { status: 'no-data', reason: 'no-tests-ran' };
+    const scoped = scopeCoverageToTarget(report, projectRoot, target);
+    if (scoped.length === 0)
+        return { status: 'no-data', reason: 'target-not-covered' };
+    // Coverage OF a test file is not production coverage (#569). A report with
+    // only test entries yields no production figure — never the unfiltered set.
+    const production = scoped.filter(f => !isTestPath(f.path, projectRoot));
+    if (production.length === 0)
+        return { status: 'no-data', reason: 'test-only-report' };
+    return { status: 'measured', files: production };
+}
+/**
+ * Resolve a target to coverage that already exists on disk, without running
+ * anything:
+ *   - a coverage report passed as the target is parsed and analysed whole;
+ *   - otherwise the PROJECT ROOT's report (not the cwd's, not the subfolder's)
+ *     is scoped to the target;
+ *   - `no-report` tells the caller it may run tooling from `projectRoot`.
+ */
+export async function resolveExistingCoverage(targetPath) {
+    const target = path.resolve(targetPath);
+    let stat;
+    try {
+        stat = fs.statSync(target);
+    }
+    catch {
+        return { status: 'target-missing', target };
+    }
+    if (stat.isFile() && isCoverageReportFile(target)) {
+        const reportDir = path.dirname(target);
+        const projectRoot = findCoverageProjectRoot(reportDir)
+            ?? (path.basename(reportDir) === 'coverage' ? path.dirname(reportDir) : reportDir);
+        const report = await loadCoverageReportFile(target);
+        const evaluation = report
+            ? evaluateCoverageForTarget(report, projectRoot, projectRoot)
+            : { status: 'no-data', reason: 'unreadable-report' };
+        return { status: 'evaluated', target, projectRoot, source: 'report-file', evaluation };
+    }
+    const projectRoot = findCoverageProjectRoot(target) ?? (stat.isDirectory() ? target : path.dirname(target));
+    const existing = await loadCoverageData(projectRoot);
+    if (!existing)
+        return { status: 'no-report', target, projectRoot };
+    return {
+        status: 'evaluated', target, projectRoot, source: 'project-report',
+        evaluation: evaluateCoverageForTarget(existing, projectRoot, target),
+    };
+}
+/**
+ * Threshold verdict over the metrics that were actually collected. Shared by
+ * MCP and CLI (#995 review NB5): an uncollected metric (no branch data in the
+ * report) is null, and a null must not drag the average down as a fake 0.
+ */
+export function thresholdVerdict(summary, threshold, collected) {
+    // #1027 N7: lcov / Cobertura carry no statement data; it is left out too.
+    const metrics = [summary.line];
+    if (collected.statement !== false)
+        metrics.push(summary.statement);
+    if (collected.branch)
+        metrics.push(summary.branch);
+    if (collected.function)
+        metrics.push(summary.function);
+    const overall = metrics.reduce((a, b) => a + b, 0) / metrics.length;
+    return { overall, meetsThreshold: overall >= threshold };
+}
+const SHORTFALL_RE = /^Coverage is [\d.]+% below threshold/i;
+/**
+ * Make the analyzer's recommendations agree with `thresholdVerdict`
+ * (#995 review NB-A). The analyzer computes its "Coverage is X% below
+ * threshold" line from a 4-metric average that counts an uncollected metric as
+ * 0 — so a line-only report at 90% got "Met" next to "35.0% below threshold".
+ * Here the shortfall line is recomputed from the collected-metrics verdict,
+ * and advice about a metric that was never collected is dropped.
+ */
+export function reconcileRecommendations(recommendations, verdict, threshold, collected) {
+    const kept = recommendations.filter(rec => !SHORTFALL_RE.test(rec) &&
+        (collected.branch || !/branch coverage/i.test(rec)) &&
+        (collected.function || !/function coverage/i.test(rec)));
+    if (verdict.meetsThreshold)
+        return kept;
+    return [
+        `Coverage is ${(threshold - verdict.overall).toFixed(1)}% below threshold. Focus on high-risk files first.`,
+        ...kept,
+    ];
+}
+/** Is this verdict "no measurement exists" (as opposed to an error or test-only report)? */
+export function isUnmeasured(reason) {
+    return reason === 'target-not-covered' || reason === 'no-tests-ran';
+}
+/** Caller-facing explanation of a no-data verdict. Shared by MCP and CLI. */
+export function describeNoData(reason, target, projectRoot) {
+    switch (reason) {
+        case 'target-missing':
+            return `Target does not exist: ${target}`;
+        case 'unreadable-report':
+            return `Unreadable coverage report: ${target}. It could not be parsed or lists no files. ` +
+                'Supported: lcov.info, istanbul coverage-final.json / coverage-summary.json, Cobertura XML. ' +
+                "Raw V8 output is not supported — convert it with c8 or your runner's istanbul reporter.";
+        case 'test-only-report':
+            return 'The coverage report contains only test files, so there is no production ' +
+                'coverage to report. Coverage OF a test file is not a meaningful metric. ' +
+                'Check that your coverage tool is instrumenting your source directory.';
+        case 'target-not-covered':
+            return `Target is UNMEASURED: the coverage data for project ${projectRoot ?? '?'} has no entry ` +
+                `for any production file under ${target}. This is not 0% coverage — no measurement exists ` +
+                "for it. Check your coverage tool's include/exclude settings, or regenerate the report.";
+        case 'no-tests-ran':
+            return `Target is UNMEASURED: the test runner reported running 0 tests from ${projectRoot ?? '?'}. ` +
+                'This is not 0% coverage.';
+    }
+}
+//# sourceMappingURL=coverage-target.js.map

package/dist/coordination/handlers/handler-types.d.ts

@@ -11,7 +11,10 @@ import type { CoverageAnalyzerService } from '../../domains/coverage-analysis';
 import type { SecurityScannerService } from '../../domains/security-compliance';
 import type { TestGeneratorService } from '../../domains/test-generation';
 import type { KnowledgeGraphService } from '../../domains/code-intelligence';
+import type { ICodeIntelligenceCoordinator } from '../../domains/code-intelligence/coordinator';
 import type { QualityAnalyzerService } from '../../domains/quality-assessment';
+/** The coordinator surface the MCP index-code handler needs (#999). */
+export type ProjectMetricsCollector = Pick<ICodeIntelligenceCoordinator, 'collectProjectMetrics'>;
 /** Signature of a single task handler */
 export type InstanceTaskHandler = (task: QueenTask) => Promise<Result<unknown, Error>>;
 /**
@@ -33,6 +36,12 @@ export interface TaskHandlerContext {
      */
     getTestGenerator(useLLM?: boolean): Promise<TestGeneratorService>;
     getKnowledgeGraph(): KnowledgeGraphService;
+    /**
+     * #999 MCP-CLI parity: the code-intelligence coordinator, whose
+     * collectProjectMetrics step `aqe code index` runs. Resolves to undefined when
+     * the domain is unavailable. Optional so lightweight contexts can omit it.
+     */
+    getCodeIntelligenceCoordinator?(): Promise<ProjectMetricsCollector | undefined>;
     getQualityAnalyzer(): QualityAnalyzerService;
     /** Executor configuration */
     readonly config: {

package/dist/coordination/handlers/handler-utils.d.ts

@@ -75,9 +75,31 @@ export interface IstanbulFileCoverage {
  */
 export declare function loadCoverageData(targetPath: string): Promise<CoverageData | null>;
 /**
- * Parse Istanbul/nyc coverage-final.json format
+ * Per-line hit counts of one istanbul file entry, computed the way istanbul's
+ * own `FileCoverage#getLineCoverage` (and therefore coverage-summary.json
+ * `lines` and lcov.info `DA:` records) does: each statement counts on its
+ * START line, and a line's count is the highest count of the statements that
+ * start on it. A line is covered when any statement on it ran (#1012).
+ */
+export declare function istanbulLineHits(fd: Pick<IstanbulFileCoverage, 'statementMap' | 's'>): Map<number, number>;
+/**
+ * Parse Istanbul/nyc coverage-final.json format.
+ *
+ * #1012: `lines` are SOURCE LINES (derived from `statementMap` start lines,
+ * as istanbul's own summary does), not statements. Before, statement counts
+ * were reported as "line", so one project had two different line figures
+ * depending on whether coverage-final.json or lcov.info was read.
  */
 export declare function parseCoverageJson(content: string): CoverageData;
+/**
+ * Parse istanbul `coverage-summary.json` (the `json-summary` reporter).
+ *
+ * Shape: `{ total: {...}, "<file>": { lines, statements, functions, branches } }`
+ * where each metric is `{ total, covered, skipped, pct }`. There is no
+ * per-line detail, so `uncoveredLines` is empty — a summary can report a
+ * figure but cannot locate a gap (#995).
+ */
+export declare function parseCoverageSummaryJson(content: string): CoverageData;
 /**
  * Parse LCOV info format
  */

package/dist/coordination/handlers/handler-utils.js

@@ -6,6 +6,7 @@
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { isAqeManagedDir } from '../../shared/aqe-managed-dirs.js';
 import { safeJsonParse } from '../../shared/safe-json.js';
 // ============================================================================
 // Coverage Data Loaders
@@ -21,6 +22,8 @@ export async function loadCoverageData(targetPath) {
         path.join(targetPath, 'coverage', 'lcov.info'),
         path.join(targetPath, '.nyc_output', 'coverage-final.json'),
         path.join(targetPath, 'coverage-final.json'),
+        // Summary-only (per-file totals, no line detail) — last JS resort (#995)
+        path.join(targetPath, 'coverage', 'coverage-summary.json'),
         // Python (pytest-cov, coverage.py)
         path.join(targetPath, 'coverage.xml'),
         path.join(targetPath, 'htmlcov', 'status.json'),
@@ -30,7 +33,10 @@ export async function loadCoverageData(targetPath) {
     for (const coveragePath of coverageLocations) {
         try {
             const content = await fs.readFile(coveragePath, 'utf-8');
-            if (coveragePath.endsWith('.json')) {
+            if (coveragePath.endsWith('coverage-summary.json')) {
+                return parseCoverageSummaryJson(content);
+            }
+            else if (coveragePath.endsWith('.json')) {
                 return parseCoverageJson(content);
             }
             else if (coveragePath.endsWith('.info')) {
@@ -47,7 +53,32 @@ export async function loadCoverageData(targetPath) {
     return null;
 }
 /**
- * Parse Istanbul/nyc coverage-final.json format
+ * Per-line hit counts of one istanbul file entry, computed the way istanbul's
+ * own `FileCoverage#getLineCoverage` (and therefore coverage-summary.json
+ * `lines` and lcov.info `DA:` records) does: each statement counts on its
+ * START line, and a line's count is the highest count of the statements that
+ * start on it. A line is covered when any statement on it ran (#1012).
+ */
+export function istanbulLineHits(fd) {
+    const lineHits = new Map();
+    const statementMap = fd.statementMap || {};
+    for (const [id, count] of Object.entries(fd.s || {})) {
+        const line = statementMap[id]?.start?.line;
+        if (typeof line !== 'number')
+            continue;
+        const prev = lineHits.get(line);
+        if (prev === undefined || prev < count)
+            lineHits.set(line, count);
+    }
+    return lineHits;
+}
+/**
+ * Parse Istanbul/nyc coverage-final.json format.
+ *
+ * #1012: `lines` are SOURCE LINES (derived from `statementMap` start lines,
+ * as istanbul's own summary does), not statements. Before, statement counts
+ * were reported as "line", so one project had two different line figures
+ * depending on whether coverage-final.json or lcov.info was read.
  */
 export function parseCoverageJson(content) {
     const data = safeJsonParse(content);
@@ -58,30 +89,21 @@ export function parseCoverageJson(content) {
     let totalStatements = 0, coveredStatements = 0;
     for (const [filePath, fileData] of Object.entries(data)) {
         const fd = fileData;
-        // Calculate file-level metrics
-        const lineMap = fd.statementMap || {};
-        const lineCounts = fd.s || {};
+        const statementCounts = fd.s || {};
         const branchMap = fd.branchMap || {};
         const branchCounts = fd.b || {};
         const fnCounts = fd.f || {};
-        const fileLines = Object.keys(lineCounts).length;
-        const fileCoveredLines = Object.values(lineCounts).filter((v) => v > 0).length;
+        const lineHits = istanbulLineHits(fd);
+        const fileLines = lineHits.size;
+        const fileCoveredLines = [...lineHits.values()].filter(v => v > 0).length;
         const fileBranches = Object.values(branchCounts).flat().length;
         const fileCoveredBranches = Object.values(branchCounts).flat().filter((v) => v > 0).length;
         const fileFunctions = Object.keys(fnCounts).length;
         const fileCoveredFunctions = Object.values(fnCounts).filter((v) => v > 0).length;
-        const fileStatements = Object.keys(lineMap).length;
-        const fileCoveredStatements = Object.values(lineCounts).filter((v) => v > 0).length;
-        // Find uncovered lines
-        const uncoveredLines = [];
-        for (const [key, count] of Object.entries(lineCounts)) {
-            if (count === 0) {
-                const stmtInfo = lineMap[key];
-                if (stmtInfo?.start?.line) {
-                    uncoveredLines.push(stmtInfo.start.line);
-                }
-            }
-        }
+        const fileStatements = Object.keys(statementCounts).length;
+        const fileCoveredStatements = Object.values(statementCounts).filter((v) => v > 0).length;
+        // Uncovered lines: lines no statement on which ran.
+        const uncoveredLines = [...lineHits.entries()].filter(([, hits]) => hits === 0).map(([line]) => line);
         // Find uncovered branches
         const uncoveredBranches = [];
         for (const [branchId, counts] of Object.entries(branchCounts)) {
@@ -98,7 +120,7 @@ export function parseCoverageJson(content) {
             branches: { covered: fileCoveredBranches, total: fileBranches },
             functions: { covered: fileCoveredFunctions, total: fileFunctions },
             statements: { covered: fileCoveredStatements, total: fileStatements },
-            uncoveredLines: Array.from(new Set(uncoveredLines)).sort((a, b) => a - b),
+            uncoveredLines: uncoveredLines.sort((a, b) => a - b),
             uncoveredBranches: Array.from(new Set(uncoveredBranches)).sort((a, b) => a - b),
         });
         totalLines += fileLines;
@@ -121,6 +143,44 @@ export function parseCoverageJson(content) {
         },
     };
 }
+/**
+ * Parse istanbul `coverage-summary.json` (the `json-summary` reporter).
+ *
+ * Shape: `{ total: {...}, "<file>": { lines, statements, functions, branches } }`
+ * where each metric is `{ total, covered, skipped, pct }`. There is no
+ * per-line detail, so `uncoveredLines` is empty — a summary can report a
+ * figure but cannot locate a gap (#995).
+ */
+export function parseCoverageSummaryJson(content) {
+    const data = safeJsonParse(content);
+    const pick = (m) => ({ covered: Number(m?.covered) || 0, total: Number(m?.total) || 0 });
+    const files = [];
+    for (const [filePath, entry] of Object.entries(data)) {
+        if (filePath === 'total' || typeof entry !== 'object' || entry === null || !entry.lines)
+            continue;
+        files.push({
+            path: filePath,
+            lines: pick(entry.lines),
+            branches: pick(entry.branches),
+            functions: pick(entry.functions),
+            statements: pick(entry.statements ?? entry.lines),
+            uncoveredLines: [],
+            uncoveredBranches: [],
+        });
+    }
+    const sum = (get) => files.reduce((acc, f) => ({ covered: acc.covered + get(f).covered, total: acc.total + get(f).total }), { covered: 0, total: 0 });
+    const pct = (m) => (m.total > 0 ? (m.covered / m.total) * 100 : 0);
+    return {
+        files,
+        summary: {
+            line: pct(sum(f => f.lines)),
+            branch: pct(sum(f => f.branches)),
+            function: pct(sum(f => f.functions)),
+            statement: pct(sum(f => f.statements)),
+            files: files.length,
+        },
+    };
+}
 /**
  * Parse LCOV info format
  */
@@ -175,7 +235,8 @@ export function parseLcovInfo(content) {
                 lines: { covered: linesCovered, total: linesTotal },
                 branches: { covered: branchesCovered, total: branchesTotal },
                 functions: { covered: functionsCovered, total: functionsTotal },
-                statements: { covered: linesCovered, total: linesTotal },
+                // #1027 N7: lcov has no statement detail — not collected, not a copy of lines.
+                statements: { covered: 0, total: 0 },
                 uncoveredLines: Array.from(new Set(uncoveredLines)),
                 uncoveredBranches: Array.from(new Set(uncoveredBranches)),
             });
@@ -312,7 +373,8 @@ export function parseCoberturaXml(content) {
             lines: { covered: linesCovered, total: linesTotal },
             branches: { covered: branchesCovered, total: branchesTotal },
             functions: { covered: functionsCovered, total: functionsTotal },
-            statements: { covered: linesCovered, total: linesTotal },
+            // #1027 N7: Cobertura has no statement detail — not collected.
+            statements: { covered: 0, total: 0 },
             uncoveredLines,
             uncoveredBranches,
         });
@@ -406,11 +468,16 @@ export async function discoverSourceFiles(targetPath, options = {}) {
                     if (['node_modules', '.git', 'dist', 'build', 'coverage', '.nyc_output',
                         '__pycache__', '.venv', 'venv', '.tox', '.mypy_cache', 'target',
                         '.gradle', 'vendor', '.bundle',
-                        '.agentic-qe', '.claude', '.cache', '.npm', '.yarn',
+                        '.cache', '.npm', '.yarn',
                         '.next', '.nuxt', '.svelte-kit', 'out', '.turbo',
                         'tmp', 'temp', '.tmp'].includes(entry.name)) {
                         continue;
                     }
+                    // #999: AQE state/assets are not source: .agentic-qe anywhere; .claude at
+                    // the root or next to a nested .agentic-qe. A plugin's own .claude/hooks
+                    // source (no AQE install beside it) is kept.
+                    if (isAqeManagedDir(dir, entry.name, dir === targetPath))
+                        continue;
                     if (files.length >= maxFiles)
                         return; // Cap reached
                     await walkDir(fullPath);