jules-orchestrator-kit 0.42.0 → 0.51.0

package/src/assertions.mjs

@@ -3,6 +3,12 @@ import { resolve, relative, join, sep } from "node:path";
 import { gzipSync } from "node:zlib";
 import { checkAssetIntegrity } from "./asset-integrity.mjs";
 import { checkRulesBudget } from "./rules-budget.mjs";
+import { runMutationTest } from "./mutation.mjs";
+import { checkTestTampering } from "./security.mjs";
+import { runV8Coverage, calculateDiffCoverage } from "./coverage.mjs";
+import { runStabilityProbe } from "./stability.mjs";
+import { measureEventLoopDelay } from "./perf.mjs";
+import { diffText } from "./git.mjs";
 
 /**
  * Normalizes path to POSIX slashes.
@@ -487,6 +493,204 @@ export function assertFileExists(config = {}, root = process.cwd()) {
   };
 }
 
+/**
+ * Asserts that mutation testing score meets minimum threshold.
+ */
+export function assertMutation(config = {}, root = process.cwd()) {
+  const minScore = typeof config.minScore === "number" ? config.minScore : 80;
+  const maxMutants = typeof config.maxMutants === "number" ? config.maxMutants : 20;
+  const testCmd = config.testCmd || config.cmd || "npm test";
+
+  const report = runMutationTest({
+    root,
+    minScore,
+    maxMutants,
+    testCmd,
+    base: config.base || "main",
+    mode: config.mode || "working-tree",
+    files: Array.isArray(config.files) ? config.files : config.file ? [config.file] : undefined,
+    executor: config.executor,
+  });
+
+  const diagnostics = [];
+  if (!report.ok) {
+    diagnostics.push(
+      `Mutation score ${report.mutationScore}% below required threshold of ${minScore}% (${report.killedMutants}/${report.totalMutants} killed, ${report.survivedMutants} survived).`
+    );
+    for (const survivor of report.survivors) {
+      diagnostics.push(`  - Survivor in ${survivor.mutant.file}:${survivor.mutant.line}: "${survivor.mutant.mutatedLine.trim()}" (${survivor.mutant.description})`);
+    }
+  }
+
+  return {
+    ok: report.ok,
+    mutationScore: report.mutationScore,
+    minScore: report.minScore,
+    totalMutants: report.totalMutants,
+    killedMutants: report.killedMutants,
+    survivedMutants: report.survivedMutants,
+    diagnostics,
+    metrics: {
+      mutationScore: report.mutationScore,
+      minScore: report.minScore,
+      totalMutants: report.totalMutants,
+      killedMutants: report.killedMutants,
+      survivedMutants: report.survivedMutants,
+    },
+  };
+}
+
+/**
+ * Asserts that no test file assertion weakening or skip injections occurred.
+ */
+export function assertTestIntegrity(config = {}, root = process.cwd()) {
+  let diffStr = config.diffStr;
+  if (!diffStr) {
+    try {
+      diffStr = diffText(root, config.base || "main", config.mode || "working-tree");
+    } catch (_) {
+      diffStr = "";
+    }
+  }
+
+  const res = checkTestTampering(diffStr, config);
+  const diagnostics = (res.violations || []).map((v) => v.reason);
+
+  return {
+    ok: res.ok,
+    violations: res.violations || [],
+    diagnostics,
+    metrics: {
+      violationCount: res.violations?.length || 0,
+    },
+  };
+}
+
+/**
+ * Asserts that newly added implementation lines meet the minimum diff coverage percentage.
+ */
+export function assertDiffCoverage(config = {}, root = process.cwd()) {
+  let diffStr = config.diffStr;
+  if (!diffStr) {
+    try {
+      diffStr = diffText(root, config.base || "main", config.mode || "working-tree");
+    } catch (_) {
+      diffStr = "";
+    }
+  }
+
+  const covRes = runV8Coverage(config.cmd || config.testCmd, {
+    root,
+    timeoutMs: config.timeoutMs,
+  });
+
+  const diffCov = calculateDiffCoverage(covRes.coverageByFile, diffStr, {
+    root,
+    minCoverage: typeof config.minCoverage === "number" ? config.minCoverage : (typeof config.min === "number" ? config.min : 100),
+  });
+
+  const diagnostics = [];
+  if (!diffCov.ok) {
+    diagnostics.push(diffCov.summary);
+    for (const [file, missed] of Object.entries(diffCov.missedByFile)) {
+      diagnostics.push(`Uncovered added lines in ${file}: lines ${missed.join(", ")}`);
+    }
+  }
+
+  return {
+    ok: diffCov.ok && covRes.ok,
+    score: diffCov.score,
+    minCoverage: diffCov.minCoverage,
+    totalLines: diffCov.totalLines,
+    coveredLines: diffCov.coveredLines,
+    missedLines: diffCov.missedLines,
+    missedByFile: diffCov.missedByFile,
+    diagnostics,
+    metrics: {
+      diffCoverageScore: diffCov.score,
+      uncoveredLinesCount: diffCov.missedLines,
+    },
+  };
+}
+
+/**
+ * Asserts that a test suite executes deterministically across multiple consecutive repetitions.
+ */
+export function assertTestStability(config = {}, root = process.cwd()) {
+  const repeat = config.repeat || config.iterations || 5;
+  const minPassRate = typeof config.minPassRate === "number" ? config.minPassRate : 1.0;
+
+  const probe = runStabilityProbe(config.cmd || config.testCmd, {
+    root,
+    repeat,
+    minPassRate,
+    timeoutMs: config.timeoutMs,
+  });
+
+  const diagnostics = [];
+  if (!probe.ok) {
+    diagnostics.push(probe.summary);
+    const failedRuns = probe.runs.filter((r) => !r.pass);
+    for (const r of failedRuns) {
+      diagnostics.push(`Iteration ${r.iteration} failed (exit ${r.exitCode})`);
+    }
+  }
+
+  return {
+    ok: probe.ok,
+    repeat: probe.repeat,
+    passes: probe.passes,
+    failures: probe.failures,
+    passRate: probe.passRate,
+    oscillation: probe.oscillation,
+    diagnostics,
+    metrics: {
+      passRate: probe.passRate,
+      oscillation: probe.oscillation,
+      failuresCount: probe.failures,
+    },
+  };
+}
+
+/**
+ * Asserts that Node.js Event Loop delay remains within acceptable thresholds during execution.
+ */
+export function assertEventLoopLag(config = {}, root = process.cwd()) {
+  const maxDelayMs = config.maxDelayMs || config.maxMs || config.thresholdMs || 50;
+  const resolution = config.resolution || 10;
+
+  const res = measureEventLoopDelay(config.cmd || config.testCmd, {
+    root,
+    maxDelayMs,
+    resolution,
+    timeoutMs: config.timeoutMs,
+  });
+
+  const diagnostics = [];
+  if (!res.ok) {
+    diagnostics.push(res.summary);
+    if (res.exitCode !== 0) {
+      diagnostics.push(`Command failed with exit code ${res.exitCode}`);
+    } else {
+      diagnostics.push(`Event loop delay exceeded threshold: p99=${res.p99Ms}ms (max allowed: ${maxDelayMs}ms)`);
+    }
+  }
+
+  return {
+    ok: res.ok,
+    maxMs: res.maxMs,
+    p99Ms: res.p99Ms,
+    meanMs: res.meanMs,
+    thresholdMs: maxDelayMs,
+    diagnostics,
+    metrics: {
+      eventLoopP99Ms: res.p99Ms,
+      eventLoopMaxMs: res.maxMs,
+      eventLoopMeanMs: res.meanMs,
+    },
+  };
+}
+
 /**
  * Dispatches and executes an assertion primitive.
  */
