agentic-qe 3.8.14 → 3.9.1

package/dist/mcp/protocol-server.js

@@ -7,6 +7,13 @@
  */
 import { createStdioTransport, JSON_RPC_ERRORS, } from './transport';
 import { createToolRegistry } from './tool-registry';
+import { MiddlewareChain } from './middleware/middleware-chain';
+import { createMicrocompactMiddleware } from './middleware/microcompact';
+import { SessionStore } from './services/session-store';
+import { createSessionDurabilityMiddleware } from './services/session-durability-middleware';
+import { withRetry } from '../shared/retry-engine';
+import { CompactionPipeline } from '../context/compaction';
+import { createLLMCompactCaller } from '../context/compaction/llm-caller-adapter';
 // AG-UI EventAdapter for streaming events
 import { createEventAdapter, } from '../adapters/ag-ui/index.js';
 import { handleFleetInit, handleFleetStatus, handleFleetHealth, handleAQEHealth, disposeFleet, handleTaskSubmit, handleTaskList, handleTaskStatus, handleTaskCancel, handleTaskOrchestrate, 
@@ -23,12 +30,16 @@ handleValidationPipeline,
 // Imp-9: YAML pipeline handlers
 handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, 
 // Cross-phase handlers
-handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseStart, handlePhaseEnd, handleCrossPhaseStats, handleFormatSignals, handleCrossPhaseCleanup, } from './handlers';
+handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseStart, handlePhaseEnd, handleCrossPhaseStats, handleFormatSignals, handleCrossPhaseCleanup, 
+// ADR-072: RVF Migration handlers
+handleMigrationStatus, handleMigrationCheck, handleMigrationPromote, } from './handlers';
 // ADR-039: Performance optimization imports
 import { registerMissingQETools } from './qe-tool-bridge.js';
 import { getConnectionPool, initializeConnectionPool, shutdownConnectionPool, } from './connection-pool';
 import { getLoadBalancer, } from './load-balancer';
 import { getPerformanceMonitor, } from './performance-monitor';
