agentic-qe 3.15.4 → 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/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>>;

package/dist/domains/coverage-analysis/services/coverage-analyzer.js

@@ -10,6 +10,17 @@ import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
+/**
+ * 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 function isMeasuredCoverage(request) {
+    if (typeof request.measured === 'boolean')
+        return request.measured;
+    return request.coverageData.instrumented === true;
+}
 const DEFAULT_CONFIG = {
     defaultThreshold: 80,
     enableLLMAnalysis: true, // On by default - opt-out
@@ -66,22 +77,30 @@ export class CoverageAnalyzerService {
             // Check if coverage meets threshold
             const overallCoverage = this.calculateOverallCoverage(summary);
             const meetsThreshold = overallCoverage >= threshold;
+            // #1008: only instrumented coverage is evidence. A static estimate is
+            // analyzed and returned to the caller, but never compared against or
+            // written over a measurement, and never stored where a quality gate,
+            // quality_assess or another reader would take it as measured.
+            const measured = isMeasuredCoverage(request);
             // Calculate delta from previous coverage (if stored)
-            const delta = await this.calculateDelta(summary);
+            const delta = measured ? await this.calculateDelta(summary) : undefined;
             // Generate recommendations based on analysis
             const recommendations = this.generateRecommendations(coverageData, summary, threshold);
-            // Store current coverage for future delta calculations
-            await this.storeCoverageSnapshot(summary);
-            // Store coverage vectors for similarity search + KV for quality-analyzer
-            if (request.includeFileDetails) {
-                await this.indexFileCoverageVectors(coverageData.files);
-                await this.storeFileCoverageKV(coverageData.files);
+            if (measured) {
+                // Store current coverage for future delta calculations
+                await this.storeCoverageSnapshot(summary);
+                // Store coverage vectors for similarity search + KV for quality-analyzer
+                if (request.includeFileDetails) {
+                    await this.indexFileCoverageVectors(coverageData.files);
+                    await this.storeFileCoverageKV(coverageData.files);
+                }
             }
             return ok({
                 summary,
                 meetsThreshold,
                 delta,
                 recommendations,
+                measured,
             });
         }
         catch (error) {
@@ -440,8 +459,9 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
             if (existing) {
                 await this.memory.set('coverage:previous', existing, { persist: true });
             }
-            // Store latest snapshot
-            await this.memory.set('coverage:latest', summary, { persist: true });
+            // Store latest snapshot, stamped with its provenance (#1008). Only
+            // measured coverage reaches this method.
+            await this.memory.set('coverage:latest', { ...summary, measured: true }, { persist: true });
             await writeQualityEvidence(this.memory, { coverage: summary.line }, {
                 measuredAt: new Date().toISOString(),
                 source: 'coverage-analysis',

package/dist/domains/quality-assessment/coordinator-claim-verifier.js

@@ -104,7 +104,8 @@ export function convertToQEReport(report, type) {
             },
         });
     }
-    if (report.score.coverage < 80) {
+    // #996: -1 means coverage was not measured; it is not a "-1%" coverage claim.
+    if (report.score.coverage >= 0 && report.score.coverage < 80) {
         claims.push({
             id: `coverage-${Date.now()}`,
             type: 'coverage-claim',

package/dist/domains/quality-assessment/coordinator.js

@@ -33,6 +33,7 @@ import { DEFAULT_RATCHET_CONFIG, } from './coherence/types.js';
 import { getWitnessChain } from '../../audit/witness-chain.js';
 // Three-loop feature flag for instantAdapt protocol
 import { isSONAThreeLoopEnabled } from '../../integrations/ruvector/feature-flags.js';
+import { measuredCoverageSummary } from './coverage-report-event.js';
 // CQ-002: Base domain coordinator
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 const DEFAULT_CONFIG = {
@@ -819,15 +820,14 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
     }
     async handleCoverageReportCreated(event) {
         // Store coverage data for quality assessment
-        const payload = event.payload;
+        // #1008: only a report explicitly marked measured is coverage evidence.
+        // Estimates and look-alike events with no coverage figures (e.g. bridged
+        // captured experiences) must never touch `coverage:latest`.
+        const summary = measuredCoverageSummary(event.payload);
+        if (!summary)
+            return;
         // Store under the canonical coverage key so quality-analyzer can read it
-        await this.memory.set('coverage:latest', {
-            line: payload.line,
-            branch: payload.branch,
-            function: 0,
-            statement: 0,
-            files: 0,
-        }, { persist: true });
+        await this.memory.set('coverage:latest', summary, { persist: true });
     }
     async handleSecurityAuditCompleted(event) {
         // Store security findings for deployment decisions

package/dist/domains/quality-assessment/coverage-report-event.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Validation of `coverage-analysis.CoverageReportCreated` payloads before the
+ * quality-assessment domain stores them as `coverage:latest` (#1008).
+ *
+ * Only a report its producer explicitly marked `measured: true`, carrying
+ * finite coverage figures, is coverage evidence. Anything else — a static
+ * estimate, a legacy event without provenance, or a look-alike event with no
+ * coverage figures at all — is ignored rather than written as zeros.
+ */
+/** The `coverage:latest` record written from a measured coverage report. */
+export interface MeasuredCoverageSummary {
+    line: number;
+    branch: number;
+    function: number;
+    statement: number;
+    files: number;
+    /** Provenance stamp: this record came from instrumented coverage. */
+    measured: true;
+}
+/**
+ * Return the measured summary to store, or `null` when the payload is not
+ * measured coverage evidence.
+ */
+export declare function measuredCoverageSummary(payload: unknown): MeasuredCoverageSummary | null;
+//# sourceMappingURL=coverage-report-event.d.ts.map

