agentic-qe 3.6.15 → 3.6.17

package/v3/dist/mcp/bundle.js

@@ -27141,6 +27141,7 @@ var StdioTransport = class {
   rl = null;
   requestHandler = null;
   notificationHandler = null;
+  errorHandler = null;
   running = false;
   metrics = {
     messagesReceived: 0,
@@ -27185,22 +27186,29 @@ var StdioTransport = class {
       });
     });
     this.rl.on("close", () => {
+      const wasRunning = this.running;
       this.running = false;
+      if (wasRunning && this.errorHandler) {
+        this.errorHandler(new Error("Transport connection closed unexpectedly"));
+      }
     });
     this.rl.on("error", (err4) => {
       this.metrics.errors++;
       console.error("[StdioTransport] Readline error:", err4);
+      if (this.errorHandler) {
+        this.errorHandler(err4);
+      }
     });
   }
   /**
    * Stop listening
    */
   stop() {
+    this.running = false;
     if (this.rl) {
       this.rl.close();
       this.rl = null;
     }
-    this.running = false;
   }
   /**
    * Send a response
@@ -27219,6 +27227,24 @@ var StdioTransport = class {
     };
     await this.write(JSON.stringify(notification));
   }
+  /**
+   * Set error handler for transport-level errors
+   */
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  /**
+   * Reconnect the transport by re-attaching to stdin/stdout.
+   * Closes the existing readline interface and creates a new one.
+   */
+  reconnect() {
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+    this.running = false;
+    this.start();
+  }
   /**
    * Get transport metrics
    */
@@ -27321,13 +27347,50 @@ var StdioTransport = class {
     };
     await this.sendResponse(response);
   }
-  write(data) {
+  /**
+   * Write with retry and backpressure handling.
+   * Retries up to 3 times with exponential backoff before rejecting.
+   */
+  async write(data) {
+    const maxAttempts = 3;
+    const backoffDelays = [0, 500, 1e3];
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        await this.writeOnce(data);
+        return;
+      } catch (err4) {
+        if (attempt < maxAttempts - 1) {
+          console.error(
+            `[StdioTransport] Write attempt ${attempt + 1} failed, retrying in ${backoffDelays[attempt + 1]}ms...`
+          );
+          await new Promise((r54) => setTimeout(r54, backoffDelays[attempt + 1]));
+        } else {
+          throw err4;
+        }
+      }
+    }
+  }
+  /**
+   * Single write attempt with 120s timeout and backpressure (drain) handling.
+   */
+  async writeOnce(data) {
+    const message = data + "\n";
+    if (this.outputStream.writableNeedDrain) {
+      await new Promise((resolve9, reject) => {
+        const drainTimeout = setTimeout(() => {
+          reject(new Error("Transport drain timeout after 30 seconds"));
+        }, 3e4);
+        this.outputStream.once("drain", () => {
+          clearTimeout(drainTimeout);
+          resolve9();
+        });
+      });
+    }
     return new Promise((resolve9, reject) => {
-      const message = data + "\n";
       const writeTimeout = setTimeout(() => {
         this.metrics.errors++;
-        reject(new Error("Transport write timeout after 30 seconds"));
-      }, 3e4);
+        reject(new Error("Transport write timeout after 120 seconds"));
+      }, 12e4);
       this.outputStream.write(message, "utf-8", (error) => {
         clearTimeout(writeTimeout);
         if (error) {
@@ -38683,11 +38746,27 @@ var BaseTestGenerator = class _BaseTestGenerator {
     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: isVoid ? `${fnCall};` : `const result = ${fnCall};`,
-      assertion: isVoid ? `// void function \u2014 no return value to assert` : "expect(result).toBeDefined();"
+      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);
@@ -38992,6 +39071,22 @@ ${importStatement}
     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}() => {
 `;
     if (isVoid) {
@@ -39002,7 +39097,7 @@ ${importStatement}
     } else {
       code += `      const result = ${methodCall};
 `;
-      code += `      expect(result).toBeDefined();
+      code += `      ${methodAssertion}
 `;
     }
     code += `    });
@@ -39399,6 +39494,22 @@ ${stubSetup}`;
     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() {
 `;
     if (isVoid) {
@@ -39407,7 +39518,7 @@ ${stubSetup}`;
     } else {
       code += `      const result = ${fnCall};
 `;
-      code += `      expect(result).to.not.be.undefined;
+      code += `      ${chaiAssertion}
 `;
     }
     code += `    });
@@ -39473,19 +39584,33 @@ ${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 isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+        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() {
 `;
-        if (isVoid) {
+        if (isMethodVoid) {
           code += `      ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
 `;
         } else {
           code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
 `;
-          code += `      expect(result).to.not.be.undefined;
+          code += `      ${methodAssertion}
 `;
         }
         code += `    });
@@ -39734,6 +39859,20 @@ class Test${this.pascalCase(moduleName)}:
 `;
     code += `        """Test ${fn.name} with valid input"""
 `;
+    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
 
@@ -39741,7 +39880,7 @@ class Test${this.pascalCase(moduleName)}:
     } else {
       code += `        result = ${fn.name}(${validParams})
 `;
-      code += `        assert result is not None
+      code += `        ${pyAssertion}
 
 `;
     }
@@ -39785,19 +39924,33 @@ 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 isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
+        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):
 `;
-        if (isVoid) {
+        if (isMethodVoid) {
           code += `        instance.${method.name}(${methodParams})
 
 `;
         } else {
           code += `        result = instance.${method.name}(${methodParams})
 `;
-          code += `        assert result is not None
+          code += `        ${mAssertion}
 
 `;
         }
