agentic-qe 3.9.29 → 3.9.31

package/dist/mcp/handlers/domain-handler-configs.js

@@ -8,6 +8,35 @@
  */
 import { generateV2LearningFeedback, analyzeComplexity, generateV2AIInsights, generateV2Tests, detectAntiPatterns, generateTestId, } from './handler-factory';
 import { MetricsCollector } from '../metrics';
+import { DEFAULT_FRAMEWORKS, FRAMEWORK_TO_LANGUAGE, } from '../../shared/types/test-frameworks.js';
+const SUPPORTED_LANGUAGES = Object.keys(DEFAULT_FRAMEWORKS);
+/**
+ * Normalize a language string from MCP input. Returns the canonical
+ * SupportedLanguage or null if we don't have a generator for it.
+ * Issue #474: previously unsupported languages silently produced JS/vitest.
+ */
+function normalizeLanguage(input) {
+    if (!input)
+        return 'typescript';
+    const lower = input.toLowerCase().trim();
+    // Common aliases
+    const aliases = {
+        ts: 'typescript',
+        js: 'javascript',
+        py: 'python',
+        'c#': 'csharp',
+        'c-sharp': 'csharp',
+        'cs': 'csharp',
+        golang: 'go',
+        rs: 'rust',
+        kt: 'kotlin',
+    };
+    if (aliases[lower])
+        return aliases[lower];
+    if (SUPPORTED_LANGUAGES.includes(lower))
+        return lower;
+    return null;
+}
 // ============================================================================
 // Test Generation Configuration
 // ============================================================================
