agentic-qe 3.15.3 → 3.15.5

package/dist/domains/code-intelligence/coordinator.js

@@ -6,7 +6,7 @@
  * - QEGNNEmbeddingIndex: Code graph embeddings with HNSW for fast similarity search
  * - QESONA: Learns and adapts code patterns for improved intelligence
  */
-import { existsSync } from 'node:fs';
+import { resolveProjectRootFromPaths } from './project-root-resolver.js';
 import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { err } from '../../shared/types/index.js';
@@ -300,11 +300,14 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
                 this.updateWorkflowProgress(workflowId, 60);
                 // V3: Collect real project metrics using actual tooling (Phase 5)
                 if (this.config.enableMetricCollector && this.metricCollector && request.paths.length > 0) {
-                    // Determine project root from first path
-                    const projectPath = this.getProjectRootFromPaths(request.paths);
+                    // Determine project root from the caller's target (or the indexed paths)
+                    const projectPath = this.getProjectRootFromPaths(request.paths, request.target);
                     if (projectPath) {
                         await this.collectProjectMetrics(projectPath);
                     }
+                    else {
+                        logger.debug('Skipping project metrics: no project root resolved (filesystem root or no paths)');
+                    }
                 }
                 this.updateWorkflowProgress(workflowId, 70);
                 // Index content for semantic search
@@ -941,36 +944,11 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
         return this.metricCollector;
     }
     /**
-     * Determine project root from indexed paths
+     * Determine project root from indexed paths (nearest marker, bottom-up; #994).
+     * Relative paths resolve against the process cwd, matching the CLI/MCP callers.
      */