+// ADR-062: Loop detection for MCP tool calls
+import { ToolCallSignatureTracker } from '../kernel/anti-drift-middleware.js';
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 const _pkg = _require('../../package.json');
@@ -48,6 +59,14 @@ export class MCPProtocolServer {
     monitor = getPerformanceMonitor();
     // AG-UI EventAdapter for streaming events to HTTP clients
     eventAdapter;
+    // IMP-00: Middleware chain for pre/post tool-call hooks
+    middlewareChain;
+    // IMP-04: Session durability store
+    sessionStore;
+    // IMP-08: 4-tier context compaction pipeline
+    compactionPipeline;
+    // ADR-062: Loop detection tracker for MCP tool calls
+    loopTracker;
     // Connection recovery state
     reconnecting = false;
     pendingRequests = [];
@@ -64,6 +83,25 @@ export class MCPProtocolServer {
         this.registry = createToolRegistry();
         // Initialize AG-UI EventAdapter for streaming
         this.eventAdapter = createEventAdapter();
+        // IMP-00: Initialize middleware chain
+        this.middlewareChain = new MiddlewareChain();
+        // IMP-04: Initialize session store and register durability middleware
+        this.sessionStore = new SessionStore();
+        this.sessionStore.startSession();
+        this.middlewareChain.register(createSessionDurabilityMiddleware(this.sessionStore));
+        // IMP-01: Register microcompact middleware for stale result eviction
+        // Extract the engine so it can be shared with IMP-08's Tier 1
+        const microcompact = createMicrocompactMiddleware();
+        this.middlewareChain.register(microcompact.middleware);
+        // IMP-08: Initialize 4-tier compaction pipeline with shared microcompact engine
+        // and LLM caller for Tier 3 (falls back to extractive if no API key)
+        this.compactionPipeline = new CompactionPipeline({
+            sharedMicrocompactEngine: microcompact.engine,
+            llmCaller: createLLMCompactCaller(),
+        });
+        this.middlewareChain.register(this.compactionPipeline.createMiddleware());
+        // ADR-062: Initialize loop detection tracker
+        this.loopTracker = new ToolCallSignatureTracker();
         // Register all tools
         this.registerAllTools();
     }
@@ -119,52 +157,61 @@ export class MCPProtocolServer {
         if (this.reconnecting)
             return;
         this.reconnecting = true;
-        const maxAttempts = 3;
-        const baseDelay = 1000; // 1s, 2s, 4s
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            const delay = baseDelay * Math.pow(2, attempt);
-            console.error(`[MCP] Reconnect attempt ${attempt + 1}/${maxAttempts} in ${delay}ms...`);
-            await new Promise(r => setTimeout(r, delay));
-            try {
-                this.transport.reconnect();
-                console.error(`[MCP] Reconnected after ${attempt + 1} attempt(s)`);
-                this.reconnecting = false;
-                // Replay any buffered requests
-                const buffered = [...this.pendingRequests];
-                this.pendingRequests = [];
-                for (const { resolve, request } of buffered) {
-                    try {
-                        const result = await this.handleRequest(request);
-                        resolve(result);
-                    }
-                    catch (err) {
-                        console.error(`[MCP] Failed to replay buffered request: ${request.method}`);
-                    }
+        try {
+            // IMP-03: Use unified retry engine instead of hardcoded loop
+            const { attempts } = await withRetry(async () => { this.transport.reconnect(); }, {
+                maxAttempts: 3,
+                baseDelayMs: 1000,
+                maxDelayMs: 8000,
+                jitterFraction: 0.25,
+                onRetry: (attempt, _error, delayMs) => {
+                    console.error(`[MCP] Reconnect attempt ${attempt + 1}/3 in ${Math.round(delayMs)}ms...`);
+                },
+            });
+            console.error(`[MCP] Reconnected after ${attempts} attempt(s)`);
+            this.reconnecting = false;
+            // Replay any buffered requests
+            const buffered = [...this.pendingRequests];
+            this.pendingRequests = [];
+            for (const { resolve, request } of buffered) {
+                try {
+                    const result = await this.handleRequest(request);
+                    resolve(result);
+                }
+                catch (err) {
+                    console.error(`[MCP] Failed to replay buffered request: ${request.method}`);
                 }
-                return;
-            }
-            catch (err) {
-                console.error(`[MCP] Reconnect attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : err}`);
             }
         }
-        this.reconnecting = false;
-        console.error('[MCP] All reconnect attempts failed. Tools unavailable until transport is restored.');
-        // Reject all buffered requests
-        const buffered = [...this.pendingRequests];
-        this.pendingRequests = [];
-        for (const { reject } of buffered) {
-            reject(new Error('MCP connection lost and reconnect failed'));
+        catch {
+            this.reconnecting = false;
+            console.error('[MCP] All reconnect attempts failed. Tools unavailable until transport is restored.');
+            // Reject all buffered requests
+            const buffered = [...this.pendingRequests];
+            this.pendingRequests = [];
+            for (const { reject } of buffered) {
+                reject(new Error('MCP connection lost and reconnect failed'));
+            }
         }
     }
     /**
      * Stop the MCP server
      */
     async stop() {
+        this.sessionStore.close(); // IMP-04: Flush session before shutdown
         this.transport.stop();
         await disposeFleet();
         await shutdownConnectionPool();
         console.error('[MCP] Server stopped');
     }
+    /** IMP-00: Register a middleware into the tool-call chain. */
+    registerMiddleware(mw) {
+        this.middlewareChain.register(mw);
+    }
+    /** IMP-00: Get registered middleware (for testing/introspection). */
+    getMiddleware() {
+        return this.middlewareChain.getRegistered();
+    }
     /**
      * Get server capabilities
      */
@@ -309,29 +356,77 @@ export class MCPProtocolServer {
             toolName: name,
             timestamp: new Date().toISOString(),
         });
+        // IMP-00: Build middleware context
+        const ctx = {
+            toolName: name,
+            params: args,
+            timestamp: Date.now(),
+            metadata: { stepId },
+        };
+        // ADR-062: Loop detection — check for repeated identical tool calls
+        let loopSteeringPrefix = '';
+        if (process.env.AQE_LOOP_DETECTION_ENABLED !== 'false') {
+            try {
+                const loopResult = this.loopTracker.trackCall('mcp-client', name, args);
+                if (loopResult.action === 'steer') {
+                    // BLOCK the tool call — return error with steering message to break the loop
+                    return {
+                        content: [{ type: 'text', text: loopResult.steeringMessage || 'Loop detected: repeated identical tool call blocked.' }],
+                        isError: true,
+                    };
+                }
+                else if (loopResult.action === 'warn' && loopResult.steeringMessage) {
+                    loopSteeringPrefix = loopResult.steeringMessage + '\n\n';
+                }
+            }
+            catch {
+                // Loop detection must not break tool execution
+            }
+        }
         try {
-            const result = await tool.handler(args);
+            // IMP-00: Execute pre-tool-call middleware
+            const processedCtx = await this.middlewareChain.executePreHooks(ctx);
+            const result = await tool.handler(processedCtx.params);
             success = true;
+            // IMP-00: Execute post-tool-result middleware
+            const processedResult = await this.middlewareChain.executePostHooks(processedCtx, result);
             // Emit AG-UI result event for tool completion
             this.eventAdapter.adapt({
                 success: true,
-                data: result,
+                data: processedResult,
                 metadata: {
                     executionTime: performance.now() - startTime,
                     requestId: stepId,
                 },
             });
+            const resultText = JSON.stringify(processedResult, null, 2);
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify(result, null, 2),
+                        text: loopSteeringPrefix ? loopSteeringPrefix + resultText : resultText,
                     },
                 ],
             };
         }
         catch (err) {
             const error = err;
+            // IMP-08: Detect context overflow (413) and trigger reactive compaction
+            const errorMsg = error.message || '';
+            const is413 = errorMsg.includes('413')
+                || errorMsg.includes('context_length_exceeded')
+                || errorMsg.includes('maximum context length')
+                || errorMsg.includes('too many tokens');
+            if (is413) {
+                try {
+                    await this.compactionPipeline.handleOverflow('status_413');
+                }
+                catch {
+                    // Compaction failed — continue with error response
+                }
+            }
+            // IMP-00: Execute error middleware
+            await this.middlewareChain.executeErrorHooks(ctx, error);
             // Emit AG-UI result event for tool failure
             this.eventAdapter.adapt({
                 success: false,
@@ -380,6 +475,7 @@ export class MCPProtocolServer {
                 name: 'fleet_status',
                 description: 'Get fleet status: agents, tasks, health, and learning stats. Example: fleet_status({ verbose: true })',
                 category: 'core',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'verbose', type: 'boolean', description: 'Include detailed information', default: false },
                 ],
@@ -391,6 +487,7 @@ export class MCPProtocolServer {
                 name: 'fleet_health',
                 description: 'Check fleet and per-domain health status with load metrics. Example: fleet_health({ domain: "test-generation" })',
                 category: 'core',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Specific domain to check' },
                 ],
@@ -416,6 +513,7 @@ export class MCPProtocolServer {
                 name: 'task_list',
                 description: 'List tasks with optional status/limit filtering. Example: task_list({ status: "running", limit: 10 })',
                 category: 'task',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'status', type: 'string', description: 'Filter by status' },
                     { name: 'limit', type: 'number', description: 'Maximum results', default: 50 },
@@ -428,6 +526,7 @@ export class MCPProtocolServer {
                 name: 'task_status',
                 description: 'Get detailed status, progress, and result of a specific task. Example: task_status({ taskId: "abc-123" })',
                 category: 'task',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'taskId', type: 'string', description: 'Task ID', required: true },
                 ],
@@ -463,6 +562,7 @@ export class MCPProtocolServer {
                 name: 'agent_list',
                 description: 'List all active agents, optionally filtered by domain. Example: agent_list({ domain: "test-generation" })',
                 category: 'agent',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Filter by domain' },
                 ],
@@ -486,6 +586,7 @@ export class MCPProtocolServer {
                 name: 'agent_metrics',
                 description: 'Get CPU, memory, and task performance metrics for agents. Example: agent_metrics({ agentId: "agent-1" })',
                 category: 'agent',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'agentId', type: 'string', description: 'Specific agent ID' },
                 ],
