agentic-qe 3.13.9 → 3.13.11

package/dist/integrations/ruvector/solver-adapter.js

@@ -4,14 +4,14 @@
  * Provides graph-based importance scoring for QE patterns using PageRank.
  *
  * Two execution paths:
- * - **Native** (@ruvector/solver-node): O(log n) sublinear via Neumann series.
- *   Requires the optional NAPI dependency to be installed.
+ * - **Async**: optional @ruvector/solver NAPI backend, then worker-thread
+ *   TypeScript fallback for large graphs.
  * - **TypeScript fallback**: Standard power iteration, O(n * m * iterations).
  *   Always available, correct results, linear-time.
  *
  * Usage:
  * ```typescript
- * import { createPageRankSolver } from './solver-adapter';
+ * import { createPageRankSolver } from './solver-adapter.js';
  *
  * const solver = createPageRankSolver({ dampingFactor: 0.85 });
  * const scores = solver.computeImportance(graph);
@@ -20,6 +20,7 @@
  *
  * @module integrations/ruvector/solver-adapter
  */
+import { computeTypeScriptPageRank, loadNativeSolverModule, runNativePageRank, runPageRankWorker, } from './page-rank-backends.js';
 // ============================================================================
 // Default Configuration
 // ============================================================================
@@ -28,33 +29,11 @@ const DEFAULT_SOLVER_CONFIG = {
     tolerance: 1e-6,
     maxIterations: 100,
 };
-// ============================================================================
-// Native Module Detection
-// ============================================================================
-/**
- * Cached reference to the @ruvector/solver-node native module.
- * `null` means we haven't attempted to load yet; `false` means load failed.
- */
-let _nativeModule = null;
-/**
- * Attempt to load the optional @ruvector/solver-node native bindings.
- * The result is cached so the cost is paid at most once per process.
- */
-function tryLoadNativeSync() {
-    if (_nativeModule === false)
-        return false;
-    if (_nativeModule != null)
-        return true;
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        _nativeModule = require('@ruvector/solver-node');
-        return true;
-    }
-    catch {
-        _nativeModule = false;
-        return false;
-    }
-}
+const DEFAULT_RUNTIME_OPTIONS = {
+    workerThreshold: 50_000,
+    workerTimeoutMs: 30_000,
+    workerRunner: runPageRankWorker,
+};
 // ============================================================================
 // Input Validation
 // ============================================================================
@@ -78,95 +57,24 @@ function validateGraph(graph) {
     return n;
 }
 // ============================================================================
-// TypeScript Power-Iteration PageRank
-// ============================================================================
-/**
- * Compute PageRank scores using the standard power-iteration method.
- *
- * Algorithm (per Wikipedia / original Brin-Page paper):
- *   1. scores[i] = 1 / N  for all i
- *   2. For each iteration:
- *        new[i] = (1 - d) / N
- *                 + d * SUM_{j -> i} ( scores[j] * edgeWeight(j,i) / weightedOutDegree[j] )
- *   3. Converge when max |new[i] - old[i]| < tolerance
- *
- * Self-loops are included in outDegree computation but their contribution
- * flows back to the same node (standard PageRank semantics).
- *
- * Dangling nodes (zero out-degree) distribute their score uniformly to all
- * nodes, matching the standard random-surfer model.
- */
-function powerIterationPageRank(graph, config) {
-    const n = graph.nodes.length;
-    const { dampingFactor: d, tolerance, maxIterations } = config;
-    // Pre-compute weighted out-degree for each node
-    const weightedOutDegree = new Float64Array(n);
-    for (const [from, , weight] of graph.edges) {
-        weightedOutDegree[from] += weight;
-    }
-    // Build adjacency list for incoming edges: inEdges[toIndex] = [[fromIndex, weight], ...]
-    const inEdges = new Array(n);
-    for (let i = 0; i < n; i++) {
-        inEdges[i] = [];
-    }
-    for (const [from, to, weight] of graph.edges) {
-        inEdges[to].push([from, weight]);
-    }
-    // Identify dangling nodes (no outgoing edges)
-    const danglingNodes = [];
-    for (let i = 0; i < n; i++) {
-        if (weightedOutDegree[i] === 0) {
-            danglingNodes.push(i);
-        }
-    }
-    // Initialize scores uniformly
-    let scores = new Float64Array(n);
-    const uniformShare = 1 / n;
-    scores.fill(uniformShare);
-    const base = (1 - d) / n;
-    for (let iter = 0; iter < maxIterations; iter++) {
-        // Dangling node contribution: their total score is redistributed uniformly
-        let danglingSum = 0;
-        for (const di of danglingNodes) {
-            danglingSum += scores[di];
-        }
-        const danglingContrib = d * danglingSum / n;
-        const next = new Float64Array(n);
-        for (let i = 0; i < n; i++) {
-            let incoming = 0;
-            for (const [from, weight] of inEdges[i]) {
-                incoming += (scores[from] * weight) / weightedOutDegree[from];
-            }
-            next[i] = base + d * incoming + danglingContrib;
-        }
-        // Check convergence (L-infinity norm)
-        let maxDelta = 0;
-        for (let i = 0; i < n; i++) {
-            const delta = Math.abs(next[i] - scores[i]);
-            if (delta > maxDelta)
-                maxDelta = delta;
-        }
-        scores = next;
-        if (maxDelta < tolerance) {
-            break;
-        }
-    }
-    return scores;
-}
-// ============================================================================
 // PageRankSolver Class
 // ============================================================================
 /**
  * Computes importance scores for pattern graphs using PageRank.
  *
- * Prefers the native @ruvector/solver-node NAPI bindings when available
- * (O(log n) via Neumann series). Falls back to a TypeScript power-iteration
- * implementation (O(n * m * iterations)) when the native module is absent.
+ * The synchronous API uses the deterministic TypeScript implementation.
+ * The async API prefers @ruvector/solver and offloads large fallback graphs.
  */
 export class PageRankSolver {
     config;
-    constructor(config) {
+    runtime;
+    nativeModule;
+    constructor(config, runtime) {
         this.config = { ...DEFAULT_SOLVER_CONFIG, ...config };
+        this.runtime = { ...DEFAULT_RUNTIME_OPTIONS, ...runtime };
+        this.nativeModule = runtime && 'nativeModule' in runtime
+            ? runtime.nativeModule ?? null
+            : loadNativeSolverModule();
         // Validate config ranges
         if (this.config.dampingFactor <= 0 || this.config.dampingFactor >= 1) {
             throw new RangeError('dampingFactor must be in (0, 1)');
@@ -177,14 +85,18 @@ export class PageRankSolver {
         if (this.config.maxIterations < 1) {
             throw new RangeError('maxIterations must be >= 1');
         }
-        // Eagerly attempt native load so isNativeAvailable() is stable
-        tryLoadNativeSync();
+        if (this.runtime.workerThreshold < 0) {
+            throw new RangeError('workerThreshold must be >= 0');
+        }
+        if (this.runtime.workerTimeoutMs < 1) {
+            throw new RangeError('workerTimeoutMs must be >= 1');
+        }
     }
     /**
-     * Check whether the native @ruvector/solver-node module is available.
+     * Check whether the native @ruvector/solver module is available.
      */
     isNativeAvailable() {
-        return tryLoadNativeSync();
+        return this.nativeModule !== null;
     }
     /**
      * Compute importance scores for all nodes in a pattern graph.
@@ -204,18 +116,35 @@ export class PageRankSolver {
             result.set(graph.nodes[0], 1.0);
             return result;
         }
+        const scores = computeTypeScriptPageRank(graph, this.config);
+        this.copyScoresToResult(graph, scores, result);
+        return result;
+    }
+    /**
+     * Compute PageRank without blocking the event loop for large graphs.
+     * Native and worker failures fall back to the verified synchronous backend.
+     */
+    async computeImportanceAsync(graph) {
+        const n = validateGraph(graph);
+        if (n < 2)
+            return this.computeImportance(graph);
         let scores;
-        if (this.isNativeAvailable() && _nativeModule?.pagerank) {
-            // Delegate to native solver
-            scores = this.computeNative(graph);
-        }
-        else {
-            // TypeScript power iteration fallback
-            scores = powerIterationPageRank(graph, this.config);
+        try {
+            if (this.nativeModule) {
+                scores = await runNativePageRank(this.nativeModule, graph, this.config);
+            }
+            else if (graph.nodes.length + graph.edges.length >= this.runtime.workerThreshold) {
+                scores = await this.runtime.workerRunner(graph, this.config, this.runtime.workerTimeoutMs);
+            }
+            else {
+                scores = computeTypeScriptPageRank(graph, this.config);
+            }
         }
-        for (let i = 0; i < n; i++) {
-            result.set(graph.nodes[i], scores[i]);
+        catch {
+            scores = computeTypeScriptPageRank(graph, this.config);
         }
+        const result = new Map();
+        this.copyScoresToResult(graph, scores, result);
         return result;
     }
     /**
@@ -242,45 +171,9 @@ export class PageRankSolver {
         }
         return ranked;
     }
-    // --------------------------------------------------------------------------
-    // Private: native solver delegation
-    // --------------------------------------------------------------------------
-    /**
-     * Delegate PageRank computation to the native @ruvector/solver-node module.
-     *
-     * The native API is expected to accept the graph in a compatible format
-     * and return a Float64Array of scores indexed by node position.
-     */
-    computeNative(graph) {
-        const n = graph.nodes.length;
-        // Build edge arrays in the format expected by native solver
-        const fromIndices = new Int32Array(graph.edges.length);
-        const toIndices = new Int32Array(graph.edges.length);
-        const weights = new Float64Array(graph.edges.length);
-        for (let i = 0; i < graph.edges.length; i++) {
-            fromIndices[i] = graph.edges[i][0];
-            toIndices[i] = graph.edges[i][1];
-            weights[i] = graph.edges[i][2];
-        }
-        try {
-            const result = _nativeModule.pagerank({
-                nodeCount: n,
-                fromIndices,
-                toIndices,
-                weights,
-                dampingFactor: this.config.dampingFactor,
-                tolerance: this.config.tolerance,
-                maxIterations: this.config.maxIterations,
-            });
-            // Expect Float64Array or plain number[]
-            if (result instanceof Float64Array) {
-                return result;
-            }
-            return Float64Array.from(result);
-        }
-        catch {
-            // If native call fails, fall back gracefully to TS implementation
-            return powerIterationPageRank(graph, this.config);
+    copyScoresToResult(graph, scores, result) {
+        for (let i = 0; i < graph.nodes.length; i++) {
+            result.set(graph.nodes[i], scores[i]);
         }
     }
 }
@@ -293,7 +186,7 @@ export class PageRankSolver {
  * @param config - Partial solver configuration (defaults applied)
  * @returns A configured PageRankSolver
  */
-export function createPageRankSolver(config) {
-    return new PageRankSolver(config);
+export function createPageRankSolver(config, runtime) {
+    return new PageRankSolver(config, runtime);
 }
 //# sourceMappingURL=solver-adapter.js.map

package/dist/integrations/ruvector/sona-persistence.d.ts

@@ -34,6 +34,18 @@ export declare const SONA_PATTERNS_SCHEMA = "\n  -- SONA Patterns table (ADR-046
  * SONA Fisher matrices table schema - stores EWC++ state per domain
  */
 export declare const SONA_FISHER_SCHEMA = "\n  -- SONA Fisher Information Matrices (Task 2.2: EWC++ Persistence)\n  CREATE TABLE IF NOT EXISTS sona_fisher_matrices (\n    domain TEXT PRIMARY KEY,\n    fisher_diagonal BLOB NOT NULL,\n    optimal_params BLOB NOT NULL,\n    base_weights BLOB,\n    dimension INTEGER NOT NULL,\n    task_boundaries INTEGER NOT NULL DEFAULT 0,\n    consolidation_cycles INTEGER NOT NULL DEFAULT 0,\n    request_count INTEGER NOT NULL DEFAULT 0,\n    ewc_lambda REAL NOT NULL DEFAULT 1000.0,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now'))\n  );\n";
+/** Read-only aggregate over the persisted SONA pattern store. */
+export interface PersistedSONAStats {
+    totalPatterns: number;
+    uniqueTypes: number;
+    uniqueDomains: number;
+    avgConfidence: number;
+    avgUsage: number;
+    totalSuccesses: number;
+    totalFailures: number;
+    byType: Record<string, number>;
+    byDomain: Record<string, number>;
+}
 /**
  * Configuration for persistent SONA engine
  */
@@ -253,17 +265,7 @@ export declare class PersistentSONAEngine {
     /**
      * Get persisted statistics from SQLite
      */
-    getPersistedStats(): Promise<{
-        totalPatterns: number;
-        uniqueTypes: number;
-        uniqueDomains: number;
-        avgConfidence: number;
-        avgUsage: number;
-        totalSuccesses: number;
-        totalFailures: number;
-        byType: Record<string, number>;
-        byDomain: Record<string, number>;
-    }>;
+    getPersistedStats(): Promise<PersistedSONAStats>;
     /**
      * Get configuration
      */

package/dist/integrations/ruvector/sona-persistence.js

@@ -66,7 +66,7 @@ export const SONA_PATTERNS_SCHEMA = `
 /**
  * SONA Fisher matrices table schema - stores EWC++ state per domain
  */
