agentic-qe 3.14.3 → 3.14.5

package/dist/integrations/ruvector/brain-rvf-exporter.js

@@ -6,7 +6,8 @@
 import { existsSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'fs';
 import { basename, dirname, join, resolve } from 'path';
 import { createRvfStore, openRvfStore, openRvfStoreReadonly, isRvfNativeAvailable, } from './rvf-native-adapter.js';
-import { sha256, tableExists, queryAll, domainFilterForColumn, ensureTargetTables, mergeGenericRow, mergeAppendOnlyRow, TABLE_CONFIGS, TABLE_BLOB_COLUMNS, PK_COLUMNS, CONFIDENCE_COLUMNS, TIMESTAMP_COLUMNS, serializeRowBlobs, deserializeRowBlobs, } from './brain-shared.js';
+import { sha256, tableExists, queryAll, domainFilterForColumn, runImportTransaction, mergeGenericRow, remapPatternReferences, mergeAppendOnlyRow, TABLE_CONFIGS, TABLE_BLOB_COLUMNS, PK_COLUMNS, CONFIDENCE_COLUMNS, TIMESTAMP_COLUMNS, serializeRowBlobs, deserializeRowBlobs, } from './brain-shared.js';
+import { appendBrainImportWitness } from './brain-import-audit.js';
 // --- Export ---
 /**
  * Sidecar suffixes that make up a complete store on disk. `''` is the store
@@ -355,7 +356,7 @@ export function importBrainFromRvf(db, rvfPath, options) {
         throw new Error(`RVF file not found: ${filePath}`);
     }
     // Open read-write so compact() can reclaim space after conflict resolution (4.5)
-    const rvf = openRvfStore(filePath);
+    const rvf = options.dryRun ? openRvfStoreReadonly(filePath) : openRvfStore(filePath);
     try {
         // --- Verify HNSW index integrity before importing (4.1) ---
         // Fresh RVF files report valid=false with totalEntries=0 and no errors —
@@ -379,22 +380,6 @@ export function importBrainFromRvf(db, rvfPath, options) {
         catch (parseErr) {
             throw new Error(`Failed to parse brain kernel data as JSON: ${parseErr instanceof Error ? parseErr.message : parseErr}`);
         }
-        if (options.dryRun) {
-            let total = 0;
-            if (brainData.tables) {
-                for (const rows of Object.values(brainData.tables)) {
-                    total += (rows?.length ?? 0);
-                }
-            }
-            else {
-                total = (brainData.patterns?.length ?? 0) +
-                    (brainData.qValues?.length ?? 0) +
-                    (brainData.dreamInsights?.length ?? 0) +
-                    (brainData.witnessChain?.length ?? 0);
-            }
-            return { imported: total, skipped: 0, conflicts: 0, embeddingsRestored: 0 };
-        }
-        ensureTargetTables(db);
         let imported = 0;
         let skipped = 0;
         let conflicts = 0;
@@ -414,24 +399,28 @@ export function importBrainFromRvf(db, rvfPath, options) {
             }
         }
         // Wrap entire import in a transaction for atomicity (Risk #3 from plan)
-        const importAll = db.transaction(() => {
+        const importAll = () => {
+            const patternIds = new Map();
+            const patternWinners = new Map();
+            let sourceWitnessRows = 0;
             // Import in TABLE_CONFIGS order (FK-aware)
             for (const config of TABLE_CONFIGS) {
                 let rows = tablesMap[config.tableName];
                 if (!rows || !Array.isArray(rows))
                     continue;
+                if (config.tableName === 'witness_chain') {
+                    // A source chain cannot be grafted into another store's live chain.
+                    sourceWitnessRows += rows.length;
+                    skipped += rows.length;
+                    continue;
+                }
                 // Deserialize BLOBs
                 const blobCols = TABLE_BLOB_COLUMNS[config.tableName];
                 if (blobCols && blobCols.length > 0) {
                     rows = rows.map(r => deserializeRowBlobs(r, blobCols));
-                    for (const row of rows) {
-                        for (const col of blobCols) {
-                            if (row[col] instanceof Buffer)
-                                embeddingsRestored++;
-                        }
-                    }
                 }
-                for (const row of rows) {
+                for (const originalRow of rows) {
+                    const row = remapPatternReferences(originalRow, patternIds);
                     let result;
                     if (config.dedupColumns && config.dedupColumns.length > 0) {
                         result = mergeAppendOnlyRow(db, config.tableName, row, config.dedupColumns, config.preserveId);
@@ -440,17 +429,31 @@ export function importBrainFromRvf(db, rvfPath, options) {
                         const idCol = PK_COLUMNS[config.tableName] || 'id';
                         const tsCol = TIMESTAMP_COLUMNS[config.tableName];
                         const confCol = CONFIDENCE_COLUMNS[config.tableName];
-                        result = mergeGenericRow(db, config.tableName, row, idCol, options.mergeStrategy, tsCol, confCol);
+                        result = mergeGenericRow(db, config.tableName, row, idCol, options.mergeStrategy, tsCol, confCol, patternIds, patternWinners, originalRow.pattern_id);
+                    }
+                    if (result.imported) {
+                        for (const col of blobCols ?? []) {
+                            if (row[col] instanceof Buffer)
+                                embeddingsRestored++;
+                        }
                     }
                     imported += result.imported;
                     skipped += result.skipped;
                     conflicts += result.conflicts;
                 }
             }
-        });
-        importAll();
+            appendBrainImportWitness(db, {
+                sourceChecksum: sha256(kernel.image.toString('utf-8')),
+                sourceWitnessRows,
+                importedRecords: imported,
+                skippedRecords: skipped,
+                conflicts,
+            });
+            imported += 1;
+        };
+        runImportTransaction(db, options.dryRun ?? false, importAll);
         // Compact after conflict resolution (best-effort)
-        if (conflicts > 0) {
+        if (!options.dryRun && conflicts > 0) {
             try {
                 rvf.compact();
             }

package/dist/integrations/ruvector/brain-shared.d.ts

@@ -131,11 +131,13 @@ export declare function writeJsonl(filePath: string, rows: unknown[]): void;
  */
 export declare function writeJsonlStreaming(filePath: string, rows: Iterable<unknown>, transform?: (row: unknown) => unknown): number;
 export declare function readJsonl<T = unknown>(filePath: string, parser?: (line: string) => T): T[];
+/** Remap relational pattern references without rewriting signed witness payloads. */
+export declare function remapPatternReferences(row: Record<string, unknown>, patternIds: ReadonlyMap<string, string>): Record<string, unknown>;
 /**
  * Generic merge for tables with a TEXT PRIMARY KEY.
  * Uses strategy-based conflict resolution identical to the pattern-specific merges.
  */
-export declare function mergeGenericRow(db: Database.Database, tableName: string, row: Record<string, unknown>, idColumn: string, strategy: MergeStrategy, timestampColumn?: string, confidenceColumn?: string): MergeResult;
+export declare function mergeGenericRow(db: Database.Database, tableName: string, row: Record<string, unknown>, idColumn: string, strategy: MergeStrategy, timestampColumn?: string, confidenceColumn?: string, patternIds?: Map<string, string>, patternWinners?: Map<string, string | null>, originalPatternId?: unknown): MergeResult;
 /**
  * Merge for append-only tables (AUTOINCREMENT PK).
  * Deduplicates by checking composite columns; inserts if no match found.
@@ -154,4 +156,6 @@ export declare function updateDreamInsight(db: Database.Database, ins: DreamInsi
 export declare function insertWitnessEntry(db: Database.Database, entry: WitnessRow): void;
 /** Ensure all brain-related tables exist in the target database. */
 export declare function ensureTargetTables(db: Database.Database): void;
+/** Execute the real importer; dry runs roll back rows and schema, including nested calls. */
+export declare function runImportTransaction(db: Database.Database, dryRun: boolean, importer: () => void): void;
 //# sourceMappingURL=brain-shared.d.ts.map

package/dist/integrations/ruvector/brain-shared.js

@@ -190,6 +190,16 @@ export function readJsonl(filePath, parser = (line) => JSON.parse(line)) {
         return [];
     return content.split('\n').map(parser);
 }
+/** Remap relational pattern references without rewriting signed witness payloads. */
+export function remapPatternReferences(row, patternIds) {
+    const mapped = { ...row };
+    for (const column of ['pattern_id', 'source_pattern_id', 'target_pattern_id']) {
+        const id = mapped[column];
+        if (typeof id === 'string' && patternIds.has(id))
+            mapped[column] = patternIds.get(id);
+    }
+    return mapped;
+}
 // --- Generic merge for TEXT PK tables ---
 /** Dynamically insert a row into any table using its column keys. */
 function dynamicInsert(db, tableName, row) {
@@ -212,18 +222,57 @@ function dynamicUpdate(db, tableName, row, idColumn) {
  * Generic merge for tables with a TEXT PRIMARY KEY.
  * Uses strategy-based conflict resolution identical to the pattern-specific merges.
  */
-export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestampColumn, confidenceColumn) {
+export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestampColumn, confidenceColumn, patternIds, patternWinners, originalPatternId) {
     const validated = validateTableName(tableName);
+    const incomingId = String(row.id);
     if (!tableExists(db, validated)) {
         dynamicInsert(db, validated, row);
         return { imported: 1, skipped: 0, conflicts: 0 };
     }
-    const existing = db.prepare(`SELECT * FROM ${validated} WHERE ${idColumn} = ?`)
+    let existing = db.prepare(`SELECT * FROM ${validated} WHERE ${idColumn} = ?`)
         .get(row[idColumn]);
+    if (!existing && tableName === 'qe_patterns') {
+        existing = db.prepare('SELECT * FROM qe_patterns WHERE name = ? AND qe_domain = ? AND pattern_type = ?').get(row.name, row.qe_domain, row.pattern_type);
+    }
+    if (existing && tableName === 'qe_patterns') {
+        // Keep the destination identity: existing children must remain attached,
+        // and incoming children are remapped after all patterns have merged.
+        if (typeof row.id === 'string' && typeof existing.id === 'string') {
+            patternIds?.set(row.id, existing.id);
+        }
+        row = { ...row, id: existing.id };
+        if (!patternWinners?.has(String(existing.id)))
+            patternWinners?.set(String(existing.id), null);
+    }
+    if (tableName === 'qe_pattern_embeddings' && patternWinners?.has(String(row.pattern_id))) {
+        if (patternWinners.get(String(row.pattern_id)) !== originalPatternId) {
+            return { imported: 0, skipped: 1, conflicts: existing ? 1 : 0 };
+        }
+        if (existing)
+            dynamicUpdate(db, validated, row, idColumn);
+        else
+            dynamicInsert(db, validated, row);
+        return { imported: 1, skipped: 0, conflicts: existing ? 1 : 0 };
+    }
     if (!existing) {
+        if (tableName === 'qe_patterns')
+            patternWinners?.set(String(row.id), incomingId);
         dynamicInsert(db, validated, row);
         return { imported: 1, skipped: 0, conflicts: 0 };
     }
+    const replaceExisting = () => {
+        if (tableName === 'qe_patterns' && patternWinners) {
+            patternWinners.set(String(row.id), incomingId);
+            // An embedding describes pattern content, not its confidence or usage.
+            // Keep a valid vector for metadata-only updates when no vector is supplied.
+            const contentColumns = ['name', 'description', 'pattern_type', 'qe_domain', 'domain', 'template_json', 'context_json'];
+            if (contentColumns.some(column => Object.hasOwn(row, column) && (row[column] ?? null) !== (existing[column] ?? null)) &&
+                tableExists(db, 'qe_pattern_embeddings')) {
+                db.prepare('DELETE FROM qe_pattern_embeddings WHERE pattern_id = ?').run(row.id);
+            }
+        }
+        dynamicUpdate(db, validated, row, idColumn);
+    };
     switch (strategy) {
         case 'skip-conflicts':
             return { imported: 0, skipped: 1, conflicts: 1 };
@@ -232,7 +281,7 @@ export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestam
             const existingTime = existing[ts] || '';
             const incomingTime = row[ts] || '';
             if (incomingTime > existingTime) {
-                dynamicUpdate(db, validated, row, idColumn);
+                replaceExisting();
                 return { imported: 1, skipped: 0, conflicts: 1 };
             }
             return { imported: 0, skipped: 1, conflicts: 1 };
@@ -241,7 +290,7 @@ export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestam
             const cc = confidenceColumn || 'confidence';
             if (typeof row[cc] === 'number' && typeof existing[cc] === 'number') {
                 if (row[cc] > existing[cc]) {
-                    dynamicUpdate(db, validated, row, idColumn);
+                    replaceExisting();
                     return { imported: 1, skipped: 0, conflicts: 1 };
                 }
             }
@@ -349,4 +398,21 @@ export function insertWitnessEntry(db, entry) {
 export function ensureTargetTables(db) {
     ensureAllBrainTables(db);
 }
+/** Execute the real importer; dry runs roll back rows and schema, including nested calls. */
+export function runImportTransaction(db, dryRun, importer) {
+    const rollback = Symbol('brain import dry run');
+    const transaction = db.transaction(() => {
+        ensureTargetTables(db);
+        importer();
+        if (dryRun)
+            throw rollback;
+    });
+    try {
+        transaction.immediate();
+    }
+    catch (error) {
+        if (error !== rollback)
+            throw error;
+    }
+}
 //# sourceMappingURL=brain-shared.js.map

package/dist/integrations/ruvector/rvf-dual-writer.js

@@ -10,7 +10,7 @@
  * intercepting pattern embedding writes/deletes/searches and routing them
  * to one or both backends depending on the configured mode.
  */
-import { getActiveEmbeddingSpaceIdentity } from '../../learning/real-embeddings.js';
+import { ensureEndpointEmbeddingSpaceIdentity, getActiveEmbeddingSpaceIdentity } from '../../learning/real-embeddings.js';
 import { verifyOrCreateEmbeddingSpaceManifest } from '../../learning/embedding-space.js';
 /**
  * Wraps the real RvfNativeAdapter to conform to the simpler RvfStore interface.
@@ -97,26 +97,47 @@ export class RvfDualWriter {
                 this.rvfAvailable = false;
                 return;
             }
-            // Try open first, create if it fails
-            let nativeAdapter;
-            try {
-                nativeAdapter = adapter.openRvfStore(this.config.rvfPath);
+            // #754: a later process opens brain.rvf before any embed call has
+            // initialized the (lazy) endpoint runtime; resolve its identity first.
+            if (!this.activeSpaceId()) {
+                await ensureEndpointEmbeddingSpaceIdentity();
             }
-            catch {
+            const { isRvfLockHeldError, removeStaleRvfLock, quarantineUnusableStore } = await import('./rvf-store-integrity.js');
+            const tryOpen = () => {
+                try {
+                    return { store: adapter.openRvfStore(this.config.rvfPath), error: null };
+                }
+                catch (error) {
+                    return { store: null, error };
+                }
+            };
+            let { store: nativeAdapter, error: openError } = tryOpen();
+            if (!nativeAdapter && isRvfLockHeldError(openError)) {
+                // A dead CLI process can leave a valid RVF behind a native lock. Only
+                // reclaim a lock with a readable dead owner, then retry the open.
+                if (!removeStaleRvfLock(this.config.rvfPath))
+                    throw openError;
+                ({ store: nativeAdapter, error: openError } = tryOpen());
+                if (!nativeAdapter && isRvfLockHeldError(openError))
+                    throw openError;
+            }
+            if (!nativeAdapter) {
                 try {
                     nativeAdapter = adapter.createRvfStore(this.config.rvfPath, this.config.dimensions);
                 }
                 catch (createErr) {
-                    // Issue #563: open failed *and* create failed, so the file on disk is
-                    // provably unusable — the signature of an export killed mid-write
-                    // (open → ManifestNotFound, create → FsyncFailed because the path
-                    // exists). Previously this fell to the catch below and disabled RVF
-                    // silently for the whole run. Quarantine and rebuild instead.
-                    const { quarantineUnusableStore } = await import('./rvf-store-integrity.js');
-                    const quarantined = quarantineUnusableStore(this.config.rvfPath, createErr instanceof Error ? createErr.message : String(createErr));
-                    if (!quarantined)
-                        throw createErr; // live peer, or nothing to move
-                    nativeAdapter = adapter.createRvfStore(this.config.rvfPath, this.config.dimensions);
+                    // A peer may have created the file since the first open. Re-open
+                    // before considering recovery, and use that error (not FsyncFailed)
+                    // to distinguish a busy healthy store from structural corruption.
+                    ({ store: nativeAdapter, error: openError } = tryOpen());
+                    if (!nativeAdapter) {
+                        if (isRvfLockHeldError(openError))
+                            throw openError;
+                        const quarantined = quarantineUnusableStore(this.config.rvfPath, createErr instanceof Error ? createErr.message : String(createErr), openError);
+                        if (!quarantined)
+                            throw createErr;
+                        nativeAdapter = adapter.createRvfStore(this.config.rvfPath, this.config.dimensions);
+                    }
                 }
             }
             this.rvfStore = wrapNativeAdapter(nativeAdapter, this.config.dimensions);
@@ -126,6 +147,11 @@ export class RvfDualWriter {
         catch (err) {
             // Native adapter unavailable, or recovery itself failed. Degrade to
             // sqlite-only — but say so, instead of vanishing silently (#563).
+            try {
+                this.rvfStore?.close();
+            }
+            catch { /* best-effort cleanup */ }
+            this.rvfStore = null;
             this.rvfAvailable = false;
             console.warn(`[RVF] Dual-writer disabled for ${this.config.rvfPath}; falling back to SQLite: ` +
                 `${err instanceof Error ? err.message : String(err)}`);

package/dist/integrations/ruvector/rvf-store-integrity.d.ts

@@ -20,9 +20,9 @@
  *     the store magic is `SFVR`; a 104-byte `FLVR` lock is just a live-or-stale
  *     lock record.
  *
- * So the only sound trigger is "open failed *and* create failed": at that point
- * the file is provably unusable. The lock's pid is used as a *guard* — if it is
- * held by a live process, the store is presumed healthy and left alone.
+ * A failed open must be inspected before recovery. `LockHeld` plus a failed
+ * create says nothing about the store's integrity: create refuses to replace
+ * any existing path. Only a structural open failure can justify quarantine.
  */
 /** The pid recorded in `<rvfPath>.lock`, or null if there is no readable lock. */
 export declare function readLockOwnerPid(rvfPath: string): number | null;
@@ -35,15 +35,20 @@ export declare function readLockOwnerPid(rvfPath: string): number | null;
  * "alive", which fails safe — we leave the store alone.
  */
 export declare function isLockHeldByLiveProcess(rvfPath: string): boolean;
+/** The native binding's exclusive-lock failure (never evidence of corruption). */
+export declare function isRvfLockHeldError(err: unknown): boolean;
+/** Only known structural open errors permit replacing a derived cache. */
+export declare function isRvfStructuralError(err: unknown): boolean;
+/** Reclaim a lock only when its record names a process known to have exited. */
+export declare function removeStaleRvfLock(rvfPath: string): boolean;
 /**
  * Move an unusable store and its sidecars aside so the next create succeeds.
  * Returns the quarantine base path, or null if nothing was quarantined.
  *
- * Only call this once open *and* create have both failed — that is the proof
- * the file is unusable. The store is a derived cache, rebuilt from the unified
- * DB, so quarantining is recoverable; we move rather than delete because the
- * bytes may hold writes that never reached SQLite, and they are the only
- * evidence if this recurs.
+ * Call only after a structural open failure and failed create/re-open. The
+ * store is a derived cache, rebuilt from the unified DB; we move rather than
+ * delete because the bytes may hold writes that never reached SQLite and are
+ * the only evidence if this recurs.
  */
-export declare function quarantineUnusableStore(rvfPath: string, reason: string): string | null;
+export declare function quarantineUnusableStore(rvfPath: string, reason: string, openError: unknown): string | null;
 //# sourceMappingURL=rvf-store-integrity.d.ts.map

package/dist/integrations/ruvector/rvf-store-integrity.js

@@ -20,9 +20,9 @@
  *     the store magic is `SFVR`; a 104-byte `FLVR` lock is just a live-or-stale
  *     lock record.
  *
- * So the only sound trigger is "open failed *and* create failed": at that point
- * the file is provably unusable. The lock's pid is used as a *guard* — if it is
- * held by a live process, the store is presumed healthy and left alone.
+ * A failed open must be inspected before recovery. `LockHeld` plus a failed
+ * create says nothing about the store's integrity: create refuses to replace
+ * any existing path. Only a structural open failure can justify quarantine.
  */
 import { existsSync, openSync, readSync, closeSync, renameSync, unlinkSync } from 'fs';
 /** Magic of a lock record (the store's own magic is `SFVR`). */
@@ -90,19 +90,49 @@ export function isLockHeldByLiveProcess(rvfPath) {
     // process still has open. Treat every live owner conservatively.
     return isPidAlive(pid);
 }
+/** The native binding's exclusive-lock failure (never evidence of corruption). */
+export function isRvfLockHeldError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.includes('LockHeld') || message.includes('0x0300');
+}
+/** Only known structural open errors permit replacing a derived cache. */
+export function isRvfStructuralError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return /ManifestNotFound|InvalidMagic|ChecksumMismatch|CorruptStore/i.test(message);
+}
+/** Reclaim a lock only when its record names a process known to have exited. */
+export function removeStaleRvfLock(rvfPath) {
+    const pid = readLockOwnerPid(rvfPath);
+    if (pid === null || isPidAlive(pid))
+        return false;
+    try {
+        // A concurrent owner could have replaced the record since the first read.
+        if (readLockOwnerPid(rvfPath) !== pid)
+            return false;
+        unlinkSync(`${rvfPath}.lock`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Move an unusable store and its sidecars aside so the next create succeeds.
  * Returns the quarantine base path, or null if nothing was quarantined.
  *
- * Only call this once open *and* create have both failed — that is the proof
- * the file is unusable. The store is a derived cache, rebuilt from the unified
- * DB, so quarantining is recoverable; we move rather than delete because the
- * bytes may hold writes that never reached SQLite, and they are the only
- * evidence if this recurs.
+ * Call only after a structural open failure and failed create/re-open. The
+ * store is a derived cache, rebuilt from the unified DB; we move rather than
+ * delete because the bytes may hold writes that never reached SQLite and are
+ * the only evidence if this recurs.
  */
-export function quarantineUnusableStore(rvfPath, reason) {
+export function quarantineUnusableStore(rvfPath, reason, openError) {
     if (!existsSync(rvfPath))
         return null;
+    // Native create reports FsyncFailed for *every* existing path, including a
+    // healthy one. A last observed LockHeld, permission, or I/O error must never
+    // trigger quarantine even when the owner exits before this check.
+    if (!isRvfStructuralError(openError))
+        return null;
     // Never pull a store out from under a live peer.
     if (isLockHeldByLiveProcess(rvfPath)) {
         console.warn(`[RVF] ${rvfPath} is unusable but its lock is held by a live process — ` +

package/dist/integrations/ruvector/shared-rvf-adapter.js

@@ -15,7 +15,7 @@
 import { findProjectRoot } from '../../kernel/project-root.js';
 // Issue #563: static import — this module is fs-only, and a require() here
 // would not resolve under the test runner.
-import { quarantineUnusableStore, isLockHeldByLiveProcess, readLockOwnerPid, } from './rvf-store-integrity.js';
+import { quarantineUnusableStore, isLockHeldByLiveProcess, isRvfLockHeldError, removeStaleRvfLock, readLockOwnerPid, } from './rvf-store-integrity.js';
 let sharedAdapter = null;
 let initAttempted = false;
 // ---------------------------------------------------------------------------
@@ -122,10 +122,6 @@ function openOrCreateRvf(openFn, createFn, rvfPath, dimensions) {
             return { adapter: null, err };
         }
     };
-    const isLockHeld = (err) => {
-        const m = err instanceof Error ? err.message : String(err);
-        return m.includes('LockHeld') || m.includes('0x0300');
-    };
     // Pass 1: try to open whatever's there.
     let { adapter: opened, err: openErr } = tryOpen();
     // Pass 1.5: stale-lock recovery. The native binding writes a `<rvfPath>.lock`
@@ -141,7 +137,7 @@ function openOrCreateRvf(openFn, createFn, rvfPath, dimensions) {
     // assumption. This includes a lock owned by the current PID: another
     // in-process adapter may still hold the store, so PID equality is not proof
     // that the lock can be removed safely.
-    if (!opened && isLockHeld(openErr)) {
+    if (!opened && isRvfLockHeldError(openErr)) {
         try {
             // eslint-disable-next-line @typescript-eslint/no-require-imports
             const fs = require('fs');
@@ -150,8 +146,7 @@ function openOrCreateRvf(openFn, createFn, rvfPath, dimensions) {
                 console.warn(`[RVF] ${rvfPath} is locked by a live process (pid ${readLockOwnerPid(rvfPath)}) — ` +
                     'not breaking the lock; degrading to SQLite for this run.');
             }
-            else if (fs.existsSync(lockPath)) {
-                fs.unlinkSync(lockPath);
+            else if (removeStaleRvfLock(rvfPath)) {
                 console.warn(`[RVF] Removed stale lock file at ${lockPath} (prior process exited without closing). ` +
                     'Retrying open. If you see this repeatedly under live concurrency, file an issue.');
                 ({ adapter: opened, err: openErr } = tryOpen());
@@ -185,29 +180,31 @@ function openOrCreateRvf(openFn, createFn, rvfPath, dimensions) {
     catch (createErr) {
         // Pass 3: create failed (likely FsyncFailed because a peer process won
         // the race). Try open one more time.
+        let reopened;
         try {
-            const reopened = openFn(rvfPath);
-            if (reopened.dimension() !== dimensions) {
-                try {
-                    reopened.close();
-                }
-                catch { /* best-effort */ }
-                throw new Error(`RVF dimension mismatch after race (file=${reopened.dimension()}, requested=${dimensions})`);
-            }
-            return reopened;
+            reopened = openFn(rvfPath);
         }
-        catch {
-            // Pass 4 (#563): open failed, create failed, re-open failed. The file is
-            // provably unusable — the signature of an export killed mid-write, which
-            // used to disable the RVF backend permanently. Quarantine it (unless a
-            // live process holds its lock) and rebuild the derived cache.
-            const quarantined = quarantineUnusableStore(rvfPath, createErr instanceof Error ? createErr.message : String(createErr));
+        catch (reopenErr) {
+            // A failed create only proves that a path exists. The final open error
+            // must be structural before we move any store aside.
+            if (isRvfLockHeldError(reopenErr))
+                throw reopenErr;
+            const quarantined = quarantineUnusableStore(rvfPath, createErr instanceof Error ? createErr.message : String(createErr), reopenErr);
             if (quarantined) {
                 return createFn(rvfPath, dimensions);
             }
             // Fall through with the more informative original error.
             throw createErr instanceof Error ? createErr : new Error(String(createErr));
         }
+        const actualDim = reopened.dimension();
+        if (actualDim !== dimensions) {
+            try {
+                reopened.close();
+            }
+            catch { /* best-effort */ }
+            throw new Error(`RVF dimension mismatch after race (file=${actualDim}, requested=${dimensions})`);
+        }
+        return reopened;
     }
 }
 /**

package/dist/kernel/hybrid-backend.d.ts

@@ -175,5 +175,11 @@ export declare class HybridMemoryBackend implements MemoryBackend {
     private ensureInitialized;
     private cleanup;
 }
+/**
+ * Create the project memory backend exactly as the QE kernel does
+ * (<dataDir>/memory.db, WAL, 'qe-kernel' default namespace). Shared with the
+ * CLI's lightweight memory path so both always open the same store.
+ */
+export declare function createKernelMemoryBackend(dataDir: string): HybridMemoryBackend;
 export {};
 //# sourceMappingURL=hybrid-backend.d.ts.map

package/dist/kernel/hybrid-backend.js

@@ -10,6 +10,7 @@
  * backward compatibility with existing MemoryBackend interface.
  */
 import { getUnifiedMemory, DEFAULT_UNIFIED_MEMORY_CONFIG } from './unified-memory.js';
+import * as path from 'path';
 import { MEMORY_CONSTANTS } from './constants.js';
 import { LoggerFactory } from '../logging/index.js';
 const logger = LoggerFactory.create('hybrid-backend');
@@ -329,4 +330,21 @@ export class HybridMemoryBackend {
         }
     }
 }
+/**
+ * Create the project memory backend exactly as the QE kernel does
+ * (<dataDir>/memory.db, WAL, 'qe-kernel' default namespace). Shared with the
+ * CLI's lightweight memory path so both always open the same store.
+ */
+export function createKernelMemoryBackend(dataDir) {
+    return new HybridMemoryBackend({
+        sqlite: {
+            path: path.join(dataDir, 'memory.db'),
+            walMode: true,
+            poolSize: 3,
+            busyTimeout: MEMORY_CONSTANTS.BUSY_TIMEOUT_MS,
+        },
+        enableFallback: true,
+        defaultNamespace: 'qe-kernel',
+    });
+}
 //# sourceMappingURL=hybrid-backend.js.map

package/dist/kernel/kernel.js

@@ -8,10 +8,10 @@ import { InMemoryEventBus } from './event-bus.js';
 import { DefaultAgentCoordinator } from './agent-coordinator.js';
 import { DefaultPluginLoader } from './plugin-loader.js';
 import { InMemoryBackend } from './memory-backend.js';
-import { HybridMemoryBackend } from './hybrid-backend.js';
+import { createKernelMemoryBackend } from './hybrid-backend.js';
 import { SemanticAntiDriftMiddleware, ToolCallSignatureTracker } from './anti-drift-middleware.js';
 import { LOOP_EVENT_TYPES } from './event-bus.js';
-import { AGENT_CONSTANTS, MEMORY_CONSTANTS } from './constants.js';
+import { AGENT_CONSTANTS } from './constants.js';
 import { findProjectRoot } from './unified-memory.js';
 import { initializeUnifiedPersistence } from './unified-persistence.js';
 import * as path from 'path';
@@ -163,16 +163,7 @@ export class QEKernelImpl {
         else {
             // Use hybrid backend for persistent storage (default)
             // All data goes to unified memory.db via UnifiedMemoryManager
-            this._memory = new HybridMemoryBackend({
-                sqlite: {
-                    path: path.join(dataDir, 'memory.db'),
-                    walMode: true,
-                    poolSize: 3,
-                    busyTimeout: MEMORY_CONSTANTS.BUSY_TIMEOUT_MS,
-                },
-                enableFallback: true,
-                defaultNamespace: 'qe-kernel',
-            });
+            this._memory = createKernelMemoryBackend(dataDir);
             // Re-create plugins with the real memory backend
             this._plugins = new DefaultPluginLoader(this._eventBus, this._memory, this._config.lazyLoading);
         }
@@ -206,6 +197,9 @@ export class QEKernelImpl {
             const pluginCache = new PluginCache({ cacheDir: pluginCacheDir });
             const pluginLifecycle = new PluginLifecycleManager({ cache: pluginCache });
             const resolution = pluginLifecycle.resolveLoadOrder();
+            for (const error of resolution.errors) {
+                console.warn(`[QEKernel] External plugin ${error.plugin}: ${error.code}: ${error.message}`);
+            }
             for (const resolved of resolution.ordered) {
                 const manifest = resolved.manifest;
                 const cachedPlugin = pluginCache.get(manifest.name, manifest.version);
@@ -232,8 +226,9 @@ export class QEKernelImpl {
                 }
             }
         }
-        catch {
-            // External plugin loading is best-effort — don't block kernel startup
+        catch (error) {
+            // External plugin loading is best-effort, but failures must be visible.
+            console.warn('[QEKernel] External plugin discovery failed:', error);
         }
         // Load plugins based on configuration
         if (!this._config.lazyLoading) {