agentic-qe 3.14.6 → 3.14.8

package/dist/coordination/services/task-audit-logger.d.ts

@@ -21,6 +21,34 @@ export interface TaskAuditEntry {
     readonly domain?: DomainName;
     readonly details?: Record<string, unknown>;
 }
+/** An entry produced by this logger, positioned within its generation. */
+export interface TaskAuditSequencedEntry extends TaskAuditEntry {
+    readonly sequence: number;
+}
+/** Filters select retained entries; they do not change retention metadata. */
+export interface TaskAuditFilter {
+    operation?: TaskOperation;
+    taskId?: string;
+    agentId?: string;
+    domain?: DomainName;
+    fromTimestamp?: Date;
+    toTimestamp?: Date;
+    limit?: number;
+}
+/** Completeness of the bounded observation window since construction/clear. */
+export interface TaskAuditWindow {
+    generation: string;
+    recordedEntries: number;
+    retainedEntries: number;
+    droppedEntries: number;
+    firstRetainedSequence: number | null;
+    lastRetainedSequence: number | null;
+    disposition: 'complete' | 'truncated';
+}
+/** Filtered entries with metadata for the entire retained window. */
+export interface TaskAuditSnapshot extends TaskAuditWindow {
+    entries: TaskAuditSequencedEntry[];
+}
 /**
  * Configuration for task audit logger
  */
