agentic-qe 3.15.12 → 3.15.13

package/dist/cli/commands/fleet.js

@@ -16,8 +16,7 @@ import { createPersistentScheduler } from '../scheduler/index.js';
 import { integrateCodeIntelligence } from '../../init/fleet-integration.js';
 import { runFleetInitWizard } from '../wizards/fleet-wizard.js';
 import { FleetProgressManager, createTimedSpinner } from '../utils/progress.js';
-import { FLEET_OPERATIONS, planFleetOperation } from '../utils/fleet-operation.js';
-import { reportFleetVerdict } from '../utils/fleet-result.js';
+import { registerFleetRunCommand } from './fleet-run.js';
 import { writeOutput, toJSON } from '../utils/ci-output.js';
 export function createFleetCommand(context, cleanupAndExit, ensureInitialized, registerDomainWorkflowActions) {
     const fleetCmd = new Command('fleet')
@@ -215,121 +214,7 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
             await cleanupAndExit(1);
         }
     });
-    fleetCmd
-        .command('run')
-        .description('Run a coordinated fleet operation')
-        .argument('<operation>', 'Operation type (test|analyze|scan)')
-        .option('-t, --target <path>', 'Target path', '.')
-        .option('--parallel <count>', 'Number of parallel agents', '4')
-        .action(async (operation, options) => {
-        if (!await ensureInitialized())
-            return cleanupAndExit(1);
-        try {
-            const parallelCount = Number(options.parallel);
-            if (!Number.isSafeInteger(parallelCount) || parallelCount < 1) {
-                throw new Error('--parallel must be a positive integer');
-            }
-            if (!FLEET_OPERATIONS.includes(operation)) {
-                throw new Error(`Unsupported operation: ${operation}`);
-            }
-            // #1125: each operation runs a real domain handler with the input it
-            // needs, taken from the target; without that input it is refused.
-            const plan = await planFleetOperation(operation, options.target);
-            if (!plan.success) {
-                console.error(chalk.red(`\n Operation '${operation}' cannot run: ${plan.error}`));
-                return cleanupAndExit(1);
-            }
-            const { domain, payload } = plan.task;
-            const taskType = plan.task.type;
-            // #1081: refuse an operation whose task no domain plugin executes,
-            // instead of submitting work that can only fail at dispatch.
-            const executable = context.queen.validateTaskExecutable(taskType, [domain]);
-            if (!executable.success) {
-                console.error(chalk.red(`\n Operation '${operation}' cannot run: ${executable.error.message}`));
-                return cleanupAndExit(1);
-            }
-            console.log(chalk.blue(`\n Fleet Operation: ${operation}\n`));
-            const progress = new FleetProgressManager({
-                title: `${operation.charAt(0).toUpperCase() + operation.slice(1)} Progress`,
-                showEta: true,
-            });
-            progress.start(parallelCount);
-            const agentOperations = Array.from({ length: parallelCount }, (_, i) => {
-                const agentId = `${operation}-agent-${i + 1}`;
-                return {
-                    id: agentId,
-                    name: `${operation}-worker-${i + 1}`,
-                    domain,
-                };
-            });
-            for (const op of agentOperations) {
-                progress.addAgent({
-                    id: op.id,
-                    name: op.name,
-                    status: 'pending',
-                    progress: 0,
-                });
-            }
-            const results = await Promise.all(agentOperations.map(async (op) => {
-                progress.updateAgent(op.id, 0, { status: 'running' });
-                try {
-                    const taskResult = await context.queen.submitTask({
-                        type: taskType,
-                        priority: 'p1',
-                        targetDomains: [domain],
-                        payload: { ...payload, target: options.target, workerId: op.id },
-                        timeout: 60000,
-                    });
-                    if (!taskResult.success) {
-                        throw taskResult.error;
-                    }
-                    // Submission is only an acknowledgement. Keep the process alive
-                    // until the domain reports a terminal result or the task expires.
-                    const deadline = Date.now() + 60000;
-                    while (Date.now() < deadline) {
-                        const task = context.queen.getTaskStatus(taskResult.value);
-                        if (!task)
-                            throw new Error(`Task status unavailable: ${taskResult.value}`);
-                        if (task.status === 'completed') {
-                            progress.completeAgent(op.id, true);
-                            return { id: op.id, success: true, result: task.result };
-                        }
-                        if (task.status === 'failed' || task.status === 'cancelled') {
-                            throw new Error(task.error || `Task ${task.status}`);
-                        }
-                        await new Promise(resolve => setTimeout(resolve, 250));
-                    }
-                    throw new Error(`Task timed out: ${taskResult.value}`);
-                }
-                catch (error) {
-                    console.error(chalk.red(`   ${op.name}: ${error instanceof Error ? error.message : String(error)}`));
-                    progress.completeAgent(op.id, false);
-                    return { id: op.id, success: false, result: undefined };
-                }
-            }));
-            // #1168: a completed agent is not a passed check, so the completion
-            // line only says "successfully" when the verdict passes.
-            const verdictPassed = reportFleetVerdict(operation, results, () => { }, plan.task.insufficientEvidence);
-            progress.stop({ verdictFailed: !verdictPassed });
-            const successful = results.filter(r => r.success).length;
-            const failed = results.filter(r => !r.success).length;
-            console.log(chalk.blue('\n Operation Summary:'));
-            console.log(chalk.gray(`   Operation: ${operation}`));
-            console.log(chalk.gray(`   Target: ${options.target}`));
-            console.log(chalk.gray(`   Completed: ${successful}`));
-            if (failed > 0) {
-                console.log(chalk.red(`   Failed: ${failed}`));
-            }
-            // #1125 review: a completed task is not a passed check.
-            const passed = reportFleetVerdict(operation, results, undefined, plan.task.insufficientEvidence);
-            console.log('');
-            await cleanupAndExit(passed ? 0 : 1);
-        }
-        catch (error) {
-            console.error(chalk.red('\n Fleet operation failed:'), error);
-            await cleanupAndExit(1);
-        }
-    });
+    registerFleetRunCommand(fleetCmd, context, cleanupAndExit, ensureInitialized);
     fleetCmd
         .command('status')
         .description('Show fleet status with agent progress')

