agentic-qe 3.15.8 → 3.15.10

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

package/dist/domains/defect-intelligence/services/defect-predictor.js

@@ -6,10 +6,12 @@
  * ADR-051: LLM enhancement for AI-powered defect risk analysis
  */
 import { v4 as uuidv4 } from 'uuid';
+import { prunePredictionHistory } from '../prediction-history.js';
 import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types/index.js';
 import { GitAnalyzer } from '../../../shared/git/index.js';
 import { FileReader } from '../../../shared/io/index.js';
+import { findProjectRoot } from '../../../kernel/project-root.js';
 import { TypeScriptParser } from '../../../shared/parsers/index.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
@@ -53,6 +55,8 @@ const DEFAULT_FEATURES = [
  * ADR-051: Added LLM enhancement for AI-powered defect risk analysis
  */
 const logger = LoggerFactory.create('defect-intelligence/defect-predictor');
+const GIT_TIMEOUT_WARNING = 'Git history timed out for this file: change frequency, developer experience, code age and bug history ' +
+    'use their "no git data" defaults, so this prediction is incomplete.';
 export class DefectPredictorService {
     config;
     memory;
@@ -79,7 +83,8 @@ export class DefectPredictorService {
             // New signature: DefectPredictorDependencies
             this.memory = memoryOrDeps.memory;
             this.gitAnalyzer = memoryOrDeps.gitAnalyzer ?? new GitAnalyzer({ enableCache: true });
-            this.fileReader = memoryOrDeps.fileReader ?? new FileReader();
+            // #1096: a symlink inside the project must not expose an outside file.
+            this.fileReader = memoryOrDeps.fileReader ?? new FileReader({ projectRoot: findProjectRoot() });
             this.tsParser = memoryOrDeps.tsParser ?? new TypeScriptParser();
             this.llmRouter = memoryOrDeps.llmRouter;
         }
@@ -87,7 +92,7 @@ export class DefectPredictorService {
             // Old signature: memory, config, gitAnalyzer, fileReader, tsParser
             this.memory = memoryOrDeps;
             this.gitAnalyzer = gitAnalyzer ?? new GitAnalyzer({ enableCache: true });
-            this.fileReader = fileReader ?? new FileReader();
+            this.fileReader = fileReader ?? new FileReader({ projectRoot: findProjectRoot() });
             this.tsParser = tsParser ?? new TypeScriptParser();
             this.llmRouter = undefined;
         }
@@ -427,7 +432,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
     // ============================================================================
     async predictForFile(file, features, threshold) {
         // Extract file metrics
-        const fileMetrics = await this.extractFileMetrics(file);
+        const { metrics: fileMetrics, gitTimedOut } = await this.extractFileMetrics(file);
         // Calculate probability based on weighted features
         const featureContributions = [];
         let probability = 0;
@@ -446,33 +451,44 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         const riskLevel = this.probabilityToRisk(probability, threshold);
         // Generate recommendations based on high-contributing factors
         const recommendations = this.generateRecommendations(featureContributions, probability);
+        if (gitTimedOut)
+            recommendations.unshift(GIT_TIMEOUT_WARNING);
         return {
             file,
             probability,
             riskLevel,
             factors: featureContributions.filter((f) => f.contribution > 0.05),
             recommendations,
+            ...(gitTimedOut ? { warnings: [GIT_TIMEOUT_WARNING] } : {}),
         };
     }
     async extractFileMetrics(file) {
         // Try to get cached metrics
         const cachedMetrics = await this.memory.get(`${this.config.modelNamespace}:file-metrics:${file}`);
         if (cachedMetrics) {
-            return cachedMetrics;
+            return { metrics: cachedMetrics, gitTimedOut: false };
         }
         // Calculate metrics using real code analysis and git history
-        const metrics = {
+        const measure = async () => ({
             codeComplexity: await this.calculateComplexity(file),
             changeFrequency: await this.getChangeFrequency(file),
             developerExperience: await this.getDeveloperExperience(file),
             testCoverage: await this.getTestCoverage(file),
             codeAge: await this.getCodeAge(file),
             bugHistory: await this.getBugHistory(file),
-        };
-        // Cache metrics
-        await this.memory.set(`${this.config.modelNamespace}:file-metrics:${file}`, metrics, { namespace: 'defect-intelligence', ttl: 3600 } // 1 hour cache
-        );
-        return metrics;
+        });
+        // #1115: the git-based metrics of one file share one deadline.
+        const metrics = this.gitAnalyzer.withFileDeadline
+            ? await this.gitAnalyzer.withFileDeadline(file, measure)
+            : await measure();
+        // #1115: a git timeout left defaults in the git-based metrics; do not
+        // cache them as this file's measured metrics.
+        const gitTimedOut = this.gitAnalyzer.consumeTimeout?.(file) === true;
+        if (!gitTimedOut) {
+            await this.memory.set(`${this.config.modelNamespace}:file-metrics:${file}`, metrics, { namespace: 'defect-intelligence', ttl: 3600 } // 1 hour cache
+            );
+        }
+        return { metrics, gitTimedOut };
     }
     /**
      * Calculate code complexity using TypeScript AST analysis
@@ -728,7 +744,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         let risk = 0;
         // Determine impacted areas based on file path
         const area = this.categorizeFile(file);
-        const fileRisk = (await this.extractFileMetrics(file)).codeComplexity;
+        const fileRisk = (await this.extractFileMetrics(file)).metrics.codeComplexity;
         areas.push({
             area,
             files: [file],
@@ -740,7 +756,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         if (depth === 'deep') {
             const dependencies = await this.analyzeDependencies(file);
             for (const dep of dependencies) {
-                const depRisk = (await this.extractFileMetrics(dep)).codeComplexity * 0.5;
+                const depRisk = (await this.extractFileMetrics(dep)).metrics.codeComplexity * 0.5;
                 areas.push({
                     area: this.categorizeFile(dep),
                     files: [dep],
@@ -903,6 +919,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
             timestamp: new Date().toISOString(),
         }, { namespace: 'defect-intelligence', ttl: 86400 * 7 } // 7 days
         );
+        await prunePredictionHistory(this.memory, this.config.modelNamespace);
     }
     async recalculateMetrics(feedback) {
         // Simple online update of accuracy

package/dist/domains/enterprise-integration/services/message-broker-service.js

@@ -375,7 +375,8 @@ export class MessageBrokerService {
             // Check required properties
             if (schemaDef.required && Array.isArray(schemaDef.required) && typeof data === 'object' && data !== null) {
                 for (const prop of schemaDef.required) {
-                    if (!(prop in data)) {
+                    // #1136: own properties only; an inherited `constructor` is not present.
+                    if (!Object.hasOwn(data, prop)) {
                         errors.push(`Required property '${prop}' is missing`);
                     }
                 }
@@ -383,7 +384,7 @@ export class MessageBrokerService {
             // Check properties if defined
             if (schemaDef.properties && typeof data === 'object' && data !== null) {
                 for (const [prop, propSchema] of Object.entries(schemaDef.properties)) {
-                    if (prop in data) {
+                    if (Object.hasOwn(data, prop)) {
                         const propDef = propSchema;
                         if (propDef.type) {
                             const actualType = Array.isArray(data[prop]) ? 'array' : typeof data[prop];

package/dist/domains/enterprise-integration/services/odata-service.js

@@ -164,7 +164,8 @@ export class ODataService {
             const errors = [];
             // Validate required parameters
             for (const param of funcImport.parameters) {
-                if (!param.nullable && !(param.name in parameters)) {
+                // #1136: own properties only; an inherited `constructor` is not a parameter.
+                if (!param.nullable && !Object.hasOwn(parameters, param.name)) {
                     errors.push({
                         type: 'metadata',
                         path: `${functionName}/${param.name}`,

package/dist/domains/enterprise-integration/services/sap-integration-service.js

@@ -251,7 +251,8 @@ export class SapIntegrationService {
     validateExportParams(expectedParams, exportValues) {
         const errors = [];
         for (const param of expectedParams) {
-            if (!(param in exportValues)) {
+            // #1136: own properties only; an inherited `constructor` is not a parameter.
+            if (!Object.hasOwn(exportValues, param)) {
                 errors.push(`Expected export parameter '${param}' not found in response`);
             }
         }
@@ -260,7 +261,7 @@ export class SapIntegrationService {
     validateTableParams(expectedParams, tableData) {
         const errors = [];
         for (const param of expectedParams) {
-            if (!(param in tableData)) {
+            if (!Object.hasOwn(tableData, param)) {
                 errors.push(`Expected table parameter '${param}' not found in response`);
             }
         }

package/dist/domains/learning-optimization/active-patterns.d.ts

@@ -7,8 +7,8 @@
  * - `learning:pattern:creation:<id>`: creation provenance written by
  *   `LearningCoordinatorService.recordPatternCreation()` (no `context`)
  * - `learning:pattern:archived:<id>`: archived patterns written by
- *   `LearningCoordinatorService.archivePattern()` and the
- *   learning-consolidation protocol (full pattern shape)
+ *   `archiveSelectedPattern()` (pattern-archive.ts) for the merge path and
+ *   the learning-consolidation protocol (full pattern shape)
  *
  * Every reader of active patterns must go through this module so that
  * provenance and archives are excluded before `get()`, and so that those rows
@@ -17,15 +17,16 @@
  */
 import type { MemoryBackend, RetrieveOptions } from '../../kernel/interfaces.js';
 import type { LearnedPattern } from './interfaces.js';
+/**
+ * The kv namespace every learning-optimization writer uses (#491 Bug 2).
+ * A database identifier: never rename it.
+ */
+export declare const LEARNING_NAMESPACE = "learning-optimization";
+/** Retrieve options for reads and deletes in `LEARNING_NAMESPACE` (#1071). */
+export declare const LEARNING_NS: Readonly<RetrieveOptions>;
 export declare const LEARNING_PATTERN_KEY_PREFIX = "learning:pattern:";
 /** Sub-key families under the pattern prefix that are not active patterns. */
 export declare const NON_ACTIVE_PATTERN_SEGMENTS: readonly string[];
-/**
- * Key-scan cap for active pattern reads. Keys are cheap to list, and only
- * active keys are fetched, so the cap is set well above realistic store
- * sizes. When it is reached, `onTruncated` is called.
- */
-export declare const ACTIVE_PATTERN_KEY_SCAN_LIMIT = 10000;
 /**
  * True when the key is in the active pattern key family
  * (`learning:pattern:<id>`), false for provenance, archives and any other
@@ -40,14 +41,13 @@ export declare function isActivePatternRecord(key: string, value: unknown): valu
 export interface ReadActivePatternsOptions {
     /** Namespace passed to `search()` and `get()`. Omit for the backend default. */
     retrieve?: RetrieveOptions;
-    /** Override the key-scan cap (tests). */
-    scanLimit?: number;
-    /** Called when the key scan hit the cap, so results may be incomplete. */
-    onTruncated?: (scanned: number) => void;
+    /** First key-scan request size (tests). The scan always reads every key. */
+    scanPageSize?: number;
 }
 /**
- * Read every active learned pattern: list keys, drop non-active key families
- * before `get()`, then drop records that fail the shape guard. Date fields
+ * Read every active learned pattern: list every key (no cap, #1071), drop
+ * non-active key families before `get()`, then drop records that fail the
+ * shape guard. Patterns come back in key order. Date fields
  * come back from kv as ISO strings and are rehydrated (#491 Bug 3), so
  * `TimeRange.contains(pattern.createdAt)` works for every reader.
  */

package/dist/domains/learning-optimization/active-patterns.js

@@ -7,8 +7,8 @@
  * - `learning:pattern:creation:<id>`: creation provenance written by
  *   `LearningCoordinatorService.recordPatternCreation()` (no `context`)
  * - `learning:pattern:archived:<id>`: archived patterns written by
- *   `LearningCoordinatorService.archivePattern()` and the
- *   learning-consolidation protocol (full pattern shape)
+ *   `archiveSelectedPattern()` (pattern-archive.ts) for the merge path and
+ *   the learning-consolidation protocol (full pattern shape)
  *
  * Every reader of active patterns must go through this module so that
  * provenance and archives are excluded before `get()`, and so that those rows
@@ -16,15 +16,17 @@
  * untouched; this is read-side classification only.
  */
 import { rehydrateDates } from '../../shared/utils/kv-date-rehydrate.js';
+import { searchAllKeys } from '../../shared/utils/namespaced-search.js';
+/**
+ * The kv namespace every learning-optimization writer uses (#491 Bug 2).
+ * A database identifier: never rename it.
+ */
+export const LEARNING_NAMESPACE = 'learning-optimization';
+/** Retrieve options for reads and deletes in `LEARNING_NAMESPACE` (#1071). */
+export const LEARNING_NS = Object.freeze({ namespace: LEARNING_NAMESPACE });
 export const LEARNING_PATTERN_KEY_PREFIX = 'learning:pattern:';
 /** Sub-key families under the pattern prefix that are not active patterns. */
 export const NON_ACTIVE_PATTERN_SEGMENTS = ['creation', 'archived'];
-/**
- * Key-scan cap for active pattern reads. Keys are cheap to list, and only
- * active keys are fetched, so the cap is set well above realistic store
- * sizes. When it is reached, `onTruncated` is called.
- */
-export const ACTIVE_PATTERN_KEY_SCAN_LIMIT = 10_000;
 /**
  * True when the key is in the active pattern key family
  * (`learning:pattern:<id>`), false for provenance, archives and any other
@@ -53,16 +55,17 @@ export function isActivePatternRecord(key, value) {
     return !!record.context && typeof record.context === 'object';
 }
 /**
- * Read every active learned pattern: list keys, drop non-active key families
- * before `get()`, then drop records that fail the shape guard. Date fields
+ * Read every active learned pattern: list every key (no cap, #1071), drop
+ * non-active key families before `get()`, then drop records that fail the
+ * shape guard. Patterns come back in key order. Date fields
  * come back from kv as ISO strings and are rehydrated (#491 Bug 3), so
  * `TimeRange.contains(pattern.createdAt)` works for every reader.
  */
 export async function readActivePatterns(memory, options = {}) {
-    const limit = options.scanLimit ?? ACTIVE_PATTERN_KEY_SCAN_LIMIT;
-    const keys = await memory.search(`${LEARNING_PATTERN_KEY_PREFIX}*`, limit, options.retrieve);
-    if (keys.length >= limit)
-        options.onTruncated?.(keys.length);
+    const keys = await searchAllKeys(memory, `${LEARNING_PATTERN_KEY_PREFIX}*`, {
+        retrieve: options.retrieve,
+        pageSize: options.scanPageSize,
+    });
     const patterns = [];
     for (const key of keys) {
         if (!isActivePatternKey(key))

package/dist/domains/learning-optimization/coordinator-helpers.js

@@ -45,9 +45,8 @@ export async function getCurrentStrategy(memory, domain) {
             retryCount: 3,
             concurrency: 4,
         },
-        expectedOutcome: {
-            success_rate: 0.8,
-        },
+        // #1099: the default strategy has never run, so no outcome is expected.
+        expectedOutcome: {},
     };
 }
 /**

package/dist/domains/learning-optimization/coordinator.d.ts

@@ -276,9 +276,6 @@ export declare class LearningOptimizationCoordinator extends BaseDomainCoordinat
      */
     importModels(modelExport: ModelExport): Promise<Result<ImportReport>>;
     protected subscribeToEvents(): void;
-    private handleTestRunCompleted;
-    private handleCoverageGap;
-    private handleQualityGate;
     /**
      * Handle experience captured from ExperienceCaptureService
      * This is the bridge between Phase 4 experience capture and the coordinator