agentic-qe 3.15.4 → 3.15.6

package/dist/cli/utils/coverage-verdict.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Agentic QE v3 - Shared CLI coverage verdict (#995, #1010, #1012)
+ *
+ * One resolution and one verdict for every CLI surface that reports coverage
+ * (`aqe coverage`, the `aqe ci` coverage phase), built on the same shared
+ * functions as the MCP `coverage_analyze_sublinear` handler
+ * (`resolveExistingCoverage`, `thresholdVerdict`, `reconcileRecommendations`):
+ *
+ *   - measured   — an instrumented report covers the target: judged on the
+ *                  metrics the report collected (an uncollected metric is null,
+ *                  never 0%, and is left out of the threshold);
+ *   - unmeasured — the report has no entry for the target, the runner ran 0
+ *                  tests, or only test files were reported: no figure, exit 3;
+ *   - estimate   — no report exists, so the CLI shows a labelled STATIC
+ *                  ESTIMATE. It carries no threshold verdict, is never
+ *                  persisted as evidence, and also exits 3: nothing was measured;
+ *   - error      — the target is missing or the given report is unreadable.
+ */
+import { type CoverageData } from './coverage-data.js';
+import { type NoDataReason } from '../../coordination/handlers/coverage-target.js';
+/** `aqe coverage` exit code when no coverage measurement exists for the target (#995). */
+export declare const EXIT_UNMEASURED = 3;
+/** Provenance labels, the same vocabulary as MCP `coverage_analyze_sublinear`. */
+export declare const MEASURED_METHOD = "instrumented-report";
+export declare const ESTIMATE_METHOD = "static-estimation";
+export type CliCoverage = {
+    kind: 'data';
+    data: CoverageData;
+    projectRoot?: string;
+} | {
+    kind: 'no-data';
+    reason: NoDataReason;
+    message: string;
+} | {
+    kind: 'no-sources';
+};
+/**
+ * Resolve the coverage data for a CLI target (#995).
+ *
+ * Uses the SAME resolution and verdict as the MCP handler
+ * (`resolveExistingCoverage`), so CLI and MCP cannot disagree about what a
+ * report says for a target:
+ *   - a coverage report file (lcov.info, coverage-final.json, ...) is parsed
+ *     directly;
+ *   - a directory or source file is scoped against the instrumented report of
+ *     its PROJECT ROOT (nearest package.json/.git above it), not the cwd;
+ *   - with no report at the project root, the CLI falls back to its labelled
+ *     heuristic estimate (the CLI never runs the test suite).
+ */
+export declare function resolveCliCoverageData(targetPath: string, log?: (message: string) => void): Promise<CliCoverage>;
+/** Which optional metrics an instrumented report actually carries. */
+export declare function metricsCollected(data: CoverageData): {
+    branch: boolean;
+    function: boolean;
+    statement: boolean;
+};
+/** The slice of the coverage-analysis domain API the verdict needs. */
+export interface CoverageAnalyzeAPI {
+    analyze(request: {
+        coverageData: CoverageData;
+        threshold?: number;
+        includeFileDetails?: boolean;
+        measured?: boolean;
+        projectRoot?: string;
+    }): Promise<{
+        success: boolean;
+        value?: unknown;
+        error?: Error;
+    }>;
+}
+/** Summary figures; `null` = not collected / not measured — never 0%. */
+export interface NullableSummary {
+    line: number | null;
+    branch: number | null;
+    function: number | null;
+    statement: number | null;
+}
+export type CliCoverageOutcome = {
+    kind: 'no-sources';
+} | {
+    kind: 'error';
+    reason: NoDataReason;
+    message: string;
+} | {
+    kind: 'unmeasured';
+    reason: NoDataReason;
+    message: string;
+} | {
+    kind: 'analysis-failed';
+    message: string;
+} | {
+    kind: 'estimate';
+    data: CoverageData;
+    /** Estimated figures — for display only. */
+    summary: NullableSummary & {
+        files: number;
+    };
+    message: string;
+} | {
+    kind: 'measured';
+    data: CoverageData;
+    summary: NullableSummary & {
+        files: number;
+    };
+    collected: {
+        branch: boolean;
+        function: boolean;
+        statement: boolean;
+    };
+    verdict: {
+        overall: number;
+        meetsThreshold: boolean;
+    };
+    recommendations: string[];
+};
+/** Caller-facing explanation of a static estimate. */
+export declare function estimateMessage(): string;
+/**
+ * Resolve, analyze and judge coverage for a CLI target. Shared by
+ * `aqe coverage` and the `aqe ci` coverage phase.
+ */
+export declare function evaluateCliCoverage(api: CoverageAnalyzeAPI, targetPath: string, threshold: number, log?: (message: string) => void): Promise<CliCoverageOutcome>;
+/**
+ * Exit code: 0 meets (by more than 5%), 1 below / error, 2 within 5% above,
+ * 3 UNMEASURED (not in the report, 0 tests, test-only report, or estimate only).
+ */
+export declare function coverageExitCode(outcome: CliCoverageOutcome, threshold: number): number;
+/** The `-F json` document for an outcome (same shape in every case). */
+export declare function coverageJson(outcome: CliCoverageOutcome, threshold: number, target: string): Record<string, unknown>;
+//# sourceMappingURL=coverage-verdict.d.ts.map

package/dist/cli/utils/coverage-verdict.js

@@ -0,0 +1,193 @@
+/**
+ * Agentic QE v3 - Shared CLI coverage verdict (#995, #1010, #1012)
+ *
+ * One resolution and one verdict for every CLI surface that reports coverage
+ * (`aqe coverage`, the `aqe ci` coverage phase), built on the same shared
+ * functions as the MCP `coverage_analyze_sublinear` handler
+ * (`resolveExistingCoverage`, `thresholdVerdict`, `reconcileRecommendations`):
+ *
+ *   - measured   — an instrumented report covers the target: judged on the
+ *                  metrics the report collected (an uncollected metric is null,
+ *                  never 0%, and is left out of the threshold);
+ *   - unmeasured — the report has no entry for the target, the runner ran 0
+ *                  tests, or only test files were reported: no figure, exit 3;
+ *   - estimate   — no report exists, so the CLI shows a labelled STATIC
+ *                  ESTIMATE. It carries no threshold verdict, is never
+ *                  persisted as evidence, and also exits 3: nothing was measured;
+ *   - error      — the target is missing or the given report is unreadable.
+ */
+import chalk from 'chalk';
+import { walkSourceFiles } from './file-discovery.js';
+import { buildCoverageData, summarizeCoverage } from './coverage-data.js';
+import { describeNoData, reconcileRecommendations, resolveExistingCoverage, thresholdVerdict, } from '../../coordination/handlers/coverage-target.js';
+/** `aqe coverage` exit code when no coverage measurement exists for the target (#995). */
+export const EXIT_UNMEASURED = 3;
+/** Provenance labels, the same vocabulary as MCP `coverage_analyze_sublinear`. */
+export const MEASURED_METHOD = 'instrumented-report';
+export const ESTIMATE_METHOD = 'static-estimation';
+/**
+ * Resolve the coverage data for a CLI target (#995).
+ *
+ * Uses the SAME resolution and verdict as the MCP handler
+ * (`resolveExistingCoverage`), so CLI and MCP cannot disagree about what a
+ * report says for a target:
+ *   - a coverage report file (lcov.info, coverage-final.json, ...) is parsed
+ *     directly;
+ *   - a directory or source file is scoped against the instrumented report of
+ *     its PROJECT ROOT (nearest package.json/.git above it), not the cwd;
+ *   - with no report at the project root, the CLI falls back to its labelled
+ *     heuristic estimate (the CLI never runs the test suite).
+ */
+export async function resolveCliCoverageData(targetPath, log = message => console.log(message)) {
+    const existing = await resolveExistingCoverage(targetPath);
+    if (existing.status === 'target-missing') {
+        return { kind: 'no-data', reason: 'target-missing', message: describeNoData('target-missing', targetPath, null) };
+    }
+    if (existing.status === 'evaluated') {
+        const { evaluation, projectRoot } = existing;
+        if (evaluation.status === 'measured') {
+            const files = evaluation.files;
+            return { kind: 'data', data: { files, summary: summarizeCoverage(files), instrumented: true }, projectRoot };
+        }
+        return { kind: 'no-data', reason: evaluation.reason, message: describeNoData(evaluation.reason, targetPath, projectRoot) };
+    }
+    const sourceFiles = walkSourceFiles(existing.target, { includeTests: false });
+    if (sourceFiles.length === 0)
+        return { kind: 'no-sources' };
+    log(chalk.gray(`  Analyzing ${sourceFiles.length} files...\n`));
+    return { kind: 'data', data: buildCoverageData(sourceFiles, existing.projectRoot), projectRoot: existing.projectRoot };
+}
+/** Which optional metrics an instrumented report actually carries. */
+export function metricsCollected(data) {
+    return {
+        branch: data.files.some(f => f.branches.total > 0),
+        function: data.files.some(f => f.functions.total > 0),
+        // #1027 N7: lcov / Cobertura carry no statement detail.
+        statement: data.files.some(f => f.statements.total > 0),
+    };
+}
+const isError = (reason) => reason === 'target-missing' || reason === 'unreadable-report';
+/** Caller-facing explanation of a static estimate. */
+export function estimateMessage() {
+    return 'UNMEASURED: no coverage report exists for this project, so these figures are a ' +
+        'STATIC ESTIMATE derived from source shape — not measured coverage. No threshold verdict ' +
+        'is given and nothing is stored as evidence. Run your tests with coverage first ' +
+        '(e.g. `npm test -- --coverage`) and re-run.';
+}
+/**
+ * Resolve, analyze and judge coverage for a CLI target. Shared by
+ * `aqe coverage` and the `aqe ci` coverage phase.
+ */
+export async function evaluateCliCoverage(api, targetPath, threshold, log) {
+    const resolved = await resolveCliCoverageData(targetPath, log);
+    if (resolved.kind === 'no-sources')
+        return resolved;
+    if (resolved.kind === 'no-data') {
+        return isError(resolved.reason)
+            ? { kind: 'error', reason: resolved.reason, message: resolved.message }
+            : { kind: 'unmeasured', reason: resolved.reason, message: resolved.message };
+    }
+    const data = resolved.data;
+    const measured = data.instrumented;
+    // #1008: a heuristic estimate is shown, never persisted as coverage evidence.
+    const result = await api.analyze({
+        coverageData: data, threshold, includeFileDetails: true, measured,
+        ...(resolved.projectRoot ? { projectRoot: resolved.projectRoot } : {}),
+    });
+    if (!result.success || !result.value) {
+        return { kind: 'analysis-failed', message: result.error?.message || 'Coverage analysis failed' };
+    }
+    const report = result.value;
+    if (!measured) {
+        return { kind: 'estimate', data, summary: { ...report.summary }, message: estimateMessage() };
+    }
+    // #995 review NB5: a metric the report never collected is null — not 0 —
+    // and is left out of the threshold verdict (same rule as MCP).
+    const collected = metricsCollected(data);
+    const verdict = thresholdVerdict(report.summary, threshold, collected);
+    return {
+        kind: 'measured',
+        data,
+        collected,
+        verdict,
+        summary: {
+            ...report.summary,
+            branch: collected.branch ? report.summary.branch : null,
+            function: collected.function ? report.summary.function : null,
+            statement: collected.statement ? report.summary.statement : null,
+        },
+        // NB-A: the shortfall advice comes from the same verdict (shared with MCP).
+        recommendations: reconcileRecommendations(report.recommendations ?? [], verdict, threshold, collected),
+    };
+}
+/**
+ * Exit code: 0 meets (by more than 5%), 1 below / error, 2 within 5% above,
+ * 3 UNMEASURED (not in the report, 0 tests, test-only report, or estimate only).
+ */
+export function coverageExitCode(outcome, threshold) {
+    switch (outcome.kind) {
+        case 'measured': {
+            const { overall, meetsThreshold } = outcome.verdict;
+            if (!meetsThreshold)
+                return 1;
+            return overall < threshold + 5 ? 2 : 0;
+        }
+        case 'estimate':
+        case 'unmeasured':
+            return EXIT_UNMEASURED;
+        case 'no-sources':
+            return 0;
+        default:
+            return 1;
+    }
+}
+/** The `-F json` document for an outcome (same shape in every case). */
+export function coverageJson(outcome, threshold, target) {
+    const nulls = { line: null, branch: null, function: null, statement: null };
+    switch (outcome.kind) {
+        case 'measured':
+            return {
+                summary: outcome.summary,
+                meetsThreshold: outcome.verdict.meetsThreshold,
+                threshold,
+                recommendations: outcome.recommendations,
+                measured: true,
+                estimated: false,
+                coverageMethod: MEASURED_METHOD,
+                branchDataCollected: outcome.collected.branch,
+                functionDataCollected: outcome.collected.function,
+                statementDataCollected: outcome.collected.statement,
+                ...(outcome.data.unmeasuredFiles?.length ? { unmeasuredFiles: outcome.data.unmeasuredFiles } : {}),
+            };
+        case 'estimate':
+            return {
+                summary: outcome.summary,
+                meetsThreshold: null,
+                threshold,
+                measured: false,
+                estimated: true,
+                unmeasured: true,
+                coverageMethod: ESTIMATE_METHOD,
+                reason: 'no-coverage-report',
+                target,
+                warning: outcome.message,
+            };
+        case 'unmeasured':
+        case 'error':
+            return {
+                summary: nulls,
+                meetsThreshold: null,
+                threshold,
+                measured: false,
+                unmeasured: outcome.kind === 'unmeasured',
+                reason: outcome.reason,
+                target,
+                warning: outcome.message,
+            };
+        case 'analysis-failed':
+            return { summary: nulls, meetsThreshold: null, threshold, measured: false, target, error: outcome.message };
+        case 'no-sources':
+            return { summary: nulls, meetsThreshold: null, threshold, measured: false, target, warning: 'No source files found' };
+    }
+}
+//# sourceMappingURL=coverage-verdict.js.map

package/dist/cli/utils/file-discovery.js

@@ -8,6 +8,7 @@
  */
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join, extname } from 'path';
+import { isAqeManagedDir } from '../../shared/aqe-managed-dirs.js';
 // ============================================================================
 // Source File Extensions by Language
 // ============================================================================
