agentic-qe 3.15.14 → 3.15.16

package/dist/learning/pattern-lifecycle.js

@@ -15,6 +15,7 @@ import { tierAllowsPromotion, DEFAULT_PROVENANCE_TIER } from './provenance-tier.
 import { reExecutePathGate, pathGateFingerprint, pathSealedHash, verifyPathPromotion, } from '../validation/gate-reexecute.js';
 import { LoggerFactory } from '../logging/index.js';
 import { isTemporalCompressionEnabled } from '../integrations/ruvector/feature-flags.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 const logger = LoggerFactory.create('pattern-lifecycle');
 /**
  * Default lifecycle configuration
@@ -100,69 +101,7 @@ export class PatternLifecycleManager {
         this.db = db;
         this.config = { ...DEFAULT_LIFECYCLE_CONFIG, ...config };
         this.asymmetricEngine = new AsymmetricLearningEngine(this.config.asymmetricLearning);
-        this.ensureSchema();
-    }
-    /**
-     * Ensure required schema extensions exist
-     */
-    ensureSchema() {
-        // Add deprecated_at column if not exists
-        try {
-            this.db.prepare(`
-        SELECT deprecated_at FROM qe_patterns LIMIT 1
-      `).get();
-        }
-        catch (e) {
-            // Column doesn't exist, add it
-            logger.debug('Adding missing deprecated_at column', { error: e instanceof Error ? e.message : String(e) });
-            this.db.exec(`
-        ALTER TABLE qe_patterns ADD COLUMN deprecated_at TEXT DEFAULT NULL
-      `);
-            console.log('[PatternLifecycle] Added deprecated_at column to qe_patterns');
-        }
-        // Add consecutive_failures column if not exists
-        try {
-            this.db.prepare(`
-        SELECT consecutive_failures FROM qe_patterns LIMIT 1
-      `).get();
-        }
-        catch (e) {
-            logger.debug('Adding missing consecutive_failures column', { error: e instanceof Error ? e.message : String(e) });
-            this.db.exec(`
-        ALTER TABLE qe_patterns ADD COLUMN consecutive_failures INTEGER DEFAULT 0
-      `);
-            console.log('[PatternLifecycle] Added consecutive_failures column to qe_patterns');
-        }
-        // Add promotion_date column if not exists
-        try {
-            this.db.prepare(`
-        SELECT promotion_date FROM qe_patterns LIMIT 1
-      `).get();
-        }
-        catch (e) {
-            logger.debug('Adding missing promotion_date column', { error: e instanceof Error ? e.message : String(e) });
-            this.db.exec(`
-        ALTER TABLE qe_patterns ADD COLUMN promotion_date TEXT DEFAULT NULL
-      `);
-            console.log('[PatternLifecycle] Added promotion_date column to qe_patterns');
-        }
-        // ADR-121: provenance_tier — additive, conservative-default migration.
-        // The DEFAULT backfills every existing row as 'proxy:structural', which can
-        // never over-credit legacy history. Rows re-derived from execution evidence
-        // are re-tiered upward through the normal write path (never up-tiered here).
-        // Distinct from the lifecycle `tier` (short-term/long-term) column.
-        try {
-            this.db.prepare(`
-        SELECT provenance_tier FROM qe_patterns LIMIT 1
-      `).get();
-        }
-        catch (e) {
-            logger.debug('Adding missing provenance_tier column', { error: e instanceof Error ? e.message : String(e) });
-            this.db.exec(`
-        ALTER TABLE qe_patterns ADD COLUMN provenance_tier TEXT DEFAULT '${DEFAULT_PROVENANCE_TIER}'
-      `);
-            console.log(`[PatternLifecycle] Added provenance_tier column to qe_patterns (backfilled '${DEFAULT_PROVENANCE_TIER}')`);
-        }
+        ensurePatternLifecycleSchema(this.db);
     }
     // ============================================================================
     // Experience Extraction
@@ -431,6 +370,14 @@ Pattern extracted from ${exp.count} successful experiences.`;
      * Promote pattern to long-term tier
      */
     promotePattern(patternId) {
+        if (!this.promotionVerified(patternId))
+            return false;
+        this.writePromotion(patternId);
+        console.log(`[PatternLifecycle] Promoted pattern ${patternId} to long-term`);
+        return true;
+    }
+    /** Whether `patternId` passes the advisory check and the frozen promote rule. */
+    promotionVerified(patternId) {
         const check = this.checkPromotion(patternId);
         if (!check.shouldPromote) {
             return false;
@@ -465,6 +412,9 @@ Pattern extracted from ${exp.count} successful experiences.`;
             console.warn(`[PatternLifecycle] Refusing to promote ${patternId}: ${rerun.reason} (${verdict.reason})`);
             return false;
         }