-    getProjectRootFromPaths(paths) {
-        if (paths.length === 0)
-            return null;
-        // Get the first path and find the project root
-        const firstPath = paths[0];
-        // Walk up the path to find package.json, Cargo.toml, go.mod, etc.
-        const parts = firstPath.split('/');
-        let currentPath = '';
-        for (const part of parts) {
-            currentPath = currentPath ? `${currentPath}/${part}` : part;
-            // Check for common project markers
-            const markers = ['package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml', '.git'];
-            for (const marker of markers) {
-                try {
-                    const markerPath = `${currentPath}/${marker}`;
-                    // Synchronous existence check (we're in an async context anyway).
-                    if (existsSync(markerPath)) {
-                        return currentPath;
-                    }
-                }
-                catch {
-                    // Continue checking
-                }
-            }
-        }
-        // If no marker found, return the parent directory of the first path
-        const lastSlash = firstPath.lastIndexOf('/');
-        return lastSlash > 0 ? firstPath.substring(0, lastSlash) : firstPath;
+    getProjectRootFromPaths(paths, target) {
+        return resolveProjectRootFromPaths(paths, { target });
     }
     // ============================================================================
     // V3: Hypergraph Integration for Intelligent Code Analysis (GOAP Action 7)

package/dist/domains/code-intelligence/interfaces.d.ts

@@ -17,6 +17,11 @@ export interface CodeIntelligenceAPI {
 }
 export interface IndexRequest {
     paths: string[];
+    /**
+     * The directory or file the caller asked to index, before it was expanded
+     * into `paths`. Used to resolve the project root for metrics (#994).
+     */
+    target?: string;
     incremental?: boolean;
     includeTests?: boolean;
     languages?: string[];

package/dist/domains/code-intelligence/plugin.js

@@ -80,6 +80,7 @@ export class CodeIntelligencePlugin extends BaseDomainPlugin {
                     return this.coordinator.index({
                         paths,
                         languages,
+                        target: typeof payload.target === 'string' ? payload.target : undefined,
                     });
                 }],
             ['search', async (payload) => {

package/dist/domains/code-intelligence/project-root-resolver.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Project root resolution for code-intelligence metric collection (#994).
+ *
+ * `index()` receives an expanded list of files (the CLI walks the target
+ * directory first). When the caller also passes the original `target`, the
+ * walk starts at the target directory (its parent for a file target), so a `.`
+ * at a monorepo root whose source all lives in one package resolves to the
+ * root. Without a target we start from the deepest directory that contains
+ * every indexed path. Either way we walk UP (bottom-up, using `path.dirname`,
+ * so absolute paths and Windows drive roots are handled by the `path` module)
+ * and return the NEAREST directory that holds a project marker.
+ *
+ * Starting from the common directory rather than the first file keeps a stray
+ * marker inside one subtree (for example `.agentic-qe/workers/package.json`)
+ * from capturing an index that spans the whole project.
+ *
+ * When no marker exists anywhere up to the filesystem root, the start
+ * directory itself is returned (the target, the files' common directory, or a
+ * single file's directory). A filesystem or drive root is never returned:
+ * measuring `/` would walk the whole disk, so the result is null instead.
+ *
+ * @module domains/code-intelligence/project-root-resolver
+ */
+import * as path from 'node:path';
+/** Files or directories whose presence marks a project root. */
+export declare const PROJECT_ROOT_MARKERS: readonly string[];
+export interface ResolveProjectRootOptions {
+    /** Base directory for relative inputs. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /** Existence check, injectable for tests. Defaults to `fs.existsSync`. */
+    exists?: (p: string) => boolean;
+    /** Directory check, injectable for tests. Defaults to `fs.statSync(...).isDirectory()`. */
+    isDirectory?: (p: string) => boolean;
+    /** Path implementation. Defaults to the platform `path`; tests pass `path.win32`. */
+    pathImpl?: path.PlatformPath;
+    /**
+     * The directory (or file) the caller asked to index, before expansion. When
+     * set, the walk starts here instead of at the common directory of `paths`.
+     */
+    target?: string;
+}
+/**
+ * Resolve the project root for a set of indexed paths.
+ *
+ * @param paths - Files and/or directories, absolute or relative to `options.cwd`
+ * @returns Absolute project root, or null when there is nothing to resolve or
+ *   the result would be a filesystem/drive root
+ */
+export declare function resolveProjectRootFromPaths(paths: readonly string[], options?: ResolveProjectRootOptions): string | null;
+//# sourceMappingURL=project-root-resolver.d.ts.map

package/dist/domains/code-intelligence/project-root-resolver.js

@@ -0,0 +1,121 @@
+/**
+ * Project root resolution for code-intelligence metric collection (#994).
+ *
+ * `index()` receives an expanded list of files (the CLI walks the target
+ * directory first). When the caller also passes the original `target`, the
+ * walk starts at the target directory (its parent for a file target), so a `.`
+ * at a monorepo root whose source all lives in one package resolves to the
+ * root. Without a target we start from the deepest directory that contains
+ * every indexed path. Either way we walk UP (bottom-up, using `path.dirname`,
+ * so absolute paths and Windows drive roots are handled by the `path` module)
+ * and return the NEAREST directory that holds a project marker.
+ *
+ * Starting from the common directory rather than the first file keeps a stray
+ * marker inside one subtree (for example `.agentic-qe/workers/package.json`)
+ * from capturing an index that spans the whole project.
+ *
+ * When no marker exists anywhere up to the filesystem root, the start
+ * directory itself is returned (the target, the files' common directory, or a
+ * single file's directory). A filesystem or drive root is never returned:
+ * measuring `/` would walk the whole disk, so the result is null instead.
+ *
+ * @module domains/code-intelligence/project-root-resolver
+ */
+import { existsSync, statSync } from 'node:fs';
+import * as path from 'node:path';
+/** Files or directories whose presence marks a project root. */
+export const PROJECT_ROOT_MARKERS = Object.freeze([
+    'package.json',
+    'Cargo.toml',
+    'go.mod',
+    'pyproject.toml',
+    '.git',
+]);
+function defaultIsDirectory(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** True when `child` is `parent` or lies inside it. */
+function isWithin(p, child, parent) {
+    const rel = p.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !p.isAbsolute(rel));
+}
+/**
+ * Deepest directory containing every input directory, or null when the inputs
+ * share no ancestor (for example different Windows drives).
+ */
+function commonAncestor(p, dirs) {
+    let common = dirs[0];
+    for (const dir of dirs.slice(1)) {
+        while (!isWithin(p, dir, common)) {
+            const parent = p.dirname(common);
+            if (parent === common)
+                return null;
+            common = parent;
+        }
+    }
+    return common;
+}
+/** Walk from `startDir` up to the filesystem root; return the nearest marker directory. */
+function findNearestMarkerDir(p, startDir, exists) {
+    let current = startDir;
+    for (;;) {
+        for (const marker of PROJECT_ROOT_MARKERS) {
+            try {
+                if (exists(p.join(current, marker)))
+                    return current;
+            }
+            catch {
+                // Unreadable entry: keep checking the remaining markers.
+            }
+        }
+        const parent = p.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+/**
+ * Resolve the project root for a set of indexed paths.
+ *
+ * @param paths - Files and/or directories, absolute or relative to `options.cwd`
+ * @returns Absolute project root, or null when there is nothing to resolve or
+ *   the result would be a filesystem/drive root
+ */
+export function resolveProjectRootFromPaths(paths, options = {}) {
+    const usable = paths.filter((p) => typeof p === 'string' && p.length > 0);
+    const target = typeof options.target === 'string' && options.target.length > 0 ? options.target : undefined;
+    if (usable.length === 0 && !target)
+        return null;
+    const p = options.pathImpl ?? path;
+    const cwd = options.cwd ?? process.cwd();
+    const exists = options.exists ?? existsSync;
+    const isDirectory = options.isDirectory ?? defaultIsDirectory;
+    // A directory contributes itself; a file contributes its parent directory.
+    const dirOf = (input) => {
+        const abs = p.resolve(cwd, input);
+        return isDirectory(abs) ? abs : p.dirname(abs);
+    };
+    let start;
+    if (target) {
+        // The caller's own target wins over the expanded file list: a `.` at a
+        // monorepo root whose source all lives in packages/a is still the root.
+        start = dirOf(target);
+    }
+    else {
+        const dirs = usable.map(dirOf);
+        // Inputs on different roots (Windows drives): use the first path's directory.
+        start = commonAncestor(p, dirs) ?? dirs[0];
+    }
+    const root = findNearestMarkerDir(p, start, exists) ?? start;
+    // Never measure a whole filesystem / drive root (review N1).
+    return isFilesystemRoot(p, root) ? null : root;
+}
+function isFilesystemRoot(p, dir) {
+    return p.parse(dir).root === dir || p.dirname(dir) === dir;
+}
+//# sourceMappingURL=project-root-resolver.js.map

package/dist/domains/code-intelligence/services/metric-collector/listing-process-owner.d.ts

@@ -0,0 +1,3 @@
+/** Register a process-tree owner, returning an idempotent release callback. */
+export declare function ownListingProcess(directory: string, stopTree: () => void): () => void;
+//# sourceMappingURL=listing-process-owner.d.ts.map

package/dist/domains/code-intelligence/services/metric-collector/listing-process-owner.js

@@ -0,0 +1,57 @@
+/**
+ * Own detached listing subprocesses until completion or caller termination.
+ * Normal attempt completion removes the handlers; interrupted callers must
+ * synchronously kill every owned group before deleting listing artifacts.
+ */
+import { rmSync } from 'node:fs';
+const owners = new Set();
+const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+function removeHandlers() {
+    process.removeListener('exit', cleanup);
+    for (const signal of signals)
+        process.removeListener(signal, signalHandlers[signal]);
+}
+function cleanup() {
+    const pending = [...owners];
+    owners.clear();
+    for (const owner of pending) {
+        try {
+            owner.stopTree();
+        }
+        catch { /* Continue terminating other owned trees. */ }
+    }
+    for (const directory of new Set(pending.map(owner => owner.directory))) {
+        try {
+            rmSync(directory, { recursive: true, force: true });
+        }
+        catch { /* Best effort during exit. */ }
+    }
+}
+function interrupted(signal) {
+    cleanup();
+    removeHandlers();
+    // Restore signal termination (including its exit status) instead of swallowing
+    // Ctrl-C or converting a requested shutdown into a successful metrics result.
+    process.kill(process.pid, signal);
+}
+const signalHandlers = {
+    SIGINT: () => interrupted('SIGINT'),
+    SIGTERM: () => interrupted('SIGTERM'),
+    SIGHUP: () => interrupted('SIGHUP'),
+};
+/** Register a process-tree owner, returning an idempotent release callback. */
+export function ownListingProcess(directory, stopTree) {
+    if (owners.size === 0) {
+        process.once('exit', cleanup);
+        for (const signal of signals)
+            process.on(signal, signalHandlers[signal]);
+    }
+    const owner = { directory, stopTree };
+    owners.add(owner);
+    return () => {
+        owners.delete(owner);
+        if (owners.size === 0)
+            removeHandlers();
+    };
+}
+//# sourceMappingURL=listing-process-owner.js.map

package/dist/domains/code-intelligence/services/metric-collector/test-counter.js

@@ -12,11 +12,14 @@
  *
  * @see docs/plans/AQE_V3_IMPROVEMENTS_PLAN.md - Phase 5, RM-003
  */
-import { execSync, spawnSync } from 'child_process';
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { join, extname } from 'path';
+import { execSync, spawn, spawnSync } from 'child_process';
+import { createRequire } from 'module';
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, extname, resolve } from 'path';
 import { DEFAULT_METRIC_CONFIG, } from './interfaces.js';
 import { safeJsonParse } from '../../../../shared/safe-json.js';
+import { ownListingProcess } from './listing-process-owner.js';
 // ============================================================================
 // Main Test Counting Function
 // ============================================================================
@@ -177,53 +180,138 @@ export function checkTestRunners(projectPath) {
 // ============================================================================
 /**
  * Count tests using Vitest
- * Uses `vitest list` for accurate test discovery WITHOUT execution.
+ * Uses `vitest list` for accurate test discovery without executing test callbacks.
  *
  * IMPORTANT: We use `vitest list` (not `vitest --run`) because:
  * - `vitest --run` EXECUTES tests, causing OOM in test-of-tests scenarios
- * - `vitest list` only enumerates tests without running them
+ * - Collection imports test modules but does not run test callbacks
  */
-function countVitestTests(projectPath, config) {
+async function countVitestTests(projectPath, config) {
+    let listingDirectory;
     try {
-        // Use vitest list for safe enumeration (NO execution). --json emits one
-        // entry per discovered test in Vitest 4 and 5; --reporter=json does not.
-        const output = execSync('npx vitest list --json', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            timeout: Math.min(config.timeout, 30000), // Cap at 30s for listing
-            maxBuffer: 10 * 1024 * 1024, // 10MB buffer (reduced from 50MB)
-        });
+        let supportsStaticParse = false;
         try {
-            const data = safeJsonParse(output);
-            // Vitest list --json returns a flat array of { name, file, location? }.
-            if (Array.isArray(data) && data.every(test => test && typeof test.name === 'string' && typeof test.file === 'string')) {
-                return classifyTests(data.length, 'vitest', projectPath);
-            }
-            // Preserve compatibility with older structured runner output.
-            if (data && typeof data.numTotalTests === 'number') {
-                return classifyTests(data.numTotalTests, 'vitest', projectPath);
-            }
+            const projectRequire = createRequire(resolve(projectPath, 'package.json'));
+            const pkg = safeJsonParse(readFileSync(projectRequire.resolve('vitest/package.json'), 'utf-8'));
+            const [major, minor] = String(pkg.version).split('.').map(Number);
+            supportsStaticParse = major > 4 || (major === 4 && minor >= 1);
         }
         catch {
-            // JSON parse failed, try line counting
+            // Retain native listing without new flags for unresolved/older runners.
         }
-        // Fallback: count test entries from text output
-        // vitest list outputs lines like "✓ test name" or "○ test name"
-        const lines = output.split('\n');
-        const testLines = lines.filter(line => line.trim().startsWith('✓') ||
-            line.trim().startsWith('○') ||
-            line.includes(' > ') // nested test format: "describe > test name"
-        );
-        if (testLines.length > 0) {
-            return classifyTests(testLines.length, 'vitest', projectPath);
+        listingDirectory = mkdtempSync(join(tmpdir(), 'aqe-vitest-list-'));
+        const readListing = (file) => {
+            try {
+                if (statSync(file).size > 10 * 1024 * 1024)
+                    return undefined;
+                const data = safeJsonParse(readFileSync(file, 'utf-8'));
+                if (Array.isArray(data) && data.every(test => test && typeof test.name === 'string' && typeof test.file === 'string'))
+                    return data.length;
+                if (data && typeof data.numTotalTests === 'number')
+                    return data.numTotalTests;
+            }
+            catch { /* Missing/invalid artifacts are not authoritative counts. */ }
+            return undefined;
+        };
+        const listTests = async (mode) => {
+            // Separate artifacts prevent a failed attempt from contaminating recovery.
+            const file = join(listingDirectory, `${mode}.json`);
+            const args = ['vitest', 'list', `--json=${file}`];
+            if (mode !== 'legacy')
+                args.push(mode === 'static' ? '--static-parse' : '--no-static-parse');
+            const succeeded = await new Promise((resolveAttempt) => {
+                const windows = process.platform === 'win32';
+                // Keep Windows artifact paths in a quoted environment expansion;
+                // interpolating a caller-controlled temporary path into cmd is unsafe.
+                const flag = mode === 'legacy' ? ''
+                    : mode === 'static' ? ' --static-parse' : ' --no-static-parse';
+                const command = windows ? `npx vitest list --json="%AQE_VITEST_LIST_JSON%"${flag}` : 'npx';
+                const child = spawn(command, windows ? [] : args, {
+                    cwd: projectPath, detached: !windows, shell: windows,
+                    env: { ...process.env, AQE_VITEST_LIST_JSON: file },
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                let stopped = false;
+                let bytes = 0;
+                const stopTree = () => {
+                    if (!child.pid)
+                        return;
+                    try {
+                        if (windows) {
+                            // Windows has no POSIX process groups; terminate this owned tree.
+                            spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], {
+                                stdio: 'ignore', timeout: 5000,
+                            });
+                        }
+                        else {
+                            process.kill(-child.pid, 'SIGKILL');
+                        }
+                    }
+                    catch { /* The process group may already have exited. */ }
+                };
+                const releaseOwnership = ownListingProcess(listingDirectory, stopTree);
+                const timer = setTimeout(() => { stopped = true; stopTree(); }, Math.min(config.timeout, 30000));
+                const consume = (chunk) => {
+                    bytes += chunk.length;
+                    if (bytes > 10 * 1024 * 1024) {
+                        stopped = true;
+                        stopTree();
+                    }
+                };
+                child.stdout?.on('data', consume);
+                child.stderr?.on('data', consume);
+                child.once('error', () => { clearTimeout(timer); stopTree(); releaseOwnership(); resolveAttempt(false); });
+                child.once('close', (code) => {
+                    clearTimeout(timer);
+                    // A wrapper may exit while its descendants are still importing modules.
+                    stopTree();
+                    releaseOwnership();
+                    resolveAttempt(!stopped && code === 0);
+                });
+            });
+            return succeeded ? readListing(file) : undefined;
+        };
+        if (!supportsStaticParse) {
+            const total = await listTests('legacy');
+            return total === undefined ? countTestsByFilePattern(projectPath, config)
+                : classifyTests(total, 'vitest', projectPath);
         }
-        // If vitest list produced no usable output, fall back to file pattern
-        return countTestsByFilePattern(projectPath, config);
+        // Inspect cheap static discovery before importing project test modules.
+        // Above 1,000 static declarations or 100 files, retain the native static
+        // count instead of paying the collection timeout for every metrics call.
+        const staticTotal = await listTests('static');
+        const staticFile = join(listingDirectory, 'static.json');
+        let staticFiles = 0;
+        if (staticTotal !== undefined) {
+            try {
+                const data = safeJsonParse(readFileSync(staticFile, 'utf-8'));
+                if (Array.isArray(data))
+                    staticFiles = new Set(data.map(test => test.file)).size;
+            }
+            catch { /* The validated count remains usable. */ }
+            if (staticTotal > 1000 || staticFiles > 100) {
+                return classifyTests(staticTotal, 'vitest', projectPath);
+            }
+        }
+        // Collection expands parameterized/computed declarations but imports every
+        // test module (with setup/describe side effects). One throwing import loses
+        // expansion for the whole suite; preserve its static count when available.
+        const collectedTotal = await listTests('collection');
+        const total = collectedTotal ?? staticTotal;
+        return total === undefined ? countTestsByFilePattern(projectPath, config)
+            : classifyTests(total, 'vitest', projectPath);
     }
     catch {
-        // vitest list failed (not installed, timeout, etc.) - fall back to file pattern
         return countTestsByFilePattern(projectPath, config);
     }
+    finally {
+        if (listingDirectory) {
+            try {
+                rmSync(listingDirectory, { recursive: true, force: true });
+            }
+            catch { /* Cleanup failure must not change an otherwise valid count. */ }
+        }
+    }
 }
 /**
  * Count tests using Jest

package/dist/domains/coverage-analysis/coordinator.js

@@ -361,7 +361,9 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
                 return err(new Error('Coverage analysis paused: topology is in critical state'));
             }
             const result = await this.coverageAnalyzer.analyze(request);
-            if (result.success) {
+            // #1008: subscribers (quality-assessment) store the report as
+            // `coverage:latest`. A static estimate must never reach them.
+            if (result.success && result.value.measured !== false) {
                 // Publish coverage report event
                 await this.publishCoverageReport(result.value);
             }
@@ -613,6 +615,7 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
             function: report.summary.function,
             statement: report.summary.statement,
             files: report.summary.files,
+            measured: true,
         };
         const event = createEvent(CoverageAnalysisEvents.CoverageReportCreated, 'coverage-analysis', payload);
         await this.eventBus.publish(event);

package/dist/domains/coverage-analysis/interfaces.d.ts

@@ -19,10 +19,20 @@ export interface AnalyzeCoverageRequest {
     coverageData: CoverageData;
     threshold?: number;
     includeFileDetails?: boolean;
+    /**
+     * Whether `coverageData` came from instrumentation (#1008). `false` marks a
+     * static estimate: it is analyzed and returned, but never persisted as
+     * `coverage:latest`, history, per-file coverage or quality evidence.
+     * Takes precedence over `coverageData.instrumented`. Fail-closed: when both
+     * are absent the data is treated as UNMEASURED and nothing is persisted.
+     */
+    measured?: boolean;
 }
 export interface CoverageData {
     files: FileCoverage[];
     summary: CoverageSummary;
+    /** Set by producers that know their provenance; `false` = static estimate (#1008). */
+    instrumented?: boolean;
 }
 export interface FileCoverage {
     path: string;
@@ -57,6 +67,11 @@ export interface CoverageReport {
     meetsThreshold: boolean;
     delta?: CoverageDelta;
     recommendations: string[];
+    /**
+     * False when the report was computed from a static estimate (#1008). Such a
+     * report was not persisted and must not be published or stored as evidence.
+     */
+    measured?: boolean;
 }
 export interface CoverageDelta {
     line: number;

package/dist/domains/coverage-analysis/plugin.js

@@ -60,10 +60,16 @@ export class CoverageAnalysisPlugin extends BaseDomainPlugin {
                     this._activeAnalyses++;
                     this.updateAgentMetrics();
                     try {
+                        // #1008: coverage numbers supplied in a task payload (e.g. MCP
+                        // `task_submit`) are caller claims, not an instrumented run. Never
+                        // trust a caller-supplied `measured`/`instrumented` flag: analyze
+                        // and return the data, but do not persist it as coverage evidence.
+                        const { instrumented: _claimed, ...callerData } = coverageData;
                         return await this.coordinator.analyze({
-                            coverageData,
+                            coverageData: callerData,
                             threshold: payload.threshold,
                             includeFileDetails: payload.includeFileDetails,
+                            measured: false,
                         });
                     }
                     finally {

package/dist/domains/coverage-analysis/services/coverage-analyzer.d.ts

@@ -8,6 +8,13 @@ import { Result } from '../../../shared/types';
 import { MemoryBackend } from '../../../kernel/interfaces';
 import { AnalyzeCoverageRequest, CoverageReport, CoverageData, CoverageSummary, CoverageGaps, CoverageGap } from '../interfaces';
 import type { HybridRouter } from '../../../shared/llm';
+/**
+ * Whether an analyze request carries instrumented (measured) coverage (#1008).
+ * Fail-closed: an explicit `request.measured` wins; otherwise only data a
+ * producer marked `instrumented: true` is measured. Anything without
+ * provenance is analyzed and returned, but never persisted as evidence.
+ */
+export declare function isMeasuredCoverage(request: AnalyzeCoverageRequest): boolean;
 export interface ICoverageAnalysisService {
     /** Analyze coverage from reports */
     analyze(request: AnalyzeCoverageRequest): Promise<Result<CoverageReport, Error>>;