@@ -543,6 +747,46 @@ export function runAssertion(stage = {}, root = process.cwd()) {
       break;
     }
 
+    case "mutation":
+    case "mutation-testing":
+    case "mutation-score":
+    case "mutation_score":
+      res = assertMutation(stage, root);
+      break;
+
+    case "test-integrity":
+    case "anti-tamper":
+    case "test-tamper":
+    case "test_integrity":
+      res = assertTestIntegrity(stage, root);
+      break;
+
+    case "diff-coverage":
+    case "diff_coverage":
+    case "coverage":
+    case "patch-coverage":
+    case "patch_coverage":
+    case "v8-coverage":
+      res = assertDiffCoverage(stage, root);
+      break;
+
+    case "test-stability":
+    case "test_stability":
+    case "stability":
+    case "flaky-probe":
+    case "stability-probe":
+      res = assertTestStability(stage, root);
+      break;
+
+    case "event-loop-lag":
+    case "event-loop-delay":
+    case "event_loop_lag":
+    case "event_loop_delay":
+    case "perf-lag":
+    case "perf_lag":
+      res = assertEventLoopLag(stage, root);
+      break;
+
     case "exists":
     case "file-exists":
     case "not-exists": {

package/src/config.mjs

@@ -79,6 +79,31 @@ export function normalizePath(p) {
   return p.split(sep).join("/").replace(/\\/g, "/");
 }
 
+/**
+ * True when a path is a Windows absolute path and therefore can never name a
+ * file inside a repository checked out to a normal relative location.
+ *
+ * Covered spellings (after `normalizePath` folds `\` to `/`):
+ *
+ *   - Drive-qualified: `C:/...`, `C:\...`
+ *   - Drive-relative:  `C:foo` — on Windows this resolves against the *current
+ *     directory of drive C:*, which is never the repository root and so is an
+ *     escape even without a leading slash.
+ *   - UNC: `//server/share`, `\\server\share`
+ *
+ * A POSIX absolute path (`/etc/passwd`) is intentionally NOT matched here:
+ * the existing `startsWith("/")` check already covers it, and the two spellings
+ * need to stay distinguishable in messages.
+ *
+ * @param {string} p
+ * @returns {boolean}
+ */
+export function isWindowsAbsolutePath(p) {
+  if (!p || typeof p !== "string") return false;
+  const norm = normalizePath(p);
+  return /^[A-Za-z]:/.test(norm) || norm.startsWith("//");
+}
+
 /**
  * Reduces a repo-relative path to a canonical form for pattern matching:
  * separators normalised, duplicate slashes collapsed, `.` segments dropped,

package/src/coverage.mjs

@@ -0,0 +1,328 @@
+import { readFileSync, readdirSync, mkdtempSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join, resolve, relative, isAbsolute } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import { resolveVerify } from "./config.mjs";
+
+/**
+ * Checks if a file path should be excluded from diff coverage enforcement.
+ * Excludes test files, configs, documentation, and agent rules.
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function isExcludedFromCoverage(filePath = "") {
+  if (!filePath) return true;
+  const norm = filePath.replace(/\\/g, "/").toLowerCase();
+  if (
+    norm.startsWith(".agent/") ||
+    norm.startsWith(".github/") ||
+    norm.startsWith(".git/") ||
+    norm.startsWith("test/") ||
+    norm.startsWith("tests/") ||
+    norm.includes("/__tests__/") ||
+    norm.includes(".test.") ||
+    norm.includes(".spec.") ||
+    norm.includes("_test.") ||
+    norm.endsWith(".md") ||
+    norm.endsWith(".json") ||
+    norm.endsWith(".yml") ||
+    norm.endsWith(".yaml") ||
+    norm.endsWith(".lock")
+  ) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Maps V8 function range offsets to 1-indexed line hit counts.
+ * @param {string} sourceContent - Full text of source file
+ * @param {Array<object>} v8Functions - Functions array from V8 coverage JSON
+ * @returns {Map<number, number>} Map of lineNo -> hitCount
+ */
+export function mapV8RangesToLines(sourceContent = "", v8Functions = []) {
+  if (!sourceContent || !Array.isArray(v8Functions) || v8Functions.length === 0) {
+    return new Map();
+  }
+
+  const lines = sourceContent.split("\n");
+  const lineRanges = [];
+  let currentOffset = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const start = currentOffset;
+    const end = currentOffset + lines[i].length;
+    lineRanges.push({ lineNo: i + 1, start, end, text: lines[i] });
+    currentOffset = end + 1;
+  }
+
+  const allRanges = [];
+  for (const fn of v8Functions) {
+    if (Array.isArray(fn.ranges)) {
+      for (const r of fn.ranges) {
+        allRanges.push(r);
+      }
+    }
+  }
+
+  // Sort ranges: broader outer ranges first
+  allRanges.sort((a, b) => {
+    if (a.startOffset !== b.startOffset) return a.startOffset - b.startOffset;
+    return b.endOffset - a.endOffset;
+  });
+
+  const lineHits = new Map();
+
+  for (const { lineNo, start, text } of lineRanges) {
+    const trimmed = text.trim();
+    if (
+      !trimmed ||
+      trimmed.startsWith("//") ||
+      trimmed.startsWith("/*") ||
+      trimmed.startsWith("*") ||
+      trimmed.startsWith("import ") ||
+      trimmed.startsWith("export default {") ||
+      trimmed === "};" ||
+      trimmed === "}"
+    ) {
+      continue;
+    }
+
+    const nonWsStart = start + text.search(/\S/);
+    const nonWsEnd = start + text.trimEnd().length;
+
+    let count = 0;
+    let matched = false;
+
+    for (const r of allRanges) {
+      if (r.startOffset <= nonWsStart && nonWsEnd <= r.endOffset) {
+        count = r.count;
+        matched = true;
+      }
+    }
+
+    if (matched) {
+      lineHits.set(lineNo, count);
+    }
+  }
+
+  return lineHits;
+}
+
+/**
+ * Spawns the verification test command with NODE_V8_COVERAGE and collects raw coverage maps.
+ * @param {string} [testCmd] - Command to execute (defaults to package test cmd)
+ * @param {object} [options]
+ * @param {string} [options.root=process.cwd()]
+ * @param {number} [options.timeoutMs=60000]
+ * @returns {object} { ok, coverageFiles, coverageByFile, stdout, stderr, exitCode }
+ */
+export function runV8Coverage(testCmd, options = {}) {
+  const root = options.root || process.cwd();
+  const cmd = testCmd || resolveVerify(root).testCmd || "npm test";
+  const timeoutMs = options.timeoutMs || 60000;
+
+  const tempCoverageDir = mkdtempSync(join(tmpdir(), "jules-v8-cov-"));
+
+  try {
+    const env = {
+      ...process.env,
+      NODE_V8_COVERAGE: tempCoverageDir,
+    };
+    // Strip child test runner flags to avoid collisions
+    for (const k of Object.keys(env)) {
+      if (k.startsWith("NODE_TEST_") || k.startsWith("NODE_CHANNEL_")) {
+        delete env[k];
+      }
+    }
+
+    let stdout = "";
+    let stderr = "";
+    let exitCode = 0;
+
+    try {
+      stdout = execSync(cmd, {
+        cwd: root,
+        env,
+        timeout: timeoutMs,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      });
+    } catch (err) {
+      exitCode = err.status || 1;
+      stdout = err.stdout ? String(err.stdout) : "";
+      stderr = err.stderr ? String(err.stderr) : err.message;
+    }
+
+    const coverageByFile = new Map();
+    const files = existsSync(tempCoverageDir) ? readdirSync(tempCoverageDir) : [];
+
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const fullPath = join(tempCoverageDir, file);
+      try {
+        const content = readFileSync(fullPath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed.result)) {
+          for (const item of parsed.result) {
+            if (!item.url || item.url.startsWith("node:")) continue;
+            let relPath = item.url;
+            if (relPath.startsWith("file://")) {
+              try {
+                relPath = fileURLToPath(item.url);
+              } catch (_) {
+                relPath = relPath.replace(/^file:\/\//, "");
+              }
+            }
+
+            let resolvedRoot = root;
+            try {
+              if (existsSync(root)) resolvedRoot = realpathSync(root);
+            } catch (_) {}
+
+            try {
+              if (existsSync(relPath)) relPath = realpathSync(relPath);
+            } catch (_) {}
+
+            if (isAbsolute(relPath)) {
+              relPath = relative(resolvedRoot, relPath);
+            }
+            relPath = relPath.replace(/\\/g, "/").replace(/^\.\//, "");
+
+            if (!isExcludedFromCoverage(relPath)) {
+              if (!coverageByFile.has(relPath)) {
+                coverageByFile.set(relPath, []);
+              }
+              coverageByFile.get(relPath).push(...(item.functions || []));
+            }
+          }
+        }
+      } catch (_) {}
+    }
+
+    return {
+      ok: exitCode === 0,
+      exitCode,
+      stdout,
+      stderr,
+      coverageFiles: files.length,
+      coverageByFile,
+    };
+  } finally {
+    try {
+      rmSync(tempCoverageDir, { recursive: true, force: true });
+    } catch (_) {}
+  }
+}
+
+/**
+ * Parses diff text to extract added line numbers for each modified file.
+ * @param {string} diffStr
+ * @returns {Map<string, number[]>} Map of filePath -> added line numbers
+ */
+export function extractAddedLinesFromDiff(diffStr = "") {
+  const fileAddedLines = new Map();
+  if (!diffStr) return fileAddedLines;
+
+  let currentFile = null;
+  let currentLineNo = null;
+
+  const lines = diffStr.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if ((line.startsWith("+++ ") || line.startsWith("+++ b/") || line.startsWith("+++ /dev/null")) && !line.startsWith("++++")) {
+      const target = line.slice(3).split("\t")[0].trim().replace(/^b\//, "");
+      currentFile = target && target !== "/dev/null" ? target : null;
+      currentLineNo = null;
+      continue;
+    }
+
+    const hunkMatch = /^@@ -\d+(?:,\d+)? \+(\d+)/.exec(line);
+    if (hunkMatch) {
+      currentLineNo = parseInt(hunkMatch[1], 10);
+      continue;
+    }
+
+    if (currentLineNo === null || !currentFile) continue;
+
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      if (!isExcludedFromCoverage(currentFile)) {
+        if (!fileAddedLines.has(currentFile)) {
+          fileAddedLines.set(currentFile, []);
+        }
+        fileAddedLines.get(currentFile).push(currentLineNo);
+      }
+      currentLineNo++;
+    } else if (!line.startsWith("-") && !line.startsWith("\\")) {
+      currentLineNo++;
+    }
+  }
+
+  return fileAddedLines;
+}
+
+/**
+ * Calculates diff coverage percentage by cross-referencing V8 coverage against added lines in the git diff.
+ * @param {Map<string, Array<object>>} coverageByFile - Map of relative file path -> V8 function arrays
+ * @param {string} diffStr - Unified git diff
+ * @param {object} [options]
+ * @param {string} [options.root=process.cwd()]
+ * @param {number} [options.minCoverage=100] - Expected minimum coverage percentage (0-100)
+ * @returns {object} { ok, score, totalLines, coveredLines, missedLines, missedByFile, summary }
+ */
+export function calculateDiffCoverage(coverageByFile, diffStr = "", options = {}) {
+  const root = options.root || process.cwd();
+  const minCoverage = typeof options.minCoverage === "number" ? options.minCoverage : 100;
+  const addedLinesMap = extractAddedLinesFromDiff(diffStr);
+
+  let totalLines = 0;
+  let coveredLines = 0;
+  const missedByFile = {};
+
+  for (const [file, addedLines] of addedLinesMap.entries()) {
+    const absPath = resolve(root, file);
+    if (!existsSync(absPath)) continue;
+
+    let sourceContent = "";
+    try {
+      sourceContent = readFileSync(absPath, "utf-8");
+    } catch (_) {
+      continue;
+    }
+
+    const v8Functions = coverageByFile.get(file) || [];
+    const lineHits = mapV8RangesToLines(sourceContent, v8Functions);
+
+    const missed = [];
+    for (const lineNo of addedLines) {
+      if (lineHits.has(lineNo)) {
+        totalLines++;
+        const count = lineHits.get(lineNo);
+        if (count > 0) {
+          coveredLines++;
+        } else {
+          missed.push(lineNo);
+        }
+      }
+    }
+
+    if (missed.length > 0) {
+      missedByFile[file] = missed;
+    }
+  }
+
+  const score = totalLines > 0 ? Math.round((coveredLines / totalLines) * 10000) / 100 : 100;
+  const ok = score >= minCoverage;
+
+  return {
+    ok,
+    score,
+    minCoverage,
+    totalLines,
+    coveredLines,
+    missedLines: totalLines - coveredLines,
+    missedByFile,
+    summary: `Diff Coverage: ${score}% (${coveredLines}/${totalLines} added executable lines covered, min: ${minCoverage}%)`,
+  };
+}

