agentic-qe 3.7.10 → 3.7.12

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"
     ]);
   }
 });
@@ -7631,11 +7639,11 @@ function createLWWRegister(nodeId, initialValue, initialTimestamp) {
       return state2.value;
     },
     set(value, timestamp) {
-      const ts4 = timestamp ?? Date.now();
-      if (state2.timestamp === 0 || compareTimestamps(ts4, nodeId, state2.timestamp, state2.nodeId) > 0) {
+      const ts = timestamp ?? Date.now();
+      if (state2.timestamp === 0 || compareTimestamps(ts, nodeId, state2.timestamp, state2.nodeId) > 0) {
         state2 = {
           value,
-          timestamp: ts4,
+          timestamp: ts,
           nodeId,
           version: state2.version + 1,
           lastUpdated: Date.now()
@@ -10506,6 +10514,47 @@ var init_domain_events = __esm({
   }
 });
 
+// typescript-lazy:typescript
+import { createRequire as createRequire4 } from "module";
+function _load() {
+  if (!_ts) {
+    const req = createRequire4(import.meta.url);
+    try {
+      _ts = req("typescript");
+    } catch {
+      try {
+        _ts = req("typescript/lib/typescript.js");
+      } catch {
+        _ts = new Proxy({}, { get(_56, p74) {
+          if (p74 === "__esModule" || typeof p74 === "symbol") return void 0;
+          throw new Error("TypeScript is required for code analysis. Install it: npm install -g typescript");
+        } });
+      }
+    }
+  }
+  return _ts;
+}
+var _ts, typescript_default;
+var init_typescript = __esm({
+  "typescript-lazy:typescript"() {
+    typescript_default = new Proxy({}, {
+      get(_56, p74) {
+        return _load()[p74];
+      },
+      has(_56, p74) {
+        return p74 in _load();
+      },
+      ownKeys() {
+        return Object.keys(_load());
+      },
+      getOwnPropertyDescriptor(_56, p74) {
+        const v62 = _load()[p74];
+        if (v62 !== void 0) return { configurable: true, enumerable: true, value: v62 };
+      }
+    });
+  }
+});
+
 // src/shared/types/test-frameworks.ts
 var test_frameworks_exports = {};
 __export(test_frameworks_exports, {
@@ -26388,7 +26437,6 @@ var init_language_prompts = __esm({
 // src/domains/test-generation/services/test-generator.ts
 import * as fs4 from "fs";
 import * as path5 from "path";
-import * as ts from "typescript/lib/typescript.js";
 function createTestGeneratorService(memory, config = {}) {
   return new TestGeneratorService({ memory }, config);
 }
@@ -26397,6 +26445,7 @@ var init_test_generator = __esm({
   "src/domains/test-generation/services/test-generator.ts"() {
     "use strict";
     init_esm_node();
+    init_typescript();
     init_types();
     init_test_generator_factory();
     init_tdd_generator();
@@ -26868,41 +26917,41 @@ ${sourceCode}
             return PytestGenerator.convertParsedFile(parsed);
           }
         }
-        const sourceFile = ts.createSourceFile(
+        const sourceFile = typescript_default.createSourceFile(
           path5.basename(fileName),
           content,
-          ts.ScriptTarget.Latest,
+          typescript_default.ScriptTarget.Latest,
           true,
-          ts.ScriptKind.TS
+          typescript_default.ScriptKind.TS
         );
         const functions = [];
         const classes = [];
         const visit = (node) => {
-          if (ts.isFunctionDeclaration(node) && node.name) {
+          if (typescript_default.isFunctionDeclaration(node) && node.name) {
             functions.push(this.extractFunctionInfo(node, sourceFile));
-          } else if (ts.isVariableStatement(node)) {
+          } else if (typescript_default.isVariableStatement(node)) {
             for (const declaration of node.declarationList.declarations) {
-              if (ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) {
+              if (typescript_default.isVariableDeclaration(declaration) && declaration.initializer && (typescript_default.isArrowFunction(declaration.initializer) || typescript_default.isFunctionExpression(declaration.initializer))) {
                 const name = declaration.name.getText(sourceFile);
                 functions.push(
                   this.extractArrowFunctionInfo(name, declaration.initializer, sourceFile, node)
                 );
               }
             }
-          } else if (ts.isClassDeclaration(node) && node.name) {
+          } else if (typescript_default.isClassDeclaration(node) && node.name) {
             classes.push(this.extractClassInfo(node, sourceFile));
           }
-          ts.forEachChild(node, visit);
+          typescript_default.forEachChild(node, visit);
         };
-        ts.forEachChild(sourceFile, visit);
+        typescript_default.forEachChild(sourceFile, visit);
         return { functions, classes };
       }
       extractFunctionInfo(node, sourceFile) {
         const name = node.name?.getText(sourceFile) || "anonymous";
         const parameters = this.extractParameters(node.parameters, sourceFile);
         const returnType = node.type?.getText(sourceFile);
-        const isAsync = node.modifiers?.some((m74) => m74.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const isExported = node.modifiers?.some((m74) => m74.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+        const isAsync = node.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.AsyncKeyword) ?? false;
+        const isExported = node.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.ExportKeyword) ?? false;
         const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
         const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
         return {
@@ -26920,8 +26969,8 @@ ${sourceCode}
       extractArrowFunctionInfo(name, node, sourceFile, parentNode) {
         const parameters = this.extractParameters(node.parameters, sourceFile);
         const returnType = node.type?.getText(sourceFile);
-        const isAsync = node.modifiers?.some((m74) => m74.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const isExported = ts.isVariableStatement(parentNode) && (parentNode.modifiers?.some((m74) => m74.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+        const isAsync = node.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.AsyncKeyword) ?? false;
+        const isExported = typescript_default.isVariableStatement(parentNode) && (parentNode.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.ExportKeyword) ?? false);
         const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
         const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
         return {
@@ -26942,13 +26991,13 @@ ${sourceCode}
         const properties = [];
         let hasConstructor = false;
         let constructorParams;
-        const isExported = node.modifiers?.some((m74) => m74.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+        const isExported = node.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.ExportKeyword) ?? false;
         for (const member of node.members) {
-          if (ts.isMethodDeclaration(member)) {
+          if (typescript_default.isMethodDeclaration(member)) {
             const methodName = member.name.getText(sourceFile);
             const parameters = this.extractParameters(member.parameters, sourceFile);
             const returnType = member.type?.getText(sourceFile);
-            const isAsync = member.modifiers?.some((m74) => m74.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+            const isAsync = member.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.AsyncKeyword) ?? false;
             const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(
               member.getStart(sourceFile)
             );
@@ -26964,14 +27013,14 @@ ${sourceCode}
               endLine: endLine + 1,
               body: member.body?.getText(sourceFile)
             });
-          } else if (ts.isConstructorDeclaration(member)) {
+          } else if (typescript_default.isConstructorDeclaration(member)) {
             hasConstructor = true;
             constructorParams = this.extractParameters(member.parameters, sourceFile);
-          } else if (ts.isPropertyDeclaration(member)) {
+          } else if (typescript_default.isPropertyDeclaration(member)) {
             const propName = member.name.getText(sourceFile);
             const propType = member.type?.getText(sourceFile);
-            const isPrivate = member.modifiers?.some((m74) => m74.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
-            const isReadonly = member.modifiers?.some((m74) => m74.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
+            const isPrivate = member.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.PrivateKeyword) ?? false;
+            const isReadonly = member.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.ReadonlyKeyword) ?? false;
             properties.push({
               name: propName,
               type: propType,
@@ -26995,14 +27044,14 @@ ${sourceCode}
         return params.map((param) => {
           let name = param.name.getText(sourceFile);
           let type = param.type?.getText(sourceFile);
-          if (ts.isObjectBindingPattern(param.name)) {
+          if (typescript_default.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)) {
+          } else if (typescript_default.isArrayBindingPattern(param.name)) {
             arrayDestructureCount++;
             name = arrayDestructureCount > 1 ? `items${arrayDestructureCount}` : "items";
             if (!type) {
@@ -27021,28 +27070,28 @@ ${sourceCode}
         let complexity = 1;
         const visit = (n61) => {
           switch (n61.kind) {
-            case ts.SyntaxKind.IfStatement:
-            case ts.SyntaxKind.ForStatement:
-            case ts.SyntaxKind.ForInStatement:
-            case ts.SyntaxKind.ForOfStatement:
-            case ts.SyntaxKind.WhileStatement:
-            case ts.SyntaxKind.DoStatement:
-            case ts.SyntaxKind.CaseClause:
-            case ts.SyntaxKind.CatchClause:
-            case ts.SyntaxKind.ConditionalExpression:
+            case typescript_default.SyntaxKind.IfStatement:
+            case typescript_default.SyntaxKind.ForStatement:
+            case typescript_default.SyntaxKind.ForInStatement:
+            case typescript_default.SyntaxKind.ForOfStatement:
+            case typescript_default.SyntaxKind.WhileStatement:
+            case typescript_default.SyntaxKind.DoStatement:
+            case typescript_default.SyntaxKind.CaseClause:
+            case typescript_default.SyntaxKind.CatchClause:
+            case typescript_default.SyntaxKind.ConditionalExpression:
               complexity++;
               break;
-            case ts.SyntaxKind.BinaryExpression: {
+            case typescript_default.SyntaxKind.BinaryExpression: {
               const binary = n61;
-              if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+              if (binary.operatorToken.kind === typescript_default.SyntaxKind.AmpersandAmpersandToken || binary.operatorToken.kind === typescript_default.SyntaxKind.BarBarToken) {
                 complexity++;
               }
               break;
             }
           }
-          ts.forEachChild(n61, visit);
+          typescript_default.forEachChild(n61, visit);
         };
-        ts.forEachChild(node, visit);
+        typescript_default.forEachChild(node, visit);
         return complexity;
       }
       // ============================================================================
@@ -27910,7 +27959,6 @@ var init_embeddings = __esm({
 });
 
 // src/domains/test-generation/services/pattern-matcher.ts
-import * as ts2 from "typescript/lib/typescript.js";
 import * as fs5 from "fs";
 import * as path6 from "path";
 var DEFAULT_CONFIG12, PatternMatcherService, TypeScriptASTParser;
@@ -27918,6 +27966,7 @@ var init_pattern_matcher = __esm({
   "src/domains/test-generation/services/pattern-matcher.ts"() {
     "use strict";
     init_esm_node();
+    init_typescript();
     init_types();
     init_embeddings();
     init_error_utils();
@@ -28899,12 +28948,12 @@ var init_pattern_matcher = __esm({
         } else {
           this.sourceCode = fs5.readFileSync(filePath, "utf-8");
         }
-        this.sourceFile = ts2.createSourceFile(
+        this.sourceFile = typescript_default.createSourceFile(
           path6.basename(filePath),
           this.sourceCode,
-          ts2.ScriptTarget.Latest,
+          typescript_default.ScriptTarget.Latest,
           true,
-          ts2.ScriptKind.TS
+          typescript_default.ScriptKind.TS
         );
         return this.sourceFile;
       }
@@ -28913,12 +28962,12 @@ var init_pattern_matcher = __esm({
        */
       parseSource(source, fileName = "module.ts") {
         this.sourceCode = source;
-        this.sourceFile = ts2.createSourceFile(
+        this.sourceFile = typescript_default.createSourceFile(
           fileName,
           source,
-          ts2.ScriptTarget.Latest,
+          typescript_default.ScriptTarget.Latest,
           true,
-          ts2.ScriptKind.TS
+          typescript_default.ScriptKind.TS
         );
         return this.sourceFile;
       }
@@ -28928,11 +28977,11 @@ var init_pattern_matcher = __esm({
       extractFunctions(sourceFile) {
         const functions = [];
         const visit = (node) => {
-          if (ts2.isFunctionDeclaration(node) && node.name) {
+          if (typescript_default.isFunctionDeclaration(node) && node.name) {
             functions.push(this.extractFunctionInfo(node, sourceFile));
-          } else if (ts2.isVariableStatement(node)) {
+          } else if (typescript_default.isVariableStatement(node)) {
             for (const declaration of node.declarationList.declarations) {
-              if (ts2.isVariableDeclaration(declaration) && declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer))) {
+              if (typescript_default.isVariableDeclaration(declaration) && declaration.initializer && (typescript_default.isArrowFunction(declaration.initializer) || typescript_default.isFunctionExpression(declaration.initializer))) {
                 const name = declaration.name.getText(sourceFile);
                 functions.push(
                   this.extractArrowFunctionInfo(
@@ -28945,9 +28994,9 @@ var init_pattern_matcher = __esm({
               }
             }
           }
-          ts2.forEachChild(node, visit);
+          typescript_default.forEachChild(node, visit);
         };
-        ts2.forEachChild(sourceFile, visit);
+        typescript_default.forEachChild(sourceFile, visit);
         return functions;
       }
       /**
@@ -28956,12 +29005,12 @@ var init_pattern_matcher = __esm({
       extractClasses(sourceFile) {
         const classes = [];
         const visit = (node) => {
-          if (ts2.isClassDeclaration(node) && node.name) {
+          if (typescript_default.isClassDeclaration(node) && node.name) {
             classes.push(this.extractClassInfo(node, sourceFile));
           }
-          ts2.forEachChild(node, visit);
+          typescript_default.forEachChild(node, visit);
         };
-        ts2.forEachChild(sourceFile, visit);
+        typescript_default.forEachChild(sourceFile, visit);
         return classes;
       }
       /**
@@ -28972,10 +29021,10 @@ var init_pattern_matcher = __esm({
         const parameters = this.extractParameters(node.parameters, sourceFile);
         const returnType = node.type?.getText(sourceFile);
         const isAsync = node.modifiers?.some(
-          (m74) => m74.kind === ts2.SyntaxKind.AsyncKeyword
+          (m74) => m74.kind === typescript_default.SyntaxKind.AsyncKeyword
         ) ?? false;
         const isExported = node.modifiers?.some(
-          (m74) => m74.kind === ts2.SyntaxKind.ExportKeyword
+          (m74) => m74.kind === typescript_default.SyntaxKind.ExportKeyword
         ) ?? false;
         const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(
           node.getStart(sourceFile)
@@ -29003,9 +29052,9 @@ var init_pattern_matcher = __esm({
         const parameters = this.extractParameters(node.parameters, sourceFile);
         const returnType = node.type?.getText(sourceFile);
         const isAsync = node.modifiers?.some(
-          (m74) => m74.kind === ts2.SyntaxKind.AsyncKeyword
+          (m74) => m74.kind === typescript_default.SyntaxKind.AsyncKeyword
         ) ?? false;
-        const isExported = ts2.isVariableStatement(parentNode) && (parentNode.modifiers?.some((m74) => m74.kind === ts2.SyntaxKind.ExportKeyword) ?? false);
+        const isExported = typescript_default.isVariableStatement(parentNode) && (parentNode.modifiers?.some((m74) => m74.kind === typescript_default.SyntaxKind.ExportKeyword) ?? false);
         const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(
           node.getStart(sourceFile)
         );
@@ -29034,15 +29083,15 @@ var init_pattern_matcher = __esm({
         const properties = [];
         let hasConstructor = false;
         const isExported = node.modifiers?.some(
-          (m74) => m74.kind === ts2.SyntaxKind.ExportKeyword
+          (m74) => m74.kind === typescript_default.SyntaxKind.ExportKeyword
         ) ?? false;
         for (const member of node.members) {
-          if (ts2.isMethodDeclaration(member)) {
+          if (typescript_default.isMethodDeclaration(member)) {
             const methodName = member.name.getText(sourceFile);
             const parameters = this.extractParameters(member.parameters, sourceFile);
             const returnType = member.type?.getText(sourceFile);
             const isAsync = member.modifiers?.some(
-              (m74) => m74.kind === ts2.SyntaxKind.AsyncKeyword
+              (m74) => m74.kind === typescript_default.SyntaxKind.AsyncKeyword
             ) ?? false;
             const { line: startLine2 } = sourceFile.getLineAndCharacterOfPosition(
               member.getStart(sourceFile)
@@ -29061,16 +29110,16 @@ var init_pattern_matcher = __esm({
               endLine: endLine2 + 1,
               body: member.body?.getText(sourceFile)
             });
-          } else if (ts2.isConstructorDeclaration(member)) {
+          } else if (typescript_default.isConstructorDeclaration(member)) {
             hasConstructor = true;
-          } else if (ts2.isPropertyDeclaration(member)) {
+          } else if (typescript_default.isPropertyDeclaration(member)) {
             const propName = member.name.getText(sourceFile);
             const propType = member.type?.getText(sourceFile);
             const isPrivate = member.modifiers?.some(
-              (m74) => m74.kind === ts2.SyntaxKind.PrivateKeyword
+              (m74) => m74.kind === typescript_default.SyntaxKind.PrivateKeyword
             ) ?? false;
             const isReadonly = member.modifiers?.some(
-              (m74) => m74.kind === ts2.SyntaxKind.ReadonlyKeyword
+              (m74) => m74.kind === typescript_default.SyntaxKind.ReadonlyKeyword
             ) ?? false;
             properties.push({
               name: propName,
@@ -29105,14 +29154,14 @@ var init_pattern_matcher = __esm({
         return params.map((param) => {
           let name = param.name.getText(sourceFile);
           let type = param.type?.getText(sourceFile);
-          if (ts2.isObjectBindingPattern(param.name)) {
+          if (typescript_default.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)) {
+          } else if (typescript_default.isArrayBindingPattern(param.name)) {
             arrayDestructureCount++;
             name = arrayDestructureCount > 1 ? `items${arrayDestructureCount}` : "items";
             if (!type) {
@@ -29134,28 +29183,28 @@ var init_pattern_matcher = __esm({
         let complexity = 1;
         const visit = (n61) => {
           switch (n61.kind) {
-            case ts2.SyntaxKind.IfStatement:
-            case ts2.SyntaxKind.ForStatement:
-            case ts2.SyntaxKind.ForInStatement:
-            case ts2.SyntaxKind.ForOfStatement:
-            case ts2.SyntaxKind.WhileStatement:
-            case ts2.SyntaxKind.DoStatement:
-            case ts2.SyntaxKind.CaseClause:
-            case ts2.SyntaxKind.CatchClause:
-            case ts2.SyntaxKind.ConditionalExpression:
-            case ts2.SyntaxKind.QuestionQuestionToken:
+            case typescript_default.SyntaxKind.IfStatement:
+            case typescript_default.SyntaxKind.ForStatement:
+            case typescript_default.SyntaxKind.ForInStatement:
+            case typescript_default.SyntaxKind.ForOfStatement:
+            case typescript_default.SyntaxKind.WhileStatement:
+            case typescript_default.SyntaxKind.DoStatement:
+            case typescript_default.SyntaxKind.CaseClause:
+            case typescript_default.SyntaxKind.CatchClause:
+            case typescript_default.SyntaxKind.ConditionalExpression:
+            case typescript_default.SyntaxKind.QuestionQuestionToken:
               complexity++;
               break;
-            case ts2.SyntaxKind.BinaryExpression:
+            case typescript_default.SyntaxKind.BinaryExpression:
               const binary = n61;
-              if (binary.operatorToken.kind === ts2.SyntaxKind.AmpersandAmpersandToken || binary.operatorToken.kind === ts2.SyntaxKind.BarBarToken) {
+              if (binary.operatorToken.kind === typescript_default.SyntaxKind.AmpersandAmpersandToken || binary.operatorToken.kind === typescript_default.SyntaxKind.BarBarToken) {
                 complexity++;
               }
               break;
           }
-          ts2.forEachChild(n61, visit);
+          typescript_default.forEachChild(n61, visit);
         };
-        ts2.forEachChild(node, visit);
+        typescript_default.forEachChild(node, visit);
         return complexity;
       }
     };
@@ -33231,13 +33280,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();
@@ -33318,7 +33384,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
@@ -33395,21 +33489,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
         };
       }
       /**
@@ -33487,12 +33585,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;
       }
       /**
@@ -33506,7 +33619,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
@@ -33642,15 +33779,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
         };
       }
       /**
@@ -33767,12 +33906,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;
       }
       /**
@@ -33796,6 +33961,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);
@@ -34164,14 +34336,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
@@ -34296,6 +34486,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
@@ -34605,6 +34812,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;
@@ -34627,6 +34835,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;
@@ -34638,6 +34850,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");
       }
@@ -34752,6 +34977,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}`);
         }
       }
@@ -34781,6 +35021,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}`);
         }
       }
@@ -35523,9 +35781,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;
@@ -35533,6 +35797,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
@@ -35544,6 +35826,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);
@@ -35687,6 +35988,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
        */
@@ -36959,6 +37291,7 @@ var init_proof_envelope_integration = __esm({
       kernel;
       chain = [];
       signingKey = "";
+      guidanceProofChain = null;
       initialized = false;
       envelopeIndex = /* @__PURE__ */ new Map();
       /**
@@ -36978,6 +37311,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;
       }
       /**
@@ -37081,6 +37427,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
@@ -39108,6 +39479,7 @@ var init_shard_retriever_integration = __esm({
       cacheMisses = 0;
       lastCacheCleanup = null;
       parseErrors = [];
+      guidanceRetriever = null;
       initialized = false;
       basePath;
       constructor(basePath) {
@@ -39115,6 +39487,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;
@@ -39122,6 +39498,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;
       }
@@ -39188,6 +39577,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()) {
@@ -39196,9 +39590,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 });
           }
@@ -41688,11 +42104,11 @@ __export(sona_exports, {
   init: () => init4,
   pipeline: () => pipeline5
 });
-import { createRequire as createRequire4 } from "module";
+import { createRequire as createRequire5 } from "module";
 var __require5, __mod4, sona_default, RuvectorLayer4, TensorCompress4, differentiableSearch4, hierarchicalForward4, getCompressionLevel4, init4, FlashAttention4, DotProductAttention4, MultiHeadAttention4, HyperbolicAttention4, LinearAttention4, MoEAttention4, SonaEngine4, pipeline5;
 var init_sona = __esm({
   "native-require:@ruvector/sona"() {
-    __require5 = createRequire4(import.meta.url);
+    __require5 = createRequire5(import.meta.url);
     __mod4 = __require5("@ruvector/sona");
     sona_default = __mod4;
     ({
@@ -43126,11 +43542,11 @@ __export(attention_exports, {
   init: () => init5,
   pipeline: () => pipeline6
 });
-import { createRequire as createRequire5 } from "module";
+import { createRequire as createRequire6 } from "module";
 var __require6, __mod5, attention_default, RuvectorLayer5, TensorCompress5, differentiableSearch5, hierarchicalForward5, getCompressionLevel5, init5, FlashAttention5, DotProductAttention5, MultiHeadAttention5, HyperbolicAttention5, LinearAttention5, MoEAttention5, SonaEngine5, pipeline6;
 var init_attention = __esm({
   "native-require:@ruvector/attention"() {
-    __require6 = createRequire5(import.meta.url);
+    __require6 = createRequire6(import.meta.url);
     __mod5 = __require6("@ruvector/attention");
     attention_default = __mod5;
     ({
@@ -62259,20 +62675,20 @@ var init_quality_gate = __esm({
 });
 
 // src/shared/parsers/typescript-parser.ts
-import * as ts3 from "typescript/lib/typescript.js";
 var TypeScriptParser, typescriptParser, TypeScriptLanguageParser, typescriptLanguageParser;
 var init_typescript_parser = __esm({
   "src/shared/parsers/typescript-parser.ts"() {
     "use strict";
+    init_typescript();
     TypeScriptParser = class {
       /**
        * Parse a TypeScript file and return the AST SourceFile
        */
       parseFile(filePath, content) {
-        return ts3.createSourceFile(
+        return typescript_default.createSourceFile(
           filePath,
           content,
-          ts3.ScriptTarget.Latest,
+          typescript_default.ScriptTarget.Latest,
           true,
           this.getScriptKind(filePath)
         );
@@ -62283,14 +62699,14 @@ var init_typescript_parser = __esm({
       extractFunctions(ast) {
         const functions = [];
         const visit = (node) => {
-          if (ts3.isFunctionDeclaration(node) && node.name) {
+          if (typescript_default.isFunctionDeclaration(node) && node.name) {
             functions.push(this.extractFunctionDeclaration(node, ast));
-          } else if (ts3.isVariableStatement(node)) {
+          } else if (typescript_default.isVariableStatement(node)) {
             this.extractArrowFunctions(node, ast, functions);
           }
-          ts3.forEachChild(node, visit);
+          typescript_default.forEachChild(node, visit);
         };
-        ts3.forEachChild(ast, visit);
+        typescript_default.forEachChild(ast, visit);
         return functions;
       }
       /**
@@ -62299,12 +62715,12 @@ var init_typescript_parser = __esm({
       extractClasses(ast) {
         const classes = [];
         const visit = (node) => {
-          if (ts3.isClassDeclaration(node) && node.name) {
+          if (typescript_default.isClassDeclaration(node) && node.name) {
             classes.push(this.extractClassDeclaration(node, ast));
           }
-          ts3.forEachChild(node, visit);
+          typescript_default.forEachChild(node, visit);
         };
-        ts3.forEachChild(ast, visit);
+        typescript_default.forEachChild(ast, visit);
         return classes;
       }
       /**
@@ -62313,12 +62729,12 @@ var init_typescript_parser = __esm({
       extractImports(ast) {
         const imports = [];
         const visit = (node) => {
-          if (ts3.isImportDeclaration(node)) {
+          if (typescript_default.isImportDeclaration(node)) {
             imports.push(this.extractImportDeclaration(node));
           }
-          ts3.forEachChild(node, visit);
+          typescript_default.forEachChild(node, visit);
         };
-        ts3.forEachChild(ast, visit);
+        typescript_default.forEachChild(ast, visit);
         return imports;
       }
       /**
@@ -62327,9 +62743,9 @@ var init_typescript_parser = __esm({
       extractExports(ast) {
         const exports = [];
         const visit = (node) => {
-          if (ts3.isExportDeclaration(node)) {
+          if (typescript_default.isExportDeclaration(node)) {
             this.extractExportDeclaration(node, exports);
-          } else if (ts3.isExportAssignment(node)) {
+          } else if (typescript_default.isExportAssignment(node)) {
             exports.push({
               name: this.getExportAssignmentName(node),
               type: "unknown",
@@ -62337,7 +62753,7 @@ var init_typescript_parser = __esm({
               isReexport: false,
               sourceModule: void 0
             });
-          } else if (ts3.isFunctionDeclaration(node) && node.name && this.hasExportModifier(node)) {
+          } else if (typescript_default.isFunctionDeclaration(node) && node.name && this.hasExportModifier(node)) {
             exports.push({
               name: node.name.text,
               type: "function",
@@ -62345,7 +62761,7 @@ var init_typescript_parser = __esm({
               isReexport: false,
               sourceModule: void 0
             });
-          } else if (ts3.isClassDeclaration(node) && node.name && this.hasExportModifier(node)) {
+          } else if (typescript_default.isClassDeclaration(node) && node.name && this.hasExportModifier(node)) {
             exports.push({
               name: node.name.text,
               type: "class",
@@ -62353,9 +62769,9 @@ var init_typescript_parser = __esm({
               isReexport: false,
               sourceModule: void 0
             });
-          } else if (ts3.isVariableStatement(node) && this.hasExportModifier(node)) {
+          } else if (typescript_default.isVariableStatement(node) && this.hasExportModifier(node)) {
             for (const declaration of node.declarationList.declarations) {
-              if (ts3.isIdentifier(declaration.name)) {
+              if (typescript_default.isIdentifier(declaration.name)) {
                 exports.push({
                   name: declaration.name.text,
                   type: "variable",
@@ -62365,7 +62781,7 @@ var init_typescript_parser = __esm({
                 });
               }
             }
-          } else if (ts3.isInterfaceDeclaration(node) && this.hasExportModifier(node)) {
+          } else if (typescript_default.isInterfaceDeclaration(node) && this.hasExportModifier(node)) {
             exports.push({
               name: node.name.text,
               type: "interface",
@@ -62373,7 +62789,7 @@ var init_typescript_parser = __esm({
               isReexport: false,
               sourceModule: void 0
             });
-          } else if (ts3.isTypeAliasDeclaration(node) && this.hasExportModifier(node)) {
+          } else if (typescript_default.isTypeAliasDeclaration(node) && this.hasExportModifier(node)) {
             exports.push({
               name: node.name.text,
               type: "type",
@@ -62381,7 +62797,7 @@ var init_typescript_parser = __esm({
               isReexport: false,
               sourceModule: void 0
             });
-          } else if (ts3.isEnumDeclaration(node) && this.hasExportModifier(node)) {
+          } else if (typescript_default.isEnumDeclaration(node) && this.hasExportModifier(node)) {
             exports.push({
               name: node.name.text,
               type: "enum",
@@ -62390,9 +62806,9 @@ var init_typescript_parser = __esm({
               sourceModule: void 0
             });
           }
-          ts3.forEachChild(node, visit);
+          typescript_default.forEachChild(node, visit);
         };
-        ts3.forEachChild(ast, visit);
+        typescript_default.forEachChild(ast, visit);
         return exports;
       }
       /**
@@ -62401,12 +62817,12 @@ var init_typescript_parser = __esm({
       extractInterfaces(ast) {
         const interfaces = [];
         const visit = (node) => {
-          if (ts3.isInterfaceDeclaration(node)) {
+          if (typescript_default.isInterfaceDeclaration(node)) {
             interfaces.push(this.extractInterfaceDeclaration(node, ast));
           }
-          ts3.forEachChild(node, visit);
+          typescript_default.forEachChild(node, visit);
         };
-        ts3.forEachChild(ast, visit);
+        typescript_default.forEachChild(ast, visit);
         return interfaces;
       }
       /**
@@ -62462,11 +62878,11 @@ var init_typescript_parser = __esm({
       // Private Helper Methods
       // ============================================================================
       getScriptKind(filePath) {
-        if (filePath.endsWith(".tsx")) return ts3.ScriptKind.TSX;
-        if (filePath.endsWith(".ts")) return ts3.ScriptKind.TS;
-        if (filePath.endsWith(".jsx")) return ts3.ScriptKind.JSX;
-        if (filePath.endsWith(".js")) return ts3.ScriptKind.JS;
-        return ts3.ScriptKind.TS;
+        if (filePath.endsWith(".tsx")) return typescript_default.ScriptKind.TSX;
+        if (filePath.endsWith(".ts")) return typescript_default.ScriptKind.TS;
+        if (filePath.endsWith(".jsx")) return typescript_default.ScriptKind.JSX;
+        if (filePath.endsWith(".js")) return typescript_default.ScriptKind.JS;
+        return typescript_default.ScriptKind.TS;
       }
       extractFunctionDeclaration(node, sourceFile) {
         const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
@@ -62485,7 +62901,7 @@ var init_typescript_parser = __esm({
       }
       extractArrowFunctions(node, sourceFile, functions) {
         for (const declaration of node.declarationList.declarations) {
-          if (ts3.isIdentifier(declaration.name) && declaration.initializer && ts3.isArrowFunction(declaration.initializer)) {
+          if (typescript_default.isIdentifier(declaration.name) && declaration.initializer && typescript_default.isArrowFunction(declaration.initializer)) {
             const arrow = declaration.initializer;
             const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
@@ -62509,11 +62925,11 @@ var init_typescript_parser = __esm({
         const methods = [];
         const properties = [];
         for (const member of node.members) {
-          if (ts3.isMethodDeclaration(member) && member.name) {
+          if (typescript_default.isMethodDeclaration(member) && member.name) {
             methods.push(this.extractMethodDeclaration(member, sourceFile));
-          } else if (ts3.isPropertyDeclaration(member) && member.name) {
+          } else if (typescript_default.isPropertyDeclaration(member) && member.name) {
             properties.push(this.extractPropertyDeclaration(member, sourceFile));
-          } else if (ts3.isConstructorDeclaration(member)) {
+          } else if (typescript_default.isConstructorDeclaration(member)) {
             methods.push(this.extractConstructor(member, sourceFile));
             this.extractParameterProperties(member, properties, sourceFile);
           }
@@ -62522,9 +62938,9 @@ var init_typescript_parser = __esm({
         const implementsClause = [];
         if (node.heritageClauses) {
           for (const clause of node.heritageClauses) {
-            if (clause.token === ts3.SyntaxKind.ExtendsKeyword) {
+            if (clause.token === typescript_default.SyntaxKind.ExtendsKeyword) {
               extendsClause = clause.types[0]?.expression.getText(sourceFile);
-            } else if (clause.token === ts3.SyntaxKind.ImplementsKeyword) {
+            } else if (clause.token === typescript_default.SyntaxKind.ImplementsKeyword) {
               for (const type of clause.types) {
                 implementsClause.push(type.expression.getText(sourceFile));
               }
@@ -62578,7 +62994,7 @@ var init_typescript_parser = __esm({
         for (const param of node.parameters) {
           if (this.isParameterProperty(param)) {
             properties.push({
-              name: ts3.isIdentifier(param.name) ? param.name.text : param.name.getText(sourceFile),
+              name: typescript_default.isIdentifier(param.name) ? param.name.text : param.name.getText(sourceFile),
               type: param.type ? param.type.getText(sourceFile) : void 0,
               isStatic: false,
               isReadonly: this.hasReadonlyModifier(param),
@@ -62590,7 +63006,7 @@ var init_typescript_parser = __esm({
       }
       isParameterProperty(param) {
         return !!param.modifiers?.some(
-          (m74) => m74.kind === ts3.SyntaxKind.PublicKeyword || m74.kind === ts3.SyntaxKind.PrivateKeyword || m74.kind === ts3.SyntaxKind.ProtectedKeyword || m74.kind === ts3.SyntaxKind.ReadonlyKeyword
+          (m74) => m74.kind === typescript_default.SyntaxKind.PublicKeyword || m74.kind === typescript_default.SyntaxKind.PrivateKeyword || m74.kind === typescript_default.SyntaxKind.ProtectedKeyword || m74.kind === typescript_default.SyntaxKind.ReadonlyKeyword
         );
       }
       extractPropertyDeclaration(node, sourceFile) {
@@ -62614,9 +63030,9 @@ var init_typescript_parser = __esm({
             defaultImport = node.importClause.name.text;
           }
           if (node.importClause.namedBindings) {
-            if (ts3.isNamespaceImport(node.importClause.namedBindings)) {
+            if (typescript_default.isNamespaceImport(node.importClause.namedBindings)) {
               namespaceImport = node.importClause.namedBindings.name.text;
-            } else if (ts3.isNamedImports(node.importClause.namedBindings)) {
+            } else if (typescript_default.isNamedImports(node.importClause.namedBindings)) {
               for (const element of node.importClause.namedBindings.elements) {
                 namedImports.push({
                   name: element.propertyName?.text ?? element.name.text,
@@ -62636,7 +63052,7 @@ var init_typescript_parser = __esm({
       }
       extractExportDeclaration(node, exports) {
         const sourceModule = node.moduleSpecifier ? node.moduleSpecifier.text : void 0;
-        if (node.exportClause && ts3.isNamedExports(node.exportClause)) {
+        if (node.exportClause && typescript_default.isNamedExports(node.exportClause)) {
           for (const element of node.exportClause.elements) {
             exports.push({
               name: element.name.text,
@@ -62662,14 +63078,14 @@ var init_typescript_parser = __esm({
         const properties = [];
         const methods = [];
         for (const member of node.members) {
-          if (ts3.isPropertySignature(member) && member.name) {
+          if (typescript_default.isPropertySignature(member) && member.name) {
             properties.push({
               name: this.getPropertyName(member.name, sourceFile),
               type: member.type ? member.type.getText(sourceFile) : void 0,
               isOptional: !!member.questionToken,
               isReadonly: this.hasReadonlyModifier(member)
             });
-          } else if (ts3.isMethodSignature(member) && member.name) {
+          } else if (typescript_default.isMethodSignature(member) && member.name) {
             methods.push({
               name: this.getPropertyName(member.name, sourceFile),
               parameters: this.extractParameters(member.parameters),
@@ -62681,7 +63097,7 @@ var init_typescript_parser = __esm({
         const extendsClause = [];
         if (node.heritageClauses) {
           for (const clause of node.heritageClauses) {
-            if (clause.token === ts3.SyntaxKind.ExtendsKeyword) {
+            if (clause.token === typescript_default.SyntaxKind.ExtendsKeyword) {
               for (const type of clause.types) {
                 extendsClause.push(type.expression.getText(sourceFile));
               }
@@ -62703,7 +63119,7 @@ var init_typescript_parser = __esm({
         return parameters.map((param) => {
           const sourceFile = param.getSourceFile();
           return {
-            name: ts3.isIdentifier(param.name) ? param.name.text : param.name.getText(sourceFile),
+            name: typescript_default.isIdentifier(param.name) ? param.name.text : param.name.getText(sourceFile),
             type: param.type ? param.type.getText(sourceFile) : void 0,
             isOptional: !!param.questionToken || !!param.initializer,
             isRest: !!param.dotDotDotToken,
@@ -62716,49 +63132,49 @@ var init_typescript_parser = __esm({
         return typeParams.map((tp) => tp.name.text);
       }
       getPropertyName(name, sourceFile) {
-        if (ts3.isIdentifier(name)) {
+        if (typescript_default.isIdentifier(name)) {
           return name.text;
         }
-        if (ts3.isStringLiteral(name)) {
+        if (typescript_default.isStringLiteral(name)) {
           return name.text;
         }
-        if (ts3.isNumericLiteral(name)) {
+        if (typescript_default.isNumericLiteral(name)) {
           return name.text;
         }
         return name.getText(sourceFile);
       }
       getExportAssignmentName(node) {
-        if (ts3.isIdentifier(node.expression)) {
+        if (typescript_default.isIdentifier(node.expression)) {
           return node.expression.text;
         }
         return "default";
       }
       hasExportModifier(node) {
-        return ts3.canHaveModifiers(node) && !!ts3.getModifiers(node)?.some((m74) => m74.kind === ts3.SyntaxKind.ExportKeyword);
+        return typescript_default.canHaveModifiers(node) && !!typescript_default.getModifiers(node)?.some((m74) => m74.kind === typescript_default.SyntaxKind.ExportKeyword);
       }
       hasDefaultModifier(node) {
-        return ts3.canHaveModifiers(node) && !!ts3.getModifiers(node)?.some((m74) => m74.kind === ts3.SyntaxKind.DefaultKeyword);
+        return typescript_default.canHaveModifiers(node) && !!typescript_default.getModifiers(node)?.some((m74) => m74.kind === typescript_default.SyntaxKind.DefaultKeyword);
       }
       hasAsyncModifier(node) {
-        return ts3.canHaveModifiers(node) && !!ts3.getModifiers(node)?.some((m74) => m74.kind === ts3.SyntaxKind.AsyncKeyword);
+        return typescript_default.canHaveModifiers(node) && !!typescript_default.getModifiers(node)?.some((m74) => m74.kind === typescript_default.SyntaxKind.AsyncKeyword);
       }
       hasStaticModifier(node) {
-        return ts3.canHaveModifiers(node) && !!ts3.getModifiers(node)?.some((m74) => m74.kind === ts3.SyntaxKind.StaticKeyword);
+        return typescript_default.canHaveModifiers(node) && !!typescript_default.getModifiers(node)?.some((m74) => m74.kind === typescript_default.SyntaxKind.StaticKeyword);
       }
       hasAbstractModifier(node) {
-        return ts3.canHaveModifiers(node) && !!ts3.getModifiers(node)?.some((m74) => m74.kind === ts3.SyntaxKind.AbstractKeyword);
+        return typescript_default.canHaveModifiers(node) && !!typescript_default.getModifiers(node)?.some((m74) => m74.kind === typescript_default.SyntaxKind.AbstractKeyword);
       }
       hasReadonlyModifier(node) {
-        return ts3.canHaveModifiers(node) && !!ts3.getModifiers(node)?.some((m74) => m74.kind === ts3.SyntaxKind.ReadonlyKeyword);
+        return typescript_default.canHaveModifiers(node) && !!typescript_default.getModifiers(node)?.some((m74) => m74.kind === typescript_default.SyntaxKind.ReadonlyKeyword);
       }
       getVisibility(node) {
-        if (!ts3.canHaveModifiers(node)) return "public";
-        const modifiers = ts3.getModifiers(node);
+        if (!typescript_default.canHaveModifiers(node)) return "public";
+        const modifiers = typescript_default.getModifiers(node);
         if (!modifiers) return "public";
-        if (modifiers.some((m74) => m74.kind === ts3.SyntaxKind.PrivateKeyword)) {
+        if (modifiers.some((m74) => m74.kind === typescript_default.SyntaxKind.PrivateKeyword)) {
           return "private";
         }
-        if (modifiers.some((m74) => m74.kind === ts3.SyntaxKind.ProtectedKeyword)) {
+        if (modifiers.some((m74) => m74.kind === typescript_default.SyntaxKind.ProtectedKeyword)) {
           return "protected";
         }
         return "public";
@@ -66621,14 +67037,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;
       /**
@@ -66753,11 +67177,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,
@@ -100311,7 +100742,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"() {
@@ -100821,7 +101252,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);
@@ -101165,7 +101596,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 {
@@ -113834,12 +114265,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;
@@ -113847,7 +114278,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;
@@ -113884,7 +114315,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
@@ -113996,13 +114427,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);
   }
 });
 
@@ -126419,12 +126850,12 @@ __export(agent_booster_wasm_exports, {
   transform: () => transform,
   warmup: () => warmup
 });
-import { createRequire as createRequire6 } from "module";
+import { createRequire as createRequire7 } from "module";
 async function loadWasm() {
   if (wasmModule) return true;
   if (loadError) return false;
   try {
-    const require3 = createRequire6(import.meta.url);
+    const require3 = createRequire7(import.meta.url);
     wasmModule = require3("./agent_booster_wasm.js");
     if (!wasmModule) {
       throw new Error("WASM module loaded but is null");
@@ -128776,11 +129207,11 @@ __export(hnswlib_node_exports, {
   init: () => init6,
   pipeline: () => pipeline7
 });
-import { createRequire as createRequire7 } from "module";
+import { createRequire as createRequire8 } from "module";
 var __require7, __mod6, hnswlib_node_default, RuvectorLayer6, TensorCompress6, differentiableSearch6, hierarchicalForward6, getCompressionLevel6, init6, FlashAttention6, DotProductAttention6, MultiHeadAttention6, HyperbolicAttention6, LinearAttention6, MoEAttention6, SonaEngine6, pipeline7;
 var init_hnswlib_node = __esm({
   "native-require:hnswlib-node"() {
-    __require7 = createRequire7(import.meta.url);
+    __require7 = createRequire8(import.meta.url);
     __mod6 = __require7("hnswlib-node");
     hnswlib_node_default = __mod6;
     ({
@@ -143929,8 +144360,8 @@ var init_trajectory_bridge = __esm({
         try {
           const { join: join32 } = await import("path");
           const { existsSync: existsSync21, mkdirSync: mkdirSync6 } = await import("fs");
-          const { createRequire: createRequire12 } = await import("module");
-          const require3 = createRequire12(import.meta.url);
+          const { createRequire: createRequire13 } = await import("module");
+          const require3 = createRequire13(import.meta.url);
           const { openDatabase: openDatabase2 } = require3("../../shared/safe-db.js");
           const dbPath = join32(this.options.projectRoot, ".agentic-qe", "trajectories.db");
           const dir = join32(this.options.projectRoot, ".agentic-qe");
@@ -147836,11 +148267,11 @@ __export(prime_radiant_advanced_wasm_exports, {
   init: () => init7,
   pipeline: () => pipeline8
 });
-import { createRequire as createRequire8 } from "module";
+import { createRequire as createRequire9 } from "module";
 var __require8, __mod7, prime_radiant_advanced_wasm_default, RuvectorLayer7, TensorCompress7, differentiableSearch7, hierarchicalForward7, getCompressionLevel7, init7, FlashAttention7, DotProductAttention7, MultiHeadAttention7, HyperbolicAttention7, LinearAttention7, MoEAttention7, SonaEngine7, pipeline8;
 var init_prime_radiant_advanced_wasm = __esm({
   "native-require:prime-radiant-advanced-wasm"() {
-    __require8 = createRequire8(import.meta.url);
+    __require8 = createRequire9(import.meta.url);
     __mod7 = __require8("prime-radiant-advanced-wasm");
     prime_radiant_advanced_wasm_default = __mod7;
     ({
@@ -147863,7 +148294,7 @@ var init_prime_radiant_advanced_wasm = __esm({
 });
 
 // src/integrations/coherence/wasm-loader.ts
-import { createRequire as createRequire9 } from "node:module";
+import { createRequire as createRequire10 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { dirname as dirname4, join as join23 } from "node:path";
 import { readFileSync as readFileSync13, existsSync as existsSync15 } from "node:fs";
@@ -148125,7 +148556,7 @@ var init_wasm_loader = __esm({
           return false;
         }
         try {
-          const require3 = createRequire9(import.meta.url);
+          const require3 = createRequire10(import.meta.url);
           const wasmPaths = [
             (() => {
               try {
@@ -148333,7 +148764,7 @@ var init_wasm_loader = __esm({
       async attemptLoad() {
         let require3;
         try {
-          require3 = createRequire9(import.meta.url);
+          require3 = createRequire10(import.meta.url);
         } catch {
           require3 = globalThis.require || (await import("module")).createRequire(__filename);
         }
@@ -148577,11 +149008,11 @@ __export(rvf_node_exports, {
   init: () => init8,
   pipeline: () => pipeline9
 });
-import { createRequire as createRequire10 } from "module";
+import { createRequire as createRequire11 } from "module";
 var __require9, __mod8, rvf_node_default, RuvectorLayer8, TensorCompress8, differentiableSearch8, hierarchicalForward8, getCompressionLevel8, init8, FlashAttention8, DotProductAttention8, MultiHeadAttention8, HyperbolicAttention8, LinearAttention8, MoEAttention8, SonaEngine8, pipeline9;
 var init_rvf_node = __esm({
   "native-require:@ruvector/rvf-node"() {
-    __require9 = createRequire10(import.meta.url);
+    __require9 = createRequire11(import.meta.url);
     __mod8 = __require9("@ruvector/rvf-node");
     rvf_node_default = __mod8;
     ({
@@ -172087,7 +172518,7 @@ async function handleAQEHealth() {
       success: true,
       data: {
         status: healthStatus,
-        version: true ? "3.7.10" : "3.7.2",
+        version: true ? "3.7.12" : "3.7.2",
         loadedDomains: domainCount,
         memory: memoryStats,
         hnsw: hnswStats,
@@ -174441,7 +174872,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());
@@ -178207,7 +178641,7 @@ var MCPProtocolServer = class {
     return {
       name: this.config.name,
       version: this.config.version,
-      protocolVersion: "2024-11-05"
+      protocolVersion: "2025-11-25"
       // MCP protocol version
     };
   }
@@ -178283,7 +178717,7 @@ var MCPProtocolServer = class {
     }
     this.initialized = true;
     return {
-      protocolVersion: "2024-11-05",
+      protocolVersion: "2025-11-25",
       capabilities: this.getCapabilities(),
       serverInfo: this.getServerInfo()
     };
@@ -180651,9 +181085,9 @@ function generateSignature(payload, secret, timestamp) {
   return hmac.digest("hex");
 }
 function generateSignatureHeader(payload, secret, timestamp) {
-  const ts4 = timestamp ?? Date.now();
-  const signature = generateSignature(payload, secret, ts4);
-  return `t=${ts4},${SIGNATURE_VERSION}=${signature}`;
+  const ts = timestamp ?? Date.now();
+  const signature = generateSignature(payload, secret, ts);
+  return `t=${ts},${SIGNATURE_VERSION}=${signature}`;
 }
 
 // src/adapters/a2a/notifications/subscription-store.ts
@@ -184474,7 +184908,7 @@ function createHTTPServer(config) {
 }
 
 // src/mcp/entry.ts
-import { createRequire as createRequire11 } from "module";
+import { createRequire as createRequire12 } from "module";
 
 // src/init/token-bootstrap.ts
 init_token_optimizer_service();
@@ -185302,10 +185736,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 },
@@ -185695,7 +186129,7 @@ init_global_instance();
 import { readFileSync as readFileSync17 } from "node:fs";
 import { resolve as resolve9, dirname as dirname10 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-var require2 = createRequire11(import.meta.url);
+var require2 = createRequire12(import.meta.url);
 var pkg = require2("../../package.json");
 var server = null;
 var httpServer = null;