@@ -77,6 +78,10 @@ export function walkSourceFiles(targetPath, options = {}) {
             if (entry.isDirectory()) {
                 if (SKIP_DIRS.has(entry.name))
                     continue;
+                // #999: AQE state/assets are not source (.agentic-qe anywhere; .claude
+                // at the root or next to a nested .agentic-qe)
+                if (isAqeManagedDir(dir, entry.name, depth === 0))
+                    continue;
                 walk(join(dir, entry.name), depth + 1);
             }
             else if (entry.isFile()) {

package/dist/contracts/verdicts.d.ts

@@ -58,14 +58,28 @@ export interface ValidationResult {
 export declare function validateRiskDecision(value: unknown): ValidationResult;
 export declare function validateFindingVerdict(value: unknown): ValidationResult;
 export declare function validateCoverageGap(value: unknown): ValidationResult;
+/** #996: confidence cap for an approve that rests on static analysis alone (no gate). */
+export declare const STATIC_APPROVAL_CONFIDENCE = 0.7;
 /**
  * Derive a RiskDecision from a quality-gate outcome (quality_assess boundary).
  * Indeterminate gates (passed undefined) escalate rather than guess.
+ *
+ * #996: when key metrics are unmeasured the decision escalates with lowered
+ * confidence, whatever `passed` says — never approve on missing data. When
+ * `gateEvaluated` is false the rationale says plainly that no gate ran.
  */
 export declare function buildRiskDecisionFromQualityGate(input: {
     passed?: boolean;
     qualityScore?: number;
     recommendations?: string[];
+    /** Requested metrics that had no measured data. */
+    unmeasured?: string[];
+    /** Share of requested metrics that were measured, in [0, 1]. */
+    evidenceConfidence?: number;
+    /** False for static analysis: no quality gate was evaluated. */
+    gateEvaluated?: boolean;
+    /** Measured metrics that fail their own limit — conclusive, so the decision blocks. */
+    failedMetrics?: string[];
 }): RiskDecision;
 export declare const RISK_DECISION_SCHEMA: {
     readonly $schema: "http://json-schema.org/draft-07/schema#";

package/dist/contracts/verdicts.js

@@ -176,21 +176,62 @@ export function validateCoverageGap(value) {
 // ============================================================================
 // Builders — derive contract envelopes at MCP boundaries
 // ============================================================================
+/** #996: confidence cap for an approve that rests on static analysis alone (no gate). */
+export const STATIC_APPROVAL_CONFIDENCE = 0.7;
 /**
  * Derive a RiskDecision from a quality-gate outcome (quality_assess boundary).
  * Indeterminate gates (passed undefined) escalate rather than guess.
+ *
+ * #996: when key metrics are unmeasured the decision escalates with lowered
+ * confidence, whatever `passed` says — never approve on missing data. When
+ * `gateEvaluated` is false the rationale says plainly that no gate ran.
  */
 export function buildRiskDecisionFromQualityGate(input) {
-    const { passed, qualityScore, recommendations = [] } = input;
+    const { passed, qualityScore, recommendations = [], unmeasured = [], failedMetrics = [], gateEvaluated, } = input;
+    const noGate = gateEvaluated === false ? ' (no quality gate was evaluated)' : '';
+    const score = typeof qualityScore === 'number' ? ` with score ${qualityScore}` : '';
+    // A measured failure cannot be rescued by metrics that were never measured.
+    if (failedMetrics.length > 0) {
+        const missing = unmeasured.length > 0 ? `; also unmeasured: ${unmeasured.join(', ')}` : '';
+        return {
+            contract: 'risk-decision@1',
+            decision: 'block',
+            riskFactors: [
+                `failed: ${failedMetrics.join(', ')}`,
+                ...(unmeasured.length > 0 ? [`unmeasured: ${unmeasured.join(', ')}`] : []),
+                ...recommendations,
+            ].slice(0, 10),
+            confidence: 0.9,
+            rationale: `Measured ${failedMetrics.join(', ')} failed its threshold${missing}${noGate}`,
+        };
+    }
+    if (unmeasured.length > 0) {
+        const share = typeof input.evidenceConfidence === 'number' && Number.isFinite(input.evidenceConfidence)
+            ? Math.min(1, Math.max(0, input.evidenceConfidence))
+            : 0;
+        return {
+            contract: 'risk-decision@1',
+            decision: 'escalate',
+            riskFactors: [`unmeasured: ${unmeasured.join(', ')}`, ...recommendations].slice(0, 10),
+            confidence: Math.round(0.5 * share * 100) / 100,
+            rationale: `Insufficient evidence: ${unmeasured.join(', ')} not measured${noGate} — `
+                + 'measure the missing metrics or run the measured quality gate before deciding',
+        };
+    }
     const decision = passed === true ? 'approve' : passed === false ? 'block' : 'escalate';
+    const subject = gateEvaluated === false ? 'Static analysis' : 'Quality gate';
+    // #996 (N1): an approval no gate evaluated is weaker evidence than a gate pass.
+    const confidence = decision === 'escalate'
+        ? 0.5
+        : decision === 'approve' && gateEvaluated === false ? STATIC_APPROVAL_CONFIDENCE : 0.9;
     return {
         contract: 'risk-decision@1',
         decision,
         riskFactors: recommendations.slice(0, 10),
-        confidence: decision === 'escalate' ? 0.5 : 0.9,
+        confidence,
         rationale: decision === 'escalate'
             ? 'Quality gate outcome indeterminate — manual review required'
-            : `Quality gate ${passed ? 'passed' : 'failed'}${typeof qualityScore === 'number' ? ` with score ${qualityScore}` : ''}`,
+            : `${subject} ${passed ? 'passed' : 'failed'}${score}${noGate}`,
     };
 }
 // ============================================================================

package/dist/coordination/deterministic-actions.js

@@ -10,6 +10,7 @@
  * for live metrics — keeping execution fully deterministic (SQL-only).
  */
 import { ok } from '../shared/types/index.js';
+import { MEASURED_COVERAGE_SESSION_SQL } from '../feedback/coverage-session-provenance.js';
 function tryGetDb() {
     try {
         // Dynamic import to avoid hard dependency — the module may not be initialised
@@ -45,8 +46,10 @@ const qualityGateCheck = {
                 try {
                     // Latest coverage from coverage_sessions
                     if (currentCoverage === null) {
-                        const row = db.prepare(`SELECT after_lines FROM coverage_sessions ORDER BY created_at DESC LIMIT 1`).get();
-                        currentCoverage = row?.after_lines ?? 0;
+                        // #1014: skip legacy estimate/unmeasured rows without provenance.
+                        const row = db.prepare(`SELECT after_lines FROM coverage_sessions WHERE ${MEASURED_COVERAGE_SESSION_SQL} ORDER BY created_at DESC LIMIT 1`).get();
+                        // #1027 N6: no measured session → unmeasured (null), never 0%.
+                        currentCoverage = typeof row?.after_lines === 'number' ? row.after_lines : null;
                     }
                     // Test pass rate from recent test_outcomes
                     if (currentTestsPassingRate === null) {
@@ -70,16 +73,17 @@ const qualityGateCheck = {
                 }
             }
         }
-        // Apply defaults for anything still null
-        currentCoverage = currentCoverage ?? 0;
+        // Apply defaults for anything still null — except coverage (#1027 N6):
+        // unmeasured coverage stays null and fails its check (no evidence ≠ 0%).
+        const coverageMeasured = currentCoverage !== null;
         currentTestsPassingRate = currentTestsPassingRate ?? 0;
         currentBugs = currentBugs ?? 0;
-        const coveragePassed = currentCoverage >= coverageMin;
+        const coveragePassed = currentCoverage !== null && currentCoverage >= coverageMin;
         const testsPassed = currentTestsPassingRate >= testsPassingMin;
         const bugsPassed = currentBugs <= maxBugs;
         const passed = coveragePassed && testsPassed && bugsPassed;
         // Score is a normalized 0-1 value
-        const coverageScore = Math.min(currentCoverage / coverageMin, 1);
+        const coverageScore = currentCoverage === null ? 0 : Math.min(currentCoverage / coverageMin, 1);
         const testsScore = Math.min(currentTestsPassingRate / testsPassingMin, 1);
         const bugsScore = maxBugs > 0 ? Math.max(0, 1 - currentBugs / maxBugs) : (currentBugs === 0 ? 1 : 0);
         const score = (coverageScore + testsScore + bugsScore) / 3;
@@ -88,7 +92,10 @@ const qualityGateCheck = {
             score: Math.round(score * 100) / 100,
             source: typeof input.currentCoverage === 'number' ? 'input' : 'database',
             details: {
-                coverage: { current: currentCoverage, threshold: coverageMin, passed: coveragePassed },
+                coverage: {
+                    current: currentCoverage, threshold: coverageMin, passed: coveragePassed,
+                    ...(coverageMeasured ? {} : { unmeasured: true }),
+                },
                 testsPassing: { current: currentTestsPassingRate, threshold: testsPassingMin, passed: testsPassed },
                 bugs: { current: currentBugs, threshold: maxBugs, passed: bugsPassed },
             },
@@ -112,25 +119,29 @@ const coverageThresholdCheck = {
             const db = tryGetDb();
             if (db) {
                 try {
-                    const row = db.prepare(`SELECT after_lines FROM coverage_sessions ORDER BY created_at DESC LIMIT 1`).get();
-                    currentCoverage = row?.after_lines ?? 0;
+                    // #1014: skip legacy estimate/unmeasured rows without provenance.
+                    const row = db.prepare(`SELECT after_lines FROM coverage_sessions WHERE ${MEASURED_COVERAGE_SESSION_SQL} ORDER BY created_at DESC LIMIT 1`).get();
+                    // #1027 N6: no measured session → unmeasured (null), never 0%.
+                    currentCoverage = typeof row?.after_lines === 'number' ? row.after_lines : null;
                 }
                 catch {
-                    currentCoverage = 0;
+                    currentCoverage = null;
                 }
             }
             else {
-                currentCoverage = 0;
+                currentCoverage = null;
             }
         }
-        const passed = currentCoverage >= minCoverage;
-        const gap = passed ? 0 : Math.round((minCoverage - currentCoverage) * 100) / 100;
+        // Unmeasured coverage fails the check (no evidence), with no fake gap.
+        const passed = currentCoverage !== null && currentCoverage >= minCoverage;
+        const gap = currentCoverage === null ? null : passed ? 0 : Math.round((minCoverage - currentCoverage) * 100) / 100;
         return ok({
             currentCoverage,
             passed,
             gap,
             minCoverage,
             source,
+            ...(currentCoverage === null ? { unmeasured: true } : {}),
         });
     },
 };

package/dist/coordination/handlers/code-intelligence-handlers.d.ts

@@ -5,5 +5,13 @@
  * Covers: index-code, predict-defects
  */
 import type { TaskHandlerContext } from './handler-types';
+/** Project metric summary returned by the MCP index-code handler (#999). */
+export interface IndexProjectMetricsSummary {
+    root: string;
+    loc: number;
+    locByLanguage: Record<string, number>;
+    tests: number;
+    toolsUsed: string[];
+}
 export declare function registerCodeIntelligenceHandlers(ctx: TaskHandlerContext): void;
 //# sourceMappingURL=code-intelligence-handlers.d.ts.map

package/dist/coordination/handlers/code-intelligence-handlers.js

@@ -9,6 +9,39 @@ import * as path from 'path';
 import { ok, err } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
 import { discoverSourceFiles } from './handler-utils.js';
+import { resolveProjectRootFromPaths } from '../../domains/code-intelligence/project-root-resolver.js';
+import { createLogger } from '../../logging/logger-factory.js';
+const logger = createLogger('CodeIntelligenceHandlers');
+async function collectProjectMetricsForTarget(ctx, targetPath, indexedFiles) {
+    if (!ctx.getCodeIntelligenceCoordinator)
+        return undefined;
+    const root = resolveProjectRootFromPaths(indexedFiles, { target: path.resolve(targetPath) });
+    if (!root) {
+        logger.debug('Skipping project metrics: no project root resolved (filesystem root or no paths)');
+        return undefined;
+    }
+    try {
+        const coordinator = await ctx.getCodeIntelligenceCoordinator();
+        if (!coordinator)
+            return undefined;
+        const metrics = await coordinator.collectProjectMetrics(root);
+        if (!metrics.success) {
+            logger.debug(`Project metrics unavailable: ${metrics.error.message}`);
+            return undefined;
+        }
+        return {
+            root,
+            loc: metrics.value.loc.total,
+            locByLanguage: metrics.value.loc.byLanguage,
+            tests: metrics.value.tests.total,
+            toolsUsed: metrics.value.toolsUsed,
+        };
+    }
+    catch (error) {
+        logger.debug(`Project metrics unavailable: ${toError(error).message}`);
+        return undefined;
+    }
+}
 export function registerCodeIntelligenceHandlers(ctx) {
     // Register code indexing handler - REAL IMPLEMENTATION
     ctx.registerHandler('index-code', async (task) => {
@@ -45,6 +78,11 @@ export function registerCodeIntelligenceHandlers(ctx) {
                 return result;
             }
             const indexResult = result.value;
+            // #999 MCP-CLI parity: `aqe code index` runs the coordinator's project
+            // metric step (LOC, tests, tools); run the same step here, rooted at the
+            // caller's target the way #997 resolves it. Best-effort: indexing has
+            // already succeeded, so a metric failure only omits projectMetrics.
+            const projectMetrics = await collectProjectMetricsForTarget(ctx, targetPath, filesToIndex);
             // Detect languages from files
             const detectedLanguages = new Set();
             const extToLang = {
@@ -78,6 +116,7 @@ export function registerCodeIntelligenceHandlers(ctx) {
                 duration: indexResult.duration,
                 errors: indexResult.errors,
                 warnings: indexResult.warnings,
+                ...(projectMetrics ? { projectMetrics } : {}),
             });
         }
         catch (error) {