agentic-qe 3.10.7 → 3.10.9

package/dist/init/phases/09-assets.js

@@ -42,8 +42,8 @@ export class AssetsPhase extends BasePhase {
         else if (options.autoMode && isVersionUpgrade) {
             context.services.log(`  Version upgrade detected: updating skills and agents`);
         }
-        // Install skills
-        if (config.skills.install) {
+        // Install skills (Claude Code surface — skipped with --no-claude, #532)
+        if (!options.noClaude && config.skills.install) {
             const skillsInstaller = createSkillsInstaller({
                 projectRoot,
                 installV2Skills: config.skills.installV2,
@@ -56,25 +56,27 @@ export class AssetsPhase extends BasePhase {
                 context.services.warn(`Skills warnings: ${skillsResult.errors.join(', ')}`);
             }
         }
-        // Install agents
-        try {
-            const agentsInstaller = createAgentsInstaller({
-                projectRoot,
-                installQEAgents: true,
-                installSubagents: true,
-                overwrite: shouldOverwrite,
-            });
-            const agentsResult = await agentsInstaller.install();
-            agentsInstalled = agentsResult.installed.length;
-            if (agentsResult.errors.length > 0) {
-                context.services.warn(`Agents warnings: ${agentsResult.errors.join(', ')}`);
+        // Install agents (Claude Code surface — skipped with --no-claude, #532)
+        if (!options.noClaude) {
+            try {
+                const agentsInstaller = createAgentsInstaller({
+                    projectRoot,
+                    installQEAgents: true,
+                    installSubagents: true,
+                    overwrite: shouldOverwrite,
+                });
+                const agentsResult = await agentsInstaller.install();
+                agentsInstalled = agentsResult.installed.length;
+                if (agentsResult.errors.length > 0) {
+                    context.services.warn(`Agents warnings: ${agentsResult.errors.join(', ')}`);
+                }
             }
+            catch (error) {
+                context.services.warn(`Agents install error: ${error instanceof Error ? error.message : error}`);
+            }
+            // Initialize overlay configs in agent registry for runtime use
+            initializeOverlays(projectRoot);
         }
-        catch (error) {
-            context.services.warn(`Agents install error: ${error instanceof Error ? error.message : error}`);
-        }
-        // Initialize overlay configs in agent registry for runtime use
-        initializeOverlays(projectRoot);
         // Install Vibium browser engine for the qe-browser fleet skill.
         // Graceful — never fails init if Vibium cannot be installed.
         // Skipped in --minimal mode per ADR-086 minimal-footprint guidance.
@@ -169,8 +171,12 @@ export class AssetsPhase extends BasePhase {
                 projectRoot,
                 installAgents: true,
                 installSkills: true,
-                installTools: true,
+                // AQE tool .ts files are not in OpenCode's tool() format and are
+                // redundant with the MCP server — never install them.
+                installTools: false,
                 overwrite: shouldOverwrite,
+                // Database-free install => MCP server configured to run in-memory.
+                memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined,
             });
             const ocResult = await openCodeInstaller.install();
             openCodeAgents = ocResult.agentsInstalled.length;
@@ -200,6 +206,7 @@ export class AssetsPhase extends BasePhase {
                 installHooks: true,
                 installSteering: true,
                 overwrite: shouldOverwrite,
+                memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined,
             });
             const kiroResult = await kiroInstaller.install();
             kiroAgents = kiroResult.agentsInstalled.length;
@@ -220,7 +227,7 @@ export class AssetsPhase extends BasePhase {
         const platformsConfigured = [];
         if (options.withCopilot || (options.autoMode && existsSync(join(projectRoot, '.vscode')))) {
             const { createCopilotInstaller } = await import('../copilot-installer.js');
-            const installer = createCopilotInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createCopilotInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('copilot');
@@ -233,7 +240,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withCursor || (options.autoMode && existsSync(join(projectRoot, '.cursor')))) {
             const { createCursorInstaller } = await import('../cursor-installer.js');
-            const installer = createCursorInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createCursorInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('cursor');
@@ -246,7 +253,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withCline) {
             const { createClineInstaller } = await import('../cline-installer.js');
-            const installer = createClineInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createClineInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('cline');
@@ -259,7 +266,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withKiloCode || (options.autoMode && existsSync(join(projectRoot, '.kilocode')))) {
             const { createKiloCodeInstaller } = await import('../kilocode-installer.js');
-            const installer = createKiloCodeInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createKiloCodeInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('kilocode');
@@ -272,7 +279,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withRooCode || (options.autoMode && existsSync(join(projectRoot, '.roo')))) {
             const { createRooCodeInstaller } = await import('../roocode-installer.js');
-            const installer = createRooCodeInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createRooCodeInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('roocode');
@@ -286,7 +293,7 @@ export class AssetsPhase extends BasePhase {
         // P2 platforms: Codex (TOML), Windsurf (JSON), Continue.dev (YAML)
         if (options.withCodex || (options.autoMode && existsSync(join(projectRoot, '.codex')))) {
             const { createCodexInstaller } = await import('../codex-installer.js');
-            const installer = createCodexInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createCodexInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('codex');
@@ -299,7 +306,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withWindsurf || (options.autoMode && existsSync(join(projectRoot, '.windsurf')))) {
             const { createWindsurfInstaller } = await import('../windsurf-installer.js');
-            const installer = createWindsurfInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createWindsurfInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('windsurf');
@@ -312,7 +319,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withContinueDev || (options.autoMode && existsSync(join(projectRoot, '.continue')))) {
             const { createContinueDevInstaller } = await import('../continuedev-installer.js');
-            const installer = createContinueDevInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createContinueDevInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('continuedev');

package/dist/init/phases/10-workers.js

@@ -18,6 +18,10 @@ export class WorkersPhase extends BasePhase {
     critical = false;
     requiresPhases = ['configuration'];
     async shouldRun(context) {
+        // Background workers persist to the SQLite DB, which is absent in
+        // database-free mode.
+        if (context.options.memoryBackend === 'memory')
+            return false;
         const config = context.config;
         return config?.workers?.daemonAutoStart && (config?.workers?.enabled?.length ?? 0) > 0;
     }

package/dist/init/phases/11-claude-md.d.ts

@@ -17,6 +17,7 @@ export declare class ClaudeMdPhase extends BasePhase<ClaudeMdResult> {
     readonly order = 110;
     readonly critical = false;
     readonly requiresPhases: readonly ["configuration"];
+    shouldRun(context: InitContext): Promise<boolean>;
     protected run(context: InitContext): Promise<ClaudeMdResult>;
     /**
      * Generate CLAUDE.md content

package/dist/init/phases/11-claude-md.js

@@ -14,6 +14,14 @@ export class ClaudeMdPhase extends BasePhase {
     order = 110;
     critical = false;
     requiresPhases = ['configuration'];
+    async shouldRun(context) {
+        // #532: --no-claude suppresses the Claude Code surface, including CLAUDE.md.
+        if (context.options.noClaude) {
+            context.services.log('  CLAUDE.md skipped (--no-claude)');
+            return false;
+        }
+        return true;
+    }
     async run(context) {
         const config = context.config;
         const { projectRoot } = context;

package/dist/init/phases/12-verification.js

@@ -23,11 +23,13 @@ export class VerificationPhase extends BasePhase {
         const config = context.config;
         const { projectRoot } = context;
         const checks = [];
-        // Check database exists
+        // Database-free mode: there is no SQLite database to verify or write to.
+        const memOnly = context.options.memoryBackend === 'memory';
+        // Check database exists (in-memory mode has none — treated as satisfied).
         const dbPath = join(projectRoot, '.agentic-qe', 'memory.db');
         checks.push({
-            name: 'Database exists',
-            passed: existsSync(dbPath),
+            name: memOnly ? 'Database (in-memory mode)' : 'Database exists',
+            passed: memOnly || existsSync(dbPath),
         });
         // Check .agentic-qe directory
         checks.push({
@@ -42,8 +44,11 @@ export class VerificationPhase extends BasePhase {
             name: 'Config saved',
             passed: existsSync(configPath),
         });
-        // Write version marker
-        const versionWritten = await this.writeVersionToDb(config.version, projectRoot);
+        // Write version marker. Skipped in database-free mode — there is no
+        // memory.db; the version is still recorded in config.yaml above.
+        const versionWritten = memOnly
+            ? true
+            : await this.writeVersionToDb(config.version, projectRoot);
         checks.push({
             name: 'Version marker',
             passed: versionWritten,

package/dist/init/phases/13-governance.js

@@ -33,6 +33,11 @@ export class GovernancePhase extends BasePhase {
      * Run unless --no-governance flag is set
      */
     async shouldRun(context) {
+        // #532: governance is part of the Claude Code surface — skip with --no-claude.
+        if (context.options.noClaude) {
+            context.services.log('  Governance skipped (--no-claude)');
+            return false;
+        }
         // Check for --no-governance flag (via noGovernance option)
         if (context.options.noGovernance) {
             context.services.log('  Governance skipped (--no-governance flag)');

package/dist/init/phases/phase-interface.d.ts

@@ -129,8 +129,22 @@ export interface InitOptions {
     withAllPlatforms?: boolean;
     /** Skip MCP server config (MCP is enabled by default) */
     noMcp?: boolean;
+    /**
+     * Suppress the default Claude Code surface (#532). When true, init does NOT
+     * write `.claude/` skills+agents, `.mcp.json`, `CLAUDE.md`, governance, or
+     * hooks — making `--with-<platform>` flags the only install targets (e.g. an
+     * OpenCode-only install). Opt-in via `--no-claude`; default install is
+     * unchanged. Pairs naturally with `--no-database`.
+     */
+    noClaude?: boolean;
     /** @deprecated Use default behavior instead — MCP is now enabled by default */
     withMcp?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the SQLite
+     * database phase is skipped and any MCP config is written to run in-memory.
+     * Undefined preserves the default persistent backend. Set via `--no-database`.
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 /**
  * V2 installation detection result

package/dist/init/platform-config-generator.d.ts

@@ -35,7 +35,9 @@ export declare class PlatformConfigGenerator {
     /**
      * Generate the MCP config for a platform
      */
-    generateMcpConfig(platformId: PlatformId): GeneratedConfig;
+    generateMcpConfig(platformId: PlatformId, opts?: {
+        memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
+    }): GeneratedConfig;
     /**
      * Generate behavioral rules / instruction file for a platform
      */

package/dist/init/platform-config-generator.js

@@ -135,14 +135,22 @@ const SAFE_AUTO_APPROVE_TOOLS = [
 // ============================================================================
 // MCP Server Entry
 // ============================================================================
-function getMcpServerEntry(withAutoApprove) {
+/**
+ * Build the MCP server env. Issue #533: in database-free mode the server must
+ * run in-memory (AQE_MEMORY_BACKEND=memory) and must NOT be pointed at a
+ * persistent db path — otherwise launching via this client recreates
+ * .agentic-qe/memory.db at runtime and defeats the --no-database install.
+ */
+function getMcpServerEnv(dbFree) {
+    return dbFree
+        ? { AQE_MEMORY_BACKEND: 'memory', AQE_V3_MODE: 'true' }
+        : { AQE_MEMORY_PATH: '.agentic-qe/memory.db', AQE_V3_MODE: 'true' };
+}
+function getMcpServerEntry(withAutoApprove, dbFree) {
     const entry = {
         command: 'npx',
         args: ['-y', 'agentic-qe@latest', 'mcp'],
-        env: {
-            AQE_MEMORY_PATH: '.agentic-qe/memory.db',
-            AQE_V3_MODE: 'true',
-        },
+        env: getMcpServerEnv(dbFree),
     };
     if (withAutoApprove) {
         entry.disabled = false;
@@ -153,8 +161,8 @@ function getMcpServerEntry(withAutoApprove) {
 // ============================================================================
 // Config Generators
 // ============================================================================
-function generateJsonConfig(platform) {
-    const serverEntry = getMcpServerEntry(platform.supportsAutoApprove);
+function generateJsonConfig(platform, dbFree) {
+    const serverEntry = getMcpServerEntry(platform.supportsAutoApprove, dbFree);
     if (platform.id === 'copilot') {
         // Copilot uses "servers" key with "type": "stdio"
         const config = {
@@ -174,7 +182,10 @@ function generateJsonConfig(platform) {
     };
     return JSON.stringify(config, null, 2) + '\n';
 }
-function generateTomlConfig() {
+function generateTomlConfig(dbFree) {
+    const envLines = dbFree
+        ? `AQE_MEMORY_BACKEND = "memory"\nAQE_V3_MODE = "true"`
+        : `AQE_MEMORY_PATH = ".agentic-qe/memory.db"\nAQE_V3_MODE = "true"`;
     return `# Agentic QE MCP Server
 [mcp_servers.agentic-qe]
 type = "stdio"
@@ -182,11 +193,13 @@ command = "npx"
 args = ["-y", "agentic-qe@latest", "mcp"]
 
 [mcp_servers.agentic-qe.env]
-AQE_MEMORY_PATH = ".agentic-qe/memory.db"
-AQE_V3_MODE = "true"
+${envLines}
 `;
 }
-function generateYamlConfig() {
+function generateYamlConfig(dbFree) {
+    const envLines = dbFree
+        ? `      AQE_MEMORY_BACKEND: memory\n      AQE_V3_MODE: "true"`
+        : `      AQE_MEMORY_PATH: .agentic-qe/memory.db\n      AQE_V3_MODE: "true"`;
     return `# Agentic QE MCP Server
 mcpServers:
   - name: agentic-qe
@@ -196,8 +209,7 @@ mcpServers:
       - agentic-qe@latest
       - mcp
     env:
-      AQE_MEMORY_PATH: .agentic-qe/memory.db
-      AQE_V3_MODE: "true"
+${envLines}
 `;
 }
 // ============================================================================
@@ -281,19 +293,21 @@ export class PlatformConfigGenerator {
     /**
      * Generate the MCP config for a platform
      */
-    generateMcpConfig(platformId) {
+    generateMcpConfig(platformId, opts) {
         const platform = this.getPlatform(platformId);
+        // Issue #533: database-free installs propagate AQE_MEMORY_BACKEND=memory.
+        const dbFree = opts?.memoryBackend === 'memory';
         let content;
         switch (platform.configFormat) {
             case 'toml':
-                content = generateTomlConfig();
+                content = generateTomlConfig(dbFree);
                 break;
             case 'yaml':
-                content = generateYamlConfig();
+                content = generateYamlConfig(dbFree);
                 break;
             case 'json':
             default:
-                content = generateJsonConfig(platform);
+                content = generateJsonConfig(platform, dbFree);
                 break;
         }
         return {

package/dist/init/roocode-installer.d.ts

@@ -8,6 +8,11 @@
 export interface RooCodeInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the MCP config
+     * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface RooCodeInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface RooCodeInstallResult {
 export declare class RooCodeInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: RooCodeInstallerOptions);
     install(): Promise<RooCodeInstallResult>;

package/dist/init/roocode-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class RooCodeInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class RooCodeInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('roocode');
+            const mcpConfig = this.generator.generateMcpConfig('roocode', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

package/dist/init/windsurf-installer.d.ts

@@ -8,6 +8,11 @@
 export interface WindsurfInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the MCP config
+     * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface WindsurfInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface WindsurfInstallResult {
 export declare class WindsurfInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: WindsurfInstallerOptions);
     install(): Promise<WindsurfInstallResult>;

package/dist/init/windsurf-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class WindsurfInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class WindsurfInstaller {
         };
         try {
             // Generate MCP config (project-level .windsurf/mcp_config.json)
-            const mcpConfig = this.generator.generateMcpConfig('windsurf');
+            const mcpConfig = this.generator.generateMcpConfig('windsurf', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

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

@@ -368,6 +368,14 @@ export function openRvfStoreReadonly(path) {
 }
 /** Check whether the native binding is loadable on this platform */
 export function isRvfNativeAvailable() {
+    // Database-free mode (#534): report RVF as unavailable so every consumer
+    // (RVF pattern store, dual-writer, agent memory branches) takes its existing
+    // "no native RVF" degraded path and writes nothing to disk — no patterns.rvf,
+    // brain.rvf, or branches/*.rvf. This is the single central gate for all
+    // on-disk RVF stores.
+    if (process.env.AQE_MEMORY_BACKEND === 'memory') {
+        return false;
+    }
     return getNative() !== null;
 }
 //# sourceMappingURL=rvf-native-adapter.js.map

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

@@ -50,6 +50,11 @@ export async function getSharedRvfDualWriter() {
             if (rvfMode === 'sqlite-only') {
                 return null;
             }
+            // Database-free mode (#534): no on-disk RVF store (brain.rvf). The unified
+            // DB is already in-memory, so there is nothing to dual-write to disk.
+            if (process.env.AQE_MEMORY_BACKEND === 'memory') {
+                return null;
+            }
             // Auto-detect native availability (dynamic import to avoid bundling .node files)
             const { isRvfNativeAvailable } = await import('./rvf-native-adapter.js');
             if (!isRvfNativeAvailable()) {

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