agentic-qe 3.9.33 → 3.9.34

package/dist/learning/dream/dream-scheduler.d.ts

@@ -258,6 +258,24 @@ export declare class DreamScheduler {
      * Auto-apply insights that meet the confidence threshold.
      */
     private autoApplyInsights;
+    /**
+     * Reclaim dead space in patterns.rvf and brain.rvf after a dream cycle.
+     *
+     * Background: RVF is append-only — every ingest/delete writes a new segment.
+     * Without periodic compaction these files grow monotonically (field reports
+     * have seen 59 GB on a fresh clone). The shared adapter exposes a helper
+     * that runs `compact()` only when configured thresholds are exceeded, so
+     * idle cycles are essentially free.
+     *
+     * Two files are compacted:
+     *   • patterns.rvf — primary HNSW vector store (every storePattern() append)
+     *   • brain.rvf — dual-write target (one append per storePattern() via
+     *     RvfDualWriter.writePattern)
+     *
+     * Best-effort throughout: any error is logged and swallowed. The dream
+     * cycle's success is not contingent on compaction completing.
+     */
+    private maybeCompactPatternsRvf;
     /**
      * Collect a metrics snapshot and, if enough have accumulated, run a
      * meta-learning analysis cycle to detect token-waste, quality plateaus,

package/dist/learning/dream/dream-scheduler.js

@@ -357,6 +357,17 @@ export class DreamScheduler {
             }
             // Publish dream completed event
             await this.publishDreamCompletedEvent(result);
+            // Reclaim dead space in patterns.rvf after each dream cycle. Best-effort
+            // and threshold-gated (only runs when deadSpaceRatio or fileSize cross
+            // configured thresholds), so idle cycles are nearly free. Without this
+            // call patterns.rvf grows monotonically — see the field reports of
+            // 59 GB regrowth on a fresh clone.
+            //
+            // AWAITED on purpose: native compact() takes an exclusive lock against
+            // the RVF file. Running concurrently with the meta-learning analysis
+            // (which reads from RVF) would risk lock contention. The threshold
+            // gate keeps the wall-clock cost near zero on healthy installations.
+            await this.maybeCompactPatternsRvf();
             // ADR-062: Run meta-learning analysis after dream cycle
             if (process.env.AQE_META_LEARNING_ENABLED === 'true') {
                 try {
@@ -411,6 +422,63 @@ export class DreamScheduler {
             }
         }
     }
+    /**
+     * Reclaim dead space in patterns.rvf and brain.rvf after a dream cycle.
+     *
+     * Background: RVF is append-only — every ingest/delete writes a new segment.
+     * Without periodic compaction these files grow monotonically (field reports
+     * have seen 59 GB on a fresh clone). The shared adapter exposes a helper
+     * that runs `compact()` only when configured thresholds are exceeded, so
+     * idle cycles are essentially free.
+     *
+     * Two files are compacted:
+     *   • patterns.rvf — primary HNSW vector store (every storePattern() append)
+     *   • brain.rvf — dual-write target (one append per storePattern() via
+     *     RvfDualWriter.writePattern)
+     *
+     * Best-effort throughout: any error is logged and swallowed. The dream
+     * cycle's success is not contingent on compaction completing.
+     */
+    async maybeCompactPatternsRvf() {
+        // patterns.rvf — threshold-gated compaction via the shared singleton.
+        try {
+            const mod = await import('../../integrations/ruvector/shared-rvf-adapter.js');
+            const result = mod.compactSharedRvfAdapter();
+            if (result && result.bytesReclaimed > 0) {
+                logger.info('patterns.rvf compacted', {
+                    bytesReclaimed: result.bytesReclaimed,
+                    segmentsCompacted: result.segmentsCompacted,
+                });
+            }
+        }
+        catch (err) {
+            logger.warn('patterns.rvf compaction skipped (non-critical)', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // brain.rvf — separate file, separate writer (RvfDualWriter). The
+        // dual-writer does not gate on thresholds (it has no status surface that
+        // exposes deadSpaceRatio), so we call compact() unconditionally. Native
+        // compact() is a no-op on a clean file, so the cost is bounded.
+        try {
+            const mod = await import('../../integrations/ruvector/shared-rvf-dual-writer.js');
+            const writer = mod.getSharedRvfDualWriterSync();
+            if (writer) {
+                const result = writer.compact();
+                if (result && result.bytesReclaimed > 0) {
+                    logger.info('brain.rvf compacted', {
+                        bytesReclaimed: result.bytesReclaimed,
+                        segmentsCompacted: result.segmentsCompacted,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            logger.warn('brain.rvf compaction skipped (non-critical)', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
     // ==========================================================================
     // Private: Meta-Learning (ADR-062)
     // ==========================================================================

package/dist/learning/qe-reasoning-bank.js

@@ -179,7 +179,19 @@ export class QEReasoningBank {
             const adapter = this.patternStore.getAdapter?.();
             if (adapter && (adapter.status()?.totalVectors ?? 0) === 0) {
                 try {
-                    const embeddings = this.getSqliteStore().getAllEmbeddings();
+                    // Cap the backfill to the most-recently-used N embeddings. Prevents
+                    // a truncated patterns.rvf (e.g. `: > patterns.rvf` for disk
+                    // recovery) from triggering an unbounded re-ingest of every
+                    // historical embedding — the path that reproduces "regrew to 59 GB"
+                    // in the field.
+                    //
+                    // Override via AQE_RVF_BACKFILL_LIMIT (default: 1000).
+                    const limit = (() => {
+                        const env = process.env.AQE_RVF_BACKFILL_LIMIT;
+                        const parsed = env ? Number(env) : NaN;
+                        return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 1000;
+                    })();
+                    const embeddings = this.getSqliteStore().getRecentEmbeddings(limit);
                     const vectors = embeddings
                         .filter(({ embedding }) => embedding && embedding.length > 0)
                         .map(({ patternId, embedding }) => ({
@@ -190,7 +202,12 @@ export class QEReasoningBank {
                     }));
                     if (vectors.length > 0) {
                         const { accepted, rejected } = adapter.ingest(vectors);
-                        logger.info('Backfilled RVF from SQLite', { count: vectors.length, accepted });
+                        logger.info('Backfilled RVF from SQLite', {
+                            requested: vectors.length,
+                            accepted,
+                            cap: limit,
+                            truncated: vectors.length >= limit,
+                        });
                         if (rejected > 0) {
                             logger.warn('RVF backfill partially rejected', { accepted, rejected });
                         }

package/dist/learning/sqlite-persistence.d.ts

@@ -114,6 +114,17 @@ export declare class SQLitePatternStore {
         patternId: string;
         embedding: number[];
     }>;
+    /**
+     * Get up to `limit` embeddings, most-recently-used first.
+     *
+     * Used by the RVF backfill path so an operator-truncated patterns.rvf does
+     * not trigger an unbounded re-ingest of every historical embedding (which
+     * is what reproduces the "regrew to 59 GB" pathology after `: > patterns.rvf`).
+     */
+    getRecentEmbeddings(limit: number): Array<{
+        patternId: string;
+        embedding: number[];
+    }>;
     /**
      * Record pattern usage.
      *

package/dist/learning/sqlite-persistence.js

@@ -361,6 +361,16 @@ export class SQLitePatternStore {
     `));
         this.prepared.set('getAllEmbeddings', this.db.prepare(`
       SELECT pattern_id, embedding, dimension FROM qe_pattern_embeddings
+    `));
+        // Recent-first variant used by the RVF backfill path. Order by
+        // qe_patterns.last_used_at (then created_at) so the bounded backfill keeps
+        // the most actively-used patterns when the cap is hit.
+        this.prepared.set('getRecentEmbeddings', this.db.prepare(`
+      SELECT e.pattern_id, e.embedding, e.dimension
+        FROM qe_pattern_embeddings e
+        LEFT JOIN qe_patterns p ON p.id = e.pattern_id
+       ORDER BY COALESCE(p.last_used_at, p.created_at, e.created_at) DESC
+       LIMIT ?
     `));
         this.prepared.set('countPatterns', this.db.prepare(`
       SELECT COUNT(*) as count FROM qe_patterns
@@ -518,6 +528,26 @@ export class SQLitePatternStore {
             embedding: Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.dimension)),
         }));
     }
+    /**
+     * Get up to `limit` embeddings, most-recently-used first.
+     *
+     * Used by the RVF backfill path so an operator-truncated patterns.rvf does
+     * not trigger an unbounded re-ingest of every historical embedding (which
+     * is what reproduces the "regrew to 59 GB" pathology after `: > patterns.rvf`).
+     */
+    getRecentEmbeddings(limit) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const cap = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1000;
+        const stmt = this.prepared.get('getRecentEmbeddings');
+        if (!stmt)
+            throw new Error('Prepared statement not ready');
+        const rows = stmt.all(cap);
+        return rows.map(row => ({
+            patternId: row.pattern_id,
+            embedding: Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.dimension)),
+        }));
+    }
     /**
      * Record pattern usage.
      *