agentic-qe 3.6.14 → 3.6.16

package/v3/dist/cli/bundle.js

@@ -14,7 +14,7 @@ var __require = /* @__PURE__ */ ((x67) => typeof require !== "undefined" ? requi
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require10() {
+var __commonJS = (cb, mod) => function __require9() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -1082,11 +1082,19 @@ function validateTableName(tableName) {
   return tableName;
 }
 function validateIdentifier(name) {
-  if (!IDENTIFIER_REGEX.test(name)) {
+  const parts = name.split(".");
+  if (parts.length > 2) {
     throw new Error(
-      `Invalid SQL identifier: "${name}" does not match pattern ${IDENTIFIER_REGEX}`
+      `Invalid SQL identifier: "${name}" has too many parts (max: schema.table)`
     );
   }
+  for (const part of parts) {
+    if (!IDENTIFIER_REGEX.test(part)) {
+      throw new Error(
+        `Invalid SQL identifier: "${name}" \u2014 part "${part}" does not match pattern ${IDENTIFIER_REGEX}`
+      );
+    }
+  }
   return name;
 }
 var ALLOWED_TABLE_NAMES, IDENTIFIER_REGEX;
@@ -16856,63 +16864,6 @@ var init_hnswlib_node = __esm({
   }
 });
 
-// native-require:pg
-var pg_exports = {};
-__export(pg_exports, {
-  DotProductAttention: () => DotProductAttention7,
-  FlashAttention: () => FlashAttention7,
-  HyperbolicAttention: () => HyperbolicAttention7,
-  LinearAttention: () => LinearAttention7,
-  MoEAttention: () => MoEAttention7,
-  MultiHeadAttention: () => MultiHeadAttention7,
-  RuvectorLayer: () => RuvectorLayer7,
-  SonaEngine: () => SonaEngine7,
-  TensorCompress: () => TensorCompress7,
-  default: () => pg_default,
-  differentiableSearch: () => differentiableSearch7,
-  getCompressionLevel: () => getCompressionLevel7,
-  hierarchicalForward: () => hierarchicalForward7,
-  init: () => init7,
-  pipeline: () => pipeline8
-});
-import { createRequire as createRequire7 } from "module";
-var __require8, __mod7, pg_default, RuvectorLayer7, TensorCompress7, differentiableSearch7, hierarchicalForward7, getCompressionLevel7, init7, FlashAttention7, DotProductAttention7, MultiHeadAttention7, HyperbolicAttention7, LinearAttention7, MoEAttention7, SonaEngine7, pipeline8;
-var init_pg = __esm({
-  "native-require:pg"() {
-    __require8 = createRequire7(import.meta.url);
-    __mod7 = __require8("pg");
-    pg_default = __mod7;
-    ({
-      RuvectorLayer: (
-        // @ruvector/gnn
-        RuvectorLayer7
-      ),
-      TensorCompress: TensorCompress7,
-      differentiableSearch: differentiableSearch7,
-      hierarchicalForward: hierarchicalForward7,
-      getCompressionLevel: getCompressionLevel7,
-      init: init7,
-      FlashAttention: (
-        // @ruvector/attention
-        FlashAttention7
-      ),
-      DotProductAttention: DotProductAttention7,
-      MultiHeadAttention: MultiHeadAttention7,
-      HyperbolicAttention: HyperbolicAttention7,
-      LinearAttention: LinearAttention7,
-      MoEAttention: MoEAttention7,
-      SonaEngine: (
-        // @ruvector/sona
-        SonaEngine7
-      ),
-      pipeline: (
-        // @xenova/transformers
-        pipeline8
-      )
-    } = __mod7 || {});
-  }
-});
-
 // src/learning/qe-reasoning-bank.ts
 var qe_reasoning_bank_exports = {};
 __export(qe_reasoning_bank_exports, {
@@ -18314,57 +18265,57 @@ On promotion:
 // native-require:prime-radiant-advanced-wasm
 var prime_radiant_advanced_wasm_exports = {};
 __export(prime_radiant_advanced_wasm_exports, {
-  DotProductAttention: () => DotProductAttention8,
-  FlashAttention: () => FlashAttention8,
-  HyperbolicAttention: () => HyperbolicAttention8,
-  LinearAttention: () => LinearAttention8,
-  MoEAttention: () => MoEAttention8,
-  MultiHeadAttention: () => MultiHeadAttention8,
-  RuvectorLayer: () => RuvectorLayer8,
-  SonaEngine: () => SonaEngine8,
-  TensorCompress: () => TensorCompress8,
+  DotProductAttention: () => DotProductAttention7,
+  FlashAttention: () => FlashAttention7,
+  HyperbolicAttention: () => HyperbolicAttention7,
+  LinearAttention: () => LinearAttention7,
+  MoEAttention: () => MoEAttention7,
+  MultiHeadAttention: () => MultiHeadAttention7,
+  RuvectorLayer: () => RuvectorLayer7,
+  SonaEngine: () => SonaEngine7,
+  TensorCompress: () => TensorCompress7,
   default: () => prime_radiant_advanced_wasm_default,
-  differentiableSearch: () => differentiableSearch8,
-  getCompressionLevel: () => getCompressionLevel8,
-  hierarchicalForward: () => hierarchicalForward8,
-  init: () => init8,
-  pipeline: () => pipeline9
+  differentiableSearch: () => differentiableSearch7,
+  getCompressionLevel: () => getCompressionLevel7,
+  hierarchicalForward: () => hierarchicalForward7,
+  init: () => init7,
+  pipeline: () => pipeline8
 });
 import { createRequire as createRequire8 } from "module";
-var __require9, __mod8, prime_radiant_advanced_wasm_default, RuvectorLayer8, TensorCompress8, differentiableSearch8, hierarchicalForward8, getCompressionLevel8, init8, FlashAttention8, DotProductAttention8, MultiHeadAttention8, HyperbolicAttention8, LinearAttention8, MoEAttention8, SonaEngine8, pipeline9;
+var __require8, __mod7, prime_radiant_advanced_wasm_default, RuvectorLayer7, TensorCompress7, differentiableSearch7, hierarchicalForward7, getCompressionLevel7, init7, FlashAttention7, DotProductAttention7, MultiHeadAttention7, HyperbolicAttention7, LinearAttention7, MoEAttention7, SonaEngine7, pipeline8;
 var init_prime_radiant_advanced_wasm = __esm({
   "native-require:prime-radiant-advanced-wasm"() {
-    __require9 = createRequire8(import.meta.url);
-    __mod8 = __require9("prime-radiant-advanced-wasm");
-    prime_radiant_advanced_wasm_default = __mod8;
+    __require8 = createRequire8(import.meta.url);
+    __mod7 = __require8("prime-radiant-advanced-wasm");
+    prime_radiant_advanced_wasm_default = __mod7;
     ({
       RuvectorLayer: (
         // @ruvector/gnn
-        RuvectorLayer8
+        RuvectorLayer7
       ),
-      TensorCompress: TensorCompress8,
-      differentiableSearch: differentiableSearch8,
-      hierarchicalForward: hierarchicalForward8,
-      getCompressionLevel: getCompressionLevel8,
-      init: init8,
+      TensorCompress: TensorCompress7,
+      differentiableSearch: differentiableSearch7,
+      hierarchicalForward: hierarchicalForward7,
+      getCompressionLevel: getCompressionLevel7,
+      init: init7,
       FlashAttention: (
         // @ruvector/attention
-        FlashAttention8
+        FlashAttention7
       ),
-      DotProductAttention: DotProductAttention8,
-      MultiHeadAttention: MultiHeadAttention8,
-      HyperbolicAttention: HyperbolicAttention8,
-      LinearAttention: LinearAttention8,
-      MoEAttention: MoEAttention8,
+      DotProductAttention: DotProductAttention7,
+      MultiHeadAttention: MultiHeadAttention7,
+      HyperbolicAttention: HyperbolicAttention7,
+      LinearAttention: LinearAttention7,
+      MoEAttention: MoEAttention7,
       SonaEngine: (
         // @ruvector/sona
-        SonaEngine8
+        SonaEngine7
       ),
       pipeline: (
         // @xenova/transformers
-        pipeline9
+        pipeline8
       )
-    } = __mod8 || {});
+    } = __mod7 || {});
   }
 });
 
@@ -25357,7 +25308,7 @@ var BaseTestGenerator = class _BaseTestGenerator {
     for (const [typeKey, generator] of _BaseTestGenerator.TYPE_VALUE_TABLE) {
       if (type.includes(typeKey)) return generator();
     }
-    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
+    return `{} /* TODO: provide ${param.name}: ${param.type || "unknown"} */`;
   }
   /**
    * Generate test cases for a function based on its signature
@@ -25370,21 +25321,62 @@ var BaseTestGenerator = class _BaseTestGenerator {
     const testCases = [];
     const validParams = fn.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>";
+    let assertion = "expect(result).toBeDefined();";
+    if (!isVoid) {
+      if (/^(is|has|can)[A-Z]/.test(fn.name)) {
+        assertion = "expect(typeof result).toBe('boolean');";
+      } else if (/^(get|fetch|find)[A-Z]/.test(fn.name)) {
+        assertion = "expect(result).not.toBeUndefined();";
+      } else if (/^(create|build|make)[A-Z]/.test(fn.name)) {
+        assertion = "expect(result).toBeTruthy();";
+      } else if (fn.returnType) {
+        const rt3 = fn.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (rt3.includes("boolean")) assertion = "expect(typeof result).toBe('boolean');";
+        else if (rt3.includes("number")) assertion = "expect(typeof result).toBe('number');";
+        else if (rt3.includes("string")) assertion = "expect(typeof result).toBe('string');";
+        else if (rt3.includes("[]") || rt3.includes("array")) assertion = "expect(Array.isArray(result)).toBe(true);";
+      }
+    }
     testCases.push({
       description: "should handle valid input correctly",
       type: "happy-path",
-      action: `const result = ${fnCall};`,
-      assertion: "expect(result).toBeDefined();"
+      action: isVoid ? `${fnCall};` : `const result = ${fnCall};`,
+      assertion: isVoid ? `// void function \u2014 no return value to assert` : assertion
     });
+    const bodyText = fn.body || "";
+    const hasExplicitThrow = /\bthrow\b/.test(bodyText) || /\bvalidat/i.test(bodyText);
     for (const param of fn.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = fn.parameters.map((p74) => p74.name === param.name ? "undefined" : this.generateTestValue(p74)).join(", ");
-        testCases.push({
-          description: `should handle undefined ${param.name}`,
-          type: "error-handling",
-          action: fn.isAsync ? `const action = async () => await ${fn.name}(${paramsWithUndefined});` : `const action = () => ${fn.name}(${paramsWithUndefined});`,
-          assertion: "expect(action).toThrow();"
-        });
+        if (hasExplicitThrow) {
+          testCases.push({
+            description: `should handle undefined ${param.name}`,
+            type: "error-handling",
+            action: fn.isAsync ? `const action = async () => await ${fn.name}(${paramsWithUndefined});` : `const action = () => ${fn.name}(${paramsWithUndefined});`,
+            assertion: "expect(action).toThrow();"
+          });
+        } else {
+          const undefinedCall = fn.isAsync ? `await ${fn.name}(${paramsWithUndefined})` : `${fn.name}(${paramsWithUndefined})`;
+          testCases.push({
+            description: `should handle undefined ${param.name}`,
+            type: "edge-case",
+            action: fn.isAsync ? `let threw = false;
+    try {
+      await ${fn.name}(${paramsWithUndefined});
+    } catch (e) {
+      threw = true;
+      expect(e).toBeInstanceOf(Error);
+    }` : `let threw = false;
+    try {
+      ${fn.name}(${paramsWithUndefined});
+    } catch (e) {
+      threw = true;
+      expect(e).toBeInstanceOf(Error);
+    }`,
+            assertion: `expect(true).toBe(true); // function either handles undefined or throws TypeError`
+          });
+        }
       }
       testCases.push(...this.generateBoundaryTestCases(fn, param));
     }
@@ -25404,32 +25396,48 @@ var BaseTestGenerator = class _BaseTestGenerator {
   generateBoundaryTestCases(fn, param) {
     const testCases = [];
     const type = param.type?.toLowerCase() || "";
+    const wrapBoundaryAction = (call, isAsync) => {
+      if (isAsync) {
+        return `try {
+      const result = await ${call};
+      expect(result).toBeDefined();
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }`;
+      }
+      return `try {
+      const result = ${call};
+      expect(result).toBeDefined();
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }`;
+    };
     if (type.includes("string")) {
       const paramsWithEmpty = fn.parameters.map((p74) => p74.name === param.name ? "''" : this.generateTestValue(p74)).join(", ");
-      const emptyCall = fn.isAsync ? `await ${fn.name}(${paramsWithEmpty})` : `${fn.name}(${paramsWithEmpty})`;
+      const emptyCall = `${fn.name}(${paramsWithEmpty})`;
       testCases.push({
         description: `should handle empty string for ${param.name}`,
         type: "boundary",
-        action: `const result = ${emptyCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(emptyCall, fn.isAsync),
+        assertion: ""
       });
     }
     if (type.includes("number")) {
       const paramsWithZero = fn.parameters.map((p74) => p74.name === param.name ? "0" : this.generateTestValue(p74)).join(", ");
-      const zeroCall = fn.isAsync ? `await ${fn.name}(${paramsWithZero})` : `${fn.name}(${paramsWithZero})`;
+      const zeroCall = `${fn.name}(${paramsWithZero})`;
       testCases.push({
         description: `should handle zero for ${param.name}`,
         type: "boundary",
-        action: `const result = ${zeroCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(zeroCall, fn.isAsync),
+        assertion: ""
       });
       const paramsWithNegative = fn.parameters.map((p74) => p74.name === param.name ? "-1" : this.generateTestValue(p74)).join(", ");
-      const negativeCall = fn.isAsync ? `await ${fn.name}(${paramsWithNegative})` : `${fn.name}(${paramsWithNegative})`;
+      const negativeCall = `${fn.name}(${paramsWithNegative})`;
       testCases.push({
         description: `should handle negative value for ${param.name}`,
         type: "edge-case",
-        action: `const result = ${negativeCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(negativeCall, fn.isAsync),
+        assertion: ""
       });
     }
     if (type.includes("[]") || type.includes("array")) {
@@ -25527,24 +25535,31 @@ ${importStatement}
 `;
     if (dependencies && dependencies.imports.length > 0) {
       const mockFn = this.framework === "vitest" ? "vi.fn()" : "jest.fn()";
-      testCode += `
+      const externalDeps = dependencies.imports.filter((dep) => !dep.startsWith("."));
+      if (externalDeps.length > 0) {
+        testCode += `
 // Auto-generated mocks from Knowledge Graph dependency analysis
 `;
-      for (const dep of dependencies.imports.slice(0, 10)) {
-        const depName = dep.split("/").pop()?.replace(/[^a-zA-Z0-9_]/g, "_") || dep;
-        testCode += `${this.framework === "vitest" ? "vi" : "jest"}.mock('${dep}', () => ({ default: ${mockFn} }));
+        for (const dep of externalDeps.slice(0, 10)) {
+          testCode += `${this.framework === "vitest" ? "vi" : "jest"}.mock('${dep}', () => ({ default: ${mockFn} }));
 `;
-      }
-      testCode += `
+        }
+        testCode += `
+`;
+      } else {
+        testCode += `
 `;
+      }
     } else {
       testCode += `
 `;
     }
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       testCode += this.generateFunctionTests(fn, testType);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       testCode += this.generateClassTests(cls, testType);
     }
     return testCode;
@@ -25631,24 +25646,68 @@ ${importStatement}
     const validParams = method.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const methodCall = method.isAsync ? `await instance.${method.name}(${validParams})` : `instance.${method.name}(${validParams})`;
     const asyncPrefix = method.isAsync ? "async " : "";
+    const isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+    let methodAssertion = "expect(result).toBeDefined();";
+    if (!isVoid) {
+      if (/^(is|has|can)[A-Z]/.test(method.name)) {
+        methodAssertion = "expect(typeof result).toBe('boolean');";
+      } else if (/^(get|fetch|find)[A-Z]/.test(method.name)) {
+        methodAssertion = "expect(result).not.toBeUndefined();";
+      } else if (/^(create|build|make)[A-Z]/.test(method.name)) {
+        methodAssertion = "expect(result).toBeTruthy();";
+      } else if (method.returnType) {
+        const mrt = method.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (mrt.includes("boolean")) methodAssertion = "expect(typeof result).toBe('boolean');";
+        else if (mrt.includes("number")) methodAssertion = "expect(typeof result).toBe('number');";
+        else if (mrt.includes("string")) methodAssertion = "expect(typeof result).toBe('string');";
+        else if (mrt.includes("[]") || mrt.includes("array")) methodAssertion = "expect(Array.isArray(result)).toBe(true);";
+      }
+    }
     code += `    it('should execute successfully', ${asyncPrefix}() => {
 `;
-    code += `      const result = ${methodCall};
+    if (isVoid) {
+      code += `      ${methodCall};
 `;
-    code += `      expect(result).toBeDefined();
+      code += `      // void return \u2014 no assertion on result needed
 `;
+    } else {
+      code += `      const result = ${methodCall};
+`;
+      code += `      ${methodAssertion}
+`;
+    }
     code += `    });
 `;
+    const methodBody = method.body || "";
+    const methodThrows = /\bthrow\b/.test(methodBody) || /\bvalidat/i.test(methodBody);
     for (const param of method.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = method.parameters.map((p74) => p74.name === param.name ? "undefined as any" : this.generateTestValue(p74)).join(", ");
-        code += `
-    it('should handle invalid ${param.name}', () => {
+        if (methodThrows) {
+          code += `
+    it('should handle invalid ${param.name}', ${asyncPrefix}() => {
 `;
-        code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();
+          code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();
 `;
-        code += `    });
+          code += `    });
 `;
+        } else {
+          code += `
+    it('should handle undefined ${param.name}', ${asyncPrefix}() => {
+`;
+          code += `      try {
+`;
+          code += `        ${method.isAsync ? "await " : ""}instance.${method.name}(${paramsWithUndefined});
+`;
+          code += `      } catch (e) {
+`;
+          code += `        expect(e).toBeInstanceOf(Error);
+`;
+          code += `      }
+`;
+          code += `    });
+`;
+        }
       }
     }
     code += `  });
@@ -25668,12 +25727,15 @@ ${importStatement}
     let mockDeclarations = "";
     if (dependencies && dependencies.imports.length > 0) {
       const mockFn = this.framework === "vitest" ? "vi.fn()" : "jest.fn()";
-      mockDeclarations += `
+      const externalDeps = dependencies.imports.filter((dep) => !dep.startsWith("."));
+      if (externalDeps.length > 0) {
+        mockDeclarations += `
 // Auto-generated mocks from Knowledge Graph dependency analysis
 `;
-      for (const dep of dependencies.imports.slice(0, 10)) {
-        mockDeclarations += `${this.mockUtil}.mock('${dep}', () => ({ default: ${mockFn} }));
+        for (const dep of externalDeps.slice(0, 10)) {
+          mockDeclarations += `${this.mockUtil}.mock('${dep}', () => ({ default: ${mockFn} }));
 `;
+        }
       }
     }
     let similarityComment = "";
@@ -25950,10 +26012,11 @@ var MochaGenerator = class extends BaseTestGenerator {
     const importStatement = this.generateImportStatement(exports, importPath, moduleName);
     let sinonImport = "";
     let stubSetup = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const externalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (externalDeps.length > 0) {
       sinonImport = `import sinon from 'sinon';
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
+      const depsToMock = externalDeps.slice(0, 5);
       stubSetup += `  // Auto-generated stubs from Knowledge Graph dependency analysis
 `;
       stubSetup += `  let stubs;
@@ -25986,10 +26049,12 @@ ${sinonImport}${importStatement}
 
 describe('${moduleName} - ${testType} tests', function() {
 ${stubSetup}`;
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       code += this.generateFunctionTests(fn, testType);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       code += this.generateClassTests(cls, testType);
     }
     code += `});
@@ -26002,26 +26067,68 @@ ${stubSetup}`;
   generateFunctionTests(fn, _testType) {
     const validParams = fn.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>";
     let code = `  describe('${fn.name}', function() {
 `;
+    let chaiAssertion = "expect(result).to.not.be.undefined;";
+    if (!isVoid) {
+      if (/^(is|has|can)[A-Z]/.test(fn.name)) {
+        chaiAssertion = "expect(typeof result).to.equal('boolean');";
+      } else if (/^(get|fetch|find)[A-Z]/.test(fn.name)) {
+        chaiAssertion = "expect(result).to.not.be.undefined;";
+      } else if (/^(create|build|make)[A-Z]/.test(fn.name)) {
+        chaiAssertion = "expect(result).to.be.ok;";
+      } else if (fn.returnType) {
+        const rt3 = fn.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (rt3.includes("boolean")) chaiAssertion = "expect(typeof result).to.equal('boolean');";
+        else if (rt3.includes("number")) chaiAssertion = "expect(typeof result).to.equal('number');";
+        else if (rt3.includes("string")) chaiAssertion = "expect(typeof result).to.equal('string');";
+        else if (rt3.includes("[]") || rt3.includes("array")) chaiAssertion = "expect(result).to.be.an('array');";
+      }
+    }
     code += `    it('should handle valid input', ${fn.isAsync ? "async " : ""}function() {
 `;
-    code += `      const result = ${fnCall};
+    if (isVoid) {
+      code += `      ${fnCall};
+`;
+    } else {
+      code += `      const result = ${fnCall};
 `;
-    code += `      expect(result).to.not.be.undefined;
+      code += `      ${chaiAssertion}
 `;
+    }
     code += `    });
 `;
+    const bodyText = fn.body || "";
+    const hasExplicitThrow = /\bthrow\b/.test(bodyText) || /\bvalidat/i.test(bodyText);
     for (const param of fn.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = fn.parameters.map((p74) => p74.name === param.name ? "undefined" : this.generateTestValue(p74)).join(", ");
-        code += `
+        if (hasExplicitThrow) {
+          code += `
     it('should handle undefined ${param.name}', function() {
 `;
-        code += `      expect(function() { ${fn.name}(${paramsWithUndefined}); }).to.throw();
+          code += `      expect(function() { ${fn.name}(${paramsWithUndefined}); }).to.throw();
 `;
-        code += `    });
+          code += `    });
+`;
+        } else {
+          code += `
+    it('should handle undefined ${param.name}', function() {
+`;
+          code += `      try {
+`;
+          code += `        ${fn.name}(${paramsWithUndefined});
+`;
+          code += `      } catch (e) {
+`;
+          code += `        expect(e).to.be.instanceOf(Error);
 `;
+          code += `      }
+`;
+          code += `    });
+`;
+        }
       }
     }
     code += `  });
@@ -26053,15 +26160,35 @@ ${stubSetup}`;
     code += `    });
 `;
     for (const method of cls.methods) {
-      if (!method.name.startsWith("_")) {
+      if (!method.name.startsWith("_") && !method.name.startsWith("#")) {
         const methodParams = method.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
+        const isMethodVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+        let methodAssertion = "expect(result).to.not.be.undefined;";
+        if (!isMethodVoid) {
+          if (/^(is|has|can)[A-Z]/.test(method.name)) {
+            methodAssertion = "expect(typeof result).to.equal('boolean');";
+          } else if (/^(create|build|make)[A-Z]/.test(method.name)) {
+            methodAssertion = "expect(result).to.be.ok;";
+          } else if (method.returnType) {
+            const mrt = method.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+            if (mrt.includes("boolean")) methodAssertion = "expect(typeof result).to.equal('boolean');";
+            else if (mrt.includes("number")) methodAssertion = "expect(typeof result).to.equal('number');";
+            else if (mrt.includes("string")) methodAssertion = "expect(typeof result).to.equal('string');";
+            else if (mrt.includes("[]") || mrt.includes("array")) methodAssertion = "expect(result).to.be.an('array');";
+          }
+        }
         code += `
     it('${method.name} should work', ${method.isAsync ? "async " : ""}function() {
 `;
-        code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
+        if (isMethodVoid) {
+          code += `      ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
 `;
-        code += `      expect(result).to.not.be.undefined;
+        } else {
+          code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
+`;
+          code += `      ${methodAssertion}
 `;
+        }
         code += `    });
 `;
       }
@@ -26084,10 +26211,11 @@ ${stubSetup}`;
     let sinonImport = "";
     let stubSetup = "";
     let stubTeardown = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const stubExternalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (stubExternalDeps.length > 0) {
       sinonImport = `import sinon from 'sinon';
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
+      const depsToMock = stubExternalDeps.slice(0, 5);
       stubSetup += `
     // Auto-generated stubs from Knowledge Graph dependency analysis
 `;
@@ -26258,12 +26386,13 @@ var PytestGenerator = class extends BaseTestGenerator {
     const exports = this.extractExports(analysis.functions, analysis.classes);
     const pythonImport = importPath.replace(/\//g, ".").replace(/\.(ts|js)$/, "");
     const importStatement = exports.length > 0 ? `from ${pythonImport} import ${exports.join(", ")}` : `import ${pythonImport} as ${moduleName}`;
+    const externalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
     let mockImport = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    if (externalDeps.length > 0) {
       mockImport = `from unittest.mock import patch, MagicMock
 `;
     }
-    const depsToMock = dependencies?.imports.slice(0, 5) || [];
+    const depsToMock = externalDeps.slice(0, 5);
     const patchDecorators = depsToMock.map((dep) => {
       const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
       return `@patch('${depModule}')`;
@@ -26276,10 +26405,12 @@ class Test${this.pascalCase(moduleName)}:
     """${testType} tests for ${moduleName}"""
 
 `;
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       code += this.generateFunctionTestsWithPatches(fn, testType, patchDecorators);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       code += this.generateClassTests(cls, testType);
     }
     return code;
@@ -26299,15 +26430,36 @@ class Test${this.pascalCase(moduleName)}:
     const allParams = mockParams ? `self, ${mockParams}` : "self";
     const patchPrefix = patchDecorators.map((d74) => `    ${d74}
 `).join("");
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>" || fn.returnType === "None";
     let code = `${patchPrefix}    def test_${fn.name}_valid_input(${allParams}):
 `;
     code += `        """Test ${fn.name} with valid input"""
 `;
-    code += `        result = ${fn.name}(${validParams})
+    let pyAssertion = "assert result is not None";
+    if (!isVoid) {
+      if (/^(is|has|can)[A-Z]/.test(fn.name)) {
+        pyAssertion = "assert isinstance(result, bool)";
+      } else if (/^(create|build|make)[A-Z]/.test(fn.name)) {
+        pyAssertion = "assert result";
+      } else if (fn.returnType) {
+        const rt3 = fn.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (rt3.includes("boolean") || rt3.includes("bool")) pyAssertion = "assert isinstance(result, bool)";
+        else if (rt3.includes("number") || rt3.includes("int") || rt3.includes("float")) pyAssertion = "assert isinstance(result, (int, float))";
+        else if (rt3.includes("string") || rt3.includes("str")) pyAssertion = "assert isinstance(result, str)";
+        else if (rt3.includes("[]") || rt3.includes("array") || rt3.includes("list")) pyAssertion = "assert isinstance(result, list)";
+      }
+    }
+    if (isVoid) {
+      code += `        ${fn.name}(${validParams})  # void function
+
+`;
+    } else {
+      code += `        result = ${fn.name}(${validParams})
 `;
-    code += `        assert result is not None
+      code += `        ${pyAssertion}
 
 `;
+    }
     for (const param of fn.parameters) {
       if (!param.optional && param.type?.includes("str")) {
         code += `${patchPrefix}    def test_${fn.name}_empty_${param.name}(${allParams}):
@@ -26348,15 +26500,36 @@ class Test${cls.name}:
 
 `;
     for (const method of cls.methods) {
-      if (!method.name.startsWith("_")) {
+      if (!method.name.startsWith("_") && !method.name.startsWith("#")) {
         const methodParams = method.parameters.map((p74) => this.generatePythonTestValue(p74)).join(", ");
+        const isMethodVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+        let mAssertion = "assert result is not None";
+        if (!isMethodVoid) {
+          if (/^(is|has|can)[A-Z]/.test(method.name)) {
+            mAssertion = "assert isinstance(result, bool)";
+          } else if (/^(create|build|make)[A-Z]/.test(method.name)) {
+            mAssertion = "assert result";
+          } else if (method.returnType) {
+            const mrt = method.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+            if (mrt.includes("boolean") || mrt.includes("bool")) mAssertion = "assert isinstance(result, bool)";
+            else if (mrt.includes("number") || mrt.includes("int") || mrt.includes("float")) mAssertion = "assert isinstance(result, (int, float))";
+            else if (mrt.includes("string") || mrt.includes("str")) mAssertion = "assert isinstance(result, str)";
+            else if (mrt.includes("[]") || mrt.includes("array") || mrt.includes("list")) mAssertion = "assert isinstance(result, list)";
+          }
+        }
         code += `    def test_${method.name}(self, instance):
 `;
-        code += `        result = instance.${method.name}(${methodParams})
+        if (isMethodVoid) {
+          code += `        instance.${method.name}(${methodParams})
+
 `;
-        code += `        assert result is not None
+        } else {
+          code += `        result = instance.${method.name}(${methodParams})
+`;
+          code += `        ${mAssertion}
 
 `;
+        }
       }
     }
     return code;
@@ -26374,11 +26547,11 @@ class Test${cls.name}:
     const asyncDef = isAsync ? "async def" : "def";
     let mockImports = "";
     let mockPatches = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const stubExternalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (stubExternalDeps.length > 0) {
       mockImports = `from unittest.mock import patch, MagicMock
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
-      for (const dep of depsToMock) {
+      for (const dep of stubExternalDeps.slice(0, 5)) {
         const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
         mockPatches += `    @patch('${depModule}')
 `;
@@ -26541,12 +26714,214 @@ class Test${this.pascalCase(moduleName)}Coverage:
   }
 };
 
+// src/domains/test-generation/generators/node-test-generator.ts
+var NodeTestGenerator = class extends BaseTestGenerator {
+  framework = "node-test";
+  /**
+   * Generate complete test file from analysis
+   */
+  generateTests(context2) {
+    const { moduleName, importPath, testType, patterns, analysis } = context2;
+    if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
+      return this.generateStubTests(context2);
+    }
+    const patternComment = this.generatePatternComment(patterns);
+    const exportedFunctions = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    const exports = this.extractExports(exportedFunctions, exportedClasses);
+    const importStatement = this.generateImportStatement(exports, importPath, moduleName);
+    let testCode = `${patternComment}import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
+${importStatement}
+
+`;
+    for (const fn of exportedFunctions) {
+      testCode += this.generateFunctionTests(fn, testType);
+    }
+    for (const cls of exportedClasses) {
+      testCode += this.generateClassTests(cls, testType);
+    }
+    return testCode;
+  }
+  /**
+   * Generate tests for a standalone function
+   */
+  generateFunctionTests(fn, _testType) {
+    const testCases = this.generateTestCasesForFunction(fn);
+    let code = `describe('${fn.name}', () => {
+`;
+    for (const testCase of testCases) {
+      if (testCase.setup) {
+        code += `  ${testCase.setup}
+
+`;
+      }
+      const asyncPrefix = fn.isAsync ? "async " : "";
+      code += `  it('${testCase.description}', ${asyncPrefix}() => {
+`;
+      code += `    ${this.convertToAssert(testCase.action)}
+`;
+      code += `    ${this.convertToAssert(testCase.assertion)}
+`;
+      code += `  });
+
+`;
+    }
+    code += `});
+
+`;
+    return code;
+  }
+  /**
+   * Generate tests for a class
+   */
+  generateClassTests(cls, testType) {
+    let code = `describe('${cls.name}', () => {
+`;
+    code += `  let instance;
+
+`;
+    const constructorArgs = cls.constructorParams?.map((p74) => this.generateTestValue(p74)).join(", ") || "";
+    code += `  beforeEach(() => {
+`;
+    code += `    instance = new ${cls.name}(${constructorArgs});
+`;
+    code += `  });
+
+`;
+    code += `  it('should instantiate correctly', () => {
+`;
+    code += `    assert.ok(instance instanceof ${cls.name});
+`;
+    code += `  });
+
+`;
+    for (const method of cls.methods) {
+      if (!method.name.startsWith("_") && !method.name.startsWith("#")) {
+        code += this.generateMethodTest(method);
+      }
+    }
+    code += `});
+
+`;
+    return code;
+  }
+  /**
+   * Generate test for a class method
+   */
+  generateMethodTest(method) {
+    const validParams = method.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
+    const isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+    const asyncPrefix = method.isAsync ? "async " : "";
+    const methodCall = method.isAsync ? `await instance.${method.name}(${validParams})` : `instance.${method.name}(${validParams})`;
+    let assertLine = "assert.ok(result !== undefined);";
+    if (!isVoid) {
+      const mLower = method.name.toLowerCase();
+      if (/^(is|has|can)[A-Z]/.test(method.name)) {
+        assertLine = "assert.strictEqual(typeof result, 'boolean');";
+      } else if (/^(get|fetch|find)[A-Z]/.test(method.name)) {
+        assertLine = "assert.ok(result !== undefined);";
+      } else if (/^(create|build|make)[A-Z]/.test(method.name)) {
+        assertLine = "assert.ok(result);";
+      } else if (method.returnType) {
+        const rt3 = method.returnType.toLowerCase().replace(/promise<(.+)>/, "$1");
+        if (rt3.includes("boolean")) assertLine = "assert.strictEqual(typeof result, 'boolean');";
+        else if (rt3.includes("number")) assertLine = "assert.strictEqual(typeof result, 'number');";
+        else if (rt3.includes("string")) assertLine = "assert.strictEqual(typeof result, 'string');";
+        else if (rt3.includes("[]") || rt3.includes("array")) assertLine = "assert.ok(Array.isArray(result));";
+      }
+    }
+    let code = `  it('${method.name} should execute successfully', ${asyncPrefix}() => {
+`;
+    if (isVoid) {
+      code += `    ${methodCall};
+`;
+    } else {
+      code += `    const result = ${methodCall};
+`;
+      code += `    ${assertLine}
+`;
+    }
+    code += `  });
+
+`;
+    return code;
+  }
+  /**
+   * Generate stub tests when no AST analysis is available
+   */
+  generateStubTests(context2) {
+    const { moduleName, importPath, testType, patterns } = context2;
+    const patternComment = this.generatePatternComment(patterns);
+    return `${patternComment}import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { ${moduleName} } from '${importPath}';
+
+describe('${moduleName}', () => {
+  describe('${testType} tests', () => {
+    it('should be defined', () => {
+      assert.ok(${moduleName} !== undefined);
+    });
+
+    it('should handle basic operations', () => {
+      const moduleType = typeof ${moduleName};
+      assert.ok(['function', 'object'].includes(moduleType));
+    });
+
+    it('should handle error conditions', () => {
+      assert.doesNotThrow(() => {
+        const instance = typeof ${moduleName} === 'function'
+          ? new ${moduleName}()
+          : ${moduleName};
+        return instance;
+      });
+    });
+  });
+});
+`;
+  }
+  /**
+   * Generate coverage-focused tests for specific lines
+   */
+  generateCoverageTests(moduleName, importPath, lines) {
+    const funcName = this.camelCase(moduleName);
+    const lineRange = this.formatLineRange(lines);
+    return `// Coverage test for ${lineRange} in ${moduleName}
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { ${funcName} } from '${importPath}';
+
+describe('${moduleName} coverage', () => {
+  it('should exercise code path covering ${lineRange}', () => {
+    const testInput = undefined; // Replace with appropriate input
+    const result = ${funcName}(testInput);
+    assert.ok(result !== undefined || result === undefined);
+  });
+
+  it('should handle edge case for ${lineRange}', () => {
+    assert.doesNotThrow(() => ${funcName}(null));
+  });
+});
+`;
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  /**
+   * Convert expect() style assertions to node:assert
+   */
+  convertToAssert(assertion) {
+    return assertion.replace(/expect\(typeof ([^)]+)\)\.toBe\('([^']+)'\);?/g, "assert.strictEqual(typeof $1, '$2');").replace(/expect\(Array\.isArray\(([^)]+)\)\)\.toBe\(true\);?/g, "assert.ok(Array.isArray($1));").replace(/expect\(([^)]+)\)\.toThrow\(\);?/g, "assert.throws($1);").replace(/expect\(([^)]+)\)\.not\.toThrow\(\);?/g, "assert.doesNotThrow($1);").replace(/expect\(([^)]+)\)\.toBeInstanceOf\(([^)]+)\);?/g, "assert.ok($1 instanceof $2);").replace(/expect\(([^)]+)\)\.toBeDefined\(\);?/g, "assert.ok($1 !== undefined);").replace(/expect\(([^)]+)\)\.not\.toBeUndefined\(\);?/g, "assert.ok($1 !== undefined);").replace(/expect\(([^)]+)\)\.toBeUndefined\(\);?/g, "assert.strictEqual($1, undefined);").replace(/expect\(([^)]+)\)\.toBeTruthy\(\);?/g, "assert.ok($1);").replace(/expect\(([^)]+)\)\.toBeFalsy\(\);?/g, "assert.ok(!$1);").replace(/expect\(([^)]+)\)\.toBe\(([^)]+)\);?/g, "assert.strictEqual($1, $2);").replace(/expect\(([^)]+)\)\.toEqual\(([^)]+)\);?/g, "assert.deepStrictEqual($1, $2);");
+  }
+};
+
 // src/domains/test-generation/factories/test-generator-factory.ts
 var SUPPORTED_FRAMEWORKS = [
   "jest",
   "vitest",
   "mocha",
-  "pytest"
+  "pytest",
+  "node-test"
 ];
 var DEFAULT_FRAMEWORK = "vitest";
 var TestGeneratorFactory = class {
@@ -26608,6 +26983,8 @@ var TestGeneratorFactory = class {
         return new MochaGenerator();
       case "pytest":
         return new PytestGenerator();
+      case "node-test":
+        return new NodeTestGenerator();
       default:
         throw new Error(`Unsupported test framework: ${framework}`);
     }
@@ -27955,12 +28332,32 @@ ${sourceCode}
     };
   }
   extractParameters(params, sourceFile) {
-    return params.map((param) => ({
-      name: param.name.getText(sourceFile),
-      type: param.type?.getText(sourceFile),
-      optional: param.questionToken !== void 0,
-      defaultValue: param.initializer?.getText(sourceFile)
-    }));
+    let objectDestructureCount = 0;
+    let arrayDestructureCount = 0;
+    return params.map((param) => {
+      let name = param.name.getText(sourceFile);
+      let type = param.type?.getText(sourceFile);
+      if (ts.isObjectBindingPattern(param.name)) {
+        objectDestructureCount++;
+        name = objectDestructureCount > 1 ? `options${objectDestructureCount}` : "options";
+        if (!type) {
+          const props = param.name.elements.map((el) => `${el.name.getText(sourceFile)}: unknown`).join(", ");
+          type = `{ ${props} }`;
+        }
+      } else if (ts.isArrayBindingPattern(param.name)) {
+        arrayDestructureCount++;
+        name = arrayDestructureCount > 1 ? `items${arrayDestructureCount}` : "items";
+        if (!type) {
+          type = "unknown[]";
+        }
+      }
+      return {
+        name,
+        type,
+        optional: param.questionToken !== void 0,
+        defaultValue: param.initializer?.getText(sourceFile)
+      };
+    });
   }
   calculateComplexity(node) {
     let complexity = 1;
@@ -28019,12 +28416,18 @@ ${sourceCode}
       const callees = [];
       const callers = [];
       const tsImports = sourceContent.matchAll(/(?:import|from)\s+['"]([^'"]+)['"]/g);
-      const pyImports = sourceContent.matchAll(/(?:^|\n)\s*(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
       for (const match of tsImports) {
         imports.push(match[1]);
       }
-      for (const match of pyImports) {
-        imports.push(match[1] || match[2]);
+      const isPython = filePath.endsWith(".py");
+      if (isPython) {
+        const pyImports = sourceContent.matchAll(/(?:^|\n)\s*(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
+        for (const match of pyImports) {
+          const mod = match[1] || match[2];
+          if (mod && /^[a-zA-Z_][\w.]*$/.test(mod)) {
+            imports.push(mod);
+          }
+        }
       }
       const normalizedPath = filePath.replace(/\\/g, "/");
       const baseName = normalizedPath.split("/").pop()?.replace(/\.(ts|js|tsx|jsx|py)$/, "") || "";
@@ -28486,7 +28889,7 @@ var PatternMatcherService = class _PatternMatcherService {
         return template.replace("{{name}}", param.name);
       }
     }
-    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
+    return `{} /* TODO: provide ${param.name}: ${param.type || "unknown"} */`;
   }
   /**
    * Estimate number of branches from cyclomatic complexity
@@ -29402,12 +29805,32 @@ var TypeScriptASTParser = class {
    * Extract parameter information
    */
   extractParameters(params, sourceFile) {
-    return params.map((param) => ({
-      name: param.name.getText(sourceFile),
-      type: param.type?.getText(sourceFile),
-      optional: param.questionToken !== void 0,
-      defaultValue: param.initializer?.getText(sourceFile)
-    }));
+    let objectDestructureCount = 0;
+    let arrayDestructureCount = 0;
+    return params.map((param) => {
+      let name = param.name.getText(sourceFile);
+      let type = param.type?.getText(sourceFile);
+      if (ts2.isObjectBindingPattern(param.name)) {
+        objectDestructureCount++;
+        name = objectDestructureCount > 1 ? `options${objectDestructureCount}` : "options";
+        if (!type) {
+          const props = param.name.elements.map((el) => `${el.name.getText(sourceFile)}: unknown`).join(", ");
+          type = `{ ${props} }`;
+        }
+      } else if (ts2.isArrayBindingPattern(param.name)) {
+        arrayDestructureCount++;
+        name = arrayDestructureCount > 1 ? `items${arrayDestructureCount}` : "items";
+        if (!type) {
+          type = "unknown[]";
+        }
+      }
+      return {
+        name,
+        type,
+        optional: param.questionToken !== void 0,
+        defaultValue: param.initializer?.getText(sourceFile)
+      };
+    });
   }
   /**
    * Calculate cyclomatic complexity of a node
@@ -114551,7 +114974,7 @@ function parsePipelineContent(content, sourcePath) {
   if (errors.length > 0) {
     return { success: false, errors };
   }
-  const pipeline11 = {
+  const pipeline10 = {
     name: parsed.name,
     description: parsed.description,
     version: parsed.version || "1.0.0",
@@ -114573,26 +114996,26 @@ function parsePipelineContent(content, sourcePath) {
     tags: parsed.tags,
     timeout: parsed.timeout
   };
-  for (let i58 = 0; i58 < pipeline11.stages.length; i58++) {
-    const stage = pipeline11.stages[i58];
+  for (let i58 = 0; i58 < pipeline10.stages.length; i58++) {
+    const stage = pipeline10.stages[i58];
     if (!stage.command) {
       errors.push(`Stage ${i58 + 1} (${stage.name}) must have a "command" field`);
     }
   }
   if (errors.length > 0) {
-    return { success: false, pipeline: pipeline11, errors };
+    return { success: false, pipeline: pipeline10, errors };
   }
-  const workflow = convertToWorkflowDefinition(pipeline11, sourcePath);
+  const workflow = convertToWorkflowDefinition(pipeline10, sourcePath);
   return {
     success: true,
-    pipeline: pipeline11,
+    pipeline: pipeline10,
     workflow,
     errors: []
   };
 }
-function convertToWorkflowDefinition(pipeline11, sourcePath) {
-  const workflowId = `pipeline-${pipeline11.name.replace(/\s+/g, "-").toLowerCase()}`;
-  const steps = pipeline11.stages.map((stage, index) => {
+function convertToWorkflowDefinition(pipeline10, sourcePath) {
+  const workflowId = `pipeline-${pipeline10.name.replace(/\s+/g, "-").toLowerCase()}`;
+  const steps = pipeline10.stages.map((stage, index) => {
     const domainAction = mapCommandToDomainAction(stage.command);
     const inputMapping = {};
     if (stage.params) {
@@ -114626,7 +115049,7 @@ function convertToWorkflowDefinition(pipeline11, sourcePath) {
     }
     return step;
   });
-  const triggers = pipeline11.triggers?.map((trigger) => {
+  const triggers = pipeline10.triggers?.map((trigger) => {
     const workflowTrigger = {
       eventType: mapTriggerEventType(trigger),
       sourceDomain: trigger.source_domain
@@ -114642,13 +115065,13 @@ function convertToWorkflowDefinition(pipeline11, sourcePath) {
   });
   return {
     id: workflowId,
-    name: pipeline11.name,
-    description: pipeline11.description || `Pipeline from ${sourcePath || "inline YAML"}`,
-    version: pipeline11.version || "1.0.0",
+    name: pipeline10.name,
+    description: pipeline10.description || `Pipeline from ${sourcePath || "inline YAML"}`,
+    version: pipeline10.version || "1.0.0",
     steps,
     triggers,
-    tags: pipeline11.tags,
-    timeout: pipeline11.timeout ? pipeline11.timeout * 1e3 : void 0
+    tags: pipeline10.tags,
+    timeout: pipeline10.timeout ? pipeline10.timeout * 1e3 : void 0
   };
 }
 function mapCommandToDomainAction(command) {
@@ -114697,17 +115120,17 @@ function mapTriggerEventType(trigger) {
   }
   return event;
 }
-function validatePipeline(pipeline11) {
+function validatePipeline(pipeline10) {
   const errors = [];
   const warnings = [];
-  if (!pipeline11.name) {
+  if (!pipeline10.name) {
     errors.push({
       path: "name",
       message: "Pipeline name is required",
       severity: "error"
     });
   }
-  if (!pipeline11.stages || pipeline11.stages.length === 0) {
+  if (!pipeline10.stages || pipeline10.stages.length === 0) {
     errors.push({
       path: "stages",
       message: "Pipeline must have at least one stage",
@@ -114715,8 +115138,8 @@ function validatePipeline(pipeline11) {
     });
   } else {
     const stageNames = /* @__PURE__ */ new Set();
-    for (let i58 = 0; i58 < pipeline11.stages.length; i58++) {
-      const stage = pipeline11.stages[i58];
+    for (let i58 = 0; i58 < pipeline10.stages.length; i58++) {
+      const stage = pipeline10.stages[i58];
       const stagePath = `stages[${i58}]`;
       if (stageNames.has(stage.name)) {
         errors.push({
@@ -114744,7 +115167,7 @@ function validatePipeline(pipeline11) {
       }
       if (stage.depends_on) {
         for (const dep of stage.depends_on) {
-          if (!pipeline11.stages.some((s70) => s70.name === dep)) {
+          if (!pipeline10.stages.some((s70) => s70.name === dep)) {
             errors.push({
               path: `${stagePath}.depends_on`,
               message: `Unknown dependency: ${dep}`,
@@ -114770,7 +115193,7 @@ function validatePipeline(pipeline11) {
         }
       }
     }
-    const circular = detectCircularDependencies(pipeline11.stages);
+    const circular = detectCircularDependencies(pipeline10.stages);
     if (circular) {
       errors.push({
         path: "stages",
@@ -114779,18 +115202,18 @@ function validatePipeline(pipeline11) {
       });
     }
   }
-  if (pipeline11.schedule) {
-    if (!isValidCronExpression(pipeline11.schedule)) {
+  if (pipeline10.schedule) {
+    if (!isValidCronExpression(pipeline10.schedule)) {
       errors.push({
         path: "schedule",
-        message: `Invalid cron expression: ${pipeline11.schedule}`,
+        message: `Invalid cron expression: ${pipeline10.schedule}`,
         severity: "error"
       });
     }
   }
-  if (pipeline11.triggers) {
-    for (let i58 = 0; i58 < pipeline11.triggers.length; i58++) {
-      const trigger = pipeline11.triggers[i58];
+  if (pipeline10.triggers) {
+    for (let i58 = 0; i58 < pipeline10.triggers.length; i58++) {
+      const trigger = pipeline10.triggers[i58];
       const triggerPath = `triggers[${i58}]`;
       if (!trigger.event) {
         errors.push({
@@ -115449,7 +115872,7 @@ var ALL_DOMAINS2 = [
   "enterprise-integration"
 ];
 function getAQEVersion() {
-  return true ? "3.6.14" : "3.0.0";
+  return true ? "3.6.16" : "3.0.0";
 }
 function createDefaultConfig(projectName, projectRoot) {
   return {
@@ -123549,11 +123972,11 @@ function createTestCommand(context2, cleanupAndExit2, ensureInitialized2) {
             console.log(chalk9.gray(`      Assertions: ${test.assertions}`));
             if (test.testCode) {
               console.log(chalk9.gray(`      Test File: ${test.testFile}`));
-              console.log(`
---- Generated Code ---`);
-              console.log(test.testCode);
-              console.log(`--- End Generated Code ---
-`);
+              const fs23 = await import("fs");
+              const testDir = path26.dirname(test.testFile);
+              fs23.mkdirSync(testDir, { recursive: true });
+              fs23.writeFileSync(test.testFile, test.testCode, "utf-8");
+              console.log(chalk9.green(`      Written to: ${test.testFile}`));
             }
           }
           if (generated.tests.length > 10) {
@@ -125641,7 +126064,7 @@ var TASK_TYPES = [
 ];
 var PRIORITIES = ["p0", "p1", "p2", "p3"];
 var STATUSES = ["pending", "running", "completed", "failed", "cancelled"];
-var FRAMEWORKS = ["jest", "vitest", "pytest", "junit", "playwright", "cypress", "go-test"];
+var FRAMEWORKS = ["jest", "vitest", "pytest", "junit", "playwright", "cypress", "go-test", "node-test"];
 var TEST_TYPES = ["unit", "integration", "e2e"];
 var MEMORY_BACKENDS = ["sqlite", "agentdb", "hybrid"];
 function generateBashCompletion() {
@@ -132588,16 +133011,15 @@ import ora2 from "ora";
 var DEFAULT_SYNC_CONFIG = {
   local: {
     // PRIMARY: Root database (consolidated, MCP-active)
-    v3MemoryDb: "../.agentic-qe/memory.db",
-    // Now points to root (consolidated)
-    rootMemoryDb: "../.agentic-qe/memory.db",
-    // Same as above
-    claudeFlowMemory: "../.claude-flow/memory/store.json",
-    claudeFlowDaemon: "../.claude-flow/daemon-state.json",
-    claudeFlowMetrics: "../.claude-flow/metrics/",
-    intelligenceJson: "../v3/.ruvector/intelligence.json",
-    swarmMemoryDb: "../.swarm/memory.db",
-    v2PatternsDb: "../v2/data/ruvector-patterns.db"
+    // Paths relative to process.cwd() which is the project root
+    v3MemoryDb: "./.agentic-qe/memory.db",
+    rootMemoryDb: "./.agentic-qe/memory.db",
+    claudeFlowMemory: "./.claude-flow/memory/store.json",
+    claudeFlowDaemon: "./.claude-flow/daemon-state.json",
+    claudeFlowMetrics: "./.claude-flow/metrics/",
+    intelligenceJson: "./v3/.ruvector/intelligence.json",
+    swarmMemoryDb: "./.swarm/memory.db",
+    v2PatternsDb: "./v2/data/ruvector-patterns.db"
   },
   cloud: {
     project: process.env.GCP_PROJECT || "",
@@ -132613,82 +133035,150 @@ var DEFAULT_SYNC_CONFIG = {
     batchSize: 1e3,
     conflictResolution: "newer-wins",
     sourcePriority: {
-      rootMemory: 1,
-      // Root is now PRIMARY (consolidated)
-      claudeFlowMemory: 2,
-      intelligenceJson: 3,
-      legacy: 4
+      qePatterns: 1,
+      // Primary QE learning data (12K+ records)
+      sonaPatterns: 2,
+      // Neural backbone patterns
+      goapActions: 3,
+      // Planning primitives
+      kvStore: 4,
+      // Key-value memory entries
+      experiences: 5,
+      // Captured RL experiences
+      claudeFlowMemory: 6,
+      intelligenceJson: 7
     },
     sources: [
       // ============================================================
-      // ROOT Memory - PRIMARY (Consolidated from V3 + Historical)
-      // All tables now in single database: .agentic-qe/memory.db
+      // ROOT Memory - PRIMARY (Consolidated database)
+      // All tables in single database: .agentic-qe/memory.db
+      //
+      // NOTE (2026-02-20): Post-consolidation table mapping:
+      //   OLD v2 tables (removed)  →  NEW v3 tables (actual)
+      //   memory_entries           →  kv_store
+      //   learning_experiences     →  captured_experiences
+      //   patterns                 →  qe_patterns (absorbed)
+      //   events                   →  (removed, use dream_cycles/routing_outcomes)
       // ============================================================
+      // QE Patterns - PRIMARY learning data (12,150+ records)
+      // Explicit columns to match cloud schema exactly
+      {
+        name: "root-qe-patterns",
+        type: "sqlite",
+        path: "./.agentic-qe/memory.db",
+        targetTable: "aqe.qe_patterns",
+        priority: "high",
+        mode: "incremental",
+        query: "SELECT id, pattern_type, qe_domain, domain, name, description, confidence, usage_count, success_rate, quality_score, tier, template_json, context_json, successful_uses, created_at, updated_at, last_used_at, tokens_used, input_tokens, output_tokens, latency_ms, reusable, reuse_count, average_token_savings, total_tokens_saved FROM qe_patterns",
+        enabled: true
+      },
+      // SONA neural patterns (731+ records)
       {
         name: "root-sona-patterns",
         type: "sqlite",
-        path: "../.agentic-qe/memory.db",
+        path: "./.agentic-qe/memory.db",
         targetTable: "aqe.sona_patterns",
         priority: "high",
         mode: "incremental",
         query: "SELECT * FROM sona_patterns",
         enabled: true
       },
+      // GOAP actions (2,243+ records)
       {
         name: "root-goap-actions",
         type: "sqlite",
-        path: "../.agentic-qe/memory.db",
+        path: "./.agentic-qe/memory.db",
         targetTable: "aqe.goap_actions",
         priority: "high",
         mode: "incremental",
         query: "SELECT * FROM goap_actions",
         enabled: true
       },
+      // KV Store → cloud memory_entries (1,619+ records)
+      // Only sync entries with valid JSON values (skip corrupt/HTML-embedded data)
       {
-        name: "root-memory-entries",
+        name: "root-kv-store",
         type: "sqlite",
-        path: "../.agentic-qe/memory.db",
+        path: "./.agentic-qe/memory.db",
         targetTable: "aqe.memory_entries",
         priority: "high",
         mode: "incremental",
-        query: "SELECT * FROM memory_entries",
+        query: "SELECT key, namespace as partition, CASE WHEN json_valid(value) THEN value ELSE json_quote(value) END as value, created_at, expires_at FROM kv_store WHERE json_valid(value) OR json_valid(json_quote(value))",
         enabled: true
       },
+      // Captured experiences → cloud learning_experiences (854+ records)
+      // Cloud id is SERIAL (auto-increment) — omit local UUID id
       {
-        name: "root-learning-experiences",
+        name: "root-captured-experiences",
         type: "sqlite",
-        path: "../.agentic-qe/memory.db",
+        path: "./.agentic-qe/memory.db",
         targetTable: "aqe.learning_experiences",
         priority: "high",
         mode: "append",
-        query: "SELECT * FROM learning_experiences",
+        query: "SELECT agent as agent_id, task as task_id, domain as task_type, COALESCE(result_json, '{}') as state, COALESCE(steps_json, '{}') as action, quality as reward, COALESCE(routing_json, '{}') as next_state, tags as episode_id, started_at as created_at FROM captured_experiences",
         enabled: true
       },
+      // GOAP plans (91+ records)
       {
-        name: "root-patterns",
+        name: "root-goap-plans",
         type: "sqlite",
-        path: "../.agentic-qe/memory.db",
-        targetTable: "aqe.patterns",
+        path: "./.agentic-qe/memory.db",
+        targetTable: "aqe.goap_plans",
         priority: "medium",
         mode: "incremental",
-        query: "SELECT * FROM patterns",
+        query: "SELECT id, goal_id, action_sequence as sequence, initial_state, goal_state, action_sequence, total_cost, estimated_duration_ms as estimated_duration, status, created_at, completed_at FROM goap_plans",
         enabled: true
       },
+      // RL Q-values (from SQLite, not JSON)
+      // Use DISTINCT to avoid duplicate (state, action) pairs in same batch
       {
-        name: "root-events",
+        name: "root-rl-q-values",
         type: "sqlite",
-        path: "../.agentic-qe/memory.db",
-        targetTable: "aqe.events",
+        path: "./.agentic-qe/memory.db",
+        targetTable: "aqe.qlearning_patterns",
+        priority: "medium",
+        mode: "incremental",
+        query: "SELECT DISTINCT state_key as state, action_key as action, q_value, visits, updated_at as last_update, created_at FROM rl_q_values GROUP BY state_key, action_key",
+        enabled: true
+      },
+      // Routing outcomes (184+ records) - model routing decisions
+      {
+        name: "root-routing-outcomes",
+        type: "sqlite",
+        path: "./.agentic-qe/memory.db",
+        targetTable: "aqe.routing_outcomes",
+        priority: "medium",
+        mode: "append",
+        query: "SELECT * FROM routing_outcomes",
+        enabled: true
+      },
+      // QE trajectories (320+ records) - execution traces
+      {
+        name: "root-qe-trajectories",
+        type: "sqlite",
+        path: "./.agentic-qe/memory.db",
+        targetTable: "aqe.qe_trajectories",
+        priority: "medium",
+        mode: "append",
+        query: "SELECT * FROM qe_trajectories",
+        enabled: true
+      },
+      // Dream insights (660+ records) - consolidation results
+      {
+        name: "root-dream-insights",
+        type: "sqlite",
+        path: "./.agentic-qe/memory.db",
+        targetTable: "aqe.dream_insights",
         priority: "low",
         mode: "append",
-        query: "SELECT * FROM events",
+        query: "SELECT * FROM dream_insights",
         enabled: true
       },
       // Claude-Flow Memory (JSON)
       {
         name: "claude-flow-memory",
         type: "json",
-        path: "../.claude-flow/memory/store.json",
+        path: "./.claude-flow/memory/store.json",
         targetTable: "aqe.claude_flow_memory",
         priority: "medium",
         mode: "full",
@@ -132698,7 +133188,7 @@ var DEFAULT_SYNC_CONFIG = {
       {
         name: "intelligence-qlearning",
         type: "json",
-        path: "../v3/.ruvector/intelligence.json",
+        path: "./v3/.ruvector/intelligence.json",
         targetTable: "aqe.qlearning_patterns",
         priority: "low",
         mode: "full",
@@ -133450,7 +133940,9 @@ function createConnectionManager(config) {
 init_sql_safety();
 init_error_utils();
 init_logging();
+import { createRequire as createRequire7 } from "module";
 var logger14 = LoggerFactory.create("postgres-writer");
+var requirePg = createRequire7(import.meta.url);
 var PostgresWriter = class {
   client = null;
   config;
@@ -133471,31 +133963,36 @@ var PostgresWriter = class {
     if (!connection) {
       throw new Error("No tunnel connection available");
     }
+    let pg;
     try {
-      const pg = await Promise.resolve().then(() => (init_pg(), pg_exports));
-      const Client = pg.Client || pg.default?.Client;
-      if (Client) {
-        const connectionConfig = {
-          host: connection.host,
-          port: connection.port,
-          database: this.config.cloud.database,
-          user: this.config.cloud.user,
-          password: process.env.PGPASSWORD || "",
-          connectionTimeoutMillis: this.config.connectionTimeout || 1e4
-        };
-        this.client = new Client(connectionConfig);
-        await this.client.connect();
-        this.connected = true;
-        console.log(`[PostgresWriter] Connected to ${connection.host}:${connection.port}/${this.config.cloud.database}`);
-      } else {
-        throw new Error("pg Client not found");
-      }
+      pg = requirePg("pg");
     } catch (e20) {
-      logger14.debug("pg module not available, using mock mode", { error: e20 instanceof Error ? e20.message : String(e20) });
-      console.warn("[PostgresWriter] pg module not available, running in mock mode");
+      logger14.debug("pg module not installed, using mock mode", { error: e20 instanceof Error ? e20.message : String(e20) });
+      console.warn("[PostgresWriter] pg module not installed, running in mock mode");
       this.client = this.createMockClient();
       this.connected = true;
+      return;
     }
+    const pgDefault = pg.default;
+    const Client = pg.Client || pgDefault?.Client;
+    if (!Client) {
+      console.warn("[PostgresWriter] pg.Client not found in module, running in mock mode");
+      this.client = this.createMockClient();
+      this.connected = true;
+      return;
+    }
+    const connectionConfig = {
+      host: connection.host,
+      port: connection.port,
+      database: this.config.cloud.database,
+      user: this.config.cloud.user,
+      password: process.env.PGPASSWORD || "",
+      connectionTimeoutMillis: this.config.connectionTimeout || 1e4
+    };
+    this.client = new Client(connectionConfig);
+    await this.client.connect();
+    this.connected = true;
+    console.log(`[PostgresWriter] Connected to ${connection.host}:${connection.port}/${this.config.cloud.database}`);
   }
   /**
    * Begin a transaction
@@ -133545,8 +134042,28 @@ var PostgresWriter = class {
     const batchSize = 100;
     for (let i58 = 0; i58 < records.length; i58 += batchSize) {
       const batch = records.slice(i58, i58 + batchSize);
-      const inserted = await this.upsertBatch(table, batch, columns, conflictColumns, updateColumns, options?.skipIfExists);
-      totalInserted += inserted;
+      try {
+        const inserted = await this.upsertBatch(table, batch, columns, conflictColumns, updateColumns, options?.skipIfExists);
+        totalInserted += inserted;
+      } catch (error) {
+        const batchNum = Math.floor(i58 / batchSize) + 1;
+        const totalBatches = Math.ceil(records.length / batchSize);
+        logger14.debug(`Batch ${batchNum}/${totalBatches} failed for ${table}, retrying individually`, { error: toErrorMessage(error) });
+        let recovered = 0;
+        for (const record of batch) {
+          try {
+            const inserted = await this.upsertBatch(table, [record], columns, conflictColumns, updateColumns, options?.skipIfExists);
+            recovered += inserted;
+          } catch (retryError) {
+            const recordId = record["id"] || record["key"] || "?";
+            logger14.debug(`Skipped record ${String(recordId).slice(0, 50)} in ${table}`, { error: toErrorMessage(retryError) });
+          }
+        }
+        totalInserted += recovered;
+        if (recovered < batch.length) {
+          console.warn(`[PostgresWriter] Batch ${batchNum}/${totalBatches} for ${table}: ${recovered}/${batch.length} recovered (${batch.length - recovered} skipped)`);
+        }
+      }
     }
     return totalInserted;
   }
@@ -133589,7 +134106,7 @@ var PostgresWriter = class {
       const result = await this.client.query(sql, params);
       return result.rowCount || 0;
     } catch (error) {
-      console.error(`[PostgresWriter] Upsert failed: ${toErrorMessage(error)}`);
+      logger14.debug(`Upsert failed for ${table}`, { error: toErrorMessage(error) });
       throw error;
     }
   }
@@ -133660,9 +134177,33 @@ var PostgresWriter = class {
       return JSON.stringify(value);
     }
     if (typeof value === "object") {
-      return JSON.stringify(value);
+      let jsonStr = JSON.stringify(value);
+      if (columnName && this.isJsonbColumn(columnName)) {
+        jsonStr = jsonStr.replace(/\u0000/g, "");
+        try {
+          JSON.parse(jsonStr);
+        } catch {
+          return JSON.stringify(String(value));
+        }
+      }
+      return jsonStr;
     }
     if (typeof value === "string") {
+      if (value === "") {
+        const timestampColumns = [
+          "created_at",
+          "updated_at",
+          "last_used_at",
+          "started_at",
+          "ended_at",
+          "completed_at",
+          "expires_at",
+          "last_update"
+        ];
+        if (columnName && timestampColumns.includes(columnName)) {
+          return null;
+        }
+      }
       if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
         return value;
       }
@@ -133670,53 +134211,83 @@ var PostgresWriter = class {
       if (!isNaN(numVal) && numVal > 9466848e5 && numVal < 41024448e5) {
         return new Date(numVal).toISOString();
       }
-      const jsonbColumns = [
-        "action_value",
-        "state",
-        "action",
-        "next_state",
-        "preconditions",
-        "effects",
-        "metadata",
-        "value",
-        "payload",
-        "context_json",
-        "template_json",
-        "execution_trace",
-        "action_sequence",
-        "initial_state",
-        "goal_state",
-        "sequence"
-      ];
-      if (columnName && jsonbColumns.includes(columnName)) {
-        if (!value.startsWith("{") && !value.startsWith("[") && !value.startsWith('"')) {
-          return JSON.stringify(value);
+      if (columnName && this.isJsonbColumn(columnName)) {
+        const sanitized = value.replace(/\u0000/g, "");
+        try {
+          JSON.parse(sanitized);
+          return sanitized;
+        } catch {
+          return JSON.stringify(sanitized);
         }
       }
     }
     return value;
   }
   /**
-   * Infer conflict columns from table name
+   * Check if a column is a JSONB column
+   */
+  isJsonbColumn(columnName) {
+    const jsonbColumns = [
+      "action_value",
+      "state",
+      "action",
+      "next_state",
+      "preconditions",
+      "effects",
+      "metadata",
+      "value",
+      "payload",
+      "context_json",
+      "template_json",
+      "execution_trace",
+      "action_sequence",
+      "initial_state",
+      "goal_state",
+      "sequence",
+      "task_json",
+      "decision_json",
+      "steps_json",
+      "metadata_json"
+    ];
+    return jsonbColumns.includes(columnName);
+  }
+  /**
+   * Infer conflict columns from table name and available columns.
+   * Only returns columns if the target table is known to have a matching unique constraint.
    */
   inferConflictColumns(table, columns) {
     const tableName = table.includes(".") ? table.split(".")[1] : table;
-    if (columns.includes("id")) {
+    const tablesWithIdPK = [
+      "qe_patterns",
+      "sona_patterns",
+      "goap_actions",
+      "goap_plans",
+      "patterns",
+      "events",
+      "routing_outcomes",
+      "qe_trajectories",
+      "dream_insights",
+      "intelligence_memories"
+    ];
+    if (columns.includes("id") && tablesWithIdPK.includes(tableName)) {
       return ["id"];
     }
-    if (columns.includes("key") && columns.includes("source_env")) {
+    if (tableName === "memory_entries" && columns.includes("key") && columns.includes("source_env")) {
       if (columns.includes("partition")) {
         return ["key", "partition", "source_env"];
       }
       return ["key", "source_env"];
     }
-    if (columns.includes("state") && columns.includes("action") && columns.includes("source_env")) {
+    if (tableName === "claude_flow_memory" && columns.includes("key") && columns.includes("source_env")) {
+      return ["key", "source_env"];
+    }
+    if (tableName === "qlearning_patterns" && columns.includes("state") && columns.includes("action") && columns.includes("source_env")) {
       return ["state", "action", "source_env"];
     }
-    if (columns.includes("worker_type") && columns.includes("source_env")) {
+    if (tableName === "claude_flow_workers" && columns.includes("worker_type") && columns.includes("source_env")) {
       return ["worker_type", "source_env"];
     }
-    return columns.includes("id") ? ["id"] : [];
+    return [];
   }
   /**
    * Create mock client for testing without pg installed
@@ -133869,17 +134440,10 @@ var CloudSyncAgent = class {
         return result;
       }
       if (this.writer && !this.config.sync.dryRun) {
-        await this.writer.beginTransaction();
-        try {
-          const written = await this.writer.upsert(source.targetTable, records, {
-            skipIfExists: source.mode === "append"
-          });
-          result.recordsSynced = written;
-          await this.writer.commit();
-        } catch (error) {
-          await this.writer.rollback();
-          throw error;
-        }
+        const written = await this.writer.upsert(source.targetTable, records, {
+          skipIfExists: source.mode === "append"
+        });
+        result.recordsSynced = written;
       } else {
         result.recordsSynced = records.length;
         this.log(`[DRY RUN] Would sync ${records.length} records to ${source.targetTable}`);
@@ -133919,15 +134483,8 @@ var CloudSyncAgent = class {
         return result;
       }
       if (this.writer && !this.config.sync.dryRun) {
-        await this.writer.beginTransaction();
-        try {
-          const written = await this.writer.upsert(source.targetTable, records);
-          result.recordsSynced = written;
-          await this.writer.commit();
-        } catch (error) {
-          await this.writer.rollback();
-          throw error;
-        }
+        const written = await this.writer.upsert(source.targetTable, records);
+        result.recordsSynced = written;
       } else {
         result.recordsSynced = records.length;
       }
@@ -135653,22 +136210,22 @@ var CategoryAdapter = class {
    * @param pipeline - The pipeline to verify
    * @returns Type verification result
    */
-  verifyPipeline(pipeline11) {
+  verifyPipeline(pipeline10) {
     const startTime = Date.now();
     this.clear();
-    this.addType(pipeline11.inputType, this.inferSchema(pipeline11.inputType));
-    this.addType(pipeline11.outputType, this.inferSchema(pipeline11.outputType));
-    for (const element of pipeline11.elements) {
+    this.addType(pipeline10.inputType, this.inferSchema(pipeline10.inputType));
+    this.addType(pipeline10.outputType, this.inferSchema(pipeline10.outputType));
+    for (const element of pipeline10.elements) {
       this.addType(element.inputType, this.inferSchema(element.inputType));
       this.addType(element.outputType, this.inferSchema(element.outputType));
     }
-    for (const element of pipeline11.elements) {
+    for (const element of pipeline10.elements) {
       this.addMorphism(element.inputType, element.outputType, element.name);
     }
-    const path26 = this.buildCompositionPath(pipeline11);
+    const path26 = this.buildCompositionPath(pipeline10);
     const compositionValid = this.verifyComposition(path26);
     const mismatches = this.checkTypeConsistency();
-    const warnings = this.generateWarnings(pipeline11, compositionValid, mismatches);
+    const warnings = this.generateWarnings(pipeline10, compositionValid, mismatches);
     const durationMs = Date.now() - startTime;
     const result = {
       isValid: compositionValid && mismatches.length === 0,
@@ -135678,7 +136235,7 @@ var CategoryAdapter = class {
       usedFallback: false
     };
     this.logger.info("Verified pipeline", {
-      pipelineId: pipeline11.id,
+      pipelineId: pipeline10.id,
       isValid: result.isValid,
       mismatchCount: mismatches.length,
       warningCount: warnings.length,
@@ -135689,16 +136246,16 @@ var CategoryAdapter = class {
   /**
    * Build a composition path from a pipeline
    */
-  buildCompositionPath(pipeline11) {
-    const path26 = [pipeline11.inputType];
-    for (const element of pipeline11.elements) {
+  buildCompositionPath(pipeline10) {
+    const path26 = [pipeline10.inputType];
+    for (const element of pipeline10.elements) {
       if (element.inputType !== path26[path26.length - 1]) {
         path26.push(element.inputType);
       }
       path26.push(element.outputType);
     }
-    if (path26[path26.length - 1] !== pipeline11.outputType) {
-      path26.push(pipeline11.outputType);
+    if (path26[path26.length - 1] !== pipeline10.outputType) {
+      path26.push(pipeline10.outputType);
     }
     return path26;
   }
@@ -135744,21 +136301,21 @@ var CategoryAdapter = class {
   /**
    * Generate warnings for potential issues
    */
-  generateWarnings(pipeline11, compositionValid, mismatches) {
+  generateWarnings(pipeline10, compositionValid, mismatches) {
     const warnings = [];
     if (!compositionValid) {
       warnings.push(
-        `Pipeline '${pipeline11.id}' has an invalid composition chain. Types do not connect properly from input to output.`
+        `Pipeline '${pipeline10.id}' has an invalid composition chain. Types do not connect properly from input to output.`
       );
     }
-    for (const element of pipeline11.elements) {
+    for (const element of pipeline10.elements) {
       if (element.inputType === "any" || element.outputType === "any") {
         warnings.push(
           `Element '${element.name}' uses 'any' type, which bypasses type safety.`
         );
       }
     }
-    for (const element of pipeline11.elements) {
+    for (const element of pipeline10.elements) {
       if (element.inputType.includes("<T>") || element.outputType.includes("<T>")) {
         warnings.push(
           `Element '${element.name}' has unconstrained generic types.`
@@ -136668,21 +137225,21 @@ var CoherenceService = class {
   /**
    * Verify type consistency in a pipeline
    */
-  async verifyTypes(pipeline11) {
+  async verifyTypes(pipeline10) {
     this.ensureInitialized();
     if (this.categoryAdapter?.isInitialized()) {
-      return this.categoryAdapter.verifyPipeline(pipeline11);
+      return this.categoryAdapter.verifyPipeline(pipeline10);
     }
-    return this.verifyTypesWithFallback(pipeline11);
+    return this.verifyTypesWithFallback(pipeline10);
   }
   /**
    * Fallback type verification using simple matching
    */
-  verifyTypesWithFallback(pipeline11) {
+  verifyTypesWithFallback(pipeline10) {
     const startTime = Date.now();
     const mismatches = [];
-    let currentType = pipeline11.inputType;
-    for (const element of pipeline11.elements) {
+    let currentType = pipeline10.inputType;
+    for (const element of pipeline10.elements) {
       if (element.inputType !== currentType && currentType !== "any") {
         mismatches.push({
           location: element.name,
@@ -136693,10 +137250,10 @@ var CoherenceService = class {
       }
       currentType = element.outputType;
     }
-    if (currentType !== pipeline11.outputType && currentType !== "any") {
+    if (currentType !== pipeline10.outputType && currentType !== "any") {
       mismatches.push({
         location: "pipeline output",
-        expected: pipeline11.outputType,
+        expected: pipeline10.outputType,
         actual: currentType,
         severity: "critical"
       });
@@ -139196,7 +139753,7 @@ import chalk28 from "chalk";
 import path24 from "node:path";
 import { createReadStream, createWriteStream } from "node:fs";
 import { createGzip, createGunzip } from "node:zlib";
-import { pipeline as pipeline10 } from "node:stream/promises";
+import { pipeline as pipeline9 } from "node:stream/promises";
 init_qe_patterns();
 var state2 = {
   reasoningBank: null,
@@ -139324,7 +139881,7 @@ function getDbPath() {
 }
 async function compressFile(inputPath, outputPath) {
   const gzPath = outputPath || `${inputPath}.gz`;
-  await pipeline10(
+  await pipeline9(
     createReadStream(inputPath),
     createGzip(),
     createWriteStream(gzPath)
@@ -139332,7 +139889,7 @@ async function compressFile(inputPath, outputPath) {
   return gzPath;
 }
 async function decompressFile(gzPath, outputPath) {
-  await pipeline10(
+  await pipeline9(
     createReadStream(gzPath),
     createGunzip(),
     createWriteStream(outputPath)
@@ -140544,7 +141101,7 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command18();
-var VERSION = true ? "3.6.14" : "0.0.0-dev";
+var VERSION = true ? "3.6.16" : "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);
@@ -140828,22 +141385,22 @@ Validating pipeline: ${file}
       console.log("");
     }
     if (options.verbose && parseResult.pipeline) {
-      const pipeline11 = parseResult.pipeline;
+      const pipeline10 = parseResult.pipeline;
       console.log(chalk30.cyan("Pipeline Details:\n"));
-      console.log(chalk30.gray(`  Name: ${pipeline11.name}`));
-      console.log(chalk30.gray(`  Version: ${pipeline11.version || "1.0.0"}`));
-      if (pipeline11.description) {
-        console.log(chalk30.gray(`  Description: ${pipeline11.description}`));
+      console.log(chalk30.gray(`  Name: ${pipeline10.name}`));
+      console.log(chalk30.gray(`  Version: ${pipeline10.version || "1.0.0"}`));
+      if (pipeline10.description) {
+        console.log(chalk30.gray(`  Description: ${pipeline10.description}`));
       }
-      if (pipeline11.schedule) {
-        console.log(chalk30.gray(`  Schedule: ${pipeline11.schedule} (${describeCronSchedule(pipeline11.schedule)})`));
+      if (pipeline10.schedule) {
+        console.log(chalk30.gray(`  Schedule: ${pipeline10.schedule} (${describeCronSchedule(pipeline10.schedule)})`));
       }
-      if (pipeline11.tags && pipeline11.tags.length > 0) {
-        console.log(chalk30.gray(`  Tags: ${pipeline11.tags.join(", ")}`));
+      if (pipeline10.tags && pipeline10.tags.length > 0) {
+        console.log(chalk30.gray(`  Tags: ${pipeline10.tags.join(", ")}`));
       }
       console.log(chalk30.cyan("\n  Stages:"));
-      for (let i58 = 0; i58 < pipeline11.stages.length; i58++) {
-        const stage = pipeline11.stages[i58];
+      for (let i58 = 0; i58 < pipeline10.stages.length; i58++) {
+        const stage = pipeline10.stages[i58];
         console.log(`    ${i58 + 1}. ${chalk30.white(stage.name)}`);
         console.log(chalk30.gray(`       Command: ${stage.command}`));
         if (stage.params) {
@@ -140856,9 +141413,9 @@ Validating pipeline: ${file}
           console.log(chalk30.gray(`       Timeout: ${stage.timeout}s`));
         }
       }
-      if (pipeline11.triggers && pipeline11.triggers.length > 0) {
+      if (pipeline10.triggers && pipeline10.triggers.length > 0) {
         console.log(chalk30.cyan("\n  Triggers:"));
-        for (const trigger of pipeline11.triggers) {
+        for (const trigger of pipeline10.triggers) {
           console.log(chalk30.gray(`    * ${trigger.event}`));
           if (trigger.branches) {
             console.log(chalk30.gray(`      Branches: ${trigger.branches.join(", ")}`));