agentic-qe 3.15.7 → 3.15.9

package/dist/domains/learning-optimization/services/metrics-optimizer.js

@@ -5,8 +5,8 @@
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
 import { toError } from '../../../shared/error-utils.js';
-import { secureRandom } from '../../../shared/utils/crypto-random.js';
 import { rehydrateDates } from '../../../shared/utils/kv-date-rehydrate.js';
+import { partitionByRewardSource } from '../reward-source.js';
 const DEFAULT_CONFIG = {
     defaultConfidenceLevel: 0.95,
     minSamplesForOptimization: 20,
@@ -14,6 +14,12 @@ const DEFAULT_CONFIG = {
     improvementThreshold: 0.05,
     explorationRate: 0.1,
 };
+/** Namespace every optimizer record is written under. */
+const LEARNING_NS = { namespace: 'learning-optimization' };
+/** Share of the most recent experiences held out from fitting (#1099). */
+const HELD_OUT_FRACTION = 0.2;
+/** Relative tolerance within which an observed outcome matches the prediction. */
+const VALIDATION_TOLERANCE = 0.2;
 /**
  * SEC-003: Dangerous keys that could lead to prototype pollution
  */
@@ -41,29 +47,54 @@ export class MetricsOptimizerService {
     /**
      * Optimize a strategy for a given objective
      */
-    async optimizeStrategy(currentStrategy, objective, experiences) {
+    async optimizeStrategy(currentStrategy, objective, input) {
         try {
+            // #1109: fit and validate on measured outcomes only.
+            const { measured: experiences, assignedExcluded } = partitionByRewardSource(input);
             if (experiences.length < this.config.minSamplesForOptimization) {
-                return err(new Error(`Need at least ${this.config.minSamplesForOptimization} experiences for optimization`));
+                const excluded = assignedExcluded > 0
+                    ? ` (${assignedExcluded} with an assigned reward excluded)`
+                    : '';
+                return err(new Error(`Need at least ${this.config.minSamplesForOptimization} measured experiences for optimization${excluded}`));
             }
-            // Calculate current performance
-            const currentPerformance = this.evaluateStrategyPerformance(currentStrategy, experiences, objective);
+            // #1099: fit on the older experiences and validate on the most recent
+            // ones, which the fit never saw, so confidence is a held-out measurement
+            // rather than a score on the data the optimizer was fitted to.
+            const ordered = [...experiences].sort((a, b) => timeOf(a) - timeOf(b));
+            const heldOutSize = Math.max(1, Math.floor(ordered.length * HELD_OUT_FRACTION));
+            const training = ordered.slice(0, -heldOutSize);
+            const heldOut = ordered.slice(-heldOutSize);
             // Generate optimized parameters
-            const optimizedParameters = await this.optimizeParameters(currentStrategy.parameters, experiences, objective);
+            const optimizedParameters = await this.optimizeParameters(currentStrategy.parameters, training, objective);
             // Create optimized strategy
             const optimizedStrategy = {
                 name: `${currentStrategy.name}-optimized`,
                 parameters: optimizedParameters,
-                expectedOutcome: this.predictOutcome(optimizedParameters, experiences),
+                expectedOutcome: this.predictOutcome(optimizedParameters, training),
+            };
+            // Validate the fitted expectation against the held-out experiences
+            const validationResults = await this.validateOptimization(currentStrategy, optimizedStrategy, heldOut);
+            // The optimized strategy has never run, so its improvement cannot be
+            // observed. It is modelled as the change in parameter score between the
+            // two strategies on the held-out experiences, and labelled an estimate.
+            const improvement = this.calculateImprovement(this.scoreParameters(currentStrategy.parameters, heldOut, objective), this.scoreParameters(optimizedParameters, heldOut, objective), objective);
+            // Confidence is the share of held-out experiences whose observed
+            // outcome matched the fitted expectation.
+            const confidence = validationResults.length > 0
+                ? validationResults.filter((r) => r.passed).length / validationResults.length
+                : 0;
+            const unmeasured = [];
+            if (improvement === undefined)
+                unmeasured.push('improvement');
+            if (validationResults.length === 0)
+                unmeasured.push('confidence');
+            const evaluation = {
+                method: 'held-out',
+                trainingSamples: training.length,
+                heldOutSamples: heldOut.length,
+                estimated: improvement === undefined ? [] : ['improvement'],
+                ...(unmeasured.length > 0 ? { unmeasured } : {}),
             };
-            // Validate optimization
-            const validationResults = await this.validateOptimization(currentStrategy, optimizedStrategy, experiences.slice(-10) // Use recent experiences for validation
-            );
-            // Calculate improvement
-            const optimizedPerformance = this.evaluateStrategyPerformance(optimizedStrategy, experiences, objective);
-            const improvement = this.calculateImprovement(currentPerformance, optimizedPerformance, objective);
-            // Calculate confidence
-            const confidence = this.calculateOptimizationConfidence(experiences.length, improvement, validationResults);
             const domain = this.inferDomainFromExperiences(experiences);
             const result = {
                 id: uuidv4(),
@@ -71,9 +102,10 @@ export class MetricsOptimizerService {
                 objective,
                 currentStrategy,
                 optimizedStrategy,
-                improvement,
+                improvement: improvement ?? 0,
                 confidence,
                 validationResults,
+                evaluation,
             };
             // Store optimization result
             await this.storeOptimizationResult(result);
@@ -88,9 +120,24 @@ export class MetricsOptimizerService {
      */
     async runABTest(strategyA, strategyB, testConfig) {
         try {
-            // Simulate or retrieve test results
-            const metricsA = await this.collectStrategyMetrics(strategyA, testConfig.metric, testConfig.minSamples);
-            const metricsB = await this.collectStrategyMetrics(strategyB, testConfig.metric, testConfig.minSamples);
+            // Recorded observations only (#1099): never pad with simulated samples.
+            const metricsA = await this.collectStrategyMetrics(strategyA, testConfig.metric);
+            const metricsB = await this.collectStrategyMetrics(strategyB, testConfig.metric);
+            // An arm with no recorded sample is never evidence, whatever minSamples says.
+            const minSamples = Math.max(1, testConfig.minSamples);
+            if (metricsA.length < minSamples || metricsB.length < minSamples) {
+                const insufficient = {
+                    winner: 'inconclusive',
+                    evidenceStatus: 'insufficient-evidence',
+                    unmeasured: [testConfig.metric, 'stdDev', 'pValue'],
+                    strategyAMetrics: { samples: metricsA.length },
+                    strategyBMetrics: { samples: metricsB.length },
+                    sampleSizeA: metricsA.length,
+                    sampleSizeB: metricsB.length,
+                };
+                await this.storeABTestResult(strategyA, strategyB, insufficient);
+                return ok(insufficient);
+            }
             // Calculate statistics
             const meanA = this.calculateMean(metricsA);
             const meanB = this.calculateMean(metricsB);
@@ -100,7 +147,7 @@ export class MetricsOptimizerService {
             const pValue = this.calculatePValue(metricsA, metricsB);
             // Determine winner
             let winner;
-            if (pValue < 1 - testConfig.confidenceLevel) {
+            if (pValue !== undefined && pValue < 1 - testConfig.confidenceLevel) {
                 winner = meanA > meanB ? 'A' : 'B';
             }
             else {
@@ -118,7 +165,10 @@ export class MetricsOptimizerService {
                     stdDev: stdB,
                     samples: metricsB.length,
                 },
-                pValue,
+                // Neither arm varied, so the t statistic is undefined (#1099).
+                ...(pValue === undefined
+                    ? { unmeasured: ['pValue'], pValueUnavailableReason: 'zero-variance' }
+                    : { pValue }),
                 sampleSizeA: metricsA.length,
                 sampleSizeB: metricsB.length,
             };
@@ -154,7 +204,8 @@ export class MetricsOptimizerService {
                 return ok({
                     name: 'default-strategy',
                     parameters: this.getDefaultParameters(context),
-                    expectedOutcome: { success_rate: 0.7 },
+                    // #1099: nothing was measured for the default, so expect nothing.
+                    expectedOutcome: {},
                 });
             }
             // Sort by score and return best
@@ -168,8 +219,21 @@ export class MetricsOptimizerService {
     /**
      * Evaluate strategy performance
      */
-    async evaluateStrategy(strategy, experiences) {
+    async evaluateStrategy(strategy, input) {
         try {
+            // #1109: an assigned reward says nothing about how the strategy performed.
+            const { measured: experiences, assignedExcluded } = partitionByRewardSource(input);
+            if (experiences.length === 0) {
+                return ok({
+                    strategy,
+                    metrics: {},
+                    strengths: [],
+                    weaknesses: [],
+                    improvementAreas: [],
+                    evidenceStatus: 'insufficient-evidence',
+                    ...(assignedExcluded > 0 ? { assignedRewardsExcluded: assignedExcluded } : {}),
+                });
+            }
             // Calculate metrics
             const metrics = {};
             const successRate = this.calculateSuccessRate(experiences);
@@ -250,12 +314,12 @@ export class MetricsOptimizerService {
      */
     async getMetricsHistory(strategyId, limit = 100) {
         try {
-            const keys = await this.memory.search(`learning:metrics:history:${strategyId}:*`, limit);
+            const keys = await this.searchLearningKeys(`learning:metrics:history:${strategyId}:*`, limit);
             const snapshots = [];
             for (const key of keys) {
                 // #493: rehydrate `timestamp` at the kv-read seam — without this,
                 // the sort below throws once any snapshot exists in the kv.
-                const snapshot = rehydrateDates(await this.memory.get(key), ['timestamp']);
+                const snapshot = rehydrateDates(await this.memory.get(key, LEARNING_NS), ['timestamp']);
                 if (snapshot) {
                     snapshots.push(snapshot);
                 }
@@ -295,15 +359,14 @@ export class MetricsOptimizerService {
     // ============================================================================
     // Private Helper Methods
     // ============================================================================
-    evaluateStrategyPerformance(_strategy, experiences, objective) {
-        let totalScore = 0;
-        let count = 0;
-        for (const exp of experiences) {
-            const metricValue = exp.result.outcome[objective.metric] ?? 0;
-            totalScore += metricValue;
-            count++;
-        }
-        return count > 0 ? totalScore / count : 0;
+    /**
+     * Keys matching `pattern` under LEARNING_NS, ready for a namespaced get().
+     * In-memory search includes its namespace; SQLite returns a bare key.
+     */
+    async searchLearningKeys(pattern, limit) {
+        const prefix = `${LEARNING_NS.namespace}:`;
+        const found = await this.memory.search(pattern, limit, LEARNING_NS);
+        return found.map((key) => (key.startsWith(prefix) ? key.slice(prefix.length) : key));
     }
     async optimizeParameters(currentParams, experiences, objective) {
         const optimized = { ...currentParams };
@@ -391,11 +454,18 @@ export class MetricsOptimizerService {
     }
     async validateOptimization(_current, optimized, validationExperiences) {
         const results = [];
+        // Nothing was predicted, so there is nothing to validate.
+        const expected = Object.entries(optimized.expectedOutcome);
+        if (expected.length === 0)
+            return results;
         for (const exp of validationExperiences) {
-            const expected = optimized.expectedOutcome;
-            const passed = Object.entries(expected).every(([key, value]) => {
-                const actual = exp.result.outcome[key] ?? 0;
-                return Math.abs(actual - value) / Math.max(value, 1) < 0.2;
+            // A metric the experience did not record is not evidence either way.
+            const comparable = expected.filter(([key]) => typeof exp.result.outcome[key] === 'number');
+            if (comparable.length === 0)
+                continue;
+            const passed = comparable.every(([key, value]) => {
+                const actual = exp.result.outcome[key];
+                return Math.abs(actual - value) / Math.max(value, 1) < VALIDATION_TOLERANCE;
             });
             results.push({
                 testId: exp.id,
@@ -405,23 +475,14 @@ export class MetricsOptimizerService {
         }
         return results;
     }
+    /** Relative change; undefined when there is no baseline to compare with. */
     calculateImprovement(currentPerf, optimizedPerf, objective) {
         if (currentPerf === 0)
-            return optimizedPerf > 0 ? 1 : 0;
+            return undefined;
         const diff = optimizedPerf - currentPerf;
         const improvement = objective.direction === 'maximize' ? diff / currentPerf : -diff / currentPerf;
         return Math.max(-1, Math.min(1, improvement));
     }
-    calculateOptimizationConfidence(sampleSize, improvement, validationResults) {
-        // Base confidence from sample size
-        const sampleConfidence = Math.min(1, sampleSize / (this.config.minSamplesForOptimization * 2));
-        // Validation pass rate
-        const passRate = validationResults.filter((r) => r.passed).length /
-            Math.max(validationResults.length, 1);
-        // Improvement significance
-        const improvementConfidence = Math.abs(improvement) > this.config.improvementThreshold ? 1 : 0.5;
-        return sampleConfidence * 0.3 + passRate * 0.5 + improvementConfidence * 0.2;
-    }
     inferDomainFromExperiences(experiences) {
         const domainCounts = new Map();
         for (const exp of experiences) {
@@ -437,22 +498,21 @@ export class MetricsOptimizerService {
         }
         return maxDomain;
     }
-    async collectStrategyMetrics(strategy, metric, minSamples) {
-        const keys = await this.memory.search(`learning:metrics:history:*:*`, minSamples * 2);
+    /**
+     * Values of `metric` recorded for this strategy through trackMetrics(),
+     * whose strategy id is the strategy name. Only recorded observations are
+     * returned; the caller decides whether there are enough (#1099).
+     */
+    async collectStrategyMetrics(strategy, metric) {
+        const keys = await this.searchLearningKeys(`learning:metrics:history:${strategy.name}:*`, 1000);
         const metrics = [];
         for (const key of keys) {
-            const snapshot = await this.memory.get(key);
-            if (snapshot &&
-                snapshot.metrics[metric] !== undefined) {
-                metrics.push(snapshot.metrics[metric]);
+            const snapshot = await this.memory.get(key, LEARNING_NS);
+            const value = snapshot?.metrics[metric];
+            if (typeof value === 'number' && Number.isFinite(value)) {
+                metrics.push(value);
             }
         }
-        // If not enough real data, generate simulated data
-        while (metrics.length < minSamples) {
-            const expected = strategy.expectedOutcome[metric] || 0.5;
-            const variation = (secureRandom() - 0.5) * 0.2;
-            metrics.push(expected + variation);
-        }
         return metrics;
     }
     calculateMean(values) {
@@ -467,6 +527,7 @@ export class MetricsOptimizerService {
         const squaredDiffs = values.map((v) => Math.pow(v - mean, 2));
         return Math.sqrt(squaredDiffs.reduce((a, b) => a + b, 0) / values.length);
     }
+    /** Undefined when neither group varies: the test statistic is undefined. */
     calculatePValue(groupA, groupB) {
         // Simplified p-value calculation using Welch's t-test approximation
         const meanA = this.calculateMean(groupA);
@@ -477,7 +538,7 @@ export class MetricsOptimizerService {
         const nB = groupB.length;
         const se = Math.sqrt(varA / nA + varB / nB);
         if (se === 0)
-            return 0.5;
+            return undefined;
         const t = Math.abs(meanA - meanB) / se;
         // Approximate p-value using normal distribution
         const pValue = 2 * (1 - this.normalCDF(t));
@@ -590,7 +651,7 @@ export class MetricsOptimizerService {
     }
     async updateAggregatedMetrics(strategyId, metrics) {
         const key = `learning:metrics:aggregated:${strategyId}`;
-        const existing = await this.memory.get(key);
+        const existing = await this.memory.get(key, LEARNING_NS);
         const aggregated = existing?.metrics || {};
         for (const [metricName, value] of Object.entries(metrics)) {
             // SEC-003: Guard against prototype pollution
@@ -627,4 +688,9 @@ export class MetricsOptimizerService {
         }, { namespace: 'learning-optimization', ttl: 86400 * 7 });
     }
 }
+/** Epoch milliseconds of an experience; kv reads may hand back an ISO string. */
+function timeOf(experience) {
+    const ms = new Date(experience.timestamp).getTime();
+    return Number.isNaN(ms) ? 0 : ms;
+}
 //# sourceMappingURL=metrics-optimizer.js.map

package/dist/domains/learning-optimization/services/transfer-specialist.js

@@ -6,6 +6,8 @@ import { v4 as uuidv4 } from 'uuid';
 import { ok, err, ALL_DOMAINS } from '../../../shared/types/index.js';
 import { toError } from '../../../shared/error-utils.js';
 import { rehydrateDates } from '../../../shared/utils/kv-date-rehydrate.js';
+import { searchAllKeys } from '../../../shared/utils/namespaced-search.js';
+import { LEARNING_NS } from '../active-patterns.js';
 const DEFAULT_CONFIG = {
     maxKnowledgeItems: 1000,
     relevanceThreshold: 0.5,
@@ -56,32 +58,35 @@ export class TransferSpecialistService {
     async queryKnowledge(query) {
         try {
             const results = [];
-            // Search by domain if specified
-            let keys;
-            if (query.domain) {
-                keys = await this.memory.search(`learning:knowledge:*:${query.domain}:*`, query.limit || 100);
-            }
-            else {
-                keys = await this.memory.search('learning:knowledge:shared:*', query.limit || 100);
-            }
+            // Secondary domain/type indexes store IDs, not Knowledge objects, and
+            // shareKnowledge() need not create them. Read canonical shared records
+            // from the same namespace as both writers, then filter and rank before
+            // applying the caller's result limit. #1071: every key is read (the
+            // config value only sizes the first scan request), so the domain filter
+            // sees every item instead of an arbitrary first page.
+            const keys = await searchAllKeys(this.memory, 'learning:knowledge:shared:*', {
+                retrieve: LEARNING_NS,
+                pageSize: this.config.maxKnowledgeItems,
+            });
             for (const key of keys) {
                 // #493: rehydrate Date fields at the kv-read seam. `createdAt` is
                 // consumed by validateRelevance().getTime() and `expiresAt` is
                 // compared via `new Date() > knowledge.expiresAt` — both broken
                 // when the field is a string after JSON round-trip.
-                const knowledge = rehydrateDates(await this.memory.get(key), ['createdAt', 'expiresAt']);
+                const knowledge = rehydrateDates(await this.memory.get(key, { namespace: 'learning-optimization' }), ['createdAt', 'expiresAt']);
                 if (knowledge && this.matchesQuery(knowledge, query)) {
                     results.push(knowledge);
                 }
             }
-            // Sort by relevance score
-            results.sort((a, b) => b.relevanceScore - a.relevanceScore);
+            // Sort by relevance score; equal scores fall back to id order so the
+            // caller's limit always keeps the same items (#1071).
+            results.sort((a, b) => b.relevanceScore - a.relevanceScore || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
             // Apply semantic search if embedding provided
             if (query.embedding && query.embedding.length > 0) {
                 const vectorResults = await this.memory.vectorSearch(query.embedding, query.limit || 10);
                 for (const vr of vectorResults) {
                     // #493: rehydrate Date fields at the kv-read seam.
-                    const knowledge = rehydrateDates(await this.memory.get(vr.key), ['createdAt', 'expiresAt']);
+                    const knowledge = rehydrateDates(await this.memory.get(vr.key, { namespace: 'learning-optimization' }), ['createdAt', 'expiresAt']);
                     if (knowledge &&
                         !results.some((r) => r.id === knowledge.id) &&
                         this.matchesQuery(knowledge, query)) {
@@ -253,7 +258,7 @@ export class TransferSpecialistService {
      */
     async getKnowledgeById(id) {
         // #493: rehydrate Date fields at the kv-read seam.
-        const knowledge = rehydrateDates(await this.memory.get(`learning:knowledge:shared:${id}`), ['createdAt', 'expiresAt']);
+        const knowledge = rehydrateDates(await this.memory.get(`learning:knowledge:shared:${id}`, { namespace: 'learning-optimization' }), ['createdAt', 'expiresAt']);
         return knowledge || null;
     }
     /**
@@ -261,11 +266,16 @@ export class TransferSpecialistService {
      */
     async bulkTransfer(sourceProject, targetProject, filter) {
         try {
-            const keys = await this.memory.search(`learning:knowledge:project:${sourceProject}:*`, 500);
+            // #1071: read project knowledge from the namespace it is written to
+            // below, every key, in key order. The scan is a glob (and
+            // case-insensitive on SQLite), so keep only this project's own
+            // `<prefix><id>` keys: `ALPHA` or `alpha:sub` must not leak into `alpha`.
+            const prefix = `learning:knowledge:project:${sourceProject}:`;
+            const keys = (await searchAllKeys(this.memory, `${prefix}*`, { retrieve: LEARNING_NS })).filter((key) => key.startsWith(prefix) && !key.slice(prefix.length).includes(':'));
             const results = [];
             for (const key of keys) {
                 // #493: rehydrate Date fields at the kv-read seam.
-                const knowledge = rehydrateDates(await this.memory.get(key), ['createdAt', 'expiresAt']);
+                const knowledge = rehydrateDates(await this.memory.get(key, LEARNING_NS), ['createdAt', 'expiresAt']);
                 if (!knowledge)
                     continue;
                 // Apply filter

package/dist/domains/test-execution/interfaces.d.ts

@@ -69,10 +69,26 @@ export interface ITestRunResult {
     skipped: number;
     duration: number;
     failedTests: IFailedTest[];
+    /**
+     * #1110: every test case as listed in the runner's own JSON report. Absent
+     * when the runner gave no per-test entries for the whole run (e.g. a
+     * summary-line fallback); never synthesized from counts.
+     */
+    testCases?: ITestCaseResult[];
     coverage?: ICoverageData;
     /** Per-file coverage data for granular quality assessment */
     fileCoverages?: IFileCoverageData[];
 }
+/** One test case taken verbatim from a runner report (#1110). */
+export interface ITestCaseResult {
+    name: string;
+    file: string;
+    status: 'passed' | 'failed' | 'skipped';
+    /** Runner-reported duration in ms; omitted when the runner reported none. */
+    duration?: number;
+    /** The runner's failure message for a failed test, when it reported one. */
+    failureMessage?: string;
+}
 export interface IFileCoverageData {
     path: string;
     line: number;

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

@@ -6,7 +6,7 @@ import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 import { jestExactPathPattern, nameFilterArg, runnerFilePath } from '../../../shared/test-runner-args.js';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { ok, err } from '../../../shared/types/index.js';
 import { TEST_EXECUTION_CONSTANTS, RETRY_CONSTANTS } from '../../constants.js';
@@ -14,6 +14,22 @@ 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';
+/**
+ * Whether a runner-reported test file and the requested target are the same
+ * file. Runners report real paths, so a target given through a symlink must be
+ * compared by realpath, falling back to the runner path when a file is missing.
+ */
+function sameTestFile(reported, target, cwd) {
+    const canonical = (file) => {
+        try {
+            return realpathSync(resolvePath(cwd, file));
+        }
+        catch {
+            return runnerFilePath(file, cwd);
+        }
+    };
+    return canonical(reported) === canonical(target);
+}
 const DEFAULT_RETRY_CONFIG = {
     simulateForTesting: false,
     simulatedRetrySuccessRate: RETRY_CONSTANTS.DEFAULT_FLAKY_PASS_RATE,
@@ -462,7 +478,7 @@ export class RetryHandlerService {
                 // Vitest's positional file filter uses prefix matching. A passing
                 // sibling must not clear a failure in the requested file (#972).
                 const targetPassed = !targetFile || result.testResults?.some((file) => typeof file.name === 'string'
-                    && resolvePath(file.name) === resolvePath(targetFile)
+                    && sameTestFile(file.name, targetFile, this.config.cwd ?? process.cwd())
                     && file.assertionResults?.some(assertion => assertion.status === 'passed'));
                 if (exitCode === 0 && result.success !== false
                     && result.numFailedTests === 0 && result.numFailedTestSuites === 0

package/dist/domains/test-execution/services/runner-test-cases.d.ts

@@ -0,0 +1,21 @@
+/**
+ * #1110: per-test results read from a Vitest/Jest JSON report.
+ *
+ * Both runners emit `testResults[].assertionResults[]`. Each entry becomes one
+ * test case with the runner's own name, status and duration; nothing is
+ * derived from aggregate counts.
+ */
+import type { ITestCaseResult } from '../interfaces';
+/**
+ * Test cases listed in a runner JSON report, or undefined when the report
+ * has no per-test entries.
+ */
+export declare function testCasesFromRunnerReport(report: {
+    testResults?: unknown;
+}, fallbackFile: string): ITestCaseResult[] | undefined;
+/** Concatenate per-run test cases; undefined unless every run listed its tests. */
+export declare function mergeTestCases(runs: ReadonlyArray<{
+    testCases?: ITestCaseResult[];
+    total: number;
+}>): ITestCaseResult[] | undefined;
+//# sourceMappingURL=runner-test-cases.d.ts.map

package/dist/domains/test-execution/services/runner-test-cases.js

@@ -0,0 +1,69 @@
+/**
+ * #1110: per-test results read from a Vitest/Jest JSON report.
+ *
+ * Both runners emit `testResults[].assertionResults[]`. Each entry becomes one
+ * test case with the runner's own name, status and duration; nothing is
+ * derived from aggregate counts.
+ */
+const SKIPPED_STATUSES = new Set(['skipped', 'pending', 'todo']);
+/** Upper bound on a reported failure message, so one stack cannot swamp the output. */
+const MAX_FAILURE_MESSAGE_LENGTH = 4000;
+function failureMessageOf(assertion) {
+    if (!Array.isArray(assertion.failureMessages))
+        return undefined;
+    const message = assertion.failureMessages.filter((m) => typeof m === 'string').join('\n').trim();
+    if (!message)
+        return undefined;
+    return message.length > MAX_FAILURE_MESSAGE_LENGTH
+        ? `${message.slice(0, MAX_FAILURE_MESSAGE_LENGTH)}… [truncated]`
+        : message;
+}
+function toStatus(status) {
+    if (status === 'passed' || status === 'failed')
+        return status;
+    return typeof status === 'string' && SKIPPED_STATUSES.has(status) ? 'skipped' : undefined;
+}
+/**
+ * Test cases listed in a runner JSON report, or undefined when the report
+ * has no per-test entries.
+ */
+export function testCasesFromRunnerReport(report, fallbackFile) {
+    if (!Array.isArray(report.testResults))
+        return undefined;
+    const cases = [];
+    for (const fileResult of report.testResults) {
+        const file = typeof fileResult?.name === 'string' ? fileResult.name : fallbackFile;
+        const assertions = Array.isArray(fileResult?.assertionResults) ? fileResult.assertionResults : [];
+        for (const assertion of assertions) {
+            // A malformed entry is skipped; the caller's count check then drops the list.
+            if (!assertion || typeof assertion !== 'object')
+                continue;
+            const status = toStatus(assertion.status);
+            if (!status)
+                continue;
+            const name = typeof assertion.fullName === 'string' && assertion.fullName
+                ? assertion.fullName
+                : typeof assertion.title === 'string' ? assertion.title : '';
+            if (!name)
+                continue;
+            const duration = typeof assertion.duration === 'number' && Number.isFinite(assertion.duration)
+                ? assertion.duration
+                : undefined;
+            const failureMessage = status === 'failed' ? failureMessageOf(assertion) : undefined;
+            cases.push({
+                name, file, status,
+                ...(duration !== undefined ? { duration } : {}),
+                ...(failureMessage ? { failureMessage } : {}),
+            });
+        }
+    }
+    return cases.length > 0 ? cases : undefined;
+}
+/** Concatenate per-run test cases; undefined unless every run listed its tests. */
+export function mergeTestCases(runs) {
+    if (runs.length === 0 || runs.some(run => run.total > 0 && !run.testCases))
+        return undefined;
+    const merged = runs.flatMap(run => run.testCases ?? []);
+    return merged.length > 0 ? merged : undefined;
+}
+//# sourceMappingURL=runner-test-cases.js.map

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

@@ -127,6 +127,11 @@ export declare class TestExecutorService implements ITestExecutionService {
      * Parse vitest JSON output
      */
     private parseVitestOutput;
+    /**
+     * #1110: the report's per-test entries, kept only when they account for
+     * every counted test; a partial list would misstate the run.
+     */
+    private reportedTestCases;
     /**
      * Parse jest JSON output
      */