@@ -41,6 +69,9 @@ export interface TaskAuditConfig {
 export declare class TaskAuditLogger {
     private readonly entries;
     private readonly config;
+    private generation;
+    private recordedEntries;
+    private droppedEntries;
     constructor(config?: Partial<TaskAuditConfig>);
     /**
      * Log a task operation
@@ -65,19 +96,13 @@ export declare class TaskAuditLogger {
     /**
      * Get audit entries with optional filtering
      */
-    getEntries(filter?: {
-        operation?: TaskOperation;
-        taskId?: string;
-        agentId?: string;
-        domain?: DomainName;
-        fromTimestamp?: Date;
-        toTimestamp?: Date;
-        limit?: number;
-    }): TaskAuditEntry[];
-    /**
-     * Get statistics about task operations
-     */
-    getStatistics(): {
+    getEntries(filter?: TaskAuditFilter): TaskAuditSequencedEntry[];
+    /** Get selected entries without losing evidence of earlier evictions/resets. */
+    getSnapshot(filter?: TaskAuditFilter): TaskAuditSnapshot;
+    private getWindow;
+    /** Get counts for the retained window, with its completeness metadata. */
+    getStatistics(): TaskAuditWindow & {
+        basis: 'retained-window';
         totalEntries: number;
         operationCounts: Record<TaskOperation, number>;
         taskCount: number;

package/dist/coordination/services/task-audit-logger.js

@@ -5,6 +5,7 @@
  * This replaces the full authorization service with simple audit logging
  * for a local CLI tool where all agents are trusted.
  */
+import { randomUUID } from 'node:crypto';
 const DEFAULT_CONFIG = {
     enableConsoleLog: true,
     maxEntries: 1000,
@@ -19,14 +20,21 @@ const DEFAULT_CONFIG = {
 export class TaskAuditLogger {
     entries = [];
     config;
+    generation = randomUUID();
+    recordedEntries = 0;
+    droppedEntries = 0;
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
+        if (!Number.isSafeInteger(this.config.maxEntries) || this.config.maxEntries < 0) {
+            throw new RangeError('maxEntries must be a non-negative safe integer');
+        }
     }
     /**
      * Log a task operation
      */
     log(operation, taskId, options) {
         const entry = {
+            sequence: ++this.recordedEntries,
             timestamp: new Date(),
             operation,
             taskId,
@@ -37,7 +45,9 @@ export class TaskAuditLogger {
         this.entries.push(entry);
         // Trim if exceeds max
         if (this.entries.length > this.config.maxEntries) {
-            this.entries.splice(0, this.entries.length - this.config.maxEntries);
+            const dropped = this.entries.length - this.config.maxEntries;
+            this.entries.splice(0, dropped);
+            this.droppedEntries += dropped;
         }
         // Console log if enabled
         if (this.config.enableConsoleLog) {
@@ -102,11 +112,24 @@ export class TaskAuditLogger {
             }
         }
         const limit = filter?.limit ?? result.length;
-        return result.slice(-limit);
+        return limit === 0 ? [] : result.slice(-limit);
     }
-    /**
-     * Get statistics about task operations
-     */
+    /** Get selected entries without losing evidence of earlier evictions/resets. */
+    getSnapshot(filter) {
+        return { ...this.getWindow(), entries: this.getEntries(filter) };
+    }
+    getWindow() {
+        return {
+            generation: this.generation,
+            recordedEntries: this.recordedEntries,
+            retainedEntries: this.entries.length,
+            droppedEntries: this.droppedEntries,
+            firstRetainedSequence: this.entries[0]?.sequence ?? null,
+            lastRetainedSequence: this.entries[this.entries.length - 1]?.sequence ?? null,
+            disposition: this.droppedEntries > 0 ? 'truncated' : 'complete',
+        };
+    }
+    /** Get counts for the retained window, with its completeness metadata. */
     getStatistics() {
         const operationCounts = {
             submit: 0,
@@ -129,6 +152,8 @@ export class TaskAuditLogger {
             }
         }
         return {
+            ...this.getWindow(),
+            basis: 'retained-window',
             totalEntries: this.entries.length,
             operationCounts,
             taskCount: taskIds.size,
@@ -140,6 +165,9 @@ export class TaskAuditLogger {
      */
     clear() {
         this.entries.length = 0;
+        this.generation = randomUUID();
+        this.recordedEntries = 0;
+        this.droppedEntries = 0;
     }
 }
 /**

package/dist/coordination/task-executor.d.ts

@@ -154,6 +154,11 @@ export declare class DomainTaskExecutor implements TaskHandlerContext {
     private getTaskDomain;
     private timeout;
     private publishTaskCompleted;
+    /**
+     * @param callerError true when the task was rejected because of invalid
+     *   caller input; the queen then neither retries it nor counts it toward
+     *   the domain circuit breaker.
+     */
     private publishTaskFailed;
 }
 export declare function createTaskExecutor(kernel: QEKernel, config?: Partial<TaskExecutorConfig>): DomainTaskExecutor;

package/dist/coordination/task-executor.js

@@ -13,7 +13,7 @@
  * Handler implementations are extracted into ./handlers/ modules.
  */
 import { v4 as uuidv4 } from 'uuid';
-import { toErrorMessage } from '../shared/error-utils.js';
+import { isCallerInputError, toErrorMessage } from '../shared/error-utils.js';
 import { createResultSaver } from './result-saver.js';
 import { createLogger } from '../logging/logger-factory.js';
 import { getClaudeModelForTier } from '../shared/llm/model-registry.js';
@@ -436,7 +436,7 @@ export class DomainTaskExecutor {
             ]);
             if (!result.success) {
                 const errorMsg = 'error' in result ? result.error.message : 'Unknown error';
-                await this.publishTaskFailed(task.id, errorMsg, domain);
+                await this.publishTaskFailed(task.id, errorMsg, domain, 'error' in result && isCallerInputError(result.error));
                 // ADR-051: Record failed outcome
                 this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch((e) => { logger.warn('recordOutcome failed', { error: e instanceof Error ? e.message : String(e), taskId: task.id }); });
                 return {
@@ -486,7 +486,7 @@ export class DomainTaskExecutor {
         }
         catch (error) {
             const errorMessage = toErrorMessage(error);
-            await this.publishTaskFailed(task.id, errorMessage, domain);
+            await this.publishTaskFailed(task.id, errorMessage, domain, isCallerInputError(error));
             // ADR-051: Record failed outcome
             this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch((e) => { logger.warn('recordOutcome failed', { error: e instanceof Error ? e.message : String(e), taskId: task.id }); });
             return {
@@ -655,13 +655,18 @@ export class DomainTaskExecutor {
             payload: { taskId, result },
         });
     }
-    async publishTaskFailed(taskId, error, domain) {
+    /**
+     * @param callerError true when the task was rejected because of invalid
+     *   caller input; the queen then neither retries it nor counts it toward
+     *   the domain circuit breaker.
+     */
+    async publishTaskFailed(taskId, error, domain, callerError = false) {
         await this.eventBus.publish({
             id: uuidv4(),
             type: 'TaskFailed',
             timestamp: new Date(),
             source: domain,
-            payload: { taskId, error },
+            payload: { taskId, error, ...(callerError ? { callerError: true } : {}) },
         });
     }
 }

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

@@ -33,7 +33,9 @@ export declare function loadQualityEvidence(memory: MemoryBackend, options?: {
     now?: number;
     maxAgeMs?: number;
 }): Promise<QualityEvidenceValues>;
-export declare function evaluateQualityEvidence(values: QualityEvidenceValues): {
+export declare function evaluateQualityEvidence(values: QualityEvidenceValues, thresholds?: {
+    coverage?: number;
+}): {
     passed: boolean;
     checks: EvaluatedQualityCheck[];
     recommendations: string[];

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

@@ -91,9 +91,14 @@ export async function loadQualityEvidence(memory, options = {}) {
     }
     return values;
 }
-export function evaluateQualityEvidence(values) {
+export function evaluateQualityEvidence(values, thresholds = {}) {
+    if (thresholds.coverage !== undefined && (!Number.isFinite(thresholds.coverage) || thresholds.coverage < 0 || thresholds.coverage > 100)) {
+        throw new Error('Coverage quality threshold must be a finite number between 0 and 100.');
+    }
     const checks = QUALITY_METRICS.map((name) => {
-        const threshold = DEFAULT_QUALITY_THRESHOLDS[name];
+        const threshold = name === 'coverage' && thresholds.coverage !== undefined
+            ? { ...DEFAULT_QUALITY_THRESHOLDS[name], value: thresholds.coverage }
+            : DEFAULT_QUALITY_THRESHOLDS[name];
         const value = values[name];
         return {
             name,

package/dist/domains/test-execution/services/retry-handler.js

@@ -11,6 +11,7 @@ import { TEST_EXECUTION_CONSTANTS, RETRY_CONSTANTS } from '../../constants.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { secureRandom } from '../../../shared/utils/crypto-random.js';
+import { terminateTestRunner, trackTestRunnerExit } from '../../../shared/test-runner-process.js';
 const DEFAULT_RETRY_CONFIG = {
     simulateForTesting: false,
     simulatedRetrySuccessRate: RETRY_CONSTANTS.DEFAULT_FLAKY_PASS_RATE,
@@ -379,6 +380,8 @@ export class RetryHandlerService {
             let stdout = '';
             let stderr = '';
             let timedOut = false;
+            let termination;
+            const timeoutError = new Error(`Test execution timed out after ${timeout}ms for command: ${command} ${args.join(' ')}`);
             const settle = (fn, value) => {
                 report?.cleanup();
                 fn(value);
@@ -387,13 +390,20 @@ export class RetryHandlerService {
             // Arguments are passed as array to avoid shell interpretation
             const proc = spawn(command, args, {
                 cwd,
+                detached: process.platform !== 'win32',
                 env: { ...process.env, FORCE_COLOR: '0', CI: 'true' },
             });
+            const untrackExit = trackTestRunnerExit(proc);
             const timeoutHandle = setTimeout(() => {
                 timedOut = true;
-                proc.kill('SIGTERM');
-                // Give it a moment to terminate gracefully, then force kill
-                setTimeout(() => proc.kill('SIGKILL'), 1000);
+                termination = terminateTestRunner(proc);
+                termination.catch(error => {
+                    logger.warn(`Retry runner cleanup failed: ${toError(error).message}`);
+                    // A denied cleanup can leave the root alive: preserve the timeout
+                    // outcome immediately, keeping artifacts because settlement is unknown.
+                    reject(timeoutError);
+                });
+                termination.then(untrackExit, () => undefined);
             }, timeout);
             proc.stdout?.on('data', (data) => {
                 stdout += data.toString();
@@ -404,9 +414,10 @@ export class RetryHandlerService {
             proc.on('close', (code) => {
                 clearTimeout(timeoutHandle);
                 if (timedOut) {
-                    settle(reject, new Error(`Test execution timed out after ${timeout}ms for command: ${command} ${args.join(' ')}`));
+                    termination?.then(() => settle(reject, timeoutError), () => reject(timeoutError));
                     return;
                 }
+                untrackExit();
                 // Parse result based on exit code and output (Vitest writes the JSON
                 // report to the --outputFile; read it back rather than trusting stdout).
                 try {
@@ -422,6 +433,7 @@ export class RetryHandlerService {
             });
             proc.on('error', (err) => {
                 clearTimeout(timeoutHandle);
+                untrackExit();
                 report?.cleanup();
                 reject(new Error(`Failed to spawn test process: ${err.message}. ` +
                     `Command: ${command} ${args.join(' ')}. ` +
@@ -433,20 +445,23 @@ export class RetryHandlerService {
      * Parse test runner output to determine pass/fail status
      */
     parseTestResult(exitCode, stdout, stderr) {
-        // A passing process and a passing report must agree when JSON is available.
+        // A retry can clear a prior failure only when the report proves a test
+        // actually passed. Empty/fully skipped selections can also exit zero.
         try {
             // Vitest JSON output
             const vitestMatch = stdout.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
             if (vitestMatch) {
                 const result = safeJsonParse(vitestMatch[0]);
                 if (exitCode === 0 && result.success !== false
-                    && result.numFailedTests === 0 && result.numFailedTestSuites === 0) {
+                    && result.numFailedTests === 0 && result.numFailedTestSuites === 0
+                    && Number.isFinite(result.numPassedTests) && result.numPassedTests > 0) {
                     return { passed: true };
                 }
                 const failedTest = result.testResults?.[0]?.assertionResults?.find((r) => r.status === 'failed');
                 return {
                     passed: false,
-                    error: failedTest?.failureMessages?.join('\n') || stderr || `Test failed with exit code ${exitCode}`,
+                    error: failedTest?.failureMessages?.join('\n') || stderr
+                        || (exitCode === 0 ? 'Retry runner did not report any passing tests.' : `Test failed with exit code ${exitCode}`),
                 };
             }
             // Jest JSON output
@@ -454,34 +469,38 @@ export class RetryHandlerService {
             if (jestMatch) {
                 const result = safeJsonParse(jestMatch[0]);
                 if (exitCode === 0 && result.success !== false
-                    && result.numFailedTests === 0 && result.numFailedTestSuites === 0) {
+                    && result.numFailedTests === 0 && result.numFailedTestSuites === 0
+                    && Number.isFinite(result.numPassedTests) && result.numPassedTests > 0) {
                     return { passed: true };
                 }
                 const failedTest = result.testResults?.[0]?.assertionResults?.find((r) => r.status === 'failed');
                 return {
                     passed: false,
-                    error: failedTest?.failureMessages?.join('\n') || stderr || `Test failed with exit code ${exitCode}`,
+                    error: failedTest?.failureMessages?.join('\n') || stderr
+                        || (exitCode === 0 ? 'Retry runner did not report any passing tests.' : `Test failed with exit code ${exitCode}`),
                 };
             }
             // Mocha JSON output
             const mochaMatch = stdout.match(/\{[\s\S]*"stats"[\s\S]*"failures"[\s\S]*\}/);
             if (mochaMatch) {
                 const result = safeJsonParse(mochaMatch[0]);
-                if (exitCode === 0 && result.stats?.failures === 0) {
+                if (exitCode === 0 && result.stats?.failures === 0
+                    && Number.isFinite(result.stats?.passes) && result.stats.passes > 0) {
                     return { passed: true };
                 }
                 const failure = result.failures?.[0];
                 return {
                     passed: false,
-                    error: failure?.err?.message || stderr || `Test failed with exit code ${exitCode}`,
+                    error: failure?.err?.message || stderr
+                        || (exitCode === 0 ? 'Retry runner did not report any passing tests.' : `Test failed with exit code ${exitCode}`),
                 };
             }
         }
         catch {
-            // JSON parsing failed, fall back to simple exit code check
+            // Unreadable output cannot prove that the retry executed a passing test.
         }
         if (exitCode === 0)
-            return { passed: true };
+            return { passed: false, error: 'Retry runner did not report any passing tests.' };
         // Non-zero exit code means failure
         const errorOutput = stderr || stdout || `Test failed with exit code ${exitCode}`;
         return {

package/dist/domains/test-execution/services/test-executor.d.ts

@@ -170,9 +170,9 @@ export declare class TestExecutorService implements ITestExecutionService {
      */
     private extractCoverageFromJson;
     /**
-     * Read coverage from disk files written by vitest/jest.
-     * Both runners write coverage-summary.json to a coverage/ directory when
-     * --coverage is passed, rather than embedding it in stdout JSON.
+     * Read coverage from the private output directory of a completed runner.
+     * Setting the directory does not enable coverage; project configuration
+     * still decides whether coverage is collected.
      */
     private readCoverageFromDisk;
     private storeResults;

package/dist/domains/test-execution/services/test-executor.js

@@ -4,7 +4,8 @@
  */
 import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
@@ -16,6 +17,7 @@ import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.
 import { getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
+import { terminateTestRunner, trackTestRunnerExit } from '../../../shared/test-runner-process.js';
 const DEFAULT_CONFIG = {
     simulateForTesting: false,
     simulatedTestsPerFile: 5,
@@ -368,19 +370,29 @@ Provide:
             return err(new Error(`Test file not found: ${missingFile}`));
         }
         // Build command based on framework
-        const { command, args, report } = this.buildTestCommand(files, framework);
+        const { command, args, report, coverageDirectory } = this.buildTestCommand(files, framework);
         const fileLabel = files.join(', ');
         return new Promise((resolve) => {
             let stdout = '';
             let stderr = '';
             let killed = false;
+            let termination;
             let settled = false;
+            const cleanupArtifacts = () => {
+                report?.cleanup();
+                if (coverageDirectory) {
+                    try {
+                        rmSync(coverageDirectory, { recursive: true, force: true });
+                    }
+                    catch { /* Best effort. */ }
+                }
+            };
             const finish = (result, cleanup = true) => {
                 if (settled)
                     return;
                 settled = true;
                 if (cleanup)
-                    report?.cleanup();
+                    cleanupArtifacts();
                 resolve(result);
             };
             // Spawn the test runner process
@@ -390,6 +402,7 @@ Provide:
             try {
                 proc = spawn(command, args, {
                     cwd: process.cwd(),
+                    detached: process.platform !== 'win32',
                     env: {
                         ...process.env,
                         FORCE_COLOR: '0', // Disable color codes for easier parsing
@@ -401,10 +414,15 @@ Provide:
                 finish(err(new Error(`Failed to spawn test runner: ${toErrorMessage(error)}. Is '${command}' installed?`)));
                 return;
             }
+            const untrackExit = trackTestRunnerExit(proc);
             // Set timeout
             const timeoutId = setTimeout(() => {
                 killed = true;
-                proc.kill('SIGTERM');
+                termination = terminateTestRunner(proc);
+                // Keep the timeout outcome immediate; cleanup waits for the owned
+                // group, rather than treating the root's close as descendant exit.
+                termination.catch(error => logger.warn(`Test runner cleanup failed: ${toErrorMessage(error)}`));
+                termination.then(untrackExit, () => undefined);
                 finish(err(new Error(`Test execution timed out after ${timeout}ms for files: ${fileLabel}`)), false);
             }, timeout);
             proc.stdout?.on('data', (data) => {
@@ -416,9 +434,12 @@ Provide:
             proc.on('close', (code) => {
                 clearTimeout(timeoutId);
                 if (killed) {
-                    report?.cleanup();
-                    return; // Timeout result was already returned; child has now closed.
+                    // Coverage and JSON reports belong to this run; clean both only
+                    // after the entire owned process group has stopped.
+                    termination?.then(() => cleanupArtifacts(), () => undefined);
+                    return; // The timeout result has already been returned.
                 }
+                untrackExit();
                 // Parse results based on framework. Vitest 5 writes the JSON report to
                 // a file instead of stdout, so read it back through the report handle.
                 let reportText;
@@ -434,10 +455,10 @@ Provide:
                     return;
                 }
                 const parseResult = this.parseTestOutput(reportText, stderr, fileLabel, framework, code);
-                // If no coverage in stdout JSON, try reading from disk
-                // (vitest/jest write coverage to coverage/coverage-summary.json)
-                if (parseResult.success && !parseResult.value.coverage && ['vitest', 'jest'].includes(framework.toLowerCase())) {
-                    const diskCoverage = this.readCoverageFromDisk();
+                // Read only this invocation's coverage artifacts. A previous or
+                // concurrent run's project coverage directory is not evidence.
+                if (parseResult.success && !parseResult.value.coverage && coverageDirectory) {
+                    const diskCoverage = this.readCoverageFromDisk(coverageDirectory);
                     if (diskCoverage) {
                         parseResult.value.coverage = diskCoverage.summary;
                         if (diskCoverage.perFile.length > 0) {
@@ -451,6 +472,7 @@ Provide:
                 clearTimeout(timeoutId);
                 if (killed)
                     return;
+                untrackExit();
                 finish(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
             });
         });
@@ -460,22 +482,35 @@ Provide:
      */
     buildTestCommand(fileOrFiles, framework) {
         const files = Array.isArray(fileOrFiles) ? fileOrFiles : [fileOrFiles];
+        const createCoverageDirectory = () => mkdtempSync(join(tmpdir(), 'aqe-test-coverage-'));
         switch (framework.toLowerCase()) {
             case 'vitest': {
                 // --outputFile makes Vitest 4 and 5 both write the JSON report to a
                 // file we own; Vitest 5 no longer prints it to stdout.
-                const report = createVitestJsonReport();
+                const coverageDirectory = createCoverageDirectory();
+                let report;
+                try {
+                    report = createVitestJsonReport();
+                }
+                catch (error) {
+                    rmSync(coverageDirectory, { recursive: true, force: true });
+                    throw error;
+                }
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args, `--coverage.reportsDirectory=${coverageDirectory}`],
                     report,
+                    coverageDirectory,
                 };
             }
-            case 'jest':
+            case 'jest': {
+                const coverageDirectory = createCoverageDirectory();
                 return {
                     command: 'npx',
-                    args: ['jest', ...files, '--json', '--no-colors', '--testLocationInResults'],
+                    args: ['jest', ...files, '--json', '--no-colors', '--testLocationInResults', `--coverageDirectory=${coverageDirectory}`],
+                    coverageDirectory,
                 };
+            }
             case 'mocha':
                 // Note: mocha has no built-in coverage — requires external nyc/c8 wrapper.
                 // Coverage data will be unavailable for mocha-based test runs.
@@ -491,11 +526,20 @@ Provide:
                 };
             default: {
                 // Default to vitest
-                const report = createVitestJsonReport();
+                const coverageDirectory = createCoverageDirectory();
+                let report;
+                try {
+                    report = createVitestJsonReport();
+                }
+                catch (error) {
+                    rmSync(coverageDirectory, { recursive: true, force: true });
+                    throw error;
+                }
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color', ...report.args, `--coverage.reportsDirectory=${coverageDirectory}`],
                     report,
+                    coverageDirectory,
                 };
             }
         }
@@ -1003,16 +1047,16 @@ Provide:
         return { perFile };
     }
     /**
-     * Read coverage from disk files written by vitest/jest.
-     * Both runners write coverage-summary.json to a coverage/ directory when
-     * --coverage is passed, rather than embedding it in stdout JSON.
+     * Read coverage from the private output directory of a completed runner.
+     * Setting the directory does not enable coverage; project configuration
+     * still decides whether coverage is collected.
      */
-    readCoverageFromDisk() {
+    readCoverageFromDisk(coverageDirectory) {
         try {
             // Check common coverage output paths
             const candidates = [
-                join(process.cwd(), 'coverage', 'coverage-summary.json'),
-                join(process.cwd(), 'coverage', 'coverage-final.json'),
+                join(coverageDirectory, 'coverage-summary.json'),
+                join(coverageDirectory, 'coverage-final.json'),
             ];
             for (const filePath of candidates) {
                 if (!existsSync(filePath))

package/dist/domains/test-generation/coordinator.js

@@ -249,7 +249,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             this.startWorkflow(workflowId, 'generate');
             // Opt-in (plan 06, D7-wire): try the FREE local model first with a repair
             // loop. Fully guarded — any miss falls through to the normal LLM path.
-            if (this.freeTierExecutor) {
+            if (this.freeTierExecutor && !request.behaviorExamples?.length) {
                 try {
                     const ft = await this.tryFreeTierGeneration(request);
                     if (ft) {
@@ -354,11 +354,12 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                     }
                 }
                 // Three-loop protocol: instantAdapt must precede recordOutcome
-                if (isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()) {
+                const coverageEstimate = result.value.coverageEstimate;
+                if (coverageEstimate !== null && isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()) {
                     const tests = result.value;
                     this.qesona.instantAdapt([
                         tests.tests.length / 20,
-                        tests.coverageEstimate / 100,
+                        coverageEstimate / 100,
                         tests.patternsUsed.length / 10,
                         request.sourceFiles.length / 20,
                         (request.coverageTarget ?? 80) / 100,
@@ -476,7 +477,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             framework,
             llmEnhanced: true,
         };
-        return { tests: [test], coverageEstimate: 0, patternsUsed: ['free-tier-local', `tier:${r.tierUsed}`] };
+        return { tests: [test], coverageEstimate: null, patternsUsed: ['free-tier-local', `tier:${r.tierUsed}`] };
     }
     /**
      * Generate tests using TDD workflow
@@ -953,7 +954,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
      * Per ADR-040: Store test generation patterns in SONA
      */
     async storeTestGenerationPattern(tests, request) {
-        if (!this.qesona) {
+        if (!this.qesona || tests.coverageEstimate === null) {
             return;
         }
         try {