-export const SONA_FISHER_SCHEMA = `
+export const SONA_FISHER_SCHEMA = `
   -- SONA Fisher Information Matrices (Task 2.2: EWC++ Persistence)
   CREATE TABLE IF NOT EXISTS sona_fisher_matrices (
     domain TEXT PRIMARY KEY,

package/dist/integrations/vibium/client.js

@@ -7,10 +7,10 @@
  * @module integrations/vibium/client
  */
 import { randomUUID } from 'crypto';
-import { DEFAULT_VIBIUM_CONFIG } from './types';
-import { VibiumError, VibiumUnavailableError, VibiumTimeoutError, VibiumElementNotFoundError, VibiumConnectionError, VibiumNavigationError, VibiumScreenshotError, VibiumInteractionError, createVibiumError, } from './errors';
+import { DEFAULT_VIBIUM_CONFIG } from './types.js';
+import { VibiumError, VibiumUnavailableError, VibiumTimeoutError, VibiumElementNotFoundError, VibiumConnectionError, VibiumNavigationError, VibiumScreenshotError, VibiumInteractionError, createVibiumError, } from './errors.js';
 import { toError } from '../../shared/error-utils.js';
-import { isBrowserModeEnabled, isScreenshotCaptureEnabled, isAutoRetryEnabled, shouldLogPerformanceMetrics, } from './feature-flags';
+import { isBrowserModeEnabled, isScreenshotCaptureEnabled, isAutoRetryEnabled, shouldLogPerformanceMetrics, } from './feature-flags.js';
 // ============================================================================
 // Vibium Import (Real Browser Automation)
 // ============================================================================

package/dist/integrations/vibium/fallback.js

@@ -8,8 +8,8 @@
  * @module integrations/vibium/fallback
  */
 import { randomUUID } from 'crypto';
-import { DEFAULT_VIBIUM_CONFIG } from './types';
-import { VibiumUnavailableError } from './errors';
+import { DEFAULT_VIBIUM_CONFIG } from './types.js';
+import { VibiumUnavailableError } from './errors.js';
 // ============================================================================
 // Fallback Client Implementation
 // ============================================================================

package/dist/integrations/vibium/index.js

@@ -42,7 +42,7 @@
  * ```
  */
 // Export constants
-export { DEFAULT_VIBIUM_CONFIG } from './types';
+export { DEFAULT_VIBIUM_CONFIG } from './types.js';
 // ============================================================================
 // Error Classes
 // ============================================================================
@@ -54,21 +54,21 @@ VibiumUnavailableError, VibiumTimeoutError, VibiumElementNotFoundError, VibiumCo
 // Error Type Guards
 isVibiumError, isVibiumUnavailable, isVibiumTimeout, isElementNotFound, isConnectionError, 
 // Error Factory Functions
-createVibiumError, createUnavailableError, } from './errors';
+createVibiumError, createUnavailableError, } from './errors.js';
 // ============================================================================
 // Feature Flags
 // ============================================================================
-export { getVibiumFeatureFlags, setVibiumFeatureFlags, resetVibiumFeatureFlags, isBrowserModeEnabled, isAxeCoreEnabled, isVisualRegressionEnabled, isScreenshotCaptureEnabled, isE2EExecutionEnabled, isDefaultHeadless, isAutoRetryEnabled, shouldLogPerformanceMetrics, initVibiumFeatureFlagsFromEnv, configureForCI, configureForDevelopment, configureForHeuristicMode, DEFAULT_FEATURE_FLAGS as DEFAULT_VIBIUM_FEATURE_FLAGS, } from './feature-flags';
+export { getVibiumFeatureFlags, setVibiumFeatureFlags, resetVibiumFeatureFlags, isBrowserModeEnabled, isAxeCoreEnabled, isVisualRegressionEnabled, isScreenshotCaptureEnabled, isE2EExecutionEnabled, isDefaultHeadless, isAutoRetryEnabled, shouldLogPerformanceMetrics, initVibiumFeatureFlagsFromEnv, configureForCI, configureForDevelopment, configureForHeuristicMode, DEFAULT_FEATURE_FLAGS as DEFAULT_VIBIUM_FEATURE_FLAGS, } from './feature-flags.js';
 // ============================================================================
 // Client Implementation Exports
 // ============================================================================
-export { VibiumClientImpl, VibiumClientProvider } from './client';
+export { VibiumClientImpl, VibiumClientProvider } from './client.js';
 // ============================================================================
 // Fallback Implementation Exports
 // ============================================================================
-export { FallbackVibiumClient, createFallbackVibiumClient, isUsingFallback, markAsFallback, } from './fallback';
-import { VibiumClientImpl } from './client';
-import { FallbackVibiumClient } from './fallback';
+export { FallbackVibiumClient, createFallbackVibiumClient, isUsingFallback, markAsFallback, } from './fallback.js';
+import { VibiumClientImpl } from './client.js';
+import { FallbackVibiumClient } from './fallback.js';
 /**
  * Create a Vibium client with automatic fallback
  *
@@ -96,7 +96,7 @@ import { FallbackVibiumClient } from './fallback';
  * ```
  */
 export async function createVibiumClient(config = {}) {
-    const { getVibiumFeatureFlags } = await import('./feature-flags');
+    const { getVibiumFeatureFlags } = await import('./feature-flags.js');
     const flags = getVibiumFeatureFlags();
     // If browser mode is disabled or fallback is preferred, use fallback
     if (!flags.useBrowserMode || (config.fallbackEnabled && !config.enabled)) {
@@ -159,7 +159,7 @@ export function createVibiumClientSync(config = {}) {
  * ```
  */
 export async function getVibiumClient(config) {
-    const { VibiumClientProvider } = await import('./client');
+    const { VibiumClientProvider } = await import('./client.js');
     const provider = VibiumClientProvider.getInstance(config);
     return provider.getClient();
 }

package/dist/kernel/agent-coordinator.js

@@ -3,7 +3,7 @@
  * Manages agent lifecycle with max concurrent agents limit
  */
 import { v4 as uuidv4 } from 'uuid';
-import { ok, err } from '../shared/types';
+import { ok, err } from '../shared/types/index.js';
 import { AGENT_CONSTANTS } from './constants.js';
 export class DefaultAgentCoordinator {
     agents = new Map();

package/dist/kernel/event-bus.js

@@ -6,7 +6,7 @@
  * - CircularBuffer for O(1) event history push (replaces O(n) shift)
  * - Subscription indexes for O(1) lookup (replaces O(n) filter)
  */
-import { CircularBuffer } from '../shared/utils/circular-buffer';
+import { CircularBuffer } from '../shared/utils/circular-buffer.js';
 import { EVENT_BUS_CONSTANTS } from './constants.js';
 // ============================================================================
 // ADR-062: Loop Detection Event Types

package/dist/kernel/hybrid-backend.js

@@ -9,7 +9,7 @@
  * This is a facade over UnifiedMemoryManager that maintains
  * backward compatibility with existing MemoryBackend interface.
  */
-import { getUnifiedMemory, DEFAULT_UNIFIED_MEMORY_CONFIG } from './unified-memory';
+import { getUnifiedMemory, DEFAULT_UNIFIED_MEMORY_CONFIG } from './unified-memory.js';
 import { MEMORY_CONSTANTS } from './constants.js';
 import { LoggerFactory } from '../logging/index.js';
 const logger = LoggerFactory.create('hybrid-backend');

package/dist/kernel/index.js

@@ -2,23 +2,23 @@
  * Agentic QE v3 - Kernel Exports
  */
 // Interfaces
-export * from './interfaces';
+export * from './interfaces.js';
 // Implementations
-export { InMemoryEventBus } from './event-bus';
-export { DefaultAgentCoordinator, ProgressiveContextLoader } from './agent-coordinator';
-export { DefaultPluginLoader } from './plugin-loader';
-export { InMemoryBackend } from './memory-backend';
-export { QEKernelImpl, createKernel } from './kernel';
+export { InMemoryEventBus } from './event-bus.js';
+export { DefaultAgentCoordinator, ProgressiveContextLoader } from './agent-coordinator.js';
+export { DefaultPluginLoader } from './plugin-loader.js';
+export { InMemoryBackend } from './memory-backend.js';
+export { QEKernelImpl, createKernel } from './kernel.js';
 // Memory Backends (unified into HybridMemoryBackend via UnifiedMemoryManager)
-export { HybridMemoryBackend } from './hybrid-backend';
+export { HybridMemoryBackend } from './hybrid-backend.js';
 // Memory Factory
-export { createMemoryBackend, createDefaultMemoryBackend, selectBackendType, getRecommendedConfig, } from './memory-factory';
+export { createMemoryBackend, createDefaultMemoryBackend, selectBackendType, getRecommendedConfig, } from './memory-factory.js';
 // Unified Memory (Single memory.db - the source of truth)
 export { UnifiedMemoryManager, getUnifiedMemory, initializeUnifiedMemory, resetUnifiedMemory, DEFAULT_UNIFIED_MEMORY_CONFIG, 
 // Project root detection for consistent DB path resolution
-findProjectRoot, clearProjectRootCache, getDefaultDbPath, getResolvedDefaultConfig, } from './unified-memory';
+findProjectRoot, clearProjectRootCache, getDefaultDbPath, getResolvedDefaultConfig, } from './unified-memory.js';
 // Migration utilities
-export { migrateToUnifiedMemory, migrationNeeded, getMigrationStatus, } from './unified-memory-migration';
+export { migrateToUnifiedMemory, migrationNeeded, getMigrationStatus, } from './unified-memory-migration.js';
 // Legacy persistence (for backward compatibility - delegates to UnifiedMemoryManager)
-export { UnifiedPersistenceManager, getUnifiedPersistence, initializeUnifiedPersistence, resetUnifiedPersistence, } from './unified-persistence';
+export { UnifiedPersistenceManager, getUnifiedPersistence, initializeUnifiedPersistence, resetUnifiedPersistence, } from './unified-persistence.js';
 //# sourceMappingURL=index.js.map

package/dist/kernel/kernel.js

@@ -3,12 +3,12 @@
  * Microkernel implementation coordinating all domains
  */
 import { randomUUID } from 'crypto';
-import { ALL_DOMAINS } from '../shared/types';
-import { InMemoryEventBus } from './event-bus';
-import { DefaultAgentCoordinator } from './agent-coordinator';
-import { DefaultPluginLoader } from './plugin-loader';
-import { InMemoryBackend } from './memory-backend';
-import { HybridMemoryBackend } from './hybrid-backend';
+import { ALL_DOMAINS } from '../shared/types/index.js';
+import { InMemoryEventBus } from './event-bus.js';
+import { DefaultAgentCoordinator } from './agent-coordinator.js';
+import { DefaultPluginLoader } from './plugin-loader.js';
+import { InMemoryBackend } from './memory-backend.js';
+import { HybridMemoryBackend } from './hybrid-backend.js';
 import { SemanticAntiDriftMiddleware, ToolCallSignatureTracker } from './anti-drift-middleware.js';
 import { LOOP_EVENT_TYPES } from './event-bus.js';
 import { AGENT_CONSTANTS, MEMORY_CONSTANTS } from './constants.js';
@@ -16,35 +16,35 @@ import { findProjectRoot } from './unified-memory.js';
 import { initializeUnifiedPersistence } from './unified-persistence.js';
 import * as path from 'path';
 import * as fs from 'fs';
-import { PluginLifecycleManager } from '../plugins/lifecycle';
-import { PluginCache } from '../plugins/cache';
+import { PluginLifecycleManager } from '../plugins/lifecycle.js';
+import { PluginCache } from '../plugins/cache.js';
 import { CapturedExperienceBridge } from '../bridge/captured-experience-bridge.js';
 import { DreamScheduler } from '../learning/dream/dream-scheduler.js';
 import { createDreamEngine } from '../learning/dream/dream-engine.js';
 import { createLLMRouterService, } from '../shared/llm/llm-router-service.js';
 // Import domain plugin factories
-import { createTestGenerationPlugin } from '../domains/test-generation/plugin';
-import { createTestExecutionPlugin } from '../domains/test-execution/plugin';
-import { createCoverageAnalysisPlugin } from '../domains/coverage-analysis/plugin';
-import { createQualityAssessmentPlugin } from '../domains/quality-assessment/plugin';
-import { createDefectIntelligencePlugin } from '../domains/defect-intelligence/plugin';
-import { createRequirementsValidationPlugin } from '../domains/requirements-validation/plugin';
-import { createCodeIntelligencePlugin } from '../domains/code-intelligence/plugin';
-import { createSecurityCompliancePlugin } from '../domains/security-compliance/plugin';
-import { createContractTestingPlugin } from '../domains/contract-testing/plugin';
-import { createVisualAccessibilityPlugin } from '../domains/visual-accessibility/plugin';
-import { createChaosResiliencePlugin } from '../domains/chaos-resilience/plugin';
-import { createLearningOptimizationPlugin } from '../domains/learning-optimization/plugin';
-import { createCoordinationPlugin } from '../coordination/plugin';
+import { createTestGenerationPlugin } from '../domains/test-generation/plugin.js';
+import { createTestExecutionPlugin } from '../domains/test-execution/plugin.js';
+import { createCoverageAnalysisPlugin } from '../domains/coverage-analysis/plugin.js';
+import { createQualityAssessmentPlugin } from '../domains/quality-assessment/plugin.js';
+import { createDefectIntelligencePlugin } from '../domains/defect-intelligence/plugin.js';
+import { createRequirementsValidationPlugin } from '../domains/requirements-validation/plugin.js';
+import { createCodeIntelligencePlugin } from '../domains/code-intelligence/plugin.js';
+import { createSecurityCompliancePlugin } from '../domains/security-compliance/plugin.js';
+import { createContractTestingPlugin } from '../domains/contract-testing/plugin.js';
+import { createVisualAccessibilityPlugin } from '../domains/visual-accessibility/plugin.js';
+import { createChaosResiliencePlugin } from '../domains/chaos-resilience/plugin.js';
+import { createLearningOptimizationPlugin } from '../domains/learning-optimization/plugin.js';
+import { createCoordinationPlugin } from '../coordination/plugin.js';
 // CQ-005: Import domain barrel exports to trigger DomainServiceRegistry.register() calls.
 // Domain index.ts files register service factories as side effects.
 // The kernel must import these so coordination/ can resolve services at runtime.
-import '../domains/test-generation';
-import '../domains/coverage-analysis';
-import '../domains/security-compliance';
-import '../domains/code-intelligence';
-import '../domains/quality-assessment';
-import { createEnterpriseIntegrationPlugin } from '../domains/enterprise-integration/plugin';
+import '../domains/test-generation/index.js';
+import '../domains/coverage-analysis/index.js';
+import '../domains/security-compliance/index.js';
+import '../domains/code-intelligence/index.js';
+import '../domains/quality-assessment/index.js';
+import { createEnterpriseIntegrationPlugin } from '../domains/enterprise-integration/plugin.js';
 // NOTE: underlying createXxxPlugin signatures are updated in Phase 2.
 // For Phase 1, the wrappers accept llmRouter but discard it — this
 // keeps the kernel boot path internally consistent without forcing

package/dist/kernel/memory-factory.js

@@ -5,8 +5,8 @@
  * NOTE: All backends now delegate to UnifiedMemoryManager for true unified storage.
  * The 'agentdb' type is kept for backward compatibility but maps to HybridMemoryBackend.
  */
-import { InMemoryBackend } from './memory-backend';
-import { HybridMemoryBackend } from './hybrid-backend';
+import { InMemoryBackend } from './memory-backend.js';
+import { HybridMemoryBackend } from './hybrid-backend.js';
 import { MEMORY_CONSTANTS, DATABASE_POOL_CONSTANTS } from './constants.js';
 // ============================================================================
 // Module Constants

package/dist/kernel/unified-persistence.js

@@ -19,7 +19,7 @@
  * - Simplified backup/restore
  */
 import { toErrorMessage } from '../shared/error-utils.js';
-import { getUnifiedMemory, resetUnifiedMemory, DEFAULT_UNIFIED_MEMORY_CONFIG, } from './unified-memory';
+import { getUnifiedMemory, resetUnifiedMemory, DEFAULT_UNIFIED_MEMORY_CONFIG, } from './unified-memory.js';
 import { MEMORY_CONSTANTS } from './constants.js';
 // Use same path as unified-memory for true unification
 export const DEFAULT_UNIFIED_CONFIG = {

package/dist/learning/aqe-learning-engine.d.ts

@@ -192,7 +192,6 @@ export declare class AQELearningEngine {
      * @param patterns - Found patterns
      * @returns Enhanced routing result
      */
-    private enhanceRoutingWithPatterns;
     /**
      * Get recommended model for a task
      *