agentic-qe 3.7.9 → 3.7.11

package/dist/mcp/bundle.js

@@ -5956,12 +5956,20 @@ var init_sql_safety = __esm({
       "coverage_sessions",
       // Sync tables
       "patterns",
-      // Hypergraph tables
+      // Hypergraph tables (actual table names from migration 20260120)
+      "hypergraph_nodes",
+      "hypergraph_edges",
+      // Legacy allowlist aliases (hypergraph-schema.ts compat)
       "hypergraph_vertices",
       "hypergraph_hyperedges",
       "hypergraph_edge_vertices",
       "hypergraph_vertex_properties",
-      "hypergraph_edge_properties"
+      "hypergraph_edge_properties",
+      // Learning experience tables
+      "captured_experiences",
+      "experience_applications",
+      // Audit trail
+      "witness_chain"
     ]);
   }
 });
@@ -24927,10 +24935,11 @@ function countBraceDelta(line) {
   }
   return delta;
 }
-var PythonParser, JavaParser, CSharpParser, GoParser, RustParser, SwiftParser, KotlinParser, DartParser, TreeSitterParserRegistry, treeSitterRegistry;
+var MAX_REGEX_LINE_LEN, PythonParser, JavaParser, CSharpParser, GoParser, RustParser, SwiftParser, KotlinParser, DartParser, TreeSitterParserRegistry, treeSitterRegistry;
 var init_multi_language_parser = __esm({
   "src/shared/parsers/multi-language-parser.ts"() {
     "use strict";
+    MAX_REGEX_LINE_LEN = 1e3;
     PythonParser = class {
       language = "python";
       supportedExtensions = [".py"];
@@ -24947,8 +24956,9 @@ var init_multi_language_parser = __esm({
         const functions = [];
         const rawLines = content.split("\n");
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const funcRegex = /^(\s*)(async\s+)?def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*([^:]+))?\s*:/;
+        const funcRegex = /^(\s*)(async\s+)?def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*([^:]*\S))?\s*:/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
+          if (logicalLines[i58].length > MAX_REGEX_LINE_LEN) continue;
           const match = logicalLines[i58].match(funcRegex);
           if (match) {
             const indent = match[1].length;
@@ -25034,9 +25044,10 @@ var init_multi_language_parser = __esm({
         const imports = [];
         const lines = content.split("\n");
         for (const line of lines) {
+          if (line.length > MAX_REGEX_LINE_LEN) continue;
           const fromMatch = line.match(/^\s*from\s+(\S+)\s+import\s+(.+)/);
           if (fromMatch) {
-            const names = fromMatch[2].split(",").map((n61) => n61.trim().split(/\s+as\s+/)[0]);
+            const names = fromMatch[2].split(",").map((n61) => n61.trim().split(" as ")[0]);
             imports.push({
               module: fromMatch[1],
               namedImports: names,
@@ -25085,10 +25096,11 @@ var init_multi_language_parser = __esm({
         const functions = [];
         const rawLines = content.split("\n");
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const methodRegex = /^\s*(public|private|protected)?\s*(static)?\s*(async)?\s*(?:<\S+>\s+)?([\w<>,.\s[\]?]+)\s+(\w+)\s*\(([^)]*)\)/;
+        const methodRegex = /^\s*(public|private|protected)?\s*(static)?\s*(async)?\s*(?:<\S+>\s+)?([\w<>,.[\]?]+(?:\s+[\w<>,.[\]?]+)*)\s+(\w+)\s*\(([^)]*)\)/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
           const line = logicalLines[i58];
           if (line.includes(" class ") || line.includes(" interface ")) continue;
+          if (line.length > MAX_REGEX_LINE_LEN) continue;
           const match = line.match(methodRegex);
           if (match) {
             const visibility = match[1] || "default";
@@ -25125,8 +25137,9 @@ var init_multi_language_parser = __esm({
         const classes = [];
         const rawLines = content.split("\n");
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const classRegex = /^\s*(public|private|protected)?\s*(abstract)?\s*class\s+(\w+)(?:<[^{]*>)?(?:\s+extends\s+(\w+))?(?:\s+implements\s+([^{]+))?\s*\{?/;
+        const classRegex = /^\s*(public|private|protected)?\s*(abstract)?\s*class\s+(\w+)(?:<[^{]*>)?(?:\s+extends\s+(\w+))?(?:\s+implements\s+([^{\s]+(?:\s+[^{\s]+)*))?\s*\{?/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
+          if (logicalLines[i58].length > MAX_REGEX_LINE_LEN) continue;
           const match = logicalLines[i58].match(classRegex);
           if (match) {
             const name = match[3];
@@ -25153,7 +25166,8 @@ var init_multi_language_parser = __esm({
         const imports = [];
         const lines = content.split("\n");
         for (const line of lines) {
-          const match = line.match(/^\s*import\s+(static\s+)?([^;]+);/);
+          if (line.length > MAX_REGEX_LINE_LEN) continue;
+          const match = line.match(/^\s*import +(static +)?(\S[^;]*);/);
           if (match) {
             const module = match[2].trim();
             const parts = module.split(".");
@@ -25194,10 +25208,11 @@ var init_multi_language_parser = __esm({
         const functions = [];
         const rawLines = content.split("\n");
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const methodRegex = /^\s*(public|private|protected|internal)?\s*(static)?\s*(async)?\s*([\w<>,.\s[\]?]+)\s+(\w+)\s*\(([^)]*)\)/;
+        const methodRegex = /^\s*(public|private|protected|internal)?\s*(static)?\s*(async)?\s*([\w<>,.[\]?]+(?:\s+[\w<>,.[\]?]+)*)\s+(\w+)\s*\(([^)]*)\)/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
           const line = logicalLines[i58];
           if (line.includes(" class ") || line.includes(" interface ") || line.includes(" namespace ")) continue;
+          if (line.length > MAX_REGEX_LINE_LEN) continue;
           const match = line.match(methodRegex);
           if (match) {
             const visibility = match[1] || "private";
@@ -25235,8 +25250,9 @@ var init_multi_language_parser = __esm({
         const classes = [];
         const rawLines = content.split("\n");
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const classRegex = /^\s*(public|private|protected|internal)?\s*(abstract|sealed|static|partial)?\s*class\s+(\w+)(?:<[^{]*>)?(?:\s*:\s*([^{]+))?\s*\{?/;
+        const classRegex = /^\s*(public|private|protected|internal)?\s*(abstract|sealed|static|partial)?\s*class\s+(\w+)(?:<[^{]*>)?(?:\s*:\s*([^{\s]+(?:\s+[^{\s]+)*))?\s*\{?/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
+          if (logicalLines[i58].length > MAX_REGEX_LINE_LEN) continue;
           const match = logicalLines[i58].match(classRegex);
           if (match) {
             const name = match[3];
@@ -25262,7 +25278,8 @@ var init_multi_language_parser = __esm({
         const imports = [];
         const lines = content.split("\n");
         for (const line of lines) {
-          const match = line.match(/^\s*using\s+(static\s+)?([^;]+);/);
+          if (line.length > MAX_REGEX_LINE_LEN) continue;
+          const match = line.match(/^\s*using +(static +)?(\S[^;]*);/);
           if (match) {
             imports.push({
               module: match[2].trim(),
@@ -25308,6 +25325,10 @@ var init_multi_language_parser = __esm({
         let braceDepth = 0;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
           const line = logicalLines[i58];
+          if (line.length > MAX_REGEX_LINE_LEN) {
+            braceDepth += (line.match(/\{/g)?.length ?? 0) - (line.match(/\}/g)?.length ?? 0);
+            continue;
+          }
           const match = line.match(funcRegex);
           if (match && braceDepth === 0) {
             const name = match[3];
@@ -25415,7 +25436,7 @@ var init_multi_language_parser = __esm({
         const functions = [];
         const rawLines = content.split("\n");
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const fnRegex = /^\s*(pub(?:\(crate\))?\s+)?(async\s+)?fn\s+(\w+)(?:<[^{]*>)?\s*\(([^)]*)\)(?:\s*->\s*([^{]+))?\s*(?:where\s+[^{]*)?\s*\{?/;
+        const fnRegex = /^\s*(pub(?:\(crate\))? +)?(async +)?fn\s+(\w+)(?:<[^{]*>)?\s*\(([^)]*)\)(?:\s*->\s*([^{\s]+(?:\s+[^{\s]+)*))?\s*(?:where\s+[^{\s]+(?:\s+[^{\s]+)*)?\s*\{?/;
         let braceDepth = 0;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
           const line = logicalLines[i58];
@@ -25475,7 +25496,8 @@ var init_multi_language_parser = __esm({
         const imports = [];
         const lines = content.split("\n");
         for (const line of lines) {
-          const match = line.match(/^\s*use\s+([^;]+);/);
+          if (line.length > MAX_REGEX_LINE_LEN) continue;
+          const match = line.match(/^\s*use +(\S[^;]*);/);
           if (match) {
             imports.push({
               module: match[1].trim(),
@@ -25520,8 +25542,9 @@ var init_multi_language_parser = __esm({
       extractFunctions(content) {
         const functions = [];
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const funcRegex = /^\s*(public|private|internal|open)?\s*(static)?\s*func\s+(\w+)(?:<[^{]*>)?\s*\(([^)]*)\)(?:\s*(async))?\s*(?:throws\s+)?(?:->\s*([^{]+))?\s*\{?/;
+        const funcRegex = /^\s*(public|private|internal|open)?\s*(static)?\s*func\s+(\w+)(?:<[^{]*>)?\s*\(([^)]*)\)(?:\s*(async))?\s*(?:throws +)?(?:->\s*([^{\s]+(?:\s+[^{\s]+)*))?\s*\{?/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
+          if (logicalLines[i58].length > MAX_REGEX_LINE_LEN) continue;
           const match = logicalLines[i58].match(funcRegex);
           if (match) {
             const visibility = match[1] || "internal";
@@ -25548,8 +25571,9 @@ var init_multi_language_parser = __esm({
       extractClasses(content) {
         const classes = [];
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const classRegex = /^\s*(public|private|internal|open)?\s*(class|struct|protocol)\s+(\w+)(?:<[^{]*>)?(?:\s*:\s*([^{]+))?\s*\{?/;
+        const classRegex = /^\s*(public|private|internal|open)?\s*(class|struct|protocol)\s+(\w+)(?:<[^{]*>)?(?:\s*:\s*([^{\s]+(?:\s+[^{\s]+)*))?\s*\{?/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
+          if (logicalLines[i58].length > MAX_REGEX_LINE_LEN) continue;
           const match = logicalLines[i58].match(classRegex);
           if (match) {
             const name = match[3];
@@ -25615,10 +25639,14 @@ var init_multi_language_parser = __esm({
         const functions = [];
         const rawLines = content.split("\n");
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const funcRegex = /^\s*(public|private|protected|internal)?\s*(suspend)?\s*fun\s+(?:<[^{]*>\s+)?(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=]+))?\s*/;
+        const funcRegex = /^\s*(public|private|protected|internal)?\s*(suspend)?\s*fun\s+(?:<[^{]*> +)?(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=\s]+(?:\s+[^{=\s]+)*))?\s*/;
         let braceDepth = 0;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
           const line = logicalLines[i58];
+          if (line.length > MAX_REGEX_LINE_LEN) {
+            braceDepth += (line.match(/\{/g)?.length ?? 0) - (line.match(/\}/g)?.length ?? 0);
+            continue;
+          }
           const match = line.match(funcRegex);
           if (match && braceDepth <= 1) {
             const visibility = match[1] || "public";
@@ -25657,8 +25685,9 @@ var init_multi_language_parser = __esm({
         const classes = [];
         const rawLines = content.split("\n");
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const classRegex = /^\s*(public|private|protected|internal)?\s*(data|sealed|abstract|open)?\s*class\s+(\w+)(?:<[^{]*>)?(?:\s*(?:\([^)]*\))?\s*:\s*([^{]+))?\s*\{?/;
+        const classRegex = /^\s*(public|private|protected|internal)?\s*(data|sealed|abstract|open)?\s*class\s+(\w+)(?:<[^{]*>)?(?:\s*(?:\([^)]*\))?\s*:\s*([^{\s]+(?:\s+[^{\s]+)*))?\s*\{?/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
+          if (logicalLines[i58].length > MAX_REGEX_LINE_LEN) continue;
           const match = logicalLines[i58].match(classRegex);
           if (match) {
             const name = match[3];
@@ -25731,10 +25760,11 @@ var init_multi_language_parser = __esm({
       extractFunctions(content) {
         const functions = [];
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const funcRegex = /^\s*([\w<>,.\s?]+)\s+(\w+)\s*\(([^)]*)\)(?:\s*(async))?\s*\{/;
+        const funcRegex = /^\s*([\w<>,.?]+(?:\s+[\w<>,.?]+)*)\s+(\w+)\s*\(([^)]*)\)(?:\s*(async))?\s*\{/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
           const line = logicalLines[i58];
           if (line.includes(" class ")) continue;
+          if (line.length > MAX_REGEX_LINE_LEN) continue;
           const match = line.match(funcRegex);
           if (match) {
             const returnTypeRaw = match[1].trim();
@@ -25768,8 +25798,9 @@ var init_multi_language_parser = __esm({
       extractClasses(content) {
         const classes = [];
         const { logicalLines, lineMap } = joinMultiLineSignatures(content);
-        const classRegex = /^\s*(abstract\s+)?class\s+(\w+)(?:<[^{]*>)?(?:\s+extends\s+(\w+))?(?:\s+(?:with|implements)\s+([^{]+))?\s*\{/;
+        const classRegex = /^\s*(abstract +)?class\s+(\w+)(?:<[^{]*>)?(?:\s+extends\s+(\w+))?(?:\s+(?:with|implements)\s+([^{\s]+(?:\s+[^{\s]+)*))?\s*\{/;
         for (let i58 = 0; i58 < logicalLines.length; i58++) {
+          if (logicalLines[i58].length > MAX_REGEX_LINE_LEN) continue;
           const match = logicalLines[i58].match(classRegex);
           if (match) {
             const name = match[2];
@@ -25938,7 +25969,7 @@ function detectFrameworkFromProject(language, projectRoot) {
 }
 function findFiles(dir, pattern) {
   try {
-    const ext = pattern.replace("*", "");
+    const ext = pattern.replace(/\*/g, "");
     return fs2.readdirSync(dir).filter((f74) => f74.endsWith(ext)).map((f74) => path2.join(dir, f74));
   } catch {
     return [];
@@ -33208,13 +33239,30 @@ var init_continue_gate_integration = __esm({
       /**
        * Initialize the ContinueGate integration
        *
-       * Note: The @claude-flow/guidance ContinueGate has a different API
-       * designed for step-level evaluation with coherence/uncertainty scores.
-       * Our local implementation is better suited for AQE agent coordination
-       * which tracks action-level loop detection and rework ratios.
+       * Attempts to load @claude-flow/guidance ContinueGate for step-level
+       * evaluation with coherence/uncertainty scoring. Falls back to local
+       * loop detection if the guidance package is unavailable.
        */
       async initialize() {
         if (this.initialized) return;
+        try {
+          const modulePath = "@claude-flow/guidance/continue-gate";
+          const mod = await import(
+            /* @vite-ignore */
+            modulePath
+          );
+          if (mod && typeof mod.createContinueGate === "function") {
+            const flags = governanceFlags.getFlags().continueGate;
+            this.guidanceContinueGate = mod.createContinueGate({
+              maxConsecutiveSteps: flags.maxConsecutiveRetries * 10,
+              maxReworkRatio: flags.reworkRatioThreshold,
+              checkpointIntervalSteps: 25
+            });
+            console.log("[ContinueGateIntegration] Guidance ContinueGate loaded");
+          }
+        } catch {
+          this.guidanceContinueGate = null;
+        }
         try {
           this.db = getUnifiedMemory();
           if (!this.db.isInitialized()) await this.db.initialize();
@@ -33295,7 +33343,35 @@ var init_continue_gate_integration = __esm({
             escalate: false
           };
         }
-        return this.localEvaluation(agentId, history, flags);
+        const localDecision = this.localEvaluation(agentId, history, flags);
+        if (this.guidanceContinueGate && localDecision.shouldContinue && !localDecision.reason) {
+          try {
+            const reworkRatio = this.calculateReworkRatio(history.slice(-10));
+            const stepContext = {
+              stepNumber: history.length,
+              totalToolCalls: history.length,
+              reworkCount: history.filter((a37) => !a37.success).length,
+              coherenceScore: 1 - reworkRatio,
+              uncertaintyScore: reworkRatio,
+              elapsedMs: history.length > 0 ? Date.now() - history[0].timestamp : 0,
+              lastCheckpointStep: 0,
+              totalTokensUsed: history.length * 500,
+              // Estimate ~500 tokens per action
+              budgetRemaining: {
+                tokens: Math.max(0, flags.maxConsecutiveRetries * 10 * 500 - history.length * 500),
+                toolCalls: Math.max(0, flags.maxConsecutiveRetries * 10 - history.length),
+                timeMs: Math.max(0, flags.idleTimeoutMs - (history.length > 0 ? Date.now() - history[0].timestamp : 0))
+              },
+              recentDecisions: []
+            };
+            const decision = this.guidanceContinueGate.evaluateWithHistory(stepContext);
+            if (decision.decision !== "continue") {
+              return this.mapGuidanceDecision(decision, agentId);
+            }
+          } catch {
+          }
+        }
+        return localDecision;
       }
       /**
        * Local loop detection implementation
@@ -33372,21 +33448,25 @@ var init_continue_gate_integration = __esm({
         return failedCount / actions.length;
       }
       /**
-       * Map guidance package decision to our format
+       * Map guidance ContinueDecision to our ContinueGateDecision format.
+       *
+       * ContinueDecision has: { decision, reasons, metrics, recommendedAction }
+       * We map to: { shouldContinue, reason, throttleMs, escalate, reworkRatio }
        */
       mapGuidanceDecision(decision, agentId) {
         const flags = governanceFlags.getFlags().continueGate;
-        if (!decision.shouldContinue && flags.throttleOnExceed) {
-          const throttleMs = decision.throttleMs || 5e3;
+        const shouldContinue = decision.decision === "continue" || decision.decision === "checkpoint";
+        const reason = decision.reasons.length > 0 ? decision.reasons.join("; ") : void 0;
+        if (!shouldContinue && flags.throttleOnExceed) {
+          const throttleMs = decision.decision === "stop" ? 3e4 : decision.decision === "pause" ? 15e3 : 5e3;
           this.throttledAgents.set(agentId, Date.now() + throttleMs);
         }
         return {
-          shouldContinue: decision.shouldContinue ?? true,
-          reason: decision.reason,
-          throttleMs: decision.throttleMs,
-          escalate: decision.escalate,
-          reworkRatio: decision.reworkRatio,
-          consecutiveCount: decision.consecutiveCount
+          shouldContinue,
+          reason,
+          throttleMs: decision.decision === "throttle" ? 5e3 : decision.decision === "pause" ? 15e3 : decision.decision === "stop" ? 3e4 : void 0,
+          escalate: decision.decision === "stop" || decision.decision === "pause",
+          reworkRatio: decision.metrics.reworkRatio
         };
       }
       /**
@@ -33464,12 +33544,27 @@ var init_memory_write_gate_integration = __esm({
       /**
        * Initialize the MemoryWriteGate integration
        *
-       * Note: The @claude-flow/guidance MemoryWriteGate has a different API.
-       * Our local implementation provides contradiction detection and temporal decay
+       * Attempts to load @claude-flow/guidance MemoryWriteGate for authority-scoped
+       * writes and rate limiting. Falls back to local contradiction detection
        * optimized for AQE's ReasoningBank pattern storage.
        */
       async initialize() {
         if (this.initialized) return;
+        try {
+          const modulePath = "@claude-flow/guidance/memory-gate";
+          const mod = await import(
+            /* @vite-ignore */
+            modulePath
+          );
+          if (mod && typeof mod.createMemoryWriteGate === "function") {
+            this.guidanceMemoryGate = mod.createMemoryWriteGate({
+              enableContradictionTracking: true
+            });
+            console.log("[MemoryWriteGateIntegration] Guidance MemoryWriteGate loaded");
+          }
+        } catch {
+          this.guidanceMemoryGate = null;
+        }
         this.initialized = true;
       }
       /**
@@ -33483,7 +33578,31 @@ var init_memory_write_gate_integration = __esm({
         const flags = governanceFlags.getFlags().memoryWriteGate;
         pattern.timestamp = pattern.timestamp || Date.now();
         pattern.useCount = pattern.useCount || 0;
-        return this.localEvaluation(pattern, flags);
+        const localDecision = this.localEvaluation(pattern, flags);
+        if (this.guidanceMemoryGate && localDecision.allowed && !localDecision.reason) {
+          try {
+            const authority = {
+              agentId: pattern.agentId || "unknown",
+              role: "worker",
+              namespaces: [pattern.domain],
+              maxWritesPerMinute: 60,
+              canDelete: false,
+              canOverwrite: true,
+              trustLevel: 0.7
+            };
+            const decision = this.guidanceMemoryGate.evaluateWrite(
+              authority,
+              pattern.key,
+              pattern.domain,
+              pattern.value
+            );
+            if (!decision.allowed) {
+              return this.mapGuidanceDecision(decision);
+            }
+          } catch {
+          }
+        }
+        return localDecision;
       }
       /**
        * Local contradiction detection implementation
@@ -33619,15 +33738,17 @@ var init_memory_write_gate_integration = __esm({
         return [...keys].map((key) => this.patternIndex.get(key)).filter((p74) => p74 !== void 0);
       }
       /**
-       * Map guidance package decision to our format
+       * Map guidance WriteDecision to our MemoryWriteGateDecision format.
+       *
+       * WriteDecision has: { allowed, reason, contradictions, authorityCheck, rateCheck, overwriteCheck }
+       * We map to: { allowed, reason, conflictingPatterns, suggestedResolution, requiresManualReview }
        */
       mapGuidanceDecision(decision) {
         return {
-          allowed: decision.allowed ?? true,
+          allowed: decision.allowed,
           reason: decision.reason,
-          conflictingPatterns: decision.conflictingPatterns,
-          suggestedResolution: decision.suggestedResolution,
-          requiresManualReview: decision.requiresManualReview
+          requiresManualReview: !decision.authorityCheck.passed || decision.contradictions.length > 0,
+          suggestedResolution: decision.contradictions.length > 0 ? "reject" : void 0
         };
       }
       /**
@@ -33744,12 +33865,38 @@ var init_trust_accumulator_integration = __esm({
       agentMetrics = /* @__PURE__ */ new Map();
       taskHistory = /* @__PURE__ */ new Map();
       tierThresholds = { ...DEFAULT_TIER_THRESHOLDS };
+      guidanceTrustSystem = null;
       initialized = false;
       /**
        * Initialize the TrustAccumulator integration
+       *
+       * Attempts to load @claude-flow/guidance TrustSystem for gate-outcome-based
+       * trust accumulation with exponential decay. Falls back to local
+       * implementation optimized for AQE agent routing.
        */
       async initialize() {
         if (this.initialized) return;
+        try {
+          const modulePath = "@claude-flow/guidance/trust";
+          const mod = await import(
+            /* @vite-ignore */
+            modulePath
+          );
+          if (mod && typeof mod.createTrustSystem === "function") {
+            this.guidanceTrustSystem = mod.createTrustSystem({
+              initialTrust: 0.7,
+              allowDelta: 0.02,
+              denyDelta: 0.05,
+              warnDelta: 0.01,
+              decayRate: 0.05,
+              decayIntervalMs: 3e5
+              // 5 minutes
+            });
+            console.log("[TrustAccumulatorIntegration] Guidance TrustSystem loaded");
+          }
+        } catch {
+          this.guidanceTrustSystem = null;
+        }
         this.initialized = true;
       }
       /**
@@ -33773,6 +33920,13 @@ var init_trust_accumulator_integration = __esm({
         }
         this.taskHistory.set(agentId, history);
         this.updateAgentMetrics(agentId, outcome);
+        if (this.guidanceTrustSystem) {
+          try {
+            const gateOutcome = success ? "allow" : "deny";
+            this.guidanceTrustSystem.recordOutcome(agentId, gateOutcome, `Task ${taskType}: ${success ? "success" : "failure"}`);
+          } catch {
+          }
+        }
         const flags = governanceFlags.getFlags().trustAccumulator;
         if (flags.autoTierAdjustment) {
           this.adjustTier(agentId);
@@ -34141,14 +34295,32 @@ var init_deterministic_gateway_integration = __esm({
       requestHistory = /* @__PURE__ */ new Map();
       resultCache = /* @__PURE__ */ new Map();
       toolSchemas = /* @__PURE__ */ new Map();
+      guidanceGateway = null;
       initialized = false;
       /**
        * Initialize the DeterministicGateway integration
+       *
+       * Attempts to load @claude-flow/guidance DeterministicToolGateway for
+       * idempotency keys, schema validation, and budget metering. Falls back
+       * to local implementation.
        */
       async initialize() {
         if (this.initialized) return;
         this.registerDefaultSchemas();
         this.initialized = true;
+        try {
+          const modulePath = "@claude-flow/guidance/gateway";
+          const mod = await import(
+            /* @vite-ignore */
+            modulePath
+          );
+          if (mod && typeof mod.createToolGateway === "function") {
+            this.guidanceGateway = mod.createToolGateway();
+            console.log("[DeterministicGateway] Guidance ToolGateway loaded");
+          }
+        } catch {
+          this.guidanceGateway = null;
+        }
       }
       /**
        * Register default schemas for AQE tools
@@ -34273,6 +34445,23 @@ var init_deterministic_gateway_integration = __esm({
             };
           }
         }
+        if (this.guidanceGateway && typeof params === "object" && params !== null) {
+          try {
+            const guidanceDecision = this.guidanceGateway.evaluate(
+              toolName,
+              params
+            );
+            if (!guidanceDecision.allowed) {
+              this.logEvent(toolName, "guidance_denied", key);
+              return {
+                allowed: !isStrictMode(),
+                reason: `Guidance gateway: ${guidanceDecision.reason}`,
+                idempotencyKey: key
+              };
+            }
+          } catch {
+          }
+        }
         return {
           allowed: true,
           idempotencyKey: key
@@ -34582,6 +34771,7 @@ var init_evolution_pipeline_integration = __esm({
       rules = /* @__PURE__ */ new Map();
       variantTests = /* @__PURE__ */ new Map();
       taskOutcomes = /* @__PURE__ */ new Map();
+      guidanceEvolution = null;
       initialized = false;
       // KV persistence
       db = null;
@@ -34604,6 +34794,10 @@ var init_evolution_pipeline_integration = __esm({
       };
       /**
        * Initialize the Evolution Pipeline integration
+       *
+       * Attempts to load @claude-flow/guidance EvolutionPipeline for
+       * signed change proposals and staged rollout. Falls back to local
+       * rule effectiveness tracking.
        */
       async initialize() {
         if (this.initialized) return;
@@ -34615,6 +34809,19 @@ var init_evolution_pipeline_integration = __esm({
           console.warn("[EvolutionPipeline] DB init failed, using memory-only:", toErrorMessage(error));
           this.db = null;
         }
+        try {
+          const modulePath = "@claude-flow/guidance/evolution";
+          const mod = await import(
+            /* @vite-ignore */
+            modulePath
+          );
+          if (mod && typeof mod.createEvolutionPipeline === "function") {
+            this.guidanceEvolution = mod.createEvolutionPipeline();
+            console.log("[EvolutionPipeline] Guidance EvolutionPipeline loaded");
+          }
+        } catch {
+          this.guidanceEvolution = null;
+        }
         this.initialized = true;
         this.logEvent("initialize", "Evolution Pipeline initialized");
       }
@@ -34729,6 +34936,21 @@ var init_evolution_pipeline_integration = __esm({
             timestamp: Date.now(),
             reason
           });
+          if (this.guidanceEvolution) {
+            try {
+              this.guidanceEvolution.propose({
+                kind: "rule-promote",
+                title: `Promote rule ${ruleId}`,
+                description: reason,
+                author: "aqe-evolution-pipeline",
+                targetPath: `rules/${ruleId}`,
+                diff: { before: oldStatus, after: newStatus },
+                rationale: reason,
+                riskAssessment: { level: "low", factors: ["automated-promotion"] }
+              });
+            } catch {
+            }
+          }
           this.logEvent("rule_promotion", `Rule ${ruleId} promoted: ${oldStatus} -> ${newStatus}. Reason: ${reason}`);
         }
       }
@@ -34758,6 +34980,24 @@ var init_evolution_pipeline_integration = __esm({
             timestamp: Date.now(),
             reason
           });
+          if (this.guidanceEvolution) {
+            try {
+              this.guidanceEvolution.propose({
+                kind: "rule-remove",
+                title: `Demote rule ${ruleId}`,
+                description: reason,
+                author: "aqe-evolution-pipeline",
+                targetPath: `rules/${ruleId}`,
+                diff: { before: oldStatus, after: newStatus },
+                rationale: reason,
+                riskAssessment: {
+                  level: newStatus === "deprecated" ? "medium" : "low",
+                  factors: ["automated-demotion"]
+                }
+              });
+            } catch {
+            }
+          }
           this.logEvent("rule_demotion", `Rule ${ruleId} demoted: ${oldStatus} -> ${newStatus}. Reason: ${reason}`);
         }
       }
@@ -35500,9 +35740,15 @@ var init_adversarial_defense_integration = __esm({
       blocklist = /* @__PURE__ */ new Map();
       stats = this.createEmptyStats();
       assessmentHistory = [];
+      guidanceThreatDetector = null;
+      guidanceCollusionDetector = null;
       initialized = false;
       /**
        * Initialize the AdversarialDefense integration
+       *
+       * Attempts to load @claude-flow/guidance adversarial defense for
+       * ThreatDetector and CollusionDetector. Falls back to local
+       * pattern-based detection.
        */
       async initialize() {
         if (this.initialized) return;
@@ -35510,6 +35756,24 @@ var init_adversarial_defense_integration = __esm({
           this.patterns.set(pattern.name, pattern);
         }
         this.initialized = true;
+        try {
+          const modulePath = "@claude-flow/guidance/adversarial";
+          const mod = await import(
+            /* @vite-ignore */
+            modulePath
+          );
+          if (mod && typeof mod.createThreatDetector === "function") {
+            this.guidanceThreatDetector = mod.createThreatDetector();
+            console.log("[AdversarialDefense] Guidance ThreatDetector loaded");
+          }
+          if (mod && typeof mod.createCollusionDetector === "function") {
+            this.guidanceCollusionDetector = mod.createCollusionDetector();
+            console.log("[AdversarialDefense] Guidance CollusionDetector loaded");
+          }
+        } catch {
+          this.guidanceThreatDetector = null;
+          this.guidanceCollusionDetector = null;
+        }
       }
       /**
        * Assess threat level of an input
@@ -35521,6 +35785,25 @@ var init_adversarial_defense_integration = __esm({
         const flags = governanceFlags.getFlags().adversarialDefense;
         const detectedPatterns = this.detectInjectionPatterns(input);
         const blocklistMatches = this.checkBlocklist(input);
+        if (this.guidanceThreatDetector && detectedPatterns.length === 0) {
+          try {
+            const guidanceContext = { agentId: context?.agentId || "", toolName: context?.taskType || "" };
+            const signals = this.guidanceThreatDetector.analyzeInput(input, guidanceContext);
+            if (signals && Array.isArray(signals) && signals.length > 0) {
+              for (const signal of signals) {
+                detectedPatterns.push({
+                  name: `guidance:${signal.category || "unknown"}`,
+                  category: signal.category || "custom",
+                  matched: signal.description || "",
+                  position: 0,
+                  severity: signal.severity || 0.5,
+                  description: signal.description || "Detected by guidance ThreatDetector"
+                });
+              }
+            }
+          } catch {
+          }
+        }
         let threatScore = 0;
         if (detectedPatterns.length > 0) {
           const severities = detectedPatterns.map((p74) => p74.severity).sort((a37, b68) => b68 - a37);
@@ -35664,6 +35947,37 @@ var init_adversarial_defense_integration = __esm({
         }
         return matches;
       }
+      /**
+       * Record an agent interaction for collusion detection
+       *
+       * Forwards to guidance CollusionDetector when available.
+       * Call this whenever two agents interact during task execution.
+       */
+      recordAgentInteraction(fromAgent, toAgent, contentHash) {
+        if (!isAdversarialDefenseEnabled()) return;
+        if (this.guidanceCollusionDetector) {
+          try {
+            this.guidanceCollusionDetector.recordInteraction(fromAgent, toAgent, contentHash);
+          } catch {
+          }
+        }
+      }
+      /**
+       * Check for collusion patterns among agents
+       *
+       * Delegates to guidance CollusionDetector when available.
+       * Returns null if collusion detection is not available.
+       */
+      detectCollusion() {
+        if (!isAdversarialDefenseEnabled()) return null;
+        if (this.guidanceCollusionDetector) {
+          try {
+            return this.guidanceCollusionDetector.detectCollusion();
+          } catch {
+          }
+        }
+        return null;
+      }
       /**
        * Penalize an agent's trust score based on threat assessment
        */
@@ -36936,6 +37250,7 @@ var init_proof_envelope_integration = __esm({
       kernel;
       chain = [];
       signingKey = "";
+      guidanceProofChain = null;
       initialized = false;
       envelopeIndex = /* @__PURE__ */ new Map();
       /**
@@ -36955,6 +37270,19 @@ var init_proof_envelope_integration = __esm({
         if (this.initialized) return;
         await this.kernel.initialize();
         this.signingKey = signingKey;
+        try {
+          const modulePath = "@claude-flow/guidance/proof";
+          const mod = await import(
+            /* @vite-ignore */
+            modulePath
+          );
+          if (mod && typeof mod.createProofChain === "function") {
+            this.guidanceProofChain = mod.createProofChain({ signingKey });
+            console.log("[ProofEnvelopeIntegration] Guidance ProofChain loaded");
+          }
+        } catch {
+          this.guidanceProofChain = null;
+        }
         this.initialized = true;
       }
       /**
@@ -37058,6 +37386,31 @@ var init_proof_envelope_integration = __esm({
         const index = this.chain.length;
         this.chain.push(envelope);
         this.envelopeIndex.set(envelope.id, index);
+        if (this.guidanceProofChain) {
+          try {
+            const runEvent = {
+              eventId: envelope.id,
+              taskId: envelope.metadata?.taskId ? String(envelope.metadata.taskId) : envelope.id,
+              guidanceHash: envelope.contentHash,
+              retrievedRuleIds: [],
+              toolsUsed: envelope.action ? [envelope.action] : [],
+              filesTouched: [],
+              diffSummary: { linesAdded: 0, linesRemoved: 0, filesChanged: 0 },
+              testResults: { passed: 0, failed: 0, skipped: 0 },
+              metrics: {},
+              timestamp: new Date(envelope.timestamp).toISOString()
+            };
+            this.guidanceProofChain.append(
+              runEvent,
+              [],
+              // toolCalls
+              [],
+              // memoryOps
+              { agentId: envelope.agentId, sessionId: envelope.metadata?.sessionId ? String(envelope.metadata.sessionId) : "aqe" }
+            );
+          } catch {
+          }
+        }
       }
       /**
        * Get the current chain
@@ -39085,6 +39438,7 @@ var init_shard_retriever_integration = __esm({
       cacheMisses = 0;
       lastCacheCleanup = null;
       parseErrors = [];
+      guidanceRetriever = null;
       initialized = false;
       basePath;
       constructor(basePath) {
@@ -39092,6 +39446,10 @@ var init_shard_retriever_integration = __esm({
       }
       /**
        * Initialize the ShardRetrieverIntegration
+       *
+       * Attempts to load @claude-flow/guidance ShardRetriever for
+       * embedding-based semantic shard matching. Falls back to local
+       * filesystem-based loading with keyword matching.
        */
       async initialize() {
         if (this.initialized) return;
@@ -39099,6 +39457,19 @@ var init_shard_retriever_integration = __esm({
           this.initialized = true;
           return;
         }
+        try {
+          const modulePath = "@claude-flow/guidance/retriever";
+          const mod = await import(
+            /* @vite-ignore */
+            modulePath
+          );
+          if (mod && typeof mod.createRetriever === "function") {
+            this.guidanceRetriever = mod.createRetriever();
+            console.log("[ShardRetrieverIntegration] Guidance ShardRetriever loaded");
+          }
+        } catch {
+          this.guidanceRetriever = null;
+        }
         await this.loadAllShards();
         this.initialized = true;
       }
@@ -39165,6 +39536,11 @@ var init_shard_retriever_integration = __esm({
       }
       /**
        * Retrieve shards relevant to a task
+       *
+       * Local filesystem-based retrieval is authoritative. When guidance
+       * ShardRetriever is available, its embedding-based results supplement
+       * the local results by boosting relevance scores for shards that
+       * guidance also considers relevant.
        */
       async retrieveForTask(taskType, context) {
         if (!isShardRetrieverEnabled()) {
@@ -39173,9 +39549,31 @@ var init_shard_retriever_integration = __esm({
         await this.initialize();
         const flags = getShardRetrieverFlags();
         const allShards = await this.getAllCachedOrLoadedShards();
+        const guidanceRelevantDomains = /* @__PURE__ */ new Set();
+        if (this.guidanceRetriever) {
+          try {
+            const result = await this.guidanceRetriever.retrieve({
+              taskDescription: `${taskType}: ${context.intent || ""} ${(context.keywords || []).join(" ")}`,
+              maxShards: flags.maxShardsPerQuery
+            });
+            if (result && result.shards) {
+              for (const s70 of result.shards) {
+                if (s70.shard?.rule?.domains) {
+                  for (const d74 of s70.shard.rule.domains) {
+                    guidanceRelevantDomains.add(d74);
+                  }
+                }
+              }
+            }
+          } catch {
+          }
+        }
         const scoredShards = [];
         for (const shard of allShards.values()) {
-          const score = this.calculateRelevance(shard, { ...context, taskType });
+          let score = this.calculateRelevance(shard, { ...context, taskType });
+          if (guidanceRelevantDomains.has(shard.domain)) {
+            score = Math.min(1, score + 0.1);
+          }
           if (score >= flags.relevanceThreshold) {
             scoredShards.push({ shard, score });
           }
@@ -66598,14 +66996,22 @@ var init_test_verifier = __esm({
 });
 
 // src/agents/claim-verifier/verifiers/output-verifier.ts
-import { exec as exec3 } from "node:child_process";
+import { execFile } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
-var execAsync3, OutputBasedVerifier;
+var execFileAsync, ALLOWED_COMMANDS, OutputBasedVerifier;
 var init_output_verifier = __esm({
   "src/agents/claim-verifier/verifiers/output-verifier.ts"() {
     "use strict";
     init_claim_verifier();
-    execAsync3 = promisify3(exec3);
+    execFileAsync = promisify3(execFile);
+    ALLOWED_COMMANDS = /* @__PURE__ */ new Map([
+      ["npm run build", { bin: "npm", args: ["run", "build"] }],
+      ["npm run lint", { bin: "npm", args: ["run", "lint"] }],
+      ["npm test", { bin: "npm", args: ["test"] }],
+      ["npm run typecheck", { bin: "npm", args: ["run", "typecheck"] }],
+      ["npm run test:unit", { bin: "npm", args: ["run", "test:unit"] }],
+      ["npm run test:ci", { bin: "npm", args: ["run", "test:ci"] }]
+    ]);
     OutputBasedVerifier = class {
       config;
       /**
@@ -66730,11 +67136,18 @@ var init_output_verifier = __esm({
       }
       /**
        * Execute a command and capture output.
+       * Uses execFile with an allowlist to prevent command injection (CWE-78).
        */
       async executeCommand(command) {
         const startTime = Date.now();
+        const allowed = ALLOWED_COMMANDS.get(command);
+        if (!allowed) {
+          throw new Error(
+            `Command not in allowlist: "${command}". Allowed: ${[...ALLOWED_COMMANDS.keys()].join(", ")}`
+          );
+        }
         try {
-          const { stdout, stderr } = await execAsync3(command, {
+          const { stdout, stderr } = await execFileAsync(allowed.bin, [...allowed.args], {
             cwd: this.config.rootDir,
             timeout: this.config.timeout,
             maxBuffer: this.config.maxOutputSize,
@@ -100288,7 +100701,7 @@ var init_plugin10 = __esm({
 
 // src/domains/chaos-resilience/services/chaos-engineer.ts
 import * as net from "net";
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 var DEFAULT_CONFIG55, ChaosEngineerService;
 var init_chaos_engineer = __esm({
   "src/domains/chaos-resilience/services/chaos-engineer.ts"() {
@@ -100798,7 +101211,7 @@ Provide:
           const parts = sanitizedCommand.trim().split(/\s+/);
           const executable = parts[0];
           const args = parts.slice(1);
-          execFile(executable, args, { timeout }, (error, stdout, _stderr) => {
+          execFile2(executable, args, { timeout }, (error, stdout, _stderr) => {
             if (error) {
               console.log(`Command probe failed: ${probe.name} -> ${error.message}`);
               resolve10(false);
@@ -101142,7 +101555,7 @@ Provide:
           const parts = sanitizedCommand.trim().split(/\s+/);
           const executable = parts[0];
           const args = parts.slice(1);
-          execFile(executable, args, { timeout }, (error, _stdout, stderr) => {
+          execFile2(executable, args, { timeout }, (error, _stdout, stderr) => {
             if (error) {
               reject(new Error(`Command rollback failed: ${error.message}. ${stderr}`));
             } else {
@@ -113811,12 +114224,12 @@ var init_coverage_analysis = __esm({
 });
 
 // src/domains/security-compliance/services/semgrep-integration.ts
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { promisify as promisify4 } from "util";
 import * as path16 from "path";
 async function isSemgrepAvailable() {
   try {
-    await execFileAsync("semgrep", ["--version"], { timeout: 5e3 });
+    await execFileAsync2("semgrep", ["--version"], { timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -113824,7 +114237,7 @@ async function isSemgrepAvailable() {
 }
 async function getSemgrepVersion() {
   try {
-    const { stdout } = await execFileAsync("semgrep", ["--version"], { timeout: 5e3 });
+    const { stdout } = await execFileAsync2("semgrep", ["--version"], { timeout: 5e3 });
     return stdout.trim();
   } catch {
     return null;
@@ -113861,7 +114274,7 @@ async function runSemgrep(config) {
     }
     args.push(fullConfig.target);
     const timeoutMs = (fullConfig.timeout ?? 300) * 1e3;
-    const { stdout, stderr } = await execFileAsync("semgrep", args, {
+    const { stdout, stderr } = await execFileAsync2("semgrep", args, {
       timeout: timeoutMs,
       maxBuffer: 50 * 1024 * 1024,
       // 50MB buffer for large results
@@ -113973,13 +114386,13 @@ function convertSemgrepFindings(findings) {
     references: f74.extra.metadata?.references || []
   }));
 }
-var execFileAsync;
+var execFileAsync2;
 var init_semgrep_integration = __esm({
   "src/domains/security-compliance/services/semgrep-integration.ts"() {
     "use strict";
     init_error_utils();
     init_safe_json();
-    execFileAsync = promisify4(execFile2);
+    execFileAsync2 = promisify4(execFile3);
   }
 });
 
@@ -172064,7 +172477,7 @@ async function handleAQEHealth() {
       success: true,
       data: {
         status: healthStatus,
-        version: true ? "3.7.9" : "3.7.2",
+        version: true ? "3.7.11" : "3.7.2",
         loadedDomains: domainCount,
         memory: memoryStats,
         hnsw: hnswStats,
@@ -174418,7 +174831,10 @@ var ToolRegistry = class {
       "domain",
       "coordination",
       "memory",
-      "learning"
+      "learning",
+      "routing",
+      "cross-phase",
+      "infra-healing"
     ];
     for (const category of categories) {
       this.categoryTools.set(category, /* @__PURE__ */ new Set());
@@ -178184,7 +178600,7 @@ var MCPProtocolServer = class {
     return {
       name: this.config.name,
       version: this.config.version,
-      protocolVersion: "2024-11-05"
+      protocolVersion: "2025-11-25"
       // MCP protocol version
     };
   }
@@ -178260,7 +178676,7 @@ var MCPProtocolServer = class {
     }
     this.initialized = true;
     return {
-      protocolVersion: "2024-11-05",
+      protocolVersion: "2025-11-25",
       capabilities: this.getCapabilities(),
       serverInfo: this.getServerInfo()
     };
@@ -185279,10 +185695,10 @@ function createCoordinationLock(defaultTtlMs) {
 // src/strange-loop/infra-healing/infra-action-executor.ts
 var ShellCommandRunner = class {
   async run(command, timeoutMs) {
-    const { execFile: execFile3 } = await import("node:child_process");
+    const { execFile: execFile4 } = await import("node:child_process");
     const startTime = Date.now();
     return new Promise((resolve10) => {
-      const child = execFile3(
+      const child = execFile4(
         "/bin/sh",
         ["-c", command],
         { timeout: timeoutMs, maxBuffer: 1024 * 1024 },