agentic-qe 3.15.11 → 3.15.13

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

@@ -8,7 +8,10 @@
  *
  *   - 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);
+ *                  never 0%, and is left out of the threshold). When target
+ *                  files are missing from the report, or the report is older
+ *                  than the sources, the evidence is insufficient (#1154): the
+ *                  threshold is not met and the exit code is 3;
  *   - 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
@@ -18,6 +21,7 @@
  */
 import { type CoverageData } from './coverage-data.js';
 import { type NoDataReason } from '../../coordination/handlers/coverage-target.js';
+import { type CoverageEvidence } from '../../coordination/handlers/coverage-evidence.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`. */
@@ -27,6 +31,7 @@ export type CliCoverage = {
     kind: 'data';
     data: CoverageData;
     projectRoot?: string;
+    evidence?: CoverageEvidence;
 } | {
     kind: 'no-data';
     reason: NoDataReason;
@@ -112,6 +117,9 @@ export type CliCoverageOutcome = {
         meetsThreshold: boolean;
     };
     recommendations: string[];
+    /** #1154: why the report cannot support a verdict for the target; empty when it can. */
+    insufficientEvidence: string[];
+    evidence?: CoverageEvidence;
 };
 /** Caller-facing explanation of a static estimate. */
 export declare function estimateMessage(): string;
@@ -122,7 +130,8 @@ export declare function estimateMessage(): string;
 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).
+ * 3 UNMEASURED (not in the report, 0 tests, test-only report, or estimate only)
+ * or insufficient evidence (target files missing from the report, stale report).
  */
 export declare function coverageExitCode(outcome: CliCoverageOutcome, threshold: number): number;
 /** The `-F json` document for an outcome (same shape in every case). */

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

@@ -8,7 +8,10 @@
  *
  *   - 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);
+ *                  never 0%, and is left out of the threshold). When target
+ *                  files are missing from the report, or the report is older
+ *                  than the sources, the evidence is insufficient (#1154): the
+ *                  threshold is not met and the exit code is 3;
  *   - 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
@@ -20,6 +23,7 @@ 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';
+import { describeEvidence } from '../../coordination/handlers/coverage-evidence.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`. */
@@ -46,8 +50,12 @@ export async function resolveCliCoverageData(targetPath, log = message => consol
     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 };
+            const { files, evidence } = evaluation;
+            const data = {
+                files, summary: summarizeCoverage(files), instrumented: true,
+                ...(evidence.unmeasuredFiles.length > 0 ? { unmeasuredFiles: evidence.unmeasuredFiles } : {}),
+            };
+            return { kind: 'data', data, projectRoot, evidence };
         }
         return { kind: 'no-data', reason: evaluation.reason, message: describeNoData(evaluation.reason, targetPath, projectRoot) };
     }
