agentic-qe 3.10.6 → 3.10.8

package/dist/kernel/kernel.js

@@ -144,8 +144,10 @@ export class QEKernelImpl {
         // and memory backend setup now happen in async initialize().
         const projectRoot = findProjectRoot();
         const dataDir = this._config.dataDir || path.join(projectRoot, '.agentic-qe');
-        // Ensure data directory exists
-        if (!fs.existsSync(dataDir)) {
+        // Ensure data directory exists. Skipped in database-free mode so the
+        // project's .agentic-qe/ is never created (the memory branch below uses a
+        // throwaway temp DB outside the project).
+        if (this._config.memoryBackend !== 'memory' && !fs.existsSync(dataDir)) {
             fs.mkdirSync(dataDir, { recursive: true });
         }
         // Initialize memory backend based on config

package/dist/kernel/unified-memory.js

@@ -125,6 +125,14 @@ export class UnifiedMemoryManager {
     constructor(config) {
         const resolvedDefaults = getResolvedDefaultConfig();
         this.config = { ...resolvedDefaults, ...config };
+        // Database-free mode (#534): keep ALL unified persistence in an ephemeral
+        // in-memory SQLite DB. Handlers/domains that reach for UnifiedMemoryManager
+        // (core-handlers, trajectory-judge, test-generator, experience-capture, …)
+        // keep working, but nothing is ever written under .agentic-qe/.
+        if (process.env.AQE_MEMORY_BACKEND === 'memory') {
+            this.config.dbPath = ':memory:';
+            return;
+        }
         if (!path.isAbsolute(this.config.dbPath)) {
             const projectRoot = findProjectRoot();
             this.config.dbPath = path.join(projectRoot, this.config.dbPath);
@@ -175,56 +183,63 @@ export class UnifiedMemoryManager {
             return;
         signal?.throwIfAborted();
         try {
-            // SAFETY: Detect test processes trying to open the production DB.
-            // If AQE_PROJECT_ROOT is set to a temp dir (vitest isolation) but the
-            // dbPath resolves to the REAL project's .agentic-qe/memory.db, redirect.
-            // Only redirect production paths — leave explicitly-set temp paths alone.
-            const envRoot = process.env.AQE_PROJECT_ROOT;
-            if (envRoot) {
-                const resolvedPath = path.resolve(this.config.dbPath);
-                const resolvedRoot = path.resolve(envRoot);
-                // Only redirect if path points OUTSIDE the env root AND into a real
-                // .agentic-qe directory (not another temp test dir)
-                if (!resolvedPath.startsWith(resolvedRoot) &&
-                    !resolvedPath.startsWith(os.tmpdir()) &&
-                    resolvedPath.includes('.agentic-qe')) {
-                    console.error(`[UnifiedMemory] WARNING: DB path "${this.config.dbPath}" points to a ` +
-                        `production .agentic-qe/ while AQE_PROJECT_ROOT="${envRoot}". ` +
-                        `Redirecting to test-safe path.`);
-                    this.config.dbPath = path.join(envRoot, '.agentic-qe', 'memory.db');
-                }
-            }
-            const dir = path.dirname(this.config.dbPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            // DATA LOSS PREVENTION: If the DB file already exists, record its size
-            // before opening. better-sqlite3's `new Database(path)` creates a fresh
-            // empty file when the path doesn't exist. If we expected an existing DB
-            // (dir exists, .agentic-qe present) but the file is missing, something
-            // deleted it — warn loudly and look for the most recent backup.
-            const dbExistedBefore = fs.existsSync(this.config.dbPath);
+            // Database-free mode (#534): ':memory:' is ephemeral — skip ALL filesystem
+            // work (dir creation, path redirect, backup recovery, size accounting).
+            const inMemory = this.config.dbPath === ':memory:';
+            let dir = '';
+            let dbExistedBefore = false;
             let dbSizeBefore = 0;
-            if (dbExistedBefore) {
-                dbSizeBefore = fs.statSync(this.config.dbPath).size;
-            }
-            else if (fs.existsSync(dir)) {
-                // The .agentic-qe directory exists but memory.db is missing — suspect data loss
-                const backups = this.findRecentBackups(dir);
-                if (backups.length > 0) {
-                    const newest = backups[0];
-                    console.error(`[UnifiedMemory] CRITICAL: Database file missing but directory exists!\n` +
-                        `  Expected: ${this.config.dbPath}\n` +
-                        `  Found ${backups.length} backup(s), newest: ${newest.path} (${(newest.size / 1024 / 1024).toFixed(1)}MB)\n` +
-                        `  Restoring from backup to prevent data loss...`);
-                    fs.copyFileSync(newest.path, this.config.dbPath);
-                    // Remove stale WAL/SHM that may belong to the old file
-                    for (const suffix of ['-wal', '-shm']) {
-                        const walPath = this.config.dbPath + suffix;
-                        if (fs.existsSync(walPath))
-                            fs.unlinkSync(walPath);
+            if (!inMemory) {
+                // SAFETY: Detect test processes trying to open the production DB.
+                // If AQE_PROJECT_ROOT is set to a temp dir (vitest isolation) but the
+                // dbPath resolves to the REAL project's .agentic-qe/memory.db, redirect.
+                // Only redirect production paths — leave explicitly-set temp paths alone.
+                const envRoot = process.env.AQE_PROJECT_ROOT;
+                if (envRoot) {
+                    const resolvedPath = path.resolve(this.config.dbPath);
+                    const resolvedRoot = path.resolve(envRoot);
+                    // Only redirect if path points OUTSIDE the env root AND into a real
+                    // .agentic-qe directory (not another temp test dir)
+                    if (!resolvedPath.startsWith(resolvedRoot) &&
+                        !resolvedPath.startsWith(os.tmpdir()) &&
+                        resolvedPath.includes('.agentic-qe')) {
+                        console.error(`[UnifiedMemory] WARNING: DB path "${this.config.dbPath}" points to a ` +
+                            `production .agentic-qe/ while AQE_PROJECT_ROOT="${envRoot}". ` +
+                            `Redirecting to test-safe path.`);
+                        this.config.dbPath = path.join(envRoot, '.agentic-qe', 'memory.db');
+                    }
+                }
+                dir = path.dirname(this.config.dbPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                // DATA LOSS PREVENTION: If the DB file already exists, record its size
+                // before opening. better-sqlite3's `new Database(path)` creates a fresh
+                // empty file when the path doesn't exist. If we expected an existing DB
+                // (dir exists, .agentic-qe present) but the file is missing, something
+                // deleted it — warn loudly and look for the most recent backup.
+                dbExistedBefore = fs.existsSync(this.config.dbPath);
+                if (dbExistedBefore) {
+                    dbSizeBefore = fs.statSync(this.config.dbPath).size;
+                }
+                else if (fs.existsSync(dir)) {
+                    // The .agentic-qe directory exists but memory.db is missing — suspect data loss
+                    const backups = this.findRecentBackups(dir);
+                    if (backups.length > 0) {
+                        const newest = backups[0];
+                        console.error(`[UnifiedMemory] CRITICAL: Database file missing but directory exists!\n` +
+                            `  Expected: ${this.config.dbPath}\n` +
+                            `  Found ${backups.length} backup(s), newest: ${newest.path} (${(newest.size / 1024 / 1024).toFixed(1)}MB)\n` +
+                            `  Restoring from backup to prevent data loss...`);
+                        fs.copyFileSync(newest.path, this.config.dbPath);
+                        // Remove stale WAL/SHM that may belong to the old file
+                        for (const suffix of ['-wal', '-shm']) {
+                            const walPath = this.config.dbPath + suffix;
+                            if (fs.existsSync(walPath))
+                                fs.unlinkSync(walPath);
+                        }
+                        dbSizeBefore = newest.size;
                     }
-                    dbSizeBefore = newest.size;
                 }
             }
             // Bail before opening the DB if the caller already gave up — saves a
@@ -327,6 +342,9 @@ export class UnifiedMemoryManager {
         }
     }
     warnIfDuplicateDatabases() {
+        // Database-free mode has no on-disk canonical DB to compare against.
+        if (this.config.dbPath === ':memory:')
+            return;
         try {
             const projectRoot = findProjectRoot();
             const canonicalDb = path.resolve(this.config.dbPath);

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

@@ -59,6 +59,14 @@ export class RvfPatternStore {
     async initialize() {
         if (this.initialized)
             return;
+        // Database-free mode (#534): never create an on-disk patterns.rvf (+ .idmap/.lock).
+        // Run adapter-less — the store degrades to metadata-only (the same graceful
+        // path used when the RVF native binding is unavailable), writing nothing.
+        if (process.env.AQE_MEMORY_BACKEND === 'memory') {
+            this.adapter = null;
+            this.initialized = true;
+            return;
+        }
         try {
             this.adapter = this.createAdapter(this.rvfPath, this.config.embeddingDimension);
             this.initialized = true;