agentic-qe 3.10.2 → 3.10.4

package/dist/domains/quality-assessment/coherence/gate-controller.js

@@ -231,37 +231,43 @@ export class CoherenceGateController {
             case QualityTier.NORMAL:
                 return [];
             case QualityTier.REDUCED:
-                const reducedActions = [
-                    'runAdditionalTests',
-                    'notifyReviewers',
-                    'requireApproval',
-                ];
-                if (reason === 'lambdaDroppedFast') {
-                    reducedActions.push('increaseMonitoring');
+                {
+                    const reducedActions = [
+                        'runAdditionalTests',
+                        'notifyReviewers',
+                        'requireApproval',
+                    ];
+                    if (reason === 'lambdaDroppedFast') {
+                        reducedActions.push('increaseMonitoring');
+                    }
+                    return reducedActions;
                 }
-                return reducedActions;
             case QualityTier.SAFE:
-                const safeActions = [
-                    'blockDeploy',
-                    'alertTeam',
-                    'scheduleReview',
-                    'generateReport',
-                ];
-                if (reason === 'testFailureSpike') {
-                    safeActions.push('runAdditionalTests');
+                {
+                    const safeActions = [
+                        'blockDeploy',
+                        'alertTeam',
+                        'scheduleReview',
+                        'generateReport',
+                    ];
+                    if (reason === 'testFailureSpike') {
+                        safeActions.push('runAdditionalTests');
+                    }
+                    return safeActions;
                 }
-                return safeActions;
             case QualityTier.QUARANTINE:
-                const quarantineActions = [
-                    'blockAllDeploys',
-                    'escalateToLeads',
-                    'rollbackIfNeeded',
-                    'generateReport',
-                ];
-                if (reason === 'securityCritical') {
-                    quarantineActions.push('runSecurityScan');
+                {
+                    const quarantineActions = [
+                        'blockAllDeploys',
+                        'escalateToLeads',
+                        'rollbackIfNeeded',
+                        'generateReport',
+                    ];
+                    if (reason === 'securityCritical') {
+                        quarantineActions.push('runSecurityScan');
+                    }
+                    return quarantineActions;
                 }
-                return quarantineActions;
         }
     }
     /**

package/dist/domains/requirements-validation/coordinator.js

@@ -18,6 +18,7 @@ import { TestabilityScorerService } from './services/testability-scorer.js';
 import { PPOAlgorithm } from '../../integrations/rl-suite/algorithms/ppo.js';
 // V3 Integration: @ruvector wrappers (persistent patterns)
 import { createPersistentSONAEngine, } from '../../integrations/ruvector/sona-persistence.js';
+// V3 Integration: MinCut Awareness (ADR-047) - only import types needed beyond base
 // CQ-002: Base domain coordinator
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 import { createDomainFinding, } from '../../coordination/consensus/domain-findings.js';

package/dist/domains/test-execution/services/e2e/wait-condition-handler.js

@@ -27,7 +27,7 @@ export class WaitConditionHandler {
         const startTime = Date.now();
         while (Date.now() - startTime < timeout) {
             let conditionMet = false;
-            let data = {};
+            const data = {};
             try {
                 switch (condition) {
                     case 'element-visible':

package/dist/domains/test-execution/services/retry-handler.js

@@ -337,25 +337,31 @@ export class RetryHandlerService {
         switch (runner) {
             case 'vitest':
                 // vitest run --reporter=json testFile -t "testName"
-                const vitestArgs = ['vitest', 'run', '--reporter=json', testFile];
-                if (testName) {
-                    vitestArgs.push('-t', testName);
+                {
+                    const vitestArgs = ['vitest', 'run', '--reporter=json', testFile];
+                    if (testName) {
+                        vitestArgs.push('-t', testName);
+                    }
+                    return { command: npx, args: vitestArgs };
                 }
-                return { command: npx, args: vitestArgs };
             case 'jest':
                 // jest --json testFile -t "testName"
-                const jestArgs = ['jest', '--json', '--testPathPattern', testFile];
-                if (testName) {
-                    jestArgs.push('-t', testName);
+                {
+                    const jestArgs = ['jest', '--json', '--testPathPattern', testFile];
+                    if (testName) {
+                        jestArgs.push('-t', testName);
+                    }
+                    return { command: npx, args: jestArgs };
                 }
-                return { command: npx, args: jestArgs };
             case 'mocha':
                 // mocha --reporter json testFile --grep "testName"
-                const mochaArgs = ['mocha', '--reporter', 'json', testFile];
-                if (testName) {
-                    mochaArgs.push('--grep', testName);
+                {
+                    const mochaArgs = ['mocha', '--reporter', 'json', testFile];
+                    if (testName) {
+                        mochaArgs.push('--grep', testName);
+                    }
+                    return { command: npx, args: mochaArgs };
                 }
-                return { command: npx, args: mochaArgs };
             default:
                 throw new Error(`Unsupported test runner: ${runner}`);
         }

package/dist/domains/test-generation/coordinator.js

@@ -229,7 +229,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                 return err(new Error('Test generation paused: topology is in critical state'));
             }
             // Fire PreTestGeneration hook to get guidance and patterns from learning system
-            let hookPatternIds = [];
+            const hookPatternIds = [];
             if (this.hookRegistry) {
                 try {
                     const targetFile = request.sourceFiles?.[0] || '';

package/dist/domains/test-generation/services/pattern-matcher.js

@@ -1284,12 +1284,14 @@ class TypeScriptASTParser {
                     complexity++;
                     break;
                 case ts.SyntaxKind.BinaryExpression:
-                    const binary = n;
-                    if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-                        binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-                        complexity++;
+                    {
+                        const binary = n;
+                        if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                            binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+                            complexity++;
+                        }
+                        break;
                     }
-                    break;
             }
             ts.forEachChild(n, visit);
         };

package/dist/domains/test-generation/services/test-generator.js

@@ -736,8 +736,9 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
             // Cross-reference with KG vectors to find callers (files that import this one)
             const normalizedPath = filePath.replace(/\\/g, '/');
             const baseName = normalizedPath.split('/').pop()?.replace(/\.(ts|js|tsx|jsx|py)$/, '') || '';
-            // Search KG node vectors for this file's name to find related nodes
-            const nodeKeys = await this.memory.search(`code-intelligence:kg:node:*${baseName}*`, 50);
+            // Search KG node vectors for this file's name to find related nodes.
+            // KG persists under its own namespace (#511 parity) — read it there.
+            const nodeKeys = await this.memory.search(`code-intelligence:kg:node:*${baseName}*`, 50, { namespace: 'code-intelligence:kg' });
             for (const key of nodeKeys) {
                 // Nodes matching this file's name that are from other files indicate callers
                 if (!key.includes(baseName))

package/dist/domains/visual-accessibility/coordinator.js

@@ -892,29 +892,33 @@ export class VisualAccessibilityCoordinator extends BaseDomainCoordinator {
                     break;
                 case 'allocate':
                     // Allocate based on resource availability
-                    const agentCount = typeof prediction.action.value === 'object' ? prediction.action.value.agents ?? 2 : 2;
-                    const testsPerAgent = Math.ceil(prioritized.length / agentCount);
-                    prioritized = prioritized.map((t, i) => ({
-                        ...t,
-                        priority: 10 - Math.floor(i / testsPerAgent),
-                        reason: `allocate-agent-${Math.floor(i / testsPerAgent)}`,
-                    }));
-                    strategy = 'allocate-by-agent';
-                    break;
+                    {
+                        const agentCount = typeof prediction.action.value === 'object' ? prediction.action.value.agents ?? 2 : 2;
+                        const testsPerAgent = Math.ceil(prioritized.length / agentCount);
+                        prioritized = prioritized.map((t, i) => ({
+                            ...t,
+                            priority: 10 - Math.floor(i / testsPerAgent),
+                            reason: `allocate-agent-${Math.floor(i / testsPerAgent)}`,
+                        }));
+                        strategy = 'allocate-by-agent';
+                        break;
+                    }
                 case 'rebalance':
                     // Rebalance based on viewport coverage
-                    const viewportCounts = new Map();
-                    for (const t of prioritized) {
-                        viewportCounts.set(t.viewport.width, (viewportCounts.get(t.viewport.width) || 0) + 1);
+                    {
+                        const viewportCounts = new Map();
+                        for (const t of prioritized) {
+                            viewportCounts.set(t.viewport.width, (viewportCounts.get(t.viewport.width) || 0) + 1);
+                        }
+                        prioritized.sort((a, b) => (viewportCounts.get(a.viewport.width) || 0) - (viewportCounts.get(b.viewport.width) || 0));
+                        prioritized = prioritized.map((t) => ({
+                            ...t,
+                            priority: 10 - (viewportCounts.get(t.viewport.width) || 0),
+                            reason: 'rebalance-viewport-coverage',
+                        }));
+                        strategy = 'rebalance-viewport-coverage';
+                        break;
                     }
-                    prioritized.sort((a, b) => (viewportCounts.get(a.viewport.width) || 0) - (viewportCounts.get(b.viewport.width) || 0));
-                    prioritized = prioritized.map((t) => ({
-                        ...t,
-                        priority: 10 - (viewportCounts.get(t.viewport.width) || 0),
-                        reason: 'rebalance-viewport-coverage',
-                    }));
-                    strategy = 'rebalance-viewport-coverage';
-                    break;
                 default:
                     break;
             }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Agentic QE v3 - Main Entry Point
- * Domain-Driven Design Architecture with 12 Bounded Contexts
+ * Domain-Driven Design Architecture with 13 Bounded Contexts
  */
 export * from './shared/types';
 export * from './shared/value-objects';
@@ -28,7 +28,7 @@ export type { TopologyType, AgentNode, CommunicationEdge, SwarmTopology, AgentHe
 export { SwarmSkillValidator, createSwarmSkillValidator, DEFAULT_SWARM_VALIDATION_CONFIG, P0_SKILLS, DEFAULT_VALIDATION_MODELS, TriggerOptimizer, createTriggerOptimizer, parseSkillFrontmatter, VersionComparator, createVersionComparator, } from './validation';
 export type { SwarmValidationConfig, SwarmTopology as ValidationSwarmTopology, SwarmValidationResult, SwarmValidationSummary, SkillValidatorFn, SkillMetadata, TriggerAnalysisConfig, TriggerAnalysisResult, TriggerSuggestion, TriggerOptimizationReport, VersionComparisonConfig, SkillVersion, VersionComparisonResult, VersionResult, ComparisonStats, TestCaseComparison, } from './validation';
 export declare const VERSION: string;
-export declare const ARCHITECTURE = "DDD with 12 Bounded Contexts";
+export declare const ARCHITECTURE = "DDD with 13 Bounded Contexts";
 export declare const MAX_CONCURRENT_AGENTS = 15;
 /**
  * Quick start example:

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
  * Agentic QE v3 - Main Entry Point
- * Domain-Driven Design Architecture with 12 Bounded Contexts
+ * Domain-Driven Design Architecture with 13 Bounded Contexts
  */
 import { createRequire } from 'module';
 // Read version from package.json dynamically
@@ -79,7 +79,7 @@ TriggerOptimizer, createTriggerOptimizer, parseSkillFrontmatter,
 VersionComparator, createVersionComparator, } from './validation';
 // Version info - read from package.json
 export const VERSION = pkg.version;
-export const ARCHITECTURE = 'DDD with 12 Bounded Contexts';
+export const ARCHITECTURE = 'DDD with 13 Bounded Contexts';
 export const MAX_CONCURRENT_AGENTS = 15;
 /**
  * Quick start example:

package/dist/init/phases/12-verification.js

@@ -179,7 +179,7 @@ export class VerificationPhase extends BasePhase {
                     continue;
                 }
                 // Second-level key (2-space indent)
-                const subMatch = line.match(/^  (\w+):\s*(.*)$/);
+                const subMatch = line.match(/^ {2}(\w+):\s*(.*)$/);
                 if (subMatch && currentSection) {
                     currentSubSection = subMatch[1];
                     const value = subMatch[2].trim();
@@ -196,7 +196,7 @@ export class VerificationPhase extends BasePhase {
                 }
                 // Third-level key (4-space indent)
                 // Use [\w-]+ to match hyphenated keys like "pattern-consolidator"
-                const thirdMatch = line.match(/^    ([\w-]+):\s*(.*)$/);
+                const thirdMatch = line.match(/^ {4}([\w-]+):\s*(.*)$/);
                 if (thirdMatch && currentSection && currentSubSection) {
                     const key = thirdMatch[1];
                     const value = thirdMatch[2].trim();
@@ -210,7 +210,7 @@ export class VerificationPhase extends BasePhase {
                     continue;
                 }
                 // Array item (4-space indent with dash)
-                const arrayMatch = line.match(/^    - "?([^"]*)"?$/);
+                const arrayMatch = line.match(/^ {4}- "?([^"]*)"?$/);
                 if (arrayMatch && currentSection && currentSubSection) {
                     const section = result[currentSection];
                     if (!Array.isArray(section[currentSubSection])) {

package/dist/integrations/agentic-flow/model-router/router.js

@@ -375,7 +375,7 @@ export class ModelRouter {
         // Step 2: Analyze complexity
         const complexityAnalysis = await this.complexityAnalyzer.analyze(input);
         // Step 3: Get recommended tier from complexity
-        let recommendedTier = complexityAnalysis.recommendedTier;
+        const recommendedTier = complexityAnalysis.recommendedTier;
         // Step 4: Estimate cost for this tier
         const estimatedCostUsd = this.estimateCost(recommendedTier, input.task.length);
         // Step 5: Check budget

package/dist/integrations/embeddings/base/EmbeddingGenerator.js

@@ -208,17 +208,21 @@ export class EmbeddingGenerator {
                 return new Float32Array(vector.map((v) => Math.fround(v)));
             case 'int8':
                 // Quantize to int8 range [-128, 127]
-                const max = Math.max(...vector.map(Math.abs));
-                return new Int8Array(vector.map((v) => Math.round((v / max) * 127)));
+                {
+                    const max = Math.max(...vector.map(Math.abs));
+                    return new Int8Array(vector.map((v) => Math.round((v / max) * 127)));
+                }
             case 'binary':
                 // Binary quantization (sign bit only)
-                const binaryBytes = new Uint8Array(Math.ceil(vector.length / 8));
-                for (let i = 0; i < vector.length; i++) {
-                    if (vector[i] >= 0) {
-                        binaryBytes[Math.floor(i / 8)] |= 1 << (i % 8);
+                {
+                    const binaryBytes = new Uint8Array(Math.ceil(vector.length / 8));
+                    for (let i = 0; i < vector.length; i++) {
+                        if (vector[i] >= 0) {
+                            binaryBytes[Math.floor(i / 8)] |= 1 << (i % 8);
+                        }
                     }
+                    return binaryBytes;
                 }
-                return binaryBytes;
             case 'none':
             default:
                 return vector;

package/dist/integrations/ruvector/hypergraph-engine.js

@@ -657,8 +657,8 @@ export class HypergraphEngine {
         const startTime = Date.now();
         let nodesSynced = 0;
         let edgesSynced = 0;
-        let nodesAdded = 0;
-        let nodesRemoved = 0;
+        const nodesAdded = 0;
+        const nodesRemoved = 0;
         // Get all nodes from hypergraph
         const hgNodes = await this.findNodes({});
         for (const node of hgNodes) {

package/dist/integrations/ruvector/shared-rvf-adapter.js

@@ -10,6 +10,9 @@
  *
  * @module integrations/ruvector/shared-rvf-adapter
  */
+// Issue #516: lightweight, sqlite-free project-root resolver (static import so it
+// resolves under the test runner; avoids pulling unified-memory's sqlite graph).
+import { findProjectRoot } from '../../kernel/project-root.js';
 let sharedAdapter = null;
 let initAttempted = false;
 // ---------------------------------------------------------------------------
@@ -62,7 +65,15 @@ export function getSharedRvfAdapter(dataDir = '.agentic-qe', dimensions = 384) {
         }
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const path = require('path');
-        const rvfPath = path.join(dataDir, 'patterns.rvf');
+        // Issue #516: resolve a relative dataDir against the project root so the
+        // store lands in the project's own .agentic-qe/, not a cwd-relative one.
+        // A subfolder cwd (vendored builds, background workers, `aqe code index
+        // docs/`) otherwise scatters stray patterns.rvf-only stores. Explicit
+        // absolute dataDir args are honored as-is.
+        const baseDir = path.isAbsolute(dataDir)
+            ? dataDir
+            : path.join(process.env.AQE_PROJECT_ROOT ?? findProjectRoot(), dataDir);
+        const rvfPath = path.join(baseDir, 'patterns.rvf');
         // Open-or-create with a try-ladder rather than `existsSync` gate.
         // Reasons:
         //  1. RVF native's `RvfDatabase.create()` throws `0x0303 FsyncFailed`

package/dist/integrations/ruvector/shared-rvf-dual-writer.js

@@ -56,16 +56,20 @@ export async function getSharedRvfDualWriter() {
                 return null;
             }
             // Get DB handle from unified memory
-            const { getUnifiedMemory } = await import('../../kernel/unified-memory.js');
+            const { getUnifiedMemory, findProjectRoot } = await import('../../kernel/unified-memory.js');
             const unifiedMemory = getUnifiedMemory();
             const db = unifiedMemory.getDatabase();
             if (!db) {
                 return null;
             }
+            // Issue #516: anchor brain.rvf to the project root rather than a
+            // cwd-relative path, so a subfolder cwd doesn't scatter a stray store.
+            const { join: joinPath } = await import('node:path');
+            const rvfPath = joinPath(process.env.AQE_PROJECT_ROOT ?? findProjectRoot(), '.agentic-qe', 'brain.rvf');
             // Create dual-writer (dynamic import to avoid bundling .node files)
             const { RvfDualWriter: DualWriterClass } = await import('./rvf-dual-writer.js');
             const writer = new DualWriterClass(db, {
-                rvfPath: '.agentic-qe/brain.rvf',
+                rvfPath,
                 mode: 'dual-write',
                 dimensions: 384,
             });

package/dist/integrations/ruvector/spectral-math.js

@@ -114,7 +114,7 @@ export function approximateFiedlerValue(adjacency, n, maxIter = 100, tol = 1e-6)
     // The trivial eigenvector of L: normalized all-ones
     const trivial = new Float64Array(n).fill(1 / Math.sqrt(n));
     // First, estimate lambda_max using a few power iterations on L
-    let maxVec = new Float64Array(n);
+    const maxVec = new Float64Array(n);
     for (let i = 0; i < n; i++)
         maxVec[i] = Math.random() - 0.5;
     deflateVector(maxVec, trivial);
@@ -134,7 +134,7 @@ export function approximateFiedlerValue(adjacency, n, maxIter = 100, tol = 1e-6)
     // Now use power iteration on (lambdaMax * I - L) to find the
     // eigenvector corresponding to the LARGEST eigenvalue of (lambdaMax*I - L),
     // which corresponds to the SMALLEST non-trivial eigenvalue of L.
-    let v = new Float64Array(n);
+    const v = new Float64Array(n);
     for (let i = 0; i < n; i++)
         v[i] = Math.random() - 0.5;
     deflateVector(v, trivial);

package/dist/integrations/ruvector/spectral-sparsifier.js

@@ -276,7 +276,7 @@ export class SpectralSparsifier {
         // Use a different pattern for each deflation round to avoid
         // starting in the null-space of the deflated matrix
         const round = previousEigenvectors.length;
-        let v = new Array(n);
+        const v = new Array(n);
         for (let i = 0; i < n; i++) {
             v[i] = Math.sin((i + 1) * (round + 1) * 1.618033988749895) + 0.1 * (i - n / 2);
         }

package/dist/kernel/kernel.js

@@ -566,7 +566,7 @@ export class QEKernelImpl {
         const activeCount = this._coordinator.getActiveCount();
         // Get memory stats - handle both backend types
         let memUsed = 0;
-        let memAvailable = Number.MAX_SAFE_INTEGER;
+        const memAvailable = Number.MAX_SAFE_INTEGER;
         if (this._memory instanceof InMemoryBackend) {
             const memStats = this._memory.getStats();
             memUsed = memStats.entries + memStats.vectors;

package/dist/kernel/project-root.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Project Root Detection
+ *
+ * Lightweight, dependency-free resolution of the AQE project root. Kept in its
+ * own module (no SQLite / kernel imports) so hot paths — e.g. the RVF pattern
+ * store factory — can import it statically without dragging in the sqlite-heavy
+ * unified-memory graph, and so it resolves cleanly under the test runner.
+ *
+ * `unified-memory` re-exports `findProjectRoot` / `clearProjectRootCache` for
+ * backward compatibility, so existing import sites keep working.
+ *
+ * @module kernel/project-root
+ */
+/**
+ * Clear the cached project root. Useful for testing or when the
+ * environment changes at runtime.
+ */
+export declare function clearProjectRootCache(): void;
+/**
+ * Find the project root by walking up the directory tree.
+ *
+ * Priority order:
+ * 1. AQE_PROJECT_ROOT environment variable (set by MCP config or init)
+ * 2. Walk up looking for the NEAREST .agentic-qe directory (existing AQE project)
+ * 3. Walk up looking for .git directory (git repo root)
+ * 4. Walk up looking for package.json WITHOUT node_modules sibling (monorepo root)
+ * 5. Fallback to current working directory
+ *
+ * Optimized: single upward walk checks all markers in one pass,
+ * and the result is cached at module level for subsequent calls.
+ */
+export declare function findProjectRoot(startDir?: string): string;
+//# sourceMappingURL=project-root.d.ts.map

package/dist/kernel/project-root.js

@@ -0,0 +1,86 @@
+/**
+ * Project Root Detection
+ *
+ * Lightweight, dependency-free resolution of the AQE project root. Kept in its
+ * own module (no SQLite / kernel imports) so hot paths — e.g. the RVF pattern
+ * store factory — can import it statically without dragging in the sqlite-heavy
+ * unified-memory graph, and so it resolves cleanly under the test runner.
+ *
+ * `unified-memory` re-exports `findProjectRoot` / `clearProjectRootCache` for
+ * backward compatibility, so existing import sites keep working.
+ *
+ * @module kernel/project-root
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/** Module-level cache for findProjectRoot result. */
+let _cachedProjectRoot = null;
+/**
+ * Clear the cached project root. Useful for testing or when the
+ * environment changes at runtime.
+ */
+export function clearProjectRootCache() {
+    _cachedProjectRoot = null;
+}
+/**
+ * Find the project root by walking up the directory tree.
+ *
+ * Priority order:
+ * 1. AQE_PROJECT_ROOT environment variable (set by MCP config or init)
+ * 2. Walk up looking for the NEAREST .agentic-qe directory (existing AQE project)
+ * 3. Walk up looking for .git directory (git repo root)
+ * 4. Walk up looking for package.json WITHOUT node_modules sibling (monorepo root)
+ * 5. Fallback to current working directory
+ *
+ * Optimized: single upward walk checks all markers in one pass,
+ * and the result is cached at module level for subsequent calls.
+ */
+export function findProjectRoot(startDir = process.cwd()) {
+    if (_cachedProjectRoot) {
+        return _cachedProjectRoot;
+    }
+    if (process.env.AQE_PROJECT_ROOT) {
+        _cachedProjectRoot = process.env.AQE_PROJECT_ROOT;
+        return _cachedProjectRoot;
+    }
+    const dir = startDir;
+    const root = path.parse(dir).root;
+    let checkDir = dir;
+    let nearestAqeDir = null;
+    let lowestGitDir = null;
+    let topmostPackageJson = null;
+    while (checkDir !== root) {
+        // Issue #516: prefer the NEAREST (lowest) .agentic-qe, mirroring the
+        // .git logic below. Keeping the topmost match let an ancestor store
+        // (e.g. ~/.agentic-qe, created by any `aqe` run from $HOME) hijack
+        // every descendant project and fragment its learning into $HOME.
+        if (fs.existsSync(path.join(checkDir, '.agentic-qe'))) {
+            if (nearestAqeDir === null) {
+                nearestAqeDir = checkDir;
+            }
+        }
+        if (fs.existsSync(path.join(checkDir, '.git'))) {
+            if (lowestGitDir === null) {
+                lowestGitDir = checkDir;
+            }
+        }
+        if (fs.existsSync(path.join(checkDir, 'package.json'))) {
+            topmostPackageJson = checkDir;
+        }
+        checkDir = path.dirname(checkDir);
+    }
+    if (nearestAqeDir) {
+        _cachedProjectRoot = nearestAqeDir;
+    }
+    else if (lowestGitDir) {
+        _cachedProjectRoot = lowestGitDir;
+    }
+    else if (topmostPackageJson) {
+        _cachedProjectRoot = topmostPackageJson;
+    }
+    else {
+        _cachedProjectRoot = process.cwd();
+    }
+    return _cachedProjectRoot;
+}
+//# sourceMappingURL=project-root.js.map

package/dist/kernel/unified-memory-hnsw.js

@@ -76,6 +76,7 @@ export class BinaryHeap {
     }
     sinkDown(i) {
         const n = this.data.length;
+        // eslint-disable-next-line no-constant-condition -- heap sift-down; loop breaks internally
         while (true) {
             let smallest = i;
             const left = 2 * i + 1;

package/dist/kernel/unified-memory.d.ts

@@ -25,25 +25,8 @@ import { type Database as DatabaseType, type Statement } from 'better-sqlite3';
 export { validateTableName, ALLOWED_TABLE_NAMES } from '../shared/sql-safety.js';
 export { BinaryHeap, UnifiedHnswIndex, createHnswIndex } from './unified-memory-hnsw.js';
 import { type CRDTStore, type CRDTStoreState, type CRDTStoreDelta } from '../memory/crdt/index.js';
-/**
- * Clear the cached project root. Useful for testing or when the
- * environment changes at runtime.
- */
-export declare function clearProjectRootCache(): void;
-/**
- * Find the project root by walking up the directory tree.
- *
- * Priority order:
- * 1. AQE_PROJECT_ROOT environment variable (set by MCP config or init)
- * 2. Walk up looking for .agentic-qe directory (existing AQE project)
- * 3. Walk up looking for .git directory (git repo root)
- * 4. Walk up looking for package.json WITHOUT node_modules sibling (monorepo root)
- * 5. Fallback to current working directory
- *
- * Optimized: single upward walk checks all markers in one pass,
- * and the result is cached at module level for subsequent calls.
- */
-export declare function findProjectRoot(startDir?: string): string;
+import { findProjectRoot, clearProjectRootCache } from './project-root.js';
+export { findProjectRoot, clearProjectRootCache };
 /**
  * Get the default database path using project root detection.
  * Always resolves to {project_root}/.agentic-qe/memory.db