agentic-qe 3.14.4 → 3.14.5

package/dist/init/token-bootstrap.js

@@ -12,10 +12,11 @@ import * as fs from 'fs';
 import { initializeTokenOptimizer, TokenOptimizerService } from '../optimization/token-optimizer-service.js';
 import { TokenMetricsCollector } from '../learning/token-tracker.js';
 import { createDefaultMemoryBackend } from '../kernel/memory-factory.js';
+import { findProjectRoot } from '../kernel/project-root.js';
 const DEFAULT_CONFIG = {
     enableOptimization: true,
     enablePersistence: true,
-    storagePath: process.env.AQE_STORAGE_PATH ?? '.agentic-qe',
+    storagePath: '.agentic-qe',
     autoSaveIntervalMs: 60000,
     verbose: process.env.AQE_VERBOSE === 'true',
 };
@@ -36,7 +37,16 @@ export async function bootstrapTokenTracking(config) {
     if (initialized) {
         return;
     }
-    const cfg = { ...DEFAULT_CONFIG, ...config };
+    // Resolve the project before creating any directory: a new cwd-local store
+    // would otherwise become the nearest AQE root and split project memory.
+    // A relative AQE_STORAGE_PATH is anchored at the project root too, so it
+    // cannot recreate a cwd-local store from a subdirectory.
+    const envStorage = process.env.AQE_STORAGE_PATH;
+    const cfg = {
+        ...DEFAULT_CONFIG, ...config,
+        storagePath: config?.storagePath
+            ?? (envStorage ? path.resolve(findProjectRoot(), envStorage) : path.join(findProjectRoot(), '.agentic-qe')),
+    };
     if (cfg.verbose) {
         console.log('[TokenBootstrap] Initializing token tracking...');
     }

package/dist/init/types.d.ts

@@ -227,6 +227,16 @@ export interface InitResult {
             policy: 'full' | 'compact' | 'none';
             ownedBytes: number;
         };
+        codexComponents?: {
+            hooks: {
+                status: string;
+                error?: string;
+            };
+            skills: {
+                status: string;
+                error?: string;
+            };
+        };
     };
     totalDurationMs: number;
     timestamp: Date;

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

@@ -21,6 +21,7 @@ import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { safeJsonParse } from '../../shared/safe-json.js';
 import { sha256, queryAll, queryIterator, countRows, domainFilterForColumn, writeJsonl, writeJsonlStreaming, readJsonl, runImportTransaction, serializeRowBlobs, deserializeRowBlobs, mergeGenericRow, remapPatternReferences, mergeAppendOnlyRow, TABLE_CONFIGS, PK_COLUMNS, CONFIDENCE_COLUMNS, TIMESTAMP_COLUMNS, } from './brain-shared.js';
+import { appendBrainImportWitness } from './brain-import-audit.js';
 // ============================================================================
 // Internal helpers
 // ============================================================================
