agentic-qe 3.8.10 → 3.8.12

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

@@ -0,0 +1,67 @@
+/**
+ * Heartbeat MCP Handlers (Imp-10)
+ *
+ * Exposes the token-free heartbeat scheduler through MCP tools:
+ * - heartbeat_status: Returns current heartbeat health and metrics
+ * - heartbeat_trigger: Triggers an immediate heartbeat cycle
+ * - heartbeat_log: Returns daily log entries for a given date
+ */
+import type { ToolResult } from '../types.js';
+export type HeartbeatStatusParams = Record<string, never>;
+export interface HeartbeatStatusResult {
+    status: string;
+    healthScore: number;
+    totalExecutions: number;
+    successfulExecutions: number;
+    failedExecutions: number;
+    avgDurationMs: number;
+    lastRunAt: string | null;
+    nextRunAt: string | null;
+    lastResult: {
+        success: boolean;
+        durationMs: number;
+        healthScore: number;
+        trend: string;
+        domainMetrics: Record<string, number | string>;
+    } | null;
+}
+export interface HeartbeatTriggerParams {
+    /** Optional: timeout in milliseconds (default: 60000) */
+    timeout?: number;
+}
+export interface HeartbeatTriggerResult {
+    success: boolean;
+    durationMs: number;
+    healthScore: number;
+    trend: string;
+    promoted: number;
+    deprecated: number;
+    decayed: number;
+    pendingExperiences: number;
+    avgConfidence: number;
+    findingsCount: number;
+    recommendationsCount: number;
+}
+export interface HeartbeatLogParams {
+    /** Date in YYYY-MM-DD format (defaults to today) */
+    date?: string;
+}
+export interface HeartbeatLogResult {
+    date: string;
+    exists: boolean;
+    content: string;
+    lineCount: number;
+}
+/**
+ * Get the current heartbeat scheduler status and health metrics.
+ */
+export declare function handleHeartbeatStatus(_params: HeartbeatStatusParams): Promise<ToolResult<HeartbeatStatusResult>>;
+/**
+ * Trigger an immediate heartbeat cycle and return the result.
+ */
+export declare function handleHeartbeatTrigger(params: HeartbeatTriggerParams): Promise<ToolResult<HeartbeatTriggerResult>>;
+/**
+ * Read the daily log for a given date (defaults to today).
+ */
+export declare function handleHeartbeatLog(params: HeartbeatLogParams): Promise<ToolResult<HeartbeatLogResult>>;
+//# sourceMappingURL=heartbeat-handlers.d.ts.map

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