package/dist/domains/quality-assessment/coverage-report-event.js

@@ -0,0 +1,36 @@
+/**
+ * Validation of `coverage-analysis.CoverageReportCreated` payloads before the
+ * quality-assessment domain stores them as `coverage:latest` (#1008).
+ *
+ * Only a report its producer explicitly marked `measured: true`, carrying
+ * finite coverage figures, is coverage evidence. Anything else — a static
+ * estimate, a legacy event without provenance, or a look-alike event with no
+ * coverage figures at all — is ignored rather than written as zeros.
+ */
+const isPercent = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 100;
+/**
+ * Return the measured summary to store, or `null` when the payload is not
+ * measured coverage evidence.
+ */
+export function measuredCoverageSummary(payload) {
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const p = payload;
+    if (p.measured !== true)
+        return null;
+    if (!isPercent(p.line) || !isPercent(p.branch) || !isPercent(p.function) || !isPercent(p.statement)) {
+        return null;
+    }
+    const files = typeof p.files === 'number' && Number.isInteger(p.files) && p.files >= 0 ? p.files : null;
+    if (files === null)
+        return null;
+    return {
+        line: p.line,
+        branch: p.branch,
+        function: p.function,
+        statement: p.statement,
+        files,
+        measured: true,
+    };
+}
+//# sourceMappingURL=coverage-report-event.js.map

package/dist/domains/quality-assessment/evidence-sufficiency.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Evidence sufficiency for static quality analysis (#996).
+ *
+ * The static analyzer marks metrics it could not measure with the `-1`
+ * sentinel (or omits them). Such metrics must never be read as numbers that
+ * support a verdict: a pass computed without them is a pass on missing data.
+ */
+import { INSUFFICIENT_EVIDENCE, type QualityThresholdOverrides } from './quality-evidence.js';
+/** `measured`: every requested metric has data. Otherwise no verdict may approve. */
+export type StaticEvidenceStatus = 'measured' | typeof INSUFFICIENT_EVIDENCE;
+/** Metric names the static quality analysis understands. */
+export declare const STATIC_QUALITY_METRICS: readonly ["coverage", "complexity", "maintainability", "duplication", "testability", "security"];
+/**
+ * #996: the coverage threshold that applies to a static assessment — the
+ * request's threshold, else the user-configured gate threshold, else the
+ * canonical default (undefined = use the default).
+ */
+export declare function resolveCoverageOverride(requested: number | undefined, configured: number | undefined): number | undefined;
+export interface MeasuredFailure {
+    metric: string;
+    value: number;
+    threshold: number;
+    direction: 'min' | 'max';
+}
+export interface EvidenceSufficiency {
+    evidenceStatus: StaticEvidenceStatus;
+    /** Requested metrics backed by measured data. */
+    measured: string[];
+    /** Requested metrics with no measured data (missing, `-1`, or non-finite). */
+    unmeasured: string[];
+    /** Share of requested metrics that were measured, in [0, 1], two decimals. */
+    confidence: number;
+}
+/** A metric value is measured only if it is a finite, non-negative number. */
+export declare function isMeasuredMetricValue(value: unknown): value is number;
+/**
+ * #996 (N3): `metrics` must be a non-empty string[] of known names. A bare
+ * string would otherwise be spread into characters. Returns the de-duplicated
+ * list, or throws a caller-facing validation error.
+ */
+export declare function validateRequestedMetrics(metrics: unknown): string[];
+/**
+ * Decide whether static analysis measured every requested metric.
+ *
+ * @param requested - metric names the caller asked to assess; when empty,
+ *   the measured values themselves define the scope.
+ * @param values - metric values produced by the analyzer (`-1` = unmeasured).
+ */
+export declare function assessEvidenceSufficiency(requested: readonly string[], values: Readonly<Record<string, number | undefined>>): EvidenceSufficiency;
+/**
+ * #996 (N2): measured metrics that already fail their own limit. Such a
+ * failure is conclusive — no unmeasured metric can turn it into a pass.
+ */
+export declare function findMeasuredFailures(measured: readonly string[], values: Readonly<Record<string, number | undefined>>, overrides?: QualityThresholdOverrides): MeasuredFailure[];
+/** Plain-language recommendation for one measured failure. */
+export declare function describeMeasuredFailure(failure: MeasuredFailure): string;
+//# sourceMappingURL=evidence-sufficiency.d.ts.map