agentic-qe 3.15.15 → 3.15.16

package/dist/learning/pattern-store.js

@@ -477,7 +477,8 @@ export class PatternStore {
         // Persist to SQLite (pattern + embedding atomically)
         if (this.sqliteStore) {
             try {
-                const actualId = this.sqliteStore.storePattern(pattern, pattern.embedding, activeSpaceId);
+                // #1283: queued, so a locked memory.db does not freeze the MCP server.
+                const actualId = await this.persistToSqlite((store) => store.storePattern(pattern, pattern.embedding, activeSpaceId));
                 // #447: ON CONFLICT(name, qe_domain, pattern_type) may preserve an
                 // existing row's id instead of the one we generated — realign the
                 // in-memory indices (and pattern.id itself) or every later
@@ -591,7 +592,7 @@ export class PatternStore {
                     successRate: pattern.successRate,
                     tier: pattern.tier,
                 };
-                this.deltaTracker.createGenesis(pattern.id, snapshot);
+                await this.deltaTracker.createGenesisWhenUnlocked(pattern.id, snapshot);
             }
             catch (error) {
                 // Genesis may already exist if pattern was re-stored; log at debug level
@@ -1088,7 +1089,7 @@ export class PatternStore {
         // Persist usage to SQLite
         if (this.sqliteStore) {
             try {
-                this.sqliteStore.recordUsage(id, success, metrics, feedback);
+                await this.persistToSqlite((store) => store.recordUsage(id, success, metrics, feedback));
             }
             catch (error) {
                 console.warn(`[PatternStore] SQLite recordUsage failed for ${id}:`, toErrorMessage(error));
@@ -1115,7 +1116,7 @@ export class PatternStore {
                     successRate: updated.successRate,
                     tier: updated.tier,
                 };
-                this.deltaTracker.recordDelta(id, before, after, { success });
+                await this.deltaTracker.recordDeltaWhenUnlocked(id, before, after, { success });
             }
             catch (error) {
                 console.debug(`[PatternStore] Delta recordDelta for ${id}:`, toErrorMessage(error));
@@ -1135,6 +1136,18 @@ export class PatternStore {
         }
         return ok(undefined);
     }
+    /**
+     * Run a SQLite write through the store's writeWhenUnlocked queue (#1274):
+     * the hourly cleanup timer and fire-and-forget usage recording write here,
+     * and must not freeze the MCP server's event loop on a locked memory.db.
+     */
+    persistToSqlite(write) {
+        const store = this.sqliteStore;
+        const run = () => write(store);
+        return typeof store.writeWhenUnlocked === 'function'
+            ? store.writeWhenUnlocked(run)
+            : new Promise((resolve) => resolve(run()));
+    }
     /**
      * Promote pattern from short-term to long-term storage
      */
@@ -1159,7 +1172,7 @@ export class PatternStore {
         // Persist promotion to SQLite
         if (this.sqliteStore) {
             try {
-                this.sqliteStore.promotePattern(id);
+                await this.persistToSqlite((store) => store.promotePattern(id));
             }
             catch (e) {
                 console.debug('[PatternStore] SQLite promotion error:', e instanceof Error ? e.message : e);
@@ -1181,7 +1194,7 @@ export class PatternStore {
         // Persist deletion to SQLite
         if (this.sqliteStore) {
             try {
-                this.sqliteStore.deletePattern(id);
+                await this.persistToSqlite((store) => store.deletePattern(id));
             }
             catch (e) {
                 console.debug('[PatternStore] SQLite deletion error:', e instanceof Error ? e.message : e);

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

@@ -365,7 +365,7 @@ export class QEReasoningBank {
         // ADR-070: Record pattern creation in witness chain
         if (committedPattern) {
             const sideEffectPattern = committedPattern;
-            getWitnessChain().then(wc => wc.append('PATTERN_CREATE', { patternId: sideEffectPattern.id, domain: sideEffectPattern.qeDomain, confidence: sideEffectPattern.confidence, name: sideEffectPattern.name }, 'reasoning-bank')).catch((e) => { logger.warn('Witness chain PATTERN_CREATE failed', { error: toErrorMessage(e) }); });
+            getWitnessChain().then(wc => wc.appendWhenUnlocked('PATTERN_CREATE', { patternId: sideEffectPattern.id, domain: sideEffectPattern.qeDomain, confidence: sideEffectPattern.confidence, name: sideEffectPattern.name }, 'reasoning-bank')).catch((e) => { logger.warn('Witness chain PATTERN_CREATE failed', { error: toErrorMessage(e) }); });
             // Phase 3: Best-effort RVF dual-write for vector replication
             if (this.rvfDualWriter && sideEffectPattern.embedding && sideEffectPattern.embedding.length > 0) {
                 try {
@@ -452,7 +452,7 @@ export class QEReasoningBank {
                     this.stats.successfulOutcomes++;
             }
             // ADR-070: Record pattern update in witness chain
-            getWitnessChain().then(wc => wc.append('PATTERN_UPDATE', { patternId: outcome.patternId, success: outcome.success }, 'reasoning-bank')).catch((e) => { logger.warn('Witness chain PATTERN_UPDATE failed', { error: toErrorMessage(e) }); });
+            getWitnessChain().then(wc => wc.appendWhenUnlocked('PATTERN_UPDATE', { patternId: outcome.patternId, success: outcome.success }, 'reasoning-bank')).catch((e) => { logger.warn('Witness chain PATTERN_UPDATE failed', { error: toErrorMessage(e) }); });
             // Check if pattern should be promoted (with coherence gate)
             const pattern = await this.getPattern(outcome.patternId);
             const deps = this.getPromotionDeps();

package/dist/learning/real-embeddings.js

@@ -442,7 +442,9 @@ export async function recheckEmbedder(config = {}) {
         return initRetryPromise;
     }
     const client = endpointClient;
-    if (!client || !client.getBreakerState().open)
+    // #1216: also when the breaker window elapsed but no trial probe has
+    // succeeded yet; embed() would only start that trial and fail fast.
+    if (!client || !client.needsTrial())
         return;
     const identity = await client.probeThroughOpenBreaker();
     if (endpointIdentity && identity.fingerprint !== endpointIdentity.fingerprint) {

package/dist/learning/real-qe-reasoning-bank.d.ts

@@ -349,6 +349,11 @@ export declare class RealQEReasoningBank {
      * @param trajectoryId - Trajectory ID
      */
     linkPatternToTrajectory(patternId: string, trajectoryId: string): Promise<void>;
+    /**
+     * 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.
+     */
+    private persist;
     /**
      * Get the enhanced ReasoningBank adapter for full agentic-flow integration
      *

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
      */