agentic-qe 3.8.13 → 3.9.0

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/http-server.js

@@ -14,6 +14,9 @@ import { createServer } from 'http';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { safeJsonParse } from '../shared/safe-json.js';
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+const _pkg = _require('../../package.json');
 // AG-UI imports
 import { createEventAdapter, } from '../adapters/ag-ui/index.js';
 // A2A imports
@@ -626,7 +629,7 @@ class HTTPServerImpl {
         res.setHeader('Content-Type', 'application/json');
         res.end(JSON.stringify({
             status: 'ok',
-            version: '3.0.0',
+            version: _pkg.version,
             protocols: ['ag-ui', 'a2a', 'a2ui'],
             agentCardsLoaded: this.agentCardsLoaded,
             agentCount: this.discoveryService.getAgentCount(),

package/dist/mcp/index.d.ts

@@ -8,9 +8,9 @@ export { getConnectionPool, initializeConnectionPool, shutdownConnectionPool, cr
 export { getLoadBalancer, resetLoadBalancer, createLoadBalancer, type AgentLoadInfo, type LoadBalancingStrategy, type LoadBalancerConfig, type LoadBalancerStats, DEFAULT_LOAD_BALANCER_CONFIG, } from './load-balancer';
 export { getPerformanceMonitor, resetPerformanceMonitor, createPerformanceMonitor, type LatencySample, type ToolExecutionMetric, type PoolMetric, type PerformanceAlert, type PerformanceReport, type PerformanceMonitorConfig, DEFAULT_MONITOR_CONFIG, } from './performance-monitor';
 export * from './handlers';
-export { MCPServer, createMCPServer } from './server';
-export { default } from './server';
 export * from './transport';
 export { MCPProtocolServer, createMCPProtocolServer, quickStart, type MCPServerConfig, type MCPCapabilities, type MCPServerInfo, } from './protocol-server';
+export { MCPProtocolServer as MCPServer } from './protocol-server';
+export { createMCPProtocolServer as createMCPServer } from './protocol-server';
 export { isToolAllowed, getToolScope, getAllowedTools, validateToolAccess, type AgentRole, type ToolScope, } from './tool-scoping';
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -14,13 +14,14 @@ export { getLoadBalancer, resetLoadBalancer, createLoadBalancer, DEFAULT_LOAD_BA
 export { getPerformanceMonitor, resetPerformanceMonitor, createPerformanceMonitor, DEFAULT_MONITOR_CONFIG, } from './performance-monitor';
 // Handlers
 export * from './handlers';
-// Server (legacy)
-export { MCPServer, createMCPServer } from './server';
-export { default } from './server';
 // Transport Layer
 export * from './transport';
-// Protocol Server (v3 - claude-flow pattern)
+// Protocol Server (production MCP server)
 export { MCPProtocolServer, createMCPProtocolServer, quickStart, } from './protocol-server';
+// Legacy aliases — server.ts was removed (dead code, never used in production).
+// MCPProtocolServer is the only server. These aliases prevent import breakage.
+export { MCPProtocolServer as MCPServer } from './protocol-server';
+export { createMCPProtocolServer as createMCPServer } from './protocol-server';
 // Per-Agent Tool Scoping
 export { isToolAllowed, getToolScope, getAllowedTools, validateToolAccess, } from './tool-scoping';
 //# sourceMappingURL=index.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

package/dist/mcp/middleware/microcompact.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Agentic QE v3 - Microcompact Engine (IMP-01)
+ *
+ * Tracks MCP tool results over time and evicts stale entries to reduce
+ * context-window pressure. Registers as a postToolResult middleware on the
+ * IMP-00 middleware chain.
+ *
+ * Eviction rules (applied in order on each compact() call):
+ *   1. Results older than `maxAgeMs` are cleared — unless they are among
+ *      the most recent `keepLastN` results.
+ *   2. If total estimated tokens still exceed `contextBudget * contextPressureThreshold`,
+ *      the oldest non-protected results are cleared until the budget is satisfied.
+ *
+ * Cleared entries have their content replaced with a sentinel string so
+ * downstream consumers can detect compacted slots.
+ */
+import type { ToolMiddleware } from './middleware-chain';
+export interface MicrocompactOptions {
+    maxAgeMs?: number;
+    keepLastN?: number;
+    contextPressureThreshold?: number;
+    contextBudget?: number;
+    sentinel?: string;
+}
+export interface ToolResultEntry {
+    toolName: string;
+    result: unknown;
+    timestamp: number;
+    estimatedTokens: number;
+    cleared: boolean;
+}
+export interface MicrocompactResult {
+    clearedCount: number;
+    tokensSaved: number;
+    totalResults: number;
+    totalTokens: number;
+}
+/**
+ * Padded heuristic for token estimation: ceil(chars / 3).
+ * Intentionally conservative — overestimates slightly to give headroom.
+ */
+export declare function estimateTokensPadded(content: unknown): number;
+export declare class MicrocompactEngine {
+    private entries;
+    private readonly maxAgeMs;
+    private readonly keepLastN;
+    private readonly pressureThreshold;
+    private readonly contextBudget;
+    private readonly sentinel;
+    constructor(options?: MicrocompactOptions);
+    /** Register a new tool result for tracking. */
+    addResult(toolName: string, result: unknown): void;
+    /**
+     * Run the two-pass eviction algorithm and return a summary.
+     *
+     * Pass 1 — age-based: clear anything older than `maxAgeMs`, except the
+     *          most recent `keepLastN` entries (regardless of age).
+     * Pass 2 — pressure-based: if total tokens still exceed the threshold,
+     *          clear the oldest non-protected entries one-by-one until under budget.
+     */
+    compact(): MicrocompactResult;
+    /** Return current tracking statistics. */
+    getStats(): {
+        totalResults: number;
+        clearedCount: number;
+        totalTokens: number;
+    };
+    /** Expose estimateTokensPadded as a static method for external callers. */
+    static estimateTokensPadded(content: unknown): number;
+    /** Read-only access to the internal entries (useful for testing). */
+    getEntries(): ReadonlyArray<ToolResultEntry>;
+}
+/**
+ * Result of createMicrocompactMiddleware — returns both the middleware
+ * and the engine so callers can share the engine with other subsystems
+ * (e.g., the compaction pipeline's Tier 1).
+ */
+export interface MicrocompactMiddlewareResult {
+    middleware: ToolMiddleware;
+    engine: MicrocompactEngine;
+}
+/**
+ * Create a ToolMiddleware that plugs the MicrocompactEngine into the
+ * IMP-00 middleware chain.
+ *
+ * The middleware:
+ *   - Records every tool result via `addResult()`
+ *   - Runs `compact()` to evict stale historical entries
+ *   - Returns the current result unchanged (compaction targets history)
+ *
+ * Priority 100 — runs after most other post-hooks.
+ *
+ * Returns both the middleware and the underlying engine so the engine
+ * can be shared with the compaction pipeline (IMP-08 Tier 1).
+ */
+export declare function createMicrocompactMiddleware(options?: MicrocompactOptions): MicrocompactMiddlewareResult;
+//# sourceMappingURL=microcompact.d.ts.map