agentic-qe 3.6.16 → 3.6.18

package/v3/dist/cli/bundle.js

@@ -617,18 +617,18 @@ var init_logger_factory = __esm({
           return this.instances.get(domain);
         }
         const level = this.getDomainLevel(domain);
-        let logger19;
+        let logger22;
         if (this.config.silent) {
-          logger19 = new NullLogger(domain);
+          logger22 = new NullLogger(domain);
         } else if (this.customProvider) {
-          logger19 = this.customProvider(domain, level, context2);
+          logger22 = this.customProvider(domain, level, context2);
         } else {
-          logger19 = new ConsoleLogger(domain, level, this.config.consoleConfig, context2);
+          logger22 = new ConsoleLogger(domain, level, this.config.consoleConfig, context2);
         }
         if (!context2) {
-          this.instances.set(domain, logger19);
+          this.instances.set(domain, logger22);
         }
-        return logger19;
+        return logger22;
       }
       /**
        * Get a logger (alias for create)
@@ -4409,7 +4409,7 @@ var init_ollama_client = __esm({
        * Sleep utility for retry delays
        */
       sleep(ms) {
-        return new Promise((resolve14) => setTimeout(resolve14, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
       /**
        * Get Ollama server info
@@ -5618,7 +5618,7 @@ Focus on accuracy over speed. It's better to mark something as "INCONCLUSIVE" if
        * Sleep for specified milliseconds
        */
       sleep(ms) {
-        return new Promise((resolve14) => setTimeout(resolve14, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
       /**
        * Get cost per token for current model
@@ -5944,7 +5944,7 @@ Focus on accuracy over speed. It's better to mark something as "INCONCLUSIVE" if
        * Sleep for specified milliseconds
        */
       sleep(ms) {
-        return new Promise((resolve14) => setTimeout(resolve14, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
       /**
        * Get cost per token for current model
@@ -6228,7 +6228,7 @@ Focus on accuracy over speed. It's better to mark something as "INCONCLUSIVE" if
        * Sleep for specified milliseconds
        */
       sleep(ms) {
-        return new Promise((resolve14) => setTimeout(resolve14, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
       /**
        * Get cost per token for current model
@@ -6514,7 +6514,7 @@ var init_openrouter_provider = __esm({
        * Sleep for a given duration
        */
       sleep(ms) {
-        return new Promise((resolve14) => setTimeout(resolve14, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
       /**
        * Get default system prompt for security verification
@@ -6797,7 +6797,7 @@ var init_ollama_provider = __esm({
        * Sleep for a given duration
        */
       sleep(ms) {
-        return new Promise((resolve14) => setTimeout(resolve14, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
       /**
        * Get default system prompt for security verification
@@ -8495,7 +8495,7 @@ var init_gnn_wrapper = __esm({
        * Save index to file
        * Note: @ruvector/gnn uses JSON serialization for layers
        */
-      async saveIndex(namespace, path26) {
+      async saveIndex(namespace, path27) {
         const index = this.indexes.get(namespace);
         if (!index) {
           throw new Error(`Namespace ${namespace} not initialized`);
@@ -8505,15 +8505,15 @@ var init_gnn_wrapper = __esm({
           vector: Array.from(emb.vector),
           metadata: emb.metadata
         }));
-        const fs23 = await import("fs/promises");
-        await fs23.writeFile(path26, JSON.stringify(data, null, 2));
+        const fs25 = await import("fs/promises");
+        await fs25.writeFile(path27, JSON.stringify(data, null, 2));
       }
       /**
        * Load index from file
        */
-      async loadIndex(namespace, path26) {
-        const fs23 = await import("fs/promises");
-        const content = await fs23.readFile(path26, "utf-8");
+      async loadIndex(namespace, path27) {
+        const fs25 = await import("fs/promises");
+        const content = await fs25.readFile(path27, "utf-8");
         const data = safeJsonParse(content);
         this.initializeIndex(namespace);
         for (const item of data) {
@@ -9693,7 +9693,7 @@ var init_path_traversal_validator = __esm({
       /**
        * Validate a file path against traversal attacks
        */
-      validate(path26, options = {}) {
+      validate(path27, options = {}) {
         const {
           basePath = "",
           allowAbsolute = false,
@@ -9702,7 +9702,7 @@ var init_path_traversal_validator = __esm({
           maxDepth = 10,
           maxLength = 4096
         } = options;
-        if (path26.length > maxLength) {
+        if (path27.length > maxLength) {
           return {
             valid: false,
             error: `Path exceeds maximum length of ${maxLength}`,
@@ -9710,7 +9710,7 @@ var init_path_traversal_validator = __esm({
           };
         }
         for (const pattern of PATH_TRAVERSAL_PATTERNS) {
-          if (pattern.test(path26)) {
+          if (pattern.test(path27)) {
             return {
               valid: false,
               error: "Path traversal attempt detected",
@@ -9718,7 +9718,7 @@ var init_path_traversal_validator = __esm({
             };
           }
         }
-        if (!allowAbsolute && (path26.startsWith("/") || /^[A-Z]:/i.test(path26))) {
+        if (!allowAbsolute && (path27.startsWith("/") || /^[A-Z]:/i.test(path27))) {
           return {
             valid: false,
             error: "Absolute paths are not allowed",
@@ -9726,7 +9726,7 @@ var init_path_traversal_validator = __esm({
           };
         }
         for (const pattern of DANGEROUS_PATH_COMPONENTS) {
-          if (pattern.test(path26)) {
+          if (pattern.test(path27)) {
             return {
               valid: false,
               error: "Access to system paths is not allowed",
@@ -9734,7 +9734,7 @@ var init_path_traversal_validator = __esm({
             };
           }
         }
-        const normalizedPath = this.normalizePath(path26);
+        const normalizedPath = this.normalizePath(path27);
         if (normalizedPath.includes("..")) {
           return {
             valid: false,
@@ -9797,8 +9797,8 @@ var init_path_traversal_validator = __esm({
       /**
        * Normalize a path by resolving . and .. components
        */
-      normalizePath(path26) {
-        let normalized = path26.replace(/\\/g, "/");
+      normalizePath(path27) {
+        let normalized = path27.replace(/\\/g, "/");
         normalized = normalized.replace(/\/+/g, "/");
         const parts = normalized.split("/");
         const result = [];
@@ -9839,13 +9839,13 @@ var init_path_traversal_validator = __esm({
       /**
        * Get file extension from path
        */
-      getExtension(path26) {
-        const match = path26.match(/\.([^./\\]+)$/);
+      getExtension(path27) {
+        const match = path27.match(/\.([^./\\]+)$/);
         return match ? match[1] : null;
       }
     };
     defaultValidator2 = new PathTraversalValidator();
-    validatePath = (path26, options) => defaultValidator2.validate(path26, options);
+    validatePath = (path27, options) => defaultValidator2.validate(path27, options);
   }
 });
 
@@ -10692,23 +10692,23 @@ var init_knowledge_graph = __esm({
           if (!incremental) {
             await this.clear();
           }
-          for (const path26 of paths) {
+          for (const path27 of paths) {
             try {
               if (languages && languages.length > 0) {
-                const ext = this.getFileExtension(path26);
+                const ext = this.getFileExtension(path27);
                 if (!this.matchesLanguage(ext, languages)) {
                   continue;
                 }
               }
-              if (!includeTests && this.isTestFile(path26)) {
+              if (!includeTests && this.isTestFile(path27)) {
                 continue;
               }
-              const result = await this.indexFile(path26);
+              const result = await this.indexFile(path27);
               nodesCreated += result.nodes;
               edgesCreated += result.edges;
             } catch (fileError) {
               errors.push({
-                file: path26,
+                file: path27,
                 error: toErrorMessage(fileError)
               });
             }
@@ -11422,16 +11422,16 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
           }
         });
       }
-      async traverseDependencies(file, direction, depth, visited, nodes, edges, path26, cycles) {
+      async traverseDependencies(file, direction, depth, visited, nodes, edges, path27, cycles) {
         if (depth <= 0 || visited.has(file)) {
-          const cycleStart = path26.indexOf(file);
+          const cycleStart = path27.indexOf(file);
           if (cycleStart >= 0) {
-            cycles.push([...path26.slice(cycleStart), file]);
+            cycles.push([...path27.slice(cycleStart), file]);
           }
           return;
         }
         visited.add(file);
-        path26.push(file);
+        path27.push(file);
         const nodeId = this.pathToNodeId(file);
         const fileEdges = await this.getEdges(nodeId, direction);
         const inDegree = fileEdges.filter((e20) => e20.target === nodeId).length;
@@ -11461,12 +11461,12 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
               visited,
               nodes,
               edges,
-              path26,
+              path27,
               cycles
             );
           }
         }
-        path26.pop();
+        path27.pop();
       }
       calculateDependencyMetrics(nodes, edges) {
         const totalNodes = nodes.length;
@@ -11551,23 +11551,23 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
         const magnitude2 = Math.sqrt(embedding.reduce((sum, v62) => sum + v62 * v62, 0)) || 1;
         return embedding.map((v62) => v62 / magnitude2);
       }
-      pathToNodeId(path26) {
-        return path26.replace(/[/\\]/g, ":").replace(/\./g, "_");
+      pathToNodeId(path27) {
+        return path27.replace(/[/\\]/g, ":").replace(/\./g, "_");
       }
       nodeIdToPath(nodeId) {
-        const path26 = nodeId.replace(/:/g, "/").replace(/_(?=[^_]*$)/, ".");
-        return path26.includes("/") ? path26 : null;
+        const path27 = nodeId.replace(/:/g, "/").replace(/_(?=[^_]*$)/, ".");
+        return path27.includes("/") ? path27 : null;
       }
-      getFileName(path26) {
-        return path26.split(/[/\\]/).pop() || path26;
+      getFileName(path27) {
+        return path27.split(/[/\\]/).pop() || path27;
       }
-      getFileExtension(path26) {
-        const name = this.getFileName(path26);
+      getFileExtension(path27) {
+        const name = this.getFileName(path27);
         const parts = name.split(".");
         return parts.length > 1 ? parts.pop() : "";
       }
-      getFileType(path26) {
-        const ext = this.getFileExtension(path26);
+      getFileType(path27) {
+        const ext = this.getFileExtension(path27);
         const typeMap = {
           ts: "typescript",
           tsx: "typescript-react",
@@ -11596,7 +11596,7 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
           return exts.includes(ext);
         });
       }
-      isTestFile(path26) {
+      isTestFile(path27) {
         const testPatterns = [
           /\.test\.[tj]sx?$/,
           /\.spec\.[tj]sx?$/,
@@ -11605,7 +11605,7 @@ ${JSON.stringify(results.map((n61) => ({ id: n61.id, label: n61.label, propertie
           /.*_test\.py$/,
           /.*_test\.go$/
         ];
-        return testPatterns.some((pattern) => pattern.test(path26));
+        return testPatterns.some((pattern) => pattern.test(path27));
       }
       /**
        * Dispose of all resources and clear caches.
@@ -12718,7 +12718,7 @@ var init_spreading_activation = __esm({
        * Helper to sleep for a duration
        */
       sleep(ms) {
-        return new Promise((resolve14) => setTimeout(resolve14, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
     };
   }
@@ -15645,11 +15645,11 @@ var init_sqlite_persistence = __esm({
             this.db = this.unifiedMemory.getDatabase();
             console.log(`[SQLitePatternStore] Using unified storage: ${this.unifiedMemory.getDbPath()}`);
           } else {
-            const path26 = await import("path");
-            const fs23 = await import("fs");
-            const dir = path26.dirname(this.config.dbPath);
-            if (!fs23.existsSync(dir)) {
-              fs23.mkdirSync(dir, { recursive: true });
+            const path27 = await import("path");
+            const fs25 = await import("fs");
+            const dir = path27.dirname(this.config.dbPath);
+            if (!fs25.existsSync(dir)) {
+              fs25.mkdirSync(dir, { recursive: true });
             }
             this.db = openDatabase(this.config.dbPath);
             this.db.pragma(`mmap_size = ${this.config.mmapSize}`);
@@ -16881,7 +16881,7 @@ __export(qe_reasoning_bank_exports, {
 function createQEReasoningBank(memory, eventBus, config, coherenceService) {
   return new QEReasoningBank(memory, eventBus, config, coherenceService);
 }
-var logger17, DEFAULT_QE_REASONING_BANK_CONFIG, QEReasoningBank;
+var logger20, DEFAULT_QE_REASONING_BANK_CONFIG, QEReasoningBank;
 var init_qe_reasoning_bank = __esm({
   "src/learning/qe-reasoning-bank.ts"() {
     "use strict";
@@ -16894,7 +16894,7 @@ var init_qe_reasoning_bank = __esm({
     init_sqlite_persistence();
     init_qe_patterns();
     init_qe_guidance();
-    logger17 = LoggerFactory.create("QEReasoningBank");
+    logger20 = LoggerFactory.create("QEReasoningBank");
     DEFAULT_QE_REASONING_BANK_CONFIG = {
       enableLearning: true,
       enableGuidance: true,
@@ -16934,7 +16934,7 @@ var init_qe_reasoning_bank = __esm({
         if (!this.sqliteStore) {
           this.sqliteStore = createSQLitePatternStore();
           this.sqliteStore.initialize().catch((e20) => {
-            logger17.warn("SQLitePatternStore init failed", { error: toErrorMessage(e20) });
+            logger20.warn("SQLitePatternStore init failed", { error: toErrorMessage(e20) });
           });
         }
         return this.sqliteStore;
@@ -17015,7 +17015,7 @@ var init_qe_reasoning_bank = __esm({
           await store.initialize();
           this.patternStore.setSqliteStore(store);
         } catch (e20) {
-          logger17.warn("Failed to wire SQLitePatternStore into PatternStore", { error: toErrorMessage(e20) });
+          logger20.warn("Failed to wire SQLitePatternStore into PatternStore", { error: toErrorMessage(e20) });
         }
         await this.loadPretrainedPatterns();
         this.initialized = true;
@@ -17027,12 +17027,12 @@ var init_qe_reasoning_bank = __esm({
             await this.seedCrossDomainPatterns();
           } else {
             const stats = await this.patternStore.getStats();
-            logger17.info("Cross-domain transfer already complete", { totalPatterns: stats.totalPatterns });
+            logger20.info("Cross-domain transfer already complete", { totalPatterns: stats.totalPatterns });
           }
         } catch (error) {
-          logger17.warn("Cross-domain seeding failed (non-fatal)", { error });
+          logger20.warn("Cross-domain seeding failed (non-fatal)", { error });
         }
-        logger17.info("Initialized");
+        logger20.info("Initialized");
       }
       /**
        * Load pre-trained patterns for common QE scenarios
@@ -17040,7 +17040,7 @@ var init_qe_reasoning_bank = __esm({
       async loadPretrainedPatterns() {
         const stats = await this.patternStore.getStats();
         if (stats.totalPatterns > 0) {
-          logger17.info("Found existing patterns", { totalPatterns: stats.totalPatterns });
+          logger20.info("Found existing patterns", { totalPatterns: stats.totalPatterns });
           return;
         }
         const foundationalPatterns = [
@@ -17758,10 +17758,10 @@ On promotion:
           try {
             await this.patternStore.create(options);
           } catch (error) {
-            logger17.warn("Failed to load pattern", { name: options.name, error });
+            logger20.warn("Failed to load pattern", { name: options.name, error });
           }
         }
-        logger17.info("Loaded foundational patterns", { count: foundationalPatterns.length });
+        logger20.info("Loaded foundational patterns", { count: foundationalPatterns.length });
       }
       /**
        * Seed cross-domain patterns by transferring generalizable patterns
@@ -17844,7 +17844,7 @@ On promotion:
             }
           }
         }
-        logger17.info("Cross-domain transfer complete", { transferred, skipped });
+        logger20.info("Cross-domain transfer complete", { transferred, skipped });
         return { transferred, skipped };
       }
       /**
@@ -17923,7 +17923,7 @@ On promotion:
             outcome.feedback
           );
         } catch (persistError) {
-          logger17.warn("SQLite pattern usage persist failed", { error: toErrorMessage(persistError) });
+          logger20.warn("SQLite pattern usage persist failed", { error: toErrorMessage(persistError) });
         }
         if (result.success) {
           this.stats.learningOutcomes++;
@@ -17933,7 +17933,7 @@ On promotion:
           const pattern = await this.getPattern(outcome.patternId);
           if (pattern && await this.checkPatternPromotionWithCoherence(pattern)) {
             await this.promotePattern(outcome.patternId);
-            logger17.info("Pattern promoted to long-term", { name: pattern.name });
+            logger20.info("Pattern promoted to long-term", { name: pattern.name });
           }
         }
         return result;
@@ -17980,7 +17980,7 @@ On promotion:
                 payload: event
               });
             }
-            logger17.info("Pattern promotion blocked due to coherence violation", {
+            logger20.info("Pattern promotion blocked due to coherence violation", {
               name: pattern.name,
               energy: coherenceResult.energy
             });
@@ -18009,9 +18009,9 @@ On promotion:
           try {
             this.getSqliteStore().promotePattern(patternId);
           } catch (e20) {
-            logger17.warn("SQLite pattern promotion persist failed", { error: toErrorMessage(e20) });
+            logger20.warn("SQLite pattern promotion persist failed", { error: toErrorMessage(e20) });
           }
-          logger17.info("Promoted pattern to long-term", { patternId });
+          logger20.info("Promoted pattern to long-term", { patternId });
           if (this.eventBus) {
             await this.eventBus.publish({
               id: `pattern-promoted-${patternId}`,
@@ -18022,7 +18022,7 @@ On promotion:
             });
           }
         } else {
-          logger17.error("Failed to promote pattern", result.error, { patternId });
+          logger20.error("Failed to promote pattern", result.error, { patternId });
         }
       }
       /**
@@ -18148,7 +18148,7 @@ On promotion:
             return embedding;
           } catch (error) {
             if (process.env.DEBUG) {
-              logger17.warn("ONNX embeddings unavailable, using hash fallback", {
+              logger20.warn("ONNX embeddings unavailable, using hash fallback", {
                 error: toErrorMessage(error)
               });
             }
@@ -33348,12 +33348,12 @@ var DeterministicGatewayIntegration = class {
   /**
    * Validate a single value against its schema
    */
-  validateValue(value, schema, path26) {
+  validateValue(value, schema, path27) {
     const errors = [];
     if (schema.required && (value === void 0 || value === null)) {
       errors.push({
-        path: path26,
-        message: `${path26} is required`,
+        path: path27,
+        message: `${path27} is required`,
         expected: schema.type,
         received: "undefined"
       });
@@ -33365,8 +33365,8 @@ var DeterministicGatewayIntegration = class {
     const actualType = Array.isArray(value) ? "array" : typeof value;
     if (actualType !== schema.type) {
       errors.push({
-        path: path26,
-        message: `${path26} must be of type ${schema.type}`,
+        path: path27,
+        message: `${path27} must be of type ${schema.type}`,
         expected: schema.type,
         received: actualType
       });
@@ -33375,16 +33375,16 @@ var DeterministicGatewayIntegration = class {
     if (schema.type === "string" && typeof value === "string") {
       if (schema.minLength !== void 0 && value.length < schema.minLength) {
         errors.push({
-          path: path26,
-          message: `${path26} must be at least ${schema.minLength} characters`,
+          path: path27,
+          message: `${path27} must be at least ${schema.minLength} characters`,
           expected: `minLength: ${schema.minLength}`,
           received: `length: ${value.length}`
         });
       }
       if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
         errors.push({
-          path: path26,
-          message: `${path26} must be at most ${schema.maxLength} characters`,
+          path: path27,
+          message: `${path27} must be at most ${schema.maxLength} characters`,
           expected: `maxLength: ${schema.maxLength}`,
           received: `length: ${value.length}`
         });
@@ -33392,8 +33392,8 @@ var DeterministicGatewayIntegration = class {
       const patternRegex = schema.pattern ? createSafeRegex(schema.pattern) : null;
       if (patternRegex && !patternRegex.test(value)) {
         errors.push({
-          path: path26,
-          message: `${path26} must match pattern ${schema.pattern}`,
+          path: path27,
+          message: `${path27} must match pattern ${schema.pattern}`,
           expected: `pattern: ${schema.pattern}`,
           received: value
         });
@@ -33402,16 +33402,16 @@ var DeterministicGatewayIntegration = class {
     if (schema.type === "number" && typeof value === "number") {
       if (schema.min !== void 0 && value < schema.min) {
         errors.push({
-          path: path26,
-          message: `${path26} must be at least ${schema.min}`,
+          path: path27,
+          message: `${path27} must be at least ${schema.min}`,
           expected: `min: ${schema.min}`,
           received: `${value}`
         });
       }
       if (schema.max !== void 0 && value > schema.max) {
         errors.push({
-          path: path26,
-          message: `${path26} must be at most ${schema.max}`,
+          path: path27,
+          message: `${path27} must be at most ${schema.max}`,
           expected: `max: ${schema.max}`,
           received: `${value}`
         });
@@ -33419,22 +33419,22 @@ var DeterministicGatewayIntegration = class {
     }
     if (schema.enum && !schema.enum.includes(value)) {
       errors.push({
-        path: path26,
-        message: `${path26} must be one of: ${schema.enum.join(", ")}`,
+        path: path27,
+        message: `${path27} must be one of: ${schema.enum.join(", ")}`,
         expected: `enum: [${schema.enum.join(", ")}]`,
         received: String(value)
       });
     }
     if (schema.type === "array" && Array.isArray(value) && schema.items) {
       value.forEach((item, index) => {
-        const itemErrors = this.validateValue(item, schema.items, `${path26}[${index}]`);
+        const itemErrors = this.validateValue(item, schema.items, `${path27}[${index}]`);
         errors.push(...itemErrors);
       });
     }
     if (schema.type === "object" && typeof value === "object" && schema.properties) {
       const objValue = value;
       for (const [propName, propSchema] of Object.entries(schema.properties)) {
-        const propErrors = this.validateValue(objValue[propName], propSchema, `${path26}.${propName}`);
+        const propErrors = this.validateValue(objValue[propName], propSchema, `${path27}.${propName}`);
         errors.push(...propErrors);
       }
     }
@@ -44951,7 +44951,7 @@ Provide:
       return err(new Error(`Test file not found: ${file}`));
     }
     const { command, args } = this.buildTestCommand(file, framework);
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       let stdout = "";
       let stderr = "";
       let killed = false;
@@ -44968,7 +44968,7 @@ Provide:
       const timeoutId = setTimeout(() => {
         killed = true;
         proc.kill("SIGTERM");
-        resolve14(err(new Error(`Test execution timed out after ${timeout}ms for file: ${file}`)));
+        resolve15(err(new Error(`Test execution timed out after ${timeout}ms for file: ${file}`)));
       }, timeout);
       proc.stdout?.on("data", (data) => {
         stdout += data.toString();
@@ -44982,11 +44982,11 @@ Provide:
           return;
         }
         const parseResult = this.parseTestOutput(stdout, stderr, file, framework, code);
-        resolve14(parseResult);
+        resolve15(parseResult);
       });
       proc.on("error", (error) => {
         clearTimeout(timeoutId);
-        resolve14(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
+        resolve15(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
       });
     });
   }
@@ -45573,7 +45573,7 @@ var FlakyDetectorService = class {
     const results = /* @__PURE__ */ new Map();
     const runId = v4_default();
     const startTime = Date.now();
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       const args = [...this.config.testRunnerArgs, file];
       const cwd = this.config.cwd ?? process.cwd();
       const child = spawn2(this.config.testRunner, args, {
@@ -45638,7 +45638,7 @@ var FlakyDetectorService = class {
               results.set(testId, records);
             }
           }
-          resolve14(results);
+          resolve15(results);
         } catch (parseError) {
           const testId = this.generateTestId(file, "main");
           results.set(testId, [
@@ -45654,7 +45654,7 @@ var FlakyDetectorService = class {
               }
             }
           ]);
-          resolve14(results);
+          resolve15(results);
         }
       });
     });
@@ -46529,7 +46529,7 @@ var RetryHandlerService = class {
    * Spawn a test process and parse the result
    */
   spawnTestProcess(command, args, cwd) {
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       const timeout = this.config.testTimeout;
       let stdout = "";
       let stderr = "";
@@ -46558,7 +46558,7 @@ var RetryHandlerService = class {
           return;
         }
         const result = this.parseTestResult(code, stdout, stderr);
-        resolve14(result);
+        resolve15(result);
       });
       proc.on("error", (err3) => {
         clearTimeout(timeoutHandle);
@@ -46647,7 +46647,7 @@ var RetryHandlerService = class {
     return Math.min(delay, maxDelay);
   }
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
   async recordRetry(testId, result) {
     const history = this.retryHistory.get(testId) ?? [];
@@ -47314,7 +47314,7 @@ var AgentBrowserCommandExecutor = class {
    * Execute a command asynchronously (for long-running ops)
    */
   async executeAsync(command, args = []) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       const fullArgs = this.buildArgs(command, args);
       if (this.config.debug) {
         console.log(`[agent-browser] Executing async: npx agent-browser ${fullArgs.join(" ")}`);
@@ -47334,16 +47334,16 @@ var AgentBrowserCommandExecutor = class {
         if (code === 0) {
           try {
             const parsed = safeJsonParse(stdout.trim());
-            resolve14({ success: true, data: parsed });
+            resolve15({ success: true, data: parsed });
           } catch {
-            resolve14({ success: true, data: stdout.trim() });
+            resolve15({ success: true, data: stdout.trim() });
           }
         } else {
-          resolve14({ success: false, error: stderr || `Exit code: ${code}` });
+          resolve15({ success: false, error: stderr || `Exit code: ${code}` });
         }
       });
       process2.on("error", (error) => {
-        resolve14({ success: false, error: error.message });
+        resolve15({ success: false, error: error.message });
       });
     });
   }
@@ -47457,11 +47457,11 @@ var AgentBrowserCommandExecutor = class {
   /**
    * Take screenshot
    */
-  screenshot(path26, fullPage) {
+  screenshot(path27, fullPage) {
     const args = [];
-    if (path26) args.push(path26);
+    if (path27) args.push(path27);
     if (fullPage) args.push("--full");
-    if (!path26) args.push("--json");
+    if (!path27) args.push("--json");
     return this.execute("screenshot", args);
   }
   // ========================================================================
@@ -47539,14 +47539,14 @@ var AgentBrowserCommandExecutor = class {
   /**
    * Save browser state (cookies, storage)
    */
-  saveState(path26) {
-    return this.execute("state", ["save", path26]);
+  saveState(path27) {
+    return this.execute("state", ["save", path27]);
   }
   /**
    * Load browser state
    */
-  loadState(path26) {
-    return this.execute("state", ["load", path26]);
+  loadState(path27) {
+    return this.execute("state", ["load", path27]);
   }
   // ========================================================================
   // Trace recording
@@ -48823,9 +48823,9 @@ var AgentBrowserClient = class {
   /**
    * Save browser state (cookies, storage, etc.)
    */
-  async saveState(path26) {
+  async saveState(path27) {
     try {
-      const result = this.executor.saveState(path26);
+      const result = this.executor.saveState(path27);
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Save state failed", "SAVE_STATE_FAILED", "agent-browser"));
       }
@@ -48844,9 +48844,9 @@ var AgentBrowserClient = class {
   /**
    * Load previously saved browser state
    */
-  async loadState(path26) {
+  async loadState(path27) {
     try {
-      const result = this.executor.loadState(path26);
+      const result = this.executor.loadState(path27);
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Load state failed", "LOAD_STATE_FAILED", "agent-browser"));
       }
@@ -49220,10 +49220,10 @@ var BrowserOrchestrator = class {
   useAgentBrowser;
   config;
   log;
-  constructor(client, config, logger19) {
+  constructor(client, config, logger22) {
     this.client = client;
     this.config = config;
-    this.log = logger19;
+    this.log = logger22;
     this.unifiedClient = config.browserClient ?? client;
     this.useAgentBrowser = isAgentBrowserClient(this.unifiedClient);
   }
@@ -49414,17 +49414,17 @@ var BrowserOrchestrator = class {
     return options;
   }
 };
-function createBrowserOrchestrator(client, config, logger19) {
-  return new BrowserOrchestrator(client, config, logger19);
+function createBrowserOrchestrator(client, config, logger22) {
+  return new BrowserOrchestrator(client, config, logger22);
 }
 
 // src/domains/test-execution/services/e2e/assertion-handlers.ts
 var AssertionHandlers = class {
   orchestrator;
   log;
-  constructor(orchestrator, logger19) {
+  constructor(orchestrator, logger22) {
     this.orchestrator = orchestrator;
-    this.log = logger19;
+    this.log = logger22;
   }
   // ==========================================================================
   // Unified Browser Client Assertions
@@ -49837,8 +49837,8 @@ var AssertionHandlers = class {
     this.assertCondition(matches, step, expected, actual);
   }
 };
-function createAssertionHandlers(orchestrator, logger19) {
-  return new AssertionHandlers(orchestrator, logger19);
+function createAssertionHandlers(orchestrator, logger22) {
+  return new AssertionHandlers(orchestrator, logger22);
 }
 
 // src/domains/test-execution/services/e2e/wait-condition-handler.ts
@@ -49936,7 +49936,7 @@ var WaitConditionHandler = class {
    * Delay execution
    */
   delay(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
 function createWaitConditionHandler(orchestrator) {
@@ -49951,12 +49951,12 @@ var StepExecutors = class {
   assertionHandlers;
   waitConditionHandler;
   log;
-  constructor(config, orchestrator, logger19) {
+  constructor(config, orchestrator, logger22) {
     this.config = config;
     this.orchestrator = orchestrator;
-    this.assertionHandlers = createAssertionHandlers(orchestrator, logger19);
+    this.assertionHandlers = createAssertionHandlers(orchestrator, logger22);
     this.waitConditionHandler = createWaitConditionHandler(orchestrator);
-    this.log = logger19;
+    this.log = logger22;
   }
   /**
    * Execute a single step based on its type
@@ -50361,11 +50361,11 @@ var StepExecutors = class {
     return new URL(url, baseUrl).toString();
   }
   delay(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
-function createStepExecutors(config, orchestrator, logger19) {
-  return new StepExecutors(config, orchestrator, logger19);
+function createStepExecutors(config, orchestrator, logger22) {
+  return new StepExecutors(config, orchestrator, logger22);
 }
 
 // src/shared/utils/safe-expression-evaluator.ts
@@ -50678,10 +50678,10 @@ var StepRetryHandler = class {
   config;
   stepExecutors;
   log;
-  constructor(config, stepExecutors, logger19) {
+  constructor(config, stepExecutors, logger22) {
     this.config = config;
     this.stepExecutors = stepExecutors;
-    this.log = logger19;
+    this.log = logger22;
   }
   /**
    * Execute a step with retry logic
@@ -50771,13 +50771,13 @@ var StepRetryHandler = class {
    * Wrap promise with timeout
    */
   async withTimeout(promise, timeout, stepId) {
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       const timer = setTimeout(() => {
         reject(new StepTimeoutError(stepId, timeout));
       }, timeout);
       promise.then((result) => {
         clearTimeout(timer);
-        resolve14(result);
+        resolve15(result);
       }).catch((error) => {
         clearTimeout(timer);
         reject(error);
@@ -50788,11 +50788,11 @@ var StepRetryHandler = class {
    * Delay execution
    */
   delay(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
-function createStepRetryHandler(config, stepExecutors, logger19) {
-  return new StepRetryHandler(config, stepExecutors, logger19);
+function createStepRetryHandler(config, stepExecutors, logger22) {
+  return new StepRetryHandler(config, stepExecutors, logger22);
 }
 
 // src/domains/test-execution/services/e2e/result-collector.ts
@@ -50918,10 +50918,10 @@ var E2ETestRunnerService = class {
   constructor(client, config = {}) {
     this.client = client;
     this.config = { ...DEFAULT_E2E_RUNNER_CONFIG, ...config };
-    const logger19 = (message) => this.log(message);
-    this.orchestrator = createBrowserOrchestrator(client, this.config, logger19);
-    this.stepExecutors = createStepExecutors(this.config, this.orchestrator, logger19);
-    this.retryHandler = createStepRetryHandler(this.config, this.stepExecutors, logger19);
+    const logger22 = (message) => this.log(message);
+    this.orchestrator = createBrowserOrchestrator(client, this.config, logger22);
+    this.stepExecutors = createStepExecutors(this.config, this.orchestrator, logger22);
+    this.retryHandler = createStepRetryHandler(this.config, this.stepExecutors, logger22);
     this.resultCollector = createResultCollector();
     this.log(
       `E2E Runner initialized with ${this.orchestrator.isUsingAgentBrowser() ? "agent-browser" : "vibium"} client`
@@ -51133,7 +51133,7 @@ var E2ETestRunnerService = class {
    * Delay execution
    */
   delay(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
   /**
    * Log message if verbose mode is enabled
@@ -54095,16 +54095,16 @@ var CoverageEmbedder = class {
     const idealRegions = Math.ceil(coverage.uncoveredLines.length / 5);
     return regions > 0 ? Math.min(1, idealRegions / regions) : 0;
   }
-  extractPathFeatures(path26) {
-    const parts = path26.split("/").filter(Boolean);
-    const extension = path26.split(".").pop() || "";
+  extractPathFeatures(path27) {
+    const parts = path27.split("/").filter(Boolean);
+    const extension = path27.split(".").pop() || "";
     const fileName = parts[parts.length - 1] || "";
     return {
       depth: parts.length,
       extension,
-      hashNormalized: this.hashString(path26) / 1e6,
-      isTest: /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(path26) || parts.includes("tests") || parts.includes("__tests__"),
-      isConfig: /\.(config|rc)\.(ts|js|json|yaml|yml)$/.test(path26),
+      hashNormalized: this.hashString(path27) / 1e6,
+      isTest: /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(path27) || parts.includes("tests") || parts.includes("__tests__"),
+      isConfig: /\.(config|rc)\.(ts|js|json|yaml|yml)$/.test(path27),
       isIndex: fileName.startsWith("index."),
       inSrc: parts.includes("src"),
       inLib: parts.includes("lib"),
@@ -54422,12 +54422,12 @@ var GhostCoverageAnalyzerService = class _GhostCoverageAnalyzerService {
   ratio(n61, d74) {
     return d74 > 0 ? n61 / d74 : 0;
   }
-  gapId(path26, cat) {
-    const h66 = `${path26}:${cat}`.split("").reduce((a37, c70) => (a37 << 5) - a37 + c70.charCodeAt(0) | 0, 0);
+  gapId(path27, cat) {
+    const h66 = `${path27}:${cat}`.split("").reduce((a37, c70) => (a37 << 5) - a37 + c70.charCodeAt(0) | 0, 0);
     return `phantom-${Math.abs(h66).toString(16)}`;
   }
-  gapDescription(path26, cat, dist) {
-    const n61 = path26.split("/").pop() || path26;
+  gapDescription(path27, cat, dist) {
+    const n61 = path27.split("/").pop() || path27;
     const s70 = dist > 0.7 ? "significant" : dist > 0.4 ? "moderate" : "minor";
     const m74 = {
       "missing-error-handler": `${n61}: ${s70} missing error handler tests. Cover error paths and failure recovery.`,
@@ -57474,10 +57474,10 @@ ${codeContext.slice(0, 2e3)}
     const coverage = await this.memory.get(key);
     return coverage ?? null;
   }
-  hashFilePath(path26) {
+  hashFilePath(path27) {
     let hash = 0;
-    for (let i58 = 0; i58 < path26.length; i58++) {
-      hash = (hash << 5) - hash + path26.charCodeAt(i58);
+    for (let i58 = 0; i58 < path27.length; i58++) {
+      hash = (hash << 5) - hash + path27.charCodeAt(i58);
       hash = hash & hash;
     }
     return hash.toString(16);
@@ -71227,7 +71227,7 @@ var ImpactAnalyzerService = class {
   // ============================================================================
   // Private Helper Methods
   // ============================================================================
-  isTestFile(path26) {
+  isTestFile(path27) {
     const testPatterns = [
       /\.test\.[tj]sx?$/,
       /\.spec\.[tj]sx?$/,
@@ -71236,15 +71236,15 @@ var ImpactAnalyzerService = class {
       /.*_test\.py$/,
       /.*_test\.go$/
     ];
-    return testPatterns.some((pattern) => pattern.test(path26));
+    return testPatterns.some((pattern) => pattern.test(path27));
   }
-  isCriticalPath(path26) {
+  isCriticalPath(path27) {
     const criticalPatterns = this.config.criticalPaths.map(
       (p74) => p74.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*")
     );
-    return criticalPatterns.some((pattern) => new RegExp(pattern).test(path26));
+    return criticalPatterns.some((pattern) => new RegExp(pattern).test(path27));
   }
-  isEntryPoint(path26) {
+  isEntryPoint(path27) {
     const entryPatterns = [
       /\/index\.[tj]sx?$/,
       /\/main\.[tj]sx?$/,
@@ -71254,14 +71254,14 @@ var ImpactAnalyzerService = class {
       /\/__init__\.py$/,
       /\/main\.go$/
     ];
-    return entryPatterns.some((pattern) => pattern.test(path26));
+    return entryPatterns.some((pattern) => pattern.test(path27));
   }
-  getBaseName(path26) {
-    const fileName = this.getFileName(path26);
+  getBaseName(path27) {
+    const fileName = this.getFileName(path27);
     return fileName.replace(/\.[^.]+$/, "");
   }
-  getFileName(path26) {
-    return path26.split(/[/\\]/).pop() || path26;
+  getFileName(path27) {
+    return path27.split(/[/\\]/).pop() || path27;
   }
   deduplicateImpact(impact) {
     const seen = /* @__PURE__ */ new Map();
@@ -72041,10 +72041,10 @@ function countTestsByFilePattern(projectPath, config) {
             fileTests = countTestsInGoFile(fullPath);
           }
           total += fileTests;
-          const path26 = fullPath.toLowerCase();
-          if (path26.includes("e2e") || path26.includes("end-to-end")) {
+          const path27 = fullPath.toLowerCase();
+          if (path27.includes("e2e") || path27.includes("end-to-end")) {
             e2e += fileTests;
-          } else if (path26.includes("integration")) {
+          } else if (path27.includes("integration")) {
             integration += fileTests;
           } else {
             unit += fileTests;
@@ -72867,7 +72867,7 @@ var HypergraphEngine = class {
     ];
     const effectiveMaxDepth = Math.min(maxDepth, this.config.maxTraversalDepth);
     while (queue.length > 0) {
-      const { nodeId, depth, path: path26 } = queue.shift();
+      const { nodeId, depth, path: path27 } = queue.shift();
       if (!visitedNodes.has(nodeId)) {
         const node = await this.getNode(nodeId);
         if (node) {
@@ -72876,7 +72876,7 @@ var HypergraphEngine = class {
       }
       maxDepthReached = Math.max(maxDepthReached, depth);
       if (depth >= effectiveMaxDepth) {
-        paths.push(path26);
+        paths.push(path27);
         continue;
       }
       const edgeCriteria = { sourceId: nodeId };
@@ -72885,15 +72885,15 @@ var HypergraphEngine = class {
       }
       const edges = await this.findEdges(edgeCriteria);
       if (edges.length === 0) {
-        paths.push(path26);
+        paths.push(path27);
         continue;
       }
       for (const edge of edges) {
         if (!visitedEdges.has(edge.id)) {
           visitedEdges.set(edge.id, edge);
           const newPath = {
-            nodes: [...path26.nodes, edge.targetId],
-            edges: [...path26.edges, edge.id]
+            nodes: [...path27.nodes, edge.targetId],
+            edges: [...path27.edges, edge.id]
           };
           queue.push({
             nodeId: edge.targetId,
@@ -73274,11 +73274,11 @@ async function createHypergraphEngine(config) {
 init_wrappers();
 async function indexCodeEmbeddings(gnnIndex, fileReader, paths) {
   try {
-    for (const path26 of paths) {
+    for (const path27 of paths) {
       try {
-        const result = await fileReader.readFile(path26);
+        const result = await fileReader.readFile(path27);
         if (result.success && result.value) {
-          const embedding = await generateCodeEmbedding(path26, result.value);
+          const embedding = await generateCodeEmbedding(path27, result.value);
           const embeddingObj = {
             vector: embedding,
             dimension: 384,
@@ -73286,12 +73286,12 @@ async function indexCodeEmbeddings(gnnIndex, fileReader, paths) {
             text: result.value.slice(0, 1e3),
             timestamp: Date.now(),
             quantization: "none",
-            metadata: { path: path26 }
+            metadata: { path: path27 }
           };
           gnnIndex.addEmbedding(embeddingObj);
         }
       } catch (error) {
-        console.error(`Failed to index ${path26}:`, error);
+        console.error(`Failed to index ${path27}:`, error);
       }
     }
     console.log(`[GNN] Indexed ${paths.length} code embeddings`);
@@ -73299,9 +73299,9 @@ async function indexCodeEmbeddings(gnnIndex, fileReader, paths) {
     console.error("Failed to index code embeddings:", error);
   }
 }
-async function generateCodeEmbedding(path26, content) {
+async function generateCodeEmbedding(path27, content) {
   const features = [];
-  const ext = path26.split(".").pop();
+  const ext = path27.split(".").pop();
   const typeHash = hashCode(ext || "");
   features.push(typeHash % 1e3 / 1e3);
   features.push(Math.min(1, content.length / 1e4));
@@ -73722,14 +73722,14 @@ var CodeIntelligenceCoordinator = class extends BaseDomainCoordinator {
   async initializeHypergraph() {
     try {
       const { openDatabase: openDatabase2 } = await Promise.resolve().then(() => (init_safe_db(), safe_db_exports));
-      const fs23 = await import("fs");
-      const path26 = await import("path");
+      const fs25 = await import("fs");
+      const path27 = await import("path");
       const { findProjectRoot: findProjectRoot2 } = await Promise.resolve().then(() => (init_unified_memory(), unified_memory_exports));
       const projectRoot = findProjectRoot2();
-      const dbPath = this.config.hypergraphDbPath || path26.join(projectRoot, ".agentic-qe", "hypergraph.db");
-      const dir = path26.dirname(dbPath);
-      if (!fs23.existsSync(dir)) {
-        fs23.mkdirSync(dir, { recursive: true });
+      const dbPath = this.config.hypergraphDbPath || path27.join(projectRoot, ".agentic-qe", "hypergraph.db");
+      const dir = path27.dirname(dbPath);
+      if (!fs25.existsSync(dir)) {
+        fs25.mkdirSync(dir, { recursive: true });
       }
       this.hypergraphDb = openDatabase2(dbPath);
       this.hypergraph = await createHypergraphEngine({
@@ -74257,11 +74257,11 @@ var CodeIntelligenceCoordinator = class extends BaseDomainCoordinator {
   // ============================================================================
   async indexForSemanticSearch(paths) {
     const filesToIndex = paths.slice(0, 100);
-    for (const path26 of filesToIndex) {
+    for (const path27 of filesToIndex) {
       try {
-        const result = await this.fileReader.readFile(path26);
+        const result = await this.fileReader.readFile(path27);
         if (result.success && result.value) {
-          await this.semanticAnalyzer.indexCode(path26, result.value);
+          await this.semanticAnalyzer.indexCode(path27, result.value);
         }
       } catch {
       }
@@ -74469,8 +74469,8 @@ var CodeIntelligenceCoordinator = class extends BaseDomainCoordinator {
       for (const marker of markers) {
         try {
           const markerPath = `${currentPath}/${marker}`;
-          const fs23 = __require("fs");
-          if (fs23.existsSync(markerPath)) {
+          const fs25 = __require("fs");
+          if (fs25.existsSync(markerPath)) {
             return currentPath;
           }
         } catch {
@@ -74975,8 +74975,8 @@ var FilePath = class _FilePath {
   equals(other) {
     return this._value === other._value;
   }
-  static create(path26) {
-    return new _FilePath(path26);
+  static create(path27) {
+    return new _FilePath(path27);
   }
 };
 var RiskScore = class _RiskScore {
@@ -75714,8 +75714,8 @@ var SASTScanner = class {
     let content;
     let lines;
     try {
-      const fs23 = await import("fs/promises");
-      content = await fs23.readFile(filePath, "utf-8");
+      const fs25 = await import("fs/promises");
+      content = await fs25.readFile(filePath, "utf-8");
       lines = content.split("\n");
     } catch {
       return { vulnerabilities: [], linesScanned: 0 };
@@ -76405,10 +76405,10 @@ async function extractAndCrawlLinks(html, baseUrl, currentCrawled, maxDepth, vul
     }
   }
   const linksToCrawl = Array.from(discoveredLinks).slice(0, Math.min(10, maxCrawl - crawledUrls));
-  for (const path26 of linksToCrawl) {
+  for (const path27 of linksToCrawl) {
     if (crawledUrls >= maxCrawl) break;
     try {
-      const crawlUrl = new URL(path26, baseUrl.origin).toString();
+      const crawlUrl = new URL(path27, baseUrl.origin).toString();
       const crawlResponse = await fetch(crawlUrl, {
         method: "GET",
         headers: { "User-Agent": "AgenticQE-DAST-Scanner/3.0" },
@@ -76417,11 +76417,11 @@ async function extractAndCrawlLinks(html, baseUrl, currentCrawled, maxDepth, vul
       });
       crawledUrls++;
       if (crawlResponse.ok) {
-        if (path26.includes("password") || path26.includes("token") || path26.includes("api_key")) {
+        if (path27.includes("password") || path27.includes("token") || path27.includes("api_key")) {
           vulnerabilities.push({
             id: v4_default(),
             title: "Sensitive Data in URL Path",
-            description: `URL path may contain sensitive parameter names: ${path26}`,
+            description: `URL path may contain sensitive parameter names: ${path27}`,
             severity: "medium",
             category: "sensitive-data",
             location: { file: crawlUrl },
@@ -77117,7 +77117,7 @@ var HttpClient = class {
    * Sleep utility for retry delays
    */
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
 function createHttpClient() {
@@ -77930,8 +77930,8 @@ var DependencyScanner = class {
    */
   async scanPackageJson(packageJsonPath) {
     try {
-      const fs23 = await import("fs/promises");
-      const content = await fs23.readFile(packageJsonPath, "utf-8");
+      const fs25 = await import("fs/promises");
+      const content = await fs25.readFile(packageJsonPath, "utf-8");
       const packageJson = safeJsonParse(content);
       const allDependencies = {
         ...packageJson.dependencies || {},
@@ -82247,17 +82247,17 @@ Provide:
       warnings.push("No consumers defined for contract");
     }
   }
-  validateServiceInfo(info, path26, errors) {
+  validateServiceInfo(info, path27, errors) {
     if (!info.name || info.name.trim() === "") {
       errors.push({
-        path: `${path26}.name`,
+        path: `${path27}.name`,
         message: "Service name is required",
         code: "REQUIRED_FIELD"
       });
     }
     if (!info.version || info.version.trim() === "") {
       errors.push({
-        path: `${path26}.version`,
+        path: `${path27}.version`,
         message: "Service version is required",
         code: "REQUIRED_FIELD"
       });
@@ -82903,13 +82903,13 @@ Provide:
   /**
    * Validate nested field selections
    */
-  validateGraphQLSelections(selections, typeName, schemaInfo, path26, errors) {
+  validateGraphQLSelections(selections, typeName, schemaInfo, path27, errors) {
     const typeDef = schemaInfo.types[typeName];
     if (!typeDef) {
       if (["String", "Int", "Float", "Boolean", "ID"].includes(typeName)) {
         if (selections.length > 0) {
           errors.push({
-            path: path26,
+            path: path27,
             keyword: "selection",
             message: `Cannot select fields on scalar type '${typeName}'`,
             params: { type: typeName }
@@ -82922,7 +82922,7 @@ Provide:
       const fieldDef = typeDef.fields[selection.name];
       if (!fieldDef) {
         errors.push({
-          path: `${path26}.${selection.name}`,
+          path: `${path27}.${selection.name}`,
           keyword: "field",
           message: `Field '${selection.name}' does not exist on type '${typeName}'`,
           params: { field: selection.name, type: typeName }
@@ -82933,7 +82933,7 @@ Provide:
           selection.selections,
           nestedType,
           schemaInfo,
-          `${path26}.${selection.name}`,
+          `${path27}.${selection.name}`,
           errors
         );
       }
@@ -82942,14 +82942,14 @@ Provide:
   /**
    * Validate variable type matches expected GraphQL type
    */
-  validateGraphQLVariableType(value, expectedType, path26, errors) {
+  validateGraphQLVariableType(value, expectedType, path27, errors) {
     const baseType = this.unwrapGraphQLType(expectedType);
     const isNonNull = expectedType.endsWith("!");
     const isList = expectedType.includes("[");
     if (value === null || value === void 0) {
       if (isNonNull) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "type",
           message: `Variable cannot be null (expected ${expectedType})`,
           params: { expectedType }
@@ -82960,7 +82960,7 @@ Provide:
     if (isList) {
       if (!Array.isArray(value)) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "type",
           message: `Expected array for type ${expectedType}`,
           params: { expectedType, actualType: typeof value }
@@ -82973,7 +82973,7 @@ Provide:
       case "ID":
         if (typeof value !== "string") {
           errors.push({
-            path: path26,
+            path: path27,
             keyword: "type",
             message: `Expected string for type ${baseType}`,
             params: { expectedType: baseType, actualType: typeof value }
@@ -82983,7 +82983,7 @@ Provide:
       case "Int":
         if (typeof value !== "number" || !Number.isInteger(value)) {
           errors.push({
-            path: path26,
+            path: path27,
             keyword: "type",
             message: `Expected integer for type Int`,
             params: { expectedType: "Int", actualType: typeof value }
@@ -82993,7 +82993,7 @@ Provide:
       case "Float":
         if (typeof value !== "number") {
           errors.push({
-            path: path26,
+            path: path27,
             keyword: "type",
             message: `Expected number for type Float`,
             params: { expectedType: "Float", actualType: typeof value }
@@ -83003,7 +83003,7 @@ Provide:
       case "Boolean":
         if (typeof value !== "boolean") {
           errors.push({
-            path: path26,
+            path: path27,
             keyword: "type",
             message: `Expected boolean for type Boolean`,
             params: { expectedType: "Boolean", actualType: typeof value }
@@ -83014,7 +83014,7 @@ Provide:
       default:
         if (typeof value !== "object") {
           errors.push({
-            path: path26,
+            path: path27,
             keyword: "type",
             message: `Expected object for type ${baseType}`,
             params: { expectedType: baseType, actualType: typeof value }
@@ -83022,10 +83022,10 @@ Provide:
         }
     }
   }
-  basicTypeValidation(data, schema, path26, errors, depth = 0) {
+  basicTypeValidation(data, schema, path27, errors, depth = 0) {
     if (depth > this.config.maxSchemaDepth) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "maxDepth",
         message: "Maximum schema depth exceeded",
         params: { maxDepth: this.config.maxSchemaDepth }
@@ -83042,7 +83042,7 @@ Provide:
       for (const prop of required) {
         if (!(prop in dataObj)) {
           errors.push({
-            path: path26 ? `${path26}.${prop}` : prop,
+            path: path27 ? `${path27}.${prop}` : prop,
             keyword: "required",
             message: `Required property '${prop}' is missing`,
             params: { missingProperty: prop }
@@ -83054,7 +83054,7 @@ Provide:
           this.basicTypeValidation(
             dataObj[prop],
             propSchema,
-            path26 ? `${path26}.${prop}` : prop,
+            path27 ? `${path27}.${prop}` : prop,
             errors,
             depth + 1
           );
@@ -83063,26 +83063,26 @@ Provide:
     } else if (type === "array" && actualType === "array") {
       const items = schema.items;
       const dataArr = data;
-      this.validateArrayConstraints(dataArr, schema, path26, errors);
+      this.validateArrayConstraints(dataArr, schema, path27, errors);
       if (items) {
         for (let i58 = 0; i58 < dataArr.length; i58++) {
           this.basicTypeValidation(
             dataArr[i58],
             items,
-            `${path26}[${i58}]`,
+            `${path27}[${i58}]`,
             errors,
             depth + 1
           );
         }
       }
     } else if (type === "string" && actualType === "string") {
-      this.validateStringConstraints(data, schema, path26, errors);
+      this.validateStringConstraints(data, schema, path27, errors);
     } else if ((type === "number" || type === "integer") && (actualType === "number" || actualType === "integer")) {
-      this.validateNumberConstraints(data, schema, path26, errors);
+      this.validateNumberConstraints(data, schema, path27, errors);
     } else if (type !== actualType) {
       if (!(type === "number" && actualType === "integer")) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "type",
           message: `Expected type '${type}' but got '${actualType}'`,
           params: { expectedType: type, actualType }
@@ -83093,7 +83093,7 @@ Provide:
       const enumValues = schema.enum;
       if (!enumValues.some((v62) => JSON.stringify(v62) === JSON.stringify(data))) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "enum",
           message: `Value must be one of: ${enumValues.map((v62) => JSON.stringify(v62)).join(", ")}`,
           params: { allowedValues: enumValues }
@@ -83101,13 +83101,13 @@ Provide:
       }
     }
   }
-  validateStringConstraints(data, schema, path26, errors) {
+  validateStringConstraints(data, schema, path27, errors) {
     const minLength = schema.minLength;
     const maxLength = schema.maxLength;
     const pattern = schema.pattern;
     if (minLength !== void 0 && data.length < minLength) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "minLength",
         message: `String must be at least ${minLength} characters`,
         params: { limit: minLength, actual: data.length }
@@ -83115,7 +83115,7 @@ Provide:
     }
     if (maxLength !== void 0 && data.length > maxLength) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "maxLength",
         message: `String must be at most ${maxLength} characters`,
         params: { limit: maxLength, actual: data.length }
@@ -83125,7 +83125,7 @@ Provide:
       const regex = createSafeRegex(pattern);
       if (regex && !regex.test(data)) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "pattern",
           message: `String must match pattern: ${pattern}`,
           params: { pattern }
@@ -83133,7 +83133,7 @@ Provide:
       }
     }
   }
-  validateNumberConstraints(data, schema, path26, errors) {
+  validateNumberConstraints(data, schema, path27, errors) {
     const minimum = schema.minimum;
     const maximum = schema.maximum;
     const exclusiveMinimum = schema.exclusiveMinimum;
@@ -83141,7 +83141,7 @@ Provide:
     const multipleOf = schema.multipleOf;
     if (minimum !== void 0 && data < minimum) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "minimum",
         message: `Number must be >= ${minimum}`,
         params: { limit: minimum, actual: data }
@@ -83149,7 +83149,7 @@ Provide:
     }
     if (maximum !== void 0 && data > maximum) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "maximum",
         message: `Number must be <= ${maximum}`,
         params: { limit: maximum, actual: data }
@@ -83157,7 +83157,7 @@ Provide:
     }
     if (exclusiveMinimum !== void 0 && data <= exclusiveMinimum) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "exclusiveMinimum",
         message: `Number must be > ${exclusiveMinimum}`,
         params: { limit: exclusiveMinimum, actual: data }
@@ -83165,7 +83165,7 @@ Provide:
     }
     if (exclusiveMaximum !== void 0 && data >= exclusiveMaximum) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "exclusiveMaximum",
         message: `Number must be < ${exclusiveMaximum}`,
         params: { limit: exclusiveMaximum, actual: data }
@@ -83173,20 +83173,20 @@ Provide:
     }
     if (multipleOf !== void 0 && data % multipleOf !== 0) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "multipleOf",
         message: `Number must be a multiple of ${multipleOf}`,
         params: { multipleOf, actual: data }
       });
     }
   }
-  validateArrayConstraints(data, schema, path26, errors) {
+  validateArrayConstraints(data, schema, path27, errors) {
     const minItems = schema.minItems;
     const maxItems = schema.maxItems;
     const uniqueItems = schema.uniqueItems;
     if (minItems !== void 0 && data.length < minItems) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "minItems",
         message: `Array must have at least ${minItems} items`,
         params: { limit: minItems, actual: data.length }
@@ -83194,7 +83194,7 @@ Provide:
     }
     if (maxItems !== void 0 && data.length > maxItems) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "maxItems",
         message: `Array must have at most ${maxItems} items`,
         params: { limit: maxItems, actual: data.length }
@@ -83206,7 +83206,7 @@ Provide:
         const serialized = JSON.stringify(data[i58]);
         if (seen.has(serialized)) {
           errors.push({
-            path: `${path26}[${i58}]`,
+            path: `${path27}[${i58}]`,
             keyword: "uniqueItems",
             message: "Array items must be unique",
             params: { duplicateIndex: i58 }
@@ -83702,11 +83702,11 @@ var ApiCompatibilityService = class {
     } catch {
     }
   }
-  scanObjectForDeprecations(obj, path26, deprecations, version, context2) {
+  scanObjectForDeprecations(obj, path27, deprecations, version, context2) {
     if (!obj || typeof obj !== "object") return;
     const record = obj;
     if (record.deprecated === true) {
-      const location = context2 ? `${context2} -> ${path26}` : path26;
+      const location = context2 ? `${context2} -> ${path27}` : path27;
       deprecations.push({
         location,
         reason: typeof record.description === "string" ? record.description : "Field marked as deprecated",
@@ -83715,7 +83715,7 @@ var ApiCompatibilityService = class {
       });
     }
     if (record["x-deprecated"] === true) {
-      const location = context2 ? `${context2} -> ${path26}` : path26;
+      const location = context2 ? `${context2} -> ${path27}` : path27;
       deprecations.push({
         location,
         reason: typeof record["x-deprecated-message"] === "string" ? record["x-deprecated-message"] : "Element marked as deprecated via x-deprecated",
@@ -83727,7 +83727,7 @@ var ApiCompatibilityService = class {
       for (const [propName, propValue] of Object.entries(props)) {
         this.scanObjectForDeprecations(
           propValue,
-          `${path26}.${propName}`,
+          `${path27}.${propName}`,
           deprecations,
           version,
           context2
@@ -83737,7 +83737,7 @@ var ApiCompatibilityService = class {
     if (record.items && typeof record.items === "object") {
       this.scanObjectForDeprecations(
         record.items,
-        `${path26}[]`,
+        `${path27}[]`,
         deprecations,
         version,
         context2
@@ -84486,13 +84486,13 @@ var ContractTestingCoordinator = class extends BaseDomainCoordinator {
     }
     return contracts;
   }
-  async loadContractFromPath(path26) {
-    const content = await this.loadFileContent(path26);
+  async loadContractFromPath(path27) {
+    const content = await this.loadFileContent(path27);
     if (!content) {
       return null;
     }
     try {
-      const filePath = path26.value.toLowerCase();
+      const filePath = path27.value.toLowerCase();
       if (filePath.endsWith(".json")) {
         const parsed = safeJsonParse(content);
         if (parsed.openapi || parsed.swagger) {
@@ -84500,22 +84500,22 @@ var ContractTestingCoordinator = class extends BaseDomainCoordinator {
         }
         return parsed;
       } else if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
-        console.warn("YAML contract files not yet supported:", path26.value);
+        console.warn("YAML contract files not yet supported:", path27.value);
         return null;
       }
       return safeJsonParse(content);
     } catch (error) {
       console.error(
-        `Failed to parse contract from ${path26.value}:`,
+        `Failed to parse contract from ${path27.value}:`,
         toErrorMessage(error)
       );
       return null;
     }
   }
-  async loadFileContent(path26) {
-    const result = await this.fileReader.readFile(path26.value);
+  async loadFileContent(path27) {
+    const result = await this.fileReader.readFile(path27.value);
     if (!result.success) {
-      console.error(`Failed to read file ${path26.value}:`, result.error);
+      console.error(`Failed to read file ${path27.value}:`, result.error);
       return null;
     }
     return result.value;
@@ -84526,13 +84526,13 @@ var ContractTestingCoordinator = class extends BaseDomainCoordinator {
     const paths = spec.paths || {};
     const endpoints = [];
     const schemas = [];
-    for (const [path26, methods] of Object.entries(paths)) {
+    for (const [path27, methods] of Object.entries(paths)) {
       const httpMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
       for (const method of httpMethods) {
         const operation = methods[method.toLowerCase()];
         if (operation) {
           endpoints.push({
-            path: path26,
+            path: path27,
             method,
             requestSchema: this.extractRequestSchema(operation),
             responseSchema: this.extractResponseSchema(operation),
@@ -85261,10 +85261,10 @@ var SchemaValidatorService = class {
   // ============================================================================
   // Private Validation Methods
   // ============================================================================
-  validateValue(value, schema, path26, errors, depth) {
+  validateValue(value, schema, path27, errors, depth) {
     if (depth > this.config.maxRecursionDepth) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "maxDepth",
         message: "Maximum recursion depth exceeded",
         params: { maxDepth: this.config.maxRecursionDepth }
@@ -85277,7 +85277,7 @@ var SchemaValidatorService = class {
       }
       if (this.config.strictMode) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "type",
           message: "Value cannot be null",
           params: {}
@@ -85287,15 +85287,15 @@ var SchemaValidatorService = class {
     }
     const schemaType = schema.type;
     if (schema.oneOf) {
-      this.validateOneOf(value, schema.oneOf, path26, errors, depth);
+      this.validateOneOf(value, schema.oneOf, path27, errors, depth);
       return;
     }
     if (schema.anyOf) {
-      this.validateAnyOf(value, schema.anyOf, path26, errors, depth);
+      this.validateAnyOf(value, schema.anyOf, path27, errors, depth);
       return;
     }
     if (schema.allOf) {
-      this.validateAllOf(value, schema.allOf, path26, errors, depth);
+      this.validateAllOf(value, schema.allOf, path27, errors, depth);
       return;
     }
     if (schemaType) {
@@ -85303,7 +85303,7 @@ var SchemaValidatorService = class {
       const actualType = this.getJsonType(value);
       if (!types.some((t50) => this.typesMatch(actualType, t50))) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "type",
           message: `Expected type '${types.join(" | ")}' but got '${actualType}'`,
           params: { expectedType: types, actualType }
@@ -85312,19 +85312,19 @@ var SchemaValidatorService = class {
       }
     }
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-      this.validateObject(value, schema, path26, errors, depth);
+      this.validateObject(value, schema, path27, errors, depth);
     } else if (Array.isArray(value)) {
-      this.validateArray(value, schema, path26, errors, depth);
+      this.validateArray(value, schema, path27, errors, depth);
     } else if (typeof value === "string") {
-      this.validateString(value, schema, path26, errors);
+      this.validateString(value, schema, path27, errors);
     } else if (typeof value === "number") {
-      this.validateNumber(value, schema, path26, errors);
+      this.validateNumber(value, schema, path27, errors);
     }
     if (schema.enum) {
       const enumValues = schema.enum;
       if (!enumValues.includes(value)) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "enum",
           message: `Value must be one of: ${enumValues.map((v62) => JSON.stringify(v62)).join(", ")}`,
           params: { allowedValues: enumValues }
@@ -85334,7 +85334,7 @@ var SchemaValidatorService = class {
     if ("const" in schema) {
       if (value !== schema.const) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "const",
           message: `Value must be ${JSON.stringify(schema.const)}`,
           params: { expected: schema.const }
@@ -85342,14 +85342,14 @@ var SchemaValidatorService = class {
       }
     }
   }
-  validateObject(value, schema, path26, errors, depth) {
+  validateObject(value, schema, path27, errors, depth) {
     const properties = schema.properties || {};
     const required = schema.required || [];
     const additionalProperties = schema.additionalProperties;
     for (const prop of required) {
       if (!(prop in value)) {
         errors.push({
-          path: path26 ? `${path26}.${prop}` : prop,
+          path: path27 ? `${path27}.${prop}` : prop,
           keyword: "required",
           message: `Required property '${prop}' is missing`,
           params: { missingProperty: prop }
@@ -85357,7 +85357,7 @@ var SchemaValidatorService = class {
       }
     }
     for (const [prop, propValue] of Object.entries(value)) {
-      const propPath = path26 ? `${path26}.${prop}` : prop;
+      const propPath = path27 ? `${path27}.${prop}` : prop;
       if (prop in properties) {
         this.validateValue(propValue, properties[prop], propPath, errors, depth + 1);
       } else if (this.config.strictMode && additionalProperties === false) {
@@ -85380,7 +85380,7 @@ var SchemaValidatorService = class {
     const propCount = Object.keys(value).length;
     if (typeof schema.minProperties === "number" && propCount < schema.minProperties) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "minProperties",
         message: `Object must have at least ${schema.minProperties} properties`,
         params: { limit: schema.minProperties, actual: propCount }
@@ -85388,23 +85388,23 @@ var SchemaValidatorService = class {
     }
     if (typeof schema.maxProperties === "number" && propCount > schema.maxProperties) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "maxProperties",
         message: `Object must have at most ${schema.maxProperties} properties`,
         params: { limit: schema.maxProperties, actual: propCount }
       });
     }
   }
-  validateArray(value, schema, path26, errors, depth) {
+  validateArray(value, schema, path27, errors, depth) {
     const items = schema.items;
     if (items) {
       for (let i58 = 0; i58 < value.length; i58++) {
-        this.validateValue(value[i58], items, `${path26}[${i58}]`, errors, depth + 1);
+        this.validateValue(value[i58], items, `${path27}[${i58}]`, errors, depth + 1);
       }
     }
     if (typeof schema.minItems === "number" && value.length < schema.minItems) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "minItems",
         message: `Array must have at least ${schema.minItems} items`,
         params: { limit: schema.minItems, actual: value.length }
@@ -85412,7 +85412,7 @@ var SchemaValidatorService = class {
     }
     if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "maxItems",
         message: `Array must have at most ${schema.maxItems} items`,
         params: { limit: schema.maxItems, actual: value.length }
@@ -85424,7 +85424,7 @@ var SchemaValidatorService = class {
         const serialized = JSON.stringify(value[i58]);
         if (seen.has(serialized)) {
           errors.push({
-            path: `${path26}[${i58}]`,
+            path: `${path27}[${i58}]`,
             keyword: "uniqueItems",
             message: "Array items must be unique",
             params: { duplicateIndex: i58 }
@@ -85434,10 +85434,10 @@ var SchemaValidatorService = class {
       }
     }
   }
-  validateString(value, schema, path26, errors) {
+  validateString(value, schema, path27, errors) {
     if (typeof schema.minLength === "number" && value.length < schema.minLength) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "minLength",
         message: `String must be at least ${schema.minLength} characters`,
         params: { limit: schema.minLength, actual: value.length }
@@ -85445,7 +85445,7 @@ var SchemaValidatorService = class {
     }
     if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "maxLength",
         message: `String must be at most ${schema.maxLength} characters`,
         params: { limit: schema.maxLength, actual: value.length }
@@ -85455,7 +85455,7 @@ var SchemaValidatorService = class {
       const regex = createSafeRegex(schema.pattern);
       if (regex && !regex.test(value)) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "pattern",
           message: `String must match pattern '${schema.pattern}'`,
           params: { pattern: schema.pattern }
@@ -85463,15 +85463,15 @@ var SchemaValidatorService = class {
       }
     }
     if (typeof schema.format === "string") {
-      this.validateFormat(value, schema.format, path26, errors);
+      this.validateFormat(value, schema.format, path27, errors);
     }
   }
-  validateNumber(value, schema, path26, errors) {
+  validateNumber(value, schema, path27, errors) {
     if (typeof schema.minimum === "number") {
       if (schema.exclusiveMinimum === true) {
         if (value <= schema.minimum) {
           errors.push({
-            path: path26,
+            path: path27,
             keyword: "exclusiveMinimum",
             message: `Number must be greater than ${schema.minimum}`,
             params: { limit: schema.minimum, actual: value }
@@ -85479,7 +85479,7 @@ var SchemaValidatorService = class {
         }
       } else if (value < schema.minimum) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "minimum",
           message: `Number must be at least ${schema.minimum}`,
           params: { limit: schema.minimum, actual: value }
@@ -85490,7 +85490,7 @@ var SchemaValidatorService = class {
       if (schema.exclusiveMaximum === true) {
         if (value >= schema.maximum) {
           errors.push({
-            path: path26,
+            path: path27,
             keyword: "exclusiveMaximum",
             message: `Number must be less than ${schema.maximum}`,
             params: { limit: schema.maximum, actual: value }
@@ -85498,7 +85498,7 @@ var SchemaValidatorService = class {
         }
       } else if (value > schema.maximum) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "maximum",
           message: `Number must be at most ${schema.maximum}`,
           params: { limit: schema.maximum, actual: value }
@@ -85509,7 +85509,7 @@ var SchemaValidatorService = class {
       const remainder = value % schema.multipleOf;
       if (Math.abs(remainder) > 1e-10) {
         errors.push({
-          path: path26,
+          path: path27,
           keyword: "multipleOf",
           message: `Number must be a multiple of ${schema.multipleOf}`,
           params: { multipleOf: schema.multipleOf, actual: value }
@@ -85517,7 +85517,7 @@ var SchemaValidatorService = class {
       }
     }
   }
-  validateFormat(value, format, path26, errors) {
+  validateFormat(value, format, path27, errors) {
     let isValid = true;
     switch (format) {
       case "email":
@@ -85554,46 +85554,46 @@ var SchemaValidatorService = class {
     }
     if (!isValid) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "format",
         message: `String must be a valid ${format}`,
         params: { format }
       });
     }
   }
-  validateOneOf(value, schemas, path26, errors, depth) {
+  validateOneOf(value, schemas, path27, errors, depth) {
     const validCount = schemas.reduce((count, schema) => {
       const subErrors = [];
-      this.validateValue(value, schema, path26, subErrors, depth + 1);
+      this.validateValue(value, schema, path27, subErrors, depth + 1);
       return count + (subErrors.length === 0 ? 1 : 0);
     }, 0);
     if (validCount !== 1) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "oneOf",
         message: `Value must match exactly one schema (matched ${validCount})`,
         params: { matched: validCount }
       });
     }
   }
-  validateAnyOf(value, schemas, path26, errors, depth) {
+  validateAnyOf(value, schemas, path27, errors, depth) {
     const hasValid = schemas.some((schema) => {
       const subErrors = [];
-      this.validateValue(value, schema, path26, subErrors, depth + 1);
+      this.validateValue(value, schema, path27, subErrors, depth + 1);
       return subErrors.length === 0;
     });
     if (!hasValid) {
       errors.push({
-        path: path26,
+        path: path27,
         keyword: "anyOf",
         message: "Value must match at least one schema",
         params: {}
       });
     }
   }
-  validateAllOf(value, schemas, path26, errors, depth) {
+  validateAllOf(value, schemas, path27, errors, depth) {
     for (const schema of schemas) {
-      this.validateValue(value, schema, path26, errors, depth + 1);
+      this.validateValue(value, schema, path27, errors, depth + 1);
     }
   }
   getJsonType(value) {
@@ -85626,20 +85626,20 @@ var SchemaValidatorService = class {
       });
     }
   }
-  compareSchemaObjects(oldSchema, newSchema, path26, additions, removals, modifications) {
+  compareSchemaObjects(oldSchema, newSchema, path27, additions, removals, modifications) {
     const oldProps = oldSchema.properties || {};
     const newProps = newSchema.properties || {};
     const oldRequired = new Set(oldSchema.required || []);
     const newRequired = new Set(newSchema.required || []);
     for (const prop of Object.keys(oldProps)) {
       if (!(prop in newProps)) {
-        const propPath = path26 ? `${path26}.${prop}` : prop;
+        const propPath = path27 ? `${path27}.${prop}` : prop;
         removals.push(propPath);
       }
     }
     for (const prop of Object.keys(newProps)) {
       if (!(prop in oldProps)) {
-        const propPath = path26 ? `${path26}.${prop}` : prop;
+        const propPath = path27 ? `${path27}.${prop}` : prop;
         additions.push(propPath);
         if (newRequired.has(prop)) {
           modifications.push({
@@ -85653,7 +85653,7 @@ var SchemaValidatorService = class {
     }
     if (oldSchema.type !== newSchema.type) {
       modifications.push({
-        path: path26 || "root",
+        path: path27 || "root",
         oldType: String(oldSchema.type || "any"),
         newType: String(newSchema.type || "any"),
         isBreaking: true
@@ -85662,7 +85662,7 @@ var SchemaValidatorService = class {
     const newRequiredArray = Array.from(newRequired);
     for (const prop of newRequiredArray) {
       if (!oldRequired.has(prop) && prop in oldProps) {
-        const propPath = path26 ? `${path26}.${prop}` : prop;
+        const propPath = path27 ? `${path27}.${prop}` : prop;
         modifications.push({
           path: propPath,
           oldType: "optional",
@@ -86538,7 +86538,7 @@ var VisualTesterService = class {
       const timestamp = /* @__PURE__ */ new Date();
       const urlHash = this.hashUrl(url);
       const viewportKey = `${viewport.width}x${viewport.height}`;
-      const path26 = FilePath.create(
+      const path27 = FilePath.create(
         `${this.config.baselineDirectory}/${urlHash}_${viewportKey}_${screenshotId}.png`
       );
       const loadTime = this.estimateLoadTime(url, viewport);
@@ -86554,7 +86554,7 @@ var VisualTesterService = class {
         url,
         viewport,
         timestamp,
-        path: path26,
+        path: path27,
         metadata
       };
       await this.storeScreenshotMetadata(screenshot);
@@ -86571,7 +86571,7 @@ var VisualTesterService = class {
       const viewport = options?.viewport || this.config.defaultViewport;
       const screenshotId = v4_default();
       const timestamp = /* @__PURE__ */ new Date();
-      const path26 = FilePath.create(
+      const path27 = FilePath.create(
         `${this.config.baselineDirectory}/${screenshotId}.png`
       );
       const metadata = {
@@ -86586,7 +86586,7 @@ var VisualTesterService = class {
         url,
         viewport,
         timestamp,
-        path: path26,
+        path: path27,
         metadata
       };
       await this.storeScreenshotMetadata(screenshot);
@@ -90797,12 +90797,12 @@ var VisualAccessibilityCoordinator = class extends BaseDomainCoordinator {
    */
   extractPathFeatures(url) {
     const features = [];
-    const path26 = new URL(url).pathname;
+    const path27 = new URL(url).pathname;
     const commonPaths = ["dashboard", "checkout", "login", "profile", "settings", "api", "admin", "search"];
     for (const cp of commonPaths) {
-      features.push(path26.includes(cp) ? 1 : 0);
+      features.push(path27.includes(cp) ? 1 : 0);
     }
-    const depth = path26.split("/").filter(Boolean).length;
+    const depth = path27.split("/").filter(Boolean).length;
     features.push(depth / 10);
     features.push(url.includes("?") ? 1 : 0);
     features.push(url.startsWith("https://") ? 1 : 0);
@@ -91900,13 +91900,13 @@ Provide:
     }
   }
   async executeTcpProbe(probe) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       try {
         const [host, portStr] = probe.target.split(":");
         const port = parseInt(portStr, 10);
         if (!host || isNaN(port)) {
           console.log(`TCP probe invalid target: ${probe.target} (expected host:port)`);
-          resolve14(false);
+          resolve15(false);
           return;
         }
         const timeout = probe.timeout ?? 5e3;
@@ -91914,22 +91914,22 @@ Provide:
         const timer = setTimeout(() => {
           socket.destroy();
           console.log(`TCP probe timeout: ${probe.name} -> ${probe.target}`);
-          resolve14(false);
+          resolve15(false);
         }, timeout);
         socket.connect(port, host, () => {
           clearTimeout(timer);
           socket.destroy();
-          resolve14(true);
+          resolve15(true);
         });
         socket.on("error", (err3) => {
           clearTimeout(timer);
           socket.destroy();
           console.log(`TCP probe error: ${probe.name} -> ${err3.message}`);
-          resolve14(false);
+          resolve15(false);
         });
       } catch (error) {
         console.log(`TCP probe exception: ${probe.name} -> ${toErrorMessage(error)}`);
-        resolve14(false);
+        resolve15(false);
       }
     });
   }
@@ -91968,13 +91968,13 @@ Provide:
     // Node.js checks
   ];
   async executeCommandProbe(probe) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       const timeout = probe.timeout ?? 1e4;
       const validation = validateCommand(probe.target, _ChaosEngineerService.ALLOWED_PROBE_COMMANDS);
       if (!validation.valid) {
         console.log(`Command probe ${probe.name} blocked: ${validation.error}`);
         console.log(`Blocked patterns: ${validation.blockedPatterns?.join(", ") || "none"}`);
-        resolve14(false);
+        resolve15(false);
         return;
       }
       const sanitizedCommand = validation.sanitizedCommand || probe.target;
@@ -91984,7 +91984,7 @@ Provide:
       execFile(executable, args, { timeout }, (error, stdout, _stderr) => {
         if (error) {
           console.log(`Command probe failed: ${probe.name} -> ${error.message}`);
-          resolve14(false);
+          resolve15(false);
           return;
         }
         if (probe.expectedOutput !== void 0) {
@@ -91992,10 +91992,10 @@ Provide:
           if (!passed) {
             console.log(`Command probe ${probe.name}: output did not contain expected value`);
           }
-          resolve14(passed);
+          resolve15(passed);
           return;
         }
-        resolve14(true);
+        resolve15(true);
       });
     });
   }
@@ -92315,7 +92315,7 @@ Provide:
     // No-op commands
   ];
   executeCommandRollback(command, timeout) {
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       const validation = validateCommand(command, _ChaosEngineerService.ALLOWED_ROLLBACK_COMMANDS);
       if (!validation.valid) {
         reject(new Error(`Rollback command blocked: ${validation.error}`));
@@ -92329,7 +92329,7 @@ Provide:
         if (error) {
           reject(new Error(`Command rollback failed: ${error.message}. ${stderr}`));
         } else {
-          resolve14();
+          resolve15();
         }
       });
     });
@@ -92350,7 +92350,7 @@ Provide:
     await this.sleep(100);
   }
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
 
@@ -92900,7 +92900,7 @@ var LoadTesterService = class {
     return result;
   }
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
 
@@ -93464,7 +93464,7 @@ var PerformanceProfilerService = class {
     );
   }
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
 
@@ -94397,12 +94397,12 @@ var ChaosResilienceCoordinator = class extends BaseDomainCoordinator {
     }
     return experiments;
   }
-  generateCriticalPathExperiment(path26, _architecture) {
-    const pathName = path26.join("-");
+  generateCriticalPathExperiment(path27, _architecture) {
+    const pathName = path27.join("-");
     return {
       id: v4_default(),
       name: `critical-path-${pathName}`,
-      description: `Test critical path: ${path26.join(" -> ")}`,
+      description: `Test critical path: ${path27.join(" -> ")}`,
       hypothesis: {
         statement: "System should handle partial path failure gracefully",
         metrics: [
@@ -94415,7 +94415,7 @@ var ChaosResilienceCoordinator = class extends BaseDomainCoordinator {
       },
       steadyState: {
         description: "All services in path are healthy",
-        probes: path26.map((service) => ({
+        probes: path27.map((service) => ({
           name: `${service}-health`,
           type: "http",
           target: `http://${service}/health`,
@@ -94423,7 +94423,7 @@ var ChaosResilienceCoordinator = class extends BaseDomainCoordinator {
           timeout: 5e3
         }))
       },
-      faults: path26.slice(0, -1).map((service) => ({
+      faults: path27.slice(0, -1).map((service) => ({
         id: v4_default(),
         type: "latency",
         target: {
@@ -101266,8 +101266,8 @@ var WorkflowOrchestrator = class {
       }
     }
   }
-  getValueByPath(obj, path26) {
-    const parts = path26.split(".");
+  getValueByPath(obj, path27) {
+    const parts = path27.split(".");
     let current = obj;
     for (const part of parts) {
       if (current === null || current === void 0) return void 0;
@@ -101276,8 +101276,8 @@ var WorkflowOrchestrator = class {
     }
     return current;
   }
-  setValueByPath(obj, path26, value) {
-    const parts = path26.split(".");
+  setValueByPath(obj, path27, value) {
+    const parts = path27.split(".");
     const dangerousKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
     for (const part of parts) {
       if (dangerousKeys.has(part)) throw new Error(`Invalid path: contains dangerous prototype key`);
@@ -101425,15 +101425,15 @@ var WorkflowOrchestrator = class {
   detectCircularDependencies(steps) {
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const visit = (stepId, path26) => {
-      if (recursionStack.has(stepId)) return [...path26, stepId].join(" -> ");
+    const visit = (stepId, path27) => {
+      if (recursionStack.has(stepId)) return [...path27, stepId].join(" -> ");
       if (visited.has(stepId)) return null;
       visited.add(stepId);
       recursionStack.add(stepId);
       const step = steps.find((s70) => s70.id === stepId);
       if (step?.dependsOn) {
         for (const dep of step.dependsOn) {
-          const result = visit(dep, [...path26, stepId]);
+          const result = visit(dep, [...path27, stepId]);
           if (result) return result;
         }
       }
@@ -101531,7 +101531,7 @@ var WorkflowOrchestrator = class {
   // Private Methods - Utilities
   // ============================================================================
   delay(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
 function createWorkflowOrchestrator(eventBus, memory, agentCoordinator, config) {
@@ -107315,6 +107315,22 @@ var DomainTeamManager = class _DomainTeamManager {
     const team = this.teams.get(domain);
     return team ? this.toSnapshot(team) : void 0;
   }
+  /**
+   * Add a specific agent as a teammate to an existing domain team.
+   * Unlike scaleTeam(), this uses the real agent ID rather than generating one.
+   * @returns True if the agent was added, false if team doesn't exist or is full
+   */
+  addTeammate(domain, agentId) {
+    const team = this.teams.get(domain);
+    if (!team) return false;
+    if (agentId === team.leadAgentId || team.teammateIds.includes(agentId)) return false;
+    const maxSize = this.getMaxTeamSize(domain);
+    if (1 + team.teammateIds.length >= maxSize) return false;
+    team.teammateIds.push(agentId);
+    team.lastActivity.set(agentId, Date.now());
+    this.adapter.registerAgent(agentId, domain);
+    return true;
+  }
   /** List all active domain teams. */
   listDomainTeams() {
     return Array.from(this.teams.values(), (t50) => this.toSnapshot(t50));
@@ -110861,8 +110877,8 @@ var CrossPhaseHookExecutor = class {
     try {
       const parts = condition.split(/\s*(>|<|>=|<=|==|!=)\s*/);
       if (parts.length !== 3) return false;
-      const [path26, op, value] = parts;
-      const actual = this.getValueFromPath(context2, path26);
+      const [path27, op, value] = parts;
+      const actual = this.getValueFromPath(context2, path27);
       const expected = isNaN(Number(value)) ? value : Number(value);
       const actualNum = typeof actual === "number" ? actual : Number(actual);
       const expectedNum = typeof expected === "number" ? expected : Number(expected);
@@ -110886,8 +110902,8 @@ var CrossPhaseHookExecutor = class {
       return false;
     }
   }
-  getValueFromPath(obj, path26) {
-    return path26.split(".").reduce((curr, key) => {
+  getValueFromPath(obj, path27) {
+    return path27.split(".").reduce((curr, key) => {
       if (curr && typeof curr === "object" && key in curr) {
         return curr[key];
       }
@@ -110896,8 +110912,8 @@ var CrossPhaseHookExecutor = class {
   }
   extractFromContext(extract, context2) {
     const result = {};
-    for (const [key, path26] of Object.entries(extract)) {
-      result[key] = this.getValueFromPath(context2, path26);
+    for (const [key, path27] of Object.entries(extract)) {
+      result[key] = this.getValueFromPath(context2, path27);
     }
     return result;
   }
@@ -111537,7 +111553,7 @@ function startWorkStealingTimer(config, doStealing) {
         clearInterval(timer);
         return;
       }
-      await new Promise((resolve14) => setTimeout(resolve14, backoffMs));
+      await new Promise((resolve15) => setTimeout(resolve15, backoffMs));
     }
   }, config.workStealing.checkInterval);
   return timer;
@@ -111976,6 +111992,22 @@ var QueenCoordinator = class {
     });
     if (result.success) {
       this.domainLastActivity.set(domain, /* @__PURE__ */ new Date());
+      if (this.domainTeamManager) {
+        const existingTeam = this.domainTeamManager.getDomainTeam(domain);
+        if (!existingTeam) {
+          try {
+            this.domainTeamManager.createDomainTeam(domain, result.value);
+          } catch {
+            if (!this.domainTeamManager.addTeammate(domain, result.value)) {
+              console.warn(`[QueenCoordinator] Agent ${result.value} could not join ${domain} team (full or max teams reached)`);
+            }
+          }
+        } else {
+          if (!this.domainTeamManager.addTeammate(domain, result.value)) {
+            console.warn(`[QueenCoordinator] Agent ${result.value} could not join ${domain} team (full)`);
+          }
+        }
+      }
       await this.publishEvent("AgentSpawned", { agentId: result.value, domain, type, capabilities });
     }
     return result;
@@ -112083,6 +112115,9 @@ var QueenCoordinator = class {
   getDomainTeamManager() {
     return this.domainTeamManager;
   }
+  getAgentTeamsAdapter() {
+    return this.agentTeamsAdapter;
+  }
   getTierSelector() {
     return this.tierSelector;
   }
@@ -113260,7 +113295,7 @@ var DefaultProtocolExecutor = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
 
@@ -114039,8 +114074,8 @@ var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
    * Save metrics to persistent storage
    */
   async save() {
-    const fs23 = await import("fs");
-    const path26 = await import("path");
+    const fs25 = await import("fs");
+    const path27 = await import("path");
     const data = {
       version: "1.0.0",
       sessionId: this.sessionId,
@@ -114054,26 +114089,26 @@ var TokenMetricsCollectorImpl = class _TokenMetricsCollectorImpl {
       },
       lastSavedAt: Date.now()
     };
-    const filePath = path26.resolve(this.persistenceConfig.filePath);
-    const dirPath = path26.dirname(filePath);
-    if (!fs23.existsSync(dirPath)) {
-      fs23.mkdirSync(dirPath, { recursive: true });
+    const filePath = path27.resolve(this.persistenceConfig.filePath);
+    const dirPath = path27.dirname(filePath);
+    if (!fs25.existsSync(dirPath)) {
+      fs25.mkdirSync(dirPath, { recursive: true });
     }
-    fs23.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    fs25.writeFileSync(filePath, JSON.stringify(data, null, 2));
     this.isDirty = false;
   }
   /**
    * Load metrics from persistent storage
    */
   async load() {
-    const fs23 = await import("fs");
-    const path26 = await import("path");
-    const filePath = path26.resolve(this.persistenceConfig.filePath);
-    if (!fs23.existsSync(filePath)) {
+    const fs25 = await import("fs");
+    const path27 = await import("path");
+    const filePath = path27.resolve(this.persistenceConfig.filePath);
+    if (!fs25.existsSync(filePath)) {
       return false;
     }
     try {
-      const content = fs23.readFileSync(filePath, "utf-8");
+      const content = fs25.readFileSync(filePath, "utf-8");
       const data = safeJsonParse(content);
       if (!data.version || !data.version.startsWith("1.")) {
         console.warn("[TokenMetricsCollector] Incompatible data version, skipping load");
@@ -115240,9 +115275,9 @@ function validatePipeline(pipeline10) {
 function detectCircularDependencies(stages) {
   const visited = /* @__PURE__ */ new Set();
   const recursionStack = /* @__PURE__ */ new Set();
-  const visit = (stageName, path26) => {
+  const visit = (stageName, path27) => {
     if (recursionStack.has(stageName)) {
-      return [...path26, stageName].join(" -> ");
+      return [...path27, stageName].join(" -> ");
     }
     if (visited.has(stageName)) {
       return null;
@@ -115252,7 +115287,7 @@ function detectCircularDependencies(stages) {
     const stage = stages.find((s70) => s70.name === stageName);
     if (stage?.depends_on) {
       for (const dep of stage.depends_on) {
-        const result = visit(dep, [...path26, stageName]);
+        const result = visit(dep, [...path27, stageName]);
         if (result) return result;
       }
     }
@@ -115722,7 +115757,7 @@ var PersistentScheduler = class {
    * Sleep for specified milliseconds
    */
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
   /**
    * Log debug message if debug mode is enabled
@@ -115872,7 +115907,7 @@ var ALL_DOMAINS2 = [
   "enterprise-integration"
 ];
 function getAQEVersion() {
-  return true ? "3.6.16" : "3.0.0";
+  return true ? "3.6.18" : "3.0.0";
 }
 function createDefaultConfig(projectName, projectRoot) {
   return {
@@ -118664,9 +118699,9 @@ var N8nInstaller = class {
       // Monorepo location
       join21(process.cwd(), "../.claude/agents/n8n")
     ];
-    for (const path26 of possiblePaths) {
-      if (existsSync19(path26)) {
-        return path26;
+    for (const path27 of possiblePaths) {
+      if (existsSync19(path27)) {
+        return path27;
       }
     }
     return join21(process.cwd(), ".claude/agents/n8n");
@@ -118681,9 +118716,9 @@ var N8nInstaller = class {
       join21(process.cwd(), ".claude/skills"),
       join21(__dirname2, "../../assets/skills")
     ];
-    for (const path26 of possiblePaths) {
-      if (existsSync19(path26)) {
-        return path26;
+    for (const path27 of possiblePaths) {
+      if (existsSync19(path27)) {
+        return path27;
       }
     }
     return join21(process.cwd(), ".claude/skills");
@@ -120442,8 +120477,8 @@ var HooksPhase = class extends BasePhase {
       let installed = false;
       for (const src of assetPaths) {
         if (existsSync25(src)) {
-          const { copyFileSync: copyFileSync9 } = __require("fs");
-          copyFileSync9(src, crossPhasePath);
+          const { copyFileSync: copyFileSync10 } = __require("fs");
+          copyFileSync10(src, crossPhasePath);
           context2.services.log("  Installed cross-phase memory config");
           installed = true;
           break;
@@ -121022,7 +121057,7 @@ try {
         error: "aqe-mcp not found. Install globally with: npm install -g agentic-qe"
       };
     }
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       try {
         const env = {
           ...process.env,
@@ -121043,7 +121078,7 @@ try {
           errorOutput += data.toString();
         });
         child.on("error", (error) => {
-          resolve14({
+          resolve15({
             started: false,
             pid: null,
             error: error.message
@@ -121058,12 +121093,12 @@ try {
 `;
               writeFileSync11(logFile, logEntry, { flag: "a" });
               child.unref();
-              resolve14({
+              resolve15({
                 started: true,
                 pid: child.pid
               });
             } else {
-              resolve14({
+              resolve15({
                 started: false,
                 pid: null,
                 error: errorOutput || "No PID assigned"
@@ -121071,7 +121106,7 @@ try {
             }
           } catch {
             const errMsg = errorOutput.includes("ERR_MODULE_NOT_FOUND") ? "Missing dependencies. Run: npm install agentic-qe" : errorOutput || "Process exited immediately";
-            resolve14({
+            resolve15({
               started: false,
               pid: null,
               error: errMsg
@@ -121079,7 +121114,7 @@ try {
           }
         }, 1500);
       } catch (error) {
-        resolve14({
+        resolve15({
           started: false,
           pid: null,
           error: error instanceof Error ? error.message : "Spawn failed"
@@ -123310,7 +123345,7 @@ var TaskHandler14 = class {
               }
             }
             if (!completed) {
-              await new Promise((resolve14) => setTimeout(resolve14, 500));
+              await new Promise((resolve15) => setTimeout(resolve15, 500));
             }
           }
           if (!completed) {
@@ -123946,8 +123981,8 @@ function createTestCommand(context2, cleanupAndExit2, ensureInitialized2) {
           console.log(chalk9.red("Test generation domain not available"));
           return;
         }
-        const path26 = await import("path");
-        const targetPath = path26.resolve(target || ".");
+        const path27 = await import("path");
+        const targetPath = path27.resolve(target || ".");
         const sourceFiles = walkSourceFiles(targetPath, { includeTests: false });
         if (sourceFiles.length === 0) {
           console.log(chalk9.yellow("No source files found"));
@@ -123968,14 +124003,14 @@ function createTestCommand(context2, cleanupAndExit2, ensureInitialized2) {
           console.log(chalk9.cyan("  Tests:"));
           for (const test of generated.tests.slice(0, 10)) {
             console.log(`    ${chalk9.white(test.name)}`);
-            console.log(chalk9.gray(`      Source: ${path26.basename(test.sourceFile)}`));
+            console.log(chalk9.gray(`      Source: ${path27.basename(test.sourceFile)}`));
             console.log(chalk9.gray(`      Assertions: ${test.assertions}`));
             if (test.testCode) {
               console.log(chalk9.gray(`      Test File: ${test.testFile}`));
-              const fs23 = await import("fs");
-              const testDir = path26.dirname(test.testFile);
-              fs23.mkdirSync(testDir, { recursive: true });
-              fs23.writeFileSync(test.testFile, test.testCode, "utf-8");
+              const fs25 = await import("fs");
+              const testDir = path27.dirname(test.testFile);
+              fs25.mkdirSync(testDir, { recursive: true });
+              fs25.writeFileSync(test.testFile, test.testCode, "utf-8");
               console.log(chalk9.green(`      Written to: ${test.testFile}`));
             }
           }
@@ -123999,8 +124034,8 @@ function createTestCommand(context2, cleanupAndExit2, ensureInitialized2) {
           console.log(chalk9.red("Test execution domain not available"));
           return;
         }
-        const path26 = await import("path");
-        const targetPath = path26.resolve(target || ".");
+        const path27 = await import("path");
+        const targetPath = path27.resolve(target || ".");
         const testFiles = walkSourceFiles(targetPath, { testsOnly: true });
         if (testFiles.length === 0) {
           console.log(chalk9.yellow("No test files found"));
@@ -124090,9 +124125,9 @@ var WizardPrompt = class {
    * Generic prompt helper - wraps readline.question in a Promise
    */
   static prompt(rl, question) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       rl.question(question, (answer) => {
-        resolve14(answer);
+        resolve15(answer);
       });
     });
   }
@@ -124261,8 +124296,8 @@ var WizardFormat = class {
   /**
    * Format a path relative to cwd
    */
-  static relativePath(path26, cwd) {
-    return relative6(cwd, path26) || ".";
+  static relativePath(path27, cwd) {
+    return relative6(cwd, path27) || ".";
   }
   /**
    * Format a boolean as Yes/No
@@ -124903,9 +124938,9 @@ function createCoverageCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk13.red("Coverage analysis domain not available"));
         return;
       }
-      const fs23 = await import("fs");
-      const path26 = await import("path");
-      const targetPath = path26.resolve(analyzeTarget);
+      const fs25 = await import("fs");
+      const path27 = await import("path");
+      const targetPath = path27.resolve(analyzeTarget);
       const sourceFiles = walkSourceFiles(targetPath, { includeTests: false });
       if (sourceFiles.length === 0) {
         console.log(chalk13.yellow("No source files found"));
@@ -124914,11 +124949,11 @@ function createCoverageCommand(context2, cleanupAndExit2, ensureInitialized2) {
       console.log(chalk13.gray(`  Analyzing ${sourceFiles.length} files...
 `));
       const files = sourceFiles.map((filePath) => {
-        const content = fs23.readFileSync(filePath, "utf-8");
+        const content = fs25.readFileSync(filePath, "utf-8");
         const lines = content.split("\n");
         const totalLines2 = lines.length;
         const testFile = filePath.replace(".ts", ".test.ts").replace("/src/", "/tests/");
-        const hasTest = fs23.existsSync(testFile);
+        const hasTest = fs25.existsSync(testFile);
         const coverageRate = hasTest ? 0.75 + Math.random() * 0.2 : 0.2 + Math.random() * 0.3;
         const coveredLines2 = Math.floor(totalLines2 * coverageRate);
         const uncoveredLines = Array.from({ length: totalLines2 - coveredLines2 }, (_56, i58) => i58 + coveredLines2 + 1);
@@ -125092,8 +125127,8 @@ function createSecurityCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk15.red("Security domain not available"));
         return;
       }
-      const path26 = await import("path");
-      const targetPath = path26.resolve(options.target);
+      const path27 = await import("path");
+      const targetPath = path27.resolve(options.target);
       const files = walkSourceFiles(targetPath, { includeTests: true });
       if (files.length === 0) {
         console.log(chalk15.yellow("No files found to scan"));
@@ -125169,12 +125204,12 @@ function createCodeCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk16.red("Code intelligence domain not available"));
         return;
       }
-      const path26 = await import("path");
+      const path27 = await import("path");
       if (action === "index") {
         console.log(chalk16.blue(`
  Indexing codebase at ${target || "."}...
 `));
-        const targetPath = path26.resolve(target || ".");
+        const targetPath = path27.resolve(target || ".");
         const paths = walkSourceFiles(targetPath, {
           includeTests: options.includeTests || false
         });
@@ -125235,7 +125270,7 @@ function createCodeCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk16.blue(`
  Analyzing impact for ${target || "recent changes"}...
 `));
-        const targetPath = path26.resolve(target || ".");
+        const targetPath = path27.resolve(target || ".");
         const changedFiles = walkSourceFiles(targetPath, { maxDepth: 2 }).slice(0, 10);
         const result = await codeAPI.analyzeImpact({
           changedFiles,
@@ -125281,7 +125316,7 @@ function createCodeCommand(context2, cleanupAndExit2, ensureInitialized2) {
         console.log(chalk16.blue(`
  Mapping dependencies for ${target || "."}...
 `));
-        const targetPath = path26.resolve(target || ".");
+        const targetPath = path27.resolve(target || ".");
         const files = walkSourceFiles(targetPath, { maxDepth: 2 }).slice(0, 50);
         const result = await codeAPI.mapDependencies({
           files,
@@ -125433,32 +125468,32 @@ var v3Agents = [
 function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
   const migrateCmd = new Command6("migrate").description("V2-to-V3 migration tools with agent compatibility (ADR-048)");
   migrateCmd.command("run").description("Run full migration from v2 to v3").option("--dry-run", "Preview migration without making changes").option("--backup", "Create backup before migration (recommended)", true).option("--skip-memory", "Skip memory database migration").option("--skip-patterns", "Skip pattern migration").option("--skip-config", "Skip configuration migration").option("--skip-agents", "Skip agent name migration").option("--target <component>", "Migrate specific component (agents, skills, config, memory)").option("--force", "Force migration even if v3 already exists").action(async (options) => {
-    const fs23 = await import("fs");
-    const path26 = await import("path");
+    const fs25 = await import("fs");
+    const path27 = await import("path");
     console.log(chalk17.blue("\n V2 to V3 Migration (ADR-048)\n"));
     const cwd = process.cwd();
-    const v2Dir = path26.join(cwd, ".agentic-qe");
-    const v3Dir = path26.join(cwd, ".aqe");
-    const claudeAgentDir = path26.join(cwd, ".claude", "agents");
+    const v2Dir = path27.join(cwd, ".agentic-qe");
+    const v3Dir = path27.join(cwd, ".aqe");
+    const claudeAgentDir = path27.join(cwd, ".claude", "agents");
     console.log(chalk17.white("1. Detecting v2 installation..."));
-    const hasV2Dir = fs23.existsSync(v2Dir);
-    const hasClaudeAgents = fs23.existsSync(claudeAgentDir);
+    const hasV2Dir = fs25.existsSync(v2Dir);
+    const hasClaudeAgents = fs25.existsSync(claudeAgentDir);
     if (!hasV2Dir && !hasClaudeAgents) {
       console.log(chalk17.yellow("   ! No v2 installation found"));
       console.log(chalk17.gray("   This might be a fresh project. Use `aqe init` instead."));
       await cleanupAndExit2(0);
     }
     const v2Files = {
-      memoryDb: path26.join(v2Dir, "memory.db"),
-      config: path26.join(v2Dir, "config.json"),
-      patterns: path26.join(v2Dir, "patterns")
+      memoryDb: path27.join(v2Dir, "memory.db"),
+      config: path27.join(v2Dir, "config.json"),
+      patterns: path27.join(v2Dir, "patterns")
     };
-    const hasMemory = hasV2Dir && fs23.existsSync(v2Files.memoryDb);
-    const hasConfig = hasV2Dir && fs23.existsSync(v2Files.config);
-    const hasPatterns = hasV2Dir && fs23.existsSync(v2Files.patterns);
+    const hasMemory = hasV2Dir && fs25.existsSync(v2Files.memoryDb);
+    const hasConfig = hasV2Dir && fs25.existsSync(v2Files.config);
+    const hasPatterns = hasV2Dir && fs25.existsSync(v2Files.patterns);
     const agentsToMigrate = [];
     if (hasClaudeAgents) {
-      const files = fs23.readdirSync(claudeAgentDir);
+      const files = fs25.readdirSync(claudeAgentDir);
       for (const file of files) {
         if (file.endsWith(".md") && file.startsWith("qe-")) {
           const agentName = file.replace(".md", "");
@@ -125475,7 +125510,7 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     console.log(chalk17.gray(`     Agents to migrate: ${agentsToMigrate.length}
 `));
     console.log(chalk17.white("2. Checking v3 status..."));
-    if (fs23.existsSync(v3Dir) && !options.force) {
+    if (fs25.existsSync(v3Dir) && !options.force) {
       console.log(chalk17.yellow("   ! v3 directory already exists at .aqe/"));
       console.log(chalk17.gray("   Use --force to overwrite existing v3 installation."));
       await cleanupAndExit2(1);
@@ -125484,14 +125519,14 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if (options.dryRun) {
       console.log(chalk17.blue(" Dry Run - Migration Plan:\n"));
       if (!options.skipMemory && hasMemory) {
-        const stats = fs23.statSync(v2Files.memoryDb);
+        const stats = fs25.statSync(v2Files.memoryDb);
         console.log(chalk17.gray(`  - Migrate memory.db (${(stats.size / 1024).toFixed(1)} KB)`));
       }
       if (!options.skipConfig && hasConfig) {
         console.log(chalk17.gray("  - Convert config.json to v3 format"));
       }
       if (!options.skipPatterns && hasPatterns) {
-        const patternFiles = fs23.readdirSync(v2Files.patterns);
+        const patternFiles = fs25.readdirSync(v2Files.patterns);
         console.log(chalk17.gray(`  - Migrate ${patternFiles.length} pattern files`));
       }
       if (!options.skipAgents && agentsToMigrate.length > 0) {
@@ -125506,22 +125541,22 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     }
     if (options.backup) {
       console.log(chalk17.white("3. Creating backup..."));
-      const backupDir = path26.join(cwd, ".aqe-backup", `backup-${Date.now()}`);
+      const backupDir = path27.join(cwd, ".aqe-backup", `backup-${Date.now()}`);
       try {
-        fs23.mkdirSync(backupDir, { recursive: true });
+        fs25.mkdirSync(backupDir, { recursive: true });
         const copyDir = (src, dest) => {
-          if (!fs23.existsSync(src)) return;
-          if (fs23.statSync(src).isDirectory()) {
-            fs23.mkdirSync(dest, { recursive: true });
-            for (const file of fs23.readdirSync(src)) {
-              copyDir(path26.join(src, file), path26.join(dest, file));
+          if (!fs25.existsSync(src)) return;
+          if (fs25.statSync(src).isDirectory()) {
+            fs25.mkdirSync(dest, { recursive: true });
+            for (const file of fs25.readdirSync(src)) {
+              copyDir(path27.join(src, file), path27.join(dest, file));
             }
           } else {
-            fs23.copyFileSync(src, dest);
+            fs25.copyFileSync(src, dest);
           }
         };
-        if (hasV2Dir) copyDir(v2Dir, path26.join(backupDir, ".agentic-qe"));
-        if (hasClaudeAgents) copyDir(claudeAgentDir, path26.join(backupDir, ".claude", "agents"));
+        if (hasV2Dir) copyDir(v2Dir, path27.join(backupDir, ".agentic-qe"));
+        if (hasClaudeAgents) copyDir(claudeAgentDir, path27.join(backupDir, ".claude", "agents"));
         console.log(chalk17.green(`   * Backup created at .aqe-backup/
 `));
       } catch (err3) {
@@ -125534,11 +125569,11 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if (!options.target || options.target === "config" || options.target === "memory") {
       console.log(chalk17.white("4. Creating v3 directory structure..."));
       try {
-        fs23.mkdirSync(v3Dir, { recursive: true });
-        fs23.mkdirSync(path26.join(v3Dir, "agentdb"), { recursive: true });
-        fs23.mkdirSync(path26.join(v3Dir, "reasoning-bank"), { recursive: true });
-        fs23.mkdirSync(path26.join(v3Dir, "cache"), { recursive: true });
-        fs23.mkdirSync(path26.join(v3Dir, "logs"), { recursive: true });
+        fs25.mkdirSync(v3Dir, { recursive: true });
+        fs25.mkdirSync(path27.join(v3Dir, "agentdb"), { recursive: true });
+        fs25.mkdirSync(path27.join(v3Dir, "reasoning-bank"), { recursive: true });
+        fs25.mkdirSync(path27.join(v3Dir, "cache"), { recursive: true });
+        fs25.mkdirSync(path27.join(v3Dir, "logs"), { recursive: true });
         console.log(chalk17.green("   * Directory structure created\n"));
       } catch (err3) {
         console.log(chalk17.red(`   x Failed: ${err3}
@@ -125549,17 +125584,17 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if ((!options.target || options.target === "memory") && !options.skipMemory && hasMemory) {
       console.log(chalk17.white("5. Migrating memory database..."));
       try {
-        const destDb = path26.join(v3Dir, "agentdb", "memory.db");
-        fs23.copyFileSync(v2Files.memoryDb, destDb);
-        const indexFile = path26.join(v3Dir, "agentdb", "index.json");
-        fs23.writeFileSync(indexFile, JSON.stringify({
+        const destDb = path27.join(v3Dir, "agentdb", "memory.db");
+        fs25.copyFileSync(v2Files.memoryDb, destDb);
+        const indexFile = path27.join(v3Dir, "agentdb", "index.json");
+        fs25.writeFileSync(indexFile, JSON.stringify({
           version: "3.0.0",
           migratedFrom: "v2",
           migratedAt: (/* @__PURE__ */ new Date()).toISOString(),
           hnswEnabled: true,
           vectorDimensions: 768
         }, null, 2));
-        const stats = fs23.statSync(v2Files.memoryDb);
+        const stats = fs25.statSync(v2Files.memoryDb);
         console.log(chalk17.green(`   * Memory database migrated (${(stats.size / 1024).toFixed(1)} KB)
 `));
       } catch (err3) {
@@ -125576,7 +125611,7 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if ((!options.target || options.target === "config") && !options.skipConfig && hasConfig) {
       console.log(chalk17.white("6. Migrating configuration..."));
       try {
-        const v2ConfigRaw = fs23.readFileSync(v2Files.config, "utf-8");
+        const v2ConfigRaw = fs25.readFileSync(v2Files.config, "utf-8");
         const v2Config = parseJsonFile(v2ConfigRaw, v2Files.config);
         const v3Config = {
           version: "3.0.0",
@@ -125612,8 +125647,8 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
             migrationDate: (/* @__PURE__ */ new Date()).toISOString()
           }
         };
-        const destConfig = path26.join(v3Dir, "config.json");
-        fs23.writeFileSync(destConfig, JSON.stringify(v3Config, null, 2));
+        const destConfig = path27.join(v3Dir, "config.json");
+        fs25.writeFileSync(destConfig, JSON.stringify(v3Config, null, 2));
         console.log(chalk17.green("   * Configuration migrated\n"));
       } catch (err3) {
         console.log(chalk17.red(`   x Config migration failed: ${err3}
@@ -125629,18 +125664,18 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if ((!options.target || options.target === "memory") && !options.skipPatterns && hasPatterns) {
       console.log(chalk17.white("7. Migrating patterns to ReasoningBank..."));
       try {
-        const patternFiles = fs23.readdirSync(v2Files.patterns);
+        const patternFiles = fs25.readdirSync(v2Files.patterns);
         let migratedCount = 0;
         for (const file of patternFiles) {
-          const srcPath = path26.join(v2Files.patterns, file);
-          const destPath = path26.join(v3Dir, "reasoning-bank", file);
-          if (fs23.statSync(srcPath).isFile()) {
-            fs23.copyFileSync(srcPath, destPath);
+          const srcPath = path27.join(v2Files.patterns, file);
+          const destPath = path27.join(v3Dir, "reasoning-bank", file);
+          if (fs25.statSync(srcPath).isFile()) {
+            fs25.copyFileSync(srcPath, destPath);
             migratedCount++;
           }
         }
-        const indexPath = path26.join(v3Dir, "reasoning-bank", "index.json");
-        fs23.writeFileSync(indexPath, JSON.stringify({
+        const indexPath = path27.join(v3Dir, "reasoning-bank", "index.json");
+        fs25.writeFileSync(indexPath, JSON.stringify({
           version: "3.0.0",
           migratedFrom: "v2",
           migratedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -125661,17 +125696,17 @@ function createMigrateCommand(context2, cleanupAndExit2, ensureInitialized2) {
     if ((!options.target || options.target === "agents") && !options.skipAgents && agentsToMigrate.length > 0) {
       console.log(chalk17.white("8. Migrating agent names (ADR-048)..."));
       let migratedAgents = 0;
-      const deprecatedDir = path26.join(claudeAgentDir, "deprecated");
-      if (!fs23.existsSync(deprecatedDir)) {
-        fs23.mkdirSync(deprecatedDir, { recursive: true });
+      const deprecatedDir = path27.join(claudeAgentDir, "deprecated");
+      if (!fs25.existsSync(deprecatedDir)) {
+        fs25.mkdirSync(deprecatedDir, { recursive: true });
       }
       for (const v2Name of agentsToMigrate) {
         const v3Name = resolveAgentName(v2Name);
-        const v2FilePath = path26.join(claudeAgentDir, `${v2Name}.md`);
-        const v3FilePath = path26.join(claudeAgentDir, `${v3Name}.md`);
-        const deprecatedPath = path26.join(deprecatedDir, `${v2Name}.md.v2`);
+        const v2FilePath = path27.join(claudeAgentDir, `${v2Name}.md`);
+        const v3FilePath = path27.join(claudeAgentDir, `${v3Name}.md`);
+        const deprecatedPath = path27.join(deprecatedDir, `${v2Name}.md.v2`);
         try {
-          const content = fs23.readFileSync(v2FilePath, "utf-8");
+          const content = fs25.readFileSync(v2FilePath, "utf-8");
           const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
           if (!frontmatterMatch) {
             console.log(chalk17.yellow(`   ! ${v2Name}: No frontmatter found, skipping`));
@@ -125699,8 +125734,8 @@ v2_compat:
           const newContent = `---
 ${newFrontmatter}
 ---${body}`;
-          fs23.writeFileSync(v3FilePath, newContent, "utf-8");
-          fs23.renameSync(v2FilePath, deprecatedPath);
+          fs25.writeFileSync(v3FilePath, newContent, "utf-8");
+          fs25.renameSync(v2FilePath, deprecatedPath);
           console.log(chalk17.gray(`   ${v2Name} -> ${v3Name}`));
           migratedAgents++;
         } catch (err3) {
@@ -125721,10 +125756,10 @@ ${newFrontmatter}
     }
     console.log(chalk17.white("9. Validating migration..."));
     const validationResults = {
-      v3DirExists: fs23.existsSync(v3Dir),
-      configExists: fs23.existsSync(path26.join(v3Dir, "config.json")),
-      agentdbExists: fs23.existsSync(path26.join(v3Dir, "agentdb")),
-      reasoningBankExists: fs23.existsSync(path26.join(v3Dir, "reasoning-bank"))
+      v3DirExists: fs25.existsSync(v3Dir),
+      configExists: fs25.existsSync(path27.join(v3Dir, "config.json")),
+      agentdbExists: fs25.existsSync(path27.join(v3Dir, "agentdb")),
+      reasoningBankExists: fs25.existsSync(path27.join(v3Dir, "reasoning-bank"))
     };
     const allValid = Object.values(validationResults).every((v62) => v62);
     if (allValid) {
@@ -125744,18 +125779,18 @@ ${newFrontmatter}
     await cleanupAndExit2(0);
   });
   migrateCmd.command("status").description("Check migration status of current project").option("--json", "Output as JSON").action(async (options) => {
-    const fs23 = await import("fs");
-    const path26 = await import("path");
+    const fs25 = await import("fs");
+    const path27 = await import("path");
     const cwd = process.cwd();
-    const v2Dir = path26.join(cwd, ".agentic-qe");
-    const v3Dir = path26.join(cwd, ".aqe");
-    const claudeAgentDir = path26.join(cwd, ".claude", "agents");
-    const isV2Project = fs23.existsSync(v2Dir);
-    const isV3Project = fs23.existsSync(v3Dir);
+    const v2Dir = path27.join(cwd, ".agentic-qe");
+    const v3Dir = path27.join(cwd, ".aqe");
+    const claudeAgentDir = path27.join(cwd, ".claude", "agents");
+    const isV2Project = fs25.existsSync(v2Dir);
+    const isV3Project = fs25.existsSync(v3Dir);
     const agentsToMigrate = [];
     const agentsMigrated = [];
-    if (fs23.existsSync(claudeAgentDir)) {
-      const files = fs23.readdirSync(claudeAgentDir);
+    if (fs25.existsSync(claudeAgentDir)) {
+      const files = fs25.readdirSync(claudeAgentDir);
       for (const file of files) {
         if (file.endsWith(".md") && file.startsWith("qe-")) {
           const agentName = file.replace(".md", "");
@@ -125804,15 +125839,15 @@ ${newFrontmatter}
     await cleanupAndExit2(0);
   });
   migrateCmd.command("verify").description("Verify migration integrity").option("--fix", "Attempt to fix issues automatically").action(async (options) => {
-    const fs23 = await import("fs");
-    const path26 = await import("path");
+    const fs25 = await import("fs");
+    const path27 = await import("path");
     console.log(chalk17.bold("\n Verifying Migration...\n"));
     const cwd = process.cwd();
-    const v3Dir = path26.join(cwd, ".aqe");
-    const claudeAgentDir = path26.join(cwd, ".claude", "agents");
+    const v3Dir = path27.join(cwd, ".aqe");
+    const claudeAgentDir = path27.join(cwd, ".claude", "agents");
     const deprecatedInUse = [];
-    if (fs23.existsSync(claudeAgentDir)) {
-      const files = fs23.readdirSync(claudeAgentDir);
+    if (fs25.existsSync(claudeAgentDir)) {
+      const files = fs25.readdirSync(claudeAgentDir);
       for (const file of files) {
         if (file.endsWith(".md") && file.startsWith("qe-")) {
           const agentName = file.replace(".md", "");
@@ -125825,8 +125860,8 @@ ${newFrontmatter}
     const checks = [
       {
         name: "V3 Directory",
-        passed: fs23.existsSync(v3Dir),
-        message: fs23.existsSync(v3Dir) ? "Exists" : "Missing .aqe/"
+        passed: fs25.existsSync(v3Dir),
+        message: fs25.existsSync(v3Dir) ? "Exists" : "Missing .aqe/"
       },
       {
         name: "Agent Compatibility",
@@ -125835,7 +125870,7 @@ ${newFrontmatter}
       },
       {
         name: "Config Format",
-        passed: fs23.existsSync(path26.join(v3Dir, "config.json")),
+        passed: fs25.existsSync(path27.join(v3Dir, "config.json")),
         message: "Valid v3 config"
       }
     ];
@@ -125860,15 +125895,15 @@ ${newFrontmatter}
     await cleanupAndExit2(0);
   });
   migrateCmd.command("rollback").description("Rollback to previous version from backup").option("--backup-id <id>", "Specific backup to restore").option("--force", "Skip confirmation").action(async (options) => {
-    const fs23 = await import("fs");
-    const path26 = await import("path");
+    const fs25 = await import("fs");
+    const path27 = await import("path");
     const cwd = process.cwd();
-    const backupRoot = path26.join(cwd, ".aqe-backup");
-    if (!fs23.existsSync(backupRoot)) {
+    const backupRoot = path27.join(cwd, ".aqe-backup");
+    if (!fs25.existsSync(backupRoot)) {
       console.log(chalk17.yellow("\n! No backups found.\n"));
       return;
     }
-    const backups = fs23.readdirSync(backupRoot).filter((f74) => f74.startsWith("backup-")).sort().reverse();
+    const backups = fs25.readdirSync(backupRoot).filter((f74) => f74.startsWith("backup-")).sort().reverse();
     if (backups.length === 0) {
       console.log(chalk17.yellow("\n! No backups found.\n"));
       return;
@@ -125880,8 +125915,8 @@ ${newFrontmatter}
       console.log(`  ${chalk17.cyan(backup)} - ${date.toLocaleString()}`);
     }
     const targetBackup = options.backupId || backups[0];
-    const backupPath = path26.join(backupRoot, targetBackup);
-    if (!fs23.existsSync(backupPath)) {
+    const backupPath = path27.join(backupRoot, targetBackup);
+    if (!fs25.existsSync(backupPath)) {
       console.log(chalk17.red(`
  Backup not found: ${targetBackup}
 `));
@@ -125896,21 +125931,21 @@ ${newFrontmatter}
     console.log(chalk17.bold(`
  Rolling back to ${targetBackup}...
 `));
-    const v2Backup = path26.join(backupPath, ".agentic-qe");
-    const agentsBackup = path26.join(backupPath, ".claude", "agents");
-    if (fs23.existsSync(v2Backup)) {
-      const v2Dir = path26.join(cwd, ".agentic-qe");
-      fs23.cpSync(v2Backup, v2Dir, { recursive: true });
+    const v2Backup = path27.join(backupPath, ".agentic-qe");
+    const agentsBackup = path27.join(backupPath, ".claude", "agents");
+    if (fs25.existsSync(v2Backup)) {
+      const v2Dir = path27.join(cwd, ".agentic-qe");
+      fs25.cpSync(v2Backup, v2Dir, { recursive: true });
       console.log(chalk17.dim("  Restored .agentic-qe/"));
     }
-    if (fs23.existsSync(agentsBackup)) {
-      const agentsDir = path26.join(cwd, ".claude", "agents");
-      fs23.cpSync(agentsBackup, agentsDir, { recursive: true });
+    if (fs25.existsSync(agentsBackup)) {
+      const agentsDir = path27.join(cwd, ".claude", "agents");
+      fs25.cpSync(agentsBackup, agentsDir, { recursive: true });
       console.log(chalk17.dim("  Restored .claude/agents/"));
     }
-    const v3Dir = path26.join(cwd, ".aqe");
-    if (fs23.existsSync(v3Dir)) {
-      fs23.rmSync(v3Dir, { recursive: true, force: true });
+    const v3Dir = path27.join(cwd, ".aqe");
+    if (fs25.existsSync(v3Dir)) {
+      fs25.rmSync(v3Dir, { recursive: true, force: true });
       console.log(chalk17.dim("  Removed .aqe/"));
     }
     console.log(chalk17.green("\n Rollback complete!\n"));
@@ -127468,8 +127503,8 @@ function createCompletionsCommand(cleanupAndExit2) {
     console.log(generateCompletion("powershell"));
   });
   completionsCmd.command("install").description("Auto-install completions for current shell").option("-s, --shell <shell>", "Target shell (bash|zsh|fish|powershell)").action(async (options) => {
-    const fs23 = await import("fs");
-    const path26 = await import("path");
+    const fs25 = await import("fs");
+    const path27 = await import("path");
     const shellInfo = options.shell ? { name: options.shell, configFile: null, detected: false } : detectShell();
     if (shellInfo.name === "unknown") {
       console.log(chalk18.red("Could not detect shell. Please specify with --shell option.\n"));
@@ -127483,11 +127518,11 @@ Installing completions for ${shellInfo.name}...
     const script = generateCompletion(shellInfo.name);
     if (shellInfo.name === "fish") {
       const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-      const fishCompletionsDir = path26.join(homeDir, ".config", "fish", "completions");
+      const fishCompletionsDir = path27.join(homeDir, ".config", "fish", "completions");
       try {
-        fs23.mkdirSync(fishCompletionsDir, { recursive: true });
-        const completionFile = path26.join(fishCompletionsDir, "aqe.fish");
-        fs23.writeFileSync(completionFile, script);
+        fs25.mkdirSync(fishCompletionsDir, { recursive: true });
+        const completionFile = path27.join(fishCompletionsDir, "aqe.fish");
+        fs25.writeFileSync(completionFile, script);
         console.log(chalk18.green(`Completions installed to: ${completionFile}`));
         console.log(chalk18.gray("\nRestart your shell or run: source ~/.config/fish/completions/aqe.fish\n"));
       } catch (err3) {
@@ -127719,13 +127754,13 @@ var FleetInitEnhancer = class {
       input: process.stdin,
       output: process.stdout
     });
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       rl.question(
         chalk19.white("  Run code intelligence scan now? [Y/n]: "),
         (answer) => {
           rl.close();
           const normalized = answer.trim().toLowerCase();
-          resolve14(normalized === "" || normalized === "y" || normalized === "yes");
+          resolve15(normalized === "" || normalized === "y" || normalized === "yes");
         }
       );
     });
@@ -128227,11 +128262,11 @@ function createFleetCommand(context2, cleanupAndExit2, ensureInitialized2, regis
       }
       const results = await Promise.all(
         agentOperations.map(async (op, index) => {
-          await new Promise((resolve14) => setTimeout(resolve14, index * 200));
+          await new Promise((resolve15) => setTimeout(resolve15, index * 200));
           progress.updateAgent(op.id, 0, { status: "running" });
           try {
             for (let p74 = 10; p74 <= 90; p74 += 20) {
-              await new Promise((resolve14) => setTimeout(resolve14, 300 + Math.random() * 200));
+              await new Promise((resolve15) => setTimeout(resolve15, 300 + Math.random() * 200));
               progress.updateAgent(op.id, p74, {
                 eta: Math.round((100 - p74) * 50)
               });
@@ -128654,7 +128689,7 @@ var SwarmSkillValidator = class {
    * Helper to delay execution
    */
   delay(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
   /**
    * Get current configuration
@@ -128740,7 +128775,7 @@ var DEFAULT_PARALLEL_EVAL_CONFIG = {
 var MockLLMExecutor = class {
   async execute(prompt, model, options) {
     const delay = Math.random() * MOCK_LLM_MAX_DELAY_MS + MOCK_LLM_MIN_DELAY_MS;
-    await new Promise((resolve14) => setTimeout(resolve14, delay));
+    await new Promise((resolve15) => setTimeout(resolve15, delay));
     const output = this.generateMockResponse(prompt);
     return {
       output,
@@ -133008,6 +133043,160 @@ import chalk26 from "chalk";
 import ora2 from "ora";
 
 // src/sync/interfaces.ts
+var DEFAULT_PULL_CONFIG = {
+  cloud: {
+    project: process.env.GCP_PROJECT || "",
+    zone: process.env.GCP_ZONE || "",
+    instance: process.env.GCP_INSTANCE || "",
+    database: process.env.GCP_DATABASE || "",
+    user: process.env.GCP_USER || "",
+    tunnelPort: parseInt(process.env.GCP_TUNNEL_PORT || "15432", 10)
+  },
+  environment: process.env.AQE_ENV || "all",
+  batchSize: 1e3,
+  sources: [
+    // QE Patterns (cloud 0 records, but may grow)
+    {
+      name: "qe-patterns",
+      cloudTable: "aqe.qe_patterns",
+      localTable: "qe_patterns",
+      enabled: true,
+      priority: "high",
+      mode: "incremental",
+      dropColumns: ["source_env", "embedding", "sync_version"],
+      transforms: { reusable: "boolean-to-int" }
+    },
+    // SONA patterns (873 records)
+    {
+      name: "sona-patterns",
+      cloudTable: "aqe.sona_patterns",
+      localTable: "sona_patterns",
+      enabled: true,
+      priority: "high",
+      mode: "incremental",
+      dropColumns: ["source_env", "sync_version"],
+      transforms: {
+        is_active: "boolean-to-int",
+        requires_fine_tuning: "boolean-to-int"
+      }
+    },
+    // GOAP actions (2,335 records)
+    {
+      name: "goap-actions",
+      cloudTable: "aqe.goap_actions",
+      localTable: "goap_actions",
+      enabled: true,
+      priority: "high",
+      mode: "incremental",
+      dropColumns: ["source_env", "sync_version"],
+      columnMap: { duration_estimate: "estimated_duration_ms" }
+    },
+    // GOAP plans (91 records)
+    {
+      name: "goap-plans",
+      cloudTable: "aqe.goap_plans",
+      localTable: "goap_plans",
+      enabled: true,
+      priority: "medium",
+      mode: "incremental",
+      dropColumns: ["source_env", "sync_version"],
+      columnMap: { estimated_duration: "estimated_duration_ms" }
+    },
+    // Memory entries → kv_store (0 records in cloud currently)
+    {
+      name: "memory-entries",
+      cloudTable: "aqe.memory_entries",
+      localTable: "kv_store",
+      enabled: true,
+      priority: "high",
+      mode: "incremental",
+      dropColumns: ["source_env", "sync_version"],
+      columnMap: { partition: "namespace" }
+    },
+    // Learning experiences → captured_experiences (7,702 records)
+    // Drop 'id' because cloud uses SERIAL auto-increment, local uses UUID
+    // Map 'created_at' → 'started_at' since push mapped started_at → created_at
+    {
+      name: "learning-experiences",
+      cloudTable: "aqe.learning_experiences",
+      localTable: "captured_experiences",
+      enabled: true,
+      priority: "high",
+      mode: "append",
+      dropColumns: ["id", "source_env", "sync_version"],
+      columnMap: {
+        agent_id: "agent",
+        task_id: "task",
+        task_type: "domain",
+        state: "result_json",
+        action: "steps_json",
+        reward: "quality",
+        next_state: "routing_json",
+        episode_id: "tags",
+        created_at: "started_at"
+      }
+    },
+    // Q-learning patterns → rl_q_values (3 records)
+    {
+      name: "qlearning-patterns",
+      cloudTable: "aqe.qlearning_patterns",
+      localTable: "rl_q_values",
+      enabled: true,
+      priority: "medium",
+      mode: "incremental",
+      dropColumns: ["source_env", "sync_version"],
+      columnMap: {
+        state: "state_key",
+        action: "action_key",
+        last_update: "updated_at"
+      }
+    },
+    // Routing outcomes (186 records)
+    {
+      name: "routing-outcomes",
+      cloudTable: "aqe.routing_outcomes",
+      localTable: "routing_outcomes",
+      enabled: true,
+      priority: "medium",
+      mode: "append",
+      dropColumns: ["source_env", "sync_version"]
+    },
+    // QE trajectories (0 records in cloud currently)
+    {
+      name: "qe-trajectories",
+      cloudTable: "aqe.qe_trajectories",
+      localTable: "qe_trajectories",
+      enabled: true,
+      priority: "medium",
+      mode: "append",
+      dropColumns: ["source_env", "sync_version", "embedding"]
+    },
+    // Dream insights (680 records)
+    {
+      name: "dream-insights",
+      cloudTable: "aqe.dream_insights",
+      localTable: "dream_insights",
+      enabled: true,
+      priority: "low",
+      mode: "append",
+      dropColumns: ["source_env", "sync_version"]
+    },
+    // Claude-Flow memory (2 records in cloud)
+    // Push syncs from JSON file; pull writes to kv_store since local has no dedicated table
+    {
+      name: "claude-flow-memory",
+      cloudTable: "aqe.claude_flow_memory",
+      localTable: "kv_store",
+      enabled: true,
+      priority: "low",
+      mode: "incremental",
+      dropColumns: ["source_env", "sync_version"],
+      columnMap: { partition: "namespace" }
+    }
+    // NOTE: intelligence-qlearning (JSON push source) is NOT pulled back —
+    // the cloud qlearning_patterns table is already pulled via the qlearning-patterns source above.
+  ]
+};
 var DEFAULT_SYNC_CONFIG = {
   local: {
     // PRIMARY: Root database (consolidated, MCP-active)
@@ -133730,21 +133919,21 @@ var IAPTunnelManager = class {
    * Check if a port is accepting connections
    */
   checkPort(host, port, timeout = 2e3) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       const socket = createConnection({ host, port });
       const timer = setTimeout(() => {
         socket.destroy();
-        resolve14(false);
+        resolve15(false);
       }, timeout);
       socket.on("connect", () => {
         clearTimeout(timer);
         socket.destroy();
-        resolve14(true);
+        resolve15(true);
       });
       socket.on("error", () => {
         clearTimeout(timer);
         socket.destroy();
-        resolve14(false);
+        resolve15(false);
       });
     });
   }
@@ -133766,7 +133955,7 @@ var IAPTunnelManager = class {
       };
       return this.connection;
     }
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       const args = [
         "compute",
         "start-iap-tunnel",
@@ -133810,7 +133999,7 @@ var IAPTunnelManager = class {
                   startedAt: /* @__PURE__ */ new Date()
                 };
                 console.log(`[TunnelManager] Tunnel ready on port ${this.config.tunnelPort}`);
-                resolve14(this.connection);
+                resolve15(this.connection);
                 return;
               }
               await new Promise((r54) => setTimeout(r54, 1e3));
@@ -133853,7 +134042,7 @@ var IAPTunnelManager = class {
     if (this.process) {
       console.log("[TunnelManager] Stopping tunnel");
       this.process.kill("SIGTERM");
-      await new Promise((resolve14) => setTimeout(resolve14, 1e3));
+      await new Promise((resolve15) => setTimeout(resolve15, 1e3));
       if (this.process) {
         this.process.kill("SIGKILL");
       }
@@ -134312,11 +134501,410 @@ function createPostgresWriter(config) {
   return new PostgresWriter(config);
 }
 
+// src/sync/cloud/postgres-reader.ts
+init_sql_safety();
+init_error_utils();
+init_logging();
+var logger15 = LoggerFactory.create("postgres-reader");
+var PostgresReader = class {
+  writer;
+  environment;
+  constructor(config) {
+    this.writer = config.writer;
+    this.environment = config.environment;
+  }
+  /**
+   * Validate and sanitize a 'schema.table' cloud table reference.
+   * Throws if the format is invalid (must contain exactly one dot).
+   */
+  sanitizeCloudTable(cloudTable) {
+    const dotIndex = cloudTable.indexOf(".");
+    if (dotIndex === -1 || dotIndex === 0 || dotIndex === cloudTable.length - 1) {
+      throw new Error(
+        `Invalid cloud table format '${cloudTable}': expected 'schema.table' (e.g., 'aqe.qe_patterns')`
+      );
+    }
+    const schema = cloudTable.substring(0, dotIndex);
+    const table = cloudTable.substring(dotIndex + 1);
+    return `${validateIdentifier(schema)}.${validateIdentifier(table)}`;
+  }
+  /**
+   * Read all records from a cloud table
+   */
+  async readAll(source) {
+    const safeTable = this.sanitizeCloudTable(source.cloudTable);
+    let sql;
+    let params;
+    if (this.environment !== "all") {
+      sql = `SELECT * FROM ${safeTable} WHERE source_env = $1`;
+      params = [this.environment];
+    } else {
+      sql = `SELECT * FROM ${safeTable}`;
+      params = [];
+    }
+    try {
+      const rows = await this.writer.query(sql, params);
+      logger15.debug(`Read ${rows.length} records from ${source.cloudTable}`, {
+        env: this.environment
+      });
+      return rows.map((row) => this.transformRecord(row, source));
+    } catch (error) {
+      throw new Error(
+        `Failed to read from ${source.cloudTable}: ${toErrorMessage(error)}`
+      );
+    }
+  }
+  /**
+   * Read records changed since a timestamp
+   */
+  async readChanged(source, since) {
+    const safeTable = this.sanitizeCloudTable(source.cloudTable);
+    const timestampCol = await this.findTimestampColumn(safeTable);
+    if (!timestampCol) {
+      logger15.debug(`No timestamp column found for ${source.cloudTable}, falling back to readAll`);
+      return this.readAll(source);
+    }
+    let sql;
+    let params;
+    if (this.environment !== "all") {
+      sql = `SELECT * FROM ${safeTable} WHERE ${validateIdentifier(timestampCol)} > $1 AND source_env = $2`;
+      params = [since.toISOString(), this.environment];
+    } else {
+      sql = `SELECT * FROM ${safeTable} WHERE ${validateIdentifier(timestampCol)} > $1`;
+      params = [since.toISOString()];
+    }
+    try {
+      const rows = await this.writer.query(sql, params);
+      return rows.map((row) => this.transformRecord(row, source));
+    } catch (error) {
+      logger15.debug(`Changed query failed for ${source.cloudTable}, falling back to readAll`, {
+        error: toErrorMessage(error)
+      });
+      return this.readAll(source);
+    }
+  }
+  /**
+   * Get record count from a cloud table
+   */
+  async count(source) {
+    const safeTable = this.sanitizeCloudTable(source.cloudTable);
+    let sql;
+    let params;
+    if (this.environment !== "all") {
+      sql = `SELECT COUNT(*) as count FROM ${safeTable} WHERE source_env = $1`;
+      params = [this.environment];
+    } else {
+      sql = `SELECT COUNT(*) as count FROM ${safeTable}`;
+      params = [];
+    }
+    try {
+      await this.writer.beginTransaction();
+      await this.writer.execute("SET LOCAL enable_indexonlyscan = off");
+      const rows = await this.writer.query(sql, params);
+      await this.writer.commit();
+      return typeof rows[0]?.count === "string" ? parseInt(rows[0].count, 10) : rows[0]?.count || 0;
+    } catch (error) {
+      try {
+        await this.writer.rollback();
+      } catch {
+      }
+      logger15.debug(`Count query failed for ${source.cloudTable}`, {
+        error: toErrorMessage(error)
+      });
+      return -1;
+    }
+  }
+  /**
+   * Transform a cloud record for local insertion.
+   * - Drops specified columns (source_env, embedding, sync_version)
+   * - Renames columns per columnMap
+   * - Applies type transforms (boolean→int, jsonb→text, etc.)
+   */
+  transformRecord(row, source) {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (source.dropColumns?.includes(key)) {
+        continue;
+      }
+      const localKey = source.columnMap?.[key] || key;
+      result[localKey] = this.transformValue(value, key, source.transforms);
+    }
+    return result;
+  }
+  /**
+   * Transform a single value based on configured transforms
+   */
+  transformValue(value, columnName, transforms) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    const transform = transforms?.[columnName];
+    if (transform === "boolean-to-int") {
+      if (typeof value === "boolean") return value ? 1 : 0;
+      if (value === "true" || value === "t") return 1;
+      if (value === "false" || value === "f") return 0;
+      return value;
+    }
+    if (transform === "jsonb-to-text") {
+      if (typeof value === "object") return JSON.stringify(value);
+      return value;
+    }
+    if (transform === "timestamptz-to-text") {
+      if (value instanceof Date) return value.toISOString();
+      return value;
+    }
+    if (typeof value === "object" && !Buffer.isBuffer(value)) {
+      return JSON.stringify(value);
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "boolean") {
+      return value ? 1 : 0;
+    }
+    return value;
+  }
+  /**
+   * Find a timestamp column in a cloud table
+   */
+  async findTimestampColumn(safeTable) {
+    const candidates = ["updated_at", "created_at", "last_update", "last_used_at"];
+    try {
+      const schema = safeTable.split(".")[0];
+      const table = safeTable.split(".")[1];
+      const rows = await this.writer.query(
+        `SELECT column_name FROM information_schema.columns
+         WHERE table_schema = $1 AND table_name = $2
+         AND data_type IN ('timestamp with time zone', 'timestamp without time zone')`,
+        [schema, table]
+      );
+      const columnNames = rows.map((r54) => r54.column_name);
+      for (const candidate of candidates) {
+        if (columnNames.includes(candidate)) {
+          return candidate;
+        }
+      }
+      return columnNames[0] || null;
+    } catch {
+      return null;
+    }
+  }
+};
+function createPostgresReader(config) {
+  return new PostgresReader(config);
+}
+
+// src/sync/writers/sqlite-writer.ts
+init_safe_db();
+init_sql_safety();
+init_error_utils();
+init_logging();
+import * as fs22 from "fs";
+var logger16 = LoggerFactory.create("sqlite-writer");
+var SQLiteWriter = class {
+  db = null;
+  dbPath;
+  batchSize;
+  constructor(config) {
+    this.dbPath = config.dbPath;
+    this.batchSize = config.batchSize || 500;
+  }
+  /**
+   * Connect to (open) the local SQLite database
+   */
+  async connect() {
+    if (this.db) return;
+    if (!fs22.existsSync(this.dbPath)) {
+      throw new Error(`SQLite database not found: ${this.dbPath}. Run 'aqe init' to create it.`);
+    }
+    try {
+      this.db = openDatabase(this.dbPath);
+      this.db.pragma("journal_mode = WAL");
+      this.db.pragma("synchronous = NORMAL");
+      logger16.debug(`Opened SQLite database: ${this.dbPath}`);
+    } catch (error) {
+      throw new Error(`Failed to open SQLite database ${this.dbPath}: ${toErrorMessage(error)}`);
+    }
+  }
+  /**
+   * Upsert records into a local table using INSERT OR REPLACE.
+   * Returns the number of records written.
+   */
+  async upsert(table, records) {
+    if (!this.db) throw new Error("Not connected");
+    if (records.length === 0) return 0;
+    const safeTable = validateTableName(table);
+    if (!this.tableExists(table)) {
+      console.warn(`[SQLiteWriter] Table '${table}' does not exist in local database \u2014 ${records.length} records skipped. Run 'aqe init' to create schema.`);
+      return 0;
+    }
+    const localColumns = this.getTableColumns(table);
+    if (localColumns.length === 0) {
+      logger16.debug(`No columns found for table ${table}`);
+      return 0;
+    }
+    const localColumnSet = new Set(localColumns);
+    let totalWritten = 0;
+    for (let i58 = 0; i58 < records.length; i58 += this.batchSize) {
+      const batch = records.slice(i58, i58 + this.batchSize);
+      try {
+        const written = this.upsertBatch(safeTable, batch, localColumnSet);
+        totalWritten += written;
+      } catch (error) {
+        const batchNum = Math.floor(i58 / this.batchSize) + 1;
+        logger16.debug(`Batch ${batchNum} failed for ${table}, retrying individually`, {
+          error: toErrorMessage(error)
+        });
+        let recovered = 0;
+        for (const record of batch) {
+          try {
+            recovered += this.upsertBatch(safeTable, [record], localColumnSet);
+          } catch (retryError) {
+            const recordId = record["id"] || record["key"] || "?";
+            logger16.debug(`Skipped record ${String(recordId).slice(0, 50)} in ${table}`, {
+              error: toErrorMessage(retryError)
+            });
+          }
+        }
+        totalWritten += recovered;
+      }
+    }
+    return totalWritten;
+  }
+  /**
+   * Get the record count for a table
+   */
+  async count(table) {
+    if (!this.db) throw new Error("Not connected");
+    if (!this.tableExists(table)) return 0;
+    try {
+      const safeTable = validateTableName(table);
+      const row = this.db.prepare(`SELECT COUNT(*) as count FROM ${safeTable}`).get();
+      return row.count;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Close the database connection
+   */
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      logger16.debug("SQLite writer closed");
+    }
+  }
+  /**
+   * Check if a table exists
+   */
+  tableExists(table) {
+    if (!this.db) return false;
+    try {
+      const result = this.db.prepare(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name=?`
+      ).get(table);
+      return !!result;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get column names for a table
+   */
+  getTableColumns(table) {
+    if (!this.db) return [];
+    try {
+      const safeTable = validateTableName(table);
+      const columns = this.db.prepare(`PRAGMA table_info(${safeTable})`).all();
+      return columns.map((c70) => c70.name);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get the primary key column(s) for a table
+   */
+  getPrimaryKeyColumns(table) {
+    if (!this.db) return [];
+    try {
+      const safeTable = validateTableName(table);
+      const columns = this.db.prepare(`PRAGMA table_info(${safeTable})`).all();
+      const pkCols = columns.filter((c70) => c70.pk > 0).sort((a37, b68) => a37.pk - b68.pk).map((c70) => c70.name);
+      return pkCols;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Upsert a batch of records.
+   * Uses INSERT ... ON CONFLICT(pk) DO UPDATE SET for mapped columns only,
+   * preserving any local columns not present in the cloud record.
+   * Falls back to INSERT OR IGNORE when no primary key is found (append-mode tables).
+   */
+  upsertBatch(safeTable, records, localColumnSet) {
+    if (!this.db || records.length === 0) return 0;
+    const firstRecord = records[0];
+    const columns = Object.keys(firstRecord).filter((k68) => localColumnSet.has(k68));
+    if (columns.length === 0) return 0;
+    const safeColumns = columns.map(validateIdentifier);
+    const placeholders = columns.map(() => "?").join(", ");
+    const rawTable = safeTable.replace(/"/g, "");
+    const pkColumns = this.getPrimaryKeyColumns(rawTable);
+    let sql;
+    if (pkColumns.length > 0) {
+      const safePkColumns = pkColumns.map(validateIdentifier);
+      const updateColumns = columns.filter((c70) => !pkColumns.includes(c70));
+      if (updateColumns.length > 0) {
+        const updateSet = updateColumns.map((c70) => `${validateIdentifier(c70)} = excluded.${validateIdentifier(c70)}`).join(", ");
+        sql = `INSERT INTO ${safeTable} (${safeColumns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${safePkColumns.join(", ")}) DO UPDATE SET ${updateSet}`;
+      } else {
+        sql = `INSERT OR IGNORE INTO ${safeTable} (${safeColumns.join(", ")}) VALUES (${placeholders})`;
+      }
+    } else {
+      sql = `INSERT OR IGNORE INTO ${safeTable} (${safeColumns.join(", ")}) VALUES (${placeholders})`;
+    }
+    const stmt = this.db.prepare(sql);
+    const insertMany = this.db.transaction((recs) => {
+      let count = 0;
+      for (const record of recs) {
+        const values = columns.map((col) => this.serializeValue(record[col]));
+        stmt.run(...values);
+        count++;
+      }
+      return count;
+    });
+    return insertMany(records);
+  }
+  /**
+   * Serialize a value for SQLite insertion
+   */
+  serializeValue(value) {
+    if (value === null || value === void 0) return null;
+    if (typeof value === "object" && !Buffer.isBuffer(value) && !(value instanceof Date)) {
+      return JSON.stringify(value);
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "boolean") {
+      return value ? 1 : 0;
+    }
+    if (Buffer.isBuffer(value)) {
+      return value;
+    }
+    return value;
+  }
+};
+function createSQLiteWriter(config) {
+  return new SQLiteWriter(config);
+}
+
 // src/sync/sync-agent.ts
 init_esm_node();
 init_logging();
 init_error_utils();
-var logger15 = LoggerFactory.create("sync-agent");
+var logger17 = LoggerFactory.create("sync-agent");
 var CloudSyncAgent = class {
   config;
   readers = /* @__PURE__ */ new Map();
@@ -134538,13 +135126,20 @@ var CloudSyncAgent = class {
       let cloudCount = 0;
       if (this.writer) {
         try {
+          await this.writer.beginTransaction();
+          await this.writer.execute("SET LOCAL enable_indexonlyscan = off");
           const rows = await this.writer.query(
             `SELECT COUNT(*) as count FROM ${source.targetTable} WHERE source_env = $1`,
             [this.config.environment]
           );
+          await this.writer.commit();
           cloudCount = rows[0]?.count || 0;
         } catch (e20) {
-          logger15.debug("Cloud count query failed", { source: source.name, error: e20 instanceof Error ? e20.message : String(e20) });
+          try {
+            await this.writer.rollback();
+          } catch {
+          }
+          logger17.debug("Cloud count query failed", { source: source.name, error: e20 instanceof Error ? e20.message : String(e20) });
           cloudCount = -1;
         }
       }
@@ -134661,6 +135256,308 @@ async function syncIncrementalToCloud(since, config) {
   }
 }
 
+// src/sync/pull-agent.ts
+init_esm_node();
+import * as fs23 from "fs";
+import * as path21 from "path";
+init_error_utils();
+init_logging();
+var logger18 = LoggerFactory.create("pull-agent");
+var PullSyncAgent = class {
+  config;
+  reader = null;
+  writer = null;
+  cloudWriter = null;
+  report = null;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_PULL_CONFIG,
+      ...config,
+      cloud: { ...DEFAULT_PULL_CONFIG.cloud, ...config.cloud },
+      sources: config.sources || DEFAULT_PULL_CONFIG.sources
+    };
+  }
+  /**
+   * Initialize connections to both cloud and local databases
+   */
+  async initialize() {
+    this.log("Initializing pull sync agent...");
+    const tunnelManager = createConnectionManager(this.config.cloud);
+    this.cloudWriter = createPostgresWriter({
+      cloud: this.config.cloud,
+      tunnelManager
+    });
+    await this.cloudWriter.connect();
+    this.log("Connected to cloud database");
+    this.reader = createPostgresReader({
+      writer: this.cloudWriter,
+      environment: this.config.environment
+    });
+    const dbPath = this.resolveTargetDb();
+    this.writer = createSQLiteWriter({ dbPath });
+    await this.writer.connect();
+    this.log(`Connected to local database: ${dbPath}`);
+  }
+  /**
+   * Full pull: download all cloud data into local DB
+   */
+  async pullAll() {
+    this.report = this.createReport("full");
+    try {
+      this.ensureInitialized();
+      this.backupLocalDb();
+      const sources = this.getEnabledSources();
+      let completed = 0;
+      for (const source of sources) {
+        this.progress(`Pulling ${source.name}...`, completed / sources.length);
+        const result = await this.pullTable(source);
+        this.report.results.push(result);
+        completed++;
+      }
+      this.report.status = this.report.results.every((r54) => r54.success) ? "completed" : "partial";
+    } catch (error) {
+      this.report.status = "failed";
+      this.report.errors.push(toErrorMessage(error));
+    } finally {
+      this.finalizeReport();
+    }
+    return this.report;
+  }
+  /**
+   * Incremental pull: only records changed since a timestamp
+   */
+  async pullIncremental(since) {
+    this.report = this.createReport("incremental");
+    const sinceDate = since || new Date(Date.now() - 24 * 60 * 60 * 1e3);
+    try {
+      this.ensureInitialized();
+      this.backupLocalDb();
+      const sources = this.getEnabledSources().filter((s70) => s70.mode !== "full");
+      for (const source of sources) {
+        this.progress(`Incremental pull ${source.name}...`, 0);
+        const result = await this.pullTableIncremental(source, sinceDate);
+        this.report.results.push(result);
+      }
+      this.report.status = this.report.results.every((r54) => r54.success) ? "completed" : "partial";
+    } catch (error) {
+      this.report.status = "failed";
+      this.report.errors.push(toErrorMessage(error));
+    } finally {
+      this.finalizeReport();
+    }
+    return this.report;
+  }
+  /**
+   * Pull a single table from cloud to local
+   */
+  async pullTable(source) {
+    const startTime = Date.now();
+    const result = {
+      success: false,
+      table: source.localTable,
+      source: source.name,
+      recordsSynced: 0,
+      conflictsResolved: 0,
+      recordsSkipped: 0,
+      durationMs: 0,
+      warnings: []
+    };
+    try {
+      this.ensureInitialized();
+      const records = await this.reader.readAll(source);
+      this.log(`Read ${records.length} records from cloud ${source.cloudTable}`);
+      if (records.length === 0) {
+        result.success = true;
+        result.durationMs = Date.now() - startTime;
+        return result;
+      }
+      if (!this.config.dryRun) {
+        const written = await this.writer.upsert(source.localTable, records);
+        result.recordsSynced = written;
+        result.recordsSkipped = records.length - written;
+      } else {
+        result.recordsSynced = records.length;
+        this.log(`[DRY RUN] Would write ${records.length} records to local ${source.localTable}`);
+      }
+      result.success = true;
+    } catch (error) {
+      result.error = toErrorMessage(error);
+      this.config.onError?.(toError(error), source.name);
+    }
+    result.durationMs = Date.now() - startTime;
+    return result;
+  }
+  /**
+   * Pull incremental changes for a single table
+   */
+  async pullTableIncremental(source, since) {
+    const startTime = Date.now();
+    const result = {
+      success: false,
+      table: source.localTable,
+      source: source.name,
+      recordsSynced: 0,
+      conflictsResolved: 0,
+      recordsSkipped: 0,
+      durationMs: 0
+    };
+    try {
+      this.ensureInitialized();
+      const records = await this.reader.readChanged(source, since);
+      this.log(`Read ${records.length} changed records from cloud ${source.cloudTable} (since ${since.toISOString()})`);
+      if (records.length === 0) {
+        result.success = true;
+        result.durationMs = Date.now() - startTime;
+        return result;
+      }
+      if (!this.config.dryRun) {
+        const written = await this.writer.upsert(source.localTable, records);
+        result.recordsSynced = written;
+      } else {
+        result.recordsSynced = records.length;
+      }
+      result.success = true;
+    } catch (error) {
+      result.error = toErrorMessage(error);
+    }
+    result.durationMs = Date.now() - startTime;
+    return result;
+  }
+  /**
+   * Verify pull by comparing cloud and local counts
+   */
+  async verify() {
+    this.ensureInitialized();
+    const results = [];
+    for (const source of this.getEnabledSources()) {
+      const cloudCount = await this.reader.count(source);
+      const localCount = await this.writer.count(source.localTable);
+      results.push({
+        source: source.name,
+        cloudTable: source.cloudTable,
+        localTable: source.localTable,
+        cloudCount,
+        localCount,
+        match: cloudCount === localCount || cloudCount === -1,
+        diff: localCount - cloudCount
+      });
+    }
+    return {
+      verified: results.every((r54) => r54.match),
+      results
+    };
+  }
+  /**
+   * Close all connections
+   */
+  async close() {
+    if (this.writer) {
+      await this.writer.close();
+      this.writer = null;
+    }
+    if (this.cloudWriter) {
+      await this.cloudWriter.close();
+      this.cloudWriter = null;
+    }
+    this.reader = null;
+    this.log("Pull sync agent closed");
+  }
+  // Private helpers
+  ensureInitialized() {
+    if (!this.reader || !this.writer) {
+      throw new Error("PullSyncAgent not initialized. Call initialize() first.");
+    }
+  }
+  getEnabledSources() {
+    let sources = this.config.sources.filter((s70) => s70.enabled);
+    if (this.config.tables && this.config.tables.length > 0) {
+      const tableSet = new Set(this.config.tables);
+      sources = sources.filter((s70) => tableSet.has(s70.localTable) || tableSet.has(s70.name));
+    }
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    return sources.sort((a37, b68) => priorityOrder[a37.priority] - priorityOrder[b68.priority]);
+  }
+  resolveTargetDb() {
+    if (this.config.targetDb) {
+      return path21.resolve(this.config.targetDb);
+    }
+    return path21.resolve(process.cwd(), ".agentic-qe/memory.db");
+  }
+  backupLocalDb() {
+    if (this.config.dryRun) return;
+    const dbPath = this.resolveTargetDb();
+    if (!fs23.existsSync(dbPath)) return;
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const backupPath = `${dbPath}.bak-${timestamp}`;
+    try {
+      fs23.copyFileSync(dbPath, backupPath);
+      this.log(`Backed up local DB to ${backupPath}`);
+    } catch (error) {
+      this.log(`Warning: Failed to backup local DB: ${toErrorMessage(error)}`, "warn");
+    }
+  }
+  createReport(mode) {
+    return {
+      syncId: v4_default(),
+      startedAt: /* @__PURE__ */ new Date(),
+      status: "running",
+      environment: this.config.environment,
+      mode,
+      results: [],
+      totalRecordsSynced: 0,
+      totalConflictsResolved: 0,
+      totalDurationMs: 0,
+      errors: []
+    };
+  }
+  finalizeReport() {
+    if (!this.report) return;
+    this.report.completedAt = /* @__PURE__ */ new Date();
+    this.report.totalDurationMs = this.report.completedAt.getTime() - this.report.startedAt.getTime();
+    this.report.totalRecordsSynced = this.report.results.reduce((sum, r54) => sum + r54.recordsSynced, 0);
+    this.report.totalConflictsResolved = this.report.results.reduce((sum, r54) => sum + r54.conflictsResolved, 0);
+  }
+  log(message, level = "info") {
+    if (!this.config.verbose && level === "info") return;
+    const prefix = `[PullSync:${this.config.environment}]`;
+    switch (level) {
+      case "warn":
+        console.warn(`${prefix} ${message}`);
+        break;
+      case "error":
+        console.error(`${prefix} ${message}`);
+        break;
+      default:
+        console.log(`${prefix} ${message}`);
+    }
+  }
+  progress(message, progress) {
+    this.config.onProgress?.(message, progress);
+    this.log(message);
+  }
+};
+function createPullSyncAgent(config) {
+  return new PullSyncAgent(config);
+}
+async function pullFromCloud(config) {
+  const agent = createPullSyncAgent({ ...config, verbose: true });
+  await agent.initialize();
+  try {
+    return await agent.pullAll();
+  } finally {
+    await agent.close();
+  }
+}
+async function pullIncrementalFromCloud(since, config) {
+  const agent = createPullSyncAgent({ ...config, verbose: true });
+  await agent.initialize();
+  try {
+    return await agent.pullIncremental(since);
+  } finally {
+    await agent.close();
+  }
+}
+
 // src/integrations/embeddings/cache/EmbeddingCache.ts
 init_safe_db();
 init_unified_memory();
@@ -134676,16 +135573,16 @@ init_sql_safety();
 init_error_utils();
 init_safe_json();
 init_logging();
-import { resolve as resolve13, dirname as dirname12 } from "path";
+import { resolve as resolve14, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-var logger16 = LoggerFactory.create("sync-embedding-generator");
+var logger19 = LoggerFactory.create("sync-embedding-generator");
 var __filename4 = fileURLToPath5(import.meta.url);
 var __dirname4 = dirname12(__filename4);
 
 // src/cli/commands/sync.ts
 init_error_utils();
-import * as fs22 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 function createSyncCommands() {
   const syncCmd = new Command14("sync").description("Sync local learning data to cloud PostgreSQL");
   syncCmd.option("-f, --full", "Run full sync instead of incremental").option("-e, --env <environment>", "Environment identifier", process.env.AQE_ENV || "devpod").option("--dry-run", "Preview sync without making changes").option("-v, --verbose", "Enable verbose output").option("--since <date>", "Sync changes since date (ISO 8601)").option("--sources <sources>", "Comma-separated list of sources to sync").action(async (options) => {
@@ -134721,6 +135618,34 @@ function createSyncCommands() {
       process.exit(1);
     }
   });
+  syncCmd.command("pull").description("Pull cloud learning data into local SQLite database").option("-f, --full", "Full pull (all cloud data)").option("-e, --env <environment>", "Pull only data from specific environment", "all").option("--tables <tables>", "Comma-separated list of tables to pull").option("--dry-run", "Preview pull without writing to local DB").option("--target <path>", "Custom target SQLite database path").option("--since <date>", "Pull changes since date (ISO 8601)").option("-v, --verbose", "Enable verbose output").action(async (options) => {
+    const pullConfig = {
+      environment: options.env,
+      verbose: options.verbose,
+      dryRun: options.dryRun,
+      targetDb: options.target
+    };
+    if (options.tables) {
+      pullConfig.tables = options.tables.split(",").map((t50) => t50.trim());
+    }
+    const spinner = ora2("Initializing pull sync agent...").start();
+    try {
+      let report;
+      if (options.full) {
+        spinner.text = "Pulling all data from cloud...";
+        report = await pullFromCloud(pullConfig);
+      } else {
+        const since = options.since ? new Date(options.since) : void 0;
+        spinner.text = `Pulling ${since ? "changes since " + since.toISOString() : "incremental changes (last 24h)"}...`;
+        report = await pullIncrementalFromCloud(since, pullConfig);
+      }
+      spinner.stop();
+      printPullReport(report);
+    } catch (error) {
+      spinner.fail(`Pull failed: ${toErrorMessage(error)}`);
+      process.exit(1);
+    }
+  });
   syncCmd.command("status").description("Show sync status and data source information").option("-e, --env <environment>", "Environment identifier", process.env.AQE_ENV || "devpod").action(async (options) => {
     const spinner = ora2("Checking sync status...").start();
     try {
@@ -134751,16 +135676,16 @@ function createSyncCommands() {
     }
   });
   syncCmd.command("init").description("Initialize cloud schema (requires GCP credentials)").option("--dry-run", "Print schema without executing").option("-o, --output <file>", "Save schema to file").action(async (options) => {
-    const schemaPath = path21.join(__dirname, "../../sync/schema/cloud-schema.sql");
+    const schemaPath = path22.join(__dirname, "../../sync/schema/cloud-schema.sql");
     let schema;
     try {
-      schema = fs22.readFileSync(schemaPath, "utf-8");
+      schema = fs24.readFileSync(schemaPath, "utf-8");
     } catch {
-      const altPath = path21.join(process.cwd(), "v3/src/sync/schema/cloud-schema.sql");
-      schema = fs22.readFileSync(altPath, "utf-8");
+      const altPath = path22.join(process.cwd(), "v3/src/sync/schema/cloud-schema.sql");
+      schema = fs24.readFileSync(altPath, "utf-8");
     }
     if (options.output) {
-      fs22.writeFileSync(options.output, schema);
+      fs24.writeFileSync(options.output, schema);
       console.log(chalk26.green(`Schema saved to ${options.output}`));
       return;
     }
@@ -134890,13 +135815,48 @@ function printVerifyResult(result) {
     console.log();
   }
 }
+function printPullReport(report) {
+  const statusColor = report.status === "completed" ? chalk26.green : report.status === "partial" ? chalk26.yellow : chalk26.red;
+  console.log(chalk26.cyan("\n=== Pull Sync Report (Cloud \u2192 Local) ===\n"));
+  console.log(chalk26.bold("Sync ID:"), report.syncId);
+  console.log(chalk26.bold("Status:"), statusColor(report.status.toUpperCase()));
+  console.log(chalk26.bold("Environment:"), report.environment);
+  console.log(chalk26.bold("Mode:"), report.mode);
+  console.log(chalk26.bold("Duration:"), `${report.totalDurationMs}ms`);
+  console.log();
+  console.log(chalk26.bold("Summary:"));
+  console.log(`   Records Pulled: ${chalk26.green(report.totalRecordsSynced)}`);
+  console.log();
+  if (report.results.length > 0) {
+    console.log(chalk26.bold("Results by Table:"));
+    for (const result of report.results) {
+      const icon = result.success ? chalk26.green("\u2713") : chalk26.red("\u2717");
+      console.log(`   ${icon} ${result.source} \u2192 ${result.table}`);
+      console.log(`      Records: ${result.recordsSynced}`);
+      console.log(`      Duration: ${result.durationMs}ms`);
+      if (result.recordsSkipped > 0) {
+        console.log(`      Skipped: ${chalk26.yellow(result.recordsSkipped)}`);
+      }
+      if (result.error) {
+        console.log(`      Error: ${chalk26.red(result.error)}`);
+      }
+    }
+    console.log();
+  }
+  if (report.errors.length > 0) {
+    console.log(chalk26.red("Errors:"));
+    for (const error of report.errors) {
+      console.log(`   - ${error}`);
+    }
+  }
+}
 
 // src/cli/commands/hooks.ts
 init_qe_reasoning_bank();
 init_safe_json();
 import { Command as Command15 } from "commander";
 import chalk27 from "chalk";
-import path22 from "node:path";
+import path23 from "node:path";
 init_unified_memory();
 
 // src/integrations/coherence/types.ts
@@ -135049,9 +136009,9 @@ var CohomologyAdapter = class {
    * @param wasmLoader - WASM module loader
    * @param logger - Optional logger for diagnostics
    */
-  constructor(wasmLoader2, logger19 = DEFAULT_COHERENCE_LOGGER) {
+  constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
     this.wasmLoader = wasmLoader2;
-    this.logger = logger19;
+    this.logger = logger22;
   }
   engine = null;
   initialized = false;
@@ -135395,9 +136355,9 @@ var SpectralAdapter = class {
    * @param wasmLoader - WASM module loader
    * @param logger - Optional logger for diagnostics
    */
-  constructor(wasmLoader2, logger19 = DEFAULT_COHERENCE_LOGGER) {
+  constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
     this.wasmLoader = wasmLoader2;
-    this.logger = logger19;
+    this.logger = logger22;
   }
   engine = null;
   initialized = false;
@@ -135806,9 +136766,9 @@ var CausalAdapter = class {
    * @param wasmLoader - WASM module loader
    * @param logger - Optional logger for diagnostics
    */
-  constructor(wasmLoader2, logger19 = DEFAULT_COHERENCE_LOGGER) {
+  constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
     this.wasmLoader = wasmLoader2;
-    this.logger = logger19;
+    this.logger = logger22;
   }
   engine = null;
   initialized = false;
@@ -136057,11 +137017,11 @@ function createCategoryEngineWrapper(rawEngine) {
     add_morphism(source, target, name) {
       morphisms.push({ source, target, name });
     },
-    verify_composition(path26) {
-      if (path26.length < 2) return true;
-      for (let i58 = 0; i58 < path26.length - 1; i58++) {
-        const source = path26[i58];
-        const target = path26[i58 + 1];
+    verify_composition(path27) {
+      if (path27.length < 2) return true;
+      for (let i58 = 0; i58 < path27.length - 1; i58++) {
+        const source = path27[i58];
+        const target = path27[i58 + 1];
         const hasMorphism = morphisms.some((m74) => m74.source === source && m74.target === target);
         if (!hasMorphism) return false;
       }
@@ -136101,9 +137061,9 @@ var CategoryAdapter = class {
    * @param wasmLoader - WASM module loader
    * @param logger - Optional logger for diagnostics
    */
-  constructor(wasmLoader2, logger19 = DEFAULT_COHERENCE_LOGGER) {
+  constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
     this.wasmLoader = wasmLoader2;
-    this.logger = logger19;
+    this.logger = logger22;
   }
   engine = null;
   initialized = false;
@@ -136176,14 +137136,14 @@ var CategoryAdapter = class {
    * @param path - Array of type names representing a composition path
    * @returns True if the composition is valid
    */
-  verifyComposition(path26) {
+  verifyComposition(path27) {
     this.ensureInitialized();
-    if (path26.length < 2) {
+    if (path27.length < 2) {
       return true;
     }
-    const isValid = this.engine.verify_composition(path26);
+    const isValid = this.engine.verify_composition(path27);
     this.logger.debug("Verified composition", {
-      path: path26,
+      path: path27,
       isValid
     });
     return isValid;
@@ -136222,8 +137182,8 @@ var CategoryAdapter = class {
     for (const element of pipeline10.elements) {
       this.addMorphism(element.inputType, element.outputType, element.name);
     }
-    const path26 = this.buildCompositionPath(pipeline10);
-    const compositionValid = this.verifyComposition(path26);
+    const path27 = this.buildCompositionPath(pipeline10);
+    const compositionValid = this.verifyComposition(path27);
     const mismatches = this.checkTypeConsistency();
     const warnings = this.generateWarnings(pipeline10, compositionValid, mismatches);
     const durationMs = Date.now() - startTime;
@@ -136247,17 +137207,17 @@ var CategoryAdapter = class {
    * Build a composition path from a pipeline
    */
   buildCompositionPath(pipeline10) {
-    const path26 = [pipeline10.inputType];
+    const path27 = [pipeline10.inputType];
     for (const element of pipeline10.elements) {
-      if (element.inputType !== path26[path26.length - 1]) {
-        path26.push(element.inputType);
+      if (element.inputType !== path27[path27.length - 1]) {
+        path27.push(element.inputType);
       }
-      path26.push(element.outputType);
+      path27.push(element.outputType);
     }
-    if (path26[path26.length - 1] !== pipeline10.outputType) {
-      path26.push(pipeline10.outputType);
+    if (path27[path27.length - 1] !== pipeline10.outputType) {
+      path27.push(pipeline10.outputType);
     }
-    return path26;
+    return path27;
   }
   /**
    * Infer a schema from a type name
@@ -136388,9 +137348,9 @@ function createHomotopyEngineWrapper(rawEngine) {
       }
       return false;
     },
-    verify_path_equivalence(path1, path26) {
+    verify_path_equivalence(path1, path27) {
       const pathObj1 = { steps: path1 };
-      const pathObj2 = { steps: path26 };
+      const pathObj2 = { steps: path27 };
       return rawEngine.checkTypeEquivalence(pathObj1, pathObj2);
     },
     get_unproven_propositions() {
@@ -136415,9 +137375,9 @@ var HomotopyAdapter = class {
    * @param wasmLoader - WASM module loader
    * @param logger - Optional logger for diagnostics
    */
-  constructor(wasmLoader2, logger19 = DEFAULT_COHERENCE_LOGGER) {
+  constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
     this.wasmLoader = wasmLoader2;
-    this.logger = logger19;
+    this.logger = logger22;
   }
   engine = null;
   initialized = false;
@@ -136506,19 +137466,19 @@ var HomotopyAdapter = class {
    * @param path2 - Second execution path
    * @returns Path equivalence result
    */
-  verifyPathEquivalence(path1, path26) {
+  verifyPathEquivalence(path1, path27) {
     this.ensureInitialized();
-    const equivalent = this.engine.verify_path_equivalence(path1, path26);
-    const explanation = this.generateEquivalenceExplanation(path1, path26, equivalent);
+    const equivalent = this.engine.verify_path_equivalence(path1, path27);
+    const explanation = this.generateEquivalenceExplanation(path1, path27, equivalent);
     const result = {
       equivalent,
       path1,
-      path2: path26,
+      path2: path27,
       explanation
     };
     this.logger.debug("Verified path equivalence", {
       path1Length: path1.length,
-      path2Length: path26.length,
+      path2Length: path27.length,
       equivalent
     });
     return result;
@@ -136526,24 +137486,24 @@ var HomotopyAdapter = class {
   /**
    * Generate an explanation for path equivalence result
    */
-  generateEquivalenceExplanation(path1, path26, equivalent) {
+  generateEquivalenceExplanation(path1, path27, equivalent) {
     if (equivalent) {
-      if (path1.length === path26.length) {
+      if (path1.length === path27.length) {
         return `The execution paths are homotopically equivalent. Both paths traverse the same abstract structure and will produce equivalent results.`;
       } else {
-        const longer = path1.length > path26.length ? "first" : "second";
+        const longer = path1.length > path27.length ? "first" : "second";
         return `The execution paths are equivalent despite different lengths. The ${longer} path contains redundant steps that can be contracted without changing the result (homotopy contraction).`;
       }
     } else {
       let divergeIndex = 0;
-      const minLen = Math.min(path1.length, path26.length);
-      while (divergeIndex < minLen && path1[divergeIndex] === path26[divergeIndex]) {
+      const minLen = Math.min(path1.length, path27.length);
+      while (divergeIndex < minLen && path1[divergeIndex] === path27[divergeIndex]) {
         divergeIndex++;
       }
       if (divergeIndex === 0) {
-        return `The execution paths diverge immediately. Path 1 starts with '${path1[0]}' while Path 2 starts with '${path26[0]}'. These lead to fundamentally different computation spaces.`;
+        return `The execution paths diverge immediately. Path 1 starts with '${path1[0]}' while Path 2 starts with '${path27[0]}'. These lead to fundamentally different computation spaces.`;
       }
-      return `The execution paths diverge at step ${divergeIndex + 1}. After '${path1[divergeIndex - 1]}', Path 1 proceeds to '${path1[divergeIndex]}' while Path 2 proceeds to '${path26[divergeIndex]}'. No homotopy exists between these paths.`;
+      return `The execution paths diverge at step ${divergeIndex + 1}. After '${path1[divergeIndex - 1]}', Path 1 proceeds to '${path1[divergeIndex]}' while Path 2 proceeds to '${path27[divergeIndex]}'. No homotopy exists between these paths.`;
     }
   }
   /**
@@ -136617,9 +137577,9 @@ var WitnessAdapter = class {
    * @param wasmLoader - WASM module loader
    * @param logger - Optional logger for diagnostics
    */
-  constructor(wasmLoader2, logger19 = DEFAULT_COHERENCE_LOGGER) {
+  constructor(wasmLoader2, logger22 = DEFAULT_COHERENCE_LOGGER) {
     this.wasmLoader = wasmLoader2;
-    this.logger = logger19;
+    this.logger = logger22;
   }
   engine = null;
   initialized = false;
@@ -136914,10 +137874,10 @@ var CoherenceService = class {
    * @param config - Optional service configuration
    * @param logger - Optional logger for diagnostics
    */
-  constructor(wasmLoader2, config = {}, logger19) {
+  constructor(wasmLoader2, config = {}, logger22) {
     this.wasmLoader = wasmLoader2;
     this.config = { ...DEFAULT_COHERENCE_CONFIG, ...config };
-    this.logger = logger19 || DEFAULT_COHERENCE_LOGGER;
+    this.logger = logger22 || DEFAULT_COHERENCE_LOGGER;
   }
   config;
   logger;
@@ -137618,8 +138578,8 @@ var CoherenceService = class {
     return (hash >>> 0).toString(16).padStart(8, "0");
   }
 };
-async function createCoherenceService(wasmLoader2, config, logger19) {
-  const service = new CoherenceService(wasmLoader2, config, logger19);
+async function createCoherenceService(wasmLoader2, config, logger22) {
+  const service = new CoherenceService(wasmLoader2, config, logger22);
   await service.initialize();
   return service;
 }
@@ -137629,7 +138589,7 @@ init_error_utils();
 import { createRequire as createRequire9 } from "node:module";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { dirname as dirname13, join as join44 } from "node:path";
-import { readFileSync as readFileSync32, existsSync as existsSync44 } from "node:fs";
+import { readFileSync as readFileSync32, existsSync as existsSync46 } from "node:fs";
 var FALLBACK_RETRY_DELAYS_MS = [1e3, 2e3, 4e3];
 var WasmLoader = class {
   state = "unloaded";
@@ -137894,8 +138854,8 @@ var WasmLoader = class {
         })(),
         join44(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
       ].filter((p74) => p74 !== null);
-      for (const path26 of wasmPaths) {
-        if (existsSync44(path26)) {
+      for (const path27 of wasmPaths) {
+        if (existsSync46(path27)) {
           return true;
         }
       }
@@ -138157,9 +139117,9 @@ var WasmLoader = class {
       join44(process.cwd(), "node_modules/prime-radiant-advanced-wasm/prime_radiant_advanced_wasm_bg.wasm")
     ].filter((p74) => p74 !== null);
     let wasmPath = null;
-    for (const path26 of wasmPaths) {
-      if (existsSync44(path26)) {
-        wasmPath = path26;
+    for (const path27 of wasmPaths) {
+      if (existsSync46(path27)) {
+        wasmPath = path27;
         break;
       }
     }
@@ -138196,7 +139156,7 @@ Ensure prime-radiant-advanced-wasm is installed.`
    * Sleep for a specified duration.
    */
   sleep(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
   // ===========================================================================
   // ADR-052 A4.3: Fallback Mode Management
@@ -138326,7 +139286,7 @@ async function initializeHooksSystem() {
   if (state.initialized) return;
   try {
     const projectRoot = findProjectRoot();
-    const dataDir = path22.join(projectRoot, ".agentic-qe");
+    const dataDir = path23.join(projectRoot, ".agentic-qe");
     const memoryBackend2 = await createHybridBackendWithTimeout(dataDir);
     try {
       state.coherenceService = await createCoherenceService(wasmLoader);
@@ -138372,7 +139332,7 @@ async function createHybridBackendWithTimeout(dataDir) {
   const timeoutMs = 5e3;
   const backend = new HybridMemoryBackend({
     sqlite: {
-      path: path22.join(dataDir, "memory.db"),
+      path: path23.join(dataDir, "memory.db"),
       // ADR-046: Unified storage
       walMode: true,
       poolSize: 3,
@@ -138678,7 +139638,7 @@ Examples:
       let dreamTriggered = false;
       try {
         const projectRoot = findProjectRoot();
-        const dataDir = path22.join(projectRoot, ".agentic-qe");
+        const dataDir = path23.join(projectRoot, ".agentic-qe");
         const memoryBackend2 = await createHybridBackendWithTimeout(dataDir);
         await incrementDreamExperience(memoryBackend2);
       } catch {
@@ -138777,7 +139737,7 @@ Examples:
           null
         );
         const projectRoot = findProjectRoot();
-        const dataDir = path22.join(projectRoot, ".agentic-qe");
+        const dataDir = path23.join(projectRoot, ".agentic-qe");
         const memoryBackend2 = await createHybridBackendWithTimeout(dataDir);
         await incrementDreamExperience(memoryBackend2);
       } catch (persistError) {
@@ -138982,7 +139942,7 @@ Registered: ${events.length}/${Object.keys(QE_HOOK_EVENTS).length}`)
       const { reasoningBank } = await getHooksSystem();
       const stats = await reasoningBank.getStats();
       const projectRoot = findProjectRoot();
-      const dataDir = path22.join(projectRoot, ".agentic-qe");
+      const dataDir = path23.join(projectRoot, ".agentic-qe");
       const memoryBackend2 = await createHybridBackendWithTimeout(dataDir);
       let dreamState = await memoryBackend2.get(DREAM_STATE_KEY);
       const isNewSession = !dreamState || !dreamState.sessionStartTime;
@@ -139141,7 +140101,7 @@ Registered: ${events.length}/${Object.keys(QE_HOOK_EVENTS).length}`)
           });
         }
         const projectRoot = findProjectRoot();
-        const dataDir = path22.join(projectRoot, ".agentic-qe");
+        const dataDir = path23.join(projectRoot, ".agentic-qe");
         const memoryBackend2 = await createHybridBackendWithTimeout(dataDir);
         const expCount = await incrementDreamExperience(memoryBackend2);
         dreamResult = await checkAndTriggerDream(memoryBackend2);
@@ -139334,7 +140294,7 @@ Registered: ${events.length}/${Object.keys(QE_HOOK_EVENTS).length}`)
         });
         experienceRecorded = true;
         const projectRoot = findProjectRoot();
-        const dataDir = path22.join(projectRoot, ".agentic-qe");
+        const dataDir = path23.join(projectRoot, ".agentic-qe");
         const memoryBackend2 = await createHybridBackendWithTimeout(dataDir);
         await incrementDreamExperience(memoryBackend2);
       } catch (initError) {
@@ -139367,8 +140327,8 @@ init_safe_json();
 init_qe_patterns();
 import { Command as Command16 } from "commander";
 import chalk29 from "chalk";
-import path25 from "node:path";
-import { existsSync as existsSync46, writeFileSync as writeFileSync22, readFileSync as readFileSync33, mkdirSync as mkdirSync19, copyFileSync as copyFileSync8 } from "node:fs";
+import path26 from "node:path";
+import { existsSync as existsSync48, writeFileSync as writeFileSync22, readFileSync as readFileSync33, mkdirSync as mkdirSync19, copyFileSync as copyFileSync9 } from "node:fs";
 import { stat as stat3, unlink } from "node:fs/promises";
 
 // src/learning/metrics-tracker.ts
@@ -139376,22 +140336,22 @@ init_safe_db();
 init_qe_patterns();
 init_safe_json();
 init_logging();
-import path23 from "node:path";
-import { existsSync as existsSync45 } from "node:fs";
-var logger18 = LoggerFactory.create("metrics-tracker");
+import path24 from "node:path";
+import { existsSync as existsSync47 } from "node:fs";
+var logger21 = LoggerFactory.create("metrics-tracker");
 var LearningMetricsTracker = class {
   db = null;
   dbPath;
   initialized = false;
   constructor(projectRoot = process.cwd()) {
-    this.dbPath = path23.join(projectRoot, ".agentic-qe", "memory.db");
+    this.dbPath = path24.join(projectRoot, ".agentic-qe", "memory.db");
   }
   /**
    * Initialize the tracker (open database, ensure tables exist)
    */
   async initialize() {
     if (this.initialized) return;
-    if (!existsSync45(this.dbPath)) {
+    if (!existsSync47(this.dbPath)) {
       throw new Error(`Database not found: ${this.dbPath}. Run "aqe init --auto" first.`);
     }
     this.db = openDatabase(this.dbPath);
@@ -139659,7 +140619,7 @@ var LearningMetricsTracker = class {
       try {
         domainCoverage = safeJsonParse(row.domain_coverage_json || "{}");
       } catch (e20) {
-        logger18.debug("Domain coverage JSON parse failed", { error: e20 instanceof Error ? e20.message : String(e20) });
+        logger21.debug("Domain coverage JSON parse failed", { error: e20 instanceof Error ? e20.message : String(e20) });
         for (const domain of QE_DOMAIN_LIST) {
           domainCoverage[domain] = 0;
         }
@@ -139750,7 +140710,7 @@ init_unified_memory();
 init_qe_reasoning_bank();
 init_safe_db();
 import chalk28 from "chalk";
-import path24 from "node:path";
+import path25 from "node:path";
 import { createReadStream, createWriteStream } from "node:fs";
 import { createGzip, createGunzip } from "node:zlib";
 import { pipeline as pipeline9 } from "node:stream/promises";
@@ -139764,10 +140724,10 @@ async function initializeLearningSystem2() {
     return state2.reasoningBank;
   }
   const projectRoot = findProjectRoot();
-  const dataDir = path24.join(projectRoot, ".agentic-qe");
+  const dataDir = path25.join(projectRoot, ".agentic-qe");
   const backend = new HybridMemoryBackend({
     sqlite: {
-      path: path24.join(dataDir, "memory.db"),
+      path: path25.join(dataDir, "memory.db"),
       walMode: true,
       poolSize: 3,
       busyTimeout: 5e3
@@ -139877,7 +140837,7 @@ function stripAnsi(text) {
 }
 function getDbPath() {
   const projectRoot = findProjectRoot();
-  return path24.join(projectRoot, ".agentic-qe", "memory.db");
+  return path25.join(projectRoot, ".agentic-qe", "memory.db");
 }
 async function compressFile(inputPath, outputPath) {
   const gzPath = outputPath || `${inputPath}.gz`;
@@ -140167,7 +141127,7 @@ function registerExportCommand(learning) {
       if (options.json) {
         printJson2(exportData);
       } else {
-        const outputPath = path25.resolve(options.output);
+        const outputPath = path26.resolve(options.output);
         writeFileSync22(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
         printSuccess2(`Exported ${patterns.length} patterns to ${outputPath}`);
       }
@@ -140181,8 +141141,8 @@ function registerExportCommand(learning) {
 function registerImportCommand(learning) {
   learning.command("import").description("Import patterns from file").requiredOption("-i, --input <file>", "Input file path").option("--dry-run", "Show what would be imported without making changes").option("--json", "Output as JSON").action(async (options) => {
     try {
-      const inputPath = path25.resolve(options.input);
-      if (!existsSync46(inputPath)) throw new Error(`File not found: ${inputPath}`);
+      const inputPath = path26.resolve(options.input);
+      if (!existsSync48(inputPath)) throw new Error(`File not found: ${inputPath}`);
       const content = readFileSync33(inputPath, "utf-8");
       const importData = safeJsonParse(content);
       if (!importData.patterns || !Array.isArray(importData.patterns)) throw new Error("Invalid pattern file format");
@@ -140243,15 +141203,15 @@ function registerResetCommand(learning) {
         process.exit(0);
       }
       const projectRoot = findProjectRoot();
-      const dataDir = path25.join(projectRoot, ".agentic-qe");
+      const dataDir = path26.join(projectRoot, ".agentic-qe");
       const filesToReset = [
-        path25.join(dataDir, "data", "patterns"),
-        path25.join(dataDir, "data", "hnsw")
+        path26.join(dataDir, "data", "patterns"),
+        path26.join(dataDir, "data", "hnsw")
       ];
-      if (!options.patternsOnly) filesToReset.push(path25.join(dataDir, "data", "learning-config.json"));
+      if (!options.patternsOnly) filesToReset.push(path26.join(dataDir, "data", "learning-config.json"));
       console.log(chalk29.bold("\n\u{1F5D1}\uFE0F  Resetting Learning Data\n"));
       for (const file of filesToReset) {
-        if (existsSync46(file)) console.log(chalk29.dim(`  Removing: ${path25.relative(projectRoot, file)}`));
+        if (existsSync48(file)) console.log(chalk29.dim(`  Removing: ${path26.relative(projectRoot, file)}`));
       }
       printSuccess2('Learning data reset. Run "aqe init --auto" to reinitialize.\n');
       process.exit(0);
@@ -140265,8 +141225,8 @@ function registerExtractCommand(learning) {
   learning.command("extract").description("Extract QE patterns from existing learning experiences").option("--min-reward <n>", "Minimum reward threshold for pattern extraction", "0.7").option("--min-count <n>", "Minimum occurrences to form a pattern", "3").option("--dry-run", "Show what would be extracted without saving").option("--json", "Output as JSON").action(async (options) => {
     try {
       const projectRoot = findProjectRoot();
-      const dbPath = path25.join(projectRoot, ".agentic-qe", "memory.db");
-      if (!existsSync46(dbPath)) throw new Error('No memory database found. Run "aqe init --auto" first.');
+      const dbPath = path26.join(projectRoot, ".agentic-qe", "memory.db");
+      if (!existsSync48(dbPath)) throw new Error('No memory database found. Run "aqe init --auto" first.');
       const minReward = parseFloat(options.minReward);
       const minCount = parseInt(options.minCount, 10);
       console.log(chalk29.bold("\n\u{1F52C} Pattern Extraction from Learning Experiences\n"));
@@ -140391,13 +141351,13 @@ function registerInfoCommand(learning) {
   learning.command("info").description("Show learning system configuration and paths").action(async () => {
     try {
       const projectRoot = findProjectRoot();
-      const dataDir = path25.join(projectRoot, ".agentic-qe");
+      const dataDir = path26.join(projectRoot, ".agentic-qe");
       console.log(chalk29.bold("\n\u{1F4CB} AQE Learning System Info\n"));
       console.log(chalk29.bold("Paths:"));
       console.log(`  Data directory: ${dataDir}`);
-      console.log(`  Memory database: ${path25.join(dataDir, "memory.db")}`);
-      console.log(`  HNSW index: ${path25.join(dataDir, "data", "hnsw")}`);
-      console.log(`  Patterns: ${path25.join(dataDir, "data", "patterns")}`);
+      console.log(`  Memory database: ${path26.join(dataDir, "memory.db")}`);
+      console.log(`  HNSW index: ${path26.join(dataDir, "data", "hnsw")}`);
+      console.log(`  Patterns: ${path26.join(dataDir, "data", "patterns")}`);
       console.log(chalk29.bold("\nConfiguration:"));
       console.log(`  Learning enabled: ${process.env.AQE_LEARNING_ENABLED !== "false" ? chalk29.green("yes") : chalk29.red("no")}`);
       console.log(`  V3 mode: ${process.env.AQE_V3_MODE === "true" ? chalk29.green("yes") : chalk29.dim("no")}`);
@@ -140419,22 +141379,22 @@ function registerBackupCommand(learning) {
   learning.command("backup").description("Backup learning database to a file").option("-o, --output <path>", "Output file path").option("--compress", "Compress backup with gzip").option("--verify", "Verify backup integrity after creation").option("--json", "Output as JSON").action(async (options) => {
     try {
       const dbPath = getDbPath();
-      if (!existsSync46(dbPath)) throw new Error(`No learning database found at: ${dbPath}`);
+      if (!existsSync48(dbPath)) throw new Error(`No learning database found at: ${dbPath}`);
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const defaultOutput = path25.join(process.cwd(), "backups", `learning-${timestamp}.db`);
-      let outputPath = options.output ? path25.resolve(options.output) : defaultOutput;
-      const backupDir = path25.dirname(outputPath);
-      if (!existsSync46(backupDir)) mkdirSync19(backupDir, { recursive: true });
+      const defaultOutput = path26.join(process.cwd(), "backups", `learning-${timestamp}.db`);
+      let outputPath = options.output ? path26.resolve(options.output) : defaultOutput;
+      const backupDir = path26.dirname(outputPath);
+      if (!existsSync48(backupDir)) mkdirSync19(backupDir, { recursive: true });
       const sourceStats = await stat3(dbPath);
       const sourceSizeKB = (sourceStats.size / 1024).toFixed(2);
-      copyFileSync8(dbPath, outputPath);
+      copyFileSync9(dbPath, outputPath);
       const walPath = `${dbPath}-wal`;
-      if (existsSync46(walPath)) copyFileSync8(walPath, `${outputPath}-wal`);
+      if (existsSync48(walPath)) copyFileSync9(walPath, `${outputPath}-wal`);
       let finalPath = outputPath;
       if (options.compress) {
         finalPath = await compressFile(outputPath);
         await unlink(outputPath);
-        if (existsSync46(`${outputPath}-wal`)) await unlink(`${outputPath}-wal`);
+        if (existsSync48(`${outputPath}-wal`)) await unlink(`${outputPath}-wal`);
       }
       const finalStats = await stat3(finalPath);
       const finalSizeKB = (finalStats.size / 1024).toFixed(2);
@@ -140470,9 +141430,9 @@ function registerBackupCommand(learning) {
 function registerRestoreCommand(learning) {
   learning.command("restore").description("Restore learning database from backup").requiredOption("-i, --input <path>", "Backup file path to restore from").option("--verify", "Verify backup integrity before restore").option("--force", "Overwrite existing database without confirmation").option("--json", "Output as JSON").action(async (options) => {
     try {
-      const inputPath = path25.resolve(options.input);
+      const inputPath = path26.resolve(options.input);
       const dbPath = getDbPath();
-      if (!existsSync46(inputPath)) throw new Error(`Backup file not found: ${inputPath}`);
+      if (!existsSync48(inputPath)) throw new Error(`Backup file not found: ${inputPath}`);
       const isCompressed = inputPath.endsWith(".gz");
       let restorePath = inputPath;
       if (isCompressed) {
@@ -140483,23 +141443,23 @@ function registerRestoreCommand(learning) {
       if (options.verify) {
         const verificationResult = await verifyDatabaseIntegrity(restorePath);
         if (!verificationResult.valid) {
-          if (isCompressed && existsSync46(restorePath)) await unlink(restorePath);
+          if (isCompressed && existsSync48(restorePath)) await unlink(restorePath);
           throw new Error(`Backup verification failed: ${verificationResult.message}`);
         }
       }
-      if (existsSync46(dbPath) && !options.force) {
+      if (existsSync48(dbPath) && !options.force) {
         printError2(`Database already exists at: ${dbPath}`);
         console.log(chalk29.yellow("  Use --force to overwrite"));
-        if (isCompressed && existsSync46(restorePath)) await unlink(restorePath);
+        if (isCompressed && existsSync48(restorePath)) await unlink(restorePath);
         process.exit(1);
       }
-      const targetDir = path25.dirname(dbPath);
-      if (!existsSync46(targetDir)) mkdirSync19(targetDir, { recursive: true });
-      if (existsSync46(dbPath)) await unlink(dbPath);
-      if (existsSync46(`${dbPath}-wal`)) await unlink(`${dbPath}-wal`);
-      if (existsSync46(`${dbPath}-shm`)) await unlink(`${dbPath}-shm`);
-      copyFileSync8(restorePath, dbPath);
-      if (isCompressed && existsSync46(restorePath)) await unlink(restorePath);
+      const targetDir = path26.dirname(dbPath);
+      if (!existsSync48(targetDir)) mkdirSync19(targetDir, { recursive: true });
+      if (existsSync48(dbPath)) await unlink(dbPath);
+      if (existsSync48(`${dbPath}-wal`)) await unlink(`${dbPath}-wal`);
+      if (existsSync48(`${dbPath}-shm`)) await unlink(`${dbPath}-shm`);
+      copyFileSync9(restorePath, dbPath);
+      if (isCompressed && existsSync48(restorePath)) await unlink(restorePath);
       const restoredStats = await stat3(dbPath);
       const schemaVersion = await getSchemaVersion(dbPath);
       if (options.json) {
@@ -140522,8 +141482,8 @@ function registerRestoreCommand(learning) {
 function registerVerifyCommand(learning) {
   learning.command("verify").description("Verify learning database integrity").option("-f, --file <path>", "Database file to verify (defaults to current)").option("--json", "Output as JSON").action(async (options) => {
     try {
-      const dbPath = options.file ? path25.resolve(options.file) : getDbPath();
-      if (!existsSync46(dbPath)) throw new Error(`Database file not found: ${dbPath}`);
+      const dbPath = options.file ? path26.resolve(options.file) : getDbPath();
+      if (!existsSync48(dbPath)) throw new Error(`Database file not found: ${dbPath}`);
       const verificationResult = await verifyDatabaseIntegrity(dbPath);
       const schemaVersion = await getSchemaVersion(dbPath);
       const fileStats = await stat3(dbPath);
@@ -140565,7 +141525,7 @@ function registerExportFullCommand(learning) {
   learning.command("export-full").description("Export all learning data including patterns, trajectories, and experiences").option("-o, --output <file>", "Output file path", "aqe-learning-export.json").option("--compress", "Compress output with gzip").option("--include-trajectories", "Include learning trajectories").option("--include-experiences", "Include learning experiences").option("--json", "Output as JSON (to stdout)").action(async (options) => {
     try {
       const dbPath = getDbPath();
-      if (!existsSync46(dbPath)) throw new Error('No learning database found. Run "aqe init --auto" first.');
+      if (!existsSync48(dbPath)) throw new Error('No learning database found. Run "aqe init --auto" first.');
       const reasoningBank = await initializeLearningSystem2();
       const schemaVersion = await getSchemaVersion(dbPath);
       const searchResult = await reasoningBank.searchPatterns("*", { limit: 1e4 });
@@ -140617,7 +141577,7 @@ function registerExportFullCommand(learning) {
       if (options.json) {
         printJson2(exportData);
       } else {
-        let outputPath = path25.resolve(options.output);
+        let outputPath = path26.resolve(options.output);
         writeFileSync22(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
         if (options.compress) {
           const compressedPath = await compressFile(outputPath);
@@ -140643,8 +141603,8 @@ function registerExportFullCommand(learning) {
 function registerImportMergeCommand(learning) {
   learning.command("import-merge").description("Import and merge patterns from export file (preserves existing data)").requiredOption("-i, --input <file>", "Input file path").option("--skip-duplicates", "Skip patterns with matching names (default: update)").option("--dry-run", "Show what would be imported without making changes").option("--json", "Output as JSON").action(async (options) => {
     try {
-      let inputPath = path25.resolve(options.input);
-      if (!existsSync46(inputPath)) throw new Error(`File not found: ${inputPath}`);
+      let inputPath = path26.resolve(options.input);
+      if (!existsSync48(inputPath)) throw new Error(`File not found: ${inputPath}`);
       let content;
       if (inputPath.endsWith(".gz")) {
         const tempPath = inputPath.replace(".gz", ".tmp.json");
@@ -140927,7 +141887,7 @@ function registerDreamCommand(learning) {
 import { Command as Command17 } from "commander";
 import { spawn as spawn7 } from "child_process";
 import { join as join45, dirname as dirname14 } from "path";
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function createMcpCommand() {
   const cmd = new Command17("mcp").description("Start the MCP protocol server for Claude Code integration").option("--http <port>", "Also start HTTP server for AG-UI/A2A protocols", "0").option("--verbose", "Enable verbose logging").action(async (options) => {
@@ -140979,7 +141939,7 @@ function findMcpEntry() {
     join45(process.cwd(), "node_modules", "agentic-qe", "v3", "dist", "mcp", "entry.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync47(candidate)) {
+    if (existsSync49(candidate)) {
       return candidate;
     }
   }
@@ -141101,14 +142061,14 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command18();
-var VERSION = true ? "3.6.16" : "0.0.0-dev";
+var VERSION = true ? "3.6.18" : "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);
 var workflowCmd = program.command("workflow").description("Manage QE workflows and pipelines (ADR-041)");
 workflowCmd.command("run <file>").description("Execute a QE pipeline from YAML file").option("-w, --watch", "Watch execution progress").option("-v, --verbose", "Show detailed output").option("--params <json>", "Additional parameters as JSON", "{}").action(async (file, options) => {
   if (!await ensureInitialized()) return;
-  const fs23 = await import("fs");
+  const fs25 = await import("fs");
   const pathModule = await import("path");
   const filePath = pathModule.resolve(file);
   try {
@@ -141176,7 +142136,7 @@ workflowCmd.command("run <file>").description("Execute a QE pipeline from YAML f
         if (status.status === "completed" || status.status === "failed" || status.status === "cancelled") {
           break;
         }
-        await new Promise((resolve14) => setTimeout(resolve14, 500));
+        await new Promise((resolve15) => setTimeout(resolve15, 500));
       }
       const finalStatus = context.workflowOrchestrator.getWorkflowStatus(executionId);
       if (finalStatus) {
@@ -141348,14 +142308,14 @@ workflowCmd.command("list").description("List workflows").option("-s, --schedule
   }
 });
 workflowCmd.command("validate <file>").description("Validate a pipeline YAML file").option("-v, --verbose", "Show detailed validation results").action(async (file, options) => {
-  const fs23 = await import("fs");
+  const fs25 = await import("fs");
   const pathModule = await import("path");
   const filePath = pathModule.resolve(file);
   try {
     console.log(chalk30.blue(`
 Validating pipeline: ${file}
 `));
-    if (!fs23.existsSync(filePath)) {
+    if (!fs25.existsSync(filePath)) {
       console.log(chalk30.red(`File not found: ${filePath}`));
       await cleanupAndExit(1);
     }