agentic-qe 3.15.9 → 3.15.11

package/dist/domains/code-intelligence/services/metric-collector/test-counter.js

@@ -12,7 +12,7 @@
  *
  * @see docs/plans/AQE_V3_IMPROVEMENTS_PLAN.md - Phase 5, RM-003
  */
-import { execSync, spawn, spawnSync } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
 import { createRequire } from 'module';
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from 'fs';
 import { tmpdir } from 'os';
@@ -21,6 +21,8 @@ import { AQE_STATE_DIR } from '../../../../shared/aqe-managed-dirs.js';
 import { DEFAULT_METRIC_CONFIG, } from './interfaces.js';
 import { safeJsonParse } from '../../../../shared/safe-json.js';
 import { ownListingProcess } from './listing-process-owner.js';
+import { runTestRunnerProcess } from '../../../../shared/test-runner-process.js';
+import { npmCliInvocation } from '../../../../shared/npm-cli-invocation.js';
 // ============================================================================
 // Main Test Counting Function
 // ============================================================================
@@ -99,82 +101,31 @@ export function detectTestRunner(projectPath) {
 /**
  * Check which test runners are available on the system
  */
-export function checkTestRunners(projectPath) {
-    const tools = [];
-    // Check npx vitest
-    try {
-        const result = spawnSync('npx', ['vitest', '--version'], {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            timeout: 10000,
-        });
-        if (result.status === 0) {
-            tools.push({ name: 'vitest', available: true, version: result.stdout.trim() });
-        }
-        else {
-            tools.push({ name: 'vitest', available: false });
-        }
-    }
-    catch {
-        tools.push({ name: 'vitest', available: false });
-    }
-    // Check npx jest
-    try {
-        const result = spawnSync('npx', ['jest', '--version'], {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            timeout: 10000,
-        });
-        if (result.status === 0) {
-            tools.push({ name: 'jest', available: true, version: result.stdout.trim() });
-        }
-        else {
-            tools.push({ name: 'jest', available: false });
-        }
-    }
-    catch {
-        tools.push({ name: 'jest', available: false });
-    }
-    // Check cargo
-    try {
-        const result = spawnSync('cargo', ['--version'], { encoding: 'utf-8', timeout: 5000 });
-        if (result.status === 0) {
-            tools.push({ name: 'cargo', available: true, version: result.stdout.trim() });
-        }
-        else {
-            tools.push({ name: 'cargo', available: false });
-        }
-    }
-    catch {
-        tools.push({ name: 'cargo', available: false });
-    }
-    // Check pytest
-    try {
-        const result = spawnSync('pytest', ['--version'], { encoding: 'utf-8', timeout: 5000 });
-        if (result.status === 0) {
-            tools.push({ name: 'pytest', available: true, version: result.stdout.trim() });
-        }
-        else {
-            tools.push({ name: 'pytest', available: false });
-        }
-    }
-    catch {
-        tools.push({ name: 'pytest', available: false });
-    }
-    // Check go
-    try {
-        const result = spawnSync('go', ['version'], { encoding: 'utf-8', timeout: 5000 });
-        if (result.status === 0) {
-            tools.push({ name: 'go', available: true, version: result.stdout.trim() });
-        }
-        else {
-            tools.push({ name: 'go', available: false });
-        }
-    }
-    catch {
-        tools.push({ name: 'go', available: false });
-    }
-    return tools;
+export async function checkTestRunners(projectPath) {
+    const npx = npmCliInvocation('npx');
+    const probes = [
+        ['vitest', npx, ['vitest', '--version'], projectPath, 10000],
+        ['jest', npx, ['jest', '--version'], projectPath, 10000],
+        ['cargo', ['cargo', []], ['--version'], process.cwd(), 5000],
+        ['pytest', ['pytest', []], ['--version'], process.cwd(), 5000],
+        ['go', ['go', []], ['version'], process.cwd(), 5000],
+    ];
+    return Promise.all(probes.map(async ([name, invocation, args, cwd, timeout]) => {
+        const output = await runListing(invocation, args, cwd, timeout);
+        return output === null ? { name, available: false } : { name, available: true, version: output.trim() };
+    }));
+}
+/**
+ * Run a probe or listing command without blocking the event loop (#1115).
+ * Resolves with stdout on exit 0, or null when it cannot start, fails or
+ * times out; a timeout stops the whole process group (cargo, npx trees).
+ */
+async function runListing(invocation, args, cwd, timeout, maxBuffer) {
+    if (!invocation)
+        return null;
+    const [command, leadingArgs] = invocation;
+    const result = await runTestRunnerProcess(command, [...leadingArgs, ...args], { cwd, timeout, maxBuffer });
+    return result.error || result.status !== 0 ? null : result.stdout;
 }
 // ============================================================================
 // Runner-Specific Implementations
@@ -319,15 +270,12 @@ async function countVitestTests(projectPath, config) {
  * Uses `jest --listTests` for accurate test file discovery WITHOUT execution.
  * Then parses the test files to count individual tests.
  */
-function countJestTests(projectPath, config) {
+async function countJestTests(projectPath, config) {
     try {
-        // Use jest --listTests for safe enumeration (NO execution)
-        const output = execSync('npx jest --listTests', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            timeout: Math.min(config.timeout, 30000), // Cap at 30s for listing
-            maxBuffer: 10 * 1024 * 1024, // 10MB buffer (reduced from 50MB)
-        });
+        // Use jest --listTests for safe enumeration (NO execution), capped at 30s
+        const output = await runListing(npmCliInvocation('npx'), ['jest', '--listTests'], projectPath, Math.min(config.timeout, 30000), 10 * 1024 * 1024);
+        if (output === null)
+            return countTestsByFilePattern(projectPath, config);
         // Output is one test file path per line
         const testFiles = output
             .split('\n')
@@ -353,13 +301,11 @@ function countJestTests(projectPath, config) {
  * Count tests using Cargo (Rust)
  * Uses `cargo test -- --list` for accurate test enumeration
  */
-function countCargoTests(projectPath, config) {
+async function countCargoTests(projectPath, config) {
     try {
-        const output = execSync('cargo test -- --list', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            timeout: config.timeout,
-        });
+        const output = await runListing(['cargo', []], ['test', '--', '--list'], projectPath, config.timeout);
+        if (output === null)
+            throw new Error('listing failed');
         // Count lines ending with ": test"
         const testLines = output.split('\n').filter(line => line.endsWith(': test'));
         const total = testLines.length;
@@ -389,13 +335,11 @@ function countCargoTests(projectPath, config) {
  * Count tests using pytest (Python)
  * Uses `pytest --collect-only` for test discovery
  */
-function countPytestTests(projectPath, config) {
+async function countPytestTests(projectPath, config) {
     try {
-        const output = execSync('pytest --collect-only -q', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            timeout: config.timeout,
-        });
+        const output = await runListing(['pytest', []], ['--collect-only', '-q'], projectPath, config.timeout);
+        if (output === null)
+            throw new Error('listing failed');
         // Count test function lines (format: "tests/test_foo.py::test_bar")
         const testLines = output.split('\n').filter(line => line.includes('::test_') || line.includes('::Test'));
         const total = testLines.length;
@@ -426,13 +370,11 @@ function countPytestTests(projectPath, config) {
  * Count tests using Go test
  * Uses `go test -list` for test discovery
  */
-function countGoTests(projectPath, config) {
+async function countGoTests(projectPath, config) {
     try {
-        const output = execSync('go test -list ".*" ./...', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            timeout: config.timeout,
-        });
+        const output = await runListing(['go', []], ['test', '-list', '.*', './...'], projectPath, config.timeout);
+        if (output === null)
+            throw new Error('listing failed');
         // Benchmarks and examples are listed too, but are not included in the
         // test total. Apply that same selection to every category.
         const testLines = output.split('\n').filter(line => line.startsWith('Test'));

package/dist/domains/code-intelligence/services/product-factors-bridge.js

@@ -15,6 +15,7 @@ import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import * as path from 'path';
 import * as fs from 'fs/promises';
+import { readConfinedText } from '../../../shared/io/confined-read.js';
 import { ok, err } from '../../../shared/types/index.js';
 import { CodeIntelligenceEvents, createEvent, } from '../../../shared/events/domain-events.js';
 import { toError } from '../../../shared/error-utils.js';
@@ -319,7 +320,7 @@ export class ProductFactorsBridgeService {
     async getProjectMetadata(projectPath) {
         try {
             const packageJsonPath = path.join(projectPath, 'package.json');
-            const content = await fs.readFile(packageJsonPath, 'utf-8');
+            const content = await readConfinedText(packageJsonPath, { outsideRoot: 'allow' }); // #1161
             const pkg = safeJsonParse(content);
             return {
                 name: pkg.name || 'Project',
@@ -344,14 +345,16 @@ export class ProductFactorsBridgeService {
             catch {
                 return systems;
             }
-            const content = await fs.readFile(packageJsonPath, 'utf-8');
+            const content = await readConfinedText(packageJsonPath, { outsideRoot: 'allow' }); // #1161
             const pkg = safeJsonParse(content);
             const allDeps = {
                 ...pkg.dependencies,
                 ...pkg.devDependencies,
             };
             for (const [depName] of Object.entries(allDeps)) {
-                const pattern = EXTERNAL_SYSTEM_PATTERNS[depName];
+                // #1157: dependency names come from package.json; a package named
+                // `constructor` is not a known external system.
+                const pattern = Object.hasOwn(EXTERNAL_SYSTEM_PATTERNS, depName) ? EXTERNAL_SYSTEM_PATTERNS[depName] : undefined;
                 if (pattern) {
                     systems.push({
                         id: sanitizeId(depName),
@@ -636,7 +639,7 @@ export class ProductFactorsBridgeService {
         // Simple hash based on package.json and file count
         try {
             const packageJsonPath = path.join(projectPath, 'package.json');
-            const content = await fs.readFile(packageJsonPath, 'utf-8');
+            const content = await readConfinedText(packageJsonPath, { outsideRoot: 'allow' }); // #1161
             return this.hashString(content);
         }
         catch {

package/dist/domains/contract-testing/services/api-compatibility.js

@@ -259,9 +259,10 @@ export class ApiCompatibilityService {
             const newProps = newContent.properties || {};
             const oldRequired = oldContent.required || [];
             const newRequired = newContent.required || [];
-            // Check for removed properties
+            // Check for removed properties. #1136: own properties only, so a
+            // property named `constructor` or `toString` is compared like any other.
             for (const prop of Object.keys(oldProps)) {
-                if (!(prop in newProps)) {
+                if (!Object.hasOwn(newProps, prop)) {
                     breakingChanges.push({
                         type: 'removed-field',
                         location: `schema:${oldSchema.id}.${prop}`,
@@ -273,7 +274,7 @@ export class ApiCompatibilityService {
             }
             // Check for added properties
             for (const prop of Object.keys(newProps)) {
-                if (!(prop in oldProps)) {
+                if (!Object.hasOwn(oldProps, prop)) {
                     nonBreakingChanges.push({
                         type: 'added-field',
                         location: `schema:${newSchema.id}.${prop}`,
@@ -284,7 +285,7 @@ export class ApiCompatibilityService {
             // Check for new required fields (breaking if field existed as optional)
             for (const req of newRequired) {
                 if (!oldRequired.includes(req)) {
-                    if (req in oldProps) {
+                    if (Object.hasOwn(oldProps, req)) {
                         // Was optional, now required
                         if (!this.config.allowOptionalToRequired) {
                             breakingChanges.push({
@@ -296,7 +297,7 @@ export class ApiCompatibilityService {
                             });
                         }
                     }
-                    else if (req in newProps) {
+                    else if (Object.hasOwn(newProps, req)) {
                         // New required field
                         breakingChanges.push({
                             type: 'required-field-added',
@@ -310,7 +311,7 @@ export class ApiCompatibilityService {
             }
             // Check for type changes
             for (const prop of Object.keys(oldProps)) {
-                if (prop in newProps) {
+                if (Object.hasOwn(newProps, prop)) {
                     const oldPropDef = oldProps[prop];
                     const newPropDef = newProps[prop];
                     if (oldPropDef.type !== newPropDef.type) {

package/dist/domains/contract-testing/services/contract-validator.js

@@ -760,7 +760,8 @@ Provide:
         // Validate variables against operation variable definitions
         if (variables && operationInfo.variableDefinitions) {
             for (const [varName, varDef] of Object.entries(operationInfo.variableDefinitions)) {
-                if (varDef.required && !(varName in variables)) {
+                // #1136: own properties only; an inherited `constructor` is not a variable.
+                if (varDef.required && !Object.hasOwn(variables, varName)) {
                     errors.push({
                         path: `variables.${varName}`,
                         keyword: 'required',
@@ -768,7 +769,7 @@ Provide:
                         params: { variable: varName },
                     });
                 }
-                if (varName in variables) {
+                if (Object.hasOwn(variables, varName)) {
                     this.validateGraphQLVariableType(variables[varName], varDef.type, `variables.${varName}`, errors);
                 }
             }
@@ -1209,7 +1210,8 @@ Provide:
             const dataObj = data;
             // Check required properties
             for (const prop of required) {
-                if (!(prop in dataObj)) {
+                // #1136: own properties only; an inherited `constructor` is not present.
+                if (!Object.hasOwn(dataObj, prop)) {
                     errors.push({
                         path: path ? `${path}.${prop}` : prop,
                         keyword: 'required',
@@ -1220,7 +1222,7 @@ Provide:
             }
             // Validate each property
             for (const [prop, propSchema] of Object.entries(properties)) {
-                if (prop in dataObj) {
+                if (Object.hasOwn(dataObj, prop)) {
                     this.basicTypeValidation(dataObj[prop], propSchema, path ? `${path}.${prop}` : prop, errors, depth + 1);
                 }
             }

package/dist/domains/contract-testing/services/schema-validator.js

@@ -308,7 +308,8 @@ export class SchemaValidatorService {
         const additionalProperties = schema.additionalProperties;
         // Check required properties
         for (const prop of required) {
-            if (!(prop in value)) {
+            // #1136: own properties only; an inherited `constructor` is not present.
+            if (!Object.hasOwn(value, prop)) {
                 errors.push({
                     path: path ? `${path}.${prop}` : prop,
                     keyword: 'required',
@@ -320,7 +321,7 @@ export class SchemaValidatorService {
         // Validate each property
         for (const [prop, propValue] of Object.entries(value)) {
             const propPath = path ? `${path}.${prop}` : prop;
-            if (prop in properties) {
+            if (Object.hasOwn(properties, prop)) {
                 this.validateValue(propValue, properties[prop], propPath, errors, depth + 1);
             }
             else if (this.config.strictMode && additionalProperties === false) {
@@ -605,15 +606,17 @@ export class SchemaValidatorService {
         const oldRequired = new Set(oldSchema.required || []);
         const newRequired = new Set(newSchema.required || []);
         // Check for removed properties
+        // #1136: own properties only, so a property named `constructor` or
+        // `toString` is compared like any other.
         for (const prop of Object.keys(oldProps)) {
-            if (!(prop in newProps)) {
+            if (!Object.hasOwn(newProps, prop)) {
                 const propPath = path ? `${path}.${prop}` : prop;
                 removals.push(propPath);
             }
         }
         // Check for added properties
         for (const prop of Object.keys(newProps)) {
-            if (!(prop in oldProps)) {
+            if (!Object.hasOwn(oldProps, prop)) {
                 const propPath = path ? `${path}.${prop}` : prop;
                 additions.push(propPath);
                 // New required property is breaking
@@ -639,7 +642,7 @@ export class SchemaValidatorService {
         // Check for required changes
         const newRequiredArray = Array.from(newRequired);
         for (const prop of newRequiredArray) {
-            if (!oldRequired.has(prop) && prop in oldProps) {
+            if (!oldRequired.has(prop) && Object.hasOwn(oldProps, prop)) {
                 const propPath = path ? `${path}.${prop}` : prop;
                 modifications.push({
                     path: propPath,

package/dist/domains/coverage-analysis/services/coverage-parser.js

@@ -19,6 +19,15 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { safeJsonParse } from '../../../shared/safe-json.js';
+import { readConfinedText } from '../../../shared/io/confined-read.js';
+/**
+ * #1161: coverage reports are found under caller-named directories, so read
+ * them from a validated descriptor: a report linked out of the project, or to
+ * a device such as /dev/zero, is refused instead of read.
+ */
+function readCoverageFile(file) {
+    return readConfinedText(file, { outsideRoot: 'allow' });
+}
 // ============================================================================
 // LCOV Parser
 // ============================================================================
@@ -28,7 +37,7 @@ import { safeJsonParse } from '../../../shared/safe-json.js';
  * LCOV format is the most common output from Istanbul, nyc, c8, etc.
  */
 export async function parseLCOV(lcovPath, projectRoot) {
-    const content = await fs.readFile(lcovPath, 'utf-8');
+    const content = await readCoverageFile(lcovPath);
     return parseLCOVContent(content, projectRoot || path.dirname(lcovPath));
 }
 /**
@@ -221,7 +230,7 @@ export function parseLCOVContent(content, projectRoot) {
  * Parse JSON coverage data (Istanbul/Vitest format)
  */
 export async function parseJSONCoverage(jsonPath, projectRoot) {
-    const content = await fs.readFile(jsonPath, 'utf-8');
+    const content = await readCoverageFile(jsonPath);
     const data = safeJsonParse(content);
     const root = projectRoot || path.dirname(jsonPath);
     const files = new Map();
@@ -334,7 +343,7 @@ export async function parseJSONCoverage(jsonPath, projectRoot) {
  *   <report><package><class><method><counter type="LINE" missed="X" covered="Y"/></method></class></package></report>
  */
 export async function parseJaCoCo(xmlPath, projectRoot) {
-    const content = await fs.readFile(xmlPath, 'utf-8');
+    const content = await readCoverageFile(xmlPath);
     return parseJaCoCoContent(content, projectRoot || path.dirname(xmlPath));
 }
 export function parseJaCoCoContent(content, projectRoot) {
@@ -437,7 +446,7 @@ function parseJaCoCoCounters(xml) {
  *   <Root CoveredStatements="X" TotalStatements="Y"><Assembly><Namespace><Type><Member Statement="..."/></Type></Namespace></Assembly></Root>
  */
 export async function parseDotcover(xmlPath, projectRoot) {
-    const content = await fs.readFile(xmlPath, 'utf-8');
+    const content = await readCoverageFile(xmlPath);
     return parseDotcoverContent(content, projectRoot || path.dirname(xmlPath));
 }
 export function parseDotcoverContent(content, projectRoot) {
@@ -531,7 +540,7 @@ export function parseDotcoverContent(content, projectRoot) {
  * Also handles tarpaulin LCOV output by delegating to parseLCOVContent.
  */
 export async function parseTarpaulin(filePath, projectRoot) {
-    const content = await fs.readFile(filePath, 'utf-8');
+    const content = await readCoverageFile(filePath);
     const root = projectRoot || path.dirname(filePath);
     // If it looks like LCOV, delegate
     if (content.includes('SF:') && content.includes('end_of_record')) {
@@ -603,7 +612,7 @@ export function parseTarpaulinContent(content, projectRoot) {
  *   pkg/file.go:startLine.startCol,endLine.endCol numStatements count
  */
 export async function parseGoCover(coverPath, projectRoot) {
-    const content = await fs.readFile(coverPath, 'utf-8');
+    const content = await readCoverageFile(coverPath);
     return parseGoCoverContent(content, projectRoot || path.dirname(coverPath));
 }
 export function parseGoCoverContent(content, projectRoot) {
@@ -681,7 +690,7 @@ export function parseGoCoverContent(content, projectRoot) {
  * but sets the format and language appropriately.
  */
 export async function parseKover(xmlPath, projectRoot) {
-    const content = await fs.readFile(xmlPath, 'utf-8');
+    const content = await readCoverageFile(xmlPath);
     const report = parseJaCoCoContent(content, projectRoot || path.dirname(xmlPath));
     report.format = 'kover';
     report.language = 'kotlin';
@@ -698,7 +707,7 @@ export async function parseKover(xmlPath, projectRoot) {
  *   { "targets": [ { "files": [ { "path": "...", "lineCoverage": 0.85, "coveredLines": N, "executableLines": N, "functions": [...] } ] } ] }
  */
 export async function parseXcresult(jsonPath, projectRoot) {
-    const content = await fs.readFile(jsonPath, 'utf-8');
+    const content = await readCoverageFile(jsonPath);
     return parseXcresultContent(content, projectRoot || path.dirname(jsonPath));
 }
 export function parseXcresultContent(content, projectRoot) {
@@ -830,7 +839,7 @@ export async function parseCoverage(coveragePath, projectRoot, format, language)
         return parseXcresult(coveragePath, projectRoot);
     }
     // Content-based detection
-    const content = await fs.readFile(coveragePath, 'utf-8');
+    const content = await readCoverageFile(coveragePath);
     const trimmed = content.trim();
     if (trimmed.startsWith('{')) {
         // Check for tarpaulin JSON structure
@@ -869,7 +878,7 @@ export async function parseCoverage(coveragePath, projectRoot, format, language)
     // Language-based fallback: try the first format associated with the language
     if (language) {
         const langLower = language.toLowerCase();
-        const hints = LANGUAGE_FORMAT_HINTS[langLower];
+        const hints = Object.hasOwn(LANGUAGE_FORMAT_HINTS, langLower) ? LANGUAGE_FORMAT_HINTS[langLower] : undefined; // #1157
         if (hints && hints.length > 0) {
             try {
                 return await parseCoverage(coveragePath, projectRoot, hints[0]);

package/dist/domains/defect-intelligence/interfaces.d.ts

@@ -55,6 +55,8 @@ export interface FilePrediction {
         contribution: number;
     }[];
     recommendations: string[];
+    /** Why this prediction is incomplete, e.g. git history timed out (#1115). */
+    warnings?: string[];
 }
 export interface RootCauseRequest {
     defectId: string;

package/dist/domains/defect-intelligence/plugin.js

@@ -4,6 +4,7 @@
  */
 import { err } from '../../shared/types/index.js';
 import { BaseDomainPlugin } from '../domain-interface.js';
+import { MAX_PAYLOAD_FILE_BYTES, requirePayloadFiles } from '../../shared/io/payload-path-guard.js';
 import { DefectIntelligenceCoordinator, } from './coordinator.js';
 import { DefectPredictorService, } from './services/defect-predictor.js';
 import { PatternLearnerService, } from './services/pattern-learner.js';
@@ -79,8 +80,12 @@ export class DefectIntelligencePlugin extends BaseDomainPlugin {
                     if (!files || files.length === 0) {
                         return err(new Error('Invalid predict-defects payload: missing files'));
                     }
+                    // #1126: refuse by name what FileReader would otherwise skip quietly.
+                    const confined = await requirePayloadFiles('predict-defects', 'files', files, { maxBytes: MAX_PAYLOAD_FILE_BYTES });
+                    if (!confined.success)
+                        return confined;
                     return this.coordinator.predictDefects({
-                        files,
+                        files: confined.value,
                         threshold: threshold ?? 0.7,
                     });
                 }],
@@ -112,8 +117,12 @@ export class DefectIntelligencePlugin extends BaseDomainPlugin {
                     if (!changedFiles || changedFiles.length === 0) {
                         return err(new Error('Invalid analyze-regression-risk payload: missing changedFiles'));
                     }
+                    // #1126: a changeset may name deleted files, but never outside ones.
+                    const confined = await requirePayloadFiles('analyze-regression-risk', 'changedFiles', changedFiles, { allowMissing: true });
+                    if (!confined.success)
+                        return confined;
                     return this.coordinator.analyzeRegressionRisk({
-                        changeset: changedFiles,
+                        changeset: confined.value,
                         baseline: payload.commitHash,
                     });
                 }],

package/dist/domains/defect-intelligence/prediction-history.d.ts

@@ -0,0 +1,27 @@
+import type { MemoryBackend } from '../../kernel/interfaces.js';
+export declare const MAX_PREDICTION_HISTORY = 32;
+type RiskLevel = 'critical' | 'high' | 'medium' | 'low' | 'info';
+/** One file prediction as the defect-intelligence predictor recorded it. */
+export interface DomainFilePrediction {
+    file: string;
+    probability: number;
+    riskLevel: RiskLevel;
+    factors: {
+        name: string;
+        contribution: number;
+    }[];
+    recommendations: string[];
+}
+/** A recorded prediction run, or `null` when the record is not a usable one. */
+export declare function parsePredictionRecord(raw: unknown, now: number): {
+    id: string;
+    timestamp: string;
+    predictions: DomainFilePrediction[];
+    predictionMethod?: 'static-code-indicators';
+    estimated?: true;
+    filesSkipped?: number;
+} | null;
+/** Keep 32 usable immutable UUID runs, preserving tied-latest ambiguity. */
+export declare function prunePredictionHistory(memory: Pick<MemoryBackend, 'search' | 'get' | 'delete'>, modelNamespace?: string): Promise<void>;
+export {};
+//# sourceMappingURL=prediction-history.d.ts.map

package/dist/domains/defect-intelligence/prediction-history.js

@@ -0,0 +1,68 @@
+export const MAX_PREDICTION_HISTORY = 32;
+const MAX_PREDICTION_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const NAMESPACE = 'defect-intelligence';
+const RISK_LEVELS = ['critical', 'high', 'medium', 'low', 'info'];
+const isRecord = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+function parseFilePrediction(raw) {
+    if (!isRecord(raw))
+        return null;
+    const { file, probability, riskLevel } = raw;
+    if (typeof file !== 'string' || file.length === 0)
+        return null;
+    if (typeof probability !== 'number' || !Number.isFinite(probability) || probability < 0 || probability > 1)
+        return null;
+    if (!RISK_LEVELS.includes(riskLevel))
+        return null;
+    const factors = Array.isArray(raw.factors)
+        ? raw.factors.filter((f) => isRecord(f) && typeof f.name === 'string' && typeof f.contribution === 'number' && Number.isFinite(f.contribution))
+        : [];
+    const recommendations = Array.isArray(raw.recommendations)
+        ? raw.recommendations.filter((r) => typeof r === 'string')
+        : [];
+    return { file, probability, riskLevel: riskLevel, factors, recommendations };
+}
+/** A recorded prediction run, or `null` when the record is not a usable one. */
+export function parsePredictionRecord(raw, now) {
+    if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.timestamp !== 'string')
+        return null;
+    const t = Date.parse(raw.timestamp);
+    if (!Number.isFinite(t) || t > now + 60_000 || now - t > MAX_PREDICTION_AGE_MS)
+        return null;
+    if (!Array.isArray(raw.predictions) || raw.predictions.length === 0)
+        return null;
+    const predictions = raw.predictions.map(parseFilePrediction);
+    if (predictions.some((p) => p === null))
+        return null;
+    return {
+        id: raw.id, timestamp: raw.timestamp, predictions: predictions,
+        ...(raw.predictionMethod === 'static-code-indicators' ? {
+            predictionMethod: 'static-code-indicators', estimated: true,
+            filesSkipped: typeof raw.filesSkipped === 'number' && Number.isSafeInteger(raw.filesSkipped) && raw.filesSkipped >= 0
+                ? raw.filesSkipped : 0,
+        } : {}),
+    };
+}
+/** Keep 32 usable immutable UUID runs, preserving tied-latest ambiguity. */
+export async function prunePredictionHistory(memory, modelNamespace = 'defect-intelligence:predictor') {
+    const prefix = `${modelNamespace}:prediction:`;
+    const keys = await memory.search(`${prefix}*`, Number.MAX_SAFE_INTEGER, { namespace: NAMESPACE });
+    const now = Date.now();
+    const records = [];
+    const invalid = [];
+    for (const found of keys) {
+        const key = found.startsWith(`${NAMESPACE}:${prefix}`) ? found.slice(NAMESPACE.length + 1) : found;
+        if (!key.startsWith(prefix))
+            continue;
+        const parsed = parsePredictionRecord(await memory.get(key, { namespace: NAMESPACE }), now);
+        if (parsed)
+            records.push({ key, timestamp: Date.parse(parsed.timestamp), id: parsed.id });
+        else
+            invalid.push(key);
+    }
+    records.sort((a, b) => b.timestamp - a.timestamp || (a.id === b.id ? (a.key === b.key ? 0 : a.key > b.key ? -1 : 1) : a.id > b.id ? -1 : 1));
+    // Only observed immutable keys are candidates; concurrent new runs are untouched.
+    for (const key of [...invalid, ...records.slice(MAX_PREDICTION_HISTORY).map(record => record.key)]) {
+        await memory.delete(key, { namespace: NAMESPACE });
+    }
+}
+//# sourceMappingURL=prediction-history.js.map