agentic-qe 3.3.5 → 3.4.0

package/v3/dist/cli/bundle.js

@@ -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;
@@ -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,6 +8630,866 @@ 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;
@@ -9181,6 +10047,8 @@ var UnifiedMemoryManager = class _UnifiedMemoryManager {
   initPromise = null;
   preparedStatements = /* @__PURE__ */ new Map();
   vectorIndex = new InMemoryHNSWIndex();
+  // CRDT store for distributed state synchronization
+  crdtStore = null;
   constructor(config) {
     const resolvedDefaults = getResolvedDefaultConfig();
     this.config = { ...resolvedDefaults, ...config };
@@ -9536,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)
   // ============================================================================
   /**
@@ -12152,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,
@@ -12172,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();
@@ -12764,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,
@@ -12774,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 });
   }
@@ -18017,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
@@ -18049,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) {
@@ -19891,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,
@@ -19915,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
@@ -22079,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,
@@ -22092,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
@@ -27356,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
@@ -27376,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;
@@ -27888,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
@@ -27913,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 };
     }
   }
   // ============================================================================
@@ -29630,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,
@@ -29645,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,
@@ -30669,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: {
@@ -30714,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);
     }
@@ -31552,7 +32613,7 @@ function getSystemMetricsCollector() {
 }
 
 // src/domains/quality-assessment/services/quality-analyzer.ts
-var DEFAULT_CONFIG12 = {
+var DEFAULT_CONFIG13 = {
   enableTrendAnalysis: true,
   trendDataPointsMin: 3,
   complexityThresholds: {
@@ -31587,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;
@@ -32216,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,
@@ -32246,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;
@@ -34400,7 +35461,7 @@ function generateContentHash(content) {
 }
 
 // src/domains/quality-assessment/coordinator.ts
-var DEFAULT_CONFIG14 = {
+var DEFAULT_CONFIG15 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   publishEvents: true,
@@ -34425,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);
@@ -36438,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"],
@@ -36451,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
@@ -36965,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,
@@ -37012,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 });
@@ -37782,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,
@@ -37829,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();
@@ -38420,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,
@@ -38563,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;
@@ -39105,7 +40166,7 @@ ${fix.codeExample}
 };
 
 // src/domains/defect-intelligence/coordinator.ts
-var DEFAULT_CONFIG19 = {
+var DEFAULT_CONFIG20 = {
   maxConcurrentWorkflows: 5,
   defaultTimeout: 6e4,
   enablePatternLearning: true,
@@ -39124,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);
@@ -40129,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,
@@ -40172,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;
@@ -40746,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,
@@ -40755,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;
   /**
@@ -41209,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
@@ -41218,7 +42279,7 @@ var TestabilityScorerService = class {
   constructor(memory, config = {}) {
     this.memory = memory;
     this.config = {
-      ...DEFAULT_CONFIG22,
+      ...DEFAULT_CONFIG23,
       ...config,
       weights: { ...DEFAULT_WEIGHTS, ...config.weights }
     };
@@ -41929,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,
@@ -41985,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,
@@ -44517,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,
@@ -44582,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;
@@ -45176,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,
@@ -45189,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;
@@ -45757,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,
@@ -45787,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;
@@ -48060,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
@@ -48087,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,
@@ -50007,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,
@@ -52009,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,
@@ -52021,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();
   }
   /**
@@ -52931,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;
@@ -53125,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,
@@ -53147,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;
   // ==========================================================================
@@ -54735,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,
@@ -54938,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) {
@@ -55791,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
@@ -55816,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,
@@ -57007,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,
@@ -57030,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
@@ -58370,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,
@@ -58379,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;
   /**
@@ -59042,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
@@ -59065,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,
@@ -60263,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,
@@ -60272,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;
   /**
@@ -61649,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: {
@@ -61677,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
@@ -62696,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",
@@ -62705,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;
   /**
@@ -63001,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,
@@ -63042,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;
@@ -64636,7 +65697,7 @@ var DEVICE_VIEWPORTS = {
     hasTouch: false
   }
 };
-var DEFAULT_CONFIG41 = {
+var DEFAULT_CONFIG42 = {
   viewports: [
     DEVICE_VIEWPORTS["iphone-14"],
     DEVICE_VIEWPORTS["ipad-mini"],
@@ -64652,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;
   /**
@@ -65402,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
@@ -65425,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,
@@ -67211,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,
@@ -67237,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();
   }
@@ -68085,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,
@@ -68097,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;
@@ -68634,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,
@@ -68648,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;
@@ -69425,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
@@ -69448,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,
@@ -71378,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,
@@ -71402,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)
@@ -72287,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,
@@ -72296,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;
   // ============================================================================
@@ -72800,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,
@@ -72814,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;
   // ============================================================================
@@ -73418,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,
@@ -73432,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;
   // ============================================================================
@@ -76509,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
@@ -76541,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,
@@ -78616,7 +79677,7 @@ var WorkflowEvents = {
   StepFailed: "workflow.StepFailed",
   StepSkipped: "workflow.StepSkipped"
 };
-var DEFAULT_CONFIG52 = {
+var DEFAULT_CONFIG53 = {
   maxConcurrentWorkflows: 10,
   defaultStepTimeout: 6e4,
   defaultWorkflowTimeout: 6e5,
@@ -78628,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();
@@ -80286,7 +81347,7 @@ function findProjectRoot2() {
   }
   return process.cwd();
 }
-var DEFAULT_CONFIG53 = {
+var DEFAULT_CONFIG54 = {
   maxConcurrentAgents: AGENT_CONSTANTS.MAX_CONCURRENT_AGENTS,
   memoryBackend: "hybrid",
   hnswEnabled: true,
@@ -80304,7 +81365,7 @@ 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 = findProjectRoot2();
     const dataDir = this._config.dataDir || path9.join(projectRoot, ".agentic-qe");
@@ -80524,7 +81585,7 @@ function createdAtComparator() {
 }
 
 // src/coordination/services/task-audit-logger.ts
-var DEFAULT_CONFIG54 = {
+var DEFAULT_CONFIG55 = {
   enableConsoleLog: true,
   maxEntries: 1e3,
   logPrefix: "[TASK]"
@@ -80533,7 +81594,7 @@ var TaskAuditLogger = class {
   entries = [];
   config;
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG54, ...config };
+    this.config = { ...DEFAULT_CONFIG55, ...config };
   }
   /**
    * Log a task operation
@@ -84258,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
@@ -84293,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,
@@ -88098,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",
@@ -88112,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...");
   }
@@ -90076,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;
     }
@@ -90239,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
@@ -91933,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: {
@@ -109201,7 +110277,7 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command13();
-var VERSION = true ? "3.3.5" : "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);