@@ -226,9 +227,17 @@ export function importBrain(db, containerPath, options) {
     const importAll = () => {
         const patternIds = new Map();
         const patternWinners = new Map();
+        let sourceWitnessRows = 0;
         for (const config of configs) {
             const filePath = join(dir, config.fileName);
             let rows = readJsonl(filePath, safeJsonParse);
+            if (config.tableName === 'witness_chain') {
+                // Source rows are signed/linked to a different store. Copying them into
+                // this live chain would make the first imported predecessor invalid.
+                sourceWitnessRows += rows.length;
+                skipped += rows.length;
+                continue;
+            }
             // Deserialize BLOBs from Base64
             if (config.blobColumns && config.blobColumns.length > 0) {
                 rows = rows.map(r => deserializeRowBlobs(r, config.blobColumns));
@@ -252,6 +261,14 @@ export function importBrain(db, containerPath, options) {
                 conflicts += result.conflicts;
             }
         }
+        appendBrainImportWitness(db, {
+            sourceChecksum: manifest.checksum,
+            sourceWitnessRows,
+            importedRecords: imported,
+            skippedRecords: skipped,
+            conflicts,
+        });
+        imported += 1;
     };
     runImportTransaction(db, options.dryRun ?? false, importAll);
     return { imported, skipped, conflicts };

package/dist/integrations/ruvector/brain-import-audit.d.ts

@@ -0,0 +1,20 @@
+/** Record a brain import without grafting another store's witness history. */
+import type Database from 'better-sqlite3';
+interface BrainImportAuditDetails {
+    sourceChecksum: string;
+    sourceWitnessRows: number;
+    importedRecords: number;
+    skippedRecords: number;
+    conflicts: number;
+}
+/**
+ * Call inside the import transaction, after merging all non-witness tables.
+ *
+ * Reuses WitnessChain's own hashing/serialization so the link format cannot
+ * drift from what WitnessChain.verify() checks. The row is intentionally left
+ * unsigned: the target DB may belong to a different project than the CWD, so
+ * the process-default signing key is not necessarily the target's key.
+ */
+export declare function appendBrainImportWitness(db: Database.Database, details: BrainImportAuditDetails): void;
+export {};
+//# sourceMappingURL=brain-import-audit.d.ts.map

package/dist/integrations/ruvector/brain-import-audit.js

@@ -0,0 +1,22 @@
+import { GENESIS_PREV_HASH, hashWith, serializeEntry, } from '../../audit/witness-chain.js';
+/**
+ * Call inside the import transaction, after merging all non-witness tables.
+ *
+ * Reuses WitnessChain's own hashing/serialization so the link format cannot
+ * drift from what WitnessChain.verify() checks. The row is intentionally left
+ * unsigned: the target DB may belong to a different project than the CWD, so
+ * the process-default signing key is not necessarily the target's key.
+ */
+export function appendBrainImportWitness(db, details) {
+    const algo = 'shake256';
+    const actionData = JSON.stringify(details);
+    const last = db.prepare('SELECT * FROM witness_chain ORDER BY id DESC LIMIT 1')
+        .get();
+    const previousHash = last ? hashWith(algo, serializeEntry(last)) : GENESIS_PREV_HASH;
+    db.prepare(`
+    INSERT INTO witness_chain
+      (prev_hash, action_hash, action_type, action_data, timestamp, actor, hash_algo)
+    VALUES (?, ?, 'BRAIN_IMPORT', ?, ?, 'brain-import', ?)
+  `).run(previousHash, hashWith(algo, actionData), actionData, new Date().toISOString(), algo);
+}
+//# sourceMappingURL=brain-import-audit.js.map

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

@@ -7,6 +7,7 @@ import { existsSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSyn
 import { basename, dirname, join, resolve } from 'path';
 import { createRvfStore, openRvfStore, openRvfStoreReadonly, isRvfNativeAvailable, } from './rvf-native-adapter.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
@@ -401,11 +402,18 @@ export function importBrainFromRvf(db, rvfPath, options) {
         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) {
@@ -434,6 +442,14 @@ export function importBrainFromRvf(db, rvfPath, options) {
                     conflicts += result.conflicts;
                 }
             }
+            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)

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

@@ -408,7 +408,7 @@ export function runImportTransaction(db, dryRun, importer) {
             throw rollback;
     });
     try {
-        transaction();
+        transaction.immediate();
     }
     catch (error) {
         if (error !== rollback)

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,6 +97,11 @@ export class RvfDualWriter {
                 this.rvfAvailable = false;
                 return;
             }
+            // #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();
+            }
             const { isRvfLockHeldError, removeStaleRvfLock, quarantineUnusableStore } = await import('./rvf-store-integrity.js');
             const tryOpen = () => {
                 try {

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) {

package/dist/kernel/project-root.d.ts

@@ -21,7 +21,7 @@ export declare function clearProjectRootCache(): void;
  *
  * Priority order:
  * 1. AQE_PROJECT_ROOT environment variable (set by MCP config or init)
- * 2. Walk up looking for the NEAREST .agentic-qe directory (existing AQE project)
+ * 2. Nearest .agentic-qe at or below the nearest .git boundary
  * 3. Walk up looking for .git directory (git repo root)
  * 4. Walk up looking for package.json WITHOUT node_modules sibling (monorepo root)
  * 5. Fallback to current working directory

package/dist/kernel/project-root.js

@@ -12,6 +12,7 @@
  * @module kernel/project-root
  */
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 /** Module-level cache for findProjectRoot result. */
 let _cachedProjectRoot = null;
@@ -24,12 +25,17 @@ export function clearProjectRootCache() {
     _cachedProjectRoot = null;
     _cachedStartDir = null;
 }
+/** True when `dir` is `parent` or inside it. */
+function isWithin(dir, parent) {
+    const rel = path.relative(parent, dir);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
 /**
  * Find the project root by walking up the directory tree.
  *
  * Priority order:
  * 1. AQE_PROJECT_ROOT environment variable (set by MCP config or init)
- * 2. Walk up looking for the NEAREST .agentic-qe directory (existing AQE project)
+ * 2. Nearest .agentic-qe at or below the nearest .git boundary
  * 3. Walk up looking for .git directory (git repo root)
  * 4. Walk up looking for package.json WITHOUT node_modules sibling (monorepo root)
  * 5. Fallback to current working directory
@@ -47,6 +53,17 @@ export function findProjectRoot(startDir = process.cwd()) {
         return _cachedProjectRoot;
     _cachedStartDir = dir;
     const root = path.parse(dir).root;
+    // A store directly in $HOME is almost always a stray from an `aqe` run in
+    // the home directory. Outside any git repository there is no boundary to
+    // stop at, so never let it claim a descendant directory (#735/#516); an
+    // `aqe` run from $HOME itself still uses it, and AQE_PROJECT_ROOT overrides.
+    let home = null;
+    try {
+        home = path.resolve(os.homedir());
+    }
+    catch {
+        home = null;
+    }
     let checkDir = dir;
     let nearestAqeDir = null;
     let lowestGitDir = null;
@@ -55,8 +72,12 @@ export function findProjectRoot(startDir = process.cwd()) {
         // Issue #516: prefer the NEAREST (lowest) .agentic-qe, mirroring the
         // .git logic below. Keeping the topmost match let an ancestor store
         // (e.g. ~/.agentic-qe, created by any `aqe` run from $HOME) hijack
-        // every descendant project and fragment its learning into $HOME.
-        if (fs.existsSync(path.join(checkDir, '.agentic-qe'))) {
+        // every descendant project and fragment its learning into $HOME. Stop
+        // considering stores above the nearest git boundary, even when the repo
+        // has not been initialized with AQE yet.
+        const isHomeStoreAboveStart = checkDir === home && checkDir !== dir
+            && !isWithin(dir, path.join(checkDir, '.agentic-qe'));
+        if (lowestGitDir === null && !isHomeStoreAboveStart && fs.existsSync(path.join(checkDir, '.agentic-qe'))) {
             if (nearestAqeDir === null) {
                 nearestAqeDir = checkDir;
             }

package/dist/learning/embedder-identity-store.js

@@ -13,9 +13,10 @@
  * We never throw out of these helpers under expected conditions; failure
  * reasons are surfaced as thrown errors only for genuine I/O problems.
  */
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { existsSync, mkdirSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import { findProjectRoot } from '../kernel/project-root.js';
 // `require` is unavailable in pure ESM; createRequire gives us synchronous
 // access to CommonJS modules like better-sqlite3 from the ESM build output.
 const nodeRequire = createRequire(import.meta.url);
@@ -26,8 +27,8 @@ const nodeRequire = createRequire(import.meta.url);
 function getMemoryDbPath() {
     const env = process.env.AQE_MEMORY_PATH;
     if (env && env.length > 0)
-        return env;
-    return join(process.cwd(), '.agentic-qe', 'memory.db');
+        return env === ':memory:' ? env : resolve(findProjectRoot(), env);
+    return join(findProjectRoot(), '.agentic-qe', 'memory.db');
 }
 const NAMESPACE = '_system';
 const KEY_PREFIX = 'embedder_identity:';

package/dist/learning/pattern-store.js

@@ -30,7 +30,7 @@ import { createVectorDeltaTracker, } from '../integrations/ruvector/vector-delta
 import { createHopfieldMemory } from '../integrations/ruvector/hopfield-memory.js';
 import { createHyperbolicPatternIndex, } from './hyperbolic-pattern-index.js';
 import { PatternNullStore } from './pattern-null-store.js';
-import { getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
+import { ensureEndpointEmbeddingSpaceIdentity, getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 import { PatternMutationError } from './pattern-mutation-error.js';
 // ============================================================================
 // R1: HDC Fingerprint Singleton (lazy-initialized)
@@ -244,6 +244,10 @@ export class PatternStore {
      */
     async initializeHNSWInternal() {
         try {
+            // #754: resolve a configured endpoint's identity before binding HNSW.
+            if (!getActiveEmbeddingSpaceIdentity() && !this.config.embeddingSpaceId) {
+                await ensureEndpointEmbeddingSpaceIdentity();
+            }
             this.hnswSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId ?? null;
             if (!this.hnswSpaceId) {
                 throw new Error('VECTOR_SPACE_UNVERIFIED: cannot initialize HNSW without runtime provenance');

package/dist/learning/real-embeddings.d.ts

@@ -86,4 +86,12 @@ export declare function isUsingEndpoint(): boolean;
 export declare function getEndpointIdentity(): EndpointIdentity | null;
 /** Runtime-backed identity of the initialized embedding space. */
 export declare function getActiveEmbeddingSpaceIdentity(): EmbeddingSpaceIdentity | null;
+/**
+ * #754: resolve the configured endpoint's embedding-space identity before an
+ * index binder (RVF pattern store, brain.rvf dual writer, SQLite HNSW) checks
+ * its space manifest. The endpoint runtime otherwise initializes lazily on the
+ * first embed call — after the binder has already refused for the process.
+ * Returns null when no endpoint is configured, so binders stay fail-closed.
+ */
+export declare function ensureEndpointEmbeddingSpaceIdentity(): Promise<EmbeddingSpaceIdentity | null>;
 //# sourceMappingURL=real-embeddings.d.ts.map

package/dist/learning/real-embeddings.js

@@ -410,4 +410,20 @@ export function getEndpointIdentity() {
 export function getActiveEmbeddingSpaceIdentity() {
     return activeEmbeddingSpaceIdentity;
 }
+/**
+ * #754: resolve the configured endpoint's embedding-space identity before an
+ * index binder (RVF pattern store, brain.rvf dual writer, SQLite HNSW) checks
+ * its space manifest. The endpoint runtime otherwise initializes lazily on the
+ * first embed call — after the binder has already refused for the process.
+ * Returns null when no endpoint is configured, so binders stay fail-closed.
+ */
+export async function ensureEndpointEmbeddingSpaceIdentity() {
+    if (activeEmbeddingSpaceIdentity)
+        return activeEmbeddingSpaceIdentity;
+    const endpoint = process.env.AQE_EMBEDDER_ENDPOINT;
+    if (!endpoint)
+        return null;
+    await initializeModel({ endpoint, endpointToken: process.env.AQE_EMBEDDER_TOKEN });
+    return activeEmbeddingSpaceIdentity;
+}
 //# sourceMappingURL=real-embeddings.js.map

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

@@ -16,7 +16,7 @@ import { ok, err } from '../shared/types/index.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { calculateQualityScore, validateQEPattern, mapQEDomainToAQE, PROMOTION_THRESHOLD, } from './qe-patterns.js';
 import { DEFAULT_PATTERN_STORE_CONFIG } from './pattern-store.js';
-import { getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
+import { ensureEndpointEmbeddingSpaceIdentity, getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 import { verifyOrCreateEmbeddingSpaceManifest } from './embedding-space.js';
 import { PatternMutationError } from './pattern-mutation-error.js';
 // ============================================================================
@@ -75,6 +75,12 @@ export class RvfPatternStore {
             return;
         }
         try {
+            // The endpoint runtime is lazy. Resolve its executable identity before
+            // binding a new RVF index; otherwise every fresh process sees null here
+            // and permanently disables RVF even though the endpoint is configured.
+            if (!this.embeddingSpaceId && !getActiveEmbeddingSpaceIdentity()) {
+                await ensureEndpointEmbeddingSpaceIdentity();
+            }
             this.adapter = this.createAdapter(this.rvfPath, this.config.embeddingDimension);
             const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.embeddingSpaceId ?? null;
             verifyOrCreateEmbeddingSpaceManifest(this.rvfPath, activeSpaceId, this.adapter.status()?.totalVectors ?? 0);
@@ -90,9 +96,10 @@ export class RvfPatternStore {
                 this.adapter?.close();
             }
             catch { /* best effort */ }
-            console.error(`[RvfPatternStore] ERROR: RVF native init failed — vector search is DISABLED. ` +
+            console.error(`[RvfPatternStore] ERROR: RVF initialization failed — vector search is DISABLED. ` +
                 `Cause: ${this.rvfInitError}. ` +
-                `Fix: install @ruvector/rvf-node native bindings, or set useRVFPatternStore=false to use SQLite HNSW.`);
+                `Fix: check the embedder endpoint and @ruvector/rvf-node binding, ` +
+                `or set RUVECTOR_USE_RVF_PATTERN_STORE=false to use SQLite HNSW.`);
             this.adapter = null;
             this.initialized = true; // mark initialized to prevent retry loops
         }