agentic-qe 3.15.15 → 3.15.16

package/dist/learning/experience-space-verification.js

@@ -0,0 +1,147 @@
+/**
+ * Attribute legacy experience vectors to an embedding space (#1217)
+ *
+ * captured_experiences rows written before #1217 carry a vector but no
+ * embedding_space_id, so ExperienceReplay never compares them. Their vectors
+ * are learning data and are never overwritten here. Instead each row's text is
+ * re-embedded with the recipe its writer used; when the result matches the
+ * stored vector (cosine >= EMBEDDING_ROUND_TRIP_MIN_COSINE), the stored vector
+ * came from the active space and only embedding_space_id is set. A row that
+ * does not match (another space, or text that can no longer be rebuilt) is
+ * left as it is: it stays excluded from comparison.
+ *
+ * Progress is kept per space in kv_store, so rows that did not match are not
+ * re-checked on every start; a different active space starts over.
+ */
+import { cosineSimilarity } from '../shared/utils/vector-math.js';
+import { safeJsonParse } from '../shared/safe-json.js';
+import { scrubReasoningBlocks } from '../shared/reasoning-scrub.js';
+import { EMBEDDING_ROUND_TRIP_MIN_COSINE } from './embedding-space.js';
+const CURSOR_NAMESPACE = '_system';
+const cursorKey = (spaceId) => `experience-space-verified-rowid:${spaceId}`;
+/**
+ * The texts the row's writer may have embedded. Each is only a candidate:
+ * a row is attributed only when one reproduces its stored vector.
+ * - experience-capture middleware and the CLI hooks: `${domain}: ${task}`,
+ *   capped at 512 chars (the hooks store task capped at 500, so a longer
+ *   task cannot be rebuilt and will not match);
+ * - ExperienceReplay's start-up backfill: the same, scrubbed (ADR-099);
+ * - ExperienceReplay.storeExperience (source 'experience-replay'):
+ *   `${task} ${strategy} ${keyActions}`, strategy in `agent`, key actions
+ *   in steps_json.
+ */
+export function legacyExperienceEmbeddingTexts(row) {
+    const domainTask = `${row.domain ?? ''}: ${row.task}`;
+    const texts = new Set([
+        domainTask.slice(0, 512),
+        scrubReasoningBlocks(domainTask).slice(0, 512),
+    ]);
+    if (row.source === 'experience-replay') {
+        const keyActions = safeJsonParse(row.steps_json || '[]');
+        if (Array.isArray(keyActions)) {
+            texts.add(`${row.task} ${row.agent ?? ''} ${keyActions.join(' ')}`);
+        }
+    }
+    return [...texts];
+}
+function storedVector(row) {
+    if (row.embedding.length < row.embedding_dimension * 4)
+        return null;
+    const v = [];
+    for (let i = 0; i < row.embedding_dimension; i++)
+        v.push(row.embedding.readFloatLE(i * 4));
+    return v;
+}
+function readCursor(db, spaceId) {
+    try {
+        const row = db.prepare('SELECT value FROM kv_store WHERE namespace = ? AND key = ?')
+            .get(CURSOR_NAMESPACE, cursorKey(spaceId));
+        return row ? Number(row.value) || 0 : 0;
+    }
+    catch {
+        return 0; // no kv_store: check from the start
+    }
+}
+function writeCursor(db, spaceId, rowid) {
+    try {
+        db.prepare('INSERT OR REPLACE INTO kv_store (key, namespace, value) VALUES (?, ?, ?)')
+            .run(cursorKey(spaceId), CURSOR_NAMESPACE, String(rowid));
+    }
+    catch {
+        // Without kv_store the next start checks these rows again.
+    }
+}
+/**
+ * Check up to `limit` legacy rows (vector, no embedding_space_id) and set
+ * embedding_space_id on those whose stored vector the active embedder
+ * reproduces. Never writes a vector. Stops at the first embedder failure.
+ */
+export async function verifyLegacyExperienceSpaces(db, options) {
+    const write = options.write ?? ((fn) => fn());
+    const result = { spaceId: null, checked: 0, stamped: [], left: 0 };
+    // The cursor is per space, so the space must be known first: embedding
+    // anything initializes the embedder if needed.
+    let spaceId = options.activeSpaceId();
+    const rowsAfter = (cursor) => db.prepare(`
+    SELECT rowid, id, task, agent, domain, steps_json, source, embedding, embedding_dimension
+    FROM captured_experiences
+    WHERE rowid > ? AND embedding IS NOT NULL AND embedding_space_id IS NULL
+      AND embedding_dimension > 0 AND consolidated_into IS NULL
+    ORDER BY rowid LIMIT ?
+  `).all(cursor, options.limit ?? 200);
+    let rows = rowsAfter(spaceId ? readCursor(db, spaceId) : 0);
+    if (rows.length === 0)
+        return result;
+    if (!spaceId) {
+        await options.embed(legacyExperienceEmbeddingTexts(rows[0])[0]);
+        spaceId = options.activeSpaceId();
+        if (!spaceId)
+            return result;
+        rows = rowsAfter(readCursor(db, spaceId));
+    }
+    result.spaceId = spaceId;
+    const stamp = db.prepare(`
+    UPDATE captured_experiences SET embedding_space_id = ?
+    WHERE id = ? AND embedding_space_id IS NULL AND embedding = ?
+  `);
+    let lastRowid = 0;
+    try {
+        for (const row of rows) {
+            const stored = storedVector(row);
+            let matched = false;
+            if (stored) {
+                for (const text of legacyExperienceEmbeddingTexts(row)) {
+                    const recomputed = await options.embed(text);
+                    if (options.activeSpaceId() !== spaceId)
+                        return result; // embedder changed mid-pass
+                    if (recomputed.length === stored.length
+                        && cosineSimilarity(stored, recomputed) >= EMBEDDING_ROUND_TRIP_MIN_COSINE) {
+                        matched = true;
+                        break;
+                    }
+                }
+            }
+            if (matched) {
+                // Only the provenance column, and only if the vector is still the one checked.
+                const changes = (await write(() => stamp.run(spaceId, row.id, row.embedding))).changes;
+                if (changes > 0)
+                    result.stamped.push(row.id);
+                else
+                    result.left++;
+            }
+            else {
+                result.left++;
+            }
+            result.checked++;
+            lastRowid = row.rowid;
+        }
+    }
+    finally {
+        // Rows checked so far are not checked again in this space, even when an
+        // embedder failure ends the pass early.
+        if (lastRowid > 0)
+            await write(() => writeCursor(db, spaceId, lastRowid));
+    }
+    return result;
+}
+//# sourceMappingURL=experience-space-verification.js.map

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

