agentic-qe 3.15.7 → 3.15.9

package/dist/domains/code-intelligence/services/knowledge-graph.js

@@ -7,6 +7,8 @@ import { ok, err } from '../../../shared/types/index.js';
 import { TypeScriptParser } from '../../../shared/parsers/index.js';
 import { FileReader } from '../../../shared/io/index.js';
 import { NomicEmbedder } from '../../../shared/embeddings/index.js';
+import { findProjectRoot } from '../../../kernel/project-root.js';
+import { confineIndexPaths } from '../index-path-guard.js';
 import { toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { existsSync, statSync } from 'fs';
@@ -51,6 +53,7 @@ export class KnowledgeGraphService {
     allEdgesCache;
     tsParser;
     fileReader;
+    projectRoot;
     embedder;
     /** ADR-051: Optional LLM router for AI-enhanced extraction */
     llmRouter;
@@ -73,7 +76,13 @@ export class KnowledgeGraphService {
             this.llmRouter = undefined;
         }
         this.tsParser = new TypeScriptParser();
-        this.fileReader = new FileReader(this.config.basePath ? { basePath: this.config.basePath } : undefined);
+        // #1096: confine reads to the project root by realpath, so a symlink
+        // inside the project cannot pull an outside file into the graph.
+        this.projectRoot = this.config.projectRoot ?? this.config.basePath ?? findProjectRoot();
+        this.fileReader = new FileReader({
+            ...(this.config.basePath ? { basePath: this.config.basePath } : {}),
+            projectRoot: this.projectRoot,
+        });
         this.embedder = new NomicEmbedder({
             enableFallback: true,
         });
@@ -110,21 +119,35 @@ export class KnowledgeGraphService {
         const unsupportedByExt = new Map();
         try {
             const { paths, incremental = false, includeTests = true, languages } = request;
+            // #1096: index only regular files whose realpath is inside the project
+            // root; everything else is reported in `skipped`, never counted.
+            const { accepted, skipped } = await confineIndexPaths(paths, this.projectRoot, this.config.basePath ?? process.cwd());
+            let filesIndexed = 0;
             // Clear existing graph if not incremental
             if (!incremental) {
                 await this.clear();
             }
-            for (const path of paths) {
+            else {
+                // #511: a file deleted since the last index must not leave its old
+                // nodes/edges behind, even though it is no longer indexed.
+                for (const entry of skipped) {
+                    if (entry.reason === 'not-found')
+                        await this.removeFileFromGraph(entry.path);
+                }
+            }
+            for (const path of accepted) {
                 try {
                     // Filter by language if specified
                     if (languages && languages.length > 0) {
                         const ext = this.getFileExtension(path);
                         if (!this.matchesLanguage(ext, languages)) {
+                            skipped.push({ path, reason: 'excluded-by-language' });
                             continue;
                         }
                     }
                     // Skip test files if not included
                     if (!includeTests && this.isTestFile(path)) {
+                        skipped.push({ path, reason: 'excluded-test-file' });
                         continue;
                     }
                     const ext = this.getFileExtension(path);
@@ -135,6 +158,7 @@ export class KnowledgeGraphService {
                     const result = await this.indexFile(path, incremental);
                     nodesCreated += result.nodes;
                     edgesCreated += result.edges;
+                    filesIndexed++;
                 }
                 catch (fileError) {
                     errors.push({
@@ -159,19 +183,20 @@ export class KnowledgeGraphService {
             }
             // Store indexing metadata
             await this.storeIndexMetadata({
-                filesIndexed: paths.length - errors.length,
+                filesIndexed,
                 nodesCreated,
                 edgesCreated,
                 duration,
                 indexedAt: new Date().toISOString(),
             });
             return ok({
-                filesIndexed: paths.length - errors.length,
+                filesIndexed,
                 nodesCreated,
                 edgesCreated,
                 duration,
                 errors,
                 warnings,
+                skipped,
             });
         }
         catch (error) {
@@ -521,7 +546,19 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
         // STALE pre-edit text. Eviction guarantees fresh reads; the two reads within
         // this method (entities + imports) still share one cache fill, so they stay
         // mutually consistent.
-        this.fileReader.invalidateCache(filePath);
+        try {
+            this.fileReader.invalidateCache(filePath);
+        }
+        catch {
+            // #1096: a path the reader's legacy validator rejects (e.g. a project
+            // root outside cwd) is never cached; the read below decides.
+        }
+        // #1096: a file that cannot be read (removed since it was confined, or
+        // blocked by the reader) is an error, not an indexed file node.
+        const readable = await this.fileReader.readFile(filePath);
+        if (!readable.success) {
+            throw readable.error;
+        }
         // #511: on an incremental re-index, drop this file's prior nodes/edges
         // first so renamed/removed entities and stale outgoing imports don't
         // linger as phantom dependencies. (A full index already cleared everything.)

package/dist/domains/contract-testing/coordinator.js

@@ -11,6 +11,7 @@ import { toError, toErrorMessage } from '../../shared/error-utils.js';
 import { Version } from '../../shared/value-objects/index.js';
 import { createHttpClient } from '../../shared/http/index.js';
 import { FileReader } from '../../shared/io/index.js';
+import { findProjectRoot } from '../../kernel/project-root.js';
 import { createEvent } from '../../shared/events/domain-events.js';
 import { ContractValidatorService } from './services/contract-validator.js';
 import { ApiCompatibilityService } from './services/api-compatibility.js';
@@ -80,7 +81,8 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
         this.contractValidator = new ContractValidatorService({ memory, llmRouter });
         this.apiCompatibility = new ApiCompatibilityService(memory);
         this.httpClient = createHttpClient();
-        this.fileReader = new FileReader();
+        // #1096: a symlink inside the project must not expose an outside file.
+        this.fileReader = new FileReader({ projectRoot: findProjectRoot() });
         // Note: schemaValidator initialized when needed for schema operations
     }
     // ==========================================================================

package/dist/domains/coverage-analysis/collected-metrics.js

@@ -7,6 +7,7 @@
  * null — never as 0% (a fake low figure) nor as istanbul's 0/0 = 100%.
  */
 import * as path from 'path';
+import { findProjectRoot } from '../../kernel/project-root.js';
 /**
  * The ONE key form for per-file coverage records (#1027 N7): the absolute
  * path. Reports write absolute (istanbul) or project-relative (lcov
@@ -14,7 +15,7 @@ import * as path from 'path';
  * (or the cwd when none is known), so one file never has two records.
  */
 export function fileCoverageKey(filePath, projectRoot) {
-    return path.isAbsolute(filePath) ? path.normalize(filePath) : path.resolve(projectRoot ?? process.cwd(), filePath);
+    return path.isAbsolute(filePath) ? path.normalize(filePath) : path.resolve(projectRoot ?? findProjectRoot(), filePath);
 }
 /** Read the canonical key first, then a measured legacy relative key if present. */
 export function fileCoverageLookupKeys(filePath, projectRoot) {

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

@@ -10,6 +10,7 @@ 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';
@@ -79,7 +80,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 +89,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;
         }

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

@@ -0,0 +1,55 @@
+/**
+ * Agentic QE v3 - Active learned-pattern reads (#1055)
+ *
+ * Active learned patterns live at `learning:pattern:<id>`. The same prefix
+ * also holds records that are NOT active patterns:
+ *
+ * - `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)
+ *
+ * Every reader of active patterns must go through this module so that
+ * provenance and archives are excluded before `get()`, and so that those rows
+ * cannot use up the search cap and push active patterns out. Records stay
+ * untouched; this is read-side classification only.
+ */
+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[];
+/**
+ * True when the key is in the active pattern key family
+ * (`learning:pattern:<id>`), false for provenance, archives and any other
+ * non-active sub-key.
+ */
+export declare function isActivePatternKey(key: string): boolean;
+/**
+ * Shape guard for a record read from an active key: it must be an object
+ * whose own id maps back to that key, and it must carry a `context` object.
+ */
+export declare function isActivePatternRecord(key: string, value: unknown): value is LearnedPattern;
+export interface ReadActivePatternsOptions {
+    /** Namespace passed to `search()` and `get()`. Omit for the backend default. */
+    retrieve?: RetrieveOptions;
+    /** First key-scan request size (tests). The scan always reads every key. */
+    scanPageSize?: number;
+}
+/**
+ * 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 declare function readActivePatterns(memory: MemoryBackend, options?: ReadActivePatternsOptions): Promise<LearnedPattern[]>;
+//# sourceMappingURL=active-patterns.d.ts.map

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

@@ -0,0 +1,80 @@
+/**
+ * Agentic QE v3 - Active learned-pattern reads (#1055)
+ *
+ * Active learned patterns live at `learning:pattern:<id>`. The same prefix
+ * also holds records that are NOT active patterns:
+ *
+ * - `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)
+ *
+ * Every reader of active patterns must go through this module so that
+ * provenance and archives are excluded before `get()`, and so that those rows
+ * cannot use up the search cap and push active patterns out. Records stay
+ * 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'];
+/**
+ * True when the key is in the active pattern key family
+ * (`learning:pattern:<id>`), false for provenance, archives and any other
+ * non-active sub-key.
+ */
+export function isActivePatternKey(key) {
+    if (!key.startsWith(LEARNING_PATTERN_KEY_PREFIX))
+        return false;
+    const rest = key.slice(LEARNING_PATTERN_KEY_PREFIX.length);
+    if (rest.length === 0)
+        return false;
+    const firstSegment = rest.split(':', 1)[0];
+    return !NON_ACTIVE_PATTERN_SEGMENTS.includes(firstSegment);
+}
+/**
+ * Shape guard for a record read from an active key: it must be an object
+ * whose own id maps back to that key, and it must carry a `context` object.
+ */
+export function isActivePatternRecord(key, value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    if (typeof record.id !== 'string' || key !== `${LEARNING_PATTERN_KEY_PREFIX}${record.id}`) {
+        return false;
+    }
+    return !!record.context && typeof record.context === 'object';
+}
+/**
+ * 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 keys = await searchAllKeys(memory, `${LEARNING_PATTERN_KEY_PREFIX}*`, {
+        retrieve: options.retrieve,
+        pageSize: options.scanPageSize,
+    });
+    const patterns = [];
+    for (const key of keys) {
+        if (!isActivePatternKey(key))
+            continue;
+        const value = await memory.get(key, options.retrieve);
+        if (isActivePatternRecord(key, value)) {
+            patterns.push(rehydrateDates(value, ['createdAt', 'lastUsedAt']));
+        }
+    }
+    return patterns;
+}
+//# sourceMappingURL=active-patterns.js.map

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

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

@@ -3,6 +3,9 @@
  * Orchestrates learning workflows across all QE domains
  */
 import { LoggerFactory } from '../../logging/index.js';
+import { readActivePatterns, LEARNING_NS } from './active-patterns.js';
+import { partitionByRewardSource } from './reward-source.js';
+import { searchAllKeys } from '../../shared/utils/namespaced-search.js';
 import { v4 as uuidv4 } from 'uuid';
 import { toError } from '../../shared/error-utils.js';
 import { rehydrateDates } from '../../shared/utils/kv-date-rehydrate.js';
@@ -18,7 +21,6 @@ import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 // CQ-004: Extracted modules
 import * as LearningHelpers from './coordinator-helpers.js';
 import * as ConsensusHelpers from './coordinator-consensus.js';
-import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 3,
     defaultTimeout: 120000, // 2 minutes
@@ -199,7 +201,10 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             // Get experiences from the last cycle
             const timeRange = TimeRange.lastNDays(1);
             const experiencesResult = await this.getExperiencesForDomain(domain, timeRange);
-            const experiences = experiencesResult.success ? experiencesResult.value : [];
+            // #1109: the reported `before` value and the optimizer use measured outcomes only.
+            const experiences = experiencesResult.success
+                ? partitionByRewardSource(experiencesResult.value).measured
+                : [];
             this.updateWorkflowProgress(workflowId, 20);
             // Mine experiences for patterns
             const insightsResult = await this.learningService.mineExperiences(domain, timeRange);
@@ -220,12 +225,19 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 const optimizationResult = await this.optimizerService.optimizeStrategy(currentStrategy, objective, experiences);
                 if (optimizationResult.success) {
                     strategiesOptimized = 1;
-                    improvements.push({
-                        metric: objective.metric,
-                        before: this.calculateMetricValue(experiences, objective.metric),
-                        after: optimizationResult.value.optimizedStrategy.expectedOutcome[objective.metric] || 0,
-                        percentChange: optimizationResult.value.improvement * 100,
-                    });
+                    // #1099: `after` is the fitted expectation and `percentChange` the
+                    // optimizer's estimate; neither was observed. Report no improvement
+                    // rather than a 0 stand-in when the metric was never predicted.
+                    const after = optimizationResult.value.optimizedStrategy.expectedOutcome[objective.metric];
+                    if (typeof after === 'number') {
+                        improvements.push({
+                            metric: objective.metric,
+                            before: this.calculateMetricValue(experiences, objective.metric),
+                            after,
+                            percentChange: optimizationResult.value.improvement * 100,
+                            estimated: true,
+                        });
+                    }
                 }
             }
             this.updateWorkflowProgress(workflowId, 80);
@@ -318,6 +330,7 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 domainsOptimized,
                 totalStrategies,
                 avgImprovement: totalStrategies > 0 ? totalImprovement / totalStrategies : 0,
+                improvementEstimated: true,
                 byDomain,
             };
             // Publish event
@@ -739,20 +752,21 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             const patterns = [];
             const knowledge = [];
             const strategies = [];
-            // Export patterns
-            for (const _domain of targetDomains) {
-                const patternKeys = await this.memory.search(`learning:pattern:*`, 500);
-                for (const key of patternKeys) {
-                    const pattern = await this.memory.get(key);
-                    if (pattern && targetDomains.includes(pattern.domain)) {
-                        patterns.push(pattern);
-                    }
+            // Export patterns (#1055: active patterns only — creation provenance
+            // and archives share the `learning:pattern:` prefix). One read covers
+            // every target domain; the previous per-domain loop exported each
+            // pattern once per target domain. #1071: every key is read, no cap.
+            const activePatterns = await readActivePatterns(this.memory, { retrieve: LEARNING_NS });
+            for (const pattern of activePatterns) {
+                if (targetDomains.includes(pattern.domain)) {
+                    patterns.push(pattern);
                 }
-                this.updateWorkflowProgress(workflowId, Math.round((patterns.length / 100) * 30));
             }
-            // Export knowledge
+            this.updateWorkflowProgress(workflowId, 30);
+            // Export knowledge. #1071: no result cap; queryKnowledge reads every
+            // shared item before filtering, so other domains cannot crowd these out.
             const knowledgeResult = await this.transferService.queryKnowledge({
-                limit: 1000,
+                limit: Number.POSITIVE_INFINITY,
             });
             if (knowledgeResult.success) {
                 for (const item of knowledgeResult.value) {
@@ -762,10 +776,13 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 }
             }
             this.updateWorkflowProgress(workflowId, 60);
-            // Export strategies
-            const strategyKeys = await this.memory.search(`learning:strategy:optimized:*`, 200);
+            // Export strategies from the namespace their writers use (#1071), every
+            // key, in key order.
+            const strategyKeys = await searchAllKeys(this.memory, 'learning:strategy:optimized:*', {
+                retrieve: LEARNING_NS,
+            });
             for (const key of strategyKeys) {
-                const strategy = await this.memory.get(key);
+                const strategy = await this.memory.get(key, LEARNING_NS);
                 if (strategy && targetDomains.includes(strategy.domain)) {
                     strategies.push(strategy);
                 }
@@ -808,7 +825,7 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             const conflicts = [];
             // Import patterns
             for (const pattern of modelExport.patterns) {
-                const existing = await this.memory.get(`learning:pattern:${pattern.id}`);
+                const existing = await this.memory.get(`learning:pattern:${pattern.id}`, { namespace: 'learning-optimization' });
                 if (existing) {
                     if (existing.confidence < pattern.confidence) {
                         // Overwrite with better pattern
@@ -844,7 +861,8 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             }
             // Import knowledge
             for (const item of modelExport.knowledge) {
-                const existing = await this.memory.get(`learning:knowledge:shared:${item.id}`);
+                // #1071: compare against the record in the namespace written below.
+                const existing = await this.memory.get(`learning:knowledge:shared:${item.id}`, LEARNING_NS);
                 if (existing) {
                     if (item.version > existing.version) {
                         await this.memory.set(`learning:knowledge:shared:${item.id}`, item, {
@@ -879,7 +897,8 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             }
             // Import strategies
             for (const strategy of modelExport.strategies) {
-                const existing = await this.memory.get(`learning:strategy:optimized:${strategy.id}`);
+                // #1071: compare against the record in the namespace written below.
+                const existing = await this.memory.get(`learning:strategy:optimized:${strategy.id}`, LEARNING_NS);
                 if (existing) {
                     if (strategy.confidence > existing.confidence) {
                         await this.memory.set(`learning:strategy:optimized:${strategy.id}`, strategy, { namespace: 'learning-optimization', persist: true });
@@ -925,87 +944,13 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
     // Event Handling
     // ============================================================================
     subscribeToEvents() {
-        // Subscribe to test execution events for learning
-        this.eventBus.subscribe('test-execution.TestRunCompleted', this.handleTestRunCompleted.bind(this));
-        // Subscribe to coverage gap events
-        this.eventBus.subscribe('coverage-analysis.CoverageGapDetected', this.handleCoverageGap.bind(this));
-        // Subscribe to quality assessment events
-        this.eventBus.subscribe('quality-assessment.QualityGateEvaluated', this.handleQualityGate.bind(this));
+        // #1110: TestRunCompleted, CoverageGapDetected and QualityGateEvaluated are
+        // recorded by LearningOptimizationPlugin, which owns this coordinator and
+        // also records the test-run production metric. Subscribing here as well
+        // stored every such event twice.
         // Subscribe to experience capture events (Phase 4 integration)
         this.eventBus.subscribe('learning.ExperienceCaptured', this.handleExperienceCaptured.bind(this));
     }
-    async handleTestRunCompleted(event) {
-        // Record experience from test run
-        const { runId, passed, failed, duration } = event.payload;
-        const successRate = (passed + failed) > 0 ? passed / (passed + failed) : 0;
-        await this.learningService.recordExperience({
-            agentId: {
-                value: 'test-execution',
-                domain: 'test-execution',
-                type: 'tester',
-            },
-            domain: 'test-execution',
-            action: 'test-run',
-            state: {
-                context: { runId },
-                metrics: { passed, failed, duration },
-            },
-            result: {
-                success: successRate > 0.8,
-                outcome: { success_rate: successRate, passed, failed },
-                duration,
-            },
-            reward: successRate,
-        });
-    }
-    async handleCoverageGap(event) {
-        // #1014: only a gap found in MEASURED coverage is acted on / learned from.
-        if (!isMeasuredGapPayload(event.payload))
-            return;
-        // Record as experience for learning
-        const { gapId, file, riskScore } = event.payload;
-        await this.learningService.recordExperience({
-            agentId: {
-                value: 'coverage-analysis',
-                domain: 'coverage-analysis',
-                type: 'analyzer',
-            },
-            domain: 'coverage-analysis',
-            action: 'gap-detection',
-            state: {
-                context: { gapId, file },
-                metrics: { riskScore },
-            },
-            result: {
-                success: true,
-                outcome: { risk_score: riskScore },
-                duration: 0,
-            },
-            reward: 1 - riskScore, // Lower risk = higher reward
-        });
-    }
-    async handleQualityGate(event) {
-        const { gateId, passed } = event.payload;
-        await this.learningService.recordExperience({
-            agentId: {
-                value: 'quality-assessment',
-                domain: 'quality-assessment',
-                type: 'validator',
-            },
-            domain: 'quality-assessment',
-            action: 'gate-evaluation',
-            state: {
-                context: { gateId },
-                metrics: { passed: passed ? 1 : 0 },
-            },
-            result: {
-                success: passed,
-                outcome: { gate_passed: passed ? 1 : 0 },
-                duration: 0,
-            },
-            reward: passed ? 1 : 0,
-        });
-    }
     /**
      * Handle experience captured from ExperienceCaptureService
      * This is the bridge between Phase 4 experience capture and the coordinator
@@ -1229,9 +1174,8 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 retryCount: 3,
                 concurrency: 4,
             },
-            expectedOutcome: {
-                success_rate: 0.8,
-            },
+            // #1099: the default strategy has never run, so no outcome is expected.
+            expectedOutcome: {},
         };
     }
     async storeStrategy(domain, strategy) {

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

@@ -10,5 +10,5 @@ export { LearningCoordinatorService, type LearningCoordinatorConfig as LearningS
 export { TransferSpecialistService, type TransferSpecialistConfig, type TransferResult, } from './services/transfer-specialist.js';
 export { MetricsOptimizerService, type MetricsOptimizerConfig, type MetricsSnapshot, } from './services/metrics-optimizer.js';
 export { ProductionIntelService, type ProductionIntelConfig, type ProductionMetric, type ProductionIncident, type ProductionHealth, } from './services/production-intel.js';
-export type { ILearningOptimizationCoordinator, LearningCycleReport, OptimizationReport, CrossDomainSharingReport, LearningDashboard, ModelExport, ImportReport, ImportConflict, Improvement, DomainOptimizationResult, TrendPoint, Milestone, LearnedPattern, PatternType, PatternContext, PatternTemplate, TemplateVariable, PatternStats, IPatternLearningService, Experience, ExperienceResult, StateSnapshot, ResourceUsage, MinedInsights, ExperienceCluster, ExperienceAnomaly, IExperienceMiningService, Knowledge, KnowledgeType, KnowledgeContent, KnowledgeQuery, IKnowledgeSynthesisService, Strategy, OptimizedStrategy, OptimizationObjective, Constraint, ValidationResult, ABTestConfig, ABTestResult, StrategyEvaluation, IStrategyOptimizerService, IPatternRepository, IExperienceRepository, IKnowledgeRepository, IStrategyRepository, PatternLearnedEvent, KnowledgeSharedEvent, StrategyOptimizedEvent, ExperienceRecordedEvent, LearningMilestoneReachedEvent, } from './interfaces.js';
+export type { ILearningOptimizationCoordinator, LearningCycleReport, OptimizationReport, CrossDomainSharingReport, LearningDashboard, ModelExport, ImportReport, ImportConflict, Improvement, DomainOptimizationResult, TrendPoint, Milestone, LearnedPattern, PatternType, PatternContext, PatternTemplate, TemplateVariable, PatternStats, IPatternLearningService, Experience, ExperienceResult, StateSnapshot, ResourceUsage, MinedInsights, ExperienceCluster, ExperienceAnomaly, IExperienceMiningService, Knowledge, KnowledgeType, KnowledgeContent, KnowledgeQuery, IKnowledgeSynthesisService, Strategy, OptimizedStrategy, OptimizationEvaluation, OptimizationObjective, Constraint, ValidationResult, ABTestConfig, ABTestResult, StrategyEvaluation, IStrategyOptimizerService, IPatternRepository, IExperienceRepository, IKnowledgeRepository, IStrategyRepository, PatternLearnedEvent, KnowledgeSharedEvent, StrategyOptimizedEvent, ExperienceRecordedEvent, LearningMilestoneReachedEvent, } from './interfaces.js';
 //# sourceMappingURL=index.d.ts.map