agentic-qe 3.10.2 → 3.10.3

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

@@ -9,6 +9,9 @@ import { FileReader } from '../../../shared/io';
 import { NomicEmbedder } from '../../../shared/embeddings';
 import { toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
+import { existsSync, statSync } from 'fs';
+import { dirname, resolve as resolvePath, join as joinPath } from 'path';
+import { extractTsJs } from '../../../shared/parsers/treesitter-ts-extractor.js';
 const DEFAULT_CONFIG = {
     maxNodes: 100000,
     maxEdgesPerNode: 500,
@@ -26,11 +29,25 @@ const DEFAULT_CONFIG = {
  * ADR-051: Added LLM enhancement for AI-powered knowledge extraction
  */
 const logger = LoggerFactory.create('code-intelligence/knowledge-graph');
+/**
+ * File extensions for which the knowledge graph has a real entity/import
+ * extractor (the TypeScript Compiler API). Files outside this set are indexed
+ * as bare file nodes with no dependency edges — `index` warns about them so the
+ * downstream 0-edge result in `deps` is not silently misleading (#511 req #2).
+ */
+const DEP_EXTRACTOR_EXTENSIONS = new Set(['ts', 'tsx', 'js', 'jsx']);
 export class KnowledgeGraphService {
     config;
     memory;
     nodeCache = new Map();
     edgeIndex = new Map();
+    /**
+     * Lazily-hydrated flat list of all persisted edges (#511).
+     * Edges are persisted per-process during index(); cross-process reads
+     * (deps/search/impact) hydrate this once and filter by source/target.
+     * Invalidated on createEdge()/clear() to avoid serving stale data.
+     */
+    allEdgesCache;
     tsParser;
     fileReader;
     embedder;
@@ -66,6 +83,18 @@ export class KnowledgeGraphService {
     isKnowledgeGraphDependencies(arg) {
         return arg.memory !== undefined;
     }
+    /**
+     * Storage options that pin every KG kv operation to a fixed, tool-independent
+     * namespace (the configured `code-intelligence:kg`) instead of the backend's
+     * default (`qe-kernel` for the CLI, `mcp-tools` for MCP). This gives CLI↔MCP
+     * parity — a graph indexed by one tool is readable by the other — and makes
+     * the init existence checks (`SELECT ... WHERE namespace = 'code-intelligence:kg'`)
+     * actually find the data (#511). Reads and writes MUST both pass this, or a
+     * write under the namespace cannot be read back (issue #491 Bug 2).
+     */
+    get nsOpts() {
+        return { namespace: this.config.namespace };
+    }
     /**
      * Index files into the knowledge graph
      */
@@ -74,6 +103,10 @@ export class KnowledgeGraphService {
         const errors = [];
         let nodesCreated = 0;
         let edgesCreated = 0;
+        // #511 req #2: count files indexed under a language with no dependency
+        // extractor, keyed by extension, so we can warn loudly instead of silently
+        // reporting a graph that `deps` then shows as 0 edges.
+        const unsupportedByExt = new Map();
         try {
             const { paths, incremental = false, includeTests = true, languages } = request;
             // Clear existing graph if not incremental
@@ -93,8 +126,12 @@ export class KnowledgeGraphService {
                     if (!includeTests && this.isTestFile(path)) {
                         continue;
                     }
+                    const ext = this.getFileExtension(path);
+                    if (!DEP_EXTRACTOR_EXTENSIONS.has(ext)) {
+                        unsupportedByExt.set(ext || '(none)', (unsupportedByExt.get(ext || '(none)') ?? 0) + 1);
+                    }
                     // Index the file
-                    const result = await this.indexFile(path);
+                    const result = await this.indexFile(path, incremental);
                     nodesCreated += result.nodes;
                     edgesCreated += result.edges;
                 }
@@ -106,6 +143,19 @@ export class KnowledgeGraphService {
                 }
             }
             const duration = Date.now() - startTime;
+            // #511 req #2: surface a loud warning for unsupported languages so the
+            // caller understands why `deps`/`impact` will be empty for those files.
+            const warnings = [];
+            if (unsupportedByExt.size > 0) {
+                const supported = Array.from(DEP_EXTRACTOR_EXTENSIONS).join(', ');
+                for (const [ext, count] of unsupportedByExt) {
+                    const msg = `${count} file(s) with extension '.${ext}' were indexed as plain ` +
+                        `nodes: no dependency extractor for this language, so 'deps'/'impact' ` +
+                        `will report 0 edges for them. Supported: ${supported}.`;
+                    warnings.push(msg);
+                    logger.warn(msg);
+                }
+            }
             // Store indexing metadata
             await this.storeIndexMetadata({
                 filesIndexed: paths.length - errors.length,
@@ -120,6 +170,7 @@ export class KnowledgeGraphService {
                 edgesCreated,
                 duration,
                 errors,
+                warnings,
             });
         }
         catch (error) {
@@ -180,7 +231,7 @@ export class KnowledgeGraphService {
         }
         // Load from memory
         const key = `${this.config.namespace}:node:${nodeId}`;
-        const node = await this.memory.get(key);
+        const node = await this.memory.get(key, this.nsOpts);
         if (node) {
             this.nodeCache.set(nodeId, node);
         }
@@ -190,34 +241,83 @@ export class KnowledgeGraphService {
      * Get edges for a node
      */
     async getEdges(nodeId, direction) {
-        const edges = [];
-        // Check index first
-        const cachedEdges = this.edgeIndex.get(nodeId);
-        if (cachedEdges) {
-            return this.filterEdgesByDirection(cachedEdges, nodeId, direction);
+        // Hydrate the full edge set from persistence once, then filter in-memory.
+        // This is required for cross-process reads (deps/search run as separate
+        // CLI processes from index) and for correct incoming/both lookups, which
+        // the old source-keyed edgeIndex could not serve (#511).
+        const allEdges = await this.loadAllEdges();
+        return this.filterEdgesByDirection(allEdges, nodeId, direction);
+    }
+    /**
+     * Load all persisted edges into a flat cache (#511).
+     * Cached for the lifetime of the read; invalidated by createEdge()/clear().
+     */
+    async loadAllEdges() {
+        if (this.allEdgesCache) {
+            return this.allEdgesCache;
         }
-        // Load from memory
+        const edges = [];
         const pattern = `${this.config.namespace}:edge:*`;
-        const keys = await this.memory.search(pattern, this.config.maxEdgesPerNode * 2);
+        const keys = await this.memory.search(pattern, Number.MAX_SAFE_INTEGER, this.nsOpts);
         for (const key of keys) {
-            const edge = await this.memory.get(key);
+            const edge = await this.memory.get(key, this.nsOpts);
             if (edge) {
-                const matches = (direction !== 'outgoing' && edge.target === nodeId) ||
-                    (direction !== 'incoming' && edge.source === nodeId);
-                if (matches) {
-                    edges.push(edge);
-                }
+                edges.push(edge);
             }
         }
+        this.allEdgesCache = edges;
         return edges;
     }
     /**
      * Clear the knowledge graph
      */
     async clear() {
-        // Cache-only: just clear in-memory caches, no kv_store cleanup needed
         this.nodeCache.clear();
         this.edgeIndex.clear();
+        this.allEdgesCache = undefined;
+        // Delete persisted nodes/edges so a non-incremental re-index does not
+        // accumulate stale graph state across runs (#511). Scoped to the KG
+        // namespace's :node:/:edge: keys only — never touches learning data.
+        for (const prefix of [
+            `${this.config.namespace}:node:`,
+            `${this.config.namespace}:edge:`,
+        ]) {
+            const keys = await this.memory.search(`${prefix}*`, Number.MAX_SAFE_INTEGER, this.nsOpts);
+            for (const key of keys) {
+                await this.memory.delete(key, this.nsOpts);
+            }
+        }
+    }
+    /**
+     * Remove a single file's contribution to the graph (#511).
+     *
+     * Deletes the file node, its entity nodes, and edges that ORIGINATE from the
+     * file or its entities (contains + outgoing imports). Incoming edges (other
+     * files importing this one) are left intact — they belong to those files and
+     * remain valid until those files are themselves re-indexed. Used for
+     * incremental re-indexing so stale entities/imports don't persist.
+     */
+    async removeFileFromGraph(filePath) {
+        const fileNodeId = this.pathToNodeId(filePath);
+        const ns = this.config.namespace;
+        // Delete the file node and all of its entity nodes (`:node:<file>` and
+        // `:node:<file>:<type>:<name>`).
+        const nodeKeys = await this.memory.search(`${ns}:node:${fileNodeId}*`, Number.MAX_SAFE_INTEGER, this.nsOpts);
+        for (const key of nodeKeys) {
+            await this.memory.delete(key, this.nsOpts);
+            this.nodeCache.delete(key.slice(`${ns}:node:`.length));
+        }
+        // Delete edges whose source is the file node or one of its entity nodes.
+        const edgeKeys = await this.memory.search(`${ns}:edge:*`, Number.MAX_SAFE_INTEGER, this.nsOpts);
+        for (const key of edgeKeys) {
+            const edge = await this.memory.get(key, this.nsOpts);
+            if (edge && (edge.source === fileNodeId || edge.source.startsWith(`${fileNodeId}:`))) {
+                await this.memory.delete(key, this.nsOpts);
+            }
+        }
+        // Drop the file's source-keyed cache entry and invalidate the flat cache.
+        this.edgeIndex.delete(fileNodeId);
+        this.allEdgesCache = undefined;
     }
     // ============================================================================
     // ADR-051: LLM Enhancement Methods
@@ -409,9 +509,22 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
     // ============================================================================
     // Private Helper Methods
     // ============================================================================
-    async indexFile(filePath) {
+    async indexFile(filePath, incremental = false) {
         let nodesCreated = 0;
         let edgesCreated = 0;
+        // #511: evict any cached content for this file before reading it. The
+        // FileReader caches content for 5 min, so in a long-lived process (e.g. the
+        // MCP server) a re-index would otherwise extract entities/imports from the
+        // 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);
+        // #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.)
+        if (incremental) {
+            await this.removeFileFromGraph(filePath);
+        }
         // Create file node
         const fileNode = await this.createFileNode(filePath);
         nodesCreated++;
@@ -428,8 +541,12 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
         // Extract imports/dependencies
         const imports = await this.extractImports(filePath);
         for (const importPath of imports) {
-            // Create dependency edge
-            const targetNodeId = this.pathToNodeId(importPath);
+            // Resolve relative specifiers to the actual file so the import edge
+            // targets the imported file's node id (#511). Without this, an edge to
+            // './math' never matches the '/abs/path/math.ts' file node and the
+            // dependency graph stays disconnected (all nodes degree-0).
+            const resolvedPath = this.resolveImportPath(importPath, filePath);
+            const targetNodeId = this.pathToNodeId(resolvedPath);
             await this.createEdge(fileNode.id, targetNodeId, 'import');
             edgesCreated++;
         }
@@ -519,11 +636,14 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
             target: targetId,
             type,
         };
-        // Cache-only: no kv_store persistence needed, KG is rebuilt from source on each init
-        // Update edge index
+        // Update in-memory edge index (source-keyed, used during same-process index)
         const sourceEdges = this.edgeIndex.get(sourceId) || [];
         sourceEdges.push(edge);
         this.edgeIndex.set(sourceId, sourceEdges);
+        // Persist so cross-process reads (deps/search/impact) see the graph (#511).
+        await this.memory.set(`${this.config.namespace}:edge:${edgeId}`, edge, this.nsOpts);
+        // Invalidate hydrated read cache so subsequent getEdges() reflects this write.
+        this.allEdgesCache = undefined;
         return edge;
     }
     async storeNode(node) {
@@ -537,70 +657,67 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
                 this.edgeIndex.delete(firstKey);
             }
         }
-        // Cache-only: KG is rebuilt from source on each init, no need for kv_store persistence
         this.nodeCache.set(node.id, node);
+        // Persist so cross-process reads (deps/search/impact) see the graph (#511).
+        await this.memory.set(`${this.config.namespace}:node:${node.id}`, node, this.nsOpts);
     }
     async extractEntities(filePath) {
         const extension = this.getFileExtension(filePath);
         const entities = [];
-        // Use TypeScript parser for TS/JS files
-        if (['ts', 'tsx', 'js', 'jsx'].includes(extension)) {
+        // TS/JS files: prefer the bundled tree-sitter WASM grammars (typescript-free,
+        // works out of the box), and fall back to the TypeScript compiler API only if
+        // tree-sitter is unavailable AND `typescript` happens to be installed (#511).
+        if (DEP_EXTRACTOR_EXTENSIONS.has(extension)) {
             const fileResult = await this.fileReader.readFile(filePath);
+            const fileName = this.getFileName(filePath);
             if (fileResult.success) {
-                const fileName = this.getFileName(filePath);
-                const ast = this.tsParser.parseFile(fileName, fileResult.value);
-                // Extract functions
-                const functions = this.tsParser.extractFunctions(ast);
-                for (const func of functions) {
-                    entities.push({
-                        type: 'function',
-                        name: func.name,
-                        line: func.startLine,
-                        visibility: 'public',
-                        isAsync: func.isAsync,
-                    });
-                }
-                // Extract classes
-                const classes = this.tsParser.extractClasses(ast);
-                for (const cls of classes) {
-                    entities.push({
-                        type: 'class',
-                        name: cls.name,
-                        line: cls.startLine,
-                        visibility: 'public',
-                        isAsync: false,
-                    });
-                    // Add class methods as entities
-                    for (const method of cls.methods) {
-                        entities.push({
-                            type: 'function',
-                            name: `${cls.name}.${method.name}`,
-                            line: method.startLine,
-                            visibility: method.visibility,
-                            isAsync: method.isAsync,
-                        });
+                let extracted = false;
+                // Primary: tree-sitter
+                try {
+                    const ts = await extractTsJs(fileResult.value, extension);
+                    if (ts) {
+                        for (const f of ts.functions) {
+                            entities.push({ type: 'function', name: f.name, line: f.startLine, visibility: f.visibility, isAsync: f.isAsync });
+                        }
+                        for (const c of ts.classes) {
+                            entities.push({ type: 'class', name: c.name, line: c.startLine, visibility: 'public', isAsync: false });
+                            for (const m of c.methods) {
+                                entities.push({ type: 'function', name: `${c.name}.${m.name}`, line: m.startLine, visibility: m.visibility, isAsync: m.isAsync });
+                            }
+                        }
+                        for (const iface of ts.interfaces) {
+                            entities.push({ type: 'interface', name: iface.name, line: iface.startLine, visibility: 'public', isAsync: false });
+                        }
+                        extracted = true;
                     }
                 }
-                // Extract interfaces
-                const interfaces = this.tsParser.extractInterfaces(ast);
-                for (const iface of interfaces) {
-                    entities.push({
-                        type: 'interface',
-                        name: iface.name,
-                        line: iface.startLine,
-                        visibility: 'public',
-                        isAsync: false,
-                    });
+                catch {
+                    // tree-sitter unavailable — fall through to the TS compiler path
                 }
-                // If no entities found, create a module entity for the file
+                // Fallback: TypeScript compiler API (only when tree-sitter didn't run).
+                if (!extracted) {
+                    try {
+                        const ast = this.tsParser.parseFile(fileName, fileResult.value);
+                        for (const func of this.tsParser.extractFunctions(ast)) {
+                            entities.push({ type: 'function', name: func.name, line: func.startLine, visibility: 'public', isAsync: func.isAsync });
+                        }
+                        for (const cls of this.tsParser.extractClasses(ast)) {
+                            entities.push({ type: 'class', name: cls.name, line: cls.startLine, visibility: 'public', isAsync: false });
+                            for (const method of cls.methods) {
+                                entities.push({ type: 'function', name: `${cls.name}.${method.name}`, line: method.startLine, visibility: method.visibility, isAsync: method.isAsync });
+                            }
+                        }
+                        for (const iface of this.tsParser.extractInterfaces(ast)) {
+                            entities.push({ type: 'interface', name: iface.name, line: iface.startLine, visibility: 'public', isAsync: false });
+                        }
+                    }
+                    catch {
+                        // Neither tree-sitter nor the TypeScript compiler is available.
+                    }
+                }
+                // If nothing was extracted, record a module entity for the file.
                 if (entities.length === 0) {
-                    entities.push({
-                        type: 'module',
-                        name: fileName.replace(/\.[^.]+$/, ''),
-                        line: 1,
-                        visibility: 'public',
-                        isAsync: false,
-                    });
+                    entities.push({ type: 'module', name: fileName.replace(/\.[^.]+$/, ''), line: 1, visibility: 'public', isAsync: false });
                 }
             }
             else {
@@ -700,19 +817,35 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
     async extractImports(filePath) {
         const extension = this.getFileExtension(filePath);
         const importPaths = [];
-        // Use TypeScript parser for TS/JS files
-        if (['ts', 'tsx', 'js', 'jsx'].includes(extension)) {
+        // TS/JS: tree-sitter primary (typescript-free), TS compiler fallback (#511).
+        if (DEP_EXTRACTOR_EXTENSIONS.has(extension)) {
             const fileResult = await this.fileReader.readFile(filePath);
             if (fileResult.success) {
                 const fileName = this.getFileName(filePath);
-                const ast = this.tsParser.parseFile(fileName, fileResult.value);
-                const imports = this.tsParser.extractImports(ast);
-                // Extract import sources (module property in new API)
-                for (const importInfo of imports) {
-                    // Only include relative imports and package imports
+                let modules = null;
+                // Primary: tree-sitter
+                try {
+                    const ts = await extractTsJs(fileResult.value, extension);
+                    if (ts)
+                        modules = ts.imports;
+                }
+                catch {
+                    modules = null;
+                }
+                // Fallback: TypeScript compiler API
+                if (modules === null) {
+                    try {
+                        const ast = this.tsParser.parseFile(fileName, fileResult.value);
+                        modules = this.tsParser.extractImports(ast).map((i) => i.module);
+                    }
+                    catch {
+                        modules = [];
+                    }
+                }
+                for (const module of modules) {
                     // Skip node built-ins for now
-                    if (!importInfo.module.startsWith('node:')) {
-                        importPaths.push(importInfo.module);
+                    if (!module.startsWith('node:')) {
+                        importPaths.push(module);
                     }
                 }
             }
@@ -807,9 +940,9 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
     async findNodesByLabel(label, limit) {
         const nodes = [];
         const pattern = `${this.config.namespace}:node:*`;
-        const keys = await this.memory.search(pattern, limit * 2);
+        const keys = await this.memory.search(pattern, limit * 2, this.nsOpts);
         for (const key of keys) {
-            const node = await this.memory.get(key);
+            const node = await this.memory.get(key, this.nsOpts);
             if (node && node.label === label) {
                 nodes.push(node);
                 if (nodes.length >= limit)
@@ -847,10 +980,10 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
         // Fallback to keyword matching
         const keywords = query.toLowerCase().split(/\s+/);
         const pattern = `${this.config.namespace}:node:*`;
-        const keys = await this.memory.search(pattern, limit * 3);
+        const keys = await this.memory.search(pattern, limit * 3, this.nsOpts);
         const nodes = [];
         for (const key of keys) {
-            const node = await this.memory.get(key);
+            const node = await this.memory.get(key, this.nsOpts);
             if (node) {
                 const nodeText = JSON.stringify(node.properties).toLowerCase();
                 if (keywords.some((kw) => nodeText.includes(kw))) {
@@ -882,7 +1015,12 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
         visited.add(file);
         path.push(file);
         const nodeId = this.pathToNodeId(file);
-        const fileEdges = await this.getEdges(nodeId, direction);
+        // Only true dependency edges (import/call/extends/implements) belong in a
+        // dependency map — exclude structural 'contains' (file→entity) edges so the
+        // graph stays a file-to-file dependency view and entities don't leak in as
+        // pseudo file nodes (#511).
+        const DEPENDENCY_EDGE_TYPES = new Set(['import', 'call', 'extends', 'implements']);
+        const fileEdges = (await this.getEdges(nodeId, direction)).filter((e) => DEPENDENCY_EDGE_TYPES.has(e.type));
         // Create dependency node
         const inDegree = fileEdges.filter((e) => e.target === nodeId).length;
         const outDegree = fileEdges.filter((e) => e.source === nodeId).length;
@@ -903,10 +1041,15 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
             if (!edges.some((e) => e.source === depEdge.source && e.target === depEdge.target)) {
                 edges.push(depEdge);
             }
-            // Recursively traverse
-            const nextFile = edge.source === nodeId
-                ? this.nodeIdToPath(edge.target)
-                : this.nodeIdToPath(edge.source);
+            // Recurse only along directed-forward (outgoing) edges so the traversal
+            // path represents a real directed dependency chain. Following 'both'
+            // adjacency backwards fabricated cycles like A→B→A (#511). Incoming
+            // neighbours are still surfaced as edges/degrees above and are visited
+            // as their own top-level entries.
+            if (edge.source !== nodeId) {
+                continue;
+            }
+            const nextFile = this.nodeIdToPath(edge.target);
             if (nextFile) {
                 await this.traverseDependencies(nextFile, direction, depth - 1, visited, nodes, edges, path, cycles);
             }
@@ -968,7 +1111,8 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
                 return edge.target === nodeId;
             if (direction === 'outgoing')
                 return edge.source === nodeId;
-            return true;
+            // 'both': edge touches nodeId on either end
+            return edge.source === nodeId || edge.target === nodeId;
         });
     }
     async storeIndexMetadata(_metadata) {
@@ -1015,6 +1159,47 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
     pathToNodeId(path) {
         return path.replace(/[/\\]/g, ':').replace(/\./g, '_');
     }
+    /**
+     * Resolve an import specifier to a concrete file path (#511).
+     *
+     * Relative specifiers ('./math', '../util') are resolved against the
+     * importing file's directory and probed for the usual TS/JS extensions and
+     * index files, so the resulting node id matches the imported file's node.
+     * Bare package specifiers ('react', '@scope/pkg') are returned unchanged and
+     * become external dependency nodes.
+     */
+    resolveImportPath(importPath, fromFile) {
+        if (!importPath.startsWith('.')) {
+            return importPath;
+        }
+        const base = resolvePath(dirname(fromFile), importPath);
+        const candidates = [
+            base,
+            `${base}.ts`,
+            `${base}.tsx`,
+            `${base}.js`,
+            `${base}.jsx`,
+            `${base}.mjs`,
+            `${base}.cjs`,
+            joinPath(base, 'index.ts'),
+            joinPath(base, 'index.tsx'),
+            joinPath(base, 'index.js'),
+            joinPath(base, 'index.jsx'),
+        ];
+        for (const candidate of candidates) {
+            try {
+                if (existsSync(candidate) && statSync(candidate).isFile()) {
+                    return candidate;
+                }
+            }
+            catch {
+                // ignore unreadable candidates and keep probing
+            }
+        }
+        // Fall back to a '.ts' sibling so extensionless imports still link to a
+        // stable node id even when the file cannot be found on disk.
+        return `${base}.ts`;
+    }
     nodeIdToPath(nodeId) {
         // Reverse the nodeId transformation
         const path = nodeId.replace(/:/g, '/').replace(/_(?=[^_]*$)/, '.');

package/dist/domains/code-intelligence/services/semantic-analyzer.js

@@ -105,8 +105,14 @@ export class SemanticAnalyzerService {
                 ...metadata,
                 indexedAt: new Date().toISOString(),
             });
-            // Store content for retrieval
-            await this.memory.set(`${this.config.namespace}:content:${this.fileToKey(file)}`, { file, content, metadata }, { namespace: this.config.namespace });
+            // Store content for retrieval.
+            // The key is already fully namespace-qualified, so do NOT also pass a
+            // {namespace} store option: every read path (semanticSearch/findSimilar/
+            // exact/fuzzy) and the storeVector() embedding write use the default
+            // namespace, and a write with {namespace} could not be read back without
+            // the same option (issue #491 Bug 2) — which silently dropped every
+            // search result (#511 follow-up).
+            await this.memory.set(`${this.config.namespace}:content:${this.fileToKey(file)}`, { file, content, metadata });
             return ok(undefined);
         }
         catch (error) {

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

@@ -859,7 +859,7 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
             // Get SARSA prediction for ordering strategy
             const prediction = await this.sarsaAlgorithm.predict(state);
             // Apply the suggested ordering strategy
-            let prioritized = [...contracts];
+            const prioritized = [...contracts];
             let strategy = 'default';
             switch (prediction.action.type) {
                 case 'sequence-early':

package/dist/domains/coverage-analysis/coordinator.js

@@ -682,8 +682,10 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
             case 'daily':
                 return `${year}-${month}-${day}`;
             case 'weekly':
-                const weekNum = Math.floor(day / 7);
-                return `${year}-${month}-W${weekNum}`;
+                {
+                    const weekNum = Math.floor(day / 7);
+                    return `${year}-${month}-W${weekNum}`;
+                }
             case 'monthly':
                 return `${year}-${month}`;
         }

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

@@ -12,6 +12,7 @@ import { LearningOptimizationEvents, createEvent, } from '../../shared/events/do
 import { LearningCoordinatorService, TransferSpecialistService, MetricsOptimizerService, ProductionIntelService, } from './services/index.js';
 import { createPersistentSONAEngine, } from '../../integrations/ruvector/sona-persistence.js';
 import { createDreamScheduler, createDreamEngine, } from '../../learning/dream/index.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';
 // CQ-004: Extracted modules