package/dist/cli/handlers/task-handler.d.ts

@@ -5,6 +5,11 @@
  */
 import { Command } from 'commander';
 import { ICommandHandler, CLIContext } from './interfaces.js';
+/**
+ * What a completed task's result says it could not check (#1135, #1052):
+ * `incompleteChecks`, or a top-level status of incomplete/failed with its reason.
+ */
+export declare function incompleteResultReasons(result: unknown): string[];
 export declare class TaskHandler implements ICommandHandler {
     readonly name = "task";
     readonly description = "Manage QE tasks";

package/dist/cli/handlers/task-handler.js

@@ -13,6 +13,20 @@ import { writeOutput, toJSON } from '../utils/ci-output.js';
 // ============================================================================
 // Task Handler
 // ============================================================================
+/**
+ * What a completed task's result says it could not check (#1135, #1052):
+ * `incompleteChecks`, or a top-level status of incomplete/failed with its reason.
+ */
+export function incompleteResultReasons(result) {
+    if (!result || typeof result !== 'object')
+        return [];
+    const { status, error, incompleteChecks } = result;
+    const reasons = Array.isArray(incompleteChecks) ? incompleteChecks.filter((reason) => typeof reason === 'string') : [];
+    if (reasons.length === 0 && (status === 'incomplete' || status === 'failed')) {
+        reasons.push(typeof error === 'string' ? error : `result status is ${status}`);
+    }
+    return reasons;
+}
 export class TaskHandler {
     name = 'task';
     description = 'Manage QE tasks';
@@ -149,6 +163,12 @@ export class TaskHandler {
                         const taskStatus = context.queen.getTaskStatus(taskId);
                         if (taskStatus) {
                             if (taskStatus.status === 'completed') {
+                                // #1135, #1052: a result that reports an incomplete or failed check is not a clean run.
+                                const incomplete = incompleteResultReasons(taskStatus.result);
+                                if (incomplete.length > 0) {
+                                    waitSpinner.fail(`Task completed, but its result is incomplete: ${incomplete.join('; ')}`);
+                                    return this.cleanupAndExit(1);
+                                }
                                 waitSpinner.succeed('Task completed successfully');
                                 completed = true;
                             }

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

@@ -32,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

@@ -17,17 +17,28 @@ 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 });

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

@@ -21,11 +21,25 @@ 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.
+ * 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. Returns whether the operation passed.
+ * 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;

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

@@ -15,6 +15,7 @@
 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;
@@ -33,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`);
@@ -97,34 +99,37 @@ export function summarizeFleetResult(operation, result) {
     }
 }
 /**
- * Print each distinct worker result once and the verdict over all workers.
+ * 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. Returns whether the operation passed.
+ * the workers returned.
  */
+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 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);
+    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}`);
     }
     for (const reason of insufficientEvidence)
         log(chalk.yellow(`   Evidence: ${reason}`));
