agentic-qe 3.11.3 → 3.11.5

package/dist/mcp/qe-tool-bridge.js

@@ -80,9 +80,14 @@ export function registerMissingQETools(registerFn) {
                 // lazily for MCP-only contexts) so the MCPToolContext.llmRouter
                 // field carries the actual instance rather than relying on each
                 // tool's getLLMRouter(context) singleton fallback.
-                const { getSharedLLMRouter } = await import('./tools/base.js');
+                const { getSharedLLMRouter, getKernel } = await import('./tools/base.js');
                 const llmRouter = (await getSharedLLMRouter()) ?? undefined;
-                const result = await tool.invoke(params, { llmRouter });
+                // A14: forward the fleet_init kernel singleton (if one exists) the
+                // same way, so tools that resolve real domain APIs
+                // (kernel.getDomainAPI) work through this bridge too, not just
+                // through whatever other entry point happens to pass one.
+                const kernel = await getKernel();
+                const result = await tool.invoke(params, { llmRouter, kernel });
                 return result;
             },
         };

package/dist/mcp/tools/base.d.ts

@@ -67,6 +67,18 @@ export declare function resetSharedLLMRouter(): void;
  * the value.
  */
 export declare function getLLMRouter(context?: MCPToolContext): Promise<import('../../shared/llm/router/hybrid-router.js').HybridRouter | undefined>;
+/**
+ * A14: get the initialized kernel from context, or fall back to the
+ * fleet_init singleton (`core-handlers.ts`'s module-level fleet state) if
+ * one has been initialized in-process. Returns undefined — never throws —
+ * when no kernel is available (fleet_init hasn't run); callers must degrade
+ * gracefully.
+ *
+ * Dynamic import here, not a static one: core-handlers.ts transitively
+ * imports tools/registry.ts, which imports every tool that extends
+ * MCPToolBase (this file) — a static import would be circular.
+ */
+export declare function getKernel(context?: MCPToolContext): Promise<import('../../kernel/interfaces.js').QEKernel | undefined>;
 /**
  * JSON Schema property definition for tool parameters
  */
@@ -127,6 +139,17 @@ export interface MCPToolContext {
      * bag so isLLMAnalysisAvailable() returns true.
      */
     llmRouter?: import('../../shared/llm/router/hybrid-router.js').HybridRouter;
+    /**
+     * A14: initialized kernel instance, for tools that need to reach a real
+     * domain plugin's public API (`kernel.getDomainAPI<T>(domain)`) rather
+     * than constructing their own service instance — the pattern
+     * `DefaultProtocolExecutor` already uses for real (non-mocked) action
+     * dispatch. Only populated when `fleet_init` has run in-process and
+     * handed its kernel to the MCP runtime (see qe-tool-bridge.ts); undefined
+     * otherwise. Tools MUST tolerate an undefined kernel and degrade
+     * gracefully (e.g. "run fleet_init first") rather than assume it's set.
+     */
+    kernel?: import('../../kernel/interfaces.js').QEKernel;
 }
 /**
  * Data source tracking for audit/transparency
@@ -229,6 +252,12 @@ export declare abstract class MCPToolBase<TParams extends Record<string, unknown
          * lazy build path.
          */
         llmRouter?: import('../../shared/llm/router/hybrid-router.js').HybridRouter;