@@ -39985,12 +40138,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(context) {
+    const { moduleName, importPath, testType, patterns, analysis } = context;
+    if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
+      return this.generateStubTests(context);
+    }
+    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(context) {
+    const { moduleName, importPath, testType, patterns } = context;
+    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 {
@@ -40052,6 +40407,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}`);
     }
@@ -41399,12 +41756,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;
@@ -43419,12 +43796,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
@@ -137639,8 +138036,83 @@ function generateV2LearningFeedback(agentType) {
   return {
     enabled: true,
     agentId: generateAgentId(agentType),
-    message: "Agent learned from this execution - patterns and Q-values updated"
+    message: "Experience captured asynchronously via learning pipeline"
+  };
+}
+async function captureExecutionLearning(agentType, toolName, params, result, durationMs) {
+  const agentId = generateAgentId(agentType);
+  try {
+    const { kernel } = getFleetState();
+    if (!kernel) {
+      return { enabled: false, agentId, message: "Learning engine not available - kernel not initialized" };
+    }
+    const engine = await getLearningEngineForCapture();
+    if (!engine) {
+      return { enabled: false, agentId, message: "Learning engine not available" };
+    }
+    const captureService = engine.getExperienceCaptureService();
+    if (!captureService) {
+      return { enabled: false, agentId, message: "Experience capture service not available" };
+    }
+    const domain = toolNameToDomain(toolName);
+    const experienceId = captureService.startCapture(
+      `${toolName}: ${JSON.stringify(params).slice(0, 200)}`,
+      {
+        agent: agentType,
+        domain: domain || void 0,
+        metadata: {
+          tool: toolName,
+          durationMs
+        }
+      }
+    );
+    captureService.recordStep(experienceId, {
+      action: `execute-${toolName}`,
+      result: typeof result === "object" ? JSON.stringify(result).slice(0, 500) : String(result).slice(0, 500),
+      quality: 0.7
+      // Default quality for successful tool execution
+    });
+    const captureResult = await captureService.completeCapture(experienceId, {
+      success: true,
+      quality: 0.7
+    });
+    if (captureResult.success) {
+      const experience = captureResult.value;
+      return {
+        enabled: true,
+        agentId,
+        message: `Experience captured: ${experience.id} (domain: ${domain || "general"}, quality: ${experience.quality})`,
+        experienceId: experience.id,
+        domain: domain || "general"
+      };
+    }
+    return { enabled: true, agentId, message: "Experience capture completed (no pattern extracted)" };
+  } catch (error) {
+    return {
+      enabled: false,
+      agentId,
+      message: `Learning capture failed: ${toErrorMessage(error)}`
+    };
+  }
+}
+function toolNameToDomain(toolName) {
+  const mapping = {
+    "test_generate_enhanced": "test-generation",
+    "test_execute_parallel": "test-execution",
+    "coverage_analyze_sublinear": "coverage-analysis",
+    "quality_assess": "quality-assessment",
+    "security_scan_comprehensive": "security-compliance",
+    "contract_validate": "contract-testing",
+    "accessibility_test": "visual-accessibility",
+    "chaos_test": "chaos-resilience",
+    "defect_predict": "defect-intelligence",
+    "requirements_validate": "requirements-validation",
+    "code_index": "code-intelligence"
   };
+  return mapping[toolName] || null;
+}
+async function getLearningEngineForCapture() {
+  return getLearningEngine();
 }
 function analyzeComplexity(sourceCode) {
   const lines = sourceCode.split("\n").length;
@@ -137946,6 +138418,14 @@ function createDomainHandler(config) {
         domain,
         result.duration
       );
+      captureExecutionLearning(
+        `qe-${domain}`,
+        taskType,
+        params,
+        data,
+        result.duration
+      ).catch(() => {
+      });
       return {
         success: true,
         data: mappedResult
@@ -153615,7 +154095,9 @@ var state = {
   router: null,
   workflowOrchestrator: null,
   initialized: false,
-  initTime: null
+  initTime: null,
+  topology: "hierarchical",
+  agentLevels: /* @__PURE__ */ new Map()
 };
 function getFleetState() {
   return state;
@@ -153623,6 +154105,23 @@ function getFleetState() {
 function isFleetInitialized() {
   return state.initialized && state.kernel !== null && state.queen !== null;
 }
+function assignAgentLevel(agentId, domain) {
+  if (state.topology !== "hierarchical") {
+    const info2 = { agentId, domain, level: "worker", spawnedAt: /* @__PURE__ */ new Date() };
+    state.agentLevels.set(agentId, info2);
+    return "worker";
+  }
+  const existingLead = Array.from(state.agentLevels.values()).find(
+    (a37) => a37.domain === domain && a37.level === "lead"
+  );
+  const level = existingLead ? "worker" : "lead";
+  const info = { agentId, domain, level, spawnedAt: /* @__PURE__ */ new Date() };
+  state.agentLevels.set(agentId, info);
+  return level;
+}
+function getAgentLevel(agentId) {
+  return state.agentLevels.get(agentId);
+}
 async function handleFleetInit(params) {
   try {
     if (state.initialized && state.kernel && state.queen) {
@@ -153687,11 +154186,13 @@ async function handleFleetInit(params) {
     registerDomainWorkflowActions(state.kernel, state.workflowOrchestrator);
     state.initialized = true;
     state.initTime = /* @__PURE__ */ new Date();
+    state.topology = params.topology || "hierarchical";
+    state.agentLevels.clear();
     return {
       success: true,
       data: {
         fleetId: state.fleetId,
-        topology: params.topology || "hierarchical",
+        topology: state.topology,
         maxAgents: params.maxAgents || 15,
         // Return user-facing domains (12) - coordination is internal
         enabledDomains: userFacingDomains,
@@ -153851,6 +154352,8 @@ async function disposeFleet() {
   state.initialized = false;
   state.fleetId = null;
   state.initTime = null;
+  state.topology = "hierarchical";
+  state.agentLevels.clear();
 }
 function registerDomainWorkflowActions(kernel, orchestrator) {
   const reqValAPI = kernel.getDomainAPI("requirements-validation");
@@ -155124,14 +155627,18 @@ async function handleAgentList(params) {
     if (typeof params.limit === "number") {
       agents = agents.slice(0, params.limit);
     }
-    const result = agents.map((agent) => ({
-      id: agent.id,
-      domain: agent.domain,
-      type: agent.type,
-      status: agent.status,
-      name: agent.name,
-      startedAt: agent.startedAt?.toISOString()
-    }));
+    const result = agents.map((agent) => {
+      const levelInfo = getAgentLevel(agent.id);
+      return {
+        id: agent.id,
+        domain: agent.domain,
+        type: agent.type,
+        status: agent.status,
+        name: agent.name,
+        startedAt: agent.startedAt?.toISOString(),
+        level: levelInfo?.level
+      };
+    });
     return {
       success: true,
       data: result
@@ -155165,6 +155672,7 @@ async function handleAgentSpawn(params) {
     }
     const balancer = getLoadBalancer();
     balancer.registerAgent(result.value);
+    const level = assignAgentLevel(result.value, params.domain);
     return {
       success: true,
       data: {
@@ -155172,7 +155680,8 @@ async function handleAgentSpawn(params) {
         domain: params.domain,
         type: params.type || "worker",
         status: "spawned",
-        capabilities: params.capabilities || ["general"]
+        capabilities: params.capabilities || ["general"],
+        level
       }
     };
   } catch (error) {
@@ -155732,6 +156241,17 @@ async function handleMemoryStore(params) {
     await kernel.memory.set(fullKey, params.value, {
       ttl: params.ttl
     });
+    try {
+      const textForEmbedding = `${params.key} ${JSON.stringify(params.value)}`;
+      const embedding = textToSimpleEmbedding(textForEmbedding);
+      await kernel.memory.storeVector(fullKey, embedding, {
+        key: params.key,
+        namespace,
+        storedAt: Date.now()
+      });
+    } catch (vecErr) {
+      console.warn(`[MemoryHandler] Vector indexing failed for ${params.key}: ${toErrorMessage(vecErr)}`);
+    }
     if (isMemoryWriteGateEnabled()) {
       memoryWriteGateIntegration.registerPattern(
         createMemoryPattern(params.key, params.value, namespace)
@@ -155795,6 +156315,9 @@ async function handleMemoryRetrieve(params) {
     };
   }
 }
+function isNaturalLanguageQuery(pattern) {
+  return pattern.includes(" ") && !pattern.includes("*") && !pattern.includes("?");
+}
 async function handleMemoryQuery(params) {
   if (!isFleetInitialized()) {
     return {
@@ -155807,6 +156330,34 @@ async function handleMemoryQuery(params) {
     const namespace = params.namespace || "default";
     const limit = params.limit || 100;
     const offset = params.offset || 0;
+    const useSemantic = params.semantic === true || params.semantic !== false && params.pattern && isNaturalLanguageQuery(params.pattern);
+    if (useSemantic && params.pattern) {
+      try {
+        const embedding = textToSimpleEmbedding(params.pattern);
+        const vectorResults = await kernel.memory.vectorSearch(embedding, limit + offset);
+        const filtered = namespace !== "default" ? vectorResults.filter((r54) => r54.key.startsWith(`${namespace}:`)) : vectorResults;
+        const paginatedResults = filtered.slice(offset, offset + limit);
+        const entries2 = paginatedResults.map((r54) => {
+          const parts = r54.key.split(":");
+          return {
+            key: parts.length > 1 ? parts.slice(1).join(":") : r54.key,
+            namespace: parts.length > 1 ? parts[0] : namespace,
+            score: r54.score
+          };
+        });
+        return {
+          success: true,
+          data: {
+            entries: entries2,
+            total: filtered.length,
+            hasMore: offset + limit < filtered.length,
+            searchType: "semantic"
+          }
+        };
+      } catch (vectorError) {
+        console.error(`[MemoryHandler] Semantic search failed, falling back to pattern: ${toErrorMessage(vectorError)}`);
+      }
+    }
     const pattern = params.pattern ? `${namespace}:${params.pattern}` : `${namespace}:*`;
     const keys = await kernel.memory.search(pattern, limit + offset);
     const paginatedKeys = keys.slice(offset, offset + limit);
@@ -155823,7 +156374,8 @@ async function handleMemoryQuery(params) {
       data: {
         entries,
         total: keys.length,
-        hasMore: offset + limit < keys.length
+        hasMore: offset + limit < keys.length,
+        searchType: "pattern"
       }
     };
   } catch (error) {
@@ -155833,6 +156385,26 @@ async function handleMemoryQuery(params) {
     };
   }
 }
+function textToSimpleEmbedding(text2) {
+  const dimension = 768;
+  const embedding = new Array(dimension).fill(0);
+  const words = text2.toLowerCase().split(/\s+/);
+  for (const word of words) {
+    let hash = 0;
+    for (let i58 = 0; i58 < word.length; i58++) {
+      hash = (hash << 5) - hash + word.charCodeAt(i58) | 0;
+    }
+    const idx = Math.abs(hash) % dimension;
+    embedding[idx] += 1;
+  }
+  const magnitude2 = Math.sqrt(embedding.reduce((sum, v62) => sum + v62 * v62, 0));
+  if (magnitude2 > 0) {
+    for (let i58 = 0; i58 < dimension; i58++) {
+      embedding[i58] /= magnitude2;
+    }
+  }
+  return embedding;
+}
 async function handleMemoryDelete(params) {
   if (!isFleetInitialized()) {
     return {
@@ -156562,6 +157134,9 @@ var MCPProtocolServer = class {
   monitor = getPerformanceMonitor();
   // AG-UI EventAdapter for streaming events to HTTP clients
   eventAdapter;
+  // Connection recovery state
+  reconnecting = false;
+  pendingRequests = [];
   constructor(config = {}) {
     this.config = {
       name: config.name ?? "agentic-qe-v3",
@@ -156604,9 +157179,53 @@ var MCPProtocolServer = class {
     this.transport.onNotification(async (notification) => {
       await this.handleNotification(notification);
     });
+    this.transport.onError(async (error) => {
+      console.error(`[MCP] Transport error: ${error.message}`);
+      await this.attemptReconnect();
+    });
     this.transport.start();
     console.error(`[MCP] ${this.config.name} v${this.config.version} started`);
   }
+  /**
+   * Attempt to reconnect the transport with exponential backoff.
+   * Buffers requests during the reconnection window and replays them after success.
+   */
+  async attemptReconnect() {
+    if (this.reconnecting) return;
+    this.reconnecting = true;
+    const maxAttempts = 3;
+    const baseDelay = 1e3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const delay = baseDelay * Math.pow(2, attempt);
+      console.error(`[MCP] Reconnect attempt ${attempt + 1}/${maxAttempts} in ${delay}ms...`);
+      await new Promise((r54) => setTimeout(r54, delay));
+      try {
+        this.transport.reconnect();
+        console.error(`[MCP] Reconnected after ${attempt + 1} attempt(s)`);
+        this.reconnecting = false;
+        const buffered2 = [...this.pendingRequests];
+        this.pendingRequests = [];
+        for (const { resolve: resolve9, request } of buffered2) {
+          try {
+            const result = await this.handleRequest(request);
+            resolve9(result);
+          } catch (err4) {
+            console.error(`[MCP] Failed to replay buffered request: ${request.method}`);
+          }
+        }
+        return;
+      } catch (err4) {
+        console.error(`[MCP] Reconnect attempt ${attempt + 1} failed: ${err4 instanceof Error ? err4.message : err4}`);
+      }
+    }
+    this.reconnecting = false;
+    console.error("[MCP] All reconnect attempts failed. Tools unavailable until transport is restored.");
+    const buffered = [...this.pendingRequests];
+    this.pendingRequests = [];
+    for (const { reject } of buffered) {
+      reject(new Error("MCP connection lost and reconnect failed"));
+    }
+  }
   /**
    * Stop the MCP server
    */
@@ -157092,11 +157711,12 @@ var MCPProtocolServer = class {
     this.registerTool({
       definition: {
         name: "memory_query",
-        description: "Query memory with pattern matching",
+        description: "Query memory with pattern matching or HNSW semantic search",
         category: "memory",
         parameters: [
-          { name: "pattern", type: "string", description: "Key pattern" },
-          { name: "namespace", type: "string", description: "Memory namespace" }
+          { name: "pattern", type: "string", description: "Key pattern (glob) or natural language query (for semantic search)" },
+          { name: "namespace", type: "string", description: "Memory namespace" },
+          { name: "semantic", type: "boolean", description: "Use HNSW vector search instead of pattern matching. Auto-detected when pattern contains spaces and no wildcards." }
         ]
       },
       handler: (params) => handleMemoryQuery(params)