+        return true;
+    }
+    writePromotion(patternId) {
         this.db.prepare(`
       UPDATE qe_patterns
       SET tier = 'long-term',
@@ -473,17 +423,12 @@ Pattern extracted from ${exp.count} successful experiences.`;
           updated_at = datetime('now')
       WHERE id = ?
     `).run(patternId);
-        console.log(`[PatternLifecycle] Promoted pattern ${patternId} to long-term`);
-        return true;
     }
     /**
      * Promote all eligible patterns
      */
     promoteEligiblePatterns() {
-        const shortTermPatterns = this.db.prepare(`
-      SELECT id FROM qe_patterns
-      WHERE tier = 'short-term' AND deprecated_at IS NULL
-    `).all();
+        const shortTermPatterns = this.selectShortTermPatternIds();
         let promoted = 0;
         for (const { id } of shortTermPatterns) {
             if (this.promotePattern(id)) {
@@ -492,6 +437,29 @@ Pattern extracted from ${exp.count} successful experiences.`;
         }
         return { promoted, checked: shortTermPatterns.length };
     }
+    /**
+     * promoteEligiblePatterns for the MCP server's background workers (#1283):
+     * each promotion is queued on the shared connection, so a locked memory.db
+     * does not freeze the event loop. Same selection, rule and result.
+     */
+    async promoteEligiblePatternsWhenUnlocked() {
+        const shortTermPatterns = this.selectShortTermPatternIds();
+        let promoted = 0;
+        for (const { id } of shortTermPatterns) {
+            if (!this.promotionVerified(id))
+                continue;
+            await writeWhenUnlockedOn(this.db, () => this.writePromotion(id));
+            console.log(`[PatternLifecycle] Promoted pattern ${id} to long-term`);
+            promoted++;
+        }
+        return { promoted, checked: shortTermPatterns.length };
+    }
+    selectShortTermPatternIds() {
+        return this.db.prepare(`
+      SELECT id FROM qe_patterns
+      WHERE tier = 'short-term' AND deprecated_at IS NULL
+    `).all();
+    }
     /**
      * Run a promotion sweep — convenience alias for pre-compaction hook.
      * Iterates short-term patterns, checks promotion criteria, promotes eligible ones.
@@ -570,6 +538,12 @@ Pattern extracted from ${exp.count} successful experiences.`;
             return false;
         }
         const actualReason = reason || check.reason || 'manual';
+        this.writeDeprecation(patternId, actualReason);
+        console.log(`[PatternLifecycle] Deprecated pattern ${patternId}: ${actualReason}`);
+        return true;
+    }
+    /** Soft-delete a pattern and record why, in one unit so a queued retry repeats both. */
+    writeDeprecation(patternId, actualReason) {
         // Move to deprecated state (soft delete)
         this.db.prepare(`
       UPDATE qe_patterns
@@ -593,17 +567,12 @@ Pattern extracted from ${exp.count} successful experiences.`;
         WHERE id = ?
       `).run(JSON.stringify({ deprecation_metadata: metadata }), patternId);
         }
-        console.log(`[PatternLifecycle] Deprecated pattern ${patternId}: ${actualReason}`);
-        return true;
     }
     /**
      * Deprecate all patterns that meet deprecation criteria
      */
     deprecateStalePatterns() {
-        const activePatterns = this.db.prepare(`
-      SELECT id FROM qe_patterns
-      WHERE deprecated_at IS NULL
-    `).all();
+        const activePatterns = this.selectActivePatternIds();
         let deprecated = 0;
         for (const { id } of activePatterns) {
             const check = this.checkDeprecation(id);
@@ -614,6 +583,30 @@ Pattern extracted from ${exp.count} successful experiences.`;
         }
         return { deprecated, checked: activePatterns.length };
     }
+    /**
+     * deprecateStalePatterns for the MCP server's background workers (#1283):
+     * each deprecation is queued on the shared connection. Same criteria and result.
+     */
+    async deprecateStalePatternsWhenUnlocked() {
+        const activePatterns = this.selectActivePatternIds();
+        let deprecated = 0;
+        for (const { id } of activePatterns) {
+            const check = this.checkDeprecation(id);
+            if (check.shouldDeprecate) {
+                const actualReason = check.reason || 'manual';
+                await writeWhenUnlockedOn(this.db, () => this.writeDeprecation(id, actualReason));
+                console.log(`[PatternLifecycle] Deprecated pattern ${id}: ${actualReason}`);
+                deprecated++;
+            }
+        }
+        return { deprecated, checked: activePatterns.length };
+    }
+    selectActivePatternIds() {
+        return this.db.prepare(`
+      SELECT id FROM qe_patterns
+      WHERE deprecated_at IS NULL
+    `).all();
+    }
     // ============================================================================
     // Confidence Decay
     // ============================================================================
