agentic-qe 3.7.9 → 3.7.11

package/dist/cli/bundle.js

@@ -1500,12 +1500,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"
     ]);
     IDENTIFIER_REGEX = /^[a-z_][a-z0-9_]{0,62}$/;
   }
@@ -5699,10 +5707,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"];
@@ -5719,8 +5728,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;
@@ -5806,9 +5816,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,
@@ -5857,10 +5868,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";
@@ -5897,8 +5909,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];
@@ -5925,7 +5938,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(".");
@@ -5966,10 +5980,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";
@@ -6007,8 +6022,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];
@@ -6034,7 +6050,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(),
@@ -6080,6 +6097,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];
@@ -6187,7 +6208,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];
@@ -6247,7 +6268,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(),
@@ -6292,8 +6314,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";
@@ -6320,8 +6343,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];
@@ -6387,10 +6411,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";
@@ -6429,8 +6457,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];
@@ -6503,10 +6532,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();
@@ -6540,8 +6570,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];
@@ -44065,7 +44096,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 [];
@@ -49082,13 +49113,30 @@ var ContinueGateIntegration = class _ContinueGateIntegration {
   /**
    * 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();
@@ -49169,7 +49217,35 @@ var ContinueGateIntegration = class _ContinueGateIntegration {
         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
@@ -49246,21 +49322,25 @@ var ContinueGateIntegration = class _ContinueGateIntegration {
     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
     };
   }
   /**
@@ -49340,12 +49420,27 @@ var MemoryWriteGateIntegration = class {
   /**
    * 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;
   }
   /**
@@ -49359,7 +49454,31 @@ var MemoryWriteGateIntegration = class {
     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
@@ -49495,15 +49614,17 @@ var MemoryWriteGateIntegration = class {
     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
     };
   }
   /**
@@ -49623,12 +49744,38 @@ var TrustAccumulatorIntegration = class {
   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;
   }
   /**
@@ -49652,6 +49799,13 @@ var TrustAccumulatorIntegration = class {
     }
     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);
@@ -50013,14 +50167,32 @@ var DeterministicGatewayIntegration = class {
   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
@@ -50145,6 +50317,23 @@ var DeterministicGatewayIntegration = class {
         };
       }
     }
+    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
@@ -50447,6 +50636,7 @@ var EvolutionPipelineIntegration = class _EvolutionPipelineIntegration {
   rules = /* @__PURE__ */ new Map();
   variantTests = /* @__PURE__ */ new Map();
   taskOutcomes = /* @__PURE__ */ new Map();
+  guidanceEvolution = null;
   initialized = false;
   // KV persistence
   db = null;
@@ -50469,6 +50659,10 @@ var EvolutionPipelineIntegration = class _EvolutionPipelineIntegration {
   };
   /**
    * 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;
@@ -50480,6 +50674,19 @@ var EvolutionPipelineIntegration = class _EvolutionPipelineIntegration {
       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");
   }
@@ -50594,6 +50801,21 @@ var EvolutionPipelineIntegration = class _EvolutionPipelineIntegration {
         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}`);
     }
   }
@@ -50623,6 +50845,24 @@ var EvolutionPipelineIntegration = class _EvolutionPipelineIntegration {
         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}`);
     }
   }
@@ -51345,9 +51585,15 @@ var AdversarialDefenseIntegration = class {
   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;
@@ -51355,6 +51601,24 @@ var AdversarialDefenseIntegration = class {
       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
@@ -51366,6 +51630,25 @@ var AdversarialDefenseIntegration = class {
     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: context2?.agentId || "", toolName: context2?.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);
@@ -51509,6 +51792,37 @@ var AdversarialDefenseIntegration = class {
     }
     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
    */
@@ -52777,6 +53091,7 @@ var ProofEnvelopeIntegration = class {
   kernel;
   chain = [];
   signingKey = "";
+  guidanceProofChain = null;
   initialized = false;
   envelopeIndex = /* @__PURE__ */ new Map();
   /**
@@ -52796,6 +53111,19 @@ var ProofEnvelopeIntegration = class {
     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;
   }
   /**
@@ -52899,6 +53227,31 @@ var ProofEnvelopeIntegration = class {
     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
@@ -54898,6 +55251,7 @@ var ShardRetrieverIntegration = class {
   cacheMisses = 0;
   lastCacheCleanup = null;
   parseErrors = [];
+  guidanceRetriever = null;
   initialized = false;
   basePath;
   constructor(basePath) {
@@ -54905,6 +55259,10 @@ var ShardRetrieverIntegration = class {
   }
   /**
    * 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;
@@ -54912,6 +55270,19 @@ var ShardRetrieverIntegration = class {
       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;
   }
@@ -54978,6 +55349,11 @@ var ShardRetrieverIntegration = class {
   }
   /**
    * 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, context2) {
     if (!isShardRetrieverEnabled()) {
@@ -54986,9 +55362,31 @@ var ShardRetrieverIntegration = class {
     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}: ${context2.intent || ""} ${(context2.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, { ...context2, taskType });
+      let score = this.calculateRelevance(shard, { ...context2, taskType });
+      if (guidanceRelevantDomains.has(shard.domain)) {
+        score = Math.min(1, score + 0.1);
+      }
       if (score >= flags.relevanceThreshold) {
         scoredShards.push({ shard, score });
       }
@@ -78317,9 +78715,17 @@ var TestBasedVerifier = class {
 };
 
 // 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 = promisify3(exec3);
+var execFileAsync = promisify3(execFile);
+var 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"] }]
+]);
 var OutputBasedVerifier = class {
   config;
   /**
@@ -78444,11 +78850,18 @@ var OutputBasedVerifier = class {
   }
   /**
    * 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,
@@ -109761,7 +110174,7 @@ init_error_utils();
 init_safe_json();
 init_crypto_random();
 import * as net from "net";
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 var DEFAULT_CONFIG48 = {
   defaultTimeout: 6e4,
   // 60 seconds
@@ -110260,7 +110673,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}`);
           resolve22(false);
@@ -110604,7 +111017,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 {
@@ -119980,13 +120393,13 @@ DomainServiceRegistry.register(
 // src/domains/security-compliance/services/semgrep-integration.ts
 init_error_utils();
 init_safe_json();
-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";
-var execFileAsync = promisify4(execFile2);
+var execFileAsync2 = promisify4(execFile3);
 async function isSemgrepAvailable() {
   try {
-    await execFileAsync("semgrep", ["--version"], { timeout: 5e3 });
+    await execFileAsync2("semgrep", ["--version"], { timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -119994,7 +120407,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;
@@ -120031,7 +120444,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
@@ -133726,7 +134139,7 @@ var ALL_DOMAINS2 = [
   "enterprise-integration"
 ];
 function getAQEVersion() {
-  return true ? "3.7.9" : "3.0.0";
+  return true ? "3.7.11" : "3.0.0";
 }
 function createDefaultConfig(projectName, projectRoot) {
   return {
@@ -138977,7 +139390,7 @@ appendFileSync(logFile, '[' + ts + '] Starting AQE v3 Worker Daemon...\\n');
 // Find the best way to run aqe-mcp
 const candidates = [
   join(projectRoot, 'node_modules', '.bin', 'aqe-mcp'),
-  join(projectRoot, 'node_modules', 'agentic-qe', 'v3', 'dist', 'mcp', 'bundle.js'),
+  join(projectRoot, 'node_modules', 'agentic-qe', 'dist', 'mcp', 'bundle.js'),
 ];
 
 let mcpCmd, mcpArgs;
@@ -139167,7 +139580,7 @@ try {
     if (existsSync39(localMcpBin)) {
       return { command: localMcpBin, args: [] };
     }
-    const localBundle = join43(projectRoot, "node_modules", "agentic-qe", "v3", "dist", "mcp", "bundle.js");
+    const localBundle = join43(projectRoot, "node_modules", "agentic-qe", "dist", "mcp", "bundle.js");
     if (existsSync39(localBundle)) {
       return { command: "node", args: [localBundle] };
     }
@@ -162537,15 +162950,15 @@ function findMcpEntry() {
   const __filename7 = fileURLToPath10(import.meta.url);
   const __dirname7 = dirname27(__filename7);
   const candidates = [
-    // 1. Bundled dist (production)
-    join64(__dirname7, "..", "..", "mcp", "bundle.js"),
-    // 2. Compiled dist
-    join64(__dirname7, "..", "..", "mcp", "entry.js"),
-    // 3. Source (development with tsx)
-    join64(__dirname7, "..", "..", "mcp", "entry.ts"),
-    // 4. From node_modules (when used as dependency)
-    join64(process.cwd(), "node_modules", "agentic-qe", "v3", "dist", "mcp", "bundle.js"),
-    join64(process.cwd(), "node_modules", "agentic-qe", "v3", "dist", "mcp", "entry.js")
+    // 1. Sibling bundle in dist/ (production: dist/cli/ -> dist/mcp/)
+    join64(__dirname7, "..", "mcp", "bundle.js"),
+    // 2. Sibling compiled in dist/
+    join64(__dirname7, "..", "mcp", "entry.js"),
+    // 3. Source (development with tsx: src/cli/ -> src/mcp/)
+    join64(__dirname7, "..", "mcp", "entry.ts"),
+    // 4. From node_modules (when used as dependency — flat structure since v3.7.5)
+    join64(process.cwd(), "node_modules", "agentic-qe", "dist", "mcp", "bundle.js"),
+    join64(process.cwd(), "node_modules", "agentic-qe", "dist", "mcp", "entry.js")
   ];
   for (const candidate of candidates) {
     if (existsSync66(candidate)) {
@@ -162952,7 +163365,7 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command20();
-var VERSION = true ? "3.7.9" : "0.0.0-dev";
+var VERSION = true ? "3.7.11" : "0.0.0-dev";
 program.name("aqe").description("Agentic QE - Domain-Driven Quality Engineering").version(VERSION);
 var registry2 = createCommandRegistry(context, cleanupAndExit, ensureInitialized, ensureInitializedStrict);
 registry2.registerAll(program);
@@ -163156,14 +163569,14 @@ workflowCmd.command("list").description("List workflows").option("-s, --schedule
       if (activeExecutions.length === 0) {
         console.log(chalk33.gray("  No active executions\n"));
       } else {
-        for (const exec4 of activeExecutions) {
-          const statusColor = exec4.status === "running" ? chalk33.yellow : chalk33.gray;
-          console.log(`  ${statusColor("*")} ${chalk33.white(exec4.workflowName)}`);
-          console.log(chalk33.gray(`     Execution: ${exec4.executionId}`));
-          console.log(chalk33.gray(`     Status: ${exec4.status}`));
-          console.log(chalk33.gray(`     Progress: ${exec4.progress}%`));
-          if (exec4.currentSteps.length > 0) {
-            console.log(chalk33.gray(`     Current: ${exec4.currentSteps.join(", ")}`));
+        for (const exec3 of activeExecutions) {
+          const statusColor = exec3.status === "running" ? chalk33.yellow : chalk33.gray;
+          console.log(`  ${statusColor("*")} ${chalk33.white(exec3.workflowName)}`);
+          console.log(chalk33.gray(`     Execution: ${exec3.executionId}`));
+          console.log(chalk33.gray(`     Status: ${exec3.status}`));
+          console.log(chalk33.gray(`     Progress: ${exec3.progress}%`));
+          if (exec3.currentSteps.length > 0) {
+            console.log(chalk33.gray(`     Current: ${exec3.currentSteps.join(", ")}`));
           }
           console.log("");
         }