@@ -497,6 +598,7 @@ export class MCPProtocolServer {
                 name: 'agent_status',
                 description: 'Get detailed status and current task of a specific agent. Example: agent_status({ agentId: "agent-1" })',
                 category: 'agent',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'agentId', type: 'string', description: 'Agent ID', required: true },
                 ],
@@ -509,6 +611,7 @@ export class MCPProtocolServer {
                 name: 'team_list',
                 description: 'List all active domain teams and their agent counts. Example: team_list({ domain: "coverage-analysis" })',
                 category: 'agent',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Filter by domain' },
                 ],
@@ -520,6 +623,7 @@ export class MCPProtocolServer {
                 name: 'team_health',
                 description: 'Get team health, agent utilization, and consensus status for a domain. Example: team_health({ domain: "security-compliance" })',
                 category: 'agent',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Domain to check', required: true },
                 ],
@@ -608,6 +712,7 @@ export class MCPProtocolServer {
                 name: 'coverage_analyze_sublinear',
                 description: 'Analyze code coverage with O(log n) sublinear algorithm and ML-powered gap detection. Example: coverage_analyze_sublinear({ target: "src/", detectGaps: true })',
                 category: 'domain',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'target', type: 'string', description: 'Target path to analyze' },
                     { name: 'detectGaps', type: 'boolean', description: 'Detect coverage gaps', default: true },
