agentic-qe 3.3.4 → 3.4.0

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
         };
@@ -2220,7 +2220,7 @@ function createMultiModelProviders(models = getRecommendedSecurityModels(), base
     })
   );
 }
-var MODEL_COSTS, DEFAULT_CONFIG3, OpenRouterModelProvider;
+var MODEL_COSTS, DEFAULT_CONFIG4, OpenRouterModelProvider;
 var init_openrouter_provider = __esm({
   "src/coordination/consensus/providers/openrouter-provider.ts"() {
     "use strict";
@@ -2254,7 +2254,7 @@ var init_openrouter_provider = __esm({
       // Cohere models
       "cohere/command-r-plus": { input: 2.5, output: 10, tier: "standard" }
     };
-    DEFAULT_CONFIG3 = {
+    DEFAULT_CONFIG4 = {
       defaultModel: "anthropic/claude-3.5-sonnet",
       defaultTimeout: 12e4,
       // 2 minutes
@@ -2281,7 +2281,7 @@ var init_openrouter_provider = __esm({
           );
         }
         this.config = {
-          ...DEFAULT_CONFIG3,
+          ...DEFAULT_CONFIG4,
           ...config,
           apiKey
         };
@@ -2525,13 +2525,13 @@ async function isOllamaAvailable(baseUrl = "http://localhost:11434") {
     return false;
   }
 }
-var DEFAULT_CONFIG4, OllamaModelProvider;
+var DEFAULT_CONFIG5, OllamaModelProvider;
 var init_ollama_provider = __esm({
   "src/coordination/consensus/providers/ollama-provider.ts"() {
     "use strict";
     init_model_provider();
     init_constants2();
-    DEFAULT_CONFIG4 = {
+    DEFAULT_CONFIG5 = {
       baseUrl: OLLAMA_CONSTANTS.DEFAULT_BASE_URL,
       defaultModel: "llama3.1",
       defaultTimeout: CONSENSUS_CONSTANTS.OLLAMA_TIMEOUT_MS,
@@ -2553,7 +2553,7 @@ var init_ollama_provider = __esm({
       constructor(config = {}) {
         super();
         this.config = {
-          ...DEFAULT_CONFIG4,
+          ...DEFAULT_CONFIG5,
           ...config
         };
         this.id = `ollama-${this.config.defaultModel.replace(/[^a-z0-9]/gi, "-")}`;
@@ -6359,7 +6359,7 @@ var knowledge_graph_exports = {};
 __export(knowledge_graph_exports, {
   KnowledgeGraphService: () => KnowledgeGraphService
 });
-var DEFAULT_CONFIG25, KnowledgeGraphService;
+var DEFAULT_CONFIG26, KnowledgeGraphService;
 var init_knowledge_graph = __esm({
   "src/domains/code-intelligence/services/knowledge-graph.ts"() {
     "use strict";
@@ -6367,7 +6367,7 @@ var init_knowledge_graph = __esm({
     init_parsers();
     init_io();
     init_embeddings();
-    DEFAULT_CONFIG25 = {
+    DEFAULT_CONFIG26 = {
       maxNodes: 1e5,
       maxEdgesPerNode: 500,
       namespace: "code-intelligence:kg",
@@ -6395,7 +6395,7 @@ var init_knowledge_graph = __esm({
        * @param config - Optional configuration overrides
        */
       constructor(dependenciesOrMemory, config = {}) {
-        this.config = { ...DEFAULT_CONFIG25, ...config };
+        this.config = { ...DEFAULT_CONFIG26, ...config };
         if (this.isKnowledgeGraphDependencies(dependenciesOrMemory)) {
           this.memory = dependenciesOrMemory.memory;
           this.llmRouter = dependenciesOrMemory.llmRouter;
@@ -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,
@@ -8459,7 +8459,13 @@ var DefaultPluginLoader = class {
     }
     const factory = this.factories.get(domain);
     if (!factory) {
-      throw new Error(`No factory registered for domain: ${domain}`);
+      const registeredDomains = Array.from(this.factories.keys());
+      throw new Error(
+        `No factory registered for domain: ${domain}
+This usually means the domain is not enabled in your config.
+Registered domains: ${registeredDomains.join(", ")}
+Fix: Add '${domain}' to domains.enabled in .agentic-qe/config.yaml, or run 'aqe init --auto-migrate' to enable all domains.`
+      );
     }
     const promise = this.loadPlugin(domain, factory);
     this.loading.set(domain, promise);
@@ -8624,15 +8630,896 @@ function isMigrationApplied(db) {
 
 // src/kernel/unified-memory.ts
 init_constants();
+
+// src/memory/crdt/lww-register.ts
+function createLWWRegister(nodeId, initialValue, initialTimestamp) {
+  let state2 = {
+    value: initialValue,
+    timestamp: initialTimestamp ?? (initialValue !== void 0 ? Date.now() : 0),
+    nodeId: initialValue !== void 0 ? nodeId : "",
+    version: initialValue !== void 0 ? 1 : 0,
+    lastUpdated: Date.now()
+  };
+  function compareTimestamps(timestampA, nodeIdA, timestampB, nodeIdB) {
+    if (timestampA !== timestampB) {
+      return timestampA - timestampB;
+    }
+    return nodeIdA.localeCompare(nodeIdB);
+  }
+  return {
+    get() {
+      return state2.value;
+    },
+    set(value, timestamp) {
+      const ts4 = timestamp ?? Date.now();
+      if (state2.timestamp === 0 || compareTimestamps(ts4, nodeId, state2.timestamp, state2.nodeId) > 0) {
+        state2 = {
+          value,
+          timestamp: ts4,
+          nodeId,
+          version: state2.version + 1,
+          lastUpdated: Date.now()
+        };
+      }
+    },
+    merge(other) {
+      const otherState = other.getState();
+      this.applyState(otherState);
+    },
+    getState() {
+      return {
+        value: state2.value,
+        timestamp: state2.timestamp,
+        nodeId: state2.nodeId,
+        version: state2.version,
+        lastUpdated: state2.lastUpdated
+      };
+    },
+    applyState(incoming) {
+      if (state2.timestamp === 0 || compareTimestamps(
+        incoming.timestamp,
+        incoming.nodeId,
+        state2.timestamp,
+        state2.nodeId
+      ) > 0) {
+        state2 = {
+          value: incoming.value,
+          timestamp: incoming.timestamp,
+          nodeId: incoming.nodeId,
+          version: Math.max(state2.version, incoming.version) + 1,
+          lastUpdated: Date.now()
+        };
+      }
+    },
+    getNodeId() {
+      return nodeId;
+    },
+    getTimestamp() {
+      return state2.timestamp;
+    }
+  };
+}
+function createLWWRegisterFromState(nodeId, existingState) {
+  const register = createLWWRegister(nodeId);
+  register.applyState(existingState);
+  return register;
+}
+
+// src/memory/crdt/g-counter.ts
+function createGCounter(nodeId) {
+  const state2 = {
+    counts: {},
+    version: 0,
+    lastUpdated: Date.now()
+  };
+  state2.counts[nodeId] = 0;
+  return {
+    get() {
+      return Object.values(state2.counts).reduce((sum, count) => sum + count, 0);
+    },
+    increment(n = 1) {
+      if (n < 0) {
+        throw new Error("G-Counter can only increment by positive values");
+      }
+      if (n === 0) {
+        return;
+      }
+      state2.counts[nodeId] = (state2.counts[nodeId] || 0) + n;
+      state2.version++;
+      state2.lastUpdated = Date.now();
+    },
+    merge(other) {
+      const otherState = other.getState();
+      this.applyState(otherState);
+    },
+    getState() {
+      return {
+        counts: { ...state2.counts },
+        version: state2.version,
+        lastUpdated: state2.lastUpdated
+      };
+    },
+    applyState(incoming) {
+      let changed = false;
+      for (const [incomingNodeId, incomingCount] of Object.entries(incoming.counts)) {
+        const currentCount = state2.counts[incomingNodeId] || 0;
+        if (incomingCount > currentCount) {
+          state2.counts[incomingNodeId] = incomingCount;
+          changed = true;
+        }
+      }
+      if (changed) {
+        state2.version = Math.max(state2.version, incoming.version) + 1;
+        state2.lastUpdated = Date.now();
+      }
+    },
+    getNodeId() {
+      return nodeId;
+    },
+    getLocalCount() {
+      return state2.counts[nodeId] || 0;
+    }
+  };
+}
+function createGCounterFromState(nodeId, existingState) {
+  const counter = createGCounter(nodeId);
+  counter.applyState(existingState);
+  return counter;
+}
+
+// src/memory/crdt/pn-counter.ts
+function createPNCounter(nodeId) {
+  const positive = createGCounter(nodeId);
+  const negative = createGCounter(nodeId);
+  let version = 0;
+  let lastUpdated = Date.now();
+  return {
+    get() {
+      return positive.get() - negative.get();
+    },
+    increment(n = 1) {
+      if (n < 0) {
+        throw new Error("Use decrement() for negative values");
+      }
+      if (n === 0) {
+        return;
+      }
+      positive.increment(n);
+      version++;
+      lastUpdated = Date.now();
+    },
+    decrement(n = 1) {
+      if (n < 0) {
+        throw new Error("Use increment() for negative values");
+      }
+      if (n === 0) {
+        return;
+      }
+      negative.increment(n);
+      version++;
+      lastUpdated = Date.now();
+    },
+    merge(other) {
+      const otherState = other.getState();
+      this.applyState(otherState);
+    },
+    getState() {
+      return {
+        positive: positive.getState(),
+        negative: negative.getState(),
+        version,
+        lastUpdated
+      };
+    },
+    applyState(incoming) {
+      const oldValue = this.get();
+      positive.applyState(incoming.positive);
+      negative.applyState(incoming.negative);
+      const newValue = this.get();
+      if (oldValue !== newValue) {
+        version = Math.max(version, incoming.version) + 1;
+        lastUpdated = Date.now();
+      }
+    },
+    getNodeId() {
+      return nodeId;
+    }
+  };
+}
+function createPNCounterFromState(nodeId, existingState) {
+  const counter = createPNCounter(nodeId);
+  counter.applyState(existingState);
+  return counter;
+}
+
+// src/memory/crdt/or-set.ts
+function generateTag(nodeId, counter) {
+  return `${nodeId}:${Date.now()}:${counter}`;
+}
+function serializeElement(element) {
+  if (typeof element === "string") {
+    return `s:${element}`;
+  }
+  if (typeof element === "number") {
+    return `n:${element}`;
+  }
+  if (typeof element === "boolean") {
+    return `b:${element}`;
+  }
+  return `j:${JSON.stringify(element)}`;
+}
+function deserializeElement(key) {
+  const type = key.substring(0, 2);
+  const value = key.substring(2);
+  switch (type) {
+    case "s:":
+      return value;
+    case "n:":
+      return Number(value);
+    case "b:":
+      return value === "true";
+    case "j:":
+      return JSON.parse(value);
+    default:
+      throw new Error(`Unknown serialization type: ${type}`);
+  }
+}
+function createORSet(nodeId) {
+  const elements = /* @__PURE__ */ new Map();
+  const tombstones = /* @__PURE__ */ new Map();
+  let version = 0;
+  let lastUpdated = Date.now();
+  let tagCounter = 0;
+  function hasActiveTags(serialized) {
+    const tags = elements.get(serialized);
+    if (!tags || tags.size === 0) {
+      return false;
+    }
+    const tombstoneTags = tombstones.get(serialized);
+    if (!tombstoneTags || tombstoneTags.size === 0) {
+      return true;
+    }
+    for (const tag of tags) {
+      if (!tombstoneTags.has(tag)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function getActiveTags(serialized) {
+    const tags = elements.get(serialized);
+    if (!tags) {
+      return /* @__PURE__ */ new Set();
+    }
+    const tombstoneTags = tombstones.get(serialized) || /* @__PURE__ */ new Set();
+    const active = /* @__PURE__ */ new Set();
+    for (const tag of tags) {
+      if (!tombstoneTags.has(tag)) {
+        active.add(tag);
+      }
+    }
+    return active;
+  }
+  return {
+    has(element) {
+      const serialized = serializeElement(element);
+      return hasActiveTags(serialized);
+    },
+    values() {
+      const result = [];
+      for (const [serialized] of elements) {
+        if (hasActiveTags(serialized)) {
+          result.push(deserializeElement(serialized));
+        }
+      }
+      return result;
+    },
+    size() {
+      let count = 0;
+      for (const [serialized] of elements) {
+        if (hasActiveTags(serialized)) {
+          count++;
+        }
+      }
+      return count;
+    },
+    add(element) {
+      const serialized = serializeElement(element);
+      const tag = generateTag(nodeId, tagCounter++);
+      if (!elements.has(serialized)) {
+        elements.set(serialized, /* @__PURE__ */ new Set());
+      }
+      elements.get(serialized).add(tag);
+      version++;
+      lastUpdated = Date.now();
+    },
+    remove(element) {
+      const serialized = serializeElement(element);
+      const tags = elements.get(serialized);
+      if (!tags || tags.size === 0) {
+        return;
+      }
+      if (!tombstones.has(serialized)) {
+        tombstones.set(serialized, /* @__PURE__ */ new Set());
+      }
+      const tombstoneTags = tombstones.get(serialized);
+      for (const tag of tags) {
+        tombstoneTags.add(tag);
+      }
+      version++;
+      lastUpdated = Date.now();
+    },
+    merge(other) {
+      const otherState = other.getState();
+      this.applyState(otherState);
+    },
+    getState() {
+      const elementsObj = {};
+      for (const [key, tags] of elements) {
+        elementsObj[key] = Array.from(tags);
+      }
+      const tombstonesObj = {};
+      for (const [key, tags] of tombstones) {
+        if (tags.size > 0) {
+          tombstonesObj[key] = Array.from(tags);
+        }
+      }
+      return {
+        elements: elementsObj,
+        tombstones: tombstonesObj,
+        version,
+        lastUpdated
+      };
+    },
+    applyState(incoming) {
+      let changed = false;
+      for (const [serialized, incomingTags] of Object.entries(incoming.elements)) {
+        if (!elements.has(serialized)) {
+          elements.set(serialized, /* @__PURE__ */ new Set());
+        }
+        const localTags = elements.get(serialized);
+        for (const tag of incomingTags) {
+          if (!localTags.has(tag)) {
+            localTags.add(tag);
+            changed = true;
+          }
+        }
+      }
+      for (const [serialized, incomingTombstones] of Object.entries(
+        incoming.tombstones
+      )) {
+        if (!tombstones.has(serialized)) {
+          tombstones.set(serialized, /* @__PURE__ */ new Set());
+        }
+        const localTombstones = tombstones.get(serialized);
+        for (const tag of incomingTombstones) {
+          if (!localTombstones.has(tag)) {
+            localTombstones.add(tag);
+            changed = true;
+          }
+        }
+      }
+      if (changed) {
+        version = Math.max(version, incoming.version) + 1;
+        lastUpdated = Date.now();
+      }
+    },
+    getNodeId() {
+      return nodeId;
+    },
+    clear() {
+      for (const [serialized, tags] of elements) {
+        if (!tombstones.has(serialized)) {
+          tombstones.set(serialized, /* @__PURE__ */ new Set());
+        }
+        const tombstoneTags = tombstones.get(serialized);
+        for (const tag of tags) {
+          tombstoneTags.add(tag);
+        }
+      }
+      version++;
+      lastUpdated = Date.now();
+    }
+  };
+}
+function createORSetFromState(nodeId, existingState) {
+  const set = createORSet(nodeId);
+  set.applyState(existingState);
+  return set;
+}
+
+// src/memory/crdt/crdt-store.ts
+var DEFAULT_CONFIG = {
+  nodeId: "default-node",
+  enableDeltaTracking: true,
+  maxDeltaHistory: 100
+};
+function createCRDTStore(config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const { nodeId, enableDeltaTracking, maxDeltaHistory } = cfg;
+  const registers = /* @__PURE__ */ new Map();
+  const gCounters = /* @__PURE__ */ new Map();
+  const pnCounters = /* @__PURE__ */ new Map();
+  const sets = /* @__PURE__ */ new Map();
+  let version = 0;
+  const deltaHistory = [];
+  const changeListeners = /* @__PURE__ */ new Set();
+  const pendingChanges = {
+    registers: /* @__PURE__ */ new Set(),
+    gCounters: /* @__PURE__ */ new Set(),
+    pnCounters: /* @__PURE__ */ new Set(),
+    sets: /* @__PURE__ */ new Set()
+  };
+  function emitChange(key, type, operation) {
+    const event = {
+      key,
+      type,
+      operation,
+      timestamp: Date.now(),
+      nodeId
+    };
+    for (const listener of changeListeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.error("[CRDTStore] Error in change listener:", error);
+      }
+    }
+  }
+  function recordChange(type, key) {
+    version++;
+    if (enableDeltaTracking) {
+      pendingChanges[type].add(key);
+    }
+  }
+  function flushDelta() {
+    if (!enableDeltaTracking) return;
+    const hasChanges = pendingChanges.registers.size > 0 || pendingChanges.gCounters.size > 0 || pendingChanges.pnCounters.size > 0 || pendingChanges.sets.size > 0;
+    if (!hasChanges) return;
+    const delta = {
+      fromVersion: deltaHistory.length > 0 ? deltaHistory[deltaHistory.length - 1].toVersion : 0,
+      toVersion: version,
+      timestamp: Date.now(),
+      nodeId
+    };
+    if (pendingChanges.registers.size > 0) {
+      delta.registers = {};
+      for (const key of pendingChanges.registers) {
+        const reg = registers.get(key);
+        if (reg) {
+          delta.registers[key] = reg.getState();
+        }
+      }
+      pendingChanges.registers.clear();
+    }
+    if (pendingChanges.gCounters.size > 0) {
+      delta.gCounters = {};
+      for (const key of pendingChanges.gCounters) {
+        const counter = gCounters.get(key);
+        if (counter) {
+          delta.gCounters[key] = counter.getState();
+        }
+      }
+      pendingChanges.gCounters.clear();
+    }
+    if (pendingChanges.pnCounters.size > 0) {
+      delta.pnCounters = {};
+      for (const key of pendingChanges.pnCounters) {
+        const counter = pnCounters.get(key);
+        if (counter) {
+          delta.pnCounters[key] = counter.getState();
+        }
+      }
+      pendingChanges.pnCounters.clear();
+    }
+    if (pendingChanges.sets.size > 0) {
+      delta.sets = {};
+      for (const key of pendingChanges.sets) {
+        const set = sets.get(key);
+        if (set) {
+          delta.sets[key] = set.getState();
+        }
+      }
+      pendingChanges.sets.clear();
+    }
+    deltaHistory.push(delta);
+    while (deltaHistory.length > maxDeltaHistory) {
+      deltaHistory.shift();
+    }
+  }
+  const store = {
+    // -------------------------------------------------------------------------
+    // Register Management
+    // -------------------------------------------------------------------------
+    getRegister(key) {
+      if (!registers.has(key)) {
+        registers.set(key, createLWWRegister(nodeId));
+      }
+      return registers.get(key);
+    },
+    setRegister(key, value) {
+      const register = store.getRegister(key);
+      register.set(value);
+      recordChange("registers", key);
+      emitChange(key, "lww-register", "set");
+    },
+    hasRegister(key) {
+      return registers.has(key);
+    },
+    deleteRegister(key) {
+      const deleted = registers.delete(key);
+      if (deleted) {
+        recordChange("registers", key);
+      }
+      return deleted;
+    },
+    // -------------------------------------------------------------------------
+    // G-Counter Management
+    // -------------------------------------------------------------------------
+    getGCounter(key) {
+      if (!gCounters.has(key)) {
+        gCounters.set(key, createGCounter(nodeId));
+      }
+      return gCounters.get(key);
+    },
+    incrementGCounter(key, n) {
+      const counter = store.getGCounter(key);
+      counter.increment(n);
+      recordChange("gCounters", key);
+      emitChange(key, "g-counter", "increment");
+    },
+    hasGCounter(key) {
+      return gCounters.has(key);
+    },
+    deleteGCounter(key) {
+      const deleted = gCounters.delete(key);
+      if (deleted) {
+        recordChange("gCounters", key);
+      }
+      return deleted;
+    },
+    // -------------------------------------------------------------------------
+    // PN-Counter Management
+    // -------------------------------------------------------------------------
+    getCounter(key) {
+      if (!pnCounters.has(key)) {
+        pnCounters.set(key, createPNCounter(nodeId));
+      }
+      return pnCounters.get(key);
+    },
+    incrementCounter(key, n) {
+      const counter = store.getCounter(key);
+      counter.increment(n);
+      recordChange("pnCounters", key);
+      emitChange(key, "pn-counter", "increment");
+    },
+    decrementCounter(key, n) {
+      const counter = store.getCounter(key);
+      counter.decrement(n);
+      recordChange("pnCounters", key);
+      emitChange(key, "pn-counter", "decrement");
+    },
+    hasCounter(key) {
+      return pnCounters.has(key);
+    },
+    deleteCounter(key) {
+      const deleted = pnCounters.delete(key);
+      if (deleted) {
+        recordChange("pnCounters", key);
+      }
+      return deleted;
+    },
+    // -------------------------------------------------------------------------
+    // OR-Set Management
+    // -------------------------------------------------------------------------
+    getSet(key) {
+      if (!sets.has(key)) {
+        sets.set(key, createORSet(nodeId));
+      }
+      return sets.get(key);
+    },
+    addToSet(key, element) {
+      const set = store.getSet(key);
+      set.add(element);
+      recordChange("sets", key);
+      emitChange(key, "or-set", "add");
+    },
+    removeFromSet(key, element) {
+      const set = store.getSet(key);
+      set.remove(element);
+      recordChange("sets", key);
+      emitChange(key, "or-set", "remove");
+    },
+    hasSet(key) {
+      return sets.has(key);
+    },
+    deleteSet(key) {
+      const deleted = sets.delete(key);
+      if (deleted) {
+        recordChange("sets", key);
+      }
+      return deleted;
+    },
+    // -------------------------------------------------------------------------
+    // Store Operations
+    // -------------------------------------------------------------------------
+    merge(other) {
+      const otherState = other.getState();
+      store.applyState(otherState);
+    },
+    getState() {
+      flushDelta();
+      const state2 = {
+        version,
+        timestamp: Date.now(),
+        nodeId,
+        registers: {},
+        gCounters: {},
+        pnCounters: {},
+        sets: {}
+      };
+      for (const [key, reg] of registers) {
+        state2.registers[key] = reg.getState();
+      }
+      for (const [key, counter] of gCounters) {
+        state2.gCounters[key] = counter.getState();
+      }
+      for (const [key, counter] of pnCounters) {
+        state2.pnCounters[key] = counter.getState();
+      }
+      for (const [key, set] of sets) {
+        state2.sets[key] = set.getState();
+      }
+      return state2;
+    },
+    applyState(incoming) {
+      for (const [key, state2] of Object.entries(incoming.registers)) {
+        if (!registers.has(key)) {
+          registers.set(
+            key,
+            createLWWRegisterFromState(nodeId, state2)
+          );
+        } else {
+          registers.get(key).applyState(state2);
+        }
+        recordChange("registers", key);
+        emitChange(key, "lww-register", "merge");
+      }
+      for (const [key, state2] of Object.entries(incoming.gCounters)) {
+        if (!gCounters.has(key)) {
+          gCounters.set(key, createGCounterFromState(nodeId, state2));
+        } else {
+          gCounters.get(key).applyState(state2);
+        }
+        recordChange("gCounters", key);
+        emitChange(key, "g-counter", "merge");
+      }
+      for (const [key, state2] of Object.entries(incoming.pnCounters)) {
+        if (!pnCounters.has(key)) {
+          pnCounters.set(key, createPNCounterFromState(nodeId, state2));
+        } else {
+          pnCounters.get(key).applyState(state2);
+        }
+        recordChange("pnCounters", key);
+        emitChange(key, "pn-counter", "merge");
+      }
+      for (const [key, state2] of Object.entries(incoming.sets)) {
+        if (!sets.has(key)) {
+          sets.set(
+            key,
+            createORSetFromState(nodeId, state2)
+          );
+        } else {
+          sets.get(key).applyState(state2);
+        }
+        recordChange("sets", key);
+        emitChange(key, "or-set", "merge");
+      }
+      version = Math.max(version, incoming.version) + 1;
+    },
+    getDelta(sinceVersion) {
+      flushDelta();
+      if (deltaHistory.length === 0) {
+        if (sinceVersion >= version) {
+          return null;
+        }
+        return null;
+      }
+      const relevantDeltas = deltaHistory.filter((d) => d.toVersion > sinceVersion);
+      if (relevantDeltas.length === 0) {
+        return null;
+        return null;
+      }
+      const mergedDelta = {
+        fromVersion: sinceVersion,
+        toVersion: version,
+        timestamp: Date.now(),
+        nodeId,
+        registers: {},
+        gCounters: {},
+        pnCounters: {},
+        sets: {}
+      };
+      for (const delta of relevantDeltas) {
+        if (delta.registers) {
+          Object.assign(mergedDelta.registers, delta.registers);
+        }
+        if (delta.gCounters) {
+          Object.assign(mergedDelta.gCounters, delta.gCounters);
+        }
+        if (delta.pnCounters) {
+          Object.assign(mergedDelta.pnCounters, delta.pnCounters);
+        }
+        if (delta.sets) {
+          Object.assign(mergedDelta.sets, delta.sets);
+        }
+      }
+      if (Object.keys(mergedDelta.registers).length === 0) {
+        delete mergedDelta.registers;
+      }
+      if (Object.keys(mergedDelta.gCounters).length === 0) {
+        delete mergedDelta.gCounters;
+      }
+      if (Object.keys(mergedDelta.pnCounters).length === 0) {
+        delete mergedDelta.pnCounters;
+      }
+      if (Object.keys(mergedDelta.sets).length === 0) {
+        delete mergedDelta.sets;
+      }
+      return mergedDelta;
+    },
+    applyDelta(delta) {
+      if (delta.registers) {
+        for (const [key, state2] of Object.entries(delta.registers)) {
+          if (!registers.has(key)) {
+            registers.set(
+              key,
+              createLWWRegisterFromState(nodeId, state2)
+            );
+          } else {
+            registers.get(key).applyState(state2);
+          }
+          recordChange("registers", key);
+          emitChange(key, "lww-register", "merge");
+        }
+      }
+      if (delta.gCounters) {
+        for (const [key, state2] of Object.entries(delta.gCounters)) {
+          if (!gCounters.has(key)) {
+            gCounters.set(key, createGCounterFromState(nodeId, state2));
+          } else {
+            gCounters.get(key).applyState(state2);
+          }
+          recordChange("gCounters", key);
+          emitChange(key, "g-counter", "merge");
+        }
+      }
+      if (delta.pnCounters) {
+        for (const [key, state2] of Object.entries(delta.pnCounters)) {
+          if (!pnCounters.has(key)) {
+            pnCounters.set(key, createPNCounterFromState(nodeId, state2));
+          } else {
+            pnCounters.get(key).applyState(state2);
+          }
+          recordChange("pnCounters", key);
+          emitChange(key, "pn-counter", "merge");
+        }
+      }
+      if (delta.sets) {
+        for (const [key, state2] of Object.entries(delta.sets)) {
+          if (!sets.has(key)) {
+            sets.set(
+              key,
+              createORSetFromState(nodeId, state2)
+            );
+          } else {
+            sets.get(key).applyState(state2);
+          }
+          recordChange("sets", key);
+          emitChange(key, "or-set", "merge");
+        }
+      }
+      version = Math.max(version, delta.toVersion) + 1;
+    },
+    getVersion() {
+      return version;
+    },
+    getNodeId() {
+      return nodeId;
+    },
+    // -------------------------------------------------------------------------
+    // Events
+    // -------------------------------------------------------------------------
+    on(event, callback) {
+      if (event === "change") {
+        changeListeners.add(callback);
+        return () => {
+          changeListeners.delete(callback);
+        };
+      }
+      throw new Error(`Unknown event type: ${event}`);
+    },
+    removeAllListeners() {
+      changeListeners.clear();
+    },
+    // -------------------------------------------------------------------------
+    // Utilities
+    // -------------------------------------------------------------------------
+    keys(type) {
+      const allKeys = [];
+      if (!type || type === "lww-register") {
+        allKeys.push(...Array.from(registers.keys()));
+      }
+      if (!type || type === "g-counter") {
+        allKeys.push(...Array.from(gCounters.keys()));
+      }
+      if (!type || type === "pn-counter") {
+        allKeys.push(...Array.from(pnCounters.keys()));
+      }
+      if (!type || type === "or-set") {
+        allKeys.push(...Array.from(sets.keys()));
+      }
+      return allKeys;
+    },
+    clear() {
+      registers.clear();
+      gCounters.clear();
+      pnCounters.clear();
+      sets.clear();
+      deltaHistory.length = 0;
+      pendingChanges.registers.clear();
+      pendingChanges.gCounters.clear();
+      pendingChanges.pnCounters.clear();
+      pendingChanges.sets.clear();
+      version = 0;
+    },
+    getStats() {
+      return {
+        total: registers.size + gCounters.size + pnCounters.size + sets.size,
+        registers: registers.size,
+        gCounters: gCounters.size,
+        pnCounters: pnCounters.size,
+        sets: sets.size,
+        version,
+        nodeId,
+        deltaHistorySize: deltaHistory.length
+      };
+    }
+  };
+  return store;
+}
+
+// src/kernel/unified-memory.ts
+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 (
@@ -9160,8 +10047,11 @@ var UnifiedMemoryManager = class _UnifiedMemoryManager {
   initPromise = null;
   preparedStatements = /* @__PURE__ */ new Map();
   vectorIndex = new InMemoryHNSWIndex();
+  // CRDT store for distributed state synchronization
+  crdtStore = null;
   constructor(config) {
-    this.config = { ...DEFAULT_UNIFIED_MEMORY_CONFIG, ...config };
+    const resolvedDefaults = getResolvedDefaultConfig();
+    this.config = { ...resolvedDefaults, ...config };
   }
   /**
    * Get or create the singleton instance (synchronous).
@@ -9514,6 +10404,199 @@ var UnifiedMemoryManager = class _UnifiedMemoryManager {
     return row.count;
   }
   // ============================================================================
+  // CRDT Operations (distributed state synchronization)
+  // ============================================================================
+  /**
+   * Initialize CRDT store for distributed state synchronization.
+   * Call this with a unique node ID for each agent/node in the cluster.
+   *
+   * @param nodeId - Unique identifier for this node (e.g., 'agent-001', 'mcp-server-1')
+   */
+  initializeCRDT(nodeId) {
+    if (this.crdtStore) {
+      console.warn("[UnifiedMemory] CRDT store already initialized");
+      return;
+    }
+    this.crdtStore = createCRDTStore({ nodeId });
+    console.log(`[UnifiedMemory] CRDT store initialized for node: ${nodeId}`);
+  }
+  /**
+   * Get the CRDT store instance.
+   * Returns null if CRDT has not been initialized.
+   */
+  getCRDTStore() {
+    return this.crdtStore;
+  }
+  /**
+   * Check if CRDT is initialized
+   */
+  isCRDTInitialized() {
+    return this.crdtStore !== null;
+  }
+  /**
+   * Set a value in both CRDT store and KV store for durability.
+   * The CRDT store provides conflict-free merge semantics,
+   * while the KV store provides persistence.
+   *
+   * @param key - Key to store
+   * @param value - Value to store
+   * @param namespace - Optional namespace (default: 'crdt')
+   */
+  async crdtSet(key, value, namespace = "crdt") {
+    this.ensureInitialized();
+    if (this.crdtStore) {
+      this.crdtStore.setRegister(key, value);
+    }
+    await this.kvSet(key, value, namespace);
+  }
+  /**
+   * Get a value from CRDT store (or fallback to KV store)
+   *
+   * @param key - Key to retrieve
+   * @param namespace - Optional namespace (default: 'crdt')
+   */
+  async crdtGet(key, namespace = "crdt") {
+    if (this.crdtStore) {
+      const register = this.crdtStore.getRegister(key);
+      if (register) {
+        return register.get();
+      }
+    }
+    return this.kvGet(key, namespace);
+  }
+  /**
+   * Increment a distributed counter (CRDT G-Counter)
+   *
+   * @param key - Counter key
+   * @param amount - Amount to increment (default: 1)
+   */
+  crdtIncrement(key, amount = 1) {
+    if (!this.crdtStore) {
+      throw new Error("CRDT store not initialized. Call initializeCRDT first.");
+    }
+    let counter = this.crdtStore.getCounter(key);
+    if (!counter) {
+      this.crdtStore.incrementCounter(key, 0);
+      counter = this.crdtStore.getCounter(key);
+    }
+    for (let i = 0; i < amount; i++) {
+      this.crdtStore.incrementCounter(key);
+    }
+  }
+  /**
+   * Get distributed counter value
+   *
+   * @param key - Counter key
+   */
+  crdtGetCounter(key) {
+    if (!this.crdtStore) {
+      return 0;
+    }
+    const counter = this.crdtStore.getCounter(key);
+    return counter?.get() ?? 0;
+  }
+  /**
+   * Add item to distributed set (CRDT OR-Set)
+   *
+   * @param key - Set key
+   * @param item - Item to add
+   */
+  crdtAddToSet(key, item) {
+    if (!this.crdtStore) {
+      throw new Error("CRDT store not initialized. Call initializeCRDT first.");
+    }
+    this.crdtStore.addToSet(key, item);
+  }
+  /**
+   * Remove item from distributed set
+   *
+   * @param key - Set key
+   * @param item - Item to remove
+   */
+  crdtRemoveFromSet(key, item) {
+    if (!this.crdtStore) {
+      throw new Error("CRDT store not initialized. Call initializeCRDT first.");
+    }
+    this.crdtStore.removeFromSet(key, item);
+  }
+  /**
+   * Get all items from distributed set
+   *
+   * @param key - Set key
+   */
+  crdtGetSet(key) {
+    if (!this.crdtStore) {
+      return /* @__PURE__ */ new Set();
+    }
+    const orSet = this.crdtStore.getSet(key);
+    return new Set(orSet.values());
+  }
+  /**
+   * Get the current CRDT state for replication
+   */
+  crdtGetState() {
+    if (!this.crdtStore) {
+      return null;
+    }
+    return this.crdtStore.getState();
+  }
+  /**
+   * Get a delta of changes since a given version
+   */
+  crdtGetDelta(sinceVersion) {
+    if (!this.crdtStore) {
+      return null;
+    }
+    return this.crdtStore.getDelta(sinceVersion ?? 0);
+  }
+  /**
+   * Merge remote CRDT state into local store.
+   * This operation is commutative, associative, and idempotent.
+   *
+   * @param remoteState - State from another node
+   */
+  crdtMerge(remoteState) {
+    if (!this.crdtStore) {
+      throw new Error("CRDT store not initialized. Call initializeCRDT first.");
+    }
+    this.crdtStore.applyState(remoteState);
+  }
+  /**
+   * Apply a delta from another node
+   *
+   * @param delta - Delta changes from another node
+   */
+  crdtApplyDelta(delta) {
+    if (!this.crdtStore) {
+      throw new Error("CRDT store not initialized. Call initializeCRDT first.");
+    }
+    this.crdtStore.applyDelta(delta);
+  }
+  /**
+   * Persist current CRDT state to KV store for recovery
+   */
+  async crdtPersist() {
+    if (!this.crdtStore) {
+      return;
+    }
+    const state2 = this.crdtStore.getState();
+    await this.kvSet("__crdt_state__", state2, "crdt-internal");
+  }
+  /**
+   * Restore CRDT state from KV store
+   */
+  async crdtRestore() {
+    if (!this.crdtStore) {
+      return false;
+    }
+    const state2 = await this.kvGet("__crdt_state__", "crdt-internal");
+    if (state2) {
+      this.crdtStore.applyState(state2);
+      return true;
+    }
+    return false;
+  }
+  // ============================================================================
   // Raw Database Access (for advanced operations)
   // ============================================================================
   /**
@@ -12130,7 +13213,7 @@ var TestDataGeneratorService = class {
 };
 
 // src/domains/test-generation/services/test-generator.ts
-var DEFAULT_CONFIG = {
+var DEFAULT_CONFIG2 = {
   defaultFramework: "vitest",
   maxTestsPerFile: 50,
   coverageTargetDefault: 80,
@@ -12150,7 +13233,7 @@ var TestGeneratorService = class {
   testDataGenerator;
   llmRouter;
   constructor(dependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.config = { ...DEFAULT_CONFIG2, ...config };
     this.memory = dependencies.memory;
     this.generatorFactory = dependencies.generatorFactory || new TestGeneratorFactory();
     this.tddGenerator = dependencies.tddGenerator || new TDDGeneratorService();
@@ -12742,7 +13825,7 @@ import { v4 as uuidv44 } from "uuid";
 import * as ts2 from "typescript";
 import * as fs3 from "fs";
 import * as path3 from "path";
-var DEFAULT_CONFIG2 = {
+var DEFAULT_CONFIG3 = {
   maxPatterns: 100,
   minMatchScore: 0.5,
   enableVectorSearch: true,
@@ -12752,7 +13835,7 @@ var DEFAULT_CONFIG2 = {
 var PatternMatcherService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.config = { ...DEFAULT_CONFIG3, ...config };
     this.tsParser = new TypeScriptASTParser();
     this.embedder = config.embedder ?? new NomicEmbedder({ enableFallback: true });
   }
@@ -17995,7 +19078,7 @@ function createTestGenerationCoherenceGate(coherenceService, embeddingService, c
 }
 
 // src/domains/test-generation/coordinator.ts
-var DEFAULT_CONFIG5 = {
+var DEFAULT_CONFIG6 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   // 60 seconds
@@ -18027,7 +19110,7 @@ var TestGenerationCoordinator = class {
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
     this.coherenceService = coherenceService;
-    this.config = { ...DEFAULT_CONFIG5, ...config };
+    this.config = { ...DEFAULT_CONFIG6, ...config };
     this.testGenerator = createTestGeneratorService(memory);
     this.patternMatcher = new PatternMatcherService(memory);
     if (this.config.enableCoherenceGate && coherenceService) {
@@ -19869,7 +20952,7 @@ var LLM_ANALYSIS_CONSTANTS = {
 };
 
 // src/domains/test-execution/services/test-executor.ts
-var DEFAULT_CONFIG6 = {
+var DEFAULT_CONFIG7 = {
   simulateForTesting: false,
   simulatedTestsPerFile: 5,
   simulatedFailureRate: 0.2,
@@ -19893,7 +20976,7 @@ var TestExecutorService = class {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG6, ...config };
+    this.config = { ...DEFAULT_CONFIG7, ...config };
   }
   /**
    * Execute a test suite sequentially
@@ -22057,7 +23140,7 @@ function createTestPrioritizationState(testId, metadata) {
 }
 
 // src/domains/test-execution/services/test-prioritizer.ts
-var DEFAULT_CONFIG7 = {
+var DEFAULT_CONFIG8 = {
   enableDT: true,
   minTrajectoriesForDT: 5,
   enableHeuristicFallback: true,
@@ -22070,7 +23153,7 @@ var DEFAULT_CONFIG7 = {
 var TestPrioritizerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG7, ...config };
+    this.config = { ...DEFAULT_CONFIG8, ...config };
     this.decisionTransformer = new DecisionTransformerAlgorithm({
       contextLength: this.config.contextLength,
       embeddingDim: this.config.embeddingDim
@@ -27334,7 +28417,7 @@ init_types();
 
 // src/domains/coverage-analysis/services/coverage-analyzer.ts
 init_types();
-var DEFAULT_CONFIG8 = {
+var DEFAULT_CONFIG9 = {
   defaultThreshold: 80,
   enableLLMAnalysis: true,
   // On by default - opt-out
@@ -27354,7 +28437,7 @@ var CoverageAnalyzerService = class _CoverageAnalyzerService {
    * @param config - Optional configuration overrides
    */
   constructor(memoryOrDependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG8, ...config };
+    this.config = { ...DEFAULT_CONFIG9, ...config };
     if (this.isMemoryBackend(memoryOrDependencies)) {
       this.memory = memoryOrDependencies;
       this.llmRouter = void 0;
@@ -27866,7 +28949,7 @@ ${truncatedSource}
 
 // src/domains/coverage-analysis/services/gap-detector.ts
 init_types();
-var DEFAULT_CONFIG9 = {
+var DEFAULT_CONFIG10 = {
   minCoverage: 80,
   enableLLMAnalysis: true,
   // On by default - opt-out
@@ -27891,11 +28974,11 @@ var GapDetectorService = class _GapDetectorService {
     if ("memory" in dependenciesOrMemory) {
       this.memory = dependenciesOrMemory.memory;
       this.llmRouter = dependenciesOrMemory.llmRouter;
-      this.config = { ...DEFAULT_CONFIG9, ...config };
+      this.config = { ...DEFAULT_CONFIG10, ...config };
     } else {
       this.memory = dependenciesOrMemory;
       this.llmRouter = void 0;
-      this.config = { ...DEFAULT_CONFIG9 };
+      this.config = { ...DEFAULT_CONFIG10 };
     }
   }
   // ============================================================================
@@ -29608,7 +30691,7 @@ var QLearningAlgorithm = class extends BaseRLAlgorithm {
 
 // src/domains/coverage-analysis/coordinator.ts
 import { v4 as uuidv411 } from "uuid";
-var DEFAULT_CONFIG10 = {
+var DEFAULT_CONFIG11 = {
   // MinCut integration defaults (ADR-047)
   enableMinCutAwareness: true,
   topologyHealthThreshold: 0.5,
@@ -29623,7 +30706,7 @@ var CoverageAnalysisCoordinator = class {
   constructor(eventBus, memory, config = {}) {
     this.eventBus = eventBus;
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG10, ...config };
+    this.config = { ...DEFAULT_CONFIG11, ...config };
     this.minCutMixin = createMinCutAwareMixin(this.domainName, {
       enableMinCutAwareness: this.config.enableMinCutAwareness,
       topologyHealthThreshold: this.config.topologyHealthThreshold,
@@ -30647,7 +31730,7 @@ import { v4 as uuidv415 } from "uuid";
 // src/domains/quality-assessment/services/quality-gate.ts
 init_types();
 import { v4 as uuidv412 } from "uuid";
-var DEFAULT_CONFIG11 = {
+var DEFAULT_CONFIG12 = {
   strictMode: false,
   enableWarnings: true,
   defaultSeverities: {
@@ -30692,7 +31775,7 @@ var DEFAULT_PRESETS = {
 var QualityGateService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG11, ...config };
+    this.config = { ...DEFAULT_CONFIG12, ...config };
     for (const [name, thresholds] of Object.entries(DEFAULT_PRESETS)) {
       this.presets.set(name, thresholds);
     }
@@ -31530,7 +32613,7 @@ function getSystemMetricsCollector() {
 }
 
 // src/domains/quality-assessment/services/quality-analyzer.ts
-var DEFAULT_CONFIG12 = {
+var DEFAULT_CONFIG13 = {
   enableTrendAnalysis: true,
   trendDataPointsMin: 3,
   complexityThresholds: {
@@ -31565,7 +32648,7 @@ var QualityAnalyzerService = class {
    * 2. New: (dependencies: QualityAnalyzerDependencies, config?: Partial<QualityAnalyzerConfig>)
    */
   constructor(memoryOrDependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG12, ...config };
+    this.config = { ...DEFAULT_CONFIG13, ...config };
     this.metricsAnalyzer = getCodeMetricsAnalyzer();
     if ("memory" in memoryOrDependencies) {
       this.memory = memoryOrDependencies.memory;
@@ -32194,7 +33277,7 @@ ${codeContext.slice(0, 2e3)}
 // src/domains/quality-assessment/services/deployment-advisor.ts
 init_types();
 import { v4 as uuidv414 } from "uuid";
-var DEFAULT_CONFIG13 = {
+var DEFAULT_CONFIG14 = {
   riskWeights: {
     coverage: 0.15,
     testsPassing: 0.2,
@@ -32224,7 +33307,7 @@ var DeploymentAdvisorService = class {
   memory;
   llmRouter;
   constructor(dependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG13, ...config };
+    this.config = { ...DEFAULT_CONFIG14, ...config };
     if ("memory" in dependencies) {
       this.memory = dependencies.memory;
       this.llmRouter = dependencies.llmRouter;
@@ -32986,7 +34069,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 +34223,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 +34317,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 +34366,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 +34654,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;
@@ -34378,7 +35461,7 @@ function generateContentHash(content) {
 }
 
 // src/domains/quality-assessment/coordinator.ts
-var DEFAULT_CONFIG14 = {
+var DEFAULT_CONFIG15 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   publishEvents: true,
@@ -34403,7 +35486,7 @@ var QualityAssessmentCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG14, ...config };
+    this.config = { ...DEFAULT_CONFIG15, ...config };
     this.qualityGate = new QualityGateService(memory);
     this.qualityAnalyzer = new QualityAnalyzerService(memory);
     this.deploymentAdvisor = new DeploymentAdvisorService(memory);
@@ -36416,7 +37499,7 @@ import * as path6 from "path";
 function sanitizeGitArg(arg) {
   return arg.replace(/[;&|`$(){}[\]<>\\'"!\n\r]/g, "");
 }
-var DEFAULT_CONFIG15 = {
+var DEFAULT_CONFIG16 = {
   repoRoot: process.cwd(),
   maxCommits: 100,
   bugKeywords: ["fix", "bug", "patch", "issue", "error", "defect", "problem"],
@@ -36429,7 +37512,7 @@ var GitAnalyzer = class {
   cache = /* @__PURE__ */ new Map();
   isGitRepo = null;
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG15, ...config };
+    this.config = { ...DEFAULT_CONFIG16, ...config };
   }
   /**
    * Check if current directory is a git repository
@@ -36943,7 +38026,7 @@ var GitAnalyzer = class {
 // src/domains/defect-intelligence/services/defect-predictor.ts
 init_io();
 init_parsers();
-var DEFAULT_CONFIG16 = {
+var DEFAULT_CONFIG17 = {
   defaultThreshold: 0.5,
   maxPredictionsPerBatch: 100,
   enableHistoricalAnalysis: true,
@@ -36990,7 +38073,7 @@ var DefectPredictorService = class {
    * Supports both old signature (memory, config, ...) and new signature (dependencies, config)
    */
   constructor(memoryOrDeps, config = {}, gitAnalyzer, fileReader, tsParser) {
-    this.config = { ...DEFAULT_CONFIG16, ...config };
+    this.config = { ...DEFAULT_CONFIG17, ...config };
     if (this.isDependenciesObject(memoryOrDeps)) {
       this.memory = memoryOrDeps.memory;
       this.gitAnalyzer = memoryOrDeps.gitAnalyzer ?? new GitAnalyzer({ enableCache: true });
@@ -37760,7 +38843,7 @@ ${fileResult.value.slice(0, 2e3)}
 init_types();
 init_embeddings();
 import { v4 as uuidv417 } from "uuid";
-var DEFAULT_CONFIG17 = {
+var DEFAULT_CONFIG18 = {
   minPatternFrequency: 2,
   maxPatterns: 50,
   clusterThreshold: 0.7,
@@ -37807,7 +38890,7 @@ var KNOWN_PATTERNS = {
 var PatternLearnerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG17, ...config };
+    this.config = { ...DEFAULT_CONFIG18, ...config };
     this.embedder = config.embedder ?? new NomicEmbedder({ enableFallback: true });
     if (this.config.enableFlashAttention) {
       this.initializeFlashAttention();
@@ -38398,7 +39481,7 @@ var PatternLearnerService = class {
 
 // src/domains/defect-intelligence/services/root-cause-analyzer.ts
 init_types();
-var DEFAULT_CONFIG18 = {
+var DEFAULT_CONFIG19 = {
   maxTimelineEvents: 20,
   maxRelatedFiles: 10,
   minConfidenceThreshold: 0.3,
@@ -38541,7 +39624,7 @@ var RootCauseAnalyzerService = class {
    * Supports both old signature (memory, config) and new signature (dependencies, config)
    */
   constructor(memoryOrDeps, config = {}) {
-    this.config = { ...DEFAULT_CONFIG18, ...config };
+    this.config = { ...DEFAULT_CONFIG19, ...config };
     if (this.isMemoryBackend(memoryOrDeps)) {
       this.memory = memoryOrDeps;
       this.llmRouter = void 0;
@@ -39083,7 +40166,7 @@ ${fix.codeExample}
 };
 
 // src/domains/defect-intelligence/coordinator.ts
-var DEFAULT_CONFIG19 = {
+var DEFAULT_CONFIG20 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   enablePatternLearning: true,
@@ -39102,7 +40185,7 @@ var DefectIntelligenceCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG19, ...config };
+    this.config = { ...DEFAULT_CONFIG20, ...config };
     this.predictor = new DefectPredictorService(memory);
     this.patternLearner = new PatternLearnerService(memory);
     this.rootCauseAnalyzer = new RootCauseAnalyzerService(memory);
@@ -40107,7 +41190,7 @@ import { v4 as uuidv421 } from "uuid";
 // src/domains/requirements-validation/services/requirements-validator.ts
 init_types();
 import { v4 as uuidv419 } from "uuid";
-var DEFAULT_CONFIG20 = {
+var DEFAULT_CONFIG21 = {
   enableAmbiguityDetection: true,
   minAcceptanceCriteria: 1,
   strictMode: false,
@@ -40150,7 +41233,7 @@ var RequirementsValidatorService = class {
   memory;
   llmRouter;
   constructor(dependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG20, ...config };
+    this.config = { ...DEFAULT_CONFIG21, ...config };
     if ("memory" in dependencies && typeof dependencies.memory === "object") {
       this.memory = dependencies.memory;
       this.llmRouter = dependencies.llmRouter;
@@ -40724,7 +41807,7 @@ Please analyze these requirements for:
 // src/domains/requirements-validation/services/bdd-scenario-writer.ts
 init_types();
 import { v4 as uuidv420 } from "uuid";
-var DEFAULT_CONFIG21 = {
+var DEFAULT_CONFIG22 = {
   defaultExampleCount: 3,
   includeBackgroundScenarios: true,
   generateNegativeScenarios: true,
@@ -40733,7 +41816,7 @@ var DEFAULT_CONFIG21 = {
 var BDDScenarioWriterService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG21, ...config };
+    this.config = { ...DEFAULT_CONFIG22, ...config };
   }
   config;
   /**
@@ -41187,7 +42270,7 @@ var DEFAULT_WEIGHTS = {
   traceability: 0.1,
   independency: 0.15
 };
-var DEFAULT_CONFIG22 = {
+var DEFAULT_CONFIG23 = {
   defaultThreshold: 60,
   weights: DEFAULT_WEIGHTS,
   enableAIScoring: false
@@ -41196,7 +42279,7 @@ var TestabilityScorerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
     this.config = {
-      ...DEFAULT_CONFIG22,
+      ...DEFAULT_CONFIG23,
       ...config,
       weights: { ...DEFAULT_WEIGHTS, ...config.weights }
     };
@@ -41907,7 +42990,7 @@ var RequirementsValidationEvents = {
   SprintValidated: "requirements-validation.SprintValidated",
   ValidationFailed: "requirements-validation.ValidationFailed"
 };
-var DEFAULT_CONFIG23 = {
+var DEFAULT_CONFIG24 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   publishEvents: true,
@@ -41963,7 +43046,7 @@ var RequirementsValidationCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG23, ...config };
+    this.config = { ...DEFAULT_CONFIG24, ...config };
     this.minCutMixin = createMinCutAwareMixin(this.domainName, {
       enableMinCutAwareness: this.config.enableMinCutAwareness,
       topologyHealthThreshold: this.config.topologyHealthThreshold,
@@ -44495,7 +45578,7 @@ function sanitizeId(str) {
 }
 
 // src/domains/code-intelligence/services/product-factors-bridge.ts
-var DEFAULT_CONFIG24 = {
+var DEFAULT_CONFIG25 = {
   cacheTtlMs: 36e5,
   // 1 hour
   publishEvents: true,
@@ -44560,7 +45643,7 @@ var ProductFactorsBridgeService = class {
   constructor(eventBus, memory, config = {}) {
     this.eventBus = eventBus;
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG24, ...config };
+    this.config = { ...DEFAULT_CONFIG25, ...config };
   }
   config;
   initialized = false;
@@ -45154,7 +46237,7 @@ init_knowledge_graph();
 // src/domains/code-intelligence/services/semantic-analyzer.ts
 init_types();
 init_embeddings();
-var DEFAULT_CONFIG26 = {
+var DEFAULT_CONFIG27 = {
   embeddingDimension: EMBEDDING_CONFIG.DIMENSIONS,
   // 768 for Nomic
   minScore: 0.5,
@@ -45167,7 +46250,7 @@ var DEFAULT_CONFIG26 = {
 var SemanticAnalyzerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG26, ...config };
+    this.config = { ...DEFAULT_CONFIG27, ...config };
     if (config.embeddingProvider) {
       this.embedder = config.embeddingProvider;
       this.embedderInitialized = true;
@@ -45735,7 +46818,7 @@ var SemanticAnalyzerService = class {
 init_types();
 init_knowledge_graph();
 import { v4 as uuidv424 } from "uuid";
-var DEFAULT_CONFIG27 = {
+var DEFAULT_CONFIG28 = {
   maxDepth: 5,
   riskWeights: {
     directImpact: 0.4,
@@ -45765,7 +46848,7 @@ var DEFAULT_CONFIG27 = {
 var ImpactAnalyzerService = class {
   constructor(memory, knowledgeGraph, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG27, ...config };
+    this.config = { ...DEFAULT_CONFIG28, ...config };
     this.knowledgeGraph = knowledgeGraph || new KnowledgeGraphService(memory);
   }
   config;
@@ -46119,7 +47202,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 +47216,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 +47364,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 +47564,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 +47584,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 +47600,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 +47881,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 +47970,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 +48129,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 +48152,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;
@@ -48038,7 +49121,7 @@ async function createHypergraphEngine(config) {
 }
 
 // src/domains/code-intelligence/coordinator.ts
-var DEFAULT_CONFIG28 = {
+var DEFAULT_CONFIG29 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 12e4,
   // 2 minutes
@@ -48065,7 +49148,7 @@ var CodeIntelligenceCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG28, ...config };
+    this.config = { ...DEFAULT_CONFIG29, ...config };
     this.minCutMixin = createMinCutAwareMixin(this.domainName, {
       enableMinCutAwareness: this.config.enableMinCutAwareness,
       topologyHealthThreshold: this.config.topologyHealthThreshold,
@@ -49985,7 +51068,7 @@ var Version = class _Version {
 init_types();
 
 // src/domains/security-compliance/services/scanners/scanner-types.ts
-var DEFAULT_CONFIG29 = {
+var DEFAULT_CONFIG30 = {
   defaultRuleSets: ["owasp-top-10", "cwe-sans-25"],
   maxConcurrentScans: 4,
   timeout: 3e5,
@@ -51987,7 +53070,7 @@ function createHttpClient() {
 }
 
 // src/shared/security/osv-client.ts
-var DEFAULT_CONFIG30 = {
+var DEFAULT_CONFIG31 = {
   baseUrl: "https://api.osv.dev",
   timeout: 3e4,
   enableCache: true,
@@ -51999,7 +53082,7 @@ var OSVClient = class {
   http;
   cache = /* @__PURE__ */ new Map();
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG30, ...config };
+    this.config = { ...DEFAULT_CONFIG31, ...config };
     this.http = new HttpClient();
   }
   /**
@@ -52909,7 +53992,7 @@ var SecurityScannerService = class {
   dastScanner;
   dependencyScanner;
   constructor(dependencies, config = {}) {
-    this.config = { ...DEFAULT_CONFIG29, ...config };
+    this.config = { ...DEFAULT_CONFIG30, ...config };
     if ("memory" in dependencies) {
       this.memory = dependencies.memory;
       this.llmRouter = dependencies.llmRouter;
@@ -53103,7 +54186,7 @@ async function httpGet(url) {
     data
   };
 }
-var DEFAULT_CONFIG31 = {
+var DEFAULT_CONFIG32 = {
   secretPatterns: [
     /(?:api[_-]?key|apikey)['":\s]*['"=]?\s*['"]?([a-zA-Z0-9_\-]{20,})['"]?/gi,
     /(?:password|passwd|pwd)['":\s]*['"=]?\s*['"]?([^\s'"]{8,})['"]?/gi,
@@ -53125,7 +54208,7 @@ var DEFAULT_CONFIG31 = {
 var SecurityAuditorService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG31, ...config };
+    this.config = { ...DEFAULT_CONFIG32, ...config };
   }
   config;
   // ==========================================================================
@@ -54713,7 +55796,7 @@ var SecurityAuditorService = class {
 // src/domains/security-compliance/services/compliance-validator.ts
 init_types();
 import { v4 as uuidv434 } from "uuid";
-var DEFAULT_CONFIG32 = {
+var DEFAULT_CONFIG33 = {
   customStandards: [],
   strictMode: false,
   includeRecommended: true,
@@ -54916,7 +55999,7 @@ var BUILT_IN_STANDARDS = [
 var ComplianceValidatorService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG32, ...config };
+    this.config = { ...DEFAULT_CONFIG33, ...config };
     this.patternAnalyzer = getCompliancePatternAnalyzer();
     this.standards = /* @__PURE__ */ new Map();
     for (const std of BUILT_IN_STANDARDS) {
@@ -55769,7 +56852,7 @@ var DQNAlgorithm = class extends BaseRLAlgorithm {
 
 // src/domains/security-compliance/coordinator.ts
 init_wrappers();
-var DEFAULT_CONFIG33 = {
+var DEFAULT_CONFIG34 = {
   maxConcurrentWorkflows: 3,
   defaultTimeout: 3e5,
   // 5 minutes
@@ -55794,7 +56877,7 @@ var SecurityComplianceCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG33, ...config };
+    this.config = { ...DEFAULT_CONFIG34, ...config };
     this.minCutMixin = createMinCutAwareMixin(this.domainName, {
       enableMinCutAwareness: this.config.enableMinCutAwareness,
       topologyHealthThreshold: this.config.topologyHealthThreshold,
@@ -56985,7 +58068,7 @@ init_io();
 
 // src/domains/contract-testing/services/contract-validator.ts
 init_types();
-var DEFAULT_CONFIG34 = {
+var DEFAULT_CONFIG35 = {
   strictMode: true,
   validateExamples: true,
   maxSchemaDepth: CONTRACT_CONSTANTS.MAX_SCHEMA_DEPTH,
@@ -57008,7 +58091,7 @@ var ContractValidatorService = class {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG34, ...config };
+    this.config = { ...DEFAULT_CONFIG35, ...config };
   }
   /**
    * ADR-051: Check if LLM analysis is available
@@ -58348,7 +59431,7 @@ Provide:
 
 // src/domains/contract-testing/services/api-compatibility.ts
 init_types();
-var DEFAULT_CONFIG35 = {
+var DEFAULT_CONFIG36 = {
   strictEnumValidation: true,
   allowOptionalToRequired: false,
   trackDeprecations: true,
@@ -58357,7 +59440,7 @@ var DEFAULT_CONFIG35 = {
 var ApiCompatibilityService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG35, ...config };
+    this.config = { ...DEFAULT_CONFIG36, ...config };
   }
   config;
   /**
@@ -59020,7 +60103,7 @@ var ContractTestingEvents = {
   ConsumerContractCreated: "contract-testing.ConsumerContractCreated",
   VerificationFailed: "contract-testing.VerificationFailed"
 };
-var DEFAULT_CONFIG36 = {
+var DEFAULT_CONFIG37 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   // 60 seconds
@@ -59043,7 +60126,7 @@ var ContractTestingCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG36, ...config };
+    this.config = { ...DEFAULT_CONFIG37, ...config };
     this.minCutMixin = createMinCutAwareMixin(this.domainName, {
       enableMinCutAwareness: this.config.enableMinCutAwareness,
       topologyHealthThreshold: this.config.topologyHealthThreshold,
@@ -60241,7 +61324,7 @@ var ContractTestingCoordinator = class {
 // src/domains/contract-testing/services/schema-validator.ts
 init_types();
 import { v4 as uuidv437 } from "uuid";
-var DEFAULT_CONFIG37 = {
+var DEFAULT_CONFIG38 = {
   strictMode: false,
   allowAdditionalProperties: true,
   maxRecursionDepth: 10,
@@ -60250,7 +61333,7 @@ var DEFAULT_CONFIG37 = {
 var SchemaValidatorService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG37, ...config };
+    this.config = { ...DEFAULT_CONFIG38, ...config };
   }
   config;
   /**
@@ -61627,7 +62710,7 @@ import { v4 as uuidv441 } from "uuid";
 // src/domains/visual-accessibility/services/visual-tester.ts
 init_types();
 import { v4 as uuidv438 } from "uuid";
-var DEFAULT_CONFIG38 = {
+var DEFAULT_CONFIG39 = {
   baselineDirectory: ".visual-tests/baselines",
   diffDirectory: ".visual-tests/diffs",
   defaultViewport: {
@@ -61655,7 +62738,7 @@ var VisualTesterService = class {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG38, ...config };
+    this.config = { ...DEFAULT_CONFIG39, ...config };
   }
   /**
    * Set the Vibium client for browser-based operations
@@ -62674,7 +63757,7 @@ function getWCAGLevel(criterionId) {
   if (levelAA.includes(criterionId)) return "AA";
   return "AAA";
 }
-var DEFAULT_CONFIG39 = {
+var DEFAULT_CONFIG40 = {
   en301549Version: "3.2.1",
   includeEAA: true,
   defaultProductCategory: "e-commerce",
@@ -62683,7 +63766,7 @@ var DEFAULT_CONFIG39 = {
 var EUComplianceService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG39, ...config };
+    this.config = { ...DEFAULT_CONFIG40, ...config };
   }
   config;
   /**
@@ -62979,7 +64062,7 @@ init_errors();
 init_client();
 
 // src/domains/visual-accessibility/services/accessibility-tester.ts
-var DEFAULT_CONFIG40 = {
+var DEFAULT_CONFIG41 = {
   defaultWCAGLevel: "AA",
   includeWarnings: true,
   auditTimeout: 3e4,
@@ -63020,7 +64103,7 @@ var AccessibilityTesterService = class {
    */
   constructor(memory, config = {}, vibiumClient) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG40, ...config };
+    this.config = { ...DEFAULT_CONFIG41, ...config };
     this.rules = this.initializeRules();
     this.vibiumClient = vibiumClient ?? null;
     this.browserClient = config.browserClient ?? null;
@@ -64614,7 +65697,7 @@ var DEVICE_VIEWPORTS = {
     hasTouch: false
   }
 };
-var DEFAULT_CONFIG41 = {
+var DEFAULT_CONFIG42 = {
   viewports: [
     DEVICE_VIEWPORTS["iphone-14"],
     DEVICE_VIEWPORTS["ipad-mini"],
@@ -64630,7 +65713,7 @@ var DEFAULT_CONFIG41 = {
 var ResponsiveTesterService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG41, ...config };
+    this.config = { ...DEFAULT_CONFIG42, ...config };
   }
   config;
   /**
@@ -65380,7 +66463,7 @@ var A2CAlgorithm = class extends BaseRLAlgorithm {
 
 // src/domains/visual-accessibility/coordinator.ts
 init_wrappers();
-var DEFAULT_CONFIG42 = {
+var DEFAULT_CONFIG43 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 12e4,
   // 2 minutes
@@ -65403,7 +66486,7 @@ var VisualAccessibilityCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG42, ...config };
+    this.config = { ...DEFAULT_CONFIG43, ...config };
     this.minCutMixin = createMinCutAwareMixin(this.domainName, {
       enableMinCutAwareness: this.config.enableMinCutAwareness,
       topologyHealthThreshold: this.config.topologyHealthThreshold,
@@ -67189,7 +68272,7 @@ init_types();
 init_cve_prevention();
 import * as net from "net";
 import { execFile } from "child_process";
-var DEFAULT_CONFIG43 = {
+var DEFAULT_CONFIG44 = {
   defaultTimeout: 6e4,
   // 60 seconds
   maxConcurrentFaults: 3,
@@ -67215,7 +68298,7 @@ var ChaosEngineerService = class _ChaosEngineerService {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG43, ...config };
+    this.config = { ...DEFAULT_CONFIG44, ...config };
     this.httpClient = new HttpClient();
     this.metricsCollector = getSystemMetricsCollector();
   }
@@ -68063,7 +69146,7 @@ Provide:
 // src/domains/chaos-resilience/services/load-tester.ts
 init_types();
 import { v4 as uuidv442 } from "uuid";
-var DEFAULT_CONFIG44 = {
+var DEFAULT_CONFIG45 = {
   defaultTimeout: 3e5,
   // 5 minutes
   maxVirtualUsers: 1e3,
@@ -68075,7 +69158,7 @@ var DEFAULT_CONFIG44 = {
 var LoadTesterService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG44, ...config };
+    this.config = { ...DEFAULT_CONFIG45, ...config };
     this.httpClient = new HttpClient();
   }
   config;
@@ -68612,7 +69695,7 @@ var LoadTesterService = class {
 // src/domains/chaos-resilience/services/performance-profiler.ts
 init_types();
 import { v4 as uuidv443 } from "uuid";
-var DEFAULT_CONFIG45 = {
+var DEFAULT_CONFIG46 = {
   defaultTimeout: 6e4,
   // 60 seconds
   healthCheckInterval: 1e3,
@@ -68626,7 +69709,7 @@ var DEFAULT_CONFIG45 = {
 var PerformanceProfilerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG45, ...config };
+    this.config = { ...DEFAULT_CONFIG46, ...config };
     this.httpClient = createHttpClient();
   }
   config;
@@ -69403,7 +70486,7 @@ var PolicyGradientAlgorithm = class extends BaseRLAlgorithm {
 };
 
 // src/domains/chaos-resilience/coordinator.ts
-var DEFAULT_CONFIG46 = {
+var DEFAULT_CONFIG47 = {
   maxConcurrentWorkflows: 3,
   defaultTimeout: 3e5,
   // 5 minutes
@@ -69426,7 +70509,7 @@ var ChaosResilienceCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG46, ...config };
+    this.config = { ...DEFAULT_CONFIG47, ...config };
     this.minCutMixin = createMinCutAwareMixin(this.domainName, {
       enableMinCutAwareness: this.config.enableMinCutAwareness,
       topologyHealthThreshold: this.config.topologyHealthThreshold,
@@ -71356,7 +72439,7 @@ import { v4 as uuidv452 } from "uuid";
 init_types();
 init_wrappers();
 import { v4 as uuidv445 } from "uuid";
-var DEFAULT_CONFIG47 = {
+var DEFAULT_CONFIG48 = {
   minExperiencesForPattern: 5,
   patternConfidenceThreshold: 0.7,
   maxPatternsPerDomain: 100,
@@ -71380,7 +72463,7 @@ var LearningCoordinatorService = class {
   constructor(dependencies, config = {}) {
     this.memory = dependencies.memory;
     this.llmRouter = dependencies.llmRouter;
-    this.config = { ...DEFAULT_CONFIG47, ...config };
+    this.config = { ...DEFAULT_CONFIG48, ...config };
   }
   // ============================================================================
   // FlashAttention Integration Methods (via @ruvector/attention)
@@ -72265,7 +73348,7 @@ Provide:
 // src/domains/learning-optimization/services/transfer-specialist.ts
 init_types();
 import { v4 as uuidv446 } from "uuid";
-var DEFAULT_CONFIG48 = {
+var DEFAULT_CONFIG49 = {
   maxKnowledgeItems: 1e3,
   relevanceThreshold: 0.5,
   transferDecayFactor: 0.1,
@@ -72274,7 +73357,7 @@ var DEFAULT_CONFIG48 = {
 var TransferSpecialistService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG48, ...config };
+    this.config = { ...DEFAULT_CONFIG49, ...config };
   }
   config;
   // ============================================================================
@@ -72778,7 +73861,7 @@ var TransferSpecialistService = class {
 // src/domains/learning-optimization/services/metrics-optimizer.ts
 init_types();
 import { v4 as uuidv447 } from "uuid";
-var DEFAULT_CONFIG49 = {
+var DEFAULT_CONFIG50 = {
   defaultConfidenceLevel: 0.95,
   minSamplesForOptimization: 20,
   maxOptimizationIterations: 100,
@@ -72792,7 +73875,7 @@ function isSafeKey(key) {
 var MetricsOptimizerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG49, ...config };
+    this.config = { ...DEFAULT_CONFIG50, ...config };
   }
   config;
   // ============================================================================
@@ -73396,7 +74479,7 @@ var MetricsOptimizerService = class {
 // src/domains/learning-optimization/services/production-intel.ts
 init_types();
 import { v4 as uuidv448 } from "uuid";
-var DEFAULT_CONFIG50 = {
+var DEFAULT_CONFIG51 = {
   metricsRetentionDays: 90,
   anomalyThreshold: 2.5,
   trendWindowSize: 7,
@@ -73410,7 +74493,7 @@ var DEFAULT_CONFIG50 = {
 var ProductionIntelService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG50, ...config };
+    this.config = { ...DEFAULT_CONFIG51, ...config };
   }
   config;
   // ============================================================================
@@ -76487,7 +77570,7 @@ function createDreamScheduler(dependencies, config) {
 }
 
 // src/domains/learning-optimization/coordinator.ts
-var DEFAULT_CONFIG51 = {
+var DEFAULT_CONFIG52 = {
   maxConcurrentWorkflows: 3,
   defaultTimeout: 12e4,
   // 2 minutes
@@ -76519,7 +77602,7 @@ var LearningOptimizationCoordinator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG51, ...config };
+    this.config = { ...DEFAULT_CONFIG52, ...config };
     this.minCutMixin = createMinCutAwareMixin(this.domainName, {
       enableMinCutAwareness: this.config.enableMinCutAwareness,
       topologyHealthThreshold: this.config.topologyHealthThreshold,
@@ -78594,7 +79677,7 @@ var WorkflowEvents = {
   StepFailed: "workflow.StepFailed",
   StepSkipped: "workflow.StepSkipped"
 };
-var DEFAULT_CONFIG52 = {
+var DEFAULT_CONFIG53 = {
   maxConcurrentWorkflows: 10,
   defaultStepTimeout: 6e4,
   defaultWorkflowTimeout: 6e5,
@@ -78606,7 +79689,7 @@ var WorkflowOrchestrator = class {
     this.eventBus = eventBus;
     this.memory = memory;
     this.agentCoordinator = agentCoordinator;
-    this.config = { ...DEFAULT_CONFIG52, ...config };
+    this.config = { ...DEFAULT_CONFIG53, ...config };
   }
   config;
   workflows = /* @__PURE__ */ new Map();
@@ -80253,7 +81336,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) {
@@ -80264,7 +81347,7 @@ function findProjectRoot() {
   }
   return process.cwd();
 }
-var DEFAULT_CONFIG53 = {
+var DEFAULT_CONFIG54 = {
   maxConcurrentAgents: AGENT_CONSTANTS.MAX_CONCURRENT_AGENTS,
   memoryBackend: "hybrid",
   hnswEnabled: true,
@@ -80282,9 +81365,9 @@ var QEKernelImpl = class {
   _startTime;
   _initialized = false;
   constructor(config = {}) {
-    this._config = { ...DEFAULT_CONFIG53, ...config };
+    this._config = { ...DEFAULT_CONFIG54, ...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 });
@@ -80502,7 +81585,7 @@ function createdAtComparator() {
 }
 
 // src/coordination/services/task-audit-logger.ts
-var DEFAULT_CONFIG54 = {
+var DEFAULT_CONFIG55 = {
   enableConsoleLog: true,
   maxEntries: 1e3,
   logPrefix: "[TASK]"
@@ -80511,7 +81594,7 @@ var TaskAuditLogger = class {
   entries = [];
   config;
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG54, ...config };
+    this.config = { ...DEFAULT_CONFIG55, ...config };
   }
   /**
    * Log a task operation
@@ -83604,7 +84687,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 +84967,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();
   }
   // ---------------------------------------------------------------------------
@@ -84236,7 +85319,7 @@ var TASK_DOMAIN_MAP = {
   // QCSD Ideation Swarm: requirements-validation is primary, with support from coverage-analysis and security-compliance
   "ideation-assessment": ["requirements-validation", "coverage-analysis", "security-compliance"]
 };
-var DEFAULT_CONFIG55 = {
+var DEFAULT_CONFIG56 = {
   maxConcurrentTasks: 50,
   defaultTaskTimeout: 3e5,
   // 5 minutes
@@ -84271,7 +85354,7 @@ var QueenCoordinator = class _QueenCoordinator {
     this.protocolExecutor = protocolExecutor;
     this.workflowExecutor = workflowExecutor;
     this.domainPlugins = domainPlugins;
-    this.config = { ...DEFAULT_CONFIG55, ...config };
+    this.config = { ...DEFAULT_CONFIG56, ...config };
     this.auditLogger = createTaskAuditLogger({
       enableConsoleLog: this.config.enableMetrics,
       maxEntries: 1e3,
@@ -88076,7 +89159,7 @@ async function createDefaultMemoryBackend(autoInitialize2 = true) {
 }
 
 // src/init/token-bootstrap.ts
-var DEFAULT_CONFIG56 = {
+var DEFAULT_CONFIG57 = {
   enableOptimization: true,
   enablePersistence: true,
   storagePath: process.env.AQE_STORAGE_PATH ?? ".aqe",
@@ -88090,7 +89173,7 @@ async function bootstrapTokenTracking(config) {
   if (initialized) {
     return;
   }
-  const cfg = { ...DEFAULT_CONFIG56, ...config };
+  const cfg = { ...DEFAULT_CONFIG57, ...config };
   if (cfg.verbose) {
     console.log("[TokenBootstrap] Initializing token tracking...");
   }
@@ -89272,7 +90355,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 +90464,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 +90492,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 +90509,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 +90526,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 +90538,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 +90557,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 +90574,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 +90600,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 +90625,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 +90670,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 +90756,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 +90936,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 +90976,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 +90988,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 +91006,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;
   }
@@ -90054,7 +91137,6 @@ var configurationRules = [
     condition: (a) => a.existingTests.totalCount === 0,
     apply: (config) => {
       config.workers.enabled = ["pattern-consolidator"];
-      config.domains.enabled = ["test-generation", "coverage-analysis", "learning-optimization"];
       config.learning.qualityThreshold = 0.5;
       config.learning.promotionThreshold = 2;
     }
@@ -90217,28 +91299,29 @@ var SelfConfigurator = class {
   }
   /**
    * Recommend enabled domains
+   *
+   * IMPORTANT: Always enable ALL 12 domains by default.
+   * Limiting domains causes "No factory registered" errors in fleet_init
+   * when MCP tools try to use domains that aren't enabled.
+   *
+   * Project analysis is used for prioritization and worker selection,
+   * but all domains remain available for users who need them.
    */
-  recommendDomains(analysis) {
-    const domains = /* @__PURE__ */ new Set([
+  recommendDomains(_analysis) {
+    return [
       "test-generation",
       "test-execution",
       "coverage-analysis",
+      "quality-assessment",
+      "defect-intelligence",
+      "requirements-validation",
+      "code-intelligence",
+      "security-compliance",
+      "contract-testing",
+      "visual-accessibility",
+      "chaos-resilience",
       "learning-optimization"
-    ]);
-    if (analysis.hasCIConfig) {
-      domains.add("quality-assessment");
-    }
-    if (analysis.codeComplexity.totalFiles > 100) {
-      domains.add("security-compliance");
-    }
-    if (analysis.frameworks.some((f) => ["playwright", "cypress"].includes(f.name))) {
-      domains.add("visual-accessibility");
-    }
-    if (analysis.hasTypeScript || analysis.codeComplexity.recommendation === "complex") {
-      domains.add("code-intelligence");
-    }
-    domains.add("contract-testing");
-    return Array.from(domains);
+    ];
   }
   /**
    * Recommend max concurrent agents
@@ -90256,7 +91339,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 +91449,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 +91488,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 +91523,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 +91557,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 +91568,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 +91582,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 +91606,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 +91659,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 +91668,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 +91756,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 +91795,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 +91836,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 +91895,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 +91932,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 +91948,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 +92081,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 +92097,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 +92160,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 +92206,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 +92252,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 +92289,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 +92317,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 +92330,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 +92569,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 +92619,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 +92844,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 +92878,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 +92891,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 +92908,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 +92934,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",
@@ -91911,7 +92994,22 @@ var InitOrchestrator = class {
           overwrite: false
         },
         domains: {
-          enabled: ["test-generation", "coverage-analysis", "learning-optimization"],
+          // Enable ALL domains - v3 supports all 12 DDD domains
+          // Limiting to 3 causes "No factory registered" errors in fleet_init
+          enabled: [
+            "test-generation",
+            "test-execution",
+            "coverage-analysis",
+            "quality-assessment",
+            "defect-intelligence",
+            "requirements-validation",
+            "code-intelligence",
+            "security-compliance",
+            "contract-testing",
+            "visual-accessibility",
+            "chaos-resilience",
+            "learning-optimization"
+          ],
           disabled: []
         },
         agents: {
@@ -92014,7 +93112,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 +93155,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 +93176,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 +93205,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 +93256,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 +93286,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 +93298,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 +93319,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 +93482,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 +93540,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 +93575,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 +93804,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 +93843,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 +93867,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 +93878,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 +93992,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 +94147,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 +94158,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 +94202,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 +94365,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 +94383,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 +94438,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 +94460,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 +94498,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 +94520,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 +94542,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 +94563,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 +94602,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 +94622,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 +94643,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 +94813,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 +94822,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 +94929,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 +94950,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 +94970,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 +94980,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 +95026,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 +95036,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 +95045,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 +95158,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 +95172,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 +95209,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 +95252,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 +95676,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 +95703,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 +95785,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 +95845,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 +96321,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 +96348,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 +97545,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 +97636,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 +97655,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 +97678,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 +97692,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 +97710,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 +101076,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 +101188,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 +101223,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 +101244,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 +102818,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 +102844,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
-      {
-        name: "v3-qe-patterns",
-        type: "sqlite",
-        path: "../v3/.agentic-qe/memory.db",
-        targetTable: "aqe.qe_patterns",
-        priority: "high",
-        mode: "incremental",
-        query: "SELECT * FROM qe_patterns",
-        enabled: true
-      },
+      // ============================================================
+      // ROOT Memory - PRIMARY (Consolidated from V3 + Historical)
+      // All tables now in single database: .agentic-qe/memory.db
+      // ============================================================
       {
-        name: "v3-sona-patterns",
+        name: "root-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 +102866,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 +102890,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 +102915,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 +108817,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 +109076,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 +109335,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 +110277,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.4.0" : "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);