agentic-qe 3.15.14 → 3.15.16

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

@@ -433,8 +433,8 @@ export class RealQEReasoningBank {
                 reuseCount: 0,
                 averageTokenSavings: 0,
             };
-            // Store in SQLite
-            this.sqliteStore.storePattern(pattern, embedding);
+            // Store in SQLite (queued, #1283)
+            await this.persist(() => this.sqliteStore.storePattern(pattern, embedding));
             // Add to HNSW index
             if (this.hnswIndex && embedding) {
                 const index = this.hnswIndex.getCurrentCount();
@@ -630,28 +630,36 @@ export class RealQEReasoningBank {
             return ok(undefined);
         }
         try {
-            this.sqliteStore.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback);
+            // #1283: writes go through the shared connection's write queue, so a
+            // locked memory.db does not freeze the MCP server during the tool call.
+            await this.persist(() => this.sqliteStore.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback));
             this.stats.learningOutcomes++;
             if (outcome.success) {
                 this.stats.successfulOutcomes++;
             }
-            // ADR-061: Apply asymmetric confidence update (10:1 failure penalty)
-            const pattern = this.sqliteStore.getPattern(outcome.patternId);
-            if (pattern) {
-                const domain = pattern.qeDomain;
-                const newConfidence = this.asymmetricEngine.computeConfidenceUpdate(pattern.confidence, outcome.success ? 'success' : 'failure', domain);
+            // ADR-061: Apply asymmetric confidence update (10:1 failure penalty).
+            // Read and update in one queued unit, so the update uses the current confidence.
+            const pattern = await this.persist(() => {
+                const current = this.sqliteStore.getPattern(outcome.patternId);
+                if (!current)
+                    return current;
+                const domain = current.qeDomain;
+                const newConfidence = this.asymmetricEngine.computeConfidenceUpdate(current.confidence, outcome.success ? 'success' : 'failure', domain);
                 // Check for quarantine
                 const quarantineDecision = this.asymmetricEngine.shouldQuarantine(newConfidence, domain);
                 if (quarantineDecision.shouldQuarantine) {
-                    logger.info('Pattern quarantined (asymmetric drop)', { name: pattern.name });
+                    logger.info('Pattern quarantined (asymmetric drop)', { name: current.name });
                 }
                 // Apply the asymmetric confidence update
                 this.sqliteStore.updatePattern(outcome.patternId, {
                     confidence: newConfidence,
                 });
+                return current;
+            });
+            if (pattern) {
                 // Check if pattern should be promoted (with coherence gate)
                 if (await this.checkPatternPromotionWithCoherence(pattern)) {
-                    this.sqliteStore.promotePattern(outcome.patternId);
+                    await this.persist(() => this.sqliteStore.promotePattern(outcome.patternId));
                     logger.info('Pattern promoted to long-term', { name: pattern.name });
                 }
             }
@@ -832,26 +840,30 @@ export class RealQEReasoningBank {
      * Record a pattern outcome for feedback learning
      */
     async recordPatternOutcome(patternId, success, qualityScore) {
-        const pattern = this.sqliteStore.getPattern(patternId);
-        if (!pattern)
-            return;
-        // Calculate updated metrics (pattern properties are readonly, so we compute new values)
-        const newUsageCount = pattern.usageCount + 1;
-        const newSuccessfulUses = success ? pattern.successfulUses + 1 : pattern.successfulUses;
-        // Update success rate (rolling average)
-        const newSuccessRate = newSuccessfulUses / newUsageCount;
-        // Update quality score (exponential moving average)
-        const alpha = 0.3; // Weight for new observation
-        const newQualityScore = (1 - alpha) * pattern.qualityScore + alpha * qualityScore;
-        // Update confidence
-        const newConfidence = Math.min(1.0, 0.5 + (newUsageCount * 0.05) + (newSuccessRate * 0.3));
-        // Persist updates
-        this.sqliteStore.updatePattern(patternId, {
-            usageCount: newUsageCount,
-            successfulUses: newSuccessfulUses,
-            successRate: newSuccessRate,
-            qualityScore: newQualityScore,
-            confidence: newConfidence,
+        // Read and update in one queued unit (#1283), so concurrent outcomes
+        // cannot both build on the same old counts.
+        await this.persist(() => {
+            const pattern = this.sqliteStore.getPattern(patternId);
+            if (!pattern)
+                return;
+            // Calculate updated metrics (pattern properties are readonly, so we compute new values)
+            const newUsageCount = pattern.usageCount + 1;
+            const newSuccessfulUses = success ? pattern.successfulUses + 1 : pattern.successfulUses;
+            // Update success rate (rolling average)
+            const newSuccessRate = newSuccessfulUses / newUsageCount;
+            // Update quality score (exponential moving average)
+            const alpha = 0.3; // Weight for new observation
+            const newQualityScore = (1 - alpha) * pattern.qualityScore + alpha * qualityScore;
+            // Update confidence
+            const newConfidence = Math.min(1.0, 0.5 + (newUsageCount * 0.05) + (newSuccessRate * 0.3));
+            // Persist updates
+            this.sqliteStore.updatePattern(patternId, {
+                usageCount: newUsageCount,
+                successfulUses: newSuccessfulUses,
+                successRate: newSuccessRate,
+                qualityScore: newQualityScore,
+                confidence: newConfidence,
+            });
         });
     }
     /**
@@ -875,21 +887,27 @@ export class RealQEReasoningBank {
      * Promote a pattern to the next tier
      */
     async promotePattern(patternId) {
-        this.sqliteStore.promotePattern(patternId);
+        await this.persist(() => this.sqliteStore.promotePattern(patternId));
     }
     /**
      * Demote a pattern to a lower tier
      */
     async demotePattern(patternId) {
-        const pattern = this.sqliteStore.getPattern(patternId);
-        if (!pattern)
-            return;
         const tierOrder = ['short-term', 'working', 'long-term'];
-        const currentIndex = tierOrder.indexOf(pattern.tier);
-        if (currentIndex > 0) {
+        // Read and update in one queued unit (#1283).
+        const demoted = await this.persist(() => {
+            const pattern = this.sqliteStore.getPattern(patternId);
+            if (!pattern)
+                return null;
+            const currentIndex = tierOrder.indexOf(pattern.tier);
+            if (currentIndex <= 0)
+                return null;
             const newTier = tierOrder[currentIndex - 1];
             this.sqliteStore.updatePattern(patternId, { tier: newTier });
-            logger.info('Pattern demoted', { name: pattern.name, newTier });
+            return { name: pattern.name, newTier };
+        });
+        if (demoted) {
+            logger.info('Pattern demoted', demoted);
         }
     }
     // ============================================================================
@@ -962,11 +980,11 @@ export class RealQEReasoningBank {
      */
     async storeTrajectory(trajectory) {
         const db = this.sqliteStore.getDb();
-        db.prepare(`
+        await this.persist(() => db.prepare(`
       INSERT OR REPLACE INTO qe_trajectories (
         id, task, agent, domain, started_at, ended_at, success, steps_json, metadata_json
       ) VALUES (?, ?, ?, ?, datetime('now'), datetime('now'), ?, ?, ?)
-    `).run(trajectory.id, trajectory.task, trajectory.agent ?? null, trajectory.domain ?? null, trajectory.success ? 1 : 0, JSON.stringify(trajectory.steps), JSON.stringify(trajectory.metrics ?? {}));
+    `).run(trajectory.id, trajectory.task, trajectory.agent ?? null, trajectory.domain ?? null, trajectory.success ? 1 : 0, JSON.stringify(trajectory.steps), JSON.stringify(trajectory.metrics ?? {})));
         return trajectory.id;
     }
     /**
@@ -1005,14 +1023,26 @@ export class RealQEReasoningBank {
      */
     async linkPatternToTrajectory(patternId, trajectoryId) {
         const db = this.sqliteStore.getDb();
-        // Store relationship in metadata
-        const pattern = this.sqliteStore.getPattern(patternId);
-        if (pattern) {
-            const context = { ...pattern.context, sourceTrajectoryId: trajectoryId };
-            db.prepare(`
-        UPDATE qe_patterns SET context_json = ?, updated_at = datetime('now') WHERE id = ?
-      `).run(JSON.stringify(context), patternId);
-        }
+        // Store relationship in metadata (read and update in one queued unit, #1283)
+        await this.persist(() => {
+            const pattern = this.sqliteStore.getPattern(patternId);
+            if (pattern) {
+                const context = { ...pattern.context, sourceTrajectoryId: trajectoryId };
+                db.prepare(`
+          UPDATE qe_patterns SET context_json = ?, updated_at = datetime('now') WHERE id = ?
+        `).run(JSON.stringify(context), patternId);
+            }
+        });
+    }
+    /**
+     * Run a SQLite write through the shared connection's write queue (#1283),
+     * so a locked memory.db does not freeze the MCP server's event loop.
+     */
+    persist(fn) {
+        // Test doubles of the store may not implement the queue.
+        return typeof this.sqliteStore.writeWhenUnlocked === 'function'
+            ? this.sqliteStore.writeWhenUnlocked(fn)
+            : new Promise((resolve) => resolve(fn()));
     }
     /**
      * Get the enhanced ReasoningBank adapter for full agentic-flow integration

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

@@ -14,6 +14,7 @@
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../shared/types/index.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 import { calculateQualityScore, validateQEPattern, mapQEDomainToAQE, PROMOTION_THRESHOLD, } from './qe-patterns.js';
 import { DEFAULT_PATTERN_STORE_CONFIG, blendFtsScore } from './pattern-store.js';
 import { ensureEndpointEmbeddingSpaceIdentity, getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
@@ -449,7 +450,9 @@ export class RvfPatternStore {
             return err(new Error('No SQLite store attached'));
         }
         try {
-            this.sqliteStore.recordUsage(id, success, metrics, feedback);
+            const store = this.sqliteStore;
+            // #1283: queued on the shared connection, so a locked memory.db does not freeze the MCP server.
+            await writeWhenUnlockedOn(store.getDatabase(), () => store.recordUsage(id, success, metrics, feedback));
             return ok(undefined);
         }
         catch (error) {
@@ -461,7 +464,8 @@ export class RvfPatternStore {
             return err(new Error('No SQLite store attached'));
         }
         try {
-            this.sqliteStore.promotePattern(id);
+            const store = this.sqliteStore;
+            await writeWhenUnlockedOn(store.getDatabase(), () => store.promotePattern(id));
             return ok(undefined);
         }
         catch (error) {

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

@@ -56,6 +56,12 @@ export declare class SQLitePatternStore {
     constructor(config?: Partial<SQLitePersistenceConfig>);
     /** Expose the underlying database for cross-module schema extensions (R8 citations, R3 deltas) */
     getDatabase(): DatabaseType | null;
+    /**
+     * Run a write through the shared connection's writeWhenUnlocked queue
+     * (#1274), so a locked memory.db does not freeze the MCP server's event
+     * loop. On a private connection (useUnified: false) the write runs now.
+     */
+    writeWhenUnlocked<T>(fn: () => T): Promise<T>;
     /**
      * Initialize the database
      */

package/dist/learning/sqlite-persistence.js

@@ -80,6 +80,16 @@ export class SQLitePatternStore {
     getDatabase() {
         return this.db;
     }
+    /**
+     * Run a write through the shared connection's writeWhenUnlocked queue
+     * (#1274), so a locked memory.db does not freeze the MCP server's event
+     * loop. On a private connection (useUnified: false) the write runs now.
+     */
+    writeWhenUnlocked(fn) {
+        return this.unifiedMemory
+            ? this.unifiedMemory.writeWhenUnlocked(fn)
+            : new Promise((resolve) => resolve(fn()));
+    }
     /**
      * Initialize the database
      */