@@ -621,6 +726,7 @@ export class MCPProtocolServer {
                 name: 'quality_assess',
                 description: 'Assess code quality metrics and optionally run a pass/fail quality gate. Example: quality_assess({ runGate: true })',
                 category: 'domain',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'runGate', type: 'boolean', description: 'Run quality gate evaluation', default: false },
                 ],
@@ -685,6 +791,7 @@ export class MCPProtocolServer {
                 name: 'defect_predict',
                 description: 'Predict potential defects using AI analysis of code complexity and change history. Example: defect_predict({ target: "src/auth/" })',
                 category: 'domain',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'target', type: 'string', description: 'Target path' },
                 ],
@@ -697,6 +804,7 @@ export class MCPProtocolServer {
                 name: 'requirements_validate',
                 description: 'Validate requirements for completeness and generate BDD scenarios. Example: requirements_validate({ requirementsPath: "docs/requirements.md" })',
                 category: 'domain',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'requirementsPath', type: 'string', description: 'Path to requirements' },
                 ],
@@ -709,6 +817,7 @@ export class MCPProtocolServer {
                 name: 'code_index',
                 description: 'Index source code into the knowledge graph for dependency and impact analysis. Example: code_index({ target: "src/" })',
                 category: 'domain',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'target', type: 'string', description: 'Target path' },
                 ],
@@ -734,6 +843,7 @@ export class MCPProtocolServer {
                 name: 'memory_retrieve',
                 description: 'Retrieve a value by key from memory. Example: memory_retrieve({ key: "pattern-auth", namespace: "patterns" })',
                 category: 'memory',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'key', type: 'string', description: 'Memory key', required: true },
                     { name: 'namespace', type: 'string', description: 'Memory namespace', default: 'default' },
@@ -746,6 +856,7 @@ export class MCPProtocolServer {
                 name: 'memory_query',
                 description: 'Query memory using glob patterns or HNSW semantic vector search. Example: memory_query({ pattern: "auth*", namespace: "patterns" }) or memory_query({ pattern: "authentication best practices", semantic: true })',
                 category: 'memory',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'pattern', type: 'string', description: 'Key pattern (glob) or natural language query (for semantic search)' },
                     { name: 'namespace', type: 'string', description: 'Memory namespace' },
@@ -771,6 +882,7 @@ export class MCPProtocolServer {
                 name: 'memory_usage',
                 description: 'Get memory usage statistics: entry counts, namespaces, and storage size. Example: memory_usage({})',
                 category: 'memory',
+                isConcurrencySafe: true,
                 parameters: [],
             },
             handler: () => handleMemoryUsage(),
@@ -813,6 +925,7 @@ export class MCPProtocolServer {
                 name: 'routing_metrics',
                 description: 'Get model routing statistics: tier distribution, cost savings, and routing log. Example: routing_metrics({ includeLog: true, logLimit: 20 })',
                 category: 'routing',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'includeLog', type: 'boolean', description: 'Include routing log entries', default: false },
                     { name: 'logLimit', type: 'number', description: 'Max log entries to return', default: 100 },
@@ -825,6 +938,7 @@ export class MCPProtocolServer {
                 name: 'routing_economics',
                 description: 'Get economic routing report: tier efficiency, budget status, cost-per-quality analysis, and savings opportunities. Example: routing_economics({ taskComplexity: 0.5 })',
                 category: 'routing',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'taskComplexity', type: 'number', description: 'Task complexity score 0-1 for tier scoring (default: 0.5)', default: 0.5 },
                 ],
@@ -837,6 +951,7 @@ export class MCPProtocolServer {
                 name: 'infra_healing_status',
                 description: 'Get infrastructure self-healing status: detected failures, recovery stats, and failing services. Example: infra_healing_status({ verbose: true })',
                 category: 'infra-healing',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'verbose', type: 'boolean', description: 'Include detailed observation data', default: false },
                 ],