-    const incomplete = workers.filter(w => !w.success).length;
-    const reasons = [...new Set(summaries.flatMap(s => s.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`);
     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/handler-types.d.ts

@@ -13,8 +13,8 @@ import type { TestGeneratorService } from '../../domains/test-generation';
 import type { KnowledgeGraphService } from '../../domains/code-intelligence';
 import type { ICodeIntelligenceCoordinator } from '../../domains/code-intelligence/coordinator';
 import type { QualityAnalyzerService } from '../../domains/quality-assessment';
-/** The coordinator surface the MCP index-code handler needs (#999). */
-export type ProjectMetricsCollector = Pick<ICodeIntelligenceCoordinator, 'collectProjectMetrics'>;
+/** The coordinator surface the MCP index-code handler needs (#999, #1224). */
+export type ProjectMetricsCollector = Pick<ICodeIntelligenceCoordinator, 'collectProjectMetrics' | 'indexForSearch'>;
 /** Signature of a single task handler */
 export type InstanceTaskHandler = (task: QueenTask) => Promise<Result<unknown, Error>>;
 /**

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

@@ -123,6 +123,12 @@ export declare function discoverSourceFiles(targetPath: string, options?: {
     includeTests?: boolean;
     languages?: string[];
     maxFiles?: number;
+    /**
+     * #1020: also include component files (.vue, .svelte) and symlinked files.
+     * For callers that judge the whole source scope (quality assessment) and
+     * read through a reader that contains symlinks to the project root.
+     */
+    completeScope?: boolean;
 }): Promise<string[]>;
 /**
  * Generate security recommendations based on findings

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

@@ -417,11 +417,11 @@ export function parseCoberturaXml(content) {
  */
 export async function discoverSourceFiles(targetPath, options = {}) {
     const files = [];
-    const { includeTests = true, languages, maxFiles = 5000 } = options;
+    const { includeTests = true, languages, maxFiles = 5000, completeScope = false } = options;
     // Determine file extensions to include
     // Default: scan ALL common source languages unless explicitly filtered
     let extensions = [
-        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', // JavaScript/TypeScript
+        '.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', // JavaScript/TypeScript
         '.py', '.pyw', // Python
         '.go', // Go
         '.rs', // Rust
@@ -437,7 +437,7 @@ export async function discoverSourceFiles(targetPath, options = {}) {
         extensions = [];
         for (const lang of languages) {
             if (lang === 'typescript')
-                extensions.push('.ts', '.tsx');
+                extensions.push('.ts', '.tsx', '.mts', '.cts');
             if (lang === 'javascript')
                 extensions.push('.js', '.jsx', '.mjs', '.cjs');
             if (lang === 'python')
@@ -464,6 +464,8 @@ export async function discoverSourceFiles(targetPath, options = {}) {
                 extensions.push('.scala');
         }
     }
+    if (completeScope && (!languages || languages.length === 0))
+        extensions.push('.vue', '.svelte');
     async function walkDir(dir) {
         try {
             const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -488,7 +490,7 @@ export async function discoverSourceFiles(targetPath, options = {}) {
                         return; // Cap reached
                     await walkDir(fullPath);
                 }
-                else if (entry.isFile()) {
+                else if (entry.isFile() || (completeScope && entry.isSymbolicLink() && await isFileTarget(fullPath))) {
                     const ext = path.extname(entry.name);
                     // Check extension
                     if (!extensions.includes(ext))
@@ -515,6 +517,14 @@ export async function discoverSourceFiles(targetPath, options = {}) {
             // Directory not accessible
         }
     }
+    async function isFileTarget(linkPath) {
+        try {
+            return (await fs.stat(linkPath)).isFile();
+        }
+        catch {
+            return false; // dangling link
+        }
+    }
     // Check if targetPath is a file or directory
     try {
         const stat = await fs.stat(targetPath);

package/dist/coordination/handlers/misc-handlers.js

@@ -16,8 +16,11 @@ export function registerMiscHandlers(ctx) {
             passed: false,
             violations: [],
             warnings: [],
-            score: 0,
-            note: 'Accessibility testing requires a browser environment (Puppeteer/Playwright). ' +
+            // #1145: nothing was audited, so `passed: false` is not a verdict and the score is -1
+            score: -1,
+            measured: false,
+            note: 'Accessibility NOT MEASURED: this is not a failing result. ' +
+                'Accessibility testing requires a browser environment (Puppeteer/Playwright). ' +
                 'Use tools like axe-core, pa11y, or Lighthouse CLI for WCAG compliance testing. ' +
                 'Example: npx pa11y ' + (payload.url || '<url>'),
         });

package/dist/coordination/handlers/quality-handlers.js

@@ -89,13 +89,13 @@ async function resolveAnalysisScope(payload) {
             throw new CallerInputError(`target ${JSON.stringify(payload.target)} does not exist.`);
         if (stat.isFile())
             return { sourceFiles: [target], explicitFiles: [target], scope: target };
-        return { sourceFiles: await discoverSourceFiles(target, { includeTests: false }), explicitFiles: [], scope: target };
+        return { sourceFiles: await discoverSourceFiles(target, { includeTests: false, completeScope: true }), explicitFiles: [], scope: target };
     }
     // Default to src/ — scanning the entire project root is too slow
     // (node_modules, dist, .git, etc. make it hang on large projects)
     const srcDir = nodePath.join(root, 'src');
     const targetDir = existsSync(srcDir) ? srcDir : root;
-    return { sourceFiles: await discoverSourceFiles(targetDir, { includeTests: false }), explicitFiles: [], scope: targetDir };
+    return { sourceFiles: await discoverSourceFiles(targetDir, { includeTests: false, completeScope: true }), explicitFiles: [], scope: targetDir };
 }
 /** #1021: one line per partially measured metric, naming the gap. */
 function describePartialMetrics(partial) {