agentic-qe 3.10.1 → 3.10.3

package/dist/coordination/consensus/providers/ollama-provider.d.ts

@@ -76,7 +76,7 @@ export declare function getCodeOllamaModels(): OllamaModel[];
 export declare class OllamaModelProvider extends BaseModelProvider {
     readonly id: string;
     readonly name: string;
-    readonly type: 'ollama';
+    readonly type: "ollama";
     protected costPerToken: {
         input: number;
         output: number;

package/dist/coordination/consensus/providers/openrouter-provider.d.ts

@@ -76,7 +76,7 @@ export declare function getCostOptimizedModels(): OpenRouterModel[];
 export declare class OpenRouterModelProvider extends BaseModelProvider {
     readonly id: string;
     readonly name: string;
-    readonly type: 'openrouter';
+    readonly type: "openrouter";
     protected costPerToken: {
         input: number;
         output: number;

package/dist/coordination/handlers/code-intelligence-handlers.js

@@ -67,11 +67,17 @@ export function registerCodeIntelligenceHandlers(ctx) {
                 filesIndexed: indexResult.filesIndexed,
                 nodesCreated: indexResult.nodesCreated,
                 edgesCreated: indexResult.edgesCreated,
+                // MCP CodeIndexResult reports symbols/relations; map them from the KG's
+                // node/edge counts so `code_index` doesn't always report 0 (#511 MCP
+                // parity — the result mapper reads these exact field names).
+                symbolsExtracted: indexResult.nodesCreated,
+                relationsFound: indexResult.edgesCreated,
                 target: targetPath,
                 incremental: payload.incremental || false,
                 languages: Array.from(detectedLanguages),
                 duration: indexResult.duration,
                 errors: indexResult.errors,
+                warnings: indexResult.warnings,
             });
         }
         catch (error) {

package/dist/coordination/mincut/neural-goap.js

@@ -881,14 +881,16 @@ export class GOAPController {
                 return { success: true, newState: action.simulate(state) };
             case 'terminate_agent':
                 // Find and remove least connected agent
-                const weakVertices = this.calculator.findWeakVertices(this.graph);
-                if (weakVertices.length > 0) {
-                    const weakestAgent = weakVertices.find((v) => v.vertex.type === 'agent');
-                    if (weakestAgent) {
-                        this.graph.removeVertex(weakestAgent.vertexId);
+                {
+                    const weakVertices = this.calculator.findWeakVertices(this.graph);
+                    if (weakVertices.length > 0) {
+                        const weakestAgent = weakVertices.find((v) => v.vertex.type === 'agent');
+                        if (weakestAgent) {
+                            this.graph.removeVertex(weakestAgent.vertexId);
+                        }
                     }
+                    return { success: true, newState: action.simulate(state) };
                 }
-                return { success: true, newState: action.simulate(state) };
             case 'heal_topology':
                 // Delegate to Strange Loop
                 if (this.strangeLoop && this.strangeLoop.isRunning()) {
@@ -897,22 +899,24 @@ export class GOAPController {
                 return { success: true, newState: action.simulate(state) };
             case 'rebalance_load':
                 // Reinforce edges between agents
-                const agents = this.graph.getVerticesByType('agent');
-                if (agents.length >= 2) {
-                    const sorted = agents.sort((a, b) => this.graph.weightedDegree(a.id) - this.graph.weightedDegree(b.id));
-                    const weak = sorted[0];
-                    const strong = sorted[sorted.length - 1];
-                    if (!this.graph.hasEdge(weak.id, strong.id)) {
-                        this.graph.addEdge({
-                            source: weak.id,
-                            target: strong.id,
-                            weight: 0.5,
-                            type: 'coordination',
-                            bidirectional: true,
-                        });
+                {
+                    const agents = this.graph.getVerticesByType('agent');
+                    if (agents.length >= 2) {
+                        const sorted = agents.sort((a, b) => this.graph.weightedDegree(a.id) - this.graph.weightedDegree(b.id));
+                        const weak = sorted[0];
+                        const strong = sorted[sorted.length - 1];
+                        if (!this.graph.hasEdge(weak.id, strong.id)) {
+                            this.graph.addEdge({
+                                source: weak.id,
+                                target: strong.id,
+                                weight: 0.5,
+                                type: 'coordination',
+                                bidirectional: true,
+                            });
+                        }
                     }
+                    return { success: true, newState: action.simulate(state) };
                 }
-                return { success: true, newState: action.simulate(state) };
             case 'optimize_tests':
             case 'retry_failures':
                 // Simulated execution

package/dist/coordination/protocols/code-intelligence-index.js

@@ -348,8 +348,10 @@ export class CodeIntelligenceIndexProtocol {
                 return this.detectChanges();
             case 'manual':
                 // Full reindex - use provided paths or default
-                const paths = trigger.paths || ['src/**', 'lib/**'];
-                return this.resolveGlobPatterns(paths);
+                {
+                    const paths = trigger.paths || ['src/**', 'lib/**'];
+                    return this.resolveGlobPatterns(paths);
+                }
             default:
                 return err(new Error(`Unknown trigger type: ${trigger.type}`));
         }
@@ -441,15 +443,17 @@ export class CodeIntelligenceIndexProtocol {
         switch (domain) {
             case 'test-generation':
                 // Notify about files needing new tests
-                const filesNeedingTests = changedFiles.filter((f) => !this.isTestFile(f) && !impact.impactedTests.some((t) => this.isTestForFile(t, f)));
-                if (filesNeedingTests.length === 0)
-                    return null;
-                return {
-                    type: 'files-need-tests',
-                    files: filesNeedingTests,
-                    priority: this.mapRiskToPriority(impact.riskLevel),
-                    recommendations: ['Generate unit tests for new/changed files'],
-                };
+                {
+                    const filesNeedingTests = changedFiles.filter((f) => !this.isTestFile(f) && !impact.impactedTests.some((t) => this.isTestForFile(t, f)));
+                    if (filesNeedingTests.length === 0)
+                        return null;
+                    return {
+                        type: 'files-need-tests',
+                        files: filesNeedingTests,
+                        priority: this.mapRiskToPriority(impact.riskLevel),
+                        recommendations: ['Generate unit tests for new/changed files'],
+                    };
+                }
             case 'coverage-analysis':
                 // Notify about coverage gap changes
                 return {
@@ -464,20 +468,22 @@ export class CodeIntelligenceIndexProtocol {
                 };
             case 'defect-intelligence':
                 // Notify for regression risk assessment
-                const highRiskFiles = [
-                    ...impact.directImpact.filter((i) => i.riskScore >= 0.7),
-                    ...impact.transitiveImpact.filter((i) => i.riskScore >= 0.7),
-                ];
-                if (highRiskFiles.length === 0 && impact.riskLevel === 'info')
-                    return null;
-                return {
-                    type: 'regression-risk',
-                    files: changedFiles,
-                    highRiskFiles: highRiskFiles.map((f) => f.file),
-                    riskLevel: impact.riskLevel,
-                    priority: this.mapRiskToPriority(impact.riskLevel),
-                    recommendations: impact.recommendations,
-                };
+                {
+                    const highRiskFiles = [
+                        ...impact.directImpact.filter((i) => i.riskScore >= 0.7),
+                        ...impact.transitiveImpact.filter((i) => i.riskScore >= 0.7),
+                    ];
+                    if (highRiskFiles.length === 0 && impact.riskLevel === 'info')
+                        return null;
+                    return {
+                        type: 'regression-risk',
+                        files: changedFiles,
+                        highRiskFiles: highRiskFiles.map((f) => f.file),
+                        riskLevel: impact.riskLevel,
+                        priority: this.mapRiskToPriority(impact.riskLevel),
+                        recommendations: impact.recommendations,
+                    };
+                }
             default:
                 return null;
         }

package/dist/coordination/queen-coordinator.js

@@ -768,6 +768,7 @@ export class QueenCoordinator {
     // Uses arrow-captured `self` to correctly proxy mutable counters.
     // ============================================================================
     createEventHandlerContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- self captured for returned handler context
         const self = this;
         return {
             config: self.config, tasks: self.tasks,
@@ -791,6 +792,7 @@ export class QueenCoordinator {
         };
     }
     createTaskContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- self captured for returned handler context
         const self = this;
         return {
             config: self.config, tasks: self.tasks,
@@ -821,6 +823,7 @@ export class QueenCoordinator {
         };
     }
     createWorkStealingContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- self captured for returned handler context
         const self = this;
         return {
             config: self.config, domainQueues: self.domainQueues,
@@ -836,6 +839,7 @@ export class QueenCoordinator {
         };
     }
     createMetricsContext() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- self captured for returned handler context
         const self = this;
         return {
             config: self.config, memory: self.memory,

package/dist/coordination/queen-work-stealing.js

@@ -55,8 +55,7 @@ export async function triggerWorkStealing(ctx) {
 export function startWorkStealingTimer(config, doStealing) {
     let workStealingFailures = 0;
     const maxConsecutiveFailures = 10;
-    let timer;
-    timer = setInterval(async () => {
+    const timer = setInterval(async () => {
         try {
             await doStealing();
             workStealingFailures = 0;

package/dist/domains/chaos-resilience/coordinator.js

@@ -554,8 +554,8 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             let lastExperimentDate;
             let lastLoadTestDate;
             let activeIncidents = 0;
-            let totalRecoveryTime = 0;
-            let recoveryCount = 0;
+            const totalRecoveryTime = 0;
+            const recoveryCount = 0;
             let failedChanges = 0;
             let totalChanges = 0;
             // Process experiment results
@@ -932,22 +932,26 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             let strategy = 'default';
             switch (prediction.action.type) {
                 case 'allocate':
-                    const allocValue = typeof prediction.action.value === 'object' ? prediction.action.value : null;
-                    if (allocValue && 'agentType' in allocValue && allocValue.agentType === 'tester') {
-                        // Allocate more tests to high-risk services (no failover, databases)
-                        const criticalServices = services.filter((s) => !s.hasFailover || s.type === 'database').slice(0, 3);
-                        selectedExperiments = this.generateExperimentsForServices(criticalServices, ['latency', 'error']);
-                        strategy = 'allocate-critical';
+                    {
+                        const allocValue = typeof prediction.action.value === 'object' ? prediction.action.value : null;
+                        if (allocValue && 'agentType' in allocValue && allocValue.agentType === 'tester') {
+                            // Allocate more tests to high-risk services (no failover, databases)
+                            const criticalServices = services.filter((s) => !s.hasFailover || s.type === 'database').slice(0, 3);
+                            selectedExperiments = this.generateExperimentsForServices(criticalServices, ['latency', 'error']);
+                            strategy = 'allocate-critical';
+                        }
+                        break;
                     }
-                    break;
                 case 'reallocate':
-                    const reallocValue = typeof prediction.action.value === 'object' ? prediction.action.value : null;
-                    if (reallocValue && 'domain' in reallocValue && reallocValue.domain === 'test-execution') {
-                        // Reallocate to test different fault types
-                        selectedExperiments = this.generateExperimentsForServices(services.slice(0, 5), ['cpu-stress', 'memory-stress']);
-                        strategy = 'reallocate-resource-stress';
+                    {
+                        const reallocValue = typeof prediction.action.value === 'object' ? prediction.action.value : null;
+                        if (reallocValue && 'domain' in reallocValue && reallocValue.domain === 'test-execution') {
+                            // Reallocate to test different fault types
+                            selectedExperiments = this.generateExperimentsForServices(services.slice(0, 5), ['cpu-stress', 'memory-stress']);
+                            strategy = 'reallocate-resource-stress';
+                        }
+                        break;
                     }
-                    break;
                 case 'scale-up':
                     // Scale up experiment count
                     selectedExperiments = this.generateExperimentsForServices(services, ['latency', 'error', 'timeout']);

package/dist/domains/chaos-resilience/services/chaos-engineer.js

@@ -659,6 +659,7 @@ Provide:
             const busyStart = Date.now();
             while (Date.now() - busyStart < busyTime) {
                 // Busy loop - CPU intensive operations
+                // eslint-disable-next-line @typescript-eslint/no-unused-expressions -- intentional CPU busy-loop
                 secureRandom() * secureRandom();
             }
             // Note: Idle time is handled by the interval itself (10ms interval)
@@ -799,8 +800,10 @@ Provide:
             case 'gte':
                 return actual >= value;
             case 'between':
-                const [min, max] = value;
-                return actual >= min && actual <= max;
+                {
+                    const [min, max] = value;
+                    return actual >= min && actual <= max;
+                }
             default:
                 return false;
         }

package/dist/domains/chaos-resilience/services/load-tester.js

@@ -375,20 +375,24 @@ export class LoadTesterService {
                 }
                 return max;
             case 'step':
-                const steps = 5;
-                const stepDuration = duration / steps;
-                const currentStep = Math.floor(elapsedTime / stepDuration);
-                const stepSize = (max - start) / steps;
-                return Math.round(start + stepSize * currentStep);
+                {
+                    const steps = 5;
+                    const stepDuration = duration / steps;
+                    const currentStep = Math.floor(elapsedTime / stepDuration);
+                    const stepSize = (max - start) / steps;
+                    return Math.round(start + stepSize * currentStep);
+                }
             case 'spike':
                 // Create periodic spikes
-                const spikeInterval = 30000; // 30 seconds
-                const spikeDuration = 5000; // 5 second spike
-                const timeInCycle = elapsedTime % spikeInterval;
-                if (timeInCycle < spikeDuration) {
-                    return max;
+                {
+                    const spikeInterval = 30000; // 30 seconds
+                    const spikeDuration = 5000; // 5 second spike
+                    const timeInCycle = elapsedTime % spikeInterval;
+                    if (timeInCycle < spikeDuration) {
+                        return max;
+                    }
+                    return start;
                 }
-                return start;
             default:
                 return max;
         }

package/dist/domains/code-intelligence/interfaces.d.ts

@@ -27,6 +27,11 @@ export interface IndexResult {
     edgesCreated: number;
     duration: number;
     errors: IndexError[];
+    /**
+     * Non-fatal warnings surfaced during indexing — e.g. files whose language has
+     * no dependency extractor, so `deps`/`impact` will show 0 edges for them (#511).
+     */
+    warnings?: string[];
 }
 export interface IndexError {
     file: string;

package/dist/domains/code-intelligence/services/c4-model/index.js

@@ -1042,14 +1042,20 @@ export class C4ModelService {
     getDiagramPreview(stored) {
         switch (stored.type) {
             case 'context':
-                const ctx = stored.model;
-                return `System: ${ctx.system.name}, External: ${ctx.externalSystems.length}`;
+                {
+                    const ctx = stored.model;
+                    return `System: ${ctx.system.name}, External: ${ctx.externalSystems.length}`;
+                }
             case 'container':
-                const cnt = stored.model;
-                return `Containers: ${cnt.containers.length}, External: ${cnt.externalSystems.length}`;
+                {
+                    const cnt = stored.model;
+                    return `Containers: ${cnt.containers.length}, External: ${cnt.externalSystems.length}`;
+                }
             case 'component':
-                const cmp = stored.model;
-                return `Components: ${cmp.components.length}, Relations: ${cmp.relationships.length}`;
+                {
+                    const cmp = stored.model;
+                    return `Components: ${cmp.components.length}, Relations: ${cmp.relationships.length}`;
+                }
             default:
                 return 'No preview available';
         }

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

@@ -128,9 +128,13 @@ export class ImpactAnalyzerService {
                 ];
                 // Search memory for matching test files
                 for (const pattern of possibleTestPatterns) {
-                    const keys = await this.memory.search(`code-intelligence:kg:node:*${pattern}*`, 10);
+                    const keys = await this.memory.search(`code-intelligence:kg:node:*${pattern}*`, 10, 
+                    // KG persists under its own namespace (#511 parity) — read it there.
+                    { namespace: 'code-intelligence:kg' });
                     for (const key of keys) {
-                        const node = await this.memory.get(key);
+                        const node = await this.memory.get(key, {
+                            namespace: 'code-intelligence:kg',
+                        });
                         if (node?.properties?.path && this.isTestFile(node.properties.path)) {
                             impactedTests.add(node.properties.path);
                         }

package/dist/domains/code-intelligence/services/knowledge-graph.d.ts

@@ -55,6 +55,13 @@ export declare class KnowledgeGraphService implements IKnowledgeGraphService {
     private readonly memory;
     private readonly nodeCache;
     private readonly edgeIndex;
+    /**
+     * 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.
+     */
+    private allEdgesCache?;
     private readonly tsParser;
     private readonly fileReader;
     private readonly embedder;
@@ -70,6 +77,16 @@ export declare class KnowledgeGraphService implements IKnowledgeGraphService {
      * Type guard to check if the argument is KnowledgeGraphDependencies
      */
     private isKnowledgeGraphDependencies;
+    /**
+     * 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).
+     */
+    private get nsOpts();
     /**
      * Index files into the knowledge graph
      */
@@ -90,10 +107,25 @@ export declare class KnowledgeGraphService implements IKnowledgeGraphService {
      * Get edges for a node
      */
     getEdges(nodeId: string, direction: 'incoming' | 'outgoing' | 'both'): Promise<KGEdge[]>;
+    /**
+     * Load all persisted edges into a flat cache (#511).
+     * Cached for the lifetime of the read; invalidated by createEdge()/clear().
+     */
+    private loadAllEdges;
     /**
      * Clear the knowledge graph
      */
     clear(): Promise<void>;
+    /**
+     * 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.
+     */
+    private removeFileFromGraph;
     /**
      * Check if LLM extraction is available and enabled
      */
@@ -151,6 +183,16 @@ export declare class KnowledgeGraphService implements IKnowledgeGraphService {
     private generateQueryEmbedding;
     private fallbackEmbedding;
     private pathToNodeId;
+    /**
+     * 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.
+     */
+    private resolveImportPath;
     private nodeIdToPath;
     private getFileName;
     private getFileExtension;