@@ -886,6 +1001,7 @@ export class MCPProtocolServer {
                 name: 'cross_phase_query',
                 description: 'Query cross-phase signals by loop type with optional filters',
                 category: 'cross-phase',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'loop', type: 'string', description: 'Feedback loop type', required: true, enum: ['strategic', 'tactical', 'operational', 'quality-criteria'] },
                     { name: 'maxAge', type: 'string', description: 'Maximum signal age (e.g., "30d", "24h")' },
@@ -935,6 +1051,7 @@ export class MCPProtocolServer {
                 name: 'cross_phase_stats',
                 description: 'Get cross-phase memory statistics (total signals, by loop, by namespace)',
                 category: 'cross-phase',
+                isConcurrencySafe: true,
                 parameters: [],
             },
             handler: () => handleCrossPhaseStats(),
@@ -944,6 +1061,7 @@ export class MCPProtocolServer {
                 name: 'format_signals',
                 description: 'Format cross-phase signals for injection into agent prompts',
                 category: 'cross-phase',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'signals', type: 'array', description: 'Signals to format', required: true },
                 ],
@@ -1010,6 +1128,7 @@ export class MCPProtocolServer {
                 name: 'pipeline_list',
                 description: 'List all loaded YAML pipelines. Example: pipeline_list({})',
                 category: 'coordination',
+                isConcurrencySafe: true,
                 parameters: [],
             },
             handler: (params) => handlePipelineList(params),