@@ -0,0 +1,180 @@
+/**
+ * Heartbeat MCP Handlers (Imp-10)
+ *
+ * Exposes the token-free heartbeat scheduler through MCP tools:
+ * - heartbeat_status: Returns current heartbeat health and metrics
+ * - heartbeat_trigger: Triggers an immediate heartbeat cycle
+ * - heartbeat_log: Returns daily log entries for a given date
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { HeartbeatSchedulerWorker } from '../../workers/workers/heartbeat-scheduler.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+import { findProjectRoot } from '../../kernel/unified-memory.js';
+// ============================================================================
+// Shared State
+// ============================================================================
+let sharedWorker = null;
+function getWorker() {
+    if (!sharedWorker) {
+        sharedWorker = new HeartbeatSchedulerWorker();
+    }
+    return sharedWorker;
+}
+// ============================================================================
+// Handlers
+// ============================================================================
+/**
+ * Get the current heartbeat scheduler status and health metrics.
+ */
+export async function handleHeartbeatStatus(_params) {
+    try {
+        const worker = getWorker();
+        await worker.initialize();
+        const health = worker.getHealth();
+        const lastResult = worker.lastResult;
+        return {
+            success: true,
+            data: {
+                status: health.status,
+                healthScore: health.healthScore,
+                totalExecutions: health.totalExecutions,
+                successfulExecutions: health.successfulExecutions,
+                failedExecutions: health.failedExecutions,
+                avgDurationMs: health.avgDurationMs,
+                lastRunAt: worker.lastRunAt?.toISOString() ?? null,
+                nextRunAt: worker.nextRunAt?.toISOString() ?? null,
+                lastResult: lastResult
+                    ? {
+                        success: lastResult.success,
+                        durationMs: lastResult.durationMs,
+                        healthScore: lastResult.metrics.healthScore,
+                        trend: lastResult.metrics.trend,
+                        domainMetrics: lastResult.metrics.domainMetrics,
+                    }
+                    : null,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get heartbeat status: ${toErrorMessage(error)}`,
+        };
+    }
+}
+/**
+ * Trigger an immediate heartbeat cycle and return the result.
+ */
+export async function handleHeartbeatTrigger(params) {
+    try {
+        const worker = getWorker();
+        await worker.initialize();
+        const abortController = new AbortController();
+        // The worker already enforces its own 60s timeout via BaseWorker.executeWithTimeout().
+        // Only add an external abort if the caller explicitly requests a *shorter* timeout.
+        const userTimeout = params.timeout && params.timeout > 0 ? params.timeout : null;
+        const timeoutHandle = userTimeout
+            ? setTimeout(() => abortController.abort(), userTimeout)
+            : null;
+        let result;
+        try {
+            result = await worker.execute({
+                eventBus: { publish: async () => { } },
+                memory: {
+                    get: async () => undefined,
+                    set: async () => { },
+                    search: async () => [],
+                },
+                logger: {
+                    debug: () => { },
+                    info: () => { },
+                    warn: () => { },
+                    error: () => { },
+                },
+                domains: {
+                    getDomainAPI: () => undefined,
+                    getDomainHealth: () => ({ status: 'healthy', errors: [] }),
+                },
+                signal: abortController.signal,
+            });
+        }
+        finally {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+        }
+        const dm = result.metrics.domainMetrics;
+        return {
+            success: true,
+            data: {
+                success: result.success,
+                durationMs: result.durationMs,
+                healthScore: result.metrics.healthScore,
+                trend: result.metrics.trend,
+                promoted: Number(dm.promoted ?? 0),
+                deprecated: Number(dm.deprecated ?? 0),
+                decayed: Number(dm.decayed ?? 0),
+                pendingExperiences: Number(dm.pendingExperiences ?? 0),
+                avgConfidence: Number(dm.avgConfidence ?? 0),
+                findingsCount: result.findings.length,
+                recommendationsCount: result.recommendations.length,
+            },
+        };
+    }
+    catch (error) {
+        const msg = toErrorMessage(error);
+        const isTimeout = msg.includes('aborted') || msg.includes('abort') || msg.includes('timed out');
+        return {
+            success: false,
+            error: isTimeout
+                ? `Heartbeat timed out after ${params.timeout ?? 60000}ms`
+                : `Failed to trigger heartbeat: ${msg}`,
+        };
+    }
+}
+/**
+ * Read the daily log for a given date (defaults to today).
+ */
+export async function handleHeartbeatLog(params) {
+    try {
+        const targetDate = params.date || new Date().toISOString().split('T')[0];
+        // Validate date format
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(targetDate)) {
+            return {
+                success: false,
+                error: "Invalid date format. Use YYYY-MM-DD (e.g., '2026-03-27').",
+            };
+        }
+        const logDir = path.join(findProjectRoot(), '.agentic-qe', 'logs');
+        const logPath = path.join(logDir, `${targetDate}.md`);
+        if (!fs.existsSync(logPath)) {
+            return {
+                success: true,
+                data: {
+                    date: targetDate,
+                    exists: false,
+                    content: '',
+                    lineCount: 0,
+                },
+            };
+        }
+        const content = fs.readFileSync(logPath, 'utf-8');
+        const lineCount = content.split('\n').filter((l) => l.trim()).length;
+        return {
+            success: true,
+            data: {
+                date: targetDate,
+                exists: true,
+                content,
+                lineCount,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to read heartbeat log: ${toErrorMessage(error)}`,
+        };
+    }
+}
+//# sourceMappingURL=heartbeat-handlers.js.map

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

@@ -3,7 +3,7 @@
  * Exports all MCP tool handlers
  */
 export { handleFleetInit, handleFleetStatus, handleFleetHealth, handleAQEHealth, getFleetState, isFleetInitialized, disposeFleet, } from './core-handlers';
-export { handleTaskSubmit, handleTaskList, handleTaskStatus, handleTaskCancel, handleTaskOrchestrate, handleModelRoute, handleRoutingMetrics, type TaskOrchestrateResult, type ModelRouteParams, type ModelRouteResult, type RoutingMetricsParams, type RoutingMetricsResult, } from './task-handlers';
+export { handleTaskSubmit, handleTaskList, handleTaskStatus, handleTaskCancel, handleTaskOrchestrate, handleModelRoute, handleRoutingMetrics, handleRoutingEconomics, type TaskOrchestrateResult, type ModelRouteParams, type ModelRouteResult, type RoutingMetricsParams, type RoutingMetricsResult, } from './task-handlers';
 export { handleAgentList, handleAgentSpawn, handleAgentMetrics, handleAgentStatus, } from './agent-handlers';
 export { handleTestGenerate, handleTestExecute, handleCoverageAnalyze, handleQualityAssess, handleSecurityScan, handleContractValidate, handleAccessibilityTest, handleChaosTest, handleDefectPredict, handleRequirementsValidate, handleCodeIndex, resetTaskExecutor, } from './wrapped-domain-handlers.js';
 export { handleInfraHealingStatus, handleInfraHealingFeedOutput, handleInfraHealingRecover, setInfraHealingOrchestrator, } from './domain-handlers';
@@ -12,5 +12,6 @@ export { handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemor
 export { handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, type PipelineLoadParams, type PipelineLoadResult, type PipelineRunParams, type PipelineRunResult, type PipelineListParams, type PipelineListResult, type PipelineValidateParams, type PipelineValidateResult, } from './pipeline-handlers.js';
 export { handleValidationPipeline, type ValidationPipelineParams, type ValidationPipelineResult, } from './validation-pipeline-handler.js';
 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';
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp/handlers/index.js

@@ -7,7 +7,9 @@ export { handleFleetInit, handleFleetStatus, handleFleetHealth, handleAQEHealth,
 // Task handlers
 export { handleTaskSubmit, handleTaskList, handleTaskStatus, handleTaskCancel, handleTaskOrchestrate, 
 // ADR-051: Model routing handlers
-handleModelRoute, handleRoutingMetrics, } from './task-handlers';
+handleModelRoute, handleRoutingMetrics, 
+// Imp-18: Economic routing handler
+handleRoutingEconomics, } from './task-handlers';
 // Agent handlers
 export { handleAgentList, handleAgentSpawn, handleAgentMetrics, handleAgentStatus, } from './agent-handlers';
 // Domain handlers (wrapped with experience capture - ADR-051)
@@ -24,6 +26,8 @@ export { handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipeli
 export { handleValidationPipeline, } from './validation-pipeline-handler.js';
 // Hypergraph query handler
 export { handleHypergraphQuery, } from './hypergraph-handler.js';
+// Heartbeat handlers (Imp-10: Token-Free Heartbeat Scheduler)
+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';
 //# sourceMappingURL=index.js.map

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

@@ -126,6 +126,34 @@ export interface RoutingMetricsResult {
  * Handle routing metrics query
  */
 export declare function handleRoutingMetrics(params: RoutingMetricsParams): Promise<ToolResult<RoutingMetricsResult>>;
+export interface RoutingEconomicsParams {
+    /** Task complexity score 0-1 for tier scoring (default: 0.5) */
+    taskComplexity?: number;
+}
+export interface RoutingEconomicsResult {
+    tierEfficiency: Array<{
+        tier: string;
+        qualityScore: number;
+        estimatedCostUsd: number;
+        qualityPerDollar: number | string;
+        economicScore: number;
+    }>;
+    currentHourlyCostUsd: number;
+    currentDailyCostUsd: number;
+    budgetRemaining: {
+        hourly: number | null;
+        daily: number | null;
+    };
+    recommendation: string;
+    savingsOpportunity: {
+        usd: number;
+        description: string;
+    } | null;
+}
+/**
+ * Handle economic routing report query
+ */
+export declare function handleRoutingEconomics(params: RoutingEconomicsParams): Promise<ToolResult<RoutingEconomicsResult>>;
 export interface TaskOutcomeRecordParams {
     /** Task ID */
     taskId: string;

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

@@ -466,6 +466,45 @@ export async function handleRoutingMetrics(params) {
         };
     }
 }
+/**
+ * Handle economic routing report query
+ */
+export async function handleRoutingEconomics(params) {
+    try {
+        const { createRoutingFeedbackCollector } = await import('../../routing/routing-feedback.js');
+        const { getGlobalCostTracker } = await import('../../shared/llm/cost-tracker.js');
+        // Create collector, initialize to load persisted state from DB, then enable economic routing
+        const collector = createRoutingFeedbackCollector(100);
+        await collector.initialize();
+        collector.enableEconomicRouting({ ...(params.taskComplexity != null ? {} : {}) }, getGlobalCostTracker());
+        const report = collector.getEconomicReport();
+        if (!report) {
+            return { success: false, error: 'Economic routing is not available' };
+        }
+        // Convert Infinity to string for JSON serialization
+        const tierEfficiency = report.tierEfficiency.map(t => ({
+            ...t,
+            qualityPerDollar: isFinite(t.qualityPerDollar) ? t.qualityPerDollar : 'Infinity',
+        }));
+        return {
+            success: true,
+            data: {
+                tierEfficiency,
+                currentHourlyCostUsd: report.currentHourlyCostUsd,
+                currentDailyCostUsd: report.currentDailyCostUsd,
+                budgetRemaining: report.budgetRemaining,
+                recommendation: report.recommendation,
+                savingsOpportunity: report.savingsOpportunity,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get economic routing report: ${toErrorMessage(error)}`,
+        };
+    }
+}
 // ============================================================================
 // Helper Functions
 // ============================================================================

package/dist/mcp/protocol-server.js

@@ -11,7 +11,9 @@ import { createToolRegistry } from './tool-registry';
 import { createEventAdapter, } from '../adapters/ag-ui/index.js';
 import { handleFleetInit, handleFleetStatus, handleFleetHealth, handleAQEHealth, disposeFleet, handleTaskSubmit, handleTaskList, handleTaskStatus, handleTaskCancel, handleTaskOrchestrate, 
 // ADR-051: Model routing handlers
-handleModelRoute, handleRoutingMetrics, handleAgentList, handleAgentSpawn, handleAgentMetrics, handleAgentStatus, handleTestGenerate, handleTestExecute, handleCoverageAnalyze, handleQualityAssess, handleSecurityScan, handleContractValidate, handleAccessibilityTest, handleChaosTest, handleDefectPredict, handleRequirementsValidate, handleCodeIndex, handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemoryDelete, handleMemoryUsage, handleMemoryShare, 
+handleModelRoute, handleRoutingMetrics, 
+// Imp-18: Economic routing handler
+handleRoutingEconomics, handleAgentList, handleAgentSpawn, handleAgentMetrics, handleAgentStatus, handleTestGenerate, handleTestExecute, handleCoverageAnalyze, handleQualityAssess, handleSecurityScan, handleContractValidate, handleAccessibilityTest, handleChaosTest, handleDefectPredict, handleRequirementsValidate, handleCodeIndex, handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemoryDelete, handleMemoryUsage, handleMemoryShare, 
 // ADR-057: Infrastructure self-healing handlers
 handleInfraHealingStatus, handleInfraHealingFeedOutput, handleInfraHealingRecover, 
 // ADR-064: Team handlers
@@ -809,6 +811,17 @@ export class MCPProtocolServer {
             },
             handler: (params) => handleRoutingMetrics(params),
         });
+        this.registerTool({
+            definition: {
+                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',
+                parameters: [
+                    { name: 'taskComplexity', type: 'number', description: 'Task complexity score 0-1 for tier scoring (default: 0.5)', default: 0.5 },
+                ],
+            },
+            handler: (params) => handleRoutingEconomics(params),
+        });
         // ADR-057: Infrastructure self-healing tools
         this.registerTool({
             definition: {
@@ -1005,6 +1018,37 @@ export class MCPProtocolServer {
             handler: (params) => handlePipelineValidate(params),
         });
         // =========================================================================
+        // Imp-15: Session Cache Stats
+        // =========================================================================
+        this.registerTool({
+            definition: {
+                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',
+                parameters: [],
+            },
+            handler: async () => {
+                try {
+                    const { getSessionCache } = await import('../optimization/session-cache.js');
+                    const stats = getSessionCache().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',
+                        },
+                    };
+                }
+                catch (err) {
+                    return {
+                        success: false,
+                        error: `Failed to get session cache stats: ${err instanceof Error ? err.message : String(err)}`,
+                    };
+                }
+            },
+        });
+        // =========================================================================
         // OpenCode Integration: Health Endpoint
         // =========================================================================
         this.registerTool({

package/dist/mcp/server.js

@@ -21,7 +21,9 @@ handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseSt
 // Pipeline handlers (Imp-9: YAML Deterministic Pipelines)
 handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, 
 // Validation Pipeline handler (BMAD-003)
-handleValidationPipeline, } from './handlers';
+handleValidationPipeline, 
+// Heartbeat handlers (Imp-10: Token-Free Heartbeat Scheduler)
+handleHeartbeatStatus, handleHeartbeatTrigger, handleHeartbeatLog, } from './handlers';
 // ============================================================================
 // Tool Definitions
 // ============================================================================
@@ -672,6 +674,43 @@ const PIPELINE_TOOLS = [
         handler: handlePipelineValidate,
     },
 ];
+// Imp-10: Token-Free Heartbeat Scheduler
+const HEARTBEAT_TOOLS = [
+    // Heartbeat Status
+    {
+        definition: {
+            name: 'mcp__agentic_qe__heartbeat_status',
+            description: 'Get heartbeat scheduler status, health metrics, and last result',
+            category: 'core',
+            parameters: [],
+        },
+        handler: handleHeartbeatStatus,
+    },
+    // Heartbeat Trigger
+    {
+        definition: {
+            name: 'mcp__agentic_qe__heartbeat_trigger',
+            description: 'Trigger an immediate heartbeat maintenance cycle (SQL-only, zero tokens)',
+            category: 'core',
+            parameters: [
+                { name: 'timeout', type: 'number', description: 'Timeout in milliseconds (default: 60000)' },
+            ],
+        },
+        handler: handleHeartbeatTrigger,
+    },
+    // Heartbeat Log
+    {
+        definition: {
+            name: 'mcp__agentic_qe__heartbeat_log',
+            description: 'Read the daily heartbeat log for a specific date',
+            category: 'core',
+            parameters: [
+                { name: 'date', type: 'string', description: 'Date in YYYY-MM-DD format (defaults to today)' },
+            ],
+        },
+        handler: handleHeartbeatLog,
+    },
+];
 // ============================================================================
 export class MCPServer {
     registry;
@@ -695,6 +734,7 @@ export class MCPServer {
             ...MEMORY_TOOLS,
             ...CROSS_PHASE_TOOLS,
             ...PIPELINE_TOOLS,
+            ...HEARTBEAT_TOOLS,
         ];
         this.registry.registerAll(allTools);
         this.initialized = true;

package/dist/optimization/index.d.ts

@@ -17,4 +17,6 @@ export type { EarlyExitConfig as TokenEarlyExitConfig, EarlyExitResult as TokenE
 export { EarlyExitTokenOptimizer, createEarlyExitTokenOptimizer, createAggressiveTokenOptimizer, createConservativeTokenOptimizer, DEFAULT_EARLY_EXIT_CONFIG, AGGRESSIVE_EARLY_EXIT_CONFIG, CONSERVATIVE_EARLY_EXIT_CONFIG, } from './early-exit-token-optimizer.js';
 export type { TokenOptimizerServiceConfig, } from './token-optimizer-service.js';
 export { TokenOptimizerService, initializeTokenOptimizer, } from './token-optimizer-service.js';
+export type { CachedOperation, SessionCacheConfig, SessionCacheStats, } from './session-cache.js';
+export { SessionOperationCache, DEFAULT_SESSION_CACHE_CONFIG, getSessionCache, resetSessionCache, } from './session-cache.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/optimization/index.js

@@ -13,4 +13,5 @@ export { AQEAutoTuner, createAutoTuner, DefaultParameterApplicatorRegistry, crea
 export { QE_OPTIMIZATION_WORKER_CONFIGS, PatternConsolidatorWorker, DreamConsolidatorWorker, CoverageGapScannerWorker, FlakyTestDetectorWorker, RoutingAccuracyMonitorWorker, createPatternConsolidatorWorker, createDreamConsolidatorWorker, createCoverageGapScannerWorker, createFlakyTestDetectorWorker, createRoutingAccuracyMonitorWorker, } from './qe-workers.js';
 export { EarlyExitTokenOptimizer, createEarlyExitTokenOptimizer, createAggressiveTokenOptimizer, createConservativeTokenOptimizer, DEFAULT_EARLY_EXIT_CONFIG, AGGRESSIVE_EARLY_EXIT_CONFIG, CONSERVATIVE_EARLY_EXIT_CONFIG, } from './early-exit-token-optimizer.js';
 export { TokenOptimizerService, initializeTokenOptimizer, } from './token-optimizer-service.js';
+export { SessionOperationCache, DEFAULT_SESSION_CACHE_CONFIG, getSessionCache, resetSessionCache, } from './session-cache.js';
 //# sourceMappingURL=index.js.map

package/dist/optimization/session-cache.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Agentic QE v3 - Session Operation Cache
+ * Imp-15: Session Reuse for Repeated Operations
+ *
+ * Lightweight fingerprint-based cache for operation results that provides
+ * O(1) exact-match lookups before falling back to HNSW similarity search.
+ * Supplements (does not replace) the EarlyExitTokenOptimizer.
+ *
+ * Architecture:
+ * - SHA-256 fingerprint from canonicalized (domain + action + input)
+ * - In-memory Map for O(1) lookups
+ * - Optional SQLite persistence via kv_store (namespace: 'session_cache')
+ * - TTL-based expiry, LRU-ish eviction at capacity
+ */
+export interface CachedOperation {
+    fingerprint: string;
+    domain: string;
+    action: string;
+    result: Record<string, unknown>;
+    tokensSaved: number;
+    cachedAt: number;
+    hitCount: number;
+    lastHitAt: number;
+}
+export interface SessionCacheConfig {
+    /** Enable the cache (default: true) */
+    enabled: boolean;
+    /** Maximum entries in memory (default: 500) */
+    maxEntries: number;
+    /** TTL in milliseconds (default: 1 hour) */
+    ttlMs: number;
+    /** Persist across sessions via SQLite kv_store (default: true) */
+    persistToDb: boolean;
+}
+export interface SessionCacheStats {
+    size: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+    estimatedTokensSaved: number;
+}
+export declare const DEFAULT_SESSION_CACHE_CONFIG: SessionCacheConfig;
+export declare class SessionOperationCache {
+    private cache;
+    private config;
+    private hits;
+    private misses;
+    constructor(config?: Partial<SessionCacheConfig>);
+    /**
+     * Compute a deterministic fingerprint from domain + action + input.
+     * Uses SHA-256 of the canonicalized JSON (recursively sorted keys), truncated to 16 hex chars.
+     */
+    computeFingerprint(domain: string, action: string, input: Record<string, unknown>): string;
+    /**
+     * Look up a cached result by fingerprint.
+     * Returns null on miss or expired entry.
+     */
+    get(fingerprint: string): CachedOperation | null;
+    /**
+     * Store an operation result in the cache.
+     */
+    set(fingerprint: string, domain: string, action: string, result: Record<string, unknown>, estimatedTokens: number): void;
+    /**
+     * Load persisted cache entries from SQLite kv_store.
+     * Called on service initialization. Gracefully degrades if DB unavailable.
+     */
+    loadFromDb(): void;
+    /** Get cache statistics */
+    getStats(): SessionCacheStats;
+    /** Clear all cache entries and reset counters */
+    clear(): void;
+    /** Evict the oldest entry by cachedAt */
+    private evictOldest;
+    /** Persist a single entry to kv_store */
+    private persistEntry;
+}
+export declare function getSessionCache(config?: Partial<SessionCacheConfig>): SessionOperationCache;
+/** Reset the singleton (for testing) */
+export declare function resetSessionCache(): void;
+//# sourceMappingURL=session-cache.d.ts.map