agentic-qe 3.10.8 → 3.11.0

package/dist/domains/test-generation/coordinator.js

@@ -9,8 +9,11 @@
  */
 import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
-import { err, } from '../../shared/types';
+import { readFile } from 'node:fs/promises';
+import { ok, err, } from '../../shared/types';
 import { toError } from '../../shared/error-utils.js';
+// Opt-in free-tier local test generation (cross-pollination plan 06, D7-wire/D8/D9).
+import { FreeTierEscalatingExecutor, defaultFreeTierLadder, createRoutingFeedbackSink, } from '../../routing/free-tier/index.js';
 import { TestGenerationEvents, LearningOptimizationEvents, createEvent, } from '../../shared/events/domain-events';
 import { createTestGeneratorServiceWithDependencies, } from './services/test-generator';
 import { PatternMatcherService, } from './services/pattern-matcher';
@@ -52,6 +55,8 @@ const DEFAULT_CONFIG = {
     consensusThreshold: 0.7,
     consensusStrategy: 'weighted',
     consensusMinModels: 2,
+    // Free-tier local generation is OFF by default (opt-in).
+    enableFreeTier: false,
 };
 /**
  * Test Generation Coordinator
@@ -71,6 +76,15 @@ const DEFAULT_CONFIG = {
  * - Verifies test patterns, mock strategies, and edge cases
  */
 const logger = LoggerFactory.create('test-generation');
+/** Strip a single ```fenced``` block if the model wrapped its output (free-tier path). */
+function stripFence(text) {
+    const m = text.match(/```(?:[a-zA-Z0-9]+)?\n([\s\S]*?)\n```/);
+    return (m ? m[1] : text).trim();
+}
+/** Derive a test file path from a source path: `foo.ts` → `foo.test.ts` (free-tier path). */
+function deriveTestFilePath(src) {
+    return src.replace(/\.([cm]?[jt]sx?)$/, '.test.$1');
+}
 export class TestGenerationCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
@@ -78,6 +92,8 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
     hookRegistry;
     testGenerator;
     patternMatcher;
+    /** Opt-in free-tier local executor (null unless enabled). */
+    freeTierExecutor = null;
     // @ruvector integrations (ADR-040)
     qesona = null;
     flashAttention = null;
@@ -87,7 +103,9 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
     recentDreamInsights = [];
     // Coherence gate (ADR-052)
     coherenceGate = null;
