agentic-qe 3.15.8 → 3.15.10

package/dist/mcp/tools/learning-optimization/optimize.js

@@ -14,7 +14,7 @@ import { LearningCoordinatorService } from '../../../domains/learning-optimizati
 import { MetricsOptimizerService } from '../../../domains/learning-optimization/services/metrics-optimizer.js';
 import { TransferSpecialistService } from '../../../domains/learning-optimization/services/transfer-specialist.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
-import { secureRandom, secureRandomFloat } from '../../../shared/utils/crypto-random.js';
+import { partitionByRewardSource } from '../../../domains/learning-optimization/reward-source.js';
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -59,12 +59,18 @@ export class LearningOptimizeTool extends MCPToolBase {
             switch (action) {
                 case 'learn':
                     result.learnResult = await this.executeLearn(domain, experienceIds, context);
+                    if (result.learnResult.evidenceStatus === 'insufficient-evidence') {
+                        result.evidenceStatus = 'insufficient-evidence';
+                    }
                     break;
                 case 'optimize':
                     if (!objective) {
                         return { success: false, error: 'Objective is required for optimize action' };
                     }
                     result.optimizeResult = await this.executeOptimize(domain, objective, context);
+                    if (result.optimizeResult.evidenceStatus === 'insufficient-evidence') {
+                        result.evidenceStatus = 'insufficient-evidence';
+                    }
                     break;
                 case 'transfer':
                     if (!domain || !targetDomain) {
@@ -74,9 +80,15 @@ export class LearningOptimizeTool extends MCPToolBase {
                     break;
                 case 'patterns':
                     result.patternResult = await this.executePatterns(domain, context);
+                    if (result.patternResult.evidenceStatus === 'insufficient-evidence') {
+                        result.evidenceStatus = 'insufficient-evidence';
+                    }
                     break;
                 case 'dashboard':
                     result.dashboardResult = await this.executeDashboard(context);
+                    if (result.dashboardResult.evidenceStatus === 'insufficient-evidence') {
+                        result.evidenceStatus = 'insufficient-evidence';
+                    }
                     break;
                 default:
                     return { success: false, error: `Unknown action: ${action}` };
@@ -107,14 +119,24 @@ export class LearningOptimizeTool extends MCPToolBase {
             status: 'learning',
             message: `Learning from ${experienceIds?.length || 'recent'} experiences`,
         });
-        // Get experiences from memory or mine recent ones
+        // #1121: learn from the requested experiences; count only those read.
+        if (experienceIds && experienceIds.length > 0) {
+            return this.learnFromExperienceIds(learningCoordinator, experienceIds);
+        }
+        // Mine recent experiences
         const timeRange = TimeRange.lastNDays(7);
         const mineResult = await learningCoordinator.mineExperiences(targetDomain, timeRange);
         const newPatterns = [];
         let experiencesProcessed = 0;
-        let improvement = 0;
+        let evidence = {};
         if (mineResult.success) {
             experiencesProcessed = mineResult.value.experienceCount;
+            // #1109: patterns come from measured outcomes only; say how many were left out.
+            evidence = {
+                measuredExperiences: mineResult.value.measuredExperienceCount ?? experiencesProcessed,
+                assignedRewardsExcluded: mineResult.value.assignedRewardsExcluded ?? 0,
+                ...(mineResult.value.evidenceStatus ? { evidenceStatus: mineResult.value.evidenceStatus } : {}),
+            };
             // Convert mined patterns to result format
             for (const pattern of mineResult.value.patterns) {
                 newPatterns.push({
@@ -127,33 +149,55 @@ export class LearningOptimizeTool extends MCPToolBase {
                     successRate: pattern.successRate,
                 });
             }
-            // Calculate improvement based on success rate vs baseline
-            improvement = mineResult.value.successRate > 0.5
-                ? (mineResult.value.successRate - 0.5) * 20 // Scale to percentage
-                : 0;
-        }
-        // If specific experience IDs provided, record them
-        if (experienceIds && experienceIds.length > 0) {
-            experiencesProcessed = experienceIds.length;
         }
         // If no patterns were learned, return empty result (not fake data)
         // This is a valid state - no patterns discovered yet
-        if (newPatterns.length === 0) {
-            this.markAsRealData(); // Still real data, just empty
-            return {
-                experiencesProcessed,
-                patternsLearned: 0,
-                newPatterns: [],
-                improvement: 0,
-            };
-        }
-        // Mark as real data - we have actual learning results
+        // #1109: there is no recorded baseline, so improvement is never computed
+        // here. The former (successRate - 0.5) * 20 was an invented scale.
         this.markAsRealData();
         return {
             experiencesProcessed,
+            ...evidence,
             patternsLearned: newPatterns.length,
             newPatterns,
-            improvement,
+            improvement: null,
+            unmeasured: ['improvement'],
+        };
+    }
+    /**
+     * #1121: learn from explicitly requested experiences. experiencesProcessed
+     * is the number actually read; IDs with no stored experience are counted in
+     * experienceIdsNotFound instead of being reported as processed.
+     */
+    async learnFromExperienceIds(learningCoordinator, experienceIds) {
+        const readResult = await learningCoordinator.getExperiencesByIds(experienceIds);
+        if (!readResult.success)
+            throw readResult.error;
+        const read = readResult.value;
+        const { measured, assignedExcluded } = partitionByRewardSource(read);
+        const learned = measured.length > 0 ? await learningCoordinator.learnPattern(read) : null;
+        const newPatterns = learned?.success
+            ? [{
+                    id: learned.value.id,
+                    type: learned.value.type,
+                    name: learned.value.name,
+                    description: learned.value.description,
+                    confidence: learned.value.confidence,
+                    usageCount: learned.value.usageCount,
+                    successRate: learned.value.successRate,
+                }]
+            : [];
+        this.markAsRealData();
+        return {
+            experiencesProcessed: read.length,
+            experienceIdsNotFound: new Set(experienceIds).size - read.length,
+            measuredExperiences: measured.length,
+            assignedRewardsExcluded: assignedExcluded,
+            ...(measured.length === 0 ? { evidenceStatus: 'insufficient-evidence' } : {}),
+            patternsLearned: newPatterns.length,
+            newPatterns,
+            improvement: null,
+            unmeasured: ['improvement'],
         };
     }
     /**
@@ -205,30 +249,18 @@ export class LearningOptimizeTool extends MCPToolBase {
         // Get recent experiences for optimization
         const targetDomain = domain || 'learning-optimization';
         const timeRange = TimeRange.lastNDays(30);
-        const mineResult = await learningCoordinator.mineExperiences(targetDomain, timeRange);
-        // Build experiences array from mined data
-        const experiences = [];
-        if (mineResult.success && mineResult.value.experienceCount > 0) {
-            // Mine experiences provides insights, so we construct dummy experiences for optimization
-            // Real implementation would fetch actual experiences from memory
-            const dummyAgentId = { value: 'optimizer-agent', domain: targetDomain, type: 'optimizer' };
-            for (let i = 0; i < Math.min(mineResult.value.experienceCount, 20); i++) {
-                experiences.push({
-                    id: `exp-${i}`,
-                    agentId: dummyAgentId,
-                    domain: targetDomain,
-                    action: 'optimize',
-                    state: { context: {}, metrics: {} },
-                    result: {
-                        success: secureRandom() > 0.3,
-                        outcome: { [objective.metric]: secureRandomFloat(70, 100) },
-                        duration: secureRandomFloat(1000, 6000),
-                    },
-                    reward: mineResult.value.avgReward,
-                    timestamp: new Date(),
-                });
-            }
-        }
+        const recorded = await learningCoordinator.getExperiences(targetDomain, timeRange);
+        if (!recorded.success)
+            throw recorded.error;
+        // #1109: an assigned reward is not an observation; leave it out before the
+        // sample-count gate so it can neither pad the count nor fail the optimizer.
+        const { measured, assignedExcluded } = partitionByRewardSource(recorded.value);
+        // Missing objective values are absence of evidence, not zero or a random
+        // synthetic observation. Preserve eligible records (including failures).
+        const experiences = measured.filter(experience => {
+            const value = experience.result.outcome[objective.metric];
+            return typeof value === 'number' && Number.isFinite(value);
+        });
         // Create current strategy
         const currentStrategy = {
             name: `${targetDomain}-current`,
@@ -237,7 +269,8 @@ export class LearningOptimizeTool extends MCPToolBase {
                 retryCount: 3,
                 timeout: 30000,
             },
-            expectedOutcome: { [objective.metric]: 70 },
+            // #1099: the current strategy's outcome was never measured here.
+            expectedOutcome: {},
         };
         // Convert objective to domain type, properly cast constraints
         const domainConstraints = (objective.constraints || []).map(c => ({
@@ -253,19 +286,32 @@ export class LearningOptimizeTool extends MCPToolBase {
         // Run optimization if we have enough experiences
         let bestStrategy = currentStrategy;
         let improvement = 0;
-        let confidence = 0.5;
+        let confidence = 0;
         let validationResults = [];
+        let unmeasured = [];
+        let estimated;
+        let evaluation;
         if (experiences.length >= 20) {
             const optimizeResult = await metricsOptimizer.optimizeStrategy(currentStrategy, domainObjective, experiences);
-            if (optimizeResult.success) {
-                bestStrategy = {
-                    name: optimizeResult.value.optimizedStrategy.name,
-                    parameters: optimizeResult.value.optimizedStrategy.parameters,
-                    expectedOutcome: optimizeResult.value.optimizedStrategy.expectedOutcome,
+            if (!optimizeResult.success)
+                throw optimizeResult.error;
+            bestStrategy = {
+                name: optimizeResult.value.optimizedStrategy.name,
+                parameters: optimizeResult.value.optimizedStrategy.parameters,
+                expectedOutcome: optimizeResult.value.optimizedStrategy.expectedOutcome,
+            };
+            improvement = optimizeResult.value.improvement * 100; // Convert to percentage
+            confidence = optimizeResult.value.confidence;
+            validationResults = optimizeResult.value.validationResults;
+            const derived = optimizeResult.value.evaluation;
+            if (derived) {
+                evaluation = {
+                    method: derived.method,
+                    trainingSamples: derived.trainingSamples,
+                    heldOutSamples: derived.heldOutSamples,
                 };
-                improvement = optimizeResult.value.improvement * 100; // Convert to percentage
-                confidence = optimizeResult.value.confidence;
-                validationResults = optimizeResult.value.validationResults;
+                estimated = derived.estimated;
+                unmeasured = [...(derived.unmeasured ?? [])];
             }
         }
         else {
@@ -274,16 +320,27 @@ export class LearningOptimizeTool extends MCPToolBase {
                 tags: [targetDomain, objective.metric],
             };
             const recommendResult = await metricsOptimizer.recommendStrategy(contextForRecommendation);
-            if (recommendResult.success) {
-                bestStrategy = {
-                    name: recommendResult.value.name,
-                    parameters: recommendResult.value.parameters,
-                    expectedOutcome: recommendResult.value.expectedOutcome,
-                };
-            }
+            if (!recommendResult.success)
+                throw recommendResult.error;
+            bestStrategy = {
+                name: recommendResult.value.name,
+                parameters: recommendResult.value.parameters,
+                expectedOutcome: recommendResult.value.expectedOutcome,
+            };
+            unmeasured = ['improvement', 'confidence'];
+        }
+        if (Object.keys(bestStrategy.expectedOutcome).length === 0) {
+            unmeasured.push('expectedOutcome');
         }
         return {
-            strategiesEvaluated: experiences.length > 0 ? Math.min(experiences.length, 12) : 1,
+            inputSource: 'recorded-experiences',
+            experiencesUsed: experiences.length,
+            ...(assignedExcluded > 0 ? { assignedRewardsExcluded: assignedExcluded } : {}),
+            strategiesEvaluated: experiences.length >= 20 ? 1 : 0,
+            ...(experiences.length < 20 ? { evidenceStatus: 'insufficient-evidence' } : {}),
+            ...(unmeasured.length > 0 ? { unmeasured } : {}),
+            ...(estimated ? { estimated } : {}),
+            ...(evaluation ? { evaluation } : {}),
             bestStrategy,
             improvement,
             confidence,
@@ -342,14 +399,15 @@ export class LearningOptimizeTool extends MCPToolBase {
         // Get pattern statistics from the real service
         const statsResult = await learningCoordinator.getPatternStats(domain);
         if (!statsResult.success) {
-            // Return empty stats on failure
+            // Stats could not be read: nothing is measured, so no averages (#1121).
             return {
                 totalPatterns: 0,
                 byType: {},
                 byDomain: {},
                 topPatterns: [],
-                avgConfidence: 0,
-                avgSuccessRate: 0,
+                avgConfidence: null,
+                avgSuccessRate: null,
+                evidenceStatus: 'insufficient-evidence',
                 sona,
             };
         }
@@ -364,13 +422,17 @@ export class LearningOptimizeTool extends MCPToolBase {
             usageCount: p.usageCount,
             successRate: p.successRate,
         }));
+        const measured = stats.totalPatterns > 0;
         return {
             totalPatterns: stats.totalPatterns,
             byType: stats.byType,
             byDomain: stats.byDomain,
             topPatterns,
-            avgConfidence: stats.avgConfidence,
-            avgSuccessRate: stats.avgSuccessRate,
+            avgConfidence: measured ? stats.avgConfidence : null,
+            avgSuccessRate: measured ? stats.avgSuccessRate : null,
+            ...(stats.assignedPatternsExcluded ? { assignedPatternsExcluded: stats.assignedPatternsExcluded } : {}),
+            ...(stats.legacyPatternsExcluded ? { legacyPatternsExcluded: stats.legacyPatternsExcluded } : {}),
+            ...(measured ? {} : { evidenceStatus: 'insufficient-evidence' }),
             sona,
         };
     }
@@ -395,16 +457,17 @@ export class LearningOptimizeTool extends MCPToolBase {
             'quality-assessment', 'defect-intelligence', 'learning-optimization'
         ];
         let experiencesLast24h = 0;
+        let assignedRewardsExcluded = 0;
         const domainPerformance = [];
         for (const domain of domains) {
             const mineResult = await learningCoordinator.mineExperiences(domain, recentTimeRange);
             if (mineResult.success) {
                 experiencesLast24h += mineResult.value.experienceCount;
-                if (mineResult.value.experienceCount > 0) {
-                    domainPerformance.push({
-                        domain,
-                        successRate: mineResult.value.successRate,
-                    });
+                assignedRewardsExcluded += mineResult.value.assignedRewardsExcluded ?? 0;
+                // #1109: only a measured success rate can rank a domain.
+                const { successRate } = mineResult.value;
+                if (successRate !== null) {
+                    domainPerformance.push({ domain, successRate });
                 }
             }
         }
@@ -414,8 +477,17 @@ export class LearningOptimizeTool extends MCPToolBase {
             .slice(0, 3)
             .map(d => d.domain);
         // Calculate overall learning rate from pattern stats
+        // getPatternStats already leaves out patterns learned from assigned rewards.
         const totalPatterns = statsResult.success ? statsResult.value.totalPatterns : 0;
-        const avgSuccessRate = statsResult.success ? statsResult.value.avgSuccessRate : 0;
+        const assignedPatternsExcluded = statsResult.success
+            ? statsResult.value.assignedPatternsExcluded ?? 0
+            : 0;
+        const legacyPatternsExcluded = statsResult.success
+            ? statsResult.value.legacyPatternsExcluded ?? 0
+            : 0;
+        const avgSuccessRate = totalPatterns > 0 && statsResult.success
+            ? statsResult.value.avgSuccessRate
+            : null;
         const overallLearningRate = avgSuccessRate;
         // Generate learning trend from weekly pattern mining
         const learningTrend = [];
@@ -437,28 +509,40 @@ export class LearningOptimizeTool extends MCPToolBase {
                 value: dayPatterns,
             });
         }
-        // Generate milestones based on actual achievements
+        // Milestones from measured figures. When each was first reached is not
+        // recorded, so achievedAt is null rather than an invented date (#1109).
         const recentMilestones = [];
         if (totalPatterns >= 100) {
             recentMilestones.push({
                 name: `Reached ${Math.floor(totalPatterns / 50) * 50} patterns`,
-                achievedAt: new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000).toISOString(),
+                achievedAt: null,
                 domain: 'learning-optimization',
             });
         }
-        if (avgSuccessRate >= 0.8) {
+        if (avgSuccessRate !== null && avgSuccessRate >= 0.8) {
             recentMilestones.push({
                 name: `${Math.round(avgSuccessRate * 100)}% pattern success rate`,
-                achievedAt: new Date(now.getTime() - 5 * 24 * 60 * 60 * 1000).toISOString(),
+                achievedAt: null,
                 domain: topPerformingDomains[0] || 'learning-optimization',
             });
         }
+        const unmeasured = [];
+        if (overallLearningRate === null)
+            unmeasured.push('overallLearningRate');
+        if (topPerformingDomains.length === 0)
+            unmeasured.push('topPerformingDomains');
         return {
             overallLearningRate,
             totalPatterns,
             totalKnowledge: knowledgeResult.success ? knowledgeResult.value.length : 0,
             experiencesLast24h,
-            topPerformingDomains: topPerformingDomains.length > 0 ? topPerformingDomains : ['test-generation'],
+            ...(assignedRewardsExcluded > 0 ? { assignedRewardsExcluded } : {}),
+            ...(assignedPatternsExcluded > 0 ? { assignedPatternsExcluded } : {}),
+            ...(legacyPatternsExcluded > 0 ? { legacyPatternsExcluded } : {}),
+            topPerformingDomains,
+            ...(unmeasured.length > 0
+                ? { evidenceStatus: 'insufficient-evidence', unmeasured }
+                : {}),
             learningTrend,
             recentMilestones,
             sona,

package/dist/mcp/tools/quality-assessment/gate.js

@@ -11,6 +11,8 @@
  */
 import { MCPToolBase } from '../base.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { MAX_PAYLOAD_FILE_BYTES, requirePayloadPath } from '../../../shared/io/payload-path-guard.js';
+import { findProjectRoot } from '../../../kernel/project-root.js';
 import { getLLMRouter } from '../base.js';
 import { runQualityGate, } from '../../../validation/quality-gate-runner.js';
 import { createRouterFrontierJudge, createUnavailableJudge, } from '../../../validation/frontier-judge.js';
@@ -32,6 +34,15 @@ export class QualityGateTool extends MCPToolBase {
             if (typeof params.artifact !== 'string' || params.artifact.length === 0) {
                 return { success: false, error: 'artifact (non-empty string) is required' };
             }
+            // #1126: a caller-named anchor must be a regular file inside the project
+            // (relative paths resolve against the project root, as the runner does).
+            let anchorPath;
+            if (params.anchorPath !== undefined) {
+                const confined = await requirePayloadPath('qe/quality/gate', 'anchorPath', params.anchorPath, { basePath: findProjectRoot(), maxBytes: MAX_PAYLOAD_FILE_BYTES });
+                if (!confined.success)
+                    return { success: false, error: confined.error.message };
+                anchorPath = confined.value;
+            }
             const router = await getLLMRouter(context);
             const judge = router
                 ? createRouterFrontierJudge(router, {
@@ -47,7 +58,7 @@ export class QualityGateTool extends MCPToolBase {
                 artifact: params.artifact,
                 checklistId: params.checklistId,
                 judge,
-                anchorPath: params.anchorPath,
+                anchorPath,
                 verificationManifest: params.verificationManifest,
             });
             return { success: true, data: result };

package/dist/mcp/tools/requirements-validation/quality-criteria.js

@@ -15,6 +15,7 @@ import { MCPToolBase } from '../base.js';
 import { createQualityCriteriaService, HTSM_CATEGORIES, NEVER_OMIT_CATEGORIES, } from '../../../domains/requirements-validation/index.js';
 import { existsSync, readFileSync } from 'fs';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { MAX_PAYLOAD_FILE_BYTES, requirePayloadPath } from '../../../shared/io/payload-path-guard.js';
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -121,8 +122,14 @@ export class QualityCriteriaTool extends MCPToolBase {
             });
             // Load epic content
             let content = epicContent || '';
-            if (epicPath && existsSync(epicPath)) {
-                content = readFileSync(epicPath, 'utf-8');
+            // #1126: the epic is returned verbatim in the agent prompt, so read it
+            // only from a regular file inside the project.
+            if (epicPath) {
+                const confined = await requirePayloadPath('quality-criteria', 'epicPath', epicPath, { allowMissing: true, maxBytes: MAX_PAYLOAD_FILE_BYTES });
+                if (!confined.success)
+                    return { success: false, error: confined.error.message };
+                if (existsSync(confined.value))
+                    content = readFileSync(confined.value, 'utf-8');
             }
             if (!content && !epicPath) {
                 return {

package/dist/memory/crdt/lww-register.js

@@ -50,7 +50,13 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
             return state.value;
         },
         set(value, timestamp) {
-            const ts = timestamp ?? Date.now();
+            let ts = timestamp ?? Date.now();
+            // Without an explicit timestamp the write means "now": a second write by
+            // this node within one clock tick (or after a backwards clock step) must
+            // still supersede its own earlier write, not tie with it and be dropped.
+            if (timestamp === undefined && state.version > 0 && state.nodeId === nodeId && ts <= state.timestamp) {
+                ts = state.timestamp + 1;
+            }
             // Only update if new timestamp wins
             if (state.version === 0 ||
                 compareTimestamps(ts, nodeId, state.timestamp, state.nodeId) > 0) {
@@ -78,6 +84,10 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
             };
         },
         applyState(incoming) {
+            // An unwritten register is the merge identity: its placeholder timestamp
+            // (0) would otherwise beat a real write at a negative timestamp.
+            if (incoming.version === 0)
+                return;
             // Only update if incoming timestamp wins
             if (state.version === 0 ||
                 compareTimestamps(incoming.timestamp, incoming.nodeId, state.timestamp, state.nodeId) > 0) {

package/dist/migration/agent-compat.js

@@ -7,6 +7,7 @@
  * @module migration/agent-compat
  * @see docs/adr/adr-048-agent-naming-conventions.md
  */
+import { getOwn } from '../shared/utils/safe-record.js';
 /**
  * Complete mapping of deprecated V2 agent names to their V3 equivalents with domain info.
  *
@@ -127,7 +128,8 @@ export const v2AgentMapping = Object.fromEntries(Object.entries(v2AgentMappingWi
  * ```
  */
 export function resolveAgentName(name) {
-    return v2AgentMapping[name] ?? name;
+    // #1136: own entries only; `constructor` is not a V2 agent name.
+    return getOwn(v2AgentMapping, name) ?? name;
 }
 /**
  * Checks if an agent name is a deprecated V2 agent.
@@ -146,7 +148,7 @@ export function resolveAgentName(name) {
  * ```
  */
 export function isDeprecatedAgent(name) {
-    return name in v2AgentMapping;
+    return Object.hasOwn(v2AgentMapping, name);
 }
 /**
  * Generates a deprecation warning message for a V2 agent name.
@@ -170,7 +172,7 @@ export function isDeprecatedAgent(name) {
  * ```
  */
 export function getDeprecationWarning(v2Name) {
-    const v3Name = v2AgentMapping[v2Name];
+    const v3Name = getOwn(v2AgentMapping, v2Name);
     if (!v3Name) {
         return '';
     }
@@ -211,7 +213,7 @@ export const v3Agents = [
  */
 export function getAgentDomain(agentName) {
     // Check V2 mapping
-    const v2Entry = v2AgentMappingWithDomain[agentName];
+    const v2Entry = getOwn(v2AgentMappingWithDomain, agentName);
     if (v2Entry) {
         return v2Entry.domain;
     }
@@ -261,7 +263,7 @@ export function generateMigrationReport(usedAgents) {
     const alreadyV3 = [];
     const unknown = [];
     for (const agent of usedAgents) {
-        const v2Entry = v2AgentMappingWithDomain[agent];
+        const v2Entry = getOwn(v2AgentMappingWithDomain, agent);
         if (v2Entry) {
             needsMigration.push({
                 v2Name: agent,

package/dist/migrations/20261018_add_dream_insights_archive.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Agentic QE v3 - Dream insights archive table (#1066, #1116)
+ *
+ * The dream_insights retention sweep copies each stale insight here before it
+ * deletes it (#1066). Until #1116 the sweep created the table lazily on its
+ * first run, outside the versioned schema; it is now created by the v14
+ * migration.
+ *
+ * Additive and idempotent: `CREATE ... IF NOT EXISTS` only, so a database where
+ * an earlier sweep already created the table (with its rows) is left as it
+ * is, and an older AQE that still creates it lazily with the same statement
+ * keeps working on a migrated database.
+ *
+ * Same columns as dream_insights plus archive_id and archived_at. `id` is not
+ * unique here: an insight that comes back (for example from a brain import)
+ * and is swept again gets a second row instead of replacing the first. No
+ * foreign key, so deleting a dream cycle does not cascade into the archive.
+ */
+import type { Database as DatabaseType } from 'better-sqlite3';
+export declare const MIGRATION_VERSION = "20261018_add_dream_insights_archive";
+export declare const DREAM_INSIGHTS_ARCHIVE_TABLE = "dream_insights_archive";
+/** The table, exactly as the 3.15.9 sweep created it lazily. */
+export declare const DREAM_INSIGHTS_ARCHIVE_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS dream_insights_archive (\n    archive_id INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL,\n    cycle_id TEXT,\n    insight_type TEXT,\n    source_concepts TEXT,\n    description TEXT,\n    novelty_score REAL,\n    confidence_score REAL,\n    actionable INTEGER,\n    applied INTEGER,\n    suggested_action TEXT,\n    pattern_id TEXT,\n    created_at TEXT,\n    archived_at TEXT NOT NULL DEFAULT (datetime('now'))\n  )\n";
+export declare const DREAM_INSIGHTS_ARCHIVE_SCHEMA = "\n  \n  CREATE TABLE IF NOT EXISTS dream_insights_archive (\n    archive_id INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL,\n    cycle_id TEXT,\n    insight_type TEXT,\n    source_concepts TEXT,\n    description TEXT,\n    novelty_score REAL,\n    confidence_score REAL,\n    actionable INTEGER,\n    applied INTEGER,\n    suggested_action TEXT,\n    pattern_id TEXT,\n    created_at TEXT,\n    archived_at TEXT NOT NULL DEFAULT (datetime('now'))\n  )\n;\n  -- The sweep's read-back looks copies up by insight id.\n  CREATE INDEX IF NOT EXISTS idx_dream_insights_archive_id ON dream_insights_archive(id);\n";
+export declare function applyMigration(db: DatabaseType): void;
+export declare function isMigrationApplied(db: DatabaseType): boolean;
+//# sourceMappingURL=20261018_add_dream_insights_archive.d.ts.map

package/dist/migrations/20261018_add_dream_insights_archive.js

@@ -0,0 +1,57 @@
+/**
+ * Agentic QE v3 - Dream insights archive table (#1066, #1116)
+ *
+ * The dream_insights retention sweep copies each stale insight here before it
+ * deletes it (#1066). Until #1116 the sweep created the table lazily on its
+ * first run, outside the versioned schema; it is now created by the v14
+ * migration.
+ *
+ * Additive and idempotent: `CREATE ... IF NOT EXISTS` only, so a database where
+ * an earlier sweep already created the table (with its rows) is left as it
+ * is, and an older AQE that still creates it lazily with the same statement
+ * keeps working on a migrated database.
+ *
+ * Same columns as dream_insights plus archive_id and archived_at. `id` is not
+ * unique here: an insight that comes back (for example from a brain import)
+ * and is swept again gets a second row instead of replacing the first. No
+ * foreign key, so deleting a dream cycle does not cascade into the archive.
+ */
+export const MIGRATION_VERSION = '20261018_add_dream_insights_archive';
+export const DREAM_INSIGHTS_ARCHIVE_TABLE = 'dream_insights_archive';
+/** The table, exactly as the 3.15.9 sweep created it lazily. */
+export const DREAM_INSIGHTS_ARCHIVE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS ${DREAM_INSIGHTS_ARCHIVE_TABLE} (
+    archive_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    id TEXT NOT NULL,
+    cycle_id TEXT,
+    insight_type TEXT,
+    source_concepts TEXT,
+    description TEXT,
+    novelty_score REAL,
+    confidence_score REAL,
+    actionable INTEGER,
+    applied INTEGER,
+    suggested_action TEXT,
+    pattern_id TEXT,
+    created_at TEXT,
+    archived_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )
+`;
+export const DREAM_INSIGHTS_ARCHIVE_SCHEMA = `
+  ${DREAM_INSIGHTS_ARCHIVE_TABLE_SQL};
+  -- The sweep's read-back looks copies up by insight id.
+  CREATE INDEX IF NOT EXISTS idx_dream_insights_archive_id ON ${DREAM_INSIGHTS_ARCHIVE_TABLE}(id);
+`;
+export function applyMigration(db) {
+    db.exec(DREAM_INSIGHTS_ARCHIVE_SCHEMA);
+}
+export function isMigrationApplied(db) {
+    try {
+        const result = db.prepare(`SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name = ?`).get(DREAM_INSIGHTS_ARCHIVE_TABLE);
+        return result.count === 1;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=20261018_add_dream_insights_archive.js.map

package/dist/routing/calibration/ema-calibrator.js

@@ -118,7 +118,9 @@ export class EMACalibrator {
      * Serialize all records for persistence.
      */
     serialize() {
-        const result = {};
+        // Null prototype: an agentId of `__proto__` must stay an own key (a plain
+        // object would turn the assignment into a prototype change and drop it).
+        const result = Object.create(null);
         for (const [key, record] of this.records) {
             result[key] = { ...record };
         }

package/dist/shared/base-domain-plugin.d.ts

@@ -180,6 +180,10 @@ export declare abstract class BaseDomainPlugin implements DomainPlugin {
      * Based on registered task handlers
      */
     canHandleTask(taskType: string): boolean;
+    /**
+     * Task types this domain executes, from its registered task handlers (#1075)
+     */
+    getSupportedTaskTypes(): string[];
     /**
      * Execute a task assigned by Queen Coordinator
      * Routes to the appropriate handler based on task type