agentic-qe 3.15.8 → 3.15.9

package/dist/learning/skill-validation-learner.d.ts

@@ -252,6 +252,8 @@ export declare class SkillValidationLearner {
      */
     extractLearnedPatterns(skillName: string): Promise<ValidationPattern[]>;
     private createEmptyConfidence;
+    /** Preserve data keys such as __proto__ without giving parsed records a prototype. */
+    private parseCrossModelAnalysis;
     private createEmptyCrossModelAnalysis;
     private calculateAvgReasoningQuality;
     private calculateTrend;

package/dist/learning/skill-validation-learner.js

@@ -24,6 +24,7 @@
  * @see .claude/skills/.validation/skill-validation-mcp-integration.md
  */
 import { safeJsonParse } from '../shared/safe-json.js';
+import { createSafeRecord, getOwn, setOwn } from '../shared/utils/safe-record.js';
 import { LoggerFactory } from '../logging/index.js';
 const logger = LoggerFactory.create('skill-validation-learner');
 // ============================================================================
@@ -207,14 +208,8 @@ export class SkillValidationLearner {
                 const pattern = existingPatterns.value[0].pattern;
                 const templateContent = pattern.template?.content;
                 if (templateContent) {
-                    const parsed = safeJsonParse(templateContent);
-                    // Validate that it has the expected structure
-                    if (parsed && typeof parsed === 'object' && typeof parsed.models === 'object') {
-                        crossModel = parsed;
-                    }
-                    else {
-                        crossModel = this.createEmptyCrossModelAnalysis();
-                    }
+                    crossModel = this.parseCrossModelAnalysis(templateContent)
+                        ?? this.createEmptyCrossModelAnalysis();
                 }
                 else {
                     crossModel = this.createEmptyCrossModelAnalysis();
@@ -230,18 +225,16 @@ export class SkillValidationLearner {
         }
         // Ensure models object exists (defensive)
         if (!crossModel.models) {
-            crossModel.models = {};
+            crossModel.models = createSafeRecord();
         }
         // Initialize model data if needed
-        if (!crossModel.models[outcome.model]) {
-            crossModel.models[outcome.model] = {
-                scores: [],
-                passRate: 0,
-                avgReasoningQuality: 0,
-                sampleCount: 0,
-            };
-        }
-        const modelData = crossModel.models[outcome.model];
+        const modelData = getOwn(crossModel.models, outcome.model) ?? {
+            scores: [],
+            passRate: 0,
+            avgReasoningQuality: 0,
+            sampleCount: 0,
+        };
+        setOwn(crossModel.models, outcome.model, modelData);
         modelData.scores.push(outcome.score);
         modelData.sampleCount++;
         // Keep last 50 scores per model
@@ -336,7 +329,7 @@ export class SkillValidationLearner {
             try {
                 const templateContent = patterns.value[0].pattern.template?.content;
                 if (templateContent) {
-                    return safeJsonParse(templateContent);
+                    return this.parseCrossModelAnalysis(templateContent);
                 }
             }
             catch (e) {
@@ -367,7 +360,7 @@ export class SkillValidationLearner {
         if (!confidence)
             return null;
         // Calculate by-model trends
-        const byModel = {};
+        const byModel = createSafeRecord();
         if (crossModel) {
             for (const model of Object.keys(crossModel.models)) {
                 const modelOutcomes = confidence.outcomes
@@ -466,9 +459,24 @@ export class SkillValidationLearner {
             lastUpdated: new Date(),
         };
     }
+    /** Preserve data keys such as __proto__ without giving parsed records a prototype. */
+    parseCrossModelAnalysis(content) {
+        // The generic safe parser strips __proto__, which would discard a legitimate
+        // model's history. This reviver copies every record into a null-prototype
+        // dictionary instead, including nested records; it never invokes setters.
+        const parsed = JSON.parse(content, (_key, value) => {
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                return Object.assign(createSafeRecord(), value);
+            }
+            return value;
+        });
+        return parsed && typeof parsed === 'object' && parsed.models
+            && typeof parsed.models === 'object' && !Array.isArray(parsed.models)
+            ? parsed : null;
+    }
     createEmptyCrossModelAnalysis() {
         return {
-            models: {},
+            models: createSafeRecord(),
             variance: 0,
             hasAnomalies: false,
             lastUpdated: new Date(),

package/dist/mcp/background-workers.js

@@ -28,9 +28,15 @@ export async function startBackgroundWorkers(log, env = process.env) {
         // (workers/daemon.ts) is the contracted default; matches the
         // shutdownDaemon() call site in entry.ts.
         const daemon = getDaemon();
-        await daemon.start();
+        // #1066: start() runs every worker's first tick one after another, which
+        // can take minutes. Let it finish in the background so the QualityDaemon
+        // (and the HTTP server after us) do not wait for it.
+        void daemon.start().catch((startError) => {
+            log(`[MCP] WARNING: Background workers failed to start: ${startError}\n`);
+        });
         const status = daemon.getStatus();
-        log(`[MCP] Background workers started (${status.workerManager.totalWorkers} workers)\n`);
+        log(`[MCP] Background workers started (${status.workerManager.totalWorkers} workers; ` +
+            'first runs continue in the background)\n');
         // IMP-10: Start QualityDaemon with persistent memory (Finding 1 & 2 resolution)
         try {
             const { UnifiedMemoryManager } = await import('../kernel/unified-memory.js');