package/src/engine.mjs

@@ -14,7 +14,7 @@ import { appendTelemetry as appendTelemetryUnsafe } from "./telemetry.mjs";
 
 import { spawn } from "node:child_process";
 import { resolveAffectedTests, executeQueueDag } from "./dag-engine.mjs";
-import { recordRemediation, queryRemediations, harvestFailureRecord, hydrateMemory } from "./remediation.mjs";
+import { recordRemediation, queryRemediations, harvestFailureRecord, hydrateMemory, createWhackAMoleDetector } from "./remediation.mjs";
 import { hydratePrompt, harvestFailure } from "./memory.mjs";
 import { resolveRolePrompt } from "./role-resolver.mjs";
 
@@ -593,17 +593,23 @@ export async function repair(failure, opts = {}) {
     threshold: 2,
     cooldownMs: 60000,
   });
+  const whackAMole = createWhackAMoleDetector({
+    maxHistory: Math.max(maxRetries + 2, 8),
+    threshold: 2,
+  });
 
   let currentFailure = failure;
   const initialFingerprint = fingerprintFailureState(currentFailure, root);
   breaker.observe(initialFingerprint);
+  whackAMole.recordTestOutcome(currentFailure.stderr || currentFailure.message);
+  let extraPromptDirective = null;
 
   for (let n = 1; n <= maxRetries; n++) {
     if (progressBus && progressToken) {
       progressBus.reportProgress(progressToken, Math.round((n / maxRetries) * 100), 100, `OODA Repair attempt ${n}/${maxRetries}`);
     }
 
-    const repairPrompt = buildRepairPrompt(currentFailure, n, config);
+    const repairPrompt = buildRepairPrompt(currentFailure, n, config, extraPromptDirective);
     let session;
     try {
       session = await withBudget(
@@ -657,6 +663,7 @@ export async function repair(failure, opts = {}) {
     const gateRes = await gate({ root, config, fix: false, progressBus, progressToken });
     if (gateRes.ok) {
       breaker.reset();
+      whackAMole.reset();
       recordRemediation(root, {
         fingerprint: initialFingerprint,
         symptom: currentFailure.stderr || currentFailure.message || "Failure resolved by OODA repair",
@@ -669,6 +676,12 @@ export async function repair(failure, opts = {}) {
     currentFailure = gateRes.phases.find((p) => p.phase === "verify")?.testResult || failure;
     const currentFingerprint = fingerprintFailureState(currentFailure, root);
 
+    // Whack-a-Mole test-oscillation check
+    const whackCheck = whackAMole.recordTestOutcome(currentFailure.stderr || currentFailure.message);
+    if (whackCheck.whackAMole) {
+      extraPromptDirective = whackCheck.promptDirective;
+    }
+
     const check = breaker.observe(currentFingerprint);
     if (check.tripped) {
       harvestFailureRecord(root, {
@@ -800,13 +813,16 @@ export async function pollSessionState(provider, session, opts = {}) {
   return { ...session, status: String(session.status || "COMPLETED").toUpperCase() };
 }
 
-function buildRepairPrompt(failure, attempt, _config) {
+function buildRepairPrompt(failure, attempt, _config, extraPromptDirective = null) {
   const cleanStderr = redactSecrets(failure.stderr || failure.stdout || "Unknown Error");
 
   let escalationStrategy = "DIRECT_REPAIR";
   let escalationDirective = "1. Ground your fix strictly in the error log below. Do NOT guess file contents or function signatures.";
 
-  if (attempt === 2) {
+  if (extraPromptDirective) {
+    escalationStrategy = "WHACK_A_MOLE_PIVOT";
+    escalationDirective = `1. ARCHITECTURAL PIVOT: ${extraPromptDirective}`;
+  } else if (attempt === 2) {
     escalationStrategy = "DIAGNOSTIC_ANALYSIS";
     escalationDirective = "1. DIAGNOSE FIRST: Two attempts have failed. Analyze if the root cause is in a different file or component than where the previous patch was applied.";
   } else if (attempt >= 3) {