agentic-qe 3.15.15 → 3.15.17

package/dist/learning/experience-capture-middleware.js

@@ -16,6 +16,7 @@ import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { createLogger } from '../logging/logger-factory.js';
 import { isLearnableResult } from './learnable-result.js';
+import { recordExperienceEmbeddingSpace } from './embedding-space.js';
 const ecLogger = createLogger('ExperienceCapture');
 // ============================================================================
 // Active Experience Tracking
@@ -308,8 +309,9 @@ async function persistExperience(context, outcome) {
         console.warn('[ExperienceCaptureMiddleware] Memory manager not available');
         return;
     }
+    const memory = memoryManager;
     try {
-        const db = memoryManager.getDatabase();
+        const db = memory.getDatabase();
         if (!db)
             return;
         const stmt = db.prepare(`
@@ -318,9 +320,11 @@ async function persistExperience(context, outcome) {
        routing_json, steps_json, result_json, error, started_at, completed_at, source)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?)
     `);
-        stmt.run(outcome.id, context.task, context.agent, context.domain, outcome.success ? 1 : 0, outcome.quality, outcome.durationMs, context.modelTier || null, safeJsonStringify(context.routing), safeJsonStringify(outcome.steps), safeJsonStringify(outcome.result), outcome.error || null, context.startedAt.toISOString(), 'middleware');
+        // #1274: queued, so a locked memory.db does not freeze the MCP server's
+        // event loop while experiences are captured.
+        await memory.writeWhenUnlocked(() => stmt.run(outcome.id, context.task, context.agent, context.domain, outcome.success ? 1 : 0, outcome.quality, outcome.durationMs, context.modelTier || null, safeJsonStringify(context.routing), safeJsonStringify(outcome.steps), safeJsonStringify(outcome.result), outcome.error || null, context.startedAt.toISOString(), 'middleware'));
         // Fire-and-forget: compute and store embedding for this experience
-        computeExperienceEmbedding(db, outcome.id, context.task, context.domain).catch((e) => { ecLogger.warn('Embedding computation failed', { error: e instanceof Error ? e.message : String(e), experienceId: outcome.id, domain: context.domain }); });
+        computeExperienceEmbedding(memory, outcome.id, context.task, context.domain).catch((e) => { ecLogger.warn('Embedding computation failed', { error: e instanceof Error ? e.message : String(e), experienceId: outcome.id, domain: context.domain }); });
     }
     catch (error) {
         console.error('[ExperienceCaptureMiddleware] Failed to persist experience:', error);
@@ -330,19 +334,26 @@ async function persistExperience(context, outcome) {
  * Compute and store embedding for a captured experience (async, non-blocking).
  * Uses the shared ONNX transformer model (all-MiniLM-L6-v2, 384-dim).
  */
-async function computeExperienceEmbedding(db, experienceId, task, domain) {
+async function computeExperienceEmbedding(memory, experienceId, task, domain) {
     try {
-        const { computeRealEmbedding } = await import('./real-embeddings.js');
+        const { computeRealEmbedding, getActiveEmbeddingSpaceIdentity } = await import('./real-embeddings.js');
         const text = `${domain}: ${task}`.slice(0, 512); // Cap input length
         const embedding = await computeRealEmbedding(text);
         if (!embedding || embedding.length === 0)
             return;
         const buffer = Buffer.from(new Float32Array(embedding).buffer);
-        db.prepare(`
-      UPDATE captured_experiences
-      SET embedding = ?, embedding_dimension = ?
-      WHERE id = ? AND embedding IS NULL
-    `).run(buffer, embedding.length, experienceId);
+        const db = memory.getDatabase();
+        await memory.writeWhenUnlocked(() => {
+            const updated = db.prepare(`
+        UPDATE captured_experiences
+        SET embedding = ?, embedding_dimension = ?
+        WHERE id = ? AND embedding IS NULL
+      `).run(buffer, embedding.length, experienceId);
+            // #1217 (ADR-097): store the vector's embedding space with it.
+            if (updated.changes > 0) {
+                recordExperienceEmbeddingSpace(db, experienceId, getActiveEmbeddingSpaceIdentity()?.spaceId);
+            }
+        });
     }
     catch {
         // Non-critical — embedding will be backfilled later if needed
@@ -354,8 +365,9 @@ async function computeExperienceEmbedding(db, experienceId, task, domain) {
 async function persistToSonaPatterns(context, outcome) {
     if (!memoryManager)
         return;
+    const memory = memoryManager;
     try {
-        const db = memoryManager.getDatabase();
+        const db = memory.getDatabase();
         if (!db)
             return;
         // Only store successful patterns with decent quality
@@ -368,12 +380,12 @@ async function persistToSonaPatterns(context, outcome) {
        confidence, usage_count, metadata, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
     `);
-        stmt.run(`sona-${outcome.id}`, 'task-execution', context.domain, context.agent, safeJsonStringify({ task: context.task.slice(0, 200) }), outcome.quality, 1, outcome.quality, outcome.quality, 1, safeJsonStringify({
+        await memory.writeWhenUnlocked(() => stmt.run(`sona-${outcome.id}`, 'task-execution', context.domain, context.agent, safeJsonStringify({ task: context.task.slice(0, 200) }), outcome.quality, 1, outcome.quality, outcome.quality, 1, safeJsonStringify({
             experienceId: outcome.id,
             durationMs: outcome.durationMs,
             stepsCount: outcome.steps.length,
             modelTier: context.modelTier,
-        }));
+        })));
     }
     catch (error) {
         // Log but don't fail - sona_patterns might not exist

package/dist/learning/experience-capture.js

@@ -234,7 +234,7 @@ export class ExperienceCaptureService {
             const contextFingerprint = `${experience.domain ?? 'unknown'}:${experience.agent ?? 'unknown'}`;
             for (const patternId of experience.appliedPatterns) {
                 try {
-                    this.nullRecorder({
+                    await this.nullRecorder({
                         patternId,
                         contextFingerprint,
                         failureMode: experience.testOutcome ?? experience.feedback ?? 'task-failure',

package/dist/learning/experience-consolidation.d.ts

@@ -70,6 +70,11 @@ export interface ConsolidationConfig {
     contradictionSimilarityThreshold: number;
     /** Min quality gap that turns a near-duplicate into a contradiction (0-1). */
     contradictionQualityDelta: number;
+    /**
+     * #1281: embedding space (ADR-097 spaceId) whose vectors Phase 1 compares.
+     * Defaults to the active embedder's space.
+     */
+    embeddingSpaceId?: string;
 }
 export declare class ExperienceConsolidator {
     private readonly config;
@@ -94,9 +99,22 @@ export declare class ExperienceConsolidator {
     bootstrapDomain(domain: string): Promise<ConsolidationResult>;
     private clusterAndMerge;
     private reinforceQuality;
+    private reinforceQualityNow;
     private archiveValueless;
+    private archiveValuelessNow;
     private hardDeleteExcess;
+    private hardDeleteExcessNow;
+    /** #1281: the embedding space Phase 1 compares vectors in, or null if unknown. */
+    private resolveEmbeddingSpaceId;
+    /** Tables created before #1217 have no embedding_space_id column. */
+    private hasEmbeddingSpaceColumn;
     private ensureInitialized;
+    /**
+     * Queue a write on the shared connection (#1283): the learning worker runs
+     * consolidation inside the MCP server, where a locked memory.db must not
+     * freeze the event loop. On any other connection the write runs at once.
+     */
+    private write;
     private bufferToFloatArray;
 }
 /**

package/dist/learning/experience-consolidation.js

@@ -15,7 +15,8 @@
  * Ensures the Exp counter is monotonically non-decreasing.
  */
 import { v4 as uuidv4 } from 'uuid';
-import { getUnifiedMemory } from '../kernel/unified-memory.js';
+import { getUnifiedMemory, writeWhenUnlockedOn } from '../kernel/unified-memory.js';
+import { ensureEndpointEmbeddingSpaceIdentity, getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 import { HNSWEmbeddingIndex } from '../integrations/embeddings/index/HNSWIndex.js';
 const DEFAULT_CONFIG = {
     mergeSimilarityThreshold: 0.85,
@@ -111,9 +112,9 @@ export class ExperienceConsolidator {
         result.merged = clusterResult.merged;
         result.contradicted = clusterResult.contradicted;
         // Phase 2: Quality Reinforcement
-        result.qualityUpdated = this.reinforceQuality(domain);
+        result.qualityUpdated = await this.reinforceQuality(domain);
         // Phase 3: Archive Valueless
-        result.archived = this.archiveValueless(domain);
+        result.archived = await this.archiveValueless(domain);
         // Safety valve: when the domain still exceeds hardThreshold after the
         // soft phases, archive (not delete) the oldest low-quality excess.
         // Result is attributed to `archived` — `hardDeleted` stays 0 since
@@ -121,7 +122,7 @@ export class ExperienceConsolidator {
         const afterCount = this.db.prepare("SELECT COUNT(*) as cnt FROM captured_experiences WHERE domain = ? AND consolidated_into IS NULL").get(domain).cnt;
         let safetyValveArchived = 0;
         if (afterCount > this.config.hardThreshold) {
-            safetyValveArchived = this.hardDeleteExcess(domain, afterCount);
+            safetyValveArchived = await this.hardDeleteExcess(domain, afterCount);
             result.archived += safetyValveArchived;
         }
         result.activeRemaining = afterCount - safetyValveArchived;
@@ -150,7 +151,8 @@ export class ExperienceConsolidator {
         Object.assign(this.config, savedConfig);
         // Set bootstrap flag
         try {
-            this.db.prepare("INSERT OR REPLACE INTO kv_store (key, value, namespace) VALUES (?, ?, 'system')").run(`consolidation_bootstrap_${domain}`, new Date().toISOString());
+            const bootstrappedAt = new Date().toISOString();
+            await this.write(() => this.db.prepare("INSERT OR REPLACE INTO kv_store (key, value, namespace) VALUES (?, ?, 'system')").run(`consolidation_bootstrap_${domain}`, bootstrappedAt));
         }
         catch {
             // kv_store may not exist in all setups
@@ -163,6 +165,12 @@ export class ExperienceConsolidator {
     // Phase 1: Cluster & Merge
     // ============================================================================
     async clusterAndMerge(domain) {
+        // #1281 (ADR-097): a cosine between vectors of different embedding spaces
+        // is meaningless, even at the same dimension. Only vectors recorded in the
+        // active space are compared; without a known space nothing is merged.
+        const spaceId = await this.resolveEmbeddingSpaceId();
+        if (!spaceId || !this.hasEmbeddingSpaceColumn())
+            return { merged: 0, contradicted: 0 };
         // Get active experiences with embeddings, sorted by quality DESC
         const candidates = this.db.prepare(`
       SELECT id, task, domain, quality, success, application_count,
@@ -170,8 +178,9 @@ export class ExperienceConsolidator {
              embedding, embedding_dimension, started_at
       FROM captured_experiences
       WHERE domain = ? AND consolidated_into IS NULL AND embedding IS NOT NULL
+        AND embedding_space_id = ?
       ORDER BY quality DESC
-    `).all(domain);
+    `).all(domain, spaceId);
         if (candidates.length < 2)
             return { merged: 0, contradicted: 0 };
         // Build a temporary HNSW index for this domain
@@ -293,7 +302,7 @@ export class ExperienceConsolidator {
                     boostSurvivor.run(mergedIds.length, boost, row.id);
                     logConsolidation.run(uuidv4(), domain, 'merge', JSON.stringify(mergedIds), row.id, JSON.stringify({ count: mergedIds.length, boost }));
                 });
-                transaction();
+                await writeWhenUnlockedOn(this.db, transaction);
             }
             // Apply contradiction suppressions in a transaction. The loser is
             // soft-suppressed (consolidated_into = 'contradicted'), so it is excluded
@@ -306,7 +315,7 @@ export class ExperienceConsolidator {
                     }
                     logConsolidation.run(uuidv4(), domain, 'contradiction', JSON.stringify(contradictedIds), row.id, JSON.stringify({ count: contradictedIds.length, survivorQuality: row.quality }));
                 });
-                tx();
+                await writeWhenUnlockedOn(this.db, tx);
             }
         }
         // Clean up HNSW index
@@ -317,6 +326,10 @@ export class ExperienceConsolidator {
     // Phase 2: Quality Reinforcement
     // ============================================================================
     reinforceQuality(domain) {
+        // Read and update in one queued unit, so the update uses current values.
+        return this.write(() => this.reinforceQualityNow(domain));
+    }
+    reinforceQualityNow(domain) {
         // Get experiences with application history
         const experiences = this.db.prepare(`
       SELECT ce.id, ce.quality, ce.consolidation_count,
@@ -366,6 +379,9 @@ export class ExperienceConsolidator {
     // Phase 3: Archive Valueless
     // ============================================================================
     archiveValueless(domain) {
+        return this.write(() => this.archiveValuelessNow(domain));
+    }
+    archiveValuelessNow(domain) {
         const cutoffDate = new Date();
         cutoffDate.setDate(cutoffDate.getDate() - this.config.archiveMinAgeDays);
         const cutoffStr = cutoffDate.toISOString().replace('T', ' ').slice(0, 19);
@@ -415,6 +431,9 @@ export class ExperienceConsolidator {
     // ConsolidationResult.hardDeleted is kept zero for that reason; the
     // archive count is rolled into Phase 3's `archived` total.
     hardDeleteExcess(domain, currentCount) {
+        return this.write(() => this.hardDeleteExcessNow(domain, currentCount));
+    }
+    hardDeleteExcessNow(domain, currentCount) {
         const excess = currentCount - this.config.hardThreshold;
         if (excess <= 0)
             return 0;
@@ -455,11 +474,39 @@ export class ExperienceConsolidator {
     // ============================================================================
     // Utilities
     // ============================================================================
+    /** #1281: the embedding space Phase 1 compares vectors in, or null if unknown. */
+    async resolveEmbeddingSpaceId() {
+        if (this.config.embeddingSpaceId)
+            return this.config.embeddingSpaceId;
+        const active = getActiveEmbeddingSpaceIdentity()?.spaceId;
+        if (active)
+            return active;
+        try {
+            // A configured endpoint's identity, as the pattern stores resolve it (#754).
+            return (await ensureEndpointEmbeddingSpaceIdentity())?.spaceId ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Tables created before #1217 have no embedding_space_id column. */
+    hasEmbeddingSpaceColumn() {
+        const columns = this.db.prepare('PRAGMA table_info(captured_experiences)').all();
+        return columns.some(c => c.name === 'embedding_space_id');
+    }
     ensureInitialized() {
         if (!this.initialized || !this.db) {
             throw new Error('ExperienceConsolidator not initialized. Call initialize() first.');
         }
     }
+    /**
+     * Queue a write on the shared connection (#1283): the learning worker runs
+     * consolidation inside the MCP server, where a locked memory.db must not
+     * freeze the event loop. On any other connection the write runs at once.
+     */
+    write(fn) {
+        return writeWhenUnlockedOn(this.db, fn);
+    }
     bufferToFloatArray(buffer, dimension) {
         const arr = [];
         for (let i = 0; i < dimension; i++) {

package/dist/learning/experience-space-verification.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+interface VerifiableDatabase {
+    prepare(sql: string): {
+        all(...params: unknown[]): unknown[];
+        get(...params: unknown[]): unknown;
+        run(...params: unknown[]): {
+            changes: number;
+        };
+    };
+}
+export interface LegacyExperienceRow {
+    rowid: number;
+    id: string;
+    task: string;
+    agent: string | null;
+    domain: string | null;
+    steps_json: string | null;
+    source: string | null;
+    embedding: Buffer;
+    embedding_dimension: number;
+}
+export interface ExperienceSpaceVerificationOptions {
+    /** Embed text in the active space; throws when the embedder fails. */
+    embed: (text: string) => Promise<number[]>;
+    /** The active embedding space, read after embedding. */
+    activeSpaceId: () => string | undefined;
+    /** Rows to check in this pass. */
+    limit?: number;
+    /** Runs a write (e.g. UnifiedMemoryManager.writeWhenUnlocked). */
+    write?: <T>(fn: () => T) => Promise<T> | T;
+}
+export interface ExperienceSpaceVerificationResult {
+    spaceId: string | null;
+    checked: number;
+    stamped: string[];
+    left: number;
+}
+/**
+ * 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 declare function legacyExperienceEmbeddingTexts(row: LegacyExperienceRow): string[];
+/**
+ * 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 declare function verifyLegacyExperienceSpaces(db: VerifiableDatabase, options: ExperienceSpaceVerificationOptions): Promise<ExperienceSpaceVerificationResult>;
+export {};
+//# sourceMappingURL=experience-space-verification.d.ts.map

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