-    constructor(eventBus, memory, agentCoordinator, config = {}, llmRouter, coherenceService, hookRegistry) {
+    constructor(eventBus, memory, agentCoordinator, config = {}, llmRouter, coherenceService, hookRegistry, 
+    /** Optional D9 sink — when provided, free-tier outcomes feed routing-feedback. */
+    routingFeedback) {
         const fullConfig = { ...DEFAULT_CONFIG, ...config };
         super(eventBus, 'test-generation', fullConfig, {
             verifyFindingTypes: [
@@ -105,6 +123,36 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         // ADR-043 wiring: dependencies factory accepts llmRouter.
         this.testGenerator = createTestGeneratorServiceWithDependencies({ memory, llmRouter });
         this.patternMatcher = new PatternMatcherService(memory);
+        // Opt-in free-tier local generation (plan 06, D7-wire/D8/D9). OFF by default;
+        // local-only with a same-tier repair loop and NO paid escalation yet.
+        const freeTierOn = this.config.enableFreeTier === true || process.env.AQE_FREE_TIER === '1';
+        if (freeTierOn) {
+            const model = this.config.freeTierModel || process.env.AQE_FREE_TIER_MODEL || 'qwen3:8b';
+            // Paid escalation: delegate Claude tiers to the existing HybridRouter, mapping
+            // the ladder tier to a complexity hint so the router selects that tier. When no
+            // router is wired, the executor stays local-only (Claude tiers report unavailable).
+            const claudeRunner = llmRouter
+                ? async (tier, msgs) => {
+                    const complexity = tier === 'opus' ? 'high' : tier === 'sonnet' ? 'medium' : 'low';
+                    const resp = await llmRouter.chat({
+                        messages: msgs.map((m) => ({ role: m.role, content: m.content })),
+                        agentType: 'qe-test-architect',
+                        complexity,
+                    });
+                    return { content: resp.content };
+                }
+                : undefined;
+            this.freeTierExecutor = new FreeTierEscalatingExecutor({
+                ladder: defaultFreeTierLadder(model),
+                claudeRunner,
+                defaultRepairAttempts: this.config.freeTierRepairAttempts ?? 1,
+                onOutcome: routingFeedback
+                    ? createRoutingFeedbackSink(routingFeedback, { taskKind: 'test-generation' }) // D9
+                    : undefined,
+            });
+            logger.info(`Free-tier local test generation enabled (model=${model}, repair, ` +
+                `${claudeRunner ? 'escalation→HybridRouter' : 'local-only'})`);
+        }
         // Initialize coherence gate if service is provided (ADR-052)
         if (this.config.enableCoherenceGate && coherenceService) {
             this.coherenceGate = createTestGenerationCoherenceGate(coherenceService, undefined, // Use default embedding service
@@ -219,6 +267,21 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         try {
             // Create workflow tracking
             this.startWorkflow(workflowId, 'generate');
+            // Opt-in (plan 06, D7-wire): try the FREE local model first with a repair
+            // loop. Fully guarded — any miss falls through to the normal LLM path.
+            if (this.freeTierExecutor) {
+                try {
+                    const ft = await this.tryFreeTierGeneration(request);
+                    if (ft) {
+                        this.completeWorkflow(workflowId);
+                        logger.info(`Free-tier local generation produced ${ft.tests.length} test file(s); skipped paid path`);
+                        return ok(ft);
+                    }
+                }
+                catch (e) {
+                    logger.debug('Free-tier generation failed; falling back to the normal path');
+                }
+            }
             // ADR-047: Check topology health before expensive operations
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
                 logger.warn('Topology degraded, using conservative strategy');
@@ -361,6 +424,78 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             return { success: false, error: err };
         }
     }
+    /**
+     * Opt-in free-tier local test generation (plan 06, D7-wire/D8/D9).
+     * Reads the first source file, asks the FREE local model to write tests,
+     * verifies the output is a real test (has a test + an assertion) with a
+     * same-tier repair loop, and parses it into a minimal GeneratedTests.
+     * Returns null on ANY miss so the caller falls back to the normal path.
+     */
+    async tryFreeTierGeneration(request) {
+        if (!this.freeTierExecutor)
+            return null;
+        // Single-file only: the cheap-first path generates one test file. For
+        // multi-file requests fall back to the normal path so EVERY file is covered.
+        if (!request.sourceFiles || request.sourceFiles.length !== 1)
+            return null;
+        const src = request.sourceFiles[0];
+        if (!src)
+            return null;
+        let code = '';
+        try {
+            code = await readFile(src, 'utf8');
+        }
+        catch {
+            return null; // unreadable → fall back
+        }
+        if (!code.trim())
+            return null;
+        const framework = request.framework ?? 'vitest';
+        const messages = [
+            { role: 'system', content: `You write ${framework} tests. Output ONLY a single fenced code block — no prose.` },
+            {
+                role: 'user',
+                content: `Write ${framework} ${request.testType ?? 'unit'} tests for this file ` +
+                    `(aim for ~${request.coverageTarget ?? 80}% coverage). Use real assertions.\n\n` +
+                    '```\n' + code.slice(0, 6000) + '\n```',
+            },
+        ];
+        // Objective oracle: output must contain a test block AND an assertion.
+        const verify = (out) => {
+            const hasTest = /\b(test|it|describe)\s*\(/.test(out);
+            const hasAssert = /\b(expect|assert)\s*\(/.test(out);
+            return hasTest && hasAssert
+                ? { passed: true }
+                : { passed: false, feedback: 'output must contain a test (test/it/describe) with an assertion (expect/assert)' };
+        };
+        const r = await this.freeTierExecutor.execute({
+            agentId: `test-gen:${src}`,
+            messages,
+            verify,
+            // Cheap-first: try local + repair, then escalate the hard tail up the
+            // ladder via the HybridRouter (when wired). Local-only if no router.
+            escalate: true,
+            repairAttempts: this.config.freeTierRepairAttempts ?? 1,
+        });
+        if (!r.ok)
+            return null;
+        const testCode = stripFence(r.content);
+        const assertions = (testCode.match(/\b(?:expect|assert)\s*\(/g) ?? []).length;
+        if (assertions === 0)
+            return null;
+        const test = {
+            id: uuidv4(),
+            name: `free-tier:${src.split('/').pop() ?? src}`,
+            sourceFile: src,
+            testFile: deriveTestFilePath(src),
+            testCode,
+            type: request.testType ?? 'unit',
+            assertions,
+            framework,
+            llmEnhanced: true,
+        };
+        return { tests: [test], coverageEstimate: 0, patternsUsed: ['free-tier-local', `tier:${r.tierUsed}`] };
+    }
     /**
      * Generate tests using TDD workflow
      */

package/dist/domains/test-generation/plugin.js

@@ -5,6 +5,8 @@
 import { err } from '../../shared/types';
 import { BaseDomainPlugin } from '../domain-interface';
 import { TestGenerationCoordinator, } from './coordinator';
+// D9: live routing-feedback so free-tier outcomes lift routing confidence.
+import { RoutingFeedbackCollector } from '../../routing/routing-feedback.js';
 import { createTestGeneratorServiceWithDependencies, } from './services/test-generator';
 import { toError } from '../../shared/error-utils.js';
 import { PatternMatcherService, } from './services/pattern-matcher';
@@ -149,8 +151,28 @@ export class TestGenerationPlugin extends BaseDomainPlugin {
         // so analyzeXxxWithLLM branches become reachable.
         this.testGenerator = createTestGeneratorServiceWithDependencies({ memory: this.memory, llmRouter: this.llmRouter }, this.pluginConfig.testGenerator);
         this.patternMatcher = new PatternMatcherService(this.memory, this.pluginConfig.patternMatcher);
+        // D9: when the free tier is opted in, stand up a live RoutingFeedbackCollector
+        // (calibrator + auto-escalation enabled) so each cheap-vs-escalated outcome
+        // feeds routing confidence. Memory-only fallback if the DB is unavailable.
+        let routingFeedback;
+        const freeTierOn = this.pluginConfig.coordinator?.enableFreeTier === true || process.env.AQE_FREE_TIER === '1';
+        if (freeTierOn) {
+            routingFeedback = new RoutingFeedbackCollector(10000, {
+                enableEMACalibration: true,
+                enableAutoEscalation: true,
+            });
+            try {
+                await routingFeedback.initialize();
+            }
+            catch {
+                // memory-only is fine — recording still drives calibration/escalation
+            }
+        }
         // Create coordinator
-        this.coordinator = new TestGenerationCoordinator(this.eventBus, this.memory, this.agentCoordinator, this.pluginConfig.coordinator, this.llmRouter);
+        this.coordinator = new TestGenerationCoordinator(this.eventBus, this.memory, this.agentCoordinator, this.pluginConfig.coordinator, this.llmRouter, undefined, // coherenceService
+        undefined, // hookRegistry
+        routingFeedback // D9 sink (undefined unless free tier is on)
+        );
         // Initialize coordinator
         await this.coordinator.initialize();
         // Issue #205 fix: Start with 'idle' status (0 agents)

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

@@ -8,6 +8,11 @@
 export interface ClineInstallerOptions {
     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 ClineInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface ClineInstallResult {
 export declare class ClineInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: ClineInstallerOptions);
     install(): Promise<ClineInstallResult>;

package/dist/init/cline-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class ClineInstaller {
     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 ClineInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('cline');
+            const mcpConfig = this.generator.generateMcpConfig('cline', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

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

@@ -8,6 +8,11 @@
 export interface CodexInstallerOptions {
     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 CodexInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface CodexInstallResult {
 export declare class CodexInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: CodexInstallerOptions);
     install(): Promise<CodexInstallResult>;

package/dist/init/codex-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class CodexInstaller {
     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 CodexInstaller {
         };
         try {
             // Generate TOML MCP config
-            const mcpConfig = this.generator.generateMcpConfig('codex');
+            const mcpConfig = this.generator.generateMcpConfig('codex', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

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

@@ -8,6 +8,11 @@
 export interface ContinueDevInstallerOptions {
     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 ContinueDevInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface ContinueDevInstallResult {
 export declare class ContinueDevInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: ContinueDevInstallerOptions);
     install(): Promise<ContinueDevInstallResult>;

package/dist/init/continuedev-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class ContinueDevInstaller {
     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 ContinueDevInstaller {
         };
         try {
             // Generate YAML MCP config
-            const mcpConfig = this.generator.generateMcpConfig('continuedev');
+            const mcpConfig = this.generator.generateMcpConfig('continuedev', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {
@@ -83,6 +85,12 @@ export class ContinueDevInstaller {
             // If existing config already has mcpServers key, append just the server entry
             // to avoid duplicate mcpServers keys (which produces invalid YAML)
             if (existing.includes('mcpServers:')) {
+                // #533: honor database-free mode on the merge path too — otherwise this
+                // hardcoded entry re-introduces AQE_MEMORY_PATH and the server recreates
+                // memory.db at runtime, defeating a --no-database install.
+                const envBlock = this.options.memoryBackend === 'memory'
+                    ? `      AQE_MEMORY_BACKEND: memory\n      AQE_V3_MODE: "true"`
+                    : `      AQE_MEMORY_PATH: .agentic-qe/memory.db\n      AQE_V3_MODE: "true"`;
                 const serverEntry = `  - name: agentic-qe
     command: npx
     args:
@@ -90,8 +98,7 @@ export class ContinueDevInstaller {
       - agentic-qe@latest
       - mcp
     env:
-      AQE_MEMORY_PATH: .agentic-qe/memory.db
-      AQE_V3_MODE: "true"`;
+${envBlock}`;
                 return existing.trimEnd() + '\n' + serverEntry + '\n';
             }
             // No existing mcpServers — append the full block

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

@@ -8,6 +8,11 @@
 export interface CopilotInstallerOptions {
     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 CopilotInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface CopilotInstallResult {
 export declare class CopilotInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: CopilotInstallerOptions);
     install(): Promise<CopilotInstallResult>;

package/dist/init/copilot-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class CopilotInstaller {
     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 CopilotInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('copilot');
+            const mcpConfig = this.generator.generateMcpConfig('copilot', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

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

@@ -8,6 +8,11 @@
 export interface CursorInstallerOptions {
     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 CursorInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface CursorInstallResult {
 export declare class CursorInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: CursorInstallerOptions);
     install(): Promise<CursorInstallResult>;

package/dist/init/cursor-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class CursorInstaller {
     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 CursorInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('cursor');
+            const mcpConfig = this.generator.generateMcpConfig('cursor', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

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

@@ -8,6 +8,11 @@
 export interface KiloCodeInstallerOptions {
     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 KiloCodeInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface KiloCodeInstallResult {
 export declare class KiloCodeInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: KiloCodeInstallerOptions);
     install(): Promise<KiloCodeInstallResult>;

package/dist/init/kilocode-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class KiloCodeInstaller {
     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 KiloCodeInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('kilocode');
+            const mcpConfig = this.generator.generateMcpConfig('kilocode', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

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

@@ -18,6 +18,11 @@ export interface KiroInstallerOptions {
     installSteering?: boolean;
     /** Overwrite existing files (default: false) */
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the Kiro MCP
+     * config runs the server in-memory (AQE_MEMORY_BACKEND=memory). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface KiroInstallResult {
     success: boolean;

package/dist/init/kiro-installer.js

@@ -130,10 +130,10 @@ export class KiroInstaller {
                 'agentic-qe': {
                     command: 'npx',
                     args: ['-y', 'agentic-qe@latest', 'mcp'],
-                    env: {
-                        AQE_MEMORY_PATH: '.agentic-qe/memory.db',
-                        AQE_V3_MODE: 'true',
-                    },
+                    // Issue #533: database-free installs run the MCP server in-memory.
+                    env: this.options.memoryBackend === 'memory'
+                        ? { AQE_MEMORY_BACKEND: 'memory', AQE_V3_MODE: 'true' }
+                        : { AQE_MEMORY_PATH: '.agentic-qe/memory.db', AQE_V3_MODE: 'true' },
                     disabled: false,
                     autoApprove: [
                         'fleet_init',

package/dist/init/orchestrator.js

@@ -49,6 +49,7 @@ export class ModularInitOrchestrator {
                 wizardAnswers: options.wizardAnswers,
                 noGovernance: options.noGovernance,
                 noMcp: options.noMcp,
+                noClaude: options.noClaude,
                 memoryBackend: options.memoryBackend,
             },
             config: {},

package/dist/init/phases/07-hooks.js

@@ -25,6 +25,11 @@ export class HooksPhase extends BasePhase {
     critical = false;
     requiresPhases = ['configuration'];
     async shouldRun(context) {
+        // #532: hooks write into .claude/ — part of the Claude Code surface.
+        if (context.options.noClaude) {
+            context.services.log('  Hooks skipped (--no-claude)');
+            return false;
+        }
         const config = context.config;
         return config?.hooks?.claudeCode ?? true;
     }

package/dist/init/phases/08-mcp.js

@@ -26,6 +26,11 @@ export class MCPPhase extends BasePhase {
     requiresPhases = ['configuration', 'database'];
     async run(context) {
         const { projectRoot } = context;
+        // #532: --no-claude suppresses the Claude Code surface, including .mcp.json.
+        if (context.options.noClaude) {
+            context.services.log('  MCP: skipped (--no-claude — .mcp.json is the Claude Code surface)');
+            return { configured: false, mcpPath: '', serverName: '' };
+        }
         // MCP is enabled by default — skip only with --no-mcp
         if (context.options.noMcp) {
             context.services.log('  MCP: skipped (--no-mcp)');
@@ -39,14 +44,29 @@ export class MCPPhase extends BasePhase {
         // AQE MCP server configuration
         // AQE_PROJECT_ROOT omitted — runtime discovery via findProjectRoot() is
         // portable across machines, devcontainers, and CI (#321)
-        const aqeServerConfig = {
-            command: 'aqe-mcp',
-            args: [],
-            env: {
+        //
+        // Issue #533: in database-free mode (--no-database / memoryBackend:'memory')
+        // the server must run in-memory and must not have learning/workers forced
+        // on (those persist to SQLite, recreating .agentic-qe/memory.db at runtime
+        // and defeating the db-free install). Those phases are already skipped at
+        // install time; mirror that in the generated env.
+        const dbFree = context.options.memoryBackend === 'memory';
+        const env = dbFree
+            ? {
+                AQE_MEMORY_BACKEND: 'memory',
+                AQE_LEARNING_ENABLED: 'false',
+                AQE_WORKERS_ENABLED: 'false',
+                NODE_ENV: 'production',
+            }
+            : {
                 AQE_LEARNING_ENABLED: 'true',
                 AQE_WORKERS_ENABLED: 'true',
                 NODE_ENV: 'production',
-            },
+            };
+        const aqeServerConfig = {
+            command: 'aqe-mcp',
+            args: [],
+            env,
         };
         // Write to .mcp.json at project root (the only location Claude Code reads)
         const rootMcpPath = join(projectRoot, '.mcp.json');
@@ -68,8 +88,15 @@ export class MCPPhase extends BasePhase {
         writeFileSync(rootMcpPath, JSON.stringify(rootMcpConfig, null, 2), 'utf-8');
         context.services.log(`  MCP config: ${rootMcpPath}`);
         context.services.log(`  Server: agentic-qe`);
-        context.services.log(`  Learning: enabled`);
-        context.services.log(`  Workers: enabled`);
+        if (dbFree) {
+            context.services.log(`  Memory backend: in-memory (database-free)`);
+            context.services.log(`  Learning: disabled (db-free)`);
+            context.services.log(`  Workers: disabled (db-free)`);
+        }
+        else {
+            context.services.log(`  Learning: enabled`);
+            context.services.log(`  Workers: enabled`);
+        }
         return {
             configured: true,
             mcpPath: rootMcpPath,