@@ -104,12 +112,17 @@ export async function evaluateCliCoverage(api, targetPath, threshold, log) {
     // #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);
+    const figures = thresholdVerdict(report.summary, threshold, collected);
+    // #1154: figures over part of the target, or from a stale report, never meet the threshold.
+    const insufficientEvidence = describeEvidence(resolved.evidence, resolved.projectRoot ?? targetPath);
+    const verdict = { ...figures, meetsThreshold: figures.meetsThreshold && insufficientEvidence.length === 0 };
     return {
         kind: 'measured',
         data,
         collected,
         verdict,
+        insufficientEvidence,
+        ...(resolved.evidence ? { evidence: resolved.evidence } : {}),
         summary: {
             ...report.summary,
             branch: collected.branch ? report.summary.branch : null,
@@ -117,16 +130,19 @@ export async function evaluateCliCoverage(api, targetPath, threshold, log) {
             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),
+        recommendations: reconcileRecommendations(report.recommendations ?? [], figures, 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).
+ * 3 UNMEASURED (not in the report, 0 tests, test-only report, or estimate only)
+ * or insufficient evidence (target files missing from the report, stale report).
  */
 export function coverageExitCode(outcome, threshold) {
     switch (outcome.kind) {
         case 'measured': {
+            if (outcome.insufficientEvidence.length > 0)
+                return EXIT_UNMEASURED;
             const { overall, meetsThreshold } = outcome.verdict;
             if (!meetsThreshold)
                 return 1;
@@ -158,6 +174,10 @@ export function coverageJson(outcome, threshold, target) {
                 functionDataCollected: outcome.collected.function,
                 statementDataCollected: outcome.collected.statement,
                 ...(outcome.data.unmeasuredFiles?.length ? { unmeasuredFiles: outcome.data.unmeasuredFiles } : {}),
+                ...(outcome.evidence ? { evidenceStatus: outcome.evidence.status } : {}),
+                ...(outcome.evidence?.stale ? { staleReport: outcome.evidence.stale } : {}),
+                ...(outcome.insufficientEvidence.length > 0
+                    ? { warning: `INSUFFICIENT EVIDENCE: ${outcome.insufficientEvidence.join('; ')}` } : {}),
             };
         case 'estimate':
             return {

package/dist/cli/utils/fleet-operation.d.ts

@@ -17,6 +17,11 @@ export interface FleetOperationTask {
     domain: DomainName;
     type: string;
     payload: Record<string, unknown>;
+    /**
+     * #1154: why the input cannot support a passing verdict (target files missing
+     * from the coverage report, a stale report). The verdict fails while non-empty.
+     */
+    insufficientEvidence?: string[];
 }
 export type FleetOperationPlan = {
     success: true;
@@ -27,6 +32,9 @@ export type FleetOperationPlan = {
 };
 /** Coverage threshold `analyze` judges against, as `aqe coverage` does by default. */
 export declare const FLEET_COVERAGE_THRESHOLD = 80;
-/** Build the domain task for a fleet operation on `target`, or say why it cannot run. */
-export declare function planFleetOperation(operation: FleetOperation, target: string): Promise<FleetOperationPlan>;
+/**
+ * Build the domain task for a fleet operation on `target`, or say why it
+ * cannot run. `projectRoot` defaults to the project `aqe` runs in.
+ */
+export declare function planFleetOperation(operation: FleetOperation, target: string, projectRoot?: string): Promise<FleetOperationPlan>;
 //# sourceMappingURL=fleet-operation.d.ts.map

package/dist/cli/utils/fleet-operation.js

@@ -15,18 +15,30 @@ import { extname, resolve } from 'node:path';
 import { walkSourceFiles } from './file-discovery.js';
 import { summarizeCoverage } from './coverage-data.js';
 import { describeNoData, resolveExistingCoverage } from '../../coordination/handlers/coverage-target.js';
+import { describeEvidence } from '../../coordination/handlers/coverage-evidence.js';
 import { MAX_SAST_FILE_BYTES } from '../../domains/security-compliance/sast-path-guard.js';
+import { confinePayloadPaths } from '../../shared/io/payload-path-guard.js';
 export const FLEET_OPERATIONS = ['test', 'analyze', 'scan'];
 /** Coverage threshold `analyze` judges against, as `aqe coverage` does by default. */
 export const FLEET_COVERAGE_THRESHOLD = 80;
 /** Extensions the built-in SAST patterns cover (sast-scanner.ts). */
 const SAST_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
 const refuse = (error) => ({ success: false, error });
-/** Build the domain task for a fleet operation on `target`, or say why it cannot run. */
-export async function planFleetOperation(operation, target) {
+/**
+ * Build the domain task for a fleet operation on `target`, or say why it
+ * cannot run. `projectRoot` defaults to the project `aqe` runs in.
+ */
+export async function planFleetOperation(operation, target, projectRoot) {
     const targetPath = resolve(target);
     if (!existsSync(targetPath))
         return refuse(`Target does not exist: ${target}`);
+    // #1146: the target is confined to the project, as handler paths are
+    // (#1096): a symlink that leads out of the project is refused here instead
+    // of failing every worker later.
+    const { skipped } = await confinePayloadPaths([target], { projectRoot, allowDirectory: true });
+    if (skipped[0]?.reason === 'outside-project-root') {
+        return refuse(`Target ${target} resolves outside the project. Run aqe from the project the target belongs to.`);
+    }
     switch (operation) {
         case 'test': {
             const sourceFiles = walkSourceFiles(targetPath, { includeTests: false });
@@ -61,9 +73,14 @@ export async function planFleetOperation(operation, target) {
             if (evaluation.status !== 'measured')
                 return refuse(describeNoData(evaluation.reason, target, projectRoot));
             const coverageData = { files: evaluation.files, summary: summarizeCoverage(evaluation.files) };
+            const insufficientEvidence = describeEvidence(evaluation.evidence, projectRoot);
             return {
                 success: true,
-                task: { domain: 'coverage-analysis', type: 'analyze-coverage', payload: { coverageData, threshold: FLEET_COVERAGE_THRESHOLD } },
+                task: {
+                    domain: 'coverage-analysis', type: 'analyze-coverage',
+                    payload: { coverageData, threshold: FLEET_COVERAGE_THRESHOLD },
+                    ...(insufficientEvidence.length > 0 ? { insufficientEvidence } : {}),
+                },
             };
         }
     }

package/dist/cli/utils/fleet-result.d.ts

@@ -8,7 +8,8 @@
  *   - test    fails when no test was generated or a generated test failed
  *             the test quality gate;
  *   - analyze fails when coverage over the collected metrics is below the
- *             threshold (an uncollected metric is not counted as 0%).
+ *             threshold (an uncollected metric is not counted as 0%), or when
+ *             the report leaves target files unmeasured or is stale (#1154).
  * A result without the expected shape fails rather than passing unread.
  */
 import { type FleetOperation } from './fleet-operation.js';
@@ -20,12 +21,27 @@ export interface FleetResultSummary {
 }
 /** Summarize one completed task's result for its fleet operation. */
 export declare function summarizeFleetResult(operation: FleetOperation, result: unknown): FleetResultSummary;
+export interface FleetVerdict {
+    /** The workers' results combined into one (#1146); undefined when no worker completed. */
+    combined: unknown;
+    /** Summary of the combined result; undefined when no worker completed. */
+    summary?: FleetResultSummary;
+    passed: boolean;
+    reasons: string[];
+}
 /**
- * Print each distinct worker result once and the verdict over all workers.
- * Returns whether the operation passed.
+ * Judge a fleet run: the completed workers' results are combined (each worker
+ * handled its own share of the target, #1146) and summarized once.
+ * `insufficientEvidence` (from the operation's plan) fails the verdict whatever
+ * the workers returned.
  */
+export declare function judgeFleetRun(operation: FleetOperation, workers: ReadonlyArray<{
+    success: boolean;
+    result: unknown;
+}>, insufficientEvidence?: readonly string[]): FleetVerdict;
+/** Print the combined result and the verdict over all workers. Returns whether the operation passed. */
 export declare function reportFleetVerdict(operation: FleetOperation, workers: ReadonlyArray<{
     success: boolean;
     result: unknown;
-}>, log?: (line: string) => void): boolean;
+}>, log?: (line: string) => void, insufficientEvidence?: readonly string[]): boolean;
 //# sourceMappingURL=fleet-result.d.ts.map

package/dist/cli/utils/fleet-result.js

@@ -8,12 +8,14 @@
  *   - test    fails when no test was generated or a generated test failed
  *             the test quality gate;
  *   - analyze fails when coverage over the collected metrics is below the
- *             threshold (an uncollected metric is not counted as 0%).
+ *             threshold (an uncollected metric is not counted as 0%), or when
+ *             the report leaves target files unmeasured or is stale (#1154).
  * A result without the expected shape fails rather than passing unread.
  */
 import chalk from 'chalk';
 import { FLEET_COVERAGE_THRESHOLD } from './fleet-operation.js';
 import { thresholdVerdict } from '../../coordination/handlers/coverage-target.js';
+import { combineFleetResults } from './fleet-shard.js';
 const SEVERITIES = ['critical', 'high', 'medium', 'low', 'informational'];
 const MAX_LISTED_FINDINGS = 10;
 const asRecord = (value) => value !== null && typeof value === 'object' ? value : undefined;
@@ -32,8 +34,9 @@ function summarizeScan(result) {
         `Files scanned: ${coverage?.filesScanned ?? 'n/a'} (evidence: ${completeness})`,
         ...findings.slice(0, MAX_LISTED_FINDINGS).map(f => `  [${f.severity ?? '?'}] ${f.title ?? 'untitled'} @ ${f.location?.file ?? '?'}:${f.location?.line ?? '?'}`),
     ];
-    if (findings.length > MAX_LISTED_FINDINGS)
-        lines.push(`  … ${findings.length - MAX_LISTED_FINDINGS} more`);
+    if (findings.length > MAX_LISTED_FINDINGS) {
+        lines.push(`  … ${findings.length - MAX_LISTED_FINDINGS} more (--format json lists every finding)`);
+    }
     const reasons = [];
     if (count('critical') + count('high') > 0)
         reasons.push(`${count('critical')} critical and ${count('high')} high findings`);
@@ -96,29 +99,37 @@ export function summarizeFleetResult(operation, result) {
     }
 }
 /**
- * Print each distinct worker result once and the verdict over all workers.
- * Returns whether the operation passed.
+ * Judge a fleet run: the completed workers' results are combined (each worker
+ * handled its own share of the target, #1146) and summarized once.
+ * `insufficientEvidence` (from the operation's plan) fails the verdict whatever
+ * the workers returned.
  */
-export function reportFleetVerdict(operation, workers, log = line => console.log(line)) {
-    const summaries = workers.filter(w => w.success).map(w => summarizeFleetResult(operation, w.result));
-    const shown = new Set();
-    for (const summary of summaries) {
-        const text = summary.lines.join('\n');
-        if (shown.has(text))
-            continue;
-        shown.add(text);
+export function judgeFleetRun(operation, workers, insufficientEvidence = []) {
+    const completed = workers.filter(w => w.success).map(w => w.result);
+    const combined = completed.length > 0 ? combineFleetResults(operation, completed) : undefined;
+    const summary = completed.length > 0 ? summarizeFleetResult(operation, combined) : undefined;
+    const incomplete = workers.length - completed.length;
+    const reasons = [...(summary?.reasons ?? [])];
+    if (insufficientEvidence.length > 0)
+        reasons.push('insufficient evidence: the coverage report is incomplete or stale for the target');
+    if (incomplete > 0)
+        reasons.unshift(`${incomplete} of ${workers.length} workers did not complete`);
+    return { combined, ...(summary ? { summary } : {}), passed: reasons.length === 0, reasons };
+}
+/** Print the combined result and the verdict over all workers. Returns whether the operation passed. */
+export function reportFleetVerdict(operation, workers, log = line => console.log(line), insufficientEvidence = []) {
+    const verdict = judgeFleetRun(operation, workers, insufficientEvidence);
+    if (verdict.summary) {
         log('');
-        for (const line of summary.lines)
+        for (const line of verdict.summary.lines)
             log(`   ${line}`);
     }
-    const incomplete = workers.filter(w => !w.success).length;
-    const reasons = [...new Set(summaries.flatMap(s => s.reasons))];
-    if (incomplete > 0)
-        reasons.unshift(`${incomplete} of ${workers.length} workers did not complete`);
+    for (const reason of insufficientEvidence)
+        log(chalk.yellow(`   Evidence: ${reason}`));
     log('');
-    log(reasons.length === 0
+    log(verdict.passed
         ? chalk.green('   Verdict: PASSED')
-        : chalk.red(`   Verdict: FAILED (${reasons.join('; ')})`));
-    return reasons.length === 0;
+        : chalk.red(`   Verdict: FAILED (${verdict.reasons.join('; ')})`));
+    return verdict.passed;
 }
 //# sourceMappingURL=fleet-result.js.map

package/dist/cli/utils/fleet-shard.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Agentic QE v3 - `aqe fleet run` work split (#1146)
+ *
+ * `--parallel N` used to submit the same payload N times, so every worker did
+ * the whole job again. Now the target's files are split across the workers:
+ *   - scan -> each worker scans its own share of the files
+ *   - test -> each worker generates tests for its own share of the source files
+ *   - analyze -> one coverage report is judged as a whole, so it runs as one task
+ * The shard results are then combined into one result for the verdict. Only
+ * figures the workers returned are combined; nothing is estimated.
+ */
+import type { FleetOperation } from './fleet-operation.js';
+/** Workers used when --parallel is not given. */
+export declare const DEFAULT_FLEET_WORKERS = 4;
+export interface FleetShardPlan {
+    /** One payload per worker. */
+    payloads: Array<Record<string, unknown>>;
+    /** Files given to each worker (empty for an operation that is not split). */
+    files: string[][];
+    /** Why fewer workers run than were asked for, if they do. */
+    note?: string;
+}
+/** Split `items` into at most `parts` contiguous chunks whose sizes differ by at most one. */
+export declare function splitEvenly<T>(items: readonly T[], parts: number): T[][];
+/**
+ * Split an operation's payload across workers. `requested` is the --parallel
+ * value, or undefined when the flag was not given.
+ */
+export declare function shardFleetPayload(operation: FleetOperation, payload: Record<string, unknown>, requested: number | undefined): FleetShardPlan;
+/**
+ * Combine the results of the workers that completed into one result of the
+ * operation's shape. Returns undefined when a result cannot be read, so the
+ * verdict fails as unreadable instead of passing on part of the results.
+ */
+export declare function combineFleetResults(operation: FleetOperation, results: readonly unknown[]): unknown;
+//# sourceMappingURL=fleet-shard.d.ts.map

package/dist/cli/utils/fleet-shard.js

@@ -0,0 +1,110 @@
+/**
+ * Agentic QE v3 - `aqe fleet run` work split (#1146)
+ *
+ * `--parallel N` used to submit the same payload N times, so every worker did
+ * the whole job again. Now the target's files are split across the workers:
+ *   - scan -> each worker scans its own share of the files
+ *   - test -> each worker generates tests for its own share of the source files
+ *   - analyze -> one coverage report is judged as a whole, so it runs as one task
+ * The shard results are then combined into one result for the verdict. Only
+ * figures the workers returned are combined; nothing is estimated.
+ */
+/** Workers used when --parallel is not given. */
+export const DEFAULT_FLEET_WORKERS = 4;
+/** The payload field each splittable operation's files are in. */
+const SHARD_FIELD = { scan: 'files', test: 'sourceFiles' };
+/** Split `items` into at most `parts` contiguous chunks whose sizes differ by at most one. */
+export function splitEvenly(items, parts) {
+    const count = Math.max(1, Math.min(parts, items.length));
+    const base = Math.floor(items.length / count);
+    const extra = items.length % count;
+    const chunks = [];
+    let start = 0;
+    for (let i = 0; i < count; i++) {
+        const size = base + (i < extra ? 1 : 0);
+        chunks.push(items.slice(start, start + size));
+        start += size;
+    }
+    return chunks;
+}
+/**
+ * Split an operation's payload across workers. `requested` is the --parallel
+ * value, or undefined when the flag was not given.
+ */
+export function shardFleetPayload(operation, payload, requested) {
+    const field = SHARD_FIELD[operation];
+    if (!field) {
+        const note = requested !== undefined && requested > 1
+            ? `${operation} judges one coverage report as a whole, so it runs as one task; --parallel ${requested} does not apply.`
+            : undefined;
+        return { payloads: [payload], files: [[]], ...(note ? { note } : {}) };
+    }
+    const files = Array.isArray(payload[field]) ? payload[field] : [];
+    const wanted = requested ?? DEFAULT_FLEET_WORKERS;
+    const chunks = splitEvenly(files, wanted);
+    const note = requested !== undefined && chunks.length < requested
+        ? `--parallel ${requested} asks for more workers than there are files (${files.length}); ${chunks.length} run.`
+        : undefined;
+    return {
+        payloads: chunks.map(chunk => ({ ...payload, [field]: chunk })),
+        files: chunks,
+        ...(note ? { note } : {}),
+    };
+}
+const asRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+const SCAN_COUNTS = ['critical', 'high', 'medium', 'low', 'informational', 'totalFiles'];
+function sum(records, key) {
+    const values = records.map(r => r?.[key]);
+    return values.every(v => typeof v === 'number') ? values.reduce((a, b) => a + b, 0) : undefined;
+}
+function combineScans(results) {
+    if (!results.every(r => asRecord(r.summary) && Array.isArray(r.vulnerabilities)))
+        return undefined;
+    const summaries = results.map(r => asRecord(r.summary));
+    const summary = {};
+    for (const key of SCAN_COUNTS) {
+        const total = sum(summaries, key);
+        if (total !== undefined)
+            summary[key] = total;
+    }
+    const coverages = results.map(r => asRecord(r.coverage));
+    const filesScanned = sum(coverages, 'filesScanned');
+    const linesScanned = sum(coverages, 'linesScanned');
+    // Complete only when every shard says so; a shard without evidence leaves it unknown.
+    const completeness = results.map(r => asRecord(r.evidence)?.completeness);
+    const combinedCompleteness = !completeness.every(c => typeof c === 'string') ? undefined
+        : completeness.every(c => c === 'complete') ? 'complete'
+            : completeness.every(c => c === 'none') ? 'none' : 'partial';
+    return {
+        vulnerabilities: results.flatMap(r => r.vulnerabilities),
+        summary,
+        ...(filesScanned !== undefined || linesScanned !== undefined
+            ? { coverage: { ...(filesScanned !== undefined ? { filesScanned } : {}), ...(linesScanned !== undefined ? { linesScanned } : {}) } }
+            : {}),
+        ...(combinedCompleteness ? { evidence: { completeness: combinedCompleteness } } : {}),
+    };
+}
+/**
+ * Combine the results of the workers that completed into one result of the
+ * operation's shape. Returns undefined when a result cannot be read, so the
+ * verdict fails as unreadable instead of passing on part of the results.
+ */
+export function combineFleetResults(operation, results) {
+    if (results.length === 0)
+        return undefined;
+    if (results.length === 1)
+        return results[0];
+    const records = results.map(asRecord);
+    if (records.some(r => !r))
+        return undefined;
+    const valid = records;
+    switch (operation) {
+        case 'scan': return combineScans(valid);
+        case 'test':
+            return valid.every(r => Array.isArray(r.tests)) ? { tests: valid.flatMap(r => r.tests) } : undefined;
+        case 'analyze':
+            // Never split, so several results mean duplicated work; none is preferred.
+            return undefined;
+    }
+}
+//# sourceMappingURL=fleet-shard.js.map

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

@@ -52,6 +52,25 @@ async function confineTarget(taskType, target) {
         return ok(undefined);
     return requirePayloadPath(taskType, 'target', target, { allowDirectory: true, allowMissing: true });
 }
+/**
+ * #1224: index the files for the code-intelligence search (the index the
+ * Queen's `search` task reads), not only the knowledge graph. Returns warnings
+ * for the index result.
+ */
+async function indexFilesForSearch(ctx, indexedFiles) {
+    const unavailable = 'Search index not updated: the code-intelligence domain is unavailable, so a code search will not find these files.';
+    if (!ctx.getCodeIntelligenceCoordinator)
+        return [unavailable];
+    try {
+        const coordinator = await ctx.getCodeIntelligenceCoordinator();
+        if (!coordinator)
+            return [unavailable];
+        return (await coordinator.indexForSearch(indexedFiles)).warnings;
+    }
+    catch (error) {
+        return [`Search index not updated: ${toError(error).message}`];
+    }
+}
 export function registerCodeIntelligenceHandlers(ctx) {
     // Register code indexing handler - REAL IMPLEMENTATION
     ctx.registerHandler('index-code', async (task) => {
@@ -108,6 +127,7 @@ export function registerCodeIntelligenceHandlers(ctx) {
             // 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, indexedFiles);
+            const searchWarnings = await indexFilesForSearch(ctx, indexedFiles);
             // Detect languages from files
             const detectedLanguages = new Set();
             const extToLang = {
@@ -140,7 +160,7 @@ export function registerCodeIntelligenceHandlers(ctx) {
                 languages: Array.from(detectedLanguages),
                 duration: indexResult.duration,
                 errors: indexResult.errors,
-                warnings: indexResult.warnings,
+                warnings: [...(indexResult.warnings ?? []), ...searchWarnings],
                 skipped: indexResult.skipped ?? [],
                 ...(projectMetrics ? { projectMetrics } : {}),
             });

package/dist/coordination/handlers/coverage-collection.d.ts

@@ -141,6 +141,8 @@ export declare function isRustProject(targetPath: string): boolean;
 export declare function collectRustCoverage(targetPath: string, options?: {
     timeoutMs?: number;
 }): Promise<CollectedCoverage | null>;
+/** Production source files under a directory (test, build and vendored directories skipped). */
+export declare function walkSourceFiles(targetPath: string): string[];
 /**
  * Static coverage estimate from source shape, for when no instrumentation could
  * be run.

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

@@ -502,7 +502,8 @@ function withRecomputedSummary(files) {
         },
     };
 }
-function walkSourceFiles(targetPath) {
+/** Production source files under a directory (test, build and vendored directories skipped). */
+export function walkSourceFiles(targetPath) {
     const found = [];
     // Classification is relative to the analysis root (see isTestPath).
     const rootDir = targetPath;

package/dist/coordination/handlers/coverage-evidence.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Coverage evidence: is a report complete and current for its target? (#1154)
+ *
+ * A report judged over only the files it happens to contain says nothing
+ * about the target's other files. `aqe fleet run analyze --target src` printed
+ * "100% over 1 files" and "Verdict: PASSED" from a report that listed
+ * `src/math.js` while `src/unsafe.js` had no measurement at all, and a report
+ * written before the sources last changed was judged as if it were current.
+ *
+ * This module answers two questions for every caller of the shared resolver
+ * (MCP `coverage_analyze_sublinear` / `task_orchestrate`, `aqe coverage`,
+ * `aqe ci`, `aqe fleet run analyze`):
+ *   1. Which production source files under the target are not in the report?
+ *      They are UNMEASURED: not 0%, and not left out silently.
+ *   2. Is the report older than source files it is judged against? (stale)
+ * Either one makes the evidence insufficient: no verdict may pass on it.
+ */
+import type { FileCoverage } from '../../domains/coverage-analysis/interfaces';
+/** The report is older than these source files. */
+export interface StaleReport {
+    reportPath: string;
+    reportModified: string;
+    newerFiles: string[];
+}
+export interface CoverageEvidence {
+    /** `insufficient-evidence` when any target file is unmeasured or the report is stale. */
+    status: 'complete' | 'insufficient-evidence';
+    /** Production source files under the target with no entry in the report (absolute paths). */
+    unmeasuredFiles: string[];
+    /** Production source files under the target, measured or not. */
+    targetFiles: number;
+    stale?: StaleReport;
+    /** The coverage config whose include/exclude scoped `unmeasuredFiles`, if any. */
+    coverageScope?: {
+        source: string;
+        readable: boolean;
+    };
+}
+/**
+ * Production source files under a directory `target` that the report has no
+ * entry for. Only files in a language the report covers count: a JS report
+ * does not make a Python helper script unmeasured. Files the project's coverage
+ * config leaves out (include/exclude) were never meant to be measured and do
+ * not count either.
+ */
+export declare function findUnmeasuredSourceFiles(reportFiles: FileCoverage[], projectRoot: string, target: string): {
+    targetFiles: string[];
+    unmeasured: string[];
+    coverageScope?: {
+        source: string;
+        readable: boolean;
+    };
+};
+/** Source files modified after the report was written; `undefined` when the report is current. */
+export declare function findStaleness(reportPath: string, sourceFiles: string[]): StaleReport | undefined;
+/**
+ * The evidence a report gives for `target`.
+ *
+ * `measuredFiles` are the report entries already scoped to the target.
+ * Completeness is checked only when `checkCompleteness` is set (a directory
+ * target, not a report file given as the target), staleness only when the
+ * report's path is known (not for a report the run just wrote).
+ */
+export declare function assessCoverageEvidence(report: {
+    files: FileCoverage[];
+}, measuredFiles: FileCoverage[], projectRoot: string, target: string, options?: {
+    reportPath?: string;
+    checkCompleteness?: boolean;
+}): CoverageEvidence;
+/**
+ * Why the evidence is insufficient, one sentence per problem; empty when it is
+ * complete. Shared by MCP and CLI so the wording cannot drift.
+ */
+export declare function describeEvidence(evidence: CoverageEvidence | undefined, projectRoot: string): string[];
+//# sourceMappingURL=coverage-evidence.d.ts.map