agentic-qe 3.3.4 → 3.3.5

package/v3/dist/cli/bundle.js

@@ -1384,7 +1384,7 @@ var init_claude_provider = __esm({
           defaultModel: config.defaultModel || "claude-3-5-sonnet-20241022",
           baseUrl: this.baseUrl,
           defaultTimeout: config.defaultTimeout || 3e4,
-          maxRetries: config.maxRetries || 3,
+          maxRetries: config.maxRetries ?? 3,
           retryDelayMs: config.retryDelayMs || 1e3,
           enableLogging: config.enableLogging || false
         };
@@ -1697,7 +1697,7 @@ var init_openai_provider = __esm({
           defaultModel: config.defaultModel || "gpt-4-turbo",
           baseUrl: this.baseUrl,
           defaultTimeout: config.defaultTimeout || CONSENSUS_CONSTANTS.MODEL_TIMEOUT_MS,
-          maxRetries: config.maxRetries || CONSENSUS_CONSTANTS.DEFAULT_RETRY_ATTEMPTS,
+          maxRetries: config.maxRetries ?? CONSENSUS_CONSTANTS.DEFAULT_RETRY_ATTEMPTS,
           retryDelayMs: config.retryDelayMs || CONSENSUS_CONSTANTS.DEFAULT_RETRY_DELAY_MS,
           enableLogging: config.enableLogging || false
         };
@@ -1947,7 +1947,7 @@ var init_gemini_provider = __esm({
           defaultModel: config.defaultModel || "gemini-1.5-pro-latest",
           baseUrl: this.baseUrl,
           defaultTimeout: config.defaultTimeout || 3e4,
-          maxRetries: config.maxRetries || 3,
+          maxRetries: config.maxRetries ?? 3,
           retryDelayMs: config.retryDelayMs || 1e3,
           enableLogging: config.enableLogging || false
         };
@@ -7438,7 +7438,7 @@ __export(v2_to_v3_migration_exports, {
   migrateV2ToV3: () => migrateV2ToV3
 });
 import Database2 from "better-sqlite3";
-async function migrateV2ToV3(v2DbPath = ".agentic-qe/memory.db", v3PatternsDbPath = ".agentic-qe/qe-patterns.db", onProgress) {
+async function migrateV2ToV3(v2DbPath = ".agentic-qe/memory.db", v3PatternsDbPath = ".agentic-qe/memory.db", onProgress) {
   const migrator = new V2ToV3Migrator({
     v2DbPath,
     v3PatternsDbPath,
@@ -8624,15 +8624,36 @@ function isMigrationApplied(db) {
 
 // src/kernel/unified-memory.ts
 init_constants();
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    if (fs.existsSync(path.join(dir, "package.json")) || fs.existsSync(path.join(dir, ".git"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+function getDefaultDbPath() {
+  const projectRoot = findProjectRoot();
+  return path.join(projectRoot, ".agentic-qe", "memory.db");
+}
 var DEFAULT_UNIFIED_MEMORY_CONFIG = {
   dbPath: ".agentic-qe/memory.db",
-  // <-- THE SINGLE SOURCE OF TRUTH
+  // Resolved to project root at runtime
   walMode: true,
   mmapSize: MEMORY_CONSTANTS.MMAP_SIZE_BYTES,
   cacheSize: MEMORY_CONSTANTS.CACHE_SIZE_KB,
   busyTimeout: MEMORY_CONSTANTS.BUSY_TIMEOUT_MS,
   vectorDimensions: MEMORY_CONSTANTS.DEFAULT_VECTOR_DIMENSIONS
 };
+function getResolvedDefaultConfig() {
+  return {
+    ...DEFAULT_UNIFIED_MEMORY_CONFIG,
+    dbPath: getDefaultDbPath()
+  };
+}
 var SCHEMA_VERSION = 7;
 var SCHEMA_VERSION_TABLE = `
   CREATE TABLE IF NOT EXISTS schema_version (
@@ -9161,7 +9182,8 @@ var UnifiedMemoryManager = class _UnifiedMemoryManager {
   preparedStatements = /* @__PURE__ */ new Map();
   vectorIndex = new InMemoryHNSWIndex();
   constructor(config) {
-    this.config = { ...DEFAULT_UNIFIED_MEMORY_CONFIG, ...config };
+    const resolvedDefaults = getResolvedDefaultConfig();
+    this.config = { ...resolvedDefaults, ...config };
   }
   /**
    * Get or create the singleton instance (synchronous).
@@ -32986,7 +33008,7 @@ var STRICT_VERIFICATION_TYPES = [
 
 // src/agents/claim-verifier/verifiers/file-verifier.ts
 import { readFile as readFile3, stat as stat2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 import fg from "fast-glob";
 var FileBasedVerifier = class {
   config;
@@ -33140,7 +33162,7 @@ var FileBasedVerifier = class {
     const evidence = [];
     let passed = 0;
     for (const filePath of filePaths) {
-      const fullPath = join2(this.config.rootDir, filePath);
+      const fullPath = join3(this.config.rootDir, filePath);
       try {
         const stats = await stat2(fullPath);
         const exists = stats.isFile();
@@ -33234,7 +33256,7 @@ var FileBasedVerifier = class {
     for (const ev of existingEvidence) {
       if (ev.type === "file-reference" || ev.type === "code-snippet") {
         const filePath = ev.location.split(":")[0];
-        const fullPath = join2(this.config.rootDir, filePath);
+        const fullPath = join3(this.config.rootDir, filePath);
         try {
           const stats = await stat2(fullPath);
           const exists = stats.isFile();
@@ -33283,7 +33305,7 @@ var FileBasedVerifier = class {
 import { exec as exec2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { readFile as readFile4 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var execAsync2 = promisify2(exec2);
 var TestBasedVerifier = class {
   config;
@@ -33571,7 +33593,7 @@ var TestBasedVerifier = class {
    * Get coverage data from report.
    */
   async getCoverageData() {
-    const reportPath = join3(this.config.rootDir, this.config.coverageReportPath);
+    const reportPath = join4(this.config.rootDir, this.config.coverageReportPath);
     const content = await readFile4(reportPath, "utf-8");
     const data = JSON.parse(content);
     const total = data.total || data;
@@ -46119,7 +46141,7 @@ init_wrappers();
 
 // src/domains/code-intelligence/services/metric-collector/index.ts
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync3 } from "fs";
-import { join as join7, extname as extname3 } from "path";
+import { join as join8, extname as extname3 } from "path";
 
 // src/domains/code-intelligence/services/metric-collector/interfaces.ts
 var DEFAULT_METRIC_CONFIG = {
@@ -46133,7 +46155,7 @@ var DEFAULT_METRIC_CONFIG = {
 // src/domains/code-intelligence/services/metric-collector/loc-counter.ts
 import { execSync as execSync4, spawnSync } from "child_process";
 import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync4 } from "fs";
-import { join as join5, extname } from "path";
+import { join as join6, extname } from "path";
 async function countLOC(projectPath, config = {}) {
   const mergedConfig = { ...DEFAULT_METRIC_CONFIG, ...config };
   const clocResult = await tryClocCount(projectPath, mergedConfig);
@@ -46281,7 +46303,7 @@ function manualLOCCount(projectPath, config) {
     }
     const entries = readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join5(dirPath, entry.name);
+      const fullPath = join6(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (config.excludeDirs.includes(entry.name)) {
           continue;
@@ -46481,7 +46503,7 @@ function getBlockCommentEnd(ext) {
 // src/domains/code-intelligence/services/metric-collector/test-counter.ts
 import { execSync as execSync5, spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
-import { join as join6, extname as extname2 } from "path";
+import { join as join7, extname as extname2 } from "path";
 async function countTests(projectPath, config = {}) {
   const mergedConfig = { ...DEFAULT_METRIC_CONFIG, ...config };
   const runner = detectTestRunner(projectPath);
@@ -46501,7 +46523,7 @@ async function countTests(projectPath, config = {}) {
   }
 }
 function detectTestRunner(projectPath) {
-  const packageJsonPath = join6(projectPath, "package.json");
+  const packageJsonPath = join7(projectPath, "package.json");
   if (existsSync6(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
@@ -46517,13 +46539,13 @@ function detectTestRunner(projectPath) {
     } catch {
     }
   }
-  if (existsSync6(join6(projectPath, "Cargo.toml"))) {
+  if (existsSync6(join7(projectPath, "Cargo.toml"))) {
     return "cargo";
   }
-  if (existsSync6(join6(projectPath, "pyproject.toml")) || existsSync6(join6(projectPath, "setup.py")) || existsSync6(join6(projectPath, "pytest.ini")) || existsSync6(join6(projectPath, "requirements.txt"))) {
+  if (existsSync6(join7(projectPath, "pyproject.toml")) || existsSync6(join7(projectPath, "setup.py")) || existsSync6(join7(projectPath, "pytest.ini")) || existsSync6(join7(projectPath, "requirements.txt"))) {
     return "pytest";
   }
-  if (existsSync6(join6(projectPath, "go.mod"))) {
+  if (existsSync6(join7(projectPath, "go.mod"))) {
     return "go";
   }
   return "fallback";
@@ -46798,7 +46820,7 @@ function countTestsByFilePattern(projectPath, config) {
     }
     const entries = readdirSync2(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join6(dirPath, entry.name);
+      const fullPath = join7(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (config.excludeDirs.includes(entry.name)) {
           continue;
@@ -46887,11 +46909,11 @@ function classifyTests(total, source, projectPath) {
   let unit = total;
   let integration = 0;
   let e2e = 0;
-  if (existsSync6(join6(projectPath, "tests", "integration")) || existsSync6(join6(projectPath, "test", "integration")) || existsSync6(join6(projectPath, "__tests__", "integration"))) {
+  if (existsSync6(join7(projectPath, "tests", "integration")) || existsSync6(join7(projectPath, "test", "integration")) || existsSync6(join7(projectPath, "__tests__", "integration"))) {
     integration = Math.floor(total * 0.2);
     unit -= integration;
   }
-  if (existsSync6(join6(projectPath, "tests", "e2e")) || existsSync6(join6(projectPath, "test", "e2e")) || existsSync6(join6(projectPath, "e2e")) || existsSync6(join6(projectPath, "cypress"))) {
+  if (existsSync6(join7(projectPath, "tests", "e2e")) || existsSync6(join7(projectPath, "test", "e2e")) || existsSync6(join7(projectPath, "e2e")) || existsSync6(join7(projectPath, "cypress"))) {
     e2e = Math.floor(total * 0.1);
     unit -= e2e;
   }
@@ -47046,11 +47068,11 @@ var MetricCollectorService = class {
    * Detect primary language of a project
    */
   detectLanguage(projectPath) {
-    if (existsSync7(join7(projectPath, "Cargo.toml"))) return "rust";
-    if (existsSync7(join7(projectPath, "go.mod"))) return "go";
-    if (existsSync7(join7(projectPath, "pyproject.toml")) || existsSync7(join7(projectPath, "requirements.txt"))) return "python";
-    if (existsSync7(join7(projectPath, "package.json"))) {
-      if (existsSync7(join7(projectPath, "tsconfig.json"))) return "typescript";
+    if (existsSync7(join8(projectPath, "Cargo.toml"))) return "rust";
+    if (existsSync7(join8(projectPath, "go.mod"))) return "go";
+    if (existsSync7(join8(projectPath, "pyproject.toml")) || existsSync7(join8(projectPath, "requirements.txt"))) return "python";
+    if (existsSync7(join8(projectPath, "package.json"))) {
+      if (existsSync7(join8(projectPath, "tsconfig.json"))) return "typescript";
       return "javascript";
     }
     return "unknown";
@@ -47069,7 +47091,7 @@ var MetricCollectorService = class {
       if (!existsSync7(dirPath)) return;
       const entries = readdirSync3(dirPath, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join7(dirPath, entry.name);
+        const fullPath = join8(dirPath, entry.name);
         if (entry.isDirectory()) {
           const excludeDirs = ["node_modules", "dist", "coverage", "build", ".git", "vendor", "target"];
           if (excludeDirs.includes(entry.name)) continue;
@@ -80253,7 +80275,7 @@ var DOMAIN_FACTORIES = {
   "learning-optimization": (eb, m, c) => createLearningOptimizationPlugin(eb, m, c),
   "coordination": (eb, m, c) => createCoordinationPlugin(eb, m, c)
 };
-function findProjectRoot() {
+function findProjectRoot2() {
   let dir = process.cwd();
   const root = path9.parse(dir).root;
   while (dir !== root) {
@@ -80284,7 +80306,7 @@ var QEKernelImpl = class {
   constructor(config = {}) {
     this._config = { ...DEFAULT_CONFIG53, ...config };
     this._startTime = /* @__PURE__ */ new Date();
-    const projectRoot = findProjectRoot();
+    const projectRoot = findProjectRoot2();
     const dataDir = this._config.dataDir || path9.join(projectRoot, ".agentic-qe");
     if (!fs8.existsSync(dataDir)) {
       fs8.mkdirSync(dataDir, { recursive: true });
@@ -83604,7 +83626,7 @@ var QueenRouterAdapter = class {
 
 // src/hooks/cross-phase-hooks.ts
 import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { parse as parseYaml } from "yaml";
 
 // src/types/cross-phase-signals.ts
@@ -83884,7 +83906,7 @@ var CrossPhaseHookExecutor = class {
   configPath;
   listeners = /* @__PURE__ */ new Map();
   constructor(configPath) {
-    this.configPath = configPath || join10(process.cwd(), ".claude/hooks/cross-phase-memory.yaml");
+    this.configPath = configPath || join11(process.cwd(), ".claude/hooks/cross-phase-memory.yaml");
     this.memory = getCrossPhaseMemory();
   }
   // ---------------------------------------------------------------------------
@@ -89272,7 +89294,7 @@ init_types();
 
 // src/init/init-wizard.ts
 import { existsSync as existsSync17, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync14, readdirSync as readdirSync8, statSync as statSync7, unlinkSync as unlinkSync2, copyFileSync as copyFileSync5 } from "fs";
-import { join as join17, dirname as dirname7 } from "path";
+import { join as join18, dirname as dirname7 } from "path";
 import { createRequire } from "module";
 
 // src/init/types.ts
@@ -89381,14 +89403,14 @@ function createDefaultConfig(projectName, projectRoot) {
 
 // src/init/project-analyzer.ts
 import { readFileSync as readFileSync10, existsSync as existsSync13, statSync as statSync4, readdirSync as readdirSync4 } from "fs";
-import { join as join13, basename as basename3, extname as extname5, relative as relative4 } from "path";
+import { join as join14, basename as basename3, extname as extname5, relative as relative4 } from "path";
 var frameworkDetectors = [
   {
     name: "jest",
     detect: (root) => {
       const configs = ["jest.config.js", "jest.config.ts", "jest.config.mjs", "jest.config.cjs"];
       for (const config of configs) {
-        if (existsSync13(join13(root, config))) {
+        if (existsSync13(join14(root, config))) {
           const version = getPackageVersion(root, "jest");
           return { name: "jest", version, configFile: config, confidence: 1 };
         }
@@ -89409,7 +89431,7 @@ var frameworkDetectors = [
     detect: (root) => {
       const configs = ["vitest.config.ts", "vitest.config.js", "vitest.config.mts", "vite.config.ts"];
       for (const config of configs) {
-        if (existsSync13(join13(root, config))) {
+        if (existsSync13(join14(root, config))) {
           const version = getPackageVersion(root, "vitest");
           return { name: "vitest", version, configFile: config, confidence: 1 };
         }
@@ -89426,7 +89448,7 @@ var frameworkDetectors = [
     detect: (root) => {
       const configs = [".mocharc.js", ".mocharc.json", ".mocharc.yaml", ".mocharc.yml"];
       for (const config of configs) {
-        if (existsSync13(join13(root, config))) {
+        if (existsSync13(join14(root, config))) {
           const version = getPackageVersion(root, "mocha");
           return { name: "mocha", version, configFile: config, confidence: 1 };
         }
@@ -89443,7 +89465,7 @@ var frameworkDetectors = [
     detect: (root) => {
       const configs = ["pytest.ini", "pyproject.toml", "setup.cfg"];
       for (const config of configs) {
-        const configPath = join13(root, config);
+        const configPath = join14(root, config);
         if (existsSync13(configPath)) {
           try {
             const content = readFileSync10(configPath, "utf-8");
@@ -89455,7 +89477,7 @@ var frameworkDetectors = [
           }
         }
       }
-      const reqPath = join13(root, "requirements.txt");
+      const reqPath = join14(root, "requirements.txt");
       if (existsSync13(reqPath)) {
         try {
           const content = readFileSync10(reqPath, "utf-8");
@@ -89474,7 +89496,7 @@ var frameworkDetectors = [
     detect: (root) => {
       const configs = ["playwright.config.ts", "playwright.config.js"];
       for (const config of configs) {
-        if (existsSync13(join13(root, config))) {
+        if (existsSync13(join14(root, config))) {
           const version = getPackageVersion(root, "@playwright/test");
           return { name: "playwright", version, configFile: config, confidence: 1 };
         }
@@ -89491,12 +89513,12 @@ var frameworkDetectors = [
     detect: (root) => {
       const configs = ["cypress.config.ts", "cypress.config.js", "cypress.json"];
       for (const config of configs) {
-        if (existsSync13(join13(root, config))) {
+        if (existsSync13(join14(root, config))) {
           const version = getPackageVersion(root, "cypress");
           return { name: "cypress", version, configFile: config, confidence: 1 };
         }
       }
-      if (existsSync13(join13(root, "cypress"))) {
+      if (existsSync13(join14(root, "cypress"))) {
         return { name: "cypress", configFile: "cypress/", confidence: 0.9 };
       }
       return null;
@@ -89517,7 +89539,7 @@ var languagePatterns = [
   { name: "swift", extensions: [".swift"] }
 ];
 function readPackageJson(root) {
-  const pkgPath = join13(root, "package.json");
+  const pkgPath = join14(root, "package.json");
   if (!existsSync13(pkgPath)) return null;
   try {
     return JSON.parse(readFileSync10(pkgPath, "utf-8"));
@@ -89542,7 +89564,7 @@ function walkDir(dir, callback, options = {}) {
     }
     for (const entry of entries) {
       if (exclude.includes(entry)) continue;
-      const fullPath = join13(currentDir, entry);
+      const fullPath = join14(currentDir, entry);
       let stat3;
       try {
         stat3 = statSync4(fullPath);
@@ -89587,7 +89609,7 @@ var ProjectAnalyzer = class {
       codeComplexity,
       coverage,
       packageManager: this.detectPackageManager(),
-      hasTypeScript: existsSync13(join13(this.projectRoot, "tsconfig.json")),
+      hasTypeScript: existsSync13(join14(this.projectRoot, "tsconfig.json")),
       hasCIConfig: this.detectCIConfig(),
       ciProvider: this.detectCIProvider(),
       analysisTimestamp: /* @__PURE__ */ new Date(),
@@ -89673,7 +89695,7 @@ var ProjectAnalyzer = class {
         } else {
           tests.byType.unknown++;
         }
-        const dir = relative4(this.projectRoot, join13(filePath, ".."));
+        const dir = relative4(this.projectRoot, join14(filePath, ".."));
         testDirs.add(dir);
       }
     });
@@ -89853,7 +89875,7 @@ var ProjectAnalyzer = class {
       "htmlcov/index.html"
     ];
     for (const coveragePath of coveragePaths) {
-      const fullPath = join13(this.projectRoot, coveragePath);
+      const fullPath = join14(this.projectRoot, coveragePath);
       if (existsSync13(fullPath)) {
         if (coveragePath.endsWith(".json")) {
           try {
@@ -89893,9 +89915,9 @@ var ProjectAnalyzer = class {
    * Detect project type
    */
   detectProjectType() {
-    if (existsSync13(join13(this.projectRoot, "lerna.json"))) return "monorepo";
-    if (existsSync13(join13(this.projectRoot, "pnpm-workspace.yaml"))) return "monorepo";
-    if (existsSync13(join13(this.projectRoot, "packages"))) return "monorepo";
+    if (existsSync13(join14(this.projectRoot, "lerna.json"))) return "monorepo";
+    if (existsSync13(join14(this.projectRoot, "pnpm-workspace.yaml"))) return "monorepo";
+    if (existsSync13(join14(this.projectRoot, "packages"))) return "monorepo";
     const pkg = readPackageJson(this.projectRoot);
     if (pkg?.workspaces) return "monorepo";
     if (pkg?.main || pkg?.module || pkg?.exports) return "library";
@@ -89905,10 +89927,10 @@ var ProjectAnalyzer = class {
    * Detect package manager
    */
   detectPackageManager() {
-    if (existsSync13(join13(this.projectRoot, "bun.lockb"))) return "bun";
-    if (existsSync13(join13(this.projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync13(join13(this.projectRoot, "yarn.lock"))) return "yarn";
-    if (existsSync13(join13(this.projectRoot, "package-lock.json"))) return "npm";
+    if (existsSync13(join14(this.projectRoot, "bun.lockb"))) return "bun";
+    if (existsSync13(join14(this.projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync13(join14(this.projectRoot, "yarn.lock"))) return "yarn";
+    if (existsSync13(join14(this.projectRoot, "package-lock.json"))) return "npm";
     return "unknown";
   }
   /**
@@ -89923,16 +89945,16 @@ var ProjectAnalyzer = class {
       ".travis.yml",
       "azure-pipelines.yml"
     ];
-    return ciFiles.some((f) => existsSync13(join13(this.projectRoot, f)));
+    return ciFiles.some((f) => existsSync13(join14(this.projectRoot, f)));
   }
   /**
    * Detect CI provider
    */
   detectCIProvider() {
-    if (existsSync13(join13(this.projectRoot, ".github/workflows"))) return "github-actions";
-    if (existsSync13(join13(this.projectRoot, ".gitlab-ci.yml"))) return "gitlab-ci";
-    if (existsSync13(join13(this.projectRoot, "Jenkinsfile"))) return "jenkins";
-    if (existsSync13(join13(this.projectRoot, ".circleci/config.yml"))) return "circleci";
+    if (existsSync13(join14(this.projectRoot, ".github/workflows"))) return "github-actions";
+    if (existsSync13(join14(this.projectRoot, ".gitlab-ci.yml"))) return "gitlab-ci";
+    if (existsSync13(join14(this.projectRoot, "Jenkinsfile"))) return "jenkins";
+    if (existsSync13(join14(this.projectRoot, ".circleci/config.yml"))) return "circleci";
     if (this.detectCIConfig()) return "other";
     return void 0;
   }
@@ -90256,7 +90278,7 @@ function createSelfConfigurator(options) {
 
 // src/init/skills-installer.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync as readdirSync5, statSync as statSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync2, copyFileSync as copyFileSync2 } from "fs";
-import { join as join14, dirname as dirname4 } from "path";
+import { join as join15, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
 var V3_DOMAIN_SKILLS = [
   // 12 DDD bounded context skills
@@ -90366,25 +90388,25 @@ var SkillsInstaller = class {
     const moduleDir = dirname4(fileURLToPath(import.meta.url));
     const possiblePaths = [
       // Development: relative to v3/src/init/ (3 levels up to agentic-qe root)
-      join14(moduleDir, "../../../.claude/skills"),
+      join15(moduleDir, "../../../.claude/skills"),
       // Development: relative to v3/dist/init/ (3 levels up to agentic-qe root)
-      join14(moduleDir, "../../../.claude/skills"),
+      join15(moduleDir, "../../../.claude/skills"),
       // NPM package: assets directory at package root (dist/init -> dist -> package root)
-      join14(moduleDir, "../../assets/skills"),
+      join15(moduleDir, "../../assets/skills"),
       // Local install: in node_modules
-      join14(this.projectRoot, "node_modules/@agentic-qe/v3/assets/skills")
+      join15(this.projectRoot, "node_modules/@agentic-qe/v3/assets/skills")
     ];
     try {
       const { execSync: execSync7 } = __require("child_process");
       const npmPrefix = execSync7("npm config get prefix", { encoding: "utf-8" }).trim();
       possiblePaths.push(
         // Global install as @agentic-qe/v3
-        join14(npmPrefix, "lib/node_modules/@agentic-qe/v3/assets/skills"),
+        join15(npmPrefix, "lib/node_modules/@agentic-qe/v3/assets/skills"),
         // Global install as agentic-qe (root package)
-        join14(npmPrefix, "lib/node_modules/agentic-qe/.claude/skills"),
+        join15(npmPrefix, "lib/node_modules/agentic-qe/.claude/skills"),
         // Linux global without lib
-        join14(npmPrefix, "node_modules/@agentic-qe/v3/assets/skills"),
-        join14(npmPrefix, "node_modules/agentic-qe/.claude/skills")
+        join15(npmPrefix, "node_modules/@agentic-qe/v3/assets/skills"),
+        join15(npmPrefix, "node_modules/agentic-qe/.claude/skills")
       );
     } catch (error) {
       console.debug("[SkillsInstaller] npm prefix lookup failed:", error instanceof Error ? error.message : error);
@@ -90405,13 +90427,13 @@ var SkillsInstaller = class {
       skipped: [],
       errors: [],
       totalCount: 0,
-      skillsDir: join14(this.projectRoot, ".claude", "skills")
+      skillsDir: join15(this.projectRoot, ".claude", "skills")
     };
     if (!existsSync14(this.sourceSkillsDir)) {
       result.errors.push(`Source skills directory not found: ${this.sourceSkillsDir}`);
       return result;
     }
-    const targetSkillsDir = join14(this.projectRoot, ".claude", "skills");
+    const targetSkillsDir = join15(this.projectRoot, ".claude", "skills");
     if (!existsSync14(targetSkillsDir)) {
       mkdirSync5(targetSkillsDir, { recursive: true });
     }
@@ -90440,7 +90462,7 @@ var SkillsInstaller = class {
     try {
       const entries = readdirSync5(this.sourceSkillsDir);
       return entries.filter((entry) => {
-        const fullPath = join14(this.sourceSkillsDir, entry);
+        const fullPath = join15(this.sourceSkillsDir, entry);
         return statSync5(fullPath).isDirectory() && !entry.startsWith(".");
       });
     } catch {
@@ -90474,8 +90496,8 @@ var SkillsInstaller = class {
    * Install a single skill
    */
   async installSkill(skillName, targetDir) {
-    const sourceDir = join14(this.sourceSkillsDir, skillName);
-    const targetSkillDir = join14(targetDir, skillName);
+    const sourceDir = join15(this.sourceSkillsDir, skillName);
+    const targetSkillDir = join15(targetDir, skillName);
     if (existsSync14(targetSkillDir) && !this.options.overwrite) {
       return null;
     }
@@ -90485,7 +90507,7 @@ var SkillsInstaller = class {
     this.copyDirectoryRecursive(sourceDir, targetSkillDir);
     const skillType = this.getSkillType(skillName);
     const description = this.getSkillDescription(targetSkillDir);
-    const hasResources = existsSync14(join14(targetSkillDir, "resources"));
+    const hasResources = existsSync14(join15(targetSkillDir, "resources"));
     return {
       name: skillName,
       type: skillType,
@@ -90499,8 +90521,8 @@ var SkillsInstaller = class {
   copyDirectoryRecursive(source, target) {
     const entries = readdirSync5(source);
     for (const entry of entries) {
-      const sourcePath = join14(source, entry);
-      const targetPath = join14(target, entry);
+      const sourcePath = join15(source, entry);
+      const targetPath = join15(target, entry);
       const stat3 = statSync5(sourcePath);
       if (stat3.isDirectory()) {
         if (!existsSync14(targetPath)) {
@@ -90523,7 +90545,7 @@ var SkillsInstaller = class {
    * Extract description from SKILL.md file
    */
   getSkillDescription(skillDir) {
-    const skillMdPath = join14(skillDir, "SKILL.md");
+    const skillMdPath = join15(skillDir, "SKILL.md");
     if (!existsSync14(skillMdPath)) return void 0;
     try {
       const content = readFileSync11(skillMdPath, "utf-8");
@@ -90576,7 +90598,7 @@ ${v3Skills.map((s) => `- **${s.name}**${s.description ? `: ${s.description}` : "
 
 *Generated by AQE v3 init on ${(/* @__PURE__ */ new Date()).toISOString()}*
 `;
-    writeFileSync2(join14(skillsDir, "README.md"), indexContent, "utf-8");
+    writeFileSync2(join15(skillsDir, "README.md"), indexContent, "utf-8");
   }
 };
 function createSkillsInstaller(options) {
@@ -90585,7 +90607,7 @@ function createSkillsInstaller(options) {
 
 // src/init/agents-installer.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync6, readdirSync as readdirSync6, statSync as statSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync3, copyFileSync as copyFileSync3 } from "fs";
-import { join as join15, dirname as dirname5 } from "path";
+import { join as join16, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var V3_QE_AGENTS = [
   // Test Generation Domain
@@ -90673,25 +90695,25 @@ var AgentsInstaller = class {
     const possiblePaths = [
       // NPM package: assets directory at package root (dist/init -> dist -> package root)
       // This is the canonical source with helpers/ directory
-      join15(moduleDir, "../../assets/agents/v3"),
+      join16(moduleDir, "../../assets/agents/v3"),
       // Development: v3/src/init/ -> v3/assets/agents/v3/
-      join15(moduleDir, "../../../v3/assets/agents/v3"),
+      join16(moduleDir, "../../../v3/assets/agents/v3"),
       // Fallback: root .claude/agents/v3 (may not have helpers/)
-      join15(moduleDir, "../../../.claude/agents/v3"),
+      join16(moduleDir, "../../../.claude/agents/v3"),
       // Local install: in node_modules
-      join15(this.projectRoot, "node_modules/@agentic-qe/v3/assets/agents/v3")
+      join16(this.projectRoot, "node_modules/@agentic-qe/v3/assets/agents/v3")
     ];
     try {
       const { execSync: execSync7 } = __require("child_process");
       const npmPrefix = execSync7("npm config get prefix", { encoding: "utf-8" }).trim();
       possiblePaths.push(
         // Global install as @agentic-qe/v3
-        join15(npmPrefix, "lib/node_modules/@agentic-qe/v3/assets/agents/v3"),
+        join16(npmPrefix, "lib/node_modules/@agentic-qe/v3/assets/agents/v3"),
         // Global install as agentic-qe (root package)
-        join15(npmPrefix, "lib/node_modules/agentic-qe/v3/assets/agents/v3"),
+        join16(npmPrefix, "lib/node_modules/agentic-qe/v3/assets/agents/v3"),
         // Linux global without lib
-        join15(npmPrefix, "node_modules/@agentic-qe/v3/assets/agents/v3"),
-        join15(npmPrefix, "node_modules/agentic-qe/v3/assets/agents/v3")
+        join16(npmPrefix, "node_modules/@agentic-qe/v3/assets/agents/v3"),
+        join16(npmPrefix, "node_modules/agentic-qe/v3/assets/agents/v3")
       );
     } catch (error) {
       console.debug("[AgentsInstaller] npm prefix lookup failed:", error instanceof Error ? error.message : error);
@@ -90712,17 +90734,17 @@ var AgentsInstaller = class {
       skipped: [],
       errors: [],
       totalCount: 0,
-      agentsDir: join15(this.projectRoot, ".claude", "agents", "v3")
+      agentsDir: join16(this.projectRoot, ".claude", "agents", "v3")
     };
     if (!existsSync15(this.sourceAgentsDir)) {
       result.errors.push(`Source agents directory not found: ${this.sourceAgentsDir}`);
       return result;
     }
-    const targetAgentsDir = join15(this.projectRoot, ".claude", "agents", "v3");
+    const targetAgentsDir = join16(this.projectRoot, ".claude", "agents", "v3");
     if (!existsSync15(targetAgentsDir)) {
       mkdirSync6(targetAgentsDir, { recursive: true });
     }
-    const targetSubagentsDir = join15(targetAgentsDir, "subagents");
+    const targetSubagentsDir = join16(targetAgentsDir, "subagents");
     if (!existsSync15(targetSubagentsDir)) {
       mkdirSync6(targetSubagentsDir, { recursive: true });
     }
@@ -90753,7 +90775,7 @@ var AgentsInstaller = class {
     try {
       const entries = readdirSync6(this.sourceAgentsDir);
       for (const entry of entries) {
-        const fullPath = join15(this.sourceAgentsDir, entry);
+        const fullPath = join16(this.sourceAgentsDir, entry);
         const stat3 = statSync6(fullPath);
         if (stat3.isFile() && entry.endsWith(".md")) {
           agents.push(entry.replace(".md", ""));
@@ -90812,8 +90834,8 @@ var AgentsInstaller = class {
   async installAgent(agentPath, targetDir, targetSubagentsDir) {
     const isSubagent = agentPath.startsWith("subagents/");
     const agentName = isSubagent ? agentPath.split("/")[1] : agentPath;
-    const sourceFile = join15(this.sourceAgentsDir, `${agentPath}.md`);
-    const targetFile = isSubagent ? join15(targetSubagentsDir, `${agentName}.md`) : join15(targetDir, `${agentName}.md`);
+    const sourceFile = join16(this.sourceAgentsDir, `${agentPath}.md`);
+    const targetFile = isSubagent ? join16(targetSubagentsDir, `${agentName}.md`) : join16(targetDir, `${agentName}.md`);
     if (existsSync15(targetFile) && !this.options.overwrite) {
       return null;
     }
@@ -90849,8 +90871,8 @@ var AgentsInstaller = class {
     }
     const entries = readdirSync6(source);
     for (const entry of entries) {
-      const sourcePath = join15(source, entry);
-      const targetPath = join15(target, entry);
+      const sourcePath = join16(source, entry);
+      const targetPath = join16(target, entry);
       const stat3 = statSync6(sourcePath);
       if (stat3.isDirectory()) {
         this.copyDirectoryRecursive(sourcePath, targetPath);
@@ -90865,8 +90887,8 @@ var AgentsInstaller = class {
    * Copy helpers directory (agent-specific reference files, templates, scripts)
    */
   async copyHelpersDirectory(targetAgentsDir) {
-    const sourceHelpersDir = join15(this.sourceAgentsDir, "helpers");
-    const targetHelpersDir = join15(targetAgentsDir, "helpers");
+    const sourceHelpersDir = join16(this.sourceAgentsDir, "helpers");
+    const targetHelpersDir = join16(targetAgentsDir, "helpers");
     if (existsSync15(sourceHelpersDir)) {
       this.copyDirectoryRecursive(sourceHelpersDir, targetHelpersDir);
     }
@@ -90998,7 +91020,7 @@ ${subagents.map((a) => `- **${a.name}**${a.description ? `: ${a.description}` :
 
 *Generated by AQE v3 init on ${(/* @__PURE__ */ new Date()).toISOString()}*
 `;
-    writeFileSync3(join15(agentsDir, "README.md"), indexContent, "utf-8");
+    writeFileSync3(join16(agentsDir, "README.md"), indexContent, "utf-8");
   }
 };
 function createAgentsInstaller(options) {
@@ -91014,7 +91036,7 @@ import {
   writeFileSync as writeFileSync4,
   copyFileSync as copyFileSync4
 } from "fs";
-import { join as join16, dirname as dirname6 } from "path";
+import { join as join17, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename2 = fileURLToPath3(import.meta.url);
 var __dirname2 = dirname6(__filename2);
@@ -91077,38 +91099,38 @@ var N8nInstaller = class {
   findSourceAgentsDir() {
     const possiblePaths = [
       // From v3/src/init/ context (development)
-      join16(__dirname2, "../../../.claude/agents/n8n"),
-      join16(__dirname2, "../../.claude/agents/n8n"),
+      join17(__dirname2, "../../../.claude/agents/n8n"),
+      join17(__dirname2, "../../.claude/agents/n8n"),
       // From project root
-      join16(process.cwd(), ".claude/agents/n8n"),
+      join17(process.cwd(), ".claude/agents/n8n"),
       // NPM package location
-      join16(__dirname2, "../../assets/agents/n8n"),
+      join17(__dirname2, "../../assets/agents/n8n"),
       // Monorepo location
-      join16(process.cwd(), "../.claude/agents/n8n")
+      join17(process.cwd(), "../.claude/agents/n8n")
     ];
     for (const path16 of possiblePaths) {
       if (existsSync16(path16)) {
         return path16;
       }
     }
-    return join16(process.cwd(), ".claude/agents/n8n");
+    return join17(process.cwd(), ".claude/agents/n8n");
   }
   /**
    * Find the source skills directory
    */
   findSourceSkillsDir() {
     const possiblePaths = [
-      join16(__dirname2, "../../../.claude/skills"),
-      join16(__dirname2, "../../.claude/skills"),
-      join16(process.cwd(), ".claude/skills"),
-      join16(__dirname2, "../../assets/skills")
+      join17(__dirname2, "../../../.claude/skills"),
+      join17(__dirname2, "../../.claude/skills"),
+      join17(process.cwd(), ".claude/skills"),
+      join17(__dirname2, "../../assets/skills")
     ];
     for (const path16 of possiblePaths) {
       if (existsSync16(path16)) {
         return path16;
       }
     }
-    return join16(process.cwd(), ".claude/skills");
+    return join17(process.cwd(), ".claude/skills");
   }
   // ==========================================================================
   // Installation
@@ -91123,8 +91145,8 @@ var N8nInstaller = class {
       skillsInstalled: [],
       configGenerated: false,
       errors: [],
-      agentsDir: join16(this.projectRoot, ".claude/agents/n8n"),
-      skillsDir: join16(this.projectRoot, ".claude/skills")
+      agentsDir: join17(this.projectRoot, ".claude/agents/n8n"),
+      skillsDir: join17(this.projectRoot, ".claude/skills")
     };
     try {
       if (this.options.installAgents) {
@@ -91169,8 +91191,8 @@ var N8nInstaller = class {
     );
     for (const category of Object.keys(N8N_AGENTS)) {
       for (const agent of N8N_AGENTS[category]) {
-        const sourceFile = join16(this.sourceAgentsDir, agent.filename);
-        const targetFile = join16(targetDir, agent.filename);
+        const sourceFile = join17(this.sourceAgentsDir, agent.filename);
+        const targetFile = join17(targetDir, agent.filename);
         if (!availableFiles.includes(agent.filename)) {
           continue;
         }
@@ -91206,8 +91228,8 @@ var N8nInstaller = class {
       return { installed, errors };
     }
     for (const skillName of N8N_SKILLS) {
-      const sourceSkillDir = join16(this.sourceSkillsDir, skillName);
-      const targetSkillDir = join16(targetDir, skillName);
+      const sourceSkillDir = join17(this.sourceSkillsDir, skillName);
+      const targetSkillDir = join17(targetDir, skillName);
       if (!existsSync16(sourceSkillDir)) {
         continue;
       }
@@ -91234,8 +91256,8 @@ var N8nInstaller = class {
     }
     const entries = readdirSync7(source, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join16(source, entry.name);
-      const targetPath = join16(target, entry.name);
+      const sourcePath = join17(source, entry.name);
+      const targetPath = join17(target, entry.name);
       if (entry.isDirectory()) {
         this.copyDirectory(sourcePath, targetPath);
       } else {
@@ -91247,7 +91269,7 @@ var N8nInstaller = class {
    * Create agents index README
    */
   createAgentsIndex(targetDir, agents) {
-    const indexPath = join16(targetDir, "README.md");
+    const indexPath = join17(targetDir, "README.md");
     const byCategory = {
       core: agents.filter((a) => a.category === "core"),
       advanced: agents.filter((a) => a.category === "advanced"),
@@ -91486,7 +91508,7 @@ var InitOrchestrator = class {
    * This marks the installation as v3
    */
   async writeVersionToDb(version) {
-    const memoryDbPath = join17(this.projectRoot, ".agentic-qe", "memory.db");
+    const memoryDbPath = join18(this.projectRoot, ".agentic-qe", "memory.db");
     try {
       const dir = dirname7(memoryDbPath);
       if (!existsSync17(dir)) {
@@ -91536,15 +91558,15 @@ var InitOrchestrator = class {
    * 3. If no version or version < 3.0.0, and v2 markers exist, it's v2
    */
   async detectV2Installation() {
-    const memoryDbPath = join17(this.projectRoot, ".agentic-qe", "memory.db");
-    const configPath = join17(this.projectRoot, ".agentic-qe", "config");
-    const agentsPath = join17(this.projectRoot, ".claude", "agents");
-    const v2ConfigFile = join17(this.projectRoot, ".agentic-qe", "config", "learning.json");
+    const memoryDbPath = join18(this.projectRoot, ".agentic-qe", "memory.db");
+    const configPath = join18(this.projectRoot, ".agentic-qe", "config");
+    const agentsPath = join18(this.projectRoot, ".claude", "agents");
+    const v2ConfigFile = join18(this.projectRoot, ".agentic-qe", "config", "learning.json");
     const hasMemoryDb = existsSync17(memoryDbPath);
     const hasConfig = existsSync17(configPath);
     const hasAgents = existsSync17(agentsPath);
     const hasV2ConfigFiles = existsSync17(v2ConfigFile);
-    const hasV3ConfigYaml = existsSync17(join17(this.projectRoot, ".agentic-qe", "config.yaml"));
+    const hasV3ConfigYaml = existsSync17(join18(this.projectRoot, ".agentic-qe", "config.yaml"));
     let version;
     let isV3Installation = false;
     if (hasMemoryDb) {
@@ -91761,7 +91783,7 @@ var InitOrchestrator = class {
       const { V2ToV3Migrator: V2ToV3Migrator2 } = await Promise.resolve().then(() => (init_v2_to_v3_migration(), v2_to_v3_migration_exports));
       if (v2Detection.memoryDbPath) {
         console.log("  Migrating V2 data to V3 format...");
-        const v3PatternsDbPath = join17(this.projectRoot, ".agentic-qe", "qe-patterns.db");
+        const v3PatternsDbPath = join18(this.projectRoot, ".agentic-qe", "memory.db");
         const migrator = new V2ToV3Migrator2({
           v2DbPath: v2Detection.memoryDbPath,
           v3PatternsDbPath,
@@ -91795,7 +91817,7 @@ var InitOrchestrator = class {
    * Removes qe-* files and specific v2 agents (qx-partner, base-template-generator)
    */
   async removeV2QEAgents() {
-    const agentsDir = join17(this.projectRoot, ".claude", "agents");
+    const agentsDir = join18(this.projectRoot, ".claude", "agents");
     if (!existsSync17(agentsDir)) {
       return;
     }
@@ -91808,13 +91830,13 @@ var InitOrchestrator = class {
       const v2QEAgents = [];
       for (const entry of entries) {
         if (entry.startsWith("qe-") && entry.endsWith(".md")) {
-          const fullPath = join17(agentsDir, entry);
+          const fullPath = join18(agentsDir, entry);
           const stat3 = statSync7(fullPath);
           if (stat3.isFile()) {
             v2QEAgents.push(entry);
           }
         } else if (V2_LEGACY_AGENTS.includes(entry)) {
-          const fullPath = join17(agentsDir, entry);
+          const fullPath = join18(agentsDir, entry);
           const stat3 = statSync7(fullPath);
           if (stat3.isFile()) {
             v2QEAgents.push(entry);
@@ -91825,14 +91847,14 @@ var InitOrchestrator = class {
         return;
       }
       console.log(`  Removing ${v2QEAgents.length} v2 QE agents from .claude/agents/...`);
-      const backupDir = join17(this.projectRoot, ".agentic-qe", "backup", "v2-agents");
+      const backupDir = join18(this.projectRoot, ".agentic-qe", "backup", "v2-agents");
       if (!existsSync17(backupDir)) {
         mkdirSync8(backupDir, { recursive: true });
       }
       const { renameSync } = await import("fs");
       for (const agent of v2QEAgents) {
-        const sourcePath = join17(agentsDir, agent);
-        const backupPath = join17(backupDir, agent);
+        const sourcePath = join18(agentsDir, agent);
+        const backupPath = join18(backupDir, agent);
         try {
           copyFileSync5(sourcePath, backupPath);
           unlinkSync2(sourcePath);
@@ -91851,16 +91873,16 @@ var InitOrchestrator = class {
    */
   async migrateV2Config(v2Detection) {
     if (!v2Detection.hasConfig) return;
-    const v2ConfigDir = join17(this.projectRoot, ".agentic-qe", "config");
-    const v3ConfigPath = join17(this.projectRoot, ".agentic-qe", "config.yaml");
+    const v2ConfigDir = join18(this.projectRoot, ".agentic-qe", "config");
+    const v3ConfigPath = join18(this.projectRoot, ".agentic-qe", "config.yaml");
     if (existsSync17(v3ConfigPath)) {
       console.log("  \u2713 V3 config already exists, preserving...");
       return;
     }
     try {
-      const learningConfig = this.readJsonSafe(join17(v2ConfigDir, "learning.json"));
-      const improvementConfig = this.readJsonSafe(join17(v2ConfigDir, "improvement.json"));
-      const codeIntelConfig = this.readJsonSafe(join17(v2ConfigDir, "code-intelligence.json"));
+      const learningConfig = this.readJsonSafe(join18(v2ConfigDir, "learning.json"));
+      const improvementConfig = this.readJsonSafe(join18(v2ConfigDir, "improvement.json"));
+      const codeIntelConfig = this.readJsonSafe(join18(v2ConfigDir, "code-intelligence.json"));
       const v3Config = {
         version: "3.0.0",
         migratedFrom: v2Detection.version || "2.x.x",
@@ -92014,7 +92036,7 @@ ${yaml.stringify(v3Config)}`;
    * Uses memory backend to check code-intelligence:kg namespace
    */
   async checkCodeIntelligenceIndex() {
-    const dbPath = join17(this.projectRoot, ".agentic-qe", "memory.db");
+    const dbPath = join18(this.projectRoot, ".agentic-qe", "memory.db");
     if (!existsSync17(dbPath)) {
       return false;
     }
@@ -92057,7 +92079,7 @@ ${yaml.stringify(v3Config)}`;
         ignore: ["node_modules/**", "dist/**", "coverage/**", ".agentic-qe/**"]
       });
       const result = await kgService.index({
-        paths: files.map((f) => join17(projectPath, f)),
+        paths: files.map((f) => join18(projectPath, f)),
         incremental: false,
         includeTests: true
       });
@@ -92078,7 +92100,7 @@ ${yaml.stringify(v3Config)}`;
    * Get count of KG entries from existing database
    */
   async getKGEntryCount() {
-    const dbPath = join17(this.projectRoot, ".agentic-qe", "memory.db");
+    const dbPath = join18(this.projectRoot, ".agentic-qe", "memory.db");
     try {
       const Database4 = (await import("better-sqlite3")).default;
       const db = new Database4(dbPath);
@@ -92107,11 +92129,11 @@ ${yaml.stringify(v3Config)}`;
         "SQLite persistence REQUIRED but better-sqlite3 is not installed.\nInstall it with: npm install better-sqlite3\nIf you see native compilation errors, ensure build tools are installed:\n  - macOS: xcode-select --install\n  - Ubuntu/Debian: sudo apt-get install build-essential python3\n  - Alpine: apk add build-base python3"
       );
     }
-    const dataDir = join17(this.projectRoot, ".agentic-qe");
+    const dataDir = join18(this.projectRoot, ".agentic-qe");
     if (!existsSync17(dataDir)) {
       mkdirSync8(dataDir, { recursive: true });
     }
-    const dbPath = join17(dataDir, "memory.db");
+    const dbPath = join18(dataDir, "memory.db");
     try {
       const db = new Database4(dbPath);
       db.pragma("journal_mode = WAL");
@@ -92158,22 +92180,22 @@ Ensure the directory is writable and has sufficient disk space.`
     if (!config.learning.enabled) {
       return 0;
     }
-    const dataDir = join17(this.projectRoot, ".agentic-qe", "data");
+    const dataDir = join18(this.projectRoot, ".agentic-qe", "data");
     if (!existsSync17(dataDir)) {
       mkdirSync8(dataDir, { recursive: true });
     }
-    const hnswDir = join17(dataDir, "hnsw");
+    const hnswDir = join18(dataDir, "hnsw");
     if (!existsSync17(hnswDir)) {
       mkdirSync8(hnswDir, { recursive: true });
     }
-    const learningConfigPath = join17(dataDir, "learning-config.json");
+    const learningConfigPath = join18(dataDir, "learning-config.json");
     const learningConfig = {
       embeddingModel: config.learning.embeddingModel,
       hnswConfig: config.learning.hnswConfig,
       qualityThreshold: config.learning.qualityThreshold,
       promotionThreshold: config.learning.promotionThreshold,
-      databasePath: join17(dataDir, "qe-patterns.db"),
-      hnswIndexPath: join17(hnswDir, "index.bin"),
+      databasePath: join18(dataDir, "memory.db"),
+      hnswIndexPath: join18(hnswDir, "index.bin"),
       initialized: (/* @__PURE__ */ new Date()).toISOString()
     };
     writeFileSync5(learningConfigPath, JSON.stringify(learningConfig, null, 2), "utf-8");
@@ -92188,7 +92210,7 @@ Ensure the directory is writable and has sufficient disk space.`
         }
         patternsByDomain.get(domain).push(pattern);
       }
-      const patternsIndexPath = join17(dataDir, "pretrained-index.json");
+      const patternsIndexPath = join18(dataDir, "pretrained-index.json");
       const patternsIndex = {
         version: library.version,
         totalPatterns: library.statistics.totalPatterns,
@@ -92200,11 +92222,11 @@ Ensure the directory is writable and has sufficient disk space.`
       };
       writeFileSync5(patternsIndexPath, JSON.stringify(patternsIndex, null, 2), "utf-8");
       for (const [domain, patterns] of patternsByDomain) {
-        const domainDir = join17(dataDir, "patterns", domain);
+        const domainDir = join18(dataDir, "patterns", domain);
         if (!existsSync17(domainDir)) {
           mkdirSync8(domainDir, { recursive: true });
         }
-        const patternsPath = join17(domainDir, "patterns.json");
+        const patternsPath = join18(domainDir, "patterns.json");
         writeFileSync5(patternsPath, JSON.stringify(patterns, null, 2), "utf-8");
         patternsLoaded += patterns.length;
       }
@@ -92221,11 +92243,11 @@ Ensure the directory is writable and has sufficient disk space.`
     if (!config.hooks.claudeCode) {
       return false;
     }
-    const claudeDir = join17(this.projectRoot, ".claude");
+    const claudeDir = join18(this.projectRoot, ".claude");
     if (!existsSync17(claudeDir)) {
       mkdirSync8(claudeDir, { recursive: true });
     }
-    const settingsPath = join17(claudeDir, "settings.json");
+    const settingsPath = join18(claudeDir, "settings.json");
     let settings = {};
     if (existsSync17(settingsPath)) {
       try {
@@ -92384,20 +92406,20 @@ Ensure the directory is writable and has sufficient disk space.`
    * Copies the QCSD feedback loop hooks from assets to .claude/hooks/
    */
   async installCrossPhaseMemoryHooks() {
-    const hooksDir = join17(this.projectRoot, ".claude", "hooks");
+    const hooksDir = join18(this.projectRoot, ".claude", "hooks");
     if (!existsSync17(hooksDir)) {
       mkdirSync8(hooksDir, { recursive: true });
     }
-    const targetPath = join17(hooksDir, "cross-phase-memory.yaml");
+    const targetPath = join18(hooksDir, "cross-phase-memory.yaml");
     if (existsSync17(targetPath)) {
       return;
     }
     const possiblePaths = [
       // Installed package location
-      join17(dirname7(import.meta.url.replace("file://", "")), "..", "..", "assets", "hooks", "cross-phase-memory.yaml"),
+      join18(dirname7(import.meta.url.replace("file://", "")), "..", "..", "assets", "hooks", "cross-phase-memory.yaml"),
       // Development location
-      join17(process.cwd(), "assets", "hooks", "cross-phase-memory.yaml"),
-      join17(process.cwd(), "v3", "assets", "hooks", "cross-phase-memory.yaml")
+      join18(process.cwd(), "assets", "hooks", "cross-phase-memory.yaml"),
+      join18(process.cwd(), "v3", "assets", "hooks", "cross-phase-memory.yaml")
     ];
     for (const sourcePath of possiblePaths) {
       try {
@@ -92442,11 +92464,11 @@ routing:
    * Creates .claude/mcp.json with AQE v3 MCP server configuration
    */
   async configureMCP() {
-    const claudeDir = join17(this.projectRoot, ".claude");
+    const claudeDir = join18(this.projectRoot, ".claude");
     if (!existsSync17(claudeDir)) {
       mkdirSync8(claudeDir, { recursive: true });
     }
-    const mcpPath = join17(claudeDir, "mcp.json");
+    const mcpPath = join18(claudeDir, "mcp.json");
     let mcpConfig = {};
     if (existsSync17(mcpPath)) {
       try {
@@ -92477,14 +92499,14 @@ routing:
    * If CLAUDE.md exists, creates backup and appends AQE v3 section
    */
   async generateCLAUDEmd(config) {
-    const claudeMdPath = join17(this.projectRoot, "CLAUDE.md");
+    const claudeMdPath = join18(this.projectRoot, "CLAUDE.md");
     const content = this.generateCLAUDEmdContent(config);
     if (existsSync17(claudeMdPath)) {
       const existing = readFileSync14(claudeMdPath, "utf-8");
       if (existing.includes("## Agentic QE v3")) {
         return true;
       }
-      const backupPath = join17(this.projectRoot, "CLAUDE.md.backup");
+      const backupPath = join18(this.projectRoot, "CLAUDE.md.backup");
       writeFileSync5(backupPath, existing, "utf-8");
       writeFileSync5(claudeMdPath, existing + "\n\n" + content, "utf-8");
     } else {
@@ -92706,7 +92728,7 @@ Bash("npx @claude-flow/cli@latest memory store --key 'qe-pattern-1' --value '...
 ### Data Storage
 
 - **Memory Backend**: \`.agentic-qe/memory.db\` (SQLite)
-- **Pattern Storage**: \`.agentic-qe/data/qe-patterns.db\` (ReasoningBank)
+- **Pattern Storage**: \`.agentic-qe/data/memory.db\` (ReasoningBank)
 - **HNSW Index**: \`.agentic-qe/data/hnsw/index.bin\`
 - **Configuration**: \`.agentic-qe/config.yaml\`
 
@@ -92745,7 +92767,7 @@ aqe init --auto
     if (!config.workers.daemonAutoStart || config.workers.enabled.length === 0) {
       return 0;
     }
-    const workersDir = join17(this.projectRoot, ".agentic-qe", "workers");
+    const workersDir = join18(this.projectRoot, ".agentic-qe", "workers");
     if (!existsSync17(workersDir)) {
       mkdirSync8(workersDir, { recursive: true });
     }
@@ -92769,7 +92791,7 @@ aqe init --auto
         status: "pending"
       };
     }
-    const registryPath = join17(workersDir, "registry.json");
+    const registryPath = join18(workersDir, "registry.json");
     const registryData = {
       version: config.version,
       maxConcurrent: config.workers.maxConcurrent,
@@ -92780,18 +92802,18 @@ aqe init --auto
     };
     writeFileSync5(registryPath, JSON.stringify(registryData, null, 2), "utf-8");
     for (const workerName of config.workers.enabled) {
-      const workerConfigPath = join17(workersDir, `${workerName}.json`);
+      const workerConfigPath = join18(workersDir, `${workerName}.json`);
       const workerConfig = {
         name: workerName,
         enabled: true,
         interval: config.workers.intervals[workerName] || defaultIntervals[workerName] || 6e4,
         projectRoot: this.projectRoot,
-        dataDir: join17(this.projectRoot, ".agentic-qe", "data"),
+        dataDir: join18(this.projectRoot, ".agentic-qe", "data"),
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       writeFileSync5(workerConfigPath, JSON.stringify(workerConfig, null, 2), "utf-8");
     }
-    const daemonScriptPath = join17(workersDir, "start-daemon.sh");
+    const daemonScriptPath = join18(workersDir, "start-daemon.sh");
     const daemonScript = `#!/bin/bash
 # AQE v3 Worker Daemon Startup Script
 # Generated by aqe init
@@ -92894,12 +92916,12 @@ echo "Use: npx aqe hooks session-start"
     if (!config) {
       throw new Error("No configuration to save");
     }
-    const configDir = join17(this.projectRoot, ".agentic-qe");
+    const configDir = join18(this.projectRoot, ".agentic-qe");
     if (!existsSync17(configDir)) {
       mkdirSync8(configDir, { recursive: true });
     }
     const yaml = this.configToYAML(config);
-    const configPath = join17(configDir, "config.yaml");
+    const configPath = join18(configDir, "config.yaml");
     writeFileSync5(configPath, yaml, "utf-8");
   }
   /**
@@ -93049,7 +93071,7 @@ var BasePhase = class {
 
 // src/init/phases/01-detection.ts
 import { existsSync as existsSync18 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { createRequire as createRequire2 } from "module";
 var require3 = createRequire2(import.meta.url);
 var DetectionPhase = class extends BasePhase {
@@ -93060,7 +93082,7 @@ var DetectionPhase = class extends BasePhase {
   async run(context2) {
     const { projectRoot } = context2;
     const v2Detection = await this.detectV2Installation(projectRoot);
-    const v3ConfigYaml = existsSync18(join18(projectRoot, ".agentic-qe", "config.yaml"));
+    const v3ConfigYaml = existsSync18(join19(projectRoot, ".agentic-qe", "config.yaml"));
     const v3Version = v2Detection.version?.startsWith("3.");
     const v2Detected = v2Detection.detected;
     const v3Detected = v3ConfigYaml || v3Version || false;
@@ -93104,15 +93126,15 @@ var DetectionPhase = class extends BasePhase {
    * Detect existing v2 AQE installation
    */
   async detectV2Installation(projectRoot) {
-    const memoryDbPath = join18(projectRoot, ".agentic-qe", "memory.db");
-    const configPath = join18(projectRoot, ".agentic-qe", "config");
-    const agentsPath = join18(projectRoot, ".claude", "agents");
-    const v2ConfigFile = join18(projectRoot, ".agentic-qe", "config", "learning.json");
+    const memoryDbPath = join19(projectRoot, ".agentic-qe", "memory.db");
+    const configPath = join19(projectRoot, ".agentic-qe", "config");
+    const agentsPath = join19(projectRoot, ".claude", "agents");
+    const v2ConfigFile = join19(projectRoot, ".agentic-qe", "config", "learning.json");
     const hasMemoryDb = existsSync18(memoryDbPath);
     const hasConfig = existsSync18(configPath);
     const hasAgents = existsSync18(agentsPath);
     const hasV2ConfigFiles = existsSync18(v2ConfigFile);
-    const hasV3ConfigYaml = existsSync18(join18(projectRoot, ".agentic-qe", "config.yaml"));
+    const hasV3ConfigYaml = existsSync18(join19(projectRoot, ".agentic-qe", "config.yaml"));
     let version;
     let isV3Installation = false;
     if (hasMemoryDb) {
@@ -93267,7 +93289,7 @@ var ConfigurationPhase = class extends BasePhase {
 
 // src/init/phases/04-database.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync9 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var DatabasePhase = class extends BasePhase {
   name = "database";
   description = "Initialize persistence database";
@@ -93285,11 +93307,11 @@ var DatabasePhase = class extends BasePhase {
         "SQLite persistence REQUIRED but better-sqlite3 is not installed.\nInstall it with: npm install better-sqlite3\nIf you see native compilation errors, ensure build tools are installed."
       );
     }
-    const dataDir = join19(projectRoot, ".agentic-qe");
+    const dataDir = join20(projectRoot, ".agentic-qe");
     if (!existsSync19(dataDir)) {
       mkdirSync9(dataDir, { recursive: true });
     }
-    const dbPath = join19(dataDir, "memory.db");
+    const dbPath = join20(dataDir, "memory.db");
     const created = !existsSync19(dbPath);
     try {
       const db = new Database4(dbPath);
@@ -93340,7 +93362,7 @@ Ensure the directory is writable and has sufficient disk space.`
 
 // src/init/phases/05-learning.ts
 import { existsSync as existsSync20, mkdirSync as mkdirSync10, writeFileSync as writeFileSync6 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 var LearningPhase = class extends BasePhase {
   name = "learning";
   description = "Initialize learning system";
@@ -93362,22 +93384,22 @@ var LearningPhase = class extends BasePhase {
         patternsLoaded: 0
       };
     }
-    const dataDir = join20(projectRoot, ".agentic-qe", "data");
+    const dataDir = join21(projectRoot, ".agentic-qe", "data");
     if (!existsSync20(dataDir)) {
       mkdirSync10(dataDir, { recursive: true });
     }
-    const hnswDir = join20(dataDir, "hnsw");
+    const hnswDir = join21(dataDir, "hnsw");
     if (!existsSync20(hnswDir)) {
       mkdirSync10(hnswDir, { recursive: true });
     }
-    const learningConfigPath = join20(dataDir, "learning-config.json");
+    const learningConfigPath = join21(dataDir, "learning-config.json");
     const learningConfig = {
       embeddingModel: config.learning.embeddingModel,
       hnswConfig: config.learning.hnswConfig,
       qualityThreshold: config.learning.qualityThreshold,
       promotionThreshold: config.learning.promotionThreshold,
-      databasePath: join20(dataDir, "qe-patterns.db"),
-      hnswIndexPath: join20(hnswDir, "index.bin"),
+      databasePath: join21(dataDir, "memory.db"),
+      hnswIndexPath: join21(hnswDir, "index.bin"),
       initialized: (/* @__PURE__ */ new Date()).toISOString()
     };
     writeFileSync6(learningConfigPath, JSON.stringify(learningConfig, null, 2), "utf-8");
@@ -93400,11 +93422,11 @@ var LearningPhase = class extends BasePhase {
    */
   async loadPretrainedPatterns(dataDir, context2) {
     try {
-      const patternsDir = join20(dataDir, "patterns");
+      const patternsDir = join21(dataDir, "patterns");
       if (!existsSync20(patternsDir)) {
         mkdirSync10(patternsDir, { recursive: true });
       }
-      const indexPath = join20(patternsDir, "index.json");
+      const indexPath = join21(patternsDir, "index.json");
       if (!existsSync20(indexPath)) {
         writeFileSync6(indexPath, JSON.stringify({
           version: "3.0.0",
@@ -93422,7 +93444,7 @@ var LearningPhase = class extends BasePhase {
 
 // src/init/phases/06-code-intelligence.ts
 import { existsSync as existsSync21 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var CodeIntelligencePhase = class extends BasePhase {
   name = "code-intelligence";
   description = "Code intelligence pre-scan";
@@ -93444,7 +93466,7 @@ var CodeIntelligencePhase = class extends BasePhase {
    * Check if code intelligence index exists
    */
   async checkCodeIntelligenceIndex(projectRoot) {
-    const dbPath = join21(projectRoot, ".agentic-qe", "memory.db");
+    const dbPath = join22(projectRoot, ".agentic-qe", "memory.db");
     if (!existsSync21(dbPath)) {
       return false;
     }
@@ -93465,7 +93487,7 @@ var CodeIntelligencePhase = class extends BasePhase {
    * Get count of KG entries
    */
   async getKGEntryCount(projectRoot) {
-    const dbPath = join21(projectRoot, ".agentic-qe", "memory.db");
+    const dbPath = join22(projectRoot, ".agentic-qe", "memory.db");
     try {
       const Database4 = (await import("better-sqlite3")).default;
       const db = new Database4(dbPath);
@@ -93504,7 +93526,7 @@ var CodeIntelligencePhase = class extends BasePhase {
         ignore: ["node_modules/**", "dist/**", "coverage/**", ".agentic-qe/**"]
       });
       const result = await kgService.index({
-        paths: files.map((f) => join21(projectRoot, f)),
+        paths: files.map((f) => join22(projectRoot, f)),
         incremental: false,
         includeTests: true
       });
@@ -93524,7 +93546,7 @@ var CodeIntelligencePhase = class extends BasePhase {
 
 // src/init/phases/07-hooks.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var HooksPhase = class extends BasePhase {
   name = "hooks";
   description = "Configure Claude Code hooks";
@@ -93545,11 +93567,11 @@ var HooksPhase = class extends BasePhase {
         hookTypes: []
       };
     }
-    const claudeDir = join22(projectRoot, ".claude");
+    const claudeDir = join23(projectRoot, ".claude");
     if (!existsSync22(claudeDir)) {
       mkdirSync11(claudeDir, { recursive: true });
     }
-    const settingsPath = join22(claudeDir, "settings.json");
+    const settingsPath = join23(claudeDir, "settings.json");
     let settings = {};
     if (existsSync22(settingsPath)) {
       try {
@@ -93715,7 +93737,7 @@ var HooksPhase = class extends BasePhase {
 
 // src/init/phases/08-mcp.ts
 import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var MCPPhase = class extends BasePhase {
   name = "mcp";
   description = "Configure MCP server";
@@ -93724,11 +93746,11 @@ var MCPPhase = class extends BasePhase {
   requiresPhases = ["configuration"];
   async run(context2) {
     const { projectRoot } = context2;
-    const claudeDir = join23(projectRoot, ".claude");
+    const claudeDir = join24(projectRoot, ".claude");
     if (!existsSync23(claudeDir)) {
       mkdirSync12(claudeDir, { recursive: true });
     }
-    const mcpPath = join23(claudeDir, "mcp.json");
+    const mcpPath = join24(claudeDir, "mcp.json");
     let mcpConfig = {};
     if (existsSync23(mcpPath)) {
       try {
@@ -93831,7 +93853,7 @@ var AssetsPhase = class extends BasePhase {
 
 // src/init/phases/10-workers.ts
 import { existsSync as existsSync24, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var WorkersPhase = class extends BasePhase {
   name = "workers";
   description = "Configure background workers";
@@ -93852,7 +93874,7 @@ var WorkersPhase = class extends BasePhase {
         registryPath: ""
       };
     }
-    const workersDir = join24(projectRoot, ".agentic-qe", "workers");
+    const workersDir = join25(projectRoot, ".agentic-qe", "workers");
     if (!existsSync24(workersDir)) {
       mkdirSync13(workersDir, { recursive: true });
     }
@@ -93872,7 +93894,7 @@ var WorkersPhase = class extends BasePhase {
         status: "pending"
       };
     }
-    const registryPath = join24(workersDir, "registry.json");
+    const registryPath = join25(workersDir, "registry.json");
     const registryData = {
       version: config.version,
       maxConcurrent: config.workers.maxConcurrent,
@@ -93882,18 +93904,18 @@ var WorkersPhase = class extends BasePhase {
     };
     writeFileSync9(registryPath, JSON.stringify(registryData, null, 2), "utf-8");
     for (const workerName of config.workers.enabled) {
-      const workerConfigPath = join24(workersDir, `${workerName}.json`);
+      const workerConfigPath = join25(workersDir, `${workerName}.json`);
       const workerConfig = {
         name: workerName,
         enabled: true,
         interval: config.workers.intervals[workerName] || defaultIntervals[workerName] || 6e4,
         projectRoot,
-        dataDir: join24(projectRoot, ".agentic-qe", "data"),
+        dataDir: join25(projectRoot, ".agentic-qe", "data"),
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       writeFileSync9(workerConfigPath, JSON.stringify(workerConfig, null, 2), "utf-8");
     }
-    const daemonScriptPath = join24(workersDir, "start-daemon.sh");
+    const daemonScriptPath = join25(workersDir, "start-daemon.sh");
     const daemonScript = `#!/bin/bash
 # AQE v3 Worker Daemon Startup Script
 # Generated by aqe init
@@ -93928,7 +93950,7 @@ echo "Use: npx aqe hooks session-start"
 
 // src/init/phases/11-claude-md.ts
 import { existsSync as existsSync25, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var ClaudeMdPhase = class extends BasePhase {
   name = "claude-md";
   description = "Generate CLAUDE.md";
@@ -93938,7 +93960,7 @@ var ClaudeMdPhase = class extends BasePhase {
   async run(context2) {
     const config = context2.config;
     const { projectRoot } = context2;
-    const claudeMdPath = join25(projectRoot, "CLAUDE.md");
+    const claudeMdPath = join26(projectRoot, "CLAUDE.md");
     const content = this.generateContent(config);
     let backupCreated = false;
     if (existsSync25(claudeMdPath)) {
@@ -93947,7 +93969,7 @@ var ClaudeMdPhase = class extends BasePhase {
         context2.services.log("  CLAUDE.md already has AQE section");
         return { generated: false, path: claudeMdPath, backupCreated: false };
       }
-      const backupPath = join25(projectRoot, "CLAUDE.md.backup");
+      const backupPath = join26(projectRoot, "CLAUDE.md.backup");
       writeFileSync10(backupPath, existing, "utf-8");
       backupCreated = true;
       writeFileSync10(claudeMdPath, existing + "\n\n" + content, "utf-8");
@@ -94060,7 +94082,7 @@ Task({ prompt: "Security audit", subagent_type: "qe-security-scanner", run_in_ba
 
 // src/init/phases/12-verification.ts
 import { existsSync as existsSync26, readFileSync as readFileSync18 } from "fs";
-import { join as join26, dirname as dirname9 } from "path";
+import { join as join27, dirname as dirname9 } from "path";
 import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync11 } from "fs";
 import { createRequire as createRequire3 } from "module";
 var require4 = createRequire3(import.meta.url);
@@ -94074,16 +94096,16 @@ var VerificationPhase = class extends BasePhase {
     const config = context2.config;
     const { projectRoot } = context2;
     const checks = [];
-    const dbPath = join26(projectRoot, ".agentic-qe", "memory.db");
+    const dbPath = join27(projectRoot, ".agentic-qe", "memory.db");
     checks.push({
       name: "Database exists",
       passed: existsSync26(dbPath)
     });
     checks.push({
       name: ".agentic-qe directory",
-      passed: existsSync26(join26(projectRoot, ".agentic-qe"))
+      passed: existsSync26(join27(projectRoot, ".agentic-qe"))
     });
-    const configPath = join26(projectRoot, ".agentic-qe", "config.yaml");
+    const configPath = join27(projectRoot, ".agentic-qe", "config.yaml");
     await this.saveConfig(config, projectRoot);
     checks.push({
       name: "Config saved",
@@ -94111,7 +94133,7 @@ var VerificationPhase = class extends BasePhase {
    * Write AQE version to memory.db
    */
   async writeVersionToDb(version, projectRoot) {
-    const memoryDbPath = join26(projectRoot, ".agentic-qe", "memory.db");
+    const memoryDbPath = join27(projectRoot, ".agentic-qe", "memory.db");
     try {
       const dir = dirname9(memoryDbPath);
       if (!existsSync26(dir)) {
@@ -94154,11 +94176,11 @@ var VerificationPhase = class extends BasePhase {
    * Preserves user customizations from existing config (Issue #206)
    */
   async saveConfig(config, projectRoot) {
-    const configDir = join26(projectRoot, ".agentic-qe");
+    const configDir = join27(projectRoot, ".agentic-qe");
     if (!existsSync26(configDir)) {
       mkdirSync14(configDir, { recursive: true });
     }
-    const configPath = join26(configDir, "config.yaml");
+    const configPath = join27(configDir, "config.yaml");
     if (existsSync26(configPath)) {
       const existingConfig = this.loadExistingConfig(configPath);
       if (existingConfig) {
@@ -94578,10 +94600,10 @@ function createModularInitOrchestrator(options) {
 
 // src/cli/commands/claude-flow-setup.ts
 import { existsSync as existsSync27, writeFileSync as writeFileSync12, readFileSync as readFileSync19 } from "node:fs";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 import { execSync as execSync6 } from "node:child_process";
 async function detectClaudeFlow(projectRoot, debug) {
-  const claudeSettingsPath = join27(projectRoot, ".claude", "settings.json");
+  const claudeSettingsPath = join28(projectRoot, ".claude", "settings.json");
   if (existsSync27(claudeSettingsPath)) {
     try {
       const settings = JSON.parse(readFileSync19(claudeSettingsPath, "utf-8"));
@@ -94605,7 +94627,7 @@ async function detectClaudeFlow(projectRoot, debug) {
   } catch {
   }
   try {
-    const packageJsonPath = join27(projectRoot, "package.json");
+    const packageJsonPath = join28(projectRoot, "package.json");
     if (existsSync27(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync19(packageJsonPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -94687,7 +94709,7 @@ function generateClaudeFlowConfig(projectRoot, features) {
   };
 }
 function updateMCPConfig(projectRoot) {
-  const claudeSettingsPath = join27(projectRoot, ".claude", "settings.json");
+  const claudeSettingsPath = join28(projectRoot, ".claude", "settings.json");
   let settings = {};
   if (existsSync27(claudeSettingsPath)) {
     try {
@@ -94747,8 +94769,8 @@ async function setupClaudeFlowIntegration(options) {
       features
     };
   }
-  const aqeDir = join27(projectRoot, ".agentic-qe");
-  const configPath = join27(aqeDir, "claude-flow-integration.json");
+  const aqeDir = join28(projectRoot, ".agentic-qe");
+  const configPath = join28(aqeDir, "claude-flow-integration.json");
   try {
     const config = generateClaudeFlowConfig(projectRoot, features);
     writeFileSync12(configPath, JSON.stringify(config, null, 2));
@@ -95223,7 +95245,7 @@ import chalk4 from "chalk";
 
 // src/cli/config/cli-config.ts
 import { existsSync as existsSync28, readFileSync as readFileSync20, writeFileSync as writeFileSync13, mkdirSync as mkdirSync15, unlinkSync as unlinkSync3 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { homedir as homedir2 } from "os";
 var DEFAULT_CLI_CONFIG = {
   wizards: {
@@ -95250,10 +95272,10 @@ var DEFAULT_CLI_CONFIG = {
   }
 };
 function getConfigDir() {
-  return join28(homedir2(), ".aqe");
+  return join29(homedir2(), ".aqe");
 }
 function getConfigPath() {
-  return join28(getConfigDir(), "cli-config.json");
+  return join29(getConfigDir(), "cli-config.json");
 }
 var cachedConfig = null;
 var cacheTimestamp = 0;
@@ -96447,7 +96469,7 @@ import { resolve as resolve5 } from "path";
 // src/cli/wizards/core/wizard-utils.ts
 import chalk10 from "chalk";
 import { existsSync as existsSync29, statSync as statSync8 } from "fs";
-import { join as join29, relative as relative6 } from "path";
+import { join as join30, relative as relative6 } from "path";
 var WizardPrompt = class {
   /**
    * Generic prompt helper - wraps readline.question in a Promise
@@ -96538,7 +96560,7 @@ var WizardSuggestions = class _WizardSuggestions {
     const suggestions = [];
     const commonDirs = ["src", "lib", "app", "packages", "api"];
     for (const dir of commonDirs) {
-      const dirPath = join29(cwd, dir);
+      const dirPath = join30(cwd, dir);
       if (existsSync29(dirPath) && statSync8(dirPath).isDirectory()) {
         suggestions.push(dir);
       }
@@ -96557,7 +96579,7 @@ var WizardSuggestions = class _WizardSuggestions {
       ".nyc_output"
     ];
     for (const loc of coverageLocations) {
-      const locPath = join29(cwd, loc);
+      const locPath = join30(cwd, loc);
       if (existsSync29(locPath)) {
         suggestions.push(loc);
       }
@@ -96580,7 +96602,7 @@ var WizardSuggestions = class _WizardSuggestions {
       "Dockerfile"
     ];
     for (const file of securityFiles) {
-      const filePath = join29(cwd, file);
+      const filePath = join30(cwd, file);
       if (existsSync29(filePath)) {
         suggestions.push(file);
       }
@@ -96594,13 +96616,13 @@ var WizardSuggestions = class _WizardSuggestions {
     const suggestions = [];
     const commonDirs = ["src", "lib", "app", "packages"];
     for (const dir of commonDirs) {
-      const dirPath = join29(cwd, dir);
+      const dirPath = join30(cwd, dir);
       if (existsSync29(dirPath) && statSync8(dirPath).isDirectory()) {
         suggestions.push(`${dir}/**/*.ts`);
         suggestions.push(dir);
       }
     }
-    if (existsSync29(join29(cwd, "src"))) {
+    if (existsSync29(join30(cwd, "src"))) {
       suggestions.push("src/services/**/*.ts");
       suggestions.push("src/utils/**/*.ts");
       suggestions.push("src/components/**/*.tsx");
@@ -96612,10 +96634,10 @@ var WizardSuggestions = class _WizardSuggestions {
    */
   static checkPatternsExist(cwd) {
     const patternLocations = [
-      join29(cwd, ".agentic-qe", "patterns"),
-      join29(cwd, ".agentic-qe", "memory.db"),
-      join29(cwd, ".aqe", "patterns"),
-      join29(cwd, "data", "patterns")
+      join30(cwd, ".agentic-qe", "patterns"),
+      join30(cwd, ".agentic-qe", "memory.db"),
+      join30(cwd, ".aqe", "patterns"),
+      join30(cwd, "data", "patterns")
     ];
     return patternLocations.some((loc) => existsSync29(loc));
   }
@@ -99978,7 +100000,7 @@ import chalk20 from "chalk";
 // src/init/fleet-integration.ts
 import chalk19 from "chalk";
 import { existsSync as existsSync31 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var FleetInitEnhancer = class {
   projectRoot;
   options;
@@ -100090,7 +100112,7 @@ var FleetInitEnhancer = class {
       });
       console.log(chalk19.gray(`  Indexing ${files.length} files...`));
       const result = await kgService.index({
-        paths: files.map((f) => join31(this.projectRoot, f)),
+        paths: files.map((f) => join32(this.projectRoot, f)),
         incremental: false,
         includeTests: true
       });
@@ -100125,7 +100147,7 @@ var FleetInitEnhancer = class {
    * Checks the memory database for code-intelligence:kg namespace entries
    */
   async hasCodeIntelligenceIndex() {
-    const dbPath = join31(this.projectRoot, ".agentic-qe", "memory.db");
+    const dbPath = join32(this.projectRoot, ".agentic-qe", "memory.db");
     if (!existsSync31(dbPath)) {
       return false;
     }
@@ -100146,7 +100168,7 @@ var FleetInitEnhancer = class {
    * Get count of knowledge graph entries
    */
   async getKGEntryCount() {
-    const dbPath = join31(this.projectRoot, ".agentic-qe", "memory.db");
+    const dbPath = join32(this.projectRoot, ".agentic-qe", "memory.db");
     try {
       const Database4 = (await import("better-sqlite3")).default;
       const db = new Database4(dbPath);
@@ -101720,9 +101742,11 @@ import ora2 from "ora";
 // src/sync/interfaces.ts
 var DEFAULT_SYNC_CONFIG = {
   local: {
-    // Paths are relative to project root (parent of v3/)
-    v3MemoryDb: "../v3/.agentic-qe/memory.db",
+    // PRIMARY: Root database (consolidated, MCP-active)
+    v3MemoryDb: "../.agentic-qe/memory.db",
+    // Now points to root (consolidated)
     rootMemoryDb: "../.agentic-qe/memory.db",
+    // Same as above
     claudeFlowMemory: "../.claude-flow/memory/store.json",
     claudeFlowDaemon: "../.claude-flow/daemon-state.json",
     claudeFlowMetrics: "../.claude-flow/metrics/",
@@ -101744,28 +101768,21 @@ var DEFAULT_SYNC_CONFIG = {
     batchSize: 1e3,
     conflictResolution: "newer-wins",
     sourcePriority: {
-      v3Memory: 1,
+      rootMemory: 1,
+      // Root is now PRIMARY (consolidated)
       claudeFlowMemory: 2,
-      rootMemory: 3,
-      intelligenceJson: 4,
-      legacy: 5
+      intelligenceJson: 3,
+      legacy: 4
     },
     sources: [
-      // V3 Memory - PRIMARY
+      // ============================================================
+      // ROOT Memory - PRIMARY (Consolidated from V3 + Historical)
+      // All tables now in single database: .agentic-qe/memory.db
+      // ============================================================
       {
-        name: "v3-qe-patterns",
+        name: "root-sona-patterns",
         type: "sqlite",
-        path: "../v3/.agentic-qe/memory.db",
-        targetTable: "aqe.qe_patterns",
-        priority: "high",
-        mode: "incremental",
-        query: "SELECT * FROM qe_patterns",
-        enabled: true
-      },
-      {
-        name: "v3-sona-patterns",
-        type: "sqlite",
-        path: "../v3/.agentic-qe/memory.db",
+        path: "../.agentic-qe/memory.db",
         targetTable: "aqe.sona_patterns",
         priority: "high",
         mode: "incremental",
@@ -101773,32 +101790,21 @@ var DEFAULT_SYNC_CONFIG = {
         enabled: true
       },
       {
-        name: "v3-goap-actions",
+        name: "root-goap-actions",
         type: "sqlite",
-        path: "../v3/.agentic-qe/memory.db",
+        path: "../.agentic-qe/memory.db",
         targetTable: "aqe.goap_actions",
         priority: "high",
         mode: "incremental",
         query: "SELECT * FROM goap_actions",
         enabled: true
       },
-      // Claude-Flow Memory
-      {
-        name: "claude-flow-memory",
-        type: "json",
-        path: "../.claude-flow/memory/store.json",
-        targetTable: "aqe.claude_flow_memory",
-        priority: "high",
-        mode: "full",
-        enabled: true
-      },
-      // Root Memory - HISTORICAL
       {
         name: "root-memory-entries",
         type: "sqlite",
         path: "../.agentic-qe/memory.db",
         targetTable: "aqe.memory_entries",
-        priority: "medium",
+        priority: "high",
         mode: "incremental",
         query: "SELECT * FROM memory_entries",
         enabled: true
@@ -101808,21 +101814,11 @@ var DEFAULT_SYNC_CONFIG = {
         type: "sqlite",
         path: "../.agentic-qe/memory.db",
         targetTable: "aqe.learning_experiences",
-        priority: "medium",
+        priority: "high",
         mode: "append",
         query: "SELECT * FROM learning_experiences",
         enabled: true
       },
-      {
-        name: "root-goap-actions",
-        type: "sqlite",
-        path: "../.agentic-qe/memory.db",
-        targetTable: "aqe.goap_actions",
-        priority: "medium",
-        mode: "incremental",
-        query: "SELECT * FROM goap_actions",
-        enabled: true
-      },
       {
         name: "root-patterns",
         type: "sqlite",
@@ -101843,13 +101839,23 @@ var DEFAULT_SYNC_CONFIG = {
         query: "SELECT * FROM events",
         enabled: true
       },
-      // Intelligence JSON
+      // Claude-Flow Memory (JSON)
+      {
+        name: "claude-flow-memory",
+        type: "json",
+        path: "../.claude-flow/memory/store.json",
+        targetTable: "aqe.claude_flow_memory",
+        priority: "medium",
+        mode: "full",
+        enabled: true
+      },
+      // Intelligence JSON (Q-Learning)
       {
         name: "intelligence-qlearning",
         type: "json",
         path: "../v3/.ruvector/intelligence.json",
         targetTable: "aqe.qlearning_patterns",
-        priority: "medium",
+        priority: "low",
         mode: "full",
         jsonPath: "$.qvalues",
         enabled: true
@@ -107735,7 +107741,7 @@ async function createCoherenceService(wasmLoader2, config, logger) {
 // src/integrations/coherence/wasm-loader.ts
 import { createRequire as createRequire4 } from "node:module";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { dirname as dirname10, join as join33 } from "node:path";
+import { dirname as dirname10, join as join34 } from "node:path";
 import { readFileSync as readFileSync23, existsSync as existsSync34 } from "node:fs";
 var FALLBACK_RETRY_DELAYS_MS = [1e3, 2e3, 4e3];
 var WasmLoader = class {
@@ -107994,12 +108000,12 @@ var WasmLoader = class {
         (() => {
           try {
             const modulePath = require5.resolve("prime-radiant-advanced-wasm");
-            return join33(dirname10(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
+            return join34(dirname10(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
           } catch {
             return null;
           }
         })(),
-        join33(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
+        join34(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
       ].filter((p) => p !== null);
       for (const path16 of wasmPaths) {
         if (existsSync34(path16)) {
@@ -108253,15 +108259,15 @@ var WasmLoader = class {
       (() => {
         try {
           const modulePath = require5.resolve("prime-radiant-advanced-wasm");
-          return join33(dirname10(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
+          return join34(dirname10(modulePath), "prime_radiant_advanced_wasm_bg.wasm");
         } catch {
           return null;
         }
       })(),
       // Direct node_modules path from current file
-      join33(dirname10(fileURLToPath4(import.meta.url)), "../../../../node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm"),
+      join34(dirname10(fileURLToPath4(import.meta.url)), "../../../../node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm"),
       // Workspace root
-      join33(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
+      join34(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
     ].filter((p) => p !== null);
     let wasmPath = null;
     for (const path16 of wasmPaths) {
@@ -109195,7 +109201,7 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command13();
-var VERSION = true ? "3.3.4" : "0.0.0-dev";
+var VERSION = true ? "3.3.5" : "0.0.0-dev";
 program.name("aqe").description("Agentic QE - Domain-Driven Quality Engineering").version(VERSION);
 var registry = createCommandRegistry(context, cleanupAndExit, ensureInitialized);
 registry.registerAll(program);