agentic-qe 3.9.0 → 3.9.2

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/protocol-server.d.ts

@@ -46,6 +46,7 @@ export declare class MCPProtocolServer {
     private readonly middlewareChain;
     private readonly sessionStore;
     private readonly compactionPipeline;
+    private readonly loopTracker;
     private reconnecting;
     private pendingRequests;
     constructor(config?: MCPServerConfig);

package/dist/mcp/protocol-server.js

@@ -30,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');
@@ -61,6 +65,8 @@ export class MCPProtocolServer {
     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 = [];
@@ -94,6 +100,8 @@ export class MCPProtocolServer {
             llmCaller: createLLMCompactCaller(),
         });
         this.middlewareChain.register(this.compactionPipeline.createMiddleware());
+        // ADR-062: Initialize loop detection tracker
+        this.loopTracker = new ToolCallSignatureTracker();
         // Register all tools
         this.registerAllTools();
     }
@@ -355,6 +363,26 @@ export class MCPProtocolServer {
             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 {
             // IMP-00: Execute pre-tool-call middleware
             const processedCtx = await this.middlewareChain.executePreHooks(ctx);
@@ -371,11 +399,12 @@ export class MCPProtocolServer {
                     requestId: stepId,
                 },
             });
+            const resultText = JSON.stringify(processedResult, null, 2);
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify(processedResult, null, 2),
+                        text: loopSteeringPrefix ? loopSteeringPrefix + resultText : resultText,
                     },
                 ],
             };
@@ -1164,6 +1193,38 @@ export class MCPProtocolServer {
             },
             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/types.d.ts

