agentic-qe 3.6.16 → 3.6.18

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) {
@@ -122676,6 +122739,22 @@ var DomainTeamManager = class _DomainTeamManager {
     const team = this.teams.get(domain);
     return team ? this.toSnapshot(team) : void 0;
   }
+  /**
+   * Add a specific agent as a teammate to an existing domain team.
+   * Unlike scaleTeam(), this uses the real agent ID rather than generating one.
+   * @returns True if the agent was added, false if team doesn't exist or is full
+   */
+  addTeammate(domain, agentId) {
+    const team = this.teams.get(domain);
+    if (!team) return false;
+    if (agentId === team.leadAgentId || team.teammateIds.includes(agentId)) return false;
+    const maxSize = this.getMaxTeamSize(domain);
+    if (1 + team.teammateIds.length >= maxSize) return false;
+    team.teammateIds.push(agentId);
+    team.lastActivity.set(agentId, Date.now());
+    this.adapter.registerAgent(agentId, domain);
+    return true;
+  }
   /** List all active domain teams. */
   listDomainTeams() {
     return Array.from(this.teams.values(), (t50) => this.toSnapshot(t50));
@@ -127337,6 +127416,22 @@ var QueenCoordinator = class {
     });
     if (result.success) {
       this.domainLastActivity.set(domain, /* @__PURE__ */ new Date());
+      if (this.domainTeamManager) {
+        const existingTeam = this.domainTeamManager.getDomainTeam(domain);
+        if (!existingTeam) {
+          try {
+            this.domainTeamManager.createDomainTeam(domain, result.value);
+          } catch {
+            if (!this.domainTeamManager.addTeammate(domain, result.value)) {
+              console.warn(`[QueenCoordinator] Agent ${result.value} could not join ${domain} team (full or max teams reached)`);
+            }
+          }
+        } else {
+          if (!this.domainTeamManager.addTeammate(domain, result.value)) {
+            console.warn(`[QueenCoordinator] Agent ${result.value} could not join ${domain} team (full)`);
+          }
+        }
+      }
       await this.publishEvent("AgentSpawned", { agentId: result.value, domain, type, capabilities });
     }
     return result;
@@ -127444,6 +127539,9 @@ var QueenCoordinator = class {
   getDomainTeamManager() {
     return this.domainTeamManager;
   }
+  getAgentTeamsAdapter() {
+    return this.agentTeamsAdapter;
+  }
   getTierSelector() {
     return this.tierSelector;
   }
@@ -137973,9 +138071,84 @@ 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;
   const branches = (sourceCode.match(/if|switch|for|while|catch/g) || []).length;
@@ -138280,6 +138453,14 @@ function createDomainHandler(config) {
         domain,
         result.duration
       );
+      captureExecutionLearning(
+        `qe-${domain}`,
+        taskType,
+        params,
+        data,
+        result.duration
+      ).catch(() => {
+      });
       return {
         success: true,
         data: mappedResult
@@ -153949,7 +154130,9 @@ var state = {
   router: null,
   workflowOrchestrator: null,
   initialized: false,
-  initTime: null
+  initTime: null,
+  topology: "hierarchical",
+  agentLevels: /* @__PURE__ */ new Map()
 };
 function getFleetState() {
   return state;
@@ -153957,6 +154140,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) {
@@ -154021,11 +154221,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,
@@ -154076,6 +154278,22 @@ async function handleFleetStatus(params) {
       }
       result.domains = domains;
     }
+    const teamManager = state.queen.getDomainTeamManager?.();
+    if (teamManager) {
+      const teams = teamManager.listDomainTeams();
+      let totalAgentsInTeams = 0;
+      let healthyCount = 0;
+      for (const team of teams) {
+        totalAgentsInTeams += 1 + team.teammateIds.length;
+        const health2 = teamManager.getTeamHealth(team.domain);
+        if (health2?.healthy) healthyCount++;
+      }
+      result.teams = {
+        active: teams.length,
+        totalAgentsInTeams,
+        healthyCount
+      };
+    }
     if (params.includeMetrics) {
       result.metrics = {
         tasksReceived: metrics.tasksReceived,
@@ -154185,6 +154403,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");
@@ -155458,14 +155678,31 @@ 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 teamLookup = /* @__PURE__ */ new Map();
+    const teamManager = queen.getDomainTeamManager?.();
+    if (teamManager) {
+      const teams = teamManager.listDomainTeams();
+      for (const team of teams) {
+        const teamSize = 1 + team.teammateIds.length;
+        teamLookup.set(team.leadAgentId, { domain: team.domain, role: "lead", teamSize });
+        for (const tid of team.teammateIds) {
+          teamLookup.set(tid, { domain: team.domain, role: "teammate", teamSize });
+        }
+      }
+    }
+    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,
+        team: teamLookup.get(agent.id)
+      };
+    });
     return {
       success: true,
       data: result
@@ -155499,6 +155736,7 @@ async function handleAgentSpawn(params) {
     }
     const balancer = getLoadBalancer();
     balancer.registerAgent(result.value);
+    const level = assignAgentLevel(result.value, params.domain);
     return {
       success: true,
       data: {
@@ -155506,7 +155744,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) {
@@ -156018,6 +156257,249 @@ var handleCodeIndex2 = createWrappedHandler(
   "qe-code-indexer"
 );
 
+// src/mcp/handlers/team-handlers.ts
+init_error_utils();
+var VALID_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "task-assignment",
+  "finding",
+  "challenge",
+  "consensus",
+  "alert",
+  "heartbeat",
+  "idle-notification",
+  "completion-report"
+]);
+function validateMessageType(type) {
+  return VALID_MESSAGE_TYPES.has(type);
+}
+async function handleTeamList(params) {
+  if (!isFleetInitialized()) {
+    return {
+      success: false,
+      error: "Fleet not initialized. Call fleet_init first."
+    };
+  }
+  const { queen } = getFleetState();
+  try {
+    const manager = queen.getDomainTeamManager();
+    if (!manager) {
+      return {
+        success: false,
+        error: "Agent Teams not initialized. Teams are created automatically when agents are spawned."
+      };
+    }
+    let teams = manager.listDomainTeams();
+    if (params.domain) {
+      teams = teams.filter((t50) => t50.domain === params.domain);
+    }
+    const result = teams.map((t50) => ({
+      domain: t50.domain,
+      leadAgentId: t50.leadAgentId,
+      teammateIds: t50.teammateIds,
+      teamSize: 1 + t50.teammateIds.length,
+      taskCount: t50.taskCount,
+      completedCount: t50.completedCount,
+      createdAt: new Date(t50.createdAt).toISOString()
+    }));
+    return {
+      success: true,
+      data: result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to list teams: ${toErrorMessage(error)}`
+    };
+  }
+}
+async function handleTeamHealth(params) {
+  if (!isFleetInitialized()) {
+    return {
+      success: false,
+      error: "Fleet not initialized. Call fleet_init first."
+    };
+  }
+  const { queen } = getFleetState();
+  try {
+    const manager = queen.getDomainTeamManager();
+    if (!manager) {
+      return {
+        success: false,
+        error: "Agent Teams not initialized."
+      };
+    }
+    const health = manager.getTeamHealth(params.domain);
+    if (!health) {
+      return {
+        success: false,
+        error: `No team found for domain: ${params.domain}`
+      };
+    }
+    return {
+      success: true,
+      data: health
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to get team health: ${toErrorMessage(error)}`
+    };
+  }
+}
+async function handleTeamMessage(params) {
+  if (!isFleetInitialized()) {
+    return {
+      success: false,
+      error: "Fleet not initialized. Call fleet_init first."
+    };
+  }
+  const { queen } = getFleetState();
+  try {
+    if (!validateMessageType(params.type)) {
+      return {
+        success: false,
+        error: `Invalid message type: '${params.type}'. Valid types: ${[...VALID_MESSAGE_TYPES].join(", ")}`
+      };
+    }
+    const adapter = queen.getAgentTeamsAdapter();
+    if (!adapter) {
+      return {
+        success: false,
+        error: "Agent Teams not initialized."
+      };
+    }
+    const message = adapter.sendMessage(
+      params.from,
+      params.to,
+      params.type,
+      params.payload,
+      params.domain ? { domain: params.domain } : void 0
+    );
+    return {
+      success: true,
+      data: {
+        messageId: message.id,
+        from: message.from,
+        to: message.to,
+        type: message.type,
+        timestamp: new Date(message.timestamp).toISOString()
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to send message: ${toErrorMessage(error)}`
+    };
+  }
+}
+async function handleTeamBroadcast(params) {
+  if (!isFleetInitialized()) {
+    return {
+      success: false,
+      error: "Fleet not initialized. Call fleet_init first."
+    };
+  }
+  const { queen } = getFleetState();
+  try {
+    if (!validateMessageType(params.type)) {
+      return {
+        success: false,
+        error: `Invalid message type: '${params.type}'. Valid types: ${[...VALID_MESSAGE_TYPES].join(", ")}`
+      };
+    }
+    const manager = queen.getDomainTeamManager();
+    if (!manager) {
+      return {
+        success: false,
+        error: "Agent Teams not initialized."
+      };
+    }
+    const team = manager.getDomainTeam(params.domain);
+    if (!team) {
+      return {
+        success: false,
+        error: `No team found for domain: ${params.domain}`
+      };
+    }
+    manager.broadcastToDomain(
+      params.domain,
+      params.type,
+      params.payload
+    );
+    const recipientCount = 1 + team.teammateIds.length;
+    return {
+      success: true,
+      data: {
+        domain: params.domain,
+        type: params.type,
+        recipientCount,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to broadcast: ${toErrorMessage(error)}`
+    };
+  }
+}
+async function handleTeamScale(params) {
+  if (!isFleetInitialized()) {
+    return {
+      success: false,
+      error: "Fleet not initialized. Call fleet_init first."
+    };
+  }
+  const { queen } = getFleetState();
+  try {
+    const manager = queen.getDomainTeamManager();
+    if (!manager) {
+      return {
+        success: false,
+        error: "Agent Teams not initialized."
+      };
+    }
+    const result = manager.scaleTeam(params.domain, params.targetSize);
+    return {
+      success: true,
+      data: result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to scale team: ${toErrorMessage(error)}`
+    };
+  }
+}
+async function handleTeamRebalance(_params) {
+  if (!isFleetInitialized()) {
+    return {
+      success: false,
+      error: "Fleet not initialized. Call fleet_init first."
+    };
+  }
+  const { queen } = getFleetState();
+  try {
+    const manager = queen.getDomainTeamManager();
+    if (!manager) {
+      return {
+        success: false,
+        error: "Agent Teams not initialized."
+      };
+    }
+    const result = manager.rebalance();
+    return {
+      success: true,
+      data: result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to rebalance teams: ${toErrorMessage(error)}`
+    };
+  }
+}
+
 // src/mcp/handlers/memory-handlers.ts
 init_error_utils();
 async function handleMemoryStore(params) {
@@ -156066,6 +156548,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)
@@ -156129,6 +156622,9 @@ async function handleMemoryRetrieve(params) {
     };
   }
 }
+function isNaturalLanguageQuery(pattern) {
+  return pattern.includes(" ") && !pattern.includes("*") && !pattern.includes("?");
+}
 async function handleMemoryQuery(params) {
   if (!isFleetInitialized()) {
     return {
@@ -156141,6 +156637,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);
@@ -156157,7 +156681,8 @@ async function handleMemoryQuery(params) {
       data: {
         entries,
         total: keys.length,
-        hasMore: offset + limit < keys.length
+        hasMore: offset + limit < keys.length,
+        searchType: "pattern"
       }
     };
   } catch (error) {
@@ -156167,6 +156692,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 {
@@ -156896,6 +157441,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",
@@ -156938,9 +157486,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
    */
@@ -157269,6 +157861,77 @@ var MCPProtocolServer = class {
       },
       handler: (params) => handleAgentStatus(params)
     });
+    this.registerTool({
+      definition: {
+        name: "team_list",
+        description: "List all domain teams",
+        category: "agent",
+        parameters: [
+          { name: "domain", type: "string", description: "Filter by domain" }
+        ]
+      },
+      handler: (params) => handleTeamList(params)
+    });
+    this.registerTool({
+      definition: {
+        name: "team_health",
+        description: "Get team health for a domain",
+        category: "agent",
+        parameters: [
+          { name: "domain", type: "string", description: "Domain to check", required: true }
+        ]
+      },
+      handler: (params) => handleTeamHealth(params)
+    });
+    this.registerTool({
+      definition: {
+        name: "team_message",
+        description: "Send message between agents",
+        category: "agent",
+        parameters: [
+          { name: "from", type: "string", description: "Sender agent ID", required: true },
+          { name: "to", type: "string", description: "Recipient agent ID", required: true },
+          { name: "type", type: "string", description: "Message type", required: true, enum: ["task-assignment", "finding", "challenge", "consensus", "alert", "heartbeat", "idle-notification", "completion-report"] },
+          { name: "payload", type: "object", description: "Message payload", required: true },
+          { name: "domain", type: "string", description: "Override domain context" }
+        ]
+      },
+      handler: (params) => handleTeamMessage(params)
+    });
+    this.registerTool({
+      definition: {
+        name: "team_broadcast",
+        description: "Broadcast to all agents in a domain",
+        category: "agent",
+        parameters: [
+          { name: "domain", type: "string", description: "Domain to broadcast to", required: true },
+          { name: "type", type: "string", description: "Message type", required: true, enum: ["task-assignment", "finding", "challenge", "consensus", "alert", "heartbeat", "idle-notification", "completion-report"] },
+          { name: "payload", type: "object", description: "Message payload", required: true }
+        ]
+      },
+      handler: (params) => handleTeamBroadcast(params)
+    });
+    this.registerTool({
+      definition: {
+        name: "team_scale",
+        description: "Scale a domain team up/down",
+        category: "agent",
+        parameters: [
+          { name: "domain", type: "string", description: "Domain to scale", required: true },
+          { name: "targetSize", type: "number", description: "Target team size", required: true }
+        ]
+      },
+      handler: (params) => handleTeamScale(params)
+    });
+    this.registerTool({
+      definition: {
+        name: "team_rebalance",
+        description: "Rebalance agents across teams",
+        category: "agent",
+        parameters: []
+      },
+      handler: (params) => handleTeamRebalance(params)
+    });
     this.registerTool({
       definition: {
         name: "test_generate_enhanced",
@@ -157426,11 +158089,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)