@@ -18,19 +47,49 @@ export const testGenerateConfig = {
     defaultTimeout: 120000,
     buildTaskDescription: (params) => `Generate ${params.testType || 'unit'} tests for ${params.language || 'typescript'} code`,
     includeCodeContext: (params) => params.sourceCode,
-    mapToPayload: (params, routingResult) => ({
-        sourceCode: params.sourceCode,
-        filePath: params.filePath,
-        language: params.language || 'typescript',
-        framework: params.framework || 'vitest',
-        testType: params.testType || 'unit',
-        coverageGoal: params.coverageGoal || 80,
-        aiEnhancement: params.aiEnhancement !== false,
-        detectAntiPatterns: params.detectAntiPatterns || false,
-        routingTier: routingResult?.decision.tier,
-        useAgentBooster: routingResult?.useAgentBooster,
-        compiledContext: routingResult?.compiledContext,
-    }),
+    mapToPayload: (params, routingResult) => {
+        // Issue #474: validate language and pick the matching framework instead of
+        // silently emitting vitest JS for anything we don't recognize.
+        const language = normalizeLanguage(params.language);
+        if (language === null) {
+            throw new Error(`Unsupported language '${params.language}'. Supported languages: ` +
+                `${SUPPORTED_LANGUAGES.join(', ')}. ` +
+                `Open a feature request for additional language support.`);
+        }
+        // Pick framework: user-provided wins; otherwise derive from language.
+        // Reject obvious mismatches (e.g. language=python, framework=vitest).
+        let framework;
+        if (params.framework) {
+            framework = params.framework;
+            const fwLang = FRAMEWORK_TO_LANGUAGE[framework];
+            if (fwLang && fwLang !== language) {
+                // typescript<->javascript is a soft compatibility — JS frameworks
+                // can target both. Treat as same family.
+                const isJsFamily = (l) => l === 'javascript' || l === 'typescript';
+                if (!(isJsFamily(fwLang) && isJsFamily(language))) {
+                    throw new Error(`Framework '${framework}' targets ${fwLang}, but language was '${language}'. ` +
+                        `Either pick a matching framework or omit \`framework\` to use the default ` +
+                        `(${DEFAULT_FRAMEWORKS[language]}).`);
+                }
+            }
+        }
+        else {
+            framework = DEFAULT_FRAMEWORKS[language];
+        }
+        return {
+            sourceCode: params.sourceCode,
+            filePath: params.filePath,
+            language,
+            framework,
+            testType: params.testType || 'unit',
+            coverageGoal: params.coverageGoal || 80,
+            aiEnhancement: params.aiEnhancement !== false,
+            detectAntiPatterns: params.detectAntiPatterns || false,
+            routingTier: routingResult?.decision.tier,
+            useAgentBooster: routingResult?.useAgentBooster,
+            compiledContext: routingResult?.compiledContext,
+        };
+    },
     mapToResult: (taskId, data, duration, savedFiles, params) => {
         const sourceCode = params?.sourceCode || '';
         const language = params?.language || 'typescript';

package/dist/mcp/protocol-server.d.ts

@@ -33,6 +33,12 @@ export interface MCPServerInfo {
     protocolVersion: string;
 }
 export declare class MCPProtocolServer {
+    /**
+     * Issue #473: Decide if a tool result is "successful enough" to cache.
+     * Refuse to cache anything that looks like a failure so we don't serve
+     * errors back to future callers.
+     */
+    private isSuccessfulResult;
     private readonly config;
     private readonly transport;
     private readonly registry;

package/dist/mcp/protocol-server.js

@@ -46,7 +46,40 @@ const _pkg = _require('../../package.json');
 // ============================================================================
 // MCP Protocol Server
 // ============================================================================
+/**
+ * Issue #473: parse the MCP tool name into a (domain, action) pair so the
+ * session cache can compute a deterministic fingerprint that's stable across
+ * naming styles. Handles both flat (`memory_query`) and slash (`qe/embeddings/search`).
+ */
+function parseToolDomainAction(name) {
+    if (name.includes('/')) {
+        const idx = name.lastIndexOf('/');
+        return { domain: name.slice(0, idx) || 'mcp', action: name.slice(idx + 1) };
+    }
+    const us = name.indexOf('_');
+    if (us > 0) {
+        return { domain: name.slice(0, us), action: name.slice(us + 1) };
+    }
+    return { domain: 'mcp', action: name };
+}
 export class MCPProtocolServer {
+    /**
+     * Issue #473: Decide if a tool result is "successful enough" to cache.
+     * Refuse to cache anything that looks like a failure so we don't serve
+     * errors back to future callers.
+     */
+    isSuccessfulResult(result) {
+        if (!result || typeof result !== 'object')
+            return false;
+        const r = result;
+        if (r.isError === true)
+            return false;
+        if (r.success === false)
+            return false;
+        if (typeof r.error === 'string' && r.error.length > 0)
+            return false;
+        return true;
+    }
     config;
     transport;
     registry;
@@ -386,10 +419,66 @@ export class MCPProtocolServer {
         try {
             // IMP-00: Execute pre-tool-call middleware
             const processedCtx = await this.middlewareChain.executePreHooks(ctx);
+            // Issue #473: Session-cache lookup for read-only tools.
+            // Concurrency-safe tools are idempotent in practice — same input yields
+            // the same output, so we can short-circuit repeated calls with an O(1)
+            // fingerprint lookup. Tools without isConcurrencySafe (writes, scans,
+            // executions) always re-run.
+            const cacheable = tool.definition.isConcurrencySafe === true;
+            let cacheFingerprint = null;
+            if (cacheable && process.env.AQE_SESSION_CACHE !== 'off') {
+                try {
+                    const { getSessionCache } = await import('../optimization/session-cache.js');
+                    const cache = getSessionCache();
+                    const { domain, action } = parseToolDomainAction(name);
+                    cacheFingerprint = cache.computeFingerprint(domain, action, processedCtx.params || {});
+                    const hit = cache.get(cacheFingerprint);
+                    if (hit) {
+                        // Cache hit — return the stored result without running the handler.
+                        const cachedText = JSON.stringify(hit.result, null, 2);
+                        this.eventAdapter.adapt({
+                            success: true,
+                            data: hit.result,
+                            metadata: {
+                                executionTime: performance.now() - startTime,
+                                timestamp: new Date().toISOString(),
+                                requestId: stepId,
+                                toolName: name,
+                            },
+                        });
+                        success = true;
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: loopSteeringPrefix ? loopSteeringPrefix + cachedText : cachedText,
+                                }],
+                        };
+                    }
+                }
+                catch {
+                    // Cache failure must never break tool execution.
+                    cacheFingerprint = null;
+                }
+            }
             const result = await tool.handler(processedCtx.params);
             success = true;
             // IMP-00: Execute post-tool-result middleware
             const processedResult = await this.middlewareChain.executePostHooks(processedCtx, result);
+            // Issue #473: Store successful results for future cache hits.
+            // Only cache successful results — error objects shouldn't be served back.
+            if (cacheable && cacheFingerprint && this.isSuccessfulResult(processedResult)) {
+                try {
+                    const { getSessionCache } = await import('../optimization/session-cache.js');
+                    const cache = getSessionCache();
+                    const { domain, action } = parseToolDomainAction(name);
+                    // Estimate tokens conservatively by length-of-JSON / 4 chars-per-token.
+                    const tokenEstimate = Math.max(50, Math.floor(JSON.stringify(processedResult).length / 4));
+                    cache.set(cacheFingerprint, domain, action, processedResult, tokenEstimate);
+                }
+                catch {
+                    // never block on cache write
+                }
+            }
             // Emit AG-UI result event for tool completion
             this.eventAdapter.adapt({
                 success: true,
@@ -688,9 +777,9 @@ export class MCPProtocolServer {
                 parameters: [
                     { name: 'sourceCode', type: 'string', description: 'Source code to generate tests for' },
                     { name: 'filePath', type: 'string', description: 'Original source file path (used as the import target in generated tests; if omitted, generated tests reference the temp source)' },
-                    { name: 'language', type: 'string', description: 'Programming language' },
+                    { name: 'language', type: 'string', description: 'Programming language (one of: typescript, javascript, python, java, csharp, go, rust, swift, kotlin, dart). Issue #474.', enum: ['typescript', 'javascript', 'python', 'java', 'csharp', 'go', 'rust', 'swift', 'kotlin', 'dart'] },
                     { name: 'testType', type: 'string', description: 'Type of tests', enum: ['unit', 'integration', 'e2e'] },
-                    { name: 'framework', type: 'string', description: 'Test framework to use', enum: ['jest', 'vitest', 'mocha', 'pytest', 'node-test'], default: 'vitest' },
+                    { name: 'framework', type: 'string', description: 'Test framework to use. If omitted, derived from `language`.', enum: ['jest', 'vitest', 'mocha', 'pytest', 'node-test', 'junit5', 'testng', 'xunit', 'nunit', 'go-test', 'rust-test', 'swift-testing', 'xctest', 'kotlin-junit', 'flutter-test', 'jest-rn'] },
                     { name: 'coverageGoal', type: 'number', description: 'Target coverage percentage (0-100)', default: 80 },
                     { name: 'aiEnhancement', type: 'boolean', description: 'Enable AI-powered enhancement', default: true },
                     { name: 'detectAntiPatterns', type: 'boolean', description: 'Detect and report anti-patterns', default: false },

package/dist/mcp/tools/coherence/collapse.d.ts

@@ -105,6 +105,10 @@ export declare class CoherenceCollapseTool extends MCPToolBase<CoherenceCollapse
     execute(params: CoherenceCollapseParams, context: MCPToolContext): Promise<ToolResult<CoherenceCollapseResult>>;
     /**
      * Categorize risk level
+     *
+     * Non-finite inputs (NaN, null, undefined coerced) fall back to 'low'
+     * rather than tripping the default-arm and returning 'critical' for
+     * degenerate input (issue #470).
      */
     private categorizeRisk;
     /**

package/dist/mcp/tools/coherence/collapse.js

@@ -112,27 +112,30 @@ export class CoherenceCollapseTool extends MCPToolBase {
         try {
             // Get service
             const service = await this.getService();
-            // Convert to SwarmState format expected by the service
+            // Convert to SwarmState format expected by the service.
+            // Default any missing numeric fields to safe values so degenerate inputs
+            // can't propagate NaN into risk scoring (issue #470).
             const state = {
                 agents: swarmState.agents.map((a) => ({
                     agentId: a.agentId,
                     agentType: (a.agentType || 'worker'),
-                    health: a.health,
+                    health: Number.isFinite(a.health) ? a.health : 1.0,
                     beliefs: [],
                     lastActivity: new Date(),
                     errorCount: a.errorCount ?? 0,
-                    successRate: a.successRate ?? 1.0,
+                    successRate: Number.isFinite(a.successRate) ? a.successRate : 1.0,
                 })),
-                activeTasks: swarmState.activeTasks,
-                pendingTasks: swarmState.pendingTasks,
-                errorRate: swarmState.errorRate,
-                utilization: swarmState.utilization,
+                activeTasks: Number.isFinite(swarmState.activeTasks) ? swarmState.activeTasks : 0,
+                pendingTasks: Number.isFinite(swarmState.pendingTasks) ? swarmState.pendingTasks : 0,
+                errorRate: Number.isFinite(swarmState.errorRate) ? swarmState.errorRate : 0,
+                utilization: Number.isFinite(swarmState.utilization) ? swarmState.utilization : 0,
                 timestamp: new Date(),
             };
             // Predict collapse using spectral analysis
             const result = await service.predictCollapse(state);
             // Determine risk level
-            const riskLevel = this.categorizeRisk(result.risk);
+            const safeRisk = Number.isFinite(result.risk) ? result.risk : 0;
+            const riskLevel = this.categorizeRisk(safeRisk);
             // Generate enhanced recommendations
             const recommendations = [
                 ...result.recommendations,
@@ -140,11 +143,16 @@ export class CoherenceCollapseTool extends MCPToolBase {
             ];
             const executionTimeMs = Date.now() - startTime;
             this.markAsRealData();
+            // Derive isAtRisk from riskLevel rather than raw risk, so the two
+            // can never disagree (issue #470). When risk is non-finite we treat
+            // it as "low" — categorizeRisk falls back to 0 above.
+            const isAtRisk = riskLevel === 'high' || riskLevel === 'critical' ||
+                (riskLevel === 'medium' && safeRisk >= riskThreshold);
             return {
                 success: true,
                 data: {
-                    risk: result.risk,
-                    isAtRisk: result.risk >= riskThreshold,
+                    risk: safeRisk,
+                    isAtRisk,
                     riskLevel,
                     fiedlerValue: result.fiedlerValue,
                     collapseImminent: result.collapseImminent,
@@ -183,8 +191,14 @@ export class CoherenceCollapseTool extends MCPToolBase {
     }
     /**
      * Categorize risk level
+     *
+     * Non-finite inputs (NaN, null, undefined coerced) fall back to 'low'
+     * rather than tripping the default-arm and returning 'critical' for
+     * degenerate input (issue #470).
      */
     categorizeRisk(risk) {
+        if (!Number.isFinite(risk))
+            return 'low';
         if (risk < 0.25)
             return 'low';
         if (risk < 0.5)
@@ -228,26 +242,35 @@ export class CoherenceCollapseTool extends MCPToolBase {
         let risk = 0;
         const recommendations = [];
         const weakVertices = [];
+        // Default missing numeric fields so degenerate input (e.g. agents without
+        // a `health` value) doesn't propagate NaN through the score (issue #470).
+        const errorRate = Number.isFinite(state.errorRate) ? state.errorRate : 0;
+        const utilization = Number.isFinite(state.utilization) ? state.utilization : 0;
+        const pendingTasks = Number.isFinite(state.pendingTasks) ? state.pendingTasks : 0;
+        const activeTasks = Number.isFinite(state.activeTasks) ? state.activeTasks : 0;
         // Factor: Average agent health
-        const avgHealth = state.agents.reduce((sum, a) => sum + a.health, 0) / state.agents.length;
+        const healths = state.agents.map(a => Number.isFinite(a.health) ? a.health : 1.0);
+        const avgHealth = healths.length > 0
+            ? healths.reduce((sum, h) => sum + h, 0) / healths.length
+            : 1.0;
         risk += (1 - avgHealth) * 0.3;
         // Factor: Error rate
-        risk += Math.min(0.25, state.errorRate * 2.5);
+        risk += Math.min(0.25, errorRate * 2.5);
         // Factor: Utilization
-        if (state.utilization > 0.7) {
-            risk += (state.utilization - 0.7) * 0.5;
+        if (utilization > 0.7) {
+            risk += (utilization - 0.7) * 0.5;
         }
         // Factor: Task pressure
-        const taskPressure = state.pendingTasks / Math.max(1, state.activeTasks);
+        const taskPressure = pendingTasks / Math.max(1, activeTasks);
         if (taskPressure > 1) {
             risk += Math.min(0.2, (taskPressure - 1) * 0.1);
         }
-        // Identify weak agents
-        for (const agent of state.agents) {
-            if (agent.health < 0.5 || (agent.errorCount ?? 0) > 5) {
+        // Identify weak agents (using sanitized health values)
+        state.agents.forEach((agent, i) => {
+            if (healths[i] < 0.5 || (agent.errorCount ?? 0) > 5) {
                 weakVertices.push(agent.agentId);
             }
-        }
+        });
         risk = Math.min(1, risk);
         // Generate recommendations
         if (risk >= riskThreshold) {
@@ -260,10 +283,14 @@ export class CoherenceCollapseTool extends MCPToolBase {
         if (risk < 0.25) {
             recommendations.push('Swarm appears stable - continue normal operations');
         }
+        const riskLevel = this.categorizeRisk(risk);
+        // Keep isAtRisk consistent with riskLevel (issue #470)
+        const isAtRisk = riskLevel === 'high' || riskLevel === 'critical' ||
+            (riskLevel === 'medium' && risk >= riskThreshold);
         return {
             risk,
-            isAtRisk: risk >= riskThreshold,
-            riskLevel: this.categorizeRisk(risk),
+            isAtRisk,
+            riskLevel,
             fiedlerValue: 0, // Can't compute without spectral analysis
             collapseImminent: risk >= 0.75,
             weakVertices,

package/dist/mcp/tools/embeddings/embedding.js

@@ -211,10 +211,13 @@ export class EmbeddingSearchTool extends MCPToolBase {
         const startTime = performance.now();
         try {
             const adapter = await getEmbeddingAdapter();
+            // Issue #469: previously used `||` which turned an explicit
+            // `threshold: 0` into the default 0.5. Use `??` so callers can
+            // legitimately disable the filter with 0.
             const results = await adapter.searchByText(params.query, {
                 metric: SimilarityMetric.COSINE,
-                topK: params.topK || 10,
-                threshold: params.threshold || 0.5,
+                topK: params.topK ?? 10,
+                threshold: params.threshold ?? 0.5,
                 namespace: params.namespace,
             });
             const latencyMs = performance.now() - startTime;

package/dist/routing/routing-feedback.js

@@ -12,6 +12,7 @@ import { safeJsonParse } from '../shared/safe-json.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { EMACalibrator } from './calibration/index.js';
 import { AutoEscalationTracker } from './escalation/index.js';
+import { ensureRoutingOutcomesAdr095Columns } from './routing-outcomes-migration.js';
 import { EconomicRoutingModel, } from './economic-routing.js';
 import { getGlobalCostTracker } from '../shared/llm/cost-tracker.js';
 // ============================================================================
@@ -144,9 +145,9 @@ export class RoutingFeedbackCollector {
             return;
         try {
             const database = this.db.getDatabase();
-            // Ensure schema columns exist for databases created before ADR-092.
-            // Runs once per process via the flag; new databases have columns from
-            // unified-memory-schemas.ts CREATE TABLE.
+            // Ensure schema columns exist for databases created before ADR-092
+            // and ADR-095. Runs once per process via the flag; new databases have
+            // columns from unified-memory-schemas.ts CREATE TABLE.
             if (!RoutingFeedbackCollector.schemaMigrated) {
                 for (const col of [
                     'ALTER TABLE routing_outcomes ADD COLUMN model_tier TEXT',
@@ -157,6 +158,9 @@ export class RoutingFeedbackCollector {
                     }
                     catch { /* column already exists */ }
                 }
+                // ADR-095: routing exploration columns via shared helper so all
+                // writer paths agree on the column set.
+                ensureRoutingOutcomesAdr095Columns(database);
                 RoutingFeedbackCollector.schemaMigrated = true;
             }
             const modelTier = this.inferTier(outcome.usedAgent);

package/dist/routing/routing-outcomes-migration.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Routing Outcomes Schema Migration (ADR-095)
+ *
+ * Idempotently adds the ADR-095 columns (`exploration`, `criticality`,
+ * `q_weight`) to `routing_outcomes` for databases created before this
+ * release. New databases get the columns from `unified-memory-schemas.ts`
+ * at CREATE TABLE time; this helper handles upgrades.
+ *
+ * Pattern matches the existing ADR-092 migration in
+ * `src/routing/routing-feedback.ts:199-207` — try the ALTER, swallow the
+ * "duplicate column name" error if the column already exists.
+ *
+ * Callers run this before INSERTing rows that reference the new columns.
+ * A process-local flag prevents repeated migration attempts.
+ */
+import type { Database as DatabaseType } from 'better-sqlite3';
+/**
+ * Add the ADR-095 columns to routing_outcomes if they don't already exist.
+ * Safe to call multiple times — second and later calls are no-ops.
+ *
+ * Failure to migrate (e.g. table doesn't exist yet, permission error) is
+ * NOT fatal — callers that depend on the new columns should fall back to
+ * not writing them. The schema is forward-compatible: inserts that omit
+ * the new columns get the defaults.
+ */
+export declare function ensureRoutingOutcomesAdr095Columns(db: DatabaseType): void;
+/**
+ * Reset the process-local migration flag. Test-only.
+ */
+export declare function resetRoutingOutcomesMigrationState(): void;
+//# sourceMappingURL=routing-outcomes-migration.d.ts.map

package/dist/routing/routing-outcomes-migration.js

@@ -0,0 +1,60 @@
+/**
+ * Routing Outcomes Schema Migration (ADR-095)
+ *
+ * Idempotently adds the ADR-095 columns (`exploration`, `criticality`,
+ * `q_weight`) to `routing_outcomes` for databases created before this
+ * release. New databases get the columns from `unified-memory-schemas.ts`
+ * at CREATE TABLE time; this helper handles upgrades.
+ *
+ * Pattern matches the existing ADR-092 migration in
+ * `src/routing/routing-feedback.ts:199-207` — try the ALTER, swallow the
+ * "duplicate column name" error if the column already exists.
+ *
+ * Callers run this before INSERTing rows that reference the new columns.
+ * A process-local flag prevents repeated migration attempts.
+ */
+let migrated = false;
+/**
+ * Add the ADR-095 columns to routing_outcomes if they don't already exist.
+ * Safe to call multiple times — second and later calls are no-ops.
+ *
+ * Failure to migrate (e.g. table doesn't exist yet, permission error) is
+ * NOT fatal — callers that depend on the new columns should fall back to
+ * not writing them. The schema is forward-compatible: inserts that omit
+ * the new columns get the defaults.
+ */
+export function ensureRoutingOutcomesAdr095Columns(db) {
+    if (migrated)
+        return;
+    for (const stmt of [
+        'ALTER TABLE routing_outcomes ADD COLUMN exploration INTEGER NOT NULL DEFAULT 0',
+        'ALTER TABLE routing_outcomes ADD COLUMN criticality REAL',
+        'ALTER TABLE routing_outcomes ADD COLUMN q_weight REAL',
+    ]) {
+        try {
+            db.prepare(stmt).run();
+        }
+        catch {
+            // Column already exists, or table doesn't exist yet. Both are
+            // acceptable — ALTER is additive, and a missing table means the
+            // unified schema hasn't been applied yet (caller's INSERT will fail
+            // separately with a clearer error).
+        }
+    }
+    // Index on exploration for the bucket-comparison queries used by
+    // `aqe learning loop-health`. Idempotent via IF NOT EXISTS.
+    try {
+        db.prepare('CREATE INDEX IF NOT EXISTS idx_routing_outcomes_exploration ON routing_outcomes(exploration)').run();
+    }
+    catch {
+        // Table missing; index attempt is best-effort.
+    }
+    migrated = true;
+}
+/**
+ * Reset the process-local migration flag. Test-only.
+ */
+export function resetRoutingOutcomesMigrationState() {
+    migrated = false;
+}
+//# sourceMappingURL=routing-outcomes-migration.js.map

package/dist/test-scheduling/pipeline.d.ts

@@ -29,7 +29,7 @@ import { type VitestConfig } from './executors/vitest-executor';
 import { GitAwareTestSelector } from './git-aware/test-selector';
 import { FlakyTestTracker, type FlakyTrackerConfig } from './flaky-tracking/flaky-tracker';
 import { type GitHubActionsConfig } from './cicd/github-actions';
-import type { TestPhase, PhaseResult, CIEnvironment } from './interfaces';
+import { type TestPhase, type PhaseResult, type CIEnvironment } from './interfaces';
 type MemoryBackend = import('../kernel/interfaces').MemoryBackend;
 export interface PipelineConfig {
     /** Working directory for git and test execution */

package/dist/test-scheduling/pipeline.js

@@ -29,6 +29,7 @@ import { VitestPhaseExecutor } from './executors/vitest-executor';
 import { createTestSelector } from './git-aware/test-selector';
 import { createFlakyTracker, loadFlakyTracker, saveFlakyTracker, } from './flaky-tracking/flaky-tracker';
 import { createGitHubActionsReporter, detectCIEnvironment, } from './cicd/github-actions';
+import { DEFAULT_TEST_PHASES } from './interfaces';
 // ============================================================================
 // Test Scheduling Pipeline
 // ============================================================================
@@ -81,10 +82,15 @@ export class TestSchedulingPipeline {
             baseRef: config.baseRef,
             impactAnalyzer, // INTEGRATION: Pass analyzer to selector
         });
-        // 5. Create PhaseScheduler with executor
+        // 5. Create PhaseScheduler with executor.
+        // Fall back to DEFAULT_TEST_PHASES when callers (e.g. the MCP wrapper)
+        // don't provide an explicit phase list — otherwise the scheduler
+        // would crash with "this.config.phases is not iterable" (issue #472).
         const scheduler = createPhaseScheduler(executor, {
             ...config.scheduler,
-            phases: config.phases,
+            phases: config.phases && config.phases.length > 0
+                ? config.phases
+                : DEFAULT_TEST_PHASES,
         });
         // 6. Create GitHubActionsReporter
         const reporter = createGitHubActionsReporter(config.reporter);

package/dist/workers/workers/learning-consolidation.d.ts

@@ -30,6 +30,34 @@ export declare class LearningConsolidationWorker extends BaseWorker {
      * Task Execution -> Experience Capture -> Pattern Extraction -> Pattern Promotion -> Pattern Utilization -> Improved Routing
      */
     private runContinuousLearningLoop;
+    /**
+     * #486 Gap A: mine experiences into `learning:pattern:*` kv per domain.
+     *
+     * The producer side of the learning-optimization domain pipeline:
+     *
+     *   captured_experiences (SQLite)
+     *     → bridge drain → learning.ExperienceCaptured event
+     *       → handleExperienceCaptured → recordExperience
+     *         → learning:experience:* kv (✓ working post-v3.9.29)
+     *           → mineExperiences (THIS STEP)
+     *             → extractPatternsFromExperiences → learnPattern → storePattern
+     *               → learning:pattern:* kv
+     *
+     * Without this step the chain ends at the experience kv, so `getPatternStats`
+     * reports zero patterns and the `LearningConsolidationWorker.collectPatterns`
+     * step a few lines above throws "No learning patterns to consolidate yet".
+     *
+     * Per-domain cursor avoids re-processing the same experiences (which would
+     * duplicate-write since `learnPattern` uses uuidv4 for pattern IDs). Cursor
+     * is stored in WorkerMemory under `learning:consolidation-cursor:{domain}`
+     * as an ISO timestamp. On first run, the cursor defaults to `now - 1 day`
+     * to match the lookback used elsewhere by `runLearningCycle`.
+     *
+     * Failures are isolated per domain — one bad domain doesn't block others.
+     * On failure or empty mining the cursor stays put so the next tick retries
+     * the same window with new experiences.
+     */
+    private mineExperiencesPerDomain;
     /**
      * Create patterns from pattern candidates
      */