@@ -30,7 +30,7 @@ export interface ToolDefinition {
 /**
  * Tool categories for organization and lazy loading
  */
-export type ToolCategory = 'core' | 'task' | 'agent' | 'domain' | 'coordination' | 'memory' | 'learning' | 'routing' | 'cross-phase' | 'infra-healing';
+export type ToolCategory = 'core' | 'task' | 'agent' | 'domain' | 'coordination' | 'memory' | 'learning' | 'routing' | 'cross-phase' | 'infra-healing' | 'persistence';
 /**
  * Tool handler function type
  */

package/dist/optimization/early-exit-token-optimizer.d.ts

@@ -3,10 +3,10 @@
  * ADR-042: Token Optimization via Pattern Reuse
  *
  * Enables LLM call skipping by reusing high-confidence patterns from
- * the PatternStore. Uses HNSW similarity search for O(log n) pattern
+ * the IPatternStore. Uses HNSW similarity search for O(log n) pattern
  * matching and tracks token savings statistics.
  */
-import type { PatternStore } from '../learning/pattern-store.js';
+import type { IPatternStore } from '../learning/pattern-store.js';
 import type { QEPattern, QEDomain } from '../learning/qe-patterns.js';
 /**
  * Configuration for early exit token optimization
@@ -181,7 +181,7 @@ export interface EarlyExitTask {
  * Early Exit Token Optimizer
  *
  * Enables LLM call skipping by reusing high-confidence patterns.
- * Uses HNSW-indexed PatternStore for O(log n) similarity search.
+ * Uses HNSW-indexed IPatternStore for O(log n) similarity search.
  *
  * @example
  * ```typescript
@@ -203,7 +203,7 @@ export declare class EarlyExitTokenOptimizer {
     private readonly config;
     private reuseHistory;
     private attemptHistory;
-    constructor(patternStore: PatternStore, config?: Partial<EarlyExitConfig>);
+    constructor(patternStore: IPatternStore, config?: Partial<EarlyExitConfig>);
     /**
      * Check if we can skip LLM call by reusing a pattern
      *
@@ -265,13 +265,13 @@ export declare class EarlyExitTokenOptimizer {
 /**
  * Create an EarlyExitTokenOptimizer with default configuration
  */
-export declare function createEarlyExitTokenOptimizer(patternStore: PatternStore, config?: Partial<EarlyExitConfig>): EarlyExitTokenOptimizer;
+export declare function createEarlyExitTokenOptimizer(patternStore: IPatternStore, config?: Partial<EarlyExitConfig>): EarlyExitTokenOptimizer;
 /**
  * Create an EarlyExitTokenOptimizer with aggressive configuration
  */
-export declare function createAggressiveTokenOptimizer(patternStore: PatternStore): EarlyExitTokenOptimizer;
+export declare function createAggressiveTokenOptimizer(patternStore: IPatternStore): EarlyExitTokenOptimizer;
 /**
  * Create an EarlyExitTokenOptimizer with conservative configuration
  */
-export declare function createConservativeTokenOptimizer(patternStore: PatternStore): EarlyExitTokenOptimizer;
+export declare function createConservativeTokenOptimizer(patternStore: IPatternStore): EarlyExitTokenOptimizer;
 //# sourceMappingURL=early-exit-token-optimizer.d.ts.map

package/dist/optimization/early-exit-token-optimizer.js

@@ -3,7 +3,7 @@
  * ADR-042: Token Optimization via Pattern Reuse
  *
  * Enables LLM call skipping by reusing high-confidence patterns from
- * the PatternStore. Uses HNSW similarity search for O(log n) pattern
+ * the IPatternStore. Uses HNSW similarity search for O(log n) pattern
  * matching and tracks token savings statistics.
  */
 import { detectQEDomain } from '../learning/qe-patterns.js';
@@ -54,7 +54,7 @@ export const CONSERVATIVE_EARLY_EXIT_CONFIG = {
  * Early Exit Token Optimizer
  *
  * Enables LLM call skipping by reusing high-confidence patterns.
- * Uses HNSW-indexed PatternStore for O(log n) similarity search.
+ * Uses HNSW-indexed IPatternStore for O(log n) similarity search.
  *
  * @example
  * ```typescript
@@ -94,7 +94,7 @@ export class EarlyExitTokenOptimizer {
             // Detect domain if not provided
             const domain = task.domain ?? detectQEDomain(task.description) ?? undefined;
             // Build search options
-            // Note: We don't pass minConfidence/minQualityScore to the PatternStore
+            // Note: We don't pass minConfidence/minQualityScore to the IPatternStore
             // because we want to evaluate patterns ourselves to provide proper rejection reasons
             const searchOptions = {
                 limit: this.config.maxSearchResults * 2, // Get extra candidates for filtering

package/dist/persistence/rvf-consistency-validator.d.ts

@@ -0,0 +1,85 @@
+/**
+ * RVF Consistency Validator (ADR-072)
+ *
+ * Periodically samples reads from both SQLite and RVF engines, compares
+ * results, and tracks divergence rate over a rolling window. Monitors
+ * RVF deadSpaceRatio and triggers compaction when needed.
+ *
+ * Used by RvfStageGate to make go/no-go decisions for stage promotion.
+ *
+ * @module persistence/rvf-consistency-validator
+ */
+import type { RvfStore } from '../integrations/ruvector/rvf-dual-writer.js';
+export interface ConsistencyCheckResult {
+    /** Timestamp of the check */
+    timestamp: number;
+    /** Number of samples compared */
+    samplesChecked: number;
+    /** Number of divergences found */
+    divergences: number;
+    /** Divergence rate (0-1) */
+    divergenceRate: number;
+    /** Details of any divergences */
+    details: DivergenceDetail[];
+    /** RVF dead space ratio (if available) */
+    deadSpaceRatio: number | null;
+    /** Whether compaction was triggered */
+    compactionTriggered: boolean;
+}
+export interface DivergenceDetail {
+    patternId: string;
+    issue: 'missing-in-rvf' | 'missing-in-sqlite' | 'score-mismatch';
+    sqliteScore?: number;
+    rvfScore?: number;
+}
+export interface ValidatorConfig {
+    /** Number of random samples per check (default: 50) */
+    sampleSize: number;
+    /** Rolling window duration in ms (default: 7 days) */
+    windowDurationMs: number;
+    /** Dead space ratio threshold to trigger compaction (default: 0.3) */
+    compactionThreshold: number;
+    /** Score difference threshold to count as divergence (default: 0.05) */
+    scoreTolerance: number;
+}
+interface SqliteDb {
+    prepare(sql: string): {
+        run(...params: unknown[]): {
+            changes: number;
+        };
+        get(...params: unknown[]): unknown;
+        all(...params: unknown[]): unknown[];
+    };
+}
+export declare class RvfConsistencyValidator {
+    private readonly config;
+    private db;
+    private rvfStore;
+    private history;
+    constructor(config?: Partial<ValidatorConfig>);
+    setSqliteDb(db: SqliteDb): void;
+    setRvfStore(store: RvfStore): void;
+    /**
+     * Run a consistency check by sampling random pattern IDs from SQLite,
+     * searching for them in both engines, and comparing results.
+     */
+    runCheck(): ConsistencyCheckResult;
+    /**
+     * Get the aggregate divergence rate over the rolling window.
+     */
+    getRollingDivergenceRate(): number;
+    /**
+     * Get the number of consistency checks performed in the rolling window.
+     */
+    getCheckCount(): number;
+    /**
+     * Get all check results in the rolling window.
+     */
+    getHistory(): ConsistencyCheckResult[];
+    private getSampleIds;
+    private getSqliteEmbedding;
+    private triggerCompaction;
+    private pruneHistory;
+}
+export {};
+//# sourceMappingURL=rvf-consistency-validator.d.ts.map

package/dist/persistence/rvf-consistency-validator.js

@@ -0,0 +1,182 @@
+/**
+ * RVF Consistency Validator (ADR-072)
+ *
+ * Periodically samples reads from both SQLite and RVF engines, compares
+ * results, and tracks divergence rate over a rolling window. Monitors
+ * RVF deadSpaceRatio and triggers compaction when needed.
+ *
+ * Used by RvfStageGate to make go/no-go decisions for stage promotion.
+ *
+ * @module persistence/rvf-consistency-validator
+ */
+const DEFAULT_CONFIG = {
+    sampleSize: 50,
+    windowDurationMs: 7 * 24 * 60 * 60 * 1000, // 7 days
+    compactionThreshold: 0.3,
+    scoreTolerance: 0.05,
+};
+// ============================================================================
+// RvfConsistencyValidator
+// ============================================================================
+export class RvfConsistencyValidator {
+    config;
+    db = null;
+    rvfStore = null;
+    history = [];
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    setSqliteDb(db) { this.db = db; }
+    setRvfStore(store) { this.rvfStore = store; }
+    // --------------------------------------------------------------------------
+    // Consistency Check
+    // --------------------------------------------------------------------------
+    /**
+     * Run a consistency check by sampling random pattern IDs from SQLite,
+     * searching for them in both engines, and comparing results.
+     */
+    runCheck() {
+        const result = {
+            timestamp: Date.now(),
+            samplesChecked: 0,
+            divergences: 0,
+            divergenceRate: 0,
+            details: [],
+            deadSpaceRatio: null,
+            compactionTriggered: false,
+        };
+        if (!this.db || !this.rvfStore) {
+            this.history.push(result);
+            return result;
+        }
+        // 1. Get random sample of pattern IDs from SQLite
+        const sampleIds = this.getSampleIds(this.config.sampleSize);
+        result.samplesChecked = sampleIds.length;
+        if (sampleIds.length === 0) {
+            this.history.push(result);
+            return result;
+        }
+        // 2. For each sample, get embedding from SQLite and search both engines
+        for (const patternId of sampleIds) {
+            const embedding = this.getSqliteEmbedding(patternId);
+            if (!embedding) {
+                result.divergences++;
+                result.details.push({ patternId, issue: 'missing-in-sqlite' });
+                continue;
+            }
+            // Search RVF
+            try {
+                const rvfResults = this.rvfStore.search(embedding, 1);
+                if (rvfResults.length === 0) {
+                    result.divergences++;
+                    result.details.push({ patternId, issue: 'missing-in-rvf' });
+                }
+                // If RVF returns results, check that the top result ID matches
+                // (self-search should return the same pattern as top-1)
+                else if (rvfResults[0].id !== patternId && rvfResults[0].score < 0.99) {
+                    result.divergences++;
+                    result.details.push({
+                        patternId,
+                        issue: 'score-mismatch',
+                        rvfScore: rvfResults[0].score,
+                    });
+                }
+            }
+            catch {
+                result.divergences++;
+                result.details.push({ patternId, issue: 'missing-in-rvf' });
+            }
+        }
+        result.divergenceRate = result.samplesChecked > 0
+            ? result.divergences / result.samplesChecked
+            : 0;
+        // 3. Check dead space ratio and trigger compaction if needed
+        try {
+            const rvfStatus = this.rvfStore.status();
+            const deadSpace = rvfStatus.deadSpaceRatio;
+            result.deadSpaceRatio = deadSpace ?? null;
+            if (deadSpace != null && deadSpace > this.config.compactionThreshold) {
+                this.triggerCompaction();
+                result.compactionTriggered = true;
+            }
+        }
+        catch {
+            // Status check is best-effort
+        }
+        // 4. Add to history and prune old entries
+        this.history.push(result);
+        this.pruneHistory();
+        return result;
+    }
+    // --------------------------------------------------------------------------
+    // Rolling Window Metrics
+    // --------------------------------------------------------------------------
+    /**
+     * Get the aggregate divergence rate over the rolling window.
+     */
+    getRollingDivergenceRate() {
+        const windowStart = Date.now() - this.config.windowDurationMs;
+        const inWindow = this.history.filter(h => h.timestamp >= windowStart);
+        if (inWindow.length === 0)
+            return 0;
+        const totalSamples = inWindow.reduce((s, h) => s + h.samplesChecked, 0);
+        const totalDivergences = inWindow.reduce((s, h) => s + h.divergences, 0);
+        return totalSamples > 0 ? totalDivergences / totalSamples : 0;
+    }
+    /**
+     * Get the number of consistency checks performed in the rolling window.
+     */
+    getCheckCount() {
+        const windowStart = Date.now() - this.config.windowDurationMs;
+        return this.history.filter(h => h.timestamp >= windowStart).length;
+    }
+    /**
+     * Get all check results in the rolling window.
+     */
+    getHistory() {
+        const windowStart = Date.now() - this.config.windowDurationMs;
+        return this.history.filter(h => h.timestamp >= windowStart);
+    }
+    // --------------------------------------------------------------------------
+    // Private
+    // --------------------------------------------------------------------------
+    getSampleIds(count) {
+        if (!this.db)
+            return [];
+        try {
+            const rows = this.db.prepare(`SELECT pattern_id FROM qe_pattern_embeddings ORDER BY RANDOM() LIMIT ?`).all(count);
+            return rows.map(r => r.pattern_id);
+        }
+        catch {
+            return [];
+        }
+    }
+    getSqliteEmbedding(patternId) {
+        if (!this.db)
+            return null;
+        try {
+            const row = this.db.prepare('SELECT embedding, dimension FROM qe_pattern_embeddings WHERE pattern_id = ?').get(patternId);
+            if (!row)
+                return null;
+            return new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.dimension);
+        }
+        catch {
+            return null;
+        }
+    }
+    triggerCompaction() {
+        // RVF compaction via the store's compact method (if available)
+        try {
+            const store = this.rvfStore;
+            store.compact?.();
+        }
+        catch {
+            // Compaction is best-effort
+        }
+    }
+    pruneHistory() {
+        const cutoff = Date.now() - this.config.windowDurationMs;
+        this.history = this.history.filter(h => h.timestamp >= cutoff);
+    }
+}
+//# sourceMappingURL=rvf-consistency-validator.js.map