@@ -1019,6 +1138,7 @@ export class MCPProtocolServer {
                 name: 'pipeline_validate',
                 description: 'Validate a YAML pipeline definition without loading it. Example: pipeline_validate({ yaml: "name: test\\nsteps: ..." })',
                 category: 'coordination',
+                isConcurrencySafe: true,
                 parameters: [
                     { name: 'yaml', type: 'string', description: 'YAML pipeline definition to validate', required: true },
                     { name: 'variables', type: 'object', description: 'Variable substitutions for validation' },
@@ -1034,18 +1154,21 @@ export class MCPProtocolServer {
                 name: 'session_cache_stats',
                 description: 'Get session operation cache statistics: hit rate, cache size, tokens saved via O(1) fingerprint reuse. Example: session_cache_stats({})',
                 category: 'learning',
+                isConcurrencySafe: true,
                 parameters: [],
             },
             handler: async () => {
                 try {
                     const { getSessionCache } = await import('../optimization/session-cache.js');
                     const stats = getSessionCache().getStats();
+                    const compactionStats = this.compactionPipeline.getStats();
                     return {
                         success: true,
                         data: {
                             ...stats,
                             hitRatePercent: `${(stats.hitRate * 100).toFixed(1)}%`,
                             description: 'Session cache provides O(1) exact-match lookups before HNSW similarity search',
+                            compaction: compactionStats,
                         },
                     };
                 }
@@ -1065,10 +1188,43 @@ export class MCPProtocolServer {
                 name: 'aqe_health',
                 description: 'Check AQE server health: returns status, loaded domains, memory stats, HNSW index status, and pattern count. Example: aqe_health({})',
                 category: 'core',
+                isConcurrencySafe: true,
                 parameters: [],
             },
             handler: () => handleAQEHealth(),
         });
+        // ADR-072 Phase 3: RVF Migration tools
+        this.registerTool({
+            definition: {
+                name: 'migration_status',
+                description: 'Get RVF migration status: current stage, metrics, consistency, and gate evaluation. Example: migration_status({})',
+                category: 'persistence',
+                isConcurrencySafe: true,
+                parameters: [],
+            },
+            handler: () => handleMigrationStatus(),
+        });
+        this.registerTool({
+            definition: {
+                name: 'migration_check',
+                description: 'Run a consistency check comparing SQLite and RVF search results. Samples random patterns and reports divergences. Example: migration_check({})',
+                category: 'persistence',
+                isConcurrencySafe: true,
+                parameters: [],
+            },
+            handler: () => handleMigrationCheck(),
+        });
+        this.registerTool({
+            definition: {
+                name: 'migration_promote',
+                description: 'Attempt to promote to the next RVF migration stage. Evaluates stage gate criteria. Example: migration_promote({ force: false })',
+                category: 'persistence',
+                parameters: [
+                    { name: 'force', type: 'boolean', description: 'Skip gate checks and force promotion', default: false },
+                ],
+            },
+            handler: (params) => handleMigrationPromote(params),
+        });
         // Register QE domain tools not already covered by hardcoded handlers above
         const bridgedCount = registerMissingQETools((entry) => this.registerTool(entry));
         console.error(`[MCP] Registered ${this.tools.size} tools (${bridgedCount} via QE bridge)`);

package/dist/mcp/services/session-durability-middleware.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Agentic QE v3 - Session Durability Middleware
+ *
+ * IMP-04: Transcript-First Session Durability
+ * Middleware factory that registers pre/post/error hooks on the
+ * MiddlewareChain to log every tool call lifecycle event into
+ * the SessionStore.
+ *
+ * @module mcp/services/session-durability-middleware
+ */
+import type { ToolMiddleware } from '../middleware/middleware-chain';
+import type { SessionStore } from './session-store';
+/**
+ * Creates a ToolMiddleware that appends session entries for every
+ * tool call, result, and error. Registers at priority 50.
+ *
+ * - preToolCall:  appends a `tool_call` entry with state='running'
+ * - postToolResult: appends a `tool_result` entry with state='idle'
+ * - onError: appends an `error` entry with state='requires_action'
+ */
+export declare function createSessionDurabilityMiddleware(store: SessionStore): ToolMiddleware;
+//# sourceMappingURL=session-durability-middleware.d.ts.map

package/dist/mcp/services/session-durability-middleware.js

@@ -0,0 +1,64 @@
+/**
+ * Agentic QE v3 - Session Durability Middleware
+ *
+ * IMP-04: Transcript-First Session Durability
+ * Middleware factory that registers pre/post/error hooks on the
+ * MiddlewareChain to log every tool call lifecycle event into
+ * the SessionStore.
+ *
+ * @module mcp/services/session-durability-middleware
+ */
+// ============================================================================
+// Middleware Factory
+// ============================================================================
+/**
+ * Creates a ToolMiddleware that appends session entries for every
+ * tool call, result, and error. Registers at priority 50.
+ *
+ * - preToolCall:  appends a `tool_call` entry with state='running'
+ * - postToolResult: appends a `tool_result` entry with state='idle'
+ * - onError: appends an `error` entry with state='requires_action'
+ */
+export function createSessionDurabilityMiddleware(store) {
+    const disabled = process.env.AQE_SESSION_DURABILITY === 'false';
+    return {
+        name: 'session-durability',
+        priority: 50,
+        async preToolCall(context) {
+            if (disabled)
+                return context;
+            store.append({
+                timestamp: context.timestamp,
+                type: 'tool_call',
+                toolName: context.toolName,
+                params: context.params,
+                state: 'running',
+            });
+            return context;
+        },
+        async postToolResult(context, result) {
+            if (disabled)
+                return result;
+            store.append({
+                timestamp: Date.now(),
+                type: 'tool_result',
+                toolName: context.toolName,
+                result,
+                state: 'idle',
+            });
+            return result;
+        },
+        async onError(context, error) {
+            if (disabled)
+                return;
+            store.append({
+                timestamp: Date.now(),
+                type: 'error',
+                toolName: context.toolName,
+                result: { message: error.message, stack: error.stack },
+                state: 'requires_action',
+            });
+        },
+    };
+}
+//# sourceMappingURL=session-durability-middleware.js.map

package/dist/mcp/services/session-resume.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Agentic QE v3 - Session Resume Service
+ *
+ * IMP-04: Transcript-First Session Durability
+ * Reads an existing JSONL session file by sampling the head (first 4KB)
+ * and tail (last 64KB) to reconstruct metadata and recent entries
+ * without reading the entire file.
+ *
+ * @module mcp/services/session-resume
+ */
+import type { SessionEntry, SessionMetadata } from './session-store';
+export interface SessionResumeResult {
+    metadata: SessionMetadata;
+    recentEntries: SessionEntry[];
+    lastState: 'idle' | 'running' | 'requires_action';
+    canResume: boolean;
+}
+/**
+ * Resume a session from a JSONL file.
+ *
+ * Reads the first 4KB (head) to extract session start metadata and
+ * the last 64KB (tail) to get recent entries. Parses JSONL lines,
+ * reconstructs the parentUuid linked list, and returns metadata +
+ * recent entries + resume capability.
+ *
+ * Corrupt or incomplete lines are skipped gracefully.
+ */
+export declare function resumeSession(filePath: string): SessionResumeResult;
+//# sourceMappingURL=session-resume.d.ts.map