@@ -621,6 +614,17 @@ Pattern extracted from ${exp.count} successful experiences.`;
      * Apply confidence decay to patterns that haven't been used recently
      */
     applyConfidenceDecay(daysSinceLastRun = 1) {
+        return this.writeConfidenceDecay(daysSinceLastRun, Date.now());
+    }
+    /**
+     * applyConfidenceDecay for the MCP server's background workers (#1283): the
+     * decay UPDATE is queued on the shared connection. Same cutoff and result.
+     */
+    async applyConfidenceDecayWhenUnlocked(daysSinceLastRun = 1) {
+        const now = Date.now();
+        return writeWhenUnlockedOn(this.db, () => this.writeConfidenceDecay(daysSinceLastRun, now));
+    }
+    writeConfidenceDecay(daysSinceLastRun, now) {
         // EWC++ (#510 item 6): per-row importance-weighted decay. The base decay
         // amount is shielded by `EWC_DECAY_PROTECTION * importance`, where
         // importance = success_rate (clamped) once usage_count >= the trust
@@ -629,7 +633,7 @@ Pattern extracted from ${exp.count} successful experiences.`;
         // so it isn't forgotten as fast as new low-value patterns.
         const baseDecayAmount = this.config.confidenceDecayRate * daysSinceLastRun;
         // Get patterns that haven't been used in the decay period
-        const cutoffTime = Date.now() - (daysSinceLastRun * 24 * 60 * 60 * 1000);
+        const cutoffTime = now - (daysSinceLastRun * 24 * 60 * 60 * 1000);
         const result = this.db.prepare(`
       UPDATE qe_patterns
       SET confidence = MAX(?, confidence * (1 - ? * (1 - ? *
@@ -931,6 +935,79 @@ Pattern extracted from ${exp.count} successful experiences.`;
 // ============================================================================
 // Factory
 // ============================================================================
+/**
+ * Add the lifecycle columns to qe_patterns if they are missing. Only writes
+ * (ALTER TABLE) on a database that predates them.
+ */
+function ensurePatternLifecycleSchema(db) {
+    // Add deprecated_at column if not exists
+    try {
+        db.prepare(`
+      SELECT deprecated_at FROM qe_patterns LIMIT 1
+    `).get();
+    }
+    catch (e) {
+        // Column doesn't exist, add it
+        logger.debug('Adding missing deprecated_at column', { error: e instanceof Error ? e.message : String(e) });
+        db.exec(`
+      ALTER TABLE qe_patterns ADD COLUMN deprecated_at TEXT DEFAULT NULL
+    `);
+        console.log('[PatternLifecycle] Added deprecated_at column to qe_patterns');
+    }
+    // Add consecutive_failures column if not exists
+    try {
+        db.prepare(`
+      SELECT consecutive_failures FROM qe_patterns LIMIT 1
+    `).get();
+    }
+    catch (e) {
+        logger.debug('Adding missing consecutive_failures column', { error: e instanceof Error ? e.message : String(e) });
+        db.exec(`
+      ALTER TABLE qe_patterns ADD COLUMN consecutive_failures INTEGER DEFAULT 0
+    `);
+        console.log('[PatternLifecycle] Added consecutive_failures column to qe_patterns');
+    }
+    // Add promotion_date column if not exists
+    try {
+        db.prepare(`
+      SELECT promotion_date FROM qe_patterns LIMIT 1
+    `).get();
+    }
+    catch (e) {
+        logger.debug('Adding missing promotion_date column', { error: e instanceof Error ? e.message : String(e) });
+        db.exec(`
+      ALTER TABLE qe_patterns ADD COLUMN promotion_date TEXT DEFAULT NULL
+    `);
+        console.log('[PatternLifecycle] Added promotion_date column to qe_patterns');
+    }
+    // ADR-121: provenance_tier — additive, conservative-default migration.
+    // The DEFAULT backfills every existing row as 'proxy:structural', which can
+    // never over-credit legacy history. Rows re-derived from execution evidence
+    // are re-tiered upward through the normal write path (never up-tiered here).
+    // Distinct from the lifecycle `tier` (short-term/long-term) column.
+    try {
+        db.prepare(`
+      SELECT provenance_tier FROM qe_patterns LIMIT 1
+    `).get();
+    }
+    catch (e) {
+        logger.debug('Adding missing provenance_tier column', { error: e instanceof Error ? e.message : String(e) });
+        db.exec(`
+      ALTER TABLE qe_patterns ADD COLUMN provenance_tier TEXT DEFAULT '${DEFAULT_PROVENANCE_TIER}'
+    `);
+        console.log(`[PatternLifecycle] Added provenance_tier column to qe_patterns (backfilled '${DEFAULT_PROVENANCE_TIER}')`);
+    }
+}
+/**
+ * Create a pattern lifecycle manager for the MCP server's background workers
+ * (#1283). A database that predates the lifecycle columns gets its ALTER
+ * TABLEs through the shared connection's write queue first, so a locked
+ * memory.db does not freeze the event loop on the worker's first tick.
+ */
+export async function createPatternLifecycleManagerWhenUnlocked(db, config) {
+    await writeWhenUnlockedOn(db, () => ensurePatternLifecycleSchema(db));
+    return new PatternLifecycleManager(db, config);
+}
 /**
  * Create a pattern lifecycle manager
  */

package/dist/learning/pattern-null-store.d.ts

@@ -20,6 +20,11 @@ export declare class PatternNullStore {
     constructor(db: DatabaseType);
     /** Record a failure; consolidates on repeat (pattern, context) pairs. */
     recordNull(record: PatternNullRecord): void;
+    /**
+     * recordNull() through the shared connection's write queue (#1283), so a
+     * locked memory.db does not freeze the MCP server's event loop.
+     */
+    recordNullWhenUnlocked(record: PatternNullRecord): Promise<void>;
     /** Batch summaries for retrieval-time surfacing. Missing patterns simply have no entry. */
     getNullSummaries(patternIds: string[]): Map<string, NullSummary>;
     /**

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

@@ -14,6 +14,7 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { applyMigration } from '../migrations/20260611_add_pattern_nulls_table.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 /** Weight of a context-matched null vs a null from elsewhere (ADR-110: local nulls outweigh remote successes). */
 const CONTEXT_MATCHED_WEIGHT = 0.15;
 const UNMATCHED_WEIGHT = 0.03;
@@ -38,6 +39,13 @@ export class PatternNullStore {
         updated_at = datetime('now')
     `).run(uuidv4(), record.patternId, record.contextFingerprint, record.failureMode, record.trajectoryRef ?? null, record.evidenceClass ?? 'EXECUTED');
     }
+    /**
+     * recordNull() through the shared connection's write queue (#1283), so a
+     * locked memory.db does not freeze the MCP server's event loop.
+     */
+    recordNullWhenUnlocked(record) {
+        return writeWhenUnlockedOn(this.db, () => this.recordNull(record));
+    }
     /** Batch summaries for retrieval-time surfacing. Missing patterns simply have no entry. */
     getNullSummaries(patternIds) {
         const out = new Map();

package/dist/learning/pattern-promotion.js

@@ -7,6 +7,7 @@
  */
 import { LoggerFactory } from '../logging/index.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { writeWhenUnlockedOn } from '../shared/sqlite-write-queue.js';
 import { shouldPromotePattern, calculateQualityScore } from './qe-patterns.js';
 import { getWitnessChain } from '../audit/witness-chain.js';
 import { RELATED_DOMAINS } from './agent-routing.js';
@@ -76,7 +77,9 @@ export async function promotePattern(patternId, deps) {
     const result = await deps.patternStore.promote(patternId);
     if (result.success) {
         try {
-            deps.getSqliteStore().promotePattern(patternId);
+            const store = deps.getSqliteStore();
+            // #1283: queued on the shared connection, so a locked memory.db does not freeze the MCP server.
+            await writeWhenUnlockedOn(store.getDatabase(), () => store.promotePattern(patternId));
         }
         catch (e) {
             logger.warn('SQLite pattern promotion persist failed', {
@@ -98,7 +101,7 @@ export async function promotePattern(patternId, deps) {
                         if (peers.success) {
                             for (const { pattern: peer } of peers.value) {
                                 if (peer.id !== patternId) {
-                                    citationGraph.recordCoOccurrence(patternId, peer.id);
+                                    await writeWhenUnlockedOn(db, () => citationGraph.recordCoOccurrence(patternId, peer.id));
                                 }
                             }
                         }
@@ -126,7 +129,7 @@ export async function promotePattern(patternId, deps) {
             }
         }
         getWitnessChain()
-            .then((wc) => wc.append('PATTERN_PROMOTE', { patternId }, 'reasoning-bank'))
+            .then((wc) => wc.appendWhenUnlocked('PATTERN_PROMOTE', { patternId }, 'reasoning-bank'))
             .catch((e) => {
             logger.warn('Witness chain PATTERN_PROMOTE failed', {
                 error: toErrorMessage(e),

package/dist/learning/pattern-store.d.ts

@@ -326,6 +326,12 @@ export declare class PatternStore implements IPatternStore {
      * Record pattern usage and update stats
      */
     recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
+    /**
+     * 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.
+     */
+    private persistToSqlite;
     /**
      * Promote pattern from short-term to long-term storage
      */

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
      *