@@ -156,10 +156,6 @@ export declare class PatternLifecycleManager {
     private _compressionService;
     set compressionService(svc: TemporalCompressionService | null);
     constructor(db: DatabaseType, config?: Partial<PatternLifecycleConfig>);
-    /**
-     * Ensure required schema extensions exist
-     */
-    private ensureSchema;
     /**
      * Get recent experiences from captured_experiences table.
      */
@@ -202,6 +198,9 @@ export declare class PatternLifecycleManager {
      * Promote pattern to long-term tier
      */
     promotePattern(patternId: string): boolean;
+    /** Whether `patternId` passes the advisory check and the frozen promote rule. */
+    private promotionVerified;
+    private writePromotion;
     /**
      * Promote all eligible patterns
      */
@@ -209,6 +208,16 @@ export declare class PatternLifecycleManager {
         promoted: number;
         checked: number;
     };
+    /**
+     * 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.
+     */
+    promoteEligiblePatternsWhenUnlocked(): Promise<{
+        promoted: number;
+        checked: number;
+    }>;
+    private selectShortTermPatternIds;
     /**
      * Run a promotion sweep — convenience alias for pre-compaction hook.
      * Iterates short-term patterns, checks promotion criteria, promotes eligible ones.
@@ -225,6 +234,8 @@ export declare class PatternLifecycleManager {
      * Deprecate a pattern (soft delete)
      */
     deprecatePattern(patternId: string, reason?: string): boolean;
+    /** Soft-delete a pattern and record why, in one unit so a queued retry repeats both. */
+    private writeDeprecation;
     /**
      * Deprecate all patterns that meet deprecation criteria
      */
@@ -232,6 +243,15 @@ export declare class PatternLifecycleManager {
         deprecated: number;
         checked: number;
     };
+    /**
+     * deprecateStalePatterns for the MCP server's background workers (#1283):
+     * each deprecation is queued on the shared connection. Same criteria and result.
+     */
+    deprecateStalePatternsWhenUnlocked(): Promise<{
+        deprecated: number;
+        checked: number;
+    }>;
+    private selectActivePatternIds;
     /**
      * Apply confidence decay to patterns that haven't been used recently
      */
@@ -239,6 +259,15 @@ export declare class PatternLifecycleManager {
         updated: number;
         decayed: number;
     };
+    /**
+     * applyConfidenceDecay for the MCP server's background workers (#1283): the
+     * decay UPDATE is queued on the shared connection. Same cutoff and result.
+     */
+    applyConfidenceDecayWhenUnlocked(daysSinceLastRun?: number): Promise<{
+        updated: number;
+        decayed: number;
+    }>;
+    private writeConfidenceDecay;
     /**
      * Record pattern usage success/failure
      */
@@ -303,6 +332,13 @@ export declare class PatternLifecycleManager {
      */
     private rowToPattern;
 }
+/**
+ * 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 declare function createPatternLifecycleManagerWhenUnlocked(db: DatabaseType, config?: Partial<PatternLifecycleConfig>): Promise<PatternLifecycleManager>;
 /**
  * Create a pattern lifecycle manager
  */

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