agentic-qe 3.9.24 → 3.9.26

package/dist/learning/rvf-pattern-store.js

@@ -89,6 +89,48 @@ export class RvfPatternStore {
                 // SQLite auto-attach is best-effort
             }
         }
+        // Issue #462: purge orphan vectors that survived in patterns.rvf when an
+        // upgrade workflow rewrote qe_patterns via INSERT OR REPLACE without
+        // calling RvfPatternStore.delete() on the old IDs. Ghost vectors win
+        // cosine-similarity matches, route to non-existent pattern IDs, and
+        // every learning write fails silently. Run once on init.
+        await this.purgeOrphanedVectors();
+    }
+    /**
+     * Compare the RVF vector count with the SQLite pattern count; if RVF has
+     * more rows, read the idmap.json and delete any vector IDs that no longer
+     * have a matching qe_patterns row.
+     *
+     * Fail-open: any error in the purge path is swallowed so a stale or
+     * corrupted idmap can't keep the store from initializing (#462).
+     */
+    async purgeOrphanedVectors() {
+        if (!this.adapter || !this.sqliteStore)
+            return;
+        try {
+            const rvfCount = this.adapter.status()?.totalVectors ?? 0;
+            const dbCount = this.sqliteStore.getStats()?.totalPatterns ?? 0;
+            if (rvfCount <= dbCount)
+                return;
+            const { readFileSync, existsSync } = await import('node:fs');
+            const idmapPath = `${this.rvfPath}.idmap.json`;
+            if (!existsSync(idmapPath))
+                return;
+            const idmap = JSON.parse(readFileSync(idmapPath, 'utf-8'));
+            const rvfIds = new Set((idmap.entries ?? [])
+                .map((e) => (Array.isArray(e) ? e[0] : undefined))
+                .filter((id) => typeof id === 'string'));
+            const dbIds = new Set(this.sqliteStore.getPatterns({ limit: 10_000 }).map((p) => p.id));
+            const orphans = [...rvfIds].filter((id) => !dbIds.has(id));
+            if (orphans.length === 0)
+                return;
+            this.adapter.delete(orphans);
+            console.log(`[RvfPatternStore] Removed ${orphans.length} ghost vectors (index ${rvfCount} > DB ${dbCount})`);
+        }
+        catch (error) {
+            // fail-open: a stale idmap or read error must not block initialization
+            console.warn(`[RvfPatternStore] orphan purge skipped: ${toErrorMessage(error)}`);
+        }
     }
     async dispose() {
         if (this.adapter && !this.skipCloseOnDispose) {

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

@@ -134,6 +134,24 @@ export declare class SQLitePatternStore {
         byDomain: Record<string, number>;
         byTier: Record<string, number>;
     };
+    /**
+     * Aggregate outcome counters used by QEReasoningBank.getStats() as a fallback
+     * when the in-memory `this.stats` object is zero — every hook subprocess
+     * starts with a fresh counter, so without this fallback observability is
+     * always blank (#454).
+     *
+     * routing_outcomes and qe_pattern_usage live in the same unified memory.db
+     * as qe_patterns. avgConfidence/avgSuccessRate return 0 when the source
+     * tables are empty rather than NaN.
+     */
+    getAggregateOutcomeStats(): {
+        routingRequests: number;
+        avgRoutingConfidence: number;
+        successfulRoutings: number;
+        learningOutcomes: number;
+        successfulOutcomes: number;
+        avgPatternSuccessRate: number;
+    };
     /**
      * Check if there's any historical data (embeddings, usage, trajectories)
      * even if qe_patterns is empty. Used to detect data loss vs fresh database.

package/dist/learning/sqlite-persistence.js

@@ -596,6 +596,65 @@ export class SQLitePatternStore {
         }
         return { totalPatterns: total, byDomain, byTier };
     }
+    /**
+     * Aggregate outcome counters used by QEReasoningBank.getStats() as a fallback
+     * when the in-memory `this.stats` object is zero — every hook subprocess
+     * starts with a fresh counter, so without this fallback observability is
+     * always blank (#454).
+     *
+     * routing_outcomes and qe_pattern_usage live in the same unified memory.db
+     * as qe_patterns. avgConfidence/avgSuccessRate return 0 when the source
+     * tables are empty rather than NaN.
+     */
+    getAggregateOutcomeStats() {
+        const empty = {
+            routingRequests: 0,
+            avgRoutingConfidence: 0,
+            successfulRoutings: 0,
+            learningOutcomes: 0,
+            successfulOutcomes: 0,
+            avgPatternSuccessRate: 0,
+        };
+        if (!this.db)
+            return empty;
+        const safeGet = (sql) => {
+            try {
+                return this.db.prepare(sql).get();
+            }
+            catch {
+                return undefined;
+            }
+        };
+        // routing_outcomes carries (success, quality_score) per closed turn.
+        // Sentinels still have quality_score = -1, so filter to closed rows.
+        const routing = safeGet(`
+      SELECT
+        COUNT(*) AS total,
+        COUNT(CASE WHEN quality_score >= 0 THEN 1 END) AS closed,
+        AVG(CASE WHEN quality_score >= 0 THEN quality_score END) AS avg_q,
+        COALESCE(SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END), 0) AS succ
+      FROM routing_outcomes
+    `);
+        const usage = safeGet(`
+      SELECT
+        COUNT(*) AS total,
+        COALESCE(SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END), 0) AS succ
+      FROM qe_pattern_usage
+    `);
+        const patternAvg = safeGet(`
+      SELECT AVG(success_rate) AS avg_sr
+      FROM qe_patterns
+      WHERE usage_count > 0
+    `);
+        return {
+            routingRequests: routing?.total ?? 0,
+            avgRoutingConfidence: routing?.avg_q ?? 0,
+            successfulRoutings: routing?.succ ?? 0,
+            learningOutcomes: usage?.total ?? 0,
+            successfulOutcomes: usage?.succ ?? 0,
+            avgPatternSuccessRate: patternAvg?.avg_sr ?? 0,
+        };
+    }
     /**
      * Check if there's any historical data (embeddings, usage, trajectories)
      * even if qe_patterns is empty. Used to detect data loss vs fresh database.