+        /**
+         * A14: optional kernel injection, mirroring the memory/llmRouter
+         * pattern — the MCP runtime forwards the fleet_init kernel singleton
+         * here (see qe-tool-bridge.ts) when one has been initialized.
+         */
+        kernel?: import('../../kernel/interfaces.js').QEKernel;
     }): Promise<ToolResult<TResult>>;
     /**
      * Create result metadata

package/dist/mcp/tools/base.js

@@ -208,6 +208,30 @@ export async function getLLMRouter(context) {
     const shared = await getSharedLLMRouter();
     return shared ?? undefined;
 }
+/**
+ * A14: get the initialized kernel from context, or fall back to the
+ * fleet_init singleton (`core-handlers.ts`'s module-level fleet state) if
+ * one has been initialized in-process. Returns undefined — never throws —
+ * when no kernel is available (fleet_init hasn't run); callers must degrade
+ * gracefully.
+ *
+ * Dynamic import here, not a static one: core-handlers.ts transitively
+ * imports tools/registry.ts, which imports every tool that extends
+ * MCPToolBase (this file) — a static import would be circular.
+ */
+export async function getKernel(context) {
+    if (context?.kernel) {
+        return context.kernel;
+    }
+    try {
+        const { getFleetState } = await import('../handlers/core-handlers.js');
+        const state = getFleetState();
+        return state.kernel ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Default console logger
  */
@@ -372,6 +396,7 @@ export class MCPToolBase {
             demoMode: options.demoMode,
             memory: options.memory,
             llmRouter: options.llmRouter,
+            kernel: options.kernel,
         };
         try {
             // Execute the tool

package/dist/mcp/tools/coverage-analysis/index.js

@@ -7,7 +7,7 @@
  * This module wraps the REAL coverage-analysis domain services.
  * Uses actual LCOV/JSON parsing and vector-based gap detection.
  */
-import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter, getKernel } from '../base';
 import { CoverageAnalyzerService } from '../../../domains/coverage-analysis/services/coverage-analyzer';
 import { GapDetectorService } from '../../../domains/coverage-analysis/services/gap-detector';
 import { findAndParseCoverage, parseCoverage, } from '../../../domains/coverage-analysis/services/coverage-parser';
@@ -396,9 +396,11 @@ export class CoverageGapsTool extends MCPToolBase {
             let ghostGaps;
             if (params.includeGhost) {
                 try {
-                    const contextExt = context;
-                    const kernel = contextExt.kernel;
-                    if (kernel) {
+                    // A14: context.kernel is now a real MCPToolContext field (was
+                    // previously always undefined — nothing set it — so this branch
+                    // was dead code regardless of --includeGhost).
+                    const kernel = await getKernel(context);
+                    if (kernel?.getDomainAPIAsync) {
                         const coordAPI = await kernel.getDomainAPIAsync('coverage-analysis');
                         if (coordAPI?.analyzeGhostCoverage) {
                             const ghostResult = await coordAPI.analyzeGhostCoverage(domainFiles.map((f) => f.path), target);

package/dist/mcp/tools/learning-optimization/dream.d.ts

@@ -127,21 +127,12 @@ export declare class DreamCycleTool extends MCPToolBase<DreamCycleParams, DreamC
     /**
      * Apply an insight to create a REAL pattern in QEReasoningBank.
      *
-     * This fixes the issue where applyInsight was generating fake pattern IDs.
-     * Now it:
-     * 1. Gets the insight details from pending insights
-     * 2. Creates a REAL pattern in QEReasoningBank with proper structure
-     * 3. Marks the insight as applied in the engine
-     * 4. Returns the REAL pattern ID
+     * DreamEngine.applyInsight() is the single implementation (shared with the
+     * scheduler's autoApplyInsights) — it creates the real pattern, wires the
+     * RVF dual-writer, and updates dream_insights.pattern_id to point at the
+     * real row. This handler is a thin wrapper around it.
      */
     private applyInsight;
-    /**
-     * Map DreamInsight type to QEPatternType.
-     *
-     * Dream insights have types like 'cross-domain', 'novel-path', etc.
-     * QEPatterns have types like 'test-template', 'coverage-strategy', etc.
-     */
-    private mapInsightTypeToPatternType;
     /**
      * Get dream cycle history
      */

package/dist/mcp/tools/learning-optimization/dream.js

@@ -269,12 +269,10 @@ export class DreamCycleTool extends MCPToolBase {
     /**
      * Apply an insight to create a REAL pattern in QEReasoningBank.
      *
-     * This fixes the issue where applyInsight was generating fake pattern IDs.
-     * Now it:
-     * 1. Gets the insight details from pending insights
-     * 2. Creates a REAL pattern in QEReasoningBank with proper structure
-     * 3. Marks the insight as applied in the engine
-     * 4. Returns the REAL pattern ID
+     * DreamEngine.applyInsight() is the single implementation (shared with the
+     * scheduler's autoApplyInsights) — it creates the real pattern, wires the
+     * RVF dual-writer, and updates dream_insights.pattern_id to point at the
+     * real row. This handler is a thin wrapper around it.
      */
     async applyInsight(params, context) {
         if (!params.insightId) {
@@ -290,92 +288,25 @@ export class DreamCycleTool extends MCPToolBase {
         }
         try {
             const engine = await this.getEngine();
-            // Step 1: Find the insight from pending insights
-            const pendingInsights = await engine.getPendingInsights(100);
-            const insight = pendingInsights.find((i) => i.id === params.insightId);
-            if (!insight) {
-                // Check if already applied or doesn't exist
+            const applyResult = await engine.applyInsight(params.insightId);
+            if (!applyResult.success) {
                 return {
                     success: false,
-                    error: `Insight not found or already applied: ${params.insightId}`,
+                    error: applyResult.error,
                     data: {
                         action: 'apply',
                         success: false,
-                        error: `Insight not found or already applied: ${params.insightId}`,
+                        error: applyResult.error,
                     },
                 };
             }
-            if (!insight.actionable) {
-                return {
-                    success: false,
-                    error: 'Insight is not actionable',
-                    data: {
-                        action: 'apply',
-                        success: false,
-                        error: 'Insight is not actionable',
-                    },
-                };
-            }
-            // Step 2: Create a REAL pattern in QEReasoningBank
-            const memoryBackend = await getSharedMemoryBackend();
-            const reasoningBank = createQEReasoningBank(memoryBackend);
-            await reasoningBank.initialize();
-            // Wire RVF dual-writer (optional, best-effort)
-            try {
-                const { getSharedRvfDualWriter } = await import('../../../integrations/ruvector/shared-rvf-dual-writer.js');
-                const dualWriter = await getSharedRvfDualWriter();
-                if (dualWriter)
-                    reasoningBank.setRvfDualWriter(dualWriter);
-            }
-            catch (e) {
-                if (process.env.DEBUG)
-                    this.logger.info('RVF wiring skipped', { error: String(e) });
-            }
-            // Map insight type to QE pattern type
-            const patternType = this.mapInsightTypeToPatternType(insight.type);
-            // Create the pattern with proper structure
-            const patternResult = await reasoningBank.storePattern({
-                patternType,
-                name: `Dream Insight: ${insight.type}`,
-                description: `${insight.description} (confidence: ${insight.confidenceScore.toFixed(2)})`,
-                template: {
-                    type: 'workflow',
-                    content: insight.suggestedAction || insight.description,
-                    variables: [],
-                },
-                context: {
-                    tags: ['dream-generated', insight.type, ...insight.sourceConcepts.slice(0, 3)],
-                    complexity: 'medium',
-                },
-            });
-            if (!patternResult.success) {
-                const errorMsg = patternResult.error?.message || 'Unknown error';
-                return {
-                    success: false,
-                    error: `Failed to create pattern: ${errorMsg}`,
-                    data: {
-                        action: 'apply',
-                        success: false,
-                        error: `Failed to create pattern: ${errorMsg}`,
-                    },
-                };
-            }
-            const realPatternId = patternResult.value.id;
-            // Step 3: Mark insight as applied in the engine
-            // This updates the engine's internal database (ignore its fake pattern ID)
-            await engine.applyInsight(params.insightId);
-            this.logger.info(`Applied insight ${params.insightId} → REAL pattern ${realPatternId} in ReasoningBank`);
-            const applyResult = {
-                insightId: params.insightId,
-                success: true,
-                patternId: realPatternId, // Return the REAL pattern ID
-            };
+            this.logger.info(`Applied insight ${params.insightId} → REAL pattern ${applyResult.patternId} in ReasoningBank`);
             return {
                 success: true,
                 data: {
                     action: 'apply',
                     success: true,
-                    applyResult,
+                    applyResult: { insightId: params.insightId, ...applyResult },
                 },
             };
         }
@@ -392,23 +323,6 @@ export class DreamCycleTool extends MCPToolBase {
             };
         }
     }
-    /**
-     * Map DreamInsight type to QEPatternType.
-     *
-     * Dream insights have types like 'cross-domain', 'novel-path', etc.
-     * QEPatterns have types like 'test-template', 'coverage-strategy', etc.
-     */
-    mapInsightTypeToPatternType(insightType) {
-        // Map insight types to the most appropriate pattern type
-        const mapping = {
-            'cross-domain': 'coverage-strategy', // Cross-domain insights suggest coverage approaches
-            'novel-path': 'test-template', // Novel paths suggest new test templates
-            'cluster': 'refactor-safe', // Clusters suggest refactoring patterns
-            'high-activation': 'assertion-pattern', // High activation suggests important assertions
-            'bridge': 'mock-pattern', // Bridges between concepts suggest mocking
-        };
-        return mapping[insightType] || 'test-template';
-    }
     /**
      * Get dream cycle history
      */

package/dist/mcp/tools/planning/goap-execute.d.ts

@@ -58,7 +58,19 @@ export declare class GOAPExecuteTool extends MCPToolBase<GOAPExecuteParams, GOAP
      */
     private getPlanner;
     /**
-     * Get or create the plan executor instance
+     * Get or create the plan executor instance.
+     *
+     * A14: previously always built a mock executor (createMockExecutor,
+     * successRate: 0.95) regardless of whether real domain services were
+     * available — every "real execution" was actually a fabricated coin
+     * flip. Now constructs a real PlanExecutor with a getDomainAPI closure:
+     * `implemented: true` actions dispatch to the real domain method;
+     * `implemented: false` actions fail honestly (see PlanExecutor.executeStep).
+     *
+     * The closure is passed even when `kernel` is undefined (fleet_init
+     * hasn't run) — PlanExecutor.executeRealAction() then reports a clear
+     * "domain not available" error per step, which is what the user should
+     * see instead of a silent fallback to simulation.
      */
     private getExecutor;
     /**

package/dist/mcp/tools/planning/goap-execute.js

@@ -7,9 +7,9 @@
  * @module mcp/tools/planning/goap-execute
  * @version 3.0.0
  */
-import { MCPToolBase, } from '../base.js';
+import { MCPToolBase, getKernel, } from '../base.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
-import { getSharedGOAPPlanner, createMockExecutor, } from '../../../planning/index.js';
+import { getSharedGOAPPlanner, PlanExecutor, MockAgentSpawner, } from '../../../planning/index.js';
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -23,8 +23,11 @@ export class GOAPExecuteTool extends MCPToolBase {
     executor = null;
     config = {
         name: 'qe/planning/goap_execute',
-        description: 'Execute a GOAP plan, spawning agents to perform each action step. ' +
-            'Supports dry-run mode to simulate execution without actual agent spawning.',
+        description: 'Execute a GOAP plan. Each action dispatches to a real domain API method ' +
+            "when the action is marked implemented and a kernel is available (run fleet_init " +
+            'first); actions with no real implementation, or with no domain/kernel available, ' +
+            'fail with a specific reason rather than reporting a fabricated success. ' +
+            'Supports dry-run mode to preview the plan without executing anything.',
         domain: 'coordination',
         schema: this.buildSchema(),
         timeout: 300000, // 5 minutes for plan execution
@@ -69,21 +72,32 @@ export class GOAPExecuteTool extends MCPToolBase {
         return this.planner;
     }
     /**
-     * Get or create the plan executor instance
+     * Get or create the plan executor instance.
+     *
+     * A14: previously always built a mock executor (createMockExecutor,
+     * successRate: 0.95) regardless of whether real domain services were
+     * available — every "real execution" was actually a fabricated coin
+     * flip. Now constructs a real PlanExecutor with a getDomainAPI closure:
+     * `implemented: true` actions dispatch to the real domain method;
+     * `implemented: false` actions fail honestly (see PlanExecutor.executeStep).
+     *
+     * The closure is passed even when `kernel` is undefined (fleet_init
+     * hasn't run) — PlanExecutor.executeRealAction() then reports a clear
+     * "domain not available" error per step, which is what the user should
+     * see instead of a silent fallback to simulation.
      */
-    async getExecutor() {
+    async getExecutor(kernel) {
         if (!this.executor) {
             const planner = await this.getPlanner();
-            this.executor = createMockExecutor(planner, {
-                successRate: 0.95, // High success rate for mock executor
-                config: {
-                    maxRetries: 2,
-                    stepTimeoutMs: 60000,
-                    replanOnFailure: true,
-                    parallelExecution: false,
-                    recordWorldState: true,
-                },
-            });
+            const getDomainAPI = (domain) => kernel?.getDomainAPI(domain);
+            this.executor = new PlanExecutor(planner, new MockAgentSpawner(), // fallback only for actions with no `implemented` classification (e.g. custom addAction() calls) — see PlanExecutor's backward-compat contract
+            undefined, {
+                maxRetries: 2,
+                stepTimeoutMs: 60000,
+                replanOnFailure: true,
+                parallelExecution: false,
+                recordWorldState: true,
+            }, getDomainAPI);
             await this.executor.initialize();
         }
         return this.executor;
@@ -121,7 +135,7 @@ export class GOAPExecuteTool extends MCPToolBase {
                         stepsCompleted: plan.actions.length,
                         stepsFailed: 0,
                         totalDurationMs: plan.estimatedDurationMs,
-                        steps: plan.actions.map((a, i) => ({
+                        steps: plan.actions.map((a) => ({
                             action: a.name,
                             status: 'would-execute',
                             retries: 0,
@@ -131,7 +145,8 @@ export class GOAPExecuteTool extends MCPToolBase {
                 };
             }
             // Real execution
-            const executor = await this.getExecutor();
+            const kernel = await getKernel(context);
+            const executor = await this.getExecutor(kernel);
             // Check if already executing
             if (executor.isExecuting()) {
                 return {

package/dist/mcp/tools/registry.js

@@ -173,9 +173,14 @@ export function registerAllQETools(registry) {
         // ADR-043: forward the shared HybridRouter so the tool's
         // MCPToolContext.llmRouter is populated explicitly.
         async (params) => {
-            const { getSharedLLMRouter } = await import('./base.js');
+            const { getSharedLLMRouter, getKernel } = await import('./base.js');
             const llmRouter = (await getSharedLLMRouter()) ?? undefined;
-            return tool.invoke(params, { llmRouter });
+            // A14: forward the fleet_init kernel singleton (if initialized) so
+            // tools that dispatch to real domain APIs (e.g. GOAPExecuteTool)
+            // can reach them — this is the actual registration path QE_TOOLS
+            // (including the GOAP planning tools) goes through in production.
+            const kernel = await getKernel();
+            return tool.invoke(params, { llmRouter, kernel });
         });
     }
 }

package/dist/persistence/rvf-migration-coordinator.js

@@ -116,7 +116,8 @@ export class RvfMigrationCoordinator {
         // Try to attach witness chain
         try {
             const { WitnessChain } = await import('../audit/witness-chain.js');
-            const wc = new WitnessChain();
+            const { getDefaultWitnessKeyManager } = await import('../audit/witness-key-manager.js');
+            const wc = new WitnessChain(undefined, getDefaultWitnessKeyManager());
             await wc.initialize();
             this.attachWitnessChain(wc);
         }