agentic-qe 3.8.14 → 3.9.1

package/dist/mcp/entry.js

@@ -20,6 +20,7 @@ import { bootstrapTokenTracking, shutdownTokenTracking } from '../init/token-boo
 import { initializeExperienceCapture, stopCleanupTimer } from '../learning/experience-capture-middleware.js';
 import { createInfraHealingOrchestratorSync, ShellCommandRunner } from '../strange-loop/infra-healing/index.js';
 import { setInfraHealingOrchestrator, handleFleetInit } from './handlers/index.js';
+import { parallelPrefetch } from '../boot/parallel-prefetch.js';
 import { readFileSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -31,11 +32,18 @@ async function main() {
     // Output startup message BEFORE suppressing stderr (Claude Code health check needs this)
     const version = pkg.version;
     process.stderr.write(`[agentic-qe-v3] MCP server starting v${version}\n`);
-    // Handle graceful shutdown
+    // Handle graceful shutdown (includes QualityDaemon)
     const shutdownDaemon = async () => {
         try {
             const { getDaemon } = await import('../workers/daemon.js');
-            await getDaemon().stop();
+            const daemon = getDaemon();
+            // Stop quality daemon first (if started)
+            try {
+                const qd = daemon.getQualityDaemon();
+                await qd.stop();
+            }
+            catch { /* not started */ }
+            await daemon.stop();
         }
         catch { /* ignore */ }
     };
@@ -98,81 +106,99 @@ async function main() {
         return true;
     });
     try {
-        // ADR-042: Initialize token tracking and optimization
-        originalStderrWrite('[MCP] Initializing token tracking...\n');
-        await bootstrapTokenTracking({
-            enableOptimization: true,
-            enablePersistence: true,
-            verbose: process.env.AQE_VERBOSE === 'true',
-        });
-        // ADR-051: Initialize experience capture and unified memory BEFORE server starts.
-        // This ensures all tool invocations (domain, memory, core) write to v3 memory.db
-        // from the first request, rather than lazy-initializing on first domain tool call.
-        originalStderrWrite('[MCP] Initializing experience capture...\n');
-        await initializeExperienceCapture();
-        // ADR-057: Initialize infrastructure self-healing
-        originalStderrWrite('[MCP] Initializing infra-healing...\n');
-        try {
-            const __filename = fileURLToPath(import.meta.url);
-            const __dirname = dirname(__filename);
-            const playbookPath = resolve(__dirname, '../strange-loop/infra-healing/default-playbook.yaml');
-            let playbookContent;
-            try {
-                playbookContent = readFileSync(playbookPath, 'utf-8');
-            }
-            catch {
-                // Fallback for bundled environments where the YAML may not be at the resolved path
-                playbookContent = [
-                    'services:',
-                    '  postgres:',
-                    '    healthCheck: "pg_isready -h localhost -p 5432"',
-                    '    recover: "echo postgres-recovery-placeholder"',
-                    '    verify: "pg_isready -h localhost -p 5432"',
-                    '  redis:',
-                    '    healthCheck: "redis-cli ping"',
-                    '    recover: "echo redis-recovery-placeholder"',
-                    '    verify: "redis-cli ping"',
-                    '  node:',
-                    '    healthCheck: "node --version"',
-                    '    recover: "echo node-recovery-placeholder"',
-                    '    verify: "node --version"',
-                ].join('\n');
-            }
-            if (playbookContent) {
-                const infraOrchestrator = createInfraHealingOrchestratorSync({
-                    commandRunner: new ShellCommandRunner(),
-                    playbook: playbookContent,
-                });
-                setInfraHealingOrchestrator(infraOrchestrator);
-                originalStderrWrite(`[MCP] Infra-healing ready (${infraOrchestrator.getPlaybook().listServices().length} services)\n`);
-            }
-            else {
-                originalStderrWrite('[MCP] Infra-healing skipped: no playbook found\n');
-            }
+        // IMP-06: Run independent init tasks in parallel via parallelPrefetch.
+        // Token tracking, experience capture, infra-healing, and fleet init are
+        // all independent — total startup time is bounded by the slowest task
+        // rather than the sum of all tasks.
+        originalStderrWrite('[MCP] Initializing subsystems in parallel...\n');
+        const prefetchResult = await parallelPrefetch([
+            {
+                // ADR-042: Initialize token tracking and optimization
+                name: 'token-tracking',
+                fn: async () => {
+                    await bootstrapTokenTracking({
+                        enableOptimization: true,
+                        enablePersistence: true,
+                        verbose: process.env.AQE_VERBOSE === 'true',
+                    });
+                },
+            },
+            {
+                // ADR-051: Initialize experience capture and unified memory BEFORE server starts.
+                // This ensures all tool invocations (domain, memory, core) write to v3 memory.db
+                // from the first request, rather than lazy-initializing on first domain tool call.
+                name: 'experience-capture',
+                fn: async () => {
+                    await initializeExperienceCapture();
+                },
+            },
+            {
+                // ADR-057: Initialize infrastructure self-healing
+                name: 'infra-healing',
+                fn: async () => {
+                    const __filename = fileURLToPath(import.meta.url);
+                    const __dirname = dirname(__filename);
+                    const playbookPath = resolve(__dirname, '../strange-loop/infra-healing/default-playbook.yaml');
+                    let playbookContent;
+                    try {
+                        playbookContent = readFileSync(playbookPath, 'utf-8');
+                    }
+                    catch {
+                        // Fallback for bundled environments where the YAML may not be at the resolved path
+                        playbookContent = [
+                            'services:',
+                            '  postgres:',
+                            '    healthCheck: "pg_isready -h localhost -p 5432"',
+                            '    recover: "echo postgres-recovery-placeholder"',
+                            '    verify: "pg_isready -h localhost -p 5432"',
+                            '  redis:',
+                            '    healthCheck: "redis-cli ping"',
+                            '    recover: "echo redis-recovery-placeholder"',
+                            '    verify: "redis-cli ping"',
+                            '  node:',
+                            '    healthCheck: "node --version"',
+                            '    recover: "echo node-recovery-placeholder"',
+                            '    verify: "node --version"',
+                        ].join('\n');
+                    }
+                    if (playbookContent) {
+                        const infraOrchestrator = createInfraHealingOrchestratorSync({
+                            commandRunner: new ShellCommandRunner(),
+                            playbook: playbookContent,
+                        });
+                        setInfraHealingOrchestrator(infraOrchestrator);
+                        originalStderrWrite(`[MCP] Infra-healing ready (${infraOrchestrator.getPlaybook().listServices().length} services)\n`);
+                    }
+                    else {
+                        originalStderrWrite('[MCP] Infra-healing skipped: no playbook found\n');
+                    }
+                },
+            },
+            {
+                // Auto-initialize fleet so tools work without requiring fleet_init call
+                name: 'fleet-init',
+                fn: async () => {
+                    const fleetResult = await handleFleetInit({
+                        topology: 'hierarchical',
+                        maxAgents: 15,
+                        memoryBackend: 'hybrid',
+                        lazyLoading: true,
+                    });
+                    if (fleetResult.success) {
+                        originalStderrWrite(`[MCP] Fleet ready: ${fleetResult.data?.fleetId}\n`);
+                    }
+                    else {
+                        originalStderrWrite(`[MCP] WARNING: Fleet auto-init failed: ${fleetResult.error}\n`);
+                    }
+                },
+            },
+        ]);
+        // Log prefetch results
+        if (prefetchResult.completedTasks.length > 0) {
+            originalStderrWrite(`[MCP] Initialized: ${prefetchResult.completedTasks.join(', ')} (${prefetchResult.totalTimeMs.toFixed(0)}ms)\n`);
         }
-        catch (infraError) {
-            originalStderrWrite(`[MCP] WARNING: Infra-healing init failed: ${infraError}\n`);
-            // Non-fatal — MCP server continues without infra-healing
-        }
-        // Auto-initialize fleet so tools work without requiring fleet_init call
-        originalStderrWrite('[MCP] Auto-initializing fleet...\n');
-        try {
-            const fleetResult = await handleFleetInit({
-                topology: 'hierarchical',
-                maxAgents: 15,
-                memoryBackend: 'hybrid',
-                lazyLoading: true,
-            });
-            if (fleetResult.success) {
-                originalStderrWrite(`[MCP] Fleet ready: ${fleetResult.data?.fleetId}\n`);
-            }
-            else {
-                originalStderrWrite(`[MCP] WARNING: Fleet auto-init failed: ${fleetResult.error}\n`);
-            }
-        }
-        catch (fleetError) {
-            originalStderrWrite(`[MCP] WARNING: Fleet auto-init error: ${fleetError}\n`);
-            // Non-fatal — tools will prompt user to call fleet_init manually
+        for (const failed of prefetchResult.failedTasks) {
+            originalStderrWrite(`[MCP] WARNING: ${failed.name} init failed: ${failed.error}\n`);
         }
         // Start the MCP server
         originalStderrWrite('[MCP] Starting server...\n');
@@ -181,13 +207,42 @@ async function main() {
             version,
         });
         originalStderrWrite('[MCP] Ready\n');
-        // Imp-10: Start background workers (heartbeat scheduler, etc.)
+        // IMP-10: Start background workers (heartbeat scheduler, etc.)
         try {
             const { getDaemon } = await import('../workers/daemon.js');
             const daemon = getDaemon({ autoStart: false });
             await daemon.start();
             const status = daemon.getStatus();
             originalStderrWrite(`[MCP] Background workers started (${status.workerManager.totalWorkers} workers)\n`);
+            // IMP-10: Start QualityDaemon with persistent memory (Finding 1 & 2 resolution)
+            try {
+                const { UnifiedMemoryManager } = await import('../kernel/unified-memory.js');
+                const { PersistentWorkerMemory } = await import('../workers/quality-daemon/persistent-memory.js');
+                const { isPrivateIp } = await import('../hooks/security/ssrf-guard.js');
+                const unifiedMemory = await UnifiedMemoryManager.getInstanceAsync();
+                const persistentMemory = new PersistentWorkerMemory(unifiedMemory);
+                const qualityDaemon = daemon.getQualityDaemon({
+                    notifications: {
+                        // IMP-07 SSRF guard: block private IPs in webhook URLs (Finding 5)
+                        urlValidator: (url) => {
+                            try {
+                                const parsed = new URL(url);
+                                const hostname = parsed.hostname.replace(/^\[|\]$/g, '');
+                                return !isPrivateIp(hostname);
+                            }
+                            catch {
+                                return false;
+                            }
+                        },
+                    },
+                });
+                await qualityDaemon.start(persistentMemory);
+                originalStderrWrite(`[MCP] Quality daemon started\n`);
+            }
+            catch (qdError) {
+                originalStderrWrite(`[MCP] WARNING: Quality daemon failed to start: ${qdError}\n`);
+                // Non-fatal — MCP continues without quality daemon
+            }
         }
         catch (daemonError) {
             originalStderrWrite(`[MCP] WARNING: Background workers failed to start: ${daemonError}\n`);

package/dist/mcp/handlers/index.d.ts

@@ -14,4 +14,5 @@ export { handleValidationPipeline, type ValidationPipelineParams, type Validatio
 export { handleHypergraphQuery, type HypergraphQueryParams, type HypergraphQueryResult, } from './hypergraph-handler.js';
 export { handleHeartbeatStatus, handleHeartbeatTrigger, handleHeartbeatLog, type HeartbeatStatusParams, type HeartbeatStatusResult, type HeartbeatTriggerParams, type HeartbeatTriggerResult, type HeartbeatLogParams, type HeartbeatLogResult, } from './heartbeat-handlers.js';
 export { handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseStart, handlePhaseEnd, handleCrossPhaseStats, handleFormatSignals, handleCrossPhaseCleanup, resetCrossPhaseHandlers, type StoreSignalParams, type StoreSignalResult, type QuerySignalsParams, type QuerySignalsResult, type AgentCompleteParams, type AgentCompleteResult, type PhaseEventParams, type PhaseStartResult, type PhaseEndResult, type CrossPhaseStatsResult, type FormatSignalsParams, type FormatSignalsResult, } from './cross-phase-handlers';
+export { handleMigrationStatus, handleMigrationCheck, handleMigrationPromote, resetMigrationHandlers, type MigrationStatusResult, type MigrationCheckResult, type MigrationPromoteResult, } from './migration-handlers.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp/handlers/index.js

@@ -30,4 +30,6 @@ export { handleHypergraphQuery, } from './hypergraph-handler.js';
 export { handleHeartbeatStatus, handleHeartbeatTrigger, handleHeartbeatLog, } from './heartbeat-handlers.js';
 // Cross-phase handlers
 export { handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseStart, handlePhaseEnd, handleCrossPhaseStats, handleFormatSignals, handleCrossPhaseCleanup, resetCrossPhaseHandlers, } from './cross-phase-handlers';
+// RVF Migration handlers (ADR-072 Phase 3)
+export { handleMigrationStatus, handleMigrationCheck, handleMigrationPromote, resetMigrationHandlers, } from './migration-handlers.js';
 //# sourceMappingURL=index.js.map

package/dist/mcp/handlers/migration-handlers.d.ts

@@ -0,0 +1,52 @@
+/**
+ * MCP Handlers for RVF Migration (ADR-072 Phase 3)
+ *
+ * Exposes migration status, consistency checks, and stage promotion
+ * via MCP tools for user-facing verification.
+ */
+import { type MigrationStatus } from '../../persistence/rvf-migration-coordinator.js';
+import type { ConsistencyCheckResult } from '../../persistence/rvf-consistency-validator.js';
+import type { StageGateResult } from '../../persistence/rvf-stage-gate.js';
+import type { MigrationStage } from '../../persistence/rvf-migration-adapter.js';
+export interface MigrationStatusResult {
+    success: boolean;
+    data: MigrationStatus | null;
+    error?: string;
+}
+export interface MigrationCheckResult {
+    success: boolean;
+    data: ConsistencyCheckResult | null;
+    error?: string;
+}
+export interface MigrationPromoteResult {
+    success: boolean;
+    data: {
+        promoted: boolean;
+        previousStage: MigrationStage;
+        newStage: MigrationStage;
+        gateResult: StageGateResult;
+    } | null;
+    error?: string;
+}
+/** Reset for testing */
+export declare function resetMigrationHandlers(): void;
+/**
+ * Get comprehensive RVF migration status including stage, metrics,
+ * consistency history, engine status, and gate evaluation.
+ */
+export declare function handleMigrationStatus(): Promise<MigrationStatusResult>;
+/**
+ * Run a consistency check comparing SQLite and RVF search results.
+ * Samples random patterns and reports divergences.
+ */
+export declare function handleMigrationCheck(): Promise<MigrationCheckResult>;
+/**
+ * Attempt to promote to the next migration stage.
+ * Evaluates stage gate criteria and records result in witness chain.
+ *
+ * @param params.force - Skip gate checks (force promotion)
+ */
+export declare function handleMigrationPromote(params?: {
+    force?: boolean;
+}): Promise<MigrationPromoteResult>;
+//# sourceMappingURL=migration-handlers.d.ts.map

package/dist/mcp/handlers/migration-handlers.js

@@ -0,0 +1,85 @@
+/**
+ * MCP Handlers for RVF Migration (ADR-072 Phase 3)
+ *
+ * Exposes migration status, consistency checks, and stage promotion
+ * via MCP tools for user-facing verification.
+ */
+import { RvfMigrationCoordinator, } from '../../persistence/rvf-migration-coordinator.js';
+// ============================================================================
+// Lazy Coordinator Init
+// ============================================================================
+let coordinator = null;
+async function getCoordinator() {
+    if (!coordinator) {
+        coordinator = RvfMigrationCoordinator.getInstance();
+        await coordinator.initialize();
+    }
+    return coordinator;
+}
+/** Reset for testing */
+export function resetMigrationHandlers() {
+    coordinator = null;
+    RvfMigrationCoordinator.resetInstance();
+}
+// ============================================================================
+// Handlers
+// ============================================================================
+/**
+ * Get comprehensive RVF migration status including stage, metrics,
+ * consistency history, engine status, and gate evaluation.
+ */
+export async function handleMigrationStatus() {
+    try {
+        const coord = await getCoordinator();
+        return { success: true, data: coord.getStatus() };
+    }
+    catch (err) {
+        return {
+            success: false,
+            data: null,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/**
+ * Run a consistency check comparing SQLite and RVF search results.
+ * Samples random patterns and reports divergences.
+ */
+export async function handleMigrationCheck() {
+    try {
+        const coord = await getCoordinator();
+        const result = coord.runConsistencyCheck();
+        return { success: true, data: result };
+    }
+    catch (err) {
+        return {
+            success: false,
+            data: null,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/**
+ * Attempt to promote to the next migration stage.
+ * Evaluates stage gate criteria and records result in witness chain.
+ *
+ * @param params.force - Skip gate checks (force promotion)
+ */
+export async function handleMigrationPromote(params = {}) {
+    try {
+        const coord = await getCoordinator();
+        const { promoted, previousStage, newStage, result } = coord.promote(params.force ?? false);
+        return {
+            success: true,
+            data: { promoted, previousStage, newStage, gateResult: result },
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            data: null,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=migration-handlers.js.map

package/dist/mcp/middleware/batch-executor.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Agentic QE v3 - Batch Tool Executor
+ *
+ * IMP-02: Tool Concurrency Partitioning
+ *
+ * Enables parallel execution of concurrent-safe tool calls within internal
+ * orchestration paths (task_orchestrate, fleet batch ops). Does NOT change
+ * the MCP protocol contract — MCP still sends one tool call per request.
+ *
+ * Strategy:
+ *   1. Partition consecutive isConcurrencySafe:true calls into batches
+ *   2. Non-safe calls break the batch and run alone, sequentially
+ *   3. Each safe batch runs via Promise.all() with a semaphore limiter
+ *   4. Results are returned in original input order
+ */
+export interface BatchToolCall {
+    name: string;
+    handler: () => Promise<unknown>;
+    isConcurrencySafe: boolean;
+}
+export interface BatchResult {
+    results: unknown[];
+    parallelBatches: number;
+    sequentialCalls: number;
+    totalWallTimeMs: number;
+}
+export declare class Semaphore {
+    private permits;
+    private readonly waiting;
+    constructor(permits: number);
+    acquire(): Promise<void>;
+    release(): void;
+    /** Current number of available permits (useful for testing). */
+    get available(): number;
+}
+export declare class BatchToolExecutor {
+    private readonly maxConcurrency;
+    constructor(maxConcurrency?: number);
+    /**
+     * Execute a batch of tool calls respecting concurrency safety annotations.
+     *
+     * @returns BatchResult with results in the same order as the input calls.
+     */
+    executeBatch(calls: BatchToolCall[]): Promise<BatchResult>;
+}
+//# sourceMappingURL=batch-executor.d.ts.map

package/dist/mcp/middleware/batch-executor.js

@@ -0,0 +1,150 @@
+/**
+ * Agentic QE v3 - Batch Tool Executor
+ *
+ * IMP-02: Tool Concurrency Partitioning
+ *
+ * Enables parallel execution of concurrent-safe tool calls within internal
+ * orchestration paths (task_orchestrate, fleet batch ops). Does NOT change
+ * the MCP protocol contract — MCP still sends one tool call per request.
+ *
+ * Strategy:
+ *   1. Partition consecutive isConcurrencySafe:true calls into batches
+ *   2. Non-safe calls break the batch and run alone, sequentially
+ *   3. Each safe batch runs via Promise.all() with a semaphore limiter
+ *   4. Results are returned in original input order
+ */
+// ============================================================================
+// Semaphore — simple concurrency limiter
+// ============================================================================
+export class Semaphore {
+    permits;
+    waiting = [];
+    constructor(permits) {
+        if (permits < 1) {
+            throw new Error('Semaphore permits must be >= 1');
+        }
+        this.permits = permits;
+    }
+    async acquire() {
+        if (this.permits > 0) {
+            this.permits--;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.waiting.push(resolve);
+        });
+    }
+    release() {
+        if (this.waiting.length > 0) {
+            const next = this.waiting.shift();
+            // Resolve on next microtick to avoid stack issues
+            queueMicrotask(next);
+        }
+        else {
+            this.permits++;
+        }
+    }
+    /** Current number of available permits (useful for testing). */
+    get available() {
+        return this.permits;
+    }
+}
+/**
+ * Partition an array of calls into consecutive segments:
+ *   - Consecutive safe calls → parallel segment
+ *   - Each non-safe call → its own sequential segment
+ */
+function partitionCalls(calls) {
+    const segments = [];
+    let currentSafe = [];
+    for (let i = 0; i < calls.length; i++) {
+        if (calls[i].isConcurrencySafe) {
+            currentSafe.push(i);
+        }
+        else {
+            // Flush any accumulated safe calls as a parallel batch
+            if (currentSafe.length > 0) {
+                segments.push({ kind: 'parallel', indices: currentSafe });
+                currentSafe = [];
+            }
+            segments.push({ kind: 'sequential', indices: [i] });
+        }
+    }
+    // Flush trailing safe calls
+    if (currentSafe.length > 0) {
+        segments.push({ kind: 'parallel', indices: currentSafe });
+    }
+    return segments;
+}
+// ============================================================================
+// BatchToolExecutor
+// ============================================================================
+const DEFAULT_MAX_CONCURRENCY = 10;
+const ENV_KEY = 'AQE_MAX_TOOL_CONCURRENCY';
+export class BatchToolExecutor {
+    maxConcurrency;
+    constructor(maxConcurrency) {
+        if (maxConcurrency !== undefined) {
+            this.maxConcurrency = maxConcurrency;
+        }
+        else {
+            const envVal = process.env[ENV_KEY];
+            this.maxConcurrency =
+                envVal && !isNaN(Number(envVal)) && Number(envVal) >= 1
+                    ? Number(envVal)
+                    : DEFAULT_MAX_CONCURRENCY;
+        }
+    }
+    /**
+     * Execute a batch of tool calls respecting concurrency safety annotations.
+     *
+     * @returns BatchResult with results in the same order as the input calls.
+     */
+    async executeBatch(calls) {
+        if (calls.length === 0) {
+            return {
+                results: [],
+                parallelBatches: 0,
+                sequentialCalls: 0,
+                totalWallTimeMs: 0,
+            };
+        }
+        const startTime = Date.now();
+        const segments = partitionCalls(calls);
+        const results = new Array(calls.length);
+        let parallelBatches = 0;
+        let sequentialCalls = 0;
+        const semaphore = new Semaphore(this.maxConcurrency);
+        for (const segment of segments) {
+            if (segment.kind === 'parallel') {
+                parallelBatches++;
+                const batchResults = await Promise.all(segment.indices.map(async (idx) => {
+                    await semaphore.acquire();
+                    try {
+                        return await calls[idx].handler();
+                    }
+                    finally {
+                        semaphore.release();
+                    }
+                }));
+                // Place results back at original indices
+                for (let j = 0; j < segment.indices.length; j++) {
+                    results[segment.indices[j]] = batchResults[j];
+                }
+            }
+            else {
+                // Sequential: exactly one call
+                sequentialCalls++;
+                const idx = segment.indices[0];
+                results[idx] = await calls[idx].handler();
+            }
+        }
+        return {
+            results,
+            parallelBatches,
+            sequentialCalls,
+            totalWallTimeMs: Date.now() - startTime,
+        };
+    }
+}
+//